From 717f0c76c60b8acd464b14b97a3b77cc2117412e Mon Sep 17 00:00:00 2001
From: Gabriel Silva <gabrielsilvadev.comercial@gmail.com>
Date: Thu, 22 Oct 2026 00:35:50 -0300
Subject: [PATCH] fix(compiler): emit the sanitizers ngtsc adds since 22.0.1

Port the sanitization fixes Angular shipped from 22.0.1 on, each gated on
the releases that got it upstream:

- sanitize two-way property bindings (angular/angular@3c70270c96)
- check host bindings against every concrete host element, so a selector
  without a URL sink no longer drops the sanitizer (angular/angular@d06e3748b7)
- treat href / xlink:href of any MathML element as a URL
  (angular/angular@3927a5b271)
- fall back from the :svg: / :math: keys to the HTML keys and validate
  iframe credentialless (angular/angular@32d7315094, angular/angular@0152e3cbdf)
- look an <animate> outside <svg> up in the SVG keys
  (angular/angular@7168bed663)
---
 .../src/component/metadata.rs                 | 135 ++++++++++++
 .../src/pipeline/phases/resolve_sanitizers.rs |  12 +-
 .../src/schema/dom_security_schema.rs         | 196 ++++++++++++++----
 .../src/transform/html_to_r3.rs               |  28 ++-
 .../oxc_angular_compiler/tests/linker_test.rs |  22 +-
 .../tests/sanitizer_parity_test.rs            | 173 ++++++++++++++++
 .../regressions/sanitizer-parity.fixture.ts   |  80 +++++++
 7 files changed, 594 insertions(+), 52 deletions(-)
 create mode 100644 crates/oxc_angular_compiler/tests/sanitizer_parity_test.rs
 create mode 100644 napi/angular-compiler/e2e/compare/fixtures/regressions/sanitizer-parity.fixture.ts

diff --git a/crates/oxc_angular_compiler/src/component/metadata.rs b/crates/oxc_angular_compiler/src/component/metadata.rs
index b97bc38d8..1c8401a6b 100644
--- a/crates/oxc_angular_compiler/src/component/metadata.rs
+++ b/crates/oxc_angular_compiler/src/component/metadata.rs
@@ -310,6 +310,99 @@ impl AngularVersion {
         self.at_22_2_2_cutoff_or_later()
     }
 
+    /// Check if this version sanitizes two-way property bindings
+    /// (`[(innerHTML)]`, `[(href)]`, ...).
+    ///
+    /// `angular/angular@3c70270c96` added `TwoWayProperty` to
+    /// `resolveSanitizers`. First released in 20.3.25, 21.2.17, 22.0.1 and
+    /// 22.1.0-next.0; the 19.2.x line never got it.
+    pub fn sanitizes_two_way_properties(&self) -> bool {
+        self.fixed_since(&[
+            Self::new(20, 3, 25),
+            Self::new(21, 2, 17),
+            Self::new(22, 0, 1),
+            Self::new(22, 1, 0).with_prerelease(Prerelease::Next(0)),
+        ])
+    }
+
+    /// Check if this version treats `href` / `xlink:href` of every MathML
+    /// element as a URL sink (`:math:*`), not only a fixed element list.
+    ///
+    /// `angular/angular@3927a5b271`, first in 22.0.1 and 22.1.0-next.0.
+    pub fn matches_any_mathml_href(&self) -> bool {
+        self.fixed_since(&[
+            Self::new(22, 0, 1),
+            Self::new(22, 1, 0).with_prerelease(Prerelease::Next(0)),
+        ])
+    }
+
+    /// Check if this version's security lookup falls back from the
+    /// `:svg:` / `:math:` table to the HTML table (`<svg><iframe [src]>` is a
+    /// resource URL), and marks iframe `credentialless` as security
+    /// sensitive.
+    ///
+    /// `angular/angular@32d7315094` and `angular/angular@0152e3cbdf`, both
+    /// first in 22.0.2 and 22.1.0-next.1.
+    pub fn uses_22_0_2_security_schema(&self) -> bool {
+        self.fixed_since(&[
+            Self::new(22, 0, 2),
+            Self::new(22, 1, 0).with_prerelease(Prerelease::Next(1)),
+        ])
+    }
+
+    /// Check if this version looks up an SVG animation element written
+    /// outside `<svg>` (no namespace) in the SVG table.
+    ///
+    /// `angular/angular@7168bed663`, first in 22.1.5 and 22.2.0-next.5.
+    pub fn validates_svg_animation_outside_svg(&self) -> bool {
+        self.fixed_since(&[
+            Self::new(22, 1, 5),
+            Self::new(22, 2, 0).with_prerelease(Prerelease::Next(5)),
+        ])
+    }
+
+    /// Check if this version computes host binding security contexts against
+    /// every possible concrete host element instead of only the declaring
+    /// selector.
+    ///
+    /// `angular/angular@d06e3748b7`, first in 20.3.28, 21.2.20, 22.1.0 and
+    /// 22.2.0-next.0. No 22.0.x release has it.
+    pub fn sanitizes_host_bindings_on_concrete_hosts(&self) -> bool {
+        self.fixed_since(&[
+            Self::new(20, 3, 28),
+            Self::new(21, 2, 20),
+            Self::new(22, 1, 0),
+            Self::new(22, 2, 0).with_prerelease(Prerelease::Next(0)),
+        ])
+    }
+
+    /// Whether a fix is in this version, given the first fixed release on
+    /// each release line, oldest line first.
+    ///
+    /// A version on a listed `major.minor` line compares against that line's
+    /// cutoff; a version newer than every listed line has the fix; a version
+    /// on any other line does not.
+    fn fixed_since(&self, cutoffs: &[AngularVersion]) -> bool {
+        if let Some(cutoff) =
+            cutoffs.iter().find(|c| c.major == self.major && c.minor == self.minor)
+        {
+            return self.cmp_release(cutoff).is_ge();
+        }
+        cutoffs.last().is_some_and(|newest| (self.major, self.minor) > (newest.major, newest.minor))
+    }
+
+    /// Orders two versions, a stable release sorting after its prereleases.
+    fn cmp_release(&self, other: &AngularVersion) -> std::cmp::Ordering {
+        (self.major, self.minor, self.patch)
+            .cmp(&(other.major, other.minor, other.patch))
+            .then_with(|| match (self.prerelease, other.prerelease) {
+                (None, None) => std::cmp::Ordering::Equal,
+                (None, Some(_)) => std::cmp::Ordering::Greater,
+                (Some(_), None) => std::cmp::Ordering::Less,
+                (Some(a), Some(b)) => a.cmp(&b),
+            })
+    }
+
     /// Parse a version string like "19.0.0" or "19.0.0-rc.1".
     ///
     /// The `-next.N` / `-rc.N` prerelease tag is retained; any other suffix
