vuejs/core

This system is the Vue.js framework, a comprehensive library for building user interfaces with a component-based architecture. It provides a reactivity engine, a modular compiler for templates and single-file components, and runtime environments for both browser DOM and server-side rendering. The codebase also includes tooling for development, testing, and migration from previous versions.

26 changes.

This period established the foundational architecture for Vue 3 by initializing the repository with modern tooling and rewriting the compiler and reactivity systems. It involved a major structural shift, removing legacy Vue 2 components and observers while introducing a modular package structure with distinct runtime, compiler, and compatibility layers. The work also included implementing new APIs for custom elements and server-side rendering, alongside comprehensive build tooling updates to support ESM and optimized bundling.

28 changes.

This period focused on the complete architectural rewrite of Vue 3's core packages, including a new version-based reactivity system, a block-tree-optimized compiler, and built-in components like Transition and Suspense. Extensive test suites were added across all packages to verify the correctness of these new runtime and compilation features. The work also included the implementation of Single File Component (SFC) compilation and the creation of comprehensive examples for the new Composition API.

28 changes.

This period focused on establishing robust server-side rendering capabilities through the introduction of a dedicated SSR compiler, specialized runtime helpers, and comprehensive test coverage. Concurrently, the project modernized its developer ecosystem by launching the SFC Playground and Template Explorer, while refactoring the Single-File Component compiler into modular, maintainable components.

The new @vue/runtime-test package is introduced to provide a DOM-agnostic runtime environment for Vue's internal tests, offering faster execution than JSDOM. It also serves as a reference implementation for developers building custom renderers, exposing core APIs like h, render, nodeOps, and dumpOps. The package includes standard distribution files (CJS production and development builds) and is licensed under MIT.

packages/runtime-test · high confidence

A new interactive Template Explorer has been added to the private packages, providing a live UI to view the compiled JavaScript output and AST of Vue templates. The tool features a Monaco Editor for input, displays compiler errors as markers, and allows toggling compiler options such as SSR mode, module/function mode, and various optimization flags. It is accessible at template-explorer.vuejs.org and includes redirects from the previous vue-next-template-explorer.netlify.app domain.

packages-private/template-explorer · high confidence

Vue now provides an automatic JSX runtime (exposed via \packages/vue/jsx-runtime\) that allows developers to use JSX syntax with TypeScript's \jsx: 'react-jsx'\ or \jsx: 'react-jsxdev'\ compiler options. This runtime handles the transformation of JSX elements into Vue VNodes, correctly managing children and keys, and exports the necessary types and \Fragment\ component to ensure seamless integration with modern build tools and TypeScript configurations.

packages/vue/jsx-runtime · high confidence

New standalone HTML examples (commits, grid, markdown, svg, todomvc, tree) have been added to the classic Vue 2.x example set. These demos demonstrate core Vue 2.x patterns such as component registration, computed properties, watchers, and event handling, and they are updated to use the Vue.createApp API signature.

packages/vue/examples/classic · high confidence

The @vue/runtime-core package now includes a standard entry point (index.js) that loads the appropriate CommonJS build based on the environment, along with a README explaining its purpose for building custom renderers and a LICENSE file. This makes the package ready for consumption by developers creating custom rendering targets, clarifying that it is not intended for direct use in application code.

packages/runtime-core · high confidence

The project now publishes a funding manifest at the standard .well-known location, pointing to https://vuejs.org/funding.json. This allows tools and platforms that support the Open Collective funding manifest specification to discover and display funding information for the project.

.well-known · high confidence

New example files have been added to the Vue transition examples directory to demonstrate list animations and modal overlays. The list example showcases \transition-group\ with fade and move animations for inserting, removing, and shuffling items, while the modal example demonstrates using the \teleport\ API to render a modal component outside the app root, including custom slot content and CSS transitions for visibility toggling.

packages/vue/examples/transition · high confidence

Added the \Transition\ and \TransitionGroup\ components in \packages/runtime-dom/src/components\. These components wrap the platform-agnostic \BaseTransition\ logic with DOM-specific CSS transition and animation handling, including support for enter/leave/appear classes, duration validation, move animations for list reordering, and compatibility with Vue 2 transition behaviors.

packages/runtime-dom/src/components · high confidence

