vite 8.2.1 → 8.3.0-beta.0

package/dist/node/index.d.ts

@@ -1,36 +1,37 @@
 /// <reference types="node" />
 import { t as ModuleRunnerTransport } from "./chunks/moduleRunnerTransport.js";
-import { ConnectedPayload, CustomPayload, CustomPayload as hmrPayload_CustomPayload, ErrorPayload, FullReloadPayload, HMRPayload, HotPayload, HotPayload as hmrPayload_HotPayload, PrunePayload, Update, UpdatePayload } from "#types/hmrPayload";
 import { CustomEventMap, InferCustomEventPayload, InferCustomEventPayload as hmrPayload_InferCustomEventPayload, InvalidatePayload } from "#types/customEvent";
+import { ConnectedPayload, CustomPayload, CustomPayload as hmrPayload_CustomPayload, ErrorPayload, FullReloadPayload, HMRPayload, HotPayload, HotPayload as hmrPayload_HotPayload, PrunePayload, Update, UpdatePayload } from "#types/hmrPayload";
 import * as Rolldown from "rolldown";
 import { CustomPluginOptions, ExistingRawSourceMap, FunctionPluginHooks, ImportKind, InputOption, InputOptions, LoadResult, MinimalPluginContext, ModuleFormat, ModuleInfo, ModuleType, ModuleTypeFilter, ObjectHook, OutputBundle, OutputChunk, OutputOptions, PartialResolvedId, PluginContext, PluginContextMeta, ResolveIdResult, RolldownOptions, RolldownOutput, RolldownWatcher, RollupError, RollupLog, SourceDescription, SourceMap, SourceMapInput, TransformPluginContext, VERSION as rolldownVersion, WatcherOptions } from "rolldown";
 import { parseAst as parseAst$1, parseAstAsync as parseAstAsync$1 } from "rolldown/parseAst";
 import * as Rollup from "#types/internal/rollupTypeCompat";
 import { esmExternalRequirePlugin } from "rolldown/plugins";
 import { ESTree, MinifyOptions, MinifyResult, ParseResult, ParserOptions, TransformOptions as rolldown_utils_TransformOptions, TransformResult as rolldown_utils_TransformResult, Visitor, VisitorObject, minify, minifySync, parse, parseSync } from "rolldown/utils";
+import { DepsOptimizerEsbuildOptions, EsbuildTarget, EsbuildTransformOptions, EsbuildTransformOptions as esbuildOptions_EsbuildTransformOptions, EsbuildTransformResult } from "#types/internal/esbuildOptions";
+import { ChunkMetadata, CustomPluginOptionsVite } from "#types/metadata";
 import * as http from "node:http";
 import { Agent, ClientRequest, ClientRequestArgs, OutgoingHttpHeaders, ServerResponse } from "node:http";
 import { Http2SecureServer } from "node:http2";
-import * as fs from "node:fs";
 import { EventEmitter } from "node:events";
+import * as fs from "node:fs";
 import { Server as HttpsServer, ServerOptions as HttpsServerOptions } from "node:https";
 import * as net from "node:net";
 import { Duplex, DuplexOptions, Stream } from "node:stream";
 import { FetchFunction, FetchFunctionOptions, FetchResult, FetchResult as moduleRunner_FetchResult, ModuleEvaluator, ModuleRunner, ModuleRunnerHmr, ModuleRunnerOptions } from "vite/module-runner";
-import { DepsOptimizerEsbuildOptions, EsbuildTarget, EsbuildTransformOptions, EsbuildTransformOptions as esbuildOptions_EsbuildTransformOptions, EsbuildTransformResult } from "#types/internal/esbuildOptions";
 import { SecureContextOptions } from "node:tls";
 import { URL as url_URL } from "node:url";
 import { ZlibOptions } from "node:zlib";
-import { ChunkMetadata, CustomPluginOptionsVite } from "#types/metadata";
+import { DevWatchOptions } from "rolldown/experimental";
 import { Terser, TerserMinifyOptions } from "#types/internal/terserOptions";
 import * as PostCSS from "postcss";
 import { ProcessOptions, Processor, Transformer } from "postcss";
-import { LightningCSSOptions, LightningCSSOptions as lightningcssOptions_LightningCSSOptions } from "#types/internal/lightningcssOptions";
 import { LessPreprocessorBaseOptions, SassModernPreprocessBaseOptions, StylusPreprocessorBaseOptions } from "#types/internal/cssPreprocessorOptions";
+import { LightningCSSOptions, LightningCSSOptions as lightningcssOptions_LightningCSSOptions } from "#types/internal/lightningcssOptions";
 import { withFilter } from "rolldown/filter";
 import { GeneralImportGlobOptions, ImportGlobFunction, ImportGlobOptions, KnownAsTypeMap, KnownQueryTypeMap } from "#types/importGlob";
 //#endregion