@@ -962,6 +1055,48 @@ mod tests {
         }
     }
 
+    /// Security fixes backported per release line: a version on a listed line
+    /// compares against that line's first fixed release, a newer line has the
+    /// fix, and an unlisted older line (21.0.x, 21.1.x, 22.0.x for host
+    /// bindings) never got it.
+    #[test]
+    fn security_backports_follow_each_release_line() {
+        let parse = |s| AngularVersion::parse(s).unwrap();
+
+        for version in
+            ["20.3.28", "21.2.20", "22.1.0", "22.1.3", "22.2.0-next.0", "22.2.2", "23.0.0"]
+        {
+            assert!(parse(version).sanitizes_host_bindings_on_concrete_hosts(), "{version}");
+        }
+        for version in [
+            "19.2.25",
+            "20.2.9",
+            "20.3.27",
+            "21.0.9",
+            "21.2.19",
+            "22.0.8",
+            "22.1.0-rc.0",
+            "22.2.0-beta.1",
+        ] {
+            assert!(!parse(version).sanitizes_host_bindings_on_concrete_hosts(), "{version}");
+        }
+
+        for version in ["20.3.25", "21.2.17", "22.0.1", "22.1.0-next.0", "22.1.0-rc.1"] {
+            assert!(parse(version).sanitizes_two_way_properties(), "{version}");
+        }
+        for version in ["19.2.25", "20.3.24", "21.1.5", "21.2.16", "22.0.0", "22.1.0-beta.1"] {
+            assert!(!parse(version).sanitizes_two_way_properties(), "{version}");
+        }
+
+        assert!(parse("22.1.0-next.1").uses_22_0_2_security_schema());
+        assert!(!parse("22.1.0-next.0").uses_22_0_2_security_schema());
+        assert!(parse("22.1.0-next.0").matches_any_mathml_href());
+        assert!(!parse("21.2.25").matches_any_mathml_href());
+        assert!(parse("22.2.0-next.5").validates_svg_animation_outside_svg());
+        assert!(!parse("22.2.0-next.4").validates_svg_animation_outside_svg());
+        assert!(!parse("22.0.8").validates_svg_animation_outside_svg());
+    }
+
     #[test]
     fn incremental_hydration_runtime_starts_at_22_0_0_next_11() {
         let parse = |s| AngularVersion::parse(s).unwrap();
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 9e0820756..90ab8f20e 100644
--- a/crates/oxc_angular_compiler/src/pipeline/phases/resolve_sanitizers.rs
+++ b/crates/oxc_angular_compiler/src/pipeline/phases/resolve_sanitizers.rs
@@ -112,9 +112,12 @@ fn resolve_iframe_sanitizer(
 ///
 /// This phase:
 /// 1. For ExtractedAttribute ops (constant attributes), sets the trusted value function
-/// 2. For Property, Attribute, and DomProperty ops, sets the sanitizer function
+/// 2. For Property, Attribute, DomProperty and (from the versions that sanitize
+///    them) TwoWayProperty ops, sets the sanitizer function
 pub fn resolve_sanitizers(job: &mut ComponentCompilationJob<'_>) {
     let iframe_validation = uses_iframe_attr_validation(job.angular_version);
+    let sanitize_two_way =
+        job.angular_version.is_none_or(|version| version.sanitizes_two_way_properties());
     // Collect view xrefs to avoid borrow issues
     let view_xrefs: Vec<_> = job.all_views().map(|v| v.xref).collect();
 
@@ -176,6 +179,13 @@ pub fn resolve_sanitizers(job: &mut ComponentCompilationJob<'_>) {
                             );
                         }
                     }
+                    // The legacy iframe fallback predates two-way sanitization,
+                    // so it never applies here.
+                    UpdateOp::TwoWayProperty(two_way) if sanitize_two_way => {
+                        if let Some(fn_name) = get_sanitizer_fn(two_way.security_context) {
+                            two_way.sanitizer = Some(Ident::from(fn_name));
+                        }
+                    }
                     _ => {}
                 }
             }
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 1c3b42d30..d529b9314 100644
--- a/crates/oxc_angular_compiler/src/schema/dom_security_schema.rs
+++ b/crates/oxc_angular_compiler/src/schema/dom_security_schema.rs
@@ -42,12 +42,18 @@ enum SchemaKind {
     V21_2_7,
     /// 21.2.14 only. Namespaced keys but no `:svg:a|href` yet.
     V21_2_14,
-    /// 19.2.23+, 20.3.22+, 21.2.15+, 22.0.0–22.2.1. Namespaced keys with
+    /// 19.2.23+, 20.3.22+, 21.2.15+, 22.0.0. Namespaced keys with
     /// `:svg:a|href`. `script|src` and `script|href` are gone.
     V22,
+    /// 22.0.1 / 22.1.0-next.0. `href` / `xlink:href` are URL sinks on every
+    /// MathML element (`:math:*`), and lookups try the `:ns:*` key.
+    V22_0_1,
+    /// 22.0.2+ / 22.1.0-next.1+ through 22.2.1. Adds iframe `credentialless`
+    /// and falls back from the `:svg:` / `:math:` keys to the HTML keys.
+    V22_0_2,
     /// 22.2.2+ / 22.3.0-next.1+. `angular/angular@439ff1bdf4` removed `img|src`
     /// and `video|src` from the URL context; the fix was never backported to
-    /// the older maintained lines, so `V22` still carries them.
+    /// the older maintained lines, so the other kinds still carry them.
     V22_2_2,
 }
 
