vite 6.0.0-alpha.0 → 6.0.0-alpha.10

package/dist/node/index.d.ts

@@ -632,6 +632,7 @@ interface Logger {
 interface LogOptions {
     clear?: boolean;
     timestamp?: boolean;
+    environment?: string;
 }
 interface LogErrorOptions extends LogOptions {
     error?: Error | RollupError | null;
@@ -787,6 +788,29 @@ type CLIShortcut<Server = ViteDevServer | PreviewServer> = {
  * https://github.com/preactjs/wmr/blob/main/packages/wmr/src/lib/rollup-plugin-container.js
  */
 
+interface BoundedPluginContainer {
+    options: InputOptions;
+    buildStart(options: InputOptions): Promise<void>;
+    resolveId(id: string, importer: string | undefined, options?: {
+        attributes?: Record<string, string>;
+        custom?: CustomPluginOptions;
+        skip?: Set<Plugin>;
+        isEntry?: boolean;
+    }): Promise<PartialResolvedId | null>;
+    transform(code: string, id: string, options?: {
+        inMap?: SourceDescription['map'];
+    }): Promise<{
+        code: string;
+        map: SourceMap | {
+            mappings: '';
+        } | null;
+    }>;
+    load(id: string, options?: {}): Promise<LoadResult | null>;
+    watchChange(id: string, change: {
+        event: 'create' | 'update' | 'delete';
+    }): Promise<void>;
+    close(): Promise<void>;
+}
 interface PluginContainer {
     options: InputOptions;
     buildStart(options: InputOptions): Promise<void>;
@@ -1353,9 +1377,11 @@ declare namespace WebSocket {
 }
 
 declare class Environment {
+    #private;
     name: string;
     config: ResolvedConfig;
     options: ResolvedEnvironmentOptions;
+    get plugins(): BoundedPlugin[];
     get logger(): Logger;
     constructor(name: string, config: ResolvedConfig, options?: ResolvedEnvironmentOptions);
 }
@@ -1370,8 +1396,14 @@ interface FetchModuleOptions {
  */
 declare function fetchModule(environment: DevEnvironment, url: string, importer?: string, options?: FetchModuleOptions): Promise<FetchResult>;
 
+declare class ScanEnvironment extends Environment {
+    mode: "scan";
+    get pluginContainer(): BoundedPluginContainer;
+    init(): Promise<void>;
+}
+
 type ExportsData = {
-    hasImports: boolean;
+    hasModuleSyntax: boolean;
     exports: readonly string[];
     jsxLoader?: boolean;
 };
@@ -1531,11 +1563,6 @@ interface DepOptimizationMetadata {
      */
     depInfoList: OptimizedDepInfo[];
 }
-/**
- * Scan and optimize dependencies within a project.
- * Used by Vite CLI when running `vite optimize`.
- */
-declare function optimizeDeps(environment: Environment, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
 
 declare class RemoteEnvironmentTransport {
     private readonly options;
@@ -1548,16 +1575,19 @@ declare class RemoteEnvironmentTransport {
 
 interface DevEnvironmentSetup {
     hot?: false | HMRChannel;
+    watcher?: FSWatcher;
     options?: EnvironmentOptions;
     runner?: FetchModuleOptions & {
         transport?: RemoteEnvironmentTransport;
     };
+    depsOptimizer?: DepsOptimizer;
 }
 declare class DevEnvironment extends Environment {
     mode: "dev";
     moduleGraph: EnvironmentModuleGraph;
-    server: ViteDevServer;
+    watcher?: FSWatcher;
     depsOptimizer?: DepsOptimizer;
+    get pluginContainer(): BoundedPluginContainer;
     /**
      * HMR channel for this environment. If not provided or disabled,
      * it will be a noop channel that does nothing.
@@ -1566,18 +1596,21 @@ declare class DevEnvironment extends Environment {
      * 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;
-    });
+    constructor(name: string, config: ResolvedConfig, setup?: DevEnvironmentSetup);
+    init(): Promise<void>;
     fetchModule(id: string, importer?: string): 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>;
 }
 
 interface TransformResult {
@@ -1585,6 +1618,7 @@ interface TransformResult {
     map: SourceMap | {
         mappings: '';
     } | null;
+    ssr?: boolean;
     etag?: string;
     deps?: string[];
     dynamicDeps?: string[];
@@ -2023,11 +2057,12 @@ interface ViteDevServer {
      *
      * Always sends a message to at least a WebSocket client. Any third party can
      * add a channel to the broadcaster to process messages
-     * @deprecated use `environments.get(id).hot` instead
+     * @deprecated use `environment.hot` instead
      */
     hot: HMRBroadcaster;
     /**
      * Rollup plugin container that can run plugin hooks on a given file
+     * @deprecated use `environment.pluginContainer` instead
      */
     pluginContainer: PluginContainer;
     /**
@@ -2037,7 +2072,7 @@ interface ViteDevServer {
     /**
      * Module graph that tracks the import relationships, url to file mapping
      * and hmr state.
-     * @deprecated use environment module graphs instead
+     * @deprecated use `environment.moduleGraph` instead
      */
     moduleGraph: ModuleGraph;
     /**
@@ -2064,6 +2099,7 @@ interface ViteDevServer {
     transformIndexHtml(url: string, html: string, originalUrl?: string): Promise<string>;
     /**
      * Transform module code into SSR format.
+     * TODO: expose this to any environment?
      */
     ssrTransform(code: string, inMap: SourceMap | {
         mappings: '';
@@ -2124,6 +2160,7 @@ interface ViteDevServer {
      * 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
+     * @deprecated use environment.waitForRequestsIdle()
      */
     waitForRequestsIdle: (ignoredId?: string) => Promise<void>;
 }
@@ -2627,7 +2664,7 @@ interface TerserOptions extends Terser.MinifyOptions {
     maxWorkers?: number;
 }
 
-interface BuildOptions {
+interface BuildEnvironmentOptions {
     /**
      * Compatibility transform target. The transform is performed with esbuild
      * and the lowest supported target is es2015/es6. Note this only handles
@@ -2770,13 +2807,6 @@ interface BuildOptions {
      * @default false
      */
     manifest?: boolean | string;
-    /**
-     * 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
-     */
-    lib?: LibraryOptions | false;
     /**
      * Produce SSR oriented build. Note this requires specifying SSR entry via
      * `rollupOptions.input`.
@@ -2822,7 +2852,16 @@ interface BuildOptions {
     /**
      * create the Build Environment instance
      */
-    createEnvironment?: (builder: ViteBuilder, name: string) => BuildEnvironment;
+    createEnvironment?: (name: string, config: ResolvedConfig) => Promise<BuildEnvironment> | BuildEnvironment;
+}
+interface BuildOptions extends BuildEnvironmentOptions {
+    /**
+     * 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
+     */
+    lib?: LibraryOptions | false;
 }
 interface LibraryOptions {
     /**
@@ -2868,6 +2907,9 @@ type ResolveModulePreloadDependenciesFn = (filename: string, deps: string[], con
     hostId: string;
     hostType: 'html' | 'js';
 }) => string[];
+interface ResolvedBuildEnvironmentOptions extends Required<Omit<BuildEnvironmentOptions, 'polyfillModulePreload'>> {
+    modulePreload: false | ResolvedModulePreloadOptions;
+}
 interface ResolvedBuildOptions extends Required<Omit<BuildOptions, 'polyfillModulePreload'>> {
     modulePreload: false | ResolvedModulePreloadOptions;
 }
@@ -2887,25 +2929,25 @@ type RenderBuiltAssetUrl = (filename: string, type: {
 } | undefined;
 declare class BuildEnvironment extends Environment {
     mode: "build";
-    builder: ViteBuilder;
-    constructor(builder: ViteBuilder, name: string, setup?: {
+    constructor(name: string, config: ResolvedConfig, setup?: {
         options?: EnvironmentOptions;
     });
+    init(): Promise<void>;
 }
 interface ViteBuilder {
     environments: Record<string, BuildEnvironment>;
     config: ResolvedConfig;
-    buildEnvironments(): Promise<void>;
+    buildApp(): Promise<void>;
     build(environment: BuildEnvironment): Promise<RollupOutput | RollupOutput[] | RollupWatcher>;
 }
 interface BuilderOptions {
-    buildEnvironments?: (builder: ViteBuilder, build: (environment: BuildEnvironment) => Promise<void>) => Promise<void>;
+    sharedConfigBuild?: boolean;
+    sharedPlugins?: boolean;
+    entireApp?: boolean;
+    buildApp?: (builder: ViteBuilder) => Promise<void>;
 }
 type ResolvedBuilderOptions = Required<BuilderOptions>;
-interface BuilderInlineConfig extends Omit<InlineConfig, 'plugins'> {
-    plugins?: () => PluginOption[];
-}
-declare function createViteBuilder(builderOptions?: BuilderOptions, defaultBuilderInlineConfig?: BuilderInlineConfig): Promise<ViteBuilder>;
+declare function createBuilder(inlineConfig?: InlineConfig): Promise<ViteBuilder>;
 
 interface ESBuildOptions extends esbuild_TransformOptions {
     include?: string | RegExp | string[] | RegExp[];
@@ -2919,7 +2961,7 @@ interface ESBuildOptions extends esbuild_TransformOptions {
 type ESBuildTransformResult = Omit<esbuild_TransformResult, 'map'> & {
     map: SourceMap;
 };
-declare function transformWithEsbuild(code: string, filename: string, options?: esbuild_TransformOptions, inMap?: object): Promise<ESBuildTransformResult>;
+declare function transformWithEsbuild(code: string, filename: string, options?: esbuild_TransformOptions, inMap?: object, root?: string, watcher?: any): Promise<ESBuildTransformResult>;
 
 interface FsUtils {
     existsSync: (path: string) => boolean;
@@ -3190,14 +3232,36 @@ type IndexHtmlTransform = IndexHtmlTransformHook | {
  * or a build environment. Plugins can use this.environment.mode === 'dev' to
  * check if they have access to dev specific APIs.
  */
-type PluginEnvironment = DevEnvironment | BuildEnvironment;
+type PluginEnvironment = DevEnvironment | BuildEnvironment | ScanEnvironment;
 interface PluginContext extends rollup.PluginContext {
     environment?: PluginEnvironment;
 }
+interface ResolveIdPluginContext extends rollup.PluginContext {
+    environment?: PluginEnvironment;
+}
 interface TransformPluginContext extends rollup.TransformPluginContext {
     environment?: PluginEnvironment;
 }
-interface Plugin<A = any> extends rollup.Plugin<A> {
+/**
+ * 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
+ * managementfor for environment specific plugins.
+ * Environment Plugins are closer to regular rollup plugins. They can't define
+ * app level hooks (like config, configResolved, configureServer, etc).
+ */
+type ModifyFunctionContext<Function_, NewContext> = Function_ extends (this: infer This, ...parameters: infer Arguments) => infer Return ? (this: NewContext, ...parameters: Arguments) => Return : never;
+type ModifyObjectHookContext<Handler, Object_ extends {
+    handler: Handler;
+}, NewContext> = Object_ & {
+    handler: ModifyFunctionContext<Handler, NewContext>;
+};
+type ModifyHookContext<Hook, NewContext> = Hook extends {
+    handler: infer Handler;
+} ? ModifyObjectHookContext<Handler, Hook, NewContext> : ModifyFunctionContext<Hook, NewContext>;
+interface BasePlugin<A = any> extends rollup.Plugin<A> {
     /**
      * Enforce plugin invocation tier similar to webpack loaders. Hooks ordering
      * is still subject to the `order` property in the hook object.
@@ -3212,6 +3276,61 @@ interface Plugin<A = any> extends rollup.Plugin<A> {
      * - vite build post plugins
      */
     enforce?: 'pre' | 'post';
+    /**
+     * Perform custom handling of HMR updates.
+     * The handler receives a context containing changed filename, timestamp, a
+     * list of modules affected by the file change, and the dev server instance.
+     *
+     * - The hook can return a filtered list of modules to narrow down the update.
+     *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
+     *   the descriptors.
+     *
+     * - The hook can also return an empty array and then perform custom updates
+     *   by sending a custom hmr payload via server.hot.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: ResolveIdPluginContext, 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>;
+    buildStart?: ModifyHookContext<rollup.Plugin<A>['buildStart'], PluginContext>;
+    generateBundle?: ModifyHookContext<rollup.Plugin<A>['generateBundle'], PluginContext>;
+    renderChunk?: ModifyHookContext<rollup.Plugin<A>['renderChunk'], PluginContext>;
+}
+type BoundedPlugin<A = any> = BasePlugin<A>;
+interface Plugin<A = any> extends BasePlugin<A> {
+    /**
+     * 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;
     /**
      * Apply the plugin only for serve or build, or on certain conditions.
      */
@@ -3282,51 +3401,19 @@ interface Plugin<A = any> extends rollup.Plugin<A> {
      * 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
-     * list of modules affected by the file change, and the dev server instance.
-     *
-     * - The hook can return a filtered list of modules to narrow down the update.
-     *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
-     *   the descriptors.
-     *
-     * - The hook can also return an empty array and then perform custom updates
-     *   by sending a custom hmr payload via server.hot.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>;
 }
 type HookHandler<T> = T extends ObjectHook<infer H> ? H : T;
 type PluginWithRequiredHook<K extends keyof Plugin> = Plugin & {
     [P in K]: NonNullable<Plugin[P]>;
 };
+type BoundedPluginConstructor = {
+    (environment: PluginEnvironment): BoundedPluginOption;
+    sharedDuringBuild?: boolean;
+};
+type MaybeBoundedPlugin = BoundedPlugin | false | null | undefined;
+type BoundedPluginOption = MaybeBoundedPlugin | BoundedPluginOption[] | Promise<MaybeBoundedPlugin | BoundedPluginOption[]>;
+type MaybePlugin = Plugin | BoundedPluginConstructor | false | null | undefined;
+type PluginOption = MaybePlugin | PluginOption[] | Promise<MaybePlugin | PluginOption[]>;
 
 interface JsonOptions {
     /**
@@ -3438,17 +3525,14 @@ 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 DevOptions {
+interface DevEnvironmentOptions {
     /**
-     * The files to be pre-transformed. Supports glob patterns.
+     * Files tßo 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;
     /**
@@ -3476,10 +3560,23 @@ interface DevOptions {
     /**
      * create the Dev Environment instance
      */
-    createEnvironment?: (server: ViteDevServer, name: string) => DevEnvironment;
+    createEnvironment?: (name: string, config: ResolvedConfig) => Promise<DevEnvironment> | DevEnvironment;
+    /**
+     * For environments that support a full-reload, like the client, we can short-circuit when
+     * restarting the server throwing early to stop processing current files. We avoided this for
+     * SSR requests. Maybe this is no longer needed.
+     * @experimental
+     */
+    recoverable?: boolean;
+    /**
+     * For environments associated with a module runner.
+     * By default it is true for the client environment and false for non-client environments.
+     * This option can also be used instead of the removed config.experimental.skipSsrTransform.
+     */
+    moduleRunnerTransform?: boolean;
 }
-type ResolvedDevOptions = Required<Omit<DevOptions, 'createEnvironment'>> & {
-    createEnvironment: ((server: ViteDevServer, name: string) => DevEnvironment) | undefined;
+type ResolvedDevEnvironmentOptions = Required<Omit<DevEnvironmentOptions, 'createEnvironment'>> & {
+    createEnvironment: ((name: string, config: ResolvedConfig) => Promise<DevEnvironment> | DevEnvironment) | undefined;
 };
 type EnvironmentResolveOptions = ResolveOptions & {
     alias?: AliasOptions;
@@ -3495,26 +3592,36 @@ interface SharedEnvironmentOptions {
      */
     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 {
     /**
      * Dev specific options
      */
-    dev?: DevOptions;
+    dev?: DevEnvironmentOptions;
     /**
      * Build specific options
      */
-    build?: BuildOptions;
+    build?: BuildEnvironmentOptions;
 }
 type ResolvedEnvironmentResolveOptions = Required<EnvironmentResolveOptions>;
 type ResolvedEnvironmentOptions = {
     resolve: ResolvedEnvironmentResolveOptions;
     nodeCompatible: boolean;
     webCompatible: boolean;
-    dev: ResolvedDevOptions;
-    build: ResolvedBuildOptions;
+    injectInvalidationTimestamp: boolean;
+    dev: ResolvedDevEnvironmentOptions;
+    build: ResolvedBuildEnvironmentOptions;
+};
+type DefaultEnvironmentOptions = Omit<EnvironmentOptions, 'build' | 'nodeCompatible' | 'webCompatible'> & {
+    build?: BuildOptions;
 };
-type DefaultEnvironmentOptions = Omit<EnvironmentOptions, 'nodeCompatible' | 'webCompatible'>;
 interface UserConfig extends DefaultEnvironmentOptions {
     /**
      * Project root directory. Can be an absolute path, or a path relative from
@@ -3727,7 +3834,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 {
@@ -3752,10 +3862,11 @@ type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'css' | 'assetsInclu
         alias: Alias[];
     };
     plugins: readonly Plugin[];
+    rawPlugins: readonly (Plugin | BoundedPluginConstructor)[];
     css: ResolvedCSSOptions;
     esbuild: ESBuildOptions | false;
     server: ResolvedServerOptions;
-    dev: ResolvedDevOptions;
+    dev: ResolvedDevEnvironmentOptions;
     builder: ResolvedBuilderOptions;
     build: ResolvedBuildOptions;
     preview: ResolvedPreviewOptions;
@@ -3774,7 +3885,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?: ((plugins: (Plugin | BoundedPluginConstructor)[]) => 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;
@@ -3784,7 +3895,7 @@ declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, c
 
 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, options?: DevEnvironmentSetup): DevEnvironment;
 
 /**
  * @experimental
@@ -3798,9 +3909,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.
@@ -3813,11 +3924,11 @@ declare function createServerModuleRunner(environment: DevEnvironment, options?:
  * @experimental
  */
 declare class ServerHMRConnector implements ModuleRunnerHMRConnection {
-    private handlers;
     private hmrChannel;
+    private handlers;
     private hmrClient;
     private connected;
-    constructor(server: ViteDevServer);
+    constructor(hmrChannel: ServerHMRChannel);
     isReady(): boolean;
     send(message: string): void;
     onUpdate(handler: (payload: HMRPayload) => void): void;
@@ -3874,6 +3985,7 @@ declare function searchForWorkspaceRoot(current: string, root?: string): string;
 
 /**
  * Check if the url is allowed to be served, via the `server.fs` config.
+ * @deprecate use isFileLoadingAllowed
  */
 declare function isFileServingAllowed(url: string, server: ViteDevServer): boolean;
 
@@ -3893,4 +4005,4 @@ interface ManifestChunk {
     dynamicImports?: string[];
 }
 
-export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type AwaitWriteFinishOptions, type BindCLIShortcutsOptions, BuildEnvironment, type BuildOptions, type CLIShortcut, type CSSModulesOptions, type CSSOptions, type CommonServerOptions, type ConfigEnv, Connect, type CorsOptions, type CorsOrigin, type DepOptimizationConfig, type DepOptimizationMetadata, type DepOptimizationOptions, DevEnvironment, type DevEnvironmentSetup, type ESBuildOptions, type ESBuildTransformResult, EnvironmentModuleGraph, EnvironmentModuleNode, type ExperimentalOptions, type ExportsData, FSWatcher, type FetchModuleOptions, type FileSystemServeOptions, type FilterPattern, type HMRBroadcaster, type HMRBroadcasterClient, type HMRChannel, type HTMLOptions, type HmrContext, type HmrOptions, type HookHandler, type HotUpdateContext, type HtmlTagDescriptor, HttpProxy, type IndexHtmlTransform, type IndexHtmlTransformContext, type IndexHtmlTransformHook, type IndexHtmlTransformResult, type InlineConfig, type InternalResolveOptions, type JsonOptions, type LegacyOptions, type LibraryFormats, type LibraryOptions, type LightningCSSOptions, type LogErrorOptions, type LogLevel, type LogOptions, type LogType, type Logger, type LoggerOptions, type Manifest, type ManifestChunk, type MapToFunction, type AnymatchMatcher as Matcher, ModuleGraph, ModuleNode, type ModulePreloadOptions, type OptimizedDepInfo, type Plugin, type PluginContainer, type PluginHookUtils, type PluginOption, type PreprocessCSSResult, type PreviewOptions, type PreviewServer, type PreviewServerHook, type ProxyOptions, RemoteEnvironmentTransport, type RenderBuiltAssetUrl, type ResolveFn, type ResolveModulePreloadDependenciesFn, type ResolveOptions, type ResolvedBuildOptions, type ResolvedCSSOptions, type ResolvedConfig, type ResolvedModulePreloadOptions, type ResolvedPreviewOptions, type ResolvedSSROptions, type ResolvedServerOptions, type ResolvedServerUrls, type ResolvedUrl, type ResolvedWorkerOptions, type ResolverFunction, type ResolverObject, type RollupCommonJSOptions, type RollupDynamicImportVarsOptions, type SSROptions, type SSRTarget, type SendOptions, type ServerHMRChannel, ServerHMRConnector, type ServerHook, type ServerModuleRunnerOptions, type ServerOptions, SplitVendorChunkCache, type SsrDepOptimizationOptions, Terser, type TerserOptions, type TransformOptions, type TransformResult, type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, type ViteDevServer, type WatchOptions, WebSocket, WebSocketAlias, type WebSocketClient, type WebSocketCustomListener, WebSocketServer, build, buildErrorMessage, createFilter, createLogger, createNodeDevEnvironment, createServer, createServerModuleRunner, createViteBuilder, defineConfig, fetchModule, formatPostcssSourceMap, isCSSRequest, isFileServingAllowed, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, normalizePath, optimizeDeps, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rollupVersion, searchForWorkspaceRoot, send, sortUserPlugins, splitVendorChunk, splitVendorChunkPlugin, transformWithEsbuild, VERSION as version };
+export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type AwaitWriteFinishOptions, type BindCLIShortcutsOptions, type BoundedPlugin, type BoundedPluginConstructor, 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 DevEnvironmentOptions, 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 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 ServerModuleRunnerOptions, type ServerOptions, SplitVendorChunkCache, type SsrDepOptimizationOptions, 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, createLogger, createNodeDevEnvironment, createServer, createServerModuleRunner, defineConfig, fetchModule, formatPostcssSourceMap, isCSSRequest, isFileServingAllowed, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, normalizePath, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rollupVersion, searchForWorkspaceRoot, send, sortUserPlugins, splitVendorChunk, splitVendorChunkPlugin, transformWithEsbuild, VERSION as version };