vite 6.0.0-alpha.2 → 6.0.0-alpha.20

package/dist/node/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-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 { PluginHooks, RollupError, SourceMap, ModuleInfo, PartialResolvedId, RollupOptions, WatcherOptions, InputOption, ModuleFormat, RollupOutput, RollupWatcher, MinimalPluginContext, InputOptions, CustomPluginOptions, LoadResult, SourceDescription, 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,16 +15,16 @@ import * as url from 'node:url';
 import { URL } from 'node:url';
 import * as stream from 'node:stream';
 import { Duplex, DuplexOptions } from 'node:stream';
-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 { FetchResult, ModuleRunnerOptions, ModuleRunnerHMRConnection, ModuleRunnerHmr, ModuleEvaluator, ModuleRunner } from 'vite/module-runner';
+import { FetchResult, FetchFunctionOptions, 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 { 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 { SecureContextOptions } from 'node:tls';
+import { ZlibOptions } from 'node:zlib';
 import * as PostCSS from 'postcss';
 export { GeneralImportGlobOptions, ImportGlobFunction, ImportGlobOptions, KnownAsTypeMap } from '../../types/importGlob.js';
 export { ChunkMetadata } from '../../types/metadata.js';
@@ -412,6 +412,7 @@ declare namespace HttpProxy {
      * @param req - Client request.
      * @param res - Client response.
      * @param options - Additional options.
+     * @param callback - Error callback.
      */
     web(
       req: http.IncomingMessage,
@@ -426,6 +427,7 @@ declare namespace HttpProxy {
      * @param socket - Client socket.
      * @param head - Client head.
      * @param options - Additional options.
+     * @param callback - Error callback.
      */
     ws(
       req: http.IncomingMessage,
@@ -616,6 +618,12 @@ 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;
+    /**
+     * rewrite the Origin header of a WebSocket request to match the the target
+     *
+     * **Exercise caution as rewriting the Origin can leave the proxying open to [CSRF attacks](https://owasp.org/www-community/attacks/csrf).**
+     */
+    rewriteWsOrigin?: boolean | undefined;
 }
 
 type LogType = 'error' | 'warn' | 'info';
@@ -632,6 +640,7 @@ interface Logger {
 interface LogOptions {
     clear?: boolean;
     timestamp?: boolean;
+    environment?: string;
 }
 interface LogErrorOptions extends LogOptions {
     error?: Error | RollupError | null;
@@ -678,8 +687,8 @@ interface CommonServerOptions {
      * ``` js
      * module.exports = {
      *   proxy: {
-     *     // string shorthand
-     *     '/foo': 'http://localhost:4567/foo',
+     *     // string shorthand: /foo -> http://localhost:4567/foo
+     *     '/foo': 'http://localhost:4567',
      *     // with options
      *     '/api': {
      *       target: 'http://jsonplaceholder.typicode.com',
@@ -707,7 +716,7 @@ interface CommonServerOptions {
  * https://github.com/expressjs/cors#configuration-options
  */
 interface CorsOptions {
-    origin?: CorsOrigin | ((origin: string, cb: (err: Error, origins: CorsOrigin) => void) => void);
+    origin?: CorsOrigin | ((origin: string | undefined, cb: (err: Error, origins: CorsOrigin) => void) => void);
     methods?: string | string[];
     allowedHeaders?: string | string[];
     exposedHeaders?: string | string[];
@@ -782,2135 +791,2185 @@ 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 file is refactored into TypeScript based on
- * https://github.com/preactjs/wmr/blob/main/packages/wmr/src/lib/rollup-plugin-container.js
+ * This is used both to avoid users to hardcode conditions like
+ * !scan && !build => dev
  */
+declare class FutureCompatEnvironment extends BaseEnvironment {
+    mode: "futureCompat";
+}
 
-interface PluginContainer {
-    options: InputOptions;
-    buildStart(options: InputOptions): Promise<void>;
-    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 | {
-            mappings: '';
-        } | null;
-    }>;
-    load(id: string, options?: {
-        ssr?: boolean;
-        environment?: PluginEnvironment;
-    }): Promise<LoadResult | null>;
-    watchChange(id: string, change: {
-        event: 'create' | 'update' | 'delete';
-    }): Promise<void>;
-    close(): Promise<void>;
+interface FetchModuleOptions {
+    cached?: boolean;
+    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>;
 
-// Modified and inlined to avoid extra dependency
-// Source: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/ws/index.d.ts
+declare class ScanEnvironment extends BaseEnvironment {
+    mode: "scan";
+    get pluginContainer(): EnvironmentPluginContainer;
+    init(): Promise<void>;
+}
 
-declare const WebSocketAlias: typeof WebSocket
-interface WebSocketAlias extends WebSocket {}
-// WebSocket socket.
-declare class WebSocket extends EventEmitter {
-  /** The connection is not yet open. */
-  static readonly CONNECTING: 0
-  /** The connection is open and ready to communicate. */
-  static readonly OPEN: 1
-  /** The connection is in the process of closing. */
-  static readonly CLOSING: 2
-  /** The connection is closed. */
-  static readonly CLOSED: 3
+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 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(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
 
-  binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments'
-  readonly bufferedAmount: number
-  readonly extensions: string
-  /** Indicates whether the websocket is paused */
-  readonly isPaused: boolean
-  readonly protocol: string
-  /** The current state of the connection */
-  readonly readyState:
-    | typeof WebSocket.CONNECTING
-    | typeof WebSocket.OPEN
-    | typeof WebSocket.CLOSING
-    | typeof WebSocket.CLOSED
-  readonly url: string
+interface TransformResult {
+    code: string;
+    map: SourceMap | {
+        mappings: '';
+    } | null;
+    ssr?: boolean;
+    etag?: string;
+    deps?: string[];
+    dynamicDeps?: string[];
+}
+interface TransformOptions {
+    /**
+     * @deprecated inferred from environment
+     */
+    ssr?: boolean;
+}
 
-  /** The connection is not yet open. */
-  readonly CONNECTING: 0
-  /** The connection is open and ready to communicate. */
-  readonly OPEN: 1
-  /** The connection is in the process of closing. */
-  readonly CLOSING: 2
-  /** The connection is closed. */
-  readonly CLOSED: 3
-
-  onopen: ((event: WebSocket.Event) => void) | null
-  onerror: ((event: WebSocket.ErrorEvent) => void) | null
-  onclose: ((event: WebSocket.CloseEvent) => void) | null
-  onmessage: ((event: WebSocket.MessageEvent) => void) | null
-
-  constructor(address: null)
-  constructor(
-    address: string | URL,
-    options?: WebSocket.ClientOptions | ClientRequestArgs,
-  )
-  constructor(
-    address: string | URL,
-    protocols?: string | string[],
-    options?: WebSocket.ClientOptions | ClientRequestArgs,
-  )
-
-  close(code?: number, data?: string | Buffer): void
-  ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void
-  pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void
-  send(data: any, cb?: (err?: Error) => void): void
-  send(
-    data: any,
-    options: {
-      mask?: boolean | undefined
-      binary?: boolean | undefined
-      compress?: boolean | undefined
-      fin?: boolean | undefined
-    },
-    cb?: (err?: Error) => void,
-  ): void
-  terminate(): void
-
-  /**
-   * Pause the websocket causing it to stop emitting events. Some events can still be
-   * emitted after this is called, until all buffered data is consumed. This method
-   * is a noop if the ready state is `CONNECTING` or `CLOSED`.
-   */
-  pause(): void
-  /**
-   * Make a paused socket resume emitting events. This method is a noop if the ready
-   * state is `CONNECTING` or `CLOSED`.
-   */
-  resume(): void
-
-  // HTML5 WebSocket events
-  addEventListener(
-    method: 'message',
-    cb: (event: WebSocket.MessageEvent) => void,
-    options?: WebSocket.EventListenerOptions,
-  ): void
-  addEventListener(
-    method: 'close',
-    cb: (event: WebSocket.CloseEvent) => void,
-    options?: WebSocket.EventListenerOptions,
-  ): void
-  addEventListener(
-    method: 'error',
-    cb: (event: WebSocket.ErrorEvent) => void,
-    options?: WebSocket.EventListenerOptions,
-  ): void
-  addEventListener(
-    method: 'open',
-    cb: (event: WebSocket.Event) => void,
-    options?: WebSocket.EventListenerOptions,
-  ): void
-
-  removeEventListener(
-    method: 'message',
-    cb: (event: WebSocket.MessageEvent) => void,
-  ): void
-  removeEventListener(
-    method: 'close',
-    cb: (event: WebSocket.CloseEvent) => void,
-  ): void
-  removeEventListener(
-    method: 'error',
-    cb: (event: WebSocket.ErrorEvent) => void,
-  ): void
-  removeEventListener(
-    method: 'open',
-    cb: (event: WebSocket.Event) => void,
-  ): void
-
-  // Events
-  on(
-    event: 'close',
-    listener: (this: WebSocket, code: number, reason: Buffer) => void,
-  ): this
-  on(event: 'error', listener: (this: WebSocket, err: Error) => void): this
-  on(
-    event: 'upgrade',
-    listener: (this: WebSocket, request: IncomingMessage) => void,
-  ): this
-  on(
-    event: 'message',
-    listener: (
-      this: WebSocket,
-      data: WebSocket.RawData,
-      isBinary: boolean,
-    ) => void,
-  ): this
-  on(event: 'open', listener: (this: WebSocket) => void): this
-  on(
-    event: 'ping' | 'pong',
-    listener: (this: WebSocket, data: Buffer) => void,
-  ): this
-  on(
-    event: 'unexpected-response',
-    listener: (
-      this: WebSocket,
-      request: ClientRequest,
-      response: IncomingMessage,
-    ) => void,
-  ): this
-  on(
-    event: string | symbol,
-    listener: (this: WebSocket, ...args: any[]) => void,
-  ): this
-
-  once(
-    event: 'close',
-    listener: (this: WebSocket, code: number, reason: Buffer) => void,
-  ): this
-  once(event: 'error', listener: (this: WebSocket, err: Error) => void): this
-  once(
-    event: 'upgrade',
-    listener: (this: WebSocket, request: IncomingMessage) => void,
-  ): this
-  once(
-    event: 'message',
-    listener: (
-      this: WebSocket,
-      data: WebSocket.RawData,
-      isBinary: boolean,
-    ) => void,
-  ): this
-  once(event: 'open', listener: (this: WebSocket) => void): this
-  once(
-    event: 'ping' | 'pong',
-    listener: (this: WebSocket, data: Buffer) => void,
-  ): this
-  once(
-    event: 'unexpected-response',
-    listener: (
-      this: WebSocket,
-      request: ClientRequest,
-      response: IncomingMessage,
-    ) => void,
-  ): this
-  once(
-    event: string | symbol,
-    listener: (this: WebSocket, ...args: any[]) => void,
-  ): this
-
-  off(
-    event: 'close',
-    listener: (this: WebSocket, code: number, reason: Buffer) => void,
-  ): this
-  off(event: 'error', listener: (this: WebSocket, err: Error) => void): this
-  off(
-    event: 'upgrade',
-    listener: (this: WebSocket, request: IncomingMessage) => void,
-  ): this
-  off(
-    event: 'message',
-    listener: (
-      this: WebSocket,
-      data: WebSocket.RawData,
-      isBinary: boolean,
-    ) => void,
-  ): this
-  off(event: 'open', listener: (this: WebSocket) => void): this
-  off(
-    event: 'ping' | 'pong',
-    listener: (this: WebSocket, data: Buffer) => void,
-  ): this
-  off(
-    event: 'unexpected-response',
-    listener: (
-      this: WebSocket,
-      request: ClientRequest,
-      response: IncomingMessage,
-    ) => void,
-  ): this
-  off(
-    event: string | symbol,
-    listener: (this: WebSocket, ...args: any[]) => void,
-  ): this
-
-  addListener(
-    event: 'close',
-    listener: (code: number, reason: Buffer) => void,
-  ): this
-  addListener(event: 'error', listener: (err: Error) => void): this
-  addListener(
-    event: 'upgrade',
-    listener: (request: IncomingMessage) => void,
-  ): this
-  addListener(
-    event: 'message',
-    listener: (data: WebSocket.RawData, isBinary: boolean) => void,
-  ): this
-  addListener(event: 'open', listener: () => void): this
-  addListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this
-  addListener(
-    event: 'unexpected-response',
-    listener: (request: ClientRequest, response: IncomingMessage) => void,
-  ): this
-  addListener(event: string | symbol, listener: (...args: any[]) => void): this
-
-  removeListener(
-    event: 'close',
-    listener: (code: number, reason: Buffer) => void,
-  ): this
-  removeListener(event: 'error', listener: (err: Error) => void): this
-  removeListener(
-    event: 'upgrade',
-    listener: (request: IncomingMessage) => void,
-  ): this
-  removeListener(
-    event: 'message',
-    listener: (data: WebSocket.RawData, isBinary: boolean) => void,
-  ): this
-  removeListener(event: 'open', listener: () => void): this
-  removeListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this
-  removeListener(
-    event: 'unexpected-response',
-    listener: (request: ClientRequest, response: IncomingMessage) => void,
-  ): this
-  removeListener(
-    event: string | symbol,
-    listener: (...args: any[]) => void,
-  ): this
-}
- // tslint:disable-line no-empty-interface
-
-declare namespace WebSocket {
-  /**
-   * Data represents the raw message payload received over the WebSocket.
-   */
-  type RawData = Buffer | ArrayBuffer | Buffer[]
-
-  /**
-   * Data represents the message payload received over the WebSocket.
-   */
-  type Data = string | Buffer | ArrayBuffer | Buffer[]
-
-  /**
-   * CertMeta represents the accepted types for certificate & key data.
-   */
-  type CertMeta = string | string[] | Buffer | Buffer[]
-
-  /**
-   * VerifyClientCallbackSync is a synchronous callback used to inspect the
-   * incoming message. The return value (boolean) of the function determines
-   * whether or not to accept the handshake.
-   */
-  type VerifyClientCallbackSync = (info: {
-    origin: string
-    secure: boolean
-    req: IncomingMessage
-  }) => boolean
-
-  /**
-   * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
-   * incoming message. The return value (boolean) of the function determines
-   * whether or not to accept the handshake.
-   */
-  type VerifyClientCallbackAsync = (
-    info: { origin: string; secure: boolean; req: IncomingMessage },
-    callback: (
-      res: boolean,
-      code?: number,
-      message?: string,
-      headers?: OutgoingHttpHeaders,
-    ) => void,
-  ) => void
-
-  interface ClientOptions extends SecureContextOptions {
-    protocol?: string | undefined
-    followRedirects?: boolean | undefined
-    generateMask?(mask: Buffer): void
-    handshakeTimeout?: number | undefined
-    maxRedirects?: number | undefined
-    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
-    localAddress?: string | undefined
-    protocolVersion?: number | undefined
-    headers?: { [key: string]: string } | undefined
-    origin?: string | undefined
-    agent?: Agent | undefined
-    host?: string | undefined
-    family?: number | undefined
-    checkServerIdentity?(servername: string, cert: CertMeta): boolean
-    rejectUnauthorized?: boolean | undefined
-    maxPayload?: number | undefined
-    skipUTF8Validation?: boolean | undefined
-  }
-
-  interface PerMessageDeflateOptions {
-    serverNoContextTakeover?: boolean | undefined
-    clientNoContextTakeover?: boolean | undefined
-    serverMaxWindowBits?: number | undefined
-    clientMaxWindowBits?: number | undefined
-    zlibDeflateOptions?:
-      | {
-          flush?: number | undefined
-          finishFlush?: number | undefined
-          chunkSize?: number | undefined
-          windowBits?: number | undefined
-          level?: number | undefined
-          memLevel?: number | undefined
-          strategy?: number | undefined
-          dictionary?: Buffer | Buffer[] | DataView | undefined
-          info?: boolean | undefined
-        }
-      | undefined
-    zlibInflateOptions?: ZlibOptions | undefined
-    threshold?: number | undefined
-    concurrencyLimit?: number | undefined
-  }
-
-  interface Event {
-    type: string
-    target: WebSocket
-  }
-
-  interface ErrorEvent {
-    error: any
-    message: string
-    type: string
-    target: WebSocket
-  }
-
-  interface CloseEvent {
-    wasClean: boolean
-    code: number
-    reason: string
-    type: string
-    target: WebSocket
-  }
-
-  interface MessageEvent {
-    data: Data
-    type: string
-    target: WebSocket
-  }
-
-  interface EventListenerOptions {
-    once?: boolean | undefined
-  }
-
-  interface ServerOptions {
-    host?: string | undefined
-    port?: number | undefined
-    backlog?: number | undefined
-    server?: Server | HttpsServer | undefined
-    verifyClient?:
-      | VerifyClientCallbackAsync
-      | VerifyClientCallbackSync
-      | undefined
-    handleProtocols?: (
-      protocols: Set<string>,
-      request: IncomingMessage,
-    ) => string | false
-    path?: string | undefined
-    noServer?: boolean | undefined
-    clientTracking?: boolean | undefined
-    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
-    maxPayload?: number | undefined
-    skipUTF8Validation?: boolean | undefined
-    WebSocket?: typeof WebSocket.WebSocket | undefined
-  }
-
-  interface AddressInfo {
-    address: string
-    family: string
-    port: number
-  }
-
-  // WebSocket Server
-  class Server<T extends WebSocket = WebSocket> extends EventEmitter {
-    options: ServerOptions
-    path: string
-    clients: Set<T>
-
-    constructor(options?: ServerOptions, callback?: () => void)
-
-    address(): AddressInfo | string
-    close(cb?: (err?: Error) => void): void
-    handleUpgrade(
-      request: IncomingMessage,
-      socket: Duplex,
-      upgradeHead: Buffer,
-      callback: (client: T, request: IncomingMessage) => void,
-    ): void
-    shouldHandle(request: IncomingMessage): boolean | Promise<boolean>
-
-    // Events
-    on(
-      event: 'connection',
-      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void,
-    ): this
-    on(event: 'error', cb: (this: Server<T>, error: Error) => void): this
-    on(
-      event: 'headers',
-      cb: (
-        this: Server<T>,
-        headers: string[],
-        request: IncomingMessage,
-      ) => void,
-    ): this
-    on(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
-    on(
-      event: string | symbol,
-      listener: (this: Server<T>, ...args: any[]) => void,
-    ): this
-
-    once(
-      event: 'connection',
-      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void,
-    ): this
-    once(event: 'error', cb: (this: Server<T>, error: Error) => void): this
-    once(
-      event: 'headers',
-      cb: (
-        this: Server<T>,
-        headers: string[],
-        request: IncomingMessage,
-      ) => void,
-    ): this
-    once(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
-    once(
-      event: string | symbol,
-      listener: (this: Server<T>, ...args: any[]) => void,
-    ): this
-
-    off(
-      event: 'connection',
-      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void,
-    ): this
-    off(event: 'error', cb: (this: Server<T>, error: Error) => void): this
-    off(
-      event: 'headers',
-      cb: (
-        this: Server<T>,
-        headers: string[],
-        request: IncomingMessage,
-      ) => void,
-    ): this
-    off(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
-    off(
-      event: string | symbol,
-      listener: (this: Server<T>, ...args: any[]) => void,
-    ): this
-
-    addListener(
-      event: 'connection',
-      cb: (client: T, request: IncomingMessage) => void,
-    ): this
-    addListener(event: 'error', cb: (err: Error) => void): this
-    addListener(
-      event: 'headers',
-      cb: (headers: string[], request: IncomingMessage) => void,
-    ): this
-    addListener(event: 'close' | 'listening', cb: () => void): this
-    addListener(
-      event: string | symbol,
-      listener: (...args: any[]) => void,
-    ): this
-
-    removeListener(event: 'connection', cb: (client: T) => void): this
-    removeListener(event: 'error', cb: (err: Error) => void): this
-    removeListener(
-      event: 'headers',
-      cb: (headers: string[], request: IncomingMessage) => void,
-    ): this
-    removeListener(event: 'close' | 'listening', cb: () => void): this
-    removeListener(
-      event: string | symbol,
-      listener: (...args: any[]) => void,
-    ): this
-  }
-
-  const WebSocketServer: typeof Server
-  interface WebSocketServer extends Server {} // tslint:disable-line no-empty-interface
-  const WebSocket: typeof WebSocketAlias
-  interface WebSocket extends WebSocketAlias {} // tslint:disable-line no-empty-interface
-
-  // 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;
+declare class EnvironmentModuleNode {
+    environment: string;
     /**
-     * Metadata for each already optimized dependency
+     * Public served url path, starts with /
      */
-    optimized: Record<string, OptimizedDepInfo>;
+    url: string;
     /**
-     * Metadata for non-entry optimized chunks and dynamic imports
+     * Resolved file system path + query
      */
-    chunks: Record<string, OptimizedDepInfo>;
+    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;
     /**
-     * Metadata for each newly discovered dependency after processing
+     * @param setIsSelfAccepting - set `false` to set `isSelfAccepting` later. e.g. #7870
      */
-    discovered: Record<string, OptimizedDepInfo>;
+    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;
     /**
-     * OptimizedDepInfo list
+     * 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.
      */
-    depInfoList: OptimizedDepInfo[];
+    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;
 }
+
 /**
- * Scan and optimize dependencies within a project.
- * Used by Vite CLI when running `vite optimize`.
+ * Backward compatible ModuleNode and ModuleGraph with mixed nodes from both the client and ssr environments
+ * 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 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;
+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;
     });
-    register(environment: DevEnvironment): void;
+    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;
+    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 DevEnvironmentSetup {
-    hot?: false | HMRChannel;
-    options?: EnvironmentOptions;
-    runner?: FetchModuleOptions & {
-        transport?: RemoteEnvironmentTransport;
-    };
+interface HmrOptions {
+    protocol?: string;
+    host?: string;
+    port?: number;
+    clientPort?: number;
+    path?: string;
+    timeout?: number;
+    overlay?: boolean;
+    server?: HttpServer;
 }
-declare class DevEnvironment extends Environment {
-    mode: "dev";
-    moduleGraph: EnvironmentModuleGraph;
+interface HotUpdateOptions {
+    type: 'create' | 'update' | 'delete';
+    file: string;
+    timestamp: number;
+    modules: Array<EnvironmentModuleNode>;
+    read: () => string | Promise<string>;
     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>;
+     * @deprecated use this.environment in the hotUpdate hook instead
+     **/
+    environment: DevEnvironment;
 }
-
-interface TransformResult {
-    code: string;
-    map: SourceMap | {
-        mappings: '';
-    } | null;
-    etag?: string;
-    deps?: string[];
-    dynamicDeps?: string[];
+interface HmrContext {
+    file: string;
+    timestamp: number;
+    modules: Array<ModuleNode>;
+    read: () => string | Promise<string>;
+    server: ViteDevServer;
 }
-interface TransformOptions {
+interface HotChannelClient {
     /**
-     * @deprecated infered from environment
+     * Send event to the client
      */
-    ssr?: boolean;
+    send(payload: HotPayload): void;
     /**
-     * TODO: should this be internal?
+     * Send custom event
      */
-    html?: boolean;
+    send(event: string, payload?: CustomPayload['data']): void;
 }
-
-declare class EnvironmentModuleNode {
-    environment: string;
+/** @deprecated use `HotChannelClient` instead */
+type HMRBroadcasterClient = HotChannelClient;
+interface HotChannel {
     /**
-     * Public served url path, starts with /
+     * Broadcast events to all clients
      */
-    url: string;
+    send(payload: HotPayload): void;
     /**
-     * Resolved file system path + query
+     * Send custom event
      */
-    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;
+    send<T extends string>(event: T, payload?: InferCustomEventPayload<T>): void;
     /**
-     * @param setIsSelfAccepting - set `false` to set `isSelfAccepting` later. e.g. #7870
+     * Handle custom event emitted by `import.meta.hot.send`
      */
-    constructor(url: string, environment: string, setIsSelfAccepting?: boolean);
+    on<T extends string>(event: T, listener: (data: InferCustomEventPayload<T>, client: HotChannelClient, ...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;
+}
+/** @deprecated use `HotChannel` instead */
+type HMRChannel = HotChannel;
+interface ServerHotChannel extends HotChannel {
+    api: {
+        innerEmitter: EventEmitter;
+        outsideEmitter: EventEmitter;
+    };
+}
+/** @deprecated use `ServerHotChannel` instead */
+type ServerHMRChannel = ServerHotChannel;
+/** @deprecated use `environment.hot` instead */
+interface HotBroadcaster extends HotChannel {
+    readonly channels: HotChannel[];
+    /**
+     * A noop.
+     * @deprecated
+     */
+    addChannel(channel: HotChannel): HotBroadcaster;
+    close(): Promise<unknown[]>;
 }
-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;
+/** @deprecated use `environment.hot` instead */
+type HMRBroadcaster = HotBroadcaster;
+
+declare class RemoteEnvironmentTransport {
+    private readonly options;
+    constructor(options: {
+        send: (data: any) => void;
+        onMessage: (handler: (data: any) => void) => void;
+    });
+    register(environment: DevEnvironment): void;
+}
+
+interface DevEnvironmentContext {
+    hot: false | HotChannel;
+    options?: EnvironmentOptions;
+    runner?: FetchModuleOptions & {
+        transport?: RemoteEnvironmentTransport;
+    };
+    depsOptimizer?: DepsOptimizer;
+}
+declare class DevEnvironment extends BaseEnvironment {
+    mode: "dev";
+    moduleGraph: EnvironmentModuleGraph;
+    depsOptimizer?: DepsOptimizer;
+    get pluginContainer(): EnvironmentPluginContainer;
     /**
-     * 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.
+     * Hot channel for this environment. If not provided or disabled,
+     * it will be a noop channel that does nothing.
      *
-     * @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.
+     * @example
+     * environment.hot.send({ type: 'full-reload' })
      */
-    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;
+    hot: HotChannel;
+    constructor(name: string, config: ResolvedConfig, context: DevEnvironmentContext);
+    init(options?: {
+        watcher?: FSWatcher;
+    }): Promise<void>;
+    fetchModule(id: string, importer?: string, options?: FetchFunctionOptions): Promise<FetchResult>;
+    transformRequest(url: string): Promise<TransformResult | null>;
+    warmupRequest(url: string): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * 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
+     */
+    waitForRequestsIdle(ignoredId?: string): Promise<void>;
 }
 
-/**
- * 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;
+interface RollupCommonJSOptions {
+  /**
+   * A minimatch pattern, or array of patterns, which specifies the files in
+   * the build the plugin should operate on. By default, all files with
+   * extension `".cjs"` or those in `extensions` are included, but you can
+   * narrow this list by only including specific files. These files will be
+   * analyzed and transpiled if either the analysis does not find ES module
+   * specific statements or `transformMixedEsModules` is `true`.
+   * @default undefined
+   */
+  include?: string | RegExp | readonly (string | RegExp)[]
+  /**
+   * A minimatch pattern, or array of patterns, which specifies the files in
+   * the build the plugin should _ignore_. By default, all files with
+   * extensions other than those in `extensions` or `".cjs"` are ignored, but you
+   * can exclude additional files. See also the `include` option.
+   * @default undefined
+   */
+  exclude?: string | RegExp | readonly (string | RegExp)[]
+  /**
+   * For extensionless imports, search for extensions other than .js in the
+   * order specified. Note that you need to make sure that non-JavaScript files
+   * are transpiled by another plugin first.
+   * @default [ '.js' ]
+   */
+  extensions?: ReadonlyArray<string>
+  /**
+   * If true then uses of `global` won't be dealt with by this plugin
+   * @default false
+   */
+  ignoreGlobal?: boolean
+  /**
+   * If false, skips source map generation for CommonJS modules. This will
+   * improve performance.
+   * @default true
+   */
+  sourceMap?: boolean
+  /**
+   * Some `require` calls cannot be resolved statically to be translated to
+   * imports.
+   * When this option is set to `false`, the generated code will either
+   * directly throw an error when such a call is encountered or, when
+   * `dynamicRequireTargets` is used, when such a call cannot be resolved with a
+   * configured dynamic require target.
+   * Setting this option to `true` will instead leave the `require` call in the
+   * code or use it as a fallback for `dynamicRequireTargets`.
+   * @default false
+   */
+  ignoreDynamicRequires?: boolean
+  /**
+   * Instructs the plugin whether to enable mixed module transformations. This
+   * is useful in scenarios with modules that contain a mix of ES `import`
+   * statements and CommonJS `require` expressions. Set to `true` if `require`
+   * calls should be transformed to imports in mixed modules, or `false` if the
+   * `require` expressions should survive the transformation. The latter can be
+   * important if the code contains environment detection, or you are coding
+   * for an environment with special treatment for `require` calls such as
+   * ElectronJS. See also the `ignore` option.
+   * @default false
+   */
+  transformMixedEsModules?: boolean
+  /**
+   * By default, this plugin will try to hoist `require` statements as imports
+   * to the top of each file. While this works well for many code bases and
+   * allows for very efficient ESM output, it does not perfectly capture
+   * CommonJS semantics as the order of side effects like log statements may
+   * change. But it is especially problematic when there are circular `require`
+   * calls between CommonJS modules as those often rely on the lazy execution of
+   * nested `require` calls.
+   *
+   * Setting this option to `true` will wrap all CommonJS files in functions
+   * which are executed when they are required for the first time, preserving
+   * NodeJS semantics. Note that this can have an impact on the size and
+   * performance of the generated code.
+   *
+   * The default value of `"auto"` will only wrap CommonJS files when they are
+   * part of a CommonJS dependency cycle, e.g. an index file that is required by
+   * many of its dependencies. All other CommonJS files are hoisted. This is the
+   * recommended setting for most code bases.
+   *
+   * `false` will entirely prevent wrapping and hoist all files. This may still
+   * work depending on the nature of cyclic dependencies but will often cause
+   * problems.
+   *
+   * You can also provide a minimatch pattern, or array of patterns, to only
+   * specify a subset of files which should be wrapped in functions for proper
+   * `require` semantics.
+   *
+   * `"debug"` works like `"auto"` but after bundling, it will display a warning
+   * containing a list of ids that have been wrapped which can be used as
+   * minimatch pattern for fine-tuning.
+   * @default "auto"
+   */
+  strictRequires?: boolean | string | RegExp | readonly (string | RegExp)[]
+  /**
+   * Sometimes you have to leave require statements unconverted. Pass an array
+   * containing the IDs or a `id => boolean` function.
+   * @default []
+   */
+  ignore?: ReadonlyArray<string> | ((id: string) => boolean)
+  /**
+   * In most cases, where `require` calls are inside a `try-catch` clause,
+   * they should be left unconverted as it requires an optional dependency
+   * that may or may not be installed beside the rolled up package.
+   * Due to the conversion of `require` to a static `import` - the call is
+   * hoisted to the top of the file, outside the `try-catch` clause.
+   *
+   * - `true`: Default. All `require` calls inside a `try` will be left unconverted.
+   * - `false`: All `require` calls inside a `try` will be converted as if the
+   *   `try-catch` clause is not there.
+   * - `remove`: Remove all `require` calls from inside any `try` block.
+   * - `string[]`: Pass an array containing the IDs to left unconverted.
+   * - `((id: string) => boolean|'remove')`: Pass a function that controls
+   *   individual IDs.
+   *
+   * @default true
+   */
+  ignoreTryCatch?:
+    | boolean
+    | 'remove'
+    | ReadonlyArray<string>
+    | ((id: string) => boolean | 'remove')
+  /**
+   * Controls how to render imports from external dependencies. By default,
+   * this plugin assumes that all external dependencies are CommonJS. This
+   * means they are rendered as default imports to be compatible with e.g.
+   * NodeJS where ES modules can only import a default export from a CommonJS
+   * dependency.
+   *
+   * If you set `esmExternals` to `true`, this plugin assumes that all
+   * external dependencies are ES modules and respect the
+   * `requireReturnsDefault` option. If that option is not set, they will be
+   * rendered as namespace imports.
+   *
+   * You can also supply an array of ids to be treated as ES modules, or a
+   * function that will be passed each external id to determine whether it is
+   * an ES module.
+   * @default false
+   */
+  esmExternals?: boolean | ReadonlyArray<string> | ((id: string) => boolean)
+  /**
+   * Controls what is returned when requiring an ES module from a CommonJS file.
+   * When using the `esmExternals` option, this will also apply to external
+   * modules. By default, this plugin will render those imports as namespace
+   * imports i.e.
+   *
+   * ```js
+   * // input
+   * const foo = require('foo');
+   *
+   * // output
+   * import * as foo from 'foo';
+   * ```
+   *
+   * However, there are some situations where this may not be desired.
+   * For these situations, you can change Rollup's behaviour either globally or
+   * per module. To change it globally, set the `requireReturnsDefault` option
+   * to one of the following values:
+   *
+   * - `false`: This is the default, requiring an ES module returns its
+   *   namespace. This is the only option that will also add a marker
+   *   `__esModule: true` to the namespace to support interop patterns in
+   *   CommonJS modules that are transpiled ES modules.
+   * - `"namespace"`: Like `false`, requiring an ES module returns its
+   *   namespace, but the plugin does not add the `__esModule` marker and thus
+   *   creates more efficient code. For external dependencies when using
+   *   `esmExternals: true`, no additional interop code is generated.
+   * - `"auto"`: This is complementary to how `output.exports: "auto"` works in
+   *   Rollup: If a module has a default export and no named exports, requiring
+   *   that module returns the default export. In all other cases, the namespace
+   *   is returned. For external dependencies when using `esmExternals: true`, a
+   *   corresponding interop helper is added.
+   * - `"preferred"`: If a module has a default export, requiring that module
+   *   always returns the default export, no matter whether additional named
+   *   exports exist. This is similar to how previous versions of this plugin
+   *   worked. Again for external dependencies when using `esmExternals: true`,
+   *   an interop helper is added.
+   * - `true`: This will always try to return the default export on require
+   *   without checking if it actually exists. This can throw at build time if
+   *   there is no default export. This is how external dependencies are handled
+   *   when `esmExternals` is not used. The advantage over the other options is
+   *   that, like `false`, this does not add an interop helper for external
+   *   dependencies, keeping the code lean.
+   *
+   * To change this for individual modules, you can supply a function for
+   * `requireReturnsDefault` instead. This function will then be called once for
+   * each required ES module or external dependency with the corresponding id
+   * and allows you to return different values for different modules.
+   * @default false
+   */
+  requireReturnsDefault?:
+    | boolean
+    | 'auto'
+    | 'preferred'
+    | 'namespace'
+    | ((id: string) => boolean | 'auto' | 'preferred' | 'namespace')
+
+  /**
+   * @default "auto"
+   */
+  defaultIsModuleExports?: boolean | 'auto' | ((id: string) => boolean | 'auto')
+  /**
+   * Some modules contain dynamic `require` calls, or require modules that
+   * contain circular dependencies, which are not handled well by static
+   * imports. Including those modules as `dynamicRequireTargets` will simulate a
+   * CommonJS (NodeJS-like) environment for them with support for dynamic
+   * dependencies. It also enables `strictRequires` for those modules.
+   *
+   * Note: In extreme cases, this feature may result in some paths being
+   * rendered as absolute in the final bundle. The plugin tries to avoid
+   * exposing paths from the local machine, but if you are `dynamicRequirePaths`
+   * with paths that are far away from your project's folder, that may require
+   * replacing strings like `"/Users/John/Desktop/foo-project/"` -\> `"/"`.
+   */
+  dynamicRequireTargets?: string | ReadonlyArray<string>
+  /**
+   * To avoid long paths when using the `dynamicRequireTargets` option, you can use this option to specify a directory
+   * that is a common parent for all files that use dynamic require statements. Using a directory higher up such as `/`
+   * may lead to unnecessarily long paths in the generated code and may expose directory names on your machine like your
+   * home directory name. By default, it uses the current working directory.
+   */
+  dynamicRequireRoot?: string
 }
-type ModuleSetNames = 'acceptedHmrDeps' | 'importedModules';
 
-interface HmrOptions {
-    protocol?: string;
-    host?: string;
-    port?: number;
-    clientPort?: number;
-    path?: string;
-    timeout?: number;
-    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;
-    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 RollupDynamicImportVarsOptions {
+  /**
+   * Files to include in this plugin (default all).
+   * @default []
+   */
+  include?: string | RegExp | (string | RegExp)[]
+  /**
+   * Files to exclude in this plugin (default none).
+   * @default []
+   */
+  exclude?: string | RegExp | (string | RegExp)[]
+  /**
+   * By default, the plugin quits the build process when it encounters an error. If you set this option to true, it will throw a warning instead and leave the code untouched.
+   * @default false
+   */
+  warnOnError?: boolean
 }
-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;
+
+// Modified and inlined to avoid extra dependency
+// Source: https://github.com/terser/terser/blob/master/tools/terser.d.ts
+// BSD Licensed https://github.com/terser/terser/blob/master/LICENSE
+
+declare namespace Terser {
+  export type ECMA = 5 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020
+
+  export type ConsoleProperty = keyof typeof console
+  type DropConsoleOption = boolean | ConsoleProperty[]
+
+  export interface ParseOptions {
+    bare_returns?: boolean
+    /** @deprecated legacy option. Currently, all supported EcmaScript is valid to parse. */
+    ecma?: ECMA
+    html5_comments?: boolean
+    shebang?: boolean
+  }
+
+  export interface CompressOptions {
+    arguments?: boolean
+    arrows?: boolean
+    booleans_as_integers?: boolean
+    booleans?: boolean
+    collapse_vars?: boolean
+    comparisons?: boolean
+    computed_props?: boolean
+    conditionals?: boolean
+    dead_code?: boolean
+    defaults?: boolean
+    directives?: boolean
+    drop_console?: DropConsoleOption
+    drop_debugger?: boolean
+    ecma?: ECMA
+    evaluate?: boolean
+    expression?: boolean
+    global_defs?: object
+    hoist_funs?: boolean
+    hoist_props?: boolean
+    hoist_vars?: boolean
+    ie8?: boolean
+    if_return?: boolean
+    inline?: boolean | InlineFunctions
+    join_vars?: boolean
+    keep_classnames?: boolean | RegExp
+    keep_fargs?: boolean
+    keep_fnames?: boolean | RegExp
+    keep_infinity?: boolean
+    loops?: boolean
+    module?: boolean
+    negate_iife?: boolean
+    passes?: number
+    properties?: boolean
+    pure_funcs?: string[]
+    pure_new?: boolean
+    pure_getters?: boolean | 'strict'
+    reduce_funcs?: boolean
+    reduce_vars?: boolean
+    sequences?: boolean | number
+    side_effects?: boolean
+    switches?: boolean
+    toplevel?: boolean
+    top_retain?: null | string | string[] | RegExp
+    typeofs?: boolean
+    unsafe_arrows?: boolean
+    unsafe?: boolean
+    unsafe_comps?: boolean
+    unsafe_Function?: boolean
+    unsafe_math?: boolean
+    unsafe_symbols?: boolean
+    unsafe_methods?: boolean
+    unsafe_proto?: boolean
+    unsafe_regexp?: boolean
+    unsafe_undefined?: boolean
+    unused?: boolean
+  }
+
+  export enum InlineFunctions {
+    Disabled = 0,
+    SimpleFunctions = 1,
+    WithArguments = 2,
+    WithArgumentsAndVariables = 3,
+  }
+
+  export interface MangleOptions {
+    eval?: boolean
+    keep_classnames?: boolean | RegExp
+    keep_fnames?: boolean | RegExp
+    module?: boolean
+    nth_identifier?: SimpleIdentifierMangler | WeightedIdentifierMangler
+    properties?: boolean | ManglePropertiesOptions
+    reserved?: string[]
+    safari10?: boolean
+    toplevel?: boolean
+  }
+
+  /**
+   * An identifier mangler for which the output is invariant with respect to the source code.
+   */
+  export interface SimpleIdentifierMangler {
     /**
-     * Handle custom event emitted by `import.meta.hot.send`
+     * Obtains the nth most favored (usually shortest) identifier to rename a variable to.
+     * The mangler will increment n and retry until the return value is not in use in scope, and is not a reserved word.
+     * This function is expected to be stable; Evaluating get(n) === get(n) should always return true.
+     * @param n The ordinal of the identifier.
      */
-    on<T extends string>(event: T, listener: (data: InferCustomEventPayload<T>, client: HMRBroadcasterClient, ...args: any[]) => void): void;
-    on(event: 'connection', listener: () => void): void;
+    get(n: number): string
+  }
+
+  /**
+   * An identifier mangler that leverages character frequency analysis to determine identifier precedence.
+   */
+  export interface WeightedIdentifierMangler extends SimpleIdentifierMangler {
     /**
-     * Unregister event listener
+     * Modifies the internal weighting of the input characters by the specified delta.
+     * Will be invoked on the entire printed AST, and then deduct mangleable identifiers.
+     * @param chars The characters to modify the weighting of.
+     * @param delta The numeric weight to add to the characters.
      */
-    off(event: string, listener: Function): void;
+    consider(chars: string, delta: number): number
     /**
-     * Start listening for messages
+     * Resets character weights.
      */
-    listen(): void;
+    reset(): void
     /**
-     * Disconnect all clients, called when server is closed or restarted.
+     * Sorts identifiers by character frequency, in preparation for calls to get(n).
      */
-    close(): void;
+    sort(): void
+  }
+
+  export interface ManglePropertiesOptions {
+    builtins?: boolean
+    debug?: boolean
+    keep_quoted?: boolean | 'strict'
+    nth_identifier?: SimpleIdentifierMangler | WeightedIdentifierMangler
+    regex?: RegExp | string
+    reserved?: string[]
+  }
+
+  export interface FormatOptions {
+    ascii_only?: boolean
+    /** @deprecated Not implemented anymore */
+    beautify?: boolean
+    braces?: boolean
+    comments?:
+      | boolean
+      | 'all'
+      | 'some'
+      | RegExp
+      | ((
+          node: any,
+          comment: {
+            value: string
+            type: 'comment1' | 'comment2' | 'comment3' | 'comment4'
+            pos: number
+            line: number
+            col: number
+          },
+        ) => boolean)
+    ecma?: ECMA
+    ie8?: boolean
+    keep_numbers?: boolean
+    indent_level?: number
+    indent_start?: number
+    inline_script?: boolean
+    keep_quoted_props?: boolean
+    max_line_len?: number | false
+    preamble?: string
+    preserve_annotations?: boolean
+    quote_keys?: boolean
+    quote_style?: OutputQuoteStyle
+    safari10?: boolean
+    semicolons?: boolean
+    shebang?: boolean
+    shorthand?: boolean
+    source_map?: SourceMapOptions
+    webkit?: boolean
+    width?: number
+    wrap_iife?: boolean
+    wrap_func_args?: boolean
+  }
+
+  export enum OutputQuoteStyle {
+    PreferDouble = 0,
+    AlwaysSingle = 1,
+    AlwaysDouble = 2,
+    AlwaysOriginal = 3,
+  }
+
+  export interface MinifyOptions {
+    compress?: boolean | CompressOptions
+    ecma?: ECMA
+    enclose?: boolean | string
+    ie8?: boolean
+    keep_classnames?: boolean | RegExp
+    keep_fnames?: boolean | RegExp
+    mangle?: boolean | MangleOptions
+    module?: boolean
+    nameCache?: object
+    format?: FormatOptions
+    /** @deprecated */
+    output?: FormatOptions
+    parse?: ParseOptions
+    safari10?: boolean
+    sourceMap?: boolean | SourceMapOptions
+    toplevel?: boolean
+  }
+
+  export interface MinifyOutput {
+    code?: string
+    map?: object | string
+    decoded_map?: object | null
+  }
+
+  export interface SourceMapOptions {
+    /** Source map object, 'inline' or source map file content */
+    content?: object | string
+    includeSources?: boolean
+    filename?: string
+    root?: string
+    asObject?: boolean
+    url?: string | 'inline'
+  }
 }
-interface HMRBroadcaster extends Omit<HMRChannel, 'close' | 'name'> {
-    /**
-     * All registered channels. Always has websocket channel.
-     */
-    readonly channels: HMRChannel[];
+
+interface TerserOptions extends Terser.MinifyOptions {
     /**
-     * Add a new third-party channel.
+     * Vite-specific option to specify the max number of workers to spawn
+     * when minifying files with terser.
+     *
+     * @default number of CPUs minus 1
      */
-    addChannel(connection: HMRChannel): HMRBroadcaster;
-    close(): Promise<unknown[]>;
-}
-interface ServerHMRChannel extends HMRChannel {
-    api: {
-        innerEmitter: EventEmitter;
-        outsideEmitter: EventEmitter;
-    };
+    maxWorkers?: number;
 }
 
-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>;
-    /**
-     * 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.
-     */
-    off: WebSocket.Server['off'] & {
-        (event: string, listener: Function): void;
+/** 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>;
     };
 }
-interface WebSocketClient {
-    /**
-     * Send event to the client
-     */
-    send(payload: HMRPayload): void;
-    /**
-     * Send custom event
-     */
-    send(event: string, payload?: CustomPayload['data']): void;
-    /**
-     * The raw WebSocket instance
-     * @advanced
-     */
-    socket: WebSocket;
-}
 
-interface ServerOptions extends CommonServerOptions {
+interface BuildEnvironmentOptions {
     /**
-     * Configure HMR-specific options (port, host, path & protocol)
+     * 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)
+     *
+     * 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
+     *
+     * Another special value is 'esnext' - which only performs minimal transpiling
+     * (for minification compat) and assumes native dynamic imports support.
+     *
+     * For custom targets, see https://esbuild.github.io/api/#target and
+     * https://esbuild.github.io/content-types/#javascript for more details.
+     * @default 'modules'
      */
-    hmr?: HmrOptions | boolean;
+    target?: 'modules' | esbuild_TransformOptions['target'] | 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.
-     * @deprecated use dev.warmup / environment.ssr.dev.warmup
+     * whether to inject module preload polyfill.
+     * Note: does not apply to library mode.
+     * @default true
+     * @deprecated use `modulePreload.polyfill` instead
      */
-    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[];
-    };
+    polyfillModulePreload?: boolean;
     /**
-     * chokidar watch options or null to disable FS watching
-     * https://github.com/paulmillr/chokidar#api
+     * Configure module preload
+     * Note: does not apply to library mode.
+     * @default true
      */
-    watch?: WatchOptions | null;
+    modulePreload?: boolean | ModulePreloadOptions;
     /**
-     * Create Vite dev server to be used as a middleware in an existing server
-     * @default false
+     * Directory relative from `root` where build output will be placed. If the
+     * directory exists, it will be removed before the build.
+     * @default 'dist'
      */
-    middlewareMode?: boolean | {
-        /**
-         * Parent server instance to attach to
-         *
-         * This is needed to proxy WebSocket connections to the parent server.
-         */
-        server: http.Server;
-    };
+    outDir?: string;
     /**
-     * Options for files served via '/\@fs/'.
+     * Directory relative from `outDir` where the built js/css/image assets will
+     * be placed.
+     * @default 'assets'
      */
-    fs?: FileSystemServeOptions;
+    assetsDir?: string;
     /**
-     * Origin for the generated asset URLs.
-     *
-     * @example `http://127.0.0.1:8080`
+     * 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.
+     * @default 4096
      */
-    origin?: string;
+    assetsInlineLimit?: number | ((filePath: string, content: Buffer) => boolean | undefined);
     /**
-     * Pre-transform known direct imports
+     * Whether to code-split CSS. When enabled, CSS in async chunks will be
+     * inlined as strings in the chunk and inserted via dynamically created
+     * style tags when the chunk is loaded.
      * @default true
-     * @deprecated use dev.preTransformRequests
      */
-    preTransformRequests?: boolean;
+    cssCodeSplit?: 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.
-     * @deprecated use dev.sourcemapIgnoreList
+     * An optional separate target for CSS minification.
+     * As esbuild only supports configuring targets to mainstream
+     * browsers, users may need this option when they are targeting
+     * a niche browser that comes with most modern JavaScript features
+     * but has poor CSS support, e.g. Android WeChat WebView, which
+     * doesn't support the #RGBA syntax.
+     * @default target
      */
-    sourcemapIgnoreList?: false | ((sourcePath: string, sourcemapPath: string) => boolean);
+    cssTarget?: esbuild_TransformOptions['target'] | false;
     /**
-     * Run HMR tasks, by default the HMR propagation is done in parallel for all environments
-     * @experimental
+     * Override CSS minification specifically instead of defaulting to `build.minify`,
+     * so you can configure minification for JS and CSS separately.
+     * @default 'esbuild'
      */
-    hotUpdateEnvironments?: (server: ViteDevServer, hmr: (environment: DevEnvironment) => Promise<void>) => Promise<void>;
-}
-interface ResolvedServerOptions extends Omit<ServerOptions, 'fs' | 'middlewareMode' | 'sourcemapIgnoreList'> {
-    fs: Required<FileSystemServeOptions>;
-    middlewareMode: NonNullable<ServerOptions['middlewareMode']>;
-    sourcemapIgnoreList: Exclude<ServerOptions['sourcemapIgnoreList'], false | undefined>;
-}
-interface FileSystemServeOptions {
+    cssMinify?: boolean | 'esbuild' | 'lightningcss';
     /**
-     * Strictly restrict file accessing outside of allowing paths.
-     *
-     * Set to `false` to disable the warning
-     *
-     * @default true
+     * If `true`, a separate sourcemap file will be created. If 'inline', the
+     * sourcemap will be appended to the resulting output file as data URI.
+     * 'hidden' works like `true` except that the corresponding sourcemap
+     * comments in the bundled files are suppressed.
+     * @default false
      */
-    strict?: boolean;
+    sourcemap?: boolean | 'inline' | 'hidden';
     /**
-     * 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.
+     * Set to `false` to disable minification, or specify the minifier to use.
+     * Available options are 'terser' or 'esbuild'.
+     * @default 'esbuild'
      */
-    allow?: string[];
+    minify?: boolean | 'terser' | 'esbuild';
     /**
-     * Restrict accessing files that matches the patterns.
-     *
-     * This will have higher priority than `allow`.
-     * picomatch patterns are supported.
+     * Options for terser
+     * https://terser.org/docs/api-reference#minify-options
      *
-     * @default ['.env', '.env.*', '*.crt', '*.pem']
+     * In addition, you can also pass a `maxWorkers: number` option to specify the
+     * max number of workers to spawn. Defaults to the number of CPUs minus 1.
      */
-    deny?: string[];
+    terserOptions?: TerserOptions;
     /**
-     * Enable caching of fs calls. It is enabled by default if no custom watch ignored patterns are provided.
-     *
-     * @experimental
-     * @default undefined
+     * Will be merged with internal rollup options.
+     * https://rollupjs.org/configuration-options/
      */
-    cachedChecks?: boolean;
-}
-type ServerHook = (this: void, server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>;
-type HttpServer = http.Server | Http2SecureServer;
-interface ViteDevServer {
+    rollupOptions?: RollupOptions;
     /**
-     * The resolved vite config object
+     * Options to pass on to `@rollup/plugin-commonjs`
      */
-    config: ResolvedConfig;
+    commonjsOptions?: RollupCommonJSOptions;
     /**
-     * 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
+     * Options to pass on to `@rollup/plugin-dynamic-import-vars`
      */
-    middlewares: Connect.Server;
+    dynamicImportVarsOptions?: RollupDynamicImportVarsOptions;
     /**
-     * native Node http server instance
-     * will be null in middleware mode
+     * Whether to write bundle to disk
+     * @default true
      */
-    httpServer: HttpServer | null;
+    write?: boolean;
     /**
-     * chokidar watcher instance
-     * https://github.com/paulmillr/chokidar#api
+     * Empty outDir on write.
+     * @default true when outDir is a sub directory of project root
      */
-    watcher: FSWatcher;
+    emptyOutDir?: boolean | null;
     /**
-     * web socket server with `send(payload)` method
-     * @deprecated use `hot` instead
+     * Copy the public directory to outDir on write.
+     * @default true
      */
-    ws: WebSocketServer;
+    copyPublicDir?: boolean;
     /**
-     * HMR broadcaster that can be used to send custom HMR messages to the client
+     * Whether to emit a .vite/manifest.json under assets 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.
      *
-     * 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
+     * Example:
+     *
+     * ```json
+     * {
+     *   "main.js": {
+     *     "file": "main.68fe3fad.js",
+     *     "css": "main.e6b63442.css",
+     *     "imports": [...],
+     *     "dynamicImports": [...]
+     *   }
+     * }
+     * ```
+     * @default false
      */
-    hot: HMRBroadcaster;
+    manifest?: boolean | string;
     /**
-     * Rollup plugin container that can run plugin hooks on a given file
+     * Build in library mode. The value should be the global name of the lib in
+     * UMD mode. This will produce esm + cjs + umd bundle formats with default
+     * configurations that are suitable for distributing libraries.
+     * @default false
      */
-    pluginContainer: PluginContainer;
+    lib?: LibraryOptions | false;
     /**
-     * Module execution environments attached to the Vite server.
+     * Produce SSR oriented build. Note this requires specifying SSR entry via
+     * `rollupOptions.input`.
+     * @default false
      */
-    environments: Record<'client' | 'ssr' | (string & {}), DevEnvironment>;
+    ssr?: boolean | string;
     /**
-     * Module graph that tracks the import relationships, url to file mapping
-     * and hmr state.
-     * @deprecated use environment module graphs instead
+     * Generate SSR manifest for determining style links and asset preload
+     * directives in production.
+     * @default false
      */
-    moduleGraph: ModuleGraph;
+    ssrManifest?: boolean | string;
     /**
-     * The resolved urls Vite prints on the CLI. null in middleware mode or
-     * before `server.listen` is called.
+     * Emit assets during SSR.
+     * @default false
      */
-    resolvedUrls: ResolvedServerUrls | null;
+    ssrEmitAssets?: boolean;
     /**
-     * Programmatically resolve, load and transform a URL and get the result
-     * without going through the http request pipeline.
-     * @deprecated use environment.transformRequest
+     * Emit assets during build. Frameworks can set environments.ssr.build.emitAssets
+     * By default, it is true for the client and false for other environments.
      */
-    transformRequest(url: string, options?: TransformOptions): Promise<TransformResult | null>;
+    emitAssets?: boolean;
     /**
-     * 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
+     * Set to false to disable reporting compressed chunk sizes.
+     * Can slightly improve build speed.
+     * @default true
      */
-    warmupRequest(url: string, options?: TransformOptions): Promise<void>;
+    reportCompressedSize?: boolean;
     /**
-     * Apply vite built-in HTML transforms and any plugin HTML transforms.
+     * Adjust chunk size warning limit (in kB).
+     * @default 500
      */
-    transformIndexHtml(url: string, html: string, originalUrl?: string): Promise<string>;
+    chunkSizeWarningLimit?: number;
     /**
-     * Transform module code into SSR format.
+     * Rollup watch options
+     * https://rollupjs.org/configuration-options/#watch
+     * @default null
      */
-    ssrTransform(code: string, inMap: SourceMap | {
-        mappings: '';
-    } | null, url: string, originalCode?: string): Promise<TransformResult | null>;
+    watch?: WatcherOptions | null;
     /**
-     * Load a given URL as an instantiated module for SSR.
+     * create the Build Environment instance
      */
-    ssrLoadModule(url: string, opts?: {
-        fixStacktrace?: boolean;
-    }): Promise<Record<string, any>>;
+    createEnvironment?: (name: string, config: ResolvedConfig) => Promise<BuildEnvironment> | BuildEnvironment;
+}
+type BuildOptions = BuildEnvironmentOptions;
+interface LibraryOptions {
     /**
-     * Returns a fixed version of the given stack
+     * Path of library entry
      */
-    ssrRewriteStacktrace(stack: string): string;
+    entry: InputOption;
     /**
-     * Mutates the given SSR error by rewriting the stacktrace
+     * The name of the exposed global variable. Required when the `formats` option includes
+     * `umd` or `iife`
      */
-    ssrFixStacktrace(e: Error): void;
+    name?: string;
     /**
-     * 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.
+     * Output bundle formats
+     * @default ['es', 'umd']
      */
-    reloadModule(module: ModuleNode): Promise<void>;
+    formats?: LibraryFormats[];
     /**
-     * Triggers HMR for an environment module in the module graph.
-     * If `hmr` is false, this is a no-op.
+     * The name of the package file output. The default file name is the name option
+     * of the project package.json. It can also be defined as a function taking the
+     * format as an argument.
      */
-    reloadEnvironmentModule(module: EnvironmentModuleNode): Promise<void>;
+    fileName?: string | ((format: ModuleFormat, entryName: string) => string);
+}
+type LibraryFormats = 'es' | 'cjs' | 'umd' | 'iife' | 'system';
+interface ModulePreloadOptions {
     /**
-     * Start the server.
+     * Whether to inject a module preload polyfill.
+     * Note: does not apply to library mode.
+     * @default true
      */
-    listen(port?: number, isRestart?: boolean): Promise<ViteDevServer>;
+    polyfill?: boolean;
     /**
-     * Stop the server.
+     * Resolve the list of dependencies to preload for a given dynamic import
+     * @experimental
      */
+    resolveDependencies?: ResolveModulePreloadDependenciesFn;
+}
+interface ResolvedModulePreloadOptions {
+    polyfill: boolean;
+    resolveDependencies?: ResolveModulePreloadDependenciesFn;
+}
+type ResolveModulePreloadDependenciesFn = (filename: string, deps: string[], context: {
+    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 a single environment for production.
+ * Returns a Promise containing the build result.
+ */
+declare function build(inlineConfig?: InlineConfig): Promise<RollupOutput | RollupOutput[] | RollupWatcher>;
+type RenderBuiltAssetUrl = (filename: string, type: {
+    type: 'asset' | 'public';
+    hostId: string;
+    hostType: 'js' | 'css' | 'html';
+    ssr: boolean;
+}) => string | {
+    relative?: boolean;
+    runtime?: string;
+} | undefined;
+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 {
+    sharedConfigBuild?: boolean;
+    sharedPlugins?: boolean;
+    entireApp?: boolean;
+    buildApp?: (builder: ViteBuilder) => Promise<void>;
+}
+type ResolvedBuilderOptions = Required<BuilderOptions>;
+/**
+ * Creates a ViteBuilder to orchestrate building multiple environments.
+ */
+declare function createBuilder(inlineConfig?: InlineConfig): Promise<ViteBuilder>;
+
+type Environment = DevEnvironment | BuildEnvironment | ScanEnvironment | FutureCompatEnvironment;
+
+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 _closed;
+    private _updateModuleLoadAddedImports;
+    private _getAddedImports;
+    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>;
+        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>;
-    /**
-     * 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 class PluginContainer {
+    private environments;
+    constructor(environments: Record<string, Environment>);
+    private _getEnvironment;
+    private _getPluginContainer;
+    get options(): InputOptions;
+    buildStart(_options?: InputOptions): Promise<void>;
+    resolveId(rawId: string, importer?: string, 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;
+        environment?: Environment;
+        inMap?: SourceDescription['map'];
+    }): Promise<{
+        code: string;
+        map: SourceMap | {
+            mappings: '';
+        } | null;
+    }>;
+    watchChange(_id: string, _change: {
+        event: 'create' | 'update' | 'delete';
+    }): Promise<void>;
+    close(): Promise<void>;
 }
-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>;
-    };
-}
+// Modified and inlined to avoid extra dependency
+// Source: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/ws/index.d.ts
+
+declare const WebSocketAlias: typeof WebSocket
+interface WebSocketAlias extends WebSocket {}
+
+// WebSocket socket.
+declare class WebSocket extends EventEmitter {
+  /** The connection is not yet open. */
+  static readonly CONNECTING: 0
+  /** The connection is open and ready to communicate. */
+  static readonly OPEN: 1
+  /** The connection is in the process of closing. */
+  static readonly CLOSING: 2
+  /** The connection is closed. */
+  static readonly CLOSED: 3
+
+  binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments'
+  readonly bufferedAmount: number
+  readonly extensions: string
+  /** Indicates whether the websocket is paused */
+  readonly isPaused: boolean
+  readonly protocol: string
+  /** The current state of the connection */
+  readonly readyState:
+    | typeof WebSocket.CONNECTING
+    | typeof WebSocket.OPEN
+    | typeof WebSocket.CLOSING
+    | typeof WebSocket.CLOSED
+  readonly url: string
+
+  /** The connection is not yet open. */
+  readonly CONNECTING: 0
+  /** The connection is open and ready to communicate. */
+  readonly OPEN: 1
+  /** The connection is in the process of closing. */
+  readonly CLOSING: 2
+  /** The connection is closed. */
+  readonly CLOSED: 3
+
+  onopen: ((event: WebSocket.Event) => void) | null
+  onerror: ((event: WebSocket.ErrorEvent) => void) | null
+  onclose: ((event: WebSocket.CloseEvent) => void) | null
+  onmessage: ((event: WebSocket.MessageEvent) => void) | null
+
+  constructor(address: null)
+  constructor(
+    address: string | URL,
+    options?: WebSocket.ClientOptions | ClientRequestArgs,
+  )
+  constructor(
+    address: string | URL,
+    protocols?: string | string[],
+    options?: WebSocket.ClientOptions | ClientRequestArgs,
+  )
+
+  close(code?: number, data?: string | Buffer): void
+  ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void
+  pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void
+  send(data: any, cb?: (err?: Error) => void): void
+  send(
+    data: any,
+    options: {
+      mask?: boolean | undefined
+      binary?: boolean | undefined
+      compress?: boolean | undefined
+      fin?: boolean | undefined
+    },
+    cb?: (err?: Error) => void,
+  ): void
+  terminate(): void
 
-interface RollupCommonJSOptions {
-  /**
-   * A minimatch pattern, or array of patterns, which specifies the files in
-   * the build the plugin should operate on. By default, all files with
-   * extension `".cjs"` or those in `extensions` are included, but you can
-   * narrow this list by only including specific files. These files will be
-   * analyzed and transpiled if either the analysis does not find ES module
-   * specific statements or `transformMixedEsModules` is `true`.
-   * @default undefined
-   */
-  include?: string | RegExp | readonly (string | RegExp)[]
-  /**
-   * A minimatch pattern, or array of patterns, which specifies the files in
-   * the build the plugin should _ignore_. By default, all files with
-   * extensions other than those in `extensions` or `".cjs"` are ignored, but you
-   * can exclude additional files. See also the `include` option.
-   * @default undefined
-   */
-  exclude?: string | RegExp | readonly (string | RegExp)[]
-  /**
-   * For extensionless imports, search for extensions other than .js in the
-   * order specified. Note that you need to make sure that non-JavaScript files
-   * are transpiled by another plugin first.
-   * @default [ '.js' ]
-   */
-  extensions?: ReadonlyArray<string>
-  /**
-   * If true then uses of `global` won't be dealt with by this plugin
-   * @default false
-   */
-  ignoreGlobal?: boolean
-  /**
-   * If false, skips source map generation for CommonJS modules. This will
-   * improve performance.
-   * @default true
-   */
-  sourceMap?: boolean
-  /**
-   * Some `require` calls cannot be resolved statically to be translated to
-   * imports.
-   * When this option is set to `false`, the generated code will either
-   * directly throw an error when such a call is encountered or, when
-   * `dynamicRequireTargets` is used, when such a call cannot be resolved with a
-   * configured dynamic require target.
-   * Setting this option to `true` will instead leave the `require` call in the
-   * code or use it as a fallback for `dynamicRequireTargets`.
-   * @default false
-   */
-  ignoreDynamicRequires?: boolean
-  /**
-   * Instructs the plugin whether to enable mixed module transformations. This
-   * is useful in scenarios with modules that contain a mix of ES `import`
-   * statements and CommonJS `require` expressions. Set to `true` if `require`
-   * calls should be transformed to imports in mixed modules, or `false` if the
-   * `require` expressions should survive the transformation. The latter can be
-   * important if the code contains environment detection, or you are coding
-   * for an environment with special treatment for `require` calls such as
-   * ElectronJS. See also the `ignore` option.
-   * @default false
-   */
-  transformMixedEsModules?: boolean
-  /**
-   * By default, this plugin will try to hoist `require` statements as imports
-   * to the top of each file. While this works well for many code bases and
-   * allows for very efficient ESM output, it does not perfectly capture
-   * CommonJS semantics as the order of side effects like log statements may
-   * change. But it is especially problematic when there are circular `require`
-   * calls between CommonJS modules as those often rely on the lazy execution of
-   * nested `require` calls.
-   *
-   * Setting this option to `true` will wrap all CommonJS files in functions
-   * which are executed when they are required for the first time, preserving
-   * NodeJS semantics. Note that this can have an impact on the size and
-   * performance of the generated code.
-   *
-   * The default value of `"auto"` will only wrap CommonJS files when they are
-   * part of a CommonJS dependency cycle, e.g. an index file that is required by
-   * many of its dependencies. All other CommonJS files are hoisted. This is the
-   * recommended setting for most code bases.
-   *
-   * `false` will entirely prevent wrapping and hoist all files. This may still
-   * work depending on the nature of cyclic dependencies but will often cause
-   * problems.
-   *
-   * You can also provide a minimatch pattern, or array of patterns, to only
-   * specify a subset of files which should be wrapped in functions for proper
-   * `require` semantics.
-   *
-   * `"debug"` works like `"auto"` but after bundling, it will display a warning
-   * containing a list of ids that have been wrapped which can be used as
-   * minimatch pattern for fine-tuning.
-   * @default "auto"
-   */
-  strictRequires?: boolean | string | RegExp | readonly (string | RegExp)[]
-  /**
-   * Sometimes you have to leave require statements unconverted. Pass an array
-   * containing the IDs or a `id => boolean` function.
-   * @default []
-   */
-  ignore?: ReadonlyArray<string> | ((id: string) => boolean)
-  /**
-   * In most cases, where `require` calls are inside a `try-catch` clause,
-   * they should be left unconverted as it requires an optional dependency
-   * that may or may not be installed beside the rolled up package.
-   * Due to the conversion of `require` to a static `import` - the call is
-   * hoisted to the top of the file, outside the `try-catch` clause.
-   *
-   * - `true`: Default. All `require` calls inside a `try` will be left unconverted.
-   * - `false`: All `require` calls inside a `try` will be converted as if the
-   *   `try-catch` clause is not there.
-   * - `remove`: Remove all `require` calls from inside any `try` block.
-   * - `string[]`: Pass an array containing the IDs to left unconverted.
-   * - `((id: string) => boolean|'remove')`: Pass a function that controls
-   *   individual IDs.
-   *
-   * @default true
-   */
-  ignoreTryCatch?:
-    | boolean
-    | 'remove'
-    | ReadonlyArray<string>
-    | ((id: string) => boolean | 'remove')
   /**
-   * Controls how to render imports from external dependencies. By default,
-   * this plugin assumes that all external dependencies are CommonJS. This
-   * means they are rendered as default imports to be compatible with e.g.
-   * NodeJS where ES modules can only import a default export from a CommonJS
-   * dependency.
-   *
-   * If you set `esmExternals` to `true`, this plugin assumes that all
-   * external dependencies are ES modules and respect the
-   * `requireReturnsDefault` option. If that option is not set, they will be
-   * rendered as namespace imports.
-   *
-   * You can also supply an array of ids to be treated as ES modules, or a
-   * function that will be passed each external id to determine whether it is
-   * an ES module.
-   * @default false
+   * Pause the websocket causing it to stop emitting events. Some events can still be
+   * emitted after this is called, until all buffered data is consumed. This method
+   * is a noop if the ready state is `CONNECTING` or `CLOSED`.
    */
-  esmExternals?: boolean | ReadonlyArray<string> | ((id: string) => boolean)
+  pause(): void
   /**
-   * Controls what is returned when requiring an ES module from a CommonJS file.
-   * When using the `esmExternals` option, this will also apply to external
-   * modules. By default, this plugin will render those imports as namespace
-   * imports i.e.
-   *
-   * ```js
-   * // input
-   * const foo = require('foo');
-   *
-   * // output
-   * import * as foo from 'foo';
-   * ```
-   *
-   * However, there are some situations where this may not be desired.
-   * For these situations, you can change Rollup's behaviour either globally or
-   * per module. To change it globally, set the `requireReturnsDefault` option
-   * to one of the following values:
-   *
-   * - `false`: This is the default, requiring an ES module returns its
-   *   namespace. This is the only option that will also add a marker
-   *   `__esModule: true` to the namespace to support interop patterns in
-   *   CommonJS modules that are transpiled ES modules.
-   * - `"namespace"`: Like `false`, requiring an ES module returns its
-   *   namespace, but the plugin does not add the `__esModule` marker and thus
-   *   creates more efficient code. For external dependencies when using
-   *   `esmExternals: true`, no additional interop code is generated.
-   * - `"auto"`: This is complementary to how `output.exports: "auto"` works in
-   *   Rollup: If a module has a default export and no named exports, requiring
-   *   that module returns the default export. In all other cases, the namespace
-   *   is returned. For external dependencies when using `esmExternals: true`, a
-   *   corresponding interop helper is added.
-   * - `"preferred"`: If a module has a default export, requiring that module
-   *   always returns the default export, no matter whether additional named
-   *   exports exist. This is similar to how previous versions of this plugin
-   *   worked. Again for external dependencies when using `esmExternals: true`,
-   *   an interop helper is added.
-   * - `true`: This will always try to return the default export on require
-   *   without checking if it actually exists. This can throw at build time if
-   *   there is no default export. This is how external dependencies are handled
-   *   when `esmExternals` is not used. The advantage over the other options is
-   *   that, like `false`, this does not add an interop helper for external
-   *   dependencies, keeping the code lean.
-   *
-   * To change this for individual modules, you can supply a function for
-   * `requireReturnsDefault` instead. This function will then be called once for
-   * each required ES module or external dependency with the corresponding id
-   * and allows you to return different values for different modules.
-   * @default false
+   * Make a paused socket resume emitting events. This method is a noop if the ready
+   * state is `CONNECTING` or `CLOSED`.
    */
-  requireReturnsDefault?:
-    | boolean
-    | 'auto'
-    | 'preferred'
-    | 'namespace'
-    | ((id: string) => boolean | 'auto' | 'preferred' | 'namespace')
+  resume(): void
+
+  // HTML5 WebSocket events
+  addEventListener(
+    method: 'message',
+    cb: (event: WebSocket.MessageEvent) => void,
+    options?: WebSocket.EventListenerOptions,
+  ): void
+  addEventListener(
+    method: 'close',
+    cb: (event: WebSocket.CloseEvent) => void,
+    options?: WebSocket.EventListenerOptions,
+  ): void
+  addEventListener(
+    method: 'error',
+    cb: (event: WebSocket.ErrorEvent) => void,
+    options?: WebSocket.EventListenerOptions,
+  ): void
+  addEventListener(
+    method: 'open',
+    cb: (event: WebSocket.Event) => void,
+    options?: WebSocket.EventListenerOptions,
+  ): void
+
+  removeEventListener(
+    method: 'message',
+    cb: (event: WebSocket.MessageEvent) => void,
+  ): void
+  removeEventListener(
+    method: 'close',
+    cb: (event: WebSocket.CloseEvent) => void,
+  ): void
+  removeEventListener(
+    method: 'error',
+    cb: (event: WebSocket.ErrorEvent) => void,
+  ): void
+  removeEventListener(
+    method: 'open',
+    cb: (event: WebSocket.Event) => void,
+  ): void
+
+  // Events
+  on(
+    event: 'close',
+    listener: (this: WebSocket, code: number, reason: Buffer) => void,
+  ): this
+  on(event: 'error', listener: (this: WebSocket, err: Error) => void): this
+  on(
+    event: 'upgrade',
+    listener: (this: WebSocket, request: IncomingMessage) => void,
+  ): this
+  on(
+    event: 'message',
+    listener: (
+      this: WebSocket,
+      data: WebSocket.RawData,
+      isBinary: boolean,
+    ) => void,
+  ): this
+  on(event: 'open', listener: (this: WebSocket) => void): this
+  on(
+    event: 'ping' | 'pong',
+    listener: (this: WebSocket, data: Buffer) => void,
+  ): this
+  on(
+    event: 'unexpected-response',
+    listener: (
+      this: WebSocket,
+      request: ClientRequest,
+      response: IncomingMessage,
+    ) => void,
+  ): this
+  on(
+    event: string | symbol,
+    listener: (this: WebSocket, ...args: any[]) => void,
+  ): this
+
+  once(
+    event: 'close',
+    listener: (this: WebSocket, code: number, reason: Buffer) => void,
+  ): this
+  once(event: 'error', listener: (this: WebSocket, err: Error) => void): this
+  once(
+    event: 'upgrade',
+    listener: (this: WebSocket, request: IncomingMessage) => void,
+  ): this
+  once(
+    event: 'message',
+    listener: (
+      this: WebSocket,
+      data: WebSocket.RawData,
+      isBinary: boolean,
+    ) => void,
+  ): this
+  once(event: 'open', listener: (this: WebSocket) => void): this
+  once(
+    event: 'ping' | 'pong',
+    listener: (this: WebSocket, data: Buffer) => void,
+  ): this
+  once(
+    event: 'unexpected-response',
+    listener: (
+      this: WebSocket,
+      request: ClientRequest,
+      response: IncomingMessage,
+    ) => void,
+  ): this
+  once(
+    event: string | symbol,
+    listener: (this: WebSocket, ...args: any[]) => void,
+  ): this
+
+  off(
+    event: 'close',
+    listener: (this: WebSocket, code: number, reason: Buffer) => void,
+  ): this
+  off(event: 'error', listener: (this: WebSocket, err: Error) => void): this
+  off(
+    event: 'upgrade',
+    listener: (this: WebSocket, request: IncomingMessage) => void,
+  ): this
+  off(
+    event: 'message',
+    listener: (
+      this: WebSocket,
+      data: WebSocket.RawData,
+      isBinary: boolean,
+    ) => void,
+  ): this
+  off(event: 'open', listener: (this: WebSocket) => void): this
+  off(
+    event: 'ping' | 'pong',
+    listener: (this: WebSocket, data: Buffer) => void,
+  ): this
+  off(
+    event: 'unexpected-response',
+    listener: (
+      this: WebSocket,
+      request: ClientRequest,
+      response: IncomingMessage,
+    ) => void,
+  ): this
+  off(
+    event: string | symbol,
+    listener: (this: WebSocket, ...args: any[]) => void,
+  ): this
 
+  addListener(
+    event: 'close',
+    listener: (code: number, reason: Buffer) => void,
+  ): this
+  addListener(event: 'error', listener: (err: Error) => void): this
+  addListener(
+    event: 'upgrade',
+    listener: (request: IncomingMessage) => void,
+  ): this
+  addListener(
+    event: 'message',
+    listener: (data: WebSocket.RawData, isBinary: boolean) => void,
+  ): this
+  addListener(event: 'open', listener: () => void): this
+  addListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this
+  addListener(
+    event: 'unexpected-response',
+    listener: (request: ClientRequest, response: IncomingMessage) => void,
+  ): this
+  addListener(event: string | symbol, listener: (...args: any[]) => void): this
+
+  removeListener(
+    event: 'close',
+    listener: (code: number, reason: Buffer) => void,
+  ): this
+  removeListener(event: 'error', listener: (err: Error) => void): this
+  removeListener(
+    event: 'upgrade',
+    listener: (request: IncomingMessage) => void,
+  ): this
+  removeListener(
+    event: 'message',
+    listener: (data: WebSocket.RawData, isBinary: boolean) => void,
+  ): this
+  removeListener(event: 'open', listener: () => void): this
+  removeListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this
+  removeListener(
+    event: 'unexpected-response',
+    listener: (request: ClientRequest, response: IncomingMessage) => void,
+  ): this
+  removeListener(
+    event: string | symbol,
+    listener: (...args: any[]) => void,
+  ): this
+}
+
+declare namespace WebSocket {
   /**
-   * @default "auto"
-   */
-  defaultIsModuleExports?: boolean | 'auto' | ((id: string) => boolean | 'auto')
-  /**
-   * Some modules contain dynamic `require` calls, or require modules that
-   * contain circular dependencies, which are not handled well by static
-   * imports. Including those modules as `dynamicRequireTargets` will simulate a
-   * CommonJS (NodeJS-like) environment for them with support for dynamic
-   * dependencies. It also enables `strictRequires` for those modules.
-   *
-   * Note: In extreme cases, this feature may result in some paths being
-   * rendered as absolute in the final bundle. The plugin tries to avoid
-   * exposing paths from the local machine, but if you are `dynamicRequirePaths`
-   * with paths that are far away from your project's folder, that may require
-   * replacing strings like `"/Users/John/Desktop/foo-project/"` -\> `"/"`.
+   * Data represents the raw message payload received over the WebSocket.
    */
-  dynamicRequireTargets?: string | ReadonlyArray<string>
+  type RawData = Buffer | ArrayBuffer | Buffer[]
+
   /**
-   * To avoid long paths when using the `dynamicRequireTargets` option, you can use this option to specify a directory
-   * that is a common parent for all files that use dynamic require statements. Using a directory higher up such as `/`
-   * may lead to unnecessarily long paths in the generated code and may expose directory names on your machine like your
-   * home directory name. By default, it uses the current working directory.
+   * Data represents the message payload received over the WebSocket.
    */
-  dynamicRequireRoot?: string
-}
+  type Data = string | Buffer | ArrayBuffer | Buffer[]
 
-interface RollupDynamicImportVarsOptions {
   /**
-   * Files to include in this plugin (default all).
-   * @default []
+   * CertMeta represents the accepted types for certificate & key data.
    */
-  include?: string | RegExp | (string | RegExp)[]
+  type CertMeta = string | string[] | Buffer | Buffer[]
+
   /**
-   * Files to exclude in this plugin (default none).
-   * @default []
+   * VerifyClientCallbackSync is a synchronous callback used to inspect the
+   * incoming message. The return value (boolean) of the function determines
+   * whether or not to accept the handshake.
    */
-  exclude?: string | RegExp | (string | RegExp)[]
+  type VerifyClientCallbackSync = (info: {
+    origin: string
+    secure: boolean
+    req: IncomingMessage
+  }) => boolean
+
   /**
-   * By default, the plugin quits the build process when it encounters an error. If you set this option to true, it will throw a warning instead and leave the code untouched.
-   * @default false
+   * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
+   * incoming message. The return value (boolean) of the function determines
+   * whether or not to accept the handshake.
    */
-  warnOnError?: boolean
-}
-
-// Modified and inlined to avoid extra dependency
-// Source: https://github.com/terser/terser/blob/master/tools/terser.d.ts
-// BSD Licensed https://github.com/terser/terser/blob/master/LICENSE
-
-declare namespace Terser {
-  export type ECMA = 5 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020
-
-  export interface ParseOptions {
-    bare_returns?: boolean
-    /** @deprecated legacy option. Currently, all supported EcmaScript is valid to parse. */
-    ecma?: ECMA
-    html5_comments?: boolean
-    shebang?: boolean
-  }
+  type VerifyClientCallbackAsync = (
+    info: { origin: string; secure: boolean; req: IncomingMessage },
+    callback: (
+      res: boolean,
+      code?: number,
+      message?: string,
+      headers?: OutgoingHttpHeaders,
+    ) => void,
+  ) => void
 
-  export interface CompressOptions {
-    arguments?: boolean
-    arrows?: boolean
-    booleans_as_integers?: boolean
-    booleans?: boolean
-    collapse_vars?: boolean
-    comparisons?: boolean
-    computed_props?: boolean
-    conditionals?: boolean
-    dead_code?: boolean
-    defaults?: boolean
-    directives?: boolean
-    drop_console?: boolean
-    drop_debugger?: boolean
-    ecma?: ECMA
-    evaluate?: boolean
-    expression?: boolean
-    global_defs?: object
-    hoist_funs?: boolean
-    hoist_props?: boolean
-    hoist_vars?: boolean
-    ie8?: boolean
-    if_return?: boolean
-    inline?: boolean | InlineFunctions
-    join_vars?: boolean
-    keep_classnames?: boolean | RegExp
-    keep_fargs?: boolean
-    keep_fnames?: boolean | RegExp
-    keep_infinity?: boolean
-    loops?: boolean
-    module?: boolean
-    negate_iife?: boolean
-    passes?: number
-    properties?: boolean
-    pure_funcs?: string[]
-    pure_getters?: boolean | 'strict'
-    reduce_funcs?: boolean
-    reduce_vars?: boolean
-    sequences?: boolean | number
-    side_effects?: boolean
-    switches?: boolean
-    toplevel?: boolean
-    top_retain?: null | string | string[] | RegExp
-    typeofs?: boolean
-    unsafe_arrows?: boolean
-    unsafe?: boolean
-    unsafe_comps?: boolean
-    unsafe_Function?: boolean
-    unsafe_math?: boolean
-    unsafe_symbols?: boolean
-    unsafe_methods?: boolean
-    unsafe_proto?: boolean
-    unsafe_regexp?: boolean
-    unsafe_undefined?: boolean
-    unused?: boolean
+  interface ClientOptions extends SecureContextOptions {
+    protocol?: string | undefined
+    followRedirects?: boolean | undefined
+    generateMask?(mask: Buffer): void
+    handshakeTimeout?: number | undefined
+    maxRedirects?: number | undefined
+    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
+    localAddress?: string | undefined
+    protocolVersion?: number | undefined
+    headers?: { [key: string]: string } | undefined
+    origin?: string | undefined
+    agent?: Agent | undefined
+    host?: string | undefined
+    family?: number | undefined
+    checkServerIdentity?(servername: string, cert: CertMeta): boolean
+    rejectUnauthorized?: boolean | undefined
+    maxPayload?: number | undefined
+    skipUTF8Validation?: boolean | undefined
   }
 
-  export enum InlineFunctions {
-    Disabled = 0,
-    SimpleFunctions = 1,
-    WithArguments = 2,
-    WithArgumentsAndVariables = 3,
+  interface PerMessageDeflateOptions {
+    serverNoContextTakeover?: boolean | undefined
+    clientNoContextTakeover?: boolean | undefined
+    serverMaxWindowBits?: number | undefined
+    clientMaxWindowBits?: number | undefined
+    zlibDeflateOptions?:
+      | {
+          flush?: number | undefined
+          finishFlush?: number | undefined
+          chunkSize?: number | undefined
+          windowBits?: number | undefined
+          level?: number | undefined
+          memLevel?: number | undefined
+          strategy?: number | undefined
+          dictionary?: Buffer | Buffer[] | DataView | undefined
+          info?: boolean | undefined
+        }
+      | undefined
+    zlibInflateOptions?: ZlibOptions | undefined
+    threshold?: number | undefined
+    concurrencyLimit?: number | undefined
   }
 
-  export interface MangleOptions {
-    eval?: boolean
-    keep_classnames?: boolean | RegExp
-    keep_fnames?: boolean | RegExp
-    module?: boolean
-    nth_identifier?: SimpleIdentifierMangler | WeightedIdentifierMangler
-    properties?: boolean | ManglePropertiesOptions
-    reserved?: string[]
-    safari10?: boolean
-    toplevel?: boolean
+  interface Event {
+    type: string
+    target: WebSocket
   }
 
-  /**
-   * An identifier mangler for which the output is invariant with respect to the source code.
-   */
-  export interface SimpleIdentifierMangler {
-    /**
-     * Obtains the nth most favored (usually shortest) identifier to rename a variable to.
-     * The mangler will increment n and retry until the return value is not in use in scope, and is not a reserved word.
-     * This function is expected to be stable; Evaluating get(n) === get(n) should always return true.
-     * @param n - The ordinal of the identifier.
-     */
-    get(n: number): string
+  interface ErrorEvent {
+    error: any
+    message: string
+    type: string
+    target: WebSocket
   }
 
-  /**
-   * An identifier mangler that leverages character frequency analysis to determine identifier precedence.
-   */
-  export interface WeightedIdentifierMangler extends SimpleIdentifierMangler {
-    /**
-     * Modifies the internal weighting of the input characters by the specified delta.
-     * Will be invoked on the entire printed AST, and then deduct mangleable identifiers.
-     * @param chars - The characters to modify the weighting of.
-     * @param delta - The numeric weight to add to the characters.
-     */
-    consider(chars: string, delta: number): number
-    /**
-     * Resets character weights.
-     */
-    reset(): void
-    /**
-     * Sorts identifiers by character frequency, in preparation for calls to get(n).
-     */
-    sort(): void
+  interface CloseEvent {
+    wasClean: boolean
+    code: number
+    reason: string
+    type: string
+    target: WebSocket
   }
 
-  export interface ManglePropertiesOptions {
-    builtins?: boolean
-    debug?: boolean
-    keep_quoted?: boolean | 'strict'
-    nth_identifier?: SimpleIdentifierMangler | WeightedIdentifierMangler
-    regex?: RegExp | string
-    reserved?: string[]
+  interface MessageEvent {
+    data: Data
+    type: string
+    target: WebSocket
   }
 
-  export interface FormatOptions {
-    ascii_only?: boolean
-    /** @deprecated Not implemented anymore */
-    beautify?: boolean
-    braces?: boolean
-    comments?:
-      | boolean
-      | 'all'
-      | 'some'
-      | RegExp
-      | ((
-          node: any,
-          comment: {
-            value: string
-            type: 'comment1' | 'comment2' | 'comment3' | 'comment4'
-            pos: number
-            line: number
-            col: number
-          },
-        ) => boolean)
-    ecma?: ECMA
-    ie8?: boolean
-    keep_numbers?: boolean
-    indent_level?: number
-    indent_start?: number
-    inline_script?: boolean
-    keep_quoted_props?: boolean
-    max_line_len?: number | false
-    preamble?: string
-    preserve_annotations?: boolean
-    quote_keys?: boolean
-    quote_style?: OutputQuoteStyle
-    safari10?: boolean
-    semicolons?: boolean
-    shebang?: boolean
-    shorthand?: boolean
-    source_map?: SourceMapOptions
-    webkit?: boolean
-    width?: number
-    wrap_iife?: boolean
-    wrap_func_args?: boolean
+  interface EventListenerOptions {
+    once?: boolean | undefined
   }
 
-  export enum OutputQuoteStyle {
-    PreferDouble = 0,
-    AlwaysSingle = 1,
-    AlwaysDouble = 2,
-    AlwaysOriginal = 3,
+  interface ServerOptions {
+    host?: string | undefined
+    port?: number | undefined
+    backlog?: number | undefined
+    server?: Server | HttpsServer | undefined
+    verifyClient?:
+      | VerifyClientCallbackAsync
+      | VerifyClientCallbackSync
+      | undefined
+    handleProtocols?: (
+      protocols: Set<string>,
+      request: IncomingMessage,
+    ) => string | false
+    path?: string | undefined
+    noServer?: boolean | undefined
+    clientTracking?: boolean | undefined
+    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
+    maxPayload?: number | undefined
+    skipUTF8Validation?: boolean | undefined
+    WebSocket?: typeof WebSocket.WebSocket | undefined
   }
 
-  export interface MinifyOptions {
-    compress?: boolean | CompressOptions
-    ecma?: ECMA
-    enclose?: boolean | string
-    ie8?: boolean
-    keep_classnames?: boolean | RegExp
-    keep_fnames?: boolean | RegExp
-    mangle?: boolean | MangleOptions
-    module?: boolean
-    nameCache?: object
-    format?: FormatOptions
-    /** @deprecated deprecated */
-    output?: FormatOptions
-    parse?: ParseOptions
-    safari10?: boolean
-    sourceMap?: boolean | SourceMapOptions
-    toplevel?: boolean
+  interface AddressInfo {
+    address: string
+    family: string
+    port: number
   }
 
-  export interface MinifyOutput {
-    code?: string
-    map?: object | string
-    decoded_map?: object | null
-  }
+  // WebSocket Server
+  class Server<T extends WebSocket = WebSocket> extends EventEmitter {
+    options: ServerOptions
+    path: string
+    clients: Set<T>
 
-  export interface SourceMapOptions {
-    /** Source map object, 'inline' or source map file content */
-    content?: object | string
-    includeSources?: boolean
-    filename?: string
-    root?: string
-    url?: string | 'inline'
+    constructor(options?: ServerOptions, callback?: () => void)
+
+    address(): AddressInfo | string
+    close(cb?: (err?: Error) => void): void
+    handleUpgrade(
+      request: IncomingMessage,
+      socket: Duplex,
+      upgradeHead: Buffer,
+      callback: (client: T, request: IncomingMessage) => void,
+    ): void
+    shouldHandle(request: IncomingMessage): boolean | Promise<boolean>
+
+    // Events
+    on(
+      event: 'connection',
+      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void,
+    ): this
+    on(event: 'error', cb: (this: Server<T>, error: Error) => void): this
+    on(
+      event: 'headers',
+      cb: (
+        this: Server<T>,
+        headers: string[],
+        request: IncomingMessage,
+      ) => void,
+    ): this
+    on(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
+    on(
+      event: string | symbol,
+      listener: (this: Server<T>, ...args: any[]) => void,
+    ): this
+
+    once(
+      event: 'connection',
+      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void,
+    ): this
+    once(event: 'error', cb: (this: Server<T>, error: Error) => void): this
+    once(
+      event: 'headers',
+      cb: (
+        this: Server<T>,
+        headers: string[],
+        request: IncomingMessage,
+      ) => void,
+    ): this
+    once(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
+    once(
+      event: string | symbol,
+      listener: (this: Server<T>, ...args: any[]) => void,
+    ): this
+
+    off(
+      event: 'connection',
+      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void,
+    ): this
+    off(event: 'error', cb: (this: Server<T>, error: Error) => void): this
+    off(
+      event: 'headers',
+      cb: (
+        this: Server<T>,
+        headers: string[],
+        request: IncomingMessage,
+      ) => void,
+    ): this
+    off(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
+    off(
+      event: string | symbol,
+      listener: (this: Server<T>, ...args: any[]) => void,
+    ): this
+
+    addListener(
+      event: 'connection',
+      cb: (client: T, request: IncomingMessage) => void,
+    ): this
+    addListener(event: 'error', cb: (err: Error) => void): this
+    addListener(
+      event: 'headers',
+      cb: (headers: string[], request: IncomingMessage) => void,
+    ): this
+    addListener(event: 'close' | 'listening', cb: () => void): this
+    addListener(
+      event: string | symbol,
+      listener: (...args: any[]) => void,
+    ): this
+
+    removeListener(event: 'connection', cb: (client: T) => void): this
+    removeListener(event: 'error', cb: (err: Error) => void): this
+    removeListener(
+      event: 'headers',
+      cb: (headers: string[], request: IncomingMessage) => void,
+    ): this
+    removeListener(event: 'close' | 'listening', cb: () => void): this
+    removeListener(
+      event: string | symbol,
+      listener: (...args: any[]) => void,
+    ): this
   }
+
+  const WebSocketServer: typeof Server
+  interface WebSocketServer extends Server {}
+  const WebSocket: typeof WebSocketAlias
+  interface WebSocket extends WebSocketAlias {}
+
+  // WebSocket stream
+  function createWebSocketStream(
+    websocket: WebSocket,
+    options?: DuplexOptions,
+  ): Duplex
+}
+
+type WebSocketCustomListener<T> = (data: T, client: WebSocketClient) => void;
+interface WebSocketServer extends HotChannel {
+    /**
+     * Listen on port and host
+     */
+    listen(): void;
+    /**
+     * Get all connected clients.
+     */
+    clients: Set<WebSocketClient>;
+    /**
+     * Disconnect all clients and terminate the server.
+     */
+    close(): Promise<void>;
+    /**
+     * 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.
+     */
+    off: WebSocket.Server['off'] & {
+        (event: string, listener: Function): void;
+    };
 }
-
-interface TerserOptions extends Terser.MinifyOptions {
+interface WebSocketClient extends HotChannelClient {
     /**
-     * Vite-specific option to specify the max number of workers to spawn
-     * when minifying files with terser.
-     *
-     * @default number of CPUs minus 1
+     * The raw WebSocket instance
+     * @advanced
      */
-    maxWorkers?: number;
+    socket: WebSocket;
 }
 
-interface BuildEnvironmentOptions {
+interface ServerOptions extends CommonServerOptions {
     /**
-     * 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)
-     *
-     * 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
-     *
-     * Another special value is 'esnext' - which only performs minimal transpiling
-     * (for minification compat) and assumes native dynamic imports support.
-     *
-     * For custom targets, see https://esbuild.github.io/api/#target and
-     * https://esbuild.github.io/content-types/#javascript for more details.
-     * @default 'modules'
+     * Configure HMR-specific options (port, host, path & protocol)
      */
-    target?: 'modules' | esbuild_TransformOptions['target'] | false;
+    hmr?: HmrOptions | boolean;
     /**
-     * whether to inject module preload polyfill.
-     * Note: does not apply to library mode.
-     * @default true
-     * @deprecated use `modulePreload.polyfill` instead
+     * Do not start the websocket connection.
+     * @experimental
      */
-    polyfillModulePreload?: boolean;
+    ws?: false;
     /**
-     * Configure module preload
-     * Note: does not apply to library mode.
-     * @default true
+     * Warm-up files to transform and cache the results in advance. This improves the
+     * initial page load during server starts and prevents transform waterfalls.
      */
-    modulePreload?: boolean | ModulePreloadOptions;
+    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[];
+    };
     /**
-     * Directory relative from `root` where build output will be placed. If the
-     * directory exists, it will be removed before the build.
-     * @default 'dist'
+     * chokidar watch options or null to disable FS watching
+     * https://github.com/paulmillr/chokidar#api
      */
-    outDir?: string;
+    watch?: WatchOptions | null;
     /**
-     * Directory relative from `outDir` where the built js/css/image assets will
-     * be placed.
-     * @default 'assets'
+     * Create Vite dev server to be used as a middleware in an existing server
+     * @default false
      */
-    assetsDir?: string;
+    middlewareMode?: boolean | {
+        /**
+         * Parent server instance to attach to
+         *
+         * This is needed to proxy WebSocket connections to the parent server.
+         */
+        server: HttpServer;
+    };
     /**
-     * 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.
-     * @default 4096
+     * Options for files served via '/\@fs/'.
      */
-    assetsInlineLimit?: number | ((filePath: string, content: Buffer) => boolean | undefined);
+    fs?: FileSystemServeOptions;
     /**
-     * Whether to code-split CSS. When enabled, CSS in async chunks will be
-     * inlined as strings in the chunk and inserted via dynamically created
-     * style tags when the chunk is loaded.
+     * Origin for the generated asset URLs.
+     *
+     * @example `http://127.0.0.1:8080`
+     */
+    origin?: string;
+    /**
+     * Pre-transform known direct imports
      * @default true
      */
-    cssCodeSplit?: boolean;
+    preTransformRequests?: boolean;
     /**
-     * An optional separate target for CSS minification.
-     * As esbuild only supports configuring targets to mainstream
-     * browsers, users may need this option when they are targeting
-     * a niche browser that comes with most modern JavaScript features
-     * but has poor CSS support, e.g. Android WeChat WebView, which
-     * doesn't support the #RGBA syntax.
-     * @default target
+     * 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.
      */
-    cssTarget?: esbuild_TransformOptions['target'] | false;
+    sourcemapIgnoreList?: false | ((sourcePath: string, sourcemapPath: string) => boolean);
     /**
-     * Override CSS minification specifically instead of defaulting to `build.minify`,
-     * so you can configure minification for JS and CSS separately.
-     * @default 'esbuild'
+     * Run HMR tasks, by default the HMR propagation is done in parallel for all environments
+     * @experimental
      */
-    cssMinify?: boolean | 'esbuild' | 'lightningcss';
+    hotUpdateEnvironments?: (server: ViteDevServer, hmr: (environment: DevEnvironment) => Promise<void>) => Promise<void>;
+}
+interface ResolvedServerOptions extends Omit<ServerOptions, 'fs' | 'middlewareMode' | 'sourcemapIgnoreList'> {
+    fs: Required<FileSystemServeOptions>;
+    middlewareMode: NonNullable<ServerOptions['middlewareMode']>;
+    sourcemapIgnoreList: Exclude<ServerOptions['sourcemapIgnoreList'], false | undefined>;
+}
+interface FileSystemServeOptions {
     /**
-     * If `true`, a separate sourcemap file will be created. If 'inline', the
-     * sourcemap will be appended to the resulting output file as data URI.
-     * 'hidden' works like `true` except that the corresponding sourcemap
-     * comments in the bundled files are suppressed.
-     * @default false
+     * Strictly restrict file accessing outside of allowing paths.
+     *
+     * Set to `false` to disable the warning
+     *
+     * @default true
      */
-    sourcemap?: boolean | 'inline' | 'hidden';
+    strict?: boolean;
     /**
-     * Set to `false` to disable minification, or specify the minifier to use.
-     * Available options are 'terser' or 'esbuild'.
-     * @default 'esbuild'
+     * 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.
      */
-    minify?: boolean | 'terser' | 'esbuild';
+    allow?: string[];
     /**
-     * Options for terser
-     * https://terser.org/docs/api-reference#minify-options
+     * Restrict accessing files that matches the patterns.
      *
-     * In addition, you can also pass a `maxWorkers: number` option to specify the
-     * max number of workers to spawn. Defaults to the number of CPUs minus 1.
+     * This will have higher priority than `allow`.
+     * picomatch patterns are supported.
+     *
+     * @default ['.env', '.env.*', '*.crt', '*.pem']
      */
-    terserOptions?: TerserOptions;
+    deny?: string[];
     /**
-     * Will be merged with internal rollup options.
-     * https://rollupjs.org/configuration-options/
+     * Enable caching of fs calls. It is enabled by default if no custom watch ignored patterns are provided.
+     *
+     * @experimental
+     * @default undefined
      */
-    rollupOptions?: RollupOptions;
+    cachedChecks?: boolean;
+}
+type ServerHook = (this: void, server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>;
+type HttpServer = http.Server | Http2SecureServer;
+interface ViteDevServer {
     /**
-     * Options to pass on to `@rollup/plugin-commonjs`
+     * The resolved vite config object
      */
-    commonjsOptions?: RollupCommonJSOptions;
+    config: ResolvedConfig;
     /**
-     * Options to pass on to `@rollup/plugin-dynamic-import-vars`
+     * 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
      */
-    dynamicImportVarsOptions?: RollupDynamicImportVarsOptions;
+    middlewares: Connect.Server;
     /**
-     * Whether to write bundle to disk
-     * @default true
+     * native Node http server instance
+     * will be null in middleware mode
      */
-    write?: boolean;
+    httpServer: HttpServer | null;
     /**
-     * Empty outDir on write.
-     * @default true when outDir is a sub directory of project root
+     * chokidar watcher instance
+     * https://github.com/paulmillr/chokidar#api
      */
-    emptyOutDir?: boolean | null;
+    watcher: FSWatcher;
     /**
-     * Copy the public directory to outDir on write.
-     * @default true
+     * web socket server with `send(payload)` method
      */
-    copyPublicDir?: boolean;
+    ws: WebSocketServer;
     /**
-     * Whether to emit a .vite/manifest.json under assets 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.
-     *
-     * Example:
+     * HMR broadcaster that can be used to send custom HMR messages to the client
      *
-     * ```json
-     * {
-     *   "main.js": {
-     *     "file": "main.68fe3fad.js",
-     *     "css": "main.e6b63442.css",
-     *     "imports": [...],
-     *     "dynamicImports": [...]
-     *   }
-     * }
-     * ```
-     * @default false
+     * Always sends a message to at least a WebSocket client. Any third party can
+     * add a channel to the broadcaster to process messages
      */
-    manifest?: boolean | string;
+    hot: HotBroadcaster;
     /**
-     * Produce SSR oriented build. Note this requires specifying SSR entry via
-     * `rollupOptions.input`.
-     * @default false
+     * 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 & Record<string, never>), DevEnvironment>;
+    /**
+     * 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.
      */
-    ssr?: boolean | string;
+    warmupRequest(url: string, options?: TransformOptions): Promise<void>;
     /**
-     * Generate SSR manifest for determining style links and asset preload
-     * directives in production.
-     * @default false
+     * Apply vite built-in HTML transforms and any plugin HTML transforms.
      */
-    ssrManifest?: boolean | string;
+    transformIndexHtml(url: string, html: string, originalUrl?: string): Promise<string>;
     /**
-     * Emit assets during SSR.
-     * @default false
-     * @deprecated use emitAssets
+     * Transform module code into SSR format.
+     * TODO: expose this to any environment?
      */
-    ssrEmitAssets?: boolean;
+    ssrTransform(code: string, inMap: SourceMap | {
+        mappings: '';
+    } | null, url: string, originalCode?: string): Promise<TransformResult | null>;
     /**
-     * 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.
+     * Load a given URL as an instantiated module for SSR.
      */
-    emitAssets?: boolean;
+    ssrLoadModule(url: string, opts?: {
+        fixStacktrace?: boolean;
+    }): Promise<Record<string, any>>;
     /**
-     * Set to false to disable reporting compressed chunk sizes.
-     * Can slightly improve build speed.
-     * @default true
+     * Returns a fixed version of the given stack
      */
-    reportCompressedSize?: boolean;
+    ssrRewriteStacktrace(stack: string): string;
     /**
-     * Adjust chunk size warning limit (in kB).
-     * @default 500
+     * Mutates the given SSR error by rewriting the stacktrace
      */
-    chunkSizeWarningLimit?: number;
+    ssrFixStacktrace(e: Error): void;
     /**
-     * Rollup watch options
-     * https://rollupjs.org/configuration-options/#watch
-     * @default null
+     * 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.
      */
-    watch?: WatcherOptions | null;
+    reloadModule(module: ModuleNode): Promise<void>;
     /**
-     * create the Build Environment instance
+     * Triggers HMR for an environment module in the module graph.
+     * If `hmr` is false, this is a no-op.
      */
-    createEnvironment?: (builder: ViteBuilder, name: string) => Promise<BuildEnvironment> | BuildEnvironment;
-}
-interface BuildOptions extends BuildEnvironmentOptions {
+    reloadEnvironmentModule(module: EnvironmentModuleNode): Promise<void>;
     /**
-     * Build in library mode. The value should be the global name of the lib in
-     * UMD mode. This will produce esm + cjs + umd bundle formats with default
-     * configurations that are suitable for distributing libraries.
-     * @default false
+     * Start the server.
      */
-    lib?: LibraryOptions | false;
-}
-interface LibraryOptions {
+    listen(port?: number, isRestart?: boolean): Promise<ViteDevServer>;
     /**
-     * Path of library entry
+     * Stop the server.
      */
-    entry: InputOption;
+    close(): Promise<void>;
     /**
-     * The name of the exposed global variable. Required when the `formats` option includes
-     * `umd` or `iife`
+     * Print server urls
      */
-    name?: string;
+    printUrls(): void;
     /**
-     * Output bundle formats
-     * @default ['es', 'umd']
+     * Bind CLI shortcuts
      */
-    formats?: LibraryFormats[];
+    bindCLIShortcuts(options?: BindCLIShortcutsOptions<ViteDevServer>): void;
     /**
-     * The name of the package file output. The default file name is the name option
-     * of the project package.json. It can also be defined as a function taking the
-     * format as an argument.
+     * Restart the server.
+     *
+     * @param forceOptimize - force the optimizer to re-bundle, same as --force cli flag
      */
-    fileName?: string | ((format: ModuleFormat, entryName: string) => string);
-}
-type LibraryFormats = 'es' | 'cjs' | 'umd' | 'iife';
-interface ModulePreloadOptions {
+    restart(forceOptimize?: boolean): Promise<void>;
     /**
-     * Whether to inject a module preload polyfill.
-     * Note: does not apply to library mode.
-     * @default true
+     * Open browser
      */
-    polyfill?: boolean;
+    openBrowser(): void;
     /**
-     * Resolve the list of dependencies to preload for a given dynamic import
-     * @experimental
+     * 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.
      */
-    resolveDependencies?: ResolveModulePreloadDependenciesFn;
-}
-interface ResolvedModulePreloadOptions {
-    polyfill: boolean;
-    resolveDependencies?: ResolveModulePreloadDependenciesFn;
-}
-type ResolveModulePreloadDependenciesFn = (filename: string, deps: string[], context: {
-    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.
- * Returns a Promise containing the build result.
- */
-declare function build(inlineConfig?: InlineConfig): Promise<RollupOutput | RollupOutput[] | RollupWatcher>;
-type RenderBuiltAssetUrl = (filename: string, type: {
-    type: 'asset' | 'public';
-    hostId: string;
-    hostType: 'js' | 'css' | 'html';
-    ssr: boolean;
-}) => string | {
-    relative?: boolean;
-    runtime?: string;
-} | undefined;
-declare class BuildEnvironment extends Environment {
-    mode: "build";
-    builder: ViteBuilder;
-    constructor(builder: ViteBuilder, name: string, setup?: {
-        options?: EnvironmentOptions;
-    });
-}
-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>;
+    waitForRequestsIdle: (ignoredId?: string) => Promise<void>;
 }
-type ResolvedBuilderOptions = Required<BuilderOptions>;
-interface BuilderInlineConfig extends Omit<InlineConfig, 'plugins'> {
-    plugins?: () => PluginOption[];
+interface ResolvedServerUrls {
+    local: string[];
+    network: string[];
 }
-declare function createViteBuilder(builderOptions?: BuilderOptions, defaultBuilderInlineConfig?: BuilderInlineConfig): Promise<ViteBuilder>;
+declare function createServer(inlineConfig?: InlineConfig): Promise<ViteDevServer>;
 
 interface ESBuildOptions extends esbuild_TransformOptions {
     include?: string | RegExp | string[] | RegExp[];
@@ -2978,14 +3037,13 @@ interface ResolvePluginOptions {
     tryPrefix?: string;
     preferRelative?: boolean;
     isRequire?: boolean;
-    nodeCompatible?: boolean;
     webCompatible?: boolean;
     isFromTsImporter?: boolean;
     tryEsmOnly?: boolean;
     scan?: boolean;
     ssrOptimizeCheck?: boolean;
     /**
-     * @deprecated environment.options are used instead
+     * @deprecated environment.config are used instead
      */
     ssrConfig?: SSROptions;
 }
@@ -3044,6 +3102,7 @@ type LightningCSSOptions = {
   pseudoClasses?: PseudoClasses
   unusedSymbols?: string[]
   cssModules?: CSSModulesConfig
+  errorRecovery?: boolean
 }
 
 interface CSSOptions {
@@ -3082,7 +3141,6 @@ interface CSSOptions {
      * Enables css sourcemaps during dev
      * @default false
      * @experimental
-     * @deprecated use dev.sourcemap instead
      */
     devSourcemap?: boolean;
     /**
@@ -3116,7 +3174,7 @@ interface PreprocessCSSResult {
 /**
  * @experimental
  */
-declare function preprocessCSS(code: string, filename: string, config: ResolvedConfig, environment?: Environment): Promise<PreprocessCSSResult>;
+declare function preprocessCSS(code: string, filename: string, config: ResolvedConfig): Promise<PreprocessCSSResult>;
 declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;
 
 interface HtmlTagDescriptor {
@@ -3187,22 +3245,81 @@ 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.
+ * 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.
  */
-type PluginEnvironment = DevEnvironment | BuildEnvironment;
-interface PluginContext extends rollup.PluginContext {
-    environment?: PluginEnvironment;
+interface PluginContextExtension {
+    /**
+     * Vite-specific environment instance
+     */
+    environment: Environment;
+}
+interface HotUpdatePluginContext {
+    environment: DevEnvironment;
+}
+interface PluginContext extends rollup.PluginContext, PluginContextExtension {
 }
-interface TransformPluginContext extends rollup.TransformPluginContext {
-    environment?: PluginEnvironment;
+interface ResolveIdPluginContext extends rollup.PluginContext, PluginContextExtension {
 }
+interface TransformPluginContext extends rollup.TransformPluginContext, PluginContextExtension {
+}
+declare module 'rollup' {
+    interface PluginContext 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: ResolveIdPluginContext, 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>;
+    /**
+     * 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;
     /**
      * Enforce plugin invocation tier similar to webpack loaders. Hooks ordering
      * is still subject to the `order` property in the hook object.
@@ -3221,6 +3338,11 @@ 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
+     */
+    applyToEnvironment?: (environment: Environment) => boolean;
     /**
      * 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
@@ -3281,12 +3403,6 @@ 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
@@ -3297,41 +3413,20 @@ interface Plugin<A = any> extends rollup.Plugin<A> {
      *   the descriptors.
      *
      * - The hook can also return an empty array and then perform custom updates
-     *   by sending a custom hmr payload via server.hot.send().
+     *   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.
      */
-    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>;
+    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[]>;
 
 interface JsonOptions {
     /**
@@ -3348,18 +3443,9 @@ interface JsonOptions {
 }
 
 type SSRTarget = 'node' | 'webworker';
-type SsrDepOptimizationOptions = DepOptimizationConfig;
-/**
- * @deprecated use environments.ssr
- */
+type SsrDepOptimizationConfig = DepOptimizationConfig;
 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
@@ -3372,7 +3458,6 @@ interface SSROptions {
      * }
      *
      * @default 'node'
-     * @deprecated use environment.webCompatible
      */
     target?: SSRTarget;
     /**
@@ -3382,12 +3467,8 @@ interface SSROptions {
      * During dev:
      *   explicit no external CJS dependencies are optimized by default
      * @experimental
-     * @deprecated
-     */
-    optimizeDeps?: SsrDepOptimizationOptions;
-    /**
-     * @deprecated
      */
+    optimizeDeps?: SsrDepOptimizationConfig;
     resolve?: {
         /**
          * Conditions that are used in the plugin pipeline. The default value is the root config's `resolve.conditions`.
@@ -3395,21 +3476,28 @@ interface SSROptions {
          * 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;
+    optimizeDeps: SsrDepOptimizationConfig;
+}
+
+interface FutureDeprecationWarningsOptions {
+    pluginHookHandleHotUpdate?: boolean;
+    pluginHookSsrArgument?: boolean;
+    serverModuleGraph?: boolean;
+    serverHot?: boolean;
+    serverTransformRequest?: boolean;
+    ssrLoadModule?: boolean;
 }
 
 interface ConfigEnv {
@@ -3443,17 +3531,17 @@ declare function defineConfig(config: UserConfig): UserConfig;
 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 CreateDevEnvironmentContext {
+    ws: WebSocketServer;
+}
 interface DevEnvironmentOptions {
     /**
-     * The files to be pre-transformed. Supports glob patterns.
+     * Files to be pre-transformed. Supports glob patterns.
      */
-    warmup?: {
-        files: string[];
-    };
+    warmup?: string[];
     /**
      * Pre-transform known direct imports
-     * @default true
+     * defaults to true for the client environment, false for the rest
      */
     preTransformRequests?: boolean;
     /**
@@ -3477,11 +3565,11 @@ interface DevEnvironmentOptions {
     /**
      * Optimize deps config
      */
-    optimizeDeps?: DepOptimizationConfig;
+    optimizeDeps?: DepOptimizationOptions;
     /**
      * create the Dev Environment instance
      */
-    createEnvironment?: (server: ViteDevServer, name: string) => Promise<DevEnvironment> | DevEnvironment;
+    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
@@ -3489,24 +3577,44 @@ interface DevEnvironmentOptions {
      * @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 = Required<Omit<DevEnvironmentOptions, 'createEnvironment'>> & {
-    createEnvironment: ((server: ViteDevServer, name: string) => Promise<DevEnvironment> | DevEnvironment) | undefined;
-};
+type ResolvedDevEnvironmentOptions = Required<DevEnvironmentOptions>;
 type EnvironmentResolveOptions = 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';
     /**
      * Runtime Compatibility
      * Temporal options, we should remove these in favor of fine-grained control
      */
-    nodeCompatible?: boolean;
     webCompatible?: boolean;
+    /**
+     * Should Vite inject timestamp if module is invalidated
+     * Disabling this will break built-in HMR support
+     * @experimental
+     * @default true
+     */
+    injectInvalidationTimestamp?: boolean;
 }
 interface EnvironmentOptions extends SharedEnvironmentOptions {
     /**
@@ -3520,13 +3628,15 @@ interface EnvironmentOptions extends SharedEnvironmentOptions {
 }
 type ResolvedEnvironmentResolveOptions = Required<EnvironmentResolveOptions>;
 type ResolvedEnvironmentOptions = {
+    define?: Record<string, any>;
     resolve: ResolvedEnvironmentResolveOptions;
-    nodeCompatible: boolean;
+    consumer: 'client' | 'server';
     webCompatible: boolean;
+    injectInvalidationTimestamp: boolean;
     dev: ResolvedDevEnvironmentOptions;
     build: ResolvedBuildEnvironmentOptions;
 };
-type DefaultEnvironmentOptions = Omit<EnvironmentOptions, 'build' | 'nodeCompatible' | 'webCompatible'> & {
+type DefaultEnvironmentOptions = Omit<EnvironmentOptions, 'build' | 'consumer' | 'webCompatible' | 'injectInvalidationTimestamp'> & {
     build?: BuildOptions;
 };
 interface UserConfig extends DefaultEnvironmentOptions {
@@ -3565,11 +3675,6 @@ interface UserConfig extends DefaultEnvironmentOptions {
      * 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.
      */
@@ -3615,6 +3720,10 @@ interface UserConfig extends DefaultEnvironmentOptions {
      * @experimental
      */
     experimental?: ExperimentalOptions;
+    /**
+     * Options to opt-in to future behavior
+     */
+    future?: FutureOptions;
     /**
      * Legacy options
      *
@@ -3696,6 +3805,14 @@ interface HTMLOptions {
      */
     cspNonce?: string;
 }
+interface FutureOptions {
+    /**
+     * Emit warning messages for deprecated/will-deprecated features at runtime.
+     *
+     * Setting to `true` to enable all warnings
+     */
+    deprecationWarnings?: boolean | FutureDeprecationWarningsOptions;
+}
 interface ExperimentalOptions {
     /**
      * Append fake `&lang.(ext)` when queries are specified, to preserve the file extension for following plugins to process.
@@ -3741,7 +3858,10 @@ interface LegacyOptions {
 }
 interface ResolvedWorkerOptions {
     format: 'es' | 'iife';
-    plugins: (bundleChain: string[]) => Promise<Plugin[]>;
+    plugins: (bundleChain: string[]) => Promise<{
+        plugins: Plugin[];
+        config: ResolvedConfig;
+    }>;
     rollupOptions: RollupOptions;
 }
 interface InlineConfig extends UserConfig {
@@ -3788,7 +3908,7 @@ interface PluginHookUtils {
     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, patchConfig?: ((config: ResolvedConfig) => void) | undefined, patchPlugins?: ((resolvedPlugins: Plugin[]) => void) | undefined): 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<{
     path: string;
@@ -3796,9 +3916,16 @@ declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, c
     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;
 
-declare function createNodeDevEnvironment(server: ViteDevServer, name: string, options?: DevEnvironmentSetup): DevEnvironment;
+declare function createNodeDevEnvironment(name: string, config: ResolvedConfig, context: DevEnvironmentContext): DevEnvironment;
 
 /**
  * @experimental
@@ -3812,9 +3939,9 @@ interface ServerModuleRunnerOptions extends Omit<ModuleRunnerOptions, 'root' | '
         logger?: ModuleRunnerHmr['logger'];
     };
     /**
-     * Provide a custom module runner. This controls how the code is executed.
+     * Provide a custom module evaluator. This controls how the code is executed.
      */
-    runner?: ModuleEvaluator;
+    evaluator?: ModuleEvaluator;
 }
 /**
  * Create an instance of the Vite SSR runtime that support HMR.
@@ -3827,21 +3954,30 @@ declare function createServerModuleRunner(environment: DevEnvironment, options?:
  * @experimental
  */
 declare class ServerHMRConnector implements ModuleRunnerHMRConnection {
+    private hotChannel;
     private handlers;
-    private hmrChannel;
     private hmrClient;
     private connected;
-    constructor(server: ViteDevServer);
+    constructor(hotChannel: ServerHotChannel);
     isReady(): boolean;
     send(message: string): void;
-    onUpdate(handler: (payload: HMRPayload) => void): void;
+    onUpdate(handler: (payload: HotPayload) => void): void;
+}
+
+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 isCSSRequest: (request: string) => boolean;
 /**
- * @deprecated use build.rollupOutput.manualChunks or framework specific configuration
+ * @deprecated use build.rollupOptions.output.manualChunks or framework specific configuration
  */
 declare class SplitVendorChunkCache {
     cache: Map<string, boolean>;
@@ -3849,13 +3985,13 @@ declare class SplitVendorChunkCache {
     reset(): void;
 }
 /**
- * @deprecated use build.rollupOutput.manualChunks or framework specific configuration
+ * @deprecated use build.rollupOptions.output.manualChunks or framework specific configuration
  */
 declare function splitVendorChunk(options?: {
     cache?: SplitVendorChunkCache;
 }): GetManualChunk;
 /**
- * @deprecated use build.rollupOutput.manualChunks or framework specific configuration
+ * @deprecated use build.rollupOptions.output.manualChunks or framework specific configuration
  */
 declare function splitVendorChunkPlugin(): Plugin;
 
@@ -3890,6 +4026,7 @@ declare function searchForWorkspaceRoot(current: string, root?: string): string;
  * Check if the url is allowed to be served, via the `server.fs` config.
  */
 declare function isFileServingAllowed(url: string, server: ViteDevServer): boolean;
+declare function isFileLoadingAllowed(config: ResolvedConfig, filePath: string): boolean;
 
 declare function loadEnv(mode: string, envDir: string, prefixes?: string | string[]): Record<string, string>;
 declare function resolveEnvPrefix({ envPrefix, }: UserConfig): string[];
@@ -3907,4 +4044,4 @@ interface ManifestChunk {
     dynamicImports?: string[];
 }
 
-export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type AwaitWriteFinishOptions, type BindCLIShortcutsOptions, BuildEnvironment, type BuildEnvironmentOptions, 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 ResolvedBuildEnvironmentOptions, 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 };
+export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type AwaitWriteFinishOptions, type BindCLIShortcutsOptions, BuildEnvironment, type BuildEnvironmentOptions, type BuildOptions, type BuilderOptions, type CLIShortcut, type CSSModulesOptions, type CSSOptions, type CommonServerOptions, type ConfigEnv, Connect, type CorsOptions, type CorsOrigin, type DepOptimizationConfig, type DepOptimizationMetadata, type DepOptimizationOptions, DevEnvironment, type DevEnvironmentContext, type DevEnvironmentOptions, type ESBuildOptions, type ESBuildTransformResult, type Environment, 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 HotChannel, type HotChannelClient, type HotUpdateOptions, 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 Manifest, type ManifestChunk, type MapToFunction, type AnymatchMatcher as Matcher, ModuleGraph, ModuleNode, type ModulePreloadOptions, type ModuleRunnerTransformOptions, type OptimizedDepInfo, type Plugin, 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 ResolvedBuildEnvironmentOptions, type ResolvedBuildOptions, type ResolvedCSSOptions, type ResolvedConfig, type ResolvedDevEnvironmentOptions, 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 ServerHotChannel, type ServerModuleRunnerOptions, type ServerOptions, SplitVendorChunkCache, type SsrDepOptimizationConfig, Terser, type TerserOptions, type TransformOptions, type TransformResult, type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, type ViteBuilder, type ViteDevServer, type WatchOptions, WebSocket, WebSocketAlias, type WebSocketClient, type WebSocketCustomListener, WebSocketServer, build, buildErrorMessage, createBuilder, createFilter, createIdResolver, createLogger, createNodeDevEnvironment, createServer, createServerModuleRunner, defineConfig, fetchModule, formatPostcssSourceMap, isCSSRequest, isFileLoadingAllowed, isFileServingAllowed, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, ssrTransform as moduleRunnerTransform, normalizePath, optimizeDeps, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rollupVersion, searchForWorkspaceRoot, send, sortUserPlugins, splitVendorChunk, splitVendorChunkPlugin, transformWithEsbuild, VERSION as version };