@@ -76,19 +82,27 @@ struct SecurityProfile {
     /// removed this when the iframe `attributeNoBinding` keys landed
     /// (19.2.17 / 20.3.15 / 21.0.2), so it only exists on the legacy schema.
     iframe_attr_validation: bool,
+    /// A tag with no namespace that misses the HTML keys is looked up in the
+    /// SVG keys, so `<animate>` written outside `<svg>` still hits
+    /// `:svg:animate|to` (22.1.5+ / 22.2.0-next.5+).
+    svg_animation_fallback: bool,
 }
 
 fn security_profile(version: Option<crate::AngularVersion>) -> SecurityProfile {
     let Some(version) = version else {
-        return v22_profile(SchemaKind::V22_2_2);
+        return v22_profile(SchemaKind::V22_2_2, true);
     };
     if version.major >= 22 {
         let kind = if version.drops_img_video_src_url_context() {
             SchemaKind::V22_2_2
+        } else if version.uses_22_0_2_security_schema() {
+            SchemaKind::V22_0_2
+        } else if version.matches_any_mathml_href() {
+            SchemaKind::V22_0_1
         } else {
             SchemaKind::V22
         };
-        return v22_profile(kind);
+        return v22_profile(kind, version.validates_svg_animation_outside_svg());
     }
 
     let (kind, iframe_src_i18n) = match version.major {
@@ -124,7 +138,7 @@ fn security_profile(version: Option<crate::AngularVersion>) -> SecurityProfile {
         _ => (SchemaKind::Legacy, false),
     };
 
-    let namespaced = matches!(kind, SchemaKind::V21_2_14 | SchemaKind::V22 | SchemaKind::V22_2_2);
+    let namespaced = matches!(kind, SchemaKind::V21_2_14 | SchemaKind::V22);
     // `:svg:style` stripping existed only in 19.2.23, 20.3.22 and 21.2.14.
     let strip_svg_style = matches!(kind, SchemaKind::V21_2_14)
         || (version.major == 20 && version.minor == 3 && version.patch == 22)
@@ -135,15 +149,16 @@ fn security_profile(version: Option<crate::AngularVersion>) -> SecurityProfile {
         // `normalizeTagName` in `securityContext` landed with the schema
         // backports that carried `:svg:a|href` (19.2.23 / 20.3.22 / 21.2.15);
         // 21.2.14 has namespaced keys but no normalizer.
-        normalizes_tag_names: matches!(kind, SchemaKind::V22 | SchemaKind::V22_2_2),
+        normalizes_tag_names: matches!(kind, SchemaKind::V22),
         strip_svg_script: namespaced,
         strip_svg_style,
         iframe_src_i18n,
         iframe_attr_validation: matches!(kind, SchemaKind::Legacy),
+        svg_animation_fallback: false,
     }
 }
 
-fn v22_profile(kind: SchemaKind) -> SecurityProfile {
+fn v22_profile(kind: SchemaKind, svg_animation_fallback: bool) -> SecurityProfile {
     SecurityProfile {
         kind,
         namespaced: true,
@@ -152,6 +167,7 @@ fn v22_profile(kind: SchemaKind) -> SecurityProfile {
         strip_svg_style: false,
         iframe_src_i18n: true,
         iframe_attr_validation: false,
+        svg_animation_fallback,
     }
 }
 
@@ -214,6 +230,11 @@ fn build_v22_schema(kind: SchemaKind) -> FxHashMap<String, SecurityContext> {
     // (`angular/angular@439ff1bdf4`); that change was never backported to
     // the 21.x/20.x/19.x lines.
     let with_img_video_src = kind != SchemaKind::V22_2_2;
+    // `angular/angular@3927a5b271` replaced the MathML element list with `*`.
+    let mathml_wildcard =
+        matches!(kind, SchemaKind::V22_0_1 | SchemaKind::V22_0_2 | SchemaKind::V22_2_2);
+    // `angular/angular@0152e3cbdf` added iframe `credentialless`.
+    let with_credentialless = matches!(kind, SchemaKind::V22_0_2 | SchemaKind::V22_2_2);
     let mut schema = FxHashMap::default();
 
     register(
@@ -245,11 +266,12 @@ fn build_v22_schema(kind: SchemaKind) -> FxHashMap<String, SecurityContext> {
         );
     }
 
+    let mathml_url_elements: &[&str] = if mathml_wildcard { &["*"] } else { MATHML_URL_ELEMENTS };
     register_uniform(
         &mut schema,
         SecurityContext::Url,
         Some("math"),
-        MATHML_URL_ELEMENTS,
+        mathml_url_elements,
         &["href", "xlink:href"],
     );
 
@@ -312,12 +334,24 @@ fn build_v22_schema(kind: SchemaKind) -> FxHashMap<String, SecurityContext> {
             ),
         ],
     );
+    if with_credentialless {
+        register(
+            &mut schema,
+            SecurityContext::AttributeNoBinding,
+            None,
+            &[("unknown", &["credentialless"]), ("iframe", &["credentialless"])],
+        );
+    }
 
     schema
 }
 
 static V22_SCHEMA: LazyLock<FxHashMap<String, SecurityContext>> =
     LazyLock::new(|| build_v22_schema(SchemaKind::V22));
+static V22_0_1_SCHEMA: LazyLock<FxHashMap<String, SecurityContext>> =
+    LazyLock::new(|| build_v22_schema(SchemaKind::V22_0_1));
+static V22_0_2_SCHEMA: LazyLock<FxHashMap<String, SecurityContext>> =
+    LazyLock::new(|| build_v22_schema(SchemaKind::V22_0_2));
 static V22_2_2_SCHEMA: LazyLock<FxHashMap<String, SecurityContext>> =
     LazyLock::new(|| build_v22_schema(SchemaKind::V22_2_2));
 static V21_2_14_SCHEMA: LazyLock<FxHashMap<String, SecurityContext>> =
@@ -345,6 +379,8 @@ fn schema_for(kind: SchemaKind) -> &'static FxHashMap<String, SecurityContext> {
         SchemaKind::V21_2_7 => &V21_27_SCHEMA,
         SchemaKind::V21_2_14 => &V21_2_14_SCHEMA,
         SchemaKind::V22 => &V22_SCHEMA,
+        SchemaKind::V22_0_1 => &V22_0_1_SCHEMA,
+        SchemaKind::V22_0_2 => &V22_0_2_SCHEMA,
         SchemaKind::V22_2_2 => &V22_2_2_SCHEMA,
     }
 }
