allow template to access private props

do not encapsulate nested selectors if parent contains ::ng-deep

scope nested CSS rules

add strictUnclaimedEventNames option to catch misspelled output bindings

scope type-checking of keyed defer blocks

deduplicate deferred imports across multiple blocks

add ErrorBoundary programmatic APIs

add utility for testing directives

allow reading `Injector` from a view or content query

support annotations in WebMCP tool declarations

cancel leave animations in nested views during list reordering

support function and signal bindings in animate.enter and animate.leave

update FakeNavigation to match WHATWG HTML spec

allow permanent hidden fields in signal forms

hard-code `readOnlyHint` and `untrustedContentHint` for WebMCP implicit signal forms

add support for `@boundary` blocks

add containsTree as public API

allow throwing RedirectCommand to trigger redirects

expose router resources in public API

stabilize auto cleanup injectors feature

determine blocking state solely by resource loading status

expose reload method on ActivatedRoute resources

maintain frozen state on rollback until resource loading completes

mark router_resource module-level symbols as side-effect free

remove abort listener on the abort path too in httpResource

add return type to pure functions

avoid hitting TypeScript limits if template has many translations

do not copy expression type into output AST variables

guard unverified ctor parameter types in class metadata

output function return types in linker

don't use plain objects as maps for jsaction data

ensure references are cleared from idle scheduler

loosen return types for arrow functions in generated code

wait for app stability before cleaning up dehydrated views

create controls before listeners

preserve Unicode whitespace in ServerXhr URLs

avoid dense elements allocation for numeric URL keys

wrap `@for` collection expression before appending non-null assertion

return null when getDirectiveMetadata is called with null or undefined

mark control as dirty before setting its value in FVC interop

namespace `@property` declarations

do not flag callable objects with zero parameters in uninvoked track function check

apply SkipSelf to only the starting node in embedded views

avoid sourcemap corruption during domino path substitution

keep detached route subtree contexts isolated and intact

check uninvoked signal aliases in extended diagnostic

cancel stale debounce timers to prevent timer leaks

don't fail NgModule checks for a pipe that extends a base class

validate SVG animation attributes outside the SVG namespace

avoid writing to `name` input on ControlValueAccessor

skip tsconfig files of non-Angular projects

resolve HTTP(S) URLs without authority as relative during SSR

avoid view transitions when the user agent provides one

avoid prototype member collisions

use locale NaN symbol in number formatting

scope animations declared in minified nested rules

default template diagnostic related message source file to template

Produce correct tcb expression for optional chaining

retain metadata for strict standalone errors

avoid prototype member collisions

explicitly reject foreign components in JIT mode

preserve namespace for dynamic component hosts

prevent TransferState prototype pollution

throw coded RuntimeErrors instead of crashing when hydration/rendering can't find an expected DOM node

use dot-access for readonly rule configuration

honor quote style preference when generating imports

preserve registerLocaleData calls in standalone bootstrap migration

avoid stripping unicode whitespace during url resolution

detect object trigger values with Object.hasOwn

preserve literal key union in KeyValuePipe.transform()

preserve &ngsp; between sibling control flow blocks

accept readonly arrays for setClassMetadata decorators

allow readonly arrays in RawScopeInfoFromDecorator

expose debuggableFn for non-computed signal graph nodes

prevent orphaned requestIdleCallback handle from re-entrant scheduling

replace all hasOwnProperty usages with Object.hasOwn

stop running further effects once one destroys the view mid-flush

throw a descriptive error instead of crashing when a hydration node is missing

throw NG0500 instead of a raw TypeError on element hydration mismatch

report forbidden 2way bindings on when `FormField` is applied

warn in dev mode when ngModel cannot reach parent NgForm across component boundary

cancel oversized fetch response bodies

recover project for external templates in solution-style workspaces

disallow event handler attributes in Meta

throw a descriptive error when insertBefore reference node is missing

pass correct component to canDeactivate for named outlets in componentless parent routes

Generate correct expression for optional chaning.

remove namespaced MathML script elements

correctly resolve symbol for SafePropertyRead in chained optional navigation

record class extends clause references in DeferredSymbolTracker

ensure i18n_util hasOwnProperty checks are safe for property renaming

incorrect loop in defer blocks

reject prefixed SVG script hosts

keep radio inputs in sync when values change

always decode JSON responses as UTF-8

limit protocol-relative URL handling to serialization

initialize hydration triggers after late runtime activation

warn when style property bindings receive invalid values

avoid aborting completed requests in FetchBackend

respect content-type charset in fetch backend text decoder

run root interceptors in the terminal request chain

strip RFC 6265 DQUOTE characters and handle URIError in parseCookieValue

skip transfer cache for uncacheable HTTP traffic

Add an error for --global-foo cases

Disable '--global-' error outside of g3

Namespace CSS variables to the app

