diff --git a/crates/angular_conformance/fixtures/ml_parser_html_parser_spec.json b/crates/angular_conformance/fixtures/ml_parser_html_parser_spec.json
index 440d49118..6291269b9 100644
--- a/crates/angular_conformance/fixtures/ml_parser_html_parser_spec.json
+++ b/crates/angular_conformance/fixtures/ml_parser_html_parser_spec.json
@@ -112,6 +112,28 @@
                     }
                   ]
                 },
+                {
+                  "name": "should parse named HTML entities containing digits",
+                  "path": "HtmlParser/parse/text nodes/should parse named HTML entities containing digits",
+                  "assertions": [
+                    {
+                      "type": "HumanizeDom",
+                      "input": "<div>&sup1;</div>",
+                      "expected": [
+                        ["html.Element", "div", 0.0],
+                        ["html.Text", "¹", 1.0, [""], ["¹", "&sup1;"], [""]]
+                      ]
+                    },
+                    {
+                      "type": "HumanizeDom",
+                      "input": "<div>&frac12;</div>",
+                      "expected": [
+                        ["html.Element", "div", 0.0],
+                        ["html.Text", "½", 1.0, [""], ["½", "&frac12;"], [""]]
+                      ]
+                    }
+                  ]
+                },
                 {
                   "name": "should normalize line endings within CDATA",
                   "path": "HtmlParser/parse/text nodes/should normalize line endings within CDATA",
@@ -995,6 +1017,24 @@
                     }
                   ]
                 },
+                {
+                  "name": "should parse exhaustive default checks in a switch block",
+                  "path": "HtmlParser/parse/blocks/should parse exhaustive default checks in a switch block",
+                  "assertions": [
+                    {
+                      "type": "HumanizeDom",
+                      "input": "@switch (expr) {@case ('foo') {} @default never;}",
+                      "expected": [
+                        ["html.Block", "switch", 0.0],
+                        ["html.BlockParameter", "expr"],
+                        ["html.Block", "case", 1.0],
+                        ["html.BlockParameter", "'foo'"],
+                        ["html.Text", " ", 1.0, [" "]],
+                        ["html.Block", "default never", 1.0]
+                      ]
+                    }
+                  ]
+                },
                 {
                   "name": "should close void elements used right before a block",
                   "path": "HtmlParser/parse/blocks/should close void elements used right before a block",
diff --git a/crates/angular_conformance/fixtures/ml_parser_lexer_spec.json b/crates/angular_conformance/fixtures/ml_parser_lexer_spec.json
index 8a0daaa99..17dededf9 100644
--- a/crates/angular_conformance/fixtures/ml_parser_lexer_spec.json
+++ b/crates/angular_conformance/fixtures/ml_parser_lexer_spec.json
@@ -3154,6 +3154,48 @@
                 }
               ]
             },
+            {
+              "name": "should parse named entities containing digits",
+              "path": "HtmlLexer/entities/should parse named entities containing digits",
+              "assertions": [
+                {
+                  "type": "HtmlLexerTest",
+                  "input": "&sup1;",
+                  "test_type": "HumanizeParts",
+                  "expected": [
+                    ["TokenType.TEXT", ""],
+                    ["TokenType.ENCODED_ENTITY", "¹", "&sup1;"],
+                    ["TokenType.TEXT", ""],
+                    ["TokenType.EOF"]
+                  ],
+                  "options": null
+                },
+                {
+                  "type": "HtmlLexerTest",
+                  "input": "&frac12;",
+                  "test_type": "HumanizeParts",
+                  "expected": [
+                    ["TokenType.TEXT", ""],
+                    ["TokenType.ENCODED_ENTITY", "½", "&frac12;"],
+                    ["TokenType.TEXT", ""],
+                    ["TokenType.EOF"]
+                  ],
+                  "options": null
+                },
+                {
+                  "type": "HtmlLexerTest",
+                  "input": "&blk34;",
+                  "test_type": "HumanizeParts",
+                  "expected": [
+                    ["TokenType.TEXT", ""],
+                    ["TokenType.ENCODED_ENTITY", "▓", "&blk34;"],
+                    ["TokenType.TEXT", ""],
+                    ["TokenType.EOF"]
+                  ],
+                  "options": null
+                }
+              ]
+            },
             {
               "name": "should parse hexadecimal entities",
               "path": "HtmlLexer/entities/should parse hexadecimal entities",
@@ -5046,25 +5088,6 @@
                 }
               ]
             },
-            {
-              "name": "should parse @default never(expr);",
-              "path": "HtmlLexer/blocks/should parse @default never(expr);",
-              "assertions": [
-                {
-                  "type": "HtmlLexerTest",
-                  "input": "@default never(expr);",
-                  "test_type": "HumanizeParts",
-                  "expected": [
-                    ["TokenType.BLOCK_OPEN_START", "default never"],
-                    ["TokenType.BLOCK_PARAMETER", "expr"],
-                    ["TokenType.BLOCK_OPEN_END"],
-                    ["TokenType.BLOCK_CLOSE"],
-                    ["TokenType.EOF"]
-                  ],
-                  "options": null
-                }
-              ]
-            },
             {
               "name": "should parse @default never ;",
               "path": "HtmlLexer/blocks/should parse @default never ;",
diff --git a/crates/angular_conformance/fixtures/render3_r3_ast_spans_spec.json b/crates/angular_conformance/fixtures/render3_r3_ast_spans_spec.json
index 1a84935d1..f0be4f148 100644
--- a/crates/angular_conformance/fixtures/render3_r3_ast_spans_spec.json
+++ b/crates/angular_conformance/fixtures/render3_r3_ast_spans_spec.json
@@ -164,7 +164,7 @@
                       "<div data-prop=\"{{v}}\">",
                       "</div>"
                     ],
-                    ["BoundAttribute", "data-prop=\"{{v}}\"", "data-prop", "{{v}}"]
+                    ["BoundAttribute", "data-prop=\"{{v}}\"", "prop", "{{v}}"]
                   ],
                   "ignore_error": false
                 }
@@ -345,7 +345,7 @@
                       "<ng-template data-ref-a>",
                       "</ng-template>"
                     ],
-                    ["TextAttribute", "data-ref-a", "data-ref-a", "<empty>"]
+                    ["Reference", "data-ref-a", "a", "<empty>"]
                   ],
                   "ignore_error": false
                 }
@@ -385,7 +385,7 @@
                       "<ng-template data-let-a=\"b\">",
                       "</ng-template>"
                     ],
-                    ["TextAttribute", "data-let-a=\"b\"", "data-let-a", "b"]
+                    ["Variable", "data-let-a=\"b\"", "a", "b"]
                   ],
                   "ignore_error": false
                 }
@@ -618,7 +618,7 @@
                       "<div data-on-event=\"v\">",
                       "</div>"
                     ],
-                    ["TextAttribute", "data-on-event=\"v\"", "data-on-event", "v"]
+                    ["BoundEvent", "data-on-event=\"v\"", "event", "v"]
                   ],
                   "ignore_error": false
                 }
@@ -675,7 +675,8 @@
                       "<div data-bindon-prop=\"v\">",
                       "</div>"
                     ],
-                    ["TextAttribute", "data-bindon-prop=\"v\"", "data-bindon-prop", "v"]
+                    ["BoundAttribute", "data-bindon-prop=\"v\"", "prop", "v"],
+                    ["BoundEvent", "data-bindon-prop=\"v\"", "prop", "v"]
                   ],
                   "ignore_error": false
                 }
@@ -751,6 +752,21 @@
                   "ignore_error": false
                 }
               ]
+            },
+            {
+              "name": "is correct for references via data-ref-",
+              "path": "R3 AST source spans/references/is correct for references via data-ref-",
+              "assertions": [
+                {
+                  "type": "ExpectFromHtml",
+                  "input": "<div ref-a></div>",
+                  "expected": [
+                    ["Element", "<div ref-a></div>", "<div ref-a>", "</div>"],
+                    ["Reference", "ref-a", "a", "<empty>"]
+                  ],
+                  "ignore_error": false
+                }
+              ]
             }
           ]
         },
@@ -934,6 +950,29 @@
                 }
               ]
             },
+            {
+              "name": "is correct for switch blocks with exhaustive checking",
+              "path": "R3 AST source spans/switch blocks/is correct for switch blocks with exhaustive checking",
+              "assertions": [
+                {
+                  "type": "ExpectFromHtml",
+                  "input": "@switch (cond.kind) {@case (x()) {X case}@default never;}",
+                  "expected": [
+                    [
+                      "SwitchBlock",
+                      "@switch (cond.kind) {@case (x()) {X case}@default never;}",
+                      "@switch (cond.kind) {",
+                      "}"
+                    ],
+                    ["SwitchBlockCaseGroup", "@case (x()) {X case}", "@case (x()) {"],
+                    ["SwitchBlockCase", "@case (x()) {X case}", "@case (x()) {"],
+                    ["Text", "X case"],
+                    ["SwitchExhaustiveCheck", "@default never;", "@default never;"]
+                  ],
+                  "ignore_error": false
+                }
+              ]
+            },
             {
               "name": "is correct for switch blocks with exhaustive checking",
               "path": "R3 AST source spans/switch blocks/is correct for switch blocks with exhaustive checking",
@@ -1048,7 +1087,7 @@
                 {
                   "type": "ExpectFromHtml",
                   "input": "@let foo = 123;",
-                  "expected": [["LetDeclaration", "@let foo = 123;", "foo", "123"]],
+                  "expected": [["LetDeclaration", "@let foo = 123", "foo", "123"]],
                   "ignore_error": false
                 }
               ]
diff --git a/crates/angular_conformance/fixtures/render3_r3_template_transform_spec.json b/crates/angular_conformance/fixtures/render3_r3_template_transform_spec.json
index c1794704f..05367b00a 100644
--- a/crates/angular_conformance/fixtures/render3_r3_template_transform_spec.json
+++ b/crates/angular_conformance/fixtures/render3_r3_template_transform_spec.json
@@ -2077,6 +2077,18 @@
                 }
               ]
             },
+            {
+              "name": "should parse a switch block with a default never case",
+              "path": "R3 template transform/switch blocks/should parse a switch block with a default never case",
+              "assertions": [
+                {
+                  "type": "ExpectFromHtml",
+                  "input": "\n          @switch (cond.kind) {\n            @default never;\n          }\n        ",
+                  "expected": [["SwitchBlock", "cond.kind"], ["SwitchExhaustiveCheck"]],
+                  "ignore_error": false
+                }
+              ]
+            },
             {
               "name": "should parse a switch block when preserveWhitespaces is enabled",
               "path": "R3 template transform/switch blocks/should parse a switch block when preserveWhitespaces is enabled",
diff --git a/crates/angular_conformance/fixtures/shadow_css_polyfills_spec.json b/crates/angular_conformance/fixtures/shadow_css_polyfills_spec.json
new file mode 100644
index 000000000..718a20b18
--- /dev/null
+++ b/crates/angular_conformance/fixtures/shadow_css_polyfills_spec.json
@@ -0,0 +1,32 @@
+{
+  "name": "polyfills_spec.ts",
+  "file_path": "/Users/brooklyn/workspace/github/oxc-angular-compiler/crates/oxc_angular_compiler/angular/packages/compiler/test/shadow_css/polyfills_spec.ts",
+  "test_groups": [
+    {
+      "name": "ShadowCss, polyfills",
+      "groups": [],
+      "tests": [
+        {
+          "name": "should support polyfill-next-selector",
+          "path": "ShadowCss, polyfills/should support polyfill-next-selector",
+          "assertions": []
+        },
+        {
+          "name": "should support polyfill-unscoped-rule",
+          "path": "ShadowCss, polyfills/should support polyfill-unscoped-rule",
+          "assertions": []
+        },
+        {
+          "name": "should support multiple instances polyfill-unscoped-rule",
+          "path": "ShadowCss, polyfills/should support multiple instances polyfill-unscoped-rule",
+          "assertions": []
+        },
+        {
+          "name": "should support polyfill-rule",
+          "path": "ShadowCss, polyfills/should support polyfill-rule",
+          "assertions": []
+        }
+      ]
+    }
+  ]
+}
diff --git a/crates/angular_conformance/fixtures/shadow_css_shadow_css_spec.json b/crates/angular_conformance/fixtures/shadow_css_shadow_css_spec.json
index 1d92513e8..c1c2db8f6 100644
--- a/crates/angular_conformance/fixtures/shadow_css_shadow_css_spec.json
+++ b/crates/angular_conformance/fixtures/shadow_css_shadow_css_spec.json
@@ -15,10 +15,24 @@
               "assertions": [
                 {
                   "type": "ShimCss",
-                  "input": "/* b {} */ b {}",
+                  "input": "/* b {c} */ b {c}",
                   "content_attr": "contenta",
                   "host_attr": null,
-                  "expected": " b[contenta] {}",
+                  "expected": " b[contenta] {c}",
+                  "normalized": false
+                }
+              ]
+            },
+            {
+              "name": "should preserve internal newlines from multiline comments",
+              "path": "ShadowCss/comments/should preserve internal newlines from multiline comments",
+              "assertions": [
+                {
+                  "type": "ShimCss",
+                  "input": "/* b {c}\n */ b {c}",
+                  "content_attr": "contenta",
+                  "host_attr": null,
+                  "expected": "\n b[contenta] {c}",
                   "normalized": false
                 }
               ]
@@ -43,10 +57,10 @@
               "assertions": [
                 {
                   "type": "ShimCss",
-                  "input": "/* b {} */ b {} /* a {} */ a {}",
+                  "input": "/* b {c} */ b {c} /* a {c} */ a {c}",
                   "content_attr": "contenta",
                   "host_attr": null,
-                  "expected": " b[contenta] {}  a[contenta] {}",
+                  "expected": " b[contenta] {c}  a[contenta] {c}",
                   "normalized": false
                 }
               ]
@@ -79,10 +93,10 @@
               "assertions": [
                 {
                   "type": "ShimCss",
-                  "input": "/* comment 1 */ /* comment 2 */ b {}",
+                  "input": "/* comment 1 */ /* comment 2 */ b {c}",
                   "content_attr": "contenta",
                   "host_attr": null,
-                  "expected": "  b[contenta] {}",
+                  "expected": "  b[contenta] {c}",
                   "normalized": false
                 }
               ]
diff --git a/crates/angular_conformance/snapshots/angular.snap.md b/crates/angular_conformance/snapshots/angular.snap.md
index a627e954a..3d482852c 100644
--- a/crates/angular_conformance/snapshots/angular.snap.md
+++ b/crates/angular_conformance/snapshots/angular.snap.md
@@ -9,11 +9,11 @@
 | expression_lexer | 137 | 0 | 0 | 0 | 137 | 100.0% |
 | expression_parser | 270 | 0 | 0 | 0 | 270 | 100.0% |
 | expression_serializer | 38 | 0 | 0 | 0 | 38 | 100.0% |
-| html_lexer | 289 | 0 | 0 | 0 | 289 | 100.0% |
-| html_parser | 87 | 0 | 0 | 0 | 87 | 100.0% |
+| html_lexer | 291 | 0 | 0 | 0 | 291 | 100.0% |
+| html_parser | 90 | 0 | 0 | 0 | 90 | 100.0% |
 | html_whitespace | 21 | 0 | 0 | 0 | 21 | 100.0% |
-| r3_transform | 177 | 0 | 0 | 0 | 177 | 100.0% |
-| shadow_css | 169 | 0 | 0 | 0 | 169 | 100.0% |
+| r3_transform | 180 | 0 | 0 | 0 | 180 | 100.0% |
+| shadow_css | 170 | 0 | 0 | 0 | 170 | 100.0% |
 | style_parser | 15 | 0 | 0 | 0 | 15 | 100.0% |
-| **Total** | **1264** | **0** | **0** | **0** | **1264** | **100.0%** |
+| **Total** | **1273** | **0** | **0** | **0** | **1273** | **100.0%** |
 
diff --git a/crates/angular_conformance/src/subsystems/r3_transform/humanizer.rs b/crates/angular_conformance/src/subsystems/r3_transform/humanizer.rs
index 5fb24fcdb..a3714fdf8 100644
--- a/crates/angular_conformance/src/subsystems/r3_transform/humanizer.rs
+++ b/crates/angular_conformance/src/subsystems/r3_transform/humanizer.rs
@@ -544,8 +544,10 @@ impl<'a> R3Visitor<'a> for R3Humanizer<'_> {
     ) {
         if self.mode == HumanizeMode::SourceSpans {
             // Source spans mode: [LetDeclaration, sourceSpan, name, value]
-            // The source span includes the trailing semicolon (Angular v22).
+            // v21.2.7 fixtures: the humanized source span does not include the
+            // trailing semicolon (Angular later changed this in v22).
             let source_span = self.span_text(&decl.source_span);
+            let source_span = source_span.trim_end_matches(';').to_string();
             let name = self.span_text(&decl.name_span);
             let value = self.span_text(&decl.value_span);
             self.result.push(vec!["LetDeclaration".to_string(), source_span, name, value]);
@@ -675,18 +677,27 @@ impl<'a> R3Visitor<'a> for R3Humanizer<'_> {
         for group in &block.groups {
             self.visit_switch_block_case_group(group);
         }
-        if let Some(check) = &block.exhaustive_check {
-            let row = if self.mode == HumanizeMode::SourceSpans {
-                let source_span = self.span_text(&check.source_span);
-                let start_span = self.span_text(&check.start_source_span);
-                vec!["SwitchExhaustiveCheck".to_string(), source_span, start_span]
-            } else {
-                vec!["SwitchExhaustiveCheck".to_string()]
-            };
-            self.result.push(row);
+        // Angular v21.2.7 exhaustive-switch feature: emit the `@default never;`
+        // marker after the case groups (matching upstream `block.exhaustiveCheck?.visit`).
+        if let Some(exhaustive_check) = &block.exhaustive_check {
+            self.visit_switch_exhaustive_check(exhaustive_check);
         }
     }
 
+    fn visit_switch_exhaustive_check(
+        &mut self,
+        check: &oxc_angular_compiler::ast::r3::R3SwitchExhaustiveCheck,
+    ) {
+        let row = if self.mode == HumanizeMode::SourceSpans {
+            let source_span = self.span_text(&check.source_span);
+            let start_span = self.span_text(&check.start_source_span);
+            vec!["SwitchExhaustiveCheck".to_string(), source_span, start_span]
+        } else {
+            vec!["SwitchExhaustiveCheck".to_string()]
+        };
+        self.result.push(row);
+    }
+
     fn visit_switch_block_case_group(
         &mut self,
         group: &oxc_angular_compiler::ast::r3::R3SwitchBlockCaseGroup<'a>,
diff --git a/crates/oxc_angular_compiler/angular b/crates/oxc_angular_compiler/angular
index 1cb0524f8..50761c8be 160000
--- a/crates/oxc_angular_compiler/angular
+++ b/crates/oxc_angular_compiler/angular
@@ -1 +1 @@
-Subproject commit 1cb0524f82ebcc06642ceebd0b96a19bba883b2e
+Subproject commit 50761c8be4939c5a8f14b986cea93a9b68152c49
diff --git a/crates/oxc_angular_compiler/src/ast/html.rs b/crates/oxc_angular_compiler/src/ast/html.rs
index 4e9291ef8..8028c5402 100644
--- a/crates/oxc_angular_compiler/src/ast/html.rs
+++ b/crates/oxc_angular_compiler/src/ast/html.rs
@@ -125,6 +125,18 @@ pub struct HtmlElement<'a> {
     /// Whether this is a void element (area, base, br, col, embed, hr, img, input, link, meta, param, source, track, wbr).
     /// Void elements cannot have content and do not have end tags.
     pub is_void: bool,
+    /// True only when the parser tokenized this as a selectorless COMPONENT
+    /// (which requires selectorless mode to be enabled). This distinguishes a
+    /// bare component `<MyCmp>` from an uppercase NORMAL element `<IFRAME>`,
+    /// which are otherwise identical at this node (`component_prefix` /
+    /// `component_tag_name` are both `None` for a bare component too). The R3
+    /// transform uses this marker — NOT a leading-character casing heuristic —
+    /// to decide whether to build a component node and route the
+    /// security-context / i18n trusted-types lookups through `component.tagName`.
+    /// Because a component is only ever produced when `selectorless_enabled` is
+    /// true, this is automatically `false` for the default (selectorless-off)
+    /// pipeline the real compiler uses.
+    pub is_component: bool,
 }
 
 /// A selectorless component in the HTML AST.
@@ -253,6 +265,8 @@ pub enum BlockType {
     Case,
     /// A @default block.
     Default,
+    /// A `@default never;` exhaustive-switch marker (Angular v21.2.7).
+    DefaultNever,
     /// A @defer block.
     Defer,
     /// A @placeholder block.
@@ -518,6 +532,7 @@ mod tests {
             end_span: None,
             is_self_closing: false,
             is_void: false,
+            is_component: false,
         };
 
         let child2 = HtmlElement {
@@ -532,6 +547,7 @@ mod tests {
             end_span: None,
             is_self_closing: false,
             is_void: false,
+            is_component: false,
         };
 
         let mut children = Vec::new_in(&&allocator);
@@ -550,6 +566,7 @@ mod tests {
             end_span: None,
             is_self_closing: false,
             is_void: false,
+            is_component: false,
         };
 
         let mut nodes = Vec::new_in(&&allocator);
diff --git a/crates/oxc_angular_compiler/src/ast/r3.rs b/crates/oxc_angular_compiler/src/ast/r3.rs
index 5b887557e..5800d2a54 100644
--- a/crates/oxc_angular_compiler/src/ast/r3.rs
+++ b/crates/oxc_angular_compiler/src/ast/r3.rs
@@ -913,8 +913,12 @@ pub struct R3SwitchBlock<'a> {
     pub groups: Vec<'a, R3SwitchBlockCaseGroup<'a>>,
     /// Unknown blocks for error recovery.
     pub unknown_blocks: Vec<'a, R3UnknownBlock<'a>>,
-    /// Optional exhaustive check (`@default never;`, v22+).
-    pub exhaustive_check: Option<R3SwitchExhaustiveCheck<'a>>,
+    /// Exhaustive-check marker (`@default never;`), if present.
+    ///
+    /// Angular v21.2.7 exhaustive-switch feature: a `@default never;` block
+    /// inside a `@switch` produces a `SwitchExhaustiveCheck` node stored here
+    /// (rather than a regular `@default` case group).
+    pub exhaustive_check: Option<R3SwitchExhaustiveCheck>,
     /// Source span.
     pub source_span: Span,
     /// Start span.
@@ -925,14 +929,13 @@ pub struct R3SwitchBlock<'a> {
     pub name_span: Span,
 }
 
-/// A switch exhaustive check (`@default never;`, v22+).
+/// A switch exhaustive-check marker (`@default never;`).
 ///
-/// Marks a `@switch` as exhaustive for type-narrowing purposes. It carries no
-/// body and emits no runtime output.
+/// Angular v21.2.7 exhaustive-switch feature: asserts that the surrounding
+/// `@switch` is exhaustively type-checked. It is a self-terminating block with
+/// no body and is stored on `R3SwitchBlock::exhaustive_check`.
 #[derive(Debug)]
-pub struct R3SwitchExhaustiveCheck<'a> {
-    /// Optional expression (`@default never(expr);`).
-    pub expression: Option<AngularExpression<'a>>,
+pub struct R3SwitchExhaustiveCheck {
     /// Source span.
     pub source_span: Span,
     /// Start span.
@@ -1531,13 +1534,13 @@ pub trait R3Visitor<'a> {
         for group in &block.groups {
             self.visit_switch_block_case_group(group);
         }
-        if let Some(check) = &block.exhaustive_check {
-            self.visit_switch_exhaustive_check(check);
+        if let Some(exhaustive_check) = &block.exhaustive_check {
+            self.visit_switch_exhaustive_check(exhaustive_check);
         }
     }
 
-    /// Visit a switch exhaustive check (`@default never;`).
-    fn visit_switch_exhaustive_check(&mut self, _check: &R3SwitchExhaustiveCheck<'a>) {}
+    /// Visit a switch exhaustive-check marker (`@default never;`).
+    fn visit_switch_exhaustive_check(&mut self, _check: &R3SwitchExhaustiveCheck) {}
 
     /// Visit a switch block case group.
     fn visit_switch_block_case_group(&mut self, group: &R3SwitchBlockCaseGroup<'a>) {
diff --git a/crates/oxc_angular_compiler/src/component/transform.rs b/crates/oxc_angular_compiler/src/component/transform.rs
index ae02fd4fc..dccfa9098 100644
--- a/crates/oxc_angular_compiler/src/component/transform.rs
+++ b/crates/oxc_angular_compiler/src/component/transform.rs
@@ -32,7 +32,7 @@ use super::import_elision::{ImportElisionAnalyzer, import_elision_edits};
 use super::metadata::{AngularVersion, ComponentMetadata, HostMetadata};
 use super::namespace_registry::NamespaceRegistry;
 use crate::ast::expression::{BindingType, ParsedEventType};
-use crate::ast::r3::{R3BoundAttribute, R3BoundEvent, SecurityContext};
+use crate::ast::r3::{R3BoundAttribute, R3BoundEvent};
 use crate::class_metadata::{
     R3ClassMetadata, R3DeferPerComponentDependency, build_ctor_params_metadata,
     build_decorator_metadata_array, build_prop_decorators_metadata, compile_class_metadata,
@@ -4660,6 +4660,17 @@ fn convert_host_metadata_to_input<'a>(
         // Determine binding type based on property name prefix
         let (binding_type, final_name, unit) = parse_host_property_name(prop_name);
 
+        // Compute the security context for the host binding using the component
+        // selector as the element context, mirroring upstream Angular's
+        // `createHostBindingsFunction` → `calcPossibleSecurityContexts`. Attribute
+        // and property bindings get a real context (and thus a sanitizer/validator
+        // downstream); class/style/animation bindings keep their fixed contexts.
+        let security_context = crate::schema::host_binding_security_context(
+            binding_type,
+            final_name,
+            component_selector.as_str(),
+        );
+
         // Parse the value expression
         let value_str = allocator.alloc_str(value.as_str());
         let parse_result = binding_parser.parse_binding(value_str, empty_span);
@@ -4667,7 +4678,7 @@ fn convert_host_metadata_to_input<'a>(
         properties.push(R3BoundAttribute {
             name: Ident::from_in(final_name, &allocator),
             binding_type,
-            security_context: SecurityContext::None,
+            security_context,
             value: parse_result.ast,
             unit: unit.map(|u| Ident::from_in(u, &allocator)),
             source_span: empty_span,
diff --git a/crates/oxc_angular_compiler/src/directive/compiler.rs b/crates/oxc_angular_compiler/src/directive/compiler.rs
index 7df853a01..24f429b23 100644
--- a/crates/oxc_angular_compiler/src/directive/compiler.rs
+++ b/crates/oxc_angular_compiler/src/directive/compiler.rs
@@ -23,7 +23,7 @@ use super::metadata::{
     R3DirectiveMetadata, R3HostDirectiveMetadata, R3HostMetadata, R3InputMetadata,
 };
 use crate::ast::expression::{BindingType, ParsedEventType};
-use crate::ast::r3::{R3BoundAttribute, R3BoundEvent, SecurityContext};
+use crate::ast::r3::{R3BoundAttribute, R3BoundEvent};
 use crate::output::ast::{
     FunctionExpr, InvokeFunctionExpr, LiteralArrayExpr, LiteralExpr, LiteralMapEntry,
     LiteralMapExpr, LiteralValue, OutputExpression, OutputStatement, ReadPropExpr, ReadVarExpr,
@@ -624,6 +624,17 @@ fn convert_r3_host_metadata_to_input<'a>(
         // Determine binding type based on property name prefix
         let (binding_type, final_name, unit) = parse_host_property_name(prop_name);
 
+        // Compute the security context for the host binding using the directive
+        // selector as the element context, mirroring upstream Angular's
+        // `createHostBindingsFunction` → `calcPossibleSecurityContexts`. Attribute
+        // and property bindings get a real context (and thus a sanitizer/validator
+        // downstream); class/style/animation bindings keep their fixed contexts.
+        let security_context = crate::schema::host_binding_security_context(
+            binding_type,
+            final_name,
+            directive_selector.as_str(),
+        );
+
         // Parse the value expression
         let value_str = allocator.alloc_str(value.as_str());
         let parse_result = binding_parser.parse_binding(value_str, empty_span);
@@ -631,7 +642,7 @@ fn convert_r3_host_metadata_to_input<'a>(
         properties.push(R3BoundAttribute {
             name: Ident::from_in(final_name, &allocator),
             binding_type,
-            security_context: SecurityContext::None,
+            security_context,
             value: parse_result.ast,
             unit: unit.map(|u| Ident::from_in(u, &allocator)),
             source_span: empty_span,
diff --git a/crates/oxc_angular_compiler/src/i18n/extractor_merger.rs b/crates/oxc_angular_compiler/src/i18n/extractor_merger.rs
index 3a143e4aa..3a65af909 100644
--- a/crates/oxc_angular_compiler/src/i18n/extractor_merger.rs
+++ b/crates/oxc_angular_compiler/src/i18n/extractor_merger.rs
@@ -17,6 +17,7 @@ use crate::i18n::ast::{
 };
 use crate::i18n::parser::{I18nMessageFactory, create_i18n_message_factory};
 use crate::i18n::translation_bundle::TranslationBundle;
+use crate::schema::is_trusted_types_sink;
 use crate::util::{ParseSourceFile, ParseSourceSpan};
 
 // ============================================================================
@@ -1099,6 +1100,23 @@ impl<'a> I18nVisitor<'a> {
             }
         }
 
+        // Issue #315 (defense-in-depth): never translate Trusted Types sink attributes
+        // (e.g. `iframe src`) on the merge path either. The extraction path
+        // (`visit_attributes_of`) reports an error for these; this method is `&self`, so
+        // it cannot push to `self.errors` — it silently keeps the original (untranslated)
+        // value, which is the safe outcome.
+        //
+        // FAITHFULNESS NOTE (no namespace strip): `is_trusted_types_sink` only
+        // LOWERCASES the tag — it does NOT strip a `:ns:` prefix (matching upstream
+        // `schema/trusted_types_sinks.ts` `isTrustedTypesSink`, a single `.toLowerCase()`
+        // then `${tag}|${name}` / `*|${name}`). So we pass the FULL element `name`
+        // un-stripped, exactly as the AOT i18n guard passes `node.name`
+        // (`render3/view/i18n/meta.ts` ~213). Hence `<svg:iframe i18n-src>` looks up
+        // `:svg:iframe|src`, which is NOT a sink -> allowed (the previous ns-strip wrongly
+        // mapped it to `iframe|src` and blocked it). This JIT-style merge model has no
+        // selectorless-component nodes, so the component/bare-component cases handled in
+        // `transform/html_to_r3.rs` do not arise here.
+
         attrs
             .iter()
             .filter_map(|attr| {
@@ -1112,7 +1130,10 @@ impl<'a> I18nVisitor<'a> {
                 let needs_translation =
                     i18n_meta.is_some() || implicit_attr_names.iter().any(|n| n == attr.name);
 
-                if needs_translation && !attr.is_interpolation_only && !attr.value.trim().is_empty()
+                if needs_translation
+                    && !is_trusted_types_sink(element_name, attr.name)
+                    && !attr.is_interpolation_only
+                    && !attr.value.trim().is_empty()
                 {
                     // Look up translation for this attribute
                     if let Some(translated_value) = self.translate_attribute_value_for_merge(
@@ -1243,8 +1264,46 @@ impl<'a> I18nVisitor<'a> {
             }
         }
 
+        // Issue #315 (defense-in-depth): refuse to translate Trusted Types sink
+        // attributes (e.g. `iframe src`). The AOT i18n path already guards this in
+        // `render3/view/i18n/meta.ts` (mirrored in `transform/html_to_r3.rs`);
+        // upstream's `extractor_merger.ts` does NOT have this guard, but a translated
+        // sink value would still be an XSS vector, so we refuse it here too.
+        //
+        // FAITHFULNESS NOTE (no namespace strip): `is_trusted_types_sink` only
+        // LOWERCASES the tag — it does NOT strip a `:ns:` prefix (matching upstream
+        // `schema/trusted_types_sinks.ts` `isTrustedTypesSink`). So we pass the FULL
+        // element `name` un-stripped, exactly as the AOT i18n guard passes `node.name`
+        // (`render3/view/i18n/meta.ts` ~213). Hence `<svg:iframe i18n-src>` looks up
+        // `:svg:iframe|src`, which is NOT a sink -> allowed (the previous ns-strip
+        // wrongly mapped it to `iframe|src` and blocked it). This JIT-style extraction
+        // model has no selectorless-component nodes, so the component/bare-component
+        // cases handled in `transform/html_to_r3.rs` do not arise here.
+        //
+        // SCOPE NOTE: like the AOT path, this only blocks *trusted-types sink*
+        // attributes; it does not block other security-sensitive contexts (e.g. a
+        // translatable `<svg:script i18n-href>`), matching v21.2.7's scope rather than
+        // hardening beyond it. See the parallel NOTE in `transform/html_to_r3.rs`.
+
         // Process attributes
         for attr in attrs {
+            let is_explicit = explicit_attr_names.contains_key(attr.name);
+            let is_implicit = implicit_attr_names.iter().any(|n| n == attr.name);
+            if !is_explicit && !is_implicit {
+                continue;
+            }
+
+            if is_trusted_types_sink(element_name, attr.name) {
+                self.report_error(
+                    attr.span,
+                    &format!(
+                        "Translating attribute '{}' is disallowed for security reasons.",
+                        attr.name
+                    ),
+                );
+                continue;
+            }
+
             if let Some(i18n_meta) = explicit_attr_names.get(attr.name) {
                 self.add_message_from_attr(
                     attr.name,
@@ -1253,7 +1312,7 @@ impl<'a> I18nVisitor<'a> {
                     attr.span,
                     attr.is_interpolation_only,
                 );
-            } else if implicit_attr_names.iter().any(|n| n == attr.name) {
+            } else {
                 self.add_message_from_attr(
                     attr.name,
                     attr.value,
@@ -1794,6 +1853,148 @@ mod tests {
         assert!(result.errors.is_empty());
     }
 
+    // ------------------------------------------------------------------
+    // Issue #315: Trusted Types sink attributes must not be translated.
+    // ------------------------------------------------------------------
+
+    /// Builds a single `<element i18n-<attr>="..." <attr>="value">` node for tests.
+    fn element_with_i18n_attr<'a>(
+        element: &'a str,
+        attr: &'a str,
+        i18n_marker: &'a str,
+        value: &'a str,
+    ) -> Vec<HtmlNodeRef<'a>> {
+        vec![HtmlNodeRef::Element {
+            name: element,
+            attrs: vec![
+                HtmlAttrRef {
+                    name: i18n_marker,
+                    value: "",
+                    span: Span::default(),
+                    is_interpolation_only: false,
+                },
+                HtmlAttrRef {
+                    name: attr,
+                    value,
+                    span: Span::default(),
+                    is_interpolation_only: false,
+                },
+            ],
+            children: vec![],
+            span: Span::default(),
+            start_span: Span::default(),
+            end_span: None,
+        }]
+    }
+
+    #[test]
+    fn test_sink_attr_iframe_src_not_extracted_and_reports_error() {
+        // `<iframe i18n-src src="http://evil"> ` — `iframe|src` is a Trusted Types
+        // (TrustedScriptURL) sink, so it must NOT be collected as a translatable
+        // message, and the extraction path must report a security error.
+        let source_file = Arc::new(ParseSourceFile::new("", "<test>"));
+        let nodes = element_with_i18n_attr("iframe", "src", "i18n-src", "http://example.com");
+        let result = extract_messages(&nodes, &[], &FxHashMap::default(), true, source_file);
+        assert!(
+            result.messages.is_empty(),
+            "sink attribute `iframe src` must not be extracted, got {:?}",
+            result.messages
+        );
+        assert!(
+            result.errors.iter().any(|e| e.message.contains("disallowed for security reasons")),
+            "expected a security error for `iframe src`, got {:?}",
+            result.errors
+        );
+    }
+
+    #[test]
+    fn test_sink_attr_srcdoc_not_extracted() {
+        // `iframe|srcdoc` is a TrustedHTML sink.
+        let source_file = Arc::new(ParseSourceFile::new("", "<test>"));
+        let nodes = element_with_i18n_attr("iframe", "srcdoc", "i18n-srcdoc", "<b>hi</b>");
+        let result = extract_messages(&nodes, &[], &FxHashMap::default(), true, source_file);
+        assert!(result.messages.is_empty());
+        assert!(
+            result.errors.iter().any(|e| e.message.contains("disallowed for security reasons"))
+        );
+    }
+
+    #[test]
+    fn test_sink_attr_wildcard_innerhtml_not_extracted() {
+        // `*|innerHTML` is a sink on ANY tag; check on a plain `<div>` and verify the
+        // match is case-insensitive (`innerHTML` vs lowercase set entry).
+        let source_file = Arc::new(ParseSourceFile::new("", "<test>"));
+        let nodes = element_with_i18n_attr("div", "innerHTML", "i18n-innerHTML", "<b>hi</b>");
+        let result = extract_messages(&nodes, &[], &FxHashMap::default(), true, source_file);
+        assert!(result.messages.is_empty());
+        assert!(
+            result.errors.iter().any(|e| e.message.contains("disallowed for security reasons"))
+        );
+    }
+
+    #[test]
+    fn test_sink_attr_namespaced_element_not_stripped_is_allowed() {
+        // FAITHFUL to v21.2.7: `is_trusted_types_sink` only LOWERCASES the tag — it does
+        // NOT strip `:ns:` (matching upstream `schema/trusted_types_sinks.ts`
+        // `isTrustedTypesSink`). The i18n guard passes the FULL element name un-stripped
+        // (`render3/view/i18n/meta.ts` ~213 passes `node.name`), so `:svg:iframe|src` is
+        // NOT a member of `TRUSTED_TYPES_SINKS` -> ALLOWED. Verified against
+        // @angular/compiler@21.2.7 `parseTemplate({enableSelectorless:true})`:
+        // `<svg:iframe i18n-src>` produces NO error. (Pre-fix this path ns-stripped to
+        // `iframe|src` and wrongly blocked it.)
+        let source_file = Arc::new(ParseSourceFile::new("", "<test>"));
+        let nodes = element_with_i18n_attr(":svg:iframe", "src", "i18n-src", "http://example.com");
+        let result = extract_messages(&nodes, &[], &FxHashMap::default(), true, source_file);
+        assert_eq!(
+            result.messages.len(),
+            1,
+            "namespaced `:svg:iframe src` is NOT a sink and must be extracted, got {:?}",
+            result.messages
+        );
+        assert!(
+            !result.errors.iter().any(|e| e.message.contains("disallowed for security reasons")),
+            "namespaced `:svg:iframe src` must NOT trigger a security error, got {:?}",
+            result.errors
+        );
+    }
+
+    #[test]
+    fn test_sink_attr_plain_iframe_still_blocked() {
+        // CONTROL (unchanged): a plain `<iframe i18n-src>` -> `iframe|src` IS a sink ->
+        // blocked. Verified against @angular/compiler@21.2.7.
+        let source_file = Arc::new(ParseSourceFile::new("", "<test>"));
+        let nodes = element_with_i18n_attr("iframe", "src", "i18n-src", "http://example.com");
+        let result = extract_messages(&nodes, &[], &FxHashMap::default(), true, source_file);
+        assert!(
+            result.messages.is_empty(),
+            "plain `iframe src` IS a sink and must be blocked, got {:?}",
+            result.messages
+        );
+        assert!(
+            result.errors.iter().any(|e| e.message.contains("disallowed for security reasons"))
+        );
+    }
+
+    #[test]
+    fn test_non_sink_attr_title_is_extracted() {
+        // Control: `<a i18n-title title="Go">` — `a|title` is NOT a sink, so it must
+        // still be extracted and produce no security error.
+        let source_file = Arc::new(ParseSourceFile::new("", "<test>"));
+        let nodes = element_with_i18n_attr("a", "title", "i18n-title", "Go home");
+        let result = extract_messages(&nodes, &[], &FxHashMap::default(), true, source_file);
+        assert_eq!(
+            result.messages.len(),
+            1,
+            "non-sink `a title` must be extracted, got {:?}",
+            result.messages
+        );
+        assert!(
+            !result.errors.iter().any(|e| e.message.contains("disallowed for security reasons")),
+            "non-sink attribute must not trigger a security error, got {:?}",
+            result.errors
+        );
+    }
+
     #[test]
     fn test_parse_translated_text_plain() {
         let nodes = parse_translated_text("Hello World", Span::default());
diff --git a/crates/oxc_angular_compiler/src/i18n/parser.rs b/crates/oxc_angular_compiler/src/i18n/parser.rs
index ce9bbd834..0ed783549 100644
--- a/crates/oxc_angular_compiler/src/i18n/parser.rs
+++ b/crates/oxc_angular_compiler/src/i18n/parser.rs
@@ -545,8 +545,34 @@ impl I18nMessageFactory {
         context: &mut I18nVisitorContext,
         visit_fn: VisitNodeFn,
     ) -> Option<Node> {
-        let tag_name = element.name.as_str();
-        let is_void = is_void_element(tag_name);
+        // Compute the placeholder tag NAME and voidness. For a selectorless COMPONENT
+        // (parsed as an `HtmlElement` with `is_component == true`; the parser never
+        // produces `HtmlNode::Component`), upstream v21.2.7 `i18n/i18n_parser.ts`
+        // `_visitElementLike` uses `node.fullName` for the placeholder name and derives
+        // voidness from `getHtmlTagDefinition(node.tagName).isVoid` (null tagName -> false):
+        //   ```
+        //   if (node instanceof html.Element) {
+        //     nodeName = node.name;
+        //     isVoid = getHtmlTagDefinition(node.name).isVoid;
+        //   } else {
+        //     nodeName = node.fullName;
+        //     isVoid = node.tagName ? getHtmlTagDefinition(node.tagName).isVoid : false;
+        //   }
+        //   ```
+        // `getHtmlTagDefinition` does NOT strip the namespace (only lowercases), so a
+        // resolved `:svg:image` host misses the void set (-> false) while a bare `img`
+        // host hits it (-> true) — matching `is_void_element` here. For a normal element,
+        // the name and voidness come from `element.name` unchanged.
+        let component_tag = element.is_component.then(|| component_tag_name(element)).flatten();
+        let component_full_name =
+            element.is_component.then(|| component_full_name(element, component_tag.as_deref()));
+        let tag_name: &str =
+            component_full_name.as_deref().unwrap_or_else(|| element.name.as_str());
+        let is_void = if element.is_component {
+            component_tag.as_deref().is_some_and(is_void_element)
+        } else {
+            is_void_element(tag_name)
+        };
 
         // Convert element attributes to an IndexMap for placeholder registry (ordered for consistent serialization)
         let mut attrs: IndexMap<String, String> = element
@@ -794,6 +820,37 @@ pub fn create_i18n_message_factory(
     I18nMessageFactory::new(retain_empty_tokens, preserve_expression_whitespace)
 }
 
+/// Resolves a selectorless component's HOST tag name (upstream `_getComponentTagName` /
+/// `component.tagName`) from the parser-resolved `component_prefix`/`component_tag_name`.
+/// Mirrors `transform/html_to_r3.rs` exactly:
+///   * (None, None)            -> None (bare `<MyCmp>`, tagName null)
+///   * (None, Some(tag))       -> the bare tag (e.g. "button")
+///   * (Some(prefix), None)    -> `:prefix:ng-component`
+///   * (Some(prefix), Some(t)) -> `:prefix:t` (e.g. ":svg:rect")
+fn component_tag_name(element: &HtmlElement<'_>) -> Option<String> {
+    match (&element.component_prefix, &element.component_tag_name) {
+        (None, None) => None,
+        (None, Some(tag)) => Some(tag.to_string()),
+        (Some(prefix), None) => Some(format!(":{prefix}:ng-component")),
+        (Some(prefix), Some(tag)) => Some(format!(":{prefix}:{tag}")),
+    }
+}
+
+/// Composes a selectorless component's FULL NAME (upstream `_getComponentFullName` /
+/// `component.fullName`), used as the i18n placeholder tag name. Mirrors
+/// `transform/html_to_r3.rs`:
+///   * resolved tag starts with ':' -> `ComponentName` + tag (e.g. "MyCmp:svg:rect")
+///   * other resolved tag           -> `ComponentName:tag`   (e.g. "MyCmp:button")
+///   * no resolved tag (bare)       -> `ComponentName`       (e.g. "MyCmp")
+/// `element.name` is the component class name for a selectorless component.
+fn component_full_name(element: &HtmlElement<'_>, resolved_tag: Option<&str>) -> String {
+    match resolved_tag {
+        Some(tag) if tag.starts_with(':') => format!("{}{}", element.name, tag),
+        Some(tag) => format!("{}:{}", element.name, tag),
+        None => element.name.to_string(),
+    }
+}
+
 /// Extracts a custom placeholder name from an expression if present.
 /// Looks for comments like `// i18n(ph="CUSTOM_NAME")` in the expression.
 ///
@@ -933,4 +990,111 @@ mod tests {
             panic!("Expected Container node");
         }
     }
+
+    // ---- Finding 1: selectorless component placeholders (fullName + resolved-tag voidness) ----
+    //
+    // Selectorless components are parsed as `HtmlNode::Element` with `is_component == true`
+    // (the parser never produces `HtmlNode::Component`). The i18n message factory therefore
+    // routes them through `visit_element`. Upstream v21.2.7 `i18n/i18n_parser.ts`
+    // `_visitElementLike` uses `node.fullName` for the placeholder NAME and
+    // `getHtmlTagDefinition(node.tagName).isVoid` (null tagName -> false) for voidness.
+    //
+    // Oracle (`@angular/compiler@21.2.7` `parseTemplate(html, url, {enableSelectorless:true})`):
+    //   <MyCmp:button>x</MyCmp:button> -> fullName "MyCmp:button", isVoid=false,
+    //                                     START_TAG_MYCMP:BUTTON / CLOSE_TAG_MYCMP:BUTTON
+    //   <MyCmp:img />                  -> fullName "MyCmp:img", isVoid=true (host "img"),
+    //                                     TAG_MYCMP:IMG / "" (no close)
+    //   <MyCmp>x</MyCmp>               -> fullName "MyCmp", isVoid=false (tagName null),
+    //                                     START_TAG_MYCMP / CLOSE_TAG_MYCMP
+    //   <MyCmp:svg:rect>y</...>        -> fullName "MyCmp:svg:rect", isVoid=false
+    //   <svg><MyCmp:image></svg>       -> fullName "MyCmp:svg:image", isVoid=false
+    //                                     (getHtmlTagDefinition(":svg:image") -> default, NOT void)
+
+    /// Parses `inner_html` wrapped in `<div i18n>...</div>` with selectorless enabled and
+    /// returns the i18n Message extracted from the div's children (mirrors the AOT path in
+    /// `transform/html_to_r3.rs`, which calls `create_message(&element.children, ..)`).
+    fn extract_component_message(inner_html: &str) -> Message {
+        use crate::parser::html::HtmlParser;
+        let html = format!("<div i18n>{inner_html}</div>");
+        let allocator = oxc_allocator::Allocator::default();
+        // Leak the source so it outlives the parse result borrow within this helper.
+        let src: &str = allocator.alloc_str(&html);
+        let parser = HtmlParser::with_selectorless(&allocator, src, "<test>");
+        let result = parser.parse();
+        assert!(result.errors.is_empty(), "parse errors: {:?}", result.errors);
+        // The single root is the <div i18n>; extract the message from its children.
+        let HtmlNode::Element(div) = &result.nodes[0] else {
+            panic!("expected <div> root, got {:?}", result.nodes[0]);
+        };
+        let factory = I18nMessageFactory::new(false, true);
+        let source_file = Arc::new(ParseSourceFile::new(html.clone(), "<test>"));
+        factory.create_message(&div.children, None, None, None, None, source_file)
+    }
+
+    fn first_tag_placeholder(message: &Message) -> &TagPlaceholder {
+        match &message.nodes[0] {
+            Node::TagPlaceholder(tp) => tp,
+            other => panic!("expected TagPlaceholder, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn test_component_placeholder_with_host_tag() {
+        let message = extract_component_message("<MyCmp:button>x</MyCmp:button>");
+        let tp = first_tag_placeholder(&message);
+        assert_eq!(tp.tag, "MyCmp:button");
+        assert!(!tp.is_void);
+        assert_eq!(tp.start_name, "START_TAG_MYCMP:BUTTON");
+        assert_eq!(tp.close_name, "CLOSE_TAG_MYCMP:BUTTON");
+        assert!(message.placeholders.contains_key("START_TAG_MYCMP:BUTTON"));
+        assert!(message.placeholders.contains_key("CLOSE_TAG_MYCMP:BUTTON"));
+    }
+
+    #[test]
+    fn test_component_placeholder_void_host() {
+        let message = extract_component_message("<MyCmp:img />");
+        let tp = first_tag_placeholder(&message);
+        assert_eq!(tp.tag, "MyCmp:img");
+        assert!(tp.is_void, "img host tag must be void");
+        assert_eq!(tp.start_name, "TAG_MYCMP:IMG");
+        assert_eq!(tp.close_name, "");
+        assert!(message.placeholders.contains_key("TAG_MYCMP:IMG"));
+    }
+
+    #[test]
+    fn test_component_placeholder_bare() {
+        let message = extract_component_message("<MyCmp>x</MyCmp>");
+        let tp = first_tag_placeholder(&message);
+        assert_eq!(tp.tag, "MyCmp");
+        assert!(!tp.is_void, "bare component (null tagName) is not void");
+        assert_eq!(tp.start_name, "START_TAG_MYCMP");
+        assert_eq!(tp.close_name, "CLOSE_TAG_MYCMP");
+    }
+
+    #[test]
+    fn test_component_placeholder_namespaced_host() {
+        let message = extract_component_message("<MyCmp:svg:rect>y</MyCmp:svg:rect>");
+        let tp = first_tag_placeholder(&message);
+        assert_eq!(tp.tag, "MyCmp:svg:rect");
+        assert!(!tp.is_void);
+        assert_eq!(tp.start_name, "START_TAG_MYCMP:SVG:RECT");
+        assert_eq!(tp.close_name, "CLOSE_TAG_MYCMP:SVG:RECT");
+    }
+
+    #[test]
+    fn test_component_placeholder_svg_inherited_ns() {
+        // Host tag "image" inherits svg ns -> tagName ":svg:image"; getHtmlTagDefinition
+        // does not ns-strip, so the lookup misses and isVoid stays false.
+        let message = extract_component_message("<svg><MyCmp:image></MyCmp:image></svg>");
+        // Outer placeholder is the <svg> element; its child is the component.
+        let svg = first_tag_placeholder(&message);
+        assert_eq!(svg.tag, ":svg:svg");
+        let Node::TagPlaceholder(cmp) = &svg.children[0] else {
+            panic!("expected component TagPlaceholder child, got {:?}", svg.children[0]);
+        };
+        assert_eq!(cmp.tag, "MyCmp:svg:image");
+        assert!(!cmp.is_void);
+        assert_eq!(cmp.start_name, "START_TAG_MYCMP:SVG:IMAGE");
+        assert_eq!(cmp.close_name, "CLOSE_TAG_MYCMP:SVG:IMAGE");
+    }
 }
diff --git a/crates/oxc_angular_compiler/src/parser/html/lexer.rs b/crates/oxc_angular_compiler/src/parser/html/lexer.rs
index 1add82126..d192de769 100644
--- a/crates/oxc_angular_compiler/src/parser/html/lexer.rs
+++ b/crates/oxc_angular_compiler/src/parser/html/lexer.rs
@@ -40,7 +40,7 @@ pub enum HtmlTokenType {
     IncompleteTagOpen,
     /// Text content
     Text,
-    /// Escapable raw text (inside script/style)
+    /// Escapable raw text (inside `title`/`textarea`; `svg:title` is parsable, not escapable)
     EscapableRawText,
     /// Raw text
     RawText,
@@ -114,6 +114,28 @@ pub enum HtmlTokenType {
     Eof,
 }
 
+/// Describes how to emit the synthetic close token at the end of a raw-text /
+/// escapable-raw-text region, once the close boundary has been matched.
+///
+/// This is the ONLY thing that differs between the regular raw-text path and the
+/// selectorless-component raw-text path in upstream v21.2.7
+/// `_consumeRawTextWithTagClose` (ml_parser/lexer.ts:891-912): the close token kind
+/// (`TAG_CLOSE` vs `COMPONENT_CLOSE`, chosen by `openToken.type` on lines 904-908) and
+/// the original-case parts emitted via `_endToken(openToken.parts)` (line 911). The
+/// scanning loop itself (`_consumeRawText`, lines 737-757: cursor snapshot/restore on a
+/// failed close candidate + entity decoding when escapable) is shared by both paths.
+enum RawTextClose<'p> {
+    /// Regular element close: emits a `TagClose` token with `[prefix, name]`
+    /// (original case), matching upstream `_endToken(openToken.parts)` where
+    /// `openToken.parts` are the `TAG_OPEN_START` parts `[prefix, tagName]`.
+    Tag { prefix: &'p str, name: &'p str },
+    /// Selectorless-component close: emits a `ComponentClose` token with
+    /// `[component_name, prefix, tag_name]` (original case), matching upstream
+    /// `_endToken(openToken.parts)` where `openToken.parts` are the
+    /// `COMPONENT_OPEN_START` parts.
+    Component { component_name: &'p str, prefix: &'p str, tag_name: &'p str },
+}
+
 /// A token in an HTML template.
 #[derive(Debug, Clone)]
 pub struct HtmlToken {
@@ -681,6 +703,42 @@ impl<'a> HtmlLexer<'a> {
         ch == '_' || ch.is_ascii_uppercase()
     }
 
+    /// Whether `<` followed by `next` should begin a tag-open (vs being plain text).
+    ///
+    /// Faithful to upstream v21.2.7 `_consumeTagOpen` (ml_parser/lexer.ts:819-835): a
+    /// regular tag-open requires an ASCII LETTER after `<`; `/` (close) and `!`
+    /// (comment/doctype/cdata) are also tag-opens. A selectorless component name
+    /// additionally starts with `_` (`isSelectorlessNameStart` = `_`|A-Z), but ONLY when
+    /// selectorless mode is enabled. Uppercase letters are already ASCII letters, so the
+    /// only selectorless-specific addition is `_`. Hence in DEFAULT mode `<_foo>` is NOT a
+    /// tag-open and becomes text, while `<MyCmp>` (ASCII-letter start) stays a normal tag.
+    fn is_tag_open_start(next: char, selectorless_enabled: bool) -> bool {
+        next == '/'
+            || next == '!'
+            || next.is_ascii_alphabetic()
+            || (selectorless_enabled && next == '_')
+    }
+
+    /// Whether `<` followed by `next` ends a TEXT run (i.e. is the start of a tag for
+    /// the purposes of TEXT accumulation / interpolation termination).
+    ///
+    /// This is the exact twin of upstream `_isTagStart` (ml_parser/lexer.ts:1348-1364):
+    /// `<` is a text-end tag start only when the next char is an ASCII LETTER (a-z|A-Z),
+    /// `/`, or `!`. Crucially it has NO `_` and NO selectorless gating — in BOTH modes.
+    ///
+    /// This differs from `is_tag_open_start` (the token-DISPATCH predicate, which adds
+    /// selectorless `_`). The split matters for selectorless components mid-text: upstream's
+    /// main `tokenize` loop dispatches a `<` to `_consumeTagOpen` only when the cursor is AT
+    /// `<` at the start of an iteration; during TEXT accumulation it stops at the next
+    /// `_isTagStart`, which is false for `<_`. So mid-text `x<_foo>` is absorbed into the
+    /// text run (until the next real tag like `</…`), while a TOP-LEVEL `<_foo>` (cursor at
+    /// `<` when a token scan begins) still dispatches to the component path. Mirrored here:
+    /// `scan_token` uses `is_tag_open_start` (top-level dispatch, keeps `_`); `scan_text`
+    /// uses `is_text_tag_start` (text-end, no `_`).
+    fn is_text_tag_start(next: char) -> bool {
+        next == '/' || next == '!' || next.is_ascii_alphabetic()
+    }
+
     /// Checks if a character can be part of a selectorless name.
     fn is_selectorless_name_char(ch: char) -> bool {
         ch.is_ascii_alphanumeric() || ch == '_'
@@ -1065,8 +1123,15 @@ impl<'a> HtmlLexer<'a> {
         // A `<` followed by whitespace or other non-tag characters is just text
         if self.peek() == '<' {
             let next = self.peek_at(1);
-            // Valid tag start: `/` (close tag), `!` (comment/doctype/cdata), or letter/underscore
-            if next == '/' || next == '!' || next.is_ascii_alphabetic() || next == '_' {
+            // Valid tag start: `/` (close tag), `!` (comment/doctype/cdata), or a tag-name
+            // start. Upstream v21.2.7 `_consumeTagOpen` (ml_parser/lexer.ts:819-835) accepts
+            // a regular tag only when the next char is an ASCII LETTER; a selectorless
+            // component name additionally starts with `_` (`isSelectorlessNameStart` =
+            // `_`|A-Z), but ONLY when selectorless is enabled. A non-letter like `_` in
+            // DEFAULT mode is not a valid tag-open (upstream throws and emits `<` as text),
+            // so `<_foo>` must be treated as text. Uppercase letters are covered by
+            // `is_ascii_alphabetic`, so the only selectorless-specific addition is `_`.
+            if Self::is_tag_open_start(next, self.selectorless_enabled) {
                 self.scan_tag(start);
                 return;
             }
@@ -1106,22 +1171,16 @@ impl<'a> HtmlLexer<'a> {
             }
         }
 
-        // Normalize whitespace: collapse multiple spaces/tabs into single space
-        let raw = self.input[name_start as usize..self.index as usize].trim();
-        let mut result = String::with_capacity(raw.len());
-        let mut prev_was_whitespace = false;
-        for ch in raw.chars() {
-            if ch.is_whitespace() {
-                if !prev_was_whitespace {
-                    result.push(' ');
-                    prev_was_whitespace = true;
-                }
-            } else {
-                result.push(ch);
-                prev_was_whitespace = false;
-            }
-        }
-        result
+        // Mirror upstream `_getBlockName` (ml_parser/lexer.ts:294):
+        // `return this._cursor.getChars(nameCursor).trim();`
+        // Only leading/trailing whitespace is trimmed; internal whitespace is
+        // PRESERVED verbatim. This matters for the exhaustive marker, which is
+        // recognized by an EXACT equality `parts[0] === 'default never'` (single
+        // space, lexer.ts:302). Collapsing internal runs here would over-accept
+        // malformed forms like `@default   never;` / `@default<TAB>never;`, which
+        // upstream rejects as INCOMPLETE_BLOCK_OPEN (verified vs
+        // @angular/compiler@21.2.7). The diagnostic also preserves the raw spelling.
+        self.input[name_start as usize..self.index as usize].trim().to_string()
     }
 
     /// Scans a block (@if, @for, etc.).
@@ -1140,6 +1199,19 @@ impl<'a> HtmlLexer<'a> {
             self.index,
         ));
 
+        // Angular v21.2.7 exhaustive-switch feature: `@default never;` is a
+        // self-terminating block (no `{ }` body, terminated by `;`). Mirror the
+        // upstream lexer (`_consumeBlockStart` in ml_parser/lexer.ts) which, right
+        // after reading the block name, treats a `default never` name followed by a
+        // semicolon as a complete block: emit BLOCK_OPEN_END + BLOCK_CLOSE.
+        if name == "default never" && self.peek() == ';' {
+            self.advance(); // consume ;
+            let pos = self.index;
+            self.tokens.push(HtmlToken::empty(HtmlTokenType::BlockOpenEnd, pos, pos));
+            self.tokens.push(HtmlToken::empty(HtmlTokenType::BlockClose, pos, pos));
+            return;
+        }
+
         // Skip whitespace
         self.skip_whitespace();
 
@@ -1709,12 +1781,42 @@ impl<'a> HtmlLexer<'a> {
             let lower_name = name.to_lowercase();
             let ns_prefix = if prefix.is_empty() { None } else { Some(prefix.as_str()) };
             let content_type = get_html_tag_definition(&lower_name).get_content_type(ns_prefix);
+            // Faithful to upstream v21.2.7 `_consumeTagOpen` (ml_parser/lexer.ts:837-839):
+            // for a REGULAR tag, `tagName = closingTagName = openToken.parts[1]`, i.e. the
+            // LOCAL name ONLY (e.g. `script`/`style`), WITHOUT any namespace prefix. The
+            // raw-text close boundary is therefore matched against the local name alone.
+            // Only the selectorless-COMPONENT path (lines 821-827) appends `:prefix:tagName`
+            // to `closingTagName`; that path lives in `scan_component_raw_text` and is left
+            // untouched here. Consequently, for `<svg:script>x</svg:script><div>` the boundary
+            // is `script`, the source close tag `</svg:script>` does NOT match it (it reads
+            // `svg:script`), and the raw-text scan runs to EOF — exactly as v21.2.7 does. A
+            // BARE `</script>` (case-insensitive) is what closes it. The match is
+            // case-insensitive, mirroring `_attemptStrCaseInsensitive(tagName)` (line 900),
+            // so `close_match_name` is the lowercased local name.
+            let close_match_name = lower_name.clone();
+            // The EMITTED synthetic TAG_CLOSE token must carry the ORIGINAL-case
+            // prefix/name (matching the TAG_OPEN_START), so the parser pairs them by
+            // exact name. Upstream v21.2.7 `_consumeRawTextWithTagClose`
+            // (ml_parser/lexer.ts:911) emits the close token with `openToken.parts`
+            // (the original-case open-tag parts), while the boundary itself is matched
+            // case-insensitively via `_attemptStrCaseInsensitive(tagName)` (line 900).
+            // Hence `close_match_name` stays the lowercased LOCAL name for boundary
+            // detection, but the token prefix/name passed below are the original-case
+            // `prefix`/`name` (not lowercased).
             match content_type {
                 TagContentType::RawText => {
-                    self.scan_raw_text_with_tag_close(&lower_name, false);
+                    self.scan_raw_text_with_tag_close(
+                        &close_match_name,
+                        RawTextClose::Tag { prefix: &prefix, name: &name },
+                        false,
+                    );
                 }
                 TagContentType::EscapableRawText => {
-                    self.scan_raw_text_with_tag_close(&lower_name, true);
+                    self.scan_raw_text_with_tag_close(
+                        &close_match_name,
+                        RawTextClose::Tag { prefix: &prefix, name: &name },
+                        true,
+                    );
                 }
                 TagContentType::Parsable => {
                     // Normal parsable content, no special handling needed
@@ -1747,10 +1849,41 @@ impl<'a> HtmlLexer<'a> {
         }
     }
 
-    /// Scans raw text content until the closing tag.
+    /// Scans raw text content until the closing tag — the SHARED scanning core used by
+    /// BOTH the regular raw-text path and the selectorless-component raw-text path.
+    ///
     /// For RAW_TEXT (script/style): entities are NOT decoded.
     /// For ESCAPABLE_RAW_TEXT (title/textarea): entities ARE decoded.
-    fn scan_raw_text_with_tag_close(&mut self, tag_name: &str, consume_entities: bool) {
+    ///
+    /// Faithful to upstream v21.2.7 `_consumeRawText` + `_consumeRawTextWithTagClose`
+    /// (ml_parser/lexer.ts:737-757, 891-912): there is exactly ONE raw-text scanner; the
+    /// regular path and the component path differ ONLY in the close-boundary NAME (local
+    /// name for regular tags, full prefixed name for components — see `_consumeTagOpen`
+    /// lines 837-839 vs 821-827) and in the emitted close TOKEN (TAG_CLOSE vs
+    /// COMPONENT_CLOSE — see lines 904-911). The loop body (cursor snapshot/restore on a
+    /// failed close candidate + entity decoding when escapable + original-case emit) is
+    /// identical, so both callers funnel through this one function exactly as upstream
+    /// funnels both through `_consumeRawTextWithTagClose`.
+    fn scan_raw_text_with_tag_close(
+        &mut self,
+        // The lowercased name used to detect the raw-text close boundary. For a REGULAR
+        // tag this is the LOCAL (prefix-stripped) name, e.g. `script` for `<svg:script>`,
+        // faithful to upstream `_consumeTagOpen` (ml_parser/lexer.ts:837-839) where
+        // `closingTagName = openToken.parts[1]`. For a selectorless COMPONENT this is the
+        // FULL prefixed close name, e.g. `comp:script`, faithful to lines 821-827. Matching
+        // is case-insensitive, mirroring upstream `_attemptStrCaseInsensitive(tagName)`
+        // (line 900); the caller passes an already-lowercased name and the scanned source
+        // close name is lowercased here before comparison.
+        close_match_name: &str,
+        // Describes the synthetic close token to emit once the boundary is matched: the
+        // token KIND (TAG_CLOSE vs COMPONENT_CLOSE) and the ORIGINAL-case parts. Upstream
+        // v21.2.7 `_consumeRawTextWithTagClose` chooses the kind by `openToken.type`
+        // (ml_parser/lexer.ts:904-908) and emits `_endToken(openToken.parts)`
+        // (line 911) — the original-case open-tag parts — so the parser pairs open/close by
+        // exact name.
+        close: RawTextClose<'_>,
+        consume_entities: bool,
+    ) {
         let token_type =
             if consume_entities { HtmlTokenType::EscapableRawText } else { HtmlTokenType::RawText };
 
@@ -1781,7 +1914,7 @@ impl<'a> HtmlLexer<'a> {
 
                 self.skip_whitespace();
 
-                if close_tag_name == tag_name && self.peek() == '>' {
+                if close_tag_name == close_match_name && self.peek() == '>' {
                     // Found the closing tag - emit any accumulated content
                     if consume_entities {
                         // For escapable raw text, Angular ALWAYS emits a text token, even if empty.
@@ -1808,15 +1941,33 @@ impl<'a> HtmlLexer<'a> {
                         }
                     }
 
-                    // Emit the closing tag
+                    // Emit the closing tag. Upstream v21.2.7 emits TAG_CLOSE or
+                    // COMPONENT_CLOSE (chosen by `openToken.type`, ml_parser/lexer.ts:904-908)
+                    // with the original-case `openToken.parts` (line 911).
                     self.advance(); // consume >
-                    self.tokens.push(HtmlToken::with_prefix_name(
-                        HtmlTokenType::TagClose,
-                        "",
-                        tag_name,
-                        saved_index,
-                        self.index,
-                    ));
+                    match close {
+                        RawTextClose::Tag { prefix, name } => {
+                            self.tokens.push(HtmlToken::with_prefix_name(
+                                HtmlTokenType::TagClose,
+                                prefix,
+                                name,
+                                saved_index,
+                                self.index,
+                            ));
+                        }
+                        RawTextClose::Component { component_name, prefix, tag_name } => {
+                            self.tokens.push(HtmlToken::new(
+                                HtmlTokenType::ComponentClose,
+                                vec![
+                                    component_name.to_string(),
+                                    prefix.to_string(),
+                                    tag_name.to_string(),
+                                ],
+                                saved_index,
+                                self.index,
+                            ));
+                        }
+                    }
                     return;
                 } else {
                     // Not the matching closing tag - revert and include in content
@@ -1962,7 +2113,20 @@ impl<'a> HtmlLexer<'a> {
         }
     }
 
-    /// Scans raw text content for a component until its closing tag.
+    /// Scans raw text content for a selectorless component until its closing tag.
+    ///
+    /// This is a THIN wrapper over the shared raw-text scanning core
+    /// `scan_raw_text_with_tag_close`. Faithful to upstream v21.2.7 (ml_parser/lexer.ts):
+    /// the component path and the regular path differ ONLY in (a) the close-boundary NAME
+    /// and (b) the emitted close TOKEN, and BOTH funnel through the SAME
+    /// `_consumeRawTextWithTagClose(openToken, closingTagName, ...)` (lines 884-887). The
+    /// scanning LOOP — cursor snapshot/restore on a failed `</...>` close candidate
+    /// (`_consumeRawText`, lines 741-746) plus entity decoding when escapable (lines
+    /// 747-751) — is therefore IDENTICAL to the regular path. Previously this function
+    /// reimplemented the loop and drifted: it (1) failed to restore the cursor after a
+    /// non-matching close candidate (so a valid later `</Comp:script>` could be skipped and
+    /// following siblings swallowed to EOF) and (2) never decoded entities for escapable
+    /// component raw text. Delegating to the shared core fixes both and prevents recurrence.
     fn scan_component_raw_text(
         &mut self,
         component_name: &str,
@@ -1970,79 +2134,27 @@ impl<'a> HtmlLexer<'a> {
         tag_name: &str,
         consume_entities: bool,
     ) {
-        let token_type =
-            if consume_entities { HtmlTokenType::EscapableRawText } else { HtmlTokenType::RawText };
-
-        let content_start = self.index;
-
-        loop {
-            // Check if we're at the closing tag
-            if self.peek() == '<' && self.peek_at(1) == '/' {
-                let saved_index = self.index;
-
-                self.advance(); // <
-                self.advance(); // /
-                self.skip_whitespace();
-
-                // Check if closing tag matches: </ComponentName:prefix:tag> or </ComponentName:tag>
-                let close_name_start = self.index;
-                while !chars::is_whitespace(self.peek())
-                    && self.peek() != '>'
-                    && self.peek() != chars::EOF
-                {
-                    self.advance();
-                }
-                let close_name = &self.input[close_name_start as usize..self.index as usize];
-
-                // Build the expected closing tag name
-                let expected_close = if prefix.is_empty() {
-                    format!("{}:{}", component_name, tag_name)
-                } else {
-                    format!("{}:{}:{}", component_name, prefix, tag_name)
-                };
-
-                self.skip_whitespace();
-
-                if close_name == expected_close && self.peek() == '>' {
-                    // Found the closing tag - emit content
-                    let content = &self.input[content_start as usize..saved_index as usize];
-                    let normalized = normalize_line_endings(content);
-                    self.tokens.push(HtmlToken::with_part(
-                        token_type,
-                        &normalized,
-                        content_start,
-                        saved_index,
-                    ));
-
-                    // Emit the closing component tag
-                    self.advance(); // consume >
-                    self.tokens.push(HtmlToken::new(
-                        HtmlTokenType::ComponentClose,
-                        vec![component_name.to_string(), prefix.to_string(), tag_name.to_string()],
-                        saved_index,
-                        self.index,
-                    ));
-                    return;
-                }
-
-                // Not our closing tag - continue scanning
-            }
-
-            if self.peek() == chars::EOF {
-                // EOF reached - emit whatever content we have
-                let content = &self.input[content_start as usize..self.index as usize];
-                let normalized = normalize_line_endings(content);
-                self.tokens.push(HtmlToken::with_part(
-                    token_type,
-                    &normalized,
-                    content_start,
-                    self.index,
-                ));
-                return;
-            }
-
-            self.advance();
+        // Build the close-boundary NAME. Faithful to upstream v21.2.7 `_consumeTagOpen`
+        // (ml_parser/lexer.ts:821-827): for a selectorless COMPONENT,
+        // `[closingTagName, prefix, tagName] = openToken.parts` and the prefix/tagName are
+        // appended so `closingTagName` is the FULL prefixed component close name
+        // (e.g. `Comp:script` or `Comp:svg:script`). Lowercased here because the shared
+        // core matches the (also-lowercased) scanned close name case-insensitively,
+        // mirroring `_attemptStrCaseInsensitive(tagName)` (line 900). The emitted
+        // ComponentClose token still carries the ORIGINAL-case parts (see the descriptor
+        // below), matching `_endToken(openToken.parts)` (line 911).
+        let close_match_name = if prefix.is_empty() {
+            format!("{component_name}:{tag_name}")
+        } else {
+            format!("{component_name}:{prefix}:{tag_name}")
         }
+        .to_lowercase();
+
+        self.scan_raw_text_with_tag_close(
+            &close_match_name,
+            RawTextClose::Component { component_name, prefix, tag_name },
+            consume_entities,
+        );
     }
 
     /// Scans a component name with optional namespace and tag name.
@@ -3066,11 +3178,18 @@ impl<'a> HtmlLexer<'a> {
                 break;
             }
 
-            // Handle `<` - only stop if it's a valid tag start
+            // Handle `<` - end the TEXT run only at an upstream `_isTagStart`: `<` + (ASCII
+            // letter | `/` | `!`). NO `_`, NO selectorless gating, in BOTH modes (this is the
+            // text-END check, the twin of upstream `_isTagStart`, ml_parser/lexer.ts:1348).
+            // It must NOT use the token-dispatch predicate `is_tag_open_start` (which adds
+            // selectorless `_`): mid-text selectorless `x<_foo>` is absorbed into the text run
+            // (upstream's TEXT scanner doesn't stop at `<_`), only the TOP-LEVEL `<_foo>`
+            // dispatch in `scan_token` treats `_` as a component start. Using the dispatch
+            // predicate here broke mid-text `<_foo>` by turning it into a component (the I16
+            // regression this restores).
             if ch == '<' {
                 let next = self.peek_at(1);
-                // Valid tag start: `/` (close tag), `!` (comment/doctype/cdata), or letter/underscore
-                if next == '/' || next == '!' || next.is_ascii_alphabetic() || next == '_' {
+                if Self::is_text_tag_start(next) {
                     break;
                 }
                 // Otherwise, `<` is just text, continue
@@ -3364,4 +3483,145 @@ mod tests {
             tokens.iter().filter(|t| t.token_type == HtmlTokenType::AttrQuote).collect();
         assert_eq!(quotes.len(), 2);
     }
+
+    // ---- Finding 2: default-mode `<_foo>` is NOT a valid normal element ----
+    //
+    // Upstream v21.2.7 `ml_parser/lexer.ts` `_consumeTagOpen` (~829-835): when
+    // selectorless is OFF (or the char is not a selectorless name start), a regular tag
+    // MUST start with an ASCII letter; otherwise it throws `_unexpectedCharacterErrorMsg`.
+    // Since `openToken` is still undefined at that point, the catch block (~870-874)
+    // emits `<` as a TEXT token (the error is swallowed, not recorded). `_foo>` is then
+    // consumed as text. `<MyCmp>` starts with an ASCII letter, so it stays a normal
+    // element in default mode. With selectorless ON, `<_foo>` is a Component
+    // (`isSelectorlessNameStart` includes `_`).
+    //
+    // Oracle (`@angular/compiler@21.2.7`):
+    //   default `<_foo></_foo>`        -> Text "<_foo>" (open) + "Unexpected closing tag
+    //                                     \"_foo\"" error from the parser on `</_foo>`.
+    //   selectorless `<_foo></_foo>`   -> Component fullName "_foo".
+    //   default `<MyCmp></MyCmp>`      -> Element name "MyCmp" (control).
+
+    fn tokenize_selectorless(input: &str) -> Vec<HtmlToken> {
+        HtmlLexer::new(input).with_selectorless(true).tokenize().tokens
+    }
+
+    #[test]
+    fn test_default_mode_underscore_tag_is_text_not_element() {
+        // Default mode: `<_foo>` must NOT scan as a normal element. The `<` becomes text.
+        let tokens = tokenize("<_foo>");
+        assert!(
+            !tokens.iter().any(|t| t.token_type == HtmlTokenType::TagOpenStart),
+            "default-mode `<_foo>` must not produce a TagOpenStart, got: {:?}",
+            tokens.iter().map(|t| t.token_type).collect::<Vec<_>>()
+        );
+        assert!(
+            !tokens.iter().any(|t| t.token_type == HtmlTokenType::ComponentOpenStart),
+            "default-mode `<_foo>` must not produce a ComponentOpenStart"
+        );
+        // The whole `<_foo>` is emitted as text (OXC merges the leading `<` with the
+        // following `_foo>` text, matching upstream's final Text "<_foo>" result).
+        assert!(
+            tokens.iter().any(|t| t.token_type == HtmlTokenType::Text
+                && t.parts.first().map(String::as_str) == Some("<_foo>")),
+            "expected a Text token with `<_foo>`, got: {:?}",
+            tokens.iter().map(|t| (t.token_type, t.parts.clone())).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn test_selectorless_mode_underscore_tag_is_component() {
+        // Selectorless mode: `<_foo>` IS a component (isSelectorlessNameStart includes `_`).
+        let tokens = tokenize_selectorless("<_foo>");
+        let comp = tokens
+            .iter()
+            .find(|t| t.token_type == HtmlTokenType::ComponentOpenStart)
+            .expect("selectorless `<_foo>` must produce a ComponentOpenStart");
+        // parts[0] = component_name.
+        assert_eq!(comp.parts.first().map(String::as_str), Some("_foo"));
+    }
+
+    // ---- Finding 2: mid-text selectorless `<_foo>` must be absorbed into TEXT ----
+    //
+    // Upstream `_isTagStart` (ml_parser/lexer.ts:1348-1364), the TEXT-end check, returns
+    // true only for `<` + (ASCII letter | `/` | `!`) — NO `_`, NO selectorless gating, in
+    // both modes. The main `tokenize` loop dispatches a `<` to `_consumeTagOpen` (which
+    // handles selectorless `_`) only when the cursor is AT `<` at the start of a token
+    // scan; during text accumulation it stops at `_isTagStart`. So a selectorless `<_foo>`
+    // is a component only at top level; mid-text it is plain text up to the next real tag.
+    //
+    // Oracle (`@angular/compiler@21.2.7`, `{selectorlessEnabled:true}`):
+    //   `<_foo></_foo>`            -> Component "_foo" [0-13], 0 errors.
+    //   `x<_foo></_foo>`           -> Text "x<_foo>" [0-7] + ComponentClose [7-14].
+    //   `<div>x<_Foo></_Foo></div>`-> div > Text "x<_Foo>" [5-12] + ComponentClose [12-19].
+    //   `x<Foo></Foo>` (control)   -> Text "x" [0-1] + Component "Foo" [1-12].
+
+    #[test]
+    fn test_selectorless_midtext_underscore_is_text() {
+        // Mid-text `<_foo>` is absorbed into the text run; only the close is a token.
+        let tokens = tokenize_selectorless("x<_foo></_foo>");
+        // No ComponentOpenStart: `<_foo>` did NOT begin a component mid-text.
+        assert!(
+            !tokens.iter().any(|t| t.token_type == HtmlTokenType::ComponentOpenStart),
+            "mid-text `<_foo>` must not open a component, got: {:?}",
+            tokens.iter().map(|t| (t.token_type, t.parts.clone())).collect::<Vec<_>>()
+        );
+        // The text run is `x<_foo>` (offsets 0-7).
+        let text = tokens
+            .iter()
+            .find(|t| t.token_type == HtmlTokenType::Text)
+            .expect("expected a Text token");
+        assert_eq!(text.parts.first().map(String::as_str), Some("x<_foo>"));
+        assert_eq!((text.start, text.end), (0, 7));
+        // The dangling close `</_foo>` IS still a ComponentClose token at [7-14].
+        let close = tokens
+            .iter()
+            .find(|t| t.token_type == HtmlTokenType::ComponentClose)
+            .expect("expected a ComponentClose token");
+        assert_eq!((close.start, close.end), (7, 14));
+    }
+
+    #[test]
+    fn test_selectorless_toplevel_underscore_still_component() {
+        // Top-level `<_foo>` (cursor at `<` when a token scan begins) still dispatches to
+        // the component path — only the TEXT scanner ignores `<_`.
+        let tokens = tokenize_selectorless("<_foo></_foo>");
+        let comp = tokens
+            .iter()
+            .find(|t| t.token_type == HtmlTokenType::ComponentOpenStart)
+            .expect("top-level selectorless `<_foo>` must open a component");
+        assert_eq!(comp.parts.first().map(String::as_str), Some("_foo"));
+    }
+
+    #[test]
+    fn test_selectorless_midtext_uppercase_is_component() {
+        // Control: uppercase `<Foo>` mid-text IS a tag start (`<F` matches `_isTagStart`),
+        // so it opens a component and the preceding `x` is its own text run.
+        let tokens = tokenize_selectorless("x<Foo></Foo>");
+        let text = tokens
+            .iter()
+            .find(|t| t.token_type == HtmlTokenType::Text)
+            .expect("expected a Text token");
+        assert_eq!(text.parts.first().map(String::as_str), Some("x"));
+        assert_eq!((text.start, text.end), (0, 1));
+        assert!(
+            tokens.iter().any(|t| t.token_type == HtmlTokenType::ComponentOpenStart),
+            "mid-text `<Foo>` must open a component"
+        );
+    }
+
+    #[test]
+    fn test_default_mode_uppercase_tag_is_normal_element() {
+        // Control: `<MyCmp>` starts with an ASCII letter, so it is a normal element
+        // even in default mode.
+        let tokens = tokenize("<MyCmp>");
+        let tag = tokens
+            .iter()
+            .find(|t| t.token_type == HtmlTokenType::TagOpenStart)
+            .expect("default-mode `<MyCmp>` must be a normal TagOpenStart");
+        assert_eq!(tag.name(), "MyCmp");
+        assert!(
+            !tokens.iter().any(|t| t.token_type == HtmlTokenType::ComponentOpenStart),
+            "default-mode `<MyCmp>` must not be a component"
+        );
+    }
 }
diff --git a/crates/oxc_angular_compiler/src/parser/html/parser.rs b/crates/oxc_angular_compiler/src/parser/html/parser.rs
index 161c12742..b1a4b360e 100644
--- a/crates/oxc_angular_compiler/src/parser/html/parser.rs
+++ b/crates/oxc_angular_compiler/src/parser/html/parser.rs
@@ -21,7 +21,9 @@ use crate::util::{ParseError, ParseLocation, ParseSourceFile, ParseSourceSpan};
 
 use super::entities::decode_entities_in_string;
 use super::lexer::{HtmlLexer, HtmlToken, HtmlTokenType};
-use super::tags::{get_html_tag_definition, is_void_element};
+use super::tags::{
+    get_html_tag_definition, get_ns_prefix, is_void_element, merge_ns_and_name, split_ns_name,
+};
 
 /// Result of parsing an HTML template.
 pub struct HtmlParseResult<'a> {
@@ -178,6 +180,17 @@ impl<'a> HtmlParser<'a> {
         ParseError::new(span, msg)
     }
 
+    /// Build a parse error whose span covers `[start, end)`. Used for diagnostics that
+    /// upstream attaches to the full source span of a token (e.g. the unexpected
+    /// closing-tag errors, which use `endToken.sourceSpan`), rather than a zero-length
+    /// caret at the token start. Uses `from_offsets` so the start/end `ParseLocation`s
+    /// carry correct line/column (computed via `location_at`), matching Angular's
+    /// `endToken.sourceSpan` on multiline templates — not fabricated `(0, 0)` line/col.
+    fn make_error_span(&self, start: u32, end: u32, msg: impl Into<String>) -> ParseError {
+        let span = ParseSourceSpan::from_offsets(&self.source_file, start, end, None, None);
+        ParseError::new(span, msg)
+    }
+
     /// Parses the template.
     pub fn parse(mut self) -> HtmlParseResult<'a> {
         // Parse all nodes using container stack
@@ -235,6 +248,7 @@ impl<'a> HtmlParser<'a> {
                             end_span: None,
                             is_self_closing: false,
                             is_void: false,
+                            is_component: false,
                         },
                     );
                     let node = HtmlNode::Element(Box::new_in(element, &self.allocator));
@@ -288,6 +302,131 @@ impl<'a> HtmlParser<'a> {
         idx
     }
 
+    /// Returns the namespace-relevant *name* of the closest element-like parent on
+    /// the container stack, skipping non-element containers (e.g. blocks).
+    ///
+    /// Mirrors upstream `Parser._getClosestElementLikeParent` (ml_parser/parser.ts:903-912)
+    /// combined with the per-node-kind name selection in `_getPrefix`
+    /// (ml_parser/parser.ts:991):
+    ///   `const parentName = parent instanceof html.Element ? parent.name : parent.tagName;`
+    /// i.e. for an `html.Element` parent it is `parent.name`, but for an
+    /// `html.Component` parent it is the RESOLVED component `tagName` (e.g.
+    /// `:svg:button`), NOT the component class name (`MyComp`). `getNsPrefix` is then
+    /// applied to this string, so children of a namespaced selectorless component
+    /// inherit `:svg:`/`:math:` just like children of a real namespaced element.
+    /// Block containers do not affect namespace inheritance, so SVG children inside
+    /// `@if {...}` still inherit `:svg:`.
+    ///
+    /// In OXC a selectorless component is stored as an `HtmlElement` whose `name` is
+    /// the component class name (always starting uppercase or `_`, since only such
+    /// tags produce a `ComponentOpenStart` token) and whose `component_prefix` /
+    /// `component_tag_name` hold the resolved prefix and raw tag-name part. For those
+    /// we compose the resolved `tagName` exactly as `_getComponentTagName`
+    /// (ml_parser/parser.ts:946-961) / the R3 transform (`html_to_r3.rs`) do.
+    fn closest_element_like_parent_name(&self) -> Option<String> {
+        for &container in self.container_stack.iter().rev() {
+            if let ContainerIndex::Element(idx) = container {
+                let element = &self.elements[idx];
+                return Some(Self::namespace_parent_name(element));
+            }
+        }
+        None
+    }
+
+    /// Computes the namespace-inheritance parent name for an element-like parent,
+    /// mirroring upstream `_getPrefix`'s `parent instanceof html.Element ? parent.name
+    /// : parent.tagName` (ml_parser/parser.ts:991).
+    ///
+    /// For a normal element this is just `element.name`. For a selectorless component
+    /// (detected by an uppercase/`_` leading char, matching the lexer's
+    /// `ComponentOpenStart` rule and the R3 transform's component check) it is the
+    /// RESOLVED component tag name composed from `component_prefix` /
+    /// `component_tag_name`, exactly as `_getComponentTagName`
+    /// (ml_parser/parser.ts:946-961):
+    ///   - prefix=Some, tag=Some -> `:{prefix}:{tag}`
+    ///   - prefix=Some, tag=None -> `:{prefix}:ng-component`
+    ///   - prefix=None, tag=Some -> `{tag}`
+    ///   - prefix=None, tag=None -> the bare component name (upstream returns `null`,
+    ///     i.e. no namespace; `getNsPrefix` on a plain name yields `None`, so children
+    ///     stay HTML — the bare component name has the same effect).
+    fn namespace_parent_name(element: &HtmlElement<'a>) -> String {
+        let name = element.name.as_str();
+        let is_component = name.chars().next().is_some_and(|c| c.is_ascii_uppercase() || c == '_');
+        if !is_component {
+            return name.to_string();
+        }
+        match (element.component_prefix.as_ref(), element.component_tag_name.as_ref()) {
+            (Some(prefix), Some(tag)) => format!(":{prefix}:{tag}"),
+            (Some(prefix), None) => format!(":{prefix}:ng-component"),
+            (None, Some(tag)) => tag.to_string(),
+            (None, None) => name.to_string(),
+        }
+    }
+
+    /// Returns the name used to MATCH a close tag against this open element on the
+    /// container stack, mirroring upstream `_popContainer`'s
+    /// `node instanceof html.Component ? node.fullName : node.name`
+    /// (ml_parser/parser.ts:600).
+    ///
+    /// For a normal element this is `element.name`. For a selectorless component the
+    /// stored `name` is only the class name, so we compose the RESOLVED full name
+    /// exactly as `_getComponentFullName` (ml_parser/parser.ts:932-944) /
+    /// the R3 transform do, from `component_prefix` / `component_tag_name`:
+    ///   - tagName null (no prefix, no tag part) -> the bare component name
+    ///   - tagName `:prefix:tag` (a prefix is present) -> `componentName:prefix:tag`
+    ///   - tagName `tag` (no prefix) -> `componentName:tag`
+    fn element_match_name(element: &HtmlElement<'a>) -> String {
+        let name = element.name.as_str();
+        let is_component = name.chars().next().is_some_and(|c| c.is_ascii_uppercase() || c == '_');
+        if !is_component {
+            return name.to_string();
+        }
+        match (element.component_prefix.as_ref(), element.component_tag_name.as_ref()) {
+            // Prefix present -> tagName is `:prefix:tag` (or `:prefix:ng-component`);
+            // full name is `componentName` + `:prefix:tag` (tagName already starts ':').
+            (Some(prefix), Some(tag)) => format!("{name}:{prefix}:{tag}"),
+            (Some(prefix), None) => format!("{name}:{prefix}:ng-component"),
+            // No prefix, a tag part -> full name is `componentName:tag`.
+            (None, Some(tag)) => format!("{name}:{tag}"),
+            // No prefix, no tag part -> tagName null -> full name is the bare class name.
+            (None, None) => name.to_string(),
+        }
+    }
+
+    /// Resolves the namespace prefix for an element, mirroring upstream
+    /// `Parser._getPrefix` (ml_parser/parser.ts ~973-1001).
+    ///
+    /// Order of precedence:
+    ///   1. An explicit prefix from the source (`<svg:rect>`).
+    ///   2. The tag's own `implicit_namespace_prefix` (e.g. `<svg>` -> `svg`).
+    ///   3. The parent element's namespace prefix, inherited unless the parent's
+    ///      tag definition sets `prevent_namespace_inheritance` (e.g. `foreignObject`).
+    ///
+    /// `explicit_prefix` is the prefix lexed from the source (empty when absent).
+    /// `local_name` is the prefix-stripped tag name.
+    fn resolve_element_prefix(&self, explicit_prefix: &str, local_name: &str) -> Option<String> {
+        // 1 & 2: explicit prefix, falling back to the tag's implicit namespace prefix.
+        let mut prefix: Option<String> = if explicit_prefix.is_empty() {
+            get_html_tag_definition(local_name).implicit_namespace_prefix.map(str::to_string)
+        } else {
+            Some(explicit_prefix.to_string())
+        };
+
+        // 3: inherit the parent element's prefix when the child has none and the
+        // parent does not prevent namespace inheritance.
+        if prefix.is_none()
+            && let Some(parent_name) = self.closest_element_like_parent_name()
+        {
+            let (_, parent_local) = split_ns_name(&parent_name);
+            let parent_def = get_html_tag_definition(parent_local);
+            if !parent_def.prevent_namespace_inheritance {
+                prefix = get_ns_prefix(&parent_name).map(str::to_string);
+            }
+        }
+
+        prefix
+    }
+
     /// Pops a block from the container stack and returns it as an HtmlNode.
     fn pop_block_container(&mut self, end_span: Option<Span>) -> Option<HtmlNode<'a>> {
         // Find the topmost block in the stack
@@ -337,7 +476,10 @@ impl<'a> HtmlParser<'a> {
         let mut match_elem_idx = None;
         for i in (0..self.container_stack.len()).rev() {
             if let ContainerIndex::Element(idx) = self.container_stack[i] {
-                if self.elements[idx].name.as_str() == tag_name {
+                // Match by the element's full name. For a selectorless component this
+                // is the composed `componentName(:prefix):tag` (upstream `_popContainer`
+                // compares `node.fullName` for components), NOT the bare class name.
+                if Self::element_match_name(&self.elements[idx]) == tag_name {
                     match_stack_idx = Some(i);
                     match_elem_idx = Some(idx);
                     break;
@@ -384,6 +526,7 @@ impl<'a> HtmlParser<'a> {
                             end_span: None,
                             is_self_closing: false,
                             is_void: false,
+                            is_component: false,
                         },
                     );
                     // Add to the next parent on the stack (which is now the matching element)
@@ -429,6 +572,7 @@ impl<'a> HtmlParser<'a> {
                 end_span: None,
                 is_self_closing: false,
                 is_void: false,
+                is_component: false,
             },
         );
         if let Some(es) = end_span {
@@ -539,6 +683,12 @@ impl<'a> HtmlParser<'a> {
             HtmlTokenType::BlockClose => {
                 self.consume_block_close();
             }
+            HtmlTokenType::IncompleteBlockOpen => {
+                // Upstream v21.2.7 routes INCOMPLETE_BLOCK_OPEN to `_consumeIncompleteBlock`
+                // (ml_parser/parser.ts:132-134); without this arm the token would hit the
+                // default `_ => advance()` below and be silently dropped.
+                self.consume_incomplete_block();
+            }
             HtmlTokenType::LetStart => {
                 if let Some(node) = self.parse_let_declaration() {
                     self.add_to_parent(node);
@@ -568,31 +718,67 @@ impl<'a> HtmlParser<'a> {
             return; // No token to consume
         };
         let start = start_token.start;
+        // A `ComponentOpenStart` is only ever emitted by the lexer when
+        // selectorless mode is enabled (`lexer.rs` gates `scan_component_open` on
+        // `self.selectorless_enabled`). This is the AUTHORITATIVE marker that the
+        // element is a selectorless component, carried on the AST so the R3
+        // transform never has to fall back to a leading-character casing heuristic
+        // (which wrongly classified uppercase normal elements like `<IFRAME>`).
+        let is_component = start_token.token_type == HtmlTokenType::ComponentOpenStart;
         // TagOpenStart has parts [prefix, name]
         // ComponentOpenStart has parts [component_name, prefix, tag_name]
-        let (tag_name, local_name, has_ns_prefix, component_prefix, component_tag_name) =
+        let (tag_name, local_name, _has_ns_prefix, component_prefix, component_tag_name) =
             if start_token.token_type == HtmlTokenType::ComponentOpenStart {
                 // For components, extract all three parts:
                 // parts[0] = component_name, parts[1] = prefix, parts[2] = tag_name
                 let component_name = start_token.parts.first().cloned().unwrap_or_default();
-                let prefix = start_token.parts.get(1).cloned().unwrap_or_default();
+                let explicit_prefix = start_token.parts.get(1).cloned().unwrap_or_default();
                 let raw_tag_name = start_token.parts.get(2).cloned().unwrap_or_default();
 
-                // Store prefix and tag_name for HtmlElement
-                let prefix_opt = if prefix.is_empty() { None } else { Some(prefix.clone()) };
+                // Resolve the namespace prefix EXACTLY like upstream `_getPrefix`
+                // (ml_parser/parser.ts ~963-1002), which is shared between normal
+                // elements and components: an explicit prefix (`<MyComp:svg:title>`),
+                // else the tag's own `implicit_namespace_prefix`, else the closest
+                // element-like parent's prefix (so `<svg><MyComp:button>` resolves to
+                // prefix `svg`, yielding tagName `:svg:button` /
+                // fullName `MyComp:svg:button`), unless the parent prevents inheritance
+                // (e.g. `foreignObject`). This mirrors `_getComponentTagName` /
+                // `_getComponentFullName`, which route the component tag name through the
+                // same prefix/namespace logic as normal elements. We pass the component's
+                // *tag-name* part (`parts[2]`) as the local name so an empty tag name still
+                // inherits the parent namespace (upstream then falls back to `ng-component`,
+                // done in the R3 transform). Resolve BEFORE `auto_close_element_if_needed`
+                // pops the parent, matching upstream which computes the name from the
+                // closest element-like parent before `_pushContainer`. The local-name copy
+                // releases the `start_token` borrow (which aliases `&self`) before calling
+                // `resolve_element_prefix(&self, ..)`.
+                let resolved_prefix = self.resolve_element_prefix(&explicit_prefix, &raw_tag_name);
+
+                // Store the RESOLVED prefix and the raw tag_name for HtmlElement; the R3
+                // transform composes them into `:prefix:tag` and `ComponentName:prefix:tag`.
                 let tag_opt =
                     if raw_tag_name.is_empty() { None } else { Some(raw_tag_name.clone()) };
 
-                (component_name.clone(), component_name, false, prefix_opt, tag_opt)
+                (component_name.clone(), component_name, false, resolved_prefix, tag_opt)
             } else {
-                // For regular tags, include the namespace prefix if present
-                // Angular uses :prefix:name format for namespaced elements
-                let prefix = start_token.prefix();
-                let name = start_token.name();
-                let has_prefix = !prefix.is_empty();
-                let full_name =
-                    if has_prefix { format!(":{}:{}", prefix, name) } else { name.to_string() };
-                (full_name, name.to_string(), has_prefix, None, None)
+                // For regular tags, resolve the namespace prefix the way upstream
+                // `Parser._getElementFullName` / `_getPrefix` do: an explicit prefix
+                // (`<svg:rect>`), else the tag's own `implicit_namespace_prefix`
+                // (`<svg>` -> `svg`), else the closest element-like parent's prefix
+                // (so an implicit `<style>`/`<rect>` inside `<svg>` becomes
+                // `:svg:style` / `:svg:rect`), unless the parent prevents inheritance
+                // (e.g. `foreignObject`). This must run before `auto_close_element_if_needed`
+                // pops the parent, matching upstream which computes `fullName` from the
+                // closest element-like parent before `_pushContainer` performs auto-close.
+                // Copy the prefix/name to owned strings to release the borrow of
+                // `start_token` (which aliases `&self`) before calling
+                // `resolve_element_prefix(&self, ..)`.
+                let explicit_prefix = start_token.prefix().to_string();
+                let name = start_token.name().to_string();
+                let has_prefix = !explicit_prefix.is_empty();
+                let resolved_prefix = self.resolve_element_prefix(&explicit_prefix, &name);
+                let full_name = merge_ns_and_name(resolved_prefix.as_deref(), &name);
+                (full_name, name.clone(), has_prefix, None, None)
             };
 
         // Check if we need to auto-close the current element (HTML5 optional end tags)
@@ -610,11 +796,17 @@ impl<'a> HtmlParser<'a> {
                 let end_pos = token.end;
                 self.advance();
 
-                // Validate self-closing: only void, custom, and foreign elements can be self-closed
-                // Foreign elements include those with explicit namespace prefix (e.g., svg:rect)
-                // or those with implicit namespace prefix (e.g., <svg> has implicitNamespacePrefix='svg')
+                // Validate self-closing: only void, custom, and foreign elements can be self-closed.
+                // Upstream `Parser._consumeElementStartTag` (ml_parser/parser.ts:405) uses
+                //   `!(tagDef?.canSelfClose || getNsPrefix(fullName) !== null || tagDef?.isVoid)`
+                // — the "foreign" test is `getNsPrefix(fullName) !== null` on the *resolved* full
+                // name, NOT on whether the SOURCE tag had an explicit prefix. This matters for
+                // namespace inheritance (F5): `<svg><p/></svg>` resolves the implicit child to
+                // `:svg:p`, whose `getNsPrefix` is `svg` (non-null), so it is foreign and may
+                // self-close even though `<p>` carried no explicit prefix (`_has_ns_prefix == false`).
+                // We therefore key the foreign decision off the resolved `tag_name`'s namespace.
                 let tag_def = get_html_tag_definition(&local_name);
-                let is_foreign = has_ns_prefix || tag_def.implicit_namespace_prefix.is_some();
+                let is_foreign = get_ns_prefix(&tag_name).is_some();
                 if !(tag_def.can_self_close || is_foreign || tag_def.is_void) {
                     let err = self.make_error(
                         start,
@@ -664,6 +856,7 @@ impl<'a> HtmlParser<'a> {
             end_span,
             is_self_closing,
             is_void,
+            is_component,
         };
 
         if is_self_closing || is_void {
@@ -684,53 +877,157 @@ impl<'a> HtmlParser<'a> {
         let end = token.end;
         // TagClose has parts [prefix, name]
         // ComponentClose has parts [component_name, prefix, tag_name]
-        let (tag_name, local_name) = if token.token_type == HtmlTokenType::ComponentClose {
-            let name = token.value().to_string();
-            (name.clone(), name)
+        let is_component_close = token.token_type == HtmlTokenType::ComponentClose;
+        // For a component close, the bare class name (parts[0]); used to decide the
+        // "did you mean" vs generic suffix, matching upstream
+        // `container.componentName === endToken.parts[0]` (ml_parser/parser.ts:537).
+        let close_component_name: String = if is_component_close {
+            token.parts.first().cloned().unwrap_or_default()
+        } else {
+            String::new()
+        };
+        let (tag_name, local_name) = if is_component_close {
+            // Resolve the close's FULL name with the SAME logic as the open
+            // (`_getComponentFullName` -> `_getComponentTagName` -> `_getPrefix`):
+            // an explicit prefix (parts[1]), else the tag's implicit namespace, else
+            // inherited from the closest element-like parent — which at close time is
+            // the still-open component itself (carrying its resolved tagName, e.g.
+            // `:svg:button`), so `</MyComp:button>` under `<svg>` inherits `:svg:` and
+            // matches the open `MyComp:svg:button`. Copy parts to owned strings to
+            // release the `token` borrow (which aliases `&self`) before calling
+            // `resolve_element_prefix(&self, ..)`.
+            let component_name = close_component_name.clone();
+            let explicit_prefix = token.parts.get(1).cloned().unwrap_or_default();
+            let raw_tag_name = token.parts.get(2).cloned().unwrap_or_default();
+            let resolved_prefix = self.resolve_element_prefix(&explicit_prefix, &raw_tag_name);
+            // Compose tagName (None when no prefix and no tag part) then full name,
+            // mirroring `_getComponentTagName` / `_getComponentFullName`.
+            let tag_name_opt: Option<String> = match (&resolved_prefix, raw_tag_name.is_empty()) {
+                (Some(prefix), false) => Some(format!(":{prefix}:{raw_tag_name}")),
+                (Some(prefix), true) => Some(format!(":{prefix}:ng-component")),
+                (None, false) => Some(raw_tag_name.clone()),
+                (None, true) => None,
+            };
+            let full_name = match &tag_name_opt {
+                Some(tag) if tag.starts_with(':') => format!("{component_name}{tag}"),
+                Some(tag) => format!("{component_name}:{tag}"),
+                None => component_name.clone(),
+            };
+            // `local_name` (void-element/tag-definition lookups) uses the local tag
+            // part; for a bare component close there is none, so fall back to the
+            // component name (never a void element).
+            let local = if raw_tag_name.is_empty() { component_name } else { raw_tag_name };
+            (full_name, local)
         } else {
-            // For regular tags, include the namespace prefix if present
-            // Angular uses :prefix:name format for namespaced elements
-            let prefix = token.prefix();
-            let name = token.name();
-            let full_name =
-                if prefix.is_empty() { name.to_string() } else { format!(":{}:{}", prefix, name) };
-            (full_name, name.to_string())
+            // For regular tags, resolve the namespace prefix exactly like the start
+            // tag (upstream `_consumeEndTag` -> `_getElementFullName`). When closing a
+            // tag, the closest element-like parent is the matching open element itself
+            // (still on the container stack), so an implicit `</style>` inside `<svg>`
+            // inherits `:svg:` from its own `:svg:style` open tag and matches it.
+            // Copy the prefix/name to owned strings to release the borrow of `token`
+            // (which aliases `&self`) before calling `resolve_element_prefix(&self, ..)`.
+            let explicit_prefix = token.prefix().to_string();
+            let name = token.name().to_string();
+            let resolved_prefix = self.resolve_element_prefix(&explicit_prefix, &name);
+            let full_name = merge_ns_and_name(resolved_prefix.as_deref(), &name);
+            (full_name, name)
         };
         let end_span = self.make_span(start, end);
 
-        // Check if this is a void element - void elements don't have end tags
-        let tag_def = get_html_tag_definition(&local_name);
-        if tag_def.is_void {
-            let err = self.make_error(
-                start,
-                format!("Void elements do not have end tags \"{}\"", local_name),
-            );
-            self.errors.push(err);
-            return;
+        // Void-element end tags are only diagnosed for NORMAL elements (upstream's
+        // void check lives in `_consumeElementEndTag`, ml_parser/parser.ts:572-579,
+        // NOT in `_consumeComponentEndTag`). A component close whose tag part happens
+        // to be a void HTML name (e.g. `</MyComp:input>`) must NOT trigger it.
+        if !is_component_close {
+            // Voidness is checked on the RESOLVED FULL name (`fullName`), exactly
+            // like upstream `_consumeElementEndTag` -> `_getTagDefinition(fullName)`
+            // (ml_parser/parser.ts:572). A namespaced close such as `</svg:input>`
+            // or an implicit-namespace `<svg><input></input></svg>` resolves to
+            // `:svg:input`, and `getHtmlTagDefinition(':svg:input')` falls back to
+            // the DEFAULT (non-void) definition (html_tags.ts:192 -> no lowercase
+            // match -> DEFAULT_TAG_DEFINITION), so upstream ACCEPTS the close and
+            // pops the element with NO error. Using the NS-stripped `local_name`
+            // here ("input") would wrongly diagnose the void error and bail before
+            // popping. Plain `<input></input>` (no namespace) has `tag_name ==
+            // local_name == "input"` -> void -> error retained, matching upstream.
+            let tag_def = get_html_tag_definition(&tag_name);
+            if tag_def.is_void {
+                // Span is the FULL close-token source span (`endTagToken.sourceSpan`,
+                // ml_parser/parser.ts:573-579), not a zero-length caret at the start.
+                // Matches the I17 unexpected-close path below. The error message
+                // quotes the LOCAL name (`endTagToken.parts[1]`, ml_parser/parser.ts:
+                // 577), not the full name — for void elements `tag_name` is never
+                // namespaced anyway, so `local_name == tag_name` in this branch.
+                let err = self.make_error_span(
+                    start,
+                    end,
+                    format!("Void elements do not have end tags \"{}\"", local_name),
+                );
+                self.errors.push(err);
+                return;
+            }
         }
 
         // Pop the matching element from the stack
         let (node, unexpected_close) = self.pop_element_container(&tag_name, Some(end_span));
-        if let Some(node) = node {
-            if unexpected_close {
-                // Matching open tag exists, but at least one still-open container above it
-                // had to be implicitly closed. Mirrors Angular's reference parser, which
-                // attaches the diagnostic to the closing tag itself.
-                let err = self.make_error(
+
+        if is_component_close {
+            // Component close: upstream `_consumeComponentEndTag` (ml_parser/parser.ts:
+            // 530-545) reports an error whenever `_popContainer` returns false, i.e. on
+            // NO match OR a match that required implicitly closing a still-open container
+            // above it. The suffix is `, did you mean "<fullName>"?` when the CURRENT
+            // topmost container is a component with the same `componentName` as the close
+            // (parts[0]), else the generic ". It may happen ..." (NO trailing URL).
+            if node.is_none() || unexpected_close {
+                let suffix = match self.container_stack.last() {
+                    Some(&ContainerIndex::Element(idx))
+                        if self.elements[idx].name.as_str() == close_component_name
+                            && self.elements[idx]
+                                .name
+                                .as_str()
+                                .chars()
+                                .next()
+                                .is_some_and(|c| c.is_ascii_uppercase() || c == '_') =>
+                    {
+                        let open_full = Self::element_match_name(&self.elements[idx]);
+                        format!(", did you mean \"{open_full}\"?")
+                    }
+                    _ => ". It may happen when the tag has already been closed by another tag."
+                        .to_string(),
+                };
+                // Span is the FULL close-token source span (`endToken.sourceSpan`,
+                // ml_parser/parser.ts:544), not a zero-length caret at the start.
+                let err = self.make_error_span(
                     start,
-                    format!("Unexpected closing tag \"{}\". It may happen when the tag has already been closed by another tag. For more info see https://www.w3.org/TR/html5/syntax.html#closing-elements-that-have-implied-end-tags", tag_name),
+                    end,
+                    format!("Unexpected closing tag \"{tag_name}\"{suffix}"),
                 );
                 self.errors.push(err);
             }
-            self.add_to_parent(node);
-        } else {
-            // No matching element - report error for stray closing tag
-            let err = self.make_error(
+            if let Some(node) = node {
+                self.add_to_parent(node);
+            }
+            return;
+        }
+
+        // Element close: upstream `_consumeElementEndTag` (ml_parser/parser.ts:580-583)
+        // reports a SINGLE error message whenever `_popContainer` returns false — i.e. on
+        // NO match (stray close) OR a match that required implicitly closing a still-open
+        // container above it (`unexpected_close`). Both use the IDENTICAL message INCLUDING
+        // the trailing W3C help URL, and the span is the FULL close-token source span
+        // (`endTagToken.sourceSpan`), not a zero-length caret at the start. (The component
+        // close path above intentionally omits the URL, mirroring `_consumeComponentEndTag`.)
+        if node.is_none() || unexpected_close {
+            let err = self.make_error_span(
                 start,
-                format!("Unexpected closing tag \"{}\". It may happen when the tag has already been closed by another tag.", tag_name),
+                end,
+                format!("Unexpected closing tag \"{}\". It may happen when the tag has already been closed by another tag. For more info see https://www.w3.org/TR/html5/syntax.html#closing-elements-that-have-implied-end-tags", tag_name),
             );
             self.errors.push(err);
         }
+        if let Some(node) = node {
+            self.add_to_parent(node);
+        }
     }
 
     /// Parses attributes and directives.
@@ -1156,6 +1453,9 @@ impl<'a> HtmlParser<'a> {
             end_span: None,
             is_self_closing: false,
             is_void: is_void_element(&tag_name),
+            // An incomplete tag (`IncompleteTagOpen`) is never a selectorless
+            // component: the lexer only emits `ComponentOpenStart` for components.
+            is_component: false,
         };
         Some(HtmlNode::Element(Box::new_in(element, &self.allocator)))
     }
@@ -1469,6 +1769,7 @@ impl<'a> HtmlParser<'a> {
                             end_span: None,
                             is_self_closing: false,
                             is_void: false,
+                            is_component: false,
                         },
                     );
                     self.add_to_parent(HtmlNode::Element(Box::new_in(element, &self.allocator)));
@@ -1538,25 +1839,7 @@ impl<'a> HtmlParser<'a> {
         let start = token.start;
         let name_end = token.end;
 
-        let block_type = match name.as_str() {
-            "if" => BlockType::If,
-            "else" => BlockType::Else,
-            // Match Angular's ELSE_IF_PATTERN: /^else[^\S\r\n]+if/
-            // Any block name starting with "else " followed by "if" (e.g. "else if",
-            // "else ifx") is classified as ElseIf, matching Angular's regex-based
-            // connected-block detection.
-            _ if is_else_if_pattern(&name) => BlockType::ElseIf,
-            "for" => BlockType::For,
-            "empty" => BlockType::Empty,
-            "switch" => BlockType::Switch,
-            "case" => BlockType::Case,
-            "default" => BlockType::Default,
-            "defer" => BlockType::Defer,
-            "placeholder" => BlockType::Placeholder,
-            "loading" => BlockType::Loading,
-            "error" => BlockType::Error,
-            _ => BlockType::If, // Default
-        };
+        let block_type = classify_block_type(&name);
 
         // Collect block parameters
         let mut parameters = Vec::new_in(&self.allocator);
@@ -1606,6 +1889,78 @@ impl<'a> HtmlParser<'a> {
         self.push_block_container(block);
     }
 
+    /// Consumes an `IncompleteBlockOpen` token (e.g. `@default never` WITHOUT a trailing
+    /// `;`, or any `@name` that never opened a `{ }` body). Mirrors upstream v21.2.7
+    /// `Parser._consumeIncompleteBlock` (ml_parser/parser.ts:786-812): it collects any
+    /// trailing `BlockParameter` tokens, builds the Block node (using the token's part as
+    /// the name, so the block is NOT silently dropped), pushes it and immediately closes it
+    /// (incomplete blocks have no children), then reports the exact "Incomplete block ..."
+    /// diagnostic. Without this, `parse_and_add_node`'s default arm would just `advance()`
+    /// past the token and the `@default never` would vanish with zero errors.
+    fn consume_incomplete_block(&mut self) {
+        let Some(token) = self.advance() else {
+            return; // No token to consume
+        };
+        // `token.parts[0]` is the block name, e.g. `default never` (upstream `token.parts[0]`).
+        let name = token.value().to_string();
+        let start = token.start;
+        let name_end = token.end;
+        let block_type = classify_block_type(&name);
+
+        // Collect any trailing block parameters (matches upstream's `while BLOCK_PARAMETER`).
+        let mut parameters = Vec::new_in(&self.allocator);
+        while let Some(tok) = self.peek() {
+            if tok.token_type == HtmlTokenType::BlockParameter {
+                let Some(param_token) = self.advance() else {
+                    break; // Should not happen after peek, but handle gracefully
+                };
+                let param_text = param_token.value().to_string();
+                let param_start = param_token.start;
+                let param_end = param_token.end;
+                let param_span = self.make_span(param_start, param_end);
+                parameters.push(HtmlBlockParameter {
+                    expression: Ident::from_in(&param_text, &self.allocator),
+                    span: param_span,
+                });
+            } else {
+                break;
+            }
+        }
+
+        let end = self.peek().map(|t| t.start).unwrap_or(start);
+        let span = self.make_span(start, end);
+        let name_span = self.make_span(start, name_end);
+        let start_span = self.make_span(start, end);
+
+        let block = HtmlBlock {
+            block_type,
+            name: Ident::from_in(name.clone(), &self.allocator),
+            parameters,
+            children: Vec::new_in(&self.allocator),
+            span,
+            name_span,
+            start_span,
+            end_span: None,
+        };
+
+        // Incomplete blocks have no children: push then immediately close (pop) so the node
+        // is preserved in the tree, mirroring upstream `_pushContainer` + `_popContainer`.
+        self.push_block_container(block);
+        if let Some(node) = self.pop_block_container(None) {
+            self.add_to_parent(node);
+        }
+
+        // Report the upstream-exact diagnostic (ml_parser/parser.ts:804-811).
+        let err = self.make_error(
+            start,
+            format!(
+                "Incomplete block \"{name}\". If you meant to write the @ character, \
+                 you should use the \"&#64;\" HTML entity instead."
+            ),
+        );
+        self.errors.push(err);
+    }
+
     /// Parses a directive token sequence: DirectiveName → DirectiveOpen? → attrs → DirectiveClose?
     /// Returns an HtmlDirective node representing the selectorless directive.
     fn parse_directive(&mut self) -> Option<HtmlDirective<'a>> {
@@ -1760,6 +2115,33 @@ impl<'a> HtmlParser<'a> {
     }
 }
 
+/// Classifies a block name (the lexer's `BlockOpenStart`/`IncompleteBlockOpen` part) into
+/// a `BlockType`. Used by both `consume_block_open` and `consume_incomplete_block` so an
+/// incomplete `@default never` carries the same `BlockType::DefaultNever` it would when valid.
+fn classify_block_type(name: &str) -> BlockType {
+    match name {
+        "if" => BlockType::If,
+        "else" => BlockType::Else,
+        // Match Angular's ELSE_IF_PATTERN: /^else[^\S\r\n]+if/
+        // Any block name starting with "else " followed by "if" (e.g. "else if",
+        // "else ifx") is classified as ElseIf, matching Angular's regex-based
+        // connected-block detection.
+        _ if is_else_if_pattern(name) => BlockType::ElseIf,
+        "for" => BlockType::For,
+        "empty" => BlockType::Empty,
+        "switch" => BlockType::Switch,
+        "case" => BlockType::Case,
+        "default" => BlockType::Default,
+        // Angular v21.2.7 exhaustive-switch feature: `@default never;`.
+        "default never" => BlockType::DefaultNever,
+        "defer" => BlockType::Defer,
+        "placeholder" => BlockType::Placeholder,
+        "loading" => BlockType::Loading,
+        "error" => BlockType::Error,
+        _ => BlockType::If, // Default
+    }
+}
+
 /// Checks if the current element should be auto-closed when a new element is opened.
 /// Uses the tag definitions from tags.rs to match Angular's behavior exactly.
 fn should_auto_close(current_tag: &str, new_tag: &str) -> bool {
@@ -1797,6 +2179,169 @@ mod tests {
         assert!(matches!(&result.nodes[0], HtmlNode::Text(_)));
     }
 
+    // ---- Finding 2: default-mode `<_foo>` is text, not an element ----
+    //
+    // Oracle (`@angular/compiler@21.2.7` `HtmlParser.parse(..)`):
+    //   default `<_foo></_foo>`      -> ONE root Text node "<_foo>" + a single
+    //                                   "Unexpected closing tag \"_foo\"" parse error.
+    //   selectorless `<_foo></_foo>` -> a Component node (`is_component == true`).
+    //   default `<MyCmp></MyCmp>`    -> a normal Element named "MyCmp" (control).
+    #[test]
+    fn test_unexpected_close_error_span_has_correct_line_col_multiline() {
+        // FINDING 3 (span fidelity): the unexpected-closing-tag error span must carry the
+        // correct LINE/COLUMN (not fabricated 0/0) on multiline templates, matching
+        // Angular's `endToken.sourceSpan`. For "<div>\n  text\n</span>" the stray
+        // `</span>` close spans offset 13..20, line 2 col 0..7 (0-based line/col).
+        // Verified vs @angular/compiler@21.2.7.
+        let allocator = Allocator::default();
+        let result = HtmlParser::new(&allocator, "<div>\n  text\n</span>", "test.html").parse();
+        assert_eq!(result.errors.len(), 1, "errors: {:?}", result.errors);
+        let span = &result.errors[0].span;
+        assert_eq!((span.start.offset, span.start.line, span.start.col), (13, 2, 0), "start loc");
+        assert_eq!((span.end.offset, span.end.line, span.end.col), (20, 2, 7), "end loc");
+        assert!(
+            result.errors[0].msg.ends_with("implied-end-tags"),
+            "msg: {:?}",
+            result.errors[0].msg
+        );
+    }
+
+    #[test]
+    fn test_parse_default_mode_underscore_tag_is_text() {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::new(&allocator, "<_foo></_foo>", "test.html");
+        let result = parser.parse();
+        // Open tag becomes a Text node "<_foo>".
+        assert_eq!(result.nodes.len(), 1, "expected a single Text node, got {:?}", result.nodes);
+        match &result.nodes[0] {
+            HtmlNode::Text(t) => assert_eq!(t.value.as_str(), "<_foo>"),
+            other => panic!("expected Text node, got {other:?}"),
+        }
+        // The only error is the unexpected-closing-tag error for `</_foo>`; the lexer's
+        // unexpected-character error for the open tag is swallowed (upstream parity).
+        assert_eq!(result.errors.len(), 1, "errors: {:?}", result.errors);
+        // FINDING 3: in DEFAULT mode `</_foo>` is an ELEMENT close, so the message
+        // includes the W3C help URL and the span is the FULL close-token span [6-13].
+        // Verified vs @angular/compiler@21.2.7 (`_consumeElementEndTag`, parser.ts:581).
+        assert_eq!(
+            result.errors[0].msg,
+            "Unexpected closing tag \"_foo\". It may happen when the tag has already been closed by another tag. For more info see https://www.w3.org/TR/html5/syntax.html#closing-elements-that-have-implied-end-tags",
+            "unexpected error message: {:?}",
+            result.errors[0].msg
+        );
+        assert_eq!(
+            (result.errors[0].span.start.offset, result.errors[0].span.end.offset),
+            (6, 13),
+            "error span must be the full close-token span"
+        );
+    }
+
+    // ---- Finding 2 (parser): mid-text selectorless `<_foo>` is TEXT + dangling close ----
+    //
+    // Oracle (`@angular/compiler@21.2.7`, `{selectorlessEnabled:true}`):
+    //   `x<_foo></_foo>`            -> Text "x<_foo>" [0-7] + a COMPONENT-close error
+    //                                  (NO URL) at span [7-14].
+    //   `<div>x<_Foo></_Foo></div>`-> div with child Text "x<_Foo>" [5-12] + a
+    //                                  component-close error at [12-19].
+    #[test]
+    fn test_parse_selectorless_midtext_underscore_is_text() {
+        let allocator = Allocator::default();
+        let result =
+            HtmlParser::with_selectorless(&allocator, "x<_foo></_foo>", "test.html").parse();
+        // Single root Text node "x<_foo>" — the `<_foo>` open is NOT a component mid-text.
+        assert_eq!(result.nodes.len(), 1, "nodes: {:?}", result.nodes);
+        match &result.nodes[0] {
+            HtmlNode::Text(t) => assert_eq!(t.value.as_str(), "x<_foo>"),
+            other => panic!("expected Text node, got {other:?}"),
+        }
+        // The dangling `</_foo>` is a COMPONENT close: error has NO W3C URL, span [7-14].
+        assert_eq!(result.errors.len(), 1, "errors: {:?}", result.errors);
+        assert_eq!(
+            result.errors[0].msg,
+            "Unexpected closing tag \"_foo\". It may happen when the tag has already been closed by another tag.",
+            "msg: {:?}",
+            result.errors[0].msg
+        );
+        assert_eq!((result.errors[0].span.start.offset, result.errors[0].span.end.offset), (7, 14));
+    }
+
+    #[test]
+    fn test_parse_selectorless_midtext_underscore_inside_element() {
+        let allocator = Allocator::default();
+        let result =
+            HtmlParser::with_selectorless(&allocator, "<div>x<_Foo></_Foo></div>", "test.html")
+                .parse();
+        // One root `div` containing a single Text child "x<_Foo>".
+        assert_eq!(result.nodes.len(), 1, "nodes: {:?}", result.nodes);
+        match &result.nodes[0] {
+            HtmlNode::Element(el) => {
+                assert_eq!(el.name.as_str(), "div");
+                assert_eq!(el.children.len(), 1, "children: {:?}", el.children);
+                match &el.children[0] {
+                    HtmlNode::Text(t) => assert_eq!(t.value.as_str(), "x<_Foo>"),
+                    other => panic!("expected Text child, got {other:?}"),
+                }
+            }
+            other => panic!("expected div Element, got {other:?}"),
+        }
+        // The dangling `</_Foo>` component close error at [12-19].
+        assert_eq!(result.errors.len(), 1, "errors: {:?}", result.errors);
+        assert_eq!(
+            (result.errors[0].span.start.offset, result.errors[0].span.end.offset),
+            (12, 19)
+        );
+    }
+
+    #[test]
+    fn test_parse_selectorless_midtext_uppercase_is_component() {
+        // Control: mid-text uppercase `<Foo>` IS a tag start and opens a component.
+        let allocator = Allocator::default();
+        let result = HtmlParser::with_selectorless(&allocator, "x<Foo></Foo>", "test.html").parse();
+        assert_eq!(result.errors.len(), 0, "errors: {:?}", result.errors);
+        assert_eq!(result.nodes.len(), 2, "nodes: {:?}", result.nodes);
+        match &result.nodes[0] {
+            HtmlNode::Text(t) => assert_eq!(t.value.as_str(), "x"),
+            other => panic!("expected Text node, got {other:?}"),
+        }
+        match &result.nodes[1] {
+            HtmlNode::Element(el) => {
+                assert!(el.is_component, "mid-text `<Foo>` must be a component");
+                assert_eq!(el.name.as_str(), "Foo");
+            }
+            other => panic!("expected component Element, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn test_parse_selectorless_mode_underscore_tag_is_component() {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::with_selectorless(&allocator, "<_foo></_foo>", "test.html");
+        let result = parser.parse();
+        assert_eq!(result.nodes.len(), 1, "nodes: {:?}", result.nodes);
+        match &result.nodes[0] {
+            HtmlNode::Element(el) => {
+                assert!(el.is_component, "selectorless `<_foo>` must be a component");
+                assert_eq!(el.name.as_str(), "_foo");
+            }
+            other => panic!("expected component Element, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn test_parse_default_mode_uppercase_tag_is_normal_element() {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::new(&allocator, "<MyCmp></MyCmp>", "test.html");
+        let result = parser.parse();
+        assert_eq!(result.nodes.len(), 1);
+        match &result.nodes[0] {
+            HtmlNode::Element(el) => {
+                assert!(!el.is_component, "default-mode `<MyCmp>` must be a normal element");
+                assert_eq!(el.name.as_str(), "MyCmp");
+            }
+            other => panic!("expected Element, got {other:?}"),
+        }
+    }
+
     #[test]
     fn test_parse_nested() {
         let allocator = Allocator::default();
diff --git a/crates/oxc_angular_compiler/src/parser/html/whitespace.rs b/crates/oxc_angular_compiler/src/parser/html/whitespace.rs
index bcb4025d7..644616dc6 100644
--- a/crates/oxc_angular_compiler/src/parser/html/whitespace.rs
+++ b/crates/oxc_angular_compiler/src/parser/html/whitespace.rs
@@ -378,6 +378,7 @@ impl<'a> WhitespaceVisitor<'a> {
             end_span: el.end_span,
             is_self_closing: el.is_self_closing,
             is_void: el.is_void,
+            is_component: el.is_component,
         }
     }
 
@@ -571,6 +572,7 @@ impl<'a> WhitespaceVisitor<'a> {
                     end_span: element.end_span,
                     is_self_closing: element.is_self_closing,
                     is_void: element.is_void,
+                    is_component: element.is_component,
                 },
                 &self.allocator,
             )));
@@ -592,6 +594,7 @@ impl<'a> WhitespaceVisitor<'a> {
                 end_span: element.end_span,
                 is_self_closing: element.is_self_closing,
                 is_void: element.is_void,
+                is_component: element.is_component,
             },
             &self.allocator,
         )))
diff --git a/crates/oxc_angular_compiler/src/partial/factory.rs b/crates/oxc_angular_compiler/src/partial/factory.rs
index c7a54db39..71c20cc06 100644
--- a/crates/oxc_angular_compiler/src/partial/factory.rs
+++ b/crates/oxc_angular_compiler/src/partial/factory.rs
@@ -175,7 +175,10 @@ fn factory_target_expr<'a>(
         FactoryTarget::Directive => "Directive",
         FactoryTarget::Pipe => "Pipe",
         FactoryTarget::NgModule => "NgModule",
-        FactoryTarget::Injectable | FactoryTarget::Service => "Injectable",
+        FactoryTarget::Injectable => "Injectable",
+        // `@Service` (Angular v22+) uses the same `ɵɵinject` token resolution as
+        // `Injectable`, so its partial-declaration factory target is `Injectable`.
+        FactoryTarget::Service => "Injectable",
     };
 
     let factory_target_ref = OutputExpression::ReadProp(Box::new_in(
diff --git a/crates/oxc_angular_compiler/src/pipeline/ingest.rs b/crates/oxc_angular_compiler/src/pipeline/ingest.rs
index 22c9955af..e3d98acab 100644
--- a/crates/oxc_angular_compiler/src/pipeline/ingest.rs
+++ b/crates/oxc_angular_compiler/src/pipeline/ingest.rs
@@ -4130,60 +4130,6 @@ fn ingest_host_dom_property<'a>(
     job.root.update.push(op);
 }
 
-/// Computes the security context for an attribute binding.
-///
-/// This is a simplified implementation of Angular's `calcPossibleSecurityContexts`
-/// that handles the most common cases based on element and property names.
-///
-/// Ported from Angular's `binding_parser.ts` and `dom_security_schema.ts`.
-fn compute_security_context(selector: &str, attr_name: &str) -> SecurityContext {
-    use crate::schema::{calc_security_context_for_unknown_element, get_security_context};
-
-    // Extract element name from selector if present (e.g., "a[myDirective]" → "a")
-    let element = extract_element_from_selector(selector);
-
-    match element {
-        Some(element_name) => {
-            // Element is known - use the specific lookup
-            get_security_context(&element_name, attr_name)
-        }
-        None => {
-            // Element is unknown (e.g., attribute-only directive like [myDirective])
-            // Use the ambiguous lookup that checks all possible elements
-            calc_security_context_for_unknown_element(attr_name)
-        }
-    }
-}
-
-/// Extracts the element name from a CSS selector.
-///
-/// Examples:
-/// - "a[myDirective]" → Some("a")
-/// - "div.my-class" → Some("div")
-/// - "[myDirective]" → None
-/// - ".my-class" → None
-fn extract_element_from_selector(selector: &str) -> Option<String> {
-    // Skip leading whitespace
-    let s = selector.trim();
-
-    // If starts with [, ., or :, there's no element
-    if s.starts_with('[') || s.starts_with('.') || s.starts_with(':') || s.starts_with('#') {
-        return None;
-    }
-
-    // Find the element name (alphanumeric and hyphens until a special char)
-    let mut element_end = 0;
-    for (i, c) in s.char_indices() {
-        if c.is_alphanumeric() || c == '-' || c == '_' {
-            element_end = i + c.len_utf8();
-        } else {
-            break;
-        }
-    }
-
-    if element_end > 0 { Some(s[..element_end].to_lowercase()) } else { None }
-}
-
 /// Ingests a static host attribute.
 ///
 /// Host attributes are static attributes that should be extracted to `hostAttrs`
@@ -4198,6 +4144,7 @@ fn ingest_host_attribute<'a>(
 ) {
     use crate::ir::expression::IrExpression;
     use crate::ir::ops::{BindingOp, UpdateOp, UpdateOpBase};
+    use crate::schema::compute_security_context;
 
     let allocator = job.allocator;
 
diff --git a/crates/oxc_angular_compiler/src/pipeline/phases/binding_specialization.rs b/crates/oxc_angular_compiler/src/pipeline/phases/binding_specialization.rs
index d2dbad0b4..e309e9e32 100644
--- a/crates/oxc_angular_compiler/src/pipeline/phases/binding_specialization.rs
+++ b/crates/oxc_angular_compiler/src/pipeline/phases/binding_specialization.rs
@@ -31,6 +31,7 @@ use crate::ir::ops::{
     AnimationBindingOp, AttributeOp, ControlOp, CreateOp, DomPropertyOp, PropertyOp,
     TwoWayPropertyOp, UpdateOp, UpdateOpBase, XrefId,
 };
+use crate::parser::html::split_ns_name;
 use crate::pipeline::compilation::{
     ComponentCompilationJob, HostBindingCompilationJob, TemplateCompilationMode,
 };
@@ -46,39 +47,21 @@ fn is_aria_attribute(name: &str) -> bool {
     name.starts_with(ARIA_PREFIX) && name.len() > ARIA_PREFIX.len()
 }
 
-/// Known XML/SVG namespace prefixes.
-/// These are standard namespace prefixes that should be separated from the local name.
-const KNOWN_NS_PREFIXES: &[&str] = &["xlink", "xml", "xmlns"];
-
-/// Splits a namespaced name into (namespace, local_name).
+/// Splits a namespaced attribute name into (namespace, local_name), faithfully
+/// matching upstream `splitNsName` (`ml_parser/tags.ts:27-43`): ONLY the
+/// internal `:namespace:name` form is split; a plain `prefix:name` (e.g. the
+/// host-binding `xlink:href`) is returned as `(None, "prefix:name")` — exactly
+/// what the binding-specialization phase's `splitNsName(op.name)` does upstream.
 ///
-/// Handles two formats:
-/// - `:namespace:name` → (Some("namespace"), "name") - Angular's internal format
-/// - `namespace:name` → (Some("namespace"), "name") - for known namespaces like xlink, xml, xmlns
-/// - `name` → (None, "name") - no namespace
-fn split_ns_name(name: &str) -> (Option<&str>, &str) {
-    // Check Angular's internal format first: `:namespace:name`
-    if name.starts_with(':') {
-        if let Some(colon_index) = name[1..].find(':') {
-            let namespace = &name[1..colon_index + 1];
-            let local_name = &name[colon_index + 2..];
-            return (Some(namespace), local_name);
-        }
-        // Malformed `:` prefix - fall through
-    }
-
-    // Check for known namespace prefixes: `namespace:name`
-    if let Some(colon_index) = name.find(':') {
-        let prefix = &name[..colon_index];
-        if KNOWN_NS_PREFIXES.contains(&prefix) {
-            let local_name = &name[colon_index + 1..];
-            return (Some(prefix), local_name);
-        }
-    }
-
-    // No namespace
-    (None, name)
-}
+/// The TEMPLATE attribute path stores the merged `:ns:name` form (via
+/// `mergeNsAndName` in `html_to_r3.rs`, mirroring `createBoundElementProperty`),
+/// so namespaced template attrs split here and emit the namespace argument of
+/// `ɵɵattribute(name, value, sanitizer?, namespace?)`. The HOST attribute path
+/// stores the plain name (upstream host ingest never merges), so it does NOT
+/// split and emits `ɵɵattribute("xlink:href", ...)` with no namespace — both
+/// faithful to v21.2.7.
+///
+/// (See the `split_ns_name` import at the top of this module.)
 
 /// Specializes generic bindings to specific binding operations.
 ///
diff --git a/crates/oxc_angular_compiler/src/pipeline/phases/resolve_sanitizers.rs b/crates/oxc_angular_compiler/src/pipeline/phases/resolve_sanitizers.rs
index 2b56aac97..eb2ab7b90 100644
--- a/crates/oxc_angular_compiler/src/pipeline/phases/resolve_sanitizers.rs
+++ b/crates/oxc_angular_compiler/src/pipeline/phases/resolve_sanitizers.rs
@@ -27,10 +27,13 @@ fn get_sanitizer_fn(security_context: SecurityContext) -> Option<&'static str> {
         // selects the actual sanitizer at runtime based on the tag name.
         SecurityContext::UrlOrResourceUrl => Some(Identifiers::SANITIZE_URL_OR_RESOURCE_URL),
         SecurityContext::None => None,
-        // AttributeNoBinding means the attribute should not be bound at all.
-        // This should produce a compile-time error in the HTML-to-R3 transform.
-        // For now, return None but the binding should have been rejected earlier.
-        SecurityContext::AttributeNoBinding => None,
+        // `ATTRIBUTE_NO_BINDING` attributes (e.g. `animate|attributeName`,
+        // `iframe|sandbox`) must be validated at runtime: upstream
+        // `resolve_sanitizers.ts` maps this context to `Identifiers.validateAttribute`
+        // (`ɵɵvalidateAttribute`). Previously this returned `None`, leaving such
+        // bindings unprotected (Issue #315 sub-gap 2). Mirror upstream by emitting
+        // the validate-attribute "sanitizer" so the binding is checked at runtime.
+        SecurityContext::AttributeNoBinding => Some(Identifiers::VALIDATE_ATTRIBUTE),
     }
 }
 
diff --git a/crates/oxc_angular_compiler/src/schema/dom_security_schema.rs b/crates/oxc_angular_compiler/src/schema/dom_security_schema.rs
index 30c5337e9..498c4c68e 100644
--- a/crates/oxc_angular_compiler/src/schema/dom_security_schema.rs
+++ b/crates/oxc_angular_compiler/src/schema/dom_security_schema.rs
@@ -7,7 +7,9 @@
 //!
 //! DO NOT EDIT THIS LIST OF SECURITY SENSITIVE PROPERTIES WITHOUT A SECURITY REVIEW!
 
+use crate::ast::expression::BindingType;
 use crate::ast::r3::SecurityContext;
+use crate::parser::html::split_ns_name;
 use rustc_hash::FxHashMap;
 use std::sync::LazyLock;
 
@@ -122,6 +124,17 @@ static SECURITY_SCHEMA: LazyLock<FxHashMap<&'static str, SecurityContext>> = Laz
             "object|codebase",
             "object|data",
             "script|src",
+            // SVGScriptElement href sinks. v21.2.7 dom_security_schema.ts:122-125
+            // registers `script|href` and `script|xlink:href` as RESOURCE_URL with a
+            // comment pointing at SVGScriptElement.href. Because a namespaced
+            // `<svg:script>` is stored `:svg:script` and `get_security_context`
+            // strips the `:ns:` prefix before lookup, `:svg:script|href` resolves to
+            // these bare `script|...` keys. This pairs with the transform keeping
+            // `:svg:script` alive (G4): the SVG script element survives and its href
+            // is sanitized as a resource URL — the actual XSS mechanism for an
+            // SVGScriptElement.
+            "script|href",
+            "script|xlink:href",
         ],
     );
 
@@ -136,6 +149,28 @@ static SECURITY_SCHEMA: LazyLock<FxHashMap<&'static str, SecurityContext>> = Laz
             "animatemotion|attributename",
             "animatetransform|attributename",
             "unknown|attributename",
+            // SVG animation *value* attributes. Binding these animates the
+            // referenced attribute's value at runtime, so they are an XSS vector
+            // identical to `attributeName` and must be validated. Latest upstream
+            // `dom_security_schema.ts` registers them under SVG_NAMESPACE as
+            // ATTRIBUTE_NO_BINDING:
+            //   ['animate', ['attributeName', 'values', 'to', 'from']]
+            //   ['set', ['to', 'attributeName']]
+            // OXC stores schema keys non-namespaced (the `:ns:` prefix is stripped
+            // in `get_security_context`), so they are added here as bare lowercase
+            // `tag|attr` keys. (Issue #315 sub-gap 2: "SVG animation value
+            // attributes bypass sanitization".)
+            "animate|to",
+            "animate|from",
+            "animate|values",
+            "set|to",
+            // The no-namespace `unknown` element aggregates every value attribute
+            // upstream registers, so bindings on an unknown host still validate
+            // these. (Issue #315 sub-gap 2 / upstream `unknown` entry in
+            // `dom_security_schema.ts`.)
+            "unknown|to",
+            "unknown|from",
+            "unknown|values",
             "iframe|sandbox",
             "iframe|allow",
             "iframe|allowfullscreen",
@@ -180,8 +215,16 @@ pub fn get_security_context(element: &str, property: &str) -> SecurityContext {
     let element_lower = element.to_ascii_lowercase();
     let property_lower = property.to_ascii_lowercase();
 
+    // Strip any explicit `:ns:` prefix so namespaced element names resolve to the
+    // same security context as the bare local name. Angular's template pipeline
+    // looks security up by the element's *local* name (namespace tracked
+    // separately), so e.g. `<svg:animate>` (stored as `:svg:animate`) must resolve
+    // like `animate`. Schema keys are never namespaced. (Issue #315 sub-gap 2 /
+    // Codex namespaced-lookup finding.)
+    let (_, element_normalized) = split_ns_name(&element_lower);
+
     // First try element-specific lookup
-    let key = format!("{}|{}", element_lower, property_lower);
+    let key = format!("{}|{}", element_normalized, property_lower);
     if let Some(&ctx) = SECURITY_SCHEMA.get(key.as_str()) {
         return ctx;
     }
@@ -196,6 +239,89 @@ pub fn get_security_context(element: &str, property: &str) -> SecurityContext {
     SecurityContext::None
 }
 
+/// `SECURITY_SCHEMA` element segments that are NOT a BARE entry of upstream
+/// `DomElementSchemaRegistry.allKnownElementNames()` — the complete "phantom"
+/// set. These bare keys exist in `SECURITY_SCHEMA` (and upstream
+/// `dom_security_schema.ts`) but the matching element name is registered in the
+/// element SCHEMA only under a namespace (e.g. `:svg:animate`, `:math:math`) or
+/// is absent from the element schema entirely (e.g. `none`, `annotation`,
+/// `malignmark`, `mglyph`, `mprescripts`, `annotation-xml`).
+///
+/// Upstream's host-unknown scan (`calcPossibleSecurityContexts`,
+/// `binding_parser.ts:888-896`) iterates the REAL `allKnownElementNames()` and
+/// maps each through `securityContext(name, prop)` WITHOUT stripping the
+/// namespace (`dom_element_schema_registry.ts:449-456`). So for a namespaced-only
+/// element, `securityContext(':svg:animate','to')`/`securityContext(':math:math',
+/// 'href')` looks up `:svg:animate|to`/`:math:math|href` -> NOT FOUND -> NONE,
+/// and the bare keys (`animate|to`, `math|href`, …) are UNREACHABLE from the host
+/// path; an absent element name is never iterated at all. OXC stores the security
+/// schema non-namespaced (the `:ns:` prefix is stripped at lookup), so without
+/// this skip these bare keys would contribute to the host-unknown aggregation as
+/// if a real `animate`/`math`/`semantics`/… element existed.
+///
+/// The only OBSERVABLE divergence this causes is when a `:not(element)` selector
+/// excludes EVERY real bare contributor of a property while a phantom segment
+/// still supplies it. Concretely, the MathML `*|href`/`*|xlink:href` URL keys
+/// (`math|href`, `mi|href`, `annotation|href`, `semantics|href`, …) made
+/// `[x]:not(a):not(area):not(base):not(link):not(script)` + `[attr.href]` resolve
+/// to `Url` in OXC where @angular/compiler@21.2.7 yields `NONE` (all the real
+/// bare `href` contributors — `a`, `area`, `base`, `link`, `script` — are
+/// excluded, and the MathML elements exist only as `:math:*`). Skipping the full
+/// phantom set makes OXC's host-unknown scan byte-for-byte match upstream's
+/// real-element-name iteration for every property, since each phantom prop is
+/// also supplied by a bare-known element (`unknown` for the SVG animation
+/// value/`attributeName` props; `a`/`area`/`base`/`link`/`script` for the
+/// MathML href props), so the only difference is the unreachable-upstream
+/// phantom contribution.
+///
+/// Derived from the @angular/compiler@21.2.7 oracle: every `SECURITY_SCHEMA`
+/// element segment minus the bare `allKnownElementNames()` entries. The real bare
+/// elements (`a`, `area`, `base`, `embed`, `form`, `frame`, `iframe`, `img`,
+/// `link`, `object`, `script`, `video`, `unknown`) and the `*` wildcard are NOT
+/// in this set and keep contributing.
+const ELEMENTS_ONLY_KNOWN_NAMESPACED: &[&str] = &[
+    // SVG animation elements (registered only as `:svg:*`).
+    "animate",
+    "set",
+    "animatemotion",
+    "animatetransform",
+    // MathML elements (registered only as `:math:*`).
+    "maction",
+    "math",
+    "merror",
+    "mfrac",
+    "mi",
+    "mmultiscripts",
+    "mn",
+    "mo",
+    "mover",
+    "mpadded",
+    "mphantom",
+    "mroot",
+    "mrow",
+    "ms",
+    "mspace",
+    "msqrt",
+    "mstyle",
+    "msub",
+    "msubsup",
+    "msup",
+    "mtable",
+    "mtd",
+    "mtext",
+    "mtr",
+    "munder",
+    "munderover",
+    "semantics",
+    // Names absent from the element SCHEMA entirely (never iterated upstream).
+    "annotation",
+    "annotation-xml",
+    "malignmark",
+    "mglyph",
+    "mprescripts",
+    "none",
+];
+
 /// Calculates all possible security contexts for a property when the element is unknown.
 ///
 /// This is used when the host element isn't known at compile time (e.g., for directives
@@ -214,9 +340,47 @@ pub fn get_security_context(element: &str, property: &str) -> SecurityContext {
 /// # Returns
 /// The appropriate `SecurityContext` for sanitization.
 pub fn calc_security_context_for_unknown_element(property: &str) -> SecurityContext {
+    calc_security_context_for_unknown_element_excluding(property, &[])
+}
+
+/// Like [`calc_security_context_for_unknown_element`], but excludes any schema
+/// entry whose element name appears in `excluded_elements` via a CASE-SENSITIVE
+/// exact match. This mirrors upstream `notElementNames.has(elName)`, a `Set.has`
+/// over the LOWERCASE `allKnownElementNames()` vs the case-PRESERVED `:not()`
+/// element names (`CssSelector.setElement` does not lowercase). The schema keys
+/// are lowercase, so `:not(object)` excludes `object` but `:not(OBJECT)` does
+/// not.
+///
+/// This mirrors the attribute-only / wildcard branch of upstream
+/// `calcPossibleSecurityContexts` (`binding_parser.ts:888-896`), where the
+/// candidate element set is `registry.allKnownElementNames()` minus the
+/// `:not(element)` exclusions before each name is mapped through
+/// `registry.securityContext(name, propName)`:
+///
+/// ```ts
+/// const elementNames = selector.element ? [selector.element] : registry.allKnownElementNames();
+/// const notElementNames = new Set(
+///   selector.notSelectors.filter((s) => s.isElementSelector()).map((s) => s.element),
+/// );
+/// const possibleElementNames = elementNames.filter((elName) => !notElementNames.has(elName));
+/// ctxs.push(...possibleElementNames.map(nameToContext));
+/// ```
+///
+/// OXC scans the schema map keyed `"element|property"` rather than iterating an
+/// explicit element list, so the exclusion is applied by skipping element-specific
+/// entries whose `element` segment is excluded. Wildcard entries (`"*|property"`)
+/// are never excluded: upstream a `*|prop` context applies to *every* known
+/// element name, so it survives unless every element is excluded — and `*` is
+/// never itself an element `:not()` name. (With `excluded_elements` empty this is
+/// identical to the original all-elements scan.)
+fn calc_security_context_for_unknown_element_excluding(
+    property: &str,
+    excluded_elements: &[String],
+) -> SecurityContext {
     let property_lower = property.to_ascii_lowercase();
 
-    // Collect all security contexts for this property across all elements
+    // Collect all security contexts for this property across all (non-excluded)
+    // elements.
     let mut has_url = false;
     let mut has_resource_url = false;
     let mut has_other = false;
@@ -225,8 +389,57 @@ pub fn calc_security_context_for_unknown_element(property: &str) -> SecurityCont
     for (key, &ctx) in SECURITY_SCHEMA.iter() {
         // Check if this entry is for our property (format: "element|property")
         if let Some(pipe_pos) = key.find('|') {
+            let elem = &key[..pipe_pos];
             let prop = &key[pipe_pos + 1..];
             if prop.eq_ignore_ascii_case(&property_lower) {
+                // Skip element-specific entries whose element is excluded by a
+                // `:not(element)` selector (upstream `possibleElementNames`
+                // filter). Wildcard `*|prop` entries are handled separately
+                // below and never excluded.
+                if elem == "*" {
+                    continue;
+                }
+                // Skip schema keys whose element segment is NOT a real bare
+                // `allKnownElementNames()` entry (the complete phantom set; see
+                // `ELEMENTS_ONLY_KNOWN_NAMESPACED`). Upstream's host-unknown scan
+                // iterates `DomElementSchemaRegistry.allKnownElementNames()` and
+                // maps each through `securityContext(name, prop)` WITHOUT
+                // stripping the namespace (`dom_element_schema_registry.ts:449`).
+                // The SVG animation elements (`:svg:animate`, `:svg:set`,
+                // `:svg:animateMotion`, `:svg:animateTransform`) and the MathML
+                // elements (`:math:math`, `:math:mi`, `:math:semantics`, …) are
+                // registered in the element schema ONLY as namespaced keys; a few
+                // others (`none`, `annotation`, `annotation-xml`, `malignmark`,
+                // `mglyph`, `mprescripts`) are absent from the element schema
+                // entirely. So e.g. `securityContext(':svg:animate','to')` and
+                // `securityContext(':math:math','href')` resolve to NONE, and the
+                // bare keys (`animate|to`, `set|to`, `math|href`, `mi|href`,
+                // `semantics|href`, …) are UNREACHABLE from upstream's
+                // host-unknown scan. OXC stores the security schema non-namespaced
+                // (with ns stripped at lookup), which would otherwise make these
+                // bare keys contribute here as if a real `animate`/`math`/… element
+                // existed. The observable bug: `[x]:not(a):not(area):not(base)
+                // :not(link):not(script)` + `[attr.href]` reduced to `Url` in OXC
+                // via the phantom MathML href keys, where @angular/compiler@21.2.7
+                // yields NONE (all real bare `href` contributors excluded).
+                // Skipping the full phantom set restores faithfulness: each phantom
+                // prop is also supplied by a real bare element (`unknown` for the
+                // SVG animation value/`attributeName` props; `a`/`area`/`base`/
+                // `link`/`script` for the MathML href props), so the only behavior
+                // change is removing the unreachable-upstream phantom contribution.
+                // The `iframe|*` sandbox-family keys are kept (real `iframe`).
+                if ELEMENTS_ONLY_KNOWN_NAMESPACED.contains(&elem) {
+                    continue;
+                }
+                // CASE-SENSITIVE exact match, mirroring upstream
+                // `notElementNames.has(elName)` (a `Set.has` over LOWERCASE
+                // `allKnownElementNames()` vs the case-PRESERVED `:not()` name).
+                // The schema keys (`elem`) are lowercase, so a lowercase
+                // `:not(object)` still excludes `object`, while `:not(OBJECT)`
+                // does NOT (no exact match) — matching v21.2.7.
+                if excluded_elements.iter().any(|ex| ex == elem) {
+                    continue;
+                }
                 match ctx {
                     SecurityContext::Url => has_url = true,
                     SecurityContext::ResourceUrl => has_resource_url = true,
@@ -240,7 +453,7 @@ pub fn calc_security_context_for_unknown_element(property: &str) -> SecurityCont
         }
     }
 
-    // Also check wildcard entries
+    // Also check wildcard entries (apply to all known elements -> never excluded).
     let wildcard_key = format!("*|{}", property_lower);
     if let Some(&ctx) = SECURITY_SCHEMA.get(wildcard_key.as_str()) {
         match ctx {
@@ -270,6 +483,264 @@ pub fn calc_security_context_for_unknown_element(property: &str) -> SecurityCont
     }
 }
 
+/// Collects the element names excluded by an alternate's `:not(...)` selectors,
+/// mirroring upstream's `notSelectors.filter((s) => s.isElementSelector())`.
+///
+/// Upstream `isElementSelector()` (`directive_matching.ts:168-175`) is `true`
+/// only when the negated selector is a *pure* element selector: it has an
+/// element AND no classes, no attributes, and no nested `:not()`. So
+/// `:not(object)` contributes `object`, but `:not(object.foo)`,
+/// `:not(object[x])`, `:not(.foo)`, and `:not([y])` contribute nothing.
+///
+/// The element name is returned with its ORIGINAL case PRESERVED, matching
+/// upstream `CssSelector.setElement` (`directive_matching.ts:181-183`), which
+/// stores the element verbatim (NO `.toLowerCase()`). The exclusion downstream
+/// is a CASE-SENSITIVE exact match against the lowercase known/schema element
+/// names (upstream `notElementNames.has(...)` over `allKnownElementNames()`),
+/// so `:not(object)` excludes `object` but `:not(OBJECT)` does not.
+fn not_element_names(css: &crate::pipeline::selector::CssSelector) -> Vec<String> {
+    css.not_selectors
+        .iter()
+        .filter_map(|n| {
+            // Pure element selector only (upstream `isElementSelector()`).
+            if n.class_names.is_empty() && n.attrs.is_empty() && n.not_selectors.is_empty() {
+                n.element.as_deref().map(str::to_string)
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+/// Computes the security context for a HOST binding given a directive/component
+/// selector and the bound attribute/property name.
+///
+/// This mirrors the upstream HOST pipeline, which differs from the template
+/// pipeline in how it reduces the candidate contexts to a single result:
+///
+/// 1. `calcPossibleSecurityContexts(registry, selector, propName, isAttribute)`
+///    (`binding_parser.ts:874-900`) parses ALL comma-separated alternates via
+///    `CssSelector.parse(selector)` (one `CssSelector` per alternate) and, for
+///    each alternate, looks up `registry.securityContext(elName, ...)` for every
+///    `possibleElementName`. When the alternate names a concrete element the set
+///    is just that element; when it is attribute-only
+///    (`selector.element === null`) it is ALL known element names. In BOTH cases
+///    the `:not(element)` element exclusions are filtered out first
+///    (`possibleElementNames = elementNames.filter((n) => !notElementNames.has(n))`),
+///    so e.g. `[x]:not(object)` excludes `object` from the all-elements scan.
+///    The collected contexts are de-duplicated and returned.
+///
+/// 2. The HOST consumer in `ingest.ts:117-130` then
+///    `.filter(context => context !== SecurityContext.NONE)` (DROP `NONE`).
+///
+/// 3. `resolve_sanitizers.ts:60-99` resolves the filtered array to a sanitizer:
+///    if it is EXACTLY `{URL, RESOURCE_URL}` -> `sanitizeUrlOrResourceUrl`;
+///    otherwise `getOnlySecurityContext` (which throws on length > 1 and returns
+///    the single remaining context, or `NONE` when empty).
+///
+/// In this codebase, `resolve_sanitizers.rs` consumes a single
+/// `SecurityContext` (not an array), with the special `UrlOrResourceUrl`
+/// variant standing in for the `{URL, RESOURCE_URL}` pair. So this function
+/// performs steps 1-3 here and returns that single reduced context:
+///
+/// - empty (after dropping `NONE`)            -> `SecurityContext::None`
+/// - exactly `{Url, ResourceUrl}`             -> `SecurityContext::UrlOrResourceUrl`
+/// - a single surviving context               -> that context
+/// - more than one (and not the URL pair)     -> the lowest-enum-order context
+///   (see the fallback note below)
+///
+/// The attribute-vs-property (`isAttribute`) distinction is carried by the
+/// `name` passed in: callers pass the `attr.`-stripped name for attribute
+/// bindings and the plain property name for property bindings, matching the
+/// schema keys (e.g. `animate|to`, `a|href`, `*|innerhtml`). This is the same
+/// convention the template path uses in `html_to_r3.rs`.
+///
+/// NOTE: this helper implements the HOST-path reduction only. The template path
+/// uses `get_security_context` directly with the concrete element name (see
+/// `html_to_r3.rs`) and the upstream `securityContexts[0]` rule; it does NOT go
+/// through this function.
+pub fn compute_security_context(selector: &str, name: &str) -> SecurityContext {
+    use crate::pipeline::selector::CssSelector;
+
+    // Step 1: collect a context for every possible element across all
+    // comma-separated alternates (mirrors `calcPossibleSecurityContexts`).
+    let mut contexts: Vec<SecurityContext> = Vec::new();
+    let mut push_unique = |ctx: SecurityContext| {
+        if !contexts.contains(&ctx) {
+            contexts.push(ctx);
+        }
+    };
+
+    for css in CssSelector::parse(selector) {
+        // `:not(element)` exclusions for this alternate (upstream
+        // `notElementNames`). Only *pure* element `:not()` selectors count, per
+        // upstream `isElementSelector()`.
+        let excluded = not_element_names(&css);
+        match &css.element {
+            // Concrete element alternate (e.g. `img` in `img[x]`).
+            Some(element_name) if element_name != "*" => {
+                // Honor `:not(element)` element exclusions, like upstream's
+                // `possibleElementNames = elementNames.filter(...)`: a concrete
+                // element that is itself excluded contributes no context
+                // (upstream's single-element list becomes empty). CASE-SENSITIVE
+                // exact match (upstream `notElementNames.has(elName)` over the
+                // case-preserved `[selector.element]`), so `object:not(OBJECT)`
+                // does NOT self-exclude.
+                let is_excluded = excluded.iter().any(|n| n == element_name);
+                if !is_excluded {
+                    push_unique(get_security_context(element_name, name));
+                }
+            }
+            // Attribute-only alternate (`selector.element === null`) or the `*`
+            // wildcard: aggregate across ALL known elements, but first drop the
+            // `:not(element)` exclusions, mirroring upstream's
+            // `possibleElementNames = registry.allKnownElementNames().filter(
+            //   (elName) => !notElementNames.has(elName))`. Without this filter
+            // a directive like `[x]:not(object)` with host `[attr.data]` would
+            // still see `object|data` and over-sanitize as RESOURCE_URL, whereas
+            // upstream excludes `object` and yields no sanitizer.
+            _ => {
+                push_unique(calc_security_context_for_unknown_element_excluding(name, &excluded));
+            }
+        }
+    }
+
+    // `calc_security_context_for_unknown_element` already collapses the
+    // all-elements URL/RESOURCE_URL pair into the `UrlOrResourceUrl` variant.
+    // Expand it back to its constituents so the merge below can combine it with
+    // contexts contributed by other (concrete-element) alternates and re-derive
+    // the pair faithfully.
+    let mut expanded: Vec<SecurityContext> = Vec::new();
+    for ctx in contexts {
+        match ctx {
+            SecurityContext::UrlOrResourceUrl => {
+                if !expanded.contains(&SecurityContext::Url) {
+                    expanded.push(SecurityContext::Url);
+                }
+                if !expanded.contains(&SecurityContext::ResourceUrl) {
+                    expanded.push(SecurityContext::ResourceUrl);
+                }
+            }
+            other if !expanded.contains(&other) => expanded.push(other),
+            _ => {}
+        }
+    }
+
+    // Step 2: drop `NONE` (the HOST-path filter in `ingest.ts`).
+    expanded.retain(|ctx| *ctx != SecurityContext::None);
+
+    // Step 3: reduce to a single context, mirroring `resolve_sanitizers.ts`.
+    match expanded.as_slice() {
+        // empty -> NONE (no sanitizer)
+        [] => SecurityContext::None,
+        // exactly one surviving context
+        [single] => *single,
+        // exactly the {URL, RESOURCE_URL} pair -> runtime-resolved sanitizer
+        two if two.len() == 2
+            && two.contains(&SecurityContext::Url)
+            && two.contains(&SecurityContext::ResourceUrl) =>
+        {
+            SecurityContext::UrlOrResourceUrl
+        }
+        // More than one surviving context that is NOT the URL/RESOURCE_URL pair.
+        // Upstream `getOnlySecurityContext` THROWS an `AssertionError` here
+        // ("Ambiguous security context") — its own comment says this is believed
+        // to never happen in practice outside the URL/RESOURCE_URL case. A
+        // compiler should not panic on user input, so we pick the lowest context
+        // by enum order (matching upstream's ascending sort + TDB's historical
+        // "take the first one" behavior). This branch is effectively unreachable.
+        many => many
+            .iter()
+            .copied()
+            .min_by_key(|ctx| security_context_rank(*ctx))
+            .unwrap_or(SecurityContext::None),
+    }
+}
+
+/// Rank a `SecurityContext` by upstream Angular's `SecurityContext` enum order
+/// (`core.ts`): NONE=0, HTML=1, STYLE=2, SCRIPT=3, URL=4, RESOURCE_URL=5,
+/// ATTRIBUTE_NO_BINDING=6. Used only for the unreachable >1-context fallback in
+/// `compute_security_context` to deterministically pick the lowest context,
+/// matching upstream's ascending sort. `UrlOrResourceUrl` is an OXC-only
+/// composite and never appears in the ranked set (it is expanded beforehand).
+fn security_context_rank(ctx: SecurityContext) -> u8 {
+    match ctx {
+        SecurityContext::None => 0,
+        SecurityContext::Html => 1,
+        SecurityContext::Style => 2,
+        SecurityContext::Script => 3,
+        SecurityContext::Url => 4,
+        SecurityContext::ResourceUrl => 5,
+        SecurityContext::AttributeNoBinding => 6,
+        // Composite variant; not part of upstream's enum. Rank after all real
+        // contexts so it never wins the `min_by_key` (it is expanded away).
+        SecurityContext::UrlOrResourceUrl => 7,
+    }
+}
+
+/// Extracts the element name from a CSS selector, if the selector begins with
+/// a concrete element name.
+///
+/// Examples:
+/// - `"a[myDirective]"` → `Some("a")`
+/// - `"div.my-class"` → `Some("div")`
+/// - `"[myDirective]"` → `None`
+/// - `".my-class"` → `None`
+/// - `""` → `None` (no element; mirrors upstream's `selector === null`)
+pub fn extract_element_from_selector(selector: &str) -> Option<String> {
+    let s = selector.trim();
+
+    // A leading `[`, `.`, `:`, or `#` means there is no element in this selector.
+    if s.starts_with('[') || s.starts_with('.') || s.starts_with(':') || s.starts_with('#') {
+        return None;
+    }
+
+    // The element name runs until the first non-identifier character.
+    let mut element_end = 0;
+    for (i, c) in s.char_indices() {
+        if c.is_alphanumeric() || c == '-' || c == '_' {
+            element_end = i + c.len_utf8();
+        } else {
+            break;
+        }
+    }
+
+    if element_end > 0 { Some(s[..element_end].to_lowercase()) } else { None }
+}
+
+/// Computes the security context for a `host` binding, given its binding type,
+/// the bound (already prefix-stripped) name, and the directive/component
+/// selector used as the element context.
+///
+/// Mirrors upstream `BindingParser.createBoundElementProperty`
+/// (`binding_parser.ts`): attribute bindings use the attribute security lookup
+/// (`isAttribute = true`) and property bindings the property lookup
+/// (`isAttribute = false`), while `class`/`style`/animation bindings carry their
+/// fixed contexts (`NONE`/`STYLE`/`NONE`). In this codebase the `isAttribute`
+/// distinction is encoded by the schema key (the `attr.`-stripped name passed in
+/// for attribute bindings), so both attribute and property bindings resolve via
+/// the shared `compute_security_context`.
+pub fn host_binding_security_context(
+    binding_type: BindingType,
+    name: &str,
+    selector: &str,
+) -> SecurityContext {
+    match binding_type {
+        // Attribute (`[attr.X]`) and property (`[domProp]`) bindings get a real
+        // security context derived from the selector's element.
+        BindingType::Attribute | BindingType::Property | BindingType::TwoWay => {
+            compute_security_context(selector, name)
+        }
+        // `[style.X]` bindings are always the STYLE context (upstream uses
+        // `[SecurityContext.STYLE]` for the `style` prefix).
+        BindingType::Style => SecurityContext::Style,
+        // `[class.X]` and animation bindings are never sanitized.
+        BindingType::Class | BindingType::Animation | BindingType::LegacyAnimation => {
+            SecurityContext::None
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -301,6 +772,24 @@ mod tests {
         assert_eq!(get_security_context("embed", "src"), SecurityContext::ResourceUrl);
     }
 
+    #[test]
+    fn test_svg_script_href_resource_url_context() {
+        // v21.2.7 dom_security_schema.ts:122-125 registers `script|href` and
+        // `script|xlink:href` as RESOURCE_URL (the SVGScriptElement.href sinks).
+        // Plain (bare) lookups resolve directly.
+        assert_eq!(get_security_context("script", "href"), SecurityContext::ResourceUrl);
+        assert_eq!(get_security_context("script", "xlink:href"), SecurityContext::ResourceUrl);
+        // A namespaced `<svg:script>` is stored `:svg:script`; the `:ns:` prefix is
+        // stripped before lookup, so it resolves to the same RESOURCE_URL context.
+        // This is reachable in templates now that the transform keeps `:svg:script`
+        // alive (G4).
+        assert_eq!(get_security_context(":svg:script", "href"), SecurityContext::ResourceUrl);
+        assert_eq!(get_security_context(":svg:script", "xlink:href"), SecurityContext::ResourceUrl);
+        // Lookup is case-insensitive.
+        assert_eq!(get_security_context("SCRIPT", "HREF"), SecurityContext::ResourceUrl);
+        assert_eq!(get_security_context(":svg:script", "XLINK:HREF"), SecurityContext::ResourceUrl);
+    }
+
     #[test]
     fn test_attribute_no_binding_context() {
         assert_eq!(
@@ -310,6 +799,68 @@ mod tests {
         assert_eq!(get_security_context("iframe", "sandbox"), SecurityContext::AttributeNoBinding);
     }
 
+    #[test]
+    fn test_svg_animation_value_attribute_no_binding() {
+        // Latest upstream `dom_security_schema.ts` registers SVG animation *value*
+        // attributes as ATTRIBUTE_NO_BINDING (under SVG_NAMESPACE):
+        //   ['animate', ['attributeName', 'values', 'to', 'from']]
+        //   ['set', ['to', 'attributeName']]
+        // plus the no-namespace `unknown` aggregate (which includes 'values', 'to',
+        // 'from'). Binding these animates an attribute's *value* at runtime, so
+        // leaving them unsanitized is the XSS vector this closes. OXC stores keys
+        // non-namespaced (the `:ns:` prefix is stripped before lookup), so they
+        // resolve to AttributeNoBinding -> `ɵɵvalidateAttribute` at runtime.
+        // (Issue #315 sub-gap 2.)
+        assert_eq!(get_security_context("animate", "to"), SecurityContext::AttributeNoBinding);
+        assert_eq!(get_security_context("animate", "from"), SecurityContext::AttributeNoBinding);
+        assert_eq!(get_security_context("animate", "values"), SecurityContext::AttributeNoBinding);
+        assert_eq!(get_security_context("set", "to"), SecurityContext::AttributeNoBinding);
+        assert_eq!(get_security_context("unknown", "to"), SecurityContext::AttributeNoBinding);
+        assert_eq!(get_security_context("unknown", "from"), SecurityContext::AttributeNoBinding);
+        assert_eq!(get_security_context("unknown", "values"), SecurityContext::AttributeNoBinding);
+        // The namespaced element form resolves identically (the `:svg:` prefix is
+        // stripped before lookup).
+        assert_eq!(get_security_context(":svg:animate", "to"), SecurityContext::AttributeNoBinding);
+        // Lookup is case-insensitive (matching the SVG `<animate>` element name).
+        assert_eq!(get_security_context("ANIMATE", "TO"), SecurityContext::AttributeNoBinding);
+        // The pre-existing `attributeName` registration is unaffected.
+        assert_eq!(
+            get_security_context("animate", "attributeName"),
+            SecurityContext::AttributeNoBinding
+        );
+        assert_eq!(
+            get_security_context("ANIMATE", "ATTRIBUTENAME"),
+            SecurityContext::AttributeNoBinding
+        );
+        assert_eq!(
+            get_security_context("unknown", "attributeName"),
+            SecurityContext::AttributeNoBinding
+        );
+    }
+
+    #[test]
+    fn test_namespaced_svg_element_security_lookup() {
+        // Issue #315 sub-gap 2 / Codex namespaced-lookup finding: an explicitly
+        // namespaced element is stored with a `:ns:` prefix (e.g. `:svg:animate`).
+        // The lookup strips the prefix so the namespaced form resolves to the same
+        // context as the bare local name.
+        assert_eq!(
+            get_security_context(":svg:animate", "attributeName"),
+            SecurityContext::AttributeNoBinding
+        );
+        assert_eq!(
+            get_security_context(":svg:set", "attributeName"),
+            SecurityContext::AttributeNoBinding
+        );
+        assert_eq!(
+            get_security_context(":svg:iframe", "sandbox"),
+            SecurityContext::AttributeNoBinding
+        );
+        // Namespaced URL contexts (wildcard and element-specific) still resolve.
+        assert_eq!(get_security_context(":svg:a", "href"), SecurityContext::Url);
+        assert_eq!(get_security_context(":svg:iframe", "srcdoc"), SecurityContext::Html);
+    }
+
     #[test]
     fn test_no_context() {
         assert_eq!(get_security_context("div", "class"), SecurityContext::None);
@@ -352,4 +903,324 @@ mod tests {
         // "class" has no security context
         assert_eq!(calc_security_context_for_unknown_element("class"), SecurityContext::None);
     }
+
+    // -----------------------------------------------------------------------
+    // G1: `compute_security_context` (HOST path) must consider EVERY
+    // comma-separated selector alternate and merge their contexts, mirroring
+    // upstream `calcPossibleSecurityContexts` + the host NONE-filter +
+    // `resolve_sanitizers` URL/RESOURCE_URL special case.
+    // -----------------------------------------------------------------------
+    #[test]
+    fn test_compute_sc_single_concrete_element() {
+        // Single alternate, concrete element -> element-specific lookup.
+        assert_eq!(compute_security_context("img[x]", "src"), SecurityContext::Url);
+        assert_eq!(compute_security_context("iframe[x]", "src"), SecurityContext::ResourceUrl);
+        assert_eq!(compute_security_context("a[appLink]", "href"), SecurityContext::Url);
+    }
+
+    #[test]
+    fn test_compute_sc_attribute_only_aggregates() {
+        // Attribute-only selector (`element === null`) -> unknown-element scan.
+        assert_eq!(
+            compute_security_context("[appHref]", "href"),
+            SecurityContext::UrlOrResourceUrl
+        );
+    }
+
+    #[test]
+    fn test_compute_sc_merges_url_and_resource_url() {
+        // img|src = URL, iframe|src = RESOURCE_URL -> {URL, RESOURCE_URL} merge.
+        assert_eq!(
+            compute_security_context("img[x],iframe[x]", "src"),
+            SecurityContext::UrlOrResourceUrl
+        );
+    }
+
+    #[test]
+    fn test_compute_sc_filters_none_single_survivor() {
+        // div|src = NONE (filtered), iframe|src = RESOURCE_URL -> single survivor.
+        assert_eq!(
+            compute_security_context("div[x],iframe[x]", "src"),
+            SecurityContext::ResourceUrl
+        );
+        // Order must not matter.
+        assert_eq!(
+            compute_security_context("iframe[x],div[x]", "src"),
+            SecurityContext::ResourceUrl
+        );
+    }
+
+    #[test]
+    fn test_compute_sc_all_none_is_none() {
+        // Neither a|title nor b|title is sensitive -> empty after filter -> NONE.
+        assert_eq!(compute_security_context("a[x],b[x]", "title"), SecurityContext::None);
+    }
+
+    #[test]
+    fn test_compute_sc_dedupes_same_context() {
+        // Two URL alternates collapse to a single URL context (not the pair).
+        assert_eq!(compute_security_context("a[x],area[x]", "href"), SecurityContext::Url);
+    }
+
+    #[test]
+    fn test_compute_sc_not_excludes_concrete_element() {
+        // `:not(iframe)` removes the only RESOURCE_URL contributor, leaving just
+        // img|src = URL.
+        assert_eq!(
+            compute_security_context("img[x],iframe[x]:not(iframe)", "src"),
+            SecurityContext::Url
+        );
+    }
+
+    // -----------------------------------------------------------------------
+    // v21.2.7 faithfulness (Codex iteration-10): the attribute-only / wildcard
+    // branch must filter `:not(element)` names out of the all-elements scan,
+    // mirroring upstream `possibleElementNames = elementNames.filter(...)` in
+    // `binding_parser.ts:888-896`. Previously OXC ignored `:not(...)` here and
+    // over-sanitized.
+    //
+    // Schema facts (dom_security_schema.ts): `data`/`codebase` are ONLY on
+    // `object` (RESOURCE_URL); `srcdoc` is ONLY on `iframe` (HTML). So excluding
+    // those elements removes the sole contributor and yields NONE.
+    // -----------------------------------------------------------------------
+    #[test]
+    fn test_compute_sc_attr_only_not_object_excludes_data() {
+        // `object|data` is the ONLY `data` sink. `[x]:not(object)` excludes it,
+        // so nothing else contributes `data` -> NONE (upstream: no sanitizer).
+        // Sanity: `object|data` really is RESOURCE_URL and `data` is object-only.
+        assert_eq!(get_security_context("object", "data"), SecurityContext::ResourceUrl);
+        assert_eq!(calc_security_context_for_unknown_element("data"), SecurityContext::ResourceUrl);
+        assert_eq!(compute_security_context("[x]:not(object)", "data"), SecurityContext::None);
+    }
+
+    #[test]
+    fn test_compute_sc_attr_only_not_object_excludes_codebase() {
+        // `object|codebase` is the ONLY `codebase` sink. Excluding `object`
+        // leaves nothing -> NONE.
+        assert_eq!(get_security_context("object", "codebase"), SecurityContext::ResourceUrl);
+        assert_eq!(compute_security_context("[x]:not(object)", "codebase"), SecurityContext::None);
+    }
+
+    #[test]
+    fn test_compute_sc_attr_only_not_iframe_excludes_srcdoc() {
+        // `iframe|srcdoc` is the ONLY `srcdoc` sink (HTML). Excluding `iframe`
+        // leaves nothing -> NONE.
+        assert_eq!(get_security_context("iframe", "srcdoc"), SecurityContext::Html);
+        assert_eq!(calc_security_context_for_unknown_element("srcdoc"), SecurityContext::Html);
+        assert_eq!(compute_security_context("[x]:not(iframe)", "srcdoc"), SecurityContext::None);
+    }
+
+    #[test]
+    fn test_compute_sc_attr_only_no_not_still_sanitizes() {
+        // CONTROL: without `:not`, `object|data` is still in the set -> RESOURCE_URL.
+        assert_eq!(compute_security_context("[x]", "data"), SecurityContext::ResourceUrl);
+        assert_eq!(compute_security_context("[x]", "srcdoc"), SecurityContext::Html);
+    }
+
+    #[test]
+    fn test_compute_sc_attr_only_not_unrelated_element_still_sanitizes() {
+        // CONTROL: excluding a non-sink element (`div`) leaves `object` in the
+        // set -> still RESOURCE_URL for `data`.
+        assert_eq!(compute_security_context("[x]:not(div)", "data"), SecurityContext::ResourceUrl);
+    }
+
+    #[test]
+    fn test_compute_sc_attr_only_non_element_not_does_not_filter() {
+        // CONTROL: a NON-element `:not()` (class / attribute) is NOT an
+        // `isElementSelector()`, so it excludes nothing -> still RESOURCE_URL.
+        assert_eq!(compute_security_context("[x]:not(.foo)", "data"), SecurityContext::ResourceUrl);
+        assert_eq!(compute_security_context("[x]:not([y])", "data"), SecurityContext::ResourceUrl);
+    }
+
+    #[test]
+    fn test_compute_sc_wildcard_not_object_excludes_data() {
+        // The `*` wildcard alternate aggregates over all elements just like the
+        // attribute-only case, and must also honor `:not(object)`.
+        assert_eq!(compute_security_context("*:not(object)", "data"), SecurityContext::None);
+    }
+
+    #[test]
+    fn test_compute_sc_attr_only_not_object_keeps_wildcard_prop() {
+        // Excluding `object` must NOT drop a wildcard `*|prop` context, which
+        // upstream treats as applying to every (remaining) element. `innerhtml`
+        // is `*|innerhtml` = HTML, so `[x]:not(object)` still yields HTML.
+        assert_eq!(compute_security_context("[x]:not(object)", "innerHTML"), SecurityContext::Html);
+    }
+
+    // -----------------------------------------------------------------------
+    // v21.2.7 faithfulness (Finding 1): the `:not(element)` exclusion is a
+    // CASE-SENSITIVE exact match. Upstream `CssSelector.setElement`
+    // (directive_matching.ts:181-183) stores the element verbatim (no
+    // `.toLowerCase()`), while `allKnownElementNames()` and the schema keys are
+    // LOWERCASE. So `notElementNames.has(name)` only excludes when the `:not()`
+    // name is exactly the lowercase known name.
+    //
+    // Oracle (faithful reimpl of calcPossibleSecurityContexts over the real
+    // @angular/compiler@21.2.7 DomElementSchemaRegistry + CssSelector):
+    //   [x]:not(object) + data => [NONE]                    -> None
+    //   [x]:not(OBJECT) + data => [NONE, RESOURCE_URL]      -> ResourceUrl
+    //   [x]:not(IFRAME) + src  => [NONE, URL, RESOURCE_URL] -> UrlOrResourceUrl
+    //
+    // Previously OXC lowercased the `:not()` name and compared
+    // case-insensitively, so `:not(OBJECT)` wrongly excluded `object` -> None,
+    // an UNDER-sanitization XSS gap.
+    // -----------------------------------------------------------------------
+    #[test]
+    fn test_compute_sc_not_uppercase_object_does_not_exclude() {
+        // Uppercase `:not(OBJECT)` does NOT exclude lowercase `object`, so
+        // `object|data` (RESOURCE_URL) survives.
+        assert_eq!(
+            compute_security_context("[x]:not(OBJECT)", "data"),
+            SecurityContext::ResourceUrl
+        );
+    }
+
+    #[test]
+    fn test_compute_sc_not_lowercase_object_excludes() {
+        // CONTROL companion: lowercase `:not(object)` DOES exclude `object`.
+        assert_eq!(compute_security_context("[x]:not(object)", "data"), SecurityContext::None);
+    }
+
+    #[test]
+    fn test_compute_sc_not_uppercase_iframe_does_not_exclude() {
+        // Uppercase `:not(IFRAME)` does NOT exclude lowercase `iframe`; the
+        // across-all-elements `src` set is {URL, RESOURCE_URL}.
+        assert_eq!(
+            compute_security_context("[x]:not(IFRAME)", "src"),
+            SecurityContext::UrlOrResourceUrl
+        );
+    }
+
+    #[test]
+    fn test_compute_sc_concrete_uppercase_not_self_does_not_exclude() {
+        // A concrete-element alternate whose `:not()` is the SAME element but in
+        // a different case must NOT self-exclude (case-sensitive). `object` is a
+        // concrete element here and `:not(OBJECT)` does not match it, so
+        // `object|data` = RESOURCE_URL survives.
+        assert_eq!(
+            compute_security_context("object:not(OBJECT)", "data"),
+            SecurityContext::ResourceUrl
+        );
+        // CONTROL: same-case self-exclusion DOES drop it -> None.
+        assert_eq!(compute_security_context("object:not(object)", "data"), SecurityContext::None);
+    }
+
+    #[test]
+    fn test_calc_excluding_helper_directly() {
+        // The exclusion helper drops the named element from the all-elements scan.
+        assert_eq!(
+            calc_security_context_for_unknown_element_excluding("data", &[]),
+            SecurityContext::ResourceUrl
+        );
+        assert_eq!(
+            calc_security_context_for_unknown_element_excluding("data", &["object".to_string()]),
+            SecurityContext::None
+        );
+        // Excluding `object` does not affect a wildcard context.
+        assert_eq!(
+            calc_security_context_for_unknown_element_excluding(
+                "innerhtml",
+                &["object".to_string()]
+            ),
+            SecurityContext::Html
+        );
+    }
+
+    // Finding 1 (issue #315): host-unknown `:not(<animation element>)` faithfulness.
+    //
+    // Upstream `calcPossibleSecurityContexts` iterates
+    // `DomElementSchemaRegistry.allKnownElementNames()` and maps each through
+    // `securityContext(name, prop)` WITHOUT stripping the namespace. The SVG
+    // animation elements exist in the element schema ONLY as namespaced keys
+    // (`:svg:animate`, `:svg:set`, `:svg:animatemotion`, `:svg:animatetransform`),
+    // so they resolve to NONE; the bare ATTRIBUTE_NO_BINDING security keys
+    // (`animate|to`, `set|to`, …) are reachable from the host-unknown scan ONLY
+    // via the real `unknown` element. Verified against @angular/compiler@21.2.7:
+    //   calc('[x]','to',true)            -> [NONE, ATTRIBUTE_NO_BINDING] -> host ATTRIBUTE_NO_BINDING
+    //   calc('[x]:not(unknown)','to',true) -> [NONE]                     -> host NONE
+    //   calc('[x]:not(animate)','to',true) -> [NONE, ATTRIBUTE_NO_BINDING] -> host ATTRIBUTE_NO_BINDING
+    #[test]
+    fn host_unknown_animation_props_match_v21_2_7() {
+        // Base attribute-only host selector: ATTRIBUTE_NO_BINDING via real `unknown`.
+        for prop in ["to", "from", "values", "attributeName"] {
+            assert_eq!(
+                compute_security_context("[x]", prop),
+                SecurityContext::AttributeNoBinding,
+                "base [x] + {prop} should be ATTRIBUTE_NO_BINDING (via real `unknown` element)",
+            );
+        }
+        // `:not(unknown)` removes the ONLY real contributor -> NONE upstream. The
+        // phantom bare `animate`/`set` keys must NOT keep it ATTRIBUTE_NO_BINDING.
+        for prop in ["to", "from", "values", "attributeName"] {
+            assert_eq!(
+                compute_security_context("[x]:not(unknown)", prop),
+                SecurityContext::None,
+                "[x]:not(unknown) + {prop} should be NONE to match @angular/compiler@21.2.7",
+            );
+        }
+        // `:not(animate)` excludes a phantom (non-)element; the real `unknown`
+        // element still contributes -> ATTRIBUTE_NO_BINDING (matches upstream).
+        assert_eq!(
+            compute_security_context("[x]:not(animate)", "to"),
+            SecurityContext::AttributeNoBinding,
+        );
+        // The iframe sandbox-family ATTRIBUTE_NO_BINDING props are kept under
+        // `:not(unknown)` because the real `iframe` element still contributes
+        // (upstream parity).
+        for prop in ["sandbox", "allow", "allowfullscreen", "csp", "fetchpriority"] {
+            assert_eq!(
+                compute_security_context("[x]:not(unknown)", prop),
+                SecurityContext::AttributeNoBinding,
+                "[x]:not(unknown) + {prop} stays ATTRIBUTE_NO_BINDING via real `iframe`",
+            );
+        }
+    }
+
+    // Finding (iteration-21): the host-unknown scan must skip the COMPLETE phantom
+    // element set, not just the four SVG animation names. The MathML `*|href` /
+    // `*|xlink:href` URL keys (`math|href`, `mi|href`, `annotation|href`,
+    // `semantics|href`, …) name elements registered in the element schema ONLY as
+    // `:math:*` (or absent entirely), so upstream's `allKnownElementNames()`
+    // iteration never reaches them. Verified against @angular/compiler@21.2.7:
+    //   calc('[x]:not(a):not(area):not(base):not(link):not(script)','href',true)
+    //      -> [NONE] -> host NONE
+    // (all real bare `href` contributors are `a`/`area`/`base`/`link`/`script`).
+    // Previously OXC scanned bare SECURITY_SCHEMA keys and the phantom MathML
+    // `*|href` keys kept it `Url`.
+    #[test]
+    fn host_unknown_mathml_href_phantom_match_v21_2_7() {
+        // Excluding EVERY real bare `href` contributor leaves only phantom MathML
+        // elements -> upstream NONE. OXC must not return `Url` via phantom keys.
+        assert_eq!(
+            compute_security_context(
+                "[x]:not(a):not(area):not(base):not(link):not(script)",
+                "href"
+            ),
+            SecurityContext::None,
+            "all real bare `href` sinks excluded; phantom MathML keys must not contribute",
+        );
+        // Same for `xlink:href` (real bare contributors are only `a` and `script`).
+        assert_eq!(
+            compute_security_context("[x]:not(a):not(script)", "xlink:href"),
+            SecurityContext::None,
+            "all real bare `xlink:href` sinks excluded; phantom MathML keys must not contribute",
+        );
+        // CONTROL: without the `:not()` exclusions the real bare `href` sinks make
+        // `[x]` + `href` the {URL, RESOURCE_URL} pair (`a`/`area` = URL,
+        // `base`/`link` = RESOURCE_URL), matching upstream `[NONE,URL,RESOURCE_URL]`.
+        assert_eq!(compute_security_context("[x]", "href"), SecurityContext::UrlOrResourceUrl,);
+        // CONTROL: excluding only some real contributors still leaves `a` (URL),
+        // so the phantom skip does not over-reduce. `:not(area):not(base)
+        // :not(link):not(script)` keeps `a|href` = URL.
+        assert_eq!(
+            compute_security_context("[x]:not(area):not(base):not(link):not(script)", "href"),
+            SecurityContext::Url,
+            "`a|href` (real bare URL sink) survives",
+        );
+        // CONTROL: a concrete MathML-ish phantom element selector resolves via the
+        // bare-key element-specific lookup in `get_security_context` (the template
+        // path), which is unchanged — only the host-unknown aggregation skips
+        // phantoms. `math[x]` + `href` is still URL (concrete element path).
+        assert_eq!(compute_security_context("math[x]", "href"), SecurityContext::Url);
+    }
 }
diff --git a/crates/oxc_angular_compiler/src/schema/mod.rs b/crates/oxc_angular_compiler/src/schema/mod.rs
index 4a3a14d89..3825ec295 100644
--- a/crates/oxc_angular_compiler/src/schema/mod.rs
+++ b/crates/oxc_angular_compiler/src/schema/mod.rs
@@ -4,5 +4,10 @@
 //! and security contexts.
 
 mod dom_security_schema;
+mod trusted_types_sinks;
 
-pub use dom_security_schema::{calc_security_context_for_unknown_element, get_security_context};
+pub use dom_security_schema::{
+    calc_security_context_for_unknown_element, compute_security_context,
+    extract_element_from_selector, get_security_context, host_binding_security_context,
+};
+pub use trusted_types_sinks::is_trusted_types_sink;
diff --git a/crates/oxc_angular_compiler/src/schema/trusted_types_sinks.rs b/crates/oxc_angular_compiler/src/schema/trusted_types_sinks.rs
new file mode 100644
index 000000000..ebb7d576c
--- /dev/null
+++ b/crates/oxc_angular_compiler/src/schema/trusted_types_sinks.rs
@@ -0,0 +1,88 @@
+//! Trusted Types sinks
+//!
+//! Set of `tagName|propertyName` corresponding to Trusted Types sinks. Properties applying to all
+//! tags use `*`.
+//!
+//! Ported from Angular's `schema/trusted_types_sinks.ts`. Extracted from, and should be kept in
+//! sync with <https://www.w3.org/TR/trusted-types/#integrations>.
+//!
+//! DO NOT EDIT THIS LIST OF SECURITY SENSITIVE SINKS WITHOUT A SECURITY REVIEW!
+
+use rustc_hash::FxHashSet;
+use std::sync::LazyLock;
+
+/// Set of `"tagName|propertyName"` Trusted Types sinks. Properties applying to all tags use `"*"`.
+///
+/// NOTE: All strings in this set *must* be lowercase!
+static TRUSTED_TYPES_SINKS: LazyLock<FxHashSet<&'static str>> = LazyLock::new(|| {
+    FxHashSet::from_iter([
+        // TrustedHTML
+        "iframe|srcdoc",
+        "*|innerhtml",
+        "*|outerhtml",
+        // NB: no TrustedScript here, as the corresponding tags are stripped by the compiler.
+        // TrustedScriptURL
+        "embed|src",
+        "iframe|src",
+        "object|codebase",
+        "object|data",
+    ])
+});
+
+/// Returns `true` if the given property on the given DOM tag is a Trusted Types sink.
+///
+/// In that case, use [`crate::schema::get_security_context`] to determine which particular
+/// Trusted Type is required for values passed to the sink:
+/// - [`crate::ast::r3::SecurityContext::Html`] corresponds to `TrustedHTML`
+/// - [`crate::ast::r3::SecurityContext::ResourceUrl`] corresponds to `TrustedScriptURL`
+///
+/// The lookup is case-insensitive, so that case differences between attribute and property names
+/// do not have a security impact.
+pub fn is_trusted_types_sink(tag_name: &str, prop_name: &str) -> bool {
+    let tag = tag_name.to_ascii_lowercase();
+    let prop = prop_name.to_ascii_lowercase();
+
+    TRUSTED_TYPES_SINKS.contains(format!("{tag}|{prop}").as_str())
+        || TRUSTED_TYPES_SINKS.contains(format!("*|{prop}").as_str())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn detects_html_sinks() {
+        assert!(is_trusted_types_sink("iframe", "srcdoc"));
+        assert!(is_trusted_types_sink("p", "innerHTML"));
+        assert!(is_trusted_types_sink("div", "outerHTML"));
+    }
+
+    #[test]
+    fn detects_resource_url_sinks() {
+        assert!(is_trusted_types_sink("embed", "src"));
+        assert!(is_trusted_types_sink("object", "codebase"));
+        assert!(is_trusted_types_sink("object", "data"));
+    }
+
+    #[test]
+    fn detects_iframe_src() {
+        // Issue #315 sub-gap 1 / upstream commit 78dea55351: `iframe|src` is a sink.
+        assert!(is_trusted_types_sink("iframe", "src"));
+    }
+
+    #[test]
+    fn is_case_insensitive() {
+        assert!(is_trusted_types_sink("IFRAME", "SRC"));
+        assert!(is_trusted_types_sink("P", "iNnErHtMl"));
+    }
+
+    #[test]
+    fn rejects_non_sinks() {
+        assert!(!is_trusted_types_sink("a", "href"));
+        assert!(!is_trusted_types_sink("base", "href"));
+        assert!(!is_trusted_types_sink("div", "style"));
+        // `img|src` is a navigable URL, not a Trusted Types sink.
+        assert!(!is_trusted_types_sink("img", "src"));
+        assert!(!is_trusted_types_sink("p", "formaction"));
+    }
+}
diff --git a/crates/oxc_angular_compiler/src/styles/encapsulation.rs b/crates/oxc_angular_compiler/src/styles/encapsulation.rs
index 251abfaff..dbe18bb8d 100644
--- a/crates/oxc_angular_compiler/src/styles/encapsulation.rs
+++ b/crates/oxc_angular_compiler/src/styles/encapsulation.rs
@@ -320,8 +320,78 @@ pub fn shim_css_text(css: &str, content_attr: &str, host_attr: &str) -> String {
     restore_comments(&result, &comments)
 }
 
+/// Returns `true` if `ch` is an ECMAScript `\s` whitespace code point.
+///
+/// FINDING 2: upstream `ShadowCss` matches comments with two JavaScript regexes
+/// whose `\s` follows ECMAScript whitespace semantics, NOT Rust's `char::is_whitespace`
+/// (Unicode `White_Space`). The two sets differ for exactly the code points that bite
+/// here:
+///   * U+FEFF (BOM / ZERO WIDTH NO-BREAK SPACE) — IS ECMAScript `\s`, but is NOT in
+///     Rust's `White_Space`.
+///   * U+0085 (NEL) — is NOT ECMAScript `\s`, but IS in Rust's `White_Space`.
+/// So the hash-comment predicate must use this function instead of `trim`/`is_whitespace`.
+///
+/// ECMAScript `\s` = WhiteSpace ∪ LineTerminator, i.e.:
+///   \t \n \v \f \r, U+0020, U+00A0, U+1680, U+2000–U+200A, U+2028, U+2029,
+///   U+202F, U+205F, U+3000, U+FEFF.
+fn is_ecmascript_whitespace(ch: char) -> bool {
+    matches!(
+        ch,
+        '\u{0009}'   // \t
+        | '\u{000A}' // \n
+        | '\u{000B}' // \v
+        | '\u{000C}' // \f
+        | '\u{000D}' // \r
+        | '\u{0020}' // space
+        | '\u{00A0}' // NBSP
+        | '\u{1680}'
+        | '\u{2000}'
+            ..='\u{200A}'
+        | '\u{2028}' // LINE SEPARATOR
+        | '\u{2029}' // PARAGRAPH SEPARATOR
+        | '\u{202F}'
+        | '\u{205F}'
+        | '\u{3000}'
+        | '\u{FEFF}' // BOM / ZWNBSP — ECMAScript ws but NOT Rust White_Space
+    )
+}
+
+/// Tests a closed comment against upstream `_commentWithHashRe`
+/// (`/\/\*\s*#\s*source(Mapping)?URL=/g`): literal `/*`, ECMAScript-`\s`*, `#`,
+/// ECMAScript-`\s`*, then literally `sourceURL=` or `sourceMappingURL=` (trailing `=`
+/// required; `Mapping` optional; case-sensitive). `comment` includes the leading `/*`.
+///
+/// FINDING 1: upstream uses `m.match(_commentWithHashRe)`, which is UNANCHORED — it
+/// searches the ENTIRE comment string `m` for the pattern. Because the pattern STARTS
+/// WITH a literal `/*`, it can match an INNER `/*#sourceURL=` occurrence inside the
+/// comment body, e.g. `/* outer /*#sourceURL=x */` (a single closed comment per
+/// `_commentRe`'s non-greedy match to the first `*/`) matches the inner `/*#sourceURL=`
+/// and is PRESERVED. So we must scan EVERY `/*` position in `comment`, not just the
+/// leading one.
+fn comment_is_sourcemap(comment: &str) -> bool {
+    let bytes = comment.as_bytes();
+    // Find every literal `/*` in the comment (the pattern's required prefix).
+    for start in 0..bytes.len().saturating_sub(1) {
+        if bytes[start] == b'/' && bytes[start + 1] == b'*' {
+            // `start + 2` is a UTF-8 char boundary (`/` and `*` are ASCII).
+            let after_start = &comment[start + 2..];
+            let after_ws = after_start.trim_start_matches(is_ecmascript_whitespace);
+            let Some(after_hash) = after_ws.strip_prefix('#') else {
+                continue;
+            };
+            let token = after_hash.trim_start_matches(is_ecmascript_whitespace);
+            if token.starts_with("sourceURL=") || token.starts_with("sourceMappingURL=") {
+                return true;
+            }
+        }
+    }
+    false
+}
+
 /// Extract comments and replace them with placeholders.
-/// Sourcemap comments are preserved, other comments are replaced with newlines.
+/// Sourcemap comments are preserved verbatim; other comments are replaced with
+/// only their interior newlines (empty when single-line), matching upstream
+/// Angular `ShadowCss` v21.2.7 so that stripping a comment adds no extra lines.
 fn extract_comments(css: &str) -> (String, Vec<String>) {
     let mut comments = Vec::new();
     let mut result = String::with_capacity(css.len());
@@ -333,37 +403,74 @@ fn extract_comments(css: &str) -> (String, Vec<String>) {
         // Check for comment start: /*
         if i + 1 < len && bytes[i] == b'/' && bytes[i + 1] == b'*' {
             let comment_start = i;
-            i += 2;
-
-            // Find comment end: */
-            while i + 1 < len {
-                if bytes[i] == b'*' && bytes[i + 1] == b'/' {
-                    i += 2;
+            let mut scan = i + 2;
+
+            // Find comment end: */ (CLOSED comments only).
+            let mut closed = false;
+            while scan + 1 < len {
+                if bytes[scan] == b'*' && bytes[scan + 1] == b'/' {
+                    scan += 2;
+                    closed = true;
                     break;
                 }
-                i += 1;
+                scan += 1;
+            }
+
+            // FINDING 2: upstream `_commentRe = /\/\*[\s\S]*?\*\//g` matches ONLY closed
+            // comments. An unterminated `/*` (no closing `*/`) is NOT a comment — leave it
+            // (and the rest of the text) UNCHANGED. Emit the leading `/` as an ordinary
+            // char and continue normal char-by-char scanning so any later well-formed
+            // `/* ... */` still gets processed.
+            if !closed {
+                i += push_utf8_char(&mut result, css, i);
+                continue;
             }
 
+            i = scan;
             let comment = &css[comment_start..i];
 
-            // Check if it's a sourcemap comment: /* # source... or /*# source...
-            // Matches regex r"/\*\s*#\s*source"
-            let is_sourcemap = {
-                let after_start = &comment[2..]; // skip /*
-                let trimmed = after_start.trim_start();
-                trimmed.starts_with('#') && trimmed[1..].trim_start().starts_with("source")
-            };
+            // Preserve ONLY sourcemap/sourceURL comments verbatim; every other comment
+            // is stripped (collapsed to its interior newlines) so no comment text — which
+            // could leak sensitive data — survives. This matches upstream Angular
+            // `ShadowCss` v21.2.7 exactly (shadow_css.ts:182-189), which tests each
+            // CLOSED comment (`_commentRe`, shadow_css.ts:1113) against:
+            //   const _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=/g;
+            // i.e. `/*`, optional whitespace, `#`, optional whitespace, then literally
+            // `sourceURL=` OR `sourceMappingURL=` (the `(Mapping)?` group is optional and
+            // the trailing `=` is REQUIRED; the match is case-sensitive). So
+            // `/* # source: secret */`, `/* #sourceURLx */`, `/* sourceURL= */` (no `#`)
+            // and `/* # sourceMap */` are all NON-matching and get stripped, while
+            // `/*#sourceURL=foo*/` and `/* # sourceMappingURL=foo */` are preserved.
+            // The `\s` here uses `is_ecmascript_whitespace` (NOT Rust `trim`), so it
+            // matches JS exactly for the divergent code points U+FEFF (JS ws, Rust not)
+            // and U+0085 (Rust ws, JS not).
+            let is_sourcemap = comment_is_sourcemap(comment);
 
             if is_sourcemap {
                 comments.push(comment.to_string());
             } else {
-                // Preserve only the newlines that were inside the comment. Angular
-                // v22 no longer appends an extra trailing newline (the old `+ '\n'`),
-                // so removing a comment doesn't insert blank lines.
-                let newline_count = comment.bytes().filter(|&b| b == b'\n').count();
+                // Replace non-hash comments with only their interior newlines. This mirrors
+                // upstream Angular `ShadowCss` (v21.2.7), which substitutes a non-sourcemap
+                // comment with `newLinesMatches?.join('') ?? ''` using `_newLinesRe = /\r?\n/g`.
+                // The comment collapses to nothing except the `\r\n`/`\n` sequences it contained,
+                // so removing a comment does not add extra blank lines while interior newlines
+                // (needed to keep sourcemap line counts stable) are preserved verbatim.
                 let mut preserved = String::new();
-                for _ in 0..newline_count {
-                    preserved.push('\n');
+                let comment_bytes = comment.as_bytes();
+                let mut j = 0;
+                while j < comment_bytes.len() {
+                    if comment_bytes[j] == b'\r'
+                        && j + 1 < comment_bytes.len()
+                        && comment_bytes[j + 1] == b'\n'
+                    {
+                        preserved.push_str("\r\n");
+                        j += 2;
+                    } else if comment_bytes[j] == b'\n' {
+                        preserved.push('\n');
+                        j += 1;
+                    } else {
+                        j += 1;
+                    }
                 }
                 comments.push(preserved);
             }
@@ -378,19 +485,53 @@ fn extract_comments(css: &str) -> (String, Vec<String>) {
 }
 
 /// Restore comments from placeholders.
+///
+/// FINDING 2: this must be a SINGLE left-to-right pass over the scoped CSS, mirroring
+/// upstream `scopedCssText.replace(_commentWithHashPlaceHolderRe, () => comments[idx++])`
+/// (shadow_css.ts:199). JavaScript `String.replace(re, replacer)` matches placeholders
+/// ONLY in the original string and never rescans replacement text. The previous OXC
+/// implementation looped `while result.find(PLACEHOLDER)`, re-searching the WHOLE result
+/// after each replacement — so if a PRESERVED (sourceURL) comment's body literally
+/// contained the `%COMMENT%` sentinel, that literal text was treated as another
+/// placeholder slot, corrupting/shifting the output. Walking the scoped string once and
+/// replacing each ORIGINAL placeholder exactly once (in order) keeps any literal
+/// `%COMMENT%` inside a restored comment literal, matching upstream exactly.
+///
+/// FINDING 3 (surplus placeholders): upstream's sentinel is the literal `%COMMENT%`
+/// (shadow_css.ts:1115), which a CSS author CAN type outside any comment (e.g. in a
+/// string or `url()`). Such a literal survives extraction (it is not a `/* */` comment)
+/// and is then matched by the global restore replace. Because the extraction step pushes
+/// exactly one `comments[]` entry per extracted comment, a surplus match has no
+/// corresponding entry: `comments[idx++]` is `undefined`, which JavaScript's
+/// `String.replace` coerces to the STRING `"undefined"`. We replicate that quirk
+/// faithfully — surplus `%COMMENT%` occurrences become the literal text `undefined`
+/// rather than being dropped. Verified against `@angular/compiler@21.2.7`
+/// `ShadowCss().shimCssText`, e.g. `div { content: "%COMMENT%"; }` ->
+/// `... content: "undefined"; ...`.
 fn restore_comments(css: &str, comments: &[String]) -> String {
-    let mut result = css.to_string();
+    let mut result = String::with_capacity(css.len());
+    let mut rest = css;
     let mut idx = 0;
 
-    while result.find(COMMENT_PLACEHOLDER).is_some() {
+    while let Some(pos) = rest.find(COMMENT_PLACEHOLDER) {
+        // Copy literal text before the placeholder verbatim.
+        result.push_str(&rest[..pos]);
+        // Substitute this placeholder with its stored comment. For a surplus placeholder
+        // (more `%COMMENT%` occurrences than extracted comments — e.g. an author-typed
+        // literal `%COMMENT%`), upstream's `comments[idx++]` is `undefined`, stringified
+        // by `String.replace` to "undefined"; emit that literal to match exactly.
         if idx < comments.len() {
-            result = result.replacen(COMMENT_PLACEHOLDER, &comments[idx], 1);
-            idx += 1;
+            result.push_str(&comments[idx]);
         } else {
-            break;
+            result.push_str("undefined");
         }
+        idx += 1;
+        // Continue AFTER the matched placeholder; never rescan the inserted comment.
+        rest = &rest[pos + COMMENT_PLACEHOLDER.len()..];
     }
 
+    // Copy any trailing text after the last placeholder.
+    result.push_str(rest);
     result
 }
 
@@ -1860,6 +2001,37 @@ fn scope_selector_list(selector_list: &str, content_attr: &str, host_attr: &str)
     scope_selector_list_with_context(selector_list, &ctx)
 }
 
+/// Length (in bytes) of a LEADING `\s*(%COMMENT%\s*)*` run at the start of `s`,
+/// mirroring capture group 1 of upstream's `_ruleRe` (shadow_css.ts:1119-1120):
+/// `(\s*(?:%COMMENT%\s*)*)`. Such a prefix is stripped off the selector and
+/// re-prepended verbatim AFTER scoping, so a leading/whole comment placeholder is
+/// never scoped. A comment placeholder that is NOT part of this leading run (e.g.
+/// embedded in `a%COMMENT%b`, or after a comma) stays in the selector and is scoped
+/// normally.
+fn leading_comment_prefix_len(s: &str) -> usize {
+    // Consume a run of ECMAScript `\s` (matching the regex `\s*`) starting at byte
+    // index `i`, returning the new byte index. Char-based so non-ASCII whitespace
+    // (e.g. U+FEFF / U+00A0, which upstream's `\s` matches) is handled correctly.
+    fn skip_ws(s: &str, mut i: usize) -> usize {
+        while let Some(ch) = s[i..].chars().next() {
+            if is_ecmascript_whitespace(ch) {
+                i += ch.len_utf8();
+            } else {
+                break;
+            }
+        }
+        i
+    }
+
+    // Leading whitespace, then zero or more (`%COMMENT%` followed by `\s*`).
+    let mut i = skip_ws(s, 0);
+    while s[i..].starts_with(COMMENT_PLACEHOLDER) {
+        i += COMMENT_PLACEHOLDER.len();
+        i = skip_ws(s, i);
+    }
+    i
+}
+
 /// Scope a selector list with a given context (allows recursive calls to share state)
 fn scope_selector_list_with_context(selector_list: &str, parent_ctx: &ScopingContext) -> String {
     // Preserve leading and trailing whitespace
@@ -1870,6 +2042,34 @@ fn scope_selector_list_with_context(selector_list: &str, parent_ctx: &ScopingCon
     }
     let trailing: &str = &selector_list[selector_list.trim_end().len()..];
 
+    // FINDING 1: strip a LEADING `\s*(%COMMENT%\s*)*` run (upstream `_ruleRe` group 1)
+    // from the selector list before scoping; re-prepend it verbatim afterwards. This
+    // keeps a leading/whole comment placeholder unscoped while letting embedded
+    // placeholders be scoped as ordinary selector text. `leading` already captured the
+    // outermost whitespace, so here we only need to consume the comment run (plus any
+    // interior whitespace between/after placeholders) from the trimmed selector.
+    //
+    // CRUCIAL: upstream performs this strip ONLY at the real CSS rule boundary
+    // (`processRules`/`_ruleRe`), feeding `_scopeSelector({ isParentSelector: true })`.
+    // The RECURSIVE calls for pseudo-function inner selectors (`:is()`/`:where()`,
+    // reached below via `scope_selector_list_with_context(inner, &child_ctx)` with
+    // `is_parent_selector == false`) do NOT get the pre-strip, so a leading comment
+    // placeholder inside `:is(/*x*/ .b)` is scoped as ordinary selector text (becomes
+    // `:is([c]   .b[c])`), NOT treated as an unscoped prefix. We therefore gate the
+    // strip to the parent (top-level rule) context only. Verified vs
+    // @angular/compiler@21.2.7.
+    let (comment_prefix, trimmed): (&str, &str) = if parent_ctx.is_parent_selector {
+        let comment_prefix_len = leading_comment_prefix_len(trimmed);
+        if comment_prefix_len == trimmed.len() {
+            // Selector was nothing but a leading comment placeholder run (a pure-comment
+            // "rule"): emit it unchanged, exactly like upstream (empty `m[2]`).
+            return selector_list.to_string();
+        }
+        (&trimmed[..comment_prefix_len], &trimmed[comment_prefix_len..])
+    } else {
+        ("", trimmed)
+    };
+
     // Create SafeSelector to escape problematic patterns
     // (attribute selectors, escaped characters, :nth-*() expressions)
     let safe_selector = SafeSelector::new(trimmed);
@@ -1891,7 +2091,7 @@ fn scope_selector_list_with_context(selector_list: &str, parent_ctx: &ScopingCon
     // Restore escaped patterns
     let restored = safe_selector.restore(&scoped_result);
 
-    format!("{}{}{}", leading, restored, trailing)
+    format!("{}{}{}{}", leading, comment_prefix, restored, trailing)
 }
 
 /// Split a string by top-level commas (not inside parentheses).
@@ -2243,10 +2443,16 @@ fn scope_simple_selector(selector: &str, content_attr: &str) -> String {
         return String::new();
     }
 
-    // Don't scope comment placeholders
-    if selector.contains(COMMENT_PLACEHOLDER) {
-        return selector.to_string();
-    }
+    // NOTE (FINDING 1): there is intentionally NO `contains(COMMENT_PLACEHOLDER)`
+    // bypass here. Upstream `ShadowCss` never special-cases the comment placeholder
+    // inside `_scopeSelector`/`_applySelectorScope` (shadow_css.ts:735-857). A
+    // comment placeholder embedded in a selector part is ordinary selector text and
+    // must receive the content attribute, e.g. `a%COMMENT%b` -> `a%COMMENT%b[c]`.
+    // The ONLY comment placeholders upstream excludes from scoping are a LEADING
+    // run, which `_ruleRe` group 1 (shadow_css.ts:1119-1120) strips off the selector
+    // before scoping; that stripping is mirrored in `scope_selector_list_with_context`.
+    // A previous broad `if selector.contains(COMMENT_PLACEHOLDER) { return; }` bypass
+    // here caused an emulated-encapsulation LEAK (rule emitted unscoped).
 
     // Already has the content attribute
     let attr = format!("[{}]", content_attr);
@@ -3233,6 +3439,125 @@ mod tests {
         assert!(result.contains(".button[contenta]"), "Got: {}", result);
     }
 
+    // ---- FINDING 1: ShadowCss must not leak rules whose selector contains an
+    // embedded comment placeholder. Upstream `_ruleRe` (shadow_css.ts:1119) strips a
+    // LEADING `\s*(%COMMENT%\s*)*` prefix off the selector and scopes the rest
+    // normally; it never special-cases `%COMMENT%` inside `_scopeSelector`. An
+    // embedded comment placeholder is therefore part of an ordinary selector part
+    // and gets the content attribute. Verified against @angular/compiler@21.2.7
+    // `new ShadowCss().shimCssText(css, 'contenta', 'hosta')`.
+    //
+    // NOTE: OXC normalizes descendant combinators to a single space (pre-existing
+    // `normalize_combinator` behavior; upstream emits three spaces). These tests
+    // therefore assert the LEAK is closed (content attribute present on every
+    // comment-bearing part) rather than upstream's exact inter-part whitespace.
+
+    #[test]
+    fn test_leading_comment_inside_pseudo_function_is_scoped_not_stripped() {
+        // FINDING 1 (recursive path): the leading-comment prefix strip must apply ONLY at
+        // the top-level rule boundary, NOT inside the recursive `:is()`/`:where()` inner
+        // selector scoping. Upstream's `_ruleRe` group-1 strip happens in `processRules`
+        // and feeds `_scopeSelector({isParentSelector:true})`; the recursive pseudo calls
+        // use `isParentSelector:false`, so a leading comment placeholder inside `:is(...)`
+        // is scoped as ordinary selector text. Verified vs @angular/compiler@21.2.7:
+        //   ":is(/*x*/ .b)"  -> ":is([contenta]   .b[contenta])"
+        //   ":where(/*# sourceURL=x */ .b)" ->
+        //                       ":where(/*# sourceURL=x */[contenta]   .b[contenta])"
+        // (OXC single-spaces descendant combinators; the load-bearing fact is that the
+        // comment part receives `[contenta]` rather than being stripped as a prefix.)
+        let out = shim_css_text(":is(/*x*/ .b) {color:red}", "contenta", "hosta");
+        assert_eq!(out, ":is([contenta] .b[contenta]) {color:red}", "Got: {out}");
+
+        // Hash comment is kept AND the comment part is scoped (not stripped).
+        let out2 = shim_css_text(":where(/*# sourceURL=x */ .b) {color:red}", "contenta", "hosta");
+        assert_eq!(
+            out2, ":where(/*# sourceURL=x */[contenta] .b[contenta]) {color:red}",
+            "Got: {out2}"
+        );
+    }
+
+    #[test]
+    fn test_embedded_comment_single_part_is_scoped() {
+        // Upstream: "a/*x*/b {color:red}" -> "ab[contenta] {color:red}"
+        let out = shim_css_text("a/*x*/b {color:red}", "contenta", "hosta");
+        assert_eq!(out, "ab[contenta] {color:red}", "Got: {out}");
+    }
+
+    #[test]
+    fn test_embedded_comment_class_part_is_scoped() {
+        // Upstream: ".foo/*x*/.bar {color:red}" -> ".foo.bar[contenta] {color:red}"
+        let out = shim_css_text(".foo/*x*/.bar {color:red}", "contenta", "hosta");
+        assert_eq!(out, ".foo.bar[contenta] {color:red}", "Got: {out}");
+    }
+
+    #[test]
+    fn test_leading_comment_then_embedded_comment_is_scoped() {
+        // Upstream: "/*# sourceURL=h */.a/*# sourceURL=h2 */ {color:red}"
+        //        -> "/*# sourceURL=h */.a/*# sourceURL=h2 */[contenta] {color:red}"
+        let out = shim_css_text(
+            "/*# sourceURL=h */.a/*# sourceURL=h2 */ {color:red}",
+            "contenta",
+            "hosta",
+        );
+        assert_eq!(
+            out, "/*# sourceURL=h */.a/*# sourceURL=h2 */[contenta] {color:red}",
+            "Got: {out}"
+        );
+    }
+
+    #[test]
+    fn test_leading_comment_placeholder_is_not_scoped() {
+        // Upstream: "/*x*/ .a {color:red}" -> " .a[contenta] {color:red}"
+        // The leading comment prefix is stripped and re-prepended verbatim; only
+        // `.a` is scoped.
+        let out = shim_css_text("/*x*/ .a {color:red}", "contenta", "hosta");
+        assert_eq!(out, " .a[contenta] {color:red}", "Got: {out}");
+    }
+
+    #[test]
+    fn test_leading_hash_comment_is_kept_and_selector_scoped() {
+        // Upstream: "/*# sourceURL=foo.css */ .a {color:red}"
+        //        -> "/*# sourceURL=foo.css */ .a[contenta] {color:red}"
+        let out = shim_css_text("/*# sourceURL=foo.css */ .a {color:red}", "contenta", "hosta");
+        assert_eq!(out, "/*# sourceURL=foo.css */ .a[contenta] {color:red}", "Got: {out}");
+    }
+
+    #[test]
+    fn test_comment_after_comma_is_scoped_not_treated_as_leading() {
+        // Upstream strips a leading prefix only at the very start of the whole
+        // selector list. A comment after a comma is part of the 2nd selector and
+        // every part of it is scoped. (OXC single-space normalization.)
+        // Upstream: ".a[contenta], [contenta]   .b[contenta] {color:red}" (the non-hash
+        // comment `/*x*/` restores to empty). OXC matches except for descendant
+        // combinator whitespace (single space vs upstream's three — pre-existing).
+        let out = shim_css_text(".a, /*x*/ .b {color:red}", "contenta", "hosta");
+        // Leak proof: both selectors and the comment-bearing part are scoped.
+        assert!(out.starts_with(".a[contenta], "), "Got: {out}");
+        assert!(out.contains(".b[contenta]"), "Got: {out}");
+        // The comment-only middle part must also receive the attribute (no leak).
+        // The non-hash comment is stripped to empty, leaving a bare `[contenta]`.
+        assert!(out.contains("[contenta] .b[contenta]"), "Got: {out}");
+    }
+
+    #[test]
+    fn test_middle_comment_part_is_scoped() {
+        // Upstream scopes the empty-comment middle part: `%COMMENT%` -> `[contenta]`.
+        // Upstream: "div[contenta]   [contenta]   span[contenta] {color:red}".
+        // OXC single-spaces descendant combinators (pre-existing) ->
+        // "div[contenta] [contenta] span[contenta] {color:red}".
+        let out = shim_css_text("div /*x*/ span {color:red}", "contenta", "hosta");
+        assert_eq!(out, "div[contenta] [contenta] span[contenta] {color:red}", "Got: {out}");
+    }
+
+    #[test]
+    fn test_trailing_comment_part_is_scoped() {
+        // Upstream: "a b/*# sourceURL=h */ {color:red}"
+        // The trailing comment is part of the 2nd selector part and is scoped.
+        let out = shim_css_text("a b/*# sourceURL=h */ {color:red}", "contenta", "hosta");
+        assert!(out.contains("a[contenta]"), "Got: {out}");
+        assert!(out.contains("b/*# sourceURL=h */[contenta]"), "Got: {out}");
+    }
+
     #[test]
     fn test_multiple_selectors() {
         let result = shim_css_text("h1, h2, h3 { font-weight: bold; }", "contenta", "");
@@ -3530,4 +3855,48 @@ mod tests {
             result
         );
     }
+
+    // ---- Finding 3: surplus literal `%COMMENT%` placeholders restore to "undefined" ----
+    //
+    // Upstream's sentinel is the literal `%COMMENT%` (shadow_css.ts:1115). A CSS author
+    // can type it outside any comment; it survives extraction and is matched by the global
+    // restore replace `() => comments[idx++]`. With no corresponding extracted comment,
+    // `comments[idx]` is `undefined`, stringified to "undefined" by `String.replace`.
+    //
+    // Oracle (`@angular/compiler@21.2.7` `ShadowCss().shimCssText`):
+    //   div { content: "%COMMENT%"; }                  -> content: "undefined";
+    //   /*# sourceURL=foo */ div { content:"%COMMENT%"}-> comment kept, surplus->undefined
+    //   div::before { content: "%COMMENT%%COMMENT%"; } -> content: "undefinedundefined";
+    //   div { background: url(%COMMENT%); }            -> url(undefined)
+    #[test]
+    fn test_surplus_comment_placeholder_becomes_undefined() {
+        let out = shim_css_text(r#"div { content: "%COMMENT%"; }"#, "a-host", "a-host");
+        assert!(out.contains(r#"content: "undefined";"#), "Got: {out}");
+    }
+
+    #[test]
+    fn test_surplus_comment_placeholder_two_occurrences() {
+        let out =
+            shim_css_text(r#"div::before { content: "%COMMENT%%COMMENT%"; }"#, "a-host", "a-host");
+        assert!(out.contains(r#"content: "undefinedundefined";"#), "Got: {out}");
+    }
+
+    #[test]
+    fn test_surplus_comment_placeholder_in_url() {
+        let out = shim_css_text("div { background: url(%COMMENT%); }", "a-host", "a-host");
+        assert!(out.contains("url(undefined)"), "Got: {out}");
+    }
+
+    #[test]
+    fn test_real_comment_kept_with_surplus_literal() {
+        // A real hash comment is restored at its position; the extra author-typed literal
+        // is surplus and becomes "undefined".
+        let out = shim_css_text(
+            r#"/*# sourceURL=foo */ div { content: "%COMMENT%"; }"#,
+            "a-host",
+            "a-host",
+        );
+        assert!(out.contains("/*# sourceURL=foo */"), "comment must be kept. Got: {out}");
+        assert!(out.contains(r#"content: "undefined";"#), "Got: {out}");
+    }
 }
diff --git a/crates/oxc_angular_compiler/src/transform/html_to_r3.rs b/crates/oxc_angular_compiler/src/transform/html_to_r3.rs
index f4a139475..5b9d8e77f 100644
--- a/crates/oxc_angular_compiler/src/transform/html_to_r3.rs
+++ b/crates/oxc_angular_compiler/src/transform/html_to_r3.rs
@@ -29,7 +29,8 @@ use crate::i18n::parser::I18nMessageFactory;
 use crate::i18n::placeholder::PlaceholderRegistry;
 use crate::parser::expression::{BindingParser, find_comment_start};
 use crate::parser::html::decode_entities_in_string;
-use crate::schema::get_security_context;
+use crate::parser::html::split_ns_name;
+use crate::schema::{get_security_context, is_trusted_types_sink};
 use crate::transform::control_flow::{parse_conditional_params, parse_defer_triggers};
 use crate::util::ParseError;
 
@@ -308,47 +309,189 @@ impl<'a> HtmlToR3Transform<'a> {
     fn visit_element(&mut self, element: &HtmlElement<'a>) -> Option<R3Node<'a>> {
         let raw_name = element.name.as_str();
 
-        // Check for special elements. `<script>`/`<style>` are only treated
-        // specially in the HTML namespace: Angular classifies them by the
-        // lowercased element name, so a namespaced SVG `<style>` (`:svg:style`)
-        // is a normal element, not a stylesheet to extract (v22 conformance).
-        let in_html_namespace = self.current_namespace() == ElementNamespace::Html;
-        if in_html_namespace && raw_name == "script" {
-            return None;
-        }
-        if in_html_namespace && raw_name == "style" {
-            // Extract style content
-            if let Some(content) = self.get_text_content(element) {
-                self.styles.push(content);
-            }
-            return None;
-        }
-        if raw_name == "link" {
-            // Collect stylesheet URLs
-            if let Some(href) = self.get_stylesheet_href(element) {
-                self.style_urls.push(href);
+        // Determine whether this element node is actually a selectorless COMPONENT
+        // BEFORE any preparser special-element handling. Upstream splits the two
+        // paths:
+        //   * `visitElement`   calls `preparseElement` (script/style/link strip)
+        //   * `visitComponent` does NOT call `preparseElement` at all — it only
+        //     validates the resolved HOST tag (`component.tagName`) against
+        //     `UNSUPPORTED_SELECTORLESS_TAGS` later.
+        // So a bare selectorless component whose CLASS name collides with a special
+        // HTML tag (e.g. `<Script></Script>`, `tagName === null`) must be kept as
+        // an R3Component, not dropped as if it were a real `<script>` element.
+        // The parser-produced `is_component` marker is the authoritative discriminator
+        // (set true ONLY when the lexer tokenized a `ComponentOpenStart`, which
+        // requires selectorless mode). It correctly distinguishes a bare component
+        // `<MyCmp>` from an uppercase NORMAL element like `<IFRAME>` / `<OBJECT>`
+        // (identical at this node otherwise), which a leading-character casing
+        // heuristic would conflate. In the default (selectorless-off) pipeline the
+        // real compiler uses, no component is ever produced, so an uppercase tag
+        // stays a normal element and its security-context / i18n trusted-types
+        // lookups route through its own name (lowercased internally) — e.g.
+        // `<IFRAME [src]>` -> `iframe|src` -> RESOURCE_URL, matching upstream
+        // v21.2.7 `parseTemplate(html, url, {})`.
+        let is_component = element.is_component;
+
+        // Classify special HTML elements the way upstream `template_preparser.ts`
+        // does — Element path ONLY (`visitElement` → `preparseElement`). Skipped
+        // entirely for selectorless components (`visitComponent` never preparses).
+        // Upstream computes `nodeName = ast.name.toLowerCase()` — the FULL
+        // (lower-cased) node name *including* any namespace prefix — and then
+        // compares it against:
+        //   - SCRIPT_ELEMENT = 'script'  (singular string, NOT a set)
+        //   - STYLE_ELEMENT  = 'style'
+        //   - LINK_ELEMENT   = 'link'
+        // (v21.2.7 template_preparser.ts:18,45,49-53). Because the comparison uses
+        // the FULL node name, only the un-namespaced `<script>` / `<style>` /
+        // `<link>` are classified as SCRIPT / STYLE / STYLESHEET and dropped; an
+        // explicitly namespaced `<svg:script>` (stored `:svg:script`) does NOT equal
+        // 'script', so it stays `PreparsedElementType.OTHER` and is KEPT as an
+        // element. This is the real XSS sink for an SVGScriptElement, whose
+        // `href`/`xlink:href` is sanitized as a RESOURCE_URL (see
+        // dom_security_schema). (NOTE: angular/angular MAIN later changed
+        // SCRIPT_ELEMENT to a Set including ':svg:script' via commit 90494cd909,
+        // which DOES strip it — but that is POST-v21.2.7 and is not our pinned
+        // version.) All matches are case-insensitive.
+        let lower_name = raw_name.to_ascii_lowercase();
+        // Namespace-stripped local name with original case, used for the structural
+        // element checks below (ng-content / ng-template / ng-container). Upstream
+        // detects these via `isNgContent`/`isNgTemplate`/`isNgContainer`, which all
+        // compare `splitNsName(name)[1]` — i.e. they ignore the namespace prefix, so a
+        // `:svg:ng-content` produced by parent-namespace inheritance is still treated
+        // as projection ("regardless the namespace"). This is distinct from the
+        // STYLE/LINK checks above, which deliberately compare the FULL node name.
+        let (_, raw_local_name) = split_ns_name(raw_name);
+
+        // Preparser special-element handling is Element-only. Selectorless
+        // components keep going; unsupported HOST tags are rejected later via
+        // UNSUPPORTED_SELECTORLESS_TAGS on the resolved host tag (not the class
+        // name). Upstream compares the FULL lower-cased node name against
+        // SCRIPT_ELEMENT='script', so plain `<script>` is dropped but a
+        // namespaced `:svg:script` is kept (v21.2.7 template_preparser.ts:45,51).
+        if !is_component {
+            if lower_name == "script" {
+                return None;
             }
-            // Filter out <link rel="stylesheet"> inside ngNonBindable elements
-            if self.non_bindable_depth > 0 && self.is_stylesheet_link(element) {
+            if lower_name == "style" {
+                // Extract style content
+                if let Some(content) = self.get_text_content(element) {
+                    self.styles.push(content);
+                }
                 return None;
             }
+            if lower_name == "link" {
+                // Collect stylesheet URLs
+                if let Some(href) = self.get_stylesheet_href(element) {
+                    self.style_urls.push(href);
+                }
+                // Filter out <link rel="stylesheet"> inside ngNonBindable elements
+                if self.non_bindable_depth > 0 && self.is_stylesheet_link(element) {
+                    return None;
+                }
+            }
         }
 
-        // Parse attributes
-        let (attributes, inputs, outputs, references, variables, template_attr) =
-            self.parse_attributes(&element.attrs, raw_name, raw_name == "ng-template");
+        // Resolve the host tag name (upstream `component.tagName`) up-front, BEFORE
+        // attribute categorization, so the security-context and i18n trusted-types
+        // sink lookups use the resolved HOST TAG (e.g. `iframe` / `:svg:image`) rather
+        // than the component class name. This mirrors v21.2.7, where:
+        //   * the security context is computed via
+        //     `categorizePropertyAttributes(component.tagName, ...)` ->
+        //     `createBoundElementProperty(elementName=component.tagName, ...)`
+        //     (render3/r3_template_transform.ts:411-415, binding_parser.ts:594-615), and
+        //   * the i18n trusted-types guard uses
+        //     `node instanceof html.Component ? node.tagName : node.name`
+        //     (render3/view/i18n/meta.ts:205-208).
+        // The formula matches upstream `_getComponentTagName` exactly (null when no
+        // prefix and no tag part; the bare tag when no prefix; else
+        // `mergeNsAndName(prefix, tag || 'ng-component')` i.e. `:prefix:tag`).
+        let component_tag_name: Option<Ident<'a>> = if is_component {
+            match (&element.component_prefix, &element.component_tag_name) {
+                (None, None) => None,
+                (None, Some(tag)) => Some(*tag),
+                (Some(prefix), None) => {
+                    Some(Ident::from_in(&format!(":{prefix}:ng-component"), self.allocator))
+                }
+                (Some(prefix), Some(tag)) => {
+                    Some(Ident::from_in(&format!(":{prefix}:{tag}"), self.allocator))
+                }
+            }
+        } else {
+            None
+        };
+
+        // Element name used for the bound-attribute SECURITY-CONTEXT lookup inside
+        // `parse_attributes` (`get_security_context`, which itself ns-strips internally
+        // — faithful, because upstream routes the security context through `CssSelector`
+        // which strips the namespace).
+        //   * Normal element  -> the element's own name (`raw_name`), unchanged.
+        //   * Selectorless component with a host tag -> the resolved host tag
+        //     (`component.tagName`), so `<MyCmp:iframe [src]>` sanitizes as
+        //     `iframe|src` (RESOURCE_URL).
+        //   * Bare selectorless component (`<MyCmp>`, tagName null) -> empty string,
+        //     faithfully reproducing upstream's null-tagName behavior:
+        //     `calcPossibleSecurityContexts` with a null selector yields `NONE` for
+        //     element-specific props (the empty element name never matches an
+        //     `element|prop` key, only `*|prop` wildcards). This also fixes a latent
+        //     divergence where a class name that happens to collide with a real element
+        //     name (e.g. `<Object [data]>`) would otherwise be looked up as that element.
+        let security_element_name: &str = if is_component {
+            component_tag_name.as_ref().map_or("", Ident::as_str)
+        } else {
+            raw_name
+        };
+
+        // Element name used SEPARATELY for the i18n trusted-types sink check inside
+        // `parse_attributes`. This path does NOT ns-strip and is faithful to v21.2.7
+        // `render3/view/i18n/meta.ts` (~210-214):
+        //   isTrustedType = node instanceof html.Component
+        //     ? (node.tagName === null ? false : isTrustedTypesSink(node.tagName, name))
+        //     : isTrustedTypesSink(node.name, name);
+        // and `schema/trusted_types_sinks.ts` `isTrustedTypesSink`, which ONLY lowercases
+        // the tag (no namespace strip) before testing `${tag}|${name}` / `*|${name}`.
+        //   * Normal element  -> the FULL element name `node.name` un-stripped, so
+        //     `<svg:iframe i18n-src>` looks up `:svg:iframe|src` (NOT a sink) -> ALLOWED.
+        //   * Component with a host tag -> the resolved `node.tagName` un-stripped, so
+        //     `<MyCmp:iframe i18n-src>` -> `iframe|src` (sink) -> BLOCKED, but
+        //     `<svg><MyCmp:iframe i18n-src>` -> `:svg:iframe|src` (NOT a sink) -> ALLOWED.
+        //   * Bare component (tagName null) -> `None`, so the sink check is SKIPPED
+        //     entirely (short-circuit to false). Passing an empty string here would
+        //     wrongly match the `*|innerhtml` / `*|outerhtml` wildcards, so we model it
+        //     as `Option::None` instead. Verified against @angular/compiler@21.2.7
+        //     `parseTemplate(.., {enableSelectorless:true})`.
+        let i18n_sink_element_name: Option<&str> = if is_component {
+            component_tag_name.as_ref().map(Ident::as_str)
+        } else {
+            Some(raw_name)
+        };
+
+        // Parse attributes. The `is_template` flag mirrors upstream
+        // `isTemplateElement = isNgTemplate(element.name)`, which strips the namespace,
+        // so `let-` handling works for a namespace-inherited `:svg:ng-template` too.
+        let (attributes, inputs, outputs, references, variables, template_attr) = self
+            .parse_attributes(
+                &element.attrs,
+                security_element_name,
+                i18n_sink_element_name,
+                raw_local_name == "ng-template",
+            );
 
         // Resolve namespace for this element and its children.
-        // Note: foreignObject is an SVG element but its children use HTML namespace.
-        // We need to distinguish between the element's own namespace (for naming) and
-        // the namespace for its children (pushed to stack).
+        // Note: foreignObject is an SVG element but its children use HTML namespace
+        // (upstream html_tags.ts: implicitNamespacePrefix:'svg' +
+        // preventNamespaceInheritance:true). We distinguish the element's own
+        // namespace (for naming) from the namespace its children inherit
+        // (pushed onto the stack). `resolve_namespace` returns the CHILD namespace,
+        // which for foreignObject is HTML.
         let parent_namespace = self.current_namespace();
         let child_namespace = self.resolve_namespace(raw_name, parent_namespace);
 
-        // For foreignObject in SVG context: the element itself is SVG, only children are HTML.
-        // For all other elements: element namespace equals child namespace.
+        // For foreignObject in an SVG context the element itself stays SVG (it is
+        // stored `:svg:foreignObject`), only its children reset to HTML. Detect it
+        // by LOCAL name so the prefixed `:svg:foreignObject` form also matches.
+        // For all other elements the element namespace equals the child namespace.
         let element_namespace = if parent_namespace == ElementNamespace::Svg
-            && raw_name.eq_ignore_ascii_case("foreignObject")
+            && split_ns_name(raw_name).1.eq_ignore_ascii_case("foreignObject")
         {
             ElementNamespace::Svg
         } else {
@@ -469,7 +612,7 @@ impl<'a> HtmlToR3Transform<'a> {
         // Check for ng-content
         // Reference: r3_template_transform.ts lines 191-204
         // Children are passed directly without extra whitespace filtering
-        if raw_name == "ng-content" {
+        if raw_local_name == "ng-content" {
             let selector = self.get_ng_content_selector(element);
             self.ng_content_selectors.push(selector);
 
@@ -520,7 +663,7 @@ impl<'a> HtmlToR3Transform<'a> {
         }
 
         // Check for ng-template
-        if raw_name == "ng-template" {
+        if raw_local_name == "ng-template" {
             let name = self.qualify_element_name(element.name, element_namespace);
             let template = R3Template {
                 tag_name: Some(name),
@@ -550,7 +693,7 @@ impl<'a> HtmlToR3Transform<'a> {
 
         // Validate ng-container attribute bindings
         // Reference: r3_template_transform.ts lines 238-247
-        if raw_name == "ng-container" {
+        if raw_local_name == "ng-container" {
             use crate::ast::expression::BindingType;
             for input in &inputs {
                 if input.binding_type == BindingType::Attribute {
@@ -564,39 +707,43 @@ impl<'a> HtmlToR3Transform<'a> {
 
         let name = self.qualify_element_name(element.name, element_namespace);
 
-        // Check if this is a component (uppercase first letter or underscore)
-        let first_char = raw_name.chars().next().unwrap_or('a');
-        let is_component = first_char.is_ascii_uppercase() || first_char == '_';
-
         let mut result = if is_component {
-            // Validate selectorless component - check for unsupported tags
-            let tag_name_lower = raw_name.to_ascii_lowercase();
-            if UNSUPPORTED_SELECTORLESS_TAGS.contains(&tag_name_lower.as_str()) {
-                self.report_error(
-                    &format!("Tag name \"{raw_name}\" cannot be used as a component tag"),
-                    element.start_span,
-                );
-                return None;
+            // The resolved host tag (`component.tagName`) was already computed up-front
+            // (`component_tag_name`) so the security-context and i18n trusted-types sink
+            // lookups in `parse_attributes` could consume it. Reuse that exact value
+            // here for the unsupported-tag check, `full_name` composition, and the R3
+            // node, so the security path and the AST stay in lock-step. It matches
+            // upstream `_getComponentTagName` (ml_parser/parser.ts:946-961): null when
+            // no prefix and no tag part; the bare tag when no prefix;
+            // `mergeNsAndName(prefix, tag||'ng-component')` (`:prefix:tag`) otherwise.
+            let tag_name = component_tag_name;
+
+            // Validate selectorless component — reject unsupported HOST tags.
+            // Upstream `HtmlAstToIvyAst.visitComponent`
+            // (render3/r3_template_transform.ts:378-384) tests `component.tagName`
+            // (the RESOLVED tag name, NOT the component class name) against
+            // UNSUPPORTED_SELECTORLESS_TAGS={link,style,script,ng-template,
+            // ng-container,ng-content} and does NOT strip the namespace first. So a
+            // bare `script`/`style`/`link` (no prefix) is rejected, but a namespaced
+            // `:svg:script` (explicit OR parent-inherited) is NOT a member and is
+            // accepted; a `null` tagName (bare `<MyComp>` / class-only `<Script>`) is
+            // never rejected. The error message quotes the resolved tag name.
+            // NOTE: the membership test is CASE-SENSITIVE (upstream `Set.has` on the raw
+            // `component.tagName`, set members are lowercase), so `<MyComp:SCRIPT>`
+            // (tagName "SCRIPT") is NOT a member and is accepted — matching upstream.
+            if let Some(tag) = &tag_name {
+                if UNSUPPORTED_SELECTORLESS_TAGS.contains(&tag.as_str()) {
+                    self.report_error(
+                        &format!("Tag name \"{tag}\" cannot be used as a component tag"),
+                        element.start_span,
+                    );
+                    return None;
+                }
             }
 
             // Validate selectorless references
             self.validate_selectorless_references(&references);
 
-            // Compute tag_name from component_prefix and component_tag_name
-            // Format: ":prefix:tag_name" (e.g., ":svg:rect") or just "tag_name"
-            let tag_name = match (&element.component_prefix, &element.component_tag_name) {
-                (None, None) => None,
-                (None, Some(tag)) => Some(*tag),
-                (Some(prefix), None) => {
-                    // Has prefix but no tag name - use "ng-component" as default
-                    Some(Ident::from_in(&format!(":{prefix}:ng-component"), &self.allocator))
-                }
-                (Some(prefix), Some(tag)) => {
-                    // Both prefix and tag name: ":prefix:tag_name"
-                    Some(Ident::from_in(&format!(":{prefix}:{tag}"), &self.allocator))
-                }
-            };
-
             // Compute full_name: "ComponentName:prefix:tag_name" or "ComponentName:tag_name"
             let full_name = match &tag_name {
                 Some(tag) if tag.starts_with(':') => {
@@ -658,9 +805,19 @@ impl<'a> HtmlToR3Transform<'a> {
 
     /// Visits an HTML component (selectorless component AST node).
     fn visit_html_component(&mut self, component: &HtmlComponent<'a>) -> Option<R3Node<'a>> {
+        // i18n trusted-types sink name: the resolved host `tag_name` (un-stripped,
+        // `node.tagName`), or `None` for a bare `<MyComp>` (tagName null -> skip the
+        // sink check). See the FAITHFULNESS NOTE in `parse_attributes`; this mirrors
+        // v21.2.7 `render3/view/i18n/meta.ts` (~210-214).
+        let i18n_sink_element_name: Option<&str> = component.tag_name.as_ref().map(Ident::as_str);
         // Parse attributes
-        let (attributes, inputs, outputs, references, _variables, template_attr) =
-            self.parse_attributes(&component.attrs, component.full_name.as_str(), false);
+        let (attributes, inputs, outputs, references, _variables, template_attr) = self
+            .parse_attributes(
+                &component.attrs,
+                component.full_name.as_str(),
+                i18n_sink_element_name,
+                false,
+            );
 
         // Resolve namespace for this component and its children.
         let parent_namespace = self.current_namespace();
@@ -745,7 +902,25 @@ impl<'a> HtmlToR3Transform<'a> {
         self.namespace_stack.last().copied().unwrap_or(ElementNamespace::Html)
     }
 
+    /// Resolves the namespace that an element's *children* inherit (the value
+    /// pushed onto `namespace_stack`). The element's own naming namespace is
+    /// computed separately in `visit_element` (see `element_namespace`).
+    ///
+    /// Mirrors upstream `html_tags.ts`: `foreignObject` is declared with
+    /// `implicitNamespacePrefix:'svg'` (the element itself is SVG) AND
+    /// `preventNamespaceInheritance:true` (its children do NOT inherit svg and
+    /// reset to HTML — v21.2.7 html_tags.ts:132-142). foreignObject is detected
+    /// by its LOCAL name so that BOTH `<foreignObject>` and the prefix-inherited
+    /// `:svg:foreignObject` (stored by the parser's implicit-prefix rule) reset
+    /// their children — this check runs before the explicit-prefix branch so the
+    /// `:svg:` prefix does not pre-empt the reset.
     fn resolve_namespace(&self, raw_name: &str, parent: ElementNamespace) -> ElementNamespace {
+        // foreignObject's children reset to HTML regardless of the element's own
+        // (svg) prefix. Detect by local name so `:svg:foreignObject` also matches.
+        if split_ns_name(raw_name).1.eq_ignore_ascii_case("foreignObject") {
+            return ElementNamespace::Html;
+        }
+
         if let Some(explicit) = Self::namespace_from_prefixed_name(raw_name) {
             return explicit;
         }
@@ -758,13 +933,7 @@ impl<'a> HtmlToR3Transform<'a> {
         }
 
         match parent {
-            ElementNamespace::Svg => {
-                if raw_name.eq_ignore_ascii_case("foreignObject") {
-                    ElementNamespace::Html
-                } else {
-                    ElementNamespace::Svg
-                }
-            }
+            ElementNamespace::Svg => ElementNamespace::Svg,
             ElementNamespace::Math => ElementNamespace::Math,
             ElementNamespace::Html => ElementNamespace::Html,
         }
@@ -1784,8 +1953,8 @@ impl<'a> HtmlToR3Transform<'a> {
                 )))
             }
             BlockType::Switch => self.visit_switch_block(block),
-            BlockType::Case | BlockType::Default => {
-                // Standalone @case/@default outside @switch - emit error and create UnknownBlock
+            BlockType::Case | BlockType::Default | BlockType::DefaultNever => {
+                // Standalone @case/@default/@default never outside @switch - emit error and create UnknownBlock
                 // Reference: r3_template_transform.ts:518 - falls through to "Unrecognized block"
                 self.report_error(&format!("Unrecognized block @{}.", block.name), block.span);
                 Some(R3Node::UnknownBlock(Box::new_in(
@@ -2367,7 +2536,7 @@ impl<'a> HtmlToR3Transform<'a> {
     /// Consecutive cases without bodies are grouped together into a single `SwitchBlockCaseGroup`.
     fn visit_switch_block(&mut self, block: &HtmlBlock<'a>) -> Option<R3Node<'a>> {
         use crate::ast::html::{BlockType, HtmlNode};
-        use crate::ast::r3::{R3SwitchBlockCase, R3SwitchBlockCaseGroup, R3SwitchExhaustiveCheck};
+        use crate::ast::r3::{R3SwitchBlockCase, R3SwitchBlockCaseGroup};
 
         // Validation: @switch must have exactly one parameter.
         // Match Angular's createSwitchBlock: always parse the first parameter when present
@@ -2389,7 +2558,8 @@ impl<'a> HtmlToR3Transform<'a> {
         let mut collected_cases: std::vec::Vec<R3SwitchBlockCase<'a>> = std::vec::Vec::new();
         let mut first_case_start: Option<Span> = None;
         let mut has_default = false;
-        let mut exhaustive_check: Option<R3SwitchExhaustiveCheck<'a>> = None;
+        // Angular v21.2.7 exhaustive-switch feature: tracks an `@default never;` marker.
+        let mut exhaustive_check: Option<crate::ast::r3::R3SwitchExhaustiveCheck> = None;
 
         for child in &block.children {
             // Skip comments and whitespace-only text nodes (same as Angular)
@@ -2410,40 +2580,10 @@ impl<'a> HtmlToR3Transform<'a> {
                 continue;
             };
 
-            // v22: `@default never;` is an exhaustive check, not a case. Its block
-            // name is the literal "default never". It carries an optional expression
-            // (`@default never(expr);`), no body, and produces no runtime output.
-            if child_block.name.as_str() == "default never" {
-                let check_expression = if child_block.parameters.is_empty() {
-                    None
-                } else {
-                    let expr_str = child_block.parameters[0].expression.as_str();
-                    Some(
-                        self.binding_parser
-                            .parse_binding(expr_str, child_block.parameters[0].span)
-                            .ast,
-                    )
-                };
-                if exhaustive_check.is_some() {
-                    self.report_error(
-                        "@default block with \"never\" parameter must be the last case in a switch",
-                        child_block.span,
-                    );
-                } else {
-                    exhaustive_check = Some(R3SwitchExhaustiveCheck {
-                        expression: check_expression,
-                        source_span: child_block.span,
-                        start_source_span: child_block.start_span,
-                        end_source_span: child_block.end_span,
-                        name_span: child_block.name_span,
-                    });
-                }
-                continue;
-            }
-
-            // Validate: only @case and @default are allowed inside @switch
+            // Validate: only @case, @default and `@default never;` are allowed inside @switch
             if child_block.block_type != BlockType::Case
                 && child_block.block_type != BlockType::Default
+                && child_block.block_type != BlockType::DefaultNever
             {
                 self.report_error(
                     "@switch block can only contain @case and @default blocks",
@@ -2457,6 +2597,64 @@ impl<'a> HtmlToR3Transform<'a> {
                 continue;
             }
 
+            // Angular v21.2.7 exhaustive-switch feature: `@default never;` becomes a
+            // `SwitchExhaustiveCheck` node stored on the switch block (not a case group).
+            // Reference: r3_control_flow.ts createSwitchBlock + validateSwitchBlock.
+            if child_block.block_type == BlockType::DefaultNever {
+                // Validation (validateSwitchBlock): `default never` counts as a @default.
+                if has_default {
+                    self.report_error(
+                        "@switch block can only have one @default block",
+                        child_block.start_span,
+                    );
+                }
+                has_default = true;
+
+                // Must be the last case in the switch.
+                if exhaustive_check.is_some() {
+                    self.report_error(
+                        "@default block with \"never\" parameter must be the last case in a switch",
+                        child_block.span,
+                    );
+                }
+
+                // Cannot have a body (no children and a zero-length end span).
+                let has_body = !child_block.children.is_empty()
+                    || child_block.end_span.is_some_and(|end_span| end_span.start != end_span.end);
+                if has_body {
+                    self.report_error(
+                        "@default block with \"never\" parameter cannot have a body",
+                        child_block.span,
+                    );
+                }
+
+                // A fallthrough @case (no body) cannot be followed by `@default never;`.
+                if !collected_cases.is_empty() {
+                    self.report_error(
+                        "A @case block with no body cannot be followed by a @default block with \"never\" parameter",
+                        child_block.span,
+                    );
+                }
+
+                exhaustive_check = Some(crate::ast::r3::R3SwitchExhaustiveCheck {
+                    source_span: child_block.span,
+                    start_source_span: child_block.start_span,
+                    end_source_span: child_block.end_span,
+                    name_span: child_block.name_span,
+                });
+                continue;
+            }
+
+            // Angular v21.2.7: a normal @case/@default following `@default never;`
+            // is invalid — the exhaustive check must be the last case.
+            // Reference: r3_control_flow.ts createSwitchBlock (`exhaustiveCheck !== null`).
+            if exhaustive_check.is_some() {
+                self.report_error(
+                    "@default block with \"never\" parameter must be the last case in a switch",
+                    child_block.span,
+                );
+            }
+
             let is_default = child_block.block_type == BlockType::Default;
 
             // Validate @default
@@ -2909,6 +3107,7 @@ impl<'a> HtmlToR3Transform<'a> {
         &mut self,
         attrs: &[HtmlAttribute<'a>],
         element_name: &str,
+        i18n_sink_element_name: Option<&str>,
         is_template: bool,
     ) -> (
         Vec<'a, R3TextAttribute<'a>>,  // Static attributes
@@ -2932,6 +3131,49 @@ impl<'a> HtmlToR3Transform<'a> {
         for attr in attrs {
             let name = attr.name.as_str();
             if let Some(target_attr) = name.strip_prefix("i18n-") {
+                // Issue #315 sub-gap 1: refuse to translate trusted-types sink attributes
+                // (e.g. `iframe src`), mirroring upstream `I18nMetaVisitor` in
+                // `render3/view/i18n/meta.ts` (~210-214):
+                //   isTrustedType = node instanceof html.Component
+                //     ? (node.tagName === null ? false : isTrustedTypesSink(node.tagName, name))
+                //     : isTrustedTypesSink(node.name, name);
+                // A translated value flowing into such a sink is an XSS vector, so emit an
+                // error and skip extracting it as a message.
+                //
+                // FAITHFULNESS NOTE (no namespace strip; bare component skips):
+                // `is_trusted_types_sink` only LOWERCASES the tag — it does NOT strip a
+                // `:ns:` prefix (matching `schema/trusted_types_sinks.ts`
+                // `isTrustedTypesSink`, which tests `${tag}|${name}` / `*|${name}` after a
+                // single `.toLowerCase()`). So the element name fed here must be the FULL,
+                // un-stripped name that upstream passes:
+                //   * normal element -> `node.name`  (e.g. `:svg:iframe` -> `:svg:iframe|src`
+                //     is NOT a sink -> ALLOWED);
+                //   * component with a host tag -> resolved `node.tagName` un-stripped
+                //     (`<MyCmp:iframe>` -> `iframe|src` blocked; `<svg><MyCmp:iframe>` ->
+                //     `:svg:iframe|src` allowed);
+                //   * bare component (tagName null) -> `i18n_sink_element_name` is `None`,
+                //     so we SKIP the check (short-circuit to false). Passing an empty string
+                //     would wrongly match the `*|innerhtml`/`*|outerhtml` wildcards.
+                // (The SECURITY-CONTEXT path above still ns-strips via `get_security_context`
+                // — that is faithful because upstream routes it through `CssSelector`.)
+                //
+                // SCOPE NOTE (deliberate upstream parity): like upstream `I18nMetaVisitor`,
+                // this only blocks *trusted-types sink* attributes — it does NOT block other
+                // security-sensitive contexts (e.g. `ResourceUrl`/`Html`). So a translatable
+                // `<svg:script i18n-href>` is accepted here and emitted as a static const
+                // with no sanitizer, exactly as v21.2.7 does (`script|href` is intentionally
+                // absent from `TRUSTED_TYPES_SINKS`). This shared gap is left as-is for
+                // faithfulness to the pinned compiler rather than hardened beyond upstream.
+                if i18n_sink_element_name.is_some_and(|tag| is_trusted_types_sink(tag, target_attr))
+                {
+                    self.report_error(
+                        &format!(
+                            "Translating attribute '{target_attr}' is disallowed for security reasons."
+                        ),
+                        attr.span,
+                    );
+                    continue;
+                }
                 let instance_id = self.allocate_i18n_message_instance_id();
                 let meta = parse_i18n_meta(self.allocator, attr.value.as_str(), instance_id);
                 i18n_attrs_meta.insert(target_attr, meta);
@@ -2940,10 +3182,11 @@ impl<'a> HtmlToR3Transform<'a> {
 
         for attr in attrs {
             let raw_name = attr.name.as_str();
-            // Angular v22 removed the `data-` prefix normalization: binding syntax
-            // (`bind-`, `on-`, `bindon-`, `ref-`, `let-`, `*`, `@`) is matched against
-            // the raw attribute name, so e.g. `data-ref-a` is a plain text attribute.
-            let name = raw_name;
+            // Normalize name early (case-insensitive data- prefix stripping).
+            // v21.2.7 binding_parser strips /^data-/i before matching bind-/on-/etc.
+            // This must happen before ANY binding syntax checks. (Angular v22 later
+            // removed this normalization; we stay on the v21.2.7 pin for #315.)
+            let name = self.normalize_attribute_name(raw_name);
 
             // Skip i18n-* attributes early - they are metadata for other attributes, not bindings.
             // In Angular's TypeScript compiler, these are filtered out by I18nMetaVisitor before
@@ -3181,11 +3424,19 @@ impl<'a> HtmlToR3Transform<'a> {
     }
 
     /// Normalizes an attribute name by stripping the data- prefix (case-insensitive).
-    /// This matches TypeScript's behavior: /^data-/i.test(attrName) ? attrName.substring(5) : attrName
-    /// Parses a binding prefix (`bind-`, `let-`, `ref-`, `on-`, `bindon-`) from an
-    /// attribute name. Angular v22 matches these against the raw name; a `data-`
-    /// prefix is no longer stripped, so `data-on-x` is not an event binding.
+    /// Matches TypeScript v21.2.7: `/^data-/i.test(attrName) ? attrName.substring(5) : attrName`.
+    fn normalize_attribute_name<'b>(&self, name: &'b str) -> &'b str {
+        if name.len() > 5 && name[..5].eq_ignore_ascii_case("data-") { &name[5..] } else { name }
+    }
+
+    /// Parses a binding prefix from an attribute name.
+    /// Handles the data- prefix as per Angular v21.2.7 normalization:
+    /// `data-bind-*`, `data-on-*`, `data-ref-*`, `data-let-*`, `data-bindon-*`.
     fn parse_binding_prefix<'b>(&self, name: &'b str) -> Option<(BindingPrefix, &'b str)> {
+        // Strip data- prefix if present (case-insensitive). Callers typically already
+        // normalized, but keep this for safety when invoked with a raw name.
+        let name = self.normalize_attribute_name(name);
+
         for (prefix, kind) in BIND_NAME_PREFIXES {
             if let Some(rest) = name.strip_prefix(prefix) {
                 return Some((*kind, rest));
@@ -3210,6 +3461,34 @@ impl<'a> HtmlToR3Transform<'a> {
         }
     }
 
+    /// Applies upstream's `mergeNsAndName` namespace normalization to an
+    /// attribute binding name, mirroring `createBoundElementProperty`
+    /// (binding_parser.ts:582-587):
+    ///
+    /// ```ts
+    /// const nsSeparatorIdx = boundPropertyName.indexOf(':');
+    /// if (nsSeparatorIdx > -1) {
+    ///   const ns = boundPropertyName.substring(0, nsSeparatorIdx);
+    ///   const name = boundPropertyName.substring(nsSeparatorIdx + 1);
+    ///   boundPropertyName = mergeNsAndName(ns, name);   // -> `:ns:name`
+    /// }
+    /// ```
+    ///
+    /// Only `BindingType::Attribute` bindings are merged; the split is on the
+    /// FIRST `:` and applies to ANY namespace prefix (not just well-known ones),
+    /// so e.g. `xlink:href` -> `:xlink:href` and `custom:foo` -> `:custom:foo`.
+    /// Non-namespaced names and non-attribute bindings are returned unchanged.
+    fn merge_attr_ns_name(&self, binding_type: BindingType, name: &str) -> String {
+        if binding_type == BindingType::Attribute {
+            if let Some(idx) = name.find(':') {
+                let ns = &name[..idx];
+                let local = &name[idx + 1..];
+                return crate::parser::html::merge_ns_and_name(Some(ns), local);
+            }
+        }
+        name.to_string()
+    }
+
     /// Creates a bound attribute.
     fn create_bound_attribute(
         &mut self,
@@ -3221,11 +3500,23 @@ impl<'a> HtmlToR3Transform<'a> {
     ) -> R3BoundAttribute<'a> {
         let value_span = attr.value_span.unwrap_or(attr.span);
         let value = self.parse_binding_expression(&attr.value, value_span);
-        let name_atom = Ident::from(self.allocator.alloc_str(property_name));
 
-        // Look up security context based on element and property
+        // Look up security context based on element and the PLAIN property name.
+        // This mirrors upstream `createBoundElementProperty`
+        // (binding_parser.ts:575-580): the security lookup uses the un-merged
+        // `attr.`-stripped name (e.g. `xlink:href`) BEFORE the namespace merge.
         let security_context = get_security_context(element_name, property_name);
 
+        // For attribute bindings, store the namespace-bearing INTERNAL form
+        // `:ns:local` via `mergeNsAndName` (binding_parser.ts:582-587). This lets
+        // the downstream binding-specialization `split_ns_name` split it into the
+        // local name + namespace for ANY prefix, so codegen emits the namespace
+        // argument of `ɵɵattribute(name, value, sanitizer?, namespace?)` — exactly
+        // like v21.2.7. Non-namespaced attrs and non-attribute bindings keep the
+        // plain name.
+        let stored_name = self.merge_attr_ns_name(binding_type, property_name);
+        let name_atom = Ident::from(self.allocator.alloc_str(&stored_name));
+
         R3BoundAttribute {
             name: name_atom,
             binding_type,
@@ -4589,7 +4880,11 @@ impl<'a> HtmlToR3Transform<'a> {
                 (BindingType::Property, name, None, security_context)
             };
 
-        let name_atom = Ident::from(self.allocator.alloc_str(final_name));
+        // For attribute bindings, store the namespace-bearing `:ns:local` form
+        // (upstream `mergeNsAndName`) so downstream codegen emits the namespace
+        // argument. Security was already computed above with the PLAIN name.
+        let stored_name = self.merge_attr_ns_name(binding_type, final_name);
+        let name_atom = Ident::from(self.allocator.alloc_str(&stored_name));
 
         Some(R3BoundAttribute {
             name: name_atom,
diff --git a/crates/oxc_angular_compiler/tests/host_binding_security_test.rs b/crates/oxc_angular_compiler/tests/host_binding_security_test.rs
new file mode 100644
index 000000000..a9ab86594
--- /dev/null
+++ b/crates/oxc_angular_compiler/tests/host_binding_security_test.rs
@@ -0,0 +1,560 @@
+//! Issue #315 finding F1: host bindings must compute a real security context.
+//!
+//! `@Component`/`@Directive` `host: { '[attr.href]': '...', '[innerHTML]': '...' }`
+//! bindings previously hard-coded `SecurityContext::None`, so no sanitizer or
+//! validator was ever emitted — an XSS gap. Upstream Angular computes the
+//! security context for host bindings using the directive/component SELECTOR as
+//! the element context (`createHostBindingsFunction` →
+//! `calcPossibleSecurityContexts(registry, selector, name, isAttribute)`).
+//!
+//! These tests drive the full public pipeline (`transform_angular_file`) and
+//! assert that the generated host-bindings update block contains (or, for the
+//! control case, omits) the expected sanitizer/validator identifier.
+
+use oxc_allocator::Allocator;
+use oxc_angular_compiler::transform_angular_file;
+
+/// Compile an Angular `.ts` source and return generated JS, asserting no errors.
+fn compile(source: &str, file: &str) -> String {
+    let allocator = Allocator::default();
+    let result = transform_angular_file(&allocator, file, source, None, None);
+    assert!(!result.has_errors(), "compile errors: {:?}", result.diagnostics);
+    result.code
+}
+
+// ---------------------------------------------------------------------------
+// URL context — `[attr.href]` on a selector whose element is `<a>`.
+// ---------------------------------------------------------------------------
+#[test]
+fn directive_host_attr_href_on_anchor_emits_url_sanitizer() {
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: 'a[appLink]',
+    host: { '[attr.href]': 'url' }
+})
+export class LinkDirective {
+    url = '';
+}
+";
+    let code = compile(source, "link.directive.ts");
+    assert!(
+        code.contains("ɵɵsanitizeUrl"),
+        "expected ɵɵsanitizeUrl for host [attr.href] on a[appLink].\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// HTML context — `[innerHTML]` DOM-property host binding.
+// ---------------------------------------------------------------------------
+#[test]
+fn component_host_inner_html_emits_html_sanitizer() {
+    let source = r"
+import { Component } from '@angular/core';
+
+@Component({
+    selector: 'app-card',
+    template: '',
+    host: { '[innerHTML]': 'content' }
+})
+export class CardComponent {
+    content = '';
+}
+";
+    let code = compile(source, "card.component.ts");
+    assert!(
+        code.contains("ɵɵsanitizeHtml"),
+        "expected ɵɵsanitizeHtml for host [innerHTML].\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// AttributeNoBinding — `[attr.to]` on an attribute-only selector (unknown
+// element). The unknown-element fallback aggregates the SVG-animation value
+// attributes, which resolve to AttributeNoBinding -> ɵɵvalidateAttribute.
+// ---------------------------------------------------------------------------
+#[test]
+fn directive_host_attr_to_unknown_element_emits_validate_attribute() {
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[appAnim]',
+    host: { '[attr.to]': 'target' }
+})
+export class AnimDirective {
+    target = '';
+}
+";
+    let code = compile(source, "anim.directive.ts");
+    assert!(
+        code.contains("ɵɵvalidateAttribute"),
+        "expected ɵɵvalidateAttribute for host [attr.to] on unknown element.\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Finding 1 (issue #315): host-unknown `:not(unknown)` + animation attr.
+//
+// Upstream `calcPossibleSecurityContexts` iterates `allKnownElementNames()`
+// (the SVG animation elements are registered ONLY as namespaced names like
+// `:svg:animate`, which resolve to NONE) and reaches ATTRIBUTE_NO_BINDING for
+// `to`/`from`/`values`/`attributeName` ONLY via the real `unknown` element.
+// A `:not(unknown)` selector therefore excludes the SOLE contributor and the
+// host binding yields NONE — NO `ɵɵvalidateAttribute`. Verified by running
+// @angular/compiler@21.2.7:
+//   calc('[x]:not(unknown)','to',true).filter(c=>c!==NONE) === []  -> NONE.
+#[test]
+fn directive_host_attr_to_not_unknown_emits_no_validator() {
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[appAnim]:not(unknown)',
+    host: { '[attr.to]': 'target' }
+})
+export class AnimDirective {
+    target = '';
+}
+";
+    let code = compile(source, "anim-not-unknown.directive.ts");
+    assert!(
+        !code.contains("ɵɵvalidateAttribute") && !code.contains("ɵɵsanitize"),
+        "host [attr.to] on `[appAnim]:not(unknown)` must NOT gain a validator \
+         (matches @angular/compiler@21.2.7: excluding `unknown` removes the only \
+         ATTRIBUTE_NO_BINDING source).\nGot:\n{code}"
+    );
+}
+
+// `:not(animate)` excludes a phantom (non-)element — the real `unknown` element
+// still contributes, so the validator IS retained (upstream parity).
+#[test]
+fn directive_host_attr_to_not_animate_keeps_validator() {
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[appAnim]:not(animate)',
+    host: { '[attr.to]': 'target' }
+})
+export class AnimDirective {
+    target = '';
+}
+";
+    let code = compile(source, "anim-not-animate.directive.ts");
+    assert!(
+        code.contains("ɵɵvalidateAttribute"),
+        "host [attr.to] on `[appAnim]:not(animate)` must KEEP ɵɵvalidateAttribute \
+         (the real `unknown` element still contributes).\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// UrlOrResourceUrl — `[attr.href]` on an attribute-only selector. `href` is a
+// URL context on <a>/<area> and a ResourceUrl context on <base>/<link>, so the
+// unknown-element fallback yields the runtime-resolved sanitizer.
+// ---------------------------------------------------------------------------
+#[test]
+fn directive_host_attr_href_unknown_element_emits_url_or_resource_url() {
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[appHref]',
+    host: { '[attr.href]': 'url' }
+})
+export class HrefDirective {
+    url = '';
+}
+";
+    let code = compile(source, "href.directive.ts");
+    assert!(
+        code.contains("ɵɵsanitizeUrlOrResourceUrl"),
+        "expected ɵɵsanitizeUrlOrResourceUrl for host [attr.href] on unknown element.\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Control — a non-sensitive host attribute must NOT gain any sanitizer.
+// ---------------------------------------------------------------------------
+#[test]
+fn directive_host_attr_title_emits_no_sanitizer() {
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[appTitle]',
+    host: { '[attr.title]': 'title' }
+})
+export class TitleDirective {
+    title = '';
+}
+";
+    let code = compile(source, "title.directive.ts");
+    assert!(
+        !code.contains("ɵɵsanitize") && !code.contains("ɵɵvalidateAttribute"),
+        "host [attr.title] must not gain a sanitizer/validator.\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// G1 — multi-selector merge to URL/RESOURCE_URL.
+//
+// `selector: 'img[x],iframe[x]'` with host `[attr.src]`: `img|src` is URL and
+// `iframe|src` is RESOURCE_URL. Upstream `calcPossibleSecurityContexts`
+// considers BOTH comma alternates and the host pipeline merges the
+// {URL, RESOURCE_URL} pair into the runtime-resolved sanitizer
+// `ɵɵsanitizeUrlOrResourceUrl`. The old single-leading-element behavior wrongly
+// used only `img|src` -> `ɵɵsanitizeUrl`.
+// ---------------------------------------------------------------------------
+#[test]
+fn directive_host_attr_src_img_iframe_merges_to_url_or_resource_url() {
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: 'img[x],iframe[x]',
+    host: { '[attr.src]': 'v' }
+})
+export class SrcDirective {
+    v = '';
+}
+";
+    let code = compile(source, "src.directive.ts");
+    assert!(
+        code.contains("ɵɵsanitizeUrlOrResourceUrl"),
+        "expected ɵɵsanitizeUrlOrResourceUrl for host [attr.src] on 'img[x],iframe[x]' \
+         (img|src=URL + iframe|src=RESOURCE_URL).\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// G1 — multi-selector with a NONE alternate filtered out, single survivor.
+//
+// `selector: 'div[x],iframe[x]'` with host `[attr.src]`: `div|src` is NONE
+// (filtered by the host pipeline) and `iframe|src` is RESOURCE_URL. The merged
+// set is exactly {RESOURCE_URL} -> `ɵɵsanitizeResourceUrl`. The old behavior
+// used only `div|src` -> NONE -> NO sanitizer at all.
+// ---------------------------------------------------------------------------
+#[test]
+fn directive_host_attr_src_div_iframe_emits_resource_url() {
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: 'div[x],iframe[x]',
+    host: { '[attr.src]': 'v' }
+})
+export class DivIframeDirective {
+    v = '';
+}
+";
+    let code = compile(source, "div-iframe.directive.ts");
+    assert!(
+        code.contains("ɵɵsanitizeResourceUrl"),
+        "expected ɵɵsanitizeResourceUrl for host [attr.src] on 'div[x],iframe[x]' \
+         (div|src=NONE filtered, iframe|src=RESOURCE_URL).\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// G1 control — single-element selector behavior is unchanged.
+//
+// `selector: 'img[x]'` host `[attr.src]` -> `img|src` = URL -> `ɵɵsanitizeUrl`.
+// ---------------------------------------------------------------------------
+#[test]
+fn directive_host_attr_src_single_img_emits_url() {
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: 'img[x]',
+    host: { '[attr.src]': 'v' }
+})
+export class ImgDirective {
+    v = '';
+}
+";
+    let code = compile(source, "img.directive.ts");
+    assert!(
+        code.contains("ɵɵsanitizeUrl") && !code.contains("ɵɵsanitizeUrlOrResourceUrl"),
+        "expected plain ɵɵsanitizeUrl for host [attr.src] on single 'img[x]'.\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// G1 control — non-sensitive multi-selector must NOT gain any sanitizer.
+//
+// `selector: 'a[x],b[x]'` host `[attr.title]`: neither `a|title` nor `b|title`
+// is security-sensitive, so the merged set is empty -> NONE -> no sanitizer.
+// ---------------------------------------------------------------------------
+#[test]
+fn directive_host_attr_title_multi_selector_emits_no_sanitizer() {
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: 'a[x],b[x]',
+    host: { '[attr.title]': 't' }
+})
+export class TitleMultiDirective {
+    t = '';
+}
+";
+    let code = compile(source, "title-multi.directive.ts");
+    assert!(
+        !code.contains("ɵɵsanitize") && !code.contains("ɵɵvalidateAttribute"),
+        "host [attr.title] on 'a[x],b[x]' must not gain a sanitizer/validator.\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Control — class/style host bindings must NOT gain a content sanitizer.
+// ---------------------------------------------------------------------------
+#[test]
+fn directive_host_class_binding_emits_no_content_sanitizer() {
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: 'a[appActive]',
+    host: { '[class.active]': 'isActive' }
+})
+export class ActiveDirective {
+    isActive = false;
+}
+";
+    let code = compile(source, "active.directive.ts");
+    assert!(
+        !code.contains("ɵɵsanitizeUrl")
+            && !code.contains("ɵɵsanitizeHtml")
+            && !code.contains("ɵɵvalidateAttribute"),
+        "host [class.active] must not gain a content sanitizer.\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// v21.2.7 faithfulness (Codex iteration-10): the attribute-only / wildcard
+// selector branch of the host security aggregator must honor `:not(element)`
+// exclusions before scanning all known elements, mirroring upstream
+// `calcPossibleSecurityContexts` (`binding_parser.ts:888-896`):
+//
+//   const elementNames = selector.element ? [selector.element]
+//                                          : registry.allKnownElementNames();
+//   const notElementNames = new Set(
+//     selector.notSelectors.filter((s) => s.isElementSelector()).map((s) => s.element));
+//   const possibleElementNames = elementNames.filter((n) => !notElementNames.has(n));
+//
+// Schema facts (`dom_security_schema.ts`): `object|data`/`object|codebase` are
+// the ONLY `data`/`codebase` sinks (RESOURCE_URL) and `iframe|srcdoc` is the
+// ONLY `srcdoc` sink (HTML). Excluding those elements removes the sole
+// contributor, so the host binding gets NO sanitizer. The previous OXC code
+// ignored `:not(...)` here and over-sanitized.
+// ---------------------------------------------------------------------------
+#[test]
+fn directive_host_attr_data_not_object_emits_no_sanitizer() {
+    // `[x]:not(object)` excludes the only `data` sink (`object|data`).
+    // Upstream yields no sanitizer; the old OXC behavior emitted
+    // ɵɵsanitizeResourceUrl (over-sanitization).
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[x]:not(object)',
+    host: { '[attr.data]': 'v' }
+})
+export class NotObjectDirective {
+    v = '';
+}
+";
+    let code = compile(source, "not-object.directive.ts");
+    assert!(
+        !code.contains("ɵɵsanitize") && !code.contains("ɵɵvalidateAttribute"),
+        "host [attr.data] on '[x]:not(object)' must NOT gain a sanitizer (object \
+         is the only `data` sink and is excluded).\nGot:\n{code}"
+    );
+}
+
+#[test]
+fn directive_host_attr_srcdoc_not_iframe_emits_no_sanitizer() {
+    // `[x]:not(iframe)` excludes the only `srcdoc` sink (`iframe|srcdoc`).
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[x]:not(iframe)',
+    host: { '[attr.srcdoc]': 'v' }
+})
+export class NotIframeDirective {
+    v = '';
+}
+";
+    let code = compile(source, "not-iframe.directive.ts");
+    assert!(
+        !code.contains("ɵɵsanitize") && !code.contains("ɵɵvalidateAttribute"),
+        "host [attr.srcdoc] on '[x]:not(iframe)' must NOT gain a sanitizer \
+         (iframe is the only `srcdoc` sink and is excluded).\nGot:\n{code}"
+    );
+}
+
+#[test]
+fn directive_host_attr_data_no_not_still_emits_resource_url() {
+    // CONTROL: without `:not`, the attribute-only scan still sees `object|data`
+    // -> ɵɵsanitizeResourceUrl.
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[x]',
+    host: { '[attr.data]': 'v' }
+})
+export class PlainDataDirective {
+    v = '';
+}
+";
+    let code = compile(source, "plain-data.directive.ts");
+    assert!(
+        code.contains("ɵɵsanitizeResourceUrl"),
+        "host [attr.data] on '[x]' (no :not) must still emit ɵɵsanitizeResourceUrl \
+         (object|data present).\nGot:\n{code}"
+    );
+}
+
+#[test]
+fn directive_host_attr_data_not_unrelated_element_still_emits_resource_url() {
+    // CONTROL: `:not(div)` excludes a NON-sink element, so `object` stays in
+    // the set -> ɵɵsanitizeResourceUrl.
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[x]:not(div)',
+    host: { '[attr.data]': 'v' }
+})
+export class NotDivDirective {
+    v = '';
+}
+";
+    let code = compile(source, "not-div.directive.ts");
+    assert!(
+        code.contains("ɵɵsanitizeResourceUrl"),
+        "host [attr.data] on '[x]:not(div)' must still emit ɵɵsanitizeResourceUrl \
+         (div is not a `data` sink; object remains).\nGot:\n{code}"
+    );
+}
+
+#[test]
+fn directive_host_attr_data_non_element_not_still_emits_resource_url() {
+    // CONTROL: a NON-element `:not()` (class selector) is not an
+    // `isElementSelector()`, so it excludes nothing -> ɵɵsanitizeResourceUrl.
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[x]:not(.foo)',
+    host: { '[attr.data]': 'v' }
+})
+export class NotClassDirective {
+    v = '';
+}
+";
+    let code = compile(source, "not-class.directive.ts");
+    assert!(
+        code.contains("ɵɵsanitizeResourceUrl"),
+        "host [attr.data] on '[x]:not(.foo)' must still emit ɵɵsanitizeResourceUrl \
+         (non-element :not does not filter).\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// v21.2.7 faithfulness (Finding 1): the `:not(element)` exclusion is a
+// CASE-SENSITIVE exact match, mirroring upstream's `Set.has` over LOWERCASE
+// `allKnownElementNames()` vs the case-PRESERVED `:not()` element name.
+//
+// Upstream `CssSelector.setElement` (directive_matching.ts:181-183) stores the
+// element name verbatim (no `.toLowerCase()`), so `:not(OBJECT)` parses to
+// element `"OBJECT"`. `notElementNames.has("object")` is then FALSE, so
+// `object` is NOT excluded and `object|data` (RESOURCE_URL) survives.
+//
+// Oracle (faithful reimpl of calcPossibleSecurityContexts driving the real
+// @angular/compiler@21.2.7 DomElementSchemaRegistry + CssSelector):
+//   [x]:not(object) + data => [NONE]                -> None (no sanitizer)
+//   [x]:not(OBJECT) + data => [NONE, RESOURCE_URL]  -> ResourceUrl
+//   [x]:not(IFRAME) + src  => [NONE, URL, RESOURCE_URL] -> UrlOrResourceUrl
+//
+// The previous OXC code lowercased the `:not()` name AND compared
+// case-insensitively, so `:not(OBJECT)` wrongly excluded `object` -> None ->
+// UNDER-SANITIZATION (an XSS gap on a reachable host-binding path).
+// ---------------------------------------------------------------------------
+#[test]
+fn directive_host_attr_data_not_uppercase_object_still_emits_resource_url() {
+    // `[x]:not(OBJECT)` does NOT exclude lowercase `object` (case-sensitive
+    // exact match), so `object|data` survives -> ɵɵsanitizeResourceUrl.
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[x]:not(OBJECT)',
+    host: { '[attr.data]': 'v' }
+})
+export class NotUpperObjectDirective {
+    v = '';
+}
+";
+    let code = compile(source, "not-upper-object.directive.ts");
+    assert!(
+        code.contains("ɵɵsanitizeResourceUrl"),
+        "host [attr.data] on '[x]:not(OBJECT)' must STILL emit ɵɵsanitizeResourceUrl \
+         (uppercase :not does NOT exclude lowercase `object`; case-sensitive match).\nGot:\n{code}"
+    );
+}
+
+#[test]
+fn directive_host_attr_data_not_lowercase_object_emits_no_sanitizer() {
+    // CONTROL companion: lowercase `[x]:not(object)` DOES exclude `object`
+    // (exact match) -> no sanitizer. (Mirrors the existing
+    // `directive_host_attr_data_not_object_emits_no_sanitizer` but kept next to
+    // the uppercase case for the case-sensitivity contrast.)
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[x]:not(object)',
+    host: { '[attr.data]': 'v' }
+})
+export class NotLowerObjectDirective {
+    v = '';
+}
+";
+    let code = compile(source, "not-lower-object.directive.ts");
+    assert!(
+        !code.contains("ɵɵsanitize") && !code.contains("ɵɵvalidateAttribute"),
+        "host [attr.data] on '[x]:not(object)' must NOT gain a sanitizer \
+         (lowercase exact match excludes `object`).\nGot:\n{code}"
+    );
+}
+
+#[test]
+fn directive_host_attr_src_not_uppercase_iframe_emits_url_or_resource_url() {
+    // `[x]:not(IFRAME)` does NOT exclude lowercase `iframe`. Per the oracle,
+    // the surviving set across all elements is {URL, RESOURCE_URL} (iframe is
+    // not the only `src` RESOURCE_URL sink) -> ɵɵsanitizeUrlOrResourceUrl.
+    let source = r"
+import { Directive } from '@angular/core';
+
+@Directive({
+    selector: '[x]:not(IFRAME)',
+    host: { '[attr.src]': 'v' }
+})
+export class NotUpperIframeDirective {
+    v = '';
+}
+";
+    let code = compile(source, "not-upper-iframe.directive.ts");
+    assert!(
+        code.contains("ɵɵsanitizeUrlOrResourceUrl"),
+        "host [attr.src] on '[x]:not(IFRAME)' must emit ɵɵsanitizeUrlOrResourceUrl \
+         (uppercase :not does NOT exclude `iframe`; URL+RESOURCE_URL survive).\nGot:\n{code}"
+    );
+}
diff --git a/crates/oxc_angular_compiler/tests/html_parser_test.rs b/crates/oxc_angular_compiler/tests/html_parser_test.rs
index 3d6b349dd..9f6525f9d 100644
--- a/crates/oxc_angular_compiler/tests/html_parser_test.rs
+++ b/crates/oxc_angular_compiler/tests/html_parser_test.rs
@@ -764,6 +764,151 @@ mod errors {
         let (_nodes, errors) = parse_with_errors("@if (cond) {");
         assert!(!errors.is_empty(), "Expected errors for incomplete template");
     }
+
+    // `@default never` WITHOUT a trailing `;` is an incomplete block. The lexer emits an
+    // IncompleteBlockOpen token; the parser must route it to `_consumeIncompleteBlock`
+    // (upstream v21.2.7 ml_parser/parser.ts:786-812), preserve the block node, and report
+    // the exact "Incomplete block ..." diagnostic. Previously the token hit the default
+    // `_ => advance()` arm and the `@default never` was SILENTLY dropped with 0 errors.
+    #[test]
+    fn incomplete_default_never_without_semicolon_reports_error() {
+        let errors = parse_errors("@switch (cond) { @default never }");
+        assert!(
+            errors.iter().any(|e| e.contains("Incomplete block \"default never\"")),
+            "Expected incomplete block error, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn incomplete_default_never_reports_exact_upstream_message() {
+        // Verify the diagnostic matches upstream v21.2.7 verbatim, including the
+        // `&#64;` HTML entity guidance.
+        let errors = parse_errors("@switch (cond) { @default never }");
+        let expected = "Incomplete block \"default never\". If you meant to write the @ character, \
+                        you should use the \"&#64;\" HTML entity instead.";
+        assert!(
+            errors.iter().any(|e| e == expected),
+            "Expected exact upstream message, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn incomplete_default_never_block_is_not_dropped() {
+        // The block node must be preserved in the tree (not silently lost), mirroring
+        // upstream's push+immediate-pop of the incomplete block.
+        let (nodes, _errors) = parse_with_errors("@switch (cond) { @default never }");
+        // The @switch block contains a child @default-never block.
+        let block_names: Vec<_> = nodes
+            .iter()
+            .filter(|n| n.node_type() == Some("Block"))
+            .filter_map(|n| n.name().map(|s| s.to_string()))
+            .collect();
+        assert!(
+            block_names.iter().any(|n| n == "default never"),
+            "Expected a preserved 'default never' block, got blocks: {block_names:?}"
+        );
+    }
+
+    #[test]
+    fn valid_default_never_with_semicolon_has_no_incomplete_error() {
+        // The VALID self-terminating `@default never;` (with `;`) must NOT regress: it
+        // produces a complete `default never` block and no "Incomplete block" diagnostic.
+        let (nodes, errors) = parse_with_errors("@switch (cond) { @default never; }");
+        assert!(
+            !errors.iter().any(|e| e.contains("Incomplete block")),
+            "Valid @default never; should not report incomplete block, got: {errors:?}"
+        );
+        let block_names: Vec<_> = nodes
+            .iter()
+            .filter(|n| n.node_type() == Some("Block"))
+            .filter_map(|n| n.name().map(|s| s.to_string()))
+            .collect();
+        assert!(
+            block_names.iter().any(|n| n == "default never"),
+            "Expected a complete 'default never' block, got blocks: {block_names:?}"
+        );
+    }
+
+    // Upstream v21.2.7 `_getBlockName` (ml_parser/lexer.ts:294) only `.trim()`s the
+    // raw block name; it does NOT collapse internal whitespace. The exhaustive marker
+    // is recognized by an EXACT equality `parts[0] === 'default never'` (single space,
+    // lexer.ts:302). So `@default   never;` (multiple internal spaces) does NOT match
+    // the marker and falls through to INCOMPLETE_BLOCK_OPEN, reporting an incomplete
+    // block whose name PRESERVES the raw internal whitespace ("default   never").
+    // Verified by executing @angular/compiler@21.2.7 parseTemplate:
+    //   "@switch (x) { @case (1) { a } @default   never; }"
+    //   -> errors: ['Incomplete block "default   never". ...'], exhaustive=0
+    #[test]
+    fn default_never_multiple_internal_spaces_is_incomplete_block() {
+        let (nodes, errors) = parse_with_errors("@switch (cond) { @default   never; }");
+        // Incomplete-block diagnostic preserving the raw (uncollapsed) internal spaces.
+        assert!(
+            errors.iter().any(|e| e.contains("Incomplete block \"default   never\"")),
+            "Expected incomplete block with raw internal spaces, got: {errors:?}"
+        );
+        // NOT recognized as the canonical exhaustive marker.
+        let block_names: Vec<_> = nodes
+            .iter()
+            .filter(|n| n.node_type() == Some("Block"))
+            .filter_map(|n| n.name().map(|s| s.to_string()))
+            .collect();
+        assert!(
+            !block_names.iter().any(|n| n == "default never"),
+            "Multi-space form must NOT become the canonical 'default never' marker, \
+             got blocks: {block_names:?}"
+        );
+    }
+
+    // Same as above but with a TAB between `default` and `never`. Upstream
+    // `chars.isWhitespace` (chars.ts:78) treats TAB as whitespace inside the name
+    // scan, but `.trim()` does not strip it internally, so the name stays
+    // "default\tnever" and never matches the single-space marker.
+    // Verified by executing @angular/compiler@21.2.7:
+    //   "@switch (x) { @case (1) { a } @default\tnever; }"
+    //   -> errors: ['Incomplete block "default\tnever". ...'], exhaustive=0
+    #[test]
+    fn default_never_tab_separator_is_incomplete_block() {
+        let (nodes, errors) = parse_with_errors("@switch (cond) { @default\tnever; }");
+        assert!(
+            errors.iter().any(|e| e.contains("Incomplete block \"default\tnever\"")),
+            "Expected incomplete block with raw tab separator, got: {errors:?}"
+        );
+        let block_names: Vec<_> = nodes
+            .iter()
+            .filter(|n| n.node_type() == Some("Block"))
+            .filter_map(|n| n.name().map(|s| s.to_string()))
+            .collect();
+        assert!(
+            !block_names.iter().any(|n| n == "default never"),
+            "Tab form must NOT become the canonical 'default never' marker, \
+             got blocks: {block_names:?}"
+        );
+    }
+
+    // CONTROL: a single trailing space before the `;` IS faithful-valid upstream.
+    // The name scan greedily consumes the trailing space (spacesInNameAllowed=true),
+    // then `.trim()` removes it, yielding exactly "default never"; the cursor lands
+    // on `;`, so the marker is recognized.
+    // Verified by executing @angular/compiler@21.2.7:
+    //   "@switch (x) { @case (1) { a } @default never ; }" -> errors: [], exhaustive=1
+    #[test]
+    fn default_never_trailing_space_before_semicolon_is_valid() {
+        let (nodes, errors) = parse_with_errors("@switch (cond) { @default never ; }");
+        assert!(
+            !errors.iter().any(|e| e.contains("Incomplete block")),
+            "Trailing-space @default never ; should be valid, got: {errors:?}"
+        );
+        let block_names: Vec<_> = nodes
+            .iter()
+            .filter(|n| n.node_type() == Some("Block"))
+            .filter_map(|n| n.name().map(|s| s.to_string()))
+            .collect();
+        assert!(
+            block_names.iter().any(|n| n == "default never"),
+            "Expected canonical 'default never' marker for trailing-space form, \
+             got blocks: {block_names:?}"
+        );
+    }
 }
 
 // ============================================================================
@@ -859,6 +1004,54 @@ mod void_elements {
             vec![element("div", 0), element("input", 1), element("br", 1), element("span", 1),]
         );
     }
+
+    // Finding 2 (issue #315): the void-element end-tag check must run on the
+    // RESOLVED FULL name, not the NS-stripped local name. Upstream
+    // `_consumeElementEndTag` checks `_getTagDefinition(fullName)?.isVoid`
+    // (ml_parser/parser.ts:572), and `getHtmlTagDefinition(':svg:input')` falls
+    // back to the DEFAULT non-void definition (html_tags.ts:192). Verified by
+    // running @angular/compiler@21.2.7 HtmlParser.parse:
+    //   '<svg:input></svg:input>'      -> 0 errors, element ':svg:input'
+    //   '<svg><input></input></svg>'   -> 0 errors, ':svg:input' under ':svg:svg'
+    //   '<input></input>'              -> 1 error "Void elements do not have end
+    //                                     tags \"input\"", element 'input'
+    #[test]
+    fn explicit_namespaced_void_local_close_is_accepted() {
+        let (nodes, errors) = parse_with_errors("<svg:input></svg:input>");
+        assert!(
+            errors.is_empty(),
+            "`</svg:input>` must NOT trigger the void-element error \
+             (`:svg:input` is non-void). Got: {errors:?}"
+        );
+        // The namespaced element is popped/parsed (single root element).
+        assert_eq!(nodes, vec![element(":svg:input", 0)]);
+    }
+
+    #[test]
+    fn implicit_svg_namespaced_void_local_close_is_accepted() {
+        let (nodes, errors) = parse_with_errors("<svg><input></input></svg>");
+        assert!(
+            errors.is_empty(),
+            "`<input>` under `<svg>` resolves to `:svg:input` (non-void) and its \
+             close must be accepted. Got: {errors:?}"
+        );
+        assert_eq!(nodes, vec![element(":svg:svg", 0), element(":svg:input", 1)]);
+    }
+
+    // Control: a plain (non-namespaced) `<input>` is `input` -> void, so the
+    // explicit end tag still errors with the LOCAL name in the message
+    // (`endTagToken.parts[1]`, upstream parity).
+    #[test]
+    fn plain_void_input_explicit_close_still_errors() {
+        let (nodes, errors) = parse_with_errors("<input></input>");
+        assert_eq!(
+            errors,
+            vec!["Void elements do not have end tags \"input\"".to_string()],
+            "plain `<input></input>` must still report the void end-tag error"
+        );
+        // The element is still parsed.
+        assert_eq!(nodes, vec![element("input", 0)]);
+    }
 }
 
 // ============================================================================
@@ -1302,9 +1495,354 @@ mod namespaces {
 
     #[test]
     fn should_parse_svg_with_children() {
+        // Upstream namespaces both the `<svg>` root and its implicit children
+        // (`<circle>` inherits `:svg:` from its parent).
         let result = parse_and_humanize("<svg><circle></circle></svg>");
         assert_eq!(result.len(), 2);
-        assert_eq!(result, vec![element("svg", 0), element("circle", 1),]);
+        assert_eq!(result, vec![element(":svg:svg", 0), element(":svg:circle", 1),]);
+    }
+
+    // -----------------------------------------------------------------------
+    // Inherited foreign self-closing elements (F5 namespace inheritance).
+    //
+    // Upstream v21.2.7 `Parser._consumeElementStartTag` (ml_parser/parser.ts:405):
+    //   `if (!(tagDef?.canSelfClose || getNsPrefix(fullName) !== null || tagDef?.isVoid))`
+    // The "foreign" test is `getNsPrefix(fullName) !== null` on the RESOLVED full name,
+    // not on whether the source tag had an explicit prefix. `getNsPrefix(':svg:p')` is
+    // `'svg'` (tags.ts:62-64 -> splitNsName), so an inherited `:svg:p` may self-close.
+    // `getNsPrefix('p')` is `null` and `p` has `canSelfClose: false`, so a real-HTML
+    // `<p/>` still reports the error (the negative control below).
+
+    /// Finds the first element in a parsed template and returns
+    /// `(name, is_self_closing)`. Bypasses the error-asserting humanizer so the
+    /// self-closing tests can inspect the resolved element directly.
+    fn first_element(html: &str) -> (String, bool) {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::new(&allocator, html, "TestComp");
+        let result = parser.parse();
+        fn find<'a>(nodes: &'a [HtmlNode<'a>]) -> Option<&'a HtmlElement<'a>> {
+            for n in nodes {
+                if let HtmlNode::Element(e) = n {
+                    return Some(e);
+                }
+            }
+            None
+        }
+        let el = find(&result.nodes).expect("expected an element");
+        (el.name.to_string(), el.is_self_closing)
+    }
+
+    #[test]
+    fn inherited_svg_p_self_closes_without_error() {
+        // `<svg><p/></svg>`: the implicit `<p>` inherits the `svg` namespace ->
+        // resolved `:svg:p`, which is foreign (getNsPrefix non-null), so the
+        // self-close is allowed with NO "Only void..." error.
+        let errors = parse_errors("<svg><p/></svg>");
+        assert!(
+            errors.is_empty(),
+            "expected no errors for inherited foreign <svg><p/></svg>, got: {errors:?}"
+        );
+        // The inner element resolves to `:svg:p` and is self-closing.
+        let result = parse_and_humanize("<svg><p/></svg>");
+        assert_eq!(result, vec![element(":svg:svg", 0), element(":svg:p", 1)]);
+    }
+
+    #[test]
+    fn inherited_svg_title_self_closes_without_error() {
+        // `<svg><title/></svg>`: inherited `:svg:title` is foreign -> no error.
+        let errors = parse_errors("<svg><title/></svg>");
+        assert!(
+            errors.is_empty(),
+            "expected no errors for inherited foreign <svg><title/></svg>, got: {errors:?}"
+        );
+        let result = parse_and_humanize("<svg><title/></svg>");
+        assert_eq!(result, vec![element(":svg:svg", 0), element(":svg:title", 1)]);
+    }
+
+    #[test]
+    fn inherited_math_mi_self_closes_without_error() {
+        // `<math><mi/></math>`: inherited `:math:mi` is foreign -> no error.
+        let errors = parse_errors("<math><mi/></math>");
+        assert!(
+            errors.is_empty(),
+            "expected no errors for inherited foreign <math><mi/></math>, got: {errors:?}"
+        );
+        let result = parse_and_humanize("<math><mi/></math>");
+        assert_eq!(result, vec![element(":math:math", 0), element(":math:mi", 1)]);
+    }
+
+    #[test]
+    fn explicit_namespaced_self_close_still_allowed() {
+        // Sanity: an explicitly namespaced foreign element self-closes (resolved
+        // `:svg:rect` is foreign). This already worked via the explicit-prefix
+        // path and must keep working through the resolved-name check.
+        let (name, self_closing) = first_element("<svg:rect/>");
+        assert_eq!(name, ":svg:rect");
+        assert!(self_closing, "explicit <svg:rect/> should be self-closing");
+        assert!(parse_errors("<svg:rect/>").is_empty());
+    }
+
+    #[test]
+    fn real_html_self_close_still_errors() {
+        // NEGATIVE control: a genuine top-level HTML `<p/>` (resolved name `p`,
+        // getNsPrefix == null, not void, canSelfClose == false) MUST still report
+        // the self-closing error. This proves the fix did not disable the check for
+        // real HTML.
+        //
+        // NOTE: `<p>` (not `<div>`) is used deliberately. OXC's
+        // `get_html_tag_definition` does not register the full DOM element-name
+        // list with `canSelfClose: false` the way upstream's
+        // `allKnownElementNames().forEach` does, so OXC treats `div`/`span` as
+        // unknown tags (`canSelfClose: true`) and does NOT error on `<div/>` —
+        // a PRE-EXISTING divergence outside this fix's scope. `p` IS an explicitly
+        // defined tag with `canSelfClose: false` in BOTH OXC and upstream
+        // v21.2.7, so it is the faithful negative control here.
+        let errors = parse_errors("<p/>");
+        assert!(
+            errors
+                .iter()
+                .any(|e| e.contains("Only void, custom and foreign elements can be self closed")),
+            "expected self-closing error for real-HTML <p/>, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn real_html_p_in_div_self_close_still_errors() {
+        // NEGATIVE control with a non-foreign parent: `<div><p/></div>` keeps `<p>`
+        // in the HTML namespace (resolved `p`, getNsPrefix == null), so the
+        // self-close error still fires — confirming inheritance, not the bare tag,
+        // is what flips the foreign decision.
+        let errors = parse_errors("<div><p/></div>");
+        assert!(
+            errors
+                .iter()
+                .any(|e| e.contains("Only void, custom and foreign elements can be self closed")),
+            "expected self-closing error for <div><p/></div>, got: {errors:?}"
+        );
+    }
+
+    // Faithful to upstream v21.2.7: a namespaced raw-text element (e.g. `<svg:script>`,
+    // `<svg:style>`) closes on its LOCAL name only (`script`/`style`), matched
+    // case-insensitively. In `_consumeTagOpen` (ml_parser/lexer.ts:837-839) a REGULAR tag
+    // sets `tagName = closingTagName = openToken.parts[1]` — the local name, WITHOUT the
+    // namespace prefix; only the selectorless-component path (lines 821-827) appends the
+    // prefix. The boundary is matched via `_attemptStrCaseInsensitive(tagName)` (line 900).
+    // Therefore `</svg:script>` does NOT close `<svg:script>` (the boundary is bare
+    // `script`, but the source close tag reads `svg:script`), and the raw-text scan runs to
+    // EOF, swallowing the trailing `<div>after</div>` into the script's raw text. Only a
+    // BARE `</script>` (any case) closes it. The parser stores namespaced names in
+    // Angular's internal `:ns:name` form. These assertions were verified empirically against
+    // the lexer and match v21.2.7 1:1.
+    #[test]
+    fn svg_script_closes_on_local_name_and_swallows_until_bare_close() {
+        // No bare `</script>` is present, so `</svg:script>` does not close the raw-text
+        // element and everything runs to EOF as the script's raw text (v21.2.7-faithful).
+        let result = parse_and_humanize("<svg:script>evil</svg:script><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element(":svg:script", 0), text("evil</svg:script><div>after</div>", 1)]
+        );
+
+        // A BARE `</script>` (local name) DOES close it case-insensitively, leaving the
+        // following `<div>after</div>` as a sibling — proving local-name close matching.
+        let result = parse_and_humanize("<svg:script>evil</script><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element(":svg:script", 0), text("evil", 1), element("div", 0), text("after", 1),]
+        );
+    }
+
+    #[test]
+    fn svg_style_closes_on_local_name_and_swallows_until_bare_close() {
+        // No bare `</style>`: `</svg:style>` does not close; runs to EOF (v21.2.7-faithful).
+        let result = parse_and_humanize("<svg:style>x</svg:style><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element(":svg:style", 0), text("x</svg:style><div>after</div>", 1)]
+        );
+
+        // A bare `</style>` closes it; the `<div>` survives as a sibling.
+        let result = parse_and_humanize("<svg:style>x</style><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element(":svg:style", 0), text("x", 1), element("div", 0), text("after", 1),]
+        );
+    }
+
+    #[test]
+    fn svg_script_close_tag_is_case_insensitive_on_local_name() {
+        // Local-name close matching is case-insensitive (`_attemptStrCaseInsensitive`).
+        // `</SVG:SCRIPT>` does NOT close `<svg:script>` — the boundary is the local name
+        // `script`, but the source close tag reads `SVG:SCRIPT` (a prefixed name), so the
+        // raw-text scan runs to EOF (v21.2.7-faithful).
+        let result = parse_and_humanize("<svg:script>evil</SVG:SCRIPT><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element(":svg:script", 0), text("evil</SVG:SCRIPT><div>after</div>", 1)]
+        );
+
+        // A BARE upper-case `</SCRIPT>` DOES close it (case-insensitive local match),
+        // leaving the `<div>` as a sibling.
+        let result = parse_and_humanize("<svg:script>evil</SCRIPT><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element(":svg:script", 0), text("evil", 1), element("div", 0), text("after", 1),]
+        );
+    }
+
+    #[test]
+    fn plain_script_still_keeps_following_sibling() {
+        // Guard against regressions in the non-namespaced raw-text path.
+        let result = parse_and_humanize("<script>a</script><div>b</div>");
+        assert_eq!(
+            result,
+            vec![element("script", 0), text("a", 1), element("div", 0), text("b", 1),]
+        );
+    }
+
+    #[test]
+    fn plain_style_still_keeps_following_sibling() {
+        let result = parse_and_humanize("<style>.a{}</style><div>b</div>");
+        assert_eq!(
+            result,
+            vec![element("style", 0), text(".a{}", 1), element("div", 0), text("b", 1),]
+        );
+    }
+
+    // Issue: an UPPER-case (or mixed-case) raw-text opening tag (`<SCRIPT>`, `<Script>`,
+    // `<svg:SCRIPT>`, `<TEXTAREA>`, `<TITLE>`) must close on its matching close tag and
+    // keep following content as SIBLINGS, not nest them under the raw-text element.
+    //
+    // The lexer detects the raw-text boundary case-insensitively (correct), but it must
+    // emit the synthetic TAG_CLOSE token with the ORIGINAL-case open-tag name so the parser
+    // pairs open/close by exact name. Upstream v21.2.7 `_consumeRawTextWithTagClose`
+    // (ml_parser/lexer.ts:911) emits the close token with `openToken.parts` (original case),
+    // while the boundary is matched via `_attemptStrCaseInsensitive(tagName)` (line 900).
+    // Previously OXC emitted the close token with the LOWER-cased name, so `<SCRIPT>` (open)
+    // never matched `script` (synthetic close), and `<div>` nested under SCRIPT with an
+    // "Unexpected closing tag" error.
+    #[test]
+    fn uppercase_script_keeps_following_sibling() {
+        let (nodes, errors) = parse_with_errors("<SCRIPT>a</SCRIPT><div>b</div>");
+        assert!(errors.is_empty(), "Expected no errors, got: {errors:?}");
+        assert_eq!(
+            nodes,
+            vec![element("SCRIPT", 0), text("a", 1), element("div", 0), text("b", 1),]
+        );
+    }
+
+    #[test]
+    fn mixedcase_script_keeps_following_sibling() {
+        let (nodes, errors) = parse_with_errors("<Script>a</Script><div>b</div>");
+        assert!(errors.is_empty(), "Expected no errors, got: {errors:?}");
+        assert_eq!(
+            nodes,
+            vec![element("Script", 0), text("a", 1), element("div", 0), text("b", 1),]
+        );
+    }
+
+    #[test]
+    fn uppercase_namespaced_script_closes_on_bare_local_name() {
+        // v21.2.7-faithful: a namespaced raw-text element closes on its LOCAL name only,
+        // case-insensitively. `</svg:SCRIPT>` does NOT close `<svg:SCRIPT>` (the boundary is
+        // local `script`, but the source close tag reads `svg:SCRIPT`), so the scan runs to
+        // EOF and swallows the following content as raw text.
+        let (nodes, errors) = parse_with_errors("<svg:SCRIPT>evil</svg:SCRIPT><div>after</div>");
+        assert!(errors.is_empty(), "Expected no errors, got: {errors:?}");
+        assert_eq!(
+            nodes,
+            vec![element(":svg:SCRIPT", 0), text("evil</svg:SCRIPT><div>after</div>", 1)]
+        );
+
+        // A BARE `</SCRIPT>` closes it (case-insensitive local match). The element keeps its
+        // ORIGINAL-case name `:svg:SCRIPT` (H2: the synthetic close token carries the
+        // original-case open-tag parts), so open/close pair with no errors and the `<div>`
+        // survives as a sibling.
+        let (nodes, errors) = parse_with_errors("<svg:SCRIPT>evil</SCRIPT><div>after</div>");
+        assert!(errors.is_empty(), "Expected no errors, got: {errors:?}");
+        assert_eq!(
+            nodes,
+            vec![element(":svg:SCRIPT", 0), text("evil", 1), element("div", 0), text("after", 1),]
+        );
+    }
+
+    #[test]
+    fn uppercase_textarea_keeps_following_sibling() {
+        let (nodes, errors) = parse_with_errors("<TEXTAREA>a</TEXTAREA><div>b</div>");
+        assert!(errors.is_empty(), "Expected no errors, got: {errors:?}");
+        assert_eq!(
+            nodes,
+            vec![element("TEXTAREA", 0), text("a", 1), element("div", 0), text("b", 1),]
+        );
+    }
+
+    #[test]
+    fn uppercase_title_keeps_following_sibling() {
+        let (nodes, errors) = parse_with_errors("<TITLE>a</TITLE><div>b</div>");
+        assert!(errors.is_empty(), "Expected no errors, got: {errors:?}");
+        assert_eq!(
+            nodes,
+            vec![element("TITLE", 0), text("a", 1), element("div", 0), text("b", 1),]
+        );
+    }
+
+    #[test]
+    fn lowercase_script_still_keeps_following_sibling_with_no_errors() {
+        // Confirm the lower-case path (already correct) is unaffected by the case fix.
+        let (nodes, errors) = parse_with_errors("<script>a</script><div>b</div>");
+        assert!(errors.is_empty(), "Expected no errors, got: {errors:?}");
+        assert_eq!(
+            nodes,
+            vec![element("script", 0), text("a", 1), element("div", 0), text("b", 1),]
+        );
+    }
+
+    // Codex finding F5: an IMPLICIT (un-prefixed) child of an SVG element must
+    // inherit the parent's namespace prefix, mirroring upstream `_getPrefix`.
+    // `<svg>` itself gets `:svg:` from its own `implicitNamespacePrefix`.
+
+    #[test]
+    fn svg_root_gets_implicit_namespace_prefix() {
+        // Upstream: `<svg></svg>` -> `:svg:svg` (implicitNamespacePrefix='svg').
+        let result = parse_and_humanize("<svg></svg>");
+        assert_eq!(result, vec![element(":svg:svg", 0)]);
+    }
+
+    #[test]
+    fn svg_implicit_child_inherits_namespace() {
+        // `<svg><rect></rect></svg>` -> `:svg:svg`, `:svg:rect`.
+        let result = parse_and_humanize("<svg><rect></rect></svg>");
+        assert_eq!(result, vec![element(":svg:svg", 0), element(":svg:rect", 1)]);
+    }
+
+    #[test]
+    fn svg_implicit_style_child_inherits_namespace() {
+        // The whole point of F5: an implicit `<style>` inside `<svg>` is `:svg:style`,
+        // NOT bare `style`, so it is not treated as a component-style element.
+        let result = parse_and_humanize("<svg><style>.x{}</style></svg>");
+        assert_eq!(result, vec![element(":svg:svg", 0), element(":svg:style", 1), text(".x{}", 2)]);
+    }
+
+    #[test]
+    fn foreign_object_children_reset_to_html() {
+        // `foreignObject` sets preventNamespaceInheritance, so its children do NOT
+        // inherit the svg namespace and stay in the HTML namespace (bare `div`).
+        // `foreignObject` itself is `:svg:foreignObject` (implicitNamespacePrefix='svg').
+        let result = parse_and_humanize("<svg><foreignObject><div></div></foreignObject></svg>");
+        assert_eq!(
+            result,
+            vec![element(":svg:svg", 0), element(":svg:foreignObject", 1), element("div", 2),]
+        );
+    }
+
+    #[test]
+    fn explicit_svg_style_still_namespaced() {
+        // Explicit `<svg:style>` keeps working and is namespaced `:svg:style` (regression
+        // guard for the explicit path). v21.2.7-faithful: the raw-text element closes on its
+        // LOCAL name, so the close tag here must be the bare `</style>`; `</svg:style>` would
+        // not close it (it would run to EOF as raw text).
+        let result = parse_and_humanize("<svg:style>x</style>");
+        assert_eq!(result, vec![element(":svg:style", 0), text("x", 1)]);
     }
 }
 
@@ -1740,6 +2278,140 @@ mod parser_component_tags {
         let result = parse_selectorless_and_humanize("<Comp/>");
         assert!(!result.is_empty());
     }
+
+    // Faithful to upstream v21.2.7: a selectorless-COMPONENT raw-text element
+    // (e.g. `<Comp:script>`, whose suffix `script` is RAW_TEXT, or `<Comp:title>`,
+    // whose suffix `title` is ESCAPABLE_RAW_TEXT) closes on the FULL prefixed component
+    // close name, matched CASE-INSENSITIVELY. In `_consumeTagOpen`
+    // (ml_parser/lexer.ts:821-827) the component branch builds
+    // `closingTagName = parts[0](+ ":" + prefix)(+ ":" + tagName)` (e.g. `Comp:script`),
+    // then closes via the SAME `_consumeRawTextWithTagClose(openToken, closingTagName, ...)`
+    // used by the regular path, whose boundary match is `_attemptStrCaseInsensitive`
+    // (line 900) — case-insensitive — while the emitted ComponentClose token uses
+    // `_endToken(openToken.parts)` (line 911), i.e. the ORIGINAL-case open-tag parts.
+    // So `</COMP:SCRIPT>` (different case) DOES close `<Comp:script>`, and the following
+    // `<div>after</div>` survives as a sibling. A genuinely different prefixed close name
+    // (`</Other:script>`) does NOT match and the raw text runs to EOF. These assertions
+    // were verified empirically against the lexer.
+    #[test]
+    fn component_raw_text_close_is_case_insensitive_and_keeps_sibling() {
+        // Same-case close: closes `<Comp:script>` and `<div>after</div>` is a sibling.
+        let result =
+            parse_selectorless_and_humanize("<Comp:script>evil</Comp:script><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element("Comp", 0), text("evil", 1), element("div", 0), text("after", 1),]
+        );
+
+        // DIFFERENT-case close `</COMP:SCRIPT>` closes the component raw-text element
+        // case-insensitively, leaving `<div>after</div>` as a sibling (the F1 fix). Before
+        // the fix this byte-sensitive compare failed and the scan swallowed to EOF.
+        let result =
+            parse_selectorless_and_humanize("<Comp:script>evil</COMP:SCRIPT><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element("Comp", 0), text("evil", 1), element("div", 0), text("after", 1),]
+        );
+
+        // Mixed-case close `</Comp:SCRIPT>` (only the suffix differs) also closes it.
+        let result =
+            parse_selectorless_and_humanize("<Comp:script>evil</Comp:SCRIPT><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element("Comp", 0), text("evil", 1), element("div", 0), text("after", 1),]
+        );
+    }
+
+    #[test]
+    fn component_escapable_raw_text_close_is_case_insensitive() {
+        // `<Comp:title>` has an ESCAPABLE_RAW_TEXT suffix (`title`); a different-case
+        // close `</COMP:TITLE>` closes it case-insensitively, `<div>after</div>` survives.
+        let result = parse_selectorless_and_humanize("<Comp:title>x</COMP:TITLE><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element("Comp", 0), text("x", 1), element("div", 0), text("after", 1),]
+        );
+    }
+
+    #[test]
+    fn component_raw_text_non_matching_close_runs_to_eof() {
+        // A genuinely DIFFERENT prefixed component close name does NOT match the boundary
+        // (the full prefixed name compare fails even case-insensitively), so the raw-text
+        // scan runs to EOF and swallows the trailing markup — proving the boundary is the
+        // FULL prefixed component close name, not a bare local name.
+        let result =
+            parse_selectorless_and_humanize("<Comp:script>evil</Other:script><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element("Comp", 0), text("evil</Other:script><div>after</div>", 1),]
+        );
+    }
+
+    // CURSOR ROLLBACK (faithful to upstream v21.2.7 `_consumeRawText`,
+    // ml_parser/lexer.ts:741-746): before each `</...>` close attempt the cursor is
+    // SNAPSHOTTED; on a FAILED attempt the cursor is RESTORED to the snapshot and the `<`
+    // is consumed as one ordinary text char, so a later VALID close is still found. Both
+    // the regular raw-text path and the component path now share that core, so a
+    // non-matching `</bad...>` candidate preceding the real `</Comp:script>` does NOT
+    // swallow the following `<div>` sibling to EOF. Before unification the component fork
+    // never rolled back the cursor, so the non-matching candidate consumed the real close
+    // and everything ran to EOF.
+    #[test]
+    fn component_raw_text_rolls_back_failed_close_and_keeps_real_close() {
+        let result =
+            parse_selectorless_and_humanize("<Comp:script>x</bad</Comp:script><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element("Comp", 0), text("x</bad", 1), element("div", 0), text("after", 1),]
+        );
+    }
+
+    // REGULAR-path parity sanity for the same rollback behavior (`<script>` is RAW_TEXT;
+    // its boundary is the bare local name `script`). A non-matching `</bad...>` candidate
+    // is rolled back and the real `</script>` still closes, keeping `<div>` as a sibling.
+    #[test]
+    fn regular_raw_text_rolls_back_failed_close_and_keeps_real_close() {
+        let result = parse_selectorless_and_humanize("<script>x</bad</script><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element("script", 0), text("x</bad", 1), element("div", 0), text("after", 1),]
+        );
+    }
+
+    // ENTITY DECODING for ESCAPABLE component raw text (faithful to upstream v21.2.7
+    // `_consumeRawText`, ml_parser/lexer.ts:747-751: when `consumeEntities` is true and the
+    // next char is `&`, the entity is decoded into an ENCODED_ENTITY token). `<Comp:title>`
+    // has an ESCAPABLE_RAW_TEXT suffix (`title`), so `&amp;` DECODES to `&`. The close is
+    // matched case-insensitively (`</COMP:TITLE>`) and `<div>after</div>` survives. Before
+    // unification the component fork used `consume_entities` only to pick the token type and
+    // never decoded, leaving the literal `&amp;`.
+    #[test]
+    fn component_escapable_raw_text_decodes_entities() {
+        let result =
+            parse_selectorless_and_humanize("<Comp:title>&amp;</COMP:TITLE><div>after</div>");
+        assert_eq!(
+            result,
+            vec![element("Comp", 0), text("&", 1), element("div", 0), text("after", 1),]
+        );
+    }
+
+    // ENTITY NON-DECODING for FLAT component raw text (faithful to upstream: `<Comp:script>`
+    // is RAW_TEXT, `consumeEntities=false`, so `_consumeRawText` never enters the entity
+    // branch and `&amp;` stays LITERAL). This mirrors the regular `<script>&amp;</script>`
+    // behavior — see `regular_raw_text_does_not_decode_entities` below.
+    #[test]
+    fn component_raw_text_does_not_decode_entities() {
+        let result = parse_selectorless_and_humanize("<Comp:script>&amp;</Comp:script>");
+        assert_eq!(result, vec![element("Comp", 0), text("&amp;", 1)]);
+    }
+
+    // REGULAR-path parity for entity non-decoding: `<script>` is RAW_TEXT, so `&amp;` stays
+    // literal — identical to the component `<Comp:script>` case above.
+    #[test]
+    fn regular_raw_text_does_not_decode_entities() {
+        let result = parse_selectorless_and_humanize("<script>&amp;</script>");
+        assert_eq!(result, vec![element("script", 0), text("&amp;", 1)]);
+    }
 }
 
 // ============================================================================
@@ -2206,9 +2878,11 @@ mod more_blocks {
     #[test]
     fn should_infer_namespace_through_block_boundary() {
         // TS: it("should infer namespace through block boundary")
+        // The @if block is skipped when finding the closest element-like parent, so
+        // `<circle/>` still inherits `:svg:` from the enclosing `<svg>`.
         let result = parse_and_humanize("<svg>@if (cond) {<circle/>}</svg>");
-        assert!(result.iter().any(|n| n.name() == Some("svg")));
-        assert!(result.iter().any(|n| n.name() == Some("circle")));
+        assert!(result.iter().any(|n| n.name() == Some(":svg:svg")));
+        assert!(result.iter().any(|n| n.name() == Some(":svg:circle")));
     }
 }
 
@@ -2459,3 +3133,473 @@ mod visitor_tests {
         assert!(result.iter().filter(|n| n.node_type() == Some("Attribute")).count() == 2);
     }
 }
+
+// ============================================================================
+// Selectorless component namespace inheritance
+//
+// Mirrors upstream `Parser._getComponentTagName` / `_getComponentFullName` /
+// `_getPrefix` (ml_parser/parser.ts ~924-1002): a selectorless component's tag
+// name inherits the parent implicit namespace exactly like a normal element.
+// OXC stores the *resolved* prefix in `HtmlElement.component_prefix` and the raw
+// tag name in `HtmlElement.component_tag_name`; the R3 transform then merges them
+// into `:prefix:tag`. These tests assert the resolved prefix/tag directly on the
+// parsed AST so they don't depend on the R3 transform.
+//
+// Ported from `html_parser_spec.ts` "component nodes" group, which the conformance
+// harness cannot capture: those upstream tests use the two-statement
+// `const parsed = humanizeDom(...); expect(parsed).toEqual([...])` pattern, which
+// the extractor stores as `expected: []`, and the conformance Humanizer humanizes
+// selectorless components as plain `html.Element` nodes (no component fields).
+// ============================================================================
+mod selectorless_component_namespace {
+    use oxc_allocator::Allocator;
+    use oxc_angular_compiler::ast::html::{HtmlElement, HtmlNode};
+    use oxc_angular_compiler::parser::html::HtmlParser;
+
+    /// Finds the first selectorless component element (one whose `name` is the
+    /// component class name, i.e. starts uppercase) anywhere in the tree and
+    /// returns its `(component_name, component_prefix, component_tag_name)`.
+    fn first_component<'a>(
+        nodes: &[HtmlNode<'a>],
+    ) -> Option<(String, Option<String>, Option<String>)> {
+        for node in nodes {
+            if let HtmlNode::Element(el) = node {
+                if el
+                    .name
+                    .as_str()
+                    .chars()
+                    .next()
+                    .is_some_and(|c| c.is_ascii_uppercase() || c == '_')
+                {
+                    return Some((
+                        el.name.to_string(),
+                        el.component_prefix.as_ref().map(|p| p.to_string()),
+                        el.component_tag_name.as_ref().map(|t| t.to_string()),
+                    ));
+                }
+                if let Some(found) = first_component(&el.children) {
+                    return Some(found);
+                }
+            }
+        }
+        None
+    }
+
+    fn parse_component(html: &str) -> (String, Option<String>, Option<String>) {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::with_selectorless(&allocator, html, "TestComp");
+        let result = parser.parse();
+        assert!(
+            result.errors.is_empty(),
+            "Unexpected parse errors for '{}': {:?}",
+            html,
+            result.errors.iter().map(|e| e.msg.clone()).collect::<Vec<_>>()
+        );
+        first_component(&result.nodes).unwrap_or_else(|| panic!("no component found in '{html}'"))
+    }
+
+    /// Local mirror of the R3 transform's tag-name/full-name composition
+    /// (html_to_r3.rs `visit_html_element` component branch) so the test asserts
+    /// the *observable* tagName/fullName upstream humanizes.
+    fn tag_and_full(
+        name: &str,
+        prefix: Option<&str>,
+        tag: Option<&str>,
+    ) -> (Option<String>, String) {
+        let tag_name = match (prefix, tag) {
+            (None, None) => None,
+            (None, Some(t)) => Some(t.to_string()),
+            (Some(p), None) => Some(format!(":{p}:ng-component")),
+            (Some(p), Some(t)) => Some(format!(":{p}:{t}")),
+        };
+        let full_name = match &tag_name {
+            Some(t) if t.starts_with(':') => format!("{name}{t}"),
+            Some(t) => format!("{name}:{t}"),
+            None => name.to_string(),
+        };
+        (tag_name, full_name)
+    }
+
+    #[test]
+    fn simple_component_no_namespace() {
+        // <MyComp> -> tagName null, fullName "MyComp"
+        let (name, prefix, tag) = parse_component("<MyComp>Hello</MyComp>");
+        assert_eq!((prefix.as_deref(), tag.as_deref()), (None, None));
+        let (tag_name, full_name) = tag_and_full(&name, prefix.as_deref(), tag.as_deref());
+        assert_eq!(tag_name, None);
+        assert_eq!(full_name, "MyComp");
+    }
+
+    #[test]
+    fn component_with_tag_name_no_namespace() {
+        // <MyComp:button> -> tagName "button", fullName "MyComp:button"
+        let (name, prefix, tag) = parse_component("<MyComp:button>Hello</MyComp:button>");
+        assert_eq!((prefix.as_deref(), tag.as_deref()), (None, Some("button")));
+        let (tag_name, full_name) = tag_and_full(&name, prefix.as_deref(), tag.as_deref());
+        assert_eq!(tag_name.as_deref(), Some("button"));
+        assert_eq!(full_name, "MyComp:button");
+    }
+
+    #[test]
+    fn component_with_explicit_namespace() {
+        // <MyComp:svg:title> -> tagName ":svg:title", fullName "MyComp:svg:title"
+        let (name, prefix, tag) = parse_component("<MyComp:svg:title>Hello</MyComp:svg:title>");
+        assert_eq!((prefix.as_deref(), tag.as_deref()), (Some("svg"), Some("title")));
+        let (tag_name, full_name) = tag_and_full(&name, prefix.as_deref(), tag.as_deref());
+        assert_eq!(tag_name.as_deref(), Some(":svg:title"));
+        assert_eq!(full_name, "MyComp:svg:title");
+    }
+
+    #[test]
+    fn inferred_svg_namespace_no_tag_name() {
+        // <svg><MyComp>...</svg> -> tagName ":svg:ng-component",
+        // fullName "MyComp:svg:ng-component" (parent <svg> implicit ns inherited).
+        let (name, prefix, tag) = parse_component("<svg><MyComp>Hello</MyComp></svg>");
+        assert_eq!((prefix.as_deref(), tag.as_deref()), (Some("svg"), None));
+        let (tag_name, full_name) = tag_and_full(&name, prefix.as_deref(), tag.as_deref());
+        assert_eq!(tag_name.as_deref(), Some(":svg:ng-component"));
+        assert_eq!(full_name, "MyComp:svg:ng-component");
+    }
+
+    #[test]
+    fn inferred_svg_namespace_with_tag_name() {
+        // <svg><MyComp:button>...</svg> -> tagName ":svg:button",
+        // fullName "MyComp:svg:button" (THE divergence case from the finding).
+        let (name, prefix, tag) =
+            parse_component("<svg><MyComp:button>Hello</MyComp:button></svg>");
+        assert_eq!((prefix.as_deref(), tag.as_deref()), (Some("svg"), Some("button")));
+        let (tag_name, full_name) = tag_and_full(&name, prefix.as_deref(), tag.as_deref());
+        assert_eq!(tag_name.as_deref(), Some(":svg:button"));
+        assert_eq!(full_name, "MyComp:svg:button");
+    }
+
+    #[test]
+    fn inferred_math_with_explicit_svg_namespace_wins() {
+        // <math><MyComp:svg:title>...</math>: an EXPLICIT prefix beats inheritance,
+        // so tagName stays ":svg:title", fullName "MyComp:svg:title".
+        let (name, prefix, tag) =
+            parse_component("<math><MyComp:svg:title>Hello</MyComp:svg:title></math>");
+        assert_eq!((prefix.as_deref(), tag.as_deref()), (Some("svg"), Some("title")));
+        let (tag_name, full_name) = tag_and_full(&name, prefix.as_deref(), tag.as_deref());
+        assert_eq!(tag_name.as_deref(), Some(":svg:title"));
+        assert_eq!(full_name, "MyComp:svg:title");
+    }
+
+    #[test]
+    fn non_svg_control_stays_unnamespaced() {
+        // Control: <div><MyComp:button>...</div> — a non-namespaced parent does NOT
+        // inject a namespace, so tagName stays "button", fullName "MyComp:button".
+        let (name, prefix, tag) =
+            parse_component("<div><MyComp:button>Hello</MyComp:button></div>");
+        assert_eq!((prefix.as_deref(), tag.as_deref()), (None, Some("button")));
+        let (tag_name, full_name) = tag_and_full(&name, prefix.as_deref(), tag.as_deref());
+        assert_eq!(tag_name.as_deref(), Some("button"));
+        assert_eq!(full_name, "MyComp:button");
+    }
+
+    #[test]
+    fn foreign_object_prevents_namespace_inheritance() {
+        // <svg><foreignObject><MyComp:button>...: foreignObject prevents namespace
+        // inheritance, so the component does NOT inherit `:svg:` -> tagName "button".
+        let (name, prefix, tag) = parse_component(
+            "<svg><foreignObject><MyComp:button>Hello</MyComp:button></foreignObject></svg>",
+        );
+        assert_eq!((prefix.as_deref(), tag.as_deref()), (None, Some("button")));
+        let (tag_name, full_name) = tag_and_full(&name, prefix.as_deref(), tag.as_deref());
+        assert_eq!(tag_name.as_deref(), Some("button"));
+        assert_eq!(full_name, "MyComp:button");
+    }
+
+    // Silence unused-import warnings if the helper signature changes.
+    #[allow(dead_code)]
+    fn _uses(_e: &HtmlElement<'_>) {}
+}
+
+// ============================================================================
+// Selectorless-component CHILD namespace inheritance (the iteration-11 finding)
+//
+// Upstream `_getPrefix` (ml_parser/parser.ts:990-998) inherits a child's namespace
+// from the closest element-like parent's NAME: for an `html.Element` parent that is
+// `parent.name`, but for an `html.Component` parent it is `parent.tagName` (line 991:
+// `parent instanceof html.Element ? parent.name : parent.tagName`) — i.e. the
+// RESOLVED component tag name (`:svg:button`), NOT the component class name (`MyComp`).
+// `getNsPrefix(':svg:button')` is `'svg'`, so a child with no explicit/implicit
+// namespace inherits `:svg:`. These tests assert the resolved CHILD element names.
+// ============================================================================
+mod selectorless_component_child_namespace {
+    use super::{HumanizedNode, element, parse_selectorless_and_humanize, text};
+
+    /// Returns the resolved name of the first element whose humanized name equals
+    /// `child_name` is unnecessary; instead we assert on the full humanized tree.
+    fn humanize(html: &str) -> Vec<HumanizedNode> {
+        parse_selectorless_and_humanize(html)
+    }
+
+    #[test]
+    fn child_div_inherits_svg_through_component_with_tag_name() {
+        // <svg><MyComp:button><div></div></MyComp:button></svg>
+        // Component tagName resolves to `:svg:button`; getNsPrefix -> 'svg', so the
+        // child <div> inherits and resolves to `:svg:div` (NOT plain html `div`).
+        let result = humanize("<svg><MyComp:button><div></div></MyComp:button></svg>");
+        assert_eq!(
+            result,
+            vec![
+                element(":svg:svg", 0),
+                // Component humanizes by its class name at depth 1.
+                element("MyComp", 1),
+                element(":svg:div", 2),
+            ]
+        );
+    }
+
+    #[test]
+    fn child_script_inherits_svg_and_is_kept_namespaced() {
+        // The security-relevant case: a <script> child under a namespaced component
+        // parent resolves to `:svg:script`, which is foreign and parsed as a normal
+        // element (children/raw-text handled by the svg path), NOT the plain-html
+        // `script` special path. The parser keeps it as `:svg:script`.
+        let result = humanize("<svg><MyComp:button><script>x</script></MyComp:button></svg>");
+        assert_eq!(
+            result,
+            vec![
+                element(":svg:svg", 0),
+                element("MyComp", 1),
+                element(":svg:script", 2),
+                text("x", 3),
+            ]
+        );
+    }
+
+    #[test]
+    fn child_style_inherits_svg_and_is_kept_namespaced() {
+        let result = humanize("<svg><MyComp:button><style>x</style></MyComp:button></svg>");
+        assert_eq!(
+            result,
+            vec![
+                element(":svg:svg", 0),
+                element("MyComp", 1),
+                element(":svg:style", 2),
+                text("x", 3),
+            ]
+        );
+    }
+
+    #[test]
+    fn child_inherits_svg_through_explicitly_namespaced_component() {
+        // Explicit `<MyComp:svg:rect>` (no enclosing <svg> needed): tagName `:svg:rect`,
+        // getNsPrefix -> 'svg', so the child <circle> inherits -> `:svg:circle`.
+        let result = humanize("<MyComp:svg:rect><circle></circle></MyComp:svg:rect>");
+        assert_eq!(result, vec![element("MyComp", 0), element(":svg:circle", 1)]);
+    }
+
+    #[test]
+    fn child_inherits_svg_through_component_without_tag_part_under_svg() {
+        // <svg><MyComp><div></div></MyComp></svg>: per `_getComponentTagName`
+        // (parser.ts:946-961), with prefix='svg' (inherited) and no tagName, the
+        // component tagName is `mergeNsAndName('svg','ng-component')` = `:svg:ng-component`
+        // (NOT null). getNsPrefix(':svg:ng-component') -> 'svg', so the child <div>
+        // inherits -> `:svg:div`.
+        let result = humanize("<svg><MyComp><div></div></MyComp></svg>");
+        assert_eq!(
+            result,
+            vec![element(":svg:svg", 0), element("MyComp", 1), element(":svg:div", 2),]
+        );
+    }
+
+    #[test]
+    fn control_non_svg_component_child_stays_html() {
+        // CONTROL: <MyComp:button><div></div></MyComp:button> outside any svg.
+        // Component tagName resolves to `button` (no namespace); getNsPrefix('button')
+        // -> null, so the child <div> stays plain html `div`.
+        let result = humanize("<MyComp:button><div></div></MyComp:button>");
+        assert_eq!(result, vec![element("MyComp", 0), element("div", 1)]);
+    }
+
+    #[test]
+    fn control_bare_component_child_stays_html() {
+        // CONTROL: bare <MyComp><div></div></MyComp> outside any svg.
+        // `_getComponentTagName` with no prefix and no tagName returns null
+        // (parser.ts:953-954) -> fullName is `MyComp`; getNsPrefix(null)/'' -> null,
+        // so the child <div> stays plain html `div`.
+        let result = humanize("<MyComp><div></div></MyComp>");
+        assert_eq!(result, vec![element("MyComp", 0), element("div", 1)]);
+    }
+
+    #[test]
+    fn grandchild_inherits_svg_transitively_through_component() {
+        // Deeper nesting: <svg><MyComp:button><g><circle/></g></MyComp:button></svg>
+        // <g> inherits `:svg:` from the component (-> `:svg:g`), and <circle> then
+        // inherits `:svg:` from `:svg:g` (a normal element parent) -> `:svg:circle`.
+        let result = humanize("<svg><MyComp:button><g><circle></circle></g></MyComp:button></svg>");
+        assert_eq!(
+            result,
+            vec![
+                element(":svg:svg", 0),
+                element("MyComp", 1),
+                element(":svg:g", 2),
+                element(":svg:circle", 3),
+            ]
+        );
+    }
+}
+
+// ============================================================================
+// FINDING 2: a selectorless-component CLOSE tag must match the open element by its
+// RESOLVED FULL name (`componentName(+:prefix):tag`), not the bare class name.
+//
+// Upstream v21.2.7 `Parser._consumeComponentEndTag` (ml_parser/parser.ts:530-546):
+//   const fullName = this._getComponentFullName(endToken, this._getClosestElementLikeParent());
+//   if (!this._popContainer(fullName, html.Component, endToken.sourceSpan)) {
+//     const container = this._containerStack[this._containerStack.length - 1];
+//     let suffix: string;
+//     if (container instanceof html.Component && container.componentName === endToken.parts[0]) {
+//       suffix = `, did you mean "${container.fullName}"?`;
+//     } else {
+//       suffix = '. It may happen when the tag has already been closed by another tag.';
+//     }
+//     const errMsg = `Unexpected closing tag "${fullName}"${suffix}`;
+//     this.errors.push(TreeError.create(fullName, endToken.sourceSpan, errMsg));
+//   }
+// `_popContainer` (lines 592-621) matches against `node.fullName` for an
+// `html.Component` (line 600), so the close full name is composed via the SAME
+// `_getComponentFullName`/`_getComponentTagName`/`_getPrefix` logic as the open —
+// INCLUDING parent-namespace inheritance from the closest element-like parent (which,
+// at close time, is the still-open component itself, carrying its resolved tagName).
+// ============================================================================
+mod selectorless_component_close_match {
+    use super::{element, parse_selectorless_and_humanize, text};
+    use oxc_allocator::Allocator;
+    use oxc_angular_compiler::parser::html::HtmlParser;
+
+    fn selectorless_errors(html: &str) -> Vec<String> {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::with_selectorless(&allocator, html, "TestComp");
+        let result = parser.parse();
+        result.errors.iter().map(|e| e.msg.clone()).collect()
+    }
+
+    #[test]
+    fn mismatched_tag_part_reports_error() {
+        // Open `MyComp:button`, close `MyComp:link`: full names differ
+        // (MyComp:button vs MyComp:link) -> does NOT silently close. Same componentName
+        // -> "did you mean" suffix quoting the open full name.
+        let errors = selectorless_errors("<MyComp:button></MyComp:link>");
+        assert!(
+            errors
+                .iter()
+                .any(|e| e
+                    == "Unexpected closing tag \"MyComp:link\", did you mean \"MyComp:button\"?"),
+            "expected mismatch error, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn mismatched_class_name_reports_error() {
+        // Open `MyComp:button`, close `Other:button`: full names differ; different
+        // componentName -> generic "may happen" suffix.
+        let errors = selectorless_errors("<MyComp:button></Other:button>");
+        assert!(
+            errors.iter().any(|e| e
+                == "Unexpected closing tag \"Other:button\". It may happen when the tag has already been closed by another tag."),
+            "expected class-mismatch error, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn matching_full_name_closes_cleanly() {
+        // Open and close both `MyComp:button` -> closes cleanly, no error.
+        let errors = selectorless_errors("<MyComp:button></MyComp:button>");
+        assert!(errors.is_empty(), "expected no error, got: {errors:?}");
+
+        let result = parse_selectorless_and_humanize("<MyComp:button></MyComp:button>");
+        assert_eq!(result, vec![element("MyComp", 0)]);
+    }
+
+    #[test]
+    fn matching_full_name_under_svg_closes_cleanly() {
+        // SUBTLE inheritance case: open `<MyComp:button>` under `<svg>` resolves to
+        // fullName `MyComp:svg:button` (button inherits svg). The close
+        // `</MyComp:button>` (no explicit svg) ALSO inherits svg from the closest
+        // element-like parent (the still-open MyComp, whose resolved tagName is
+        // `:svg:button`), so its full name is ALSO `MyComp:svg:button` -> they MATCH.
+        // Upstream-faithful: NO error.
+        let errors = selectorless_errors("<svg><MyComp:button></MyComp:button></svg>");
+        assert!(errors.is_empty(), "expected no error under svg, got: {errors:?}");
+
+        let result = parse_selectorless_and_humanize("<svg><MyComp:button></MyComp:button></svg>");
+        assert_eq!(result, vec![element(":svg:svg", 0), element("MyComp", 1)]);
+    }
+
+    #[test]
+    fn bare_component_closes_cleanly() {
+        // Open/close bare `<MyComp>` -> closes cleanly, no error.
+        let errors = selectorless_errors("<MyComp></MyComp>");
+        assert!(errors.is_empty(), "expected no error, got: {errors:?}");
+
+        let result = parse_selectorless_and_humanize("<MyComp>hi</MyComp>");
+        assert_eq!(result, vec![element("MyComp", 0), text("hi", 1)]);
+    }
+}
+
+// ============================================================================
+// FINDING 3: the void-element end-tag error must attach the FULL close-token
+// source span (`endTagToken.sourceSpan`), not a zero-length caret at the start.
+//
+// Upstream v21.2.7 `_consumeElementEndTag` (ml_parser/parser.ts:569-584):
+//   if (this._getTagDefinition(fullName)?.isVoid) {
+//     this.errors.push(TreeError.create(
+//       fullName, endTagToken.sourceSpan,
+//       `Void elements do not have end tags "${endTagToken.parts[1]}"`));
+//   }
+//
+// Oracle (@angular/compiler@21.2.7 HtmlParser.parse):
+//   "<input></input>"                  -> msg `Void elements do not have end
+//        tags "input"`, span offset 7..15, line 0 col 7..15
+//   "<div>\n  <input></input>\n</div>" -> span offset 15..23, line 1 col 9..17
+// ============================================================================
+mod void_end_tag_span {
+    use oxc_allocator::Allocator;
+    use oxc_angular_compiler::parser::html::HtmlParser;
+
+    #[test]
+    fn void_input_close_uses_full_close_token_span() {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::new(&allocator, "<input></input>", "TestComp");
+        let result = parser.parse();
+        let err = result
+            .errors
+            .iter()
+            .find(|e| e.msg.contains("Void elements do not have end tags"))
+            .expect("expected a void end-tag error");
+        assert_eq!(err.msg, "Void elements do not have end tags \"input\"");
+        // FULL close-token span `</input>` (offset 7..15), NOT a zero-length caret.
+        assert_eq!(err.span.start.offset, 7, "start offset");
+        assert_eq!(err.span.end.offset, 15, "end offset (must NOT equal start)");
+        assert_ne!(err.span.start.offset, err.span.end.offset, "must not be zero-length");
+        assert_eq!(err.span.start.line, 0);
+        assert_eq!(err.span.start.col, 7);
+        assert_eq!(err.span.end.line, 0);
+        assert_eq!(err.span.end.col, 15);
+    }
+
+    #[test]
+    fn void_input_close_multiline_span_has_correct_line_col() {
+        let allocator = Allocator::default();
+        let src = "<div>\n  <input></input>\n</div>";
+        let parser = HtmlParser::new(&allocator, src, "TestComp");
+        let result = parser.parse();
+        let err = result
+            .errors
+            .iter()
+            .find(|e| e.msg.contains("Void elements do not have end tags"))
+            .expect("expected a void end-tag error");
+        assert_eq!(err.msg, "Void elements do not have end tags \"input\"");
+        // `</input>` on the second line: offset 15..23, line 1, col 9..17.
+        assert_eq!(err.span.start.offset, 15, "start offset");
+        assert_eq!(err.span.end.offset, 23, "end offset");
+        assert_eq!(err.span.start.line, 1, "start line");
+        assert_eq!(err.span.start.col, 9, "start col");
+        assert_eq!(err.span.end.line, 1, "end line");
+        assert_eq!(err.span.end.col, 17, "end col");
+    }
+}
diff --git a/crates/oxc_angular_compiler/tests/namespaced_attr_codegen_test.rs b/crates/oxc_angular_compiler/tests/namespaced_attr_codegen_test.rs
new file mode 100644
index 000000000..5f5952f65
--- /dev/null
+++ b/crates/oxc_angular_compiler/tests/namespaced_attr_codegen_test.rs
@@ -0,0 +1,127 @@
+//! Finding 2: namespaced `attr.` bindings must emit the v21.2.7-faithful
+//! `ɵɵattribute(name, value, sanitizer?, namespace?)` form.
+//!
+//! TEMPLATE path: upstream `createBoundElementProperty` stores the merged
+//! `:ns:local` name (`mergeNsAndName`), so `binding_specialization`'s
+//! `splitNsName` splits it and codegen emits the namespace argument with the
+//! LOCAL name. This works for ANY namespace prefix (not just well-known ones).
+//!
+//! HOST path: upstream host ingest stores the PLAIN name (no merge), so
+//! `splitNsName("xlink:href") = [null, "xlink:href"]` does NOT split and codegen
+//! emits `ɵɵattribute("xlink:href", ...)` with NO namespace argument.
+//!
+//! All expected `ɵɵattribute(...)` forms below were captured from
+//! @angular/compiler@21.2.7 via `parseTemplate` + `compileComponentFromMetadata`
+//! / `compileDirectiveFromMetadata` (the oracle), NOT from OXC.
+
+use oxc_allocator::Allocator;
+use oxc_angular_compiler::transform_angular_file;
+
+fn compile(source: &str, file: &str) -> String {
+    let allocator = Allocator::default();
+    let result = transform_angular_file(&allocator, file, source, None, None);
+    assert!(!result.has_errors(), "compile errors: {:?}", result.diagnostics);
+    result.code
+}
+
+fn component_with_template(template: &str) -> String {
+    let source = format!(
+        r#"
+import {{ Component }} from '@angular/core';
+
+@Component({{
+    selector: 'test-cmp',
+    template: '{template}'
+}})
+export class TestCmp {{
+    u = '';
+}}
+"#
+    );
+    compile(&source, "test.component.ts")
+}
+
+fn directive_with_host(selector: &str, host: &str) -> String {
+    let source = format!(
+        r#"
+import {{ Directive }} from '@angular/core';
+
+@Directive({{
+    selector: '{selector}',
+    host: {{ {host} }}
+}})
+export class TestDir {{
+    url = '';
+}}
+"#
+    );
+    compile(&source, "test.directive.ts")
+}
+
+// ---------------------------------------------------------------------------
+// TEMPLATE path: well-known prefix `xlink` -> local name + namespace arg.
+// Upstream: ɵɵattribute("href", ctx.u, ɵɵsanitizeUrl, "xlink")
+// ---------------------------------------------------------------------------
+#[test]
+fn template_attr_xlink_href_emits_local_name_and_namespace() {
+    let code = component_with_template(r#"<svg><a [attr.xlink:href]=\"u\"></a></svg>"#);
+    assert!(
+        code.contains(r#"ɵɵattribute("href",ctx.u,i0.ɵɵsanitizeUrl,"xlink")"#),
+        "expected ɵɵattribute(\"href\", ..., ɵɵsanitizeUrl, \"xlink\").\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// TEMPLATE path: ARBITRARY (non-well-known) prefix must ALSO split, because
+// upstream stores the merged `:custom:foo` form and `splitNsName` is prefix-
+// agnostic. Upstream: ɵɵattribute("foo", ctx.u, null, "custom")
+// (This is the case the old OXC `KNOWN_NS_PREFIXES`-only split got WRONG.)
+// ---------------------------------------------------------------------------
+#[test]
+fn template_attr_custom_prefix_emits_local_name_and_namespace() {
+    let code = component_with_template(r#"<svg><a [attr.custom:foo]=\"u\"></a></svg>"#);
+    assert!(
+        code.contains(r#"ɵɵattribute("foo",ctx.u,null,"custom")"#),
+        "expected ɵɵattribute(\"foo\", ctx.u, null, \"custom\") for an arbitrary ns prefix.\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// TEMPLATE control: non-namespaced attr stays a plain 2-arg call.
+// Upstream: ɵɵattribute("foo", ctx.u)
+// ---------------------------------------------------------------------------
+#[test]
+fn template_attr_plain_no_namespace_arg() {
+    let code = component_with_template(r#"<div [attr.foo]=\"u\"></div>"#);
+    assert!(
+        code.contains(r#"ɵɵattribute("foo",ctx.u)"#),
+        "expected plain ɵɵattribute(\"foo\", ctx.u).\nGot:\n{code}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// HOST path: name kept PLAIN, NO namespace argument (upstream host ingest never
+// merges; splitNsName("xlink:href") does not split).
+// Upstream: ɵɵattribute("xlink:href", ctx.url, ɵɵsanitizeUrl)
+// ---------------------------------------------------------------------------
+#[test]
+fn host_attr_xlink_href_keeps_plain_name_no_namespace() {
+    let code = directive_with_host("a[appLink]", r#"'[attr.xlink:href]': 'url'"#);
+    assert!(
+        code.contains(r#"ɵɵattribute("xlink:href",ctx.url,i0.ɵɵsanitizeUrl)"#),
+        "expected host ɵɵattribute(\"xlink:href\", ctx.url, ɵɵsanitizeUrl) with NO namespace arg.\nGot:\n{code}"
+    );
+    assert!(
+        !code.contains(r#"ɵɵattribute("href",ctx.url"#),
+        "host path must NOT split xlink:href into local name + namespace.\nGot:\n{code}"
+    );
+}
+
+#[test]
+fn host_attr_custom_prefix_keeps_plain_name_no_namespace() {
+    let code = directive_with_host("[appLink]", r#"'[attr.custom:foo]': 'url'"#);
+    assert!(
+        code.contains(r#"ɵɵattribute("custom:foo",ctx.url)"#),
+        "expected host ɵɵattribute(\"custom:foo\", ctx.url) with NO namespace arg.\nGot:\n{code}"
+    );
+}
diff --git a/crates/oxc_angular_compiler/tests/r3_template_transform_test.rs b/crates/oxc_angular_compiler/tests/r3_template_transform_test.rs
index de6102647..aadfa3882 100644
--- a/crates/oxc_angular_compiler/tests/r3_template_transform_test.rs
+++ b/crates/oxc_angular_compiler/tests/r3_template_transform_test.rs
@@ -765,6 +765,45 @@ fn get_transform_errors(html: &str) -> Vec<String> {
     r3_result.errors.iter().map(|e| e.msg.clone()).collect()
 }
 
+/// Helper that transforms an HTML template and returns, for the first element's
+/// first bound-attribute input, a `(name, binding_type, security_context)`
+/// tuple as strings. Used by the SVG/security tests to assert the resolved
+/// `SecurityContext` (which the standard humanizer does not expose).
+fn first_input_security(html: &str) -> (String, BindingType, String) {
+    use oxc_angular_compiler::ast::r3::{R3Node, SecurityContext};
+
+    let allocator = Box::new(Allocator::default());
+    let allocator_ref: &'static Allocator =
+        unsafe { &*std::ptr::from_ref::<Allocator>(allocator.as_ref()) };
+
+    let parser = HtmlParser::new(allocator_ref, html, "test.html");
+    let html_result = parser.parse();
+
+    let options = TransformOptions { collect_comment_nodes: false };
+    let transformer = HtmlToR3Transform::new(allocator_ref, html, options);
+    let r3_result = transformer.transform(&html_result.nodes);
+
+    let element = r3_result
+        .nodes
+        .iter()
+        .find_map(|n| if let R3Node::Element(e) = n { Some(e) } else { None })
+        .expect("expected at least one element");
+    let input = element.inputs.first().expect("expected at least one bound-attribute input");
+
+    let sc = match input.security_context {
+        SecurityContext::None => "None",
+        SecurityContext::Html => "Html",
+        SecurityContext::Style => "Style",
+        SecurityContext::Script => "Script",
+        SecurityContext::Url => "Url",
+        SecurityContext::ResourceUrl => "ResourceUrl",
+        SecurityContext::AttributeNoBinding => "AttributeNoBinding",
+        SecurityContext::UrlOrResourceUrl => "UrlOrResourceUrl",
+    };
+
+    (input.name.to_string(), input.binding_type, sc.to_string())
+}
+
 // ============================================================================
 // Tests: Nodes without binding
 // ============================================================================
@@ -1352,6 +1391,163 @@ mod ignored_elements {
         assert_eq!(result[0], h!["Text", "a"]);
     }
 
+    #[test]
+    fn should_keep_namespaced_svg_script_elements() {
+        // v21.2.7 template_preparser.ts compares the FULL lower-cased node name
+        // against `SCRIPT_ELEMENT = 'script'` (a singular string, lines 18,45,51).
+        // An explicitly namespaced `:svg:script` is NOT equal to 'script', so it
+        // stays `PreparsedElementType.OTHER` and is KEPT as an element (only plain
+        // `<script>` is dropped). This is the genuine SVGScriptElement XSS sink,
+        // whose href is sanitized as a RESOURCE_URL by dom_security_schema.
+        // (angular/angular MAIN later widened SCRIPT_ELEMENT to a Set including
+        // ':svg:script' via commit 90494cd909, but that post-dates v21.2.7.)
+        //
+        // v21.2.7-faithful note: a namespaced raw-text element closes on its LOCAL name
+        // only (case-insensitive); `</svg:script>` would NOT close it (the boundary is bare
+        // `script`) and the scan would run to EOF. We therefore close with a BARE `</script>`
+        // so the `:svg:script` element closes cleanly and the `<div>` survives as a sibling —
+        // which keeps this test focused on G4's actual point (the `:svg:script` element is
+        // KEPT, not stripped).
+        let result = humanize("<svg:script>x</script><div>after</div>");
+        assert_eq!(result[0], h!["Element", ":svg:script"]);
+        // The script's raw-text content survives because the element is kept,
+        // and the following <div> sibling is unaffected.
+        assert!(result.iter().any(|r| r[0] == HumanValue::from("Text") && r[1] == "x".into()));
+        assert!(result.iter().any(|r| r[0] == HumanValue::from("Element") && r[1] == "div".into()));
+    }
+
+    // -----------------------------------------------------------------------
+    // SVG <script> href / xlink:href security-context faithfulness to v21.2.7.
+    //
+    // Ground truth derived by reading vendored v21.2.7 (commit 50761c8be4):
+    //
+    // - `_consumeAttr` (ml_parser/parser.ts:624) stores a namespaced attribute
+    //   `xlink:href` in MERGED colon form `:xlink:href` via `mergeNsAndName`.
+    // - `<svg:script>` element name is the merged `:svg:script`.
+    // - `createBoundElementProperty` (binding_parser.ts:543-632):
+    //     * `[attr.xlink:href]` -> `parts[0]=="attr"`, security lookup propName =
+    //       `xlink:href` (PLAIN colon, isAttribute=true), THEN the stored
+    //       BoundAttribute name is merged to `:xlink:href` via `mergeNsAndName`
+    //       (binding_parser.ts:582-587). (Finding 2.)
+    //     * `[xlink:href]`       -> property binding; the `[...]` lexer path keeps
+    //       the bare name `xlink:href` (PLAIN colon), isAttribute=false.
+    //     * `xlink:href="{{u}}"` (interpolated STATIC attr) -> property binding
+    //       with the FULL merged name `:xlink:href` (LEADING colon retained,
+    //       no `.`-split happens), isAttribute=false.
+    // - `CssSelector.parse(":svg:script")` (directive_matching.ts:9-20 regexp)
+    //   drops the leading `:` and namespace, leaving element = `script` (local).
+    // - `securityContext("script", propName, isAttribute)`
+    //   (dom_element_schema_registry.ts:437-457) lowercases and looks up
+    //   `script|propName`, falling back to `*|propName`, else NONE. The schema
+    //   keys are `script|href` and `script|xlink:href` -> RESOURCE_URL
+    //   (dom_security_schema.ts:124-125).
+    //
+    // Therefore upstream v21.2.7 sanitizes:
+    //   `[attr.xlink:href]`, `[xlink:href]`, `[(xlink:href)]`,
+    //   `href="{{u}}"`, `[attr.href]`, `[href]`
+    // as RESOURCE_URL, but does NOT sanitize the INTERPOLATED static
+    //   `xlink:href="{{u}}"` (its lookup key is `script|:xlink:href`, a MISS,
+    //   because the merged colon form is passed verbatim as a property name).
+    //
+    // These tests assert OXC matches that exact behavior. The values were
+    // observed empirically (see PR notes) — they are NOT assumptions.
+
+    #[test]
+    fn svg_script_bracketed_xlink_href_is_resource_url() {
+        // `[xlink:href]` property binding -> name kept `xlink:href`, key
+        // `script|xlink:href` -> RESOURCE_URL (matches v21.2.7).
+        assert_eq!(
+            first_input_security(r#"<svg:script [xlink:href]="u"></svg:script>"#),
+            ("xlink:href".to_string(), BindingType::Property, "ResourceUrl".to_string()),
+        );
+    }
+
+    #[test]
+    fn svg_script_attr_xlink_href_is_resource_url() {
+        // `[attr.xlink:href]` attribute binding -> `attr.` stripped, security
+        // computed with the PLAIN `xlink:href` (key `script|xlink:href` ->
+        // RESOURCE_URL), THEN the stored binding name is the namespace-bearing
+        // merged form `:xlink:href` (upstream `createBoundElementProperty`
+        // `mergeNsAndName`, binding_parser.ts:582-587). Confirmed against
+        // @angular/compiler@21.2.7: `parseTemplate('<svg><script
+        // [attr.xlink:href]="u">')` yields BoundAttribute name `:xlink:href`,
+        // securityContext RESOURCE_URL (Finding 2 fix).
+        assert_eq!(
+            first_input_security(r#"<svg:script [attr.xlink:href]="u"></svg:script>"#),
+            (":xlink:href".to_string(), BindingType::Attribute, "ResourceUrl".to_string()),
+        );
+    }
+
+    #[test]
+    fn svg_script_bracketed_href_is_resource_url() {
+        // Non-xlink control proving G2 still works through the lookup:
+        // `[href]` -> key `script|href` -> RESOURCE_URL.
+        assert_eq!(
+            first_input_security(r#"<svg:script [href]="u"></svg:script>"#),
+            ("href".to_string(), BindingType::Property, "ResourceUrl".to_string()),
+        );
+    }
+
+    #[test]
+    fn svg_script_attr_href_is_resource_url() {
+        // `[attr.href]` -> key `script|href` -> RESOURCE_URL.
+        assert_eq!(
+            first_input_security(r#"<svg:script [attr.href]="u"></svg:script>"#),
+            ("href".to_string(), BindingType::Attribute, "ResourceUrl".to_string()),
+        );
+    }
+
+    #[test]
+    fn svg_script_interpolated_href_is_resource_url() {
+        // Interpolated static `href="{{u}}"` -> property binding with name
+        // `href` (no namespace), key `script|href` -> RESOURCE_URL. This proves
+        // the non-namespaced interpolated case IS sanitized (matches v21.2.7).
+        assert_eq!(
+            first_input_security(r#"<svg:script href="{{u}}"></svg:script>"#),
+            ("href".to_string(), BindingType::Property, "ResourceUrl".to_string()),
+        );
+    }
+
+    #[test]
+    fn svg_script_interpolated_xlink_href_is_none_matching_upstream() {
+        // CRITICAL faithfulness case: interpolated static `xlink:href="{{u}}"`
+        // is stored as the merged `:xlink:href` and treated as a PROPERTY
+        // binding with that full name. Upstream's lookup key is
+        // `script|:xlink:href` (leading colon retained) -> MISS -> NONE. OXC
+        // must NOT sanitize this either (no over-sanitization). The emitted
+        // binding name is the merged `:xlink:href`, unchanged.
+        assert_eq!(
+            first_input_security(r#"<svg:script xlink:href="{{u}}"></svg:script>"#),
+            (":xlink:href".to_string(), BindingType::Property, "None".to_string()),
+        );
+    }
+
+    #[test]
+    fn svg_image_interpolated_xlink_href_is_none_matching_upstream() {
+        // `<svg:image>` is NOT in the RESOURCE_URL/URL schema for `xlink:href`
+        // (only the MathML elements + `a` are URL; `image` is not listed). An
+        // interpolated static `xlink:href="{{u}}"` resolves to NONE both because
+        // the merged-name property lookup misses and because `image|xlink:href`
+        // is not a schema key. Control case proving no over-sanitization.
+        assert_eq!(
+            first_input_security(r#"<svg:image xlink:href="{{u}}"></svg:image>"#),
+            (":xlink:href".to_string(), BindingType::Property, "None".to_string()),
+        );
+    }
+
+    #[test]
+    fn svg_script_non_sensitive_namespaced_attr_stays_none() {
+        // Control: a non-sensitive namespaced attribute binding on `<svg:script>`
+        // must remain NONE (no over-sanitization from any normalization). The
+        // stored name is the merged `:xlink:title` form (Finding 2). Confirmed
+        // against @angular/compiler@21.2.7: BoundAttribute name `:xlink:title`,
+        // securityContext NONE.
+        assert_eq!(
+            first_input_security(r#"<svg:script [attr.xlink:title]="u"></svg:script>"#),
+            (":xlink:title".to_string(), BindingType::Attribute, "None".to_string()),
+        );
+    }
+
     #[test]
     fn should_ignore_style_elements() {
         // TS: expectFromHtml('<style></style>a')
@@ -1837,6 +2033,60 @@ mod svg_elements {
                     && r[1] == HumanValue::from(":svg:rect"))
         );
     }
+
+    #[test]
+    fn foreign_object_children_reset_to_html_namespace() {
+        // Upstream html_tags.ts declares `foreignObject` with
+        // `implicitNamespacePrefix:'svg'` AND `preventNamespaceInheritance:true`
+        // (v21.2.7 html_tags.ts:132-142): the element itself is SVG (stored
+        // `:svg:foreignObject`), but its CHILDREN do NOT inherit the svg namespace —
+        // they reset to HTML. So `<div>` inside foreignObject is plain `div`, NOT
+        // `:svg:div`.
+        let result = humanize("<svg><foreignObject><div></div></foreignObject></svg>");
+        assert_eq!(result[0], h!["Element", ":svg:svg"]);
+        // foreignObject element itself stays namespaced.
+        assert!(result.iter().any(|r| r[0] == HumanValue::from("Element")
+            && r[1] == HumanValue::from(":svg:foreignObject")));
+        // Its child div is HTML, not :svg:div.
+        assert!(
+            result
+                .iter()
+                .any(|r| r[0] == HumanValue::from("Element") && r[1] == HumanValue::from("div"))
+        );
+        assert!(
+            !result.iter().any(
+                |r| r[0] == HumanValue::from("Element") && r[1] == HumanValue::from(":svg:div")
+            ),
+            "foreignObject child must not be emitted in the svg namespace: {result:?}"
+        );
+    }
+
+    #[test]
+    fn svg_sibling_after_foreign_object_stays_svg() {
+        // Sanity: resetting foreignObject's children to HTML must not leak into
+        // svg siblings. A `<rect>` sibling (back under `<svg>`) is still `:svg:rect`,
+        // and grandchildren of foreignObject (`<span>`) remain HTML.
+        let result = humanize(
+            "<svg><foreignObject><div><span></span></div></foreignObject><rect></rect></svg>",
+        );
+        assert!(
+            result
+                .iter()
+                .any(|r| r[0] == HumanValue::from("Element") && r[1] == HumanValue::from("div"))
+        );
+        assert!(
+            result
+                .iter()
+                .any(|r| r[0] == HumanValue::from("Element") && r[1] == HumanValue::from("span"))
+        );
+        assert!(
+            result
+                .iter()
+                .any(|r| r[0] == HumanValue::from("Element")
+                    && r[1] == HumanValue::from(":svg:rect")),
+            "svg sibling after foreignObject must stay in svg namespace: {result:?}"
+        );
+    }
 }
 
 // ============================================================================
@@ -2322,6 +2572,63 @@ mod switch_validation {
             "Expected error about @default with parameters, got: {errors:?}"
         );
     }
+
+    // Upstream v21.2.7 only recognizes the EXACT `default never` (single internal
+    // space) as the exhaustive marker; `_getBlockName` trims but does NOT collapse
+    // internal whitespace (ml_parser/lexer.ts:294, render3/r3_control_flow.ts:620).
+    // So `@default   never;` (multiple spaces) is an incomplete block named
+    // "default   never" inside the switch, which `validateSwitchBlock` rejects with
+    // "@switch block can only contain @case and @default blocks" and createSwitchBlock
+    // turns into an UnknownBlock — it does NOT become a SwitchExhaustiveCheck node.
+    // Verified by executing @angular/compiler@21.2.7 parseTemplate:
+    //   "@switch (x) { @case (1) { a } @default   never; }"
+    //   -> errors: ['Incomplete block "default   never". ...'], switch=0 exhaustive=0
+    #[test]
+    fn multi_space_default_never_is_not_exhaustive_marker() {
+        let errors = get_transform_errors("@switch (expr) { @case (1) { a } @default   never; }");
+        // Not accepted as the exhaustive marker -> rejected as invalid switch content.
+        assert!(
+            errors
+                .iter()
+                .any(|e| e.contains("@switch block can only contain @case and @default blocks")),
+            "Multi-space @default   never; must be rejected as invalid switch content, \
+             got: {errors:?}"
+        );
+        // And it must NOT silently pass as a valid exhaustive marker.
+        assert!(
+            !errors.is_empty(),
+            "Multi-space @default   never; must NOT be silently accepted, got: {errors:?}"
+        );
+    }
+
+    // Same for a TAB separator: not the canonical marker, rejected as switch content.
+    // Verified by executing @angular/compiler@21.2.7:
+    //   "@switch (x) { @case (1) { a } @default\tnever; }"
+    //   -> errors: ['Incomplete block "default\tnever". ...'], switch=0 exhaustive=0
+    #[test]
+    fn tab_default_never_is_not_exhaustive_marker() {
+        let errors = get_transform_errors("@switch (expr) { @case (1) { a } @default\tnever; }");
+        assert!(
+            errors
+                .iter()
+                .any(|e| e.contains("@switch block can only contain @case and @default blocks")),
+            "Tab @default\\tnever; must be rejected as invalid switch content, got: {errors:?}"
+        );
+    }
+
+    // CONTROL: the canonical single-space `@default never;` STILL produces a valid
+    // exhaustive marker with no errors (no regression).
+    // Verified by executing @angular/compiler@21.2.7:
+    //   "@switch (x) { @case (1) { a } @default never; }" -> errors: [], exhaustive=1
+    #[test]
+    fn single_space_default_never_is_valid_exhaustive_marker() {
+        let errors = get_transform_errors("@switch (expr) { @case (1) { a } @default never; }");
+        assert!(
+            errors.is_empty(),
+            "Canonical @default never; must remain a valid exhaustive marker with no errors, \
+             got: {errors:?}"
+        );
+    }
 }
 
 // ============================================================================
@@ -2640,3 +2947,967 @@ mod for_track_expression_parsing {
         );
     }
 }
+
+// ============================================================================
+// Selectorless component namespace inheritance (R3 transform end-to-end)
+//
+// Verifies that a selectorless component's `R3Component.tag_name` / `full_name`
+// inherit the parent implicit namespace, matching upstream
+// `_getComponentTagName` / `_getComponentFullName` (ml_parser/parser.ts).
+// Uses the real `HtmlParser::with_selectorless` + `HtmlToR3Transform` pipeline
+// (the shared `parse()` helper above keeps selectorless OFF).
+// ============================================================================
+mod selectorless_component_namespace_r3 {
+    use oxc_allocator::Allocator;
+    use oxc_angular_compiler::ast::r3::R3Node;
+    use oxc_angular_compiler::parser::html::HtmlParser;
+    use oxc_angular_compiler::transform::html_to_r3::{HtmlToR3Transform, TransformOptions};
+
+    /// Parses `html` with selectorless mode, transforms to R3, and returns the
+    /// first `R3Component`'s `(component_name, tag_name, full_name)`.
+    fn first_r3_component(html: &str) -> (String, Option<String>, String) {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::with_selectorless(&allocator, html, "test.html");
+        let html_result = parser.parse();
+        assert!(
+            html_result.errors.is_empty(),
+            "HTML parse errors for '{html}': {:?}",
+            html_result.errors.iter().map(|e| e.msg.clone()).collect::<Vec<_>>()
+        );
+
+        let transformer = HtmlToR3Transform::new(
+            &allocator,
+            html,
+            TransformOptions { collect_comment_nodes: false },
+        );
+        let r3 = transformer.transform(&html_result.nodes);
+        assert!(
+            r3.errors.is_empty(),
+            "Transform errors for '{html}': {:?}",
+            r3.errors.iter().map(|e| e.msg.clone()).collect::<Vec<_>>()
+        );
+
+        fn find<'a>(nodes: &[R3Node<'a>]) -> Option<(String, Option<String>, String)> {
+            for node in nodes {
+                if let R3Node::Component(c) = node {
+                    return Some((
+                        c.component_name.to_string(),
+                        c.tag_name.as_ref().map(|t| t.to_string()),
+                        c.full_name.to_string(),
+                    ));
+                }
+                let children: &[R3Node<'a>] = match node {
+                    R3Node::Element(e) => &e.children,
+                    R3Node::Template(t) => &t.children,
+                    _ => continue,
+                };
+                if let Some(found) = find(children) {
+                    return Some(found);
+                }
+            }
+            None
+        }
+
+        find(&r3.nodes).unwrap_or_else(|| panic!("no R3 component found in '{html}'"))
+    }
+
+    #[test]
+    fn inferred_svg_namespace_with_tag_name() {
+        // THE divergence case: <svg><MyComp:button> -> ":svg:button" / "MyComp:svg:button".
+        let (name, tag, full) = first_r3_component("<svg><MyComp:button>Hi</MyComp:button></svg>");
+        assert_eq!(name, "MyComp");
+        assert_eq!(tag.as_deref(), Some(":svg:button"));
+        assert_eq!(full, "MyComp:svg:button");
+    }
+
+    #[test]
+    fn inferred_svg_namespace_no_tag_name() {
+        // <svg><MyComp> -> ":svg:ng-component" / "MyComp:svg:ng-component".
+        let (name, tag, full) = first_r3_component("<svg><MyComp>Hi</MyComp></svg>");
+        assert_eq!(name, "MyComp");
+        assert_eq!(tag.as_deref(), Some(":svg:ng-component"));
+        assert_eq!(full, "MyComp:svg:ng-component");
+    }
+
+    #[test]
+    fn explicit_namespace_wins_over_inheritance() {
+        // <math><MyComp:svg:title> -> explicit svg beats math: ":svg:title".
+        let (name, tag, full) =
+            first_r3_component("<math><MyComp:svg:title>Hi</MyComp:svg:title></math>");
+        assert_eq!(name, "MyComp");
+        assert_eq!(tag.as_deref(), Some(":svg:title"));
+        assert_eq!(full, "MyComp:svg:title");
+    }
+
+    #[test]
+    fn non_svg_control_stays_unnamespaced() {
+        // Control: <div><MyComp:button> -> "button" / "MyComp:button".
+        let (name, tag, full) = first_r3_component("<div><MyComp:button>Hi</MyComp:button></div>");
+        assert_eq!(name, "MyComp");
+        assert_eq!(tag.as_deref(), Some("button"));
+        assert_eq!(full, "MyComp:button");
+    }
+
+    #[test]
+    fn bare_component_stays_unnamespaced() {
+        // Control: top-level <MyComp> -> tag_name None, full_name "MyComp".
+        let (name, tag, full) = first_r3_component("<MyComp>Hi</MyComp>");
+        assert_eq!(name, "MyComp");
+        assert_eq!(tag, None);
+        assert_eq!(full, "MyComp");
+    }
+}
+
+// ============================================================================
+// R3-level: CHILDREN of a namespaced selectorless component inherit `:svg:`
+// (the iteration-11 finding). Upstream `_getPrefix` derives a child's namespace
+// from the closest element-like parent's name, which for an `html.Component`
+// parent is `parent.tagName` (the resolved `:svg:button`), NOT the class name
+// (ml_parser/parser.ts:991). So children inherit `:svg:`, and crucially a child
+// `<script>`/`<style>` resolves to `:svg:script`/`:svg:style`, which the R3
+// template_preparser KEEPS namespaced (G4) instead of dropping/extracting the
+// plain-html `script`/`style`. This is the security-relevant divergence.
+// ============================================================================
+mod selectorless_component_child_namespace_r3 {
+    use oxc_allocator::Allocator;
+    use oxc_angular_compiler::ast::r3::R3Node;
+    use oxc_angular_compiler::parser::html::HtmlParser;
+    use oxc_angular_compiler::transform::html_to_r3::{HtmlToR3Transform, TransformOptions};
+
+    /// Parses `html` selectorless, transforms to R3, finds the first `R3Component`,
+    /// and returns the list of its DIRECT child ELEMENT names (in order). Style/script
+    /// that the preparser drops/extracts will simply be absent from this list, so an
+    /// expected `:svg:script` present here proves it was KEPT as a namespaced element.
+    fn component_child_element_names(html: &str) -> Vec<String> {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::with_selectorless(&allocator, html, "test.html");
+        let html_result = parser.parse();
+        assert!(
+            html_result.errors.is_empty(),
+            "HTML parse errors for '{html}': {:?}",
+            html_result.errors.iter().map(|e| e.msg.clone()).collect::<Vec<_>>()
+        );
+
+        let transformer = HtmlToR3Transform::new(
+            &allocator,
+            html,
+            TransformOptions { collect_comment_nodes: false },
+        );
+        let r3 = transformer.transform(&html_result.nodes);
+        assert!(
+            r3.errors.is_empty(),
+            "Transform errors for '{html}': {:?}",
+            r3.errors.iter().map(|e| e.msg.clone()).collect::<Vec<_>>()
+        );
+
+        fn find_component<'a, 'b>(nodes: &'b [R3Node<'a>]) -> Option<&'b [R3Node<'a>]> {
+            for node in nodes {
+                if let R3Node::Component(c) = node {
+                    return Some(&c.children);
+                }
+                let children: &[R3Node<'a>] = match node {
+                    R3Node::Element(e) => &e.children,
+                    R3Node::Template(t) => &t.children,
+                    _ => continue,
+                };
+                if let Some(found) = find_component(children) {
+                    return Some(found);
+                }
+            }
+            None
+        }
+
+        let children =
+            find_component(&r3.nodes).unwrap_or_else(|| panic!("no R3 component in '{html}'"));
+        children
+            .iter()
+            .filter_map(|n| match n {
+                R3Node::Element(e) => Some(e.name.to_string()),
+                _ => None,
+            })
+            .collect()
+    }
+
+    #[test]
+    fn child_div_inherits_svg() {
+        // <svg><MyComp:button><div></div></MyComp:button></svg> -> child `:svg:div`.
+        let names =
+            component_child_element_names("<svg><MyComp:button><div></div></MyComp:button></svg>");
+        assert_eq!(names, vec![":svg:div".to_string()]);
+    }
+
+    #[test]
+    fn child_script_inherits_svg_and_is_kept() {
+        // THE security-relevant case: a plain `<script>` child under a namespaced
+        // component resolves to `:svg:script`, which is KEPT (G4) — NOT dropped as a
+        // plain-html `<script>`. (A plain `<script>` would be absent from the list.)
+        let names = component_child_element_names(
+            "<svg><MyComp:button><script>x</script></MyComp:button></svg>",
+        );
+        assert_eq!(names, vec![":svg:script".to_string()]);
+    }
+
+    #[test]
+    fn child_style_inherits_svg_and_is_kept() {
+        // A plain `<style>` child resolves to `:svg:style`, KEPT as a namespaced
+        // element — NOT extracted as a stylesheet (plain `<style>` is removed).
+        let names = component_child_element_names(
+            "<svg><MyComp:button><style>x</style></MyComp:button></svg>",
+        );
+        assert_eq!(names, vec![":svg:style".to_string()]);
+    }
+
+    #[test]
+    fn child_inherits_svg_through_explicit_namespace_component() {
+        // Explicit `<MyComp:svg:rect>` (no enclosing <svg>): child `<circle>` -> `:svg:circle`.
+        let names =
+            component_child_element_names("<MyComp:svg:rect><circle></circle></MyComp:svg:rect>");
+        assert_eq!(names, vec![":svg:circle".to_string()]);
+    }
+
+    #[test]
+    fn child_inherits_svg_through_component_without_tag_part() {
+        // <svg><MyComp><div></div></MyComp></svg>: tagName `:svg:ng-component` -> child `:svg:div`.
+        let names = component_child_element_names("<svg><MyComp><div></div></MyComp></svg>");
+        assert_eq!(names, vec![":svg:div".to_string()]);
+    }
+
+    #[test]
+    fn control_non_svg_component_child_stays_html_and_script_is_dropped() {
+        // CONTROL: <MyComp:button><div></div><script></script></MyComp:button> outside svg.
+        // child `<div>` stays plain `div`; the plain `<script>` is DROPPED (absent).
+        let names = component_child_element_names(
+            "<MyComp:button><div></div><script>x</script></MyComp:button>",
+        );
+        assert_eq!(names, vec!["div".to_string()]);
+    }
+
+    #[test]
+    fn control_bare_component_child_stays_html() {
+        // CONTROL: bare <MyComp><div></div></MyComp> outside svg -> child stays plain `div`.
+        let names = component_child_element_names("<MyComp><div></div></MyComp>");
+        assert_eq!(names, vec!["div".to_string()]);
+    }
+}
+
+// ============================================================================
+// FINDING 1: UNSUPPORTED_SELECTORLESS_TAGS must be tested against the RESOLVED
+// selectorless TAG name (`component.tagName`), NOT the component CLASS name.
+//
+// Upstream v21.2.7 `HtmlAstToIvyAst.visitComponent`
+// (render3/r3_template_transform.ts:378-384):
+//   if (component.tagName !== null && UNSUPPORTED_SELECTORLESS_TAGS.has(component.tagName)) {
+//     this.reportError(`Tag name "${component.tagName}" cannot be used as a component tag`, ...);
+//     return null;
+//   }
+// where the set (lines 64-71) is {link, style, script, ng-template, ng-container,
+// ng-content} and `component.tagName` is the output of `_getComponentTagName`
+// (ml_parser/parser.ts:946-961): null when no prefix and no tag part; the bare tag
+// when no prefix; `mergeNsAndName(prefix, tag)` (`:prefix:tag`) when a prefix is
+// present. The membership test runs against that resolved name WITHOUT stripping the
+// namespace, so a namespaced `:svg:script` is NOT a member and is ACCEPTED, while a
+// bare `script` (no prefix) IS rejected. The error message quotes the RESOLVED
+// tagName, not the class name.
+// ============================================================================
+mod selectorless_unsupported_tag_r3 {
+    use oxc_allocator::Allocator;
+    use oxc_angular_compiler::parser::html::HtmlParser;
+    use oxc_angular_compiler::transform::html_to_r3::{HtmlToR3Transform, TransformOptions};
+
+    /// Parses `html` selectorless and transforms to R3, returning the combined
+    /// parse + transform error messages.
+    fn selectorless_transform_errors(html: &str) -> Vec<String> {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::with_selectorless(&allocator, html, "test.html");
+        let html_result = parser.parse();
+
+        let transformer = HtmlToR3Transform::new(
+            &allocator,
+            html,
+            TransformOptions { collect_comment_nodes: false },
+        );
+        let r3 = transformer.transform(&html_result.nodes);
+
+        html_result
+            .errors
+            .iter()
+            .map(|e| e.msg.clone())
+            .chain(r3.errors.iter().map(|e| e.msg.clone()))
+            .collect()
+    }
+
+    fn has_unsupported_error(errors: &[String], expected_tag: &str) -> bool {
+        let needle = format!("Tag name \"{expected_tag}\" cannot be used as a component tag");
+        errors.iter().any(|e| e == &needle)
+    }
+
+    fn any_unsupported_error(errors: &[String]) -> bool {
+        errors.iter().any(|e| e.contains("cannot be used as a component tag"))
+    }
+
+    #[test]
+    fn comp_script_tag_is_rejected() {
+        // <MyComp:script> -> tagName "script" (no prefix) -> in set -> rejected,
+        // message quotes the RESOLVED tag name "script".
+        let errors = selectorless_transform_errors("<MyComp:script>x</MyComp:script>");
+        assert!(
+            has_unsupported_error(&errors, "script"),
+            "expected unsupported-tag error for \"script\", got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn comp_style_tag_is_rejected() {
+        let errors = selectorless_transform_errors("<MyComp:style>x</MyComp:style>");
+        assert!(
+            has_unsupported_error(&errors, "style"),
+            "expected unsupported-tag error for \"style\", got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn comp_link_tag_is_rejected() {
+        let errors = selectorless_transform_errors("<MyComp:link>x</MyComp:link>");
+        assert!(
+            has_unsupported_error(&errors, "link"),
+            "expected unsupported-tag error for \"link\", got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn class_named_script_without_tag_is_accepted() {
+        // <Script> -> class named "Script", NO tag part -> tagName null -> NOT in set.
+        let errors = selectorless_transform_errors("<Script>x</Script>");
+        assert!(
+            !any_unsupported_error(&errors),
+            "expected NO unsupported-tag error for class <Script>, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn class_named_script_with_safe_tag_is_accepted() {
+        // <Script:div> -> tagName "div" -> NOT in set.
+        let errors = selectorless_transform_errors("<Script:div>x</Script:div>");
+        assert!(
+            !any_unsupported_error(&errors),
+            "expected NO unsupported-tag error for <Script:div>, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn explicit_namespaced_script_tag_is_accepted() {
+        // <MyComp:svg:script> -> tagName ":svg:script" (prefix present) -> NOT a member
+        // of the bare-name set -> ACCEPTED. Upstream does NOT strip the namespace before
+        // the membership test.
+        let errors = selectorless_transform_errors("<MyComp:svg:script>x</MyComp:svg:script>");
+        assert!(
+            !any_unsupported_error(&errors),
+            "expected NO unsupported-tag error for explicit :svg:script, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn inherited_svg_namespaced_script_tag_is_accepted() {
+        // <svg><MyComp:script> -> prefix inherited "svg" -> tagName ":svg:script" -> NOT
+        // a member -> ACCEPTED (subtle inheritance case).
+        let errors = selectorless_transform_errors("<svg><MyComp:script>x</MyComp:script></svg>");
+        assert!(
+            !any_unsupported_error(&errors),
+            "expected NO unsupported-tag error for inherited :svg:script, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn bare_component_is_accepted() {
+        // CONTROL: bare <MyComp> -> tagName null -> NOT rejected.
+        let errors = selectorless_transform_errors("<MyComp>x</MyComp>");
+        assert!(
+            !any_unsupported_error(&errors),
+            "expected NO unsupported-tag error for bare <MyComp>, got: {errors:?}"
+        );
+    }
+}
+
+// ============================================================================
+// Selectorless components whose CLASS name collides with special HTML tags
+// (`Script` / `Style` / `Link`) must NOT be dropped by the preparser path.
+//
+// Upstream splits the two visitors:
+//   * `visitElement`   → calls `preparseElement` (strips script/style/link)
+//   * `visitComponent` → never calls `preparseElement`; only validates the
+//     resolved HOST tag (`component.tagName`) against UNSUPPORTED_SELECTORLESS_TAGS
+//
+// A bare selectorless component `<Script></Script>` has `tagName === null` and
+// must be emitted as an R3Component. Real lowercase HTML `<script>`/`<style>`
+// elements are still stripped. Host-tag syntax `<MyComp:script>` still errors
+// via UNSUPPORTED_SELECTORLESS_TAGS (covered above).
+// ============================================================================
+mod selectorless_special_element_preparser_r3 {
+    use oxc_allocator::Allocator;
+    use oxc_angular_compiler::ast::r3::R3Node;
+    use oxc_angular_compiler::parser::html::HtmlParser;
+    use oxc_angular_compiler::transform::html_to_r3::{HtmlToR3Transform, TransformOptions};
+
+    /// Parses with selectorless ON and returns the transformed R3 result.
+    fn transform_selectorless(html: &str) -> (Vec<String>, Vec<String>, Vec<String>) {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::with_selectorless(&allocator, html, "test.html");
+        let html_result = parser.parse();
+        assert!(
+            html_result.errors.is_empty(),
+            "HTML parse errors for '{html}': {:?}",
+            html_result.errors.iter().map(|e| e.msg.clone()).collect::<Vec<_>>()
+        );
+
+        let transformer = HtmlToR3Transform::new(
+            &allocator,
+            html,
+            TransformOptions { collect_comment_nodes: false },
+        );
+        let r3 = transformer.transform(&html_result.nodes);
+
+        fn collect_components<'a>(nodes: &[R3Node<'a>], out: &mut Vec<String>) {
+            for node in nodes {
+                match node {
+                    R3Node::Component(c) => out.push(c.component_name.to_string()),
+                    R3Node::Element(e) => collect_components(&e.children, out),
+                    R3Node::Template(t) => collect_components(&t.children, out),
+                    _ => {}
+                }
+            }
+        }
+        fn collect_elements<'a>(nodes: &[R3Node<'a>], out: &mut Vec<String>) {
+            for node in nodes {
+                match node {
+                    R3Node::Element(e) => {
+                        out.push(e.name.to_string());
+                        collect_elements(&e.children, out);
+                    }
+                    R3Node::Component(c) => collect_elements(&c.children, out),
+                    R3Node::Template(t) => collect_elements(&t.children, out),
+                    _ => {}
+                }
+            }
+        }
+
+        let mut components = Vec::new();
+        let mut elements = Vec::new();
+        collect_components(&r3.nodes, &mut components);
+        collect_elements(&r3.nodes, &mut elements);
+        let styles: Vec<String> = r3.styles.iter().map(|s| s.to_string()).collect();
+        (components, elements, styles)
+    }
+
+    #[test]
+    fn bare_script_class_component_is_kept() {
+        // `<Script></Script>` is a selectorless component (class name "Script"),
+        // NOT a real HTML script element — must be emitted as R3Component.
+        let (components, elements, styles) = transform_selectorless("<Script></Script>");
+        assert_eq!(components, vec!["Script".to_string()]);
+        assert!(elements.is_empty(), "expected no Element nodes, got {elements:?}");
+        assert!(styles.is_empty(), "expected no extracted styles, got {styles:?}");
+    }
+
+    #[test]
+    fn bare_style_class_component_is_kept() {
+        let (components, elements, styles) = transform_selectorless("<Style></Style>");
+        assert_eq!(components, vec!["Style".to_string()]);
+        assert!(elements.is_empty(), "expected no Element nodes, got {elements:?}");
+        // Must NOT extract class-name Style as a stylesheet.
+        assert!(styles.is_empty(), "expected no extracted styles, got {styles:?}");
+    }
+
+    #[test]
+    fn bare_link_class_component_is_kept() {
+        // `link` is a void element in HTML; use self-closing form so the parser
+        // doesn't emit an unexpected-closing-tag error for `</Link>`.
+        let (components, elements, _styles) = transform_selectorless("<Link/>");
+        assert_eq!(components, vec!["Link".to_string()]);
+        assert!(elements.is_empty(), "expected no Element nodes, got {elements:?}");
+    }
+
+    #[test]
+    fn real_lowercase_script_element_is_stripped() {
+        // Real HTML `<script>` is still dropped by the Element preparser path.
+        let (components, elements, styles) =
+            transform_selectorless("<script>evil()</script><div>after</div>");
+        assert!(components.is_empty(), "expected no components, got {components:?}");
+        assert_eq!(elements, vec!["div".to_string()]);
+        assert!(styles.is_empty());
+    }
+
+    #[test]
+    fn real_lowercase_style_element_is_extracted() {
+        let (components, elements, styles) =
+            transform_selectorless("<style>.x{}</style><div>after</div>");
+        assert!(components.is_empty(), "expected no components, got {components:?}");
+        assert_eq!(elements, vec!["div".to_string()]);
+        assert_eq!(styles, vec![".x{}".to_string()]);
+    }
+
+    #[test]
+    fn mixed_script_component_and_real_script() {
+        // Component kept, real script stripped, following div kept.
+        let (components, elements, _) =
+            transform_selectorless("<Script></Script><script>x</script><div>y</div>");
+        assert_eq!(components, vec!["Script".to_string()]);
+        assert_eq!(elements, vec!["div".to_string()]);
+    }
+}
+
+// ============================================================================
+// FINDING 1 [HIGH, SECURITY]: selectorless-component HOST TAG is threaded into
+// the bound-attribute security-context lookup AND the i18n trusted-types sink
+// check, matching upstream v21.2.7.
+//
+// In v21.2.7 a selectorless component's security context is computed from
+// `component.tagName` (the RESOLVED host tag), NOT the component class name:
+//   * `categorizePropertyAttributes(component.tagName, ...)` ->
+//     `createBoundElementProperty(elementName = component.tagName, ...)`
+//     (render3/r3_template_transform.ts:411-415, binding_parser.ts:594-615), and
+//   * the i18n trusted-types guard uses
+//     `node instanceof html.Component ? node.tagName : node.name`, with
+//     `tagName === null ? false : isTrustedTypesSink(node.tagName, name)`
+//     (render3/view/i18n/meta.ts:205-208).
+//
+// Ground truth below was settled by EXECUTING @angular/compiler@21.2.7
+// (VERSION.full == 21.2.7) `parseTemplate(html, 'test.html', {enableSelectorless:
+// true})` and reading the resulting `BoundAttribute.securityContext` / errors:
+//   <MyCmp:iframe [src]>       -> RESOURCE_URL
+//   <MyCmp:iframe [attr.src]>  -> RESOURCE_URL
+//   <MyCmp:object [data]>      -> RESOURCE_URL
+//   <MyCmp:iframe [srcdoc]>    -> HTML
+//   <MyCmp:img [src]>          -> URL
+//   <svg><MyCmp:image [xlink:href]> -> NONE (no `image|xlink:href` schema entry)
+//   bare <MyCmp [src]>         -> NONE   (tagName null; NONE sorts first in union)
+//   bare <MyCmp [innerHTML]>   -> HTML   (wildcard `*|innerHTML` applies)
+//   bare <Object [data]>       -> NONE   (tagName null, NOT looked up as `object`)
+//   <MyCmp:iframe i18n-src>    -> error "Translating attribute 'src' is disallowed..."
+//   bare <MyCmp i18n-src>      -> NO error (tagName null -> false)
+//   <Object i18n-data> (bare)  -> NO error (tagName null -> false)
+//   CONTROL <iframe [src]>     -> RESOURCE_URL ; <iframe i18n-src> -> error
+// ============================================================================
+mod selectorless_component_security_r3 {
+    use oxc_allocator::Allocator;
+    use oxc_angular_compiler::ast::r3::{R3Node, SecurityContext};
+    use oxc_angular_compiler::parser::html::HtmlParser;
+    use oxc_angular_compiler::transform::html_to_r3::{HtmlToR3Transform, TransformOptions};
+
+    fn sc_str(sc: SecurityContext) -> &'static str {
+        match sc {
+            SecurityContext::None => "None",
+            SecurityContext::Html => "Html",
+            SecurityContext::Style => "Style",
+            SecurityContext::Script => "Script",
+            SecurityContext::Url => "Url",
+            SecurityContext::ResourceUrl => "ResourceUrl",
+            SecurityContext::AttributeNoBinding => "AttributeNoBinding",
+            SecurityContext::UrlOrResourceUrl => "UrlOrResourceUrl",
+        }
+    }
+
+    /// Parses `html` in selectorless mode, transforms to R3, finds the first
+    /// `R3Component` (selectorless components are stored as components), and
+    /// returns its first bound-attribute input as `(name, security_context)`.
+    fn first_component_input_security(html: &str) -> (String, String) {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::with_selectorless(&allocator, html, "test.html");
+        let html_result = parser.parse();
+        let transformer = HtmlToR3Transform::new(
+            &allocator,
+            html,
+            TransformOptions { collect_comment_nodes: false },
+        );
+        let r3 = transformer.transform(&html_result.nodes);
+
+        fn find<'a>(
+            nodes: &'a [R3Node<'a>],
+        ) -> Option<&'a oxc_angular_compiler::ast::r3::R3Component<'a>> {
+            for n in nodes {
+                match n {
+                    R3Node::Component(c) => return Some(c),
+                    R3Node::Element(e) => {
+                        if let Some(c) = find(&e.children) {
+                            return Some(c);
+                        }
+                    }
+                    R3Node::Template(t) => {
+                        if let Some(c) = find(&t.children) {
+                            return Some(c);
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            None
+        }
+
+        let component = find(&r3.nodes).expect("expected at least one R3Component");
+        let input = component.inputs.first().expect("expected at least one bound-attribute input");
+        (input.name.to_string(), sc_str(input.security_context).to_string())
+    }
+
+    /// Like above but for a NORMAL element (control).
+    fn first_element_input_security(html: &str) -> (String, String) {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::with_selectorless(&allocator, html, "test.html");
+        let html_result = parser.parse();
+        let transformer = HtmlToR3Transform::new(
+            &allocator,
+            html,
+            TransformOptions { collect_comment_nodes: false },
+        );
+        let r3 = transformer.transform(&html_result.nodes);
+
+        fn find<'a>(
+            nodes: &'a [R3Node<'a>],
+        ) -> Option<&'a oxc_angular_compiler::ast::r3::R3Element<'a>> {
+            for n in nodes {
+                match n {
+                    R3Node::Element(e) => {
+                        if !e.inputs.is_empty() {
+                            return Some(e);
+                        }
+                        if let Some(c) = find(&e.children) {
+                            return Some(c);
+                        }
+                    }
+                    R3Node::Template(t) => {
+                        if let Some(c) = find(&t.children) {
+                            return Some(c);
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            None
+        }
+        let element = find(&r3.nodes).expect("expected at least one element with inputs");
+        let input = element.inputs.first().expect("expected at least one bound-attribute input");
+        (input.name.to_string(), sc_str(input.security_context).to_string())
+    }
+
+    fn transform_errors(html: &str) -> Vec<String> {
+        let allocator = Allocator::default();
+        let parser = HtmlParser::with_selectorless(&allocator, html, "test.html");
+        let html_result = parser.parse();
+        let transformer = HtmlToR3Transform::new(
+            &allocator,
+            html,
+            TransformOptions { collect_comment_nodes: false },
+        );
+        let r3 = transformer.transform(&html_result.nodes);
+        html_result
+            .errors
+            .iter()
+            .map(|e| e.msg.clone())
+            .chain(r3.errors.iter().map(|e| e.msg.clone()))
+            .collect()
+    }
+
+    fn has_disallowed_error(errors: &[String], attr: &str) -> bool {
+        let needle = format!("Translating attribute '{attr}' is disallowed for security reasons.");
+        errors.iter().any(|e| e == &needle)
+    }
+
+    // ---- Security context (bound attributes) ----
+
+    #[test]
+    fn comp_iframe_src_is_resource_url() {
+        assert_eq!(
+            first_component_input_security(r#"<MyCmp:iframe [src]="u" />"#),
+            ("src".to_string(), "ResourceUrl".to_string())
+        );
+    }
+
+    #[test]
+    fn comp_iframe_attr_src_is_resource_url() {
+        assert_eq!(
+            first_component_input_security(r#"<MyCmp:iframe [attr.src]="u" />"#),
+            ("src".to_string(), "ResourceUrl".to_string())
+        );
+    }
+
+    #[test]
+    fn comp_object_data_is_resource_url() {
+        assert_eq!(
+            first_component_input_security(r#"<MyCmp:object [data]="u" />"#),
+            ("data".to_string(), "ResourceUrl".to_string())
+        );
+    }
+
+    #[test]
+    fn comp_iframe_srcdoc_is_html() {
+        assert_eq!(
+            first_component_input_security(r#"<MyCmp:iframe [srcdoc]="u" />"#),
+            ("srcdoc".to_string(), "Html".to_string())
+        );
+    }
+
+    #[test]
+    fn comp_img_src_is_url_not_resource_url() {
+        // `img|src` is a navigable URL (not a Trusted Types / RESOURCE_URL sink).
+        assert_eq!(
+            first_component_input_security(r#"<MyCmp:img [src]="u" />"#),
+            ("src".to_string(), "Url".to_string())
+        );
+    }
+
+    #[test]
+    fn svg_comp_image_xlink_href_is_none() {
+        // <svg><MyCmp:image [xlink:href]> -> resolved tag ":svg:image" -> ns-stripped
+        // "image" -> no `image|xlink:href` schema entry -> NONE (no over-sanitization).
+        assert_eq!(
+            first_component_input_security(r#"<svg><MyCmp:image [xlink:href]="u" /></svg>"#),
+            ("xlink:href".to_string(), "None".to_string())
+        );
+    }
+
+    // ---- CONTROL: bare component (tagName null) ----
+
+    #[test]
+    fn bare_comp_src_is_none() {
+        // tagName null -> security NONE (matches upstream null-selector union).
+        assert_eq!(
+            first_component_input_security(r#"<MyCmp [src]="u" />"#),
+            ("src".to_string(), "None".to_string())
+        );
+    }
+
+    #[test]
+    fn bare_comp_inner_html_is_html_via_wildcard() {
+        // tagName null but `*|innerHTML` is a wildcard sink -> HTML.
+        assert_eq!(
+            first_component_input_security(r#"<MyCmp [innerHTML]="u" />"#),
+            ("innerHTML".to_string(), "Html".to_string())
+        );
+    }
+
+    #[test]
+    fn bare_comp_class_named_object_data_is_none() {
+        // REGRESSION GUARD: a class name that collides with a real element name
+        // (`Object`) with NO tag part must NOT be looked up as the `object` element.
+        // tagName null -> NONE (matches upstream; pre-fix this leaked RESOURCE_URL).
+        assert_eq!(
+            first_component_input_security(r#"<Object [data]="u" />"#),
+            ("data".to_string(), "None".to_string())
+        );
+    }
+
+    // ---- CONTROL: normal element (non-component) unchanged ----
+
+    #[test]
+    fn control_normal_iframe_src_is_resource_url() {
+        assert_eq!(
+            first_element_input_security(r#"<iframe [src]="u"></iframe>"#),
+            ("src".to_string(), "ResourceUrl".to_string())
+        );
+    }
+
+    // ---- i18n trusted-types sink ----
+
+    #[test]
+    fn comp_iframe_i18n_src_is_disallowed() {
+        let errors = transform_errors(r#"<MyCmp:iframe i18n-src src="x">hi</MyCmp:iframe>"#);
+        assert!(
+            has_disallowed_error(&errors, "src"),
+            "expected i18n disallowed error for iframe|src, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn control_bare_comp_i18n_src_is_allowed() {
+        // tagName null -> isTrustedType false -> NO error (matches upstream).
+        let errors = transform_errors(r#"<MyCmp i18n-src src="x">hi</MyCmp>"#);
+        assert!(
+            !errors.iter().any(|e| e.contains("disallowed for security reasons")),
+            "expected NO i18n disallowed error for bare <MyCmp>, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn control_bare_comp_class_named_object_i18n_data_is_allowed() {
+        // REGRESSION GUARD: class `Object`, NO tag part -> tagName null -> NO error
+        // (pre-fix the class name leaked into `object|data` and spuriously errored).
+        let errors = transform_errors(r#"<Object i18n-data data="x">hi</Object>"#);
+        assert!(
+            !errors.iter().any(|e| e.contains("disallowed for security reasons")),
+            "expected NO i18n disallowed error for bare <Object>, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn control_normal_iframe_i18n_src_is_disallowed() {
+        let errors = transform_errors(r#"<iframe i18n-src src="x"></iframe>"#);
+        assert!(
+            has_disallowed_error(&errors, "src"),
+            "expected i18n disallowed error for normal iframe|src, got: {errors:?}"
+        );
+    }
+
+    // ---- i18n trusted-types sink: namespace must NOT be stripped, bare component skips ----
+    //
+    // These assert faithfulness to v21.2.7 `render3/view/i18n/meta.ts` (~210-214):
+    //   isTrustedType = node instanceof html.Component
+    //     ? (node.tagName === null ? false : isTrustedTypesSink(node.tagName, name))
+    //     : isTrustedTypesSink(node.name, name);
+    // For a NORMAL element it passes the FULL `node.name` (un-stripped, e.g.
+    // `:svg:iframe`); for a COMPONENT it passes the resolved `node.tagName`
+    // (un-stripped, e.g. `:svg:iframe`); for a BARE component (tagName null) it
+    // SHORT-CIRCUITS to false. `isTrustedTypesSink` only lowercases (NO ns-strip),
+    // so `:svg:iframe|src` is NOT a member of TRUSTED_TYPES_SINKS -> ALLOWED.
+    // All expected outcomes were verified by executing
+    // `parseTemplate(tpl, 'test.html', {enableSelectorless:true})` against
+    // @angular/compiler@21.2.7.
+
+    #[test]
+    fn normal_svg_iframe_i18n_src_is_allowed() {
+        // Normal namespaced element, full name `:svg:iframe`; upstream passes
+        // `node.name` un-stripped -> `:svg:iframe|src` is NOT a sink -> ALLOWED.
+        // (Pre-fix OXC ns-stripped to `iframe|src` and wrongly BLOCKED.)
+        let errors = transform_errors(r#"<svg:iframe i18n-src src="x"></svg:iframe>"#);
+        assert!(
+            !errors.iter().any(|e| e.contains("disallowed for security reasons")),
+            "expected NO i18n disallowed error for <svg:iframe i18n-src>, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn comp_svg_iframe_i18n_src_is_allowed() {
+        // Selectorless component resolved to `:svg:iframe` (inside <svg>); upstream
+        // passes `node.tagName` un-stripped -> `:svg:iframe|src` NOT a sink -> ALLOWED.
+        // (Pre-fix OXC ns-stripped to `iframe|src` and wrongly BLOCKED.)
+        let errors =
+            transform_errors(r#"<svg><MyCmp:iframe i18n-src src="x">hi</MyCmp:iframe></svg>"#);
+        assert!(
+            !errors.iter().any(|e| e.contains("disallowed for security reasons")),
+            "expected NO i18n disallowed error for <svg><MyCmp:iframe i18n-src>, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn bare_comp_i18n_inner_html_is_allowed() {
+        // Bare component (tagName null) -> upstream short-circuits isTrustedType to
+        // false -> ALLOWED, even though `*|innerhtml` IS a wildcard sink. (Pre-fix
+        // OXC passed an EMPTY STRING which matched `*|innerhtml` and wrongly BLOCKED.)
+        let errors = transform_errors(r#"<MyCmp i18n-innerHTML innerHTML="x">hi</MyCmp>"#);
+        assert!(
+            !errors.iter().any(|e| e.contains("disallowed for security reasons")),
+            "expected NO i18n disallowed error for bare <MyCmp i18n-innerHTML>, got: {errors:?}"
+        );
+    }
+}
+
+// ============================================================================
+// DEFAULT (non-selectorless) parse mode: an UPPERCASE-leading HTML tag like
+// `<IFRAME>` / `<OBJECT>` is a NORMAL element, NOT a selectorless component.
+//
+// This is the path the real compiler uses: every parse site in
+// `component/transform.rs` builds `ParseTemplateOptions { ..Default::default() }`
+// and `enable_selectorless` defaults to `false`, so the lexer never tokenizes a
+// `ComponentOpenStart` and never produces an `HtmlComponent` / component-marked
+// `HtmlElement`. An `<IFRAME>` is therefore an ordinary `HtmlElement` whose name
+// is preserved as-is.
+//
+// Ground truth settled by EXECUTING @angular/compiler@21.2.7
+// `parseTemplate(html, 'test.html', {})` (NO enableSelectorless ->
+// `selectorlessEnabled = options.enableSelectorless ?? false` is false):
+//   <IFRAME [src]>     -> NODE Element name=IFRAME, src securityContext 5 (RESOURCE_URL)
+//   <OBJECT [data]>    -> NODE Element name=OBJECT, data securityContext 5 (RESOURCE_URL)
+//   <IFRAME i18n-src>  -> error "Translating attribute 'src' is disallowed for security reasons."
+//   <MyCmp [src]>      -> NODE Element name=MyCmp, src securityContext 0 (NONE), NO i18n error
+//
+// The security lookup (`get_security_context`) and the i18n sink check
+// (`is_trusted_types_sink`) both lowercase internally, so routing the uppercase
+// element through its own `raw_name` yields the correct `iframe|src` /
+// `object|data` lookups automatically. Before the fix, `html_to_r3`'s casing
+// heuristic (`first_char.is_ascii_uppercase()`) mis-flagged `<IFRAME>` as a bare
+// selectorless component (tagName null) -> `SecurityContext::None` and SKIPPED
+// the i18n guard, dropping the sanitizer.
+// ============================================================================
+mod default_mode_uppercase_element_security {
+    use super::*;
+
+    /// Parses `html` in DEFAULT mode (selectorless OFF, exactly like the real
+    /// pipeline) and returns the first element's first bound-attribute input as
+    /// `(name, security_context)`.
+    fn first_element_input_security(html: &str) -> (String, String) {
+        let (name, _ty, sc) = first_input_security(html);
+        (name, sc)
+    }
+
+    /// Parses `html` in DEFAULT mode and returns the combined parse + transform
+    /// error messages.
+    fn transform_errors(html: &str) -> Vec<String> {
+        let allocator = Box::new(Allocator::default());
+        let allocator_ref: &'static Allocator =
+            unsafe { &*std::ptr::from_ref::<Allocator>(allocator.as_ref()) };
+        let parser = HtmlParser::new(allocator_ref, html, "test.html");
+        let html_result = parser.parse();
+        let options = TransformOptions { collect_comment_nodes: false };
+        let transformer = HtmlToR3Transform::new(allocator_ref, html, options);
+        let r3_result = transformer.transform(&html_result.nodes);
+        html_result
+            .errors
+            .iter()
+            .map(|e| e.msg.clone())
+            .chain(r3_result.errors.iter().map(|e| e.msg.clone()))
+            .collect()
+    }
+
+    #[test]
+    fn uppercase_iframe_src_is_resource_url() {
+        // Upstream (default mode): `<IFRAME [src]>` is an Element; `iframe|src`
+        // (lowercased) -> RESOURCE_URL. (Pre-fix OXC mis-flagged as a bare
+        // component -> NONE, dropping the sanitizer — a security regression.)
+        assert_eq!(
+            first_element_input_security(r#"<IFRAME [src]="u"></IFRAME>"#),
+            ("src".to_string(), "ResourceUrl".to_string())
+        );
+    }
+
+    #[test]
+    fn uppercase_object_data_is_resource_url() {
+        // `<OBJECT [data]>` -> `object|data` -> RESOURCE_URL.
+        assert_eq!(
+            first_element_input_security(r#"<OBJECT [data]="u"></OBJECT>"#),
+            ("data".to_string(), "ResourceUrl".to_string())
+        );
+    }
+
+    #[test]
+    fn uppercase_iframe_i18n_src_is_disallowed() {
+        // `<IFRAME i18n-src>` -> isTrustedTypesSink("IFRAME","src") lowercases to
+        // `iframe|src` (a sink) -> ERROR. (Pre-fix OXC treated it as a bare
+        // component with tagName null and SKIPPED the guard, allowing translation.)
+        let errors = transform_errors(r#"<IFRAME i18n-src="x" src="y">hi</IFRAME>"#);
+        assert!(
+            errors
+                .iter()
+                .any(|e| e == "Translating attribute 'src' is disallowed for security reasons."),
+            "expected i18n disallowed error for IFRAME|src in default mode, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn control_unknown_uppercase_element_src_is_none() {
+        // CONTROL: in default mode `<MyCmp>` is an unknown NORMAL element (NOT a
+        // component); `mycmp|src` is not a schema key -> NONE, and NO i18n error.
+        assert_eq!(
+            first_element_input_security(r#"<MyCmp [src]="u"></MyCmp>"#),
+            ("src".to_string(), "None".to_string())
+        );
+        let errors = transform_errors(r#"<MyCmp i18n-src="x" src="y">hi</MyCmp>"#);
+        assert!(
+            !errors.iter().any(|e| e.contains("disallowed for security reasons")),
+            "expected NO i18n disallowed error for unknown <MyCmp> in default mode, got: {errors:?}"
+        );
+    }
+
+    #[test]
+    fn uppercase_iframe_is_element_node_not_component() {
+        // Upstream produces a t.Element (not t.Component) for `<IFRAME>` in
+        // default mode. Assert the R3 node is an Element with name "IFRAME".
+        assert_eq!(humanize_ignore_errors("<IFRAME></IFRAME>"), vec![h!["Element", "IFRAME"]]);
+    }
+}
diff --git a/crates/oxc_angular_compiler/tests/shadow_css_test.rs b/crates/oxc_angular_compiler/tests/shadow_css_test.rs
index 53b050d47..84880054f 100644
--- a/crates/oxc_angular_compiler/tests/shadow_css_test.rs
+++ b/crates/oxc_angular_compiler/tests/shadow_css_test.rs
@@ -524,12 +524,26 @@ fn test_not_selector() {
 // ============================================================================
 
 #[test]
-fn test_replace_comments_without_adding_lines() {
-    // Angular v22 removes inline comments without inserting an extra newline.
+fn test_remove_inline_comments_without_adding_extra_lines() {
+    // Upstream v21.2.7: a single-line comment collapses to nothing (no extra newline);
+    // only the literal space following it remains.
     let result = shim("/* b {c} */ b {c}", "contenta");
     assert_eq!(result, " b[contenta] {c}");
 }
 
+#[test]
+fn test_preserve_internal_newlines_from_multiline_comments() {
+    // Upstream v21.2.7: only the newline INSIDE the comment is preserved.
+    let result = shim("/* b {c}\n */ b {c}", "contenta");
+    assert_eq!(result, "\n b[contenta] {c}");
+}
+
+#[test]
+fn test_remove_multiple_inline_comments_without_adding_extra_lines() {
+    let result = shim("/* b {c} */ b {c} /* a {c} */ a {c}", "contenta");
+    assert_eq!(result, " b[contenta] {c}  a[contenta] {c}");
+}
+
 #[test]
 fn test_keep_sourcemapping_url_comments() {
     let result = shim("b {c} /*# sourceMappingURL=data:x */", "contenta");
@@ -538,10 +552,78 @@ fn test_keep_sourcemapping_url_comments() {
 
 #[test]
 fn test_handle_adjacent_comments() {
+    // Upstream v21.2.7: adjacent single-line comments collapse to nothing; only the two
+    // literal spaces (between the comments and before the selector) remain.
     let result = shim("/* comment 1 */ /* comment 2 */ b {c}", "contenta");
     assert_eq!(result, "  b[contenta] {c}");
 }
 
+// ----------------------------------------------------------------------------
+// FINDING 2 [MEDIUM]: ShadowCss preserves ONLY `sourceURL=` / `sourceMappingURL=`
+// hash comments; every other comment (including `/* # source: ... */`) is
+// stripped to its interior newlines, so no comment text leaks.
+//
+// Matches upstream v21.2.7 `_commentWithHashRe` (shadow_css.ts:1114):
+//   const _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=/g;
+// i.e. `/*`, optional ws, `#`, optional ws, then literally `sourceURL=` OR
+// `sourceMappingURL=` (trailing `=` REQUIRED; case-sensitive). Ground truth below
+// was confirmed by running upstream's exact `stripComments` regex logic.
+// ----------------------------------------------------------------------------
+
+#[test]
+fn test_preserve_source_url_comment() {
+    // `/*#sourceURL=foo*/` matches -> PRESERVED verbatim.
+    let result = shim("/*#sourceURL=foo*/ b {c}", "contenta");
+    assert_eq!(result, "/*#sourceURL=foo*/ b[contenta] {c}");
+}
+
+#[test]
+fn test_preserve_source_mapping_url_comment_with_spaces() {
+    // `/* # sourceMappingURL=foo */` matches -> PRESERVED verbatim.
+    let result = shim("/* # sourceMappingURL=foo */ b {c}", "contenta");
+    assert_eq!(result, "/* # sourceMappingURL=foo */ b[contenta] {c}");
+}
+
+#[test]
+fn test_strip_non_sourcemap_hash_comment() {
+    // `/* # source: secret */` does NOT match `source(Mapping)?URL=` -> STRIPPED.
+    // (single line -> collapses to nothing, leaving only the trailing space).
+    let result = shim("/* # source: secret */ b {c}", "contenta");
+    assert_eq!(result, " b[contenta] {c}");
+}
+
+#[test]
+fn test_strip_source_url_without_equals() {
+    // `/* #sourceURLx */` -> `#sourceURL` not followed by `=` -> STRIPPED.
+    let result = shim("/* #sourceURLx */ b {c}", "contenta");
+    assert_eq!(result, " b[contenta] {c}");
+}
+
+#[test]
+fn test_strip_source_url_without_hash() {
+    // `/* sourceURL= */` -> no `#` -> STRIPPED.
+    let result = shim("/* sourceURL= */ b {c}", "contenta");
+    assert_eq!(result, " b[contenta] {c}");
+}
+
+#[test]
+fn test_strip_source_map_hash_comment() {
+    // `/* # sourceMap */` -> `sourceMap` is neither `sourceURL=` nor
+    // `sourceMappingURL=` -> STRIPPED.
+    let result = shim("/* # sourceMap */ b {c}", "contenta");
+    assert_eq!(result, " b[contenta] {c}");
+}
+
+#[test]
+fn test_strip_non_sourcemap_hash_comment_preserves_interior_newline() {
+    // A stripped non-sourcemap comment still keeps its interior `\n` (line-count
+    // stability), collapsing to just that newline plus the trailing space.
+    let result = shim("/* # source:\nsecret */ b {c}", "contenta");
+    assert_eq!(result, "\n b[contenta] {c}");
+}
+
+// =====================================================================}
+
 // ============================================================================
 // Additional Attribute Selector Tests
 // ============================================================================
diff --git a/crates/oxc_angular_compiler/tests/svg_animation_sanitization_test.rs b/crates/oxc_angular_compiler/tests/svg_animation_sanitization_test.rs
new file mode 100644
index 000000000..e1489a4a4
--- /dev/null
+++ b/crates/oxc_angular_compiler/tests/svg_animation_sanitization_test.rs
@@ -0,0 +1,144 @@
+//! Issue #315 sub-gap 2: SVG animation *value* attributes must be validated.
+//!
+//! Binding `[attr.to]` / `[attr.from]` / `[attr.values]` on an SVG `<animate>`
+//! (or `[attr.to]` on `<set>`) animates the referenced attribute's *value* at
+//! runtime. This is an XSS vector identical to `attributeName`, so upstream
+//! registers these as `ATTRIBUTE_NO_BINDING`, which resolves to the
+//! `ɵɵvalidateAttribute` validator in generated code.
+//!
+//! Before the schema fix these emitted a plain `ɵɵattribute("to", ctx.x)` with no
+//! validator. After the fix they emit
+//! `ɵɵattribute("to", ctx.x, ɵɵvalidateAttribute)`.
+//!
+//! The harness here mirrors `integration_test.rs::compile_template_to_js`
+//! (the same public pipeline API), kept self-contained to avoid disturbing the
+//! large shared integration file.
+
+use oxc_allocator::Allocator;
+use oxc_angular_compiler::{
+    output::ast::FunctionExpr,
+    output::emitter::JsEmitter,
+    parser::html::HtmlParser,
+    pipeline::{emit::compile_template, ingest::ingest_component},
+    transform::html_to_r3::{HtmlToR3Transform, TransformOptions},
+};
+use oxc_str::Ident;
+
+/// Compiles an Angular template to JavaScript via the full pipeline.
+fn compile_template_to_js(template: &str, component_name: &str) -> String {
+    let allocator = Allocator::default();
+
+    let parser = HtmlParser::with_expansion_forms(&allocator, template, "test.html");
+    let html_result = parser.parse();
+    if !html_result.errors.is_empty() {
+        let errors: Vec<_> = html_result.errors.iter().map(|e| e.msg.clone()).collect();
+        panic!("HTML parse errors: {errors:?}");
+    }
+
+    let transformer = HtmlToR3Transform::new(&allocator, template, TransformOptions::default());
+    let r3_result = transformer.transform(&html_result.nodes);
+    if !r3_result.errors.is_empty() {
+        let errors: Vec<_> = r3_result.errors.iter().map(|e| e.msg.clone()).collect();
+        panic!("Transform errors: {errors:?}");
+    }
+
+    let mut job = ingest_component(&allocator, Ident::from(component_name), r3_result.nodes);
+    let result = compile_template(&mut job);
+
+    let emitter = JsEmitter::new();
+    let mut output = String::new();
+    for decl in &result.declarations {
+        output.push_str(&emitter.emit_statement(decl));
+        output.push('\n');
+    }
+    output.push_str(&emit_function(&emitter, &result.template_fn));
+    output
+}
+
+/// Emit a `FunctionExpr` to JavaScript (mirrors the integration-test helper).
+fn emit_function(emitter: &JsEmitter, func: &FunctionExpr<'_>) -> String {
+    let mut result = String::new();
+    result.push_str("function ");
+    if let Some(ref name) = func.name {
+        result.push_str(name.as_str());
+    }
+    result.push('(');
+    for (i, param) in func.params.iter().enumerate() {
+        if i > 0 {
+            result.push(',');
+        }
+        result.push_str(param.name.as_str());
+    }
+    result.push_str(") {\n");
+    for stmt in &func.statements {
+        let stmt_str = emitter.emit_statement(stmt);
+        for line in stmt_str.lines() {
+            result.push_str("  ");
+            result.push_str(line);
+            result.push('\n');
+        }
+    }
+    result.push('}');
+    result
+}
+
+#[test]
+fn svg_animate_to_binding_emits_validate_attribute() {
+    // <animate [attr.to]> -> ɵɵattribute("to", ctx.x, ɵɵvalidateAttribute)
+    let js = compile_template_to_js("<svg><animate [attr.to]=\"x\"></animate></svg>", "TestCmp");
+    assert!(
+        js.contains("ɵɵvalidateAttribute"),
+        "expected ɵɵvalidateAttribute for <animate [attr.to]>, got:\n{js}"
+    );
+}
+
+#[test]
+fn svg_animate_from_binding_emits_validate_attribute() {
+    let js = compile_template_to_js("<svg><animate [attr.from]=\"x\"></animate></svg>", "TestCmp");
+    assert!(
+        js.contains("ɵɵvalidateAttribute"),
+        "expected ɵɵvalidateAttribute for <animate [attr.from]>, got:\n{js}"
+    );
+}
+
+#[test]
+fn svg_animate_values_binding_emits_validate_attribute() {
+    let js =
+        compile_template_to_js("<svg><animate [attr.values]=\"x\"></animate></svg>", "TestCmp");
+    assert!(
+        js.contains("ɵɵvalidateAttribute"),
+        "expected ɵɵvalidateAttribute for <animate [attr.values]>, got:\n{js}"
+    );
+}
+
+#[test]
+fn svg_namespaced_animate_to_binding_emits_validate_attribute() {
+    // Explicitly namespaced `<svg:animate>` (stored as `:svg:animate`) must
+    // resolve identically once the namespace prefix is stripped at lookup.
+    let js = compile_template_to_js("<svg:animate [attr.to]=\"x\"></svg:animate>", "TestCmp");
+    assert!(
+        js.contains("ɵɵvalidateAttribute"),
+        "expected ɵɵvalidateAttribute for <svg:animate [attr.to]>, got:\n{js}"
+    );
+}
+
+#[test]
+fn svg_set_to_binding_emits_validate_attribute() {
+    let js = compile_template_to_js("<svg><set [attr.to]=\"x\"></set></svg>", "TestCmp");
+    assert!(
+        js.contains("ɵɵvalidateAttribute"),
+        "expected ɵɵvalidateAttribute for <set [attr.to]>, got:\n{js}"
+    );
+}
+
+#[test]
+fn plain_attr_binding_does_not_emit_validate_attribute() {
+    // Control: an ordinary attribute binding must NOT gain a validator, proving
+    // the harness compiles distinct templates and the schema change is targeted.
+    let js = compile_template_to_js("<div [attr.title]=\"x\"></div>", "TestCmp");
+    assert!(
+        !js.contains("ɵɵvalidateAttribute"),
+        "unexpected ɵɵvalidateAttribute for <div [attr.title]>, got:\n{js}"
+    );
+    assert!(js.contains("ɵɵattribute"), "expected ɵɵattribute for <div [attr.title]>, got:\n{js}");
+}