-//#region ../../node_modules/.pnpm/@vitejs+devtools@0.4.10_crossws@0.4.10_srvx@0.12.5_typescript@6.0.3_valibot@1.4.2_vite@packages+vite/node_modules/@vitejs/devtools/dist/cli-commands.d.ts
+//#region ../../node_modules/.pnpm/@vitejs+devtools@0.5.1_@devframes+json-render@0.9.7_srvx@0.12.7_vite@packages+vite/node_modules/@vitejs/devtools/dist/cli-commands.d.ts
 //#region src/node/cli-commands.d.ts
 interface StartOptions {
   root?: string;
@@ -40,7 +41,7 @@ interface StartOptions {
   open?: boolean;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@vitejs+devtools@0.4.10_crossws@0.4.10_srvx@0.12.5_typescript@6.0.3_valibot@1.4.2_vite@packages+vite/node_modules/@vitejs/devtools/dist/config.d.ts
+//#region ../../node_modules/.pnpm/@vitejs+devtools@0.5.1_@devframes+json-render@0.9.7_srvx@0.12.7_vite@packages+vite/node_modules/@vitejs/devtools/dist/config.d.ts
 //#region src/node/config.d.ts
 interface DevToolsConfig extends Partial<StartOptions> {
   enabled: boolean;
@@ -114,148 +115,409 @@ type AliasOptions = readonly Alias[] | {
   [find: string]: string;
 };
 //#endregion
-//#region src/types/anymatch.d.ts
-type AnymatchFn = (testString: string) => boolean;
-type AnymatchPattern = string | RegExp | AnymatchFn;
-type AnymatchMatcher = AnymatchPattern | AnymatchPattern[];
-//#endregion
-//#region src/types/chokidar.d.ts
-declare class FSWatcher extends EventEmitter implements fs.FSWatcher {
-  options: WatchOptions;
-  /**
-   * Constructs a new FSWatcher instance with optional WatchOptions parameter.
-   */
-  constructor(options?: WatchOptions);
-  /**
-   * When called, requests that the Node.js event loop not exit so long as the fs.FSWatcher is active.
-   * Calling watcher.ref() multiple times will have no effect.
-   */
-  ref(): this;
-  /**
-   * When called, the active fs.FSWatcher object will not require the Node.js event loop to remain active.
-   * If there is no other activity keeping the event loop running, the process may exit before the fs.FSWatcher object's callback is invoked.
-   * Calling watcher.unref() multiple times will have no effect.
-   */
-  unref(): this;
-  /**
-   * Add files, directories, or glob patterns for tracking. Takes an array of strings or just one
-   * string.
-   */
-  add(paths: string | ReadonlyArray<string>): this;
-  /**
-   * Stop watching files, directories, or glob patterns. Takes an array of strings or just one
-   * string.
-   */
-  unwatch(paths: string | ReadonlyArray<string>): this;
-  /**
-   * Returns an object representing all the paths on the file system being watched by this
-   * `FSWatcher` instance. The object's keys are all the directories (using absolute paths unless
-   * the `cwd` option was used), and the values are arrays of the names of the items contained in
-   * each directory.
-   */
-  getWatched(): {
-    [directory: string]: string[];
-  };
-  /**
-   * Removes all listeners from watched files.
-   */
-  close(): Promise<void>;
-  on(event: 'add' | 'addDir' | 'change', listener: (path: string, stats?: fs.Stats) => void): this;
-  on(event: 'all', listener: (eventName: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir', path: string, stats?: fs.Stats) => void): this;
+//#region src/node/assetSource.d.ts
+/**
+ * Defines which attributes of an HTML element should be treated as asset sources.
+ * Used in `html.additionalAssetSources` configuration.
+ */
+interface HtmlAssetSource {
   /**
-   * Error occurred
+   * Attributes that contain a single asset URL.
+   * @example ['src', 'data-src-dark']
    */
-  on(event: 'error', listener: (error: Error) => void): this;
+  srcAttributes?: string[];
   /**
-   * Exposes the native Node `fs.FSWatcher events`
+   * Attributes that contain srcset-format URLs.
+   * @example ['srcset', 'imagesrcset']
    */
-  on(event: 'raw', listener: (eventName: string, path: string, details: any) => void): this;
+  srcsetAttributes?: string[];
   /**
-   * Fires when the initial scan is complete
+   * Called before handling an attribute to determine if it should be processed.
    */
-  on(event: 'ready', listener: () => void): this;
-  on(event: 'unlink' | 'unlinkDir', listener: (path: string) => void): this;
-  on(event: string, listener: (...args: any[]) => void): this;
+  filter?: (data: HtmlAssetSourceFilterData) => boolean;
 }
-interface WatchOptions {
-  /**
-   * Indicates whether the process should continue to run as long as files are being watched. If
-   * set to `false` when using `fsevents` to watch, no more events will be emitted after `ready`,
-   * even if the process continues to run.
-   */
-  persistent?: boolean;
-  /**
-   * ([anymatch](https://github.com/micromatch/anymatch)-compatible definition) Defines files/paths to
-   * be ignored. The whole relative or absolute path is tested, not just filename. If a function
-   * with two arguments is provided, it gets called twice per path - once with a single argument
-   * (the path), second time with two arguments (the path and the
-   * [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object of that path).
-   */
-  ignored?: AnymatchMatcher;
+interface HtmlAssetSourceFilterData {
+  key: string;
+  value: string;
+  attributes: Record<string, string>;
+}
+//#endregion
+//#region src/types/commonjs.d.ts
+
+interface RollupCommonJSOptions {
   /**
-   * If set to `false` then `add`/`addDir` events are also emitted for matching paths while
-   * instantiating the watching as chokidar discovers these file paths (before the `ready` event).
+   * 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
    */
-  ignoreInitial?: boolean;
+  include?: string | RegExp | readonly (string | RegExp)[];
   /**
-   * When `false`, only the symlinks themselves will be watched for changes instead of following
-   * the link references and bubbling events through the link's path.
+   * 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
    */
-  followSymlinks?: boolean;
+  exclude?: string | RegExp | readonly (string | RegExp)[];
   /**
-   * The base directory from which watch `paths` are to be derived. Paths emitted with events will
-   * be relative to this.
+   * 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' ]
    */
-  cwd?: string;
+  extensions?: ReadonlyArray<string>;
   /**
-   * If set to true then the strings passed to .watch() and .add() are treated as literal path
-   * names, even if they look like globs.
-   *
+   * If true then uses of `global` won't be dealt with by this plugin
    * @default false
    */
-  disableGlobbing?: boolean;
+  ignoreGlobal?: boolean;
   /**
-   * Whether to use fs.watchFile (backed by polling), or fs.watch. If polling leads to high CPU
-   * utilization, consider setting this to `false`. It is typically necessary to **set this to
-   * `true` to successfully watch files over a network**, and it may be necessary to successfully
-   * watch files in other non-standard situations. Setting to `true` explicitly on OS X overrides
-   * the `useFsEvents` default.
+   * If false, skips source map generation for CommonJS modules. This will
+   * improve performance.
+   * @default true
    */
-  usePolling?: boolean;
+  sourceMap?: boolean;
   /**
-   * Whether to use the `fsevents` watching interface if available. When set to `true` explicitly
-   * and `fsevents` is available this supersedes the `usePolling` setting. When set to `false` on
-   * OS X, `usePolling: true` becomes the default.
+   * 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
    */
-  useFsEvents?: boolean;
+  ignoreDynamicRequires?: boolean;
   /**
-   * If relying upon the [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object that
-   * may get passed with `add`, `addDir`, and `change` events, set this to `true` to ensure it is
-   * provided even in cases where it wasn't already available from the underlying watch events.
+   * 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
    */
-  alwaysStat?: boolean;
+  transformMixedEsModules?: boolean;
   /**
-   * If set, limits how many levels of subdirectories will be traversed.
+   * 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"
    */
-  depth?: number;
+  strictRequires?: boolean | string | RegExp | readonly (string | RegExp)[];
   /**
-   * Interval of file system polling.
+   * Sometimes you have to leave require statements unconverted. Pass an array
+   * containing the IDs or a `id => boolean` function.
+   * @default []
    */
-  interval?: number;
+  ignore?: ReadonlyArray<string> | ((id: string) => boolean);
   /**
-   * Interval of file system polling for binary files. ([see list of binary extensions](https://gi
-   * thub.com/sindresorhus/binary-extensions/blob/master/binary-extensions.json))
+   * 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
    */
-  binaryInterval?: number;
+  ignoreTryCatch?: boolean | 'remove' | ReadonlyArray<string> | ((id: string) => boolean | 'remove');
   /**
-   *  Indicates whether to watch files that don't have read permissions if possible. If watching
-   *  fails due to `EPERM` or `EACCES` with this set to `true`, the errors will be suppressed
-   *  silently.
+   * 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
    */
-  ignorePermissionErrors?: boolean;
+  esmExternals?: boolean | ReadonlyArray<string> | ((id: string) => boolean);
   /**
-   * `true` if `useFsEvents` and `usePolling` are `false`. Automatically filters out artifacts
-   * that occur when using editors that use "atomic writes" instead of writing directly to the
+   * 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;
+}
+//#endregion
+//#region src/types/dynamicImportVars.d.ts
+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)[];
+  /**
+   * @deprecated This option is no-op and will be removed in future versions.
+   */
+  warnOnError?: boolean;
+}
+//#endregion
+//#region src/types/anymatch.d.ts
+type AnymatchFn = (testString: string) => boolean;
+type AnymatchPattern = string | RegExp | AnymatchFn;
+type AnymatchMatcher = AnymatchPattern | AnymatchPattern[];
+//#endregion
+//#region src/types/chokidar.d.ts
+declare class FSWatcher extends EventEmitter implements fs.FSWatcher {
+  options: WatchOptions;
+  /**
+   * Constructs a new FSWatcher instance with optional WatchOptions parameter.
+   */
+  constructor(options?: WatchOptions);
+  /**
+   * When called, requests that the Node.js event loop not exit so long as the fs.FSWatcher is active.
+   * Calling watcher.ref() multiple times will have no effect.
+   */
+  ref(): this;
+  /**
+   * When called, the active fs.FSWatcher object will not require the Node.js event loop to remain active.
+   * If there is no other activity keeping the event loop running, the process may exit before the fs.FSWatcher object's callback is invoked.
+   * Calling watcher.unref() multiple times will have no effect.
+   */
+  unref(): this;
+  /**
+   * Add files, directories, or glob patterns for tracking. Takes an array of strings or just one
+   * string.
+   */
+  add(paths: string | ReadonlyArray<string>): this;
+  /**
+   * Stop watching files, directories, or glob patterns. Takes an array of strings or just one
+   * string.
+   */
+  unwatch(paths: string | ReadonlyArray<string>): this;
+  /**
+   * Returns an object representing all the paths on the file system being watched by this
+   * `FSWatcher` instance. The object's keys are all the directories (using absolute paths unless
+   * the `cwd` option was used), and the values are arrays of the names of the items contained in
+   * each directory.
+   */
+  getWatched(): {
+    [directory: string]: string[];
+  };
+  /**
+   * Removes all listeners from watched files.
+   */
+  close(): Promise<void>;
+  on(event: 'add' | 'addDir' | 'change', listener: (path: string, stats?: fs.Stats) => void): this;
+  on(event: 'all', listener: (eventName: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir', path: string, stats?: fs.Stats) => void): this;
+  /**
+   * Error occurred
+   */
+  on(event: 'error', listener: (error: Error) => void): this;
+  /**
+   * Exposes the native Node `fs.FSWatcher events`
+   */
+  on(event: 'raw', listener: (eventName: string, path: string, details: any) => void): this;
+  /**
+   * Fires when the initial scan is complete
+   */
+  on(event: 'ready', listener: () => void): this;
+  on(event: 'unlink' | 'unlinkDir', listener: (path: string) => void): this;
+  on(event: string, listener: (...args: any[]) => void): this;
+}
+interface WatchOptions {
+  /**
+   * Indicates whether the process should continue to run as long as files are being watched. If
+   * set to `false` when using `fsevents` to watch, no more events will be emitted after `ready`,
+   * even if the process continues to run.
+   */
+  persistent?: boolean;
+  /**
+   * ([anymatch](https://github.com/micromatch/anymatch)-compatible definition) Defines files/paths to
+   * be ignored. The whole relative or absolute path is tested, not just filename. If a function
+   * with two arguments is provided, it gets called twice per path - once with a single argument
+   * (the path), second time with two arguments (the path and the
+   * [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object of that path).
+   */
+  ignored?: AnymatchMatcher;
+  /**
+   * If set to `false` then `add`/`addDir` events are also emitted for matching paths while
+   * instantiating the watching as chokidar discovers these file paths (before the `ready` event).
+   */
+  ignoreInitial?: boolean;
+  /**
+   * When `false`, only the symlinks themselves will be watched for changes instead of following
+   * the link references and bubbling events through the link's path.
+   */
+  followSymlinks?: boolean;
+  /**
+   * The base directory from which watch `paths` are to be derived. Paths emitted with events will
+   * be relative to this.
+   */
+  cwd?: string;
+  /**
+   * If set to true then the strings passed to .watch() and .add() are treated as literal path
+   * names, even if they look like globs.
+   *
+   * @default false
+   */
+  disableGlobbing?: boolean;
+  /**
+   * Whether to use fs.watchFile (backed by polling), or fs.watch. If polling leads to high CPU
+   * utilization, consider setting this to `false`. It is typically necessary to **set this to
+   * `true` to successfully watch files over a network**, and it may be necessary to successfully
+   * watch files in other non-standard situations. Setting to `true` explicitly on OS X overrides
+   * the `useFsEvents` default.
+   */
+  usePolling?: boolean;
+  /**
+   * Whether to use the `fsevents` watching interface if available. When set to `true` explicitly
+   * and `fsevents` is available this supersedes the `usePolling` setting. When set to `false` on
+   * OS X, `usePolling: true` becomes the default.
+   */
+  useFsEvents?: boolean;
+  /**
+   * If relying upon the [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object that
+   * may get passed with `add`, `addDir`, and `change` events, set this to `true` to ensure it is
+   * provided even in cases where it wasn't already available from the underlying watch events.
+   */
+  alwaysStat?: boolean;
+  /**
+   * If set, limits how many levels of subdirectories will be traversed.
+   */
+  depth?: number;
+  /**
+   * Interval of file system polling.
+   */
+  interval?: number;
+  /**
+   * Interval of file system polling for binary files. ([see list of binary extensions](https://gi
+   * thub.com/sindresorhus/binary-extensions/blob/master/binary-extensions.json))
+   */
+  binaryInterval?: number;
+  /**
+   *  Indicates whether to watch files that don't have read permissions if possible. If watching
+   *  fails due to `EPERM` or `EACCES` with this set to `true`, the errors will be suppressed
+   *  silently.
+   */
+  ignorePermissionErrors?: boolean;
+  /**
+   * `true` if `useFsEvents` and `usePolling` are `false`. Automatically filters out artifacts
+   * that occur when using editors that use "atomic writes" instead of writing directly to the
    * source file. If a file is re-added within 100 ms of being deleted, Chokidar emits a `change`
    * event rather than `unlink` then `add`. If the default of 100 ms does not work well for you,
    * you can override it by setting `atomic` to a custom value, in milliseconds.
@@ -345,6 +607,18 @@ declare namespace Connect {
   }
 }
 //#endregion
+//#region src/shared/forwardConsole.d.ts
+type ForwardConsoleLogLevel = "error" | "warn" | "info" | "log" | "debug" | (string & {});
+interface ForwardConsoleOptions {
+  unhandledErrors?: boolean;
+  logLevels?: ForwardConsoleLogLevel[];
+}
+interface ResolvedForwardConsoleOptions {
+  enabled: boolean;
+  unhandledErrors: boolean;
+  logLevels: ForwardConsoleLogLevel[];
+}
+//#endregion
 //#region ../../node_modules/.pnpm/http-proxy-3@1.23.3_ms@2.1.3/node_modules/http-proxy-3/dist/lib/http-proxy/index.d.ts
 interface ProxyTargetDetailed {
   host: string;
@@ -576,34 +850,6 @@ interface ProxyOptions extends ServerOptions$3 {
   rewriteWsOrigin?: boolean | undefined;
 }
 //#endregion
-//#region src/node/logger.d.ts
-type LogType = "error" | "warn" | "info";
-type LogLevel = LogType | "silent";
-interface Logger {
-  info(msg: string, options?: LogOptions): void;
-  warn(msg: string, options?: LogOptions): void;
-  warnOnce(msg: string, options?: LogOptions): void;
-  error(msg: string, options?: LogErrorOptions): void;
-  clearScreen(type: LogType): void;
-  hasErrorLogged(error: Error | RollupError): boolean;
-  hasWarned: boolean;
-}
-interface LogOptions {
-  clear?: boolean;
-  timestamp?: boolean;
-  environment?: string;
-}
-interface LogErrorOptions extends LogOptions {
-  error?: Error | RollupError | null;
-}
-interface LoggerOptions {
-  prefix?: string;
-  allowClearScreen?: boolean;
-  customLogger?: Logger;
-  console?: Console;
-}
-declare function createLogger(level?: LogLevel, options?: LoggerOptions): Logger;
-//#endregion
 //#region src/node/http.d.ts
 interface CommonServerOptions {
   /**
@@ -704,120 +950,6 @@ interface CorsOptions {
 }
 type CorsOrigin = boolean | string | RegExp | (string | RegExp)[];
 //#endregion
-//#region src/shared/forwardConsole.d.ts
-type ForwardConsoleLogLevel = "error" | "warn" | "info" | "log" | "debug" | (string & {});
-interface ForwardConsoleOptions {
-  unhandledErrors?: boolean;
-  logLevels?: ForwardConsoleLogLevel[];
-}
-interface ResolvedForwardConsoleOptions {
-  enabled: boolean;
-  unhandledErrors: boolean;
-  logLevels: ForwardConsoleLogLevel[];
-}
-//#endregion
-//#region src/node/typeUtils.d.ts
-type RequiredExceptFor<T, K extends keyof T> = Pick<T, K> & Required<Omit<T, K>>;
-//#endregion
-//#region src/node/preview.d.ts
-interface PreviewOptions extends CommonServerOptions {}
-interface ResolvedPreviewOptions extends RequiredExceptFor<PreviewOptions, "host" | "https" | "proxy"> {}
-interface PreviewServer {
-  /**
-   * The resolved vite config object
-   */
-  config: ResolvedConfig;
-  /**
-   * Stop the server.
-   */
-  close(): Promise<void>;
-  /**
-   * A connect app instance.
-   * - Can be used to attach custom middlewares to the preview server.
-   * - Can also be used as the handler function of a custom http server
-   *   or as a middleware in any connect-style Node.js frameworks
-   *
-   * https://github.com/senchalabs/connect#use-middleware
-   */
-  middlewares: Connect.Server;
-  /**
-   * native Node http server instance
-   */
-  httpServer: HttpServer;
-  /**
-   * The resolved urls Vite prints on the CLI (URL-encoded). Returns `null`
-   * if the server is not listening on any port.
-   */
-  resolvedUrls: ResolvedServerUrls | null;
-  /**
-   * Print server urls
-   */
-  printUrls(): void;
-  /**
-   * Bind CLI shortcuts
-   */
-  bindCLIShortcuts(options?: BindCLIShortcutsOptions<PreviewServer>): void;
-}
-type PreviewServerHook = (this: MinimalPluginContextWithoutEnvironment, server: PreviewServer) => (() => void) | void | Promise<(() => void) | void>;
-/**
- * Starts the Vite server in preview mode, to simulate a production deployment
- */
-declare function preview(inlineConfig?: InlineConfig): Promise<PreviewServer>;
-//#endregion
-//#region src/node/shortcuts.d.ts
-type BindCLIShortcutsOptions<Server = ViteDevServer | PreviewServer> = {
-  /**
-   * Print a one-line shortcuts "help" hint to the terminal
-   */
-  print?: boolean;
-  /**
-   * Custom shortcuts to run when a key is pressed. These shortcuts take priority
-   * over the default shortcuts if they have the same keys (except the `h` key).
-   * To disable a default shortcut, define the same key but with `action: undefined`.
-   */
-  customShortcuts?: CLIShortcut<Server>[];
-};
-type CLIShortcut<Server = ViteDevServer | PreviewServer> = {
-  key: string;
-  description: string;
-  action?(server: Server): void | Promise<void>;
-};
-//#endregion
-//#region src/node/baseEnvironment.d.ts
-declare class PartialEnvironment {
-  name: string;
-  getTopLevelConfig(): ResolvedConfig;
-  config: ResolvedConfig & ResolvedEnvironmentOptions;
-  logger: Logger;
-  constructor(name: string, topLevelConfig: ResolvedConfig, options?: ResolvedEnvironmentOptions);
-}
-declare class BaseEnvironment extends PartialEnvironment {
-  get plugins(): readonly Plugin[];
-  constructor(name: string, config: ResolvedConfig, options?: ResolvedEnvironmentOptions);
-}
-/**
- * This class discourages users from inversely checking the `mode`
- * to determine the type of environment, e.g.
- *
- * ```js
- * const isDev = environment.mode !== 'build' // bad
- * const isDev = environment.mode === 'dev'   // good
- * ```
- *
- * You should also not check against `"unknown"` specifically. It's
- * a placeholder for more possible environment types.
- */
-declare class UnknownEnvironment extends BaseEnvironment {
-  mode: "unknown";
-}
-//#endregion
-//#region src/node/optimizer/scan.d.ts
-declare class ScanEnvironment extends BaseEnvironment {
-  mode: "scan";
-  get pluginContainer(): EnvironmentPluginContainer;
-  init(): Promise<void>;
-}
-//#endregion
 //#region src/node/optimizer/index.d.ts
 type ExportsData = {
   hasModuleSyntax: boolean;
@@ -1013,7 +1145,59 @@ interface DepOptimizationMetadata {
  *
  * @deprecated the optimization process runs automatically and does not need to be called
  */
-declare function optimizeDeps(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
+export declare function optimizeDeps(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
+//#endregion
+//#region src/node/server/bundledDev.d.ts
+type MemoryFile = {
+  source: string | Uint8Array;
+  etag?: string;
+};
+declare class MemoryFiles {
+  private files;
+  get size(): number;
+  get(file: string): MemoryFile | undefined;
+  set(file: string, content: MemoryFile | (() => MemoryFile)): void;
+  has(file: string): boolean;
+  clear(): void;
+}
+declare class BundledDev {
+  private environment;
+  private _devEngine;
+  private viteRuntime?;
+  private initialBuildCompleted;
+  private _closed;
+  private clients;
+  private debouncedFullReload;
+  private fullReloadPending;
+  private reloadNeededClientIds;
+  private debouncedReloadNeededFlush;
+  private lastBuildError;
+  memoryFiles: MemoryFiles;
+  constructor(environment: DevEnvironment);
+  private get devEngine();
+  private pendingPayloadFilenames;
+  get hasBuildOutput(): boolean;
+  listen(): Promise<void>;
+  private waitForInitialBuildFinish;
+  private ensureOutputAndFlushReloadNeeded;
+  triggerBundleRegenerationIfStale(): Promise<boolean>;
+  triggerLazyBundling(moduleId: string | null, clientId: string | null): Promise<{
+    code: string;
+    filename: string;
+  } | undefined>;
+  /**
+   * Called by the serving middlewares when the response for a payload completed.
+   * Only delivered payloads are recorded on the server's per-client ship map, so
+   * later chunks may omit a module only if the payload carrying it was delivered.
+   *
+   * Note: the payload filename is unique across all clients.
+   */
+  markPayloadDelivered(filename: string): void;
+  close(): Promise<void>;
+  private storeOutputFiles;
+  private getRolldownOptions;
+  private handleHmrOutput;
+}
 //#endregion
 //#region src/node/server/transformRequest.d.ts
 interface TransformResult {
@@ -1306,79 +1490,187 @@ type ServerHotChannelApi = {
 };
 type ServerHotChannel = HotChannel<ServerHotChannelApi>;
 type NormalizedServerHotChannel = NormalizedHotChannel<ServerHotChannelApi>;
-declare function createServerHotChannel(): ServerHotChannel;
+export declare function createServerHotChannel(): ServerHotChannel;
 //#endregion
-//#region src/types/ws.d.ts
-// 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_URL, options?: WebSocket.ClientOptions | ClientRequestArgs);
-  constructor(address: string | url_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: http.IncomingMessage) => void): this;
-  on(event: 'message', listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this;
+//#region src/node/server/pluginContainer.d.ts
+type SkipInformation = {
+  id: string;
+  importer: string | undefined;
+  plugin: Plugin;
+  called?: boolean;
+};
+declare class EnvironmentPluginContainer<Env extends Environment = Environment> {
+  private _pluginContextMap;
+  private _resolvedRolldownOptions?;
+  private _processesing;
+  private _seenResolves;
+  private _moduleNodeToLoadAddedImports;
+  getSortedPluginHooks: PluginHookUtils["getSortedPluginHooks"];
+  getSortedPlugins: PluginHookUtils["getSortedPlugins"];
+  moduleGraph: EnvironmentModuleGraph | undefined;
+  watchFiles: Set<string>;
+  minimalContext: MinimalPluginContext$1<Env>;
+  private _started;
+  private _buildStartPromise;
+  private _closed;
+  private _updateModuleLoadAddedImports;
+  private _getAddedImports;
+  getModuleInfo(id: string): ModuleInfo | null;
+  private handleHookPromise;
+  get options(): InputOptions;
+  resolveRolldownOptions(): Promise<InputOptions>;
+  private _getPluginContext;
+  private hookParallel;
+  buildStart(_options?: InputOptions): Promise<void>;
+  resolveId(rawId: string, importer?: string | undefined, options?: {
+    kind?: ImportKind;
+    attributes?: Record<string, string>;
+    custom?: CustomPluginOptions;
+    /** @deprecated use `skipCalls` instead */
+    skip?: Set<Plugin>;
+    skipCalls?: readonly SkipInformation[];
+    
+    isEntry?: boolean;
+  }): Promise<PartialResolvedId | null>;
+  load(id: string): Promise<LoadResult | null>;
+  transform(code: string, id: string, options?: {
+    inMap?: SourceDescription["map"];
+    moduleType?: string;
+  }): Promise<{
+    code: string;
+    map: SourceMap | {
+      mappings: "";
+    } | null;
+    moduleType?: ModuleType;
+  }>;
+  watchChange(id: string, change: {
+    event: "create" | "update" | "delete";
+  }): Promise<void>;
+  close(): Promise<void>;
+}
+declare class BasicMinimalPluginContext<Meta = PluginContextMeta> {
+  meta: Meta;
+  private _logger;
+  constructor(meta: Meta, _logger: Logger);
+  get pluginName(): string;
+  debug(rawLog: string | RollupLog | (() => string | RollupLog)): void;
+  info(rawLog: string | RollupLog | (() => string | RollupLog)): void;
+  warn(rawLog: string | RollupLog | (() => string | RollupLog)): void;
+  error(e: string | RollupError): never;
+  private _normalizeRawLog;
+}
+declare class MinimalPluginContext$1<T extends Environment = Environment> extends BasicMinimalPluginContext implements MinimalPluginContext {
+  environment: T;
+  constructor(meta: PluginContextMeta, environment: T);
+}
+declare class PluginContainer {
+  private environments;
+  constructor(environments: Record<string, Environment>);
+  private _getEnvironment;
+  private _getPluginContainer;
+  getModuleInfo(id: string): ModuleInfo | null;
+  get options(): InputOptions;
+  buildStart(_options?: InputOptions): Promise<void>;
+  watchChange(id: string, change: {
+    event: "create" | "update" | "delete";
+  }): Promise<void>;
+  resolveId(rawId: string, importer?: string, options?: {
+    attributes?: Record<string, string>;
+    custom?: CustomPluginOptions;
+    /** @deprecated use `skipCalls` instead */
+    skip?: Set<Plugin>;
+    skipCalls?: readonly SkipInformation[];
+    ssr?: boolean;
+    
+    isEntry?: boolean;
+  }): Promise<PartialResolvedId | null>;
+  load(id: string, options?: {
+    ssr?: boolean;
+  }): Promise<LoadResult | null>;
+  transform(code: string, id: string, options?: {
+    ssr?: boolean;
+    environment?: Environment;
+    inMap?: SourceDescription["map"];
+  }): Promise<{
+    code: string;
+    map: SourceMap | {
+      mappings: "";
+    } | null;
+  }>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/types/ws.d.ts
+// 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_URL, options?: WebSocket.ClientOptions | ClientRequestArgs);
+  constructor(address: string | url_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: http.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: http.IncomingMessage) => void): this;
@@ -1620,58 +1912,6 @@ interface WebSocketClient extends NormalizedHotChannelClient {
   socket: WebSocket;
 }
 //#endregion
-//#region src/node/server/bundledDev.d.ts
-type MemoryFile = {
-  source: string | Uint8Array;
-  etag?: string;
-};
-declare class MemoryFiles {
-  private files;
-  get size(): number;
-  get(file: string): MemoryFile | undefined;
-  set(file: string, content: MemoryFile | (() => MemoryFile)): void;
-  has(file: string): boolean;
-  clear(): void;
-}
-declare class BundledDev {
-  private environment;
-  private _devEngine;
-  private viteRuntime?;
-  private initialBuildCompleted;
-  private _closed;
-  private clients;
-  private debouncedFullReload;
-  private fullReloadPending;
-  private reloadNeededClientIds;
-  private debouncedReloadNeededFlush;
-  private lastBuildError;
-  memoryFiles: MemoryFiles;
-  constructor(environment: DevEnvironment);
-  private get devEngine();
-  private pendingPayloadFilenames;
-  get hasBuildOutput(): boolean;
-  listen(): Promise<void>;
-  private waitForInitialBuildFinish;
-  private ensureOutputAndFlushReloadNeeded;
-  triggerBundleRegenerationIfStale(): Promise<boolean>;
-  triggerLazyBundling(moduleId: string | null, clientId: string | null): Promise<{
-    code: string;
-    filename: string;
-  } | undefined>;
-  /**
-   * Called by the serving middlewares when the response for a payload completed.
-   * Only delivered payloads are recorded on the server's per-client ship map, so
-   * later chunks may omit a module only if the payload carrying it was delivered.
-   *
-   * Note: the payload filename is unique across all clients.
-   */
-  markPayloadDelivered(filename: string): void;
-  close(): Promise<void>;
-  private storeOutputFiles;
-  private getRolldownOptions;
-  private handleHmrOutput;
-}
-//#endregion
 //#region src/node/server/environment.d.ts
 interface DevEnvironmentContext {
   hot: boolean;
@@ -1682,7 +1922,7 @@ interface DevEnvironmentContext {
   };
   depsOptimizer?: DepsOptimizer;
 }
-declare class DevEnvironment extends BaseEnvironment {
+export declare class DevEnvironment extends BaseEnvironment {
   mode: "dev";
   moduleGraph: EnvironmentModuleGraph;
   depsOptimizer?: DepsOptimizer;
@@ -1740,1369 +1980,1197 @@ declare class DevEnvironment extends BaseEnvironment {
   waitForRequestsIdle(ignoredId?: string): Promise<void>;
 }
 //#endregion
-//#region src/types/commonjs.d.ts
-
-interface RollupCommonJSOptions {
+//#region src/node/optimizer/scan.d.ts
+declare class ScanEnvironment extends BaseEnvironment {
+  mode: "scan";
+  get pluginContainer(): EnvironmentPluginContainer;
+  init(): Promise<void>;
+}
+//#endregion
+//#region src/node/environment.d.ts
+type Environment = DevEnvironment | BuildEnvironment | ScanEnvironment | UnknownEnvironment;
+/**
+ * Creates a function that hides the complexities of a WeakMap with an initial value
+ * to implement object metadata. Used by plugins to implement cross hooks per
+ * environment metadata
+ *
+ * @experimental
+ */
+export declare function perEnvironmentState<State>(initial: (environment: Environment) => State): (context: PluginContext) => State;
+//#endregion
+//#region src/node/plugins/html.d.ts
+interface HtmlTagDescriptor {
+  tag: string;
   /**
-   * 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' ]
+   * attribute values will be escaped automatically if needed
    */
-  extensions?: ReadonlyArray<string>;
+  attrs?: Record<string, string | boolean | undefined>;
+  children?: string | HtmlTagDescriptor[];
   /**
-   * If true then uses of `global` won't be dealt with by this plugin
-   * @default false
+   * default: 'head-prepend'
    */
-  ignoreGlobal?: boolean;
+  injectTo?: "head" | "body" | "head-prepend" | "body-prepend";
+}
+type IndexHtmlTransformResult = string | HtmlTagDescriptor[] | {
+  html: string;
+  tags: HtmlTagDescriptor[];
+};
+interface IndexHtmlTransformContext {
   /**
-   * If false, skips source map generation for CommonJS modules. This will
-   * improve performance.
-   * @default true
+   * public path when served
    */
-  sourceMap?: boolean;
+  path: string;
   /**
-   * 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
+   * filename on disk
    */
-  ignoreDynamicRequires?: boolean;
+  filename: string;
+  server?: ViteDevServer;
+  bundle?: OutputBundle;
+  chunk?: OutputChunk;
+  originalUrl?: string;
+}
+type IndexHtmlTransformHook = (this: MinimalPluginContextWithoutEnvironment, html: string, ctx: IndexHtmlTransformContext) => IndexHtmlTransformResult | void | Promise<IndexHtmlTransformResult | void>;
+type IndexHtmlTransform = IndexHtmlTransformHook | {
+  order?: "pre" | "post" | null;
+  handler: IndexHtmlTransformHook;
+};
+//#endregion
+//#region src/node/plugins/pluginFilter.d.ts
+type StringFilter<Value = string | RegExp> = Value | Array<Value> | {
+  include?: Value | Array<Value>;
+  exclude?: Value | Array<Value>;
+};
+//#endregion
+//#region src/node/shortcuts.d.ts
+type BindCLIShortcutsOptions<Server = ViteDevServer | PreviewServer> = {
   /**
-   * 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
+   * Print a one-line shortcuts "help" hint to the terminal
    */
-  transformMixedEsModules?: boolean;
+  print?: 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"
+   * Custom shortcuts to run when a key is pressed. These shortcuts take priority
+   * over the default shortcuts if they have the same keys (except the `h` key).
+   * To disable a default shortcut, define the same key but with `action: undefined`.
    */
-  strictRequires?: boolean | string | RegExp | readonly (string | RegExp)[];
+  customShortcuts?: CLIShortcut<Server>[];
+};
+type CLIShortcut<Server = ViteDevServer | PreviewServer> = {
+  key: string;
+  description: string;
+  action?(server: Server): void | Promise<void>;
+};
+//#endregion
+//#region src/node/typeUtils.d.ts
+type RequiredExceptFor<T, K extends keyof T> = Pick<T, K> & Required<Omit<T, K>>;
+//#endregion
+//#region src/node/preview.d.ts
+interface PreviewOptions extends CommonServerOptions {}
+interface ResolvedPreviewOptions extends RequiredExceptFor<PreviewOptions, "host" | "https" | "proxy"> {}
+interface PreviewServer {
   /**
-   * Sometimes you have to leave require statements unconverted. Pass an array
-   * containing the IDs or a `id => boolean` function.
-   * @default []
+   * The resolved vite config object
    */
-  ignore?: ReadonlyArray<string> | ((id: string) => boolean);
+  config: ResolvedConfig;
   /**
-   * 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
+   * Stop the server.
    */
-  ignoreTryCatch?: boolean | 'remove' | ReadonlyArray<string> | ((id: string) => boolean | 'remove');
+  close(): Promise<void>;
   /**
-   * 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.
+   * A connect app instance.
+   * - Can be used to attach custom middlewares to the preview 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
    *
-   * 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
+   * https://github.com/senchalabs/connect#use-middleware
    */
-  esmExternals?: boolean | ReadonlyArray<string> | ((id: string) => boolean);
+  middlewares: Connect.Server;
   /**
-   * 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
+   * native Node http server instance
    */
-  requireReturnsDefault?: boolean | 'auto' | 'preferred' | 'namespace' | ((id: string) => boolean | 'auto' | 'preferred' | 'namespace');
+  httpServer: HttpServer;
   /**
-   * @default "auto"
+   * The resolved urls Vite prints on the CLI (URL-encoded). Returns `null`
+   * if the server is not listening on any port.
    */
-  defaultIsModuleExports?: boolean | 'auto' | ((id: string) => boolean | 'auto');
+  resolvedUrls: ResolvedServerUrls | null;
   /**
-   * 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/"` -\> `"/"`.
+   * Print server urls
    */
-  dynamicRequireTargets?: string | ReadonlyArray<string>;
+  printUrls(): void;
   /**
-   * 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.
+   * Bind CLI shortcuts
    */
-  dynamicRequireRoot?: string;
+  bindCLIShortcuts(options?: BindCLIShortcutsOptions<PreviewServer>): void;
 }
-//#endregion
-//#region src/types/dynamicImportVars.d.ts
-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)[];
+type PreviewServerHook = (this: MinimalPluginContextWithoutEnvironment, server: PreviewServer) => (() => void) | void | Promise<(() => void) | void>;
+type ClosePreviewServerHook = (this: MinimalPluginContextWithoutEnvironment) => void | Promise<void>;
+/**
+ * Starts the Vite server in preview mode, to simulate a production deployment
+ */
+export declare function preview(inlineConfig?: InlineConfig): Promise<PreviewServer>;
+//#endregion
+//#region src/node/plugin.d.ts
+/**
+ * Vite plugins extends the Rollup plugin interface with a few extra
+ * vite-specific options. A valid vite plugin is also a valid Rollup plugin.
+ * On the contrary, a Rollup plugin may or may NOT be a valid vite universal
+ * plugin, since some Rollup features do not make sense in an unbundled
+ * dev server context. That said, as long as a rollup plugin doesn't have strong
+ * coupling between its bundle phase and output phase hooks then it should
+ * just work (that means, most of them).
+ *
+ * By default, the plugins are run during both serve and build. When a plugin
+ * is applied during serve, it will only run **non output plugin hooks** (see
+ * rollup type definition of {@link rollup#PluginHooks}). You can think of the
+ * dev server as only running `const bundle = rollup.rollup()` but never calling
+ * `bundle.generate()`.
+ *
+ * A plugin that expects to have different behavior depending on serve/build can
+ * export a factory function that receives the command being run via options.
+ *
+ * If a plugin should be applied only for server or build, a function format
+ * config file can be used to conditional determine the plugins to use.
+ *
+ * The current environment can be accessed from the context for the all non-global
+ * hooks (it is not available in config, configResolved, configureServer, etc).
+ * It can be a dev, build, or scan environment.
+ * Plugins can use this.environment.mode === 'dev' to guard for dev specific APIs.
+ */
+interface PluginContextExtension {
   /**
-   * @deprecated This option is no-op and will be removed in future versions.
+   * Vite-specific environment instance
    */
-  warnOnError?: boolean;
+  environment: Environment;
 }
-//#endregion
-//#region src/node/plugins/terser.d.ts
-interface TerserOptions extends TerserMinifyOptions {
+interface PluginContextMetaExtension {
+  viteVersion: string;
+}
+interface ConfigPluginContext extends Omit<MinimalPluginContext, "meta" | "environment"> {
+  meta: Omit<PluginContextMeta, "watchMode">;
+}
+interface MinimalPluginContextWithoutEnvironment extends Omit<MinimalPluginContext, "environment"> {}
+declare module "rolldown" {
+  interface MinimalPluginContext extends PluginContextExtension {}
+  interface PluginContextMeta extends PluginContextMetaExtension {}
+}
+/**
+ * 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 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 Rolldown.Plugin<A> {
   /**
-   * Vite-specific option to specify the max number of workers to spawn
-   * when minifying files with terser.
+   * 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.
    *
-   * @default number of CPUs minus 1
+   * - 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.
    */
-  maxWorkers?: number;
-}
-//#endregion
-//#region src/node/plugins/resolve.d.ts
-interface EnvironmentResolveOptions {
+  hotUpdate?: ObjectHook<(this: MinimalPluginContext & {
+    environment: DevEnvironment;
+  }, options: HotUpdateOptions) => Array<EnvironmentModuleNode> | void | Promise<Array<EnvironmentModuleNode> | void>>;
   /**
-   * @default ['browser', 'module', 'jsnext:main', 'jsnext']
+   * extend hooks with ssr flag
    */
-  mainFields?: string[];
-  conditions?: string[];
-  externalConditions?: string[];
+  resolveId?: ObjectHook<(this: PluginContext, source: string, importer: string | undefined, options: {
+    kind?: ImportKind;
+    custom?: CustomPluginOptions;
+    ssr?: boolean | undefined;
+    
+    isEntry: boolean;
+  }) => Promise<ResolveIdResult> | ResolveIdResult, {
+    filter?: {
+      id?: StringFilter<RegExp>;
+    };
+  }>;
+  load?: ObjectHook<(this: PluginContext, id: string, options?: {
+    ssr?: boolean | undefined;
+  }) => Promise<LoadResult> | LoadResult, {
+    filter?: {
+      id?: StringFilter;
+    };
+  }>;
+  transform?: ObjectHook<(this: TransformPluginContext, code: string, id: string, options?: {
+    moduleType: ModuleType;
+    ssr?: boolean | undefined;
+  }) => Promise<Rolldown.TransformResult> | Rolldown.TransformResult, {
+    filter?: {
+      id?: StringFilter;
+      code?: StringFilter;
+      moduleType?: ModuleTypeFilter;
+    };
+  }>;
   /**
-   * @default ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json']
+   * 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
    */
-  extensions?: string[];
-  dedupe?: string[];
+  sharedDuringBuild?: boolean;
   /**
-   * Prevent listed dependencies from being externalized and will get bundled in build.
-   * Only works in server environments for now. Previously this was `ssr.noExternal`.
+   * Opt-in this plugin into per-environment buildStart and buildEnd during dev.
+   * For backward-compatibility, the buildStart hook is called only once during
+   * dev, for the client environment. Plugins can opt-in to be called
+   * per-environment, aligning with the build hook behavior.
    * @experimental
    */
-  noExternal?: string | RegExp | (string | RegExp)[] | true;
+  perEnvironmentStartEndDuringDev?: boolean;
   /**
-   * Externalize the given dependencies and their transitive dependencies.
-   * Only works in server environments for now. Previously this was `ssr.external`.
+   * Opt-in this plugin into per-environment watchChange during dev.
+   * For backward-compatibility, the watchChange hook is called only once during
+   * dev, for the client environment. Plugins can opt-in to be called
+   * per-environment, aligning with the watchChange hook behavior.
    * @experimental
    */
-  external?: string[] | true;
+  perEnvironmentWatchChangeDuringDev?: boolean;
   /**
-   * Array of strings or regular expressions that indicate what modules are builtin for the environment.
+   * Enforce plugin invocation tier similar to webpack loaders. Hooks ordering
+   * is still subject to the `order` property in the hook object.
+   *
+   * Plugin invocation order:
+   * - alias resolution
+   * - `enforce: 'pre'` plugins
+   * - vite core plugins
+   * - normal plugins
+   * - vite build plugins
+   * - `enforce: 'post'` plugins
+   * - vite build post plugins
    */
-  builtins?: (string | RegExp)[];
-}
-interface ResolveOptions extends EnvironmentResolveOptions {
+  enforce?: "pre" | "post";
   /**
-   * @default false
+   * Apply the plugin only for serve or build, or on certain conditions.
    */
-  preserveSymlinks?: boolean;
+  apply?: "serve" | "build" | ((this: void, config: UserConfig, env: ConfigEnv) => boolean);
   /**
-   * Enable tsconfig paths resolution
-   *
-   * @default false
+   * Define environments where this plugin should be active
+   * By default, the plugin is active in all environments
+   * @experimental
    */
-  tsconfigPaths?: boolean;
-}
-interface ResolvePluginOptions {
-  root: string;
-  isBuild: boolean;
-  isProduction: boolean;
-  packageCache?: PackageCache;
+  applyToEnvironment?: (environment: PartialEnvironment) => boolean | Promise<boolean> | PluginOption;
   /**
-   * src code mode also attempts the following:
-   * - resolving /xxx as URLs
-   * - resolving bare imports from optimized deps
+   * 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
+   * deeply merged into existing config.
+   *
+   * Note: User plugins are resolved before running this hook so injecting other
+   * plugins inside  the `config` hook will have no effect.
    */
-  asSrc?: boolean;
-  tryIndex?: boolean;
-  tryPrefix?: string;
-  preferRelative?: boolean;
-  isRequire?: boolean;
-  scan?: boolean;
+  config?: ObjectHook<(this: ConfigPluginContext, config: UserConfig, env: ConfigEnv) => Omit<UserConfig, "plugins"> | null | void | Promise<Omit<UserConfig, "plugins"> | null | void>>;
   /**
-   * Enable when `legacy.inconsistentCjsInterop` is true. See that option for more details.
+   * Modify environment configs before it's resolved. The hook can either mutate the
+   * passed-in environment config directly, or return a partial config object that will be
+   * deeply merged into existing config.
+   * This hook is called for each environment with a partially resolved environment config
+   * that already accounts for the default environment config values set at the root level.
+   * If plugins need to modify the config of a given environment, they should do it in this
+   * hook instead of the config hook. Leaving the config hook only for modifying the root
+   * default environment config.
    */
-  legacyInconsistentCjsInterop?: boolean;
-}
-interface InternalResolveOptions extends Required<ResolveOptions>, ResolvePluginOptions {}
-//#endregion
-//#region src/node/packages.d.ts
-/** Cache for package.json resolution and package.json contents */
-type PackageCache = Map<string, PackageData>;
-interface PackageData {
-  dir: string;
-  hasSideEffects: (id: string) => boolean | "no-treeshake" | null;
-  setResolvedCache: (key: string, entry: string, options: InternalResolveOptions) => void;
-  getResolvedCache: (key: string, options: InternalResolveOptions) => string | undefined;
-  data: {
-    [field: string]: any;
-    name: string;
-    type: string;
-    version: string;
-    main: string;
-    module: string;
-    browser: string | Record<string, string | false>;
-    exports: string | Record<string, any> | string[];
-    imports: Record<string, any>;
-    dependencies: Record<string, string>;
-  };
-}
-//#endregion
-//#region src/node/plugins/license.d.ts
-interface LicenseOptions {
+  configEnvironment?: ObjectHook<(this: ConfigPluginContext, name: string, config: EnvironmentOptions, env: ConfigEnv & {
+    /**
+     * Whether this environment is SSR environment and `ssr.target` is set to `'webworker'`.
+     * Only intended to be used for backward compatibility.
+     */
+    isSsrTargetWebworker?: boolean;
+  }) => EnvironmentOptions | null | void | Promise<EnvironmentOptions | null | void>>;
   /**
-   * The output file name of the license file relative to the output directory.
-   * Specify a path that ends with `.json` to output the raw JSON metadata.
-   *
-   * @default '.vite/license.md'
+   * Use this hook to read and store the final resolved vite config.
    */
-  fileName: string;
-}
-//#endregion
-//#region src/node/build.d.ts
-interface BuildEnvironmentOptions {
+  configResolved?: ObjectHook<(this: MinimalPluginContextWithoutEnvironment, config: ResolvedConfig) => void | Promise<void>>;
   /**
-   * Compatibility transform target. The transform is performed with esbuild
-   * and the lowest supported target is es2015. Note this only handles
-   * syntax transformation and does not cover polyfills
-   *
-   * Default: 'baseline-widely-available' - transpile targeting browsers that
-   * are included in the Baseline Widely Available on 2026-01-01.
-   * (Chrome 111+, Edge 111+, Firefox 114+, Safari 16.4+).
-   *
-   * Another special value is 'esnext' - which only performs minimal transpiling
-   * (for minification compat).
+   * Configure the vite server. The hook receives the {@link ViteDevServer}
+   * instance. This can also be used to store a reference to the server
+   * for use in other hooks.
    *
-   * For custom targets, see https://esbuild.github.io/api/#target and
-   * https://esbuild.github.io/content-types/#javascript for more details.
-   * @default 'baseline-widely-available'
+   * The hooks will be called before internal middlewares are applied. A hook
+   * can return a post hook that will be called after internal middlewares
+   * are applied. Hook can be async functions and will be called in series.
    */
-  target?: "baseline-widely-available" | EsbuildTarget | false;
+  configureServer?: ObjectHook<ServerHook>;
   /**
-   * whether to inject module preload polyfill.
-   * Note: does not apply to library mode.
-   * @default true
-   * @deprecated use `modulePreload.polyfill` instead
+   * Configure the preview server. The hook receives the {@link PreviewServer}
+   * instance. This can also be used to store a reference to the server
+   * for use in other hooks.
+   *
+   * The hooks are called before other middlewares are applied. A hook can
+   * return a post hook that will be called after other middlewares are
+   * applied. Hooks can be async functions and will be called in series.
    */
-  polyfillModulePreload?: boolean;
+  configurePreviewServer?: ObjectHook<PreviewServerHook>;
   /**
-   * Configure module preload
-   * Note: does not apply to library mode.
-   * @default true
+   * Run logic when the server is restarted or closed. The hook receives a
+   * `reason` that is `'restart'` when the server is restarting and `'close'`
+   * when it is closing.
+   *
+   * The hooks are called after the server is torn down. Hooks can be async
+   * functions and will be called in parallel.
    */
-  modulePreload?: boolean | ModulePreloadOptions;
+  closeServer?: ObjectHook<CloseServerHook>;
   /**
-   * Directory relative from `root` where build output will be placed. If the
-   * directory exists, it will be removed before the build.
-   * @default 'dist'
+   * Same as `closeServer` but for the preview server. The preview server never
+   * restarts, so no `reason` is provided.
    */
-  outDir?: string;
+  closePreviewServer?: ObjectHook<ClosePreviewServerHook>;
   /**
-   * Directory relative from `outDir` where the built js/css/image assets will
-   * be placed.
-   * @default 'assets'
+   * Transform index.html.
+   * The hook receives the following arguments:
+   *
+   * - html: string
+   * - ctx: IndexHtmlTransformContext, which contains:
+   *    - path: public path when served
+   *    - filename: filename on disk
+   *    - server?: ViteDevServer (only present during serve)
+   *    - bundle?: rollup.OutputBundle (only present during build)
+   *    - chunk?: rollup.OutputChunk
+   *    - originalUrl?: string
+   *
+   * It can either return a transformed string, or a list of html tag
+   * descriptors that will be injected into the `<head>` or `<body>`.
+   *
+   * By default the transform is applied **after** vite's internal html
+   * transform. If you need to apply the transform before vite, use an object:
+   * `{ order: 'pre', handler: hook }`
    */
-  assetsDir?: string;
+  transformIndexHtml?: IndexHtmlTransform;
   /**
-   * Static asset files smaller than this number (in bytes) will be inlined as
-   * base64 strings. If a callback is passed, a boolean can be returned to opt-in
-   * or opt-out of inlining. If nothing is returned the default logic applies.
+   * Build Environments
    *
-   * Default limit is `4096` (4 KiB). Set to `0` to disable.
-   * @default 4096
+   * @experimental
    */
-  assetsInlineLimit?: number | ((filePath: string, content: Buffer) => boolean | undefined);
+  buildApp?: ObjectHook<BuildAppHook>;
   /**
-   * 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
+   * Perform custom handling of HMR updates.
+   * The handler receives a context containing changed filename, timestamp, a
+   * list of modules affected by the file change, and the dev server instance.
+   *
+   * - The hook can return a filtered list of modules to narrow down the update.
+   *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
+   *   the descriptors.
+   *
+   * - The hook can also return an empty array and then perform custom updates
+   *   by sending a custom hmr payload via server.ws.send().
+   *
+   * - If the hook doesn't return a value, the hmr update will be performed as
+   *   normal.
    */
-  cssCodeSplit?: boolean;
+  handleHotUpdate?: ObjectHook<(this: MinimalPluginContextWithoutEnvironment, ctx: HmrContext) => Array<ModuleNode> | void | Promise<Array<ModuleNode> | void>>;
   /**
-   * 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
+   * This hook is not supported by Rolldown yet. But the type is declared for compatibility.
+   *
+   * @deprecated This hook is **not** deprecated. It is marked as deprecated just to make it clear that this hook is currently a no-op.
    */
-  cssTarget?: EsbuildTarget | false;
+  shouldTransformCachedModule?: ObjectHook<(this: PluginContext, options: {
+    code: string;
+    id: string;
+    meta: CustomPluginOptions;
+    moduleSideEffects: boolean | "no-treeshake";
+  }) => boolean | null | 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 | {
+  name: string;
+} | FalsyPlugin | PluginOption[]>;
+/**
+ * @experimental
+ */
+export declare function perEnvironmentPlugin(name: string, applyToEnvironment: (environment: PartialEnvironment) => boolean | Promise<boolean> | PluginOption): Plugin;
+//#endregion
+//#region src/node/watch.d.ts
+/**
+ * Watch options for the dev server. Accepts both chokidar options and Rolldown
+ * watch options. The chokidar options are used by the chokidar watcher, while
+ * the Rolldown options are used by the Rolldown file watcher when bundled dev
+ * mode is enabled.
+ */
+type ServerWatchOptions = WatchOptions & Omit<DevWatchOptions, "enabled" | "skipWrite">;
+//#endregion
+//#region src/node/server/index.d.ts
+interface ServerOptions$1 extends CommonServerOptions {
   /**
-   * Override CSS minification specifically instead of defaulting to `build.minify`,
-   * so you can configure minification for JS and CSS separately.
-   * @default 'lightningcss', but false if build.minify is disabled for client build
+   * Configure HMR-specific options (port, host, path & protocol)
    */
-  cssMinify?: boolean | "lightningcss" | "esbuild";
+  hmr?: HmrOptions | boolean;
   /**
-   * 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
+   * Configure WebSocket connection options.
+   * Set to `false` to disable the WebSocket server and connection.
    */
-  sourcemap?: boolean | "inline" | "hidden";
+  ws?: WsOptions | false;
   /**
-   * Set to `false` to disable minification, or specify the minifier to use.
-   * Available options are 'oxc' or 'terser' or 'esbuild'.
-   * @default 'oxc' for client build, false for SSR build
+   * Warm-up files to transform and cache the results in advance. This improves the
+   * initial page load during server starts and prevents transform waterfalls.
    */
-  minify?: boolean | "oxc" | "terser" | "esbuild";
+  warmup?: {
+    /**
+     * The files to be transformed and used on the client-side. Supports glob patterns.
+     */
+    clientFiles?: string[];
+    /**
+     * The files to be transformed and used in SSR. Supports glob patterns.
+     */
+    ssrFiles?: string[];
+  };
   /**
-   * Options for terser
-   * https://terser.org/docs/api-reference#minify-options
+   * File system watcher options, or null to disable FS watching.
    *
-   * 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.
+   * Accepts chokidar options
+   * (https://github.com/paulmillr/chokidar/tree/3.6.0#api), which are used by
+   * the chokidar watcher, and Rolldown watch options, which are used by the
+   * Rolldown file watcher when bundled dev mode is enabled.
    */
-  terserOptions?: TerserOptions;
+  watch?: ServerWatchOptions | null;
   /**
-   * Whether to use import maps feature to optimize chunk caching efficiency.
+   * Create Vite dev server to be used as a middleware in an existing server
    * @default false
-   * @experimental
    */
-  chunkImportMap?: boolean;
+  middlewareMode?: boolean | {
+    /**
+     * Parent server instance to attach to
+     *
+     * This is needed to proxy WebSocket connections to the parent server.
+     */
+    server: HttpServer;
+  };
   /**
-   * Alias to `rolldownOptions`
-   * @deprecated Use `rolldownOptions` instead.
+   * Options for files served via '/\@fs/'.
    */
-  rollupOptions?: RolldownOptions;
+  fs?: FileSystemServeOptions;
   /**
-   * Will be merged with internal rolldown options.
-   * https://rolldown.rs/reference/Interface.RolldownOptions
+   * Origin for the generated asset URLs.
+   *
+   * @example `http://127.0.0.1:8080`
    */
-  rolldownOptions?: RolldownOptions;
+  origin?: string;
   /**
-   * Options to pass on to `@rollup/plugin-commonjs`
-   * @deprecated This option is no-op and will be removed in future versions.
+   * Pre-transform known direct imports
+   * @default true
    */
-  commonjsOptions?: RollupCommonJSOptions;
+  preTransformRequests?: boolean;
   /**
-   * Options to pass on to `@rollup/plugin-dynamic-import-vars`
+   * 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.
    */
-  dynamicImportVarsOptions?: RollupDynamicImportVarsOptions;
+  sourcemapIgnoreList?: false | ((sourcePath: string, sourcemapPath: string) => boolean);
   /**
-   * Whether to write bundle to disk
-   * @default true
+   * Backward compatibility. The buildStart and buildEnd hooks were called only once for
+   * the client environment. This option enables per-environment buildStart and buildEnd hooks.
+   * @default false
+   * @experimental
    */
-  write?: boolean;
+  perEnvironmentStartEndDuringDev?: boolean;
   /**
-   * Empty outDir on write.
-   * @default true when outDir is a sub directory of project root
+   * Backward compatibility. The watchChange hook was called only once for the client environment.
+   * This option enables per-environment watchChange hooks.
+   * @default false
+   * @experimental
    */
-  emptyOutDir?: boolean | null;
+  perEnvironmentWatchChangeDuringDev?: boolean;
   /**
-   * Copy the public directory to outDir on write.
-   * @default true
+   * Run HMR tasks, by default the HMR propagation is done in parallel for all environments
+   * @experimental
    */
-  copyPublicDir?: boolean;
+  hotUpdateEnvironments?: (server: ViteDevServer, hmr: (environment: DevEnvironment) => Promise<void>) => Promise<void>;
+  forwardConsole?: boolean | ForwardConsoleOptions;
+}
+interface ResolvedServerOptions extends Omit<RequiredExceptFor<ServerOptions$1, "host" | "https" | "proxy" | "hmr" | "ws" | "watch" | "origin" | "hotUpdateEnvironments">, "fs" | "middlewareMode" | "sourcemapIgnoreList" | "forwardConsole"> {
+  fs: Required<FileSystemServeOptions>;
+  middlewareMode: NonNullable<ServerOptions$1["middlewareMode"]>;
+  sourcemapIgnoreList: Exclude<ServerOptions$1["sourcemapIgnoreList"], false | undefined>;
+  forwardConsole: ResolvedForwardConsoleOptions;
+}
+interface FileSystemServeOptions {
   /**
-   * Whether to emit a `.vite/license.md` file that includes all bundled dependencies'
-   * licenses. Pass an object to customize the output file name.
-   * @default false
+   * Strictly restrict file accessing outside of allowing paths.
+   *
+   * Set to `false` to disable the warning
+   *
+   * @default true
    */
-  license?: boolean | LicenseOptions;
+  strict?: boolean;
   /**
-   * Whether to emit a .vite/manifest.json in the output dir to map hash-less filenames
-   * to their hashed versions. Useful when you want to generate your own HTML
-   * instead of using the one generated by Vite.
-   *
-   * Example:
+   * Restrict accessing files outside the allowed directories.
    *
-   * ```json
-   * {
-   *   "main.js": {
-   *     "file": "main.68fe3fad.js",
-   *     "css": "main.e6b63442.css",
-   *     "imports": [...],
-   *     "dynamicImports": [...]
-   *   }
-   * }
-   * ```
-   * @default false
+   * Accepts absolute path or a path relative to project root.
+   * Will try to search up for workspace root by default.
    */
-  manifest?: boolean | string;
+  allow?: 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
+   * Restrict accessing files that matches the patterns.
+   *
+   * This will have higher priority than `allow`.
+   * picomatch patterns are supported.
+   *
+   * @default ['.env', '.env.*', '*.{crt,pem,key,p12,pfx,cer,der}', '.npmrc', '.yarnrc.yml', '**\/.git/**']
    */
-  lib?: LibraryOptions | false;
+  deny?: string[];
+}
+type ServerHook = (this: MinimalPluginContextWithoutEnvironment, server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>;
+interface CloseServerHookContext {
   /**
-   * Produce SSR oriented build. Note this requires specifying SSR entry via
-   * `rolldownOptions.input`.
-   * @default false
+   * Whether the server is being restarted (e.g. a config change or
+   * `server.restart()`) or closed (e.g. the `q` shortcut, SIGTERM, stdin
+   * ending, or `server.close()`).
    */
-  ssr?: boolean | string;
+  reason: "restart" | "close";
+}
+type CloseServerHook = (this: MinimalPluginContextWithoutEnvironment, context: CloseServerHookContext) => void | Promise<void>;
+type HttpServer = http.Server | Http2SecureServer;
+interface ViteDevServer {
   /**
-   * Generate SSR manifest for determining style links and asset preload
-   * directives in production.
-   * @default false
+   * The resolved vite config object
    */
-  ssrManifest?: boolean | string;
+  config: ResolvedConfig;
   /**
-   * Emit assets during SSR.
-   * @default false
+   * 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
    */
-  ssrEmitAssets?: boolean;
+  middlewares: Connect.Server;
   /**
-   * Emit assets during build. Frameworks can set environments.ssr.build.emitAssets
-   * By default, it is true for the client and false for other environments.
+   * native Node http server instance
+   * will be null in middleware mode
    */
-  emitAssets?: boolean;
+  httpServer: HttpServer | null;
   /**
-   * Set to false to disable reporting compressed chunk sizes.
-   * Can slightly improve build speed.
-   * @default true
+   * Chokidar watcher instance. If `config.server.watch` is set to `null`,
+   * it will not watch any files and calling `add` or `unwatch` will have no effect.
+   * https://github.com/paulmillr/chokidar/tree/3.6.0#api
    */
-  reportCompressedSize?: boolean;
+  watcher: FSWatcher;
   /**
-   * Adjust chunk size warning limit (in kB).
-   * @default 500
+   * WebSocket server with `send(payload)` method
    */
-  chunkSizeWarningLimit?: number;
+  ws: WebSocketServer;
   /**
-   * Rollup watch options
-   * https://rollupjs.org/configuration-options/#watch
-   * @default null
+   * An alias to `server.environments.client.hot`.
+   * If you want to interact with all environments, loop over `server.environments`.
    */
-  watch?: WatcherOptions | null;
+  hot: NormalizedHotChannel;
   /**
-   * create the Build Environment instance
+   * Rollup plugin container that can run plugin hooks on a given file
    */
-  createEnvironment?: (name: string, config: ResolvedConfig) => Promise<BuildEnvironment> | BuildEnvironment;
-}
-type BuildOptions = BuildEnvironmentOptions;
-interface LibraryOptions {
+  pluginContainer: PluginContainer;
   /**
-   * Path of library entry.
-   * Defaults to the top-level `input` option when omitted.
+   * Module execution environments attached to the Vite server.
    */
-  entry?: InputOption;
+  environments: Record<"client" | "ssr" | (string & {}), DevEnvironment>;
   /**
-   * The name of the exposed global variable. Required when the `formats` option includes
-   * `umd` or `iife`
+   * Module graph that tracks the import relationships, url to file mapping
+   * and hmr state.
    */
-  name?: string;
+  moduleGraph: ModuleGraph;
   /**
-   * Output bundle formats. Defaults to `['es', 'umd']` for a single entry, or
-   * `['es', 'cjs']` for multiple entries (`umd` and `iife` do not support
-   * multiple entries).
-   * @default ['es', 'umd']
+   * The resolved urls Vite prints on the CLI (URL-encoded). Returns `null`
+   * in middleware mode or if the server is not listening on any port.
    */
-  formats?: LibraryFormats[];
+  resolvedUrls: ResolvedServerUrls | null;
   /**
-   * 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.
+   * Programmatically resolve, load and transform a URL and get the result
+   * without going through the http request pipeline.
    */
-  fileName?: string | ((format: ModuleFormat, entryName: string) => string);
+  transformRequest(url: string, options?: TransformOptions): Promise<TransformResult | null>;
   /**
-   * The name of the CSS file output if the library imports CSS. Defaults to the
-   * same value as `build.lib.fileName` if it's set a string, otherwise it falls
-   * back to the name option of the project package.json.
+   * 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.
    */
-  cssFileName?: string;
-}
-type LibraryFormats = "es" | "cjs" | "umd" | "iife";
-interface ModulePreloadOptions {
+  warmupRequest(url: string, options?: TransformOptions): Promise<void>;
   /**
-   * Whether to inject a module preload polyfill.
-   * Note: does not apply to library mode.
-   * @default true
+   * Apply vite built-in HTML transforms and any plugin HTML transforms.
    */
-  polyfill?: boolean;
+  transformIndexHtml(url: string, html: string, originalUrl?: string): Promise<string>;
   /**
-   * Resolve the list of dependencies to preload for a given dynamic import
-   * @experimental
+   * Transform module code into SSR format.
    */
-  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<RolldownOutput | RolldownOutput[] | RolldownWatcher>;
-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";
-  isBuilt: boolean;
-  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<RolldownOutput | RolldownOutput[] | RolldownWatcher>;
-  runDevTools(): Promise<void>;
-}
-interface BuilderOptions {
+  ssrTransform(code: string, inMap: SourceMap | {
+    mappings: "";
+  } | null, url: string, originalCode?: string): Promise<TransformResult | null>;
   /**
-   * Whether to share the config instance among environments to align with the behavior of dev server.
-   *
-   * @default false
-   * @experimental
+   * Load a given URL as an instantiated module for SSR.
    */
-  sharedConfigBuild?: boolean;
+  ssrLoadModule(url: string, opts?: {
+    fixStacktrace?: boolean;
+  }): Promise<Record<string, any>>;
   /**
-   * Whether to share the plugin instances among environments to align with the behavior of dev server.
-   *
-   * @default false
-   * @experimental
+   * Returns a fixed version of the given stack
    */
-  sharedPlugins?: boolean;
-  buildApp?: (builder: ViteBuilder) => Promise<void>;
-}
-type ResolvedBuilderOptions = Required<BuilderOptions>;
-/**
- * Creates a ViteBuilder to orchestrate building multiple environments.
- * @experimental
- */
-declare function createBuilder(inlineConfig?: InlineConfig, useLegacyBuilder?: null | boolean): Promise<ViteBuilder>;
-type BuildAppHook = (this: MinimalPluginContextWithoutEnvironment, builder: ViteBuilder) => Promise<void>;
-//#endregion
-//#region src/node/environment.d.ts
-type Environment = DevEnvironment | BuildEnvironment | ScanEnvironment | UnknownEnvironment;
-/**
- * Creates a function that hides the complexities of a WeakMap with an initial value
- * to implement object metadata. Used by plugins to implement cross hooks per
- * environment metadata
- *
- * @experimental
- */
-declare function perEnvironmentState<State>(initial: (environment: Environment) => State): (context: PluginContext) => State;
-//#endregion
-//#region src/node/server/pluginContainer.d.ts
-type SkipInformation = {
-  id: string;
-  importer: string | undefined;
-  plugin: Plugin;
-  called?: boolean;
-};
-declare class EnvironmentPluginContainer<Env extends Environment = Environment> {
-  private _pluginContextMap;
-  private _resolvedRolldownOptions?;
-  private _processesing;
-  private _seenResolves;
-  private _moduleNodeToLoadAddedImports;
-  getSortedPluginHooks: PluginHookUtils["getSortedPluginHooks"];
-  getSortedPlugins: PluginHookUtils["getSortedPlugins"];
-  moduleGraph: EnvironmentModuleGraph | undefined;
-  watchFiles: Set<string>;
-  minimalContext: MinimalPluginContext$1<Env>;
-  private _started;
-  private _buildStartPromise;
-  private _closed;
-  private _updateModuleLoadAddedImports;
-  private _getAddedImports;
-  getModuleInfo(id: string): ModuleInfo | null;
-  private handleHookPromise;
-  get options(): InputOptions;
-  resolveRolldownOptions(): Promise<InputOptions>;
-  private _getPluginContext;
-  private hookParallel;
-  buildStart(_options?: InputOptions): Promise<void>;
-  resolveId(rawId: string, importer?: string | undefined, options?: {
-    kind?: ImportKind;
-    attributes?: Record<string, string>;
-    custom?: CustomPluginOptions;
-    /** @deprecated use `skipCalls` instead */
-    skip?: Set<Plugin>;
-    skipCalls?: readonly SkipInformation[];
-    
-    isEntry?: boolean;
-  }): Promise<PartialResolvedId | null>;
-  load(id: string): Promise<LoadResult | null>;
-  transform(code: string, id: string, options?: {
-    inMap?: SourceDescription["map"];
-    moduleType?: string;
-  }): Promise<{
-    code: string;
-    map: SourceMap | {
-      mappings: "";
-    } | null;
-    moduleType?: ModuleType;
-  }>;
-  watchChange(id: string, change: {
-    event: "create" | "update" | "delete";
-  }): Promise<void>;
-  close(): Promise<void>;
-}
-declare class BasicMinimalPluginContext<Meta = PluginContextMeta> {
-  meta: Meta;
-  private _logger;
-  constructor(meta: Meta, _logger: Logger);
-  get pluginName(): string;
-  debug(rawLog: string | RollupLog | (() => string | RollupLog)): void;
-  info(rawLog: string | RollupLog | (() => string | RollupLog)): void;
-  warn(rawLog: string | RollupLog | (() => string | RollupLog)): void;
-  error(e: string | RollupError): never;
-  private _normalizeRawLog;
-}
-declare class MinimalPluginContext$1<T extends Environment = Environment> extends BasicMinimalPluginContext implements MinimalPluginContext {
-  environment: T;
-  constructor(meta: PluginContextMeta, environment: T);
-}
-declare class PluginContainer {
-  private environments;
-  constructor(environments: Record<string, Environment>);
-  private _getEnvironment;
-  private _getPluginContainer;
-  getModuleInfo(id: string): ModuleInfo | null;
-  get options(): InputOptions;
-  buildStart(_options?: InputOptions): Promise<void>;
-  watchChange(id: string, change: {
-    event: "create" | "update" | "delete";
-  }): Promise<void>;
-  resolveId(rawId: string, importer?: string, options?: {
-    attributes?: Record<string, string>;
-    custom?: CustomPluginOptions;
-    /** @deprecated use `skipCalls` instead */
-    skip?: Set<Plugin>;
-    skipCalls?: readonly SkipInformation[];
-    ssr?: boolean;
-    
-    isEntry?: boolean;
-  }): Promise<PartialResolvedId | null>;
-  load(id: string, options?: {
-    ssr?: boolean;
-  }): Promise<LoadResult | null>;
-  transform(code: string, id: string, options?: {
-    ssr?: boolean;
-    environment?: Environment;
-    inMap?: SourceDescription["map"];
-  }): Promise<{
-    code: string;
-    map: SourceMap | {
-      mappings: "";
-    } | null;
-  }>;
-  close(): Promise<void>;
-}
-//#endregion
-//#region src/node/server/index.d.ts
-interface ServerOptions$1 extends CommonServerOptions {
+  ssrRewriteStacktrace(stack: string): string;
   /**
-   * Configure HMR-specific options (port, host, path & protocol)
+   * Mutates the given SSR error by rewriting the stacktrace
    */
-  hmr?: HmrOptions | boolean;
+  ssrFixStacktrace(e: Error): void;
   /**
-   * Configure WebSocket connection options.
-   * Set to `false` to disable the WebSocket server and connection.
+   * 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.
    */
-  ws?: WsOptions | false;
+  reloadModule(module: ModuleNode): Promise<void>;
   /**
-   * Warm-up files to transform and cache the results in advance. This improves the
-   * initial page load during server starts and prevents transform waterfalls.
+   * Start the server.
    */
-  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[];
-  };
+  listen(port?: number, isRestart?: boolean): Promise<ViteDevServer>;
   /**
-   * chokidar watch options or null to disable FS watching
-   * https://github.com/paulmillr/chokidar/tree/3.6.0#api
+   * Stop the server.
    */
-  watch?: WatchOptions | null;
+  close(): Promise<void>;
   /**
-   * Create Vite dev server to be used as a middleware in an existing server
-   * @default false
+   * Print server urls
    */
-  middlewareMode?: boolean | {
-    /**
-     * Parent server instance to attach to
-     *
-     * This is needed to proxy WebSocket connections to the parent server.
-     */
-    server: HttpServer;
-  };
+  printUrls(): void;
   /**
-   * Options for files served via '/\@fs/'.
+   * Bind CLI shortcuts
    */
-  fs?: FileSystemServeOptions;
+  bindCLIShortcuts(options?: BindCLIShortcutsOptions<ViteDevServer>): void;
   /**
-   * Origin for the generated asset URLs.
+   * Restart the server.
    *
-   * @example `http://127.0.0.1:8080`
+   * @param forceOptimize - force the optimizer to re-bundle, same as --force cli flag
    */
-  origin?: string;
+  restart(forceOptimize?: boolean): Promise<void>;
+  /**
+   * Open browser
+   */
+  openBrowser(): void;
+  /**
+   * Calling `await server.waitForRequestsIdle(id)` will wait until all static imports
+   * are processed. If called from a load or transform plugin hook, the id needs to be
+   * passed as a parameter to avoid deadlocks. Calling this function after the first
+   * static imports section of the module graph has been processed will resolve immediately.
+   */
+  waitForRequestsIdle: (ignoredId?: string) => Promise<void>;
+}
+interface ResolvedServerUrls {
+  local: string[];
+  network: string[];
+  /**
+   * Names of the network interface that each {@link ResolvedServerUrls.network}
+   * URL is bound to, in the same order as `network`. An entry is `undefined`
+   * when the interface name is not known, for example when an explicit `host`
+   * is set.
+   */
+  networkInterfaceNames?: (string | undefined)[];
+}
+export declare function createServer(inlineConfig?: InlineConfig | ResolvedConfig): Promise<ViteDevServer>;
+//#endregion
+//#region src/node/logger.d.ts
+type LogType = "error" | "warn" | "info";
+type LogLevel = LogType | "silent";
+interface Logger {
+  info(msg: string, options?: LogOptions): void;
+  warn(msg: string, options?: LogOptions): void;
+  warnOnce(msg: string, options?: LogOptions): void;
+  error(msg: string, options?: LogErrorOptions): void;
+  clearScreen(type: LogType): void;
+  hasErrorLogged(error: Error | RollupError): boolean;
+  hasWarned: boolean;
+}
+interface LogOptions {
+  clear?: boolean;
+  timestamp?: boolean;
+  environment?: string;
+}
+interface LogErrorOptions extends LogOptions {
+  error?: Error | RollupError | null;
+}
+interface LoggerOptions {
+  prefix?: string;
+  allowClearScreen?: boolean;
+  customLogger?: Logger;
+  console?: Console;
+}
+export declare function createLogger(level?: LogLevel, options?: LoggerOptions): Logger;
+//#endregion
+//#region src/node/baseEnvironment.d.ts
+declare class PartialEnvironment {
+  name: string;
+  getTopLevelConfig(): ResolvedConfig;
+  config: ResolvedConfig & ResolvedEnvironmentOptions;
+  logger: Logger;
+  constructor(name: string, topLevelConfig: ResolvedConfig, options?: ResolvedEnvironmentOptions);
+}
+declare class BaseEnvironment extends PartialEnvironment {
+  get plugins(): readonly Plugin[];
+  constructor(name: string, config: ResolvedConfig, options?: ResolvedEnvironmentOptions);
+}
+/**
+ * This class discourages users from inversely checking the `mode`
+ * to determine the type of environment, e.g.
+ *
+ * ```js
+ * const isDev = environment.mode !== 'build' // bad
+ * const isDev = environment.mode === 'dev'   // good
+ * ```
+ *
+ * You should also not check against `"unknown"` specifically. It's
+ * a placeholder for more possible environment types.
+ */
+declare class UnknownEnvironment extends BaseEnvironment {
+  mode: "unknown";
+}
+//#endregion
+//#region src/node/plugins/resolve.d.ts
+interface EnvironmentResolveOptions {
   /**
-   * Pre-transform known direct imports
-   * @default true
+   * @default ['browser', 'module', 'jsnext:main', 'jsnext']
    */
-  preTransformRequests?: boolean;
+  mainFields?: string[];
+  conditions?: string[];
+  externalConditions?: string[];
   /**
-   * 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.
+   * @default ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json']
    */
-  sourcemapIgnoreList?: false | ((sourcePath: string, sourcemapPath: string) => boolean);
+  extensions?: string[];
+  dedupe?: string[];
   /**
-   * Backward compatibility. The buildStart and buildEnd hooks were called only once for
-   * the client environment. This option enables per-environment buildStart and buildEnd hooks.
-   * @default false
+   * Prevent listed dependencies from being externalized and will get bundled in build.
+   * Only works in server environments for now. Previously this was `ssr.noExternal`.
    * @experimental
    */
-  perEnvironmentStartEndDuringDev?: boolean;
+  noExternal?: string | RegExp | (string | RegExp)[] | true;
   /**
-   * Backward compatibility. The watchChange hook was called only once for the client environment.
-   * This option enables per-environment watchChange hooks.
-   * @default false
+   * Externalize the given dependencies and their transitive dependencies.
+   * Only works in server environments for now. Previously this was `ssr.external`.
    * @experimental
    */
-  perEnvironmentWatchChangeDuringDev?: boolean;
+  external?: string[] | true;
   /**
-   * Run HMR tasks, by default the HMR propagation is done in parallel for all environments
-   * @experimental
+   * Array of strings or regular expressions that indicate what modules are builtin for the environment.
    */
-  hotUpdateEnvironments?: (server: ViteDevServer, hmr: (environment: DevEnvironment) => Promise<void>) => Promise<void>;
-  forwardConsole?: boolean | ForwardConsoleOptions;
-}
-interface ResolvedServerOptions extends Omit<RequiredExceptFor<ServerOptions$1, "host" | "https" | "proxy" | "hmr" | "ws" | "watch" | "origin" | "hotUpdateEnvironments">, "fs" | "middlewareMode" | "sourcemapIgnoreList" | "forwardConsole"> {
-  fs: Required<FileSystemServeOptions>;
-  middlewareMode: NonNullable<ServerOptions$1["middlewareMode"]>;
-  sourcemapIgnoreList: Exclude<ServerOptions$1["sourcemapIgnoreList"], false | undefined>;
-  forwardConsole: ResolvedForwardConsoleOptions;
+  builtins?: (string | RegExp)[];
 }
-interface FileSystemServeOptions {
-  /**
-   * Strictly restrict file accessing outside of allowing paths.
-   *
-   * Set to `false` to disable the warning
-   *
-   * @default true
-   */
-  strict?: boolean;
+interface ResolveOptions extends EnvironmentResolveOptions {
   /**
-   * 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.
+   * @default false
    */
-  allow?: string[];
+  preserveSymlinks?: boolean;
   /**
-   * Restrict accessing files that matches the patterns.
-   *
-   * This will have higher priority than `allow`.
-   * picomatch patterns are supported.
+   * Enable tsconfig paths resolution
    *
-   * @default ['.env', '.env.*', '*.{crt,pem,key,p12,pfx,cer,der}', '.npmrc', '.yarnrc.yml', '**\/.git/**']
+   * @default false
    */
-  deny?: string[];
+  tsconfigPaths?: boolean;
 }
-type ServerHook = (this: MinimalPluginContextWithoutEnvironment, server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>;
-type HttpServer = http.Server | Http2SecureServer;
-interface ViteDevServer {
-  /**
-   * The resolved vite config object
-   */
-  config: ResolvedConfig;
-  /**
-   * A connect app instance.
-   * - Can be used to attach custom middlewares to the dev server.
-   * - Can also be used as the handler function of a custom http server
-   *   or as a middleware in any connect-style Node.js frameworks
-   *
-   * https://github.com/senchalabs/connect#use-middleware
-   */
-  middlewares: Connect.Server;
-  /**
-   * native Node http server instance
-   * will be null in middleware mode
-   */
-  httpServer: HttpServer | null;
-  /**
-   * Chokidar watcher instance. If `config.server.watch` is set to `null`,
-   * it will not watch any files and calling `add` or `unwatch` will have no effect.
-   * https://github.com/paulmillr/chokidar/tree/3.6.0#api
-   */
-  watcher: FSWatcher;
+interface ResolvePluginOptions {
+  root: string;
+  isBuild: boolean;
+  isProduction: boolean;
+  packageCache?: PackageCache;
   /**
-   * WebSocket server with `send(payload)` method
+   * src code mode also attempts the following:
+   * - resolving /xxx as URLs
+   * - resolving bare imports from optimized deps
    */
-  ws: WebSocketServer;
+  asSrc?: boolean;
+  tryIndex?: boolean;
+  tryPrefix?: string;
+  preferRelative?: boolean;
+  isRequire?: boolean;
+  scan?: boolean;
   /**
-   * An alias to `server.environments.client.hot`.
-   * If you want to interact with all environments, loop over `server.environments`.
+   * Enable when `legacy.inconsistentCjsInterop` is true. See that option for more details.
    */
-  hot: NormalizedHotChannel;
+  legacyInconsistentCjsInterop?: boolean;
+}
+interface InternalResolveOptions extends Required<ResolveOptions>, ResolvePluginOptions {}
+//#endregion
+//#region src/node/packages.d.ts
+/** Cache for package.json resolution and package.json contents */
+type PackageCache = Map<string, PackageData>;
+interface PackageData {
+  dir: string;
+  hasSideEffects: (id: string) => boolean | "no-treeshake" | null;
+  setResolvedCache: (key: string, entry: string, options: InternalResolveOptions) => void;
+  getResolvedCache: (key: string, options: InternalResolveOptions) => string | undefined;
+  data: {
+    [field: string]: any;
+    name: string;
+    type: string;
+    version: string;
+    main: string;
+    module: string;
+    browser: string | Record<string, string | false>;
+    exports: string | Record<string, any> | string[];
+    imports: Record<string, any>;
+    dependencies: Record<string, string>;
+  };
+}
+//#endregion
+//#region src/node/plugins/license.d.ts
+interface LicenseOptions {
   /**
-   * Rollup plugin container that can run plugin hooks on a given file
+   * The output file name of the license file relative to the output directory.
+   * Specify a path that ends with `.json` to output the raw JSON metadata.
+   *
+   * @default '.vite/license.md'
    */
-  pluginContainer: PluginContainer;
+  fileName: string;
+}
+//#endregion
+//#region src/node/plugins/terser.d.ts
+interface TerserOptions extends TerserMinifyOptions {
   /**
-   * Module execution environments attached to the Vite server.
+   * Vite-specific option to specify the max number of workers to spawn
+   * when minifying files with terser.
+   *
+   * @default number of CPUs minus 1
    */
-  environments: Record<"client" | "ssr" | (string & {}), DevEnvironment>;
+  maxWorkers?: number;
+}
+//#endregion
+//#region src/node/build.d.ts
+interface BuildEnvironmentOptions {
   /**
-   * Module graph that tracks the import relationships, url to file mapping
-   * and hmr state.
+   * Compatibility transform target. The transform is performed with esbuild
+   * and the lowest supported target is es2015. Note this only handles
+   * syntax transformation and does not cover polyfills
+   *
+   * Default: 'baseline-widely-available' - transpile targeting browsers that
+   * are included in the Baseline Widely Available on 2026-01-01.
+   * (Chrome 111+, Edge 111+, Firefox 114+, Safari 16.4+).
+   *
+   * Another special value is 'esnext' - which only performs minimal transpiling
+   * (for minification compat).
+   *
+   * For custom targets, see https://esbuild.github.io/api/#target and
+   * https://esbuild.github.io/content-types/#javascript for more details.
+   * @default 'baseline-widely-available'
    */
-  moduleGraph: ModuleGraph;
+  target?: "baseline-widely-available" | EsbuildTarget | false;
   /**
-   * The resolved urls Vite prints on the CLI (URL-encoded). Returns `null`
-   * in middleware mode or if the server is not listening on any port.
+   * whether to inject module preload polyfill.
+   * Note: does not apply to library mode.
+   * @default true
+   * @deprecated use `modulePreload.polyfill` instead
    */
-  resolvedUrls: ResolvedServerUrls | null;
+  polyfillModulePreload?: boolean;
   /**
-   * Programmatically resolve, load and transform a URL and get the result
-   * without going through the http request pipeline.
+   * Configure module preload
+   * Note: does not apply to library mode.
+   * @default true
    */
-  transformRequest(url: string, options?: TransformOptions): Promise<TransformResult | null>;
+  modulePreload?: boolean | ModulePreloadOptions;
   /**
-   * 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.
+   * Directory relative from `root` where build output will be placed. If the
+   * directory exists, it will be removed before the build.
+   * @default 'dist'
    */
-  warmupRequest(url: string, options?: TransformOptions): Promise<void>;
+  outDir?: string;
   /**
-   * Apply vite built-in HTML transforms and any plugin HTML transforms.
+   * Directory relative from `outDir` where the built js/css/image assets will
+   * be placed.
+   * @default 'assets'
    */
-  transformIndexHtml(url: string, html: string, originalUrl?: string): Promise<string>;
+  assetsDir?: string;
   /**
-   * Transform module code into SSR format.
+   * Static asset files smaller than this number (in bytes) will be inlined as
+   * base64 strings. If a callback is passed, a boolean can be returned to opt-in
+   * or opt-out of inlining. If nothing is returned the default logic applies.
+   *
+   * Default limit is `4096` (4 KiB). Set to `0` to disable.
+   * @default 4096
    */
-  ssrTransform(code: string, inMap: SourceMap | {
-    mappings: "";
-  } | null, url: string, originalCode?: string): Promise<TransformResult | null>;
+  assetsInlineLimit?: number | ((filePath: string, content: Buffer) => boolean | undefined);
   /**
-   * Load a given URL as an instantiated module for SSR.
+   * 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
    */
-  ssrLoadModule(url: string, opts?: {
-    fixStacktrace?: boolean;
-  }): Promise<Record<string, any>>;
+  cssCodeSplit?: boolean;
   /**
-   * Returns a fixed version of the given stack
+   * 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.
+   * When `build.cssMinify` is `lightningcss` (the default), this
+   * option takes precedence over `css.lightningcss.targets` for the
+   * minification step.
+   * @default target
    */
-  ssrRewriteStacktrace(stack: string): string;
+  cssTarget?: EsbuildTarget | false;
   /**
-   * Mutates the given SSR error by rewriting the stacktrace
+   * Override CSS minification specifically instead of defaulting to `build.minify`,
+   * so you can configure minification for JS and CSS separately.
+   * @default 'lightningcss', but false if build.minify is disabled for client build
    */
-  ssrFixStacktrace(e: Error): void;
+  cssMinify?: boolean | "lightningcss" | "esbuild";
   /**
-   * 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.
+   * 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
    */
-  reloadModule(module: ModuleNode): Promise<void>;
+  sourcemap?: boolean | "inline" | "hidden";
   /**
-   * Start the server.
+   * Set to `false` to disable minification, or specify the minifier to use.
+   * Available options are 'oxc' or 'terser' or 'esbuild'.
+   * @default 'oxc' for client build, false for SSR build
    */
-  listen(port?: number, isRestart?: boolean): Promise<ViteDevServer>;
+  minify?: boolean | "oxc" | "terser" | "esbuild";
   /**
-   * Stop the server.
+   * Options for terser
+   * https://terser.org/docs/api-reference#minify-options
+   *
+   * 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.
    */
-  close(): Promise<void>;
+  terserOptions?: TerserOptions;
   /**
-   * Print server urls
+   * Whether to use import maps feature to optimize chunk caching efficiency.
+   * @default false
+   * @experimental
    */
-  printUrls(): void;
+  chunkImportMap?: boolean;
   /**
-   * Bind CLI shortcuts
+   * Alias to `rolldownOptions`
+   * @deprecated Use `rolldownOptions` instead.
    */
-  bindCLIShortcuts(options?: BindCLIShortcutsOptions<ViteDevServer>): void;
+  rollupOptions?: RolldownOptions;
   /**
-   * Restart the server.
-   *
-   * @param forceOptimize - force the optimizer to re-bundle, same as --force cli flag
+   * Will be merged with internal rolldown options.
+   * https://rolldown.rs/reference/Interface.RolldownOptions
    */
-  restart(forceOptimize?: boolean): Promise<void>;
+  rolldownOptions?: RolldownOptions;
   /**
-   * Open browser
+   * Options to pass on to `@rollup/plugin-commonjs`
+   * @deprecated This option is no-op and will be removed in future versions.
    */
-  openBrowser(): void;
+  commonjsOptions?: RollupCommonJSOptions;
   /**
-   * 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.
+   * Options to pass on to `@rollup/plugin-dynamic-import-vars`
    */
-  waitForRequestsIdle: (ignoredId?: string) => Promise<void>;
-}
-interface ResolvedServerUrls {
-  local: string[];
-  network: string[];
+  dynamicImportVarsOptions?: RollupDynamicImportVarsOptions;
   /**
-   * Names of the network interface that each {@link ResolvedServerUrls.network}
-   * URL is bound to, in the same order as `network`. An entry is `undefined`
-   * when the interface name is not known, for example when an explicit `host`
-   * is set.
+   * Whether to write bundle to disk
+   * @default true
    */
-  networkInterfaceNames?: (string | undefined)[];
-}
-declare function createServer(inlineConfig?: InlineConfig | ResolvedConfig): Promise<ViteDevServer>;
-//#endregion
-//#region src/node/plugins/html.d.ts
-interface HtmlTagDescriptor {
-  tag: string;
+  write?: boolean;
   /**
-   * attribute values will be escaped automatically if needed
+   * Empty outDir on write.
+   * @default true when outDir is a sub directory of project root
    */
-  attrs?: Record<string, string | boolean | undefined>;
-  children?: string | HtmlTagDescriptor[];
+  emptyOutDir?: boolean | null;
   /**
-   * default: 'head-prepend'
+   * Copy the public directory to outDir on write.
+   * @default true
    */
-  injectTo?: "head" | "body" | "head-prepend" | "body-prepend";
-}
-type IndexHtmlTransformResult = string | HtmlTagDescriptor[] | {
-  html: string;
-  tags: HtmlTagDescriptor[];
-};
-interface IndexHtmlTransformContext {
+  copyPublicDir?: boolean;
   /**
-   * public path when served
+   * Whether to emit a `.vite/license.md` file that includes all bundled dependencies'
+   * licenses. Pass an object to customize the output file name.
+   * @default false
    */
-  path: string;
+  license?: boolean | LicenseOptions;
   /**
-   * filename on disk
+   * Whether to emit a .vite/manifest.json in the output dir to map hash-less filenames
+   * to their hashed versions. Useful when you want to generate your own HTML
+   * instead of using the one generated by Vite.
+   *
+   * Example:
+   *
+   * ```json
+   * {
+   *   "main.js": {
+   *     "file": "main.68fe3fad.js",
+   *     "css": "main.e6b63442.css",
+   *     "imports": [...],
+   *     "dynamicImports": [...]
+   *   }
+   * }
+   * ```
+   * @default false
    */
-  filename: string;
-  server?: ViteDevServer;
-  bundle?: OutputBundle;
-  chunk?: OutputChunk;
-  originalUrl?: string;
-}
-type IndexHtmlTransformHook = (this: MinimalPluginContextWithoutEnvironment, html: string, ctx: IndexHtmlTransformContext) => IndexHtmlTransformResult | void | Promise<IndexHtmlTransformResult | void>;
-type IndexHtmlTransform = IndexHtmlTransformHook | {
-  order?: "pre" | "post" | null;
-  handler: IndexHtmlTransformHook;
-};
-//#endregion
-//#region src/node/plugins/pluginFilter.d.ts
-type StringFilter<Value = string | RegExp> = Value | Array<Value> | {
-  include?: Value | Array<Value>;
-  exclude?: Value | Array<Value>;
-};
-//#endregion
-//#region src/node/plugin.d.ts
-/**
- * Vite plugins extends the Rollup plugin interface with a few extra
- * vite-specific options. A valid vite plugin is also a valid Rollup plugin.
- * On the contrary, a Rollup plugin may or may NOT be a valid vite universal
- * plugin, since some Rollup features do not make sense in an unbundled
- * dev server context. That said, as long as a rollup plugin doesn't have strong
- * coupling between its bundle phase and output phase hooks then it should
- * just work (that means, most of them).
- *
- * By default, the plugins are run during both serve and build. When a plugin
- * is applied during serve, it will only run **non output plugin hooks** (see
- * rollup type definition of {@link rollup#PluginHooks}). You can think of the
- * dev server as only running `const bundle = rollup.rollup()` but never calling
- * `bundle.generate()`.
- *
- * A plugin that expects to have different behavior depending on serve/build can
- * export a factory function that receives the command being run via options.
- *
- * If a plugin should be applied only for server or build, a function format
- * config file can be used to conditional determine the plugins to use.
- *
- * The current environment can be accessed from the context for the all non-global
- * hooks (it is not available in config, configResolved, configureServer, etc).
- * It can be a dev, build, or scan environment.
- * Plugins can use this.environment.mode === 'dev' to guard for dev specific APIs.
- */
-interface PluginContextExtension {
+  manifest?: boolean | string;
   /**
-   * Vite-specific environment instance
+   * 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
    */
-  environment: Environment;
-}
-interface PluginContextMetaExtension {
-  viteVersion: string;
-}
-interface ConfigPluginContext extends Omit<MinimalPluginContext, "meta" | "environment"> {
-  meta: Omit<PluginContextMeta, "watchMode">;
-}
-interface MinimalPluginContextWithoutEnvironment extends Omit<MinimalPluginContext, "environment"> {}
-declare module "rolldown" {
-  interface MinimalPluginContext extends PluginContextExtension {}
-  interface PluginContextMeta extends PluginContextMetaExtension {}
-}
-/**
- * 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 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 Rolldown.Plugin<A> {
+  lib?: LibraryOptions | false;
   /**
-   * 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.
+   * Produce SSR oriented build. Note this requires specifying SSR entry via
+   * `rolldownOptions.input`.
+   * @default false
    */
-  hotUpdate?: ObjectHook<(this: MinimalPluginContext & {
-    environment: DevEnvironment;
-  }, options: HotUpdateOptions) => Array<EnvironmentModuleNode> | void | Promise<Array<EnvironmentModuleNode> | void>>;
+  ssr?: boolean | string;
   /**
-   * extend hooks with ssr flag
+   * Generate SSR manifest for determining style links and asset preload
+   * directives in production.
+   * @default false
    */
-  resolveId?: ObjectHook<(this: PluginContext, source: string, importer: string | undefined, options: {
-    kind?: ImportKind;
-    custom?: CustomPluginOptions;
-    ssr?: boolean | undefined;
-    
-    isEntry: boolean;
-  }) => Promise<ResolveIdResult> | ResolveIdResult, {
-    filter?: {
-      id?: StringFilter<RegExp>;
-    };
-  }>;
-  load?: ObjectHook<(this: PluginContext, id: string, options?: {
-    ssr?: boolean | undefined;
-  }) => Promise<LoadResult> | LoadResult, {
-    filter?: {
-      id?: StringFilter;
-    };
-  }>;
-  transform?: ObjectHook<(this: TransformPluginContext, code: string, id: string, options?: {
-    moduleType: ModuleType;
-    ssr?: boolean | undefined;
-  }) => Promise<Rolldown.TransformResult> | Rolldown.TransformResult, {
-    filter?: {
-      id?: StringFilter;
-      code?: StringFilter;
-      moduleType?: ModuleTypeFilter;
-    };
-  }>;
+  ssrManifest?: boolean | string;
   /**
-   * 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
+   * Emit assets during SSR.
+   * @default false
    */
-  sharedDuringBuild?: boolean;
+  ssrEmitAssets?: boolean;
   /**
-   * Opt-in this plugin into per-environment buildStart and buildEnd during dev.
-   * For backward-compatibility, the buildStart hook is called only once during
-   * dev, for the client environment. Plugins can opt-in to be called
-   * per-environment, aligning with the build hook behavior.
-   * @experimental
+   * Emit assets during build. Frameworks can set environments.ssr.build.emitAssets
+   * By default, it is true for the client and false for other environments.
    */
-  perEnvironmentStartEndDuringDev?: boolean;
+  emitAssets?: boolean;
   /**
-   * Opt-in this plugin into per-environment watchChange during dev.
-   * For backward-compatibility, the watchChange hook is called only once during
-   * dev, for the client environment. Plugins can opt-in to be called
-   * per-environment, aligning with the watchChange hook behavior.
-   * @experimental
+   * Set to false to disable reporting compressed chunk sizes.
+   * Can slightly improve build speed.
+   * @default true
    */
-  perEnvironmentWatchChangeDuringDev?: boolean;
+  reportCompressedSize?: boolean;
   /**
-   * Enforce plugin invocation tier similar to webpack loaders. Hooks ordering
-   * is still subject to the `order` property in the hook object.
-   *
-   * Plugin invocation order:
-   * - alias resolution
-   * - `enforce: 'pre'` plugins
-   * - vite core plugins
-   * - normal plugins
-   * - vite build plugins
-   * - `enforce: 'post'` plugins
-   * - vite build post plugins
+   * Adjust chunk size warning limit (in kB).
+   * @default 500
    */
-  enforce?: "pre" | "post";
+  chunkSizeWarningLimit?: number;
   /**
-   * Apply the plugin only for serve or build, or on certain conditions.
+   * Rollup watch options
+   * https://rollupjs.org/configuration-options/#watch
+   * @default null
    */
-  apply?: "serve" | "build" | ((this: void, config: UserConfig, env: ConfigEnv) => boolean);
+  watch?: WatcherOptions | null;
   /**
-   * Define environments where this plugin should be active
-   * By default, the plugin is active in all environments
-   * @experimental
+   * create the Build Environment instance
    */
-  applyToEnvironment?: (environment: PartialEnvironment) => boolean | Promise<boolean> | PluginOption;
+  createEnvironment?: (name: string, config: ResolvedConfig) => Promise<BuildEnvironment> | BuildEnvironment;
+}
+type BuildOptions = BuildEnvironmentOptions;
+interface LibraryOptions {
   /**
-   * 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
-   * deeply merged into existing config.
-   *
-   * Note: User plugins are resolved before running this hook so injecting other
-   * plugins inside  the `config` hook will have no effect.
+   * Path of library entry.
+   * Defaults to the top-level `input` option when omitted.
    */
-  config?: ObjectHook<(this: ConfigPluginContext, config: UserConfig, env: ConfigEnv) => Omit<UserConfig, "plugins"> | null | void | Promise<Omit<UserConfig, "plugins"> | null | void>>;
+  entry?: InputOption;
   /**
-   * Modify environment configs before it's resolved. The hook can either mutate the
-   * passed-in environment config directly, or return a partial config object that will be
-   * deeply merged into existing config.
-   * This hook is called for each environment with a partially resolved environment config
-   * that already accounts for the default environment config values set at the root level.
-   * If plugins need to modify the config of a given environment, they should do it in this
-   * hook instead of the config hook. Leaving the config hook only for modifying the root
-   * default environment config.
+   * The name of the exposed global variable. Required when the `formats` option includes
+   * `umd` or `iife`
    */
-  configEnvironment?: ObjectHook<(this: ConfigPluginContext, name: string, config: EnvironmentOptions, env: ConfigEnv & {
-    /**
-     * Whether this environment is SSR environment and `ssr.target` is set to `'webworker'`.
-     * Only intended to be used for backward compatibility.
-     */
-    isSsrTargetWebworker?: boolean;
-  }) => EnvironmentOptions | null | void | Promise<EnvironmentOptions | null | void>>;
+  name?: string;
   /**
-   * Use this hook to read and store the final resolved vite config.
+   * Output bundle formats. Defaults to `['es', 'umd']` for a single entry, or
+   * `['es', 'cjs']` for multiple entries (`umd` and `iife` do not support
+   * multiple entries).
+   * @default ['es', 'umd']
    */
-  configResolved?: ObjectHook<(this: MinimalPluginContextWithoutEnvironment, config: ResolvedConfig) => void | Promise<void>>;
+  formats?: LibraryFormats[];
   /**
-   * Configure the vite server. The hook receives the {@link ViteDevServer}
-   * instance. This can also be used to store a reference to the server
-   * for use in other hooks.
-   *
-   * The hooks will be called before internal middlewares are applied. A hook
-   * can return a post hook that will be called after internal middlewares
-   * are applied. Hook can be async functions and will be called in series.
+   * 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.
    */
-  configureServer?: ObjectHook<ServerHook>;
+  fileName?: string | ((format: ModuleFormat, entryName: string) => string);
   /**
-   * Configure the preview server. The hook receives the {@link PreviewServer}
-   * instance. This can also be used to store a reference to the server
-   * for use in other hooks.
-   *
-   * The hooks are called before other middlewares are applied. A hook can
-   * return a post hook that will be called after other middlewares are
-   * applied. Hooks can be async functions and will be called in series.
+   * The name of the CSS file output if the library imports CSS. Defaults to the
+   * same value as `build.lib.fileName` if it's set a string, otherwise it falls
+   * back to the name option of the project package.json.
    */
-  configurePreviewServer?: ObjectHook<PreviewServerHook>;
+  cssFileName?: string;
+}
+type LibraryFormats = "es" | "cjs" | "umd" | "iife";
+interface ModulePreloadOptions {
   /**
-   * Transform index.html.
-   * The hook receives the following arguments:
-   *
-   * - html: string
-   * - ctx: IndexHtmlTransformContext, which contains:
-   *    - path: public path when served
-   *    - filename: filename on disk
-   *    - server?: ViteDevServer (only present during serve)
-   *    - bundle?: rollup.OutputBundle (only present during build)
-   *    - chunk?: rollup.OutputChunk
-   *    - originalUrl?: string
-   *
-   * It can either return a transformed string, or a list of html tag
-   * descriptors that will be injected into the `<head>` or `<body>`.
-   *
-   * By default the transform is applied **after** vite's internal html
-   * transform. If you need to apply the transform before vite, use an object:
-   * `{ order: 'pre', handler: hook }`
+   * Whether to inject a module preload polyfill.
+   * Note: does not apply to library mode.
+   * @default true
    */
-  transformIndexHtml?: IndexHtmlTransform;
+  polyfill?: boolean;
   /**
-   * Build Environments
-   *
+   * Resolve the list of dependencies to preload for a given dynamic import
    * @experimental
    */
-  buildApp?: ObjectHook<BuildAppHook>;
+  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.
+ */
+export declare function build(inlineConfig?: InlineConfig): Promise<RolldownOutput | RolldownOutput[] | RolldownWatcher>;
+type RenderBuiltAssetUrl = (filename: string, type: {
+  type: "asset" | "public";
+  hostId: string;
+  hostType: "js" | "css" | "html";
+  ssr: boolean;
+}) => string | {
+  relative?: boolean;
+  runtime?: string;
+} | undefined;
+export declare class BuildEnvironment extends BaseEnvironment {
+  mode: "build";
+  isBuilt: boolean;
+  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<RolldownOutput | RolldownOutput[] | RolldownWatcher>;
+  runDevTools(): Promise<void>;
+}
+interface BuilderOptions {
   /**
-   * Perform custom handling of HMR updates.
-   * The handler receives a context containing changed filename, timestamp, a
-   * list of modules affected by the file change, and the dev server instance.
-   *
-   * - The hook can return a filtered list of modules to narrow down the update.
-   *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
-   *   the descriptors.
-   *
-   * - The hook can also return an empty array and then perform custom updates
-   *   by sending a custom hmr payload via server.ws.send().
+   * Whether to share the config instance among environments to align with the behavior of dev server.
    *
-   * - If the hook doesn't return a value, the hmr update will be performed as
-   *   normal.
+   * @default false
+   * @experimental
    */
-  handleHotUpdate?: ObjectHook<(this: MinimalPluginContextWithoutEnvironment, ctx: HmrContext) => Array<ModuleNode> | void | Promise<Array<ModuleNode> | void>>;
+  sharedConfigBuild?: boolean;
   /**
-   * This hook is not supported by Rolldown yet. But the type is declared for compatibility.
+   * Whether to share the plugin instances among environments to align with the behavior of dev server.
    *
-   * @deprecated This hook is **not** deprecated. It is marked as deprecated just to make it clear that this hook is currently a no-op.
+   * @default false
+   * @experimental
    */
-  shouldTransformCachedModule?: ObjectHook<(this: PluginContext, options: {
-    code: string;
-    id: string;
-    meta: CustomPluginOptions;
-    moduleSideEffects: boolean | "no-treeshake";
-  }) => boolean | null | void>;
+  sharedPlugins?: boolean;
+  buildApp?: (builder: ViteBuilder) => Promise<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 | {
-  name: string;
-} | FalsyPlugin | PluginOption[]>;
+type ResolvedBuilderOptions = Required<BuilderOptions>;
 /**
+ * Creates a ViteBuilder to orchestrate building multiple environments.
  * @experimental
  */
-declare function perEnvironmentPlugin(name: string, applyToEnvironment: (environment: PartialEnvironment) => boolean | Promise<boolean> | PluginOption): Plugin;
+export declare function createBuilder(inlineConfig?: InlineConfig, useLegacyBuilder?: null | boolean): Promise<ViteBuilder>;
+type BuildAppHook = (this: MinimalPluginContextWithoutEnvironment, builder: ViteBuilder) => Promise<void>;
 //#endregion
 //#region src/node/idResolver.d.ts
 type ResolveIdFn = (environment: PartialEnvironment, id: string, importer?: string, aliasOnly?: boolean) => Promise<string | undefined>;
@@ -3110,9 +3178,9 @@ type ResolveIdFn = (environment: PartialEnvironment, id: string, importer?: stri
  * 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;
+export declare function createIdResolver(config: ResolvedConfig, options?: Partial<InternalResolveOptions>): ResolveIdFn;
 //#endregion
-//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.25_tsx@4.23.1_yaml@2.9.0/node_modules/postcss-load-config/src/index.d.ts
+//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.26_tsx@4.23.13_yaml@2.9.0/node_modules/postcss-load-config/src/index.d.ts
 type ConfigPlugin = Transformer | PostCSS.Plugin | Processor;
 interface Config {
   parser?: string | ProcessOptions['parser'] | false;
@@ -3197,8 +3265,8 @@ interface PreprocessCSSResult {
 /**
  * @experimental
  */
-declare function preprocessCSS(code: string, filename: string, config: ResolvedConfig): Promise<PreprocessCSSResult>;
-declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;
+export declare function preprocessCSS(code: string, filename: string, config: ResolvedConfig): Promise<PreprocessCSSResult>;
+export declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;
 type PreprocessorAdditionalDataResult = string | {
   content: string;
   map?: ExistingRawSourceMap;
@@ -3227,7 +3295,7 @@ interface ESBuildOptions extends esbuildOptions_EsbuildTransformOptions {
 type ESBuildTransformResult = Omit<EsbuildTransformResult, "map"> & {
   map: SourceMap;
 };
-declare function transformWithEsbuild(code: string, filename: string, options?: esbuildOptions_EsbuildTransformOptions, inMap?: object, config?: ResolvedConfig, watcher?: FSWatcher, ignoreEsbuildWarning?: boolean): Promise<ESBuildTransformResult>;
+export declare function transformWithEsbuild(code: string, filename: string, options?: esbuildOptions_EsbuildTransformOptions, inMap?: object, config?: ResolvedConfig, watcher?: FSWatcher, ignoreEsbuildWarning?: boolean): Promise<ESBuildTransformResult>;
 //#endregion
 //#region src/node/plugins/json.d.ts
 interface JsonOptions {
@@ -3245,32 +3313,15 @@ interface JsonOptions {
   stringify?: boolean | "auto";
 }
 //#endregion
-//#region src/node/assetSource.d.ts
-/**
- * Defines which attributes of an HTML element should be treated as asset sources.
- * Used in `html.additionalAssetSources` configuration.
- */
-interface HtmlAssetSource {
-  /**
-   * Attributes that contain a single asset URL.
-   * @example ['src', 'data-src-dark']
-   */
-  srcAttributes?: string[];
-  /**
-   * Attributes that contain srcset-format URLs.
-   * @example ['srcset', 'imagesrcset']
-   */
-  srcsetAttributes?: string[];
-  /**
-   * Called before handling an attribute to determine if it should be processed.
-   */
-  filter?: (data: HtmlAssetSourceFilterData) => boolean;
-}
-interface HtmlAssetSourceFilterData {
-  key: string;
-  value: string;
-  attributes: Record<string, string>;
+//#region src/node/plugins/oxc.d.ts
+interface OxcOptions extends Omit<rolldown_utils_TransformOptions, "cwd" | "sourceType" | "lang" | "sourcemap" | "helpers" | "inject" | "tsconfig" | "inputMap"> {
+  include?: string | RegExp | ReadonlyArray<string | RegExp>;
+  exclude?: string | RegExp | ReadonlyArray<string | RegExp>;
+  jsxInject?: string;
+  jsxRefreshInclude?: string | RegExp | ReadonlyArray<string | RegExp>;
+  jsxRefreshExclude?: string | RegExp | ReadonlyArray<string | RegExp>;
 }
+export declare function transformWithOxc(code: string, filename: string, options?: rolldown_utils_TransformOptions, inMap?: object, config?: ResolvedConfig, watcher?: FSWatcher): Promise<Omit<rolldown_utils_TransformResult, "errors">>;
 //#endregion
 //#region src/node/ssr/index.d.ts
 type SSRTarget = "node" | "webworker";
@@ -3317,16 +3368,6 @@ interface ResolvedSSROptions extends SSROptions {
   optimizeDeps: SsrDepOptimizationConfig;
 }
 //#endregion
-//#region src/node/plugins/oxc.d.ts
-interface OxcOptions extends Omit<rolldown_utils_TransformOptions, "cwd" | "sourceType" | "lang" | "sourcemap" | "helpers" | "inject" | "tsconfig" | "inputMap"> {
-  include?: string | RegExp | ReadonlyArray<string | RegExp>;
-  exclude?: string | RegExp | ReadonlyArray<string | RegExp>;
-  jsxInject?: string;
-  jsxRefreshInclude?: string | RegExp | ReadonlyArray<string | RegExp>;
-  jsxRefreshExclude?: string | RegExp | ReadonlyArray<string | RegExp>;
-}
-declare function transformWithOxc(code: string, filename: string, options?: rolldown_utils_TransformOptions, inMap?: object, config?: ResolvedConfig, watcher?: FSWatcher): Promise<Omit<rolldown_utils_TransformResult, "errors">>;
-//#endregion
 //#region src/node/config.d.ts
 interface ConfigEnv {
   /**
@@ -3355,12 +3396,12 @@ type UserConfigExport = UserConfig | Promise<UserConfig> | UserConfigFnObject |
  * accepts a direct {@link UserConfig} object, or a function that returns it.
  * The function receives a {@link ConfigEnv} object.
  */
-declare function defineConfig(config: UserConfig): UserConfig;
-declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
-declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
-declare function defineConfig(config: UserConfigFnPromise): UserConfigFnPromise;
-declare function defineConfig(config: UserConfigFn): UserConfigFn;
-declare function defineConfig(config: UserConfigExport): UserConfigExport;
+export declare function defineConfig(config: UserConfig): UserConfig;
+export declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
+export declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
+export declare function defineConfig(config: UserConfigFnPromise): UserConfigFnPromise;
+export declare function defineConfig(config: UserConfigFn): UserConfigFn;
+export declare function defineConfig(config: UserConfigExport): UserConfigExport;
 interface CreateDevEnvironmentContext {
   ws: WebSocketServer;
 }
@@ -3491,6 +3532,11 @@ interface UserConfig extends DefaultEnvironmentOptions {
    * @default process.cwd()
    */
   root?: string;
+  /**
+   * Path to the TypeScript configuration file. Relative paths are resolved
+   * from the project root.
+   */
+  tsconfig?: string;
   /**
    * Base public path when served in development or production.
    * @default '/'
@@ -3851,16 +3897,16 @@ 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, 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, configLoader?: "bundle" | "runner" | "native"): Promise<{
+export 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>;
+export declare function sortUserPlugins(plugins: (Plugin | Plugin[])[] | undefined): [Plugin[], Plugin[], Plugin[]];
+export declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, configRoot?: string, logLevel?: LogLevel, customLogger?: Logger, configLoader?: "bundle" | "runner" | "native"): Promise<{
   path: string;
   config: UserConfig;
   dependencies: string[];
 } | null>;
 //#endregion
 //#region src/node/server/middlewares/error.d.ts
-declare function buildErrorMessage(err: RollupError, args?: string[], includeStack?: boolean): string;
+export declare function buildErrorMessage(err: RollupError, args?: string[], includeStack?: boolean): string;
 //#endregion
 //#region src/node/ssr/runtime/serverModuleRunner.d.ts
 /**
@@ -3878,23 +3924,23 @@ interface ServerModuleRunnerOptions extends Omit<ModuleRunnerOptions, "root" | "
    */
   evaluator?: ModuleEvaluator;
 }
-declare const createServerModuleRunnerTransport: (options: {
+export declare const createServerModuleRunnerTransport: (options: {
   channel: NormalizedServerHotChannel;
 }) => ModuleRunnerTransport;
 /**
  * Create an instance of the Vite SSR runtime that support HMR.
  * @experimental
  */
-declare function createServerModuleRunner(environment: DevEnvironment, options?: ServerModuleRunnerOptions): ModuleRunner;
+export declare function createServerModuleRunner(environment: DevEnvironment, options?: ServerModuleRunnerOptions): ModuleRunner;
 //#endregion
 //#region src/node/server/environments/runnableEnvironment.d.ts
-declare function createRunnableDevEnvironment(name: string, config: ResolvedConfig, context?: RunnableDevEnvironmentContext): RunnableDevEnvironment;
+export declare function createRunnableDevEnvironment(name: string, config: ResolvedConfig, context?: RunnableDevEnvironmentContext): RunnableDevEnvironment;
 interface RunnableDevEnvironmentContext extends Omit<DevEnvironmentContext, "hot"> {
   runner?: (environment: RunnableDevEnvironment, options?: ServerModuleRunnerOptions) => ModuleRunner;
   runnerOptions?: ServerModuleRunnerOptions;
   hot?: boolean;
 }
-declare function isRunnableDevEnvironment(environment: Environment): environment is RunnableDevEnvironment;
+export declare function isRunnableDevEnvironment(environment: Environment): environment is RunnableDevEnvironment;
 declare class RunnableDevEnvironment extends DevEnvironment {
   private _runner;
   private _runnerFactory;
@@ -3908,8 +3954,8 @@ declare class RunnableDevEnvironment extends DevEnvironment {
 interface FetchableDevEnvironmentContext extends DevEnvironmentContext {
   handleRequest(request: Request): Promise<Response> | Response;
 }
-declare function createFetchableDevEnvironment(name: string, config: ResolvedConfig, context: FetchableDevEnvironmentContext): FetchableDevEnvironment;
-declare function isFetchableDevEnvironment(environment: Environment): environment is FetchableDevEnvironment;
+export declare function createFetchableDevEnvironment(name: string, config: ResolvedConfig, context: FetchableDevEnvironmentContext): FetchableDevEnvironment;
+export declare function isFetchableDevEnvironment(environment: Environment): environment is FetchableDevEnvironment;
 declare class FetchableDevEnvironment extends DevEnvironment {
   private _handleRequest;
   constructor(name: string, config: ResolvedConfig, context: FetchableDevEnvironmentContext);
@@ -3925,7 +3971,7 @@ interface RunnerImportResult<T> {
  * Import any file using the default Vite environment.
  * @experimental
  */
-declare function runnerImport<T>(moduleId: string, inlineConfig?: InlineConfig): Promise<RunnerImportResult<T>>;
+export declare function runnerImport<T>(moduleId: string, inlineConfig?: InlineConfig): Promise<RunnerImportResult<T>>;
 //#endregion
 //#region src/node/ssr/fetchModule.d.ts
 interface FetchModuleOptions {
@@ -3937,7 +3983,7 @@ interface FetchModuleOptions {
  * Fetch module information for Vite module runner.
  * @experimental
  */
-declare function fetchModule(environment: DevEnvironment, url: string, importer?: string, options?: FetchModuleOptions): Promise<moduleRunner_FetchResult>;
+export declare function fetchModule(environment: DevEnvironment, url: string, importer?: string, options?: FetchModuleOptions): Promise<moduleRunner_FetchResult>;
 //#endregion
 //#region src/node/ssr/ssrTransform.d.ts
 interface ModuleRunnerTransformOptions {
@@ -3956,21 +4002,21 @@ declare const DEFAULT_SERVER_MAIN_FIELDS: readonly string[];
 declare const DEFAULT_CLIENT_CONDITIONS: readonly string[];
 declare const DEFAULT_SERVER_CONDITIONS: readonly string[];
 declare const DEFAULT_EXTERNAL_CONDITIONS: readonly string[];
-declare const defaultAllowedOrigins: RegExp;
+export declare const defaultAllowedOrigins: RegExp;
 //#endregion
 //#region src/node/utils.d.ts
 /**
  * Inlined to keep `@rollup/pluginutils` in devDependencies
  */
 type FilterPattern = ReadonlyArray<string | RegExp> | string | RegExp | null;
-declare const createFilter: (include?: FilterPattern, exclude?: FilterPattern, options?: {
+export declare const createFilter: (include?: FilterPattern, exclude?: FilterPattern, options?: {
   resolve?: string | false | null;
 }) => (id: unknown) => boolean;
-declare const rollupVersion = "4.23.0";
-declare function normalizePath(id: string): string;
-declare const isCSSRequest: (request: string) => boolean;
-declare function mergeConfig<D extends Record<string, any>, O extends Record<string, any>>(defaults: D extends Function ? never : D, overrides: O extends Function ? never : O, isRoot?: boolean): Record<string, any>;
-declare function mergeAlias(a?: AliasOptions, b?: AliasOptions): AliasOptions | undefined;
+export declare const rollupVersion = "4.23.0";
+export declare function normalizePath(id: string): string;
+export declare const isCSSRequest: (request: string) => boolean;
+export declare function mergeConfig<D extends Record<string, any>, O extends Record<string, any>>(defaults: D extends Function ? never : D, overrides: O extends Function ? never : O, isRoot?: boolean): Record<string, any>;
+export declare function mergeAlias(a?: AliasOptions, b?: AliasOptions): AliasOptions | undefined;
 //#endregion
 //#region src/node/server/send.d.ts
 interface SendOptions {
@@ -3981,33 +4027,33 @@ interface SendOptions {
     mappings: "";
   } | null;
 }
-declare function send(req: http.IncomingMessage, res: ServerResponse, content: string | Buffer, type: string, options: SendOptions): void;
+export declare function send(req: http.IncomingMessage, res: ServerResponse, content: string | Buffer, type: string, options: SendOptions): void;
 //#endregion
 //#region src/node/server/searchRoot.d.ts
 /**
  * Search up for the nearest workspace root
  */
-declare function searchForWorkspaceRoot(current: string, root?: string): string;
+export declare function searchForWorkspaceRoot(current: string, root?: string): string;
 //#endregion
 //#region src/node/server/middlewares/static.d.ts
 /**
  * Check if the url is allowed to be served, via the `server.fs` config.
  * @deprecated Use the `isFileLoadingAllowed` function instead.
  */
-declare function isFileServingAllowed(config: ResolvedConfig, url: string): boolean;
-declare function isFileServingAllowed(url: string, server: ViteDevServer): boolean;
+export declare function isFileServingAllowed(config: ResolvedConfig, url: string): boolean;
+export declare function isFileServingAllowed(url: string, server: ViteDevServer): boolean;
 /**
  * Warning: parameters are not validated, only works with normalized absolute paths
  */
-declare function isFileLoadingAllowed(config: ResolvedConfig, filePath: string): boolean;
+export declare function isFileLoadingAllowed(config: ResolvedConfig, filePath: string): boolean;
 //#endregion
 //#region src/node/env.d.ts
 /**
  * Load `.env` files within the `envDir` and merge them with the matching
  * variables already present in `process.env`.
  */
-declare function loadEnv(mode: string, envDir: string | false, prefixes?: string | string[]): Record<string, string>;
-declare function resolveEnvPrefix({ envPrefix }: UserConfig): string[];
+export declare function loadEnv(mode: string, envDir: string | false, prefixes?: string | string[]): Record<string, string>;
+export declare function resolveEnvPrefix({ envPrefix }: UserConfig): string[];
 //#endregion
 //#region src/node/plugins/manifest.d.ts
 type Manifest = Record<string, ManifestChunk>;
@@ -4058,9 +4104,9 @@ interface ManifestChunk {
 //#endregion
 //#region src/node/index.d.ts
 /** @deprecated - use `parseSync` instead */
-declare const parseAst: typeof parseAst$1;
+export declare const parseAst: typeof parseAst$1;
 /** @deprecated - use `parse` instead */
-declare const parseAstAsync: typeof parseAstAsync$1;
-declare const esbuildVersion = "0.25.0";
+export declare const parseAstAsync: typeof parseAstAsync$1;
+export declare const esbuildVersion = "0.25.0";
 //#endregion
-export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type BindCLIShortcutsOptions, type BuildAppHook, BuildEnvironment, type BuildEnvironmentOptions, type BuildOptions, type BuilderOptions, type CLIShortcut, type CSSModulesOptions, type CSSOptions, type ChunkMetadata, type CommonServerOptions, type ConfigEnv, type ConfigPluginContext, type Connect, type ConnectedPayload, type CorsOptions, type CorsOrigin, type CustomEventMap, type CustomPayload, type CustomPluginOptionsVite, type DepOptimizationConfig, type DepOptimizationMetadata, type DepOptimizationOptions, DevEnvironment, type DevEnvironmentContext, type DevEnvironmentOptions, type ESBuildOptions, type ESTree, type Environment, type EnvironmentModuleGraph, type EnvironmentModuleNode, type EnvironmentOptions, type ErrorPayload, type EsbuildTransformOptions, type ExperimentalOptions, type ExportsData, type FSWatcher, type FetchFunction, type FetchModuleOptions, type FetchResult, type FetchableDevEnvironment, type FetchableDevEnvironmentContext, type FileSystemServeOptions, type FilterPattern, type FullReloadPayload, type GeneralImportGlobOptions, type HMRPayload, type HTMLOptions, type HmrContext, type HmrOptions, type HookHandler, type HotChannel, type HotChannelClient, type HotChannelListener, type HotPayload, type HotUpdateOptions, type HtmlAssetSource, type HtmlTagDescriptor, type index_d_exports as HttpProxy, type HttpServer, type ImportGlobFunction, type ImportGlobOptions, type IndexHtmlTransform, type IndexHtmlTransformContext, type IndexHtmlTransformHook, type IndexHtmlTransformResult, type InferCustomEventPayload, type InlineConfig, type InternalResolveOptions, type InvalidatePayload, type JsonOptions, type KnownAsTypeMap, type KnownQueryTypeMap, type LegacyOptions, type LessPreprocessorOptions, 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, type MinifyOptions, type MinifyResult, type MinimalPluginContextWithoutEnvironment, type ModuleGraph, type ModuleNode, type ModulePreloadOptions, type ModuleRunnerTransformOptions, type NormalizedHotChannel, type NormalizedHotChannelClient, type NormalizedServerHotChannel, type OptimizedDepInfo, type OxcOptions, type ParseResult, type ParserOptions, type Plugin, type PluginContainer, type PluginHookUtils, type PluginOption, type Config as PostcssUserConfig, type PreprocessCSSResult, type PreviewOptions, type PreviewServer, type PreviewServerHook, type ProxyOptions, type PrunePayload, 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 Rolldown, type Rollup, type RollupCommonJSOptions, type RollupDynamicImportVarsOptions, type RunnableDevEnvironment, type RunnableDevEnvironmentContext, type SSROptions, type SSRTarget, type SassPreprocessorOptions, type SendOptions, type ServerHook, type ServerHotChannel, type ServerModuleRunnerOptions, type ServerOptions$1 as ServerOptions, type SkipInformation, type SsrDepOptimizationConfig, type StylusPreprocessorOptions, type Terser, type TerserOptions, type TransformOptions, type TransformResult, type Update, type UpdatePayload, type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, Visitor, type VisitorObject, type ViteBuilder, type ViteDevServer, type WatchOptions, type WebSocket, type WebSocketAlias, type WebSocketClient, type WebSocketCustomListener, type WebSocketServer, type WsOptions, build, buildErrorMessage, createBuilder, createFetchableDevEnvironment, createFilter, createIdResolver, createLogger, createRunnableDevEnvironment, createServer, createServerHotChannel, createServerModuleRunner, createServerModuleRunnerTransport, defaultAllowedOrigins, DEFAULT_CLIENT_CONDITIONS as defaultClientConditions, DEFAULT_CLIENT_MAIN_FIELDS as defaultClientMainFields, DEFAULT_EXTERNAL_CONDITIONS as defaultExternalConditions, DEFAULT_SERVER_CONDITIONS as defaultServerConditions, DEFAULT_SERVER_MAIN_FIELDS as defaultServerMainFields, defineConfig, esbuildVersion, esmExternalRequirePlugin, fetchModule, formatPostcssSourceMap, isCSSRequest, isFetchableDevEnvironment, isFileLoadingAllowed, isFileServingAllowed, isRunnableDevEnvironment, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, minify, minifySync, ssrTransform as moduleRunnerTransform, normalizePath, optimizeDeps, parse, parseAst, parseAstAsync, parseSync, perEnvironmentPlugin, perEnvironmentState, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rolldownVersion, rollupVersion, runnerImport, searchForWorkspaceRoot, send, sortUserPlugins, transformWithEsbuild, transformWithOxc, VERSION as version, withFilter };
+export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type BindCLIShortcutsOptions, type BuildAppHook, type BuildEnvironmentOptions, type BuildOptions, type BuilderOptions, type CLIShortcut, type CSSModulesOptions, type CSSOptions, type ChunkMetadata, type CommonServerOptions, type ConfigEnv, type ConfigPluginContext, type Connect, type ConnectedPayload, type CorsOptions, type CorsOrigin, type CustomEventMap, type CustomPayload, type CustomPluginOptionsVite, type DepOptimizationConfig, type DepOptimizationMetadata, type DepOptimizationOptions, type DevEnvironmentContext, type DevEnvironmentOptions, type ESBuildOptions, type ESTree, type Environment, type EnvironmentModuleGraph, type EnvironmentModuleNode, type EnvironmentOptions, type ErrorPayload, type EsbuildTransformOptions, type ExperimentalOptions, type ExportsData, type FSWatcher, type FetchFunction, type FetchModuleOptions, type FetchResult, type FetchableDevEnvironment, type FetchableDevEnvironmentContext, type FileSystemServeOptions, type FilterPattern, type FullReloadPayload, type GeneralImportGlobOptions, type HMRPayload, type HTMLOptions, type HmrContext, type HmrOptions, type HookHandler, type HotChannel, type HotChannelClient, type HotChannelListener, type HotPayload, type HotUpdateOptions, type HtmlAssetSource, type HtmlTagDescriptor, type index_d_exports as HttpProxy, type HttpServer, type ImportGlobFunction, type ImportGlobOptions, type IndexHtmlTransform, type IndexHtmlTransformContext, type IndexHtmlTransformHook, type IndexHtmlTransformResult, type InferCustomEventPayload, type InlineConfig, type InternalResolveOptions, type InvalidatePayload, type JsonOptions, type KnownAsTypeMap, type KnownQueryTypeMap, type LegacyOptions, type LessPreprocessorOptions, 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, type MinifyOptions, type MinifyResult, type MinimalPluginContextWithoutEnvironment, type ModuleGraph, type ModuleNode, type ModulePreloadOptions, type ModuleRunnerTransformOptions, type NormalizedHotChannel, type NormalizedHotChannelClient, type NormalizedServerHotChannel, type OptimizedDepInfo, type OxcOptions, type ParseResult, type ParserOptions, type Plugin, type PluginContainer, type PluginHookUtils, type PluginOption, type Config as PostcssUserConfig, type PreprocessCSSResult, type PreviewOptions, type PreviewServer, type PreviewServerHook, type ProxyOptions, type PrunePayload, 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 Rolldown, type Rollup, type RollupCommonJSOptions, type RollupDynamicImportVarsOptions, type RunnableDevEnvironment, type RunnableDevEnvironmentContext, type SSROptions, type SSRTarget, type SassPreprocessorOptions, type SendOptions, type ServerHook, type ServerHotChannel, type ServerModuleRunnerOptions, type ServerOptions$1 as ServerOptions, type ServerWatchOptions, type SkipInformation, type SsrDepOptimizationConfig, type StylusPreprocessorOptions, type Terser, type TerserOptions, type TransformOptions, type TransformResult, type Update, type UpdatePayload, type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, Visitor, type VisitorObject, type ViteBuilder, type ViteDevServer, type WatchOptions, type WebSocket, type WebSocketAlias, type WebSocketClient, type WebSocketCustomListener, type WebSocketServer, type WsOptions, DEFAULT_CLIENT_CONDITIONS as defaultClientConditions, DEFAULT_CLIENT_MAIN_FIELDS as defaultClientMainFields, DEFAULT_EXTERNAL_CONDITIONS as defaultExternalConditions, DEFAULT_SERVER_CONDITIONS as defaultServerConditions, DEFAULT_SERVER_MAIN_FIELDS as defaultServerMainFields, esmExternalRequirePlugin, minify, minifySync, ssrTransform as moduleRunnerTransform, parse, parseSync, rolldownVersion, VERSION as version, withFilter };