Support css var namespacing in properties

permissive whitespace parsing in default never blocks

support foreign components defined outside top-level scope

support foreign components inside control flow blocks

do not emit tag name when control flow root is foreign component

allow passing uninvoked signals as foreign component props

support import aliases in foreignImports

add custom set option to linkedSignal

Adds deep linking from Performance panel to DevTools

account for namespaces in host binding sanitization

correct container anchor collection order to match DOM layout

introduce disposal mechanism for Angular views in foreign `@content`

introduce logical-only containers for foreign content

sanitize host bindings on concrete hosts

set current tnode in foreign component instruction on reuse

add utility to assert that value is a field tree

add options to allow caching of credentialed and non-cacheable HTTP requests

enable xsrf for root-provided HttpClient

match header values exactly when deleting

preserve immutability of materialized clones

skip transfer cache for fetch credentialed requests

deprecate jsonp support

compile non-exported classes if standalone

Typecheck templates which would require inline typecheck blocks

account for strictTemplates being enabled by default

add migration from injectable to service

correctly detect `then`/`else` keywords in control flow migration

harden platform location origin validation during SSR

handle null and undefined inputs in RouterLinkActive

preserve crossorigin on image preloads

ensure SVG animation attributeName is checked case-insensitively

ensure `pending` status propagates to the root form in signal forms

prevent transfer cache key collisions

correctly migrate ngClass with mixed space-separated keys

preserve NgClass import on partial migration

avoid prototype lookups in date format caches

parsing of an empty template literal interpolation

re-tag SourceFiles after TsCreateProgramDriver.updateFiles()

allow static attributes for explicit input transforms

ignore processing instruction syntax in templates

preserve explicit input transform write type

allow multiple async validators

preserve intermediate number values in signal forms

prevent stale CVA writeback during debounce

prevent interceptor signal reads from leaking into calling reactive contexts

build runtime translations map with a null prototype

use Object.hasOwn for placeholder lookup in translate

prevent ReDoS in SOURCEMAP_URL_REGEXP

use regular optional chaining expression for safe function calls in TCBs

apply debugName transform to required signal queries

detect uninvoked signals in bound expressions using ternary

make extractValue reactive for compat AbstractControl values

preserve transitive NgModule references when pruning

remove stale model import in model-output migration

handle outlet named __proto__ in segment group maps

use safe hasOwnProperty when parsing query params

use Object.hasOwn in I18nSelectPipe to handle null-prototype and shadowed mappings

include toSignal in debugName transform

improve input writes migration in best effort mode

reject dynamic script host elements

fix malformed jsdoc comment for RouterLinkWithHref export

resolve migration failure when tsconfig specifies rootDir

account for NgModule dependencies in JIT-compiled partial declarations

remove unused import breaking CI in 22.0.x

report diagnostic instead of crashing on malformed host binding

avoid uncaught promise errors in injectAsync prefetching

prevent caching of responses with Set-Cookie headers

preserve referrer in asset requests

preserve referrer policy in asset requests

support model() signals in downgradeComponent

escape anchor fragment in shadow DOM name selector

skip transfer cache for uncacheable HTTP traffic

restrict possible event handler check to property names longer than 2 characters

avoid caching missing locale data

escape overlapping comment delimiters in escapeCommentText

guard against DOM clobbering in declareExperimentalWebMcpTool

preserve leave animation for sibling instances sharing a TNode

prevent unsubscribe during emit from throwing off other listeners

treat iframe credentialless as security-sensitive

detect existing signal dependency without checking all producer links

distinguish repeated transfer cache params

skip transfer cache for fetch credentialed requests

migration skip any target are not build or test

escape CSS string-terminating characters in escapeCssUrl

Limits date format string length

prevent prototype pollution in formatDateTime

use cryptographically secure SHA-256 for transfer cache key generation

disallow i18n event attributes

more robust logic to check if regex can be optimized

sanitize `href`/`xlink:href` attributes of any element of the MathML namespace

sanitize two-way properties

bind switch exhaustive check expressions

disable WebMCP during SSR

Handle synchronous errors in PendingTasks.run function

harden TransferState restoration against DOM clobbering

prevent dangling prevConsumer reference from leaking destroyed views

require WebMCP tool descriptions

update comment for Default change detection

use Object.hasOwn to handle null-prototype objects in toStylingKeyValueArray

validate lowercase SVG animation attribute names

delay mcp reading the form model by a `tick`

harden FormGroup control lookups against prototype shadowing

remove animationstart listener on component destroy to prevent memory leak

set `additionalProperties: false` on generated WebMCP form

ensure query parameters are inserted before URL fragments

pass down the `reportUploadProgress` and `reportDownloadProgress` on post/patch requests

preserve empty referrer option in HttpRequest

Rejects non-HTTP(S) URLs in JSONP requests