This change introduces the core SSR compiler transform logic located in \packages/compiler-ssr/src/transforms\. It adds dedicated handlers for structural directives (\v-if\, \v-for\), form bindings (\v-model\, \v-show\), and built-in components (\Transition\, \TransitionGroup\, \Teleport\, \Suspense\). Additionally, it includes logic to inject CSS variables and handle attribute fallthroughs, enabling the compiler to generate correct server-side rendered output for these Vue features.

packages/compiler-ssr/src/transforms · high confidence

This change introduces the new \packages/vue\ package, providing a unified entry point for Vue that supports various runtime environments. It includes build artifacts for global browser usage (IIFE), native ES modules, bundler integration (ESM with tree-shaking support), and Node.js server-side rendering (CJS). The package also adds TypeScript definitions for global JSX namespace registration (\jsx.d.ts\) to enable JSX syntax support in TypeScript projects, and exposes compile-time feature flags (such as \\_\_VUE\_PROD\_HYDRATION\_MISMATCH\DETAILS\\_\) for bundler optimization.

packages/vue · high confidence

A new \@vue/compat\ package is introduced to support upgrading Vue 2 applications to Vue 3. This build runs in Vue 2 mode by default, providing configurable Vue 2 compatible behavior and emitting runtime warnings for deprecated or changed features. It is intended for migrating Vue 2 apps to Vue 3, helping developers identify breaking changes and gradually adopt Vue 3 APIs.

packages/vue-compat · high confidence

A new standalone Single-File Component playground is available at play.vuejs.org, allowing users to write, run, and share Vue code directly in the browser. The playground supports switching between Vue and TypeScript versions, toggling production and server-side rendering modes, and automatically adapting to the system's dark or light theme. It features auto-save functionality, a version selector that limits pre-release noise, and the ability to download the current project as a zip file.

packages-private/sfc-playground/src · high confidence

This change introduces the core built-in components for Vue's runtime: BaseTransition (providing enter/leave/appear animation hooks and mode handling), KeepAlive (caching inactive component instances to preserve state), Suspense (handling asynchronous dependencies with fallback UI), and Teleport (rendering child content into a different DOM location). These components are now available as first-class built-ins within the runtime-core package, enabling declarative animations, state persistence, async loading boundaries, and DOM portaling directly in templates.

packages/runtime-core/src/components · high confidence

Adds a new \@vue/compiler-ssr\ package that provides a specialized compiler for server-side rendering. This includes a new \compile\ entry point that configures the AST transform pipeline specifically for SSR (e.g., disabling static hoisting, prefixing identifiers), defines a set of SSR-specific runtime helpers (such as \ssrRenderVNode\, \ssrRenderComponent\, \ssrRenderTeleport\), and implements error codes for SSR-specific issues like missing teleport targets or unsafe attribute names.

packages/compiler-ssr/src · high confidence

The server-renderer package now includes a new set of helper modules in \packages/server-renderer/src/helpers\ to manage specific rendering tasks. These include \ssrCompile\ for on-the-fly template compilation (restricted to CJS builds), \ssrRenderAttrs\ and \ssrRenderClass\ for handling HTML attributes and classes (including \className\ support), \ssrRenderSlot\ for rendering slot content with fragment handling, \ssrRenderTeleport\ for portal support, \ssrRenderSuspense\ for Suspense boundaries, \ssrRenderList\ for v-for iteration with validation, \ssrGetDirectiveProps\ for directive SSR properties, \ssrInterpolate\ for text interpolation, \ssrRenderComponent\ for component rendering, and \ssrVModelHelpers\ for input model binding. This refactoring centralizes SSR-specific rendering logic into dedicated, reusable functions.

packages/server-renderer/src/helpers · high confidence

This change introduces the \defineCustomElement\ API in \packages/runtime-dom/src/apiCustomElement.ts\, allowing Vue components to be registered as native Web Components with support for shadow DOM, scoped styles, and custom element options. It replaces the legacy \patchData\ and \teardownVNode\ mechanisms with a new \patchProp\ implementation that handles modern prop/attribute reflection, including support for \.prop\ and \.attr\ modifiers and specific handling for Vue custom elements. Additionally, \nodeOps\ is expanded to support MathML namespaces, static content caching, and Trusted Types compatibility for safer innerHTML handling.

packages/runtime-dom/src · high confidence

This change adds the core runtime logic for three key directives in the DOM runtime. The v-model directive now handles text, checkbox, and select inputs, supporting modifiers like .trim, .number, and .lazy, as well as native Set models for checkboxes. The v-on directive provides runtime support for event modifiers (e.g., .stop, .prevent) and key modifiers (e.g., .enter), including compatibility layers for legacy keyCode usage. The v-show directive implements visibility toggling via display styles, integrates with Vue's transition system for enter/leave animations, and includes SSR support to ensure correct initial rendering.

