diff --git a/crates/oxc_angular_compiler/src/component/metadata.rs b/crates/oxc_angular_compiler/src/component/metadata.rs
index 2a6440eb1..d2eb46a01 100644
--- a/crates/oxc_angular_compiler/src/component/metadata.rs
+++ b/crates/oxc_angular_compiler/src/component/metadata.rs
@@ -10,6 +10,39 @@ use super::dependency::R3DependencyMetadata;
 use crate::directive::R3InputMetadata;
 use crate::output::ast::OutputExpression;
 
+/// Angular prerelease tag (`-next.N` / `-rc.N` in the published version).
+///
+/// Ordering follows Angular's release cadence: `next.N` builds come off
+/// `main` weekly, `rc.N` builds are cut from the release branch later, so
+/// `Next` < `Rc` < release. Unrecognized tags map to [`Prerelease::Other`],
+/// which sorts below both so an unknown suffix is treated as earlier than
+/// any published prerelease of the same `major.minor.patch`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Prerelease {
+    /// Any prerelease tag that is not `next.N` or `rc.N`.
+    Other,
+    /// A `next.N` (main-branch snapshot) prerelease.
+    Next(u32),
+    /// An `rc.N` (release candidate) prerelease.
+    Rc(u32),
+}
+
+impl Prerelease {
+    /// Parse a prerelease tag like `next.0` or `rc.1`.
+    ///
+    /// Unknown tags are kept as [`Prerelease::Other`] rather than dropped so
+    /// they still sort below the release of the same triple.
+    pub fn parse(tag: &str) -> Self {
+        let (channel, ordinal) = tag.split_once('.').unwrap_or((tag, "0"));
+        let ordinal: u32 = ordinal.parse().unwrap_or(0);
+        match channel {
+            "next" => Self::Next(ordinal),
+            "rc" => Self::Rc(ordinal),
+            _ => Self::Other,
+        }
+    }
+}
+
 /// Angular version information for feature detection.
 ///
 /// Used to determine version-conditional behavior like the default value
