vitejs/vite

This system is Vite, a next-generation frontend build tool and development server that provides a fast, modular architecture for modern web applications. It scaffolds projects via create-vite, manages dependency optimization and bundling using Rolldown, and supports a wide array of frontend frameworks including React, Vue, Svelte, and Solid. The platform features robust Server-Side Rendering capabilities with a dedicated module runner, extensive HMR support, and comprehensive testing infrastructure to ensure reliability across diverse environments.

133 changes.

This period focused on migrating Vite's core tooling from esbuild to Rolldown, including the dependency optimizer, dev server bundling, and CLI. It also involved modernizing the project infrastructure by adopting Oxfmt, dropping Node.js 18 support, and introducing a dedicated SSR module runner. The work was heavily supported by extensive test coverage expansions and the overhaul of create-vite templates to align with new branding and strict TypeScript configurations.

58 changes.

This period focused on expanding Vite's Server-Side Rendering capabilities by introducing a new SSR module runner with HMR support and a multi-environment architecture. The work included adding comprehensive test coverage for SSR resolution, dependency optimization, and hot reloading, alongside new starter templates for Solid.js and Qwik.

27 changes.

This period focused on expanding the playground suite with new environments for features like Tailwind CSS v3, SSR WebAssembly, and import attributes, while significantly increasing test coverage for configuration resolution, optimizer edge cases, and HMR behavior. It also included targeted fixes for base path stripping, trailing slash handling, and lazy compilation race conditions to ensure stability across these new and existing capabilities.

A new playground example has been added to demonstrate and test the Lightning CSS transformer. It includes a Vite configuration that enables Lightning CSS for both development and build-time minification, along with a suite of CSS files covering linked styles, imports, CSS modules (including composes and path resolution), external URLs, aliased assets, and nested CSS. The setup also includes a custom plugin to verify that Lightning CSS visitors are not re-run during the minification phase.

playground/css-lightningcss · high confidence

New Qwik project templates are now available when creating a Vite application, supporting both JavaScript (app.jsx) and TypeScript (app.tsx) variants. These templates include a pre-configured entry point that initializes the Qwik renderer, a counter component demonstrating Qwik's signals and HMR, and a styled landing page with documentation links pointing to the updated vite.dev and qwik.dev domains.

packages/create-vite/template-qwik-ts, packages/create-vite/template-qwik-ts/src, packages/create-vite/template-qwik/src · high confidence

A new playground environment (\playground/environment-react-ssr\) demonstrates Server-Side Rendering (SSR) using Vite's multi-environment feature. It configures separate \client\ and \ssr\ environments, enabling dependency discovery and pre-bundling for the SSR environment, and implements a custom middleware plugin to handle SSR requests in development and preview modes.

playground/environment-react-ssr · high confidence

A new playground environment has been added to validate WebAssembly support within Vite's Server-Side Rendering (SSR) workflow. This setup demonstrates two primary integration patterns: using the \.wasm?init\ query syntax for static initialization and performing direct ES module imports of \.wasm\ files. The playground includes a custom Express-based SSR server and a suite of end-to-end tests that verify correct asset handling, ensuring that WebAssembly modules are either inlined as base64 data URIs or emitted as separate files depending on the configuration.

playground/ssr-wasm · high confidence

New starter templates for Solid.js (both JavaScript and TypeScript variants) are now available when creating a new Vite project. These templates include the necessary configuration files (such as \tsconfig.json\ and \vite.config.ts\/\.js\) and source files to immediately run and build a Solid.js application using \vite-plugin-solid\.

packages/create-vite/template-solid-ts · high confidence

New SolidJS project templates (both TypeScript and JavaScript variants) are now available when scaffolding a new Vite application. These templates include a pre-configured entry point using \solid-js/web\, a sample \App\ component featuring a counter with Hot Module Replacement (HMR) support, and a unified UI theme with light/dark mode support. The templates also provide a 'Next Steps' section with links to Vite and SolidJS documentation, as well as community channels like GitHub, Discord, X, and Bluesky.

packages/create-vite/template-solid-ts/src, packages/create-vite/template-solid/src · high confidence

A new playground has been added to demonstrate Tailwind CSS v3 integration with Vite. It includes a Vite configuration with a custom plugin to delay CSS loading, a PostCSS setup using \import.meta.url\ for the Tailwind config path, and source files that utilize Tailwind utility classes. The entry also includes a test suite that verifies CSS regeneration and Hot Module Replacement (HMR) behavior when modifying styles and components.

playground/tailwind-v3 · high confidence

A new playground example for backend integration has been added, featuring a Vite configuration that utilizes Tailwind CSS v4, the modern Sass API, and the tinyglobby library. The setup includes a custom Vite plugin to manage entry points and serves on port 5009, accompanied by specific CSS styles for asset references.

playground/backend-integration · high confidence

The \packages/vite/scripts\ directory now includes two new utility scripts: \generateTarget.ts\ generates the list of ESBuild target strings based on the \baseline-browser-mapping\ data for a specified date (defaulting to 2026-01-01), and \benchCircularImport.ts\ provides a benchmarking tool to measure module evaluation performance in the SSR ModuleRunner against synthetic graphs with configurable cycle fractions. These scripts support internal development and release processes by automating target configuration and performance validation.

packages/vite/scripts · high confidence

Added a new SCSS file (blue.scss) defining a primary text color and a new TypeScript entrypoint (sub.ts) that imports an external CSS file, establishing test assets for the nested backend-integration frontend entrypoints.

playground/backend-integration/frontend/entrypoints/nested · high confidence

A new playground example named 'css-codesplit-cjs' has been added to demonstrate CSS code-splitting behavior when targeting CommonJS output. The setup includes a multi-entry configuration (main and other entry points) that imports separate CSS files, configured via Vite to output CommonJS modules using rolldownOptions.

playground/css-codesplit-cjs · high confidence

A new playground example has been added to demonstrate Tailwind CSS integration with Vite, specifically focusing on source map generation. The setup includes a Vite configuration that enables both development and build source maps, uses PostCSS with the @tailwindcss/postcss plugin, and imports Tailwind via the new v4 CSS import syntax (@import 'tailwindcss').

playground/tailwind-sourcemap · high confidence

A new playground entry has been added to simulate a Laravel/Rails-like project structure, enabling tests for how Vite handles CSS and JS assets when the root directory differs from the source. The entry includes an HTML page that imports global styles and JavaScript modules, a main entry point that dynamically injects CSS and references external assets (including an SVG), and supporting style files to verify correct URL generation and asset serving.