packages/runtime-dom/src/directives · high confidence

A new \@vue/runtime-test\ package is introduced to provide a minimal, non-observable DOM-like environment for testing Vue's renderer. This package exports \render\, \createApp\, and \renderToString\ functions that operate on \TestElement\ nodes, allowing tests to validate component behavior without a real browser DOM. It includes utilities for serializing the rendered output to strings, triggering event listeners manually via \triggerEvent\, and recording/dumping node operations (create, insert, remove, patch) to verify renderer internals.

packages/runtime-test/src · high confidence

The repository now includes a new \@vue/compiler-dom\ package, established by renaming the previous \packages/observer\ directory and updating its entry point to load the new \compiler-dom\ distribution files. This change introduces the DOM-specific compiler as a distinct module within the project structure.

packages/compiler-dom · high confidence

The @vue/shared package is now published as a public npm package, including its source entry point (index.js), a LICENSE file, and a README. This allows external consumers to import shared utility functions and constants directly from @vue/shared rather than relying on internal or private package access.

packages/shared · high confidence

Added six new demonstration applications in the \packages/vue/examples/composition\ directory to showcase the Vue 3 Composition API. These examples include a TodoMVC app, a GitHub commits viewer, a markdown editor, a sortable data grid, an interactive SVG polygraph chart, and a recursive tree component. They serve as practical references for using Composition API features such as \ref\, \reactive\, \computed\, \watchEffect\, and lifecycle hooks like \onMounted\ and \onUnmounted\.

packages/vue/examples/composition · high confidence

The \packages/runtime-core/src/helpers\ directory now contains dedicated runtime helper modules that implement core compiler outputs. \createSlots\ manages dynamic and conditional slot registration, while \renderSlot\ handles slot rendering, block tracking, and fallback content. \renderList\ powers \v-for\ loops, supporting arrays, objects, numbers, and iterables with caching. \useModel\ implements the \defineModel\ API, handling prop syncing, modifiers, and emission logic. \useTemplateRef\ provides a typed, reactive way to access template refs, and \useId\ generates unique IDs for accessibility. Additional helpers include \resolveAssets\ for component/directive resolution, \toHandlers\ for \v-on\ object syntax, \useSSRContext\ for server-side rendering context, and \withMemo\ for \v-memo\ optimization.

packages/runtime-core/src/helpers · high confidence

Added \useCssModule\ and \useCssVars\ helper functions in the runtime-dom package. \useCssModule\ allows components to access scoped CSS class names from CSS modules at runtime, while \useCssVars\ provides the underlying mechanism for injecting CSS variables defined in Single File Components (SFCs) onto the DOM, handling updates, suspense boundaries, and teleported content.

packages/runtime-dom/src/helpers · high confidence

The repository has been initialized with the Vue 3.5.43 source code, establishing the baseline for the project. This includes a comprehensive changelog documenting bug fixes for hydration, reactivity, and the compiler, alongside the addition of standard project files such as the MIT license, security policy, and funding configuration. The development environment is configured with a pnpm workspace, a new ESLint setup using TypeScript ESLint, and a Vitest test configuration that supports unit, jsdom, and browser-based e2e testing.

(repo-wide) · high confidence

The \packages/observer/src\ directory has been completely removed from the codebase. This deletion eliminates the reactive observer implementation, including the core \observable\ and \immutable\ proxy handlers, the \autorun\ and \computed\ execution logic, and the collection instrumentation for Sets and Maps. Users relying on this package for reactivity will no longer have access to these features.

packages/observer/src · high confidence

The \packages/core\ directory has been completely removed, eliminating the legacy Vue 2-style component system that relied on class-based components, prototype-based options, and the \@vue/observer\ reactive API. This change removes the internal infrastructure for the old component model, including the \Component\ class, render proxies, and associated utilities, signaling a shift away from the previous architecture.

packages/core · high confidence

The scheduler module located at packages/scheduler/src/index.ts has been removed from the codebase. This deletion eliminates the previous implementation that managed job queuing, post-flush callbacks, and execution via nextTick.

packages/scheduler/src · high confidence