@@ -22,12 +55,21 @@ pub struct AngularVersion {
     pub minor: u32,
     /// Patch version number (e.g., 0 for Angular 19.0.0).
     pub patch: u32,
+    /// Prerelease tag (e.g., `Next(0)` for `22.3.0-next.0`), if any.
+    pub prerelease: Option<Prerelease>,
 }
 
 impl AngularVersion {
-    /// Create a new AngularVersion.
-    pub fn new(major: u32, minor: u32, patch: u32) -> Self {
-        Self { major, minor, patch }
+    /// Create a new AngularVersion for a stable release.
+    pub const fn new(major: u32, minor: u32, patch: u32) -> Self {
+        Self { major, minor, patch, prerelease: None }
+    }
+
+    /// Set the prerelease tag (e.g., `Prerelease::Next(0)` for `-next.0`).
+    #[must_use]
+    pub fn with_prerelease(mut self, prerelease: Prerelease) -> Self {
+        self.prerelease = Some(prerelease);
+        self
     }
 
     /// Check if this version supports implicit standalone default (v19.0.0+).
@@ -159,24 +201,89 @@ impl AngularVersion {
         false
     }
 
+    /// Check if this version is `major.minor.patch` or newer.
+    ///
+    /// Compares the release triple only: a prerelease of `22.3.0` counts as
+    /// `>= 22.2.2` even though it predates the `22.3.0` stable. Callers gating
+    /// on a fix that landed mid-`next` cycle must compare the stored
+    /// prerelease against the cutoff explicitly (see
+    /// [`AngularVersion::at_22_2_2_cutoff_or_later`]).
+    pub fn is_at_least(&self, major: u32, minor: u32, patch: u32) -> bool {
+        (self.major, self.minor, self.patch) >= (major, minor, patch)
+    }
+
+    /// True when the fixes shipped in `22.2.2` / `22.3.0-next.1` apply.
+    ///
+    /// Every prerelease of `22.3.0` before `next.1` — `next.0`, plus any
+    /// unrecognized tag which parses to [`Prerelease::Other`] and sorts below
+    /// `next`/`rc` — was cut before the fixes landed on `main`, so it must
+    /// compare strictly below the `next.1` cutoff rather than be excluded by
+    /// ordinal. [`AngularVersion::Rc`] sorts after `Next`, so `rc` builds
+    /// take the fixed path.
+    fn at_22_2_2_cutoff_or_later(&self) -> bool {
+        if self.major == 22 && self.minor == 3 && self.patch == 0 {
+            return match self.prerelease {
+                None => true,
+                Some(prerelease) => prerelease >= Prerelease::Next(1),
+            };
+        }
+        self.is_at_least(22, 2, 2)
+    }
+
+    /// Check if this version drops `img|src` and `video|src` from the URL
+    /// security context (v22.2.2+ / v22.3.0-next.1+).
+    ///
+    /// `angular/angular@439ff1bdf4` ("refactor(compiler): remove img/video src
+    /// attribute from the URL security context") landed only on the v22 line,
+    /// so a bound `src` on `<img>`/`<video>` no longer receives
+    /// `ɵɵsanitizeUrl`. The 19.x/20.x/21.x security backports kept the keys.
+    /// `22.3.0-next.0` and every earlier `22.3.0` prerelease are excluded:
+    /// they sort after `22.2.2` by triple but were cut before the fix landed
+    /// on `main` (first in `v22.3.0-next.1`).
+    pub fn drops_img_video_src_url_context(&self) -> bool {
+        self.at_22_2_2_cutoff_or_later()
+    }
+
+    /// Check if this version strips the `:svg:`/`:math:` namespace prefix from
+    /// the single-root tag passed to `ɵɵconditionalCreate` /
+    /// `ɵɵconditionalBranchCreate` / `ɵɵrepeaterCreate` (v22.2.2+ /
+    /// v22.3.0-next.1+).
+    ///
+    /// `angular/angular@0244a1cb3` ("fix(compiler): match namespaced root nodes
+    /// of control flow blocks against ng-content tag selectors") was never
+    /// backported to the 21.x/20.x/19.x lines. `22.3.0-next.0` and every
+    /// earlier `22.3.0` prerelease are excluded: they sort after `22.2.2` by
+    /// triple but were cut before the fix landed on `main` (first in
+    /// `v22.3.0-next.1`).
+    pub fn strips_namespaced_block_tag(&self) -> bool {
+        self.at_22_2_2_cutoff_or_later()
+    }
+
     /// Parse a version string like "19.0.0" or "19.0.0-rc.1".
     ///
-    /// Returns `None` if the version string is invalid.
+    /// The `-next.N` / `-rc.N` prerelease tag is retained; any other suffix
+    /// parses to [`Prerelease::Other`]. Returns `None` if the version string
+    /// is invalid.
     pub fn parse(version_str: &str) -> Option<Self> {
         // Handle placeholder version (means latest/head)
         if version_str == "0.0.0-PLACEHOLDER" {
             return Some(Self::new(u32::MAX, 0, 0)); // Treat as latest
         }
 
-        // Strip any prerelease suffix: "19.0.0-rc.1" -> "19.0.0"
-        let base_version = version_str.split('-').next()?;
+        // "19.0.0-rc.1" -> base "19.0.0", prerelease tag "rc.1"
+        let (base_version, prerelease) = match version_str.split_once('-') {
+            Some((base, tag)) => (base, Some(Prerelease::parse(tag))),
+            None => (version_str, None),
+        };
 
         let mut parts = base_version.split('.');
         let major = parts.next()?.parse().ok()?;
         let minor = parts.next().and_then(|s| s.parse().ok()).unwrap_or(0);
         let patch = parts.next().and_then(|s| s.parse().ok()).unwrap_or(0);
 
-        Some(Self::new(major, minor, patch))
+        let mut version = Self::new(major, minor, patch);
+        version.prerelease = prerelease;
+        Some(version)
     }
 }
 
@@ -722,3 +829,67 @@ impl<'a> ComponentMetadata<'a> {
         format!("{}@{}", file_path, self.class_name)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_keeps_prerelease_tag() {
+        assert_eq!(
+            AngularVersion::parse("22.3.0-next.0"),
+            Some(AngularVersion::new(22, 3, 0).with_prerelease(Prerelease::Next(0)))
+        );
+        assert_eq!(
+            AngularVersion::parse("19.0.0-rc.1"),
+            Some(AngularVersion::new(19, 0, 0).with_prerelease(Prerelease::Rc(1)))
+        );
+        // Unknown tags stay a prerelease (below the release) rather than being
+        // dropped.
+        assert_eq!(
+            AngularVersion::parse("19.0.0-beta.2"),
+            Some(AngularVersion::new(19, 0, 0).with_prerelease(Prerelease::Other))
+        );
+        assert_eq!(AngularVersion::parse("22.2.2"), Some(AngularVersion::new(22, 2, 2)));
+        // Placeholder means latest/head: no prerelease, so every gate takes the
+        // newest path.
+        assert_eq!(
+            AngularVersion::parse("0.0.0-PLACEHOLDER"),
+            Some(AngularVersion::new(u32::MAX, 0, 0))
+        );
+    }
+
+    /// Both 22.2.2 gates share the same cutoff, so they are exercised
+    /// together: `>= 22.2.2` stable and `22.3.0-next.1+`, but not
+    /// `22.3.0-next.0` or any earlier/unknown `22.3.0` prerelease — all of
+    /// those were cut before the fixes landed on `main`.
+    #[test]
+    fn prerelease_gates_respect_22_3_0_next_1_cutoff() {
+        let parse = |s| AngularVersion::parse(s).unwrap();
+
+        for version in [
+            parse("22.2.2"),
+            parse("22.3.0-next.1"),
+            parse("22.3.0-rc.0"),
+            parse("22.3.0"),
+            parse("23.0.0"),
+            AngularVersion::new(u32::MAX, 0, 0),
+        ] {
+            assert!(version.drops_img_video_src_url_context(), "{version:?}");
+            assert!(version.strips_namespaced_block_tag(), "{version:?}");
+        }
+
+        for version in [
+            parse("22.2.1"),
+            parse("22.3.0-next.0"),
+            // Unknown tags parse to `Other` and sort below `next`/`rc`, so
+            // hypothetical prereleases of 22.3.0 keep the old behavior.
+            parse("22.3.0-beta.2"),
+            parse("22.3.0-snapshot.9"),
+            AngularVersion::new(22, 2, 0).with_prerelease(Prerelease::Next(5)),
+        ] {
+            assert!(!version.drops_img_video_src_url_context(), "{version:?}");
+            assert!(!version.strips_namespaced_block_tag(), "{version:?}");
+        }
+    }
+}
diff --git a/crates/oxc_angular_compiler/src/component/mod.rs b/crates/oxc_angular_compiler/src/component/mod.rs
index 0a699d38e..4736641f7 100644
--- a/crates/oxc_angular_compiler/src/component/mod.rs
+++ b/crates/oxc_angular_compiler/src/component/mod.rs
@@ -32,7 +32,7 @@ pub use dependency::{
 pub use import_elision::ImportElisionAnalyzer;
 pub use metadata::{
     AngularVersion, ChangeDetectionStrategy, ComponentMetadata, DeclarationListEmitMode,
-    HostDirectiveMetadata, HostMetadata, LifecycleMetadata, TemplateDependency,
+    HostDirectiveMetadata, HostMetadata, LifecycleMetadata, Prerelease, TemplateDependency,
     TemplateDependencyKind, ViewEncapsulation,
 };
 pub use namespace_registry::NamespaceRegistry;
diff --git a/crates/oxc_angular_compiler/src/lib.rs b/crates/oxc_angular_compiler/src/lib.rs
index b985030ea..437626eab 100644
--- a/crates/oxc_angular_compiler/src/lib.rs
+++ b/crates/oxc_angular_compiler/src/lib.rs
@@ -65,10 +65,10 @@ pub use transform::{HtmlToR3Transform, html_to_r3::html_ast_to_r3_ast};
 pub use component::{
     AngularVersion, ChangeDetectionStrategy, CompiledComponent, ComponentMetadata,
     HmrTemplateCompileOutput, HostMetadata, HostMetadataInput, ImportInfo, ImportMap,
-    NamespaceRegistry, ResolvedResources, TemplateCompileOutput, TransformOptions, TransformResult,
-    ViewEncapsulation, build_import_map, compile_component_template, compile_for_hmr,
-    compile_template_for_hmr, compile_template_to_js, compile_template_to_js_with_options,
-    extract_component_metadata, transform_angular_file,
+    NamespaceRegistry, Prerelease, ResolvedResources, TemplateCompileOutput, TransformOptions,
+    TransformResult, ViewEncapsulation, build_import_map, compile_component_template,
+    compile_for_hmr, compile_template_for_hmr, compile_template_to_js,
+    compile_template_to_js_with_options, extract_component_metadata, transform_angular_file,
 };
 
 // Re-export cross-file elision types when feature is enabled
diff --git a/crates/oxc_angular_compiler/src/pipeline/ingest.rs b/crates/oxc_angular_compiler/src/pipeline/ingest.rs
index 4293ff76c..f7a13338d 100644
--- a/crates/oxc_angular_compiler/src/pipeline/ingest.rs
+++ b/crates/oxc_angular_compiler/src/pipeline/ingest.rs
@@ -2452,9 +2452,9 @@ fn ingest_if_block<'a>(
         let tag_name =
             ingest_control_flow_insertion_point(job, view_xref, branch_view_xref, &branch.children);
 
-        // Tag name is passed directly for content projection (including namespace prefix).
-        // This matches TypeScript's ingestIfBlock which passes tagName directly from
-        // ingestControlFlowInsertionPoint without stripping the namespace.
+        // Tag name is passed directly for content projection;
+        // ingest_control_flow_insertion_point strips the namespace on 22.2.2+
+        // (angular/angular@0244a1cb3).
         let tag = tag_name.clone();
 
         // fn_name_suffix is hardcoded to "Conditional" without namespace prefix
@@ -3036,9 +3036,9 @@ fn ingest_switch_block<'a>(
         let tag_name =
             ingest_control_flow_insertion_point(job, view_xref, group_view_xref, &group.children);
 
-        // Tag name is passed directly for content projection (including namespace prefix).
-        // This matches TypeScript's ingestSwitchBlock which passes tagName directly from
-        // ingestControlFlowInsertionPoint without stripping the namespace.
+        // Tag name is passed directly for content projection;
+        // ingest_control_flow_insertion_point strips the namespace on 22.2.2+
+        // (angular/angular@0244a1cb3).
         let tag = tag_name.clone();
 
         // fn_name_suffix is hardcoded to "Case" without namespace prefix
@@ -4682,6 +4682,24 @@ fn ingest_control_flow_insertion_point<'a, 'b>(
     // Get the tag name
     let tag_name = root.tag_name();
 
+    if job.angular_version.map_or(true, |v| v.strips_namespaced_block_tag()) {
+        // 22.2.2+ matches the root tag against ng-content tag selectors, so the
+        // namespace prefix is stripped upstream (`rawTagName ?
+        // splitNsName(rawTagName)[1] : null`); `ng-template` is checked on the
+        // stripped name. See `angular/angular@0244a1cb3`.
+        if tag_name.as_str().is_empty() {
+            return None;
+        }
+        let (namespace, stripped) = split_ns_name(tag_name.as_str());
+        if stripped == NG_TEMPLATE_TAG_NAME {
+            return None;
+        }
+        if namespace.is_some() {
+            return Some(Ident::from(allocator.alloc_str(stripped)));
+        }
+        return Some(tag_name);
+    }
+
     // Don't pass along `ng-template` tag name since it enables directive matching.
     if tag_name.as_str() == NG_TEMPLATE_TAG_NAME { None } else { Some(tag_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 61ade27eb..4300e9d56 100644
--- a/crates/oxc_angular_compiler/src/schema/dom_security_schema.rs
+++ b/crates/oxc_angular_compiler/src/schema/dom_security_schema.rs
@@ -42,9 +42,13 @@ 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+. Namespaced keys with `:svg:a|href`.
-    /// `script|src` and `script|href` are gone.
+    /// 19.2.23+, 20.3.22+, 21.2.15+, 22.0.0–22.2.1. Namespaced keys with
+    /// `:svg:a|href`. `script|src` and `script|href` are gone.
     V22,
+    /// 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.
+    V22_2_2,
 }
 
 struct SecurityProfile {
@@ -76,10 +80,15 @@ struct SecurityProfile {
 
 fn security_profile(version: Option<crate::AngularVersion>) -> SecurityProfile {
     let Some(version) = version else {
-        return v22_profile();
+        return v22_profile(SchemaKind::V22_2_2);
     };
     if version.major >= 22 {
-        return v22_profile();
+        let kind = if version.drops_img_video_src_url_context() {
+            SchemaKind::V22_2_2
+        } else {
+            SchemaKind::V22
+        };
+        return v22_profile(kind);
     }
 
     let (kind, iframe_src_i18n) = match version.major {
@@ -115,7 +124,7 @@ fn security_profile(version: Option<crate::AngularVersion>) -> SecurityProfile {
         _ => (SchemaKind::Legacy, false),
     };
 
-    let namespaced = matches!(kind, SchemaKind::V21_2_14 | SchemaKind::V22);
+    let namespaced = matches!(kind, SchemaKind::V21_2_14 | SchemaKind::V22 | SchemaKind::V22_2_2);
     // `: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)
@@ -126,7 +135,7 @@ 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),
+        normalizes_tag_names: matches!(kind, SchemaKind::V22 | SchemaKind::V22_2_2),
         strip_svg_script: namespaced,
         strip_svg_style,
         iframe_src_i18n,
@@ -134,9 +143,9 @@ fn security_profile(version: Option<crate::AngularVersion>) -> SecurityProfile {
     }
 }
 
-fn v22_profile() -> SecurityProfile {
+fn v22_profile(kind: SchemaKind) -> SecurityProfile {
     SecurityProfile {
-        kind: SchemaKind::V22,
+        kind,
         namespaced: true,
         normalizes_tag_names: true,
         strip_svg_script: true,
@@ -188,7 +197,12 @@ pub fn is_iframe_security_sensitive_attr(attr_name: &str) -> bool {
     )
 }
 
-fn build_v22_schema(with_svg_a: bool) -> FxHashMap<String, SecurityContext> {
+fn build_v22_schema(kind: SchemaKind) -> FxHashMap<String, SecurityContext> {
+    let with_svg_a = kind != SchemaKind::V21_2_14;
+    // `img|src` and `video|src` left the URL context in 22.2.2
+    // (`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;
     let mut schema = FxHashMap::default();
 
     register(
@@ -209,11 +223,16 @@ fn build_v22_schema(with_svg_a: bool) -> FxHashMap<String, SecurityContext> {
             ("area", &["href"]),
             ("a", &["href", "xlink:href"]),
             ("form", &["action"]),
-            // Kept for compatibility with upstream; safe in practice.
-            ("img", &["src"]),
-            ("video", &["src"]),
         ],
     );
+    if with_img_video_src {
+        register(
+            &mut schema,
+            SecurityContext::Url,
+            None,
+            &[("img", &["src"]), ("video", &["src"])],
+        );
+    }
 
     register_uniform(
         &mut schema,
@@ -287,9 +306,11 @@ fn build_v22_schema(with_svg_a: bool) -> FxHashMap<String, SecurityContext> {
 }
 
 static V22_SCHEMA: LazyLock<FxHashMap<String, SecurityContext>> =
-    LazyLock::new(|| build_v22_schema(true));
+    LazyLock::new(|| build_v22_schema(SchemaKind::V22));
+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>> =
-    LazyLock::new(|| build_v22_schema(false));
+    LazyLock::new(|| build_v22_schema(SchemaKind::V21_2_14));
 static V21_27_SCHEMA: LazyLock<FxHashMap<String, SecurityContext>> =
     LazyLock::new(|| build_pren22_schema(SchemaKind::V21_2_7));
 static V21_1_SCHEMA: LazyLock<FxHashMap<String, SecurityContext>> =
@@ -313,6 +334,7 @@ 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_2_2 => &V22_2_2_SCHEMA,
     }
 }
 /// Pre-v22 schemas look up bare `tag|attr` keys (`normalizeTagName` did not keep
@@ -1114,13 +1136,71 @@ mod tests {
     fn test_url_context() {
         assert_eq!(get_security_context("a", "href"), SecurityContext::Url);
         assert_eq!(get_security_context("form", "action"), SecurityContext::Url);
-        assert_eq!(get_security_context("img", "src"), SecurityContext::Url);
         assert_eq!(get_security_context(":svg:a", "href"), SecurityContext::Url);
         assert_eq!(get_security_context(":math:mi", "href"), SecurityContext::Url);
         // Bare MathML local names are not the schema key.
         assert_eq!(get_security_context("mi", "href"), SecurityContext::None);
     }
 
+    #[test]
+    fn v22_2_2_drops_img_and_video_src_from_the_url_context() {
+        // Latest (`None`) and 22.2.2+/22.3.x: `img|src` and `video|src` are no
+        // URL sinks, so bound `src` gets no `ɵɵsanitizeUrl`. `iframe|src` keeps
+        // the ResourceUrl context.
+        for version in [
+            None,
+            Some(crate::AngularVersion::new(22, 2, 2)),
+            Some(crate::AngularVersion::new(22, 3, 0)),
+            Some(crate::AngularVersion::new(23, 0, 0)),
+            crate::AngularVersion::parse("22.3.0-next.1"),
+            crate::AngularVersion::parse("22.3.0-rc.0"),
+        ] {
+            assert_eq!(
+                get_security_context_for("img", "src", version),
+                SecurityContext::None,
+                "{version:?}"
+            );
+            assert_eq!(
+                get_security_context_for("video", "src", version),
+                SecurityContext::None,
+                "{version:?}"
+            );
+            assert_eq!(
+                host_binding_security_context_for("img", "src", version),
+                SecurityContext::None,
+                "{version:?}"
+            );
+            assert_eq!(
+                element_security_context_for("img", "src", version),
+                SecurityContext::None,
+                "{version:?}"
+            );
+        }
+        // 22.0.0 through 22.2.1 — 22.3.0-next.0, which predates the fix
+        // upstream — and the 21.x/20.x/19.x lines, which the fix never reached —
+        // still classify `img|src` as a URL sink.
+        for version in [
+            crate::AngularVersion::new(22, 0, 0),
+            crate::AngularVersion::new(22, 2, 1),
+            crate::AngularVersion::new(21, 2, 15),
+            crate::AngularVersion::new(20, 3, 22),
+            crate::AngularVersion::new(19, 2, 23),
+            crate::AngularVersion::parse("22.3.0-next.0").unwrap(),
+        ] {
+            let version = Some(version);
+            assert_eq!(
+                get_security_context_for("img", "src", version),
+                SecurityContext::Url,
+                "{version:?}"
+            );
+            assert_eq!(
+                get_security_context_for("video", "src", version),
+                SecurityContext::Url,
+                "{version:?}"
+            );
+        }
+    }
+
     #[test]
     fn test_resource_url_context() {
         assert_eq!(get_security_context("iframe", "src"), SecurityContext::ResourceUrl);
@@ -1170,10 +1250,9 @@ mod tests {
 
     #[test]
     fn test_unknown_element_url_or_resource_url() {
-        assert_eq!(
-            calc_security_context_for_unknown_element("src"),
-            SecurityContext::UrlOrResourceUrl
-        );
+        // 22.2.2 dropped the last `*|src` URL contributor (`img`/`video`), so
+        // `src` only hits `embed`/`frame`/`iframe` ResourceUrl keys.
+        assert_eq!(calc_security_context_for_unknown_element("src"), SecurityContext::ResourceUrl);
         assert_eq!(
             calc_security_context_for_unknown_element("href"),
             SecurityContext::UrlOrResourceUrl
@@ -1205,8 +1284,17 @@ mod tests {
             SecurityContext::AttributeNoBinding
         );
         assert_eq!(host_binding_security_context("a", "href"), SecurityContext::Url);
-        assert_eq!(host_binding_security_context("img", "src"), SecurityContext::Url);
         assert_eq!(host_binding_security_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!(
+            host_binding_security_context_for(
+                "img",
+                "src",
+                Some(crate::AngularVersion::new(22, 2, 1))
+            ),
+            SecurityContext::Url
+        );
     }
 
     #[test]
@@ -1223,9 +1311,10 @@ mod tests {
         // `*` never produces an element name upstream, so `*` / `*[x]` behave
         // like an attribute-only selector and scan every known element.
         for selector in ["*", "*[x]", "[x]"] {
+            // 22.2.2 removed the `src` URL keys, leaving only ResourceUrl.
             assert_eq!(
                 host_binding_security_context(selector, "src"),
-                SecurityContext::UrlOrResourceUrl,
+                SecurityContext::ResourceUrl,
                 "{selector}"
             );
             assert_eq!(
diff --git a/crates/oxc_angular_compiler/tests/change_detection_eager_test.rs b/crates/oxc_angular_compiler/tests/change_detection_eager_test.rs
index 6e8befe25..ff6948649 100644
--- a/crates/oxc_angular_compiler/tests/change_detection_eager_test.rs
+++ b/crates/oxc_angular_compiler/tests/change_detection_eager_test.rs
@@ -46,8 +46,8 @@ fn has_change_detection(region: &str, value: u32) -> bool {
         || region.contains(&format!("changeDetection: {value}"))
 }
 
-const V22: Option<AngularVersion> = Some(AngularVersion { major: 22, minor: 0, patch: 0 });
-const V21: Option<AngularVersion> = Some(AngularVersion { major: 21, minor: 0, patch: 0 });
+const V22: Option<AngularVersion> = Some(AngularVersion::new(22, 0, 0));
+const V21: Option<AngularVersion> = Some(AngularVersion::new(21, 0, 0));
 
 // --- v22+ (and unknown version, which assumes latest) -----------------------
 
diff --git a/crates/oxc_angular_compiler/tests/element_name_case_test.rs b/crates/oxc_angular_compiler/tests/element_name_case_test.rs
index b0012f43a..f97ba0227 100644
--- a/crates/oxc_angular_compiler/tests/element_name_case_test.rs
+++ b/crates/oxc_angular_compiler/tests/element_name_case_test.rs
@@ -6,12 +6,12 @@
 //! and that ingest discards, so `<View><text>hi</text></View>` compiled to an empty
 //! template with no error.
 //!
-//! The expected output is ngtsc 22.2.1's for the same template, in this emitter's
-//! spelling.
+//! The expected output is ngtsc 22.2.2's for the same template (the default is
+//! the latest release line), in this emitter's spelling.
 
 use oxc_allocator::Allocator;
 use oxc_angular_compiler::{
-    TransformOptions,
+    AngularVersion, TransformOptions,
     output::emitter::JsEmitter,
     parser::html::HtmlParser,
     pipeline::{emit::compile_template, ingest::ingest_component},
@@ -22,6 +22,11 @@ use oxc_str::Ident;
 
 /// The whitespace-free definition of the component compiled from `template`.
 fn definition(template: &str) -> String {
+    definition_for(template, None)
+}
+
+/// `definition` pinned to an Angular version (`None` is the latest line).
+fn definition_for(template: &str, angular_version: Option<AngularVersion>) -> String {
     let source = format!(
         "import {{ Component }} from '@angular/core';\n\
          @Component({{ selector: 'x', template: `{template}` }})\n\
@@ -32,7 +37,7 @@ fn definition(template: &str) -> String {
         &allocator,
         "/x/a.ts",
         &source,
-        Some(&TransformOptions::default()),
+        Some(&TransformOptions { angular_version, ..TransformOptions::default() }),
         None,
     );
     assert!(result.diagnostics.is_empty(), "`{template}`: {:?}", result.diagnostics);
@@ -147,13 +152,20 @@ fn html_elements_written_in_capitals() {
             r#"i0.ɵɵelementStart(5,"P");i0.ɵɵtext(6,"p");i0.ɵɵelementEnd();i0.ɵɵelementStart(7,"P");"#,
         ],
     );
-    assert_compiles_to(
-        r#"<INPUT [value]="t"><BR><Img [src]="t">after"#,
-        &[
-            "decls:4,vars:2,",
-            r#"i0.ɵɵelement(0,"INPUT",0)(1,"BR")(2,"Img",1);i0.ɵɵtext(3,"after");"#,
-            r#"i0.ɵɵproperty("src",ctx.t,i0.ɵɵsanitizeUrl);"#,
-        ],
+    let img_src = definition(r#"<INPUT [value]="t"><BR><Img [src]="t">after"#);
+    assert!(
+        img_src.contains(r#"i0.ɵɵelement(0,"INPUT",0)(1,"BR")(2,"Img",1);i0.ɵɵtext(3,"after");"#),
+        "{img_src}"
+    );
+    // 22.2.2 (`angular/angular@439ff1bdf4`) removed `img|src` from the URL
+    // security context, so bound `src` no longer receives `ɵɵsanitizeUrl`.
+    assert!(img_src.contains(r#"i0.ɵɵproperty("src",ctx.t)"#), "{img_src}");
+    assert!(!img_src.contains("sanitizeUrl"), "{img_src}");
+    // Versions through 22.2.1 still sanitize it.
+    let img_src_22_2_1 = definition_for(r#"<Img [src]="t">"#, Some(AngularVersion::new(22, 2, 1)));
+    assert!(
+        img_src_22_2_1.contains(r#"i0.ɵɵproperty("src",ctx.t,i0.ɵɵsanitizeUrl)"#),
+        "{img_src_22_2_1}"
     );
     assert_compiles_to(
         r#"<A [href]="t">a</A><IFRAME [src]="t"></IFRAME>"#,
diff --git a/crates/oxc_angular_compiler/tests/integration_test.rs b/crates/oxc_angular_compiler/tests/integration_test.rs
index 314b22a08..2c2283ca6 100644
--- a/crates/oxc_angular_compiler/tests/integration_test.rs
+++ b/crates/oxc_angular_compiler/tests/integration_test.rs
@@ -3846,30 +3846,70 @@ export class TestComponent {
 // SVG Namespace Tests
 // ============================================================================
 
-/// Test that SVG elements inside @switch/@case inside @for have the correct namespace prefix.
+/// Test that SVG elements inside @switch/@case inside @for pass the namespaced root tag.
 ///
-/// This is a regression test for a bug where conditionalCreate was emitting "svg" instead
-/// of ":svg:svg" for the tag parameter when the SVG element was inside a @switch/@case
-/// that was nested inside a @for loop.
+/// This is a regression test for the tag parameter emitted by conditionalCreate when
+/// the SVG element is inside a @switch/@case nested inside a @for loop.
 ///
-/// Expected: `conditionalCreate(0, ..., 2, 0, ":svg:svg", 0)`
-/// Bug:      `conditionalCreate(0, ..., 2, 0, "svg", 0)`
+/// Angular 22.2.2 (`angular/angular@0244a1cb3`, fixed angular#71162) strips the
+/// `:svg:` namespace prefix so the tag matches ng-content tag selectors:
+/// `conditionalCreate(0, ..., 2, 0, "svg", 0)`. Versions through 22.2.1 emitted the
+/// verbatim `:svg:svg`.
 #[test]
 fn test_svg_namespace_in_switch_case_inside_for() {
     // Test with minimal whitespace - SVG is the ONLY child of @case block
-    // When SVG is the single root element, the tag should include namespace prefix ":svg:svg"
+    // When SVG is the single root element, the tag is the stripped local name "svg"
     let js = compile_template_to_js(
         r#"@for (item of items; track item.id) {@switch (item.type) {@case ('circle') {<svg viewBox="0 0 100 100"><circle cx="50" cy="50" r="40" /></svg>}@case ('rect') {<svg viewBox="0 0 100 100"><rect width="80" height="80" /></svg>}}}"#,
         "TestComponent",
     );
 
-    // Verify that conditionalCreate uses ":svg:svg" not just "svg"
+    // Verify that the block tag args carry the stripped local name: "svg" still
+    // renders for the elements while no create call keeps the ":svg:" prefix.
     assert!(
-        js.contains(r#"":svg:svg""#),
-        "conditionalCreate should use ':svg:svg' namespace prefix for SVG elements. Output:\n{js}"
+        js.contains(r#""svg""#) && !js.contains(":svg:"),
+        "conditionalCreate should use the stripped 'svg' tag for SVG elements. Output:\n{js}"
     );
 }
 
+/// The `:svg:` namespace prefix on block-create tag arguments is only stripped for
+/// Angular 22.2.2+; older versions (and the never-backported 21.x/20.x/19.x lines)
+/// emit the verbatim `:svg:svg` tag.
+#[test]
+fn test_svg_namespace_in_block_tag_is_gated_on_22_2_2() {
+    const TEMPLATE: &str =
+        r#"@if (on) {<svg viewBox="0 0 100 100"><circle cx="50" cy="50" r="40" /></svg>}"#;
+
+    // Old behavior: verbatim namespaced tag. `22.3.0-next.0` postdates 22.2.2
+    // in triple order but was cut upstream before the fix landed on `main`.
+    for version in [
+        AngularVersion::new(21, 2, 15),
+        AngularVersion::new(22, 2, 1),
+        AngularVersion::parse("22.3.0-next.0").unwrap(),
+    ] {
+        let js = compile_template_to_js_with_version(TEMPLATE, "TestComponent", Some(version));
+        assert!(
+            js.contains(r#"":svg:svg""#),
+            "{version:?} should pass ':svg:svg' verbatim. Output:\n{js}"
+        );
+    }
+
+    // New behavior: the namespace prefix is stripped. `None` means latest, so it
+    // takes the 22.2.2+ path too.
+    for version in [
+        None,
+        Some(AngularVersion::new(22, 2, 2)),
+        Some(AngularVersion::new(22, 3, 0)),
+        AngularVersion::parse("22.3.0-next.1"),
+    ] {
+        let js = compile_template_to_js_with_version(TEMPLATE, "TestComponent", version);
+        assert!(
+            js.contains("ɵɵconditionalCreate(") && js.contains(r#""svg""#) && !js.contains(":svg:"),
+            "{version:?} should pass the stripped 'svg' tag. Output:\n{js}"
+        );
+    }
+}
+
 /// Test SVG namespace using the NAPI path (with whitespace removal).
 /// This matches the actual NAPI binding behavior.
 #[test]
@@ -3905,10 +3945,10 @@ fn test_svg_namespace_in_switch_case_inside_for_napi_path() {
 
     match result {
         Ok(output) => {
-            // Verify that conditionalCreate uses ":svg:svg" not just "svg"
+            // Verify that the block tag args use "svg", without the ":svg:" prefix
             assert!(
-                output.code.contains(r#"":svg:svg""#),
-                "NAPI path: conditionalCreate should use ':svg:svg' namespace prefix. Output:\n{}",
+                output.code.contains(r#""svg""#) && !output.code.contains(":svg:"),
+                "NAPI path: conditionalCreate should use the stripped 'svg' tag. Output:\n{}",
                 output.code
             );
         }
@@ -3953,10 +3993,10 @@ fn test_svg_namespace_in_switch_case_inside_for_domonly_mode() {
 
     match result {
         Ok(output) => {
-            // Verify that conditionalCreate uses ":svg:svg" not just "svg"
+            // Verify that the block tag args use "svg", without the ":svg:" prefix
             assert!(
-                output.code.contains(r#"":svg:svg""#),
-                "DomOnly mode: conditionalCreate should use ':svg:svg' namespace prefix. Output:\n{}",
+                output.code.contains(r#""svg""#) && !output.code.contains(":svg:"),
+                "DomOnly mode: conditionalCreate should use the stripped 'svg' tag. Output:\n{}",
                 output.code
             );
         }
@@ -4001,10 +4041,10 @@ export class SvgInSwitchCaseComponent {}
 
     let result = transform_angular_file(&allocator, "test.ts", source, None, None);
 
-    // Verify that conditionalCreate uses ":svg:svg" not just "svg"
+    // Verify that the block tag args use "svg", without the ":svg:" prefix
     assert!(
-        result.code.contains(r#"":svg:svg""#),
-        "transform_angular_file: conditionalCreate should use ':svg:svg' namespace prefix. Output:\n{}",
+        result.code.contains(r#""svg""#) && !result.code.contains(":svg:"),
+        "transform_angular_file: conditionalCreate should use the stripped 'svg' tag. Output:\n{}",
         result.code
     );
 }
diff --git a/napi/angular-compiler/e2e/compare/src/compilers/oxc.ts b/napi/angular-compiler/e2e/compare/src/compilers/oxc.ts
index 2556a0544..42d485a82 100644
--- a/napi/angular-compiler/e2e/compare/src/compilers/oxc.ts
+++ b/napi/angular-compiler/e2e/compare/src/compilers/oxc.ts
@@ -19,10 +19,15 @@ import type { CompilerOutput, ProjectCompilationResult } from '../types.js'
 // is on, so version-gated emit (e.g. modern vs legacy safe-navigation `?.`,
 // gated at major >= 22) matches. Without this, OXC falls back to its
 // conservative legacy default and diverges from a newer Angular.
-const OXC_ANGULAR_VERSION = {
+// ANGULAR_VERSION.full may carry a prerelease suffix ("22.3.0-next.0"); the
+// major/minor/patch fields never include it, so pass the tag through
+// separately for gates that cut over mid-`next` cycle.
+const prereleaseTag = ANGULAR_VERSION.full.split('-')[1]
+const OXC_ANGULAR_VERSION: NonNullable<TransformOptions['angularVersion']> = {
   major: Number.parseInt(ANGULAR_VERSION.major, 10) || 0,
   minor: Number.parseInt(ANGULAR_VERSION.minor, 10) || 0,
   patch: Number.parseInt(ANGULAR_VERSION.patch, 10) || 0,
+  ...(prereleaseTag ? { prerelease: prereleaseTag } : {}),
 }
 
 // Re-export ResolvedResources type for use in runner
diff --git a/napi/angular-compiler/index.d.ts b/napi/angular-compiler/index.d.ts
index c64d16050..09d52c6df 100644
--- a/napi/angular-compiler/index.d.ts
+++ b/napi/angular-compiler/index.d.ts
@@ -17,6 +17,12 @@ export interface AngularVersion {
   minor: number
   /** Patch version number (e.g., 0 for Angular 19.0.0). */
   patch: number
+  /**
+   * Prerelease tag without the leading dash (e.g., `"next.0"` or `"rc.1"`
+   * for Angular `22.3.0-next.0`). Omit for stable releases; unknown tags
+   * sort below `next`/`rc` prereleases of the same version.
+   */
+  prerelease?: string
 }
 
 /** Result of class metadata compilation. */
@@ -851,6 +857,9 @@ export interface TransformOptions {
    * When set, used to determine defaults like:
    * - `standalone`: defaults to `false` for v18 and earlier, `true` for v19+
    *
+   * For prerelease builds, also set `prerelease` on the version (e.g.
+   * `{ major: 22, minor: 3, patch: 0, prerelease: "next.0" }`).
+   *
    * When not set, assumes latest Angular version (v19+ behavior).
    */
   angularVersion?: AngularVersion
diff --git a/napi/angular-compiler/src/lib.rs b/napi/angular-compiler/src/lib.rs
index 8cd1ba684..7cfd2e23a 100644
--- a/napi/angular-compiler/src/lib.rs
+++ b/napi/angular-compiler/src/lib.rs
@@ -21,7 +21,8 @@ use oxc_allocator::Allocator;
 use oxc_angular_compiler::{
     AngularVersion as RustAngularVersion, ChangeDetectionStrategy as RustChangeDetectionStrategy,
     HmrTemplateFields, HmrUpdateModuleOptions, HostMetadataInput as RustHostMetadataInput,
-    TransformOptions as RustTransformOptions, ViewEncapsulation as RustViewEncapsulation,
+    Prerelease as RustPrerelease, TransformOptions as RustTransformOptions,
+    ViewEncapsulation as RustViewEncapsulation,
     build_ctor_params_metadata_in as core_build_ctor_params_metadata,
     build_decorator_metadata_array as core_build_decorator_metadata_array,
     build_prop_decorators_metadata_in as core_build_prop_decorators_metadata,
@@ -41,11 +42,19 @@ pub struct AngularVersion {
     pub minor: u32,
     /// Patch version number (e.g., 0 for Angular 19.0.0).
     pub patch: u32,
+    /// Prerelease tag without the leading dash (e.g., `"next.0"` or `"rc.1"`
+    /// for Angular `22.3.0-next.0`). Omit for stable releases; unknown tags
+    /// sort below `next`/`rc` prereleases of the same version.
+    pub prerelease: Option<String>,
 }
 
 impl From<AngularVersion> for RustAngularVersion {
     fn from(v: AngularVersion) -> Self {
-        RustAngularVersion::new(v.major, v.minor, v.patch)
+        let version = RustAngularVersion::new(v.major, v.minor, v.patch);
+        match v.prerelease {
+            Some(tag) => version.with_prerelease(RustPrerelease::parse(&tag)),
+            None => version,
+        }
     }
 }
 
@@ -135,6 +144,9 @@ pub struct TransformOptions {
     /// When set, used to determine defaults like:
     /// - `standalone`: defaults to `false` for v18 and earlier, `true` for v19+
     ///
+    /// For prerelease builds, also set `prerelease` on the version (e.g.
+    /// `{ major: 22, minor: 3, patch: 0, prerelease: "next.0" }`).
+    ///
     /// When not set, assumes latest Angular version (v19+ behavior).
     pub angular_version: Option<AngularVersion>,