@venos-inc/venos 0.1.5 → 0.1.7

package/etc/mcp-server/node_modules/vite/dist/node/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { PluginHooks, RollupError, SourceMap, ModuleInfo, PartialResolvedId, MinimalPluginContext, InputOptions, CustomPluginOptions, LoadResult, SourceDescription, RollupOptions, WatcherOptions, InputOption, ModuleFormat, RollupOutput, RollupWatcher, SourceMapInput, ExistingRawSourceMap, OutputBundle, OutputChunk, ObjectHook, PluginContext, ResolveIdResult, TransformPluginContext, GetManualChunk } from 'rollup';
+import { PluginHooks, RollupError, SourceMap, ModuleInfo, PartialResolvedId, RollupOptions, InputOption, ModuleFormat, WatcherOptions, RollupOutput, RollupWatcher, PluginContext, InputOptions, CustomPluginOptions, LoadResult, SourceDescription, PluginContextMeta, RollupLog, OutputBundle, OutputChunk, ObjectHook, ResolveIdResult, TransformPluginContext, ExistingRawSourceMap, SourceMapInput, GetManualChunk } from 'rollup';
 import * as rollup from 'rollup';
 export { rollup as Rollup };
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
@@ -15,21 +15,23 @@ import * as url from 'node:url';
 import { URL } from 'node:url';
 import * as stream from 'node:stream';
 import { Duplex, DuplexOptions } from 'node:stream';
-import { F as FetchResult, H as HMRLogger } from './types.d-aGj9QkWt.js';
-export { a as FetchFunction } from './types.d-aGj9QkWt.js';
-import { SecureContextOptions } from 'node:tls';
-import { ZlibOptions } from 'node:zlib';
-import { HMRPayload, CustomPayload } from '../../types/hmrPayload.js';
-export { ConnectedPayload, CustomPayload, ErrorPayload, FullReloadPayload, HMRPayload, PrunePayload, Update, UpdatePayload } from '../../types/hmrPayload.js';
+import { FetchFunctionOptions, FetchResult, ModuleRunnerOptions, ModuleRunnerHmr, ModuleEvaluator, ModuleRunner } from 'vite/module-runner';
+export { FetchFunction, FetchResult } from 'vite/module-runner';
+import { BuildOptions as esbuild_BuildOptions, TransformOptions as esbuild_TransformOptions, TransformResult as esbuild_TransformResult } from 'esbuild';
+export { TransformOptions as EsbuildTransformOptions, version as esbuildVersion } from 'esbuild';
+import { HotPayload, CustomPayload } from '../../types/hmrPayload.js';
+export { ConnectedPayload, CustomPayload, ErrorPayload, FullReloadPayload, HMRPayload, HotPayload, PrunePayload, Update, UpdatePayload } from '../../types/hmrPayload.js';
 import { InferCustomEventPayload } from '../../types/customEvent.js';
 export { CustomEventMap, InferCustomEventPayload, InvalidatePayload } from '../../types/customEvent.js';
-import { TransformOptions as esbuild_TransformOptions, TransformResult as esbuild_TransformResult, BuildOptions as esbuild_BuildOptions } from 'esbuild';
-export { TransformOptions as EsbuildTransformOptions, version as esbuildVersion } from 'esbuild';
+import { SecureContextOptions } from 'node:tls';
+import { ZlibOptions } from 'node:zlib';
 import * as PostCSS from 'postcss';
-import { ViteRuntimeOptions, ViteModuleRunner, ViteRuntime, HMRRuntimeConnection } from 'vite/runtime';
+import { LightningCSSOptions } from '../../types/internal/lightningcssOptions.js';
+export { LightningCSSOptions } from '../../types/internal/lightningcssOptions.js';
+import { SassLegacyPreprocessBaseOptions, SassModernPreprocessBaseOptions, LessPreprocessorBaseOptions, StylusPreprocessorBaseOptions } from '../../types/internal/cssPreprocessorOptions.js';
+import { M as ModuleRunnerTransport } from './moduleRunnerTransport.d-DJ_mE5sf.js';
 export { GeneralImportGlobOptions, ImportGlobFunction, ImportGlobOptions, KnownAsTypeMap } from '../../types/importGlob.js';