The \packages/compiler-sfc/src\ directory has been restructured into a new, modular compiler architecture. The single-file logic is now split into dedicated modules: \compileScript.ts\ handles \\<script setup\>\ and normal script compilation (including macro processing like \defineProps\, \defineEmits\, and \defineModel\), \compileTemplate.ts\ manages template-to-render-function compilation with support for asset URL transforms and preprocessors, and \compileStyle.ts\ handles CSS processing via PostCSS, including scoped styles, CSS variables injection, and CSS Modules. A new \cache.ts\ module provides LRU caching for parsing, and \parse.ts\ orchestrates the SFC descriptor creation. The public API in \index.ts\ now exports these distinct compilation functions (\compileScript\, \compileTemplate\, \compileStyle\, \compileStyleAsync\) alongside utilities like \rewriteDefault\ and type resolution helpers, replacing the previous monolithic structure.

packages/compiler-sfc/src · high confidence

The template asset URL transformation logic has been reorganized into new, dedicated files (\resolveTemplateAST.ts\, \templateUtils.ts\, \transformAssetUrl.ts\, and \transformSrcset.ts\). This refactoring extracts URL parsing, validation, and import resolution utilities into \templateUtils.ts\ and separates the \img\/\source\ srcset transformation into its own module, while keeping the general asset URL transform in \transformAssetUrl.ts\. A new \resolveTemplateAST\ function handles re-parsing the template source to preserve location information when the AST has been transformed (e.g., after cache invalidation). Users benefit from cleaner internal structure and more robust handling of edge cases like hash-only hrefs on \\<image\>\ elements, asset paths with spaces, and Node.js subpath import patterns in URLs.

packages/compiler-sfc/src/template · high confidence

The \packages/compiler-sfc/src/script\ module has been restructured to improve maintainability and type resolution. A new \ScriptCompileContext\ class now centralizes compilation state, AST parsing, and error reporting. The monolithic script logic has been split into dedicated modules for each macro (\defineProps\, \defineEmits\, \defineModel\, \defineExpose\, \defineOptions\, \defineSlots\), each handling its own processing and code generation. Additionally, a new \analyzeScriptBindings\ utility handles binding analysis for standard \\<script\>\ blocks, and \importUsageCheck\ now uses AST-based analysis to determine template usage. This refactoring isolates macro-specific logic, making the compiler easier to extend and debug.

packages/compiler-sfc/src/script · high confidence

The style compilation logic in \packages/compiler-sfc/src/style\ has been reorganized into distinct, modular PostCSS plugins: \cssVars.ts\ handles CSS custom property parsing and generation (including SSR escaping and comment/string stripping), \pluginScoped.ts\ manages scoped CSS rewriting and keyframe animation scoping, \pluginTrim.ts\ normalizes whitespace, and \preprocessors.ts\ centralizes SCSS, Sass, Less, and Stylus processing with source map merging. This structural change improves maintainability and separation of concerns within the SFC compiler's style pipeline.

packages/compiler-sfc/src/style · high confidence

The \@vue/shared\ package has been restructured by extracting its internal utilities into individual, dedicated source files (such as \codeframe.ts\, \cssVars.ts\, \domAttrConfig.ts\, \domTagConfig.ts\, \escapeHtml.ts\, \general.ts\, \globalsAllowList.ts\, \looseEqual.ts\, \makeMap.ts\, \normalizeProp.ts\, \patchFlags.ts\, \shapeFlags.ts\, \slotFlags.ts\, \toDisplayString.ts\, and \typeUtils.ts\). This change improves code organization and maintainability by separating concerns like DOM tag/attribute configuration, HTML/CSS escaping, type utilities, and patch flag definitions into their own modules, while re-exporting them via the main \index.ts\ entry point.

packages/shared/src · high confidence

The browser entry points for @vue/compiler-sfc now exclude the automatic TypeScript registration that was previously applied to all environments. By removing the require/import of register-ts.js from the browser-specific bundles (index.browser.js, index.browser.mjs), the compiler no longer attempts to load or register the TypeScript compiler in browser contexts, preventing potential errors or unnecessary overhead when bundling for the web.

packages/vue/compiler-sfc · high confidence

The project's build and development scripts have been migrated from CommonJS to ES modules and refactored to use modern Node.js APIs. The \dev\ script now uses esbuild for significantly faster development builds, while the \build\ script supports parallel execution and integrates a new \inline-enums.js\ pre-processor to optimize bundle sizes by replacing TypeScript enums with object literals. New utility scripts have been added: \aliases.js\ automatically generates Vitest and Rollup aliases for all packages, \size-report.js\ generates markdown reports comparing bundle sizes (including Brotli compression), and \usage-size.js\ measures specific usage presets. The legacy \bootstrap.js\ and \verifyCommit.js\ scripts have been removed or replaced by their ESM equivalents (\verify-commit.js\), and the commit verification now supports additional categories like 'dx' and 'wip'.

