vite 5.2.8 → 6.0.0-alpha.0

package/dist/node/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { PluginHooks, RollupError, SourceMap, ModuleInfo, PartialResolvedId, InputOptions, CustomPluginOptions, SourceDescription, LoadResult, RollupOptions, WatcherOptions, InputOption, ModuleFormat, RollupOutput, RollupWatcher, SourceMapInput, ExistingRawSourceMap, OutputBundle, OutputChunk, ObjectHook, PluginContext, ResolveIdResult, TransformPluginContext, GetManualChunk } from 'rollup';
+import { PluginHooks, RollupError, InputOptions, CustomPluginOptions, PartialResolvedId, SourceDescription, SourceMap, LoadResult, ModuleInfo, RollupOptions, WatcherOptions, InputOption, ModuleFormat, RollupOutput, RollupWatcher, SourceMapInput, ExistingRawSourceMap, OutputBundle, OutputChunk, ObjectHook, ResolveIdResult, GetManualChunk } from 'rollup';
 import * as rollup from 'rollup';
 export { rollup as Rollup };
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
@@ -15,21 +15,19 @@ 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 { 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';
+import { FetchResult, ModuleRunnerOptions, ModuleRunnerHMRConnection, 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 * as PostCSS from 'postcss';
-import { ViteRuntimeOptions, ViteModuleRunner, ViteRuntime, HMRRuntimeConnection } from 'vite/runtime';
 export { GeneralImportGlobOptions, ImportGlobFunction, ImportGlobOptions, KnownAsTypeMap } from '../../types/importGlob.js';
 export { ChunkMetadata } from '../../types/metadata.js';
-import '../../types/hot.js';
 
 interface Alias {
   find: string | RegExp
@@ -784,90 +782,6 @@ type CLIShortcut<Server = ViteDevServer | PreviewServer> = {
     action?(server: Server): void | Promise<void>;
 };
 
-interface TransformResult {
-    code: string;
-    map: SourceMap | {
-        mappings: '';
-    } | null;
-    etag?: string;
-    deps?: string[];
-    dynamicDeps?: string[];
-}
-interface TransformOptions {
-    ssr?: boolean;
-    html?: boolean;
-}
-
-declare class ModuleNode {
-    /**
-     * Public served url path, starts with /
-     */
-    url: string;
-    /**
-     * Resolved file system path + query
-     */
-    id: string | null;
-    file: string | null;
-    type: 'js' | 'css';
-    info?: ModuleInfo;
-    meta?: Record<string, any>;
-    importers: Set<ModuleNode>;
-    clientImportedModules: Set<ModuleNode>;
-    ssrImportedModules: Set<ModuleNode>;
-    acceptedHmrDeps: Set<ModuleNode>;
-    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;
-    lastInvalidationTimestamp: number;
-    /**
-     * @param setIsSelfAccepting - set `false` to set `isSelfAccepting` later. e.g. #7870
-     */
-    constructor(url: string, setIsSelfAccepting?: boolean);
-    get importedModules(): Set<ModuleNode>;
-}
-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;
-    onFileChange(file: string): void;
-    onFileDelete(file: string): void;
-    invalidateModule(mod: ModuleNode, seen?: Set<ModuleNode>, timestamp?: number, isHmr?: boolean, 
-    ): void;
-    invalidateAll(): void;
-    /**
-     * Update the module graph based on a module's updated imports information
-     * If there are dependencies that no longer have any importers, they are
-     * returned as a Set.
-     *
-     * @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>;
-    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;
-    getModuleByEtag(etag: string): ModuleNode | undefined;
-}
-
 /**
  * This file is refactored into TypeScript based on
  * https://github.com/preactjs/wmr/blob/main/packages/wmr/src/lib/rollup-plugin-container.js
@@ -875,18 +789,19 @@ declare class ModuleGraph {
 
 interface PluginContainer {
     options: InputOptions;
-    getModuleInfo(id: string): ModuleInfo | null;
     buildStart(options: InputOptions): Promise<void>;
-    resolveId(id: string, importer?: string, options?: {
+    resolveId(id: string, importer: string | undefined, options?: {
         attributes?: Record<string, string>;
         custom?: CustomPluginOptions;
         skip?: Set<Plugin>;
         ssr?: boolean;
+        environment?: PluginEnvironment;
         isEntry?: boolean;
     }): Promise<PartialResolvedId | null>;
     transform(code: string, id: string, options?: {
         inMap?: SourceDescription['map'];
         ssr?: boolean;
+        environment?: PluginEnvironment;
     }): Promise<{
         code: string;
         map: SourceMap | {
@@ -895,6 +810,7 @@ interface PluginContainer {
     }>;
     load(id: string, options?: {
         ssr?: boolean;
+        environment?: PluginEnvironment;
     }): Promise<LoadResult | null>;
     watchChange(id: string, change: {
         event: 'create' | 'update' | 'delete';
@@ -1429,12 +1345,408 @@ declare namespace WebSocket {
   const WebSocket: typeof WebSocketAlias
   interface WebSocket extends WebSocketAlias {} // tslint:disable-line no-empty-interface
 
-  // WebSocket stream
-  function createWebSocketStream(
-    websocket: WebSocket,
-    options?: DuplexOptions,
-  ): Duplex
+  // WebSocket stream
+  function createWebSocketStream(
+    websocket: WebSocket,
+    options?: DuplexOptions,
+  ): Duplex
+}
+
+declare class Environment {
+    name: string;
+    config: ResolvedConfig;
+    options: ResolvedEnvironmentOptions;
+    get logger(): Logger;
+    constructor(name: string, config: ResolvedConfig, options?: ResolvedEnvironmentOptions);
+}
+
+interface FetchModuleOptions {
+    inlineSourceMap?: boolean;
+    processSourceMap?<T extends NonNullable<TransformResult['map']>>(map: T): T;
+}
+/**
+ * Fetch module information for Vite runner.
+ * @experimental
+ */
+declare function fetchModule(environment: DevEnvironment, url: string, importer?: string, options?: FetchModuleOptions): Promise<FetchResult>;
+
+type ExportsData = {
+    hasImports: 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 explicitely
+     * 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 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
+     */
+    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`.
+ */
+declare function optimizeDeps(environment: Environment, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
+
+declare class RemoteEnvironmentTransport {
+    private readonly options;
+    constructor(options: {
+        send: (data: any) => void;
+        onMessage: (handler: (data: any) => void) => void;
+    });
+    register(environment: DevEnvironment): void;
+}
+
+interface DevEnvironmentSetup {
+    hot?: false | HMRChannel;
+    options?: EnvironmentOptions;
+    runner?: FetchModuleOptions & {
+        transport?: RemoteEnvironmentTransport;
+    };
+}
+declare class DevEnvironment extends Environment {
+    mode: "dev";
+    moduleGraph: EnvironmentModuleGraph;
+    server: ViteDevServer;
+    depsOptimizer?: DepsOptimizer;
+    /**
+     * HMR 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' })
+     */
+    hot: HMRChannel;
+    constructor(server: ViteDevServer, name: string, setup?: {
+        hot?: false | HMRChannel;
+        options?: EnvironmentOptions;
+        runner?: FetchModuleOptions & {
+            transport?: RemoteEnvironmentTransport;
+        };
+        depsOptimizer?: DepsOptimizer;
+    });
+    fetchModule(id: string, importer?: string): Promise<FetchResult>;
+    transformRequest(url: string): Promise<TransformResult | null>;
+    warmupRequest(url: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+interface TransformResult {
+    code: string;
+    map: SourceMap | {
+        mappings: '';
+    } | null;
+    etag?: string;
+    deps?: string[];
+    dynamicDeps?: string[];
+}
+interface TransformOptions {
+    /**
+     * @deprecated infered from environment
+     */
+    ssr?: boolean;
+    /**
+     * TODO: should this be internal?
+     */
+    html?: boolean;
+}
+
+declare class EnvironmentModuleNode {
+    environment: string;
+    /**
+     * Public served url path, starts with /
+     */
+    url: string;
+    /**
+     * Resolved file system path + query
+     */
+    id: string | null;
+    file: string | null;
+    type: 'js' | 'css';
+    info?: ModuleInfo;
+    meta?: Record<string, any>;
+    importers: Set<EnvironmentModuleNode>;
+    importedModules: Set<EnvironmentModuleNode>;
+    acceptedHmrDeps: Set<EnvironmentModuleNode>;
+    acceptedHmrExports: Set<string> | null;
+    importedBindings: Map<string, Set<string>> | null;
+    isSelfAccepting?: boolean;
+    transformResult: TransformResult | null;
+    ssrModule: Record<string, any> | null;
+    ssrError: Error | null;
+    lastHMRTimestamp: number;
+    lastInvalidationTimestamp: number;
+    /**
+     * @param setIsSelfAccepting - set `false` to set `isSelfAccepting` later. e.g. #7870
+     */
+    constructor(url: string, environment: string, setIsSelfAccepting?: boolean);
+}
+type ResolvedUrl = [
+    url: string,
+    resolvedId: string,
+    meta: object | null | 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: EnvironmentModuleNode, seen?: Set<EnvironmentModuleNode>, timestamp?: number, isHmr?: boolean, 
+    ): void;
+    invalidateAll(): void;
+    /**
+     * Update the module graph based on a module's updated imports information
+     * If there are dependencies that no longer have any importers, they are
+     * returned as a Set.
+     *
+     * @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: 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;
+}
+
+/**
+ * Backward compatible ModuleNode and ModuleGraph with mixed nodes from both the client and ssr enviornments
+ * It would be good to take the types names for the new EnvironmentModuleNode and EnvironmentModuleGraph but we can't
+ * do that at this point without breaking to much code in the ecosystem.
+ * We are going to deprecate these types and we can try to use them back in the future.
+ */
+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];
+    _wrapModuleSet(prop: ModuleSetNames, module: EnvironmentModuleNode | undefined): Set<ModuleNode>;
+    _getModuleSetUnion(prop: 'importedModules' | 'importers'): Set<ModuleNode>;
+    get url(): string;
+    get id(): string | null;
+    get file(): 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>>;
+    constructor(moduleGraphs: {
+        client: () => EnvironmentModuleGraph;
+        ssr: () => EnvironmentModuleGraph;
+    });
+    /** @deprecated */
+    getModuleById(id: string): ModuleNode | undefined;
+    /** @deprecated */
+    getModuleByUrl(url: string, ssr?: boolean): Promise<ModuleNode | undefined>;
+    /** @deprecated */
+    getModulesByFile(file: string): Set<ModuleNode> | undefined;
+    /** @deprecated */
+    onFileChange(file: string): void;
+    /** @deprecated */
+    onFileDelete(file: string): void;
+    /** @deprecated */
+    invalidateModule(mod: ModuleNode, seen?: Set<ModuleNode>, timestamp?: number, isHmr?: boolean, 
+    ): void;
+    /** @deprecated */
+    invalidateAll(): void;
+    /** @deprecated */
+    ensureEntryFromUrl(rawUrl: string, ssr?: boolean, setIsSelfAccepting?: boolean): Promise<ModuleNode>;
+    /** @deprecated */
+    createFileOnlyEntry(file: string): ModuleNode;
+    /** @deprecated */
+    resolveUrl(url: string, ssr?: boolean): Promise<ResolvedUrl>;
+    /** @deprecated */
+    updateModuleTransformResult(mod: ModuleNode, result: TransformResult | null, ssr?: boolean): void;
+    /** @deprecated */
+    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';
 
 interface HmrOptions {
     protocol?: string;
@@ -1446,6 +1758,19 @@ interface HmrOptions {
     overlay?: boolean;
     server?: Server;
 }
+interface HotUpdateContext {
+    type: 'create' | 'update' | 'delete';
+    file: string;
+    timestamp: number;
+    modules: Array<EnvironmentModuleNode>;
+    read: () => string | Promise<string>;
+    server: ViteDevServer;
+    environment: DevEnvironment;
+}
+/**
+ * @deprecated
+ * Used by handleHotUpdate for backward compatibility with mixed client and ssr moduleGraph
+ **/
 interface HmrContext {
     file: string;
     timestamp: number;
@@ -1563,6 +1888,7 @@ interface ServerOptions extends CommonServerOptions {
     /**
      * Warm-up files to transform and cache the results in advance. This improves the
      * initial page load during server starts and prevents transform waterfalls.
+     * @deprecated use dev.warmup / environment.ssr.dev.warmup
      */
     warmup?: {
         /**
@@ -1604,6 +1930,7 @@ interface ServerOptions extends CommonServerOptions {
     /**
      * Pre-transform known direct imports
      * @default true
+     * @deprecated use dev.preTransformRequests
      */
     preTransformRequests?: boolean;
     /**
@@ -1613,8 +1940,14 @@ interface ServerOptions extends CommonServerOptions {
      * 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.
+     * @deprecated use dev.sourcemapIgnoreList
      */
     sourcemapIgnoreList?: false | ((sourcePath: string, sourcemapPath: string) => boolean);
+    /**
+     * Run HMR tasks, by default the HMR propagation is done in parallel for all environments
+     * @experimental
+     */
+    hotUpdateEnvironments?: (server: ViteDevServer, hmr: (environment: DevEnvironment) => Promise<void>) => Promise<void>;
 }
 interface ResolvedServerOptions extends Omit<ServerOptions, 'fs' | 'middlewareMode' | 'sourcemapIgnoreList'> {
     fs: Required<FileSystemServeOptions>;
@@ -1690,15 +2023,21 @@ interface ViteDevServer {
      *
      * Always sends a message to at least a WebSocket client. Any third party can
      * add a channel to the broadcaster to process messages
+     * @deprecated use `environments.get(id).hot` instead
      */
     hot: HMRBroadcaster;
     /**
      * Rollup plugin container that can run plugin hooks on a given file
      */
     pluginContainer: PluginContainer;
+    /**
+     * Module execution environments attached to the Vite server.
+     */
+    environments: Record<'client' | 'ssr' | (string & {}), DevEnvironment>;
     /**
      * Module graph that tracks the import relationships, url to file mapping
      * and hmr state.
+     * @deprecated use environment module graphs instead
      */
     moduleGraph: ModuleGraph;
     /**
@@ -1709,12 +2048,14 @@ interface ViteDevServer {
     /**
      * Programmatically resolve, load and transform a URL and get the result
      * without going through the http request pipeline.
+     * @deprecated use environment.transformRequest
      */
     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.
+     * @deprecated use environment.warmupRequest
      */
     warmupRequest(url: string, options?: TransformOptions): Promise<void>;
     /**
@@ -1733,11 +2074,6 @@ interface ViteDevServer {
     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
      */
@@ -1751,6 +2087,11 @@ interface ViteDevServer {
      * API to retrieve the module to be reloaded. If `hmr` is false, this is a no-op.
      */
     reloadModule(module: ModuleNode): Promise<void>;
+    /**
+     * Triggers HMR for an environment module in the module graph.
+     * If `hmr` is false, this is a no-op.
+     */
+    reloadEnvironmentModule(module: EnvironmentModuleNode): Promise<void>;
     /**
      * Start the server.
      */
@@ -2451,8 +2792,16 @@ interface BuildOptions {
     /**
      * Emit assets during SSR.
      * @default false
+     * @deprecated use emitAssets
      */
     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.
+     * TODO: Should this be true for all environments by default? Or should this be
+     * controlled by the builder so so we can avoid emitting duplicated assets.
+     */
+    emitAssets?: boolean;
     /**
      * Set to false to disable reporting compressed chunk sizes.
      * Can slightly improve build speed.
@@ -2470,6 +2819,10 @@ interface BuildOptions {
      * @default null
      */
     watch?: WatcherOptions | null;
+    /**
+     * create the Build Environment instance
+     */
+    createEnvironment?: (builder: ViteBuilder, name: string) => BuildEnvironment;
 }
 interface LibraryOptions {
     /**
@@ -2532,228 +2885,41 @@ 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;
-    /**
-     * 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): Promise<ESBuildTransformResult>;
-
-type ExportsData = {
-    hasImports: 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;
-}
-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 explicitely
-     * 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 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
-     */
-    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[];
+declare class BuildEnvironment extends Environment {
+    mode: "build";
+    builder: ViteBuilder;
+    constructor(builder: ViteBuilder, name: string, setup?: {
+        options?: EnvironmentOptions;
+    });
 }
-/**
- * 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;
-    /**
-     * 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'
-     */
-    target?: SSRTarget;
+interface ViteBuilder {
+    environments: Record<string, BuildEnvironment>;
+    config: ResolvedConfig;
+    buildEnvironments(): Promise<void>;
+    build(environment: BuildEnvironment): Promise<RollupOutput | RollupOutput[] | RollupWatcher>;
+}
+interface BuilderOptions {
+    buildEnvironments?: (builder: ViteBuilder, build: (environment: BuildEnvironment) => Promise<void>) => Promise<void>;
+}
+type ResolvedBuilderOptions = Required<BuilderOptions>;
+interface BuilderInlineConfig extends Omit<InlineConfig, 'plugins'> {
+    plugins?: () => PluginOption[];
+}
+declare function createViteBuilder(builderOptions?: BuilderOptions, defaultBuilderInlineConfig?: BuilderInlineConfig): Promise<ViteBuilder>;
+
+interface ESBuildOptions extends esbuild_TransformOptions {
+    include?: string | RegExp | string[] | RegExp[];
+    exclude?: string | RegExp | string[] | RegExp[];
+    jsxInject?: string;
     /**
-     * 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
+     * This option is not respected. Use `build.minify` instead.
      */
-    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;
+    minify?: never;
 }
+type ESBuildTransformResult = Omit<esbuild_TransformResult, 'map'> & {
+    map: SourceMap;
+};
+declare function transformWithEsbuild(code: string, filename: string, options?: esbuild_TransformOptions, inMap?: object): Promise<ESBuildTransformResult>;
 
 interface FsUtils {
     existsSync: (path: string) => boolean;
@@ -2773,6 +2939,7 @@ interface ResolveOptions {
      */
     mainFields?: string[];
     conditions?: string[];
+    externalConditions?: string[];
     /**
      * @default ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json']
      */
@@ -2782,12 +2949,18 @@ interface ResolveOptions {
      * @default false
      */
     preserveSymlinks?: boolean;
+    /**
+     * external/noExternal logic, this only works for certain environments
+     * Previously this was ssr.external/ssr.noExternal
+     * TODO: better abstraction that works for the client environment too?
+     */
+    noExternal?: string | RegExp | (string | RegExp)[] | true;
+    external?: string[] | true;
 }
-interface InternalResolveOptions extends Required<ResolveOptions> {
+interface ResolvePluginOptions {
     root: string;
     isBuild: boolean;
     isProduction: boolean;
-    ssrConfig?: SSROptions;
     packageCache?: PackageCache;
     fsUtils?: FsUtils;
     /**
@@ -2800,12 +2973,18 @@ interface InternalResolveOptions extends Required<ResolveOptions> {
     tryPrefix?: string;
     preferRelative?: boolean;
     isRequire?: boolean;
+    nodeCompatible?: boolean;
+    webCompatible?: boolean;
     isFromTsImporter?: boolean;
     tryEsmOnly?: boolean;
     scan?: boolean;
     ssrOptimizeCheck?: boolean;
-    getDepsOptimizer?: (ssr: boolean) => DepsOptimizer | undefined;
-    shouldExternalize?: (id: string, importer?: string) => boolean | undefined;
+    /**
+     * @deprecated environment.options are used instead
+     */
+    ssrConfig?: SSROptions;
+}
+interface InternalResolveOptions extends Required<ResolveOptions>, ResolvePluginOptions {
 }
 
 // This file is autogenerated by build-prefixes.js. DO NOT EDIT!
@@ -2898,6 +3077,7 @@ interface CSSOptions {
      * Enables css sourcemaps during dev
      * @default false
      * @experimental
+     * @deprecated use dev.sourcemap instead
      */
     devSourcemap?: boolean;
     /**
@@ -2931,7 +3111,7 @@ interface PreprocessCSSResult {
 /**
  * @experimental
  */
-declare function preprocessCSS(code: string, filename: string, config: ResolvedConfig): Promise<PreprocessCSSResult>;
+declare function preprocessCSS(code: string, filename: string, config: ResolvedConfig, environment?: Environment): Promise<PreprocessCSSResult>;
 declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;
 
 interface HtmlTagDescriptor {
@@ -3001,7 +3181,22 @@ 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 module environment can be accessed from the context for the
+ * buildStart, resolveId, transform, load, and buildEnd, hooks
+ *
+ * The current environment can be accessed from the context for the
+ * buildStart, resolveId, transform, load, and buildEnd, hooks. It can be a dev
+ * or a build environment. Plugins can use this.environment.mode === 'dev' to
+ * check if they have access to dev specific APIs.
  */
+type PluginEnvironment = DevEnvironment | BuildEnvironment;
+interface PluginContext extends rollup.PluginContext {
+    environment?: PluginEnvironment;
+}
+interface TransformPluginContext extends rollup.TransformPluginContext {
+    environment?: PluginEnvironment;
+}
 interface Plugin<A = any> extends rollup.Plugin<A> {
     /**
      * Enforce plugin invocation tier similar to webpack loaders. Hooks ordering
@@ -3030,6 +3225,17 @@ 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) => EnvironmentOptions | null | void | Promise<EnvironmentOptions | null | void>>;
     /**
      * Use this hook to read and store the final resolved vite config.
      */
@@ -3070,6 +3276,12 @@ interface Plugin<A = any> extends rollup.Plugin<A> {
      * `{ order: 'pre', handler: hook }`
      */
     transformIndexHtml?: IndexHtmlTransform;
+    /**
+     * @deprecated
+     * Compat support, ctx.modules is a backward compatible ModuleNode array
+     * with the mixed client and ssr moduleGraph. Use hotUpdate instead
+     */
+    handleHotUpdate?: ObjectHook<(this: void, ctx: HmrContext) => Array<ModuleNode> | void | Promise<Array<ModuleNode> | void>>;
     /**
      * Perform custom handling of HMR updates.
      * The handler receives a context containing changed filename, timestamp, a
@@ -3085,20 +3297,29 @@ interface Plugin<A = any> extends rollup.Plugin<A> {
      * - 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>>;
+    hotUpdate?: ObjectHook<(this: void, ctx: HotUpdateContext) => 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;
+        /**
+         * @deprecated use this.environment
+         */
         ssr?: boolean;
         isEntry: boolean;
     }) => Promise<ResolveIdResult> | ResolveIdResult>;
     load?: ObjectHook<(this: PluginContext, id: string, options?: {
+        /**
+         * @deprecated use this.environment
+         */
         ssr?: boolean;
     }) => Promise<LoadResult> | LoadResult>;
     transform?: ObjectHook<(this: TransformPluginContext, code: string, id: string, options?: {
+        /**
+         * @deprecated use this.environment
+         */
         ssr?: boolean;
     }) => Promise<rollup.TransformResult> | rollup.TransformResult>;
 }
@@ -3121,6 +3342,71 @@ interface JsonOptions {
     stringify?: boolean;
 }
 
+type SSRTarget = 'node' | 'webworker';
+type SsrDepOptimizationOptions = DepOptimizationConfig;
+/**
+ * @deprecated use environments.ssr
+ */
+interface SSROptions {
+    /**
+     * @deprecated use environment.resolve.noExternal
+     */
+    noExternal?: string | RegExp | (string | RegExp)[] | true;
+    /**
+     * @deprecated use environment.resolve.external
+     */
+    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
+     *
+     * if (ssr.target === 'webworker') {
+     *   build.rollupOptions.entryFileNames = '[name].js'
+     *   build.rollupOptions.inlineDynamicImports = (typeof input === 'string' || Object.keys(input).length === 1))
+     *   webCompatible = true
+     * }
+     *
+     * @default 'node'
+     * @deprecated use environment.webCompatible
+     */
+    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
+     * @deprecated
+     */
+    optimizeDeps?: SsrDepOptimizationOptions;
+    /**
+     * @deprecated
+     */
+    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
+         * @deprecated
+         */
+        conditions?: string[];
+        /**
+         * Conditions that are used during ssr import (including `ssrLoadModule`) of externalized dependencies.
+         *
+         * @default []
+         * @deprecated
+         */
+        externalConditions?: string[];
+    };
+}
+interface ResolvedSSROptions extends SSROptions {
+    target: SSRTarget;
+    optimizeDeps: SsrDepOptimizationOptions;
+}
+
 interface ConfigEnv {
     /**
      * 'serve': during dev (`vite` command)
@@ -3153,7 +3439,83 @@ declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
 declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
 declare function defineConfig(config: UserConfigExport): UserConfigExport;
 type PluginOption = Plugin | false | null | undefined | PluginOption[] | Promise<Plugin | false | null | undefined | PluginOption[]>;
-interface UserConfig {
+interface DevOptions {
+    /**
+     * The files to be pre-transformed. Supports glob patterns.
+     */
+    warmup?: {
+        files: string[];
+    };
+    /**
+     * Pre-transform known direct imports
+     * @default true
+     */
+    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);
+    /**
+     * Optimize deps config
+     */
+    optimizeDeps?: DepOptimizationConfig;
+    /**
+     * create the Dev Environment instance
+     */
+    createEnvironment?: (server: ViteDevServer, name: string) => DevEnvironment;
+}
+type ResolvedDevOptions = Required<Omit<DevOptions, 'createEnvironment'>> & {
+    createEnvironment: ((server: ViteDevServer, name: string) => DevEnvironment) | undefined;
+};
+type EnvironmentResolveOptions = ResolveOptions & {
+    alias?: AliasOptions;
+};
+interface SharedEnvironmentOptions {
+    /**
+     * Configure resolver
+     */
+    resolve?: EnvironmentResolveOptions;
+    /**
+     * Runtime Compatibility
+     * Temporal options, we should remove these in favor of fine-grained control
+     */
+    nodeCompatible?: boolean;
+    webCompatible?: boolean;
+}
+interface EnvironmentOptions extends SharedEnvironmentOptions {
+    /**
+     * Dev specific options
+     */
+    dev?: DevOptions;
+    /**
+     * Build specific options
+     */
+    build?: BuildOptions;
+}
+type ResolvedEnvironmentResolveOptions = Required<EnvironmentResolveOptions>;
+type ResolvedEnvironmentOptions = {
+    resolve: ResolvedEnvironmentResolveOptions;
+    nodeCompatible: boolean;
+    webCompatible: boolean;
+    dev: ResolvedDevOptions;
+    build: ResolvedBuildOptions;
+};
+type DefaultEnvironmentOptions = Omit<EnvironmentOptions, 'nodeCompatible' | 'webCompatible'>;
+interface UserConfig extends DefaultEnvironmentOptions {
     /**
      * Project root directory. Can be an absolute path, or a path relative from
      * the location of the config file itself.
@@ -3198,12 +3560,6 @@ interface UserConfig {
      * Array of vite plugins to use.
      */
     plugins?: PluginOption[];
-    /**
-     * Configure resolver
-     */
-    resolve?: ResolveOptions & {
-        alias?: AliasOptions;
-    };
     /**
      * HTML related options
      */
@@ -3226,25 +3582,17 @@ interface UserConfig {
      */
     assetsInclude?: string | RegExp | (string | RegExp)[];
     /**
-     * Server specific options, e.g. host, port, https...
+     * Builder specific options
      */
-    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
      *
@@ -3304,6 +3652,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
@@ -3372,7 +3734,7 @@ interface InlineConfig extends UserConfig {
     configFile?: string | false;
     envFile?: false;
 }
-type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'css' | 'assetsInclude' | 'optimizeDeps' | 'worker' | 'build'> & {
+type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'css' | 'assetsInclude' | 'optimizeDeps' | 'worker' | 'build' | 'dev' | 'environments'> & {
     configFile: string | undefined;
     configFileDependencies: string[];
     inlineConfig: InlineConfig;
@@ -3393,6 +3755,8 @@ type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'css' | 'assetsInclu
     css: ResolvedCSSOptions;
     esbuild: ESBuildOptions | false;
     server: ResolvedServerOptions;
+    dev: ResolvedDevOptions;
+    builder: ResolvedBuilderOptions;
     build: ResolvedBuildOptions;
     preview: ResolvedPreviewOptions;
     ssr: ResolvedSSROptions;
@@ -3403,6 +3767,7 @@ type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'css' | 'assetsInclu
     worker: ResolvedWorkerOptions;
     appType: AppType;
     experimental: ExperimentalOptions;
+    environments: Record<string, ResolvedEnvironmentOptions>;
 } & PluginHookUtils>;
 interface PluginHookUtils {
     getSortedPlugins: <K extends keyof Plugin>(hookName: K) => PluginWithRequiredHook<K>[];
@@ -3419,15 +3784,44 @@ declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, c
 
 declare function buildErrorMessage(err: RollupError, args?: string[], includeStack?: boolean): string;
 
-interface FetchModuleOptions {
-    inlineSourceMap?: boolean;
-    processSourceMap?<T extends NonNullable<TransformResult['map']>>(map: T): T;
+declare function createNodeDevEnvironment(server: ViteDevServer, name: string, options?: DevEnvironmentSetup): DevEnvironment;
+
+/**
+ * @experimental
+ */
+interface ServerModuleRunnerOptions extends Omit<ModuleRunnerOptions, 'root' | 'fetchModule' | 'hmr' | 'transport'> {
+    /**
+     * Disable HMR or configure HMR logger.
+     */
+    hmr?: false | {
+        connection?: ModuleRunnerHMRConnection;
+        logger?: ModuleRunnerHmr['logger'];
+    };
+    /**
+     * Provide a custom module runner. This controls how the code is executed.
+     */
+    runner?: ModuleEvaluator;
 }
 /**
- * Fetch module information for Vite runtime.
+ * Create an instance of the Vite SSR runtime that support HMR.
+ * @experimental
+ */
+declare function createServerModuleRunner(environment: DevEnvironment, options?: ServerModuleRunnerOptions): ModuleRunner;
+
+/**
+ * The connector class to establish HMR communication between the server and the Vite runtime.
  * @experimental
  */
-declare function fetchModule(server: ViteDevServer, url: string, importer?: string, options?: FetchModuleOptions): Promise<FetchResult>;
+declare class ServerHMRConnector implements ModuleRunnerHMRConnection {
+    private handlers;
+    private hmrChannel;
+    private hmrClient;
+    private connected;
+    constructor(server: ViteDevServer);
+    isReady(): boolean;
+    send(message: string): void;
+    onUpdate(handler: (payload: HMRPayload) => void): void;
+}
 
 declare const VERSION: string;
 
@@ -3499,40 +3893,4 @@ 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 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, type 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, isFileServingAllowed, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, normalizePath, optimizeDeps, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rollupVersion, searchForWorkspaceRoot, send, sortUserPlugins, splitVendorChunk, splitVendorChunkPlugin, transformWithEsbuild, VERSION as version };
+export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type AwaitWriteFinishOptions, type BindCLIShortcutsOptions, BuildEnvironment, type BuildOptions, type CLIShortcut, type CSSModulesOptions, type CSSOptions, type CommonServerOptions, type ConfigEnv, Connect, type CorsOptions, type CorsOrigin, type DepOptimizationConfig, type DepOptimizationMetadata, type DepOptimizationOptions, DevEnvironment, type DevEnvironmentSetup, type ESBuildOptions, type ESBuildTransformResult, EnvironmentModuleGraph, EnvironmentModuleNode, 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 HotUpdateContext, type HtmlTagDescriptor, HttpProxy, 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 Manifest, type ManifestChunk, type MapToFunction, type AnymatchMatcher as Matcher, ModuleGraph, ModuleNode, type ModulePreloadOptions, type OptimizedDepInfo, type Plugin, type PluginContainer, type PluginHookUtils, type PluginOption, type PreprocessCSSResult, type PreviewOptions, type PreviewServer, type PreviewServerHook, type ProxyOptions, RemoteEnvironmentTransport, 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 ServerModuleRunnerOptions, 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, createNodeDevEnvironment, createServer, createServerModuleRunner, createViteBuilder, defineConfig, fetchModule, formatPostcssSourceMap, isCSSRequest, isFileServingAllowed, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, normalizePath, optimizeDeps, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rollupVersion, searchForWorkspaceRoot, send, sortUserPlugins, splitVendorChunk, splitVendorChunkPlugin, transformWithEsbuild, VERSION as version };