-export { ChunkMetadata } from '../../types/metadata.js';
-import '../../types/hot.js';
+export { ChunkMetadata, CustomPluginOptionsVite } from '../../types/metadata.js';
 
 interface Alias {
   find: string | RegExp
@@ -619,9 +621,11 @@ interface ProxyOptions extends HttpProxy.ServerOptions {
     /**
      * webpack-dev-server style bypass function
      */
-    bypass?: (req: http.IncomingMessage, res: http.ServerResponse, options: ProxyOptions) => void | null | undefined | false | string;
+    bypass?: (req: http.IncomingMessage, 
+    /** undefined for WebSocket upgrade requests */
+    res: http.ServerResponse | undefined, options: ProxyOptions) => void | null | undefined | false | string | Promise<void | null | undefined | boolean | string>;
     /**
-     * rewrite the Origin header of a WebSocket request to match the the target
+     * rewrite the Origin header of a WebSocket request to match the target
      *
      * **Exercise caution as rewriting the Origin can leave the proxying open to [CSRF attacks](https://owasp.org/www-community/attacks/csrf).**
      */
@@ -642,6 +646,7 @@ interface Logger {
 interface LogOptions {
     clear?: boolean;
     timestamp?: boolean;
+    environment?: string;
 }
 interface LogErrorOptions extends LogOptions {
     error?: Error | RollupError | null;
@@ -650,6 +655,7 @@ interface LoggerOptions {
     prefix?: string;
     allowClearScreen?: boolean;
     customLogger?: Logger;
+    console?: Console;
 }
 declare function createLogger(level?: LogLevel, options?: LoggerOptions): Logger;
 
@@ -752,9 +758,11 @@ interface CorsOptions {
 }
 type CorsOrigin = boolean | string | RegExp | (string | RegExp)[];
 
+type RequiredExceptFor<T, K extends keyof T> = Pick<T, K> & Required<Omit<T, K>>;
+
 interface PreviewOptions extends CommonServerOptions {
 }
-interface ResolvedPreviewOptions extends PreviewOptions {
+interface ResolvedPreviewOptions extends RequiredExceptFor<PreviewOptions, 'host' | 'https' | 'proxy'> {
 }
 interface PreviewServer {
     /**
@@ -779,8 +787,8 @@ interface PreviewServer {
      */
     httpServer: HttpServer;
     /**
-     * The resolved urls Vite prints on the CLI.
-     * null before server is listening.
+     * The resolved urls Vite prints on the CLI (URL-encoded). Returns `null`
+     * if the server is not listening on any port.
      */
     resolvedUrls: ResolvedServerUrls | null;
     /**
@@ -816,21 +824,231 @@ type CLIShortcut<Server = ViteDevServer | PreviewServer> = {
     action?(server: Server): void | Promise<void>;
 };
 
+declare class PartialEnvironment {
+    name: string;
+    getTopLevelConfig(): ResolvedConfig;
+    config: ResolvedConfig & ResolvedEnvironmentOptions;
+    /**
+     * @deprecated use environment.config instead
+     **/
+    get options(): ResolvedEnvironmentOptions;
+    logger: Logger;
+    constructor(name: string, topLevelConfig: ResolvedConfig, options?: ResolvedEnvironmentOptions);
+}
+declare class BaseEnvironment extends PartialEnvironment {
+    get plugins(): Plugin[];
+    constructor(name: string, config: ResolvedConfig, options?: ResolvedEnvironmentOptions);
+}
+/**
+ * This class discourages users from inversely checking the `mode`
+ * to determine the type of environment, e.g.
+ *
+ * ```js
+ * const isDev = environment.mode !== 'build' // bad
+ * const isDev = environment.mode === 'dev'   // good
+ * ```
+ *
+ * You should also not check against `"unknown"` specifically. It's
+ * a placeholder for more possible environment types.
+ */
+declare class UnknownEnvironment extends BaseEnvironment {
+    mode: "unknown";
+}
+
+declare class ScanEnvironment extends BaseEnvironment {
+    mode: "scan";
+    get pluginContainer(): EnvironmentPluginContainer;
+    init(): Promise<void>;
+}
+
+type ExportsData = {
+    hasModuleSyntax: boolean;
+    exports: readonly string[];
+    jsxLoader?: boolean;
+};
+interface DepsOptimizer {
+    init: () => Promise<void>;
+    metadata: DepOptimizationMetadata;
+    scanProcessing?: Promise<void>;
+    registerMissingImport: (id: string, resolved: string) => OptimizedDepInfo;
+    run: () => void;
+    isOptimizedDepFile: (id: string) => boolean;
+    isOptimizedDepUrl: (url: string) => boolean;
+    getOptimizedDepId: (depInfo: OptimizedDepInfo) => string;
+    close: () => Promise<void>;
+    options: DepOptimizationOptions;
+}
+interface DepOptimizationConfig {
+    /**
+     * Force optimize listed dependencies (must be resolvable import paths,
+     * cannot be globs).
+     */
+    include?: string[];
+    /**
+     * Do not optimize these dependencies (must be resolvable import paths,
+     * cannot be globs).
+     */
+    exclude?: string[];
+    /**
+     * Forces ESM interop when importing these dependencies. Some legacy
+     * packages advertise themselves as ESM but use `require` internally
+     * @experimental
+     */
+    needsInterop?: string[];
+    /**
+     * Options to pass to esbuild during the dep scanning and optimization
+     *
+     * Certain options are omitted since changing them would not be compatible
+     * with Vite's dep optimization.
+     *
+     * - `external` is also omitted, use Vite's `optimizeDeps.exclude` option
+     * - `plugins` are merged with Vite's dep plugin
+     *
+     * https://esbuild.github.io/api
+     */
+    esbuildOptions?: Omit<esbuild_BuildOptions, 'bundle' | 'entryPoints' | 'external' | 'write' | 'watch' | 'outdir' | 'outfile' | 'outbase' | 'outExtension' | 'metafile'>;
+    /**
+     * List of file extensions that can be optimized. A corresponding esbuild
+     * plugin must exist to handle the specific extension.
+     *
+     * By default, Vite can optimize `.mjs`, `.js`, `.ts`, and `.mts` files. This option
+     * allows specifying additional extensions.
+     *
+     * @experimental
+     */
+    extensions?: string[];
+    /**
+     * Deps optimization during build was removed in Vite 5.1. This option is
+     * now redundant and will be removed in a future version. Switch to using
+     * `optimizeDeps.noDiscovery` and an empty or undefined `optimizeDeps.include`.
+     * true or 'dev' disables the optimizer, false or 'build' leaves it enabled.
+     * @default 'build'
+     * @deprecated
+     * @experimental
+     */
+    disabled?: boolean | 'build' | 'dev';
+    /**
+     * Automatic dependency discovery. When `noDiscovery` is true, only dependencies
+     * listed in `include` will be optimized. The scanner isn't run for cold start
+     * in this case. CJS-only dependencies must be present in `include` during dev.
+     * @default false
+     * @experimental
+     */
+    noDiscovery?: boolean;
+    /**
+     * When enabled, it will hold the first optimized deps results until all static
+     * imports are crawled on cold start. This avoids the need for full-page reloads
+     * when new dependencies are discovered and they trigger the generation of new
+     * common chunks. If all dependencies are found by the scanner plus the explicitly
+     * defined ones in `include`, it is better to disable this option to let the
+     * browser process more requests in parallel.
+     * @default true
+     * @experimental
+     */
+    holdUntilCrawlEnd?: boolean;
+}
+type DepOptimizationOptions = DepOptimizationConfig & {
+    /**
+     * By default, Vite will crawl your `index.html` to detect dependencies that
+     * need to be pre-bundled. If `build.rollupOptions.input` is specified, Vite
+     * will crawl those entry points instead.
+     *
+     * If neither of these fit your needs, you can specify custom entries using
+     * this option - the value should be a tinyglobby pattern or array of patterns
+     * (https://github.com/SuperchupuDev/tinyglobby) that are relative from
+     * vite project root. This will overwrite default entries inference.
+     */
+    entries?: string | string[];
+    /**
+     * Force dep pre-optimization regardless of whether deps have changed.
+     * @experimental
+     */
+    force?: boolean;
+};
+interface OptimizedDepInfo {
+    id: string;
+    file: string;
+    src?: string;
+    needsInterop?: boolean;
+    browserHash?: string;
+    fileHash?: string;
+    /**
+     * During optimization, ids can still be resolved to their final location
+     * but the bundles may not yet be saved to disk
+     */
+    processing?: Promise<void>;
+    /**
+     * ExportData cache, discovered deps will parse the src entry to get exports
+     * data used both to define if interop is needed and when pre-bundling
+     */
+    exportsData?: Promise<ExportsData>;
+}
+interface DepOptimizationMetadata {
+    /**
+     * The main hash is determined by user config and dependency lockfiles.
+     * This is checked on server startup to avoid unnecessary re-bundles.
+     */
+    hash: string;
+    /**
+     * This hash is determined by dependency lockfiles.
+     * This is checked on server startup to avoid unnecessary re-bundles.
+     */
+    lockfileHash: string;
+    /**
+     * This hash is determined by user config.
+     * This is checked on server startup to avoid unnecessary re-bundles.
+     */
+    configHash: string;
+    /**
+     * The browser hash is determined by the main hash plus additional dependencies
+     * discovered at runtime. This is used to invalidate browser requests to
+     * optimized deps.
+     */
+    browserHash: string;
+    /**
+     * Metadata for each already optimized dependency
+     */
+    optimized: Record<string, OptimizedDepInfo>;
+    /**
+     * Metadata for non-entry optimized chunks and dynamic imports
+     */
+    chunks: Record<string, OptimizedDepInfo>;
+    /**
+     * Metadata for each newly discovered dependency after processing
+     */
+    discovered: Record<string, OptimizedDepInfo>;
+    /**
+     * OptimizedDepInfo list
+     */
+    depInfoList: OptimizedDepInfo[];
+}
+/**
+ * Scan and optimize dependencies within a project.
+ * Used by Vite CLI when running `vite optimize`.
+ *
+ * @deprecated the optimization process runs automatically and does not need to be called
+ */
+declare function optimizeDeps(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
+
 interface TransformResult {
     code: string;
     map: SourceMap | {
         mappings: '';
     } | null;
+    ssr?: boolean;
     etag?: string;
     deps?: string[];
     dynamicDeps?: string[];
 }
 interface TransformOptions {
+    /**
+     * @deprecated inferred from environment
+     */
     ssr?: boolean;
-    html?: boolean;
 }
 
-declare class ModuleNode {
+declare class EnvironmentModuleNode {
+    environment: string;
     /**
      * Public served url path, starts with /
      */
@@ -843,15 +1061,13 @@ declare class ModuleNode {
     type: 'js' | 'css';
     info?: ModuleInfo;
     meta?: Record<string, any>;
-    importers: Set<ModuleNode>;
-    clientImportedModules: Set<ModuleNode>;
-    ssrImportedModules: Set<ModuleNode>;
-    acceptedHmrDeps: Set<ModuleNode>;
+    importers: Set<EnvironmentModuleNode>;
+    importedModules: Set<EnvironmentModuleNode>;
+    acceptedHmrDeps: Set<EnvironmentModuleNode>;
     acceptedHmrExports: Set<string> | null;
     importedBindings: Map<string, Set<string>> | null;
     isSelfAccepting?: boolean;
     transformResult: TransformResult | null;
-    ssrTransformResult: TransformResult | null;
     ssrModule: Record<string, any> | null;
     ssrError: Error | null;
     lastHMRTimestamp: number;
@@ -859,28 +1075,26 @@ declare class ModuleNode {
     /**
      * @param setIsSelfAccepting - set `false` to set `isSelfAccepting` later. e.g. #7870
      */
-    constructor(url: string, setIsSelfAccepting?: boolean);
-    get importedModules(): Set<ModuleNode>;
+    constructor(url: string, environment: string, setIsSelfAccepting?: boolean);
 }
 type ResolvedUrl = [
     url: string,
     resolvedId: string,
     meta: object | null | undefined
 ];
-declare class ModuleGraph {
-    private resolveId;
-    urlToModuleMap: Map<string, ModuleNode>;
-    idToModuleMap: Map<string, ModuleNode>;
-    etagToModuleMap: Map<string, ModuleNode>;
-    fileToModulesMap: Map<string, Set<ModuleNode>>;
-    safeModulesPath: Set<string>;
-    constructor(resolveId: (url: string, ssr: boolean) => Promise<PartialResolvedId | null>);
-    getModuleByUrl(rawUrl: string, ssr?: boolean): Promise<ModuleNode | undefined>;
-    getModuleById(id: string): ModuleNode | undefined;
-    getModulesByFile(file: string): Set<ModuleNode> | undefined;
+declare class EnvironmentModuleGraph {
+    environment: string;
+    urlToModuleMap: Map<string, EnvironmentModuleNode>;
+    idToModuleMap: Map<string, EnvironmentModuleNode>;
+    etagToModuleMap: Map<string, EnvironmentModuleNode>;
+    fileToModulesMap: Map<string, Set<EnvironmentModuleNode>>;
+    constructor(environment: string, resolveId: (url: string) => Promise<PartialResolvedId | null>);
+    getModuleByUrl(rawUrl: string): Promise<EnvironmentModuleNode | undefined>;
+    getModuleById(id: string): EnvironmentModuleNode | undefined;
+    getModulesByFile(file: string): Set<EnvironmentModuleNode> | undefined;
     onFileChange(file: string): void;
     onFileDelete(file: string): void;
-    invalidateModule(mod: ModuleNode, seen?: Set<ModuleNode>, timestamp?: number, isHmr?: boolean, 
+    invalidateModule(mod: EnvironmentModuleNode, seen?: Set<EnvironmentModuleNode>, timestamp?: number, isHmr?: boolean, 
     ): void;
     invalidateAll(): void;
     /**
@@ -891,69 +1105,215 @@ declare class ModuleGraph {
      * @param staticImportedUrls Subset of `importedModules` where they're statically imported in code.
      *   This is only used for soft invalidations so `undefined` is fine but may cause more runtime processing.
      */
-    updateModuleInfo(mod: ModuleNode, importedModules: Set<string | ModuleNode>, importedBindings: Map<string, Set<string>> | null, acceptedModules: Set<string | ModuleNode>, acceptedExports: Set<string> | null, isSelfAccepting: boolean, ssr?: boolean, 
-    ): Promise<Set<ModuleNode> | undefined>;
+    updateModuleInfo(mod: EnvironmentModuleNode, importedModules: Set<string | EnvironmentModuleNode>, importedBindings: Map<string, Set<string>> | null, acceptedModules: Set<string | EnvironmentModuleNode>, acceptedExports: Set<string> | null, isSelfAccepting: boolean, 
+    ): Promise<Set<EnvironmentModuleNode> | undefined>;
+    ensureEntryFromUrl(rawUrl: string, setIsSelfAccepting?: boolean): Promise<EnvironmentModuleNode>;
+    createFileOnlyEntry(file: string): EnvironmentModuleNode;
+    resolveUrl(url: string): Promise<ResolvedUrl>;
+    updateModuleTransformResult(mod: EnvironmentModuleNode, result: TransformResult | null): void;
+    getModuleByEtag(etag: string): EnvironmentModuleNode | undefined;
+}
+
+declare class ModuleNode {
+    _moduleGraph: ModuleGraph;
+    _clientModule: EnvironmentModuleNode | undefined;
+    _ssrModule: EnvironmentModuleNode | undefined;
+    constructor(moduleGraph: ModuleGraph, clientModule?: EnvironmentModuleNode, ssrModule?: EnvironmentModuleNode);
+    _get<T extends keyof EnvironmentModuleNode>(prop: T): EnvironmentModuleNode[T];
+    _set<T extends keyof EnvironmentModuleNode>(prop: T, value: EnvironmentModuleNode[T]): void;
+    _wrapModuleSet(prop: ModuleSetNames, module: EnvironmentModuleNode | undefined): Set<ModuleNode>;
+    _getModuleSetUnion(prop: 'importedModules' | 'importers'): Set<ModuleNode>;
+    _getModuleInfoUnion(prop: 'info'): ModuleInfo | undefined;
+    _getModuleObjectUnion(prop: 'meta'): Record<string, any> | undefined;
+    get url(): string;
+    set url(value: string);
+    get id(): string | null;
+    set id(value: string | null);
+    get file(): string | null;
+    set file(value: string | null);
+    get type(): 'js' | 'css';
+    get info(): ModuleInfo | undefined;
+    get meta(): Record<string, any> | undefined;
+    get importers(): Set<ModuleNode>;
+    get clientImportedModules(): Set<ModuleNode>;
+    get ssrImportedModules(): Set<ModuleNode>;
+    get importedModules(): Set<ModuleNode>;
+    get acceptedHmrDeps(): Set<ModuleNode>;
+    get acceptedHmrExports(): Set<string> | null;
+    get importedBindings(): Map<string, Set<string>> | null;
+    get isSelfAccepting(): boolean | undefined;
+    get transformResult(): TransformResult | null;
+    set transformResult(value: TransformResult | null);
+    get ssrTransformResult(): TransformResult | null;
+    set ssrTransformResult(value: TransformResult | null);
+    get ssrModule(): Record<string, any> | null;
+    get ssrError(): Error | null;
+    get lastHMRTimestamp(): number;
+    set lastHMRTimestamp(value: number);
+    get lastInvalidationTimestamp(): number;
+    get invalidationState(): TransformResult | 'HARD_INVALIDATED' | undefined;
+    get ssrInvalidationState(): TransformResult | 'HARD_INVALIDATED' | undefined;
+}
+declare class ModuleGraph {
+    urlToModuleMap: Map<string, ModuleNode>;
+    idToModuleMap: Map<string, ModuleNode>;
+    etagToModuleMap: Map<string, ModuleNode>;
+    fileToModulesMap: Map<string, Set<ModuleNode>>;
+    private moduleNodeCache;
+    constructor(moduleGraphs: {
+        client: () => EnvironmentModuleGraph;
+        ssr: () => EnvironmentModuleGraph;
+    });
+    getModuleById(id: string): ModuleNode | undefined;
+    getModuleByUrl(url: string, _ssr?: boolean): Promise<ModuleNode | undefined>;
+    getModulesByFile(file: string): Set<ModuleNode> | undefined;
+    onFileChange(file: string): void;
+    onFileDelete(file: string): void;
+    invalidateModule(mod: ModuleNode, seen?: Set<ModuleNode>, timestamp?: number, isHmr?: boolean, 
+    ): void;
+    invalidateAll(): void;
     ensureEntryFromUrl(rawUrl: string, ssr?: boolean, setIsSelfAccepting?: boolean): Promise<ModuleNode>;
     createFileOnlyEntry(file: string): ModuleNode;
     resolveUrl(url: string, ssr?: boolean): Promise<ResolvedUrl>;
-    updateModuleTransformResult(mod: ModuleNode, result: TransformResult | null, ssr: boolean): void;
+    updateModuleTransformResult(mod: ModuleNode, result: TransformResult | null, ssr?: boolean): void;
     getModuleByEtag(etag: string): ModuleNode | undefined;
+    getBackwardCompatibleBrowserModuleNode(clientModule: EnvironmentModuleNode): ModuleNode;
+    getBackwardCompatibleServerModuleNode(ssrModule: EnvironmentModuleNode): ModuleNode;
+    getBackwardCompatibleModuleNode(mod: EnvironmentModuleNode): ModuleNode;
+    getBackwardCompatibleModuleNodeDual(clientModule?: EnvironmentModuleNode, ssrModule?: EnvironmentModuleNode): ModuleNode;
 }
+type ModuleSetNames = 'acceptedHmrDeps' | 'importedModules';
 
-/**
- * This file is refactored into TypeScript based on
- * https://github.com/preactjs/wmr/blob/main/packages/wmr/src/lib/rollup-plugin-container.js
- */
-
-declare class PluginContainer {
-    config: ResolvedConfig;
-    moduleGraph?: ModuleGraph | undefined;
-    watcher?: FSWatcher | undefined;
-    plugins: readonly Plugin<any>[];
-    private _pluginContextMap;
-    private _pluginContextMapSsr;
-    private _resolvedRollupOptions?;
-    private _processesing;
-    private _seenResolves;
-    private _closed;
-    private _moduleNodeToLoadAddedImports;
-    getSortedPluginHooks: PluginHookUtils['getSortedPluginHooks'];
-    getSortedPlugins: PluginHookUtils['getSortedPlugins'];
-    watchFiles: Set<string>;
-    minimalContext: MinimalPluginContext;
-    private _updateModuleLoadAddedImports;
-    private _getAddedImports;
-    getModuleInfo(id: string): ModuleInfo | null;
-    private handleHookPromise;
-    get options(): InputOptions;
-    resolveRollupOptions(): Promise<InputOptions>;
-    private _getPluginContext;
-    private hookParallel;
-    buildStart(_options?: InputOptions): Promise<void>;
-    resolveId(rawId: string, importer?: string | undefined, options?: {
-        attributes?: Record<string, string>;
-        custom?: CustomPluginOptions;
-        skip?: Set<Plugin>;
-        ssr?: boolean;
-        isEntry?: boolean;
-    }): Promise<PartialResolvedId | null>;
-    load(id: string, options?: {
-        ssr?: boolean;
-    }): Promise<LoadResult | null>;
-    transform(code: string, id: string, options?: {
-        ssr?: boolean;
-        inMap?: SourceDescription['map'];
-    }): Promise<{
-        code: string;
-        map: SourceMap | {
-            mappings: '';
-        } | null;
+interface HmrOptions {
+    protocol?: string;
+    host?: string;
+    port?: number;
+    clientPort?: number;
+    path?: string;
+    timeout?: number;
+    overlay?: boolean;
+    server?: HttpServer;
+}
+interface HotUpdateOptions {
+    type: 'create' | 'update' | 'delete';
+    file: string;
+    timestamp: number;
+    modules: Array<EnvironmentModuleNode>;
+    read: () => string | Promise<string>;
+    server: ViteDevServer;
+    /**
+     * @deprecated use this.environment in the hotUpdate hook instead
+     **/
+    environment: DevEnvironment;
+}
+interface HmrContext {
+    file: string;
+    timestamp: number;
+    modules: Array<ModuleNode>;
+    read: () => string | Promise<string>;
+    server: ViteDevServer;
+}
+interface HotChannelClient {
+    send(payload: HotPayload): void;
+}
+/** @deprecated use `HotChannelClient` instead */
+type HMRBroadcasterClient = HotChannelClient;
+type HotChannelListener<T extends string = string> = (data: InferCustomEventPayload<T>, client: HotChannelClient) => void;
+interface HotChannel<Api = any> {
+    /**
+     * When true, the fs access check is skipped in fetchModule.
+     * Set this for transports that is not exposed over the network.
+     */
+    skipFsCheck?: boolean;
+    /**
+     * Broadcast events to all clients
+     */
+    send?(payload: HotPayload): void;
+    /**
+     * Handle custom event emitted by `import.meta.hot.send`
+     */
+    on?<T extends string>(event: T, listener: HotChannelListener<T>): void;
+    on?(event: 'connection', listener: () => void): void;
+    /**
+     * Unregister event listener
+     */
+    off?(event: string, listener: Function): void;
+    /**
+     * Start listening for messages
+     */
+    listen?(): void;
+    /**
+     * Disconnect all clients, called when server is closed or restarted.
+     */
+    close?(): Promise<unknown> | void;
+    api?: Api;
+}
+/** @deprecated use `HotChannel` instead */
+type HMRChannel = HotChannel;
+interface NormalizedHotChannelClient {
+    /**
+     * Send event to the client
+     */
+    send(payload: HotPayload): void;
+    /**
+     * Send custom event
+     */
+    send(event: string, payload?: CustomPayload['data']): void;
+}
+interface NormalizedHotChannel<Api = any> {
+    /**
+     * Broadcast events to all clients
+     */
+    send(payload: HotPayload): void;
+    /**
+     * Send custom event
+     */
+    send<T extends string>(event: T, payload?: InferCustomEventPayload<T>): void;
+    /**
+     * Handle custom event emitted by `import.meta.hot.send`
+     */
+    on<T extends string>(event: T, listener: (data: InferCustomEventPayload<T>, client: NormalizedHotChannelClient) => void): void;
+    on(event: 'connection', listener: () => void): void;
+    /**
+     * Unregister event listener
+     */
+    off(event: string, listener: Function): void;
+    handleInvoke(payload: HotPayload): Promise<{
+        result: any;
+    } | {
+        error: any;
     }>;
-    watchChange(id: string, change: {
-        event: 'create' | 'update' | 'delete';
-    }): Promise<void>;
-    close(): Promise<void>;
+    /**
+     * Start listening for messages
+     */
+    listen(): void;
+    /**
+     * Disconnect all clients, called when server is closed or restarted.
+     */
+    close(): Promise<unknown> | void;
+    api?: Api;
+}
+type ServerHotChannelApi = {
+    innerEmitter: EventEmitter;
+    outsideEmitter: EventEmitter;
+};
+type ServerHotChannel = HotChannel<ServerHotChannelApi>;
+type NormalizedServerHotChannel = NormalizedHotChannel<ServerHotChannelApi>;
+/** @deprecated use `ServerHotChannel` instead */
+type ServerHMRChannel = ServerHotChannel;
+declare function createServerHotChannel(): ServerHotChannel;
+/** @deprecated use `environment.hot` instead */
+interface HotBroadcaster extends NormalizedHotChannel {
+    readonly channels: NormalizedHotChannel[];
+    /**
+     * A noop.
+     * @deprecated
+     */
+    addChannel(channel: HotChannel): HotBroadcaster;
+    close(): Promise<unknown[]>;
 }
+/** @deprecated use `environment.hot` instead */
+type HMRBroadcaster = HotBroadcaster;
 
 // Modified and inlined to avoid extra dependency
 // Source: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/ws/index.d.ts
@@ -1489,118 +1849,36 @@ declare namespace WebSocket {
   ): Duplex
 }
 
-interface HmrOptions {
-    protocol?: string;
-    host?: string;
-    port?: number;
-    clientPort?: number;
-    path?: string;
-    timeout?: number;
-    overlay?: boolean;
-    server?: HttpServer;
-}
-interface HmrContext {
-    file: string;
-    timestamp: number;
-    modules: Array<ModuleNode>;
-    read: () => string | Promise<string>;
-    server: ViteDevServer;
-}
-interface HMRBroadcasterClient {
-    /**
-     * Send event to the client
-     */
-    send(payload: HMRPayload): void;
-    /**
-     * Send custom event
-     */
-    send(event: string, payload?: CustomPayload['data']): void;
-}
-interface HMRChannel {
-    /**
-     * Unique channel name
-     */
-    name: string;
-    /**
-     * Broadcast events to all clients
-     */
-    send(payload: HMRPayload): void;
-    /**
-     * Send custom event
-     */
-    send<T extends string>(event: T, payload?: InferCustomEventPayload<T>): void;
+type WebSocketCustomListener<T> = (data: T, client: WebSocketClient, invoke?: 'send' | `send:${string}`) => void;
+declare const isWebSocketServer: unique symbol;
+interface WebSocketServer extends NormalizedHotChannel {
     /**
      * Handle custom event emitted by `import.meta.hot.send`
      */
-    on<T extends string>(event: T, listener: (data: InferCustomEventPayload<T>, client: HMRBroadcasterClient, ...args: any[]) => void): void;
-    on(event: 'connection', listener: () => void): void;
-    /**
-     * Unregister event listener
-     */
-    off(event: string, listener: Function): void;
-    /**
-     * Start listening for messages
-     */
-    listen(): void;
-    /**
-     * Disconnect all clients, called when server is closed or restarted.
-     */
-    close(): void;
-}
-interface HMRBroadcaster extends Omit<HMRChannel, 'close' | 'name'> {
-    /**
-     * All registered channels. Always has websocket channel.
-     */
-    readonly channels: HMRChannel[];
+    on: WebSocket.Server['on'] & {
+        <T extends string>(event: T, listener: WebSocketCustomListener<InferCustomEventPayload<T>>): void;
+    };
     /**
-     * Add a new third-party channel.
+     * Unregister event listener.
      */
-    addChannel(connection: HMRChannel): HMRBroadcaster;
-    close(): Promise<unknown[]>;
-}
-interface ServerHMRChannel extends HMRChannel {
-    api: {
-        innerEmitter: EventEmitter;
-        outsideEmitter: EventEmitter;
+    off: WebSocket.Server['off'] & {
+        (event: string, listener: Function): void;
     };
-}
-
-type WebSocketCustomListener<T> = (data: T, client: WebSocketClient) => void;
-interface WebSocketServer extends HMRChannel {
     /**
      * Listen on port and host
      */
     listen(): void;
-    /**
-     * Get all connected clients.
-     */
-    clients: Set<WebSocketClient>;
     /**
      * Disconnect all clients and terminate the server.
      */
     close(): Promise<void>;
+    [isWebSocketServer]: true;
     /**
-     * Handle custom event emitted by `import.meta.hot.send`
-     */
-    on: WebSocket.Server['on'] & {
-        <T extends string>(event: T, listener: WebSocketCustomListener<InferCustomEventPayload<T>>): void;
-    };
-    /**
-     * Unregister event listener.
+     * Get all connected clients.
      */
-    off: WebSocket.Server['off'] & {
-        (event: string, listener: Function): void;
-    };
+    clients: Set<WebSocketClient>;
 }
-interface WebSocketClient {
-    /**
-     * Send event to the client
-     */
-    send(payload: HMRPayload): void;
-    /**
-     * Send custom event
-     */
-    send(event: string, payload?: CustomPayload['data']): void;
+interface WebSocketClient extends NormalizedHotChannelClient {
     /**
      * The raw WebSocket instance
      * @advanced
@@ -1608,269 +1886,59 @@ interface WebSocketClient {
     socket: WebSocket;
 }
 
-interface ServerOptions extends CommonServerOptions {
-    /**
-     * Configure HMR-specific options (port, host, path & protocol)
-     */
-    hmr?: HmrOptions | boolean;
-    /**
-     * Do not start the websocket connection.
-     * @experimental
-     */
-    ws?: false;
-    /**
-     * Warm-up files to transform and cache the results in advance. This improves the
-     * initial page load during server starts and prevents transform waterfalls.
-     */
-    warmup?: {
-        /**
-         * The files to be transformed and used on the client-side. Supports glob patterns.
-         */
-        clientFiles?: string[];
-        /**
-         * The files to be transformed and used in SSR. Supports glob patterns.
-         */
-        ssrFiles?: string[];
+interface DevEnvironmentContext {
+    hot: boolean;
+    transport?: HotChannel | WebSocketServer;
+    options?: EnvironmentOptions;
+    remoteRunner?: {
+        inlineSourceMap?: boolean;
     };
-    /**
-     * chokidar watch options or null to disable FS watching
-     * https://github.com/paulmillr/chokidar#api
-     */
-    watch?: WatchOptions | null;
-    /**
-     * Create Vite dev server to be used as a middleware in an existing server
-     * @default false
+    depsOptimizer?: DepsOptimizer;
+}
+declare class DevEnvironment extends BaseEnvironment {
+    mode: "dev";
+    moduleGraph: EnvironmentModuleGraph;
+    depsOptimizer?: DepsOptimizer;
+    get pluginContainer(): EnvironmentPluginContainer;
+    /**
+     * Hot channel for this environment. If not provided or disabled,
+     * it will be a noop channel that does nothing.
+     *
+     * @example
+     * environment.hot.send({ type: 'full-reload' })
      */
-    middlewareMode?: boolean | {
+    hot: NormalizedHotChannel;
+    constructor(name: string, config: ResolvedConfig, context: DevEnvironmentContext);
+    init(options?: {
+        watcher?: FSWatcher;
         /**
-         * Parent server instance to attach to
+         * the previous instance used for the environment with the same name
          *
-         * This is needed to proxy WebSocket connections to the parent server.
+         * when using, the consumer should check if it's an instance generated from the same class or factory function
          */
-        server: HttpServer;
-    };
-    /**
-     * Options for files served via '/\@fs/'.
-     */
-    fs?: FileSystemServeOptions;
-    /**
-     * Origin for the generated asset URLs.
-     *
-     * @example `http://127.0.0.1:8080`
-     */
-    origin?: string;
+        previousInstance?: DevEnvironment;
+    }): Promise<void>;
     /**
-     * Pre-transform known direct imports
-     * @default true
+     * When the dev server is restarted, the methods are called in the following order:
+     * - new instance `init`
+     * - previous instance `close`
+     * - new instance `listen`
      */
-    preTransformRequests?: boolean;
+    listen(server: ViteDevServer): Promise<void>;
+    fetchModule(id: string, importer?: string, options?: FetchFunctionOptions): Promise<FetchResult>;
+    reloadModule(module: EnvironmentModuleNode): Promise<void>;
+    transformRequest(url: string): Promise<TransformResult | null>;
+    warmupRequest(url: string): Promise<void>;
+    close(): Promise<void>;
     /**
-     * Whether or not to ignore-list source files in the dev server sourcemap, used to populate
-     * the [`x_google_ignoreList` source map extension](https://developer.chrome.com/blog/devtools-better-angular-debugging/#the-x_google_ignorelist-source-map-extension).
-     *
-     * By default, it excludes all paths containing `node_modules`. You can pass `false` to
-     * disable this behavior, or, for full control, a function that takes the source path and
-     * sourcemap path and returns whether to ignore the source path.
+     * Calling `await environment.waitForRequestsIdle(id)` will wait until all static imports
+     * are processed after the first transformRequest call. If called from a load or transform
+     * plugin hook, the id needs to be passed as a parameter to avoid deadlocks.
+     * Calling this function after the first static imports section of the module graph has been
+     * processed will resolve immediately.
+     * @experimental
      */
-    sourcemapIgnoreList?: false | ((sourcePath: string, sourcemapPath: string) => boolean);
-}
-interface ResolvedServerOptions extends Omit<ServerOptions, 'fs' | 'middlewareMode' | 'sourcemapIgnoreList'> {
-    fs: Required<FileSystemServeOptions>;
-    middlewareMode: NonNullable<ServerOptions['middlewareMode']>;
-    sourcemapIgnoreList: Exclude<ServerOptions['sourcemapIgnoreList'], false | undefined>;
-}
-interface FileSystemServeOptions {
-    /**
-     * Strictly restrict file accessing outside of allowing paths.
-     *
-     * Set to `false` to disable the warning
-     *
-     * @default true
-     */
-    strict?: boolean;
-    /**
-     * Restrict accessing files outside the allowed directories.
-     *
-     * Accepts absolute path or a path relative to project root.
-     * Will try to search up for workspace root by default.
-     */
-    allow?: string[];
-    /**
-     * Restrict accessing files that matches the patterns.
-     *
-     * This will have higher priority than `allow`.
-     * picomatch patterns are supported.
-     *
-     * @default ['.env', '.env.*', '*.crt', '*.pem']
-     */
-    deny?: string[];
-    /**
-     * Enable caching of fs calls. It is enabled by default if no custom watch ignored patterns are provided.
-     *
-     * @experimental
-     * @default undefined
-     */
-    cachedChecks?: boolean;
-}
-type ServerHook = (this: void, server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>;
-type HttpServer = http.Server | Http2SecureServer;
-interface ViteDevServer {
-    /**
-     * The resolved vite config object
-     */
-    config: ResolvedConfig;
-    /**
-     * A connect app instance.
-     * - Can be used to attach custom middlewares to the dev server.
-     * - Can also be used as the handler function of a custom http server
-     *   or as a middleware in any connect-style Node.js frameworks
-     *
-     * https://github.com/senchalabs/connect#use-middleware
-     */
-    middlewares: Connect.Server;
-    /**
-     * native Node http server instance
-     * will be null in middleware mode
-     */
-    httpServer: HttpServer | null;
-    /**
-     * chokidar watcher instance
-     * https://github.com/paulmillr/chokidar#api
-     */
-    watcher: FSWatcher;
-    /**
-     * web socket server with `send(payload)` method
-     */
-    ws: WebSocketServer;
-    /**
-     * HMR broadcaster that can be used to send custom HMR messages to the client
-     *
-     * Always sends a message to at least a WebSocket client. Any third party can
-     * add a channel to the broadcaster to process messages
-     * @deprecated will be replaced with the environment api in v6.
-     */
-    hot: HMRBroadcaster;
-    /**
-     * Rollup plugin container that can run plugin hooks on a given file
-     */
-    pluginContainer: PluginContainer;
-    /**
-     * Module graph that tracks the import relationships, url to file mapping
-     * and hmr state.
-     */
-    moduleGraph: ModuleGraph;
-    /**
-     * The resolved urls Vite prints on the CLI. null in middleware mode or
-     * before `server.listen` is called.
-     */
-    resolvedUrls: ResolvedServerUrls | null;
-    /**
-     * Programmatically resolve, load and transform a URL and get the result
-     * without going through the http request pipeline.
-     */
-    transformRequest(url: string, options?: TransformOptions): Promise<TransformResult | null>;
-    /**
-     * Same as `transformRequest` but only warm up the URLs so the next request
-     * will already be cached. The function will never throw as it handles and
-     * reports errors internally.
-     */
-    warmupRequest(url: string, options?: TransformOptions): Promise<void>;
-    /**
-     * Apply vite built-in HTML transforms and any plugin HTML transforms.
-     */
-    transformIndexHtml(url: string, html: string, originalUrl?: string): Promise<string>;
-    /**
-     * Transform module code into SSR format.
-     */
-    ssrTransform(code: string, inMap: SourceMap | {
-        mappings: '';
-    } | null, url: string, originalCode?: string): Promise<TransformResult | null>;
-    /**
-     * Load a given URL as an instantiated module for SSR.
-     */
-    ssrLoadModule(url: string, opts?: {
-        fixStacktrace?: boolean;
-    }): Promise<Record<string, any>>;
-    /**
-     * Fetch information about the module for Vite SSR runtime.
-     * @experimental
-     */
-    ssrFetchModule(id: string, importer?: string): Promise<FetchResult>;
-    /**
-     * Returns a fixed version of the given stack
-     */
-    ssrRewriteStacktrace(stack: string): string;
-    /**
-     * Mutates the given SSR error by rewriting the stacktrace
-     */
-    ssrFixStacktrace(e: Error): void;
-    /**
-     * Triggers HMR for a module in the module graph. You can use the `server.moduleGraph`
-     * API to retrieve the module to be reloaded. If `hmr` is false, this is a no-op.
-     */
-    reloadModule(module: ModuleNode): Promise<void>;
-    /**
-     * Start the server.
-     */
-    listen(port?: number, isRestart?: boolean): Promise<ViteDevServer>;
-    /**
-     * Stop the server.
-     */
-    close(): Promise<void>;
-    /**
-     * Print server urls
-     */
-    printUrls(): void;
-    /**
-     * Bind CLI shortcuts
-     */
-    bindCLIShortcuts(options?: BindCLIShortcutsOptions<ViteDevServer>): void;
-    /**
-     * Restart the server.
-     *
-     * @param forceOptimize - force the optimizer to re-bundle, same as --force cli flag
-     */
-    restart(forceOptimize?: boolean): Promise<void>;
-    /**
-     * Open browser
-     */
-    openBrowser(): void;
-    /**
-     * Calling `await server.waitForRequestsIdle(id)` will wait until all static imports
-     * are processed. If called from a load or transform plugin hook, the id needs to be
-     * passed as a parameter to avoid deadlocks. Calling this function after the first
-     * static imports section of the module graph has been processed will resolve immediately.
-     * @experimental
-     */
-    waitForRequestsIdle: (ignoredId?: string) => Promise<void>;
-}
-interface ResolvedServerUrls {
-    local: string[];
-    network: string[];
-}
-declare function createServer(inlineConfig?: InlineConfig): Promise<ViteDevServer>;
-
-/** Cache for package.json resolution and package.json contents */
-type PackageCache = Map<string, PackageData>;
-interface PackageData {
-    dir: string;
-    hasSideEffects: (id: string) => boolean | 'no-treeshake' | null;
-    webResolvedImports: Record<string, string | undefined>;
-    nodeResolvedImports: Record<string, string | undefined>;
-    setResolvedCache: (key: string, entry: string, targetWeb: boolean) => void;
-    getResolvedCache: (key: string, targetWeb: boolean) => string | undefined;
-    data: {
-        [field: string]: any;
-        name: string;
-        type: string;
-        version: string;
-        main: string;
-        module: string;
-        browser: string | Record<string, string | false>;
-        exports: string | Record<string, any> | string[];
-        imports: Record<string, any>;
-        dependencies: Record<string, string>;
-    };
+    waitForRequestsIdle(ignoredId?: string): Promise<void>;
 }
 
 interface RollupCommonJSOptions {
@@ -2349,19 +2417,100 @@ interface TerserOptions extends Terser.MinifyOptions {
     maxWorkers?: number;
 }
 
-interface BuildOptions {
+interface EnvironmentResolveOptions {
+    /**
+     * @default ['browser', 'module', 'jsnext:main', 'jsnext']
+     */
+    mainFields?: string[];
+    conditions?: string[];
+    externalConditions?: string[];
+    /**
+     * @default ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json']
+     */
+    extensions?: string[];
+    dedupe?: string[];
+    /**
+     * Prevent listed dependencies from being externalized and will get bundled in build.
+     * Only works in server environments for now. Previously this was `ssr.noExternal`.
+     * @experimental
+     */
+    noExternal?: string | RegExp | (string | RegExp)[] | true;
+    /**
+     * Externalize the given dependencies and their transitive dependencies.
+     * Only works in server environments for now. Previously this was `ssr.external`.
+     * @experimental
+     */
+    external?: string[] | true;
+    /**
+     * Array of strings or regular expressions that indicate what modules are builtin for the environment.
+     */
+    builtins?: (string | RegExp)[];
+}
+interface ResolveOptions extends EnvironmentResolveOptions {
+    /**
+     * @default false
+     */
+    preserveSymlinks?: boolean;
+}
+interface ResolvePluginOptions {
+    root: string;
+    isBuild: boolean;
+    isProduction: boolean;
+    packageCache?: PackageCache;
+    /**
+     * src code mode also attempts the following:
+     * - resolving /xxx as URLs
+     * - resolving bare imports from optimized deps
+     */
+    asSrc?: boolean;
+    tryIndex?: boolean;
+    tryPrefix?: string;
+    preferRelative?: boolean;
+    isRequire?: boolean;
+    /** @deprecated */
+    isFromTsImporter?: boolean;
+    scan?: boolean;
+    /**
+     * @deprecated environment.config are used instead
+     */
+    ssrConfig?: SSROptions;
+}
+interface InternalResolveOptions extends Required<ResolveOptions>, ResolvePluginOptions {
+}
+
+/** Cache for package.json resolution and package.json contents */
+type PackageCache = Map<string, PackageData>;
+interface PackageData {
+    dir: string;
+    hasSideEffects: (id: string) => boolean | 'no-treeshake' | null;
+    setResolvedCache: (key: string, entry: string, options: InternalResolveOptions) => void;
+    getResolvedCache: (key: string, options: InternalResolveOptions) => string | undefined;
+    data: {
+        [field: string]: any;
+        name: string;
+        type: string;
+        version: string;
+        main: string;
+        module: string;
+        browser: string | Record<string, string | false>;
+        exports: string | Record<string, any> | string[];
+        imports: Record<string, any>;
+        dependencies: Record<string, string>;
+    };
+}
+
+interface BuildEnvironmentOptions {
     /**
      * Compatibility transform target. The transform is performed with esbuild
-     * and the lowest supported target is es2015/es6. Note this only handles
-     * syntax transformation and does not cover polyfills (except for dynamic
-     * import)
+     * and the lowest supported target is es2015. Note this only handles
+     * syntax transformation and does not cover polyfills
      *
-     * Default: 'modules' - Similar to `@babel/preset-env`'s targets.esmodules,
-     * transpile targeting browsers that natively support dynamic es module imports.
-     * https://caniuse.com/es6-module-dynamic-import
+     * Default: 'modules' - transpile targeting browsers that natively support
+     * dynamic es module imports and `import.meta`
+     * (Chrome 87+, Firefox 78+, Safari 14+, Edge 88+).
      *
      * Another special value is 'esnext' - which only performs minimal transpiling
-     * (for minification compat) and assumes native dynamic imports support.
+     * (for minification compat).
      *
      * For custom targets, see https://esbuild.github.io/api/#target and
      * https://esbuild.github.io/content-types/#javascript for more details.
@@ -2395,7 +2544,10 @@ interface BuildOptions {
     assetsDir?: string;
     /**
      * Static asset files smaller than this number (in bytes) will be inlined as
-     * base64 strings. Default limit is `4096` (4 KiB). Set to `0` to disable.
+     * base64 strings. If a callback is passed, a boolean can be returned to opt-in
+     * or opt-out of inlining. If nothing is returned the default logic applies.
+     *
+     * Default limit is `4096` (4 KiB). Set to `0` to disable.
      * @default 4096
      */
     assetsInlineLimit?: number | ((filePath: string, content: Buffer) => boolean | undefined);
@@ -2473,7 +2625,7 @@ interface BuildOptions {
      */
     copyPublicDir?: boolean;
     /**
-     * Whether to emit a .vite/manifest.json under assets dir to map hash-less filenames
+     * Whether to emit a .vite/manifest.json in the output dir to map hash-less filenames
      * to their hashed versions. Useful when you want to generate your own HTML
      * instead of using the one generated by Vite.
      *
@@ -2516,6 +2668,11 @@ interface BuildOptions {
      * @default false
      */
     ssrEmitAssets?: boolean;
+    /**
+     * Emit assets during build. Frameworks can set environments.ssr.build.emitAssets
+     * By default, it is true for the client and false for other environments.
+     */
+    emitAssets?: boolean;
     /**
      * Set to false to disable reporting compressed chunk sizes.
      * Can slightly improve build speed.
@@ -2533,7 +2690,12 @@ interface BuildOptions {
      * @default null
      */
     watch?: WatcherOptions | null;
+    /**
+     * create the Build Environment instance
+     */
+    createEnvironment?: (name: string, config: ResolvedConfig) => Promise<BuildEnvironment> | BuildEnvironment;
 }
+type BuildOptions = BuildEnvironmentOptions;
 interface LibraryOptions {
     /**
      * Path of library entry
@@ -2555,6 +2717,12 @@ interface LibraryOptions {
      * format as an argument.
      */
     fileName?: string | ((format: ModuleFormat, entryName: string) => string);
+    /**
+     * The name of the CSS file output if the library imports CSS. Defaults to the
+     * same value as `build.lib.fileName` if it's set a string, otherwise it falls
+     * back to the name option of the project package.json.
+     */
+    cssFileName?: string;
 }
 type LibraryFormats = 'es' | 'cjs' | 'umd' | 'iife' | 'system';
 interface ModulePreloadOptions {
@@ -2578,11 +2746,14 @@ type ResolveModulePreloadDependenciesFn = (filename: string, deps: string[], con
     hostId: string;
     hostType: 'html' | 'js';
 }) => string[];
+interface ResolvedBuildEnvironmentOptions extends Required<Omit<BuildEnvironmentOptions, 'polyfillModulePreload'>> {
+    modulePreload: false | ResolvedModulePreloadOptions;
+}
 interface ResolvedBuildOptions extends Required<Omit<BuildOptions, 'polyfillModulePreload'>> {
     modulePreload: false | ResolvedModulePreloadOptions;
 }
 /**
- * Bundles the app for production.
+ * Bundles a single environment for production.
  * Returns a Promise containing the build result.
  */
 declare function build(inlineConfig?: InlineConfig): Promise<RollupOutput | RollupOutput[] | RollupWatcher>;
@@ -2595,408 +2766,397 @@ type RenderBuiltAssetUrl = (filename: string, type: {
     relative?: boolean;
     runtime?: string;
 } | undefined;
-
-interface ESBuildOptions extends esbuild_TransformOptions {
-    include?: string | RegExp | string[] | RegExp[];
-    exclude?: string | RegExp | string[] | RegExp[];
-    jsxInject?: string;
+declare class BuildEnvironment extends BaseEnvironment {
+    mode: "build";
+    constructor(name: string, config: ResolvedConfig, setup?: {
+        options?: EnvironmentOptions;
+    });
+    init(): Promise<void>;
+}
+interface ViteBuilder {
+    environments: Record<string, BuildEnvironment>;
+    config: ResolvedConfig;
+    buildApp(): Promise<void>;
+    build(environment: BuildEnvironment): Promise<RollupOutput | RollupOutput[] | RollupWatcher>;
+}
+interface BuilderOptions {
     /**
-     * This option is not respected. Use `build.minify` instead.
+     * Whether to share the config instance among environments to align with the behavior of dev server.
+     *
+     * @default false
+     * @experimental
      */
-    minify?: never;
+    sharedConfigBuild?: boolean;
+    /**
+     * Whether to share the plugin instances among environments to align with the behavior of dev server.
+     *
+     * @default false
+     * @experimental
+     */
+    sharedPlugins?: boolean;
+    buildApp?: (builder: ViteBuilder) => Promise<void>;
 }
-type ESBuildTransformResult = Omit<esbuild_TransformResult, 'map'> & {
-    map: SourceMap;
-};
-declare function transformWithEsbuild(code: string, filename: string, options?: esbuild_TransformOptions, inMap?: object): Promise<ESBuildTransformResult>;
+type ResolvedBuilderOptions = Required<BuilderOptions>;
+/**
+ * Creates a ViteBuilder to orchestrate building multiple environments.
+ * @experimental
+ */
+declare function createBuilder(inlineConfig?: InlineConfig, useLegacyBuilder?: null | boolean): Promise<ViteBuilder>;
 
-type ExportsData = {
-    hasModuleSyntax: boolean;
-    exports: readonly string[];
-    jsxLoader?: boolean;
-};
-interface DepsOptimizer {
-    metadata: DepOptimizationMetadata;
-    scanProcessing?: Promise<void>;
-    registerMissingImport: (id: string, resolved: string) => OptimizedDepInfo;
-    run: () => void;
-    isOptimizedDepFile: (id: string) => boolean;
-    isOptimizedDepUrl: (url: string) => boolean;
-    getOptimizedDepId: (depInfo: OptimizedDepInfo) => string;
-    close: () => Promise<void>;
-    options: DepOptimizationOptions;
+type Environment = DevEnvironment | BuildEnvironment |  UnknownEnvironment;
+/**
+ * Creates a function that hides the complexities of a WeakMap with an initial value
+ * to implement object metadata. Used by plugins to implement cross hooks per
+ * environment metadata
+ *
+ * @experimental
+ */
+declare function perEnvironmentState<State>(initial: (environment: Environment) => State): (context: PluginContext) => State;
+
+type SkipInformation = {
+    id: string;
+    importer: string | undefined;
+    plugin: Plugin;
+    called?: boolean;
+};
+declare class EnvironmentPluginContainer {
+    environment: Environment;
+    plugins: Plugin[];
+    watcher?: FSWatcher | undefined;
+    private _pluginContextMap;
+    private _resolvedRollupOptions?;
+    private _processesing;
+    private _seenResolves;
+    private _moduleNodeToLoadAddedImports;
+    getSortedPluginHooks: PluginHookUtils['getSortedPluginHooks'];
+    getSortedPlugins: PluginHookUtils['getSortedPlugins'];
+    moduleGraph: EnvironmentModuleGraph | undefined;
+    watchFiles: Set<string>;
+    minimalContext: MinimalPluginContext;
+    private _started;
+    private _buildStartPromise;
+    private _closed;
+    private _updateModuleLoadAddedImports;
+    private _getAddedImports;
+    getModuleInfo(id: string): ModuleInfo | null;
+    private handleHookPromise;
+    get options(): InputOptions;
+    resolveRollupOptions(): Promise<InputOptions>;
+    private _getPluginContext;
+    private hookParallel;
+    buildStart(_options?: InputOptions): Promise<void>;
+    resolveId(rawId: string, importer?: string | undefined, options?: {
+        attributes?: Record<string, string>;
+        custom?: CustomPluginOptions;
+        /** @deprecated use `skipCalls` instead */
+        skip?: Set<Plugin>;
+        skipCalls?: readonly SkipInformation[];
+        isEntry?: boolean;
+    }): Promise<PartialResolvedId | null>;
+    load(id: string): Promise<LoadResult | null>;
+    transform(code: string, id: string, options?: {
+        inMap?: SourceDescription['map'];
+    }): Promise<{
+        code: string;
+        map: SourceMap | {
+            mappings: '';
+        } | null;
+    }>;
+    watchChange(id: string, change: {
+        event: 'create' | 'update' | 'delete';
+    }): Promise<void>;
+    close(): Promise<void>;
 }
-interface DepOptimizationConfig {
+declare class MinimalPluginContext implements rollup.MinimalPluginContext {
+    meta: PluginContextMeta;
+    environment: Environment;
+    constructor(meta: PluginContextMeta, environment: Environment);
+    debug(rawLog: string | RollupLog | (() => string | RollupLog)): void;
+    info(rawLog: string | RollupLog | (() => string | RollupLog)): void;
+    warn(rawLog: string | RollupLog | (() => string | RollupLog)): void;
+    error(e: string | RollupError): never;
+    private _normalizeRawLog;
+}
+declare class PluginContainer {
+    private environments;
+    constructor(environments: Record<string, Environment>);
+    private _getEnvironment;
+    private _getPluginContainer;
+    getModuleInfo(id: string): ModuleInfo | null;
+    get options(): InputOptions;
+    buildStart(_options?: InputOptions): Promise<void>;
+    watchChange(id: string, change: {
+        event: 'create' | 'update' | 'delete';
+    }): Promise<void>;
+    resolveId(rawId: string, importer?: string, options?: {
+        attributes?: Record<string, string>;
+        custom?: CustomPluginOptions;
+        /** @deprecated use `skipCalls` instead */
+        skip?: Set<Plugin>;
+        skipCalls?: readonly SkipInformation[];
+        ssr?: boolean;
+        isEntry?: boolean;
+    }): Promise<PartialResolvedId | null>;
+    load(id: string, options?: {
+        ssr?: boolean;
+    }): Promise<LoadResult | null>;
+    transform(code: string, id: string, options?: {
+        ssr?: boolean;
+        environment?: Environment;
+        inMap?: SourceDescription['map'];
+    }): Promise<{
+        code: string;
+        map: SourceMap | {
+            mappings: '';
+        } | null;
+    }>;
+    close(): Promise<void>;
+}
+
+interface ServerOptions extends CommonServerOptions {
     /**
-     * Force optimize listed dependencies (must be resolvable import paths,
-     * cannot be globs).
+     * Configure HMR-specific options (port, host, path & protocol)
      */
-    include?: string[];
+    hmr?: HmrOptions | boolean;
     /**
-     * Do not optimize these dependencies (must be resolvable import paths,
-     * cannot be globs).
+     * Do not start the websocket connection.
+     * @experimental
      */
-    exclude?: string[];
+    ws?: false;
     /**
-     * Forces ESM interop when importing these dependencies. Some legacy
-     * packages advertise themselves as ESM but use `require` internally
-     * @experimental
+     * Warm-up files to transform and cache the results in advance. This improves the
+     * initial page load during server starts and prevents transform waterfalls.
      */
-    needsInterop?: string[];
+    warmup?: {
+        /**
+         * The files to be transformed and used on the client-side. Supports glob patterns.
+         */
+        clientFiles?: string[];
+        /**
+         * The files to be transformed and used in SSR. Supports glob patterns.
+         */
+        ssrFiles?: string[];
+    };
     /**
-     * Options to pass to esbuild during the dep scanning and optimization
-     *
-     * Certain options are omitted since changing them would not be compatible
-     * with Vite's dep optimization.
-     *
-     * - `external` is also omitted, use Vite's `optimizeDeps.exclude` option
-     * - `plugins` are merged with Vite's dep plugin
-     *
-     * https://esbuild.github.io/api
+     * chokidar watch options or null to disable FS watching
+     * https://github.com/paulmillr/chokidar/tree/3.6.0#api
      */
-    esbuildOptions?: Omit<esbuild_BuildOptions, 'bundle' | 'entryPoints' | 'external' | 'write' | 'watch' | 'outdir' | 'outfile' | 'outbase' | 'outExtension' | 'metafile'>;
+    watch?: WatchOptions | null;
     /**
-     * List of file extensions that can be optimized. A corresponding esbuild
-     * plugin must exist to handle the specific extension.
-     *
-     * By default, Vite can optimize `.mjs`, `.js`, `.ts`, and `.mts` files. This option
-     * allows specifying additional extensions.
+     * Create Vite dev server to be used as a middleware in an existing server
+     * @default false
+     */
+    middlewareMode?: boolean | {
+        /**
+         * Parent server instance to attach to
+         *
+         * This is needed to proxy WebSocket connections to the parent server.
+         */
+        server: HttpServer;
+    };
+    /**
+     * Options for files served via '/\@fs/'.
+     */
+    fs?: FileSystemServeOptions;
+    /**
+     * Origin for the generated asset URLs.
      *
-     * @experimental
+     * @example `http://127.0.0.1:8080`
      */
-    extensions?: string[];
+    origin?: string;
     /**
-     * Deps optimization during build was removed in Vite 5.1. This option is
-     * now redundant and will be removed in a future version. Switch to using
-     * `optimizeDeps.noDiscovery` and an empty or undefined `optimizeDeps.include`.
-     * true or 'dev' disables the optimizer, false or 'build' leaves it enabled.
-     * @default 'build'
-     * @deprecated
-     * @experimental
+     * Pre-transform known direct imports
+     * @default true
      */
-    disabled?: boolean | 'build' | 'dev';
+    preTransformRequests?: boolean;
     /**
-     * Automatic dependency discovery. When `noDiscovery` is true, only dependencies
-     * listed in `include` will be optimized. The scanner isn't run for cold start
-     * in this case. CJS-only dependencies must be present in `include` during dev.
+     * Whether or not to ignore-list source files in the dev server sourcemap, used to populate
+     * the [`x_google_ignoreList` source map extension](https://developer.chrome.com/blog/devtools-better-angular-debugging/#the-x_google_ignorelist-source-map-extension).
+     *
+     * By default, it excludes all paths containing `node_modules`. You can pass `false` to
+     * disable this behavior, or, for full control, a function that takes the source path and
+     * sourcemap path and returns whether to ignore the source path.
+     */
+    sourcemapIgnoreList?: false | ((sourcePath: string, sourcemapPath: string) => boolean);
+    /**
+     * Backward compatibility. The buildStart and buildEnd hooks were called only once for all
+     * environments. This option enables per-environment buildStart and buildEnd hooks.
      * @default false
      * @experimental
      */
-    noDiscovery?: boolean;
+    perEnvironmentStartEndDuringDev?: boolean;
     /**
-     * When enabled, it will hold the first optimized deps results until all static
-     * imports are crawled on cold start. This avoids the need for full-page reloads
-     * when new dependencies are discovered and they trigger the generation of new
-     * common chunks. If all dependencies are found by the scanner plus the explicitly
-     * defined ones in `include`, it is better to disable this option to let the
-     * browser process more requests in parallel.
-     * @default true
+     * Run HMR tasks, by default the HMR propagation is done in parallel for all environments
      * @experimental
      */
-    holdUntilCrawlEnd?: boolean;
+    hotUpdateEnvironments?: (server: ViteDevServer, hmr: (environment: DevEnvironment) => Promise<void>) => Promise<void>;
 }
-type DepOptimizationOptions = DepOptimizationConfig & {
+interface ResolvedServerOptions extends Omit<RequiredExceptFor<ServerOptions, 'host' | 'https' | 'proxy' | 'hmr' | 'ws' | 'watch' | 'origin' | 'hotUpdateEnvironments'>, 'fs' | 'middlewareMode' | 'sourcemapIgnoreList'> {
+    fs: Required<FileSystemServeOptions>;
+    middlewareMode: NonNullable<ServerOptions['middlewareMode']>;
+    sourcemapIgnoreList: Exclude<ServerOptions['sourcemapIgnoreList'], false | undefined>;
+}
+interface FileSystemServeOptions {
     /**
-     * By default, Vite will crawl your `index.html` to detect dependencies that
-     * need to be pre-bundled. If `build.rollupOptions.input` is specified, Vite
-     * will crawl those entry points instead.
+     * Strictly restrict file accessing outside of allowing paths.
      *
-     * If neither of these fit your needs, you can specify custom entries using
-     * this option - the value should be a fast-glob pattern or array of patterns
-     * (https://github.com/mrmlnc/fast-glob#basic-syntax) that are relative from
-     * vite project root. This will overwrite default entries inference.
-     */
-    entries?: string | string[];
-    /**
-     * Force dep pre-optimization regardless of whether deps have changed.
-     * @experimental
+     * Set to `false` to disable the warning
+     *
+     * @default true
      */
-    force?: boolean;
-};
-interface OptimizedDepInfo {
-    id: string;
-    file: string;
-    src?: string;
-    needsInterop?: boolean;
-    browserHash?: string;
-    fileHash?: string;
+    strict?: boolean;
     /**
-     * During optimization, ids can still be resolved to their final location
-     * but the bundles may not yet be saved to disk
+     * Restrict accessing files outside the allowed directories.
+     *
+     * Accepts absolute path or a path relative to project root.
+     * Will try to search up for workspace root by default.
      */
-    processing?: Promise<void>;
+    allow?: string[];
     /**
-     * ExportData cache, discovered deps will parse the src entry to get exports
-     * data used both to define if interop is needed and when pre-bundling
+     * Restrict accessing files that matches the patterns.
+     *
+     * This will have higher priority than `allow`.
+     * picomatch patterns are supported.
+     *
+     * @default ['.env', '.env.*', '*.{crt,pem}', '**\/.git/**']
      */
-    exportsData?: Promise<ExportsData>;
+    deny?: string[];
 }
-interface DepOptimizationMetadata {
+type ServerHook = (this: void, server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>;
+type HttpServer = http.Server | Http2SecureServer;
+interface ViteDevServer {
     /**
-     * The main hash is determined by user config and dependency lockfiles.
-     * This is checked on server startup to avoid unnecessary re-bundles.
+     * The resolved vite config object
      */
-    hash: string;
+    config: ResolvedConfig;
     /**
-     * This hash is determined by dependency lockfiles.
-     * This is checked on server startup to avoid unnecessary re-bundles.
+     * A connect app instance.
+     * - Can be used to attach custom middlewares to the dev server.
+     * - Can also be used as the handler function of a custom http server
+     *   or as a middleware in any connect-style Node.js frameworks
+     *
+     * https://github.com/senchalabs/connect#use-middleware
      */
-    lockfileHash: string;
+    middlewares: Connect.Server;
     /**
-     * This hash is determined by user config.
-     * This is checked on server startup to avoid unnecessary re-bundles.
+     * native Node http server instance
+     * will be null in middleware mode
      */
-    configHash: string;
+    httpServer: HttpServer | null;
     /**
-     * The browser hash is determined by the main hash plus additional dependencies
-     * discovered at runtime. This is used to invalidate browser requests to
-     * optimized deps.
+     * Chokidar watcher instance. If `config.server.watch` is set to `null`,
+     * it will not watch any files and calling `add` or `unwatch` will have no effect.
+     * https://github.com/paulmillr/chokidar/tree/3.6.0#api
      */
-    browserHash: string;
+    watcher: FSWatcher;
     /**
-     * Metadata for each already optimized dependency
+     * web socket server with `send(payload)` method
      */
-    optimized: Record<string, OptimizedDepInfo>;
+    ws: WebSocketServer;
     /**
-     * Metadata for non-entry optimized chunks and dynamic imports
+     * HMR broadcaster that can be used to send custom HMR messages to the client
+     *
+     * Always sends a message to at least a WebSocket client. Any third party can
+     * add a channel to the broadcaster to process messages
      */
-    chunks: Record<string, OptimizedDepInfo>;
+    hot: HotBroadcaster;
     /**
-     * Metadata for each newly discovered dependency after processing
+     * Rollup plugin container that can run plugin hooks on a given file
      */
-    discovered: Record<string, OptimizedDepInfo>;
+    pluginContainer: PluginContainer;
     /**
-     * OptimizedDepInfo list
+     * Module execution environments attached to the Vite server.
      */
-    depInfoList: OptimizedDepInfo[];
-}
-/**
- * Scan and optimize dependencies within a project.
- * Used by Vite CLI when running `vite optimize`.
- */
-declare function optimizeDeps(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
-
-type SSRTarget = 'node' | 'webworker';
-type SsrDepOptimizationOptions = DepOptimizationConfig;
-interface SSROptions {
-    noExternal?: string | RegExp | (string | RegExp)[] | true;
-    external?: string[] | true;
+    environments: Record<'client' | 'ssr' | (string & {}), DevEnvironment>;
     /**
-     * Define the target for the ssr build. The browser field in package.json
-     * is ignored for node but used if webworker is the target
-     * @default 'node'
+     * Module graph that tracks the import relationships, url to file mapping
+     * and hmr state.
      */
-    target?: SSRTarget;
+    moduleGraph: ModuleGraph;
     /**
-     * Control over which dependencies are optimized during SSR and esbuild options
-     * During build:
-     *   no external CJS dependencies are optimized by default
-     * During dev:
-     *   explicit no external CJS dependencies are optimized by default
-     * @experimental
+     * The resolved urls Vite prints on the CLI (URL-encoded). Returns `null`
+     * in middleware mode or if the server is not listening on any port.
      */
-    optimizeDeps?: SsrDepOptimizationOptions;
-    resolve?: {
-        /**
-         * Conditions that are used in the plugin pipeline. The default value is the root config's `resolve.conditions`.
-         *
-         * Use this to override the default ssr conditions for the ssr build.
-         *
-         * @default rootConfig.resolve.conditions
-         */
-        conditions?: string[];
-        /**
-         * Conditions that are used during ssr import (including `ssrLoadModule`) of externalized dependencies.
-         *
-         * @default []
-         */
-        externalConditions?: string[];
-    };
-}
-interface ResolvedSSROptions extends SSROptions {
-    target: SSRTarget;
-    optimizeDeps: SsrDepOptimizationOptions;
-}
-
-interface FsUtils {
-    existsSync: (path: string) => boolean;
-    isDirectory: (path: string) => boolean;
-    tryResolveRealFile: (path: string, preserveSymlinks?: boolean) => string | undefined;
-    tryResolveRealFileWithExtensions: (path: string, extensions: string[], preserveSymlinks?: boolean) => string | undefined;
-    tryResolveRealFileOrType: (path: string, preserveSymlinks?: boolean) => {
-        path?: string;
-        type: 'directory' | 'file';
-    } | undefined;
-    initWatcher?: (watcher: FSWatcher) => void;
-}
-
-interface ResolveOptions {
+    resolvedUrls: ResolvedServerUrls | null;
+    /**
+     * Programmatically resolve, load and transform a URL and get the result
+     * without going through the http request pipeline.
+     */
+    transformRequest(url: string, options?: TransformOptions): Promise<TransformResult | null>;
     /**
-     * @default ['browser', 'module', 'jsnext:main', 'jsnext']
+     * Same as `transformRequest` but only warm up the URLs so the next request
+     * will already be cached. The function will never throw as it handles and
+     * reports errors internally.
      */
-    mainFields?: string[];
-    conditions?: string[];
+    warmupRequest(url: string, options?: TransformOptions): Promise<void>;
     /**
-     * @default ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json']
+     * Apply vite built-in HTML transforms and any plugin HTML transforms.
      */
-    extensions?: string[];
-    dedupe?: string[];
+    transformIndexHtml(url: string, html: string, originalUrl?: string): Promise<string>;
     /**
-     * @default false
+     * Transform module code into SSR format.
      */
-    preserveSymlinks?: boolean;
-}
-interface InternalResolveOptions extends Required<ResolveOptions> {
-    root: string;
-    isBuild: boolean;
-    isProduction: boolean;
-    ssrConfig?: SSROptions;
-    packageCache?: PackageCache;
-    fsUtils?: FsUtils;
+    ssrTransform(code: string, inMap: SourceMap | {
+        mappings: '';
+    } | null, url: string, originalCode?: string): Promise<TransformResult | null>;
     /**
-     * src code mode also attempts the following:
-     * - resolving /xxx as URLs
-     * - resolving bare imports from optimized deps
+     * Load a given URL as an instantiated module for SSR.
      */
-    asSrc?: boolean;
-    tryIndex?: boolean;
-    tryPrefix?: string;
-    preferRelative?: boolean;
-    isRequire?: boolean;
-    isFromTsImporter?: boolean;
-    tryEsmOnly?: boolean;
-    scan?: boolean;
-    ssrOptimizeCheck?: boolean;
-    getDepsOptimizer?: (ssr: boolean) => DepsOptimizer | undefined;
-    shouldExternalize?: (id: string, importer?: string) => boolean | undefined;
-}
-
-// This file is autogenerated by build-prefixes.js. DO NOT EDIT!
-
-interface Targets {
-  android?: number,
-  chrome?: number,
-  edge?: number,
-  firefox?: number,
-  ie?: number,
-  ios_saf?: number,
-  opera?: number,
-  safari?: number,
-  samsung?: number
-}
-
-interface Drafts {
-  /** Whether to enable @custom-media rules. */
-  customMedia?: boolean
-}
-
-interface NonStandard {
-  /** Whether to enable the non-standard >>> and /deep/ selector combinators used by Angular and Vue. */
-  deepSelectorCombinator?: boolean
-}
-
-interface PseudoClasses {
-  hover?: string,
-  active?: string,
-  focus?: string,
-  focusVisible?: string,
-  focusWithin?: string
-}
-
-interface CSSModulesConfig {
-  /** The pattern to use when renaming class names and other identifiers. Default is `[hash]_[local]`. */
-  pattern?: string,
-  /** Whether to rename dashed identifiers, e.g. custom properties. */
-  dashedIdents?: boolean
-}
-
-/**
- * Options are spread, so you can also use options that are not typed here like
- * visitor (not exposed because it would impact too much the bundle size)
- */
-type LightningCSSOptions = {
-  targets?: Targets
-  include?: number
-  exclude?: number
-  drafts?: Drafts
-  nonStandard?: NonStandard
-  pseudoClasses?: PseudoClasses
-  unusedSymbols?: string[]
-  cssModules?: CSSModulesConfig
-  errorRecovery?: boolean
-}
-
-interface CSSOptions {
+    ssrLoadModule(url: string, opts?: {
+        fixStacktrace?: boolean;
+    }): Promise<Record<string, any>>;
     /**
-     * Using lightningcss is an experimental option to handle CSS modules,
-     * assets and imports via Lightning CSS. It requires to install it as a
-     * peer dependency. This is incompatible with the use of preprocessors.
-     *
-     * @default 'postcss'
-     * @experimental
+     * Returns a fixed version of the given stack
      */
-    transformer?: 'postcss' | 'lightningcss';
+    ssrRewriteStacktrace(stack: string): string;
     /**
-     * https://github.com/css-modules/postcss-modules
+     * Mutates the given SSR error by rewriting the stacktrace
      */
-    modules?: CSSModulesOptions | false;
+    ssrFixStacktrace(e: Error): void;
     /**
-     * Options for preprocessors.
-     *
-     * In addition to options specific to each processors, Vite supports `additionalData` option.
-     * The `additionalData` option can be used to inject extra code for each style content.
+     * Triggers HMR for a module in the module graph. You can use the `server.moduleGraph`
+     * API to retrieve the module to be reloaded. If `hmr` is false, this is a no-op.
      */
-    preprocessorOptions?: Record<string, any>;
+    reloadModule(module: ModuleNode): Promise<void>;
     /**
-     * If this option is set, preprocessors will run in workers when possible.
-     * `true` means the number of CPUs minus 1.
-     *
-     * @default 0
-     * @experimental
+     * Start the server.
      */
-    preprocessorMaxWorkers?: number | true;
-    postcss?: string | (PostCSS.ProcessOptions & {
-        plugins?: PostCSS.AcceptedPlugin[];
-    });
+    listen(port?: number, isRestart?: boolean): Promise<ViteDevServer>;
     /**
-     * Enables css sourcemaps during dev
-     * @default false
-     * @experimental
+     * Stop the server.
      */
-    devSourcemap?: boolean;
+    close(): Promise<void>;
     /**
-     * @experimental
+     * Print server urls
      */
-    lightningcss?: LightningCSSOptions;
-}
-interface CSSModulesOptions {
-    getJSON?: (cssFileName: string, json: Record<string, string>, outputFileName: string) => void;
-    scopeBehaviour?: 'global' | 'local';
-    globalModulePaths?: RegExp[];
-    exportGlobals?: boolean;
-    generateScopedName?: string | ((name: string, filename: string, css: string) => string);
-    hashPrefix?: string;
+    printUrls(): void;
     /**
-     * default: undefined
+     * Bind CLI shortcuts
      */
-    localsConvention?: 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly' | ((originalClassName: string, generatedClassName: string, inputFile: string) => string);
+    bindCLIShortcuts(options?: BindCLIShortcutsOptions<ViteDevServer>): void;
+    /**
+     * Restart the server.
+     *
+     * @param forceOptimize - force the optimizer to re-bundle, same as --force cli flag
+     */
+    restart(forceOptimize?: boolean): Promise<void>;
+    /**
+     * Open browser
+     */
+    openBrowser(): void;
+    /**
+     * Calling `await server.waitForRequestsIdle(id)` will wait until all static imports
+     * are processed. If called from a load or transform plugin hook, the id needs to be
+     * passed as a parameter to avoid deadlocks. Calling this function after the first
+     * static imports section of the module graph has been processed will resolve immediately.
+     */
+    waitForRequestsIdle: (ignoredId?: string) => Promise<void>;
 }
-type ResolvedCSSOptions = Omit<CSSOptions, 'lightningcss'> & {
-    lightningcss?: LightningCSSOptions & {
-        targets: LightningCSSOptions['targets'];
-    };
-};
-interface PreprocessCSSResult {
-    code: string;
-    map?: SourceMapInput;
-    modules?: Record<string, string>;
-    deps?: Set<string>;
+interface ResolvedServerUrls {
+    local: string[];
+    network: string[];
 }
-/**
- * @experimental
- */
-declare function preprocessCSS(code: string, filename: string, config: ResolvedConfig): Promise<PreprocessCSSResult>;
-declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;
+declare function createServer(inlineConfig?: InlineConfig | ResolvedConfig): Promise<ViteDevServer>;
 
 interface HtmlTagDescriptor {
     tag: string;
@@ -3045,6 +3205,11 @@ type IndexHtmlTransform = IndexHtmlTransformHook | {
     handler: IndexHtmlTransformHook;
 };
 
+type StringFilter<Value = string | RegExp> = Value | Array<Value> | {
+    include?: Value | Array<Value>;
+    exclude?: Value | Array<Value>;
+};
+
 /**
  * Vite plugins extends the Rollup plugin interface with a few extra
  * vite-specific options. A valid vite plugin is also a valid Rollup plugin.
@@ -3065,8 +3230,97 @@ type IndexHtmlTransform = IndexHtmlTransformHook | {
  *
  * If a plugin should be applied only for server or build, a function format
  * config file can be used to conditional determine the plugins to use.
+ *
+ * The current environment can be accessed from the context for the all non-global
+ * hooks (it is not available in config, configResolved, configureServer, etc).
+ * It can be a dev, build, or scan environment.
+ * Plugins can use this.environment.mode === 'dev' to guard for dev specific APIs.
+ */
+interface PluginContextExtension {
+    /**
+     * Vite-specific environment instance
+     */
+    environment: Environment;
+}
+interface HotUpdatePluginContext {
+    environment: DevEnvironment;
+}
+declare module 'rollup' {
+    interface MinimalPluginContext extends PluginContextExtension {
+    }
+}
+/**
+ * There are two types of plugins in Vite. App plugins and environment plugins.
+ * Environment Plugins are defined by a constructor function that will be called
+ * once per each environment allowing users to have completely different plugins
+ * for each of them. The constructor gets the resolved environment after the server
+ * and builder has already been created simplifying config access and cache
+ * management for for environment specific plugins.
+ * Environment Plugins are closer to regular rollup plugins. They can't define
+ * app level hooks (like config, configResolved, configureServer, etc).
  */
 interface Plugin<A = any> extends rollup.Plugin<A> {
+    /**
+     * Perform custom handling of HMR updates.
+     * The handler receives an options containing changed filename, timestamp, a
+     * list of modules affected by the file change, and the dev server instance.
+     *
+     * - The hook can return a filtered list of modules to narrow down the update.
+     *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
+     *   the descriptors.
+     *
+     * - The hook can also return an empty array and then perform custom updates
+     *   by sending a custom hmr payload via environment.hot.send().
+     *
+     * - If the hook doesn't return a value, the hmr update will be performed as
+     *   normal.
+     */
+    hotUpdate?: ObjectHook<(this: HotUpdatePluginContext, options: HotUpdateOptions) => Array<EnvironmentModuleNode> | void | Promise<Array<EnvironmentModuleNode> | void>>;
+    /**
+     * extend hooks with ssr flag
+     */
+    resolveId?: ObjectHook<(this: PluginContext, source: string, importer: string | undefined, options: {
+        attributes: Record<string, string>;
+        custom?: CustomPluginOptions;
+        ssr?: boolean;
+        isEntry: boolean;
+    }) => Promise<ResolveIdResult> | ResolveIdResult, {
+        filter?: {
+            id?: StringFilter<RegExp>;
+        };
+    }>;
+    load?: ObjectHook<(this: PluginContext, id: string, options?: {
+        ssr?: boolean;
+    }) => Promise<LoadResult> | LoadResult, {
+        filter?: {
+            id?: StringFilter;
+        };
+    }>;
+    transform?: ObjectHook<(this: TransformPluginContext, code: string, id: string, options?: {
+        ssr?: boolean;
+    }) => Promise<rollup.TransformResult> | rollup.TransformResult, {
+        filter?: {
+            id?: StringFilter;
+            code?: StringFilter;
+        };
+    }>;
+    /**
+     * Opt-in this plugin into the shared plugins pipeline.
+     * For backward-compatibility, plugins are re-recreated for each environment
+     * during `vite build --app`
+     * We have an opt-in per plugin, and a general `builder.sharedPlugins`
+     * In a future major, we'll flip the default to be shared by default
+     * @experimental
+     */
+    sharedDuringBuild?: boolean;
+    /**
+     * Opt-in this plugin into per-environment buildStart and buildEnd during dev.
+     * For backward-compatibility, the buildStart hook is called only once during
+     * dev, for the client environment. Plugins can opt-in to be called
+     * per-environment, aligning with the build hook behavior.
+     * @experimental
+     */
+    perEnvironmentStartEndDuringDev?: boolean;
     /**
      * Enforce plugin invocation tier similar to webpack loaders. Hooks ordering
      * is still subject to the `order` property in the hook object.
@@ -3085,6 +3339,12 @@ interface Plugin<A = any> extends rollup.Plugin<A> {
      * Apply the plugin only for serve or build, or on certain conditions.
      */
     apply?: 'serve' | 'build' | ((this: void, config: UserConfig, env: ConfigEnv) => boolean);
+    /**
+     * Define environments where this plugin should be active
+     * By default, the plugin is active in all environments
+     * @experimental
+     */
+    applyToEnvironment?: (environment: PartialEnvironment) => boolean | Promise<boolean> | PluginOption;
     /**
      * Modify vite config before it's resolved. The hook can either mutate the
      * passed-in config directly, or return a partial config object that will be
@@ -3094,6 +3354,23 @@ interface Plugin<A = any> extends rollup.Plugin<A> {
      * plugins inside  the `config` hook will have no effect.
      */
     config?: ObjectHook<(this: void, config: UserConfig, env: ConfigEnv) => Omit<UserConfig, 'plugins'> | null | void | Promise<Omit<UserConfig, 'plugins'> | null | void>>;
+    /**
+     * Modify environment configs before it's resolved. The hook can either mutate the
+     * passed-in environment config directly, or return a partial config object that will be
+     * deeply merged into existing config.
+     * This hook is called for each environment with a partially resolved environment config
+     * that already accounts for the default environment config values set at the root level.
+     * If plugins need to modify the config of a given environment, they should do it in this
+     * hook instead of the config hook. Leaving the config hook only for modifying the root
+     * default environment config.
+     */
+    configEnvironment?: ObjectHook<(this: void, name: string, config: EnvironmentOptions, env: ConfigEnv & {
+        /**
+         * Whether this environment is SSR environment and `ssr.target` is set to `'webworker'`.
+         * Only intended to be used for backward compatibility.
+         */
+        isSsrTargetWebworker?: boolean;
+    }) => EnvironmentOptions | null | void | Promise<EnvironmentOptions | null | void>>;
     /**
      * Use this hook to read and store the final resolved vite config.
      */
@@ -3123,8 +3400,13 @@ interface Plugin<A = any> extends rollup.Plugin<A> {
      * The hook receives the following arguments:
      *
      * - html: string
-     * - ctx?: vite.ServerContext (only present during serve)
-     * - bundle?: rollup.OutputBundle (only present during build)
+     * - ctx: IndexHtmlTransformContext, which contains:
+     *    - path: public path when served
+     *    - filename: filename on disk
+     *    - server?: ViteDevServer (only present during serve)
+     *    - bundle?: rollup.OutputBundle (only present during build)
+     *    - chunk?: rollup.OutputChunk
+     *    - originalUrl?: string
      *
      * It can either return a transformed string, or a list of html tag
      * descriptors that will be injected into the `<head>` or `<body>`.
@@ -3133,43 +3415,143 @@ interface Plugin<A = any> extends rollup.Plugin<A> {
      * transform. If you need to apply the transform before vite, use an object:
      * `{ order: 'pre', handler: hook }`
      */
-    transformIndexHtml?: IndexHtmlTransform;
+    transformIndexHtml?: IndexHtmlTransform;
+    /**
+     * Perform custom handling of HMR updates.
+     * The handler receives a context containing changed filename, timestamp, a
+     * list of modules affected by the file change, and the dev server instance.
+     *
+     * - The hook can return a filtered list of modules to narrow down the update.
+     *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
+     *   the descriptors.
+     *
+     * - The hook can also return an empty array and then perform custom updates
+     *   by sending a custom hmr payload via server.ws.send().
+     *
+     * - If the hook doesn't return a value, the hmr update will be performed as
+     *   normal.
+     */
+    handleHotUpdate?: ObjectHook<(this: void, ctx: HmrContext) => Array<ModuleNode> | void | Promise<Array<ModuleNode> | void>>;
+}
+type HookHandler<T> = T extends ObjectHook<infer H> ? H : T;
+type PluginWithRequiredHook<K extends keyof Plugin> = Plugin & {
+    [P in K]: NonNullable<Plugin[P]>;
+};
+type Thenable<T> = T | Promise<T>;
+type FalsyPlugin = false | null | undefined;
+type PluginOption = Thenable<Plugin | FalsyPlugin | PluginOption[]>;
+/**
+ * @experimental
+ */
+declare function perEnvironmentPlugin(name: string, applyToEnvironment: (environment: PartialEnvironment) => boolean | Promise<boolean> | PluginOption): Plugin;
+
+interface CSSOptions {
+    /**
+     * Using lightningcss is an experimental option to handle CSS modules,
+     * assets and imports via Lightning CSS. It requires to install it as a
+     * peer dependency.
+     *
+     * @default 'postcss'
+     * @experimental
+     */
+    transformer?: 'postcss' | 'lightningcss';
+    /**
+     * https://github.com/css-modules/postcss-modules
+     */
+    modules?: CSSModulesOptions | false;
+    /**
+     * Options for preprocessors.
+     *
+     * In addition to options specific to each processors, Vite supports `additionalData` option.
+     * The `additionalData` option can be used to inject extra code for each style content.
+     */
+    preprocessorOptions?: {
+        scss?: SassPreprocessorOptions;
+        sass?: SassPreprocessorOptions;
+        less?: LessPreprocessorOptions;
+        styl?: StylusPreprocessorOptions;
+        stylus?: StylusPreprocessorOptions;
+    };
+    /**
+     * If this option is set, preprocessors will run in workers when possible.
+     * `true` means the number of CPUs minus 1.
+     *
+     * @default 0
+     * @experimental
+     */
+    preprocessorMaxWorkers?: number | true;
+    postcss?: string | (PostCSS.ProcessOptions & {
+        plugins?: PostCSS.AcceptedPlugin[];
+    });
+    /**
+     * Enables css sourcemaps during dev
+     * @default false
+     * @experimental
+     */
+    devSourcemap?: boolean;
     /**
-     * Perform custom handling of HMR updates.
-     * The handler receives a context containing changed filename, timestamp, a
-     * list of modules affected by the file change, and the dev server instance.
-     *
-     * - The hook can return a filtered list of modules to narrow down the update.
-     *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
-     *   the descriptors.
-     *
-     * - The hook can also return an empty array and then perform custom updates
-     *   by sending a custom hmr payload via server.ws.send().
-     *
-     * - If the hook doesn't return a value, the hmr update will be performed as
-     *   normal.
+     * @experimental
      */
-    handleHotUpdate?: ObjectHook<(this: void, ctx: HmrContext) => Array<ModuleNode> | void | Promise<Array<ModuleNode> | void>>;
+    lightningcss?: LightningCSSOptions;
+}
+interface CSSModulesOptions {
+    getJSON?: (cssFileName: string, json: Record<string, string>, outputFileName: string) => void;
+    scopeBehaviour?: 'global' | 'local';
+    globalModulePaths?: RegExp[];
+    exportGlobals?: boolean;
+    generateScopedName?: string | ((name: string, filename: string, css: string) => string);
+    hashPrefix?: string;
     /**
-     * extend hooks with ssr flag
+     * default: undefined
      */
-    resolveId?: ObjectHook<(this: PluginContext, source: string, importer: string | undefined, options: {
-        attributes: Record<string, string>;
-        custom?: CustomPluginOptions;
-        ssr?: boolean;
-        isEntry: boolean;
-    }) => Promise<ResolveIdResult> | ResolveIdResult>;
-    load?: ObjectHook<(this: PluginContext, id: string, options?: {
-        ssr?: boolean;
-    }) => Promise<LoadResult> | LoadResult>;
-    transform?: ObjectHook<(this: TransformPluginContext, code: string, id: string, options?: {
-        ssr?: boolean;
-    }) => Promise<rollup.TransformResult> | rollup.TransformResult>;
+    localsConvention?: 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly' | ((originalClassName: string, generatedClassName: string, inputFile: string) => string);
 }
-type HookHandler<T> = T extends ObjectHook<infer H> ? H : T;
-type PluginWithRequiredHook<K extends keyof Plugin> = Plugin & {
-    [P in K]: NonNullable<Plugin[P]>;
+type ResolvedCSSOptions = Omit<CSSOptions, 'lightningcss'> & Required<Pick<CSSOptions, 'transformer' | 'devSourcemap'>> & {
+    lightningcss?: LightningCSSOptions;
+};
+interface PreprocessCSSResult {
+    code: string;
+    map?: SourceMapInput;
+    modules?: Record<string, string>;
+    deps?: Set<string>;
+}
+/**
+ * @experimental
+ */
+declare function preprocessCSS(code: string, filename: string, config: ResolvedConfig): Promise<PreprocessCSSResult>;
+declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;
+type PreprocessorAdditionalDataResult = string | {
+    content: string;
+    map?: ExistingRawSourceMap;
+};
+type PreprocessorAdditionalData = string | ((source: string, filename: string) => PreprocessorAdditionalDataResult | Promise<PreprocessorAdditionalDataResult>);
+type SassPreprocessorOptions = {
+    additionalData?: PreprocessorAdditionalData;
+} & (({
+    api: 'legacy';
+} & SassLegacyPreprocessBaseOptions) | ({
+    api?: 'modern' | 'modern-compiler';
+} & SassModernPreprocessBaseOptions));
+type LessPreprocessorOptions = {
+    additionalData?: PreprocessorAdditionalData;
+} & LessPreprocessorBaseOptions;
+type StylusPreprocessorOptions = {
+    additionalData?: PreprocessorAdditionalData;
+} & StylusPreprocessorBaseOptions;
+
+interface ESBuildOptions extends esbuild_TransformOptions {
+    include?: string | RegExp | ReadonlyArray<string | RegExp>;
+    exclude?: string | RegExp | ReadonlyArray<string | RegExp>;
+    jsxInject?: string;
+    /**
+     * This option is not respected. Use `build.minify` instead.
+     */
+    minify?: never;
+}
+type ESBuildTransformResult = Omit<esbuild_TransformResult, 'map'> & {
+    map: SourceMap;
 };
+declare function transformWithEsbuild(code: string, filename: string, options?: esbuild_TransformOptions, inMap?: object, config?: ResolvedConfig, watcher?: FSWatcher): Promise<ESBuildTransformResult>;
 
 interface JsonOptions {
     /**
@@ -3179,10 +3561,55 @@ interface JsonOptions {
     namedExports?: boolean;
     /**
      * Generate performant output as JSON.parse("stringified").
-     * Enabling this will disable namedExports.
-     * @default false
+     *
+     * When set to 'auto', the data will be stringified only if the data is bigger than 10kB.
+     * @default 'auto'
+     */
+    stringify?: boolean | 'auto';
+}
+
+type SSRTarget = 'node' | 'webworker';
+type SsrDepOptimizationConfig = DepOptimizationConfig;
+interface SSROptions {
+    noExternal?: string | RegExp | (string | RegExp)[] | true;
+    external?: string[] | true;
+    /**
+     * Define the target for the ssr build. The browser field in package.json
+     * is ignored for node but used if webworker is the target
+     * This option will be removed in a future major version
+     * @default 'node'
+     */
+    target?: SSRTarget;
+    /**
+     * Control over which dependencies are optimized during SSR and esbuild options
+     * During build:
+     *   no external CJS dependencies are optimized by default
+     * During dev:
+     *   explicit no external CJS dependencies are optimized by default
+     * @experimental
      */
-    stringify?: boolean;
+    optimizeDeps?: SsrDepOptimizationConfig;
+    resolve?: {
+        /**
+         * Conditions that are used in the plugin pipeline. The default value is the root config's `resolve.conditions`.
+         *
+         * Use this to override the default ssr conditions for the ssr build.
+         *
+         * @default rootConfig.resolve.conditions
+         */
+        conditions?: string[];
+        /**
+         * Conditions that are used during ssr import (including `ssrLoadModule`) of externalized dependencies.
+         *
+         * @default []
+         */
+        externalConditions?: string[];
+        mainFields?: string[];
+    };
+}
+interface ResolvedSSROptions extends SSROptions {
+    target: SSRTarget;
+    optimizeDeps: SsrDepOptimizationConfig;
 }
 
 interface ConfigEnv {
@@ -3215,9 +3642,113 @@ type UserConfigExport = UserConfig | Promise<UserConfig> | UserConfigFnObject |
 declare function defineConfig(config: UserConfig): UserConfig;
 declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
 declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
+declare function defineConfig(config: UserConfigFnPromise): UserConfigFnPromise;
+declare function defineConfig(config: UserConfigFn): UserConfigFn;
 declare function defineConfig(config: UserConfigExport): UserConfigExport;
-type PluginOption = Plugin | false | null | undefined | PluginOption[] | Promise<Plugin | false | null | undefined | PluginOption[]>;
-interface UserConfig {
+interface CreateDevEnvironmentContext {
+    ws: WebSocketServer;
+}
+interface DevEnvironmentOptions {
+    /**
+     * Files to be pre-transformed. Supports glob patterns.
+     */
+    warmup?: string[];
+    /**
+     * Pre-transform known direct imports
+     * defaults to true for the client environment, false for the rest
+     */
+    preTransformRequests?: boolean;
+    /**
+     * Enables sourcemaps during dev
+     * @default { js: true }
+     * @experimental
+     */
+    sourcemap?: boolean | {
+        js?: boolean;
+        css?: boolean;
+    };
+    /**
+     * Whether or not to ignore-list source files in the dev server sourcemap, used to populate
+     * the [`x_google_ignoreList` source map extension](https://developer.chrome.com/blog/devtools-better-angular-debugging/#the-x_google_ignorelist-source-map-extension).
+     *
+     * By default, it excludes all paths containing `node_modules`. You can pass `false` to
+     * disable this behavior, or, for full control, a function that takes the source path and
+     * sourcemap path and returns whether to ignore the source path.
+     */
+    sourcemapIgnoreList?: false | ((sourcePath: string, sourcemapPath: string) => boolean);
+    /**
+     * create the Dev Environment instance
+     */
+    createEnvironment?: (name: string, config: ResolvedConfig, context: CreateDevEnvironmentContext) => Promise<DevEnvironment> | DevEnvironment;
+    /**
+     * For environments that support a full-reload, like the client, we can short-circuit when
+     * restarting the server throwing early to stop processing current files. We avoided this for
+     * SSR requests. Maybe this is no longer needed.
+     * @experimental
+     */
+    recoverable?: boolean;
+    /**
+     * For environments associated with a module runner.
+     * By default it is true for the client environment and false for non-client environments.
+     * This option can also be used instead of the removed config.experimental.skipSsrTransform.
+     */
+    moduleRunnerTransform?: boolean;
+}
+type ResolvedDevEnvironmentOptions = Omit<Required<DevEnvironmentOptions>, 'sourcemapIgnoreList'> & {
+    sourcemapIgnoreList: Exclude<DevEnvironmentOptions['sourcemapIgnoreList'], false | undefined>;
+};
+type AllResolveOptions = ResolveOptions & {
+    alias?: AliasOptions;
+};
+interface SharedEnvironmentOptions {
+    /**
+     * Define global variable replacements.
+     * Entries will be defined on `window` during dev and replaced during build.
+     */
+    define?: Record<string, any>;
+    /**
+     * Configure resolver
+     */
+    resolve?: EnvironmentResolveOptions;
+    /**
+     * Define if this environment is used for Server Side Rendering
+     * @default 'server' if it isn't the client environment
+     */
+    consumer?: 'client' | 'server';
+    /**
+     * If true, `process.env` referenced in code will be preserved as-is and evaluated in runtime.
+     * Otherwise, it is statically replaced as an empty object.
+     */
+    keepProcessEnv?: boolean;
+    /**
+     * Optimize deps config
+     */
+    optimizeDeps?: DepOptimizationOptions;
+}
+interface EnvironmentOptions extends SharedEnvironmentOptions {
+    /**
+     * Dev specific options
+     */
+    dev?: DevEnvironmentOptions;
+    /**
+     * Build specific options
+     */
+    build?: BuildEnvironmentOptions;
+}
+type ResolvedResolveOptions = Required<ResolveOptions>;
+type ResolvedEnvironmentOptions = {
+    define?: Record<string, any>;
+    resolve: ResolvedResolveOptions;
+    consumer: 'client' | 'server';
+    keepProcessEnv?: boolean;
+    optimizeDeps: DepOptimizationOptions;
+    dev: ResolvedDevEnvironmentOptions;
+    build: ResolvedBuildEnvironmentOptions;
+};
+type DefaultEnvironmentOptions = Omit<EnvironmentOptions, 'consumer' | 'resolve' | 'keepProcessEnv'> & {
+    resolve?: AllResolveOptions;
+};
+interface UserConfig extends DefaultEnvironmentOptions {
     /**
      * Project root directory. Can be an absolute path, or a path relative from
      * the location of the config file itself.
@@ -3253,21 +3784,10 @@ interface UserConfig {
      * each command, and can be overridden by the command line --mode option.
      */
     mode?: string;
-    /**
-     * Define global variable replacements.
-     * Entries will be defined on `window` during dev and replaced during build.
-     */
-    define?: Record<string, any>;
     /**
      * Array of vite plugins to use.
      */
     plugins?: PluginOption[];
-    /**
-     * Configure resolver
-     */
-    resolve?: ResolveOptions & {
-        alias?: AliasOptions;
-    };
     /**
      * HTML related options
      */
@@ -3290,25 +3810,18 @@ interface UserConfig {
      */
     assetsInclude?: string | RegExp | (string | RegExp)[];
     /**
-     * Server specific options, e.g. host, port, https...
+     * Builder specific options
+     * @experimental
      */
-    server?: ServerOptions;
+    builder?: BuilderOptions;
     /**
-     * Build specific options
+     * Server specific options, e.g. host, port, https...
      */
-    build?: BuildOptions;
+    server?: ServerOptions;
     /**
      * Preview specific options, e.g. host, port, https...
      */
     preview?: PreviewOptions;
-    /**
-     * Dep optimization options
-     */
-    optimizeDeps?: DepOptimizationOptions;
-    /**
-     * SSR specific options
-     */
-    ssr?: SSROptions;
     /**
      * Experimental features
      *
@@ -3317,6 +3830,10 @@ interface UserConfig {
      * @experimental
      */
     experimental?: ExperimentalOptions;
+    /**
+     * Options to opt-in to future behavior
+     */
+    future?: FutureOptions;
     /**
      * Legacy options
      *
@@ -3342,7 +3859,7 @@ interface UserConfig {
      * root.
      * @default root
      */
-    envDir?: string;
+    envDir?: string | false;
     /**
      * Env variables starts with `envPrefix` will be exposed to your client source code via import.meta.env.
      * @default 'VITE_'
@@ -3368,6 +3885,20 @@ interface UserConfig {
          */
         rollupOptions?: Omit<RollupOptions, 'plugins' | 'input' | 'onwarn' | 'preserveEntrySignatures'>;
     };
+    /**
+     * Dep optimization options
+     */
+    optimizeDeps?: DepOptimizationOptions;
+    /**
+     * SSR specific options
+     * We could make SSROptions be a EnvironmentOptions if we can abstract
+     * external/noExternal for environments in general.
+     */
+    ssr?: SSROptions;
+    /**
+     * Environment overrides
+     */
+    environments?: Record<string, EnvironmentOptions>;
     /**
      * Whether your application is a Single Page Application (SPA),
      * a Multi-Page Application (MPA), or Custom Application (SSR
@@ -3384,6 +3915,14 @@ interface HTMLOptions {
      */
     cspNonce?: string;
 }
+interface FutureOptions {
+    removePluginHookHandleHotUpdate?: 'warn';
+    removePluginHookSsrArgument?: 'warn';
+    removeServerModuleGraph?: 'warn';
+    removeServerHot?: 'warn';
+    removeServerTransformRequest?: 'warn';
+    removeSsrLoadModule?: 'warn';
+}
 interface ExperimentalOptions {
     /**
      * Append fake `&lang.(ext)` when queries are specified, to preserve the file extension for following plugins to process.
@@ -3427,10 +3966,10 @@ interface LegacyOptions {
      */
     proxySsrExternalModules?: boolean;
     /**
-     * In Vite 6.0.8 / 5.4.11 and below, WebSocket server was able to connect from any web pages. However,
+     * In Vite 6.0.8 and below, WebSocket server was able to connect from any web pages. However,
      * that could be exploited by a malicious web page.
      *
-     * In Vite 6.0.9+ / 5.4.12+, the WebSocket server now requires a token to connect from a web page.
+     * In Vite 6.0.9+, the WebSocket server now requires a token to connect from a web page.
      * But this may break some plugins and frameworks that connects to the WebSocket server
      * on their own. Enabling this option will make Vite skip the token check.
      *
@@ -3441,14 +3980,18 @@ interface LegacyOptions {
 }
 interface ResolvedWorkerOptions {
     format: 'es' | 'iife';
-    plugins: (bundleChain: string[]) => Promise<Plugin[]>;
+    plugins: (bundleChain: string[]) => Promise<ResolvedConfig>;
     rollupOptions: RollupOptions;
 }
 interface InlineConfig extends UserConfig {
     configFile?: string | false;
+    /** @experimental */
+    configLoader?: 'bundle' | 'runner' | 'native';
+    /** @deprecated */
     envFile?: false;
+    forceOptimizeDeps?: boolean;
 }
-type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'css' | 'assetsInclude' | 'optimizeDeps' | 'worker' | 'build'> & {
+interface ResolvedConfig extends Readonly<Omit<UserConfig, 'plugins' | 'css' | 'json' | 'assetsInclude' | 'optimizeDeps' | 'worker' | 'build' | 'dev' | 'environments' | 'server' | 'preview'> & {
     configFile: string | undefined;
     configFileDependencies: string[];
     inlineConfig: InlineConfig;
@@ -3460,15 +4003,19 @@ type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'css' | 'assetsInclu
     mode: string;
     isWorker: boolean;
     isProduction: boolean;
-    envDir: string;
+    envDir: string | false;
     env: Record<string, any>;
     resolve: Required<ResolveOptions> & {
         alias: Alias[];
     };
     plugins: readonly Plugin[];
     css: ResolvedCSSOptions;
+    json: Required<JsonOptions>;
     esbuild: ESBuildOptions | false;
     server: ResolvedServerOptions;
+    dev: ResolvedDevEnvironmentOptions;
+    /** @experimental */
+    builder: ResolvedBuilderOptions | undefined;
     build: ResolvedBuildOptions;
     preview: ResolvedPreviewOptions;
     ssr: ResolvedSSROptions;
@@ -3479,6 +4026,7 @@ type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'css' | 'assetsInclu
     worker: ResolvedWorkerOptions;
     appType: AppType;
     experimental: ExperimentalOptions;
+    environments: Record<string, ResolvedEnvironmentOptions>;
     /**
      * The token to connect to the WebSocket server from browsers.
      *
@@ -3490,33 +4038,119 @@ type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'css' | 'assetsInclu
      * @deprecated
      */
     webSocketToken: string;
-} & PluginHookUtils>;
+} & PluginHookUtils> {
+}
 interface PluginHookUtils {
     getSortedPlugins: <K extends keyof Plugin>(hookName: K) => PluginWithRequiredHook<K>[];
     getSortedPluginHooks: <K extends keyof Plugin>(hookName: K) => NonNullable<HookHandler<Plugin[K]>>[];
 }
 type ResolveFn = (id: string, importer?: string, aliasOnly?: boolean, ssr?: boolean) => Promise<string | undefined>;
-declare function resolveConfig(inlineConfig: InlineConfig, command: 'build' | 'serve', defaultMode?: string, defaultNodeEnv?: string, isPreview?: boolean): Promise<ResolvedConfig>;
+declare function resolveConfig(inlineConfig: InlineConfig, command: 'build' | 'serve', defaultMode?: string, defaultNodeEnv?: string, isPreview?: boolean, 
+ 
+): Promise<ResolvedConfig>;
 declare function sortUserPlugins(plugins: (Plugin | Plugin[])[] | undefined): [Plugin[], Plugin[], Plugin[]];
-declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, configRoot?: string, logLevel?: LogLevel, customLogger?: Logger): Promise<{
+declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, configRoot?: string, logLevel?: LogLevel, customLogger?: Logger, configLoader?: 'bundle' | 'runner' | 'native'): Promise<{
     path: string;
     config: UserConfig;
     dependencies: string[];
 } | null>;
 
+type ResolveIdFn = (environment: PartialEnvironment, id: string, importer?: string, aliasOnly?: boolean) => Promise<string | undefined>;
+/**
+ * Create an internal resolver to be used in special scenarios, e.g.
+ * optimizer and handling css @imports
+ */
+declare function createIdResolver(config: ResolvedConfig, options?: Partial<InternalResolveOptions>): ResolveIdFn;
+
 declare function buildErrorMessage(err: RollupError, args?: string[], includeStack?: boolean): string;
 
+/**
+ * @experimental
+ */
+interface ServerModuleRunnerOptions extends Omit<ModuleRunnerOptions, 'root' | 'fetchModule' | 'hmr' | 'transport'> {
+    /**
+     * Disable HMR or configure HMR logger.
+     */
+    hmr?: false | {
+        logger?: ModuleRunnerHmr['logger'];
+    };
+    /**
+     * Provide a custom module evaluator. This controls how the code is executed.
+     */
+    evaluator?: ModuleEvaluator;
+}
+declare const createServerModuleRunnerTransport: (options: {
+    channel: NormalizedServerHotChannel;
+}) => ModuleRunnerTransport;
+/**
+ * Create an instance of the Vite SSR runtime that support HMR.
+ * @experimental
+ */
+declare function createServerModuleRunner(environment: DevEnvironment, options?: ServerModuleRunnerOptions): ModuleRunner;
+
+declare function createRunnableDevEnvironment(name: string, config: ResolvedConfig, context?: RunnableDevEnvironmentContext): RunnableDevEnvironment;
+interface RunnableDevEnvironmentContext extends Omit<DevEnvironmentContext, 'hot'> {
+    runner?: (environment: RunnableDevEnvironment, options?: ServerModuleRunnerOptions) => ModuleRunner;
+    runnerOptions?: ServerModuleRunnerOptions;
+    hot?: boolean;
+}
+declare function isRunnableDevEnvironment(environment: Environment): environment is RunnableDevEnvironment;
+declare class RunnableDevEnvironment extends DevEnvironment {
+    private _runner;
+    private _runnerFactory;
+    private _runnerOptions;
+    constructor(name: string, config: ResolvedConfig, context: RunnableDevEnvironmentContext);
+    get runner(): ModuleRunner;
+    close(): Promise<void>;
+}
+
+interface FetchableDevEnvironmentContext extends DevEnvironmentContext {
+    handleRequest(request: Request): Promise<Response> | Response;
+}
+declare function createFetchableDevEnvironment(name: string, config: ResolvedConfig, context: FetchableDevEnvironmentContext): FetchableDevEnvironment;
+declare function isFetchableDevEnvironment(environment: Environment): environment is FetchableDevEnvironment;
+declare class FetchableDevEnvironment extends DevEnvironment {
+    private _handleRequest;
+    constructor(name: string, config: ResolvedConfig, context: FetchableDevEnvironmentContext);
+    dispatchFetch(request: Request): Promise<Response>;
+}
+
+interface RunnerImportResult<T> {
+    module: T;
+    dependencies: string[];
+}
+/**
+ * Import any file using the default Vite environment.
+ * @experimental
+ */
+declare function runnerImport<T>(moduleId: string, inlineConfig?: InlineConfig): Promise<RunnerImportResult<T>>;
+
 interface FetchModuleOptions {
+    cached?: boolean;
     inlineSourceMap?: boolean;
-    processSourceMap?<T extends NonNullable<TransformResult['map']>>(map: T): T;
+    startOffset?: number;
 }
 /**
- * Fetch module information for Vite runtime.
+ * Fetch module information for Vite runner.
  * @experimental
  */
-declare function fetchModule(server: ViteDevServer, url: string, importer?: string, options?: FetchModuleOptions): Promise<FetchResult>;
+declare function fetchModule(environment: DevEnvironment, url: string, importer?: string, options?: FetchModuleOptions): Promise<FetchResult>;
+
+interface ModuleRunnerTransformOptions {
+    json?: {
+        stringify?: boolean;
+    };
+}
+declare function ssrTransform(code: string, inMap: SourceMap | {
+    mappings: '';
+} | null, url: string, originalCode: string, options?: ModuleRunnerTransformOptions): Promise<TransformResult | null>;
 
 declare const VERSION: string;
+declare const DEFAULT_CLIENT_MAIN_FIELDS: readonly string[];
+declare const DEFAULT_SERVER_MAIN_FIELDS: readonly string[];
+declare const DEFAULT_CLIENT_CONDITIONS: readonly string[];
+declare const DEFAULT_SERVER_CONDITIONS: readonly string[];
+declare const defaultAllowedOrigins: RegExp;
 
 declare const isCSSRequest: (request: string) => boolean;
 /**
@@ -3569,10 +4203,11 @@ declare function searchForWorkspaceRoot(current: string, root?: string): string;
  * Check if the url is allowed to be served, via the `server.fs` config.
  * @deprecated Use the `isFileLoadingAllowed` function instead.
  */
+declare function isFileServingAllowed(config: ResolvedConfig, url: string): boolean;
 declare function isFileServingAllowed(url: string, server: ViteDevServer): boolean;
-declare function isFileLoadingAllowed(server: ViteDevServer, filePath: string): boolean;
+declare function isFileLoadingAllowed(config: ResolvedConfig, filePath: string): boolean;
 
-declare function loadEnv(mode: string, envDir: string, prefixes?: string | string[]): Record<string, string>;
+declare function loadEnv(mode: string, envDir: string | false, prefixes?: string | string[]): Record<string, string>;
 declare function resolveEnvPrefix({ envPrefix, }: UserConfig): string[];
 
 type Manifest = Record<string, ManifestChunk>;
@@ -3588,40 +4223,5 @@ interface ManifestChunk {
     dynamicImports?: string[];
 }
 
-/**
- * @experimental
- */
-interface MainThreadRuntimeOptions extends Omit<ViteRuntimeOptions, 'root' | 'fetchModule' | 'hmr'> {
-    /**
-     * Disable HMR or configure HMR logger.
-     */
-    hmr?: false | {
-        logger?: false | HMRLogger;
-    };
-    /**
-     * Provide a custom module runner. This controls how the code is executed.
-     */
-    runner?: ViteModuleRunner;
-}
-/**
- * Create an instance of the Vite SSR runtime that support HMR.
- * @experimental
- */
-declare function createViteRuntime(server: ViteDevServer, options?: MainThreadRuntimeOptions): Promise<ViteRuntime>;
-
-/**
- * The connector class to establish HMR communication between the server and the Vite runtime.
- * @experimental
- */
-declare class ServerHMRConnector implements HMRRuntimeConnection {
-    private handlers;
-    private hmrChannel;
-    private hmrClient;
-    private connected;
-    constructor(server: ViteDevServer);
-    isReady(): boolean;
-    send(message: string): void;
-    onUpdate(handler: (payload: HMRPayload) => void): void;
-}
-
-export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type AwaitWriteFinishOptions, type BindCLIShortcutsOptions, type BuildOptions, type CLIShortcut, type CSSModulesOptions, type CSSOptions, type CommonServerOptions, type ConfigEnv, Connect, type CorsOptions, type CorsOrigin, type DepOptimizationConfig, type DepOptimizationMetadata, type DepOptimizationOptions, type ESBuildOptions, type ESBuildTransformResult, type ExperimentalOptions, type ExportsData, FSWatcher, type FetchModuleOptions, type FileSystemServeOptions, type FilterPattern, type HMRBroadcaster, type HMRBroadcasterClient, type HMRChannel, type HTMLOptions, type HmrContext, type HmrOptions, type HookHandler, type HtmlTagDescriptor, HttpProxy, type HttpServer, type IndexHtmlTransform, type IndexHtmlTransformContext, type IndexHtmlTransformHook, type IndexHtmlTransformResult, type InlineConfig, type InternalResolveOptions, type JsonOptions, type LegacyOptions, type LibraryFormats, type LibraryOptions, type LightningCSSOptions, type LogErrorOptions, type LogLevel, type LogOptions, type LogType, type Logger, type LoggerOptions, type MainThreadRuntimeOptions, type Manifest, type ManifestChunk, type MapToFunction, type AnymatchMatcher as Matcher, ModuleGraph, ModuleNode, type ModulePreloadOptions, type OptimizedDepInfo, type Plugin, PluginContainer, type PluginHookUtils, type PluginOption, type PreprocessCSSResult, type PreviewOptions, type PreviewServer, type PreviewServerHook, type ProxyOptions, type RenderBuiltAssetUrl, type ResolveFn, type ResolveModulePreloadDependenciesFn, type ResolveOptions, type ResolvedBuildOptions, type ResolvedCSSOptions, type ResolvedConfig, type ResolvedModulePreloadOptions, type ResolvedPreviewOptions, type ResolvedSSROptions, type ResolvedServerOptions, type ResolvedServerUrls, type ResolvedUrl, type ResolvedWorkerOptions, type ResolverFunction, type ResolverObject, type RollupCommonJSOptions, type RollupDynamicImportVarsOptions, type SSROptions, type SSRTarget, type SendOptions, type ServerHMRChannel, ServerHMRConnector, type ServerHook, type ServerOptions, SplitVendorChunkCache, type SsrDepOptimizationOptions, Terser, type TerserOptions, type TransformOptions, type TransformResult, type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, type ViteDevServer, type WatchOptions, WebSocket, WebSocketAlias, type WebSocketClient, type WebSocketCustomListener, WebSocketServer, build, buildErrorMessage, createFilter, createLogger, createServer, createViteRuntime, defineConfig, fetchModule, formatPostcssSourceMap, isCSSRequest, isFileLoadingAllowed, isFileServingAllowed, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, normalizePath, optimizeDeps, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rollupVersion, searchForWorkspaceRoot, send, sortUserPlugins, splitVendorChunk, splitVendorChunkPlugin, transformWithEsbuild, VERSION as version };
+export { BuildEnvironment, Connect, DevEnvironment, EnvironmentModuleGraph, EnvironmentModuleNode, FSWatcher, FetchableDevEnvironment, HttpProxy, ModuleGraph, ModuleNode, PluginContainer, RunnableDevEnvironment, SplitVendorChunkCache, Terser, WebSocket, WebSocketAlias, WebSocketServer, build, buildErrorMessage, createBuilder, createFetchableDevEnvironment, createFilter, createIdResolver, createLogger, createRunnableDevEnvironment, createServer, createServerHotChannel, createServerModuleRunner, createServerModuleRunnerTransport, defaultAllowedOrigins, DEFAULT_CLIENT_CONDITIONS as defaultClientConditions, DEFAULT_CLIENT_MAIN_FIELDS as defaultClientMainFields, DEFAULT_SERVER_CONDITIONS as defaultServerConditions, DEFAULT_SERVER_MAIN_FIELDS as defaultServerMainFields, defineConfig, fetchModule, formatPostcssSourceMap, isCSSRequest, isFetchableDevEnvironment, isFileLoadingAllowed, isFileServingAllowed, isRunnableDevEnvironment, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, ssrTransform as moduleRunnerTransform, normalizePath, optimizeDeps, perEnvironmentPlugin, perEnvironmentState, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rollupVersion, runnerImport, searchForWorkspaceRoot, send, sortUserPlugins, splitVendorChunk, splitVendorChunkPlugin, transformWithEsbuild, VERSION as version };
+export type { Alias, AliasOptions, AnymatchFn, AnymatchPattern, AppType, BindCLIShortcutsOptions, BuildEnvironmentOptions, BuildOptions, BuilderOptions, CLIShortcut, CSSModulesOptions, CSSOptions, CommonServerOptions, ConfigEnv, CorsOptions, CorsOrigin, DepOptimizationConfig, DepOptimizationMetadata, DepOptimizationOptions, DevEnvironmentContext, DevEnvironmentOptions, ESBuildOptions, ESBuildTransformResult, Environment, EnvironmentOptions, ExperimentalOptions, ExportsData, FetchModuleOptions, FetchableDevEnvironmentContext, FileSystemServeOptions, FilterPattern, HMRBroadcaster, HMRBroadcasterClient, HMRChannel, HTMLOptions, HmrContext, HmrOptions, HookHandler, HotChannel, HotChannelClient, HotChannelListener, HotUpdateOptions, HtmlTagDescriptor, HttpServer, IndexHtmlTransform, IndexHtmlTransformContext, IndexHtmlTransformHook, IndexHtmlTransformResult, InlineConfig, InternalResolveOptions, JsonOptions, LegacyOptions, LessPreprocessorOptions, LibraryFormats, LibraryOptions, LogErrorOptions, LogLevel, LogOptions, LogType, Logger, LoggerOptions, Manifest, ManifestChunk, MapToFunction, AnymatchMatcher as Matcher, ModulePreloadOptions, ModuleRunnerTransformOptions, NormalizedHotChannel, NormalizedHotChannelClient, NormalizedServerHotChannel, OptimizedDepInfo, Plugin, PluginHookUtils, PluginOption, PreprocessCSSResult, PreviewOptions, PreviewServer, PreviewServerHook, ProxyOptions, RenderBuiltAssetUrl, ResolveFn, ResolveModulePreloadDependenciesFn, ResolveOptions, ResolvedBuildEnvironmentOptions, ResolvedBuildOptions, ResolvedCSSOptions, ResolvedConfig, ResolvedDevEnvironmentOptions, ResolvedModulePreloadOptions, ResolvedPreviewOptions, ResolvedSSROptions, ResolvedServerOptions, ResolvedServerUrls, ResolvedUrl, ResolvedWorkerOptions, ResolverFunction, ResolverObject, RollupCommonJSOptions, RollupDynamicImportVarsOptions, RunnableDevEnvironmentContext, SSROptions, SSRTarget, SassPreprocessorOptions, SendOptions, ServerHMRChannel, ServerHook, ServerHotChannel, ServerModuleRunnerOptions, ServerOptions, SkipInformation, SsrDepOptimizationConfig, StylusPreprocessorOptions, TerserOptions, TransformOptions, TransformResult, UserConfig, UserConfigExport, UserConfigFn, UserConfigFnObject, UserConfigFnPromise, ViteBuilder, ViteDevServer, WatchOptions, WebSocketClient, WebSocketCustomListener };