scripts · high confidence

The compiler-core transforms have been rewritten to support block tree optimization and static hoisting. This introduces a new \cacheStatic\ transform that hoists constant nodes and caches static children arrays to reduce runtime overhead. Element processing (\transformElement\) now generates patch flags to enable targeted DOM updates, while \transformFor\ and \transformIf\ generate block nodes to correctly track dynamic children. Expression handling (\transformExpression\) now prefixes identifiers for accurate source maps and binding resolution, and text nodes are merged and converted to \createTextVNode\ calls. New transforms handle \v-bind\ shorthand expansion, slot outlet rendering, and directive transforms like \v-model\ and \v-on\ are integrated into the new codegen pipeline.

packages/compiler-core/src/transforms · high confidence

The compiler now provides runtime configuration for Vue 2-to-3 deprecations, allowing users to enable or suppress warnings for removed features like filters, v-bind.sync, and v-on.native. When legacy filter syntax (e.g., \\|\) is detected in Vue 2 compatibility mode, the compiler automatically rewrites it into function calls, ensuring backward compatibility while alerting users to the migration path.

packages/compiler-core/src/compat · high confidence

The main Vue package now defaults to a runtime-only build for bundlers, meaning the \compile\ function is no longer available out of the box. Attempting to use runtime template compilation (e.g., the \template\ option or \compileToFunction\) in this default build will trigger a warning in development mode, directing users to alias \vue\ to \vue/dist/vue.esm-bundler.js\ (or use the browser/global variants) if they require on-the-fly compilation. The full build, which includes the compiler and supports runtime compilation, remains available for those who need it.

packages/vue/src · high confidence

The server-renderer package now provides direct entry points (index.js, index.mjs, and corresponding type definitions) within the main Vue package structure. These files act as re-exports for the @vue/server-renderer module, allowing users to import server-side rendering functionality directly from the main Vue package without needing to reference the sub-package path explicitly.

packages/vue/server-renderer · high confidence

Private development packages, including the SFC playground icons and the Vite debug tool, have been moved into a dedicated \packages-private\ directory. This change reorganizes the repository structure to separate internal tooling and assets from the main public package layout, without altering the functionality of the SFC playground or the Vite-based debugging setup.

packages-private/sfc-playground/src/icons, packages-private/vite-debug · high confidence

The \packages/compiler-dom/src\ directory now contains the browser-specific implementation of the Vue compiler, separating DOM concerns from the core compiler logic. This includes HTML entity decoding via the browser's DOM API, strict HTML nesting validation to ensure template validity, and specific directive transforms for \v-html\, \v-text\, \v-model\, \v-on\, and \v-show\. It also introduces runtime helpers for transition components and specific error codes/messages for DOM-specific issues, such as invalid \v-model\ usage on file inputs or side-effect tags like \\<script\>\ being ignored.

packages/compiler-dom/src · high confidence

The package's global type definitions now expose a comprehensive set of compile-time constants (such as \_\DEV\\, \\TEST\\, \\BROWSER\\, \\CJS\\, and \\SSR\\) and specific feature flags (including \\_FEATURE\_OPTIONS\API\\, \\_FEATURE\_PROD\DEVTOOLS\\, \\_FEATURE\SUSPENSE\\, and \\_FEATURE\_PROD\_HYDRATION\_MISMATCH\DETAILS\\_). This change enables the runtime and compiler to conditionally include or exclude functionality based on the build target, allowing users to opt into or out of specific features like Suspense or hydration mismatch details at compile time.

packages · high confidence

Global type declarations, including references to Vite client types, the \_\COMMIT\\_ constant, and the file-saver module, have been moved into a new global.d.ts file within the packages-private directory. A corresponding tsconfig.json has been added to configure the TypeScript compiler for this location, specifically disabling isolated declarations to support the global type definitions.

packages-private · high confidence