prevent external template inlay hints from appearing in TS files

harden platform location origin validation during SSR

deprecate ServerXhr

use native URL object for navigation boundary and comparison

Strips sensitive headers on cross-origin redirects

allow safe navigation to correctly narrow down nullables

Angular expressions with optional chaining returns `undefined`

Support comments in html element.

abstract emitter producing incorrect code for dynamic imports

Don't bind inputs/outputs for `data-` attributes

don't escape dollar sign in literal expression

enforce parentheses containing arguments for :host-context

invalid type checking code if field name needs to be quoted

normalize tag names with custom namespaces in DomElementSchemaRegistry

preserve leading commas in animation definitions

remove dedicated support for legacy shadow DOM selectors

remove deprecated shadow CSS encapsulation polyfills

sanitize dynamic href and xlink:href bindings on SVG a elements

simplify handling of colon host with a selector list

stop generating unused field

throw on duplicate input/outputs

throw on invalid in expressions

type check invalid for loops

add support for Node.js 26.0.0

Adds warning for prefetch without main defer trigger

support external TCBs with copied content in specific mode

animation events not type checked properly when bound through HostListener decorator

resolve TCB mapping failure for safe property reads with as any

transform dropping exclamationToken from properties

introduce NG8023 compile-time diagnostic for duplicate selectors

add `IdleRequestOptions` support to `IdleService`

add `provideWebMcpTools`

Add a `injectAsync` helper function

Add a schematics to migrate `provideHttpClient` to keep using the `HttpXhrBackend` implementation.

add ability to cache resources for SSR

Add migration to add `ChangeDetectionStrategy.Eager` where applicable

add special return statuses for resource params

add TestBed.getFixture

allow debouncing signals

Allow other expression for exhaustive typechecking

allow synchronous values for stream Resources

bootstrap via `ApplicationRef` with config

de-duplicate host directives

drop support for TypeScript 5.9

enhance profiling with documentation URLs

export experimental `declareWebMcpTool` support

implement Angular DI graph in-page AI tool

introduce `@Service` decorator

re-introduce nested leave animations scoped to component boundaries

register AI runtime debugging tools

Set default Component changeDetection strategy to OnPush

support bootstrapping Angular applications underneath shadow roots

support customization of @defer's on idle behavior

Support optional timeout for idle deferred triggers

TestBed.getFixture -> TestBed.getLastFixture and update implementation

Update Testability to use PendingTasks for stability indicator

allow service with factory on abstract classes

bind global context to idle callback shims in @defer's idle service

do not register dom triggers when defer blocks are in manual mode

enforce return type for service factory

ensure custom controls resolve transitive host directives

lazy-initialize debounced state to prevent computation cycle

mark service decorator as stable

normalize tag names in runtime i18n attribute security context lookup

prevent rxResource from leaking a subscription

resolver function not matching expected type

support prefix-insensitive DOM schema lookups and compile-time i18n attribute validation

synchronize core sanitization schema with compiler

widen type for directive inputs/outputs

enhance AnimationCallbackEvent.animationComplete signature

remove `checkNoChanges` from the public API.

remove `createNgModuleRef`

remove ComponentFactoryResolver & ComponentFactory from the api surface

remove ComponentFactoryResolver & ComponentFactory from the api surface""

add `reloadValidation` to Signal Forms to manually trigger async validation

add debounce option to validateAsync and validateHttp

add FieldState.getError()

graduate signal forms APIs to public API

shim legacy NG_VALIDATORS into parseErrors for CVA mode