@@ -806,9 +842,8 @@ fn register_uniform(
 ) {
     for element in elements {
         let tag = match namespace {
-            Some(ns) if *element != "*" && *element != "unknown" => {
-                format!(":{ns}:{element}").to_ascii_lowercase()
-            }
+            // A namespaced `*` is that namespace's wildcard (`:math:*`).
+            Some(ns) if *element != "unknown" => format!(":{ns}:{element}").to_ascii_lowercase(),
             _ => (*element).to_ascii_lowercase(),
         };
         for attr in attrs {
@@ -862,16 +897,36 @@ pub fn get_security_context_for(
     let property_lower = property.to_ascii_lowercase();
     let schema = schema_for(profile.kind);
 
-    let key = format!("{tag}|{property_lower}");
-    if let Some(&ctx) = schema.get(&key) {
+    let lookup = |tag: &str| schema.get(&format!("{tag}|{property_lower}")).copied();
+    if let Some(ctx) = lookup(&tag) {
         return ctx;
     }
 
-    let wildcard_key = format!("*|{property_lower}");
-    if let Some(&ctx) = schema.get(&wildcard_key) {
+    // `checkSecurityContext` (22.0.1+) tries the namespace's own `*` key, and
+    // from 22.0.2 falls back to the HTML keys of the local name.
+    let namespaced_lookup =
+        matches!(profile.kind, SchemaKind::V22_0_1 | SchemaKind::V22_0_2 | SchemaKind::V22_2_2);
+    let (ns, local_name) = split_ns_name(&tag);
+    let ns = ns.filter(|ns| matches!(*ns, "svg" | "math"));
+    if let Some(ns) = ns.filter(|_| namespaced_lookup) {
+        let html_fallback = profile.kind != SchemaKind::V22_0_1;
+        let ctx = lookup(&format!(":{ns}:*"))
+            .or_else(|| html_fallback.then(|| lookup(local_name)).flatten());
+        if let Some(ctx) = ctx {
+            return ctx;
+        }
+    }
+
+    if let Some(ctx) = lookup("*") {
         return ctx;
     }
 
+    // An `<animate>` outside `<svg>` can still animate once projected into
+    // an SVG subtree.
+    if profile.svg_animation_fallback && ns.is_none() {
+        return lookup(&format!(":svg:{tag}")).unwrap_or(SecurityContext::None);
+    }
+
     SecurityContext::None
 }
 
@@ -879,7 +934,7 @@ pub fn get_security_context_for(
 ///
 /// `Url` together with `ResourceUrl` collapses to `UrlOrResourceUrl`.
 pub fn calc_security_context_for_unknown_element(property: &str) -> SecurityContext {
-    host_binding_security_context("", property)
+    reduce_security_contexts(&collect_host_contexts("", property, None))
 }
 
 /// Security context of a host binding on the latest schema (v22).
@@ -896,12 +951,49 @@ pub fn host_binding_security_context_for(
     prop_name: &str,
     version: Option<crate::AngularVersion>,
 ) -> SecurityContext {
-    let contexts = if security_profile(version).namespaced {
+    let declaring = collect_host_contexts(selector, prop_name, version);
+    if !version.is_none_or(|v| v.sanitizes_host_bindings_on_concrete_hosts()) {
+        return reduce_security_contexts(&declaring);
+    }
+
+    // `calcHostBindingSecurityContexts`: the binding can run on any concrete
+    // host (`hostDirectives`, inherited host bindings, `createComponent`), so
+    // the declaring selector only wins when it covers every context a known
+    // element has for this name.
+    let concrete = collect_host_contexts("", prop_name, version);
+    let has_none = concrete.contains(&SecurityContext::None);
+    let mut sinks = concrete.iter().filter(|ctx| **ctx != SecurityContext::None).peekable();
+    if has_none && sinks.peek().is_some() {
+        // NONE next to a URL kind defers the choice to runtime.
+        let url_kinds_only = concrete.iter().all(|ctx| {
+            matches!(
+                ctx,
+                SecurityContext::None | SecurityContext::Url | SecurityContext::ResourceUrl
+            )
+        });
+        if url_kinds_only {
+            return SecurityContext::UrlOrResourceUrl;
+        }
+        return reduce_security_contexts(&concrete);
+    }
+    if sinks.any(|ctx| !declaring.contains(ctx)) {
+        return reduce_security_contexts(&concrete);
+    }
+    reduce_security_contexts(&declaring)
+}
+
+/// `calcPossibleSecurityContexts` for a host selector; an empty selector
+/// stands for every known element.
+fn collect_host_contexts(
+    selector: &str,
+    prop_name: &str,
+    version: Option<crate::AngularVersion>,
+) -> Vec<SecurityContext> {
+    if security_profile(version).namespaced {
         collect_namespaced_contexts(selector, prop_name, version)
     } else {
         collect_bare_contexts(selector, prop_name, version)
-    };
-    reduce_security_contexts(&contexts)
+    }
 }
 
 /// Security context of a property/attribute binding on a concrete element,
@@ -1130,6 +1222,20 @@ fn security_context_rank(ctx: SecurityContext) -> u8 {
 mod tests {
     use super::*;
 
+    /// The declaring-selector half of a host lookup, before the concrete-host
+    /// widening of `calcHostBindingSecurityContexts`.
+    fn declaring_selector_context(selector: &str, prop_name: &str) -> SecurityContext {
+        declaring_selector_context_for(selector, prop_name, None)
+    }
+
+    fn declaring_selector_context_for(
+        selector: &str,
+        prop_name: &str,
+        version: Option<crate::AngularVersion>,
+    ) -> SecurityContext {
+        reduce_security_contexts(&collect_host_contexts(selector, prop_name, version))
+    }
+
     #[test]
     fn test_html_context() {
         assert_eq!(get_security_context("iframe", "srcdoc"), SecurityContext::Html);
@@ -1177,7 +1283,7 @@ mod tests {
                 "{version:?}"
             );
             assert_eq!(
-                host_binding_security_context_for("img", "src", version),
+                declaring_selector_context_for("img", "src", version),
                 SecurityContext::None,
                 "{version:?}"
             );
@@ -1236,9 +1342,25 @@ mod tests {
             SecurityContext::AttributeNoBinding
         );
         assert_eq!(get_security_context(":svg:set", "to"), SecurityContext::AttributeNoBinding);
-        // The un-namespaced key is not registered. HTML `<animate>` is not the SVG element.
-        assert_eq!(get_security_context("animate", "to"), SecurityContext::None);
-        assert_eq!(get_security_context("animate", "attributeName"), SecurityContext::None);
+        // There is no un-namespaced key, but from 22.1.5 an `<animate>` written
+        // outside `<svg>` falls back to the SVG keys, since it can still end
+        // up animating inside an SVG subtree.
+        assert_eq!(get_security_context("animate", "to"), SecurityContext::AttributeNoBinding);
+        assert_eq!(
+            get_security_context("animate", "attributeName"),
+            SecurityContext::AttributeNoBinding
+        );
+        for version in ["22.1.4", "22.2.0-next.4", "22.0.8"] {
+            let version = crate::AngularVersion::parse(version);
+            assert_eq!(get_security_context_for("animate", "to", version), SecurityContext::None);
+        }
+        for version in ["22.1.5", "22.2.0-next.5", "22.2.1"] {
+            let version = crate::AngularVersion::parse(version);
+            assert_eq!(
+                get_security_context_for("animate", "to", version),
+                SecurityContext::AttributeNoBinding
+            );
+        }
     }
 
     #[test]
@@ -1291,15 +1413,15 @@ mod tests {
     #[test]
     fn test_host_selector_promotes_svg_animate() {
         assert_eq!(
-            host_binding_security_context("animate", "to"),
+            declaring_selector_context("animate", "to"),
             SecurityContext::AttributeNoBinding
         );
-        assert_eq!(host_binding_security_context("a", "href"), SecurityContext::Url);
-        assert_eq!(host_binding_security_context("iframe", "src"), SecurityContext::ResourceUrl);
+        assert_eq!(declaring_selector_context("a", "href"), SecurityContext::Url);
+        assert_eq!(declaring_selector_context("iframe", "src"), SecurityContext::ResourceUrl);
         // 22.2.2 removed `img|src` from the URL context; 22.2.1 kept it.
-        assert_eq!(host_binding_security_context("img", "src"), SecurityContext::None);
+        assert_eq!(declaring_selector_context("img", "src"), SecurityContext::None);
         assert_eq!(
-            host_binding_security_context_for(
+            declaring_selector_context_for(
                 "img",
                 "src",
                 Some(crate::AngularVersion::new(22, 2, 1))
@@ -1310,9 +1432,9 @@ mod tests {
 
     #[test]
     fn test_host_not_selector_drops_the_only_contributor() {
-        assert_eq!(host_binding_security_context("[x]:not(object)", "data"), SecurityContext::None);
+        assert_eq!(declaring_selector_context("[x]:not(object)", "data"), SecurityContext::None);
         assert_eq!(
-            host_binding_security_context("[x]:not(img):not(video)", "src"),
+            declaring_selector_context("[x]:not(img):not(video)", "src"),
             SecurityContext::ResourceUrl
         );
     }
@@ -1324,12 +1446,12 @@ mod tests {
         for selector in ["*", "*[x]", "[x]"] {
             // 22.2.2 removed the `src` URL keys, leaving only ResourceUrl.
             assert_eq!(
-                host_binding_security_context(selector, "src"),
+                declaring_selector_context(selector, "src"),
                 SecurityContext::ResourceUrl,
                 "{selector}"
             );
             assert_eq!(
-                host_binding_security_context(selector, "formAction"),
+                declaring_selector_context(selector, "formAction"),
                 SecurityContext::Url,
                 "{selector}"
             );
@@ -1337,14 +1459,14 @@ mod tests {
         // Same expansion on the pre-namespaced lookup path.
         let version = Some(crate::AngularVersion::new(21, 0, 1));
         assert_eq!(
-            host_binding_security_context_for("*[x]", "src", version),
+            declaring_selector_context_for("*[x]", "src", version),
             SecurityContext::UrlOrResourceUrl
         );
         // A `:not(...)`-only selector parses to a literal `*` element upstream
         // and is looked up as the `*|attr` key, which has no `src` entry.
-        assert_eq!(host_binding_security_context("*:not(img)", "src"), SecurityContext::None);
+        assert_eq!(declaring_selector_context("*:not(img)", "src"), SecurityContext::None);
         assert_eq!(
-            host_binding_security_context(":not(img):not(video)", "src"),
+            declaring_selector_context(":not(img):not(video)", "src"),
             SecurityContext::None
         );
     }
@@ -1353,12 +1475,12 @@ mod tests {
     fn test_host_selector_leading_not_is_not_a_namespace() {
         // `:not(...)` is a pseudo-class, not a `:ns:` prefix.
         assert_eq!(
-            host_binding_security_context(":not(img):not(video)", "src"),
+            declaring_selector_context(":not(img):not(video)", "src"),
             SecurityContext::None
         );
         // A real `:svg:` prefix still namespaces the lookup.
         assert_eq!(
-            host_binding_security_context(":svg:animate", "to"),
+            declaring_selector_context(":svg:animate", "to"),
             SecurityContext::AttributeNoBinding
         );
     }
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 cb46cca31..96911e327 100644
--- a/crates/oxc_angular_compiler/src/transform/html_to_r3.rs
+++ b/crates/oxc_angular_compiler/src/transform/html_to_r3.rs
@@ -5519,9 +5519,17 @@ mod security_tests {
             "{contexts:?}"
         );
 
-        // A namespaced host does not fall back to the bare iframe sink.
-        let (_, contexts, _) =
-            compile_selectorless(r#"<MyComp:svg:iframe [src]="url"></MyComp:svg:iframe>"#);
+        // A namespaced host falls back to the bare iframe sink from 22.0.2;
+        // before that the `:svg:iframe|src` miss has no sanitizer.
+        let source = r#"<MyComp:svg:iframe [src]="url"></MyComp:svg:iframe>"#;
+        let (_, contexts, _) = compile_selectorless(source);
+        assert!(
+            contexts
+                .iter()
+                .any(|(name, ctx)| name == "src" && *ctx == SecurityContext::ResourceUrl),
+            "{contexts:?}"
+        );
+        let (_, contexts, _) = compile_selectorless_at(source, Some(AngularVersion::new(22, 0, 1)));
         assert!(
             contexts.iter().all(|(name, ctx)| name != "src" || *ctx == SecurityContext::None),
             "{contexts:?}"
@@ -5593,13 +5601,21 @@ mod security_tests {
         );
 
         // `<MyComp>` inside `<svg>` resolves to `:svg:ng-component`, so its
-        // children stay namespaced.
-        let (_, contexts, _) =
-            compile_selectorless(r#"<svg><MyComp><iframe [src]="url"></iframe></MyComp></svg>"#);
+        // children stay namespaced: `:svg:iframe|src` only hits the HTML
+        // `iframe|src` key through the 22.0.2+ fallback.
+        let source = r#"<svg><MyComp><iframe [src]="url"></iframe></MyComp></svg>"#;
+        let (_, contexts, _) = compile_selectorless_at(source, Some(AngularVersion::new(22, 0, 1)));
         assert!(
             contexts.iter().all(|(name, ctx)| name != "src" || *ctx == SecurityContext::None),
             "{contexts:?}"
         );
+        let (_, contexts, _) = compile_selectorless(source);
+        assert!(
+            contexts
+                .iter()
+                .any(|(name, ctx)| name == "src" && *ctx == SecurityContext::ResourceUrl),
+            "{contexts:?}"
+        );
 
         // At the HTML root `tagName === null`: children are plain HTML.
         let (_, contexts, _) =
diff --git a/crates/oxc_angular_compiler/tests/linker_test.rs b/crates/oxc_angular_compiler/tests/linker_test.rs
index b98c0f551..6b444be59 100644
--- a/crates/oxc_angular_compiler/tests/linker_test.rs
+++ b/crates/oxc_angular_compiler/tests/linker_test.rs
@@ -328,18 +328,24 @@ fn test_link_does_not_sanitize_img_video_src_from_22_2_2() {
     assert_eq!(default_link, link_for_version(SRC_BINDINGS_COMPONENT, None));
 }
 
-/// Checks that the application's version reaches the directive host path: before 22.2.2,
-/// `img|src` is in the URL schema, so the host binding must be sanitized.
-/// Only "sanitized" is asserted, not which sanitizer, and 22.2.2 is not asserted at all:
-/// Angular emits `ɵɵsanitizeUrlOrResourceUrl` here for both versions (concrete host security
-/// contexts, angular/angular@d06e3748b7), which OXC does not port yet.
+/// Checks that the application's version reaches the directive host path. 22.0.8 still
+/// picks the sanitizer from the `img` selector (`img|src` is a URL there); from 22.1.0 the
+/// binding is checked against every concrete host (angular/angular@d06e3748b7), so `src`
+/// defers the URL / resource URL choice to runtime.
 #[test]
 fn test_link_host_src_binding_respects_angular_version() {
-    let code = link_for_version(SRC_HOST_DIRECTIVE, Some(AngularVersion::new(22, 2, 1)));
+    let code = link_for_version(SRC_HOST_DIRECTIVE, Some(AngularVersion::new(22, 0, 8)));
     assert!(
-        code.contains(r#"ɵɵdomProperty("src",ctx.url,i0.ɵɵsanitize"#),
-        "22.2.1 must reach the directive host path and sanitize `img|src`:\n{code}"
+        code.contains(r#"ɵɵdomProperty("src",ctx.url,i0.ɵɵsanitizeUrl)"#),
+        "22.0.8 must sanitize `img|src` from the selector:\n{code}"
     );
+    for version in [Some(AngularVersion::new(22, 2, 1)), None] {
+        let code = link_for_version(SRC_HOST_DIRECTIVE, version);
+        assert!(
+            code.contains(r#"ɵɵdomProperty("src",ctx.url,i0.ɵɵsanitizeUrlOrResourceUrl)"#),
+            "{version:?} must sanitize `src` for any concrete host:\n{code}"
+        );
+    }
 }
 
 /// Component host bindings follow the application's version (`ɵɵhostProperty` before 20,
diff --git a/crates/oxc_angular_compiler/tests/sanitizer_parity_test.rs b/crates/oxc_angular_compiler/tests/sanitizer_parity_test.rs
new file mode 100644
index 000000000..fb692ea7c
--- /dev/null
+++ b/crates/oxc_angular_compiler/tests/sanitizer_parity_test.rs
@@ -0,0 +1,173 @@
+//! Sanitizers that ngtsc emits and the port used to skip.
+//!
+//! Expected fragments are ngtsc 22.2.2's output with the whitespace removed.
+//! Each fix is gated on the releases that shipped it upstream.
+
+use oxc_allocator::Allocator;
+use oxc_angular_compiler::{AngularVersion, TransformOptions, transform_angular_file};
+
+fn compile(source: &str, version: Option<&str>) -> String {
+    let allocator = Allocator::default();
+    let options = TransformOptions {
+        angular_version: version.map(|v| AngularVersion::parse(v).unwrap()),
+        ..TransformOptions::default()
+    };
+    let result = transform_angular_file(&allocator, "t.ts", source, Some(&options), None);
+    assert!(result.diagnostics.is_empty(), "{:?}", result.diagnostics);
+    result.code.chars().filter(|c| !c.is_whitespace()).collect()
+}
+
+fn component(template: &str) -> String {
+    format!(
+        "import {{ Component }} from '@angular/core';\n\
+         @Component({{ selector: 'app-t', template: `{template}` }})\n\
+         export class T {{ u = 'x'; }}\n"
+    )
+}
+
+fn directive(selector: &str, host: &str) -> String {
+    format!(
+        "import {{ Directive }} from '@angular/core';\n\
+         @Directive({{ selector: '{selector}', host: {host} }})\n\
+         export class D {{ u = 'x'; }}\n"
+    )
+}
+
+/// Asserts `needle` is in the output for every version in `with`, and
+/// `without` is there instead for every version in `before`.
+fn assert_gated(source: &str, needle: &str, without: &str, with: &[&str], before: &[&str]) {
+    for version in with.iter().map(|v| Some(*v)).chain([None]) {
+        let code = compile(source, version);
+        assert!(code.contains(needle), "{version:?}: missing `{needle}` in\n{code}");
+    }
+    for version in before {
+        let code = compile(source, Some(version));
+        assert!(code.contains(without), "{version}: missing `{without}` in\n{code}");
+    }
+}
+
+#[test]
+fn two_way_properties_are_sanitized() {
+    let with = ["20.3.25", "21.2.17", "22.0.1", "22.1.0-next.0", "22.2.2"];
+    let before = ["19.2.25", "20.3.24", "21.2.16", "22.0.0"];
+    assert_gated(
+        &component(r#"<div [(innerHTML)]="u"></div>"#),
+        r#"ɵɵtwoWayProperty("innerHTML",ctx.u,i0.ɵɵsanitizeHtml)"#,
+        r#"ɵɵtwoWayProperty("innerHTML",ctx.u)"#,
+        &with,
+        &before,
+    );
+    assert_gated(
+        &component(r#"<iframe [(src)]="u"></iframe>"#),
+        r#"ɵɵtwoWayProperty("src",ctx.u,i0.ɵɵsanitizeResourceUrl)"#,
+        r#"ɵɵtwoWayProperty("src",ctx.u)"#,
+        &with,
+        &before,
+    );
+    assert_gated(
+        &component(r#"<a [(href)]="u"></a>"#),
+        r#"ɵɵtwoWayProperty("href",ctx.u,i0.ɵɵsanitizeUrl)"#,
+        r#"ɵɵtwoWayProperty("href",ctx.u)"#,
+        &with,
+        &before,
+    );
+    assert_gated(
+        &component(r#"<ng-template [(innerHTML)]="u"></ng-template>"#),
+        r#"ɵɵtwoWayProperty("innerHTML",ctx.u,i0.ɵɵsanitizeHtml)"#,
+        r#"ɵɵtwoWayProperty("innerHTML",ctx.u)"#,
+        &with,
+        &before,
+    );
+}
+
+#[test]
+fn host_bindings_are_sanitized_for_any_concrete_host() {
+    // The directive can land on another element through `hostDirectives`, so
+    // a selector without a URL sink no longer turns the sanitizer off.
+    let with = ["20.3.28", "21.2.20", "22.1.0", "22.2.0-next.0"];
+    let before = ["20.3.27", "21.2.19", "22.0.8", "22.1.0-rc.0"];
+    assert_gated(
+        &directive("div[d]", r"{ '[href]': 'u', '[attr.src]': 'u' }"),
+        r#"ɵɵdomProperty("href",ctx.u,i0.ɵɵsanitizeUrlOrResourceUrl)"#,
+        r#"ɵɵdomProperty("href",ctx.u)"#,
+        &with,
+        &before,
+    );
+    assert_gated(
+        &directive("div[d]", r"{ '[attr.src]': 'u' }"),
+        r#"ɵɵattribute("src",ctx.u,i0.ɵɵsanitizeUrlOrResourceUrl)"#,
+        r#"ɵɵattribute("src",ctx.u)"#,
+        &with,
+        &before,
+    );
+    // A selector that is itself a URL sink still widens: `a[d]` may run on
+    // `<link>`, whose `href` is a resource URL.
+    assert_gated(
+        &directive("a[d]", r"{ '[href]': 'u' }"),
+        r#"ɵɵdomProperty("href",ctx.u,i0.ɵɵsanitizeUrlOrResourceUrl)"#,
+        r#"ɵɵdomProperty("href",ctx.u,i0.ɵɵsanitizeUrl)"#,
+        &with,
+        &before,
+    );
+    assert_gated(
+        &directive("div[d]", r"{ '[attr.srcdoc]': 'u', '[attr.sandbox]': 'u' }"),
+        r#"ɵɵattribute("srcdoc",ctx.u,i0.ɵɵsanitizeHtml)("sandbox",ctx.u,i0.ɵɵvalidateAttribute)"#,
+        r#"ɵɵattribute("srcdoc",ctx.u)("sandbox",ctx.u)"#,
+        &with,
+        &before,
+    );
+
+    // A context every element shares keeps its own sanitizer, and a name no
+    // element sanitizes stays bare.
+    let code = compile(&directive("my-el", r"{ '[innerHTML]': 'u', '[title]': 'u' }"), None);
+    assert!(
+        code.contains(r#"ɵɵdomProperty("innerHTML",ctx.u,i0.ɵɵsanitizeHtml)("title",ctx.u)"#),
+        "{code}"
+    );
+}
+
+#[test]
+fn any_mathml_element_href_is_a_url() {
+    assert_gated(
+        &component(
+            r#"<math><foo [attr.href]="u"></foo><mfenced [attr.href]="u"></mfenced></math>"#,
+        ),
+        r#"ɵɵattribute("href",ctx.u,i0.ɵɵsanitizeUrl);i0.ɵɵadvance();i0.ɵɵattribute("href",ctx.u,i0.ɵɵsanitizeUrl)"#,
+        r#"ɵɵattribute("href",ctx.u);i0.ɵɵadvance();i0.ɵɵattribute("href",ctx.u)"#,
+        &["22.0.1", "22.1.0-next.0"],
+        &["21.2.25", "22.0.0"],
+    );
+}
+
+#[test]
+fn namespaced_elements_fall_back_to_the_html_schema() {
+    let source =
+        component(r#"<svg><iframe [src]="u"></iframe><iframe [srcdoc]="u"></iframe></svg>"#);
+    let with = ["22.0.2", "22.1.0-next.1"];
+    let before = ["22.0.1", "22.1.0-next.0"];
+    assert_gated(
+        &source,
+        r#"("src",ctx.u,i0.ɵɵsanitizeResourceUrl)"#,
+        r#"("src",ctx.u)"#,
+        &with,
+        &before,
+    );
+    assert_gated(
+        &source,
+        r#"("srcdoc",ctx.u,i0.ɵɵsanitizeHtml)"#,
+        r#"("srcdoc",ctx.u)"#,
+        &with,
+        &before,
+    );
+}
+
+#[test]
+fn iframe_credentialless_is_validated() {
+    assert_gated(
+        &component(r#"<iframe [attr.credentialless]="u"></iframe>"#),
+        r#"ɵɵattribute("credentialless",ctx.u,i0.ɵɵvalidateAttribute)"#,
+        r#"ɵɵattribute("credentialless",ctx.u)"#,
+        &["22.0.2", "22.1.0-next.1"],
+        &["22.0.1", "22.1.0-next.0"],
+    );
+}
diff --git a/napi/angular-compiler/e2e/compare/fixtures/regressions/sanitizer-parity.fixture.ts b/napi/angular-compiler/e2e/compare/fixtures/regressions/sanitizer-parity.fixture.ts
new file mode 100644
index 000000000..5795a9a9f
--- /dev/null
+++ b/napi/angular-compiler/e2e/compare/fixtures/regressions/sanitizer-parity.fixture.ts
@@ -0,0 +1,80 @@
+/**
+ * Regression: sanitizers ngtsc emits.
+ *
+ * Two-way bindings, host bindings checked against every concrete host,
+ * MathML hrefs, namespaced elements falling back to the HTML schema and
+ * iframe `credentialless`.
+ */
+import type { Fixture } from '../types.js'
+
+function component(name: string, template: string): Fixture {
+  const className = `${name.replace(/(^|-)(\w)/g, (_, _d, c) => c.toUpperCase())}Component`
+  return {
+    name,
+    category: 'regressions',
+    description: name,
+    className,
+    type: 'full-transform',
+    sourceCode: `
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-${name}',
+  template: \`${template}\`,
+})
+export class ${className} {
+  u = '';
+}
+    `.trim(),
+    expectedFeatures: [],
+  }
+}
+
+function directive(name: string, selector: string, host: string): Fixture {
+  const className = `${name.replace(/(^|-)(\w)/g, (_, _d, c) => c.toUpperCase())}Directive`
+  return {
+    name,
+    category: 'regressions',
+    description: name,
+    className,
+    type: 'full-transform',
+    sourceCode: `
+import { Directive } from '@angular/core';
+
+@Directive({ selector: '${selector}', host: ${host} })
+export class ${className} {
+  u = '';
+}
+    `.trim(),
+    expectedFeatures: [],
+  }
+}
+
+export const fixtures: Fixture[] = [
+  component('sanitize-two-way-html', `<div [(innerHTML)]="u"></div>`),
+  component('sanitize-two-way-iframe', `<iframe [(src)]="u" [(srcdoc)]="u"></iframe>`),
+  component('sanitize-two-way-href', `<a [(href)]="u"></a>`),
+  component('sanitize-two-way-ng-template', `<ng-template [(innerHTML)]="u"></ng-template>`),
+  directive(
+    'sanitize-host-div',
+    'div[d]',
+    `{ '[href]': 'u', '[attr.src]': 'u', '[attr.srcdoc]': 'u', '[attr.sandbox]': 'u' }`,
+  ),
+  directive('sanitize-host-img', 'img[d]', `{ '[src]': 'u' }`),
+  directive(
+    'sanitize-host-element',
+    'my-el',
+    `{ '[href]': 'u', '[innerHTML]': 'u', '[attr.action]': 'u', '[title]': 'u' }`,
+  ),
+  directive('sanitize-host-anchor', 'a[d]', `{ '[href]': 'u' }`),
+  directive('sanitize-host-svg', ':svg:rect', `{ '[attr.href]': 'u' }`),
+  component(
+    'sanitize-mathml-href',
+    `<math><a [attr.href]="u"></a><mfenced [attr.href]="u"></mfenced><menclose [attr.xlink:href]="u"></menclose><foo [attr.href]="u"></foo></math>`,
+  ),
+  component(
+    'sanitize-svg-html-fallback',
+    `<svg><iframe [src]="u"></iframe><object [data]="u"></object><iframe [srcdoc]="u"></iframe><iframe [attr.sandbox]="u"></iframe><form [action]="u"></form><area [attr.href]="u"/></svg>`,
+  ),
+  component('sanitize-credentialless', `<iframe [attr.credentialless]="u"></iframe>`),
+]