The DOM compiler now includes dedicated transforms for several directives and behaviors. v-show is supported, including automatic injection of the 'persisted' prop when used with a single child inside a \<Transition\> to ensure correct animation persistence. v-on modifier handling is refined to correctly map .right and .middle to contextmenu and mouseup events, and to properly handle event options like .passive and .capture. v-model gains stricter validation, including warnings for usage on file inputs and checks for unnecessary value bindings. v-html and v-text transforms are updated to properly handle constant values and error on invalid usage (e.g., with children). Static content stringification is improved with better handling of SVG, MathML, and edge cases involving cached parents and runtime constants. Additionally, \<script\> and \<style\> tags are now ignored with a warning, and invalid HTML nesting triggers a hydration warning.

packages/compiler-dom/src/transforms · high confidence

The main entry point for the reactivity package (index.js) has been updated to require the newly named CommonJS build files (reactivity.cjs.js and reactivity.cjs.prod.js) instead of the previous scheduler builds. This change ensures that the package correctly loads the reactivity-specific distribution files, aligning the runtime entry with the package's renamed identity.

packages/reactivity · high confidence

The reactivity engine has been completely rewritten to replace the previous dependency-tracking mechanism with a version-based system using doubly-linked lists. This architectural change optimizes performance by allowing computed values to skip re-evaluation when no dependencies have changed, and improves memory management by efficiently cleaning up unused dependencies. The new implementation also introduces pause/resume capabilities for effects and scopes, and refines how array and collection mutations are tracked to prevent infinite loops and preserve reactivity correctly.

packages/reactivity/src · high confidence

The internal reactivity system has been refactored to use version counting and doubly-linked list tracking, replacing the previous implementation. This change optimizes dependency tracking and trigger logic, resulting in better performance for reactive updates and reduced memory overhead.

packages/runtime-core/src · high confidence

The core compiler package has been renamed from @vue/core to @vue/compiler-core. This change updates the internal module paths and distribution file names (e.g., from core.cjs.js to compiler-core.cjs.js) to reflect the new package identity, while also adding standard MIT license and README documentation files for the package.

packages/compiler-core · high confidence

The server-renderer package has been restructured to decouple the ESM build from Node.js-specific dependencies and improve the streaming API. The public entry point now exports \renderToString\ alongside a suite of streaming methods: \renderToNodeStream\, \pipeToNodeWritable\, \renderToWebStream\, and \pipeToWebWritable\, while the legacy \renderToStream\ is marked as deprecated. Internal runtime helpers (such as \ssrRenderVNode\, \ssrRenderTeleport\, and \ssrRenderSuspense\) are now explicitly exported from a dedicated \internal\ module for use by the SSR compiler. The core rendering logic utilizes a new \SSRBuffer\ system that supports both synchronous and asynchronous chunks, enabling efficient unrolling for streaming output.

packages/server-renderer/src · high confidence

When downloading a project from the SFC Playground, the generated package.json now uses the exact Vue version currently selected in the playground (e.g., 3.4.0) instead of always defaulting to "latest". This ensures that the downloaded project matches the version you were testing with, avoiding unexpected behavior from newer Vue releases. The download also includes a Vite-based project template requiring Node.js 20.19+ or 22.12+.

packages-private/sfc-playground/src/download · high confidence

The \@vue/server-renderer\ package now includes a LICENSE file and an updated README that documents the available APIs, including \renderToString\, streaming methods like \renderToNodeStream\ and \renderToWebStream\, and the note that \renderToNodeStream\ is not supported in the ESM build. The package entry point (\index.js\) explicitly loads the CommonJS build files based on the environment.

packages/server-renderer · medium confidence

The Vue 2 compatibility layer in \runtime-core\ has been refactored from a monolithic structure into distinct, modular files (e.g., \attrsFallthrough\, \componentAsync\, \componentFunctional\, \componentVModel\, \customDirective\, \global\, \instance\, \renderFn\). This change organizes the deprecation warnings and legacy behavior emulation—such as handling \v-model\ prop/event mapping, functional component conversion, async component normalization, and instance property access ($set, $delete, $listeners)—into specific modules. For users, this ensures that the Vue 2 migration path remains stable and maintainable, with clearer separation of concerns for how legacy APIs are shimmed in Vue 3.

packages/runtime-core/src/compat · high confidence

The \vue-compat\ package now provides a compatibility layer for Vue 3 that allows applications using Vue 2 patterns to run with warnings. This build exposes \configureCompat\ for granular control over deprecation behavior and registers legacy built-in components (like \Transition\ and \KeepAlive\) and directives (\v-show\, \v-model\) under internal prefixes to support legacy \h()\ calls. It also implements runtime template compilation with a cache, warns on invalid templates, and flags the removal of the \whitespace\ configuration option in development mode.