playground/backend-integration/frontend/entrypoints · high confidence

A new playground located at \playground/build-old\ has been added to test how the build process handles specific JavaScript syntaxes when targeting older browser versions (specifically Chrome 60). The setup includes an HTML page and test script that verify \import.meta.url\ and dynamic imports are preserved, while private class fields (\\#privateField\) are correctly lowered/transpiled. This ensures that the build toolchain behaves as expected for legacy environments.

playground/build-old · high confidence

A new playground example located at playground/tsconfig-json/nested-with-extends demonstrates TypeScript's behavior when 'useDefineForClassFields' is disabled via a nested tsconfig.json that extends a parent configuration. The example includes a base class with a data setter and a derived class that assigns a value to a field, illustrating how the compiler handles class field definitions under this specific setting.

playground/tsconfig-json/nested-with-extends · high confidence

A new playground example has been added to demonstrate the use of the import attributes syntax (import ... with { type: 'json' }). The demo includes source code and a dependency that utilize this syntax to import JSON data, along with corresponding tests to verify the functionality.

playground/import-attribute · high confidence

The playground/csp example has been updated to demonstrate Content Security Policy (CSP) nonce support. A custom Vite plugin now generates random nonces, injects them into the HTTP Content-Security-Policy header, and replaces a placeholder in the HTML with the actual nonce value. The setup includes test cases for linked CSS, inline styles, JavaScript modules, and dynamically imported scripts to verify that resources load correctly under the nonce policy. Additionally, a specific test case ensures that existing nonce attributes on script tags are not overwritten, preventing double-application of nonces.

playground/csp · high confidence

The playground/forward-console location demonstrates the new capability to forward browser console output (including console.error, unhandled errors, and unhandled rejections) to the terminal where the dev server is running. This is enabled by setting server.forwardConsole to true in the Vite configuration, allowing developers to see frontend logs without switching context to the browser's developer tools.

playground/forward-console · high confidence

A new Svelte + TypeScript template has been added to the create-vite package, providing a minimal starting point for Vite projects using Svelte and TypeScript. The template includes a standard project structure with an HTML entry point, a Vite configuration using the @sveltejs/vite-plugin-svelte, and TypeScript configuration files (tsconfig.json, tsconfig.app.json, tsconfig.node.json) that enforce strict type checking, target ES2023, and use modern module resolution (nodenext). It also provides recommended IDE setup instructions via VS Code extensions and a .gitignore file to streamline initial project setup.

packages/create-vite/template-svelte-ts · high confidence

A new Svelte starter template has been added to the create-vite package, providing a minimal setup for Vite + Svelte projects. The template includes a basic HTML entry point, a Vite configuration using the Svelte plugin, and a Svelte configuration file. It also provides a JavaScript configuration with strict type-checking options (checkJs, verbatimModuleSyntax) and a recommended VS Code extensions file to improve developer experience out of the box.

packages/create-vite/template-svelte · high confidence

This change adds the \@vitejs/plugin-legacy\ package, which enables building for legacy browsers that do not support native ESM dynamic imports or \import.meta\. The plugin generates SystemJS-based legacy chunks and polyfill bundles, injecting \\<script nomodule\>\ tags to conditionally load them in older browsers. It supports configuration via \targets\ and \modernTargets\ (Browserslist queries), allows custom polyfills through \additionalLegacyPolyfills\ and \additionalModernPolyfills\, and provides CSP hash utilities for strict Content Security Policy environments. The package is built using \tsdown\ and targets Node 20+.

packages/plugin-legacy · high confidence

Adds a new ModuleRunner implementation in \packages/vite/src/module-runner\ that enables Vite to evaluate ESM modules directly in Node.js. This includes the core runner class, an ESModulesEvaluator for executing transformed code, and an HMR client for hot module reloading. The runner supports \import.meta.resolve\ and \import.meta.main\, handles Windows path normalization, and manages module caching and circular dependency detection.

packages/vite/src/module-runner · high confidence

Vite now uses a dedicated module runner for SSR, replacing the previous Node.js require-based approach. This change introduces new internal APIs (\fetchModule\, \runnerImport\, \ssrLoadModule\) and a new \ssrManifestPlugin\ to support the runner's lifecycle. For users, this means improved SSR performance, better handling of dynamic imports and circular dependencies, and more accurate source maps during development.

packages/vite/src/node/ssr · high confidence

The \create-vite\ package is introduced, providing a new command-line interface for scaffolding Vite projects. It supports interactive and non-interactive modes, allows initializing in non-empty directories via an overwrite flag, and offers a selection of official templates including Vanilla, Vue, React (with TypeScript, JavaScript, and React Compiler variants), Preact, Lit, Svelte, Solid, and Qwik. The tool handles dependency installation and project setup, integrating with package managers and supporting custom commands for external starters like Nuxt and React Router.

packages/create-vite/src · high confidence

Adds a new experimental \bundledDev\ mode for the client environment that replaces the traditional Vite dev server bundling with Rolldown. This change introduces a new \BundledDev\ class to manage the Rolldown \DevEngine\, handles HMR updates via client-side scripts injected by Rolldown, and integrates with the new \DevEnvironment\ architecture. It also includes supporting infrastructure such as a \MemoryFiles\ in-memory file system, a \mixedModuleGraph\ for backward compatibility with existing module graph APIs, and a \triggerLazyBundlingMiddleware\ to support lazy bundling features.

packages/vite/src/node/server · high confidence

The \plugin-legacy\ package is now available to generate both modern and legacy JavaScript chunks, enabling support for older browsers that lack features like \import.meta.resolve\ and async generators. Users can configure browser targets via the \targets\ and \modernTargets\ options, control polyfill injection with \polyfills\ and \modernPolyfills\, and opt into legacy chunk rendering via \renderLegacyChunks\. The plugin handles polyfill chunk generation, legacy entry points, and includes a Safari 10 no-module fix, with configuration types exported for TypeScript consumers.

packages/plugin-legacy/src · high confidence

Vite introduces two new environment types to extend the dev server's capabilities. The FetchableDevEnvironment allows environments to handle standard Web Fetch API requests via a \dispatchFetch\ method, enabling integration with fetch-based workflows. The RunnableDevEnvironment provides a module runner (via \ServerModuleRunner\) for executing code within the environment, with automatic lifecycle management that closes the runner when the environment is closed. These additions expand how Vite can interact with external systems and execute modules in a dev context.

packages/vite/src/node/server/environments · high confidence

A new playground located at playground/ssr-html has been added to test server-side rendering capabilities. It includes a custom Express server setup that integrates Vite in middleware mode, demonstrating features such as virtual modules, dynamic script/style injection, trailing slash path handling, and network imports. The playground also includes specific test files to verify stacktrace resolution with and without sourcemaps, and to test the server module runner.

playground/ssr-html · high confidence

A new playground has been added to test Server-Side Rendering (SSR) builds targeting the web worker environment. This setup allows developers to verify that Vite correctly bundles and serves applications running in a web worker context, including support for dynamic imports, Node.js compatibility flags via Miniflare, and specific resolve conditions for workers.

playground/ssr-webworker · high confidence

A new \createServerModuleRunner\ function and its associated transport layer have been added to the SSR runtime, enabling server-side module execution with Hot Module Replacement (HMR) capabilities. This allows the Vite dev server to manage module updates and source maps for code running in the SSR environment, integrating with the existing HMR channel to send and receive custom events between the server and client.

packages/vite/src/node/ssr/runtime · high confidence

The \create-vite\ CLI now includes a \template-lit-ts\ option that scaffolds a Lit-based application using TypeScript. This template provides a modern development setup with a \tsconfig.json\ configured for Vite (using \bundler\ module resolution, \verbatimModuleSyntax\, and \moduleDetection: force\), an \index.html\ entry point, and a standard \.gitignore\ file, allowing users to quickly start a new Lit project with strict TypeScript settings.

packages/create-vite/template-lit-ts · high confidence

The playground/wasm location now includes a complete demo environment for WebAssembly features. It provides an interactive HTML interface and JavaScript logic that showcases direct .wasm imports (WASM ESM Integration) and the new .wasm?init query syntax. The demo covers various scenarios including inline and output-based compilation, importing WebAssembly.Instance from the init function, passing imports between modules, accessing WebAssembly.Global values, and utilizing js-string builtins with imported string constants.

playground/wasm · high confidence

A new \bundledDevClient.ts\ entry point has been added to the Vite client package to support the experimental full-bundle mode powered by Rolldown. This file initializes a \ViteDevRuntime\ that extends the Rolldown runtime, registers a custom \BundledDevHMRClient\ to handle Hot Module Replacement updates specific to the bundled environment, and exposes the standard public client APIs (such as \createHotContext\, \ErrorOverlay\, and style utilities) to maintain compatibility with the existing \/@vite/client\ interface.

packages/vite/src/client · high confidence

Added a new playground located at playground/env that demonstrates and validates Vite's environment variable features. It includes configuration for custom prefixes (VITE\_ and CUSTOM\PREFIX\), dotenv-expand support for variable substitution, and build-time define replacements for boolean, number, string, and object types. The playground also tests the exposure of process.env.NODE\_ENV via globalThis and verifies correct handling of escaped dollar signs and mode-specific .env files.

playground/env · high confidence

Added a new playground (\playground/optimize-missing-deps\) that demonstrates Vite's handling of dependencies not yet discovered or optimized. The setup includes an Express server using Vite in \middlewareMode\ with \appType: 'custom'\, which serves an HTML page that loads a module (\main.js\) importing \@vitejs/test-missing-dep\. This configuration allows testing that server-side rendering (SSR) does not trigger optimization of these 'missing' deps, while client-side loading does.

playground/optimize-missing-deps · high confidence

This change introduces a new \packages/vite/src/shared\ directory containing core utilities and runtime components for the Vite Runtime API. It adds a console forwarding mechanism (\forwardConsole\) that sends browser logs and errors to the dev server terminal, complete with a lightweight pretty-printer (\pretty-format\) that limits object depth and width to prevent excessive payload sizes. It also includes a new HMR handler (\hmrHandler\) that ensures Hot Module Replacement updates are processed sequentially via a queue, and a module runner transport layer (\moduleRunnerTransport\) that normalizes communication between the client and server, supporting both \send\/\connect\ and \invoke\ patterns. Additional utilities include ID wrapping/unwrapping for virtual modules (\utils\), builtin module detection (\builtin\), and SSR import analysis (\ssrTransform\).

packages/vite/src/shared · high confidence

Added a new playground example in the css-codesplit/order location that demonstrates how CSS styles are applied based on insertion order. The demo uses a base stylesheet (blue), a dynamically imported stylesheet (green), and an inline script-injected style (orange) to show how the final computed color of the .order-bulk element is determined by the sequence in which these styles are added to the document head.

playground/css-codesplit/order · high confidence

The playground has been updated to demonstrate building applications with multiple entry points. The configuration now defines 25 distinct JavaScript entry points (a0–a24) alongside an HTML entry point, utilizing the \rolldownOptions\ with \preserveEntrySignatures\ set to 'strict'. The demo includes dynamic imports triggered by user interaction, where clicking buttons loads separate modules that share a common reference file containing SCSS styles.

playground/multiple-entrypoints · high confidence

The nested-deps playground has been updated to include a new self-referencing test case, allowing users to verify that the build tool correctly handles packages that reference themselves. This addition is accompanied by a comprehensive test suite and supporting mock packages that validate various dependency resolution scenarios, including nested dependencies, absolute paths, and excluded dependencies.

playground/nested-deps · high confidence

The JavaScript-based development server and Hot Module Replacement (HMR) infrastructure in the lib directory has been completely removed. This includes the deletion of fileWatcher.js, hmrProxy.js, parseSFC.js, server.js, utils.js, and vueMiddleware.js, which previously handled Vue Single-File Component parsing, WebSocket-based HMR communication, and HTTP serving. Users relying on this specific JS-based dev server setup will no longer have access to these features in this location, indicating a shift to a different implementation or framework for development-time functionality.

lib · high confidence

The Vite dev server's request handling has been reorganized from a monolithic implementation into distinct, named middleware functions (base, error, hostCheck, htmlFallback, indexHtml, memoryFiles, notFound, proxy, rejectInvalidRequest, static, time, transform, and triggerLazyBundling). This change improves code maintainability and enables comprehensive unit testing for individual middleware components, such as the new \hostCheck.spec.ts\ and \indexHtml.spec.ts\ tests.

packages/vite/src/node/server/middlewares · high confidence

The playground/devtools location now includes the necessary files to serve as an integration test entry point for the devtools feature. This includes an HTML shell, a Vite configuration enabling devtools during the serve phase, and a Vue-based counter component that automatically increments and decrements to demonstrate reactivity.

playground/devtools · high confidence

The repository replaces Prettier with Oxfmt as the primary code formatter, introducing a new \.oxfmtrc.json\ configuration that enforces style rules such as no semicolons, single quotes, and import sorting, while removing the legacy \.prettierrc\ file. This change is accompanied by the addition of standard repository configuration files including \.editorconfig\ and \.gitattributes\ to enforce consistent line endings and whitespace, and a comprehensive \CONTRIBUTING.md\ guide that updates setup instructions for the pnpm workspace and details the new testing and debugging workflows.

(repo-wide) · high confidence

The dependency pre-bundling and scanning process in the Vite optimizer has been migrated from esbuild to Rolldown. This change introduces a new \rolldownOptions\ configuration property to replace the deprecated \esbuildOptions\ and \rollupOptions\, allowing users to pass Rolldown-specific settings during dependency optimization. The migration includes a plugin converter to maintain compatibility with existing esbuild plugins, updates to the dependency resolution and scanning logic to use Rolldown's API, and adjustments to how external modules and assets are handled during the pre-bundling phase.

packages/vite/src/node/optimizer · high confidence

Vite no longer supports Node.js 18. Users must upgrade to a supported Node.js version to run the development server and build tools.

packages/vite/src/node · high confidence

The external playground has been updated to test how Vite handles externalized packages via import maps and direct npm file serving. The new setup uses an import map to resolve 'vue', 'slash3', and 'slash5' to specific versions served directly from the public directory or node\_modules, allowing the application to verify that these external dependencies are correctly preserved and accessible at runtime without being bundled. This change also introduces a custom middleware to serve npm code directly and configures rolldown and commonjs options to ensure proper handling of these externalized modules during both development and build.

playground/external · high confidence

Vite now ships with inlined TypeScript type definitions for several internal dependencies (chokidar, ws, connect, anymatch, rollup alias, commonjs, and dynamic import vars) within the \packages/vite/src/types\ directory. By inlining these types, Vite removes the need for consumers to install these specific type packages separately, ensuring that TypeScript builds work correctly out-of-the-box without extra dependency resolution steps.

packages/vite/src/types · high confidence

New internal TypeScript definition files have been added to centralize and standardize type imports for Vite's optional dependencies. This includes dedicated modules for CSS preprocessors (Sass, Less, Stylus, LightningCSS), esbuild, Terser, and devtools, ensuring that type checking works correctly even when these packages are not installed. Additionally, Rollup types are now aliased to Rolldown types with deprecation notices, aligning Vite's internal type exports with the underlying bundler implementation.

packages/vite/types/internal · high confidence

The library build playground has been restructured to use ESM configuration files (vite.config.js) and includes new test scenarios for CSS code-splitting, dynamic imports, named exports, and helper injection. The main configuration now uses \import.meta.dirname\ for path resolution and explicitly sets esbuild supported features to test helper injection logic. New HTML demo pages have been added to test production builds across ES, UMD, and IIFE formats, including specific tests for preserving \process.env.NODE\_ENV\ and custom output filenames.

playground/lib · high confidence

The repository now includes a new set of TypeScript scripts in the \scripts/\ directory (\detect-release.ts\, \extract-changelog.ts\, \mergeChangelog.ts\, \prepare-release.ts\, \publishCI.ts\, \releaseUtils.ts\) that leverage the \@vitejs/release-scripts\ package to handle release workflows. These scripts automate detecting release commits, generating and merging changelog entries (including merging prerelease notes into stable versions), updating \create-vite\ template versions, and publishing packages. A shell script \docs-check.sh\ was also added to optimize CI by skipping doc builds when no relevant files have changed. This represents a shift in how releases are prepared and published, moving logic into dedicated, typed scripts rather than ad-hoc shell commands or CI workflow definitions.

scripts · high confidence

The playground/alias location has been converted to an ESM module, updating the configuration to use \import.meta.dirname\ for path resolution and adding a custom resolver for aliasing. The example now demonstrates a wider range of aliasing capabilities, including resolving to local files, directory aliases, regex-based patterns, URL-conflict patterns, and aliasing optimized dependencies like Vue to specific builds or absolute URLs.

playground/alias · high confidence

The playground directory has been relocated from its previous subdirectory to the root of the repository. This change updates the file paths for all playground examples, including the multiple-entrypoints, resolve-linked, and tsconfig-json-load-error test cases, which are now accessible directly under the new root-level playground folder.

(repo-wide) · high confidence

The Preact starter template has been redesigned to align with the new Vite documentation theme. This update introduces a modern, responsive layout featuring a hero section with 3D-transformed logos, a dedicated 'next steps' area for documentation and community links, and a fully updated CSS architecture using CSS variables for light and dark mode support. The visual style now uses system fonts, updated color palettes, and refined typography, providing a more polished and consistent look for new projects.

packages/create-vite/template-preact/src · high confidence

The React TypeScript starter template now uses Oxlint for linting instead of ESLint, with a default \.oxlintrc.json\ configuration that enables React and TypeScript plugins. The TypeScript configuration has been modernized to use project references (\tsconfig.app.json\ and \tsconfig.node.json\), targeting ES2023, and enabling strict type-checking options like \verbatimModuleSyntax\, \moduleDetection: force\, and \erasableSyntaxOnly\. The template also includes a note that the React Compiler is not enabled by default due to performance impacts, with documentation on how to enable it manually.

packages/create-vite/template-react-ts · high confidence

The React starter template has been updated to use Oxlint for linting instead of ESLint, featuring a new \_oxlintrc.json configuration with React and Oxc plugins. The README has been refreshed to reflect this change, document the available plugins (@vitejs/plugin-react and @vitejs/plugin-react-swc), and clarify that the React Compiler is not enabled by default due to performance impacts. Additionally, the template includes a standardized .gitignore file and a minimal index.html setup.

packages/create-vite/template-react · high confidence

The React TypeScript starter template has been completely overhauled to align with the new Vite documentation theme. The new landing page features a 3D-stacked hero section displaying the Vite, React, and framework logos, replacing the previous layout. The design now supports both light and dark modes using CSS variables, includes a dedicated 'Next Steps' section with links to Vite and React documentation, and provides social connection links for GitHub, Discord, X.com, and Bluesky. The counter button has been updated with \type="button"\ to prevent unintended form submissions, and the entry point now uses \createRoot\ with \StrictMode\.

packages/create-vite/template-react-ts/src · high confidence

The React starter template has been completely redesigned to align with the new Vite documentation theme. The new layout features a centered hero section with 3D-styled framework logos, a prominent counter button, and a 'Next Steps' section providing direct links to Vite and React documentation as well as community channels (GitHub, Discord, X, Bluesky). The visual style now uses a modern color palette with CSS variables supporting both light and dark modes, system fonts, and responsive adjustments for smaller screens.

packages/create-vite/template-react/src · high confidence

The type definitions in \packages/vite/types\ have been reorganized into dedicated files (\customEvent.d.ts\, \hmrPayload.d.ts\, \hot.d.ts\, \importGlob.d.ts\, \importMeta.d.ts\, \metadata.d.ts\) to improve clarity and maintainability. For users, this brings stricter and more precise typing for \import.meta.glob\, including support for the new \query\ option (deprecating \as\), \caseSensitive\, and \base\ options, as well as generic type inference for eager vs. lazy imports. The \ViteHotContext\ interface now includes \off\ and \send\ methods with typed payloads for custom events (e.g., \vite:beforeUpdate\, \vite:ws:connect\), and the \ImportMeta\ interface exposes these typed contexts. Additionally, \CustomPluginOptionsVite\ is now explicitly typed for Rollup/Rolldown plugins, supporting \cssScopeTo\ for CSS treeshaking, and \viteMetadata\ is correctly marked as optional on \RenderedChunk\ and \OutputAsset\.

packages/vite/types · high confidence

The SSR module loading in development now correctly resolves aliases for dependencies that are not explicitly marked as external or built-in. This ensures that custom alias mappings (such as those defined in the \resolve.alias\ configuration) are consistently applied to all importable modules during SSR, including third-party or non-builtin packages, aligning development behavior with production build expectations.

playground/ssr-alias · high confidence

The Svelte starter template has been upgraded to Svelte 5, replacing the previous layout with a modern, responsive design that includes a hero section with framework logos, a counter component, and updated documentation links. The new template features a refreshed visual style with CSS variables for light and dark mode support, improved typography, and accessibility enhancements such as \rel="noreferrer"\ on external links.

packages/create-vite/template-svelte/src · high confidence

The Tailwind CSS playground has been updated to use Tailwind CSS v4, introducing a new configuration structure that utilizes the \@import 'tailwindcss'\ directive in \index.css\ and a \tailwind.config.ts\ file referencing \import.meta.dirname\ for content paths. The Vite configuration now includes the \@tailwindcss/vite\ plugin and custom plugins to manage CSS loading and view transformation delays for testing purposes.

playground/tailwind · high confidence

The Lit TypeScript starter template has been refreshed to align with the new Vite documentation theme. This includes a complete redesign of the UI with updated CSS variables for light and dark modes, a new layout structure, and updated branding assets. The template now uses the \lit\ package instead of \lit-element\, includes a \type="button"\ attribute on the counter button to prevent accidental form submissions, and updates all external links to point to the new vite.dev domain.

packages/create-vite/template-lit-ts/src · high confidence

The Lit starter template has been refreshed to align with the new Vite documentation theme. This includes a complete redesign of the UI with a new layout, updated styling (including dark mode support and brand colors), and a migration from the legacy \lit-element\ package to the modern \lit\ library. The template now features a counter component, updated documentation links pointing to vite.dev, and improved accessibility attributes.

packages/create-vite/template-lit/src · high confidence

The Preact TypeScript starter template has been updated to use stricter TypeScript settings and modern build targets. The configuration now targets ES2023, uses the 'bundler' module resolution for app code and 'nodenext' for Node-side config, and enables strict type-checking options like 'verbatimModuleSyntax', 'moduleDetection: force', and 'erasableSyntaxOnly'. It also introduces a solution-style tsconfig setup (separate tsconfig.app.json and tsconfig.node.json) to properly type-check vite.config.ts, adds @types/node for Node environment support, and configures the JSX transform to use 'react-jsx' with 'jsxImportSource: preact'.

packages/create-vite/template-preact-ts · high confidence

The Preact TypeScript starter template has been refreshed to align with the new Vite documentation theme. This includes a redesigned layout with a hero section featuring the Preact and Vite logos, a counter component, and a 'next steps' section linking to documentation and community channels. The visual style now uses CSS variables for light and dark mode support, updated typography (removing the Inter font in favor of system fonts), and responsive adjustments for mobile viewports.

packages/create-vite/template-preact-ts/src · high confidence

The Svelte TypeScript starter template has been refreshed with a redesigned UI that includes a hero section with 3D-transformed logos, updated typography using system fonts, and a dark mode color scheme. The template now links to the new vite.dev domain and includes accessibility improvements such as adding rel="noreferrer" to external links and removing non-standard styles.

packages/create-vite/template-svelte-ts/src · high confidence

The Svelte starter templates (both JavaScript and TypeScript variants) have been updated to use Svelte 5, evidenced by the adoption of the \$state\ rune for reactive variables. Additionally, the Counter component now explicitly sets \type="button"\ on the button element to ensure consistent and accessible behavior across templates.

packages/create-vite/template-svelte-ts/src/lib, packages/create-vite/template-svelte/src/lib · high confidence

The vanilla TypeScript starter template now includes a new \_gitignore file to exclude common build artifacts and editor files, and an index.html entry point that loads the application from src/main.ts. The tsconfig.json has been updated to use stricter TypeScript settings, including target es2023, moduleResolution bundler, verbatimModuleSyntax, moduleDetection force, and erasableSyntaxOnly, ensuring modern module handling and stricter type checking for new projects.

packages/create-vite/template-vanilla-ts · high confidence

The Vue TypeScript starter template has been updated to align with the new Vite documentation theme. This includes a complete overhaul of the default \style.css\ with modern CSS variables for light and dark mode support, updated typography (removing the Inter font in favor of system fonts), and revised component styles for the \App.vue\ and \HelloWorld.vue\ components. The template now features a responsive layout, improved accessibility focus states, and visual updates to the hero section and counter button to match the current Vite brand identity.

packages/create-vite/template-vue-ts/src · high confidence

The starter template for Vue with TypeScript now features a redesigned landing page in the HelloWorld component. This update aligns the template's visual style with the official documentation, incorporating a new hero section with framework logos, a counter button explicitly defined as type="button" to prevent accidental form submissions, and updated links to Vite and Vue documentation as well as community channels like GitHub, Discord, and X.

packages/create-vite/template-vue-ts/src/components · high confidence

The Vue TypeScript starter template now uses a stricter TypeScript configuration aligned with modern best practices. Key changes include setting the Node.js target to ES2023, enabling \verbatimModuleSyntax\ and \moduleDetection: force\ in \tsconfig.node.json\, and adding \erasableSyntaxOnly\ to both app and node configs. The template also introduces \tsBuildInfoFile\ for incremental builds, extends from \@vue/tsconfig\, and updates the README to link to the current Vue TypeScript documentation.

packages/create-vite/template-vue-ts · high confidence

The Vue starter template's HelloWorld component has been replaced with a redesigned layout that includes a hero section with framework logos, a counter button, and new sections for documentation links and community social channels (GitHub, Discord, X, Bluesky). Additionally, the counter button now explicitly uses type="button" to prevent unintended form submission behavior, improving accessibility and consistency.

packages/create-vite/template-vue/src/components · high confidence

The playground TypeScript configurations now enable \verbatimModuleSyntax\ and \experimentalDecorators\. This ensures that type-only imports are strictly preserved as type annotations (preventing runtime import side effects) and that class/method decorators are correctly processed by the compiler.

playground/tsconfig-json · high confidence

The vanilla starter template now includes a dedicated \\_gitignore\ file to standardize ignored artifacts (logs, node\_modules, editor files) and an \index.html\ that serves as the entry point, linking to \main.js\ and setting the page title to 'Vite + JS'.

packages/create-vite/template-vanilla · high confidence

The vanilla TypeScript starter template has been refreshed to align with the new Vite documentation theme. This includes a complete redesign of the UI with updated CSS variables for light and dark modes, new typography settings, and a restructured layout featuring a hero section with 3D-transformed logos and a dedicated 'next steps' area for documentation and community links. The template now uses a dedicated \counter.ts\ module for interactivity and imports assets via Vite's module resolution, ensuring the generated project reflects the current brand identity and best practices.

packages/create-vite/template-vanilla-ts/src · high confidence

The vanilla starter template has been updated to feature a redesigned landing page with a new hero section, documentation links, and social community connections. The visual style now includes a purple accent color and full support for system dark mode, while the interactive counter component has been refactored into a separate module. New SVG assets for JavaScript and Vite are included, and the previous Inter font dependency has been removed in favor of system fonts.

packages/create-vite/template-vanilla/src · high confidence

The Vite core package now includes the release notes and bug fixes for version 8.3.1. This update addresses several issues including handling \server.ws: false\ in \mergeConfig\, correctly merging \build.rolldownOptions.output.comments\, and preventing the optimizer from skipping imports whose binding starts with \type\. It also fixes a server watcher reinitialization issue when adding a file after the server closes, skips URL source roots when injecting source content, and resolves pending discovered dependency processing on close before initialization. Additionally, non-major dependencies and rolldown-related dependencies have been updated.

packages/vite · high confidence

The Vite CLI entry point has been migrated to native ES modules (vite.js), introducing several user-facing capabilities and behavioral changes. Users can now name CPU profiles using the --profile flag (e.g., --profile myprofile), which writes the profile to \<name\>.cpuprofile. Debug mode (-d/--debug) now merges debug parameters instead of overwriting existing ones, and supports a new -f/--filter flag to narrow debug output. Source maps are enabled by default during development but can be disabled via the DEBUG\_DISABLE\_SOURCE\_MAP environment variable. Performance is improved by enabling Node's compile cache (module.enableCompileCache) and flushing it after 10 seconds. Additionally, unhandled promise rejections are now thrown as errors to aid debugging, and the macOS Chrome opening helper (openChrome.js) has been rewritten from AppleScript to JXA for better compatibility.

packages/vite/bin · high confidence

The Vue starter template has been updated to align with the new Vite documentation theme. This includes a complete redesign of the visual style with new CSS variables for light and dark modes, updated typography (removing the Inter font in favor of system fonts), and a new centered layout structure. The template now features a hero section with framework branding and a 'next steps' footer, providing a more polished and consistent starting point for new Vue projects.

packages/create-vite/template-vue/src · high confidence

The create-vite scaffolding tool has been updated to version 9.2.1, introducing support for the Nub package manager in addition to existing options like npm, yarn, pnpm, bun, and deno. This release also includes routine updates to non-major dependencies and rolldown-related packages, alongside fixes for ESLint plugin links in generated READMEs and improvements to the linter selection prompt. The tool now requires Node.js 20.19+ or 22.12+ and uses tsdown for bundling, with template files licensed under CC0 1.0 Universal.

packages/create-vite · high confidence

A new main.js file has been added to the lib directory of the dep-relative-to-main playground. This file serves as the module entry point, exporting a success message string to verify that the dependency resolution relative to the main field is functioning correctly.

playground/optimize-deps/dep-relative-to-main · high confidence

The CSS minification process in the playground now correctly handles explicit comments (such as those starting with /\*!). This change ensures that intentional legal or explicit comments in CSS files are preserved during the minification process, rather than being stripped out, by aligning the behavior with esbuild's legalComments configuration.

playground/minify/dir · high confidence

Resolves an issue where the HMR WebSocket connection would fail when using Vite in custom middleware mode with a custom server instance. This ensures reliable hot module reloading in environments where Vite is integrated as middleware rather than running its own standalone server.

packages/vite/src/node/plugins · high confidence

This change fixes an issue where absolute imports were incorrectly having the Vite base path stripped. The playground demonstrates that absolute imports now correctly retain their base prefix, ensuring that modules resolved via virtual modules or absolute paths function as expected when a non-root base is configured.

playground/base-conflict · high confidence

The playground now correctly preserves default exports from externalized packages, resolving issue \#10258. This change ensures that modules relying on default exports (such as Vue) are properly accessible when required, preventing runtime errors in scenarios where external dependencies are bundled or externalized.

playground/external/dep-that-requires · high confidence

Resolves a race condition in the bundled dev server where lazy-loaded chunks could omit shared module factories, causing \MissingFactoryError\ in the browser. The fix ensures the server waits for the client to report that a chunk has been fully delivered and evaluated before marking it as such, preventing later chunks from incorrectly skipping shared dependencies that are still in flight.

playground/lazy-compilation · high confidence

This change fixes how Vite handles relative module paths when serving HTML files located in directories with trailing slashes. The fix ensures that relative imports (such as \./filename.js\ and \../other.js\) within an HTML file inside a subdirectory are correctly resolved and loaded, preventing broken script references in SSR HTML scenarios.

playground/ssr-html/trailing-slash · high confidence

The module runner now includes a dedicated source map subsystem (decoder, interceptor, and index) to provide more accurate stack traces and error locations. This change fixes several bugs where stack trace interception would fail or produce incorrect column numbers, particularly when \Object.prototype\ was frozen, when negative column values appeared in stack traces, or when \globalThis.Buffer\ was absent. It also ensures that source maps are resolved correctly for modules evaluated by the runner.

packages/vite/src/module-runner/sourcemap · high confidence

This update applies patches to three dependencies to fix bugs and add capabilities. For chokidar, path normalization is added to prevent file watcher removal failures, and an ignored-file check is added to the fsevents callback to improve performance. For dotenv-expand, the patch enables progressive expansion across multiple files by using the provided parsed object instead of a local one. For sirv, a new shouldServe option allows callers to filter which files are served, and a minor fix ensures the base directory path ends with a separator in development mode.

patches · high confidence

A pre-bundled version of the slash@3.0.0 library has been added to the public directory to mitigate network instability during CI runs. By serving this local copy instead of fetching it from esm.sh, the SSR HTML playground reduces its dependency on external network requests, ensuring more reliable and faster module loading in automated environments.

playground/ssr-html/public · high confidence

When a JavaScript file contains only CSS imports and no other code, the build process no longer generates an empty JavaScript chunk for it. This fix ensures that assets like \async-js.js\ (which imports \async-js.css\) are correctly removed from the output, keeping the build cleaner and avoiding unnecessary empty files.

playground/css-no-codesplit · high confidence

Add CSS and asset test fixtures for backend integration; Add CSS sourcemap playground with multi-preprocessor and library build support; Add CSS style files for playground backend-integration tests; Add CommonJS dependency test fixture for define replacement; Add HMR root playground to test watching files outside the root directory; Add client-reload playground test suite; Add define playground to test environment-specific configuration; Add e2e test for missing dependency optimization; Add minify playground to test CSS and JS minification configurations; Add playground extension for Vue ESM bundling; Add playground fixtures for file-serving security tests; Add playground test for CLI module resolution in type:module packages; Add playground test for Vite proxying HMR to another Vite server; Add playground to test Lightning CSS URL resolution with custom root; Add playground to test disabling automatic dependency discovery; Add playground/json test suite for JSON import behaviors; Add proxy-bypass playground demonstrating async bypass and error handling; Added CLI integration tests for create-vite scaffolding; Added CLI playground tests for Vite server and build commands; Added SSR Pug playground tests for script injection behavior; Added SSR playground tests for circular imports and import.meta support; Added SSR runtime test fixtures; Added SSR runtime test fixtures for cyclic imports and live bindings; Added SSR test fixtures for error handling and import.meta metadata; Added TypeScript declaration tests for Vite's core APIs; Added assets-sanitize playground to test filename sanitization and .env denial; Added backend-integration test suite for asset and CSS handling; Added comprehensive test coverage for file serving security and edge cases; Added comprehensive test suite for import.meta.glob functionality; Added end-to-end tests for the CLI module in ESM packages; Added library build and serve tests; Added library build test fixtures for CSS, helpers, and environment variables; Added missing dependency test case for multi-entry optimization; Added playground test assets for directory aliasing; Added playground test for dynamic import inlining; Added preload playground to test module preloading configurations; Added snapshot tests for SSR module load parse errors; Added snapshot tests for dynamic import variable parsing; Added snapshot tests for license output formats; Added snapshot tests for module preload polyfill behavior; Added test coverage for Vite server internals; Added test coverage for dynamic CSS import duplication; Added test entry point for transform-plugin base tests; Added test fixture for multi-source sourcemaps; Added test fixture for optimizer discovery before listen; Added test fixtures for JSX runtime scanning; Added test fixtures for SSR syntax errors; Added test fixtures for Vite Runtime API; Added test fixtures for config resolution scenarios; Added test fixtures for dependency resolution conditions; Added test fixtures for dynamic import variables; Added test fixtures for environment aliasing and asset emission; Added test fixtures for import.meta.glob edge cases; Added test fixtures for license plugin validation; Added test fixtures for module runner config import; Added test fixtures for modules with spaces in paths; Added test fixtures for native compatibility configuration scenarios; Added test for CSS application on dynamic imports; Added test for CSS lib entry sourcemap generation; Added test for chunk importmap 404 errors; Added test for legacy client and SSR sequential builds; Added test for legacy styles-only entry watch rebuilds; Added tests for CSP nonce handling and script execution in the playground; Added tests for CSS LightningCSS playground; Added tests for CSS code-splitting and asset deduplication behavior; Added tests for CSS code-splitting and empty chunk handling; Added tests for CSS minification and style tag handling; Added tests for CSS sourcemap generation in the playground; Added tests for CSS sourcemap generation with Lightning CSS; Added tests for React SSR environment dependency optimization; Added tests for SSR no-external playground; Added tests for SSR resolve conditions; Added tests for Tailwind CSS playground HMR and rendering; Added tests for Tailwind CSS sourcemap warnings; Added tests for WASM playground scenarios; Added tests for dynamic import variable parsing; Added tests for environment variable handling and expansion; Added tests for external package handling and import map ordering; Added tests for file system deny rules with query strings and globs; Added tests for import.meta.glob parsing and transformation; Added tests for legacy build polyfill and preload behavior; Added tests for legacy modern-target polyfill behavior; Added tests for legacy plugin core logic and documentation; Added tests for optimizer edge cases and plugin conversion; Added tests for playground alias resolution; Added tests for the define plugin's environment variable replacement behavior; Added tests for the module preload polyfill plugin; Added tests for transform-plugin module type support and lazy hook filtering; Added tests for tsconfig JSON load error handling; Added tests for tsconfig.json playground behavior; Added unit tests for Vite core modules and test fixtures; Added unit tests for Vite plugin system internals; CSS playground tests migrated to Vitest; Expanded HMR playground tests for acceptExports and edge cases; Expanded \import.meta.glob\ playground coverage; Expanded file-system serve security and edge-case test coverage; Expanded test coverage for SSR module loading and transformation; Expanded test coverage for SSR module runner runtime; Extracted common test suite for fs-serve playground; Legacy plugin playground expanded with comprehensive test scenarios; New HTML playground for testing HTML processing features; New JS sourcemap playground for debugging and validation; New SSR conditions playground demonstrating custom resolve conditions; New SSR playground for testing external CJS module handling; New SSR resolution playground for testing deep imports and module conditions; New asset handling playground and test suite; New comprehensive test suite for dependency optimization behavior; New playground for HMR full bundle mode; New playground test for CSS LightningCSS SSR proxy; New playground tests for transform plugin capabilities; New playgrounds for SSR dependencies and Pug rendering; Playground added to verify tsconfig paths resolution; Playground adds CSS code-splitting test scenarios; Playground for dynamic import with variables is restructured and expanded; Playground test for object-style hook configuration; Playground test for preserved import order in module graph; Playground test infrastructure modernized with Vitest v4 and Rolldown; Playground test suite for chunk import map feature; Playground tests for module resolution behavior; Playground: data-uri tests migrated to Vitest with quote-handling fixes; SSR Hot Module Replacement test suite and playground; SSR external CJS module handling test fixtures; SSR external module condition resolution playground; SSR playground now tests circular dependency resolution and import.meta support; Updated snapshot tests for import.meta.glob plugin; Worker playground tests migrated to ESM and expanded with new scenarios.

The rolldown-related dependencies have been updated to their latest versions. This ensures compatibility with the latest rolldown releases and incorporates any upstream fixes or improvements.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 42 → 49 (+6.8)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 69 → 62 (-6.9)
• Architecture 37 (new)
• Maturity 63 → 55 (-7.7)
• Readiness 17 → 63 (+45.2)
• Security 73 → 82 (+8.5)
• Accessibility 60 (new)

• Dimension evaluation failed
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• LLM evaluation failed
• Low CVE: [GHSA redacted] (pnpm-lock.yaml)
• Low: security finding (details withheld)
• Low: security finding (details withheld)
• Low: security finding (details withheld)
• Medium CVE: [GHSA redacted] (pnpm-lock.yaml)
• Medium CVE: [GHSA redacted] (pnpm-lock.yaml)
• Medium CVE: [GHSA redacted] (pnpm-lock.yaml)
• Medium CVE: [GHSA redacted] (pnpm-lock.yaml)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• …and 11 more

• BundledDevHMRClient.applyUpdate (cognitive 17) (packages/vite/src/client/bundledDevHmrClient.ts)
• Change coupling: client.ts ↔ customEvent.d.ts (packages/vite/src/client/client.ts)
• Coverage not measured — JavaScript/TypeScript suite
• DevEnvironment.constructor (cyclomatic 16) (packages/vite/src/node/server/environment.ts)
• Documentation: hard to navigate (docs/blog.md)
• EnvironmentPluginContainer.resolveId (cognitive 32) (packages/vite/src/node/server/pluginContainer.ts)
• EnvironmentPluginContainer.resolveId (cyclomatic 24) (packages/vite/src/node/server/pluginContainer.ts)
• EnvironmentPluginContainer.transform (cognitive 34) (packages/vite/src/node/server/pluginContainer.ts)
• EnvironmentPluginContainer.transform (cyclomatic 16) (packages/vite/src/node/server/pluginContainer.ts)
• FileTooLong: node/build.ts (packages/vite/src/node/build.ts)
• FileTooLong: node/config.ts (packages/vite/src/node/config.ts)
• FileTooLong: node/utils.ts (packages/vite/src/node/utils.ts)
• FileTooLong: optimizer/index.ts (packages/vite/src/node/optimizer/index.ts)
• FileTooLong: optimizer/scan.ts (packages/vite/src/node/optimizer/scan.ts)
• FileTooLong: plugins/asset.ts (packages/vite/src/node/plugins/asset.ts)
• FileTooLong: plugins/css.ts (packages/vite/src/node/plugins/css.ts)
• FileTooLong: plugins/html.ts (packages/vite/src/node/plugins/html.ts)
• FileTooLong: plugins/importAnalysis.ts (packages/vite/src/node/plugins/importAnalysis.ts)
• FileTooLong: plugins/importMetaGlob.ts (packages/vite/src/node/plugins/importMetaGlob.ts)
• FileTooLong: plugins/resolve.ts (packages/vite/src/node/plugins/resolve.ts)
• …and 813 more

• 155 commits — 107 feature/other, 48 fixes

• packages/vite — 70 commits
• (root) — 24 commits
• packages/create-vite — 13 commits
• .github/workflows — 11 commits
• docs/config — 8 commits
• docs/guide — 8 commits
• docs/.vitepress — 4 commits
• playground/assets — 3 commits
• playground/css — 2 commits
• playground/hmr — 2 commits
• docs/_data — 1 commit
• docs/blog — 1 commit
• docs/plugins — 1 commit
• packages/plugin-legacy — 1 commit
• playground/css-lightningcss — 1 commit
• playground/dynamic-import — 1 commit
• playground/lazy-compilation — 1 commit
• playground/test-utils.ts — 1 commit
• playground/worker — 1 commit
• scripts/mergeChangelog.ts — 1 commit

• fix: chore: fix ts errors in build test cases (#23209)
• fix: chore: fix ts-check comment ordering (#23386)
• fix: fix(build): keep hash placeholders as-is in resolveFileUrl hook (#23422)
• fix: fix(bundled-dev): handle lazy request error (#23291)
• fix: fix(bundled-dev): hot update through circular imports instead of reloading (#23259)
• fix: fix(bundled-dev): mark payload delivered on client report (#23373)
• fix: fix(bundled-dev): serve the rolldown runtime from the installed rolldown (#23568)
• fix: fix(config): close bundles when generation fails (#23256)
• fix: fix(config): resolve sourcemap paths against sourcemap location (#23239)
• fix: fix(create-vite): add router only options for tanstack router/start (#23543)
• fix: fix(create-vite): update moved eslint-react plugin links in generated README (#23284)
• fix: fix(css): don't pass empty targets to lightningcss (#23295)
• fix: fix(css): keep newline-separated srcset candidates intact (#23265)
• fix: fix(define): fix match escaped dots to support $-prefixed define keys (#23249)
• fix: fix(deps): update all non-major dependencies (#23217)
• fix: fix(deps): update all non-major dependencies (#23337)
• fix: fix(deps): update all non-major dependencies (#23404)
• fix: fix(deps): update all non-major dependencies (#23445)
• fix: fix(deps): update all non-major dependencies (#23482)
• fix: fix(deps): update all non-major dependencies (#23537)
• …and 135 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

vitejs/vite was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.