support binding `number

support ngNoCva as an opt-out for ControlValueAccessors

template & reactive support for FVC

Add support for range type with outside of native bounds

align FormField CVA selection priority with standard forms

allow `FormRoot` to be used without submission options

allow late-bound input types for signals forms

change FieldState optional properties to non-optional

clear native date inputs correctly in signal forms when changed via native UI

deduplicate writeValue calls in CVA interop

ensure debounced async validators produce pending status during debounce

fix orphan field error on blur during array removal

implement custom control reset propagation

prevent orphan field crashes in debounceSync and async validation

restrict `SignalFormsConfig` to a readonly API

split the `touched` model into an input and `touch` output

support generic unions in signal form schemas

synchronize controls with the model on reset

Untrack `setValue` in reactive forms

use controlValue in NgControl for CVA interop

avoid redundant invalidations in parser errors signal

avoid spurious recomputation in FormField.parseErrors

lazily instantiate signal form fields

optimize reactivity by using shallow array equality

shortcut deepSignal writes if value is unchanged

remove string support from min and max validation rules

Use `FetchBackend` as default for the `HttpBackend` implementation

Introduce a max buffer size for fetch requests on SSR

prevent `httpResource` from leaking a subscription

Add `reportUploadProgress` & `reportDownloadProgress` options

add angular template inlay hints support

add Document Symbols support for Angular templates

Add support for idle timeout in defer blocks

Add support for `@Input` with transforms

Add migration for CanMatchFn snapshot parameter

add strictTemplates to tsconfig during ng update

Disabling nullishCoalescingNotNullable & optionalChainNotNullable on ng update

model + output migrations

avoid generating invalid code in ChangeDetectionStrategy.Eager migration

Fix typo for strict-template migration

Make the safe optional chaining idempotent

remove compiler import from safe optional chaining migration

make incremental hydration default behavior

remove unused styles when associated `host` is dropped

remove Hammer integration

Add `options` optional parameter for `withComponentInputBinding`

add unmatchedInputBehavior option to componentInputBinding

adds browserUrl input support to router links

Add strict typing on 'getResolvedTitleForRoute'

make currentSnapshot required in CanMatchFn

set default paramsInheritanceStrategy to 'always'

remove deprecated `provideRoutes` function.

resolve TS 6.0 compatibility for messageerror listener

remove `getAngularLib`/`setAngularLib`

add `--root` command line option to `mcp` command

skip eager yargs help message formatting during command execution

migrate Angular Linker to oxc-parser and magic-string

Support splitting browser and server stats jsonfiles for easier consumption

add automatic corruption recovery in SQLite cache store

avoid pure comment pattern in oxc transform

default preloadInitial to false when serviceWorker is enabled

disable linker internal source mapping in OXC linker

disable root config extension for inline test project

ensure chokidar watcher is ready before returning

ensure parent directory exists in SQLite cache store

execute setup file hooks for each spec file when coverage is enabled

include inline component stylesheets in referenced watch files

only compile included test files in unit-test builder

pass load cache to compiler plugin and escape extension regex in polyfills

preserve duplicate bundle filenames across output file types

prevent memory leaks in parallel compilation and caches

prevent stale bundler caching and correctly resolve load cache

prevent syntax corruption in linker and oxc transform

recursively ignore output and cache paths in watch mode

scope Sass package resolution caching for stylesheets in node_modules

support parenthesized expressions in oxc linker

use chokidar watcher when followSymlinks is enabled

avoid encoding intermediate source maps before remapping

bypass worker dispatch for files without transform candidates

consolidate component stylesheet bundling with shared load result cache

decouple diagnostic type checking from build start

implement SharedArrayBuffer translation dictionaries for zero-copy worker access

implement sliding-window batching and worker translation eviction

key Sass package resolutions without containing URL qualification

only reset Sass worker pool caches when stylesheet files change

optimize sourcemap stripping and loading with buffer fast path

reduce watcher debounce latency for faster incremental rebuilds

replace watchpack with @parcel/watcher and chokidar

selectively compress large entries in SQLite cache store

share sass directory and resolution caches across stylesheets

unify Oxc linking and optimization AST traversal passes

use iterative post-order AST traversal for OXC transforms

use native sass-embedded compiler daemon

use size-weighted task heuristics in i18n inliner

verify cache metadata before reading file and eliminate sqlite read-locks

deprecate splitting option in unit-test builder

pre-compile critical CSS plans at build time

update @types/node to a version vitest 5 accepts

name the unknown option in a schema validation error

support standard JavaScript MIME types and case insensitivity in auto-CSP

disable strictPort when port 0 is used in dev-server

avoid full JSON parsing when updating sourcemap ignore list

read rendered module length once per module in chunk optimizer

isolate temporary package installations from parent Yarn workspace

add splitting option to unit-test builder

enable code splitting for vitest browser tests

fail build and exclude routes when prerendering fails

keep dev-server Vite cache worktree-local

preserve binary values in the SQLite cache store

decode pathname when constructing server asset path

ensure public directory containment in CommonEngine

ignore side-effect annotations in unit test builds

batch prerender routes and share in-memory server bundles

abort web request signal when node request is aborted

transform fail() to expect.fail() in refactor-jasmine-vitest

enforce MCP roots in get_best_practices tool

handle errors from isAllowedWorkspacePath in best-practices tool

throw on out-of-roots workspace in best-practices tool

correct misleading error message for top-level await

disable code splitting for unit test builds

preserve integrity and crossorigin in autoCsp loader

traverse AST with iterative post-order walker in i18n inliner

generate CLAUDE.md for Claude Code instead of AGENTS.md

import UrlSegment instead of subPath in guard generator

disable searching current directory for bare executable names on Windows

serialize configuration as a single argv token in run_target strategies

avoid eager module loading during global bootstrap

count statically imported chunks in the initial total

normalize setupFiles paths to POSIX for vitest runner

prevent syntax corruption for Crockford-style enum IIFE

prevent syntax corruption in oxc transform

return direct file contents for non-Angular TypeScript files

return only lowest version per target engine

set target for Rolldown dependency prebundling in Vite dev server

avoid encoding the inline source map before remapping