packages/vue-compat/src · high confidence

The \packages/compiler-core/src\ directory has been completely rewritten to introduce a new compiler architecture. The parser now uses \@babel/parser\ to parse JavaScript expressions, enabling support for TypeScript syntax in bindings and more robust expression validation. The AST structure has been redesigned with new node types (e.g., \NodeTypes\, \ElementTypes\) and a refined \RootNode\ interface that includes \hoists\, \cached\, and \temps\ for optimized code generation. The compiler now supports module mode with identifier prefixing, source map generation via \source-map-js\, and improved error handling with specific \ErrorCodes\ and user-friendly error messages. Additionally, the codegen phase has been restructured to support SSR, static hoisting, and caching mechanisms, resulting in more efficient runtime code.

packages/compiler-core/src · high confidence

This update refines how Vue manages DOM elements in the runtime-dom module. Attribute patching now supports Vue 2 compatibility modes for enumerated attributes and false values, while also handling symbols and nullish values more consistently. Class handling has been optimized to integrate with transition classes and avoid unnecessary string normalization. Event listeners no longer use global delegation; instead, they are attached directly to elements with improved timestamp checks to prevent race conditions and support event options (capture, passive, once). Style patching now better preserves v-show display values, supports CSS custom properties with !important, and includes auto-prefixing for vendor-specific properties. DOM property patching is more robust, catching errors when setting invalid values and handling special cases for input values and innerHTML via Trusted Types.

packages/runtime-dom/src/modules · high confidence

Add dts-test suite for validating Vue TypeScript types; Add reactivity system benchmarks; Added compiler-core snapshot tests for codegen, parsing, and scopeId handling; Added comprehensive test coverage for Vue 2.x compatibility deprecations; Added comprehensive test suite for compiler-core; Added comprehensive test suites for core components; Added comprehensive test suites for runtime-core APIs; Added end-to-end tests for Vue transitions, hydration strategies, and memory leaks; Added private test package to verify Vue type declaration edge cases; Added snapshot test for DOM compiler output; Added snapshot tests for codeframe generation; Added test coverage for DOM compiler parsing and HTML decoding; Added test coverage for Vue runtime and compiler integration; Added test coverage for reactive Map, Set, WeakMap, WeakSet, and shallowReadonly collections; Added test coverage for runtime DOM directives; Added test coverage for shared utility functions; Added test snapshots for compiler-dom transforms; Added test suites for SFC script macros and compilation behavior; Added tests for compiler-core transforms; Added tests for the test renderer capabilities; Added tests for useCssModule and useCssVars helpers; Compiler-core transform snapshot tests added; Comprehensive test coverage for the reactivity system; Expanded test coverage for Vue server-side rendering; SSR compiler test suite expansion; Updated compiler-sfc macro snapshots; Updated compiler-sfc test snapshots.

This change updates dependencies across 26 manifests, including build tools (rollup, vite, esbuild, postcss, sass, typescript, eslint), test runners (jest, vitest, jsdom, puppeteer), and utility libraries (lodash, minimatch, magic-string, @babel/\*). These updates ensure compatibility with newer Node.js versions, patch security vulnerabilities (e.g., in postcss, vite, jsdom, minimatch, and lodash), and improve build performance and type safety.

(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 → 52 (+9.8)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 73 → 65 (-8.2)
• Architecture 59 (new)
• Maturity 60 → 73 (+13.0)
• Readiness 21 → 46 (+24.8)
• Security 60 → 66 (+6.8)
• Accessibility 50 (new)
• Performance 60 (new)

• Boundary-crossing change coupling: runtimeHelpers.ts ↔ index.ts (packages/compiler-core/src/runtimeHelpers.ts)
• Boundary-crossing change coupling: runtimeHelpers.ts ↔ index.ts (packages/compiler-ssr/src/runtimeHelpers.ts)
• Change coupling: apiComputed.ts ↔ component.ts (packages/runtime-core/src/apiComputed.ts)
• Change coupling: component.ts ↔ instance.ts (packages/runtime-core/src/compat/component.ts)
• Change coupling: defineEmits.ts ↔ defineProps.ts (packages/compiler-sfc/src/script/defineEmits.ts)
• Change coupling: ssrVFor.ts ↔ ssrVIf.ts (packages/compiler-ssr/src/transforms/ssrVFor.ts)
• 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)
• 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)
• …and 23 more

• Assertions commented out: should chained computeds dirtyLevel update with first computed effect (packages/reactivity/tests/computed.spec.ts)
• BaseReactiveHandler.get (cognitive 28) (packages/reactivity/src/baseHandlers.ts)
• BaseReactiveHandler.get (cyclomatic 27) (packages/reactivity/src/baseHandlers.ts)
• BaseTransition.getTransitionRawChildren (cognitive 16) (packages/runtime-core/src/components/BaseTransition.ts)
• BaseTransition.resolveTransitionHooks (cognitive 29) (packages/runtime-core/src/components/BaseTransition.ts)
• BaseTransition.resolveTransitionHooks (cyclomatic 30) (packages/runtime-core/src/components/BaseTransition.ts)
• Boundary-crossing change coupling: setupHelpers.test-d.ts ↔ apiSetupHelpers.ts (packages-private/dts-test/setupHelpers.test-d.ts)
• Boundary-crossing change coupling: watch.test-d.ts ↔ apiWatch.ts (packages-private/dts-test/watch.test-d.ts)
• ClassTooLong: compileScript (packages/compiler-sfc/src/compileScript.ts)
• Dep.track (cognitive 18) (packages/reactivity/src/dep.ts)
• EffectScope.stop (cognitive 17) (packages/reactivity/src/effectScope.ts)
• FileTooLong: components/Suspense.ts (packages/runtime-core/src/components/Suspense.ts)
• FileTooLong: script/resolveType.ts (packages/compiler-sfc/src/script/resolveType.ts)
• FileTooLong: src/apiCustomElement.ts (packages/runtime-dom/src/apiCustomElement.ts)
• FileTooLong: src/ast.ts (packages/compiler-core/src/ast.ts)
• FileTooLong: src/codegen.ts (packages/compiler-core/src/codegen.ts)
• FileTooLong: src/compileScript.ts (packages/compiler-sfc/src/compileScript.ts)
• FileTooLong: src/component.ts (packages/runtime-core/src/component.ts)
• FileTooLong: src/componentOptions.ts (packages/runtime-core/src/componentOptions.ts)
• FileTooLong: src/componentProps.ts (packages/runtime-core/src/componentProps.ts)
• …and 456 more

• 46 commits — 17 feature/other, 29 fixes

• packages/runtime-core — 13 commits
• (root) — 12 commits
• packages/compiler-sfc — 4 commits
• .github/workflows — 3 commits
• packages/shared — 3 commits
• packages/compiler-core — 2 commits
• packages/runtime-dom — 2 commits
• .vite-hooks/_ — 1 commit
• .vscode/settings.json — 1 commit
• packages-private/dts-test — 1 commit
• packages-private/sfc-playground — 1 commit
• packages/reactivity — 1 commit
• packages/server-renderer — 1 commit
• packages/vue — 1 commit

• fix: Revert "fix(compiler-core): handle invalid static arg in same-name v-bind shorthand" (#15362)
• fix: fix(compiler-core): handle invalid static arg in same-name v-bind shorthand (#15347)
• fix: fix(compiler-sfc): ignore comment delimiters inside strings and url() when parsing css vars (#15548)
• fix: fix(compiler-sfc): prepend semicolon for await in switch case (#15498)
• fix: fix(compiler-sfc): restore await scope when leaving nested blocks
• fix: fix(compiler-sfc): reuse parsed parent configs across tsconfig walks (fix #15478) (#15480)
• fix: fix(deps): update compiler (#15247)
• fix: fix(deps): update dependency jszip to ^3.10.2 (#15502)
• fix: fix(hydration): handle async component unmount before lazy hydration (#15252)
• fix: fix(hydration): handle moving unresolved async fragment (#15263)
• fix: fix(hydration): run leave hooks for hydration placeholders (#15431)
• fix: fix(reactivity): preserve readonly wrappers in array copy methods (#15469)
• fix: fix(runtime-core): avoid caching unmounted suspense children (#15291)
• fix: fix(runtime-core): keep .trim result when combined with .number v-model modifier (#15346)
• fix: fix(runtime-core): resolve $el for dev root comment fragment (#15313)
• fix: fix(runtime-core): unmount v-once children after parent rerenders (#15435)
• fix: fix(runtime-dom): support !important on CSS custom properties in style binding (#15348)
• fix: fix(server-renderer): reject CR in attribute names (#15266)
• fix: fix(shared): correctly compare Map and Set values (#15328)
• fix: fix(shared): handle circular references in looseEqual (#15499)
• …and 26 more

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

vuejs/core 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.