From 24b6b094090d796e74c2839bd4b1007514c553f7 Mon Sep 17 00:00:00 2001
From: Jane Chu <7559015+janechu@users.noreply.github.com>
Date: Thu, 2 Jul 2026 11:17:48 -0700
Subject: [PATCH 1/6] Support authored FAST f-template components

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 Cargo.lock                                    |  14 +-
 DESIGN.md                                     |  34 ++
 README.md                                     |  13 +
 crates/webui-parser/src/component_registry.rs | 483 ++++++++++++++++--
 crates/webui-parser/src/diagnostic.rs         |   2 +
 crates/webui-parser/src/lib.rs                | 220 +++++++-
 crates/webui-parser/src/plugin/fast_v2.rs     |   4 +
 crates/webui-parser/src/plugin/fast_v3.rs     |   4 +
 crates/webui-parser/src/plugin/mod.rs         |   9 +
 docs/guide/concepts/plugins/index.md          |  53 ++
 10 files changed, 767 insertions(+), 69 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 35fc5375..920af549 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -289,7 +289,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -300,7 +300,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1081,7 +1081,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2735,7 +2735,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2974,7 +2974,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52d1cfed4120b4d927bf7c0f86d2087a4a7d6027c906d9f9d525a80573b9be51"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -3072,7 +3072,7 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3533,7 +3533,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
diff --git a/DESIGN.md b/DESIGN.md
index a7346dd9..96994e40 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -1226,6 +1226,7 @@ pub trait ParserPlugin {
         component: &Component,
         processed_template: &str,
     ) -> Result<()>;
+    fn uses_fast_template_artifacts(&self) -> bool { false }
     fn classify_attribute(&mut self, attr_name: &str) -> AttributeAction;
     fn finish_element(&mut self, binding_attribute_count: u32) -> Option<Vec<u8>>;
     fn into_artifacts(self: Box<Self>) -> Result<ParserPluginArtifacts>;
@@ -1237,6 +1238,7 @@ pub trait ParserPlugin {
 - **Attribute loop**: `classify_attribute` decides whether framework-owned attrs are kept, skipped, or skipped-and-counted as bindings
 - **Element completion**: `finish_element` runs with the final binding count after all attrs are processed; returned bytes are emitted as a `Plugin` fragment
 - **Component registration**: `register_component_template` receives the plugin-facing component template HTML after HTML/CSS comment stripping. Authored root `<template>` attributes are preserved for plugins; the SSR/internal parse view may strip runtime-only attributes so rendered HTML stays clean. The component's client-ownership marker distinguishes authored from scriptless templates; Rust does not inspect JavaScript/TypeScript semantics.
+- **FAST artifact opt-in**: `uses_fast_template_artifacts` returns `true` only for FAST parser plugins. It enables authored `<f-template>` handling, parser-only binding markers for stripped FAST client directives, and preserved FAST client artifacts. Other plugins receive the normal WebUI parse view.
 - **Artifact extraction**: `into_artifacts` returns post-parse outputs such as client component templates without `Any` downcasts. It is **fallible**: template-authoring mistakes found while compiling component templates (an invalid `@event` handler or a non-braced `w-ref`) surface as `ParserError::Template` instead of panicking, so every host (CLI, Node, FFI, WASM) can handle them.
 
 **Selecting parser plugins**
@@ -1250,6 +1252,38 @@ documentation for the current list. Each plugin defines:
 - Any post-parse artifacts (e.g., client component templates) it injects at `</body>`
 - Any template-syntax conversions it performs inside component templates
 
+**Built-in FAST parser plugins**
+
+The built-in FAST parser plugins (`fast`, `fast-v2`, and `fast-v3`) opt into
+FAST template artifacts and support component source files authored as a single
+wrapping `<f-template>`. Component registration detects that wrapper before
+parsing. The wrapper's `name` attribute overrides the filename-derived component
+tag; if `name` is absent or empty, the filename-derived tag is used. Multiple
+`<f-template>` elements in one component source are unsupported and return a
+structured authoring diagnostic with code `unsupported-multiple-f-templates`.
+
+For build-time SSR parsing, WebUI converts the inner FAST declarative template
+to the WebUI parse view while keeping a separate plugin-facing client artifact:
+
+- `<f-repeat value="{{item in items}}">` converts to
+  `<for each="item in items">`.
+- `<f-when value="{{condition}}">` converts to
+  `<if condition="condition">`.
+- Directive values are unwrapped from `{{...}}` or `{...}` when moving to the
+  WebUI parse view.
+- Client-only FAST syntax that does not affect server-rendered output is removed
+  from the SSR parse view, including `@event`, `:prop`, `f-ref`, `f-slotted`,
+  `f-children`, and other client-only property/event directives.
+
+The original authored FAST template remains the client template artifact emitted
+by the FAST plugin. Parser-only markers carry the binding count for stripped
+client-only directives so FAST hydration indexes remain aligned, but those
+markers never appear in public component HTML or non-FAST plugin artifacts. The
+preserved artifact still runs through the normal component-template processing
+path before emission, including template wrapper normalization, selected
+CSS-strategy injection, module stylesheet adoption where applicable,
+legal-comment handling, and plugin artifact normalization.
+
 WebUI itself does not interpret plugin-emitted bytes; each parser plugin pairs with
 a matching handler plugin that consumes them at render time. See [packages/webui-framework/README.md](packages/webui-framework/README.md)
 for the WebUI Framework's public authoring model.
diff --git a/README.md b/README.md
index 427884b6..0d638980 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,19 @@
 - **Server-side logic:** Conditions, loops, and expressions are evaluated on the server.
 - **Plugin-ready:** Parser and handler plugins support framework-specific hydration and directives.
 
+## FAST plugin authored templates
+
+The built-in FAST plugins (`fast`, `fast-v2`, and `fast-v3`) support component
+HTML authored as a single wrapping `<f-template>`. A `name` attribute on that
+wrapper overrides the filename-derived component tag; multiple `<f-template>`
+blocks in one component source are invalid. For build-time SSR, WebUI converts
+the inner FAST declarative template to WebUI syntax by rewriting `<f-repeat>` to
+`<for>`, rewriting `<f-when>` to `<if>`, unwrapping directive values, and
+removing client-only directives such as `@event`, `:prop`, `f-ref`,
+`f-slotted`, `f-children`, and similar attributes. The authored FAST template is
+preserved as the client artifact, and preserved artifacts still receive normal
+template processing, normalization, and CSS injection.
+
 ## Install
 
 ```bash
diff --git a/crates/webui-parser/src/component_registry.rs b/crates/webui-parser/src/component_registry.rs
index 1006b34e..6f585c18 100644
--- a/crates/webui-parser/src/component_registry.rs
+++ b/crates/webui-parser/src/component_registry.rs
@@ -6,10 +6,13 @@
 //! This module manages the registry of web components used in the application.
 
 use crate::component_policy::{parse_component_render_policy, ComponentRenderPolicy};
+use crate::diagnostic::{codes, Diagnostic};
+use crate::html_parser::{self as html, Event, Walker};
 use crate::{CssFallbackChain, CssParser, LegalComments, ParserError, Result};
 use std::collections::HashMap;
 #[cfg(feature = "fs")]
 use std::fs;
+use std::ops::Range;
 #[cfg(feature = "fs")]
 use std::path::Path;
 #[cfg(feature = "fs")]
@@ -17,6 +20,18 @@ use walkdir::WalkDir;
 
 type ProcessedCss = (String, Vec<String>, Vec<CssFallbackChain>);
 
+struct PreparedComponentTemplate {
+    tag_name: String,
+    html_content: String,
+    plugin_parse_content: Option<String>,
+    plugin_template_content: Option<String>,
+}
+
+struct FTemplateSource {
+    name: Option<String>,
+    inner: Range<usize>,
+}
+
 /// Represents a web component in the registry.
 ///
 /// ```
@@ -94,6 +109,10 @@ pub struct ComponentRegistry {
     components: HashMap<String, Component>,
     /// Compiler-owned rendering policies kept outside the public component API.
     render_policies: HashMap<String, ComponentRenderPolicy>,
+    /// FAST-authored templates with parser-only binding markers.
+    plugin_parse_templates: HashMap<String, String>,
+    /// FAST-authored templates preserved for client artifact emission.
+    plugin_template_artifacts: HashMap<String, String>,
     /// Reusable CSS parser for token extraction during registration.
     css_parser: CssParser,
     /// Legal comment preservation policy for component CSS.
@@ -138,6 +157,8 @@ impl ComponentRegistry {
         Self {
             components: HashMap::new(),
             render_policies: HashMap::new(),
+            plugin_parse_templates: HashMap::new(),
+            plugin_template_artifacts: HashMap::new(),
             css_parser: CssParser::new(),
             legal_comments,
         }
@@ -194,28 +215,22 @@ impl ComponentRegistry {
             .and_then(|s| s.to_str())
             .ok_or_else(|| ParserError::Component("Invalid component file name".to_string()))?;
 
-        // Validate component name (must contain a hyphen)
-        if !tag_name.contains('-') {
-            return Err(ParserError::Component(format!(
-                "Component name '{}' must contain a hyphen",
-                tag_name
-            )));
-        }
+        // Read HTML content
+        let html_content = fs::read_to_string(html_path).map_err(|source| ParserError::IO {
+            context: format!("Failed to read HTML file: {}", html_path.display()),
+            source,
+        })?;
+        let prepared = Self::prepare_component_template(tag_name, &html_content)?;
+        Self::validate_component_name(&prepared.tag_name)?;
 
         // Check for duplicate component
-        if self.components.contains_key(tag_name) {
+        if self.components.contains_key(&prepared.tag_name) {
             return Err(ParserError::Component(format!(
                 "Component '{}' is already registered",
-                tag_name
+                prepared.tag_name
             )));
         }
 
-        // Read HTML content
-        let html_content = fs::read_to_string(html_path).map_err(|source| ParserError::IO {
-            context: format!("Failed to read HTML file: {}", html_path.display()),
-            source,
-        })?;
-
         // Read CSS content and extract definitions/fallback requirements if available
         let (mut css_content, css_definitions, css_fallback_chains) = if let Some(css_path) =
             css_path
@@ -237,13 +252,18 @@ impl ComponentRegistry {
 
         let is_client_owned = has_component_script(html_path)?;
 
-        let render_policy = parse_component_render_policy(tag_name, &html_content)?;
-        Self::append_scoped_policy_css(&mut css_content, &render_policy, tag_name);
+        let render_policy =
+            parse_component_render_policy(&prepared.tag_name, &prepared.html_content)?;
+        Self::append_scoped_policy_css(
+            &mut css_content,
+            &render_policy,
+            &prepared.tag_name,
+        );
 
         // Create and register the component
         let component = Component {
-            tag_name: tag_name.to_string(),
-            html_content,
+            tag_name: prepared.tag_name,
+            html_content: prepared.html_content,
             css_content,
             css_definitions,
             css_fallback_chains,
@@ -251,8 +271,17 @@ impl ComponentRegistry {
         };
 
         self.render_policies
-            .insert(tag_name.to_string(), render_policy);
-        self.components.insert(tag_name.to_string(), component);
+            .insert(component.tag_name.clone(), render_policy);
+        if let Some(template) = prepared.plugin_parse_content {
+            self.plugin_parse_templates
+                .insert(component.tag_name.clone(), template);
+        }
+        if let Some(template) = prepared.plugin_template_content {
+            self.plugin_template_artifacts
+                .insert(component.tag_name.clone(), template);
+        }
+        self.components
+            .insert(component.tag_name.clone(), component);
         Ok(())
     }
 
@@ -268,19 +297,14 @@ impl ComponentRegistry {
             is_client_owned,
         } = registration;
 
-        // Validate component name (must contain a hyphen)
-        if !tag_name.contains('-') {
-            return Err(ParserError::Component(format!(
-                "Component name '{}' must contain a hyphen",
-                tag_name
-            )));
-        }
+        let prepared = Self::prepare_component_template(tag_name, html_content)?;
+        Self::validate_component_name(&prepared.tag_name)?;
 
         // Check for duplicate component
-        if self.components.contains_key(tag_name) {
+        if self.components.contains_key(&prepared.tag_name) {
             return Err(ParserError::Component(format!(
                 "Component '{}' is already registered",
-                tag_name
+                prepared.tag_name
             )));
         }
 
@@ -293,11 +317,16 @@ impl ComponentRegistry {
             None => (None, Vec::new(), Vec::new()),
         };
 
-        let render_policy = parse_component_render_policy(tag_name, html_content)?;
-        Self::append_scoped_policy_css(&mut css_content, &render_policy, tag_name);
+        let render_policy =
+            parse_component_render_policy(&prepared.tag_name, &prepared.html_content)?;
+        Self::append_scoped_policy_css(
+            &mut css_content,
+            &render_policy,
+            &prepared.tag_name,
+        );
         let component: Component = Component {
-            tag_name: tag_name.to_string(),
-            html_content: html_content.to_string(),
+            tag_name: prepared.tag_name,
+            html_content: prepared.html_content,
             css_content,
             css_definitions,
             css_fallback_chains,
@@ -306,11 +335,310 @@ impl ComponentRegistry {
 
         // Register the component
         self.render_policies
-            .insert(tag_name.to_string(), render_policy);
-        self.components.insert(tag_name.to_string(), component);
+            .insert(component.tag_name.clone(), render_policy);
+        if let Some(template) = prepared.plugin_parse_content {
+            self.plugin_parse_templates
+                .insert(component.tag_name.clone(), template);
+        }
+        if let Some(template) = prepared.plugin_template_content {
+            self.plugin_template_artifacts
+                .insert(component.tag_name.clone(), template);
+        }
+        self.components
+            .insert(component.tag_name.clone(), component);
         Ok(())
     }
 
+    fn validate_component_name(tag_name: &str) -> Result<()> {
+        if tag_name.contains('-') {
+            return Ok(());
+        }
+
+        Err(ParserError::Component(format!(
+            "Component name '{}' must contain a hyphen",
+            tag_name
+        )))
+    }
+
+    fn prepare_component_template(
+        tag_name: &str,
+        html_content: &str,
+    ) -> Result<PreparedComponentTemplate> {
+        let Some(source) = Self::find_f_template_source(html_content)? else {
+            return Ok(PreparedComponentTemplate {
+                tag_name: tag_name.to_string(),
+                html_content: html_content.to_string(),
+                plugin_parse_content: None,
+                plugin_template_content: None,
+            });
+        };
+
+        let resolved_tag = source.name.as_deref().unwrap_or(tag_name).to_string();
+        let template_content = html_content[source.inner].trim();
+        let html_content = Self::convert_fast_template_to_webui(template_content, false);
+        let plugin_parse_content = Self::convert_fast_template_to_webui(template_content, true);
+        let plugin_parse_content =
+            (plugin_parse_content != html_content).then_some(plugin_parse_content);
+        Ok(PreparedComponentTemplate {
+            tag_name: resolved_tag,
+            html_content,
+            plugin_parse_content,
+            plugin_template_content: Some(template_content.to_string()),
+        })
+    }
+
+    fn find_f_template_source(html_content: &str) -> Result<Option<FTemplateSource>> {
+        let mut found: Option<FTemplateSource> = None;
+        let mut stack = Vec::with_capacity(1);
+        stack.push(0..html_content.len());
+
+        while let Some(range) = stack.pop() {
+            for event in Walker::new_range(html_content, range.start, range.end) {
+                let Event::Element(element) = event else {
+                    continue;
+                };
+
+                if element.name().eq_ignore_ascii_case("f-template") {
+                    if found.is_some() {
+                        return Err(Self::multiple_f_templates_error(
+                            html_content,
+                            element.start,
+                        ));
+                    }
+                    if !element.self_closing() && element.close_end() == element.content_end() {
+                        return Err(Self::unclosed_f_template_error(html_content, element.start));
+                    }
+                    found = Some(FTemplateSource {
+                        name: element
+                            .attr("name")
+                            .map(str::trim)
+                            .filter(|name| !name.is_empty())
+                            .map(str::to_string),
+                        inner: element.inner(),
+                    });
+                }
+
+                if !element.self_closing() && !element.is_void() {
+                    stack.push(element.inner());
+                }
+            }
+        }
+
+        Ok(found)
+    }
+
+    #[cold]
+    #[inline(never)]
+    fn multiple_f_templates_error(source: &str, offset: usize) -> ParserError {
+        Diagnostic::error("multiple <f-template> elements are not supported")
+            .code(codes::UNSUPPORTED_MULTIPLE_F_TEMPLATES)
+            .at_offset(source, offset)
+            .snippet("<f-template>")
+            .help(
+                "keep only one <f-template> per component file; multiple f-template blocks are not currently supported",
+            )
+            .into()
+    }
+
+    #[cold]
+    #[inline(never)]
+    fn unclosed_f_template_error(source: &str, offset: usize) -> ParserError {
+        Diagnostic::error("unclosed <f-template> tag")
+            .code(codes::UNCLOSED_HTML_TAG)
+            .at_offset(source, offset)
+            .snippet("<f-template>")
+            .help("add the matching </f-template> closing tag")
+            .into()
+    }
+
+    fn convert_fast_template_to_webui(input: &str, include_binding_markers: bool) -> String {
+        let mut result = String::with_capacity(input.len());
+        let bytes = input.as_bytes();
+        let len = bytes.len();
+        let mut index = 0usize;
+
+        while index < len {
+            if bytes[index] == b'<' {
+                if let Some(consumed) =
+                    Self::try_convert_fast_tag(input, index, &mut result, include_binding_markers)
+                {
+                    index += consumed;
+                    continue;
+                }
+            }
+            index = Self::push_char_at(input, index, &mut result);
+        }
+
+        result
+    }
+
+    fn try_convert_fast_tag(
+        input: &str,
+        pos: usize,
+        result: &mut String,
+        include_binding_markers: bool,
+    ) -> Option<usize> {
+        let remaining = &input[pos..];
+        let tag = html::parse_tag(remaining)?;
+
+        if tag.closing {
+            if tag.name.eq_ignore_ascii_case("f-repeat") {
+                result.push_str("</for>");
+                return Some(tag.close + 1);
+            }
+            if tag.name.eq_ignore_ascii_case("f-when") {
+                result.push_str("</if>");
+                return Some(tag.close + 1);
+            }
+            return None;
+        }
+
+        if tag.name.eq_ignore_ascii_case("f-repeat") {
+            Self::push_webui_directive_tag(
+                "for",
+                "each",
+                tag.attr("value"),
+                tag.self_closing,
+                result,
+            );
+            return Some(tag.close + 1);
+        }
+        if tag.name.eq_ignore_ascii_case("f-when") {
+            Self::push_webui_directive_tag(
+                "if",
+                "condition",
+                tag.attr("value"),
+                tag.self_closing,
+                result,
+            );
+            return Some(tag.close + 1);
+        }
+
+        if !tag.attrs().any(|attr| {
+            Self::is_fast_client_only_attr(attr.name)
+                || attr.value.and_then(Self::single_braced_value).is_some()
+        }) {
+            return None;
+        }
+
+        Self::push_webui_opening_tag(&tag, result, include_binding_markers);
+        Some(tag.close + 1)
+    }
+
+    fn push_webui_directive_tag(
+        tag_name: &str,
+        attr_name: &str,
+        value: Option<&str>,
+        self_closing: bool,
+        result: &mut String,
+    ) {
+        result.push('<');
+        result.push_str(tag_name);
+        if let Some(expr) = value.map(Self::strip_fast_value_expression) {
+            if !expr.is_empty() {
+                result.push(' ');
+                result.push_str(attr_name);
+                result.push_str("=\"");
+                result.push_str(expr);
+                result.push('"');
+            }
+        }
+        if self_closing {
+            result.push_str("></");
+            result.push_str(tag_name);
+            result.push('>');
+        } else {
+            result.push('>');
+        }
+    }
+
+    fn push_webui_opening_tag(
+        tag: &html::Tag<'_>,
+        result: &mut String,
+        include_binding_markers: bool,
+    ) {
+        result.push('<');
+        result.push_str(tag.name);
+        let mut stripped_binding_count = 0usize;
+        for attr in tag.attrs() {
+            if Self::is_fast_client_only_attr(attr.name) {
+                stripped_binding_count += 1;
+                continue;
+            }
+            result.push(' ');
+            if let Some(expr) = attr.value.and_then(Self::single_braced_value) {
+                result.push_str(attr.name);
+                result.push_str("=\"{{");
+                result.push_str(expr);
+                result.push_str("}}\"");
+            } else {
+                result.push_str(attr.raw);
+            }
+        }
+        if include_binding_markers {
+            for _ in 0..stripped_binding_count {
+                result.push(' ');
+                result.push_str(Self::INTERNAL_FAST_BINDING_ATTR);
+            }
+        }
+        if tag.self_closing {
+            result.push_str(" />");
+        } else {
+            result.push('>');
+        }
+    }
+
+    fn is_fast_client_only_attr(name: &str) -> bool {
+        name.starts_with('@')
+            || name.starts_with(':')
+            || matches!(name, "f-ref" | "f-slotted" | "f-children")
+    }
+
+    pub(crate) const INTERNAL_FAST_BINDING_ATTR: &str = "data-webui-internal-fast-binding";
+
+    fn strip_fast_value_expression(value: &str) -> &str {
+        Self::double_braced_value(value)
+            .or_else(|| Self::single_braced_value(value))
+            .unwrap_or_else(|| value.trim())
+    }
+
+    fn double_braced_value(value: &str) -> Option<&str> {
+        let trimmed = value.trim();
+        if trimmed.starts_with("{{") && trimmed.ends_with("}}") && !trimmed.starts_with("{{{") {
+            let inner = trimmed[2..trimmed.len() - 2].trim();
+            if !inner.is_empty() {
+                return Some(inner);
+            }
+        }
+        None
+    }
+
+    fn single_braced_value(value: &str) -> Option<&str> {
+        let trimmed = value.trim();
+        if trimmed.starts_with('{') && trimmed.ends_with('}') && !trimmed.starts_with("{{") {
+            let inner = trimmed[1..trimmed.len() - 1].trim();
+            if !inner.is_empty() {
+                return Some(inner);
+            }
+        }
+        None
+    }
+
+    fn push_char_at(input: &str, pos: usize, out: &mut String) -> usize {
+        let bytes = input.as_bytes();
+        if bytes[pos].is_ascii() {
+            out.push(bytes[pos] as char);
+            pos + 1
+        } else {
+            let mut end = pos + 1;
+            while end < bytes.len() && !input.is_char_boundary(end) {
+                end += 1;
+            }
+            out.push_str(&input[pos..end]);
+            end
+        }
+    }
+
     /// Strip comments and extract CSS definitions/fallback requirements.
     fn process_css_content(&mut self, css_content: &str) -> Result<ProcessedCss> {
         let (_tokens, definitions, requirements, stripped) = self
@@ -349,6 +677,29 @@ impl ComponentRegistry {
         self.components.get(tag_name)
     }
 
+    /// Get the parser-facing HTML for a component.
+    pub(crate) fn html_content_for_parse(
+        &self,
+        tag_name: &str,
+        include_fast_binding_markers: bool,
+    ) -> Option<&str> {
+        if include_fast_binding_markers {
+            if let Some(template) = self.plugin_parse_templates.get(tag_name) {
+                return Some(template);
+            }
+        }
+        self.components
+            .get(tag_name)
+            .map(|component| component.html_content.as_str())
+    }
+
+    /// Get the plugin-facing authored client template artifact for a component.
+    pub(crate) fn plugin_template_artifact(&self, tag_name: &str) -> Option<&str> {
+        self.plugin_template_artifacts
+            .get(tag_name)
+            .map(String::as_str)
+    }
+
     /// Get all registered components.
     pub fn get_all(&self) -> impl Iterator<Item = &Component> {
         self.components.values()
@@ -823,6 +1174,66 @@ mod tests {
         assert_eq!(component.html_content, html_content1);
     }
 
+    #[test]
+    fn f_template_name_overrides_file_name_and_converts_for_webui() {
+        let html = r#"<f-template name="named-card"><template><f-when value="{{visible}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" title="{title}">{{item.label}}</button></f-repeat></f-when></template></f-template>"#;
+
+        let mut registry = ComponentRegistry::new();
+        registry
+            .register_component(ComponentRegistration::new(
+                "file-card",
+                html,
+                Some(".root { color: red; }"),
+                true,
+            ))
+            .expect("register");
+
+        assert!(!registry.contains("file-card"));
+        assert!(registry.contains("named-card"));
+
+        let component = registry.get("named-card").expect("component");
+        assert_eq!(component.tag_name, "named-card");
+        assert_eq!(
+            component.html_content,
+            r#"<template><if condition="visible"><for each="item in items"><button title="{{title}}">{{item.label}}</button></for></if></template>"#
+        );
+        let parse_content = registry
+            .html_content_for_parse("named-card", true)
+            .expect("parse content");
+        assert!(parse_content.contains(ComponentRegistry::INTERNAL_FAST_BINDING_ATTR));
+        assert!(!component
+            .html_content
+            .contains(ComponentRegistry::INTERNAL_FAST_BINDING_ATTR));
+        assert_eq!(
+            registry.plugin_template_artifact("named-card"),
+            Some(
+                r#"<template><f-when value="{{visible}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" title="{title}">{{item.label}}</button></f-repeat></f-when></template>"#
+            )
+        );
+    }
+
+    #[test]
+    fn multiple_f_templates_are_not_supported() {
+        let mut registry = ComponentRegistry::new();
+        let err = registry
+            .register_component(ComponentRegistration::new(
+                "multi-card",
+                r#"<f-template name="one"><template></template></f-template><f-template name="two"><template></template></f-template>"#,
+                None,
+                true,
+            ))
+            .expect_err("multiple f-template blocks should error");
+
+        let ParserError::Template(diag) = err else {
+            panic!("expected template diagnostic");
+        };
+        assert_eq!(
+            diag.error_code(),
+            Some(codes::UNSUPPORTED_MULTIPLE_F_TEMPLATES)
+        );
+        assert!(diag.to_string().contains("not currently supported"));
+    }
+
     #[test]
     fn test_exclude_dot_in_component_name() {
         let mut registry = ComponentRegistry::new();
diff --git a/crates/webui-parser/src/diagnostic.rs b/crates/webui-parser/src/diagnostic.rs
index 10e2224d..236d7a7d 100644
--- a/crates/webui-parser/src/diagnostic.rs
+++ b/crates/webui-parser/src/diagnostic.rs
@@ -102,6 +102,8 @@ pub mod codes {
     /// A CSS token used only with a literal `var()` fallback and absent from
     /// every theme — non-fatal, but usually a typo. Severity: warning.
     pub const UNTHEMED_TOKEN: &str = "unthemed-token";
+    /// A component source contains multiple `<f-template>` blocks.
+    pub const UNSUPPORTED_MULTIPLE_F_TEMPLATES: &str = "unsupported-multiple-f-templates";
     /// `<boundary>` is missing its required, non-empty `name` attribute.
     pub const MISSING_BOUNDARY_NAME: &str = "missing-boundary-name";
     /// `<boundary name>` is not a static string literal (e.g. it
diff --git a/crates/webui-parser/src/lib.rs b/crates/webui-parser/src/lib.rs
index 5045390a..02bbcd28 100644
--- a/crates/webui-parser/src/lib.rs
+++ b/crates/webui-parser/src/lib.rs
@@ -611,6 +611,14 @@ impl BuiltComponentTemplate {
     }
 }
 
+struct ComponentTemplateInput<'a> {
+    tag_name: &'a str,
+    html: &'a str,
+    plugin_html: Option<&'a str>,
+    css_content: Option<&'a str>,
+    artifact_needed: bool,
+}
+
 fn add_token_definitions(definitions: &[String], available_counts: &mut HashMap<String, usize>) {
     for definition in definitions {
         let count = available_counts.entry(definition.clone()).or_insert(0);
@@ -938,6 +946,12 @@ impl HtmlParser {
         }
     }
 
+    fn uses_fast_template_artifacts(&self) -> bool {
+        self.plugin
+            .as_ref()
+            .is_some_and(|plugin| plugin.uses_fast_template_artifacts())
+    }
+
     /// Get a mutable reference to the component registry.
     pub fn component_registry_mut(&mut self) -> &mut ComponentRegistry {
         &mut self.component_registry
@@ -2352,6 +2366,7 @@ impl HtmlParser {
         self.flush_raw_buffer(fragments);
 
         if !self.fragment_records.contains_key(element.name()) {
+            let uses_fast_template_artifacts = self.uses_fast_template_artifacts();
             let component_data = self
                 .component_registry
                 .get(element.name())
@@ -2364,12 +2379,25 @@ impl HtmlParser {
                     .help(self.unknown_component_help(element.name()))
                 })?
                 .clone();
-            let built = self.build_component_templates(
-                element.name(),
-                &component_data.html_content,
-                component_data.css_content.as_deref(),
-                self.plugin.is_some(),
-            )?;
+            let html_content = self
+                .component_registry
+                .html_content_for_parse(element.name(), uses_fast_template_artifacts)
+                .unwrap_or(&component_data.html_content)
+                .to_string();
+            let plugin_template_artifact = if uses_fast_template_artifacts {
+                self.component_registry
+                    .plugin_template_artifact(element.name())
+                    .map(str::to_string)
+            } else {
+                None
+            };
+            let built = self.build_component_templates(ComponentTemplateInput {
+                tag_name: element.name(),
+                html: &html_content,
+                plugin_html: plugin_template_artifact.as_deref(),
+                css_content: component_data.css_content.as_deref(),
+                artifact_needed: self.plugin.is_some(),
+            })?;
 
             if let Some(ref mut p) = self.plugin {
                 p.register_component_template(element.name(), &component_data, built.artifact())?;
@@ -2471,9 +2499,17 @@ impl HtmlParser {
     ) -> Result<u32> {
         let mut first_dynamic_emitted = false;
         let mut binding_count: u32 = 0;
+        let uses_fast_template_artifacts = self.uses_fast_template_artifacts();
         for attr in attrs {
             let attr_name = attr.name;
 
+            if attr_name == ComponentRegistry::INTERNAL_FAST_BINDING_ATTR {
+                if uses_fast_template_artifacts {
+                    binding_count += 1;
+                }
+                continue;
+            }
+
             if let Some(ref mut p) = self.plugin {
                 match p.classify_attribute(attr_name) {
                     AttributeAction::Keep => {}
@@ -3121,13 +3157,27 @@ impl HtmlParser {
                 .help(self.unknown_component_help(component))
             })?
             .clone();
+        let uses_fast_template_artifacts = self.uses_fast_template_artifacts();
+        let html_content = self
+            .component_registry
+            .html_content_for_parse(component, uses_fast_template_artifacts)
+            .unwrap_or(&component_data.html_content)
+            .to_string();
+        let plugin_template_artifact = if uses_fast_template_artifacts {
+            self.component_registry
+                .plugin_template_artifact(component)
+                .map(str::to_string)
+        } else {
+            None
+        };
 
-        let built = self.build_component_templates(
-            component,
-            &component_data.html_content,
-            component_data.css_content.as_deref(),
-            self.plugin.is_some(),
-        )?;
+        let built = self.build_component_templates(ComponentTemplateInput {
+            tag_name: component,
+            html: &html_content,
+            plugin_html: plugin_template_artifact.as_deref(),
+            css_content: component_data.css_content.as_deref(),
+            artifact_needed: self.plugin.is_some(),
+        })?;
 
         if let Some(ref mut p) = self.plugin {
             p.register_component_template(component, &component_data, built.artifact())?;
@@ -3162,11 +3212,11 @@ impl HtmlParser {
     /// Build both SSR-facing and plugin-facing component template views.
     fn build_component_templates(
         &mut self,
-        tag_name: &str,
-        html: &str,
-        css_content: Option<&str>,
-        artifact_needed: bool,
+        input: ComponentTemplateInput<'_>,
     ) -> Result<BuiltComponentTemplate> {
+        let tag_name = input.tag_name;
+        let html = input.html;
+        let css_content = input.css_content;
         let adopted_specifier = match self.options.css_strategy {
             CssStrategy::Module if css_content.is_some() => Some(tag_name),
             _ => None,
@@ -3197,7 +3247,8 @@ impl HtmlParser {
             CssStrategy::Module => None,
         };
 
-        let artifact_differs = artifact_needed && Self::template_has_stripped_runtime_attrs(html);
+        let artifact_differs =
+            input.artifact_needed && Self::template_has_stripped_runtime_attrs(html);
         let policy_wrapper = parse_component_render_policy(tag_name, html)?.is_authored();
         let ssr = self.process_component_policy_template(
             html,
@@ -3205,7 +3256,14 @@ impl HtmlParser {
             adopted_specifier,
             policy_wrapper,
         )?;
-        let artifact = if artifact_differs {
+        let artifact = if let Some(plugin_html) = input.plugin_html {
+            Some(self.process_component_artifact_template(
+                plugin_html,
+                css_injection.as_deref(),
+                adopted_specifier,
+                policy_wrapper,
+            )?)
+        } else if artifact_differs {
             Some(self.process_component_artifact_template(
                 html,
                 css_injection.as_deref(),
@@ -4026,6 +4084,103 @@ mod tests {
         );
     }
 
+    fn assert_f_template_component_source(plugin: Box<dyn ParserPlugin>) {
+        let mut parser =
+            HtmlParser::with_plugin_options(plugin, (CssStrategy::Style, DomStrategy::Shadow));
+        parser
+            .component_registry
+            .register_component(ComponentRegistration::new(
+                "file-card",
+                r#"<f-template name="named-card"><template><f-when value="{{visible}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" title="{title}">{{item.label}}</button></f-repeat></f-when></template></f-template>"#,
+                Some(".root { color: red; }"),
+                true,
+            ))
+            .expect("register component");
+
+        parser
+            .parse("index.html", "<named-card></named-card>")
+            .expect("parse entry");
+        let records = parser.fragment_records.clone();
+        assert_stream!(
+            records,
+            "named-card",
+            [
+                raw("<template><style>.root { color: red; }</style>"),
+                if_cond("if-1"),
+                raw("</template>"),
+            ]
+        );
+        assert_stream!(records, "if-1", [for_loop("item", "items", "for-1"),]);
+        let for_fragments = &records["for-1"].fragments;
+        assert!(for_fragments.iter().any(|fragment| {
+            matches!(
+                fragment.fragment.as_ref(),
+                Some(Fragment::Plugin(data)) if data.data == 3u32.to_le_bytes()
+            )
+        }));
+        assert!(!for_fragments.iter().any(|fragment| {
+            matches!(
+                fragment.fragment.as_ref(),
+                Some(Fragment::Raw(raw)) if raw.value.contains(ComponentRegistry::INTERNAL_FAST_BINDING_ATTR)
+            )
+        }));
+
+        let artifacts = parser.take_plugin_artifacts().expect("artifacts");
+        let ParserPluginArtifacts::ComponentTemplates(templates) = artifacts else {
+            panic!("expected component template artifacts");
+        };
+        assert_eq!(templates.len(), 1);
+        assert_eq!(templates[0].tag_name, "named-card");
+        let template = &templates[0].template;
+        assert!(template.contains(r#"<f-template name="named-card">"#));
+        assert!(template.contains("<style>.root { color: red; }</style>"));
+        assert!(template.contains(r#"<f-when value="{{visible}}">"#));
+        assert!(template.contains(r#"<f-repeat value="{{item in items}}">"#));
+        assert!(template.contains(r#"@click="{save()}""#));
+        assert!(template.contains(r#":config="{config}""#));
+        assert!(!template.contains("file-card"));
+    }
+
+    #[test]
+    fn fast_v2_plugin_uses_authored_f_template_source() {
+        assert_f_template_component_source(Box::new(plugin::fast_v2::FastV2ParserPlugin::new()));
+    }
+
+    #[test]
+    fn fast_v3_plugin_uses_authored_f_template_source() {
+        assert_f_template_component_source(Box::new(plugin::fast_v3::FastV3ParserPlugin::new()));
+    }
+
+    #[test]
+    fn webui_plugin_does_not_use_fast_template_artifact_path() {
+        let mut parser = HtmlParser::with_plugin(Box::new(plugin::webui::WebUIParserPlugin::new()));
+        parser
+            .component_registry
+            .register_component(ComponentRegistration::new(
+                "file-card",
+                r#"<f-template name="named-card"><template><f-when value="{{visible}}"><button @click="{save()}" :config="{config}" title="{title}">Save</button></f-when></template></f-template>"#,
+                None,
+                true,
+            ))
+            .expect("register component");
+
+        parser
+            .parse("index.html", "<named-card></named-card>")
+            .expect("parse entry");
+        let artifacts = parser.take_plugin_artifacts().expect("artifacts");
+        let ParserPluginArtifacts::ComponentTemplates(templates) = artifacts else {
+            panic!("expected component template artifacts");
+        };
+        assert_eq!(templates.len(), 1);
+        assert_eq!(templates[0].tag_name, "named-card");
+        assert!(templates[0].template.is_empty());
+        assert!(!templates[0].template_json.contains("<f-template"));
+        assert!(!templates[0].template_json.contains("@click"));
+        assert!(!templates[0]
+            .template_json
+            .contains(ComponentRegistry::INTERNAL_FAST_BINDING_ATTR));
+    }
+
     #[test]
     fn test_shadow_dom_shell_fragment_graph_includes_child_components() {
         // Reproduces commerce app: mp-app has a shadow DOM template containing
@@ -5946,7 +6101,13 @@ mod tests {
 
         let mut shadow = HtmlParser::with_options(DomStrategy::Shadow);
         let shadow_built = shadow
-            .build_component_templates("my-comp", html, None, true)
+            .build_component_templates(ComponentTemplateInput {
+                tag_name: "my-comp",
+                html,
+                plugin_html: None,
+                css_content: None,
+                artifact_needed: true,
+            })
             .expect("shadow policy wrapper should compile");
         assert_eq!(
             shadow_built.ssr,
@@ -5956,7 +6117,13 @@ mod tests {
 
         let mut light = HtmlParser::with_options(DomStrategy::Light);
         let light_built = light
-            .build_component_templates("my-comp", html, None, true)
+            .build_component_templates(ComponentTemplateInput {
+                tag_name: "my-comp",
+                html,
+                plugin_html: None,
+                css_content: None,
+                artifact_needed: true,
+            })
             .expect("light policy wrapper should compile");
         assert_eq!(light_built.ssr, "<div>hi</div>");
         assert_eq!(light_built.artifact(), "<div>hi</div>");
@@ -6016,12 +6183,13 @@ mod tests {
     fn dev_template_module_strategy_appends_adopted_attr_and_preserves_root_attrs() {
         for dom_strategy in [DomStrategy::Shadow, DomStrategy::Light] {
             let mut parser = HtmlParser::with_options((CssStrategy::Module, dom_strategy));
-            let built = match parser.build_component_templates(
-                "my-comp",
-                r#"<template shadowrootmode="open" @click="{onClick()}">Hello</template>"#,
-                Some(":host { color: red; }"),
-                true,
-            ) {
+            let built = match parser.build_component_templates(ComponentTemplateInput {
+                tag_name: "my-comp",
+                html: r#"<template shadowrootmode="open" @click="{onClick()}">Hello</template>"#,
+                plugin_html: None,
+                css_content: Some(":host { color: red; }"),
+                artifact_needed: true,
+            }) {
                 Ok(built) => built,
                 Err(err) => panic!(
                     "dev-authored <template> should be accepted under {dom_strategy:?} with module CSS, got: {err}"
diff --git a/crates/webui-parser/src/plugin/fast_v2.rs b/crates/webui-parser/src/plugin/fast_v2.rs
index cd639ec6..65779b53 100644
--- a/crates/webui-parser/src/plugin/fast_v2.rs
+++ b/crates/webui-parser/src/plugin/fast_v2.rs
@@ -83,6 +83,10 @@ impl ParserPlugin for FastV2ParserPlugin {
         Ok(())
     }
 
+    fn uses_fast_template_artifacts(&self) -> bool {
+        true
+    }
+
     fn classify_attribute(&mut self, attr_name: &str) -> AttributeAction {
         if attr_name.starts_with('@')
             || attr_name == "f-ref"
diff --git a/crates/webui-parser/src/plugin/fast_v3.rs b/crates/webui-parser/src/plugin/fast_v3.rs
index 5b30ecb7..edbea9fa 100644
--- a/crates/webui-parser/src/plugin/fast_v3.rs
+++ b/crates/webui-parser/src/plugin/fast_v3.rs
@@ -83,6 +83,10 @@ impl ParserPlugin for FastV3ParserPlugin {
         Ok(())
     }
 
+    fn uses_fast_template_artifacts(&self) -> bool {
+        true
+    }
+
     fn classify_attribute(&mut self, attr_name: &str) -> AttributeAction {
         if attr_name.starts_with('@')
             || attr_name == "f-ref"
diff --git a/crates/webui-parser/src/plugin/mod.rs b/crates/webui-parser/src/plugin/mod.rs
index 2e549e21..a328bb33 100644
--- a/crates/webui-parser/src/plugin/mod.rs
+++ b/crates/webui-parser/src/plugin/mod.rs
@@ -186,6 +186,15 @@ pub trait ParserPlugin {
         processed_template: &str,
     ) -> Result<()>;
 
+    /// Return true when this plugin consumes FAST `<f-template>` artifacts.
+    ///
+    /// FAST parser plugins use this to opt into authored `<f-template>` source
+    /// handling, including parser-only binding markers for stripped FAST client
+    /// directives. Other plugins receive the normal WebUI parse view.
+    fn uses_fast_template_artifacts(&self) -> bool {
+        false
+    }
+
     /// Decide how a framework-owned attribute should be handled.
     fn classify_attribute(&mut self, attr_name: &str) -> AttributeAction;
 
diff --git a/docs/guide/concepts/plugins/index.md b/docs/guide/concepts/plugins/index.md
index 91ca56a8..86a7eed7 100644
--- a/docs/guide/concepts/plugins/index.md
+++ b/docs/guide/concepts/plugins/index.md
@@ -93,6 +93,54 @@ use webui_handler::plugin::webui::WebUIHydrationPlugin;
 let handler = WebUIHandler::with_plugin(|| Box::new(WebUIHydrationPlugin::new()));
 ```
 
+### Using FAST Plugins
+
+The built-in FAST plugins are `fast`, `fast-v2`, and `fast-v3`:
+
+```bash
+webui build ./src --out ./dist --plugin=fast-v3
+webui serve ./src --state ./data/state.json --plugin=fast-v3 --watch
+```
+
+For FAST builds, a component HTML file may be authored as one wrapping
+`<f-template>`:
+
+```html
+<!-- src/components/file-card.html -->
+<f-template name="named-card">
+  <template>
+    <f-when value="{{visible}}">
+      <f-repeat value="{{item in items}}">
+        <button @click="{select(item)}" :config="{config}">
+          {{item.label}}
+        </button>
+      </f-repeat>
+    </f-when>
+  </template>
+</f-template>
+```
+
+`<f-template name="named-card">` registers the component as `named-card` instead
+of deriving `file-card` from the filename. If the `name` attribute is omitted,
+the filename-derived tag is used. Multiple `<f-template>` elements in one
+component source are unsupported and fail the build with an authoring error.
+
+WebUI uses two views of this source:
+
+- **SSR parse view:** the inner FAST declarative template is converted to WebUI
+  syntax for build-time parsing. `<f-repeat value="{{item in items}}">` becomes
+  `<for each="item in items">`; `<f-when value="{{condition}}">` becomes
+  `<if condition="condition">`; directive values are unwrapped; client-only FAST
+  syntax that does not affect server-rendered output is removed, including
+  `@event`, `:prop`, `f-ref`, `f-slotted`, `f-children`, and similar
+  client-only directives. FAST plugins receive parser-only binding markers for
+  those stripped directives so hydration binding indexes remain aligned.
+- **Client artifact view:** the authored FAST template is preserved and emitted
+  as the client `<f-template>` payload. It still goes through normal component
+  processing and normalization, including wrapper handling and CSS injection for
+  the selected CSS strategy. Non-FAST plugins receive the normal WebUI parse
+  view instead of FAST artifacts.
+
 ## Writing Custom Plugins
 
 To create a custom plugin, implement the `ParserPlugin` and/or `HandlerPlugin` traits:
@@ -113,6 +161,11 @@ pub trait ParserPlugin {
         processed_template: &str,
     ) -> Result<()>;
 
+    /// Return true only for plugins that consume FAST `<f-template>` artifacts.
+    fn uses_fast_template_artifacts(&self) -> bool {
+        false
+    }
+
     /// Decide how a framework-owned attribute should be handled.
     fn classify_attribute(&mut self, attr_name: &str) -> AttributeAction;
 

From abce9bf9c2d799c0cc130eddce50ae00b28304d0 Mon Sep 17 00:00:00 2001
From: Jane Chu <7559015+janechu@users.noreply.github.com>
Date: Thu, 2 Jul 2026 12:36:07 -0700
Subject: [PATCH 2/6] Extract FAST template source helpers

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 crates/webui-parser/src/component_registry.rs | 300 +-----------------
 .../webui-parser/src/fast_template_source.rs  | 284 +++++++++++++++++
 crates/webui-parser/src/lib.rs                |   1 +
 3 files changed, 290 insertions(+), 295 deletions(-)
 create mode 100644 crates/webui-parser/src/fast_template_source.rs

diff --git a/crates/webui-parser/src/component_registry.rs b/crates/webui-parser/src/component_registry.rs
index 6f585c18..ed22f7c5 100644
--- a/crates/webui-parser/src/component_registry.rs
+++ b/crates/webui-parser/src/component_registry.rs
@@ -6,13 +6,11 @@
 //! This module manages the registry of web components used in the application.
 
 use crate::component_policy::{parse_component_render_policy, ComponentRenderPolicy};
-use crate::diagnostic::{codes, Diagnostic};
-use crate::html_parser::{self as html, Event, Walker};
+use crate::fast_template_source::prepare_component_template;
 use crate::{CssFallbackChain, CssParser, LegalComments, ParserError, Result};
 use std::collections::HashMap;
 #[cfg(feature = "fs")]
 use std::fs;
-use std::ops::Range;
 #[cfg(feature = "fs")]
 use std::path::Path;
 #[cfg(feature = "fs")]
@@ -20,18 +18,6 @@ use walkdir::WalkDir;
 
 type ProcessedCss = (String, Vec<String>, Vec<CssFallbackChain>);
 
-struct PreparedComponentTemplate {
-    tag_name: String,
-    html_content: String,
-    plugin_parse_content: Option<String>,
-    plugin_template_content: Option<String>,
-}
-
-struct FTemplateSource {
-    name: Option<String>,
-    inner: Range<usize>,
-}
-
 /// Represents a web component in the registry.
 ///
 /// ```
@@ -220,7 +206,7 @@ impl ComponentRegistry {
             context: format!("Failed to read HTML file: {}", html_path.display()),
             source,
         })?;
-        let prepared = Self::prepare_component_template(tag_name, &html_content)?;
+        let prepared = prepare_component_template(tag_name, &html_content)?;
         Self::validate_component_name(&prepared.tag_name)?;
 
         // Check for duplicate component
@@ -297,7 +283,7 @@ impl ComponentRegistry {
             is_client_owned,
         } = registration;
 
-        let prepared = Self::prepare_component_template(tag_name, html_content)?;
+        let prepared = prepare_component_template(tag_name, html_content)?;
         Self::validate_component_name(&prepared.tag_name)?;
 
         // Check for duplicate component
@@ -360,284 +346,8 @@ impl ComponentRegistry {
         )))
     }
 
-    fn prepare_component_template(
-        tag_name: &str,
-        html_content: &str,
-    ) -> Result<PreparedComponentTemplate> {
-        let Some(source) = Self::find_f_template_source(html_content)? else {
-            return Ok(PreparedComponentTemplate {
-                tag_name: tag_name.to_string(),
-                html_content: html_content.to_string(),
-                plugin_parse_content: None,
-                plugin_template_content: None,
-            });
-        };
-
-        let resolved_tag = source.name.as_deref().unwrap_or(tag_name).to_string();
-        let template_content = html_content[source.inner].trim();
-        let html_content = Self::convert_fast_template_to_webui(template_content, false);
-        let plugin_parse_content = Self::convert_fast_template_to_webui(template_content, true);
-        let plugin_parse_content =
-            (plugin_parse_content != html_content).then_some(plugin_parse_content);
-        Ok(PreparedComponentTemplate {
-            tag_name: resolved_tag,
-            html_content,
-            plugin_parse_content,
-            plugin_template_content: Some(template_content.to_string()),
-        })
-    }
-
-    fn find_f_template_source(html_content: &str) -> Result<Option<FTemplateSource>> {
-        let mut found: Option<FTemplateSource> = None;
-        let mut stack = Vec::with_capacity(1);
-        stack.push(0..html_content.len());
-
-        while let Some(range) = stack.pop() {
-            for event in Walker::new_range(html_content, range.start, range.end) {
-                let Event::Element(element) = event else {
-                    continue;
-                };
-
-                if element.name().eq_ignore_ascii_case("f-template") {
-                    if found.is_some() {
-                        return Err(Self::multiple_f_templates_error(
-                            html_content,
-                            element.start,
-                        ));
-                    }
-                    if !element.self_closing() && element.close_end() == element.content_end() {
-                        return Err(Self::unclosed_f_template_error(html_content, element.start));
-                    }
-                    found = Some(FTemplateSource {
-                        name: element
-                            .attr("name")
-                            .map(str::trim)
-                            .filter(|name| !name.is_empty())
-                            .map(str::to_string),
-                        inner: element.inner(),
-                    });
-                }
-
-                if !element.self_closing() && !element.is_void() {
-                    stack.push(element.inner());
-                }
-            }
-        }
-
-        Ok(found)
-    }
-
-    #[cold]
-    #[inline(never)]
-    fn multiple_f_templates_error(source: &str, offset: usize) -> ParserError {
-        Diagnostic::error("multiple <f-template> elements are not supported")
-            .code(codes::UNSUPPORTED_MULTIPLE_F_TEMPLATES)
-            .at_offset(source, offset)
-            .snippet("<f-template>")
-            .help(
-                "keep only one <f-template> per component file; multiple f-template blocks are not currently supported",
-            )
-            .into()
-    }
-
-    #[cold]
-    #[inline(never)]
-    fn unclosed_f_template_error(source: &str, offset: usize) -> ParserError {
-        Diagnostic::error("unclosed <f-template> tag")
-            .code(codes::UNCLOSED_HTML_TAG)
-            .at_offset(source, offset)
-            .snippet("<f-template>")
-            .help("add the matching </f-template> closing tag")
-            .into()
-    }
-
-    fn convert_fast_template_to_webui(input: &str, include_binding_markers: bool) -> String {
-        let mut result = String::with_capacity(input.len());
-        let bytes = input.as_bytes();
-        let len = bytes.len();
-        let mut index = 0usize;
-
-        while index < len {
-            if bytes[index] == b'<' {
-                if let Some(consumed) =
-                    Self::try_convert_fast_tag(input, index, &mut result, include_binding_markers)
-                {
-                    index += consumed;
-                    continue;
-                }
-            }
-            index = Self::push_char_at(input, index, &mut result);
-        }
-
-        result
-    }
-
-    fn try_convert_fast_tag(
-        input: &str,
-        pos: usize,
-        result: &mut String,
-        include_binding_markers: bool,
-    ) -> Option<usize> {
-        let remaining = &input[pos..];
-        let tag = html::parse_tag(remaining)?;
-
-        if tag.closing {
-            if tag.name.eq_ignore_ascii_case("f-repeat") {
-                result.push_str("</for>");
-                return Some(tag.close + 1);
-            }
-            if tag.name.eq_ignore_ascii_case("f-when") {
-                result.push_str("</if>");
-                return Some(tag.close + 1);
-            }
-            return None;
-        }
-
-        if tag.name.eq_ignore_ascii_case("f-repeat") {
-            Self::push_webui_directive_tag(
-                "for",
-                "each",
-                tag.attr("value"),
-                tag.self_closing,
-                result,
-            );
-            return Some(tag.close + 1);
-        }
-        if tag.name.eq_ignore_ascii_case("f-when") {
-            Self::push_webui_directive_tag(
-                "if",
-                "condition",
-                tag.attr("value"),
-                tag.self_closing,
-                result,
-            );
-            return Some(tag.close + 1);
-        }
-
-        if !tag.attrs().any(|attr| {
-            Self::is_fast_client_only_attr(attr.name)
-                || attr.value.and_then(Self::single_braced_value).is_some()
-        }) {
-            return None;
-        }
-
-        Self::push_webui_opening_tag(&tag, result, include_binding_markers);
-        Some(tag.close + 1)
-    }
-
-    fn push_webui_directive_tag(
-        tag_name: &str,
-        attr_name: &str,
-        value: Option<&str>,
-        self_closing: bool,
-        result: &mut String,
-    ) {
-        result.push('<');
-        result.push_str(tag_name);
-        if let Some(expr) = value.map(Self::strip_fast_value_expression) {
-            if !expr.is_empty() {
-                result.push(' ');
-                result.push_str(attr_name);
-                result.push_str("=\"");
-                result.push_str(expr);
-                result.push('"');
-            }
-        }
-        if self_closing {
-            result.push_str("></");
-            result.push_str(tag_name);
-            result.push('>');
-        } else {
-            result.push('>');
-        }
-    }
-
-    fn push_webui_opening_tag(
-        tag: &html::Tag<'_>,
-        result: &mut String,
-        include_binding_markers: bool,
-    ) {
-        result.push('<');
-        result.push_str(tag.name);
-        let mut stripped_binding_count = 0usize;
-        for attr in tag.attrs() {
-            if Self::is_fast_client_only_attr(attr.name) {
-                stripped_binding_count += 1;
-                continue;
-            }
-            result.push(' ');
-            if let Some(expr) = attr.value.and_then(Self::single_braced_value) {
-                result.push_str(attr.name);
-                result.push_str("=\"{{");
-                result.push_str(expr);
-                result.push_str("}}\"");
-            } else {
-                result.push_str(attr.raw);
-            }
-        }
-        if include_binding_markers {
-            for _ in 0..stripped_binding_count {
-                result.push(' ');
-                result.push_str(Self::INTERNAL_FAST_BINDING_ATTR);
-            }
-        }
-        if tag.self_closing {
-            result.push_str(" />");
-        } else {
-            result.push('>');
-        }
-    }
-
-    fn is_fast_client_only_attr(name: &str) -> bool {
-        name.starts_with('@')
-            || name.starts_with(':')
-            || matches!(name, "f-ref" | "f-slotted" | "f-children")
-    }
-
-    pub(crate) const INTERNAL_FAST_BINDING_ATTR: &str = "data-webui-internal-fast-binding";
-
-    fn strip_fast_value_expression(value: &str) -> &str {
-        Self::double_braced_value(value)
-            .or_else(|| Self::single_braced_value(value))
-            .unwrap_or_else(|| value.trim())
-    }
-
-    fn double_braced_value(value: &str) -> Option<&str> {
-        let trimmed = value.trim();
-        if trimmed.starts_with("{{") && trimmed.ends_with("}}") && !trimmed.starts_with("{{{") {
-            let inner = trimmed[2..trimmed.len() - 2].trim();
-            if !inner.is_empty() {
-                return Some(inner);
-            }
-        }
-        None
-    }
-
-    fn single_braced_value(value: &str) -> Option<&str> {
-        let trimmed = value.trim();
-        if trimmed.starts_with('{') && trimmed.ends_with('}') && !trimmed.starts_with("{{") {
-            let inner = trimmed[1..trimmed.len() - 1].trim();
-            if !inner.is_empty() {
-                return Some(inner);
-            }
-        }
-        None
-    }
-
-    fn push_char_at(input: &str, pos: usize, out: &mut String) -> usize {
-        let bytes = input.as_bytes();
-        if bytes[pos].is_ascii() {
-            out.push(bytes[pos] as char);
-            pos + 1
-        } else {
-            let mut end = pos + 1;
-            while end < bytes.len() && !input.is_char_boundary(end) {
-                end += 1;
-            }
-            out.push_str(&input[pos..end]);
-            end
-        }
-    }
+    pub(crate) const INTERNAL_FAST_BINDING_ATTR: &str =
+        crate::fast_template_source::INTERNAL_FAST_BINDING_ATTR;
 
     /// Strip comments and extract CSS definitions/fallback requirements.
     fn process_css_content(&mut self, css_content: &str) -> Result<ProcessedCss> {
diff --git a/crates/webui-parser/src/fast_template_source.rs b/crates/webui-parser/src/fast_template_source.rs
new file mode 100644
index 00000000..a09a7af3
--- /dev/null
+++ b/crates/webui-parser/src/fast_template_source.rs
@@ -0,0 +1,284 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+use crate::diagnostic::{codes, Diagnostic};
+use crate::html_parser::{self as html, Event, Walker};
+use crate::{ParserError, Result};
+use std::ops::Range;
+
+pub(crate) const INTERNAL_FAST_BINDING_ATTR: &str = "data-webui-internal-fast-binding";
+
+pub(crate) struct PreparedComponentTemplate {
+    pub(crate) tag_name: String,
+    pub(crate) html_content: String,
+    pub(crate) plugin_parse_content: Option<String>,
+    pub(crate) plugin_template_content: Option<String>,
+}
+
+struct FTemplateSource {
+    name: Option<String>,
+    inner: Range<usize>,
+}
+
+pub(crate) fn prepare_component_template(
+    tag_name: &str,
+    html_content: &str,
+) -> Result<PreparedComponentTemplate> {
+    let Some(source) = find_f_template_source(html_content)? else {
+        return Ok(PreparedComponentTemplate {
+            tag_name: tag_name.to_string(),
+            html_content: html_content.to_string(),
+            plugin_parse_content: None,
+            plugin_template_content: None,
+        });
+    };
+
+    let resolved_tag = source.name.as_deref().unwrap_or(tag_name).to_string();
+    let template_content = html_content[source.inner].trim();
+    let html_content = convert_fast_template_to_webui(template_content, false);
+    let plugin_parse_content = convert_fast_template_to_webui(template_content, true);
+    let plugin_parse_content =
+        (plugin_parse_content != html_content).then_some(plugin_parse_content);
+    Ok(PreparedComponentTemplate {
+        tag_name: resolved_tag,
+        html_content,
+        plugin_parse_content,
+        plugin_template_content: Some(template_content.to_string()),
+    })
+}
+
+fn find_f_template_source(html_content: &str) -> Result<Option<FTemplateSource>> {
+    let mut found: Option<FTemplateSource> = None;
+    let mut stack = Vec::with_capacity(1);
+    stack.push(0..html_content.len());
+
+    while let Some(range) = stack.pop() {
+        for event in Walker::new_range(html_content, range.start, range.end) {
+            let Event::Element(element) = event else {
+                continue;
+            };
+
+            if element.name().eq_ignore_ascii_case("f-template") {
+                if found.is_some() {
+                    return Err(multiple_f_templates_error(html_content, element.start));
+                }
+                if !element.self_closing() && element.close_end() == element.content_end() {
+                    return Err(unclosed_f_template_error(html_content, element.start));
+                }
+                found = Some(FTemplateSource {
+                    name: element
+                        .attr("name")
+                        .map(str::trim)
+                        .filter(|name| !name.is_empty())
+                        .map(str::to_string),
+                    inner: element.inner(),
+                });
+            }
+
+            if !element.self_closing() && !element.is_void() {
+                stack.push(element.inner());
+            }
+        }
+    }
+
+    Ok(found)
+}
+
+#[cold]
+#[inline(never)]
+fn multiple_f_templates_error(source: &str, offset: usize) -> ParserError {
+    Diagnostic::error("multiple <f-template> elements are not supported")
+        .code(codes::UNSUPPORTED_MULTIPLE_F_TEMPLATES)
+        .at_offset(source, offset)
+        .snippet("<f-template>")
+        .help(
+            "keep only one <f-template> per component file; multiple f-template blocks are not currently supported",
+        )
+        .into()
+}
+
+#[cold]
+#[inline(never)]
+fn unclosed_f_template_error(source: &str, offset: usize) -> ParserError {
+    Diagnostic::error("unclosed <f-template> tag")
+        .code(codes::UNCLOSED_HTML_TAG)
+        .at_offset(source, offset)
+        .snippet("<f-template>")
+        .help("add the matching </f-template> closing tag")
+        .into()
+}
+
+fn convert_fast_template_to_webui(input: &str, include_binding_markers: bool) -> String {
+    let mut result = String::with_capacity(input.len());
+    let bytes = input.as_bytes();
+    let len = bytes.len();
+    let mut index = 0usize;
+
+    while index < len {
+        if bytes[index] == b'<' {
+            if let Some(consumed) =
+                try_convert_fast_tag(input, index, &mut result, include_binding_markers)
+            {
+                index += consumed;
+                continue;
+            }
+        }
+        index = push_char_at(input, index, &mut result);
+    }
+
+    result
+}
+
+fn try_convert_fast_tag(
+    input: &str,
+    pos: usize,
+    result: &mut String,
+    include_binding_markers: bool,
+) -> Option<usize> {
+    let remaining = &input[pos..];
+    let tag = html::parse_tag(remaining)?;
+
+    if tag.closing {
+        if tag.name.eq_ignore_ascii_case("f-repeat") {
+            result.push_str("</for>");
+            return Some(tag.close + 1);
+        }
+        if tag.name.eq_ignore_ascii_case("f-when") {
+            result.push_str("</if>");
+            return Some(tag.close + 1);
+        }
+        return None;
+    }
+
+    if tag.name.eq_ignore_ascii_case("f-repeat") {
+        push_webui_directive_tag("for", "each", tag.attr("value"), tag.self_closing, result);
+        return Some(tag.close + 1);
+    }
+    if tag.name.eq_ignore_ascii_case("f-when") {
+        push_webui_directive_tag(
+            "if",
+            "condition",
+            tag.attr("value"),
+            tag.self_closing,
+            result,
+        );
+        return Some(tag.close + 1);
+    }
+
+    if !tag.attrs().any(|attr| {
+        is_fast_client_only_attr(attr.name) || attr.value.and_then(single_braced_value).is_some()
+    }) {
+        return None;
+    }
+
+    push_webui_opening_tag(&tag, result, include_binding_markers);
+    Some(tag.close + 1)
+}
+
+fn push_webui_directive_tag(
+    tag_name: &str,
+    attr_name: &str,
+    value: Option<&str>,
+    self_closing: bool,
+    result: &mut String,
+) {
+    result.push('<');
+    result.push_str(tag_name);
+    if let Some(expr) = value.map(strip_fast_value_expression) {
+        if !expr.is_empty() {
+            result.push(' ');
+            result.push_str(attr_name);
+            result.push_str("=\"");
+            result.push_str(expr);
+            result.push('"');
+        }
+    }
+    if self_closing {
+        result.push_str("></");
+        result.push_str(tag_name);
+        result.push('>');
+    } else {
+        result.push('>');
+    }
+}
+
+fn push_webui_opening_tag(tag: &html::Tag<'_>, result: &mut String, include_binding_markers: bool) {
+    result.push('<');
+    result.push_str(tag.name);
+    let mut stripped_binding_count = 0usize;
+    for attr in tag.attrs() {
+        if is_fast_client_only_attr(attr.name) {
+            stripped_binding_count += 1;
+            continue;
+        }
+        result.push(' ');
+        if let Some(expr) = attr.value.and_then(single_braced_value) {
+            result.push_str(attr.name);
+            result.push_str("=\"{{");
+            result.push_str(expr);
+            result.push_str("}}\"");
+        } else {
+            result.push_str(attr.raw);
+        }
+    }
+    if include_binding_markers {
+        for _ in 0..stripped_binding_count {
+            result.push(' ');
+            result.push_str(INTERNAL_FAST_BINDING_ATTR);
+        }
+    }
+    if tag.self_closing {
+        result.push_str(" />");
+    } else {
+        result.push('>');
+    }
+}
+
+fn is_fast_client_only_attr(name: &str) -> bool {
+    name.starts_with('@')
+        || name.starts_with(':')
+        || matches!(name, "f-ref" | "f-slotted" | "f-children")
+}
+
+fn strip_fast_value_expression(value: &str) -> &str {
+    double_braced_value(value)
+        .or_else(|| single_braced_value(value))
+        .unwrap_or_else(|| value.trim())
+}
+
+fn double_braced_value(value: &str) -> Option<&str> {
+    let trimmed = value.trim();
+    if trimmed.starts_with("{{") && trimmed.ends_with("}}") && !trimmed.starts_with("{{{") {
+        let inner = trimmed[2..trimmed.len() - 2].trim();
+        if !inner.is_empty() {
+            return Some(inner);
+        }
+    }
+    None
+}
+
+fn single_braced_value(value: &str) -> Option<&str> {
+    let trimmed = value.trim();
+    if trimmed.starts_with('{') && trimmed.ends_with('}') && !trimmed.starts_with("{{") {
+        let inner = trimmed[1..trimmed.len() - 1].trim();
+        if !inner.is_empty() {
+            return Some(inner);
+        }
+    }
+    None
+}
+
+fn push_char_at(input: &str, pos: usize, out: &mut String) -> usize {
+    let bytes = input.as_bytes();
+    if bytes[pos].is_ascii() {
+        out.push(bytes[pos] as char);
+        pos + 1
+    } else {
+        let mut end = pos + 1;
+        while end < bytes.len() && !input.is_char_boundary(end) {
+            end += 1;
+        }
+        out.push_str(&input[pos..end]);
+        end
+    }
+}
diff --git a/crates/webui-parser/src/lib.rs b/crates/webui-parser/src/lib.rs
index 02bbcd28..a8ae498d 100644
--- a/crates/webui-parser/src/lib.rs
+++ b/crates/webui-parser/src/lib.rs
@@ -13,6 +13,7 @@ mod css_link;
 mod css_parser;
 mod diagnostic;
 mod error;
+mod fast_template_source;
 mod handlebars_parser;
 mod html_parser;
 pub mod plugin;

From 9da01ebb750767fb9497acf4ac20c212c2d911d3 Mon Sep 17 00:00:00 2001
From: Jane Chu <7559015+janechu@users.noreply.github.com>
Date: Mon, 27 Jul 2026 11:30:00 -0700
Subject: [PATCH 3/6] Integrate microsoft-fast-convert for FAST templates

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: edae75de-6059-41a3-808d-0ec4b4c85b08
---
 Cargo.lock                                    |  10 +
 Cargo.toml                                    |   1 +
 DESIGN.md                                     |  66 +++---
 README.md                                     |  29 ++-
 crates/webui-parser/Cargo.toml                |   1 +
 crates/webui-parser/src/component_registry.rs |  79 ++++++-
 crates/webui-parser/src/diagnostic.rs         |   2 +
 .../webui-parser/src/fast_template_source.rs  | 201 +++++++-----------
 crates/webui-parser/src/lib.rs                |  13 +-
 crates/webui/src/lib.rs                       |  48 +++++
 docs/guide/concepts/plugins/index.md          |  46 ++--
 11 files changed, 319 insertions(+), 177 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 920af549..da76caae 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1777,6 +1777,15 @@ version = "2.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
 
+[[package]]
+name = "microsoft-fast-convert"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7343de729e1cd95b7d65814cf1f56ee7ab88f58330e1ef651e545404bccff955"
+dependencies = [
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "microsoft-webui"
 version = "0.0.23"
@@ -1926,6 +1935,7 @@ dependencies = [
  "clap",
  "criterion",
  "html-escape",
+ "microsoft-fast-convert",
  "microsoft-webui-protocol",
  "microsoft-webui-test-utils",
  "microsoft-webui-tokens",
diff --git a/Cargo.toml b/Cargo.toml
index d3d243ac..740e6429 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -47,6 +47,7 @@ expand-tilde = "0.6.1"
 mime_guess = "2.0.5"
 html-escape = "0.2.14"
 include_dir = "0.7.4"
+microsoft-fast-convert = "0.9.0"
 async-stream = "0.3.6"
 futures-util = "0.3.32"
 tokio-stream = "0.1.18"
diff --git a/DESIGN.md b/DESIGN.md
index 96994e40..e37923f9 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -1254,35 +1254,53 @@ documentation for the current list. Each plugin defines:
 
 **Built-in FAST parser plugins**
 
-The built-in FAST parser plugins (`fast`, `fast-v2`, and `fast-v3`) opt into
-FAST template artifacts and support component source files authored as a single
-wrapping `<f-template>`. Component registration detects that wrapper before
-parsing. The wrapper's `name` attribute overrides the filename-derived component
-tag; if `name` is absent or empty, the filename-derived tag is used. Multiple
-`<f-template>` elements in one component source are unsupported and return a
-structured authoring diagnostic with code `unsupported-multiple-f-templates`.
-
-For build-time SSR parsing, WebUI converts the inner FAST declarative template
-to the WebUI parse view while keeping a separate plugin-facing client artifact:
+The `fast`, `fast_v2`, and `fast_v3` parser implementations (selected as
+`fast`, `fast-v2`, and `fast-v3` by CLI and host string APIs) all opt into the
+same FAST template artifact path. Component registration automatically scans
+discovered HTML sources for an `<f-template>`. A source that has one must contain
+exactly one `<f-template>` with exactly one inner `<template>`. A present,
+non-empty `name` becomes the registered component tag and overrides the
+filename-derived tag. If `name` is absent or trims to empty, registration keeps
+the filename-derived tag. Multiple `<f-template>` elements return
+`unsupported-multiple-f-templates`; multiple inner `<template>` elements are
+also invalid. Sources without an `<f-template>` retain the normal component
+template path.
+
+For build-time SSR parsing, WebUI adapts the `<f-template>` source for
+`microsoft-fast-convert` with the `webui-prerelease` target. Because the
+converter requires a non-empty name, the adapter supplies an internal name only
+to the converter when the source name is absent or empty. This internal value
+does not replace the filename-derived component tag or appear in the emitted
+client artifact. The returned inner template becomes the WebUI parse view:
 
 - `<f-repeat value="{{item in items}}">` converts to
   `<for each="item in items">`.
 - `<f-when value="{{condition}}">` converts to
   `<if condition="condition">`.
-- Directive values are unwrapped from `{{...}}` or `{...}` when moving to the
-  WebUI parse view.
-- Client-only FAST syntax that does not affect server-rendered output is removed
-  from the SSR parse view, including `@event`, `:prop`, `f-ref`, `f-slotted`,
-  `f-children`, and other client-only property/event directives.
-
-The original authored FAST template remains the client template artifact emitted
-by the FAST plugin. Parser-only markers carry the binding count for stripped
-client-only directives so FAST hydration indexes remain aligned, but those
-markers never appear in public component HTML or non-FAST plugin artifacts. The
-preserved artifact still runs through the normal component-template processing
-path before emission, including template wrapper normalization, selected
-CSS-strategy injection, module stylesheet adoption where applicable,
-legal-comment handling, and plugin artifact normalization.
+- The converter unwraps the `value` expression for those directives. Text
+  `{{expression}}` bindings and `?boolean` bindings remain available to the
+  WebUI parser; ordinary attributes are not treated as additional converter
+  syntax.
+- Unsupported `f-*` elements or attributes and malformed directive expressions
+  return structured authoring diagnostics. WebUI does not claim support for
+  FAST constructs that the converter rejects.
+- After conversion, WebUI removes `@event`, `:property`, `f-ref`, `f-slotted`,
+  and `f-children` from the public SSR view because they are client-only. A
+  parser-only view replaces each removed binding with an internal marker so the
+  FAST plugin still emits the correct hydration binding count. Markers never
+  appear in public component HTML or plugin artifacts.
+
+WebUI separately retains the authored inner `<template>` from the source for the
+FAST client artifact, including its client-only bindings, rather than rebuilding
+it from the converted SSR view. The FAST plugin wraps that retained source in
+the resolved `<f-template name="...">` for insertion. The artifact is normalized
+rather than preserved byte-for-byte: it passes through normal component
+template processing, including wrapper normalization, selected CSS-strategy
+injection, module stylesheet adoption where applicable, legal-comment handling,
+and plugin artifact normalization. The deprecated `fast` selector aliases the
+FAST 2 implementation, while `fast_v2` and `fast_v3` use their respective
+hydration marker formats; all three share this discovery, conversion, and
+artifact-retention behavior.
 
 WebUI itself does not interpret plugin-emitted bytes; each parser plugin pairs with
 a matching handler plugin that consumes them at render time. See [packages/webui-framework/README.md](packages/webui-framework/README.md)
diff --git a/README.md b/README.md
index 0d638980..b611d598 100644
--- a/README.md
+++ b/README.md
@@ -14,16 +14,25 @@
 
 ## FAST plugin authored templates
 
-The built-in FAST plugins (`fast`, `fast-v2`, and `fast-v3`) support component
-HTML authored as a single wrapping `<f-template>`. A `name` attribute on that
-wrapper overrides the filename-derived component tag; multiple `<f-template>`
-blocks in one component source are invalid. For build-time SSR, WebUI converts
-the inner FAST declarative template to WebUI syntax by rewriting `<f-repeat>` to
-`<for>`, rewriting `<f-when>` to `<if>`, unwrapping directive values, and
-removing client-only directives such as `@event`, `:prop`, `f-ref`,
-`f-slotted`, `f-children`, and similar attributes. The authored FAST template is
-preserved as the client artifact, and preserved artifacts still receive normal
-template processing, normalization, and CSS injection.
+The `fast`, `fast_v2`, and `fast_v3` integrations (CLI names `fast`, `fast-v2`,
+and `fast-v3`) automatically detect component HTML authored as a single
+`<f-template>`. A non-empty `name` replaces the component tag derived from the
+filename; an absent or whitespace-only name keeps the filename-derived tag. The
+wrapper must contain exactly one inner `<template>`. Unsupported FAST syntax and
+multiple `<f-template>` blocks fail the build with an authoring diagnostic.
+
+For build-time SSR, WebUI adapts the source for `microsoft-fast-convert` and its
+`webui-prerelease` target, supplying a converter-only name when the authored
+name is absent or empty. The converter rewrites supported `<f-repeat>` and
+`<f-when>` directives to WebUI `<for>` and `<if>` directives while preserving
+text interpolation and boolean bindings. WebUI then removes client-only
+`@event`, `:property`, `f-ref`, `f-slotted`, and `f-children` attributes from the
+SSR view while retaining their binding counts for FAST hydration. The authored
+inner template, including its client bindings, is retained for the emitted
+`<f-template>` instead of being regenerated from the SSR conversion. It still
+receives normal wrapper normalization, legal comment processing, and CSS
+injection for the selected strategy. Component HTML without an `<f-template>`
+continues through the normal WebUI template path.
 
 ## Install
 
diff --git a/crates/webui-parser/Cargo.toml b/crates/webui-parser/Cargo.toml
index 486494a5..b048d12b 100644
--- a/crates/webui-parser/Cargo.toml
+++ b/crates/webui-parser/Cargo.toml
@@ -30,6 +30,7 @@ microsoft-webui-protocol = { path = "../webui-protocol", version = "0.0.23" }
 microsoft-webui-tokens = { path = "../webui-tokens", version = "0.0.23" }
 thiserror = { workspace = true }
 html-escape = { workspace = true }
+microsoft-fast-convert = { workspace = true }
 walkdir = { workspace = true, optional = true }
 clap = { workspace = true, optional = true }
 sha2 = { workspace = true }
diff --git a/crates/webui-parser/src/component_registry.rs b/crates/webui-parser/src/component_registry.rs
index ed22f7c5..a0362ef4 100644
--- a/crates/webui-parser/src/component_registry.rs
+++ b/crates/webui-parser/src/component_registry.rs
@@ -886,7 +886,7 @@ mod tests {
 
     #[test]
     fn f_template_name_overrides_file_name_and_converts_for_webui() {
-        let html = r#"<f-template name="named-card"><template><f-when value="{{visible}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" title="{title}">{{item.label}}</button></f-repeat></f-when></template></f-template>"#;
+        let html = r#"<f-template name="named-card"><template><f-when value="{{visible && count > 0}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" ?disabled="{{disabled}}" f-ref="{button}" title="{{title}}">{{item.label}}</button></f-repeat></f-when></template></f-template>"#;
 
         let mut registry = ComponentRegistry::new();
         registry
@@ -905,19 +905,26 @@ mod tests {
         assert_eq!(component.tag_name, "named-card");
         assert_eq!(
             component.html_content,
-            r#"<template><if condition="visible"><for each="item in items"><button title="{{title}}">{{item.label}}</button></for></if></template>"#
+            r#"<template><if condition="visible && count > 0"><for each="item in items"><button ?disabled="{{disabled}}" title="{{title}}">{{item.label}}</button></for></if></template>"#
         );
         let parse_content = registry
             .html_content_for_parse("named-card", true)
             .expect("parse content");
         assert!(parse_content.contains(ComponentRegistry::INTERNAL_FAST_BINDING_ATTR));
+        assert_eq!(
+            parse_content
+                .match_indices(ComponentRegistry::INTERNAL_FAST_BINDING_ATTR)
+                .count(),
+            3
+        );
+        assert!(parse_content.contains(r#"?disabled="{{disabled}}""#));
         assert!(!component
             .html_content
             .contains(ComponentRegistry::INTERNAL_FAST_BINDING_ATTR));
         assert_eq!(
             registry.plugin_template_artifact("named-card"),
             Some(
-                r#"<template><f-when value="{{visible}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" title="{title}">{{item.label}}</button></f-repeat></f-when></template>"#
+                r#"<template><f-when value="{{visible && count > 0}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" ?disabled="{{disabled}}" f-ref="{button}" title="{{title}}">{{item.label}}</button></f-repeat></f-when></template>"#
             )
         );
     }
@@ -944,6 +951,72 @@ mod tests {
         assert!(diag.to_string().contains("not currently supported"));
     }
 
+    #[test]
+    fn invalid_f_template_converter_error_is_a_diagnostic() {
+        let mut registry = ComponentRegistry::new();
+        let err = registry
+            .register_component(ComponentRegistration::new(
+                "invalid-card",
+                r#"<f-template name="invalid-card"><template><f-repeat value="{{items}}"></f-repeat></template></f-template>"#,
+                None,
+                true,
+            ))
+            .expect_err("invalid repeat should error");
+
+        let ParserError::Template(diag) = err else {
+            panic!("expected template diagnostic");
+        };
+        assert_eq!(diag.error_code(), Some(codes::INVALID_FAST_TEMPLATE));
+        assert!(diag.to_string().contains("item in items"));
+        assert!(diag.help_text().is_some());
+    }
+
+    #[test]
+    fn f_template_without_usable_name_uses_file_name() {
+        for html in [
+            "<f-template><template></template></f-template>",
+            r#"<f-template name=" "><template></template></f-template>"#,
+        ] {
+            let mut registry = ComponentRegistry::new();
+            registry
+                .register_component(ComponentRegistration::new("file-card", html, None, true))
+                .expect("file-derived name should satisfy the converter");
+
+            assert!(registry.contains("file-card"));
+            assert_eq!(
+                registry
+                    .get("file-card")
+                    .map(|component| component.html_content.as_str()),
+                Some("<template></template>")
+            );
+            assert_eq!(
+                registry.plugin_template_artifact("file-card"),
+                Some("<template></template>")
+            );
+        }
+    }
+
+    #[test]
+    fn plain_webui_template_uses_unchanged_fallback() {
+        let html = r#"<template><if condition="visible"><span>{{title}}</span></if></template>"#;
+        let mut registry = ComponentRegistry::new();
+        registry
+            .register_component(ComponentRegistration::new("plain-card", html, None, true))
+            .expect("register");
+
+        assert_eq!(
+            registry
+                .get("plain-card")
+                .map(|component| component.html_content.as_str()),
+            Some(html)
+        );
+        assert_eq!(
+            registry.html_content_for_parse("plain-card", true),
+            Some(html)
+        );
+        assert_eq!(registry.plugin_template_artifact("plain-card"), None);
+    }
+
     #[test]
     fn test_exclude_dot_in_component_name() {
         let mut registry = ComponentRegistry::new();
diff --git a/crates/webui-parser/src/diagnostic.rs b/crates/webui-parser/src/diagnostic.rs
index 236d7a7d..9cc34ac8 100644
--- a/crates/webui-parser/src/diagnostic.rs
+++ b/crates/webui-parser/src/diagnostic.rs
@@ -104,6 +104,8 @@ pub mod codes {
     pub const UNTHEMED_TOKEN: &str = "unthemed-token";
     /// A component source contains multiple `<f-template>` blocks.
     pub const UNSUPPORTED_MULTIPLE_F_TEMPLATES: &str = "unsupported-multiple-f-templates";
+    /// A FAST declarative template cannot be converted to WebUI syntax.
+    pub const INVALID_FAST_TEMPLATE: &str = "invalid-fast-template";
     /// `<boundary>` is missing its required, non-empty `name` attribute.
     pub const MISSING_BOUNDARY_NAME: &str = "missing-boundary-name";
     /// `<boundary name>` is not a static string literal (e.g. it
diff --git a/crates/webui-parser/src/fast_template_source.rs b/crates/webui-parser/src/fast_template_source.rs
index a09a7af3..2da8e613 100644
--- a/crates/webui-parser/src/fast_template_source.rs
+++ b/crates/webui-parser/src/fast_template_source.rs
@@ -4,9 +4,13 @@
 use crate::diagnostic::{codes, Diagnostic};
 use crate::html_parser::{self as html, Event, Walker};
 use crate::{ParserError, Result};
+use microsoft_fast_convert::{convert_template, ConvertError};
+use std::borrow::Cow;
 use std::ops::Range;
 
 pub(crate) const INTERNAL_FAST_BINDING_ATTR: &str = "data-webui-internal-fast-binding";
+const CONVERTER_FALLBACK_NAME: &str = "webui-fallback";
+const WEBUI_CONVERTER_SYNTAX: &str = "webui-prerelease";
 
 pub(crate) struct PreparedComponentTemplate {
     pub(crate) tag_name: String,
@@ -17,6 +21,7 @@ pub(crate) struct PreparedComponentTemplate {
 
 struct FTemplateSource {
     name: Option<String>,
+    start: usize,
     inner: Range<usize>,
 }
 
@@ -24,7 +29,7 @@ pub(crate) fn prepare_component_template(
     tag_name: &str,
     html_content: &str,
 ) -> Result<PreparedComponentTemplate> {
-    let Some(source) = find_f_template_source(html_content)? else {
+    let Some(source) = find_f_template_source(html_content) else {
         return Ok(PreparedComponentTemplate {
             tag_name: tag_name.to_string(),
             html_content: html_content.to_string(),
@@ -34,9 +39,12 @@ pub(crate) fn prepare_component_template(
     };
 
     let resolved_tag = source.name.as_deref().unwrap_or(tag_name).to_string();
+    let converter_input = converter_input(html_content, &source);
+    let converted = convert_template(&converter_input, WEBUI_CONVERTER_SYNTAX)
+        .map_err(|error| converter_error(html_content, source.start, error))?;
     let template_content = html_content[source.inner].trim();
-    let html_content = convert_fast_template_to_webui(template_content, false);
-    let plugin_parse_content = convert_fast_template_to_webui(template_content, true);
+    let html_content = strip_fast_client_attributes(&converted, false);
+    let plugin_parse_content = strip_fast_client_attributes(&converted, true);
     let plugin_parse_content =
         (plugin_parse_content != html_content).then_some(plugin_parse_content);
     Ok(PreparedComponentTemplate {
@@ -47,8 +55,7 @@ pub(crate) fn prepare_component_template(
     })
 }
 
-fn find_f_template_source(html_content: &str) -> Result<Option<FTemplateSource>> {
-    let mut found: Option<FTemplateSource> = None;
+fn find_f_template_source(html_content: &str) -> Option<FTemplateSource> {
     let mut stack = Vec::with_capacity(1);
     stack.push(0..html_content.len());
 
@@ -59,18 +66,13 @@ fn find_f_template_source(html_content: &str) -> Result<Option<FTemplateSource>>
             };
 
             if element.name().eq_ignore_ascii_case("f-template") {
-                if found.is_some() {
-                    return Err(multiple_f_templates_error(html_content, element.start));
-                }
-                if !element.self_closing() && element.close_end() == element.content_end() {
-                    return Err(unclosed_f_template_error(html_content, element.start));
-                }
-                found = Some(FTemplateSource {
+                return Some(FTemplateSource {
                     name: element
                         .attr("name")
                         .map(str::trim)
                         .filter(|name| !name.is_empty())
                         .map(str::to_string),
+                    start: element.start,
                     inner: element.inner(),
                 });
             }
@@ -81,34 +83,80 @@ fn find_f_template_source(html_content: &str) -> Result<Option<FTemplateSource>>
         }
     }
 
-    Ok(found)
+    None
 }
 
-#[cold]
-#[inline(never)]
-fn multiple_f_templates_error(source: &str, offset: usize) -> ParserError {
-    Diagnostic::error("multiple <f-template> elements are not supported")
-        .code(codes::UNSUPPORTED_MULTIPLE_F_TEMPLATES)
-        .at_offset(source, offset)
-        .snippet("<f-template>")
-        .help(
-            "keep only one <f-template> per component file; multiple f-template blocks are not currently supported",
-        )
-        .into()
+fn converter_input<'a>(html_content: &'a str, source: &FTemplateSource) -> Cow<'a, str> {
+    if source.name.is_some() {
+        return Cow::Borrowed(html_content);
+    }
+
+    let mut normalized =
+        String::with_capacity(html_content.len() + CONVERTER_FALLBACK_NAME.len() + 20);
+    normalized.push_str(&html_content[..source.start]);
+    normalized.push_str("<f-template name=\"");
+    normalized.push_str(CONVERTER_FALLBACK_NAME);
+    normalized.push_str("\">");
+    normalized.push_str(&html_content[source.inner.start..]);
+    Cow::Owned(normalized)
 }
 
 #[cold]
 #[inline(never)]
-fn unclosed_f_template_error(source: &str, offset: usize) -> ParserError {
-    Diagnostic::error("unclosed <f-template> tag")
-        .code(codes::UNCLOSED_HTML_TAG)
+fn converter_error(source: &str, offset: usize, error: ConvertError) -> ParserError {
+    if matches!(error, ConvertError::MultipleFTemplates { .. }) {
+        return Diagnostic::error("multiple <f-template> elements are not supported")
+            .code(codes::UNSUPPORTED_MULTIPLE_F_TEMPLATES)
+            .at_offset(source, offset)
+            .snippet("<f-template>")
+            .help(
+                "keep only one <f-template> per component file; multiple f-template blocks are not currently supported",
+            )
+            .into();
+    }
+
+    let help = match &error {
+        ConvertError::MissingFTemplateName | ConvertError::EmptyFTemplateName => {
+            "add a non-empty name attribute to <f-template>, for example <f-template name=\"my-component\">"
+        }
+        ConvertError::MissingInnerTemplate | ConvertError::MultipleInnerTemplates { .. } => {
+            "keep exactly one inner <template> element inside <f-template>"
+        }
+        ConvertError::MissingValueAttribute { .. }
+        | ConvertError::InvalidDirectiveValue { .. } => {
+            "add the required value=\"{{expression}}\" attribute to the FAST directive"
+        }
+        ConvertError::InvalidRepeatExpression { .. } => {
+            "use an f-repeat expression in \"item in items\" form"
+        }
+        ConvertError::UnclosedElement { .. } | ConvertError::UnclosedTag { .. } => {
+            "close the reported FAST template element or opening tag"
+        }
+        ConvertError::UnsupportedFAttribute { .. }
+        | ConvertError::UnsupportedFElement { .. } => {
+            "remove the unsupported FAST construct or replace it with supported declarative syntax"
+        }
+        _ => "fix the reported FAST declarative template syntax",
+    };
+
+    let code = if matches!(
+        error,
+        ConvertError::UnclosedElement { .. } | ConvertError::UnclosedTag { .. }
+    ) {
+        codes::UNCLOSED_HTML_TAG
+    } else {
+        codes::INVALID_FAST_TEMPLATE
+    };
+
+    Diagnostic::error(format!("invalid FAST template: {error}"))
+        .code(code)
         .at_offset(source, offset)
         .snippet("<f-template>")
-        .help("add the matching </f-template> closing tag")
+        .help(help)
         .into()
 }
 
-fn convert_fast_template_to_webui(input: &str, include_binding_markers: bool) -> String {
+fn strip_fast_client_attributes(input: &str, include_binding_markers: bool) -> String {
     let mut result = String::with_capacity(input.len());
     let bytes = input.as_bytes();
     let len = bytes.len();
@@ -117,7 +165,7 @@ fn convert_fast_template_to_webui(input: &str, include_binding_markers: bool) ->
     while index < len {
         if bytes[index] == b'<' {
             if let Some(consumed) =
-                try_convert_fast_tag(input, index, &mut result, include_binding_markers)
+                try_strip_fast_attributes(input, index, &mut result, include_binding_markers)
             {
                 index += consumed;
                 continue;
@@ -129,7 +177,7 @@ fn convert_fast_template_to_webui(input: &str, include_binding_markers: bool) ->
     result
 }
 
-fn try_convert_fast_tag(
+fn try_strip_fast_attributes(
     input: &str,
     pos: usize,
     result: &mut String,
@@ -139,35 +187,10 @@ fn try_convert_fast_tag(
     let tag = html::parse_tag(remaining)?;
 
     if tag.closing {
-        if tag.name.eq_ignore_ascii_case("f-repeat") {
-            result.push_str("</for>");
-            return Some(tag.close + 1);
-        }
-        if tag.name.eq_ignore_ascii_case("f-when") {
-            result.push_str("</if>");
-            return Some(tag.close + 1);
-        }
         return None;
     }
 
-    if tag.name.eq_ignore_ascii_case("f-repeat") {
-        push_webui_directive_tag("for", "each", tag.attr("value"), tag.self_closing, result);
-        return Some(tag.close + 1);
-    }
-    if tag.name.eq_ignore_ascii_case("f-when") {
-        push_webui_directive_tag(
-            "if",
-            "condition",
-            tag.attr("value"),
-            tag.self_closing,
-            result,
-        );
-        return Some(tag.close + 1);
-    }
-
-    if !tag.attrs().any(|attr| {
-        is_fast_client_only_attr(attr.name) || attr.value.and_then(single_braced_value).is_some()
-    }) {
+    if !tag.attrs().any(|attr| is_fast_client_only_attr(attr.name)) {
         return None;
     }
 
@@ -175,33 +198,6 @@ fn try_convert_fast_tag(
     Some(tag.close + 1)
 }
 
-fn push_webui_directive_tag(
-    tag_name: &str,
-    attr_name: &str,
-    value: Option<&str>,
-    self_closing: bool,
-    result: &mut String,
-) {
-    result.push('<');
-    result.push_str(tag_name);
-    if let Some(expr) = value.map(strip_fast_value_expression) {
-        if !expr.is_empty() {
-            result.push(' ');
-            result.push_str(attr_name);
-            result.push_str("=\"");
-            result.push_str(expr);
-            result.push('"');
-        }
-    }
-    if self_closing {
-        result.push_str("></");
-        result.push_str(tag_name);
-        result.push('>');
-    } else {
-        result.push('>');
-    }
-}
-
 fn push_webui_opening_tag(tag: &html::Tag<'_>, result: &mut String, include_binding_markers: bool) {
     result.push('<');
     result.push_str(tag.name);
@@ -212,14 +208,7 @@ fn push_webui_opening_tag(tag: &html::Tag<'_>, result: &mut String, include_bind
             continue;
         }
         result.push(' ');
-        if let Some(expr) = attr.value.and_then(single_braced_value) {
-            result.push_str(attr.name);
-            result.push_str("=\"{{");
-            result.push_str(expr);
-            result.push_str("}}\"");
-        } else {
-            result.push_str(attr.raw);
-        }
+        result.push_str(attr.raw);
     }
     if include_binding_markers {
         for _ in 0..stripped_binding_count {
@@ -240,34 +229,6 @@ fn is_fast_client_only_attr(name: &str) -> bool {
         || matches!(name, "f-ref" | "f-slotted" | "f-children")
 }
 
-fn strip_fast_value_expression(value: &str) -> &str {
-    double_braced_value(value)
-        .or_else(|| single_braced_value(value))
-        .unwrap_or_else(|| value.trim())
-}
-
-fn double_braced_value(value: &str) -> Option<&str> {
-    let trimmed = value.trim();
-    if trimmed.starts_with("{{") && trimmed.ends_with("}}") && !trimmed.starts_with("{{{") {
-        let inner = trimmed[2..trimmed.len() - 2].trim();
-        if !inner.is_empty() {
-            return Some(inner);
-        }
-    }
-    None
-}
-
-fn single_braced_value(value: &str) -> Option<&str> {
-    let trimmed = value.trim();
-    if trimmed.starts_with('{') && trimmed.ends_with('}') && !trimmed.starts_with("{{") {
-        let inner = trimmed[1..trimmed.len() - 1].trim();
-        if !inner.is_empty() {
-            return Some(inner);
-        }
-    }
-    None
-}
-
 fn push_char_at(input: &str, pos: usize, out: &mut String) -> usize {
     let bytes = input.as_bytes();
     if bytes[pos].is_ascii() {
diff --git a/crates/webui-parser/src/lib.rs b/crates/webui-parser/src/lib.rs
index a8ae498d..54ddde93 100644
--- a/crates/webui-parser/src/lib.rs
+++ b/crates/webui-parser/src/lib.rs
@@ -4092,7 +4092,7 @@ mod tests {
             .component_registry
             .register_component(ComponentRegistration::new(
                 "file-card",
-                r#"<f-template name="named-card"><template><f-when value="{{visible}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" title="{title}">{{item.label}}</button></f-repeat></f-when></template></f-template>"#,
+                r#"<f-template name="named-card"><template><f-when value="{{visible}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" ?disabled="{{disabled}}" f-ref="{button}" title="{{title}}">{{item.label}}</button></f-repeat></f-when></template></f-template>"#,
                 Some(".root { color: red; }"),
                 true,
             ))
@@ -4116,7 +4116,7 @@ mod tests {
         assert!(for_fragments.iter().any(|fragment| {
             matches!(
                 fragment.fragment.as_ref(),
-                Some(Fragment::Plugin(data)) if data.data == 3u32.to_le_bytes()
+                Some(Fragment::Plugin(data)) if data.data == 5u32.to_le_bytes()
             )
         }));
         assert!(!for_fragments.iter().any(|fragment| {
@@ -4139,6 +4139,9 @@ mod tests {
         assert!(template.contains(r#"<f-repeat value="{{item in items}}">"#));
         assert!(template.contains(r#"@click="{save()}""#));
         assert!(template.contains(r#":config="{config}""#));
+        assert!(template.contains(r#"?disabled="{{disabled}}""#));
+        assert!(template.contains(r#"f-ref="{button}""#));
+        assert!(template.contains(r#"title="{{title}}""#));
         assert!(!template.contains("file-card"));
     }
 
@@ -4147,6 +4150,12 @@ mod tests {
         assert_f_template_component_source(Box::new(plugin::fast_v2::FastV2ParserPlugin::new()));
     }
 
+    #[test]
+    #[allow(deprecated)]
+    fn fast_plugin_uses_authored_f_template_source() {
+        assert_f_template_component_source(Box::new(plugin::fast::FastParserPlugin::new()));
+    }
+
     #[test]
     fn fast_v3_plugin_uses_authored_f_template_source() {
         assert_f_template_component_source(Box::new(plugin::fast_v3::FastV3ParserPlugin::new()));
diff --git a/crates/webui/src/lib.rs b/crates/webui/src/lib.rs
index 893837c3..6b53d05d 100644
--- a/crates/webui/src/lib.rs
+++ b/crates/webui/src/lib.rs
@@ -2540,6 +2540,54 @@ mod tests {
         );
     }
 
+    #[test]
+    fn all_fast_plugin_variants_build_authored_f_templates() {
+        let app = create_app_dir(&[
+            (
+                "index.html",
+                "<named-card></named-card><fallback-card></fallback-card>",
+            ),
+            (
+                "file-card.html",
+                r#"<f-template name="named-card"><template><f-when value="{{visible}}"><f-repeat value="{{item in items}}"><button @click="{save()}">{{item.label}}</button></f-repeat></f-when></template></f-template>"#,
+            ),
+            ("file-card.css", "/* remove */ .card { color: red; }"),
+            (
+                "fallback-card.html",
+                r#"<f-template><template><span>{{label}}</span></template></f-template>"#,
+            ),
+        ]);
+
+        for plugin in [Plugin::Fast, Plugin::FastV2, Plugin::FastV3] {
+            let mut options = default_options(app.path());
+            options.plugin = Some(plugin);
+            options.css = CssStrategy::Style;
+
+            let result = build(options).unwrap();
+            assert!(result.protocol.fragments.contains_key("named-card"));
+            let component = result
+                .protocol
+                .components
+                .get("named-card")
+                .expect("named FAST component");
+            assert!(component.template.contains("<f-when"));
+            assert!(component.template.contains("<f-repeat"));
+            assert!(component.template.contains(r#"@click="{save()}""#));
+            assert!(component
+                .template
+                .contains("<style>.card { color: red; }</style>"));
+            let fallback = result
+                .protocol
+                .components
+                .get("fallback-card")
+                .expect("file-named FAST component");
+            assert!(fallback
+                .template
+                .contains(r#"<f-template name="fallback-card">"#));
+            assert!(fallback.template.contains("<span>{{label}}</span>"));
+        }
+    }
+
     #[test]
     fn test_build_to_disk_inline_mode_no_css_files() {
         let app = create_app_dir(&[
diff --git a/docs/guide/concepts/plugins/index.md b/docs/guide/concepts/plugins/index.md
index 86a7eed7..f27dbb4d 100644
--- a/docs/guide/concepts/plugins/index.md
+++ b/docs/guide/concepts/plugins/index.md
@@ -95,15 +95,16 @@ let handler = WebUIHandler::with_plugin(|| Box::new(WebUIHydrationPlugin::new())
 
 ### Using FAST Plugins
 
-The built-in FAST plugins are `fast`, `fast-v2`, and `fast-v3`:
+The Rust FAST integrations are `fast`, `fast_v2`, and `fast_v3`; their CLI
+names are `fast`, `fast-v2`, and `fast-v3`:
 
 ```bash
 webui build ./src --out ./dist --plugin=fast-v3
 webui serve ./src --state ./data/state.json --plugin=fast-v3 --watch
 ```
 
-For FAST builds, a component HTML file may be authored as one wrapping
-`<f-template>`:
+For FAST builds, component discovery automatically recognizes an HTML file
+authored as one wrapping `<f-template>`:
 
 ```html
 <!-- src/components/file-card.html -->
@@ -121,26 +122,35 @@ For FAST builds, a component HTML file may be authored as one wrapping
 ```
 
 `<f-template name="named-card">` registers the component as `named-card` instead
-of deriving `file-card` from the filename. If the `name` attribute is omitted,
-the filename-derived tag is used. Multiple `<f-template>` elements in one
-component source are unsupported and fail the build with an authoring error.
+of deriving `file-card` from the filename. If `name` is absent or contains only
+whitespace, WebUI keeps the filename-derived tag. The wrapper must contain
+exactly one inner `<template>`. Multiple inner templates and unsupported FAST
+syntax fail the build with an authoring error. Multiple `<f-template>` elements
+are not currently supported and have a dedicated authoring diagnostic.
 
 WebUI uses two views of this source:
 
-- **SSR parse view:** the inner FAST declarative template is converted to WebUI
-  syntax for build-time parsing. `<f-repeat value="{{item in items}}">` becomes
-  `<for each="item in items">`; `<f-when value="{{condition}}">` becomes
-  `<if condition="condition">`; directive values are unwrapped; client-only FAST
-  syntax that does not affect server-rendered output is removed, including
-  `@event`, `:prop`, `f-ref`, `f-slotted`, `f-children`, and similar
-  client-only directives. FAST plugins receive parser-only binding markers for
-  those stripped directives so hydration binding indexes remain aligned.
-- **Client artifact view:** the authored FAST template is preserved and emitted
-  as the client `<f-template>` payload. It still goes through normal component
-  processing and normalization, including wrapper handling and CSS injection for
-  the selected CSS strategy. Non-FAST plugins receive the normal WebUI parse
+- **SSR parse view:** WebUI adapts the source for `microsoft-fast-convert` with
+  the `webui-prerelease` target. When the authored name is absent or empty, the
+  adapter supplies a converter-only name without changing the filename-derived
+  component tag. The converter rewrites supported `f-repeat` and `f-when`
+  directives to WebUI `for` and `if` directives and unwraps their `value`
+  expressions. Text interpolation and boolean bindings remain for WebUI
+  parsing. Unsupported `f-*` constructs fail conversion instead of being
+  silently accepted. WebUI removes client-only `@event`, `:property`, `f-ref`,
+  `f-slotted`, and `f-children` attributes from this view. FAST plugins receive
+  parser-only binding markers for those removed attributes so hydration binding
+  indexes remain aligned.
+- **Client artifact view:** WebUI retains the authored inner template, including
+  its client bindings, and emits it inside the resolved `<f-template>` rather
+  than regenerating it from the SSR view. The artifact is normalized and still
+  receives normal wrapper handling, legal comment processing, and CSS injection
+  for the selected strategy. Non-FAST plugins receive the normal WebUI parse
   view instead of FAST artifacts.
 
+The deprecated `fast` selector aliases FAST 2. `fast`, `fast_v2`, and `fast_v3`
+all use this same discovery, conversion, and retained-artifact path.
+
 ## Writing Custom Plugins
 
 To create a custom plugin, implement the `ParserPlugin` and/or `HandlerPlugin` traits:

From 8ae68cfb10087f6709908e88c604c404046f9a8e Mon Sep 17 00:00:00 2001
From: Jane Chu <7559015+janechu@users.noreply.github.com>
Date: Mon, 27 Jul 2026 12:32:22 -0700
Subject: [PATCH 4/6] Isolate FAST source transforms in parser plugins

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: edae75de-6059-41a3-808d-0ec4b4c85b08
---
 DESIGN.md                                     |  66 ++--
 README.md                                     |   7 +-
 crates/webui-parser/src/component_registry.rs | 351 ++++++++++--------
 crates/webui-parser/src/diagnostic.rs         |   4 -
 .../webui-parser/src/fast_template_source.rs  | 245 ------------
 crates/webui-parser/src/lib.rs                | 257 +++++++++----
 crates/webui-parser/src/plugin/fast_shared.rs | 278 ++++++++++++++
 crates/webui-parser/src/plugin/fast_v2.rs     |  24 +-
 crates/webui-parser/src/plugin/fast_v3.rs     |  24 +-
 crates/webui-parser/src/plugin/mod.rs         |  71 +++-
 crates/webui/src/lib.rs                       |  13 +-
 docs/guide/concepts/plugins/index.md          |  30 +-
 12 files changed, 838 insertions(+), 532 deletions(-)
 delete mode 100644 crates/webui-parser/src/fast_template_source.rs
 create mode 100644 crates/webui-parser/src/plugin/fast_shared.rs

diff --git a/DESIGN.md b/DESIGN.md
index e37923f9..40566c08 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -1226,7 +1226,7 @@ pub trait ParserPlugin {
         component: &Component,
         processed_template: &str,
     ) -> Result<()>;
-    fn uses_fast_template_artifacts(&self) -> bool { false }
+    fn component_source_transform(&self) -> Option<ComponentSourceTransform> { None }
     fn classify_attribute(&mut self, attr_name: &str) -> AttributeAction;
     fn finish_element(&mut self, binding_attribute_count: u32) -> Option<Vec<u8>>;
     fn into_artifacts(self: Box<Self>) -> Result<ParserPluginArtifacts>;
@@ -1238,7 +1238,7 @@ pub trait ParserPlugin {
 - **Attribute loop**: `classify_attribute` decides whether framework-owned attrs are kept, skipped, or skipped-and-counted as bindings
 - **Element completion**: `finish_element` runs with the final binding count after all attrs are processed; returned bytes are emitted as a `Plugin` fragment
 - **Component registration**: `register_component_template` receives the plugin-facing component template HTML after HTML/CSS comment stripping. Authored root `<template>` attributes are preserved for plugins; the SSR/internal parse view may strip runtime-only attributes so rendered HTML stays clean. The component's client-ownership marker distinguishes authored from scriptless templates; Rust does not inspect JavaScript/TypeScript semantics.
-- **FAST artifact opt-in**: `uses_fast_template_artifacts` returns `true` only for FAST parser plugins. It enables authored `<f-template>` handling, parser-only binding markers for stripped FAST client directives, and preserved FAST client artifacts. Other plugins receive the normal WebUI parse view.
+- **Component-source transform**: `component_source_transform` returns an optional stateless function pointer, `for<'a> fn(ComponentSource<'a>) -> Result<ComponentSourceResult>`. The component registry calls it once per component — after reading the authored HTML but before name validation, duplicate checking, CSS processing, or insertion. `Unchanged` stores the filename-derived tag and HTML verbatim; `Transformed` may replace the registry key and supplies the HTML the WebUI parser consumes, plus an optional distinct source retained for the plugin's client artifact. The default returns `None`, so a component's filename-derived tag and HTML are stored unchanged and any plugin-specific markup in the source is inert. This is the sole extension point for a plugin that owns an alternate authored-template dialect; see "Built-in FAST parser plugins" below for the concrete FAST implementation.
 - **Artifact extraction**: `into_artifacts` returns post-parse outputs such as client component templates without `Any` downcasts. It is **fallible**: template-authoring mistakes found while compiling component templates (an invalid `@event` handler or a non-braced `w-ref`) surface as `ParserError::Template` instead of panicking, so every host (CLI, Node, FFI, WASM) can handle them.
 
 **Selecting parser plugins**
@@ -1255,23 +1255,33 @@ documentation for the current list. Each plugin defines:
 **Built-in FAST parser plugins**
 
 The `fast`, `fast_v2`, and `fast_v3` parser implementations (selected as
-`fast`, `fast-v2`, and `fast-v3` by CLI and host string APIs) all opt into the
-same FAST template artifact path. Component registration automatically scans
-discovered HTML sources for an `<f-template>`. A source that has one must contain
-exactly one `<f-template>` with exactly one inner `<template>`. A present,
-non-empty `name` becomes the registered component tag and overrides the
-filename-derived tag. If `name` is absent or trims to empty, registration keeps
-the filename-derived tag. Multiple `<f-template>` elements return
-`unsupported-multiple-f-templates`; multiple inner `<template>` elements are
-also invalid. Sources without an `<f-template>` retain the normal component
+`fast`, `fast-v2`, and `fast-v3` by CLI and host string APIs) share one
+`component_source_transform` implementation. Only when one of these plugins is
+selected does the component registry run that transform for each component,
+after reading the authored HTML but before name validation, duplicate
+checking, CSS processing, or insertion. With no plugin, or with any other
+plugin (including `webui`) that returns `None` from
+`component_source_transform`, the registry never scans for or interprets
+`<f-template>` syntax — an `<f-template>`-shaped source passes through
+unchanged, exactly like any other component.
+
+The shared FAST transform scans the authored source for an `<f-template>`. A
+source that has one must contain exactly one `<f-template>` with exactly one
+inner `<template>`. A present, non-empty `name` becomes the registered
+component tag and overrides the filename-derived tag. If `name` is absent or
+trims to empty, registration keeps the filename-derived tag. Multiple
+`<f-template>` elements return `unsupported-multiple-f-templates`; multiple
+inner `<template>` elements are also invalid. Sources without an `<f-template>`
+return `ComponentSourceResult::Unchanged` and follow the normal component
 template path.
 
-For build-time SSR parsing, WebUI adapts the `<f-template>` source for
+For build-time SSR parsing, the transform adapts the `<f-template>` source for
 `microsoft-fast-convert` with the `webui-prerelease` target. Because the
 converter requires a non-empty name, the adapter supplies an internal name only
 to the converter when the source name is absent or empty. This internal value
 does not replace the filename-derived component tag or appear in the emitted
-client artifact. The returned inner template becomes the WebUI parse view:
+client artifact. The returned inner template becomes the parser view returned
+as `TransformedComponentSource::parser_content`:
 
 - `<f-repeat value="{{item in items}}">` converts to
   `<for each="item in items">`.
@@ -1284,22 +1294,22 @@ client artifact. The returned inner template becomes the WebUI parse view:
 - Unsupported `f-*` elements or attributes and malformed directive expressions
   return structured authoring diagnostics. WebUI does not claim support for
   FAST constructs that the converter rejects.
-- After conversion, WebUI removes `@event`, `:property`, `f-ref`, `f-slotted`,
-  and `f-children` from the public SSR view because they are client-only. A
-  parser-only view replaces each removed binding with an internal marker so the
-  FAST plugin still emits the correct hydration binding count. Markers never
-  appear in public component HTML or plugin artifacts.
-
-WebUI separately retains the authored inner `<template>` from the source for the
-FAST client artifact, including its client-only bindings, rather than rebuilding
-it from the converted SSR view. The FAST plugin wraps that retained source in
-the resolved `<f-template name="...">` for insertion. The artifact is normalized
-rather than preserved byte-for-byte: it passes through normal component
-template processing, including wrapper normalization, selected CSS-strategy
-injection, module stylesheet adoption where applicable, legal-comment handling,
-and plugin artifact normalization. The deprecated `fast` selector aliases the
+- The FAST plugins' `classify_attribute` skips `@event`, `:property`, `f-ref`,
+  `f-slotted`, and `f-children` and counts each as a binding, so they are
+  absent from the SSR view while the hydration binding count still reflects
+  them. No parser-core marker or FAST-named branch is involved.
+
+The transform separately returns the authored inner `<template>` as
+`TransformedComponentSource::artifact_content`, including its client-only
+bindings, rather than deriving it from the converted parser view. The FAST
+plugin wraps that retained source in the resolved `<f-template name="...">`
+for insertion. The artifact is normalized rather than preserved byte-for-byte:
+it passes through the same generic component-template processing as any other
+component, including wrapper normalization, selected CSS-strategy injection,
+module stylesheet adoption where applicable, legal-comment handling, and
+plugin artifact normalization. The deprecated `fast` selector aliases the
 FAST 2 implementation, while `fast_v2` and `fast_v3` use their respective
-hydration marker formats; all three share this discovery, conversion, and
+hydration marker formats; all three share this transform, conversion, and
 artifact-retention behavior.
 
 WebUI itself does not interpret plugin-emitted bytes; each parser plugin pairs with
diff --git a/README.md b/README.md
index b611d598..4d9916c5 100644
--- a/README.md
+++ b/README.md
@@ -14,8 +14,11 @@
 
 ## FAST plugin authored templates
 
-The `fast`, `fast_v2`, and `fast_v3` integrations (CLI names `fast`, `fast-v2`,
-and `fast-v3`) automatically detect component HTML authored as a single
+WebUI's parser is framework-neutral by default: with no plugin selected, or
+with the `webui` plugin, `<f-template>` markup is not scanned or interpreted
+and passes through like any other HTML. Selecting the `fast`, `fast_v2`, or
+`fast_v3` integration (CLI names `fast`, `fast-v2`, and `fast-v3`) installs a
+shared plugin hook that detects component HTML authored as a single
 `<f-template>`. A non-empty `name` replaces the component tag derived from the
 filename; an absent or whitespace-only name keeps the filename-derived tag. The
 wrapper must contain exactly one inner `<template>`. Unsupported FAST syntax and
diff --git a/crates/webui-parser/src/component_registry.rs b/crates/webui-parser/src/component_registry.rs
index a0362ef4..d757c9ea 100644
--- a/crates/webui-parser/src/component_registry.rs
+++ b/crates/webui-parser/src/component_registry.rs
@@ -6,7 +6,7 @@
 //! This module manages the registry of web components used in the application.
 
 use crate::component_policy::{parse_component_render_policy, ComponentRenderPolicy};
-use crate::fast_template_source::prepare_component_template;
+use crate::plugin::{ComponentSource, ComponentSourceResult, ComponentSourceTransform};
 use crate::{CssFallbackChain, CssParser, LegalComments, ParserError, Result};
 use std::collections::HashMap;
 #[cfg(feature = "fs")]
@@ -18,6 +18,16 @@ use walkdir::WalkDir;
 
 type ProcessedCss = (String, Vec<String>, Vec<CssFallbackChain>);
 
+/// Resolved component source produced by [`ComponentRegistry::resolve_component_source`].
+struct ResolvedSource {
+    /// Resolved registry key.
+    tag_name: String,
+    /// Content stored on the component and consumed by the SSR parser.
+    parser_content: String,
+    /// Optional retained authored client artifact source.
+    artifact_content: Option<String>,
+}
+
 /// Represents a web component in the registry.
 ///
 /// ```
@@ -95,10 +105,13 @@ pub struct ComponentRegistry {
     components: HashMap<String, Component>,
     /// Compiler-owned rendering policies kept outside the public component API.
     render_policies: HashMap<String, ComponentRenderPolicy>,
-    /// FAST-authored templates with parser-only binding markers.
-    plugin_parse_templates: HashMap<String, String>,
-    /// FAST-authored templates preserved for client artifact emission.
-    plugin_template_artifacts: HashMap<String, String>,
+    /// Authored client artifact sources retained by a component-source
+    /// transform, keyed by resolved tag name. Framework-neutral: any plugin
+    /// that owns a distinct client template populates it.
+    component_artifact_sources: HashMap<String, String>,
+    /// Optional plugin-supplied transform applied to each component's authored
+    /// source before insertion. `None` stores sources unchanged.
+    source_transform: Option<ComponentSourceTransform>,
     /// Reusable CSS parser for token extraction during registration.
     css_parser: CssParser,
     /// Legal comment preservation policy for component CSS.
@@ -143,13 +156,55 @@ impl ComponentRegistry {
         Self {
             components: HashMap::new(),
             render_policies: HashMap::new(),
-            plugin_parse_templates: HashMap::new(),
-            plugin_template_artifacts: HashMap::new(),
+            component_artifact_sources: HashMap::new(),
+            source_transform: None,
             css_parser: CssParser::new(),
             legal_comments,
         }
     }
 
+    /// Install the component-source transform supplied by the active plugin.
+    ///
+    /// Passing `None` (the default) stores authored sources verbatim, so
+    /// framework-specific markup is inert.
+    pub(crate) fn set_component_source_transform(
+        &mut self,
+        transform: Option<ComponentSourceTransform>,
+    ) {
+        self.source_transform = transform;
+    }
+
+    /// Apply the installed source transform, returning the resolved registry
+    /// key, the parser-facing content, and any retained client artifact source.
+    ///
+    /// When no transform is installed, or it returns
+    /// [`ComponentSourceResult::Unchanged`], the filename-derived tag and the
+    /// authored HTML are preserved without extra allocation.
+    fn resolve_component_source(
+        &self,
+        tag_name: &str,
+        html_content: String,
+    ) -> Result<ResolvedSource> {
+        if let Some(transform) = self.source_transform {
+            if let ComponentSourceResult::Transformed(transformed) = transform(ComponentSource {
+                tag_name,
+                html_content: &html_content,
+            })? {
+                return Ok(ResolvedSource {
+                    tag_name: transformed.tag_name,
+                    parser_content: transformed.parser_content,
+                    artifact_content: transformed.artifact_content,
+                });
+            }
+        }
+
+        Ok(ResolvedSource {
+            tag_name: tag_name.to_string(),
+            parser_content: html_content,
+            artifact_content: None,
+        })
+    }
+
     /// Register multiple components from directories recursively.
     #[cfg(feature = "fs")]
     pub fn register_from_paths<P: AsRef<Path>>(&mut self, directories: &[P]) -> Result<&mut Self> {
@@ -206,14 +261,14 @@ impl ComponentRegistry {
             context: format!("Failed to read HTML file: {}", html_path.display()),
             source,
         })?;
-        let prepared = prepare_component_template(tag_name, &html_content)?;
-        Self::validate_component_name(&prepared.tag_name)?;
+        let resolved = self.resolve_component_source(tag_name, html_content)?;
+        Self::validate_component_name(&resolved.tag_name)?;
 
         // Check for duplicate component
-        if self.components.contains_key(&prepared.tag_name) {
+        if self.components.contains_key(&resolved.tag_name) {
             return Err(ParserError::Component(format!(
                 "Component '{}' is already registered",
-                prepared.tag_name
+                resolved.tag_name
             )));
         }
 
@@ -239,17 +294,17 @@ impl ComponentRegistry {
         let is_client_owned = has_component_script(html_path)?;
 
         let render_policy =
-            parse_component_render_policy(&prepared.tag_name, &prepared.html_content)?;
+            parse_component_render_policy(&resolved.tag_name, &resolved.parser_content)?;
         Self::append_scoped_policy_css(
             &mut css_content,
             &render_policy,
-            &prepared.tag_name,
+            &resolved.tag_name,
         );
 
         // Create and register the component
         let component = Component {
-            tag_name: prepared.tag_name,
-            html_content: prepared.html_content,
+            tag_name: resolved.tag_name,
+            html_content: resolved.parser_content,
             css_content,
             css_definitions,
             css_fallback_chains,
@@ -258,13 +313,9 @@ impl ComponentRegistry {
 
         self.render_policies
             .insert(component.tag_name.clone(), render_policy);
-        if let Some(template) = prepared.plugin_parse_content {
-            self.plugin_parse_templates
-                .insert(component.tag_name.clone(), template);
-        }
-        if let Some(template) = prepared.plugin_template_content {
-            self.plugin_template_artifacts
-                .insert(component.tag_name.clone(), template);
+        if let Some(artifact) = resolved.artifact_content {
+            self.component_artifact_sources
+                .insert(component.tag_name.clone(), artifact);
         }
         self.components
             .insert(component.tag_name.clone(), component);
@@ -283,14 +334,14 @@ impl ComponentRegistry {
             is_client_owned,
         } = registration;
 
-        let prepared = prepare_component_template(tag_name, html_content)?;
-        Self::validate_component_name(&prepared.tag_name)?;
+        let resolved = self.resolve_component_source(tag_name, html_content.to_string())?;
+        Self::validate_component_name(&resolved.tag_name)?;
 
         // Check for duplicate component
-        if self.components.contains_key(&prepared.tag_name) {
+        if self.components.contains_key(&resolved.tag_name) {
             return Err(ParserError::Component(format!(
                 "Component '{}' is already registered",
-                prepared.tag_name
+                resolved.tag_name
             )));
         }
 
@@ -304,15 +355,15 @@ impl ComponentRegistry {
         };
 
         let render_policy =
-            parse_component_render_policy(&prepared.tag_name, &prepared.html_content)?;
+            parse_component_render_policy(&resolved.tag_name, &resolved.parser_content)?;
         Self::append_scoped_policy_css(
             &mut css_content,
             &render_policy,
-            &prepared.tag_name,
+            &resolved.tag_name,
         );
         let component: Component = Component {
-            tag_name: prepared.tag_name,
-            html_content: prepared.html_content,
+            tag_name: resolved.tag_name,
+            html_content: resolved.parser_content,
             css_content,
             css_definitions,
             css_fallback_chains,
@@ -322,13 +373,9 @@ impl ComponentRegistry {
         // Register the component
         self.render_policies
             .insert(component.tag_name.clone(), render_policy);
-        if let Some(template) = prepared.plugin_parse_content {
-            self.plugin_parse_templates
-                .insert(component.tag_name.clone(), template);
-        }
-        if let Some(template) = prepared.plugin_template_content {
-            self.plugin_template_artifacts
-                .insert(component.tag_name.clone(), template);
+        if let Some(artifact) = resolved.artifact_content {
+            self.component_artifact_sources
+                .insert(component.tag_name.clone(), artifact);
         }
         self.components
             .insert(component.tag_name.clone(), component);
@@ -346,9 +393,6 @@ impl ComponentRegistry {
         )))
     }
 
-    pub(crate) const INTERNAL_FAST_BINDING_ATTR: &str =
-        crate::fast_template_source::INTERNAL_FAST_BINDING_ATTR;
-
     /// Strip comments and extract CSS definitions/fallback requirements.
     fn process_css_content(&mut self, css_content: &str) -> Result<ProcessedCss> {
         let (_tokens, definitions, requirements, stripped) = self
@@ -387,25 +431,12 @@ impl ComponentRegistry {
         self.components.get(tag_name)
     }
 
-    /// Get the parser-facing HTML for a component.
-    pub(crate) fn html_content_for_parse(
-        &self,
-        tag_name: &str,
-        include_fast_binding_markers: bool,
-    ) -> Option<&str> {
-        if include_fast_binding_markers {
-            if let Some(template) = self.plugin_parse_templates.get(tag_name) {
-                return Some(template);
-            }
-        }
-        self.components
-            .get(tag_name)
-            .map(|component| component.html_content.as_str())
-    }
-
-    /// Get the plugin-facing authored client template artifact for a component.
-    pub(crate) fn plugin_template_artifact(&self, tag_name: &str) -> Option<&str> {
-        self.plugin_template_artifacts
+    /// Get the retained authored client artifact source for a component.
+    ///
+    /// Populated only when a component-source transform returned a distinct
+    /// artifact view; otherwise `None`.
+    pub(crate) fn component_artifact_source(&self, tag_name: &str) -> Option<&str> {
+        self.component_artifact_sources
             .get(tag_name)
             .map(String::as_str)
     }
@@ -498,6 +529,7 @@ impl ComponentRegistry {
 mod tests {
     use super::*;
     use crate::codes;
+    use crate::plugin::TransformedComponentSource;
     use webui_test_utils::TestFileSystem;
 
     #[test]
@@ -525,6 +557,33 @@ mod tests {
         assert!(!component.is_client_owned);
     }
 
+    #[test]
+    #[cfg(feature = "fs")]
+    fn transform_applies_to_path_registration() {
+        let mut fs = TestFileSystem::new();
+        let html_path = fs.add_file(
+            "components/file-card.html",
+            r#"<mock-template name="renamed-card"><template>x</template></mock-template>"#,
+        );
+
+        let mut registry = ComponentRegistry::new();
+        registry.set_component_source_transform(Some(mock_rename_transform));
+        registry
+            .register_component_from_paths(&html_path, None::<&str>)
+            .expect("register");
+
+        assert!(!registry.contains("file-card"));
+        let component = registry.get("renamed-card").expect("component");
+        assert_eq!(
+            component.html_content,
+            "<template><span>parser</span></template>"
+        );
+        assert_eq!(
+            registry.component_artifact_source("renamed-card"),
+            Some("<template><span>artifact</span></template>")
+        );
+    }
+
     #[test]
     fn test_register_component_detects_ts_sibling_script() {
         let mut fs = TestFileSystem::new();
@@ -884,137 +943,131 @@ mod tests {
         assert_eq!(component.html_content, html_content1);
     }
 
+    fn mock_rename_transform(source: ComponentSource<'_>) -> Result<ComponentSourceResult> {
+        if !source.html_content.contains("<mock-template") {
+            return Ok(ComponentSourceResult::Unchanged);
+        }
+        Ok(ComponentSourceResult::Transformed(
+            TransformedComponentSource {
+                tag_name: "renamed-card".to_string(),
+                parser_content: "<template><span>parser</span></template>".to_string(),
+                artifact_content: Some("<template><span>artifact</span></template>".to_string()),
+            },
+        ))
+    }
+
+    fn mock_failing_transform(_source: ComponentSource<'_>) -> Result<ComponentSourceResult> {
+        Err(ParserError::Component("mock transform failure".to_string()))
+    }
+
     #[test]
-    fn f_template_name_overrides_file_name_and_converts_for_webui() {
-        let html = r#"<f-template name="named-card"><template><f-when value="{{visible && count > 0}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" ?disabled="{{disabled}}" f-ref="{button}" title="{{title}}">{{item.label}}</button></f-repeat></f-when></template></f-template>"#;
+    fn default_registry_leaves_authored_source_unchanged() {
+        // Without an installed transform, framework-shaped markup is inert:
+        // no renaming, conversion, or extra artifact source.
+        let html = r#"<mock-template name="renamed-card"><template>x</template></mock-template>"#;
+        let mut registry = ComponentRegistry::new();
+        registry
+            .register_component(ComponentRegistration::new("file-card", html, None, true))
+            .expect("register");
 
+        assert!(registry.contains("file-card"));
+        assert!(!registry.contains("renamed-card"));
+        assert_eq!(
+            registry
+                .get("file-card")
+                .map(|component| component.html_content.as_str()),
+            Some(html)
+        );
+        assert_eq!(registry.component_artifact_source("file-card"), None);
+    }
+
+    #[test]
+    fn transform_renames_and_provides_parser_and_artifact_views() {
         let mut registry = ComponentRegistry::new();
+        registry.set_component_source_transform(Some(mock_rename_transform));
         registry
             .register_component(ComponentRegistration::new(
                 "file-card",
-                html,
+                r#"<mock-template name="renamed-card"><template>x</template></mock-template>"#,
                 Some(".root { color: red; }"),
                 true,
             ))
             .expect("register");
 
         assert!(!registry.contains("file-card"));
-        assert!(registry.contains("named-card"));
-
-        let component = registry.get("named-card").expect("component");
-        assert_eq!(component.tag_name, "named-card");
+        let component = registry.get("renamed-card").expect("component");
+        assert_eq!(component.tag_name, "renamed-card");
         assert_eq!(
             component.html_content,
-            r#"<template><if condition="visible && count > 0"><for each="item in items"><button ?disabled="{{disabled}}" title="{{title}}">{{item.label}}</button></for></if></template>"#
-        );
-        let parse_content = registry
-            .html_content_for_parse("named-card", true)
-            .expect("parse content");
-        assert!(parse_content.contains(ComponentRegistry::INTERNAL_FAST_BINDING_ATTR));
-        assert_eq!(
-            parse_content
-                .match_indices(ComponentRegistry::INTERNAL_FAST_BINDING_ATTR)
-                .count(),
-            3
+            "<template><span>parser</span></template>"
         );
-        assert!(parse_content.contains(r#"?disabled="{{disabled}}""#));
-        assert!(!component
-            .html_content
-            .contains(ComponentRegistry::INTERNAL_FAST_BINDING_ATTR));
         assert_eq!(
-            registry.plugin_template_artifact("named-card"),
-            Some(
-                r#"<template><f-when value="{{visible && count > 0}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" ?disabled="{{disabled}}" f-ref="{button}" title="{{title}}">{{item.label}}</button></f-repeat></f-when></template>"#
-            )
+            registry.component_artifact_source("renamed-card"),
+            Some("<template><span>artifact</span></template>")
         );
     }
 
     #[test]
-    fn multiple_f_templates_are_not_supported() {
+    fn transform_returning_unchanged_preserves_source() {
         let mut registry = ComponentRegistry::new();
-        let err = registry
-            .register_component(ComponentRegistration::new(
-                "multi-card",
-                r#"<f-template name="one"><template></template></f-template><f-template name="two"><template></template></f-template>"#,
-                None,
-                true,
-            ))
-            .expect_err("multiple f-template blocks should error");
+        registry.set_component_source_transform(Some(mock_rename_transform));
+        let html = r#"<template><span>{{title}}</span></template>"#;
+        registry
+            .register_component(ComponentRegistration::new("plain-card", html, None, true))
+            .expect("register");
 
-        let ParserError::Template(diag) = err else {
-            panic!("expected template diagnostic");
-        };
+        assert!(registry.contains("plain-card"));
         assert_eq!(
-            diag.error_code(),
-            Some(codes::UNSUPPORTED_MULTIPLE_F_TEMPLATES)
+            registry
+                .get("plain-card")
+                .map(|component| component.html_content.as_str()),
+            Some(html)
         );
-        assert!(diag.to_string().contains("not currently supported"));
+        assert_eq!(registry.component_artifact_source("plain-card"), None);
     }
 
     #[test]
-    fn invalid_f_template_converter_error_is_a_diagnostic() {
+    fn transform_error_is_transactional() {
         let mut registry = ComponentRegistry::new();
+        registry.set_component_source_transform(Some(mock_failing_transform));
         let err = registry
             .register_component(ComponentRegistration::new(
-                "invalid-card",
-                r#"<f-template name="invalid-card"><template><f-repeat value="{{items}}"></f-repeat></template></f-template>"#,
+                "file-card",
+                "<template>x</template>",
                 None,
                 true,
             ))
-            .expect_err("invalid repeat should error");
+            .expect_err("failing transform should abort registration");
 
-        let ParserError::Template(diag) = err else {
-            panic!("expected template diagnostic");
-        };
-        assert_eq!(diag.error_code(), Some(codes::INVALID_FAST_TEMPLATE));
-        assert!(diag.to_string().contains("item in items"));
-        assert!(diag.help_text().is_some());
-    }
-
-    #[test]
-    fn f_template_without_usable_name_uses_file_name() {
-        for html in [
-            "<f-template><template></template></f-template>",
-            r#"<f-template name=" "><template></template></f-template>"#,
-        ] {
-            let mut registry = ComponentRegistry::new();
-            registry
-                .register_component(ComponentRegistration::new("file-card", html, None, true))
-                .expect("file-derived name should satisfy the converter");
-
-            assert!(registry.contains("file-card"));
-            assert_eq!(
-                registry
-                    .get("file-card")
-                    .map(|component| component.html_content.as_str()),
-                Some("<template></template>")
-            );
-            assert_eq!(
-                registry.plugin_template_artifact("file-card"),
-                Some("<template></template>")
-            );
-        }
+        assert!(matches!(err, ParserError::Component(ref msg) if msg.contains("mock transform")));
+        assert!(!registry.contains("file-card"));
+        assert!(registry.is_empty());
     }
 
     #[test]
-    fn plain_webui_template_uses_unchanged_fallback() {
-        let html = r#"<template><if condition="visible"><span>{{title}}</span></if></template>"#;
+    fn transform_duplicate_resolved_name_is_rejected() {
         let mut registry = ComponentRegistry::new();
+        registry.set_component_source_transform(Some(mock_rename_transform));
         registry
-            .register_component(ComponentRegistration::new("plain-card", html, None, true))
-            .expect("register");
+            .register_component(ComponentRegistration::new(
+                "first-card",
+                r#"<mock-template name="renamed-card"><template>x</template></mock-template>"#,
+                None,
+                true,
+            ))
+            .expect("first register");
+        let err = registry
+            .register_component(ComponentRegistration::new(
+                "second-card",
+                r#"<mock-template name="renamed-card"><template>y</template></mock-template>"#,
+                None,
+                true,
+            ))
+            .expect_err("duplicate resolved name should error");
 
-        assert_eq!(
-            registry
-                .get("plain-card")
-                .map(|component| component.html_content.as_str()),
-            Some(html)
-        );
-        assert_eq!(
-            registry.html_content_for_parse("plain-card", true),
-            Some(html)
+        assert!(
+            matches!(err, ParserError::Component(ref msg) if msg.contains("already registered"))
         );
-        assert_eq!(registry.plugin_template_artifact("plain-card"), None);
     }
 
     #[test]
diff --git a/crates/webui-parser/src/diagnostic.rs b/crates/webui-parser/src/diagnostic.rs
index 9cc34ac8..10e2224d 100644
--- a/crates/webui-parser/src/diagnostic.rs
+++ b/crates/webui-parser/src/diagnostic.rs
@@ -102,10 +102,6 @@ pub mod codes {
     /// A CSS token used only with a literal `var()` fallback and absent from
     /// every theme — non-fatal, but usually a typo. Severity: warning.
     pub const UNTHEMED_TOKEN: &str = "unthemed-token";
-    /// A component source contains multiple `<f-template>` blocks.
-    pub const UNSUPPORTED_MULTIPLE_F_TEMPLATES: &str = "unsupported-multiple-f-templates";
-    /// A FAST declarative template cannot be converted to WebUI syntax.
-    pub const INVALID_FAST_TEMPLATE: &str = "invalid-fast-template";
     /// `<boundary>` is missing its required, non-empty `name` attribute.
     pub const MISSING_BOUNDARY_NAME: &str = "missing-boundary-name";
     /// `<boundary name>` is not a static string literal (e.g. it
diff --git a/crates/webui-parser/src/fast_template_source.rs b/crates/webui-parser/src/fast_template_source.rs
deleted file mode 100644
index 2da8e613..00000000
--- a/crates/webui-parser/src/fast_template_source.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-use crate::diagnostic::{codes, Diagnostic};
-use crate::html_parser::{self as html, Event, Walker};
-use crate::{ParserError, Result};
-use microsoft_fast_convert::{convert_template, ConvertError};
-use std::borrow::Cow;
-use std::ops::Range;
-
-pub(crate) const INTERNAL_FAST_BINDING_ATTR: &str = "data-webui-internal-fast-binding";
-const CONVERTER_FALLBACK_NAME: &str = "webui-fallback";
-const WEBUI_CONVERTER_SYNTAX: &str = "webui-prerelease";
-
-pub(crate) struct PreparedComponentTemplate {
-    pub(crate) tag_name: String,
-    pub(crate) html_content: String,
-    pub(crate) plugin_parse_content: Option<String>,
-    pub(crate) plugin_template_content: Option<String>,
-}
-
-struct FTemplateSource {
-    name: Option<String>,
-    start: usize,
-    inner: Range<usize>,
-}
-
-pub(crate) fn prepare_component_template(
-    tag_name: &str,
-    html_content: &str,
-) -> Result<PreparedComponentTemplate> {
-    let Some(source) = find_f_template_source(html_content) else {
-        return Ok(PreparedComponentTemplate {
-            tag_name: tag_name.to_string(),
-            html_content: html_content.to_string(),
-            plugin_parse_content: None,
-            plugin_template_content: None,
-        });
-    };
-
-    let resolved_tag = source.name.as_deref().unwrap_or(tag_name).to_string();
-    let converter_input = converter_input(html_content, &source);
-    let converted = convert_template(&converter_input, WEBUI_CONVERTER_SYNTAX)
-        .map_err(|error| converter_error(html_content, source.start, error))?;
-    let template_content = html_content[source.inner].trim();
-    let html_content = strip_fast_client_attributes(&converted, false);
-    let plugin_parse_content = strip_fast_client_attributes(&converted, true);
-    let plugin_parse_content =
-        (plugin_parse_content != html_content).then_some(plugin_parse_content);
-    Ok(PreparedComponentTemplate {
-        tag_name: resolved_tag,
-        html_content,
-        plugin_parse_content,
-        plugin_template_content: Some(template_content.to_string()),
-    })
-}
-
-fn find_f_template_source(html_content: &str) -> Option<FTemplateSource> {
-    let mut stack = Vec::with_capacity(1);
-    stack.push(0..html_content.len());
-
-    while let Some(range) = stack.pop() {
-        for event in Walker::new_range(html_content, range.start, range.end) {
-            let Event::Element(element) = event else {
-                continue;
-            };
-
-            if element.name().eq_ignore_ascii_case("f-template") {
-                return Some(FTemplateSource {
-                    name: element
-                        .attr("name")
-                        .map(str::trim)
-                        .filter(|name| !name.is_empty())
-                        .map(str::to_string),
-                    start: element.start,
-                    inner: element.inner(),
-                });
-            }
-
-            if !element.self_closing() && !element.is_void() {
-                stack.push(element.inner());
-            }
-        }
-    }
-
-    None
-}
-
-fn converter_input<'a>(html_content: &'a str, source: &FTemplateSource) -> Cow<'a, str> {
-    if source.name.is_some() {
-        return Cow::Borrowed(html_content);
-    }
-
-    let mut normalized =
-        String::with_capacity(html_content.len() + CONVERTER_FALLBACK_NAME.len() + 20);
-    normalized.push_str(&html_content[..source.start]);
-    normalized.push_str("<f-template name=\"");
-    normalized.push_str(CONVERTER_FALLBACK_NAME);
-    normalized.push_str("\">");
-    normalized.push_str(&html_content[source.inner.start..]);
-    Cow::Owned(normalized)
-}
-
-#[cold]
-#[inline(never)]
-fn converter_error(source: &str, offset: usize, error: ConvertError) -> ParserError {
-    if matches!(error, ConvertError::MultipleFTemplates { .. }) {
-        return Diagnostic::error("multiple <f-template> elements are not supported")
-            .code(codes::UNSUPPORTED_MULTIPLE_F_TEMPLATES)
-            .at_offset(source, offset)
-            .snippet("<f-template>")
-            .help(
-                "keep only one <f-template> per component file; multiple f-template blocks are not currently supported",
-            )
-            .into();
-    }
-
-    let help = match &error {
-        ConvertError::MissingFTemplateName | ConvertError::EmptyFTemplateName => {
-            "add a non-empty name attribute to <f-template>, for example <f-template name=\"my-component\">"
-        }
-        ConvertError::MissingInnerTemplate | ConvertError::MultipleInnerTemplates { .. } => {
-            "keep exactly one inner <template> element inside <f-template>"
-        }
-        ConvertError::MissingValueAttribute { .. }
-        | ConvertError::InvalidDirectiveValue { .. } => {
-            "add the required value=\"{{expression}}\" attribute to the FAST directive"
-        }
-        ConvertError::InvalidRepeatExpression { .. } => {
-            "use an f-repeat expression in \"item in items\" form"
-        }
-        ConvertError::UnclosedElement { .. } | ConvertError::UnclosedTag { .. } => {
-            "close the reported FAST template element or opening tag"
-        }
-        ConvertError::UnsupportedFAttribute { .. }
-        | ConvertError::UnsupportedFElement { .. } => {
-            "remove the unsupported FAST construct or replace it with supported declarative syntax"
-        }
-        _ => "fix the reported FAST declarative template syntax",
-    };
-
-    let code = if matches!(
-        error,
-        ConvertError::UnclosedElement { .. } | ConvertError::UnclosedTag { .. }
-    ) {
-        codes::UNCLOSED_HTML_TAG
-    } else {
-        codes::INVALID_FAST_TEMPLATE
-    };
-
-    Diagnostic::error(format!("invalid FAST template: {error}"))
-        .code(code)
-        .at_offset(source, offset)
-        .snippet("<f-template>")
-        .help(help)
-        .into()
-}
-
-fn strip_fast_client_attributes(input: &str, include_binding_markers: bool) -> String {
-    let mut result = String::with_capacity(input.len());
-    let bytes = input.as_bytes();
-    let len = bytes.len();
-    let mut index = 0usize;
-
-    while index < len {
-        if bytes[index] == b'<' {
-            if let Some(consumed) =
-                try_strip_fast_attributes(input, index, &mut result, include_binding_markers)
-            {
-                index += consumed;
-                continue;
-            }
-        }
-        index = push_char_at(input, index, &mut result);
-    }
-
-    result
-}
-
-fn try_strip_fast_attributes(
-    input: &str,
-    pos: usize,
-    result: &mut String,
-    include_binding_markers: bool,
-) -> Option<usize> {
-    let remaining = &input[pos..];
-    let tag = html::parse_tag(remaining)?;
-
-    if tag.closing {
-        return None;
-    }
-
-    if !tag.attrs().any(|attr| is_fast_client_only_attr(attr.name)) {
-        return None;
-    }
-
-    push_webui_opening_tag(&tag, result, include_binding_markers);
-    Some(tag.close + 1)
-}
-
-fn push_webui_opening_tag(tag: &html::Tag<'_>, result: &mut String, include_binding_markers: bool) {
-    result.push('<');
-    result.push_str(tag.name);
-    let mut stripped_binding_count = 0usize;
-    for attr in tag.attrs() {
-        if is_fast_client_only_attr(attr.name) {
-            stripped_binding_count += 1;
-            continue;
-        }
-        result.push(' ');
-        result.push_str(attr.raw);
-    }
-    if include_binding_markers {
-        for _ in 0..stripped_binding_count {
-            result.push(' ');
-            result.push_str(INTERNAL_FAST_BINDING_ATTR);
-        }
-    }
-    if tag.self_closing {
-        result.push_str(" />");
-    } else {
-        result.push('>');
-    }
-}
-
-fn is_fast_client_only_attr(name: &str) -> bool {
-    name.starts_with('@')
-        || name.starts_with(':')
-        || matches!(name, "f-ref" | "f-slotted" | "f-children")
-}
-
-fn push_char_at(input: &str, pos: usize, out: &mut String) -> usize {
-    let bytes = input.as_bytes();
-    if bytes[pos].is_ascii() {
-        out.push(bytes[pos] as char);
-        pos + 1
-    } else {
-        let mut end = pos + 1;
-        while end < bytes.len() && !input.is_char_boundary(end) {
-            end += 1;
-        }
-        out.push_str(&input[pos..end]);
-        end
-    }
-}
diff --git a/crates/webui-parser/src/lib.rs b/crates/webui-parser/src/lib.rs
index 54ddde93..4a1cc5c5 100644
--- a/crates/webui-parser/src/lib.rs
+++ b/crates/webui-parser/src/lib.rs
@@ -13,7 +13,6 @@ mod css_link;
 mod css_parser;
 mod diagnostic;
 mod error;
-mod fast_template_source;
 mod handlebars_parser;
 mod html_parser;
 pub mod plugin;
@@ -615,7 +614,7 @@ impl BuiltComponentTemplate {
 struct ComponentTemplateInput<'a> {
     tag_name: &'a str,
     html: &'a str,
-    plugin_html: Option<&'a str>,
+    artifact_html: Option<&'a str>,
     css_content: Option<&'a str>,
     artifact_needed: bool,
 }
@@ -936,6 +935,8 @@ impl HtmlParser {
         options: impl Into<ParserOptions>,
     ) -> Self {
         let mut p = Self::with_options(options);
+        p.component_registry
+            .set_component_source_transform(plugin.component_source_transform());
         p.plugin = Some(plugin);
         p.configure_plugin();
         p
@@ -947,12 +948,6 @@ impl HtmlParser {
         }
     }
 
-    fn uses_fast_template_artifacts(&self) -> bool {
-        self.plugin
-            .as_ref()
-            .is_some_and(|plugin| plugin.uses_fast_template_artifacts())
-    }
-
     /// Get a mutable reference to the component registry.
     pub fn component_registry_mut(&mut self) -> &mut ComponentRegistry {
         &mut self.component_registry
@@ -2367,7 +2362,6 @@ impl HtmlParser {
         self.flush_raw_buffer(fragments);
 
         if !self.fragment_records.contains_key(element.name()) {
-            let uses_fast_template_artifacts = self.uses_fast_template_artifacts();
             let component_data = self
                 .component_registry
                 .get(element.name())
@@ -2380,22 +2374,14 @@ impl HtmlParser {
                     .help(self.unknown_component_help(element.name()))
                 })?
                 .clone();
-            let html_content = self
+            let artifact_html = self
                 .component_registry
-                .html_content_for_parse(element.name(), uses_fast_template_artifacts)
-                .unwrap_or(&component_data.html_content)
-                .to_string();
-            let plugin_template_artifact = if uses_fast_template_artifacts {
-                self.component_registry
-                    .plugin_template_artifact(element.name())
-                    .map(str::to_string)
-            } else {
-                None
-            };
+                .component_artifact_source(element.name())
+                .map(str::to_string);
             let built = self.build_component_templates(ComponentTemplateInput {
                 tag_name: element.name(),
-                html: &html_content,
-                plugin_html: plugin_template_artifact.as_deref(),
+                html: &component_data.html_content,
+                artifact_html: artifact_html.as_deref(),
                 css_content: component_data.css_content.as_deref(),
                 artifact_needed: self.plugin.is_some(),
             })?;
@@ -2500,17 +2486,9 @@ impl HtmlParser {
     ) -> Result<u32> {
         let mut first_dynamic_emitted = false;
         let mut binding_count: u32 = 0;
-        let uses_fast_template_artifacts = self.uses_fast_template_artifacts();
         for attr in attrs {
             let attr_name = attr.name;
 
-            if attr_name == ComponentRegistry::INTERNAL_FAST_BINDING_ATTR {
-                if uses_fast_template_artifacts {
-                    binding_count += 1;
-                }
-                continue;
-            }
-
             if let Some(ref mut p) = self.plugin {
                 match p.classify_attribute(attr_name) {
                     AttributeAction::Keep => {}
@@ -3158,24 +3136,15 @@ impl HtmlParser {
                 .help(self.unknown_component_help(component))
             })?
             .clone();
-        let uses_fast_template_artifacts = self.uses_fast_template_artifacts();
-        let html_content = self
+        let artifact_html = self
             .component_registry
-            .html_content_for_parse(component, uses_fast_template_artifacts)
-            .unwrap_or(&component_data.html_content)
-            .to_string();
-        let plugin_template_artifact = if uses_fast_template_artifacts {
-            self.component_registry
-                .plugin_template_artifact(component)
-                .map(str::to_string)
-        } else {
-            None
-        };
+            .component_artifact_source(component)
+            .map(str::to_string);
 
         let built = self.build_component_templates(ComponentTemplateInput {
             tag_name: component,
-            html: &html_content,
-            plugin_html: plugin_template_artifact.as_deref(),
+            html: &component_data.html_content,
+            artifact_html: artifact_html.as_deref(),
             css_content: component_data.css_content.as_deref(),
             artifact_needed: self.plugin.is_some(),
         })?;
@@ -3248,8 +3217,13 @@ impl HtmlParser {
             CssStrategy::Module => None,
         };
 
-        let artifact_differs =
-            input.artifact_needed && Self::template_has_stripped_runtime_attrs(html);
+        let artifact_source = if input.artifact_needed {
+            input
+                .artifact_html
+                .or_else(|| Self::template_has_stripped_runtime_attrs(html).then_some(html))
+        } else {
+            None
+        };
         let policy_wrapper = parse_component_render_policy(tag_name, html)?.is_authored();
         let ssr = self.process_component_policy_template(
             html,
@@ -3257,22 +3231,14 @@ impl HtmlParser {
             adopted_specifier,
             policy_wrapper,
         )?;
-        let artifact = if let Some(plugin_html) = input.plugin_html {
-            Some(self.process_component_artifact_template(
-                plugin_html,
-                css_injection.as_deref(),
-                adopted_specifier,
-                policy_wrapper,
-            )?)
-        } else if artifact_differs {
-            Some(self.process_component_artifact_template(
-                html,
+        let artifact = match artifact_source {
+            Some(source) => Some(self.process_component_artifact_template(
+                source,
                 css_injection.as_deref(),
                 adopted_specifier,
                 policy_wrapper,
-            )?)
-        } else {
-            None
+            )?),
+            None => None,
         };
 
         Ok(BuiltComponentTemplate { ssr, artifact })
@@ -4113,16 +4079,23 @@ mod tests {
         );
         assert_stream!(records, "if-1", [for_loop("item", "items", "for-1"),]);
         let for_fragments = &records["for-1"].fragments;
+        // Binding count is 5: @click, :config, f-ref (FAST client bindings
+        // stripped and counted via classify_attribute) plus ?disabled and
+        // title (WebUI dynamic bindings).
         assert!(for_fragments.iter().any(|fragment| {
             matches!(
                 fragment.fragment.as_ref(),
                 Some(Fragment::Plugin(data)) if data.data == 5u32.to_le_bytes()
             )
         }));
+        // No FAST client attribute leaks into the SSR raw stream.
         assert!(!for_fragments.iter().any(|fragment| {
             matches!(
                 fragment.fragment.as_ref(),
-                Some(Fragment::Raw(raw)) if raw.value.contains(ComponentRegistry::INTERNAL_FAST_BINDING_ATTR)
+                Some(Fragment::Raw(raw))
+                    if raw.value.contains("@click")
+                        || raw.value.contains(":config")
+                        || raw.value.contains("f-ref")
             )
         }));
 
@@ -4162,33 +4135,163 @@ mod tests {
     }
 
     #[test]
-    fn webui_plugin_does_not_use_fast_template_artifact_path() {
-        let mut parser = HtmlParser::with_plugin(Box::new(plugin::webui::WebUIParserPlugin::new()));
+    fn fast_client_attributes_are_counted_in_nested_source_order_without_markers() {
+        let mut parser =
+            HtmlParser::with_plugin(Box::new(plugin::fast_v3::FastV3ParserPlugin::new()));
         parser
             .component_registry
             .register_component(ComponentRegistration::new(
-                "file-card",
-                r#"<f-template name="named-card"><template><f-when value="{{visible}}"><button @click="{save()}" :config="{config}" title="{title}">Save</button></f-when></template></f-template>"#,
+                "binding-card",
+                r#"<f-template name="binding-card"><template><div @click="{save()}" :config="{config}" f-ref="{root}" f-slotted="{slot}" f-children="{children}" title="{{title}}"><span @focus="{focus()}" :value="{value}">{{label}}</span></div></template></f-template>"#,
                 None,
                 true,
             ))
             .expect("register component");
 
         parser
-            .parse("index.html", "<named-card></named-card>")
+            .parse("index.html", "<binding-card></binding-card>")
             .expect("parse entry");
-        let artifacts = parser.take_plugin_artifacts().expect("artifacts");
-        let ParserPluginArtifacts::ComponentTemplates(templates) = artifacts else {
+        let fragments = &parser.fragment_records["binding-card"].fragments;
+        let binding_counts: Vec<u32> = fragments
+            .iter()
+            .filter_map(|fragment| {
+                let Some(Fragment::Plugin(data)) = fragment.fragment.as_ref() else {
+                    return None;
+                };
+                (data.data.len() == 4).then(|| {
+                    u32::from_le_bytes([data.data[0], data.data[1], data.data[2], data.data[3]])
+                })
+            })
+            .collect();
+        assert_eq!(binding_counts, vec![6, 2]);
+
+        for fragment in fragments {
+            if let Some(Fragment::Raw(raw)) = fragment.fragment.as_ref() {
+                for client_attr in [
+                    "@click",
+                    ":config",
+                    "f-ref",
+                    "f-slotted",
+                    "f-children",
+                    "@focus",
+                    ":value",
+                    "data-webui-internal-",
+                ] {
+                    assert!(!raw.value.contains(client_attr));
+                }
+            }
+        }
+
+        let ParserPluginArtifacts::ComponentTemplates(templates) =
+            parser.take_plugin_artifacts().expect("artifacts")
+        else {
+            panic!("expected component template artifacts");
+        };
+        let template = &templates[0].template;
+        for client_attr in [
+            "@click",
+            ":config",
+            "f-ref",
+            "f-slotted",
+            "f-children",
+            "@focus",
+            ":value",
+        ] {
+            assert!(template.contains(client_attr));
+        }
+        assert!(!template.contains("data-webui-internal-"));
+    }
+
+    #[test]
+    fn route_only_fast_component_uses_retained_authored_source() {
+        let mut parser =
+            HtmlParser::with_plugin(Box::new(plugin::fast_v2::FastV2ParserPlugin::new()));
+        parser
+            .component_registry
+            .register_component(ComponentRegistration::new(
+                "route-card",
+                r#"<f-template name="route-card"><template><f-when value="{{visible}}"><span>{{label}}</span></f-when></template></f-template>"#,
+                None,
+                true,
+            ))
+            .expect("register component");
+
+        parser
+            .parse(
+                "index.html",
+                r#"<route path="/card" component="route-card" exact />"#,
+            )
+            .expect("parse route");
+        assert!(parser.fragment_records.contains_key("route-card"));
+
+        let ParserPluginArtifacts::ComponentTemplates(templates) =
+            parser.take_plugin_artifacts().expect("artifacts")
+        else {
             panic!("expected component template artifacts");
         };
         assert_eq!(templates.len(), 1);
-        assert_eq!(templates[0].tag_name, "named-card");
-        assert!(templates[0].template.is_empty());
-        assert!(!templates[0].template_json.contains("<f-template"));
-        assert!(!templates[0].template_json.contains("@click"));
-        assert!(!templates[0]
-            .template_json
-            .contains(ComponentRegistry::INTERNAL_FAST_BINDING_ATTR));
+        assert!(templates[0]
+            .template
+            .contains(r#"<f-when value="{{visible}}">"#));
+    }
+
+    #[test]
+    fn webui_plugin_leaves_f_template_shaped_source_inert() {
+        // The WebUI plugin supplies no component-source transform, so
+        // `<f-template>`-shaped markup is stored verbatim under the filename
+        // tag: no rename, no FAST conversion, and no FAST diagnostics.
+        let mut parser = HtmlParser::with_plugin(Box::new(plugin::webui::WebUIParserPlugin::new()));
+        parser
+            .component_registry
+            .register_component(ComponentRegistration::new(
+                "file-card",
+                r#"<f-template name="named-card"><template><span>{{label}}</span></template></f-template>"#,
+                None,
+                true,
+            ))
+            .expect("register component");
+
+        assert!(parser.component_registry.contains("file-card"));
+        assert!(!parser.component_registry.contains("named-card"));
+        assert_eq!(
+            parser
+                .component_registry
+                .get("file-card")
+                .map(|component| component.html_content.as_str()),
+            Some(
+                r#"<f-template name="named-card"><template><span>{{label}}</span></template></f-template>"#
+            )
+        );
+        assert_eq!(
+            parser
+                .component_registry
+                .component_artifact_source("file-card"),
+            None
+        );
+    }
+
+    #[test]
+    fn default_parser_leaves_f_template_shaped_source_inert() {
+        // With no plugin selected, `<f-template>`-shaped markup is inert too.
+        let mut parser = HtmlParser::new();
+        parser
+            .component_registry
+            .register_component(ComponentRegistration::new(
+                "file-card",
+                r#"<f-template name="named-card"><template><span>{{label}}</span></template></f-template>"#,
+                None,
+                true,
+            ))
+            .expect("register component");
+
+        assert!(parser.component_registry.contains("file-card"));
+        assert!(!parser.component_registry.contains("named-card"));
+        assert_eq!(
+            parser
+                .component_registry
+                .component_artifact_source("file-card"),
+            None
+        );
     }
 
     #[test]
@@ -6114,7 +6217,7 @@ mod tests {
             .build_component_templates(ComponentTemplateInput {
                 tag_name: "my-comp",
                 html,
-                plugin_html: None,
+                artifact_html: None,
                 css_content: None,
                 artifact_needed: true,
             })
@@ -6130,7 +6233,7 @@ mod tests {
             .build_component_templates(ComponentTemplateInput {
                 tag_name: "my-comp",
                 html,
-                plugin_html: None,
+                artifact_html: None,
                 css_content: None,
                 artifact_needed: true,
             })
@@ -6196,7 +6299,7 @@ mod tests {
             let built = match parser.build_component_templates(ComponentTemplateInput {
                 tag_name: "my-comp",
                 html: r#"<template shadowrootmode="open" @click="{onClick()}">Hello</template>"#,
-                plugin_html: None,
+                artifact_html: None,
                 css_content: Some(":host { color: red; }"),
                 artifact_needed: true,
             }) {
diff --git a/crates/webui-parser/src/plugin/fast_shared.rs b/crates/webui-parser/src/plugin/fast_shared.rs
new file mode 100644
index 00000000..fb78ca21
--- /dev/null
+++ b/crates/webui-parser/src/plugin/fast_shared.rs
@@ -0,0 +1,278 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+//! Shared FAST `<f-template>` source handling for the FAST parser plugins.
+//!
+//! This module owns everything FAST-specific about turning an authored
+//! `<f-template>` component source into the WebUI parser view: scanning for the
+//! single `<f-template>` element, resolving its `name` (falling back to the
+//! filename-derived tag), invoking `microsoft-fast-convert`, retaining the
+//! authored inner `<template>` for the client artifact, and constructing FAST
+//! diagnostics. The FAST parser plugins expose it through the framework-neutral
+//! [`ParserPlugin::component_source_transform`](super::ParserPlugin::component_source_transform)
+//! hook; the parser core never references FAST.
+
+use super::{ComponentSource, ComponentSourceResult, TransformedComponentSource};
+use crate::diagnostic::{codes, Diagnostic};
+use crate::html_parser::{Event, Walker};
+use crate::{ParserError, Result};
+use microsoft_fast_convert::{convert_template, ConvertError};
+use std::borrow::Cow;
+use std::ops::Range;
+
+/// Diagnostic code for a component source with multiple `<f-template>` blocks.
+const UNSUPPORTED_MULTIPLE_F_TEMPLATES: &str = "unsupported-multiple-f-templates";
+/// Diagnostic code for a FAST template that cannot be converted to WebUI syntax.
+const INVALID_FAST_TEMPLATE: &str = "invalid-fast-template";
+/// Placeholder `<f-template name>` supplied to the converter when the authored
+/// source omits a usable name; the resolved registry key is the filename.
+const CONVERTER_FALLBACK_NAME: &str = "webui-fallback";
+/// Target dialect requested from `microsoft-fast-convert`.
+const WEBUI_CONVERTER_SYNTAX: &str = "webui-prerelease";
+
+/// Located `<f-template>` element within an authored component source.
+struct FTemplateSource {
+    name: Option<String>,
+    start: usize,
+    inner: Range<usize>,
+}
+
+/// Component-source transform for FAST authored templates.
+///
+/// Returns [`ComponentSourceResult::Unchanged`] when the source contains no
+/// `<f-template>`; otherwise converts the FAST declarative syntax to the WebUI
+/// parser view, resolves the registry key from the `<f-template name>`
+/// attribute (or the filename), and retains the authored inner `<template>` as
+/// the client artifact.
+///
+/// # Errors
+///
+/// Returns a [`Diagnostic`]-carrying error when multiple `<f-template>` blocks
+/// are present or the FAST template cannot be converted.
+pub(crate) fn transform_component_source(
+    source: ComponentSource<'_>,
+) -> Result<ComponentSourceResult> {
+    let html_content = source.html_content;
+    let Some(found) = find_f_template_source(html_content) else {
+        return Ok(ComponentSourceResult::Unchanged);
+    };
+
+    let resolved_tag = found.name.as_deref().unwrap_or(source.tag_name).to_string();
+    let converter_input = converter_input(html_content, &found);
+    let converted = convert_template(&converter_input, WEBUI_CONVERTER_SYNTAX)
+        .map_err(|error| converter_error(html_content, found.start, error))?;
+    let artifact_content = html_content[found.inner].trim().to_string();
+
+    Ok(ComponentSourceResult::Transformed(
+        TransformedComponentSource {
+            tag_name: resolved_tag,
+            parser_content: converted,
+            artifact_content: Some(artifact_content),
+        },
+    ))
+}
+
+/// Find the first `<f-template>` element anywhere in the authored source.
+fn find_f_template_source(html_content: &str) -> Option<FTemplateSource> {
+    let mut stack = Vec::with_capacity(1);
+    stack.push(0..html_content.len());
+
+    while let Some(range) = stack.pop() {
+        for event in Walker::new_range(html_content, range.start, range.end) {
+            let Event::Element(element) = event else {
+                continue;
+            };
+
+            if element.name().eq_ignore_ascii_case("f-template") {
+                return Some(FTemplateSource {
+                    name: element
+                        .attr("name")
+                        .map(str::trim)
+                        .filter(|name| !name.is_empty())
+                        .map(str::to_string),
+                    start: element.start,
+                    inner: element.inner(),
+                });
+            }
+
+            if !element.self_closing() && !element.is_void() {
+                stack.push(element.inner());
+            }
+        }
+    }
+
+    None
+}
+
+/// Build the converter input, injecting a placeholder name when the authored
+/// `<f-template>` omits a usable one so the converter's validation is satisfied
+/// without leaking the placeholder into the resolved registry key.
+fn converter_input<'a>(html_content: &'a str, source: &FTemplateSource) -> Cow<'a, str> {
+    if source.name.is_some() {
+        return Cow::Borrowed(html_content);
+    }
+
+    let mut normalized =
+        String::with_capacity(html_content.len() + CONVERTER_FALLBACK_NAME.len() + 20);
+    normalized.push_str(&html_content[..source.start]);
+    normalized.push_str("<f-template name=\"");
+    normalized.push_str(CONVERTER_FALLBACK_NAME);
+    normalized.push_str("\">");
+    normalized.push_str(&html_content[source.inner.start..]);
+    Cow::Owned(normalized)
+}
+
+/// Build a [`Diagnostic`] error from a converter failure.
+#[cold]
+#[inline(never)]
+fn converter_error(source: &str, offset: usize, error: ConvertError) -> ParserError {
+    if matches!(error, ConvertError::MultipleFTemplates { .. }) {
+        return Diagnostic::error("multiple <f-template> elements are not supported")
+            .code(UNSUPPORTED_MULTIPLE_F_TEMPLATES)
+            .at_offset(source, offset)
+            .snippet("<f-template>")
+            .help(
+                "keep only one <f-template> per component file; multiple f-template blocks are not currently supported",
+            )
+            .into();
+    }
+
+    let help = match &error {
+        ConvertError::MissingFTemplateName | ConvertError::EmptyFTemplateName => {
+            "add a non-empty name attribute to <f-template>, for example <f-template name=\"my-component\">"
+        }
+        ConvertError::MissingInnerTemplate | ConvertError::MultipleInnerTemplates { .. } => {
+            "keep exactly one inner <template> element inside <f-template>"
+        }
+        ConvertError::MissingValueAttribute { .. }
+        | ConvertError::InvalidDirectiveValue { .. } => {
+            "add the required value=\"{{expression}}\" attribute to the FAST directive"
+        }
+        ConvertError::InvalidRepeatExpression { .. } => {
+            "use an f-repeat expression in \"item in items\" form"
+        }
+        ConvertError::UnclosedElement { .. } | ConvertError::UnclosedTag { .. } => {
+            "close the reported FAST template element or opening tag"
+        }
+        ConvertError::UnsupportedFAttribute { .. }
+        | ConvertError::UnsupportedFElement { .. } => {
+            "remove the unsupported FAST construct or replace it with supported declarative syntax"
+        }
+        _ => "fix the reported FAST declarative template syntax",
+    };
+
+    let code = if matches!(
+        error,
+        ConvertError::UnclosedElement { .. } | ConvertError::UnclosedTag { .. }
+    ) {
+        codes::UNCLOSED_HTML_TAG
+    } else {
+        INVALID_FAST_TEMPLATE
+    };
+
+    Diagnostic::error(format!("invalid FAST template: {error}"))
+        .code(code)
+        .at_offset(source, offset)
+        .snippet("<f-template>")
+        .help(help)
+        .into()
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::disallowed_methods)]
+    use super::*;
+
+    fn transform(tag: &str, html: &str) -> Result<ComponentSourceResult> {
+        transform_component_source(ComponentSource {
+            tag_name: tag,
+            html_content: html,
+        })
+    }
+
+    #[test]
+    fn plain_source_without_f_template_is_unchanged() {
+        let html = r#"<template><if condition="visible"><span>{{title}}</span></if></template>"#;
+        assert_eq!(
+            transform("plain-card", html).expect("transform"),
+            ComponentSourceResult::Unchanged
+        );
+    }
+
+    #[test]
+    fn f_template_name_overrides_tag_and_converts_for_webui() {
+        let html = r#"<f-template name="named-card"><template><f-when value="{{visible && count > 0}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" ?disabled="{{disabled}}" f-ref="{button}" title="{{title}}">{{item.label}}</button></f-repeat></f-when></template></f-template>"#;
+
+        let ComponentSourceResult::Transformed(result) =
+            transform("file-card", html).expect("transform")
+        else {
+            panic!("expected a transformed FAST source");
+        };
+
+        assert_eq!(result.tag_name, "named-card");
+        // The converter output is the SSR parser view; FAST client attributes
+        // are retained here and stripped later by `classify_attribute`.
+        assert_eq!(
+            result.parser_content,
+            r#"<template><if condition="visible && count > 0"><for each="item in items"><button @click="{save()}" :config="{config}" ?disabled="{{disabled}}" f-ref="{button}" title="{{title}}">{{item.label}}</button></for></if></template>"#
+        );
+        // The client artifact retains the authored FAST syntax verbatim.
+        assert_eq!(
+            result.artifact_content.as_deref(),
+            Some(
+                r#"<template><f-when value="{{visible && count > 0}}"><f-repeat value="{{item in items}}"><button @click="{save()}" :config="{config}" ?disabled="{{disabled}}" f-ref="{button}" title="{{title}}">{{item.label}}</button></f-repeat></f-when></template>"#
+            )
+        );
+    }
+
+    #[test]
+    fn absent_or_blank_name_falls_back_to_filename() {
+        for html in [
+            "<f-template><template></template></f-template>",
+            r#"<f-template name=" "><template></template></f-template>"#,
+        ] {
+            let ComponentSourceResult::Transformed(result) =
+                transform("file-card", html).expect("transform")
+            else {
+                panic!("expected a transformed FAST source");
+            };
+            assert_eq!(result.tag_name, "file-card");
+            assert_eq!(result.parser_content, "<template></template>");
+            assert_eq!(
+                result.artifact_content.as_deref(),
+                Some("<template></template>")
+            );
+        }
+    }
+
+    #[test]
+    fn multiple_f_templates_are_rejected() {
+        let err = transform(
+            "multi-card",
+            r#"<f-template name="one"><template></template></f-template><f-template name="two"><template></template></f-template>"#,
+        )
+        .expect_err("multiple f-template blocks should error");
+
+        let ParserError::Template(diag) = err else {
+            panic!("expected template diagnostic");
+        };
+        assert_eq!(diag.error_code(), Some(UNSUPPORTED_MULTIPLE_F_TEMPLATES));
+        assert!(diag.to_string().contains("not currently supported"));
+    }
+
+    #[test]
+    fn invalid_converter_input_is_a_diagnostic() {
+        let err = transform(
+            "invalid-card",
+            r#"<f-template name="invalid-card"><template><f-repeat value="{{items}}"></f-repeat></template></f-template>"#,
+        )
+        .expect_err("invalid repeat should error");
+
+        let ParserError::Template(diag) = err else {
+            panic!("expected template diagnostic");
+        };
+        assert_eq!(diag.error_code(), Some(INVALID_FAST_TEMPLATE));
+        assert!(diag.to_string().contains("item in items"));
+        assert!(diag.help_text().is_some());
+    }
+}
diff --git a/crates/webui-parser/src/plugin/fast_v2.rs b/crates/webui-parser/src/plugin/fast_v2.rs
index 65779b53..80aa519b 100644
--- a/crates/webui-parser/src/plugin/fast_v2.rs
+++ b/crates/webui-parser/src/plugin/fast_v2.rs
@@ -7,7 +7,10 @@
 //! artifacts after parsing. Converts WebUI Framework template syntax (`<if>`, `<for>`, `{{}}`)
 //! into FAST-compatible syntax (`<f-when>`, `<f-repeat>`, `{}`).
 
-use super::{AttributeAction, ComponentTemplateArtifact, ParserPlugin, ParserPluginArtifacts};
+use super::{
+    AttributeAction, ComponentSourceTransform, ComponentTemplateArtifact, ParserPlugin,
+    ParserPluginArtifacts,
+};
 use crate::component_registry::Component;
 use crate::html_parser::{find_tag_close, opening_tag_name};
 use crate::{CssLinkOptions, CssStrategy, Result};
@@ -83,12 +86,13 @@ impl ParserPlugin for FastV2ParserPlugin {
         Ok(())
     }
 
-    fn uses_fast_template_artifacts(&self) -> bool {
-        true
+    fn component_source_transform(&self) -> Option<ComponentSourceTransform> {
+        Some(super::fast_shared::transform_component_source)
     }
 
     fn classify_attribute(&mut self, attr_name: &str) -> AttributeAction {
         if attr_name.starts_with('@')
+            || attr_name.starts_with(':')
             || attr_name == "f-ref"
             || attr_name == "f-slotted"
             || attr_name == "f-children"
@@ -730,6 +734,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn skip_property_binding() {
+        let mut plugin = FastV2ParserPlugin::new();
+        assert_eq!(
+            plugin.classify_attribute(":title"),
+            AttributeAction::SkipAndCountBinding
+        );
+        assert_eq!(
+            plugin.classify_attribute(":config"),
+            AttributeAction::SkipAndCountBinding
+        );
+    }
+
     #[test]
     fn do_not_skip_normal_attributes() {
         let mut plugin = FastV2ParserPlugin::new();
@@ -739,7 +756,6 @@ mod tests {
             plugin.classify_attribute("data-value"),
             AttributeAction::Keep
         );
-        assert_eq!(plugin.classify_attribute(":title"), AttributeAction::Keep);
         assert_eq!(plugin.classify_attribute("f-other"), AttributeAction::Keep);
     }
 
diff --git a/crates/webui-parser/src/plugin/fast_v3.rs b/crates/webui-parser/src/plugin/fast_v3.rs
index edbea9fa..e8afd80e 100644
--- a/crates/webui-parser/src/plugin/fast_v3.rs
+++ b/crates/webui-parser/src/plugin/fast_v3.rs
@@ -7,7 +7,10 @@
 //! artifacts after parsing. Converts WebUI Framework template syntax (`<if>`, `<for>`, `{{}}`)
 //! into FAST-compatible syntax (`<f-when>`, `<f-repeat>`, `{}`).
 
-use super::{AttributeAction, ComponentTemplateArtifact, ParserPlugin, ParserPluginArtifacts};
+use super::{
+    AttributeAction, ComponentSourceTransform, ComponentTemplateArtifact, ParserPlugin,
+    ParserPluginArtifacts,
+};
 use crate::component_registry::Component;
 use crate::html_parser::{find_tag_close, opening_tag_name};
 use crate::{CssLinkOptions, CssStrategy, Result};
@@ -83,12 +86,13 @@ impl ParserPlugin for FastV3ParserPlugin {
         Ok(())
     }
 
-    fn uses_fast_template_artifacts(&self) -> bool {
-        true
+    fn component_source_transform(&self) -> Option<ComponentSourceTransform> {
+        Some(super::fast_shared::transform_component_source)
     }
 
     fn classify_attribute(&mut self, attr_name: &str) -> AttributeAction {
         if attr_name.starts_with('@')
+            || attr_name.starts_with(':')
             || attr_name == "f-ref"
             || attr_name == "f-slotted"
             || attr_name == "f-children"
@@ -730,6 +734,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn skip_property_binding() {
+        let mut plugin = FastV3ParserPlugin::new();
+        assert_eq!(
+            plugin.classify_attribute(":title"),
+            AttributeAction::SkipAndCountBinding
+        );
+        assert_eq!(
+            plugin.classify_attribute(":config"),
+            AttributeAction::SkipAndCountBinding
+        );
+    }
+
     #[test]
     fn do_not_skip_normal_attributes() {
         let mut plugin = FastV3ParserPlugin::new();
@@ -739,7 +756,6 @@ mod tests {
             plugin.classify_attribute("data-value"),
             AttributeAction::Keep
         );
-        assert_eq!(plugin.classify_attribute(":title"), AttributeAction::Keep);
         assert_eq!(plugin.classify_attribute("f-other"), AttributeAction::Keep);
     }
 
diff --git a/crates/webui-parser/src/plugin/mod.rs b/crates/webui-parser/src/plugin/mod.rs
index a328bb33..163e8c28 100644
--- a/crates/webui-parser/src/plugin/mod.rs
+++ b/crates/webui-parser/src/plugin/mod.rs
@@ -8,6 +8,7 @@
 //! and emit per-element hydration metadata for the handler.
 
 pub mod fast;
+mod fast_shared;
 pub mod fast_v2;
 pub mod fast_v3;
 pub mod webui;
@@ -153,6 +154,61 @@ impl ComponentTemplateArtifact {
     }
 }
 
+/// Borrowed authored component source presented to a parser plugin before the
+/// component registry stores it.
+#[derive(Debug, Clone, Copy)]
+pub struct ComponentSource<'a> {
+    /// Filename-derived custom-element tag name.
+    pub tag_name: &'a str,
+    /// Authored HTML template for the component.
+    pub html_content: &'a str,
+}
+
+/// Owned replacement views produced by a plugin's component-source transform.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TransformedComponentSource {
+    /// Resolved registry key. May differ from the filename-derived tag when the
+    /// authored source names the component itself.
+    pub tag_name: String,
+    /// Content the WebUI SSR parser consumes for this component.
+    pub parser_content: String,
+    /// Optional distinct authored source retained for the plugin's client
+    /// artifact. `None` reuses `parser_content` for the artifact.
+    pub artifact_content: Option<String>,
+}
+
+/// Outcome of applying a [`ComponentSourceTransform`] to one component.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ComponentSourceResult {
+    /// Preserve the registration tag and HTML exactly, without allocation.
+    Unchanged,
+    /// Replace the registry key and/or the parser/artifact views.
+    Transformed(TransformedComponentSource),
+}
+
+/// Stateless component-source transform installed into a [`ComponentRegistry`].
+///
+/// A parser plugin that owns an alternate authored-template dialect supplies
+/// this hook through [`ParserPlugin::component_source_transform`]. The registry
+/// runs it once per component — after reading the authored HTML but before name
+/// validation, duplicate checking, CSS processing, or insertion — so the plugin
+/// can resolve the registry key, produce the SSR parser view, and retain a
+/// distinct client artifact. Returning [`ComponentSourceResult::Unchanged`]
+/// leaves the component's filename-derived tag and HTML untouched.
+///
+/// The transform is a plain function pointer: it is deterministic, allocation
+/// free when absent, [`Copy`], and keeps [`ComponentRegistry`] `Debug` without
+/// a trait object.
+///
+/// # Errors
+///
+/// Returns a [`crate::Diagnostic`]-carrying error when the authored source is
+/// invalid.
+///
+/// [`ComponentRegistry`]: crate::component_registry::ComponentRegistry
+pub type ComponentSourceTransform =
+    for<'a> fn(ComponentSource<'a>) -> Result<ComponentSourceResult>;
+
 /// A parser plugin that can customize template parsing behavior.
 ///
 /// Plugins receive callbacks at key points during HTML parsing:
@@ -186,13 +242,16 @@ pub trait ParserPlugin {
         processed_template: &str,
     ) -> Result<()>;
 
-    /// Return true when this plugin consumes FAST `<f-template>` artifacts.
+    /// Return a stateless transform applied to each component's authored source
+    /// before registry insertion, or `None` to store sources unchanged.
     ///
-    /// FAST parser plugins use this to opt into authored `<f-template>` source
-    /// handling, including parser-only binding markers for stripped FAST client
-    /// directives. Other plugins receive the normal WebUI parse view.
-    fn uses_fast_template_artifacts(&self) -> bool {
-        false
+    /// Plugins that own an alternate authored-template dialect (resolving the
+    /// registry key, producing the SSR parser view, and retaining a distinct
+    /// client artifact) supply the transform here. The default performs no
+    /// transformation, so a component's filename-derived tag and HTML are
+    /// stored verbatim and framework-specific markup is inert.
+    fn component_source_transform(&self) -> Option<ComponentSourceTransform> {
+        None
     }
 
     /// Decide how a framework-owned attribute should be handled.
diff --git a/crates/webui/src/lib.rs b/crates/webui/src/lib.rs
index 6b53d05d..a3bb1df4 100644
--- a/crates/webui/src/lib.rs
+++ b/crates/webui/src/lib.rs
@@ -2545,7 +2545,7 @@ mod tests {
         let app = create_app_dir(&[
             (
                 "index.html",
-                "<named-card></named-card><fallback-card></fallback-card>",
+                "<named-card></named-card><fallback-card></fallback-card><plain-card></plain-card>",
             ),
             (
                 "file-card.html",
@@ -2556,6 +2556,10 @@ mod tests {
                 "fallback-card.html",
                 r#"<f-template><template><span>{{label}}</span></template></f-template>"#,
             ),
+            (
+                "plain-card.html",
+                r#"<template><if condition="visible"><span>{{label}}</span></if></template>"#,
+            ),
         ]);
 
         for plugin in [Plugin::Fast, Plugin::FastV2, Plugin::FastV3] {
@@ -2585,6 +2589,13 @@ mod tests {
                 .template
                 .contains(r#"<f-template name="fallback-card">"#));
             assert!(fallback.template.contains("<span>{{label}}</span>"));
+            let plain = result
+                .protocol
+                .components
+                .get("plain-card")
+                .expect("ordinary WebUI component");
+            assert!(plain.template.contains(r#"<f-template name="plain-card">"#));
+            assert!(plain.template.contains(r#"<f-when value="{{visible}}">"#));
         }
     }
 
diff --git a/docs/guide/concepts/plugins/index.md b/docs/guide/concepts/plugins/index.md
index f27dbb4d..69194766 100644
--- a/docs/guide/concepts/plugins/index.md
+++ b/docs/guide/concepts/plugins/index.md
@@ -103,8 +103,10 @@ webui build ./src --out ./dist --plugin=fast-v3
 webui serve ./src --state ./data/state.json --plugin=fast-v3 --watch
 ```
 
-For FAST builds, component discovery automatically recognizes an HTML file
-authored as one wrapping `<f-template>`:
+When a FAST plugin is selected, it installs a `component_source_transform` that
+recognizes an HTML file authored as one wrapping `<f-template>`. With no
+plugin, or with the `webui` plugin, `<f-template>` markup is not scanned or
+converted and passes through like any other HTML:
 
 ```html
 <!-- src/components/file-card.html -->
@@ -137,19 +139,20 @@ WebUI uses two views of this source:
   directives to WebUI `for` and `if` directives and unwraps their `value`
   expressions. Text interpolation and boolean bindings remain for WebUI
   parsing. Unsupported `f-*` constructs fail conversion instead of being
-  silently accepted. WebUI removes client-only `@event`, `:property`, `f-ref`,
-  `f-slotted`, and `f-children` attributes from this view. FAST plugins receive
-  parser-only binding markers for those removed attributes so hydration binding
-  indexes remain aligned.
+  silently accepted. The FAST plugins' `classify_attribute` skips `@event`,
+  `:property`, `f-ref`, `f-slotted`, and `f-children` and counts each as a
+  binding, so hydration binding indexes stay aligned without any parser-core
+  marker.
 - **Client artifact view:** WebUI retains the authored inner template, including
   its client bindings, and emits it inside the resolved `<f-template>` rather
   than regenerating it from the SSR view. The artifact is normalized and still
   receives normal wrapper handling, legal comment processing, and CSS injection
-  for the selected strategy. Non-FAST plugins receive the normal WebUI parse
-  view instead of FAST artifacts.
+  for the selected strategy. Plugins that return `None` from
+  `component_source_transform` never receive FAST artifacts; they parse the
+  component's HTML unchanged.
 
 The deprecated `fast` selector aliases FAST 2. `fast`, `fast_v2`, and `fast_v3`
-all use this same discovery, conversion, and retained-artifact path.
+all share this same transform, conversion, and retained-artifact path.
 
 ## Writing Custom Plugins
 
@@ -171,9 +174,12 @@ pub trait ParserPlugin {
         processed_template: &str,
     ) -> Result<()>;
 
-    /// Return true only for plugins that consume FAST `<f-template>` artifacts.
-    fn uses_fast_template_artifacts(&self) -> bool {
-        false
+    /// Return a stateless transform applied to a component's authored source
+    /// before registry insertion, or `None` to store sources unchanged. Only
+    /// plugins that own an alternate authored-template dialect (such as FAST's
+    /// `<f-template>`) need to implement this.
+    fn component_source_transform(&self) -> Option<ComponentSourceTransform> {
+        None
     }
 
     /// Decide how a framework-owned attribute should be handled.

From 894047e3bd09cbffe473ebb6074b7180af98ff4d Mon Sep 17 00:00:00 2001
From: Jane Chu <7559015+janechu@users.noreply.github.com>
Date: Tue, 28 Jul 2026 11:13:25 -0700
Subject: [PATCH 5/6] Optimize FAST source registration and benchmark it

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: edae75de-6059-41a3-808d-0ec4b4c85b08
---
 crates/webui-parser/benches/parser_bench.rs   |  83 ++++++++++++-
 crates/webui-parser/src/plugin/fast_shared.rs | 109 +++++++++++++++++-
 2 files changed, 190 insertions(+), 2 deletions(-)

diff --git a/crates/webui-parser/benches/parser_bench.rs b/crates/webui-parser/benches/parser_bench.rs
index 7d7897bd..ae2b07d0 100644
--- a/crates/webui-parser/benches/parser_bench.rs
+++ b/crates/webui-parser/benches/parser_bench.rs
@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use criterion::{criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion, Throughput};
 use std::hint::black_box;
 use webui_parser::{plugin::fast_v2::FastV2ParserPlugin, CssStrategy, HtmlParser};
 
@@ -316,6 +316,38 @@ fn build_nested_article_template(depth: usize) -> String {
     html
 }
 
+/// Authored component source with no FAST syntax: the FAST source transform
+/// must reject it on the byte precheck without walking the elements.
+fn build_ordinary_component_source(depth: usize) -> String {
+    let mut html = String::with_capacity(depth * 33 + 64);
+    html.push_str("<template>");
+    for _ in 0..depth {
+        html.push_str("<section class=\"level\">");
+    }
+    html.push_str("<span>{{title}}</span>");
+    for _ in 0..depth {
+        html.push_str("</section>");
+    }
+    html.push_str("</template>");
+    html
+}
+
+/// Authored FAST component source: the transform must walk it, resolve the
+/// `<f-template name>`, and run the `microsoft-fast-convert` conversion.
+fn build_fast_component_source(depth: usize) -> String {
+    let mut html = String::with_capacity(depth * 63 + 128);
+    html.push_str("<f-template name=\"x-registration-bench\"><template>");
+    for _ in 0..depth {
+        html.push_str("<f-when value=\"{{visible}}\"><section>");
+    }
+    html.push_str("<span>{{title}}</span>");
+    for _ in 0..depth {
+        html.push_str("</section></f-when>");
+    }
+    html.push_str("</template></f-template>");
+    html
+}
+
 fn parser_with_bench_components() -> HtmlParser {
     let mut parser = HtmlParser::new();
     register_bench_components(&mut parser);
@@ -599,11 +631,60 @@ fn parser_adversarial_bench(c: &mut Criterion) {
     group.finish();
 }
 
+/// Measure `ComponentRegistry::register_component` with the FAST plugin's
+/// component-source transform installed, for both a FAST-free source (byte
+/// precheck, no walk) and an authored `<f-template>` source (walk plus
+/// conversion). Each iteration registers into a freshly built parser created
+/// outside the timed closure, so parser construction and source generation are
+/// excluded and no duplicate-registration error can occur.
+fn component_registration_fast_source_transform_bench(c: &mut Criterion) {
+    let mut group = c.benchmark_group("component_registration_fast_source_transform");
+    let scenarios = [
+        ("ordinary", 8, build_ordinary_component_source(8)),
+        ("ordinary", 64, build_ordinary_component_source(64)),
+        ("f_template", 8, build_fast_component_source(8)),
+        ("f_template", 64, build_fast_component_source(64)),
+    ];
+
+    for (source_kind, depth, source) in scenarios {
+        group.throughput(Throughput::Bytes(source.len() as u64));
+        group.bench_with_input(
+            BenchmarkId::new(source_kind, depth),
+            &source,
+            |b, source| {
+                b.iter_batched(
+                    || HtmlParser::with_plugin(Box::new(FastV2ParserPlugin::new())),
+                    |mut parser| {
+                        parser
+                            .component_registry_mut()
+                            .register_component(webui_parser::ComponentRegistration::new(
+                                "x-registration-bench",
+                                black_box(source.as_str()),
+                                None,
+                                true,
+                            ))
+                            .unwrap_or_else(|error| {
+                                panic!(
+                                    "registration failed for {source_kind} depth {depth}: {error}"
+                                )
+                            });
+                        black_box(parser)
+                    },
+                    BatchSize::SmallInput,
+                );
+            },
+        );
+    }
+
+    group.finish();
+}
+
 criterion_group!(
     benches,
     parser_parse_reuse_bench,
     parser_parse_fresh_vs_reuse,
     parser_plugin_bench,
+    component_registration_fast_source_transform_bench,
     parser_css_strategy_bench,
     parser_size_sweep_bench,
     parser_realistic_bench,
diff --git a/crates/webui-parser/src/plugin/fast_shared.rs b/crates/webui-parser/src/plugin/fast_shared.rs
index fb78ca21..06f6437f 100644
--- a/crates/webui-parser/src/plugin/fast_shared.rs
+++ b/crates/webui-parser/src/plugin/fast_shared.rs
@@ -29,6 +29,10 @@ const INVALID_FAST_TEMPLATE: &str = "invalid-fast-template";
 const CONVERTER_FALLBACK_NAME: &str = "webui-fallback";
 /// Target dialect requested from `microsoft-fast-convert`.
 const WEBUI_CONVERTER_SYNTAX: &str = "webui-prerelease";
+/// The FAST element name used by both the authoritative [`Walker`] match in
+/// [`find_f_template_source`] and the cheap byte precheck in
+/// [`contains_f_template_name`], preventing false negatives from name drift.
+const F_TEMPLATE_NAME: &str = "f-template";
 
 /// Located `<f-template>` element within an authored component source.
 struct FTemplateSource {
@@ -45,6 +49,10 @@ struct FTemplateSource {
 /// attribute (or the filename), and retains the authored inner `<template>` as
 /// the client artifact.
 ///
+/// A cheap byte precheck ([`contains_f_template_name`]) rules out sources that
+/// cannot possibly contain an `<f-template>` element, so ordinary FAST-free
+/// component sources never pay for the element walk.
+///
 /// # Errors
 ///
 /// Returns a [`Diagnostic`]-carrying error when multiple `<f-template>` blocks
@@ -53,6 +61,10 @@ pub(crate) fn transform_component_source(
     source: ComponentSource<'_>,
 ) -> Result<ComponentSourceResult> {
     let html_content = source.html_content;
+    if !contains_f_template_name(html_content.as_bytes()) {
+        return Ok(ComponentSourceResult::Unchanged);
+    }
+
     let Some(found) = find_f_template_source(html_content) else {
         return Ok(ComponentSourceResult::Unchanged);
     };
@@ -72,6 +84,26 @@ pub(crate) fn transform_component_source(
     ))
 }
 
+/// Cheap case-insensitive precheck for the bare ASCII name `f-template`
+/// anywhere in `haystack`, without the surrounding `<` delimiter.
+///
+/// The HTML [`Walker`] takes an opening element name to be the run of bytes
+/// after `<` (skipping ASCII whitespace) and matches it
+/// ASCII-case-insensitively, so every spelling it accepts contains these ten
+/// bytes verbatim, case aside. Searching for the bare name therefore has no
+/// false negatives, whereas searching for `"<f-template"` would. Non-ASCII
+/// bytes are compared without case folding, so UTF-8 input can neither panic
+/// nor be misread. False positives (the bytes appearing in text, comments,
+/// attributes, or longer names) only cost the walk that would have happened
+/// anyway: [`find_f_template_source`] remains authoritative and still reports
+/// `Unchanged`.
+#[inline]
+fn contains_f_template_name(haystack: &[u8]) -> bool {
+    haystack
+        .windows(F_TEMPLATE_NAME.len())
+        .any(|window| window.eq_ignore_ascii_case(F_TEMPLATE_NAME.as_bytes()))
+}
+
 /// Find the first `<f-template>` element anywhere in the authored source.
 fn find_f_template_source(html_content: &str) -> Option<FTemplateSource> {
     let mut stack = Vec::with_capacity(1);
@@ -83,7 +115,7 @@ fn find_f_template_source(html_content: &str) -> Option<FTemplateSource> {
                 continue;
             };
 
-            if element.name().eq_ignore_ascii_case("f-template") {
+            if element.name().eq_ignore_ascii_case(F_TEMPLATE_NAME) {
                 return Some(FTemplateSource {
                     name: element
                         .attr("name")
@@ -275,4 +307,79 @@ mod tests {
         assert!(diag.to_string().contains("item in items"));
         assert!(diag.help_text().is_some());
     }
+
+    #[test]
+    fn precheck_matches_lower_upper_and_mixed_case_names() {
+        for haystack in [
+            "<f-template name=\"card\"><template></template></f-template>",
+            "<F-TEMPLATE NAME=\"card\"><template></template></F-TEMPLATE>",
+            "<F-template Name=\"card\"><template></template></f-Template>",
+        ] {
+            assert!(contains_f_template_name(haystack.as_bytes()));
+            assert!(find_f_template_source(haystack).is_some());
+        }
+    }
+
+    #[test]
+    fn whitespace_after_opening_angle_bracket_passes_precheck_and_walker() {
+        let html =
+            r#"< f-template name="card"><template><span>{{title}}</span></template></f-template>"#;
+        assert!(contains_f_template_name(html.as_bytes()));
+
+        let ComponentSourceResult::Transformed(result) =
+            transform("file-card", html).expect("transform")
+        else {
+            panic!("expected a transformed FAST source");
+        };
+        assert_eq!(result.tag_name, "card");
+    }
+
+    #[test]
+    fn precheck_covers_every_ascii_whitespace_accepted_before_the_name() {
+        for byte in (0u8..=127).filter(|byte| byte.is_ascii_whitespace()) {
+            let whitespace = char::from(byte);
+            let html =
+                format!("<{whitespace}f-template name=\"card\"><template></template></f-template>");
+            assert!(contains_f_template_name(html.as_bytes()));
+            assert!(
+                find_f_template_source(&html).is_some(),
+                "walker rejected ASCII whitespace byte {:#04x}",
+                byte
+            );
+        }
+    }
+
+    #[test]
+    fn precheck_rejects_sources_without_the_bare_name() {
+        for haystack in [
+            "<f-templat name=\"card\"></f-templat>",
+            "<f_template name=\"card\"></f_template>",
+            "<ftemplate name=\"card\"></ftemplate>",
+            "<template><span>{{title}}</span></template>",
+            "<template><span>ƒ-template ☃</span></template>",
+            "",
+            "f-templat",
+        ] {
+            assert!(!contains_f_template_name(haystack.as_bytes()));
+        }
+    }
+
+    #[test]
+    fn precheck_false_positive_in_text_comment_or_attribute_is_harmless() {
+        for html in [
+            r#"<template><span>the f-template directive is unused here</span></template>"#,
+            r#"<template><!-- f-template mentioned only in a comment --><span>{{title}}</span></template>"#,
+            r#"<template><span data-note="f-template">{{title}}</span></template>"#,
+            r#"<template><f-templatex></f-templatex></template>"#,
+        ] {
+            // The bare bytes are present, so the precheck reports a possible
+            // match, but no source contains an actual `<f-template>` element,
+            // so the authoritative walker still finds nothing.
+            assert!(contains_f_template_name(html.as_bytes()));
+            assert_eq!(
+                transform("plain-card", html).expect("transform"),
+                ComponentSourceResult::Unchanged
+            );
+        }
+    }
 }

From 36ed174879072927182fdd47d8daec7cdec91b50 Mon Sep 17 00:00:00 2001
From: Jane Chu <7559015+janechu@users.noreply.github.com>
Date: Mon, 10 Aug 2026 12:13:33 -0700
Subject: [PATCH 6/6] refactor: internalize FAST template conversion

Replace the external converter with an iterative in-tree implementation and preserve actionable FAST diagnostics. Update dependency metadata, tests, benchmarks, and user-facing documentation for the supported syntax.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: ed511a03-0959-4b9b-b067-0f77acedaa71
---
 Cargo.lock                                    |  24 +-
 Cargo.toml                                    |   1 -
 DESIGN.md                                     |  47 ++-
 README.md                                     |  20 +-
 crates/webui-parser/Cargo.toml                |   1 -
 crates/webui-parser/benches/parser_bench.rs   |   2 +-
 crates/webui-parser/src/component_registry.rs |  14 +-
 crates/webui-parser/src/diagnostic.rs         |   4 +
 .../webui-parser/src/plugin/fast_convert.rs   | 297 ++++++++++++++
 .../src/plugin/fast_convert/directive.rs      | 157 ++++++++
 .../src/plugin/fast_convert/error.rs          |  89 +++++
 .../src/plugin/fast_convert/scan.rs           |  75 ++++
 crates/webui-parser/src/plugin/fast_shared.rs | 369 ++++++++++++------
 crates/webui-parser/src/plugin/mod.rs         |   1 +
 docs/guide/concepts/plugins/index.md          |  36 +-
 15 files changed, 932 insertions(+), 205 deletions(-)
 create mode 100644 crates/webui-parser/src/plugin/fast_convert.rs
 create mode 100644 crates/webui-parser/src/plugin/fast_convert/directive.rs
 create mode 100644 crates/webui-parser/src/plugin/fast_convert/error.rs
 create mode 100644 crates/webui-parser/src/plugin/fast_convert/scan.rs

diff --git a/Cargo.lock b/Cargo.lock
index da76caae..35fc5375 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -289,7 +289,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -300,7 +300,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1081,7 +1081,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1777,15 +1777,6 @@ version = "2.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
 
-[[package]]
-name = "microsoft-fast-convert"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7343de729e1cd95b7d65814cf1f56ee7ab88f58330e1ef651e545404bccff955"
-dependencies = [
- "wasm-bindgen",
-]
-
 [[package]]
 name = "microsoft-webui"
 version = "0.0.23"
@@ -1935,7 +1926,6 @@ dependencies = [
  "clap",
  "criterion",
  "html-escape",
- "microsoft-fast-convert",
  "microsoft-webui-protocol",
  "microsoft-webui-test-utils",
  "microsoft-webui-tokens",
@@ -2745,7 +2735,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -2984,7 +2974,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52d1cfed4120b4d927bf7c0f86d2087a4a7d6027c906d9f9d525a80573b9be51"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3082,7 +3072,7 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3543,7 +3533,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 740e6429..d3d243ac 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -47,7 +47,6 @@ expand-tilde = "0.6.1"
 mime_guess = "2.0.5"
 html-escape = "0.2.14"
 include_dir = "0.7.4"
-microsoft-fast-convert = "0.9.0"
 async-stream = "0.3.6"
 futures-util = "0.3.32"
 tokio-stream = "0.1.18"
diff --git a/DESIGN.md b/DESIGN.md
index 40566c08..ad5df438 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -1275,42 +1275,41 @@ inner `<template>` elements are also invalid. Sources without an `<f-template>`
 return `ComponentSourceResult::Unchanged` and follow the normal component
 template path.
 
-For build-time SSR parsing, the transform adapts the `<f-template>` source for
-`microsoft-fast-convert` with the `webui-prerelease` target. Because the
-converter requires a non-empty name, the adapter supplies an internal name only
-to the converter when the source name is absent or empty. This internal value
-does not replace the filename-derived component tag or appear in the emitted
-client artifact. The returned inner template becomes the parser view returned
-as `TransformedComponentSource::parser_content`:
+For build-time SSR parsing, WebUI internally adapts supported FAST declarative
+constructs into the WebUI parser view. The adapted inner template becomes the
+parser view returned as `TransformedComponentSource::parser_content`:
 
 - `<f-repeat value="{{item in items}}">` converts to
   `<for each="item in items">`.
 - `<f-when value="{{condition}}">` converts to
   `<if condition="condition">`.
-- The converter unwraps the `value` expression for those directives. Text
+- The adaptation unwraps the `value` expression for those directives. Text
   `{{expression}}` bindings and `?boolean` bindings remain available to the
-  WebUI parser; ordinary attributes are not treated as additional converter
-  syntax.
+  WebUI parser; ordinary attributes are not treated as additional FAST
+  declarative syntax.
 - Unsupported `f-*` elements or attributes and malformed directive expressions
-  return structured authoring diagnostics. WebUI does not claim support for
-  FAST constructs that the converter rejects.
+  return structured authoring diagnostics. WebUI claims support only for the
+  FAST constructs described here. Stable codes are
+  `unsupported-multiple-f-templates` for multiple wrappers,
+  `invalid-fast-template` for unsupported or malformed FAST declarative syntax,
+  and the shared `unclosed-html-tag` for unclosed markup.
 - The FAST plugins' `classify_attribute` skips `@event`, `:property`, `f-ref`,
   `f-slotted`, and `f-children` and counts each as a binding, so they are
   absent from the SSR view while the hydration binding count still reflects
   them. No parser-core marker or FAST-named branch is involved.
 
-The transform separately returns the authored inner `<template>` as
-`TransformedComponentSource::artifact_content`, including its client-only
-bindings, rather than deriving it from the converted parser view. The FAST
-plugin wraps that retained source in the resolved `<f-template name="...">`
-for insertion. The artifact is normalized rather than preserved byte-for-byte:
-it passes through the same generic component-template processing as any other
-component, including wrapper normalization, selected CSS-strategy injection,
-module stylesheet adoption where applicable, legal-comment handling, and
-plugin artifact normalization. The deprecated `fast` selector aliases the
-FAST 2 implementation, while `fast_v2` and `fast_v3` use their respective
-hydration marker formats; all three share this transform, conversion, and
-artifact-retention behavior.
+The transform separately returns the authored `<f-template>` body as
+`TransformedComponentSource::artifact_content`, including its inner template
+and client-only bindings, rather than deriving it from the converted parser
+view. The FAST plugin wraps that retained source in the resolved
+`<f-template name="...">` for insertion. The artifact is normalized rather than
+preserved byte-for-byte: it passes through the same generic component-template
+processing as any other component, including wrapper normalization, selected
+CSS-strategy injection, module stylesheet adoption where applicable,
+legal-comment handling, and plugin artifact normalization. The deprecated
+`fast` selector aliases the FAST 2 implementation, while `fast_v2` and `fast_v3`
+use their respective hydration marker formats; all three share this transform,
+conversion, and artifact-retention behavior.
 
 WebUI itself does not interpret plugin-emitted bytes; each parser plugin pairs with
 a matching handler plugin that consumes them at render time. See [packages/webui-framework/README.md](packages/webui-framework/README.md)
diff --git a/README.md b/README.md
index 4d9916c5..393c5680 100644
--- a/README.md
+++ b/README.md
@@ -24,18 +24,18 @@ filename; an absent or whitespace-only name keeps the filename-derived tag. The
 wrapper must contain exactly one inner `<template>`. Unsupported FAST syntax and
 multiple `<f-template>` blocks fail the build with an authoring diagnostic.
 
-For build-time SSR, WebUI adapts the source for `microsoft-fast-convert` and its
-`webui-prerelease` target, supplying a converter-only name when the authored
-name is absent or empty. The converter rewrites supported `<f-repeat>` and
-`<f-when>` directives to WebUI `<for>` and `<if>` directives while preserving
-text interpolation and boolean bindings. WebUI then removes client-only
+For build-time SSR, WebUI internally adapts supported FAST declarative
+constructs into its parser view. It converts `<f-repeat>` and `<f-when>`
+directives to WebUI `<for>` and `<if>` directives while preserving text
+interpolation and boolean bindings. An absent or empty authored name continues
+to use the filename-derived component tag. WebUI then removes client-only
 `@event`, `:property`, `f-ref`, `f-slotted`, and `f-children` attributes from the
 SSR view while retaining their binding counts for FAST hydration. The authored
-inner template, including its client bindings, is retained for the emitted
-`<f-template>` instead of being regenerated from the SSR conversion. It still
-receives normal wrapper normalization, legal comment processing, and CSS
-injection for the selected strategy. Component HTML without an `<f-template>`
-continues through the normal WebUI template path.
+`<f-template>` body, including its inner template and client bindings, is
+retained for the emitted `<f-template>` instead of being regenerated from the
+SSR conversion. It still receives normal wrapper normalization, legal comment
+processing, and CSS injection for the selected strategy. Component HTML without
+an `<f-template>` continues through the normal WebUI template path.
 
 ## Install
 
diff --git a/crates/webui-parser/Cargo.toml b/crates/webui-parser/Cargo.toml
index b048d12b..486494a5 100644
--- a/crates/webui-parser/Cargo.toml
+++ b/crates/webui-parser/Cargo.toml
@@ -30,7 +30,6 @@ microsoft-webui-protocol = { path = "../webui-protocol", version = "0.0.23" }
 microsoft-webui-tokens = { path = "../webui-tokens", version = "0.0.23" }
 thiserror = { workspace = true }
 html-escape = { workspace = true }
-microsoft-fast-convert = { workspace = true }
 walkdir = { workspace = true, optional = true }
 clap = { workspace = true, optional = true }
 sha2 = { workspace = true }
diff --git a/crates/webui-parser/benches/parser_bench.rs b/crates/webui-parser/benches/parser_bench.rs
index ae2b07d0..aaec25b1 100644
--- a/crates/webui-parser/benches/parser_bench.rs
+++ b/crates/webui-parser/benches/parser_bench.rs
@@ -333,7 +333,7 @@ fn build_ordinary_component_source(depth: usize) -> String {
 }
 
 /// Authored FAST component source: the transform must walk it, resolve the
-/// `<f-template name>`, and run the `microsoft-fast-convert` conversion.
+/// `<f-template name>`, and run the internal FAST-to-WebUI conversion.
 fn build_fast_component_source(depth: usize) -> String {
     let mut html = String::with_capacity(depth * 63 + 128);
     html.push_str("<f-template name=\"x-registration-bench\"><template>");
diff --git a/crates/webui-parser/src/component_registry.rs b/crates/webui-parser/src/component_registry.rs
index d757c9ea..28dbf883 100644
--- a/crates/webui-parser/src/component_registry.rs
+++ b/crates/webui-parser/src/component_registry.rs
@@ -179,7 +179,7 @@ impl ComponentRegistry {
     ///
     /// When no transform is installed, or it returns
     /// [`ComponentSourceResult::Unchanged`], the filename-derived tag and the
-    /// authored HTML are preserved without extra allocation.
+    /// authored HTML are preserved without transforming their contents.
     fn resolve_component_source(
         &self,
         tag_name: &str,
@@ -295,11 +295,7 @@ impl ComponentRegistry {
 
         let render_policy =
             parse_component_render_policy(&resolved.tag_name, &resolved.parser_content)?;
-        Self::append_scoped_policy_css(
-            &mut css_content,
-            &render_policy,
-            &resolved.tag_name,
-        );
+        Self::append_scoped_policy_css(&mut css_content, &render_policy, &resolved.tag_name);
 
         // Create and register the component
         let component = Component {
@@ -356,11 +352,7 @@ impl ComponentRegistry {
 
         let render_policy =
             parse_component_render_policy(&resolved.tag_name, &resolved.parser_content)?;
-        Self::append_scoped_policy_css(
-            &mut css_content,
-            &render_policy,
-            &resolved.tag_name,
-        );
+        Self::append_scoped_policy_css(&mut css_content, &render_policy, &resolved.tag_name);
         let component: Component = Component {
             tag_name: resolved.tag_name,
             html_content: resolved.parser_content,
diff --git a/crates/webui-parser/src/diagnostic.rs b/crates/webui-parser/src/diagnostic.rs
index 10e2224d..4a474fd4 100644
--- a/crates/webui-parser/src/diagnostic.rs
+++ b/crates/webui-parser/src/diagnostic.rs
@@ -95,6 +95,10 @@ pub mod codes {
     pub const EXCESSIVE_NESTING: &str = "excessive-nesting";
     /// A template references itself (directly or transitively) at build time.
     pub const RECURSIVE_TEMPLATE: &str = "recursive-template";
+    /// A FAST component source contains more than one `<f-template>` element.
+    pub const UNSUPPORTED_MULTIPLE_F_TEMPLATES: &str = "unsupported-multiple-f-templates";
+    /// A FAST component source uses malformed or unsupported declarative syntax.
+    pub const INVALID_FAST_TEMPLATE: &str = "invalid-fast-template";
     /// A `<style>` block contains malformed CSS.
     pub const INVALID_CSS: &str = "invalid-css";
     /// A CSS token required by parser output is missing from the configured theme.
diff --git a/crates/webui-parser/src/plugin/fast_convert.rs b/crates/webui-parser/src/plugin/fast_convert.rs
new file mode 100644
index 00000000..2141d9f4
--- /dev/null
+++ b/crates/webui-parser/src/plugin/fast_convert.rs
@@ -0,0 +1,297 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+//! Focused FAST declarative-template conversion for WebUI SSR parsing.
+
+mod directive;
+mod error;
+mod scan;
+
+pub(super) use error::{ConvertError, ConvertErrorKind};
+
+use crate::html_parser::{find_comment_close, find_matching_end, parse_tag, Tag};
+use directive::{
+    directive_expression, is_repeat_expression, validate_attributes, validate_directive_attributes,
+    DirectiveKind,
+};
+use scan::{find_tag_end, read_opening_tag_name, scan_named_open_tags};
+use std::ops::Range;
+
+pub(super) const F_TEMPLATE_NAME: &str = "f-template";
+const INNER_TEMPLATE_NAME: &str = "template";
+
+/// Converted parser and artifact views for one authored `<f-template>`.
+pub(super) struct ConvertedTemplate<'a> {
+    pub(super) name: Option<&'a str>,
+    pub(super) artifact: Range<usize>,
+    pub(super) parser_content: String,
+}
+
+/// Convert the single `<f-template>` in `source` to WebUI parser syntax.
+///
+/// Returns `None` when no `<f-template>` element is present.
+pub(super) fn convert_template(
+    source: &str,
+) -> Result<Option<ConvertedTemplate<'_>>, ConvertError<'_>> {
+    let f_templates = scan_named_open_tags(source, 0..source.len(), F_TEMPLATE_NAME);
+    let Some(f_template_start) = f_templates.first else {
+        return Ok(None);
+    };
+    if f_templates.count != 1 {
+        return Err(ConvertError::new(
+            ConvertErrorKind::MultipleFTemplates {
+                count: f_templates.count,
+            },
+            f_template_start,
+        ));
+    }
+
+    let f_template_end = find_tag_end(source, f_template_start, source.len())
+        .ok_or_else(|| ConvertError::new(ConvertErrorKind::UnclosedTag, f_template_start))?;
+    let f_template = parse_tag(&source[f_template_start..f_template_end])
+        .ok_or_else(|| ConvertError::new(ConvertErrorKind::UnclosedTag, f_template_start))?;
+    if f_template.self_closing {
+        return Err(ConvertError::new(
+            ConvertErrorKind::UnclosedElement {
+                tag: f_template.name,
+            },
+            f_template_start,
+        ));
+    }
+    let (f_template_close, _) = find_matching_end(source, f_template.name, f_template_end)
+        .ok_or_else(|| {
+            ConvertError::new(
+                ConvertErrorKind::UnclosedElement {
+                    tag: f_template.name,
+                },
+                f_template_start,
+            )
+        })?;
+    let artifact = f_template_end..f_template_close;
+    let inner_templates = scan_named_open_tags(source, artifact.clone(), INNER_TEMPLATE_NAME);
+    let Some(inner_start) = inner_templates.first else {
+        return Err(ConvertError::new(
+            ConvertErrorKind::MissingInnerTemplate,
+            f_template_start,
+        ));
+    };
+    if inner_templates.count != 1 {
+        return Err(ConvertError::new(
+            ConvertErrorKind::MultipleInnerTemplates {
+                count: inner_templates.count,
+            },
+            f_template_start,
+        ));
+    }
+
+    let inner_open_end = find_tag_end(source, inner_start, artifact.end).ok_or_else(|| {
+        ConvertError::new(
+            ConvertErrorKind::UnclosedElement {
+                tag: INNER_TEMPLATE_NAME,
+            },
+            inner_start,
+        )
+    })?;
+    let inner_template = parse_tag(&source[inner_start..inner_open_end]).ok_or_else(|| {
+        ConvertError::new(
+            ConvertErrorKind::UnclosedElement {
+                tag: INNER_TEMPLATE_NAME,
+            },
+            inner_start,
+        )
+    })?;
+    if inner_template.self_closing {
+        return Err(ConvertError::new(
+            ConvertErrorKind::UnclosedElement {
+                tag: inner_template.name,
+            },
+            inner_start,
+        ));
+    }
+    let (_, inner_close_end) =
+        find_matching_end(&source[..artifact.end], inner_template.name, inner_open_end)
+            .ok_or_else(|| {
+                ConvertError::new(
+                    ConvertErrorKind::UnclosedElement {
+                        tag: inner_template.name,
+                    },
+                    inner_start,
+                )
+            })?;
+
+    let parser_content = convert_segment(source, inner_start..inner_close_end)?;
+    let name = f_template
+        .attr("name")
+        .map(str::trim)
+        .filter(|name| !name.is_empty());
+
+    Ok(Some(ConvertedTemplate {
+        name,
+        artifact,
+        parser_content,
+    }))
+}
+
+/// Iterative conversion state for nested FAST directives.
+struct ConvertState {
+    output: String,
+    directives: Vec<DirectiveFrame>,
+}
+
+#[derive(Clone, Copy)]
+struct DirectiveFrame {
+    kind: DirectiveKind,
+    offset: usize,
+}
+
+fn convert_segment<'a>(source: &'a str, range: Range<usize>) -> Result<String, ConvertError<'a>> {
+    let mut state = ConvertState {
+        output: String::with_capacity(range.len()),
+        directives: Vec::with_capacity(4),
+    };
+    let mut cursor = range.start;
+
+    while cursor < range.end {
+        let Some(relative) = source[cursor..range.end].find('<') else {
+            state.output.push_str(&source[cursor..range.end]);
+            break;
+        };
+        let start = cursor + relative;
+        state.output.push_str(&source[cursor..start]);
+
+        let remaining = &source[start..range.end];
+        if remaining.starts_with("<!--") {
+            let Some(length) = find_comment_close(remaining) else {
+                state.output.push_str(remaining);
+                cursor = range.end;
+                continue;
+            };
+            let end = start + length;
+            state.output.push_str(&source[start..end]);
+            cursor = end;
+            continue;
+        }
+
+        let Some(end) = find_tag_end(source, start, range.end) else {
+            if read_opening_tag_name(source, start, range.end).is_some() {
+                return Err(ConvertError::new(ConvertErrorKind::UnclosedTag, start));
+            }
+            state.output.push('<');
+            cursor = start + 1;
+            continue;
+        };
+        convert_tag(source, start, end, &mut state)?;
+        cursor = end;
+    }
+
+    if let Some(frame) = state.directives.first().copied() {
+        return Err(ConvertError::new(
+            ConvertErrorKind::UnclosedElement {
+                tag: frame.kind.tag_name(),
+            },
+            frame.offset,
+        ));
+    }
+
+    Ok(state.output)
+}
+
+fn convert_tag<'a>(
+    source: &'a str,
+    start: usize,
+    end: usize,
+    state: &mut ConvertState,
+) -> Result<(), ConvertError<'a>> {
+    let Some(tag) = parse_tag(&source[start..end]) else {
+        state.output.push_str(&source[start..end]);
+        return Ok(());
+    };
+
+    let raw = &source[start..end];
+    if tag.closing {
+        convert_closing_tag(&tag, raw, state)
+    } else {
+        convert_opening_tag(&tag, raw, start, state)
+    }
+}
+
+fn convert_opening_tag<'a>(
+    tag: &Tag<'a>,
+    raw: &'a str,
+    start: usize,
+    state: &mut ConvertState,
+) -> Result<(), ConvertError<'a>> {
+    if let Some(kind) = DirectiveKind::from_tag_name(tag.name) {
+        return convert_directive(tag, kind, start, state);
+    }
+    if tag.name.starts_with("f-") {
+        return Err(ConvertError::new(
+            ConvertErrorKind::UnsupportedFElement { tag: tag.name },
+            start,
+        ));
+    }
+
+    validate_attributes(tag, start)?;
+    state.output.push_str(raw);
+    Ok(())
+}
+
+fn convert_closing_tag<'a>(
+    tag: &Tag<'a>,
+    raw: &'a str,
+    state: &mut ConvertState,
+) -> Result<(), ConvertError<'a>> {
+    let Some(kind) = DirectiveKind::from_tag_name(tag.name) else {
+        state.output.push_str(raw);
+        return Ok(());
+    };
+
+    if state.directives.last().map(|frame| frame.kind) == Some(kind) {
+        state.directives.pop();
+        state.output.push_str(kind.output_close());
+        return Ok(());
+    }
+    if state.directives.iter().any(|frame| frame.kind == kind) {
+        if let Some(unclosed) = state.directives.last().copied() {
+            return Err(ConvertError::new(
+                ConvertErrorKind::UnclosedElement {
+                    tag: unclosed.kind.tag_name(),
+                },
+                unclosed.offset,
+            ));
+        }
+    }
+
+    state.output.push_str(raw);
+    Ok(())
+}
+
+fn convert_directive<'a>(
+    tag: &Tag<'a>,
+    kind: DirectiveKind,
+    offset: usize,
+    state: &mut ConvertState,
+) -> Result<(), ConvertError<'a>> {
+    validate_directive_attributes(tag, offset)?;
+    let expression = directive_expression(tag, kind, offset)?;
+    if kind == DirectiveKind::Repeat && !is_repeat_expression(expression) {
+        return Err(ConvertError::new(
+            ConvertErrorKind::InvalidRepeatExpression { expr: expression },
+            offset,
+        ));
+    }
+    if tag.self_closing {
+        return Err(ConvertError::new(
+            ConvertErrorKind::UnclosedElement {
+                tag: kind.tag_name(),
+            },
+            offset,
+        ));
+    }
+
+    state.output.push_str(kind.output_open());
+    state.output.push_str(expression);
+    state.output.push_str("\">");
+    state.directives.push(DirectiveFrame { kind, offset });
+    Ok(())
+}
diff --git a/crates/webui-parser/src/plugin/fast_convert/directive.rs b/crates/webui-parser/src/plugin/fast_convert/directive.rs
new file mode 100644
index 00000000..6eb04747
--- /dev/null
+++ b/crates/webui-parser/src/plugin/fast_convert/directive.rs
@@ -0,0 +1,157 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+use super::{ConvertError, ConvertErrorKind};
+use crate::html_parser::Tag;
+
+const F_REPEAT_NAME: &str = "f-repeat";
+const F_WHEN_NAME: &str = "f-when";
+
+pub(super) fn validate_directive_attributes<'a>(
+    tag: &Tag<'a>,
+    tag_offset: usize,
+) -> Result<(), ConvertError<'a>> {
+    for attr in tag.attrs() {
+        if attr.name.starts_with("f-") {
+            return Err(ConvertError::new(
+                ConvertErrorKind::UnsupportedFAttribute {
+                    attribute: attr.name,
+                },
+                tag_offset + attr.raw_range.start,
+            ));
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn validate_attributes<'a>(
+    tag: &Tag<'a>,
+    tag_offset: usize,
+) -> Result<(), ConvertError<'a>> {
+    for attr in tag.attrs() {
+        if attr.name.starts_with("f-") && !is_supported_f_attribute(attr.name) {
+            return Err(ConvertError::new(
+                ConvertErrorKind::UnsupportedFAttribute {
+                    attribute: attr.name,
+                },
+                tag_offset + attr.raw_range.start,
+            ));
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn directive_expression<'a>(
+    tag: &Tag<'a>,
+    kind: DirectiveKind,
+    tag_offset: usize,
+) -> Result<&'a str, ConvertError<'a>> {
+    let value_attr = tag.attrs().find(|attr| attr.name == "value");
+    let Some(value_attr) = value_attr else {
+        return Err(ConvertError::new(
+            ConvertErrorKind::MissingValueAttribute {
+                tag: kind.tag_name(),
+            },
+            tag_offset,
+        ));
+    };
+    let Some(value) = value_attr.value else {
+        return Err(ConvertError::new(
+            ConvertErrorKind::MissingValueAttribute {
+                tag: kind.tag_name(),
+            },
+            tag_offset + value_attr.raw_range.start,
+        ));
+    };
+    let value_offset = tag_offset + value_attr.raw_range.start;
+    let trimmed = value.trim();
+    if !trimmed.starts_with("{{") || !trimmed.ends_with("}}") || trimmed.len() <= 4 {
+        return Err(ConvertError::new(
+            ConvertErrorKind::InvalidDirectiveValue {
+                tag: kind.tag_name(),
+                value,
+            },
+            value_offset,
+        ));
+    }
+
+    let expression = trimmed[2..trimmed.len() - 2].trim();
+    if expression.is_empty() {
+        return Err(ConvertError::new(
+            ConvertErrorKind::InvalidDirectiveValue {
+                tag: kind.tag_name(),
+                value,
+            },
+            value_offset,
+        ));
+    }
+    Ok(expression)
+}
+
+pub(super) fn is_repeat_expression(expression: &str) -> bool {
+    let mut parts = expression.split_whitespace();
+    match (parts.next(), parts.next(), parts.next(), parts.next()) {
+        (Some(alias), Some("in"), Some(path), None) => is_identifier(alias) && is_path(path),
+        _ => false,
+    }
+}
+
+#[inline]
+fn is_supported_f_attribute(name: &str) -> bool {
+    matches!(name, "f-ref" | "f-children" | "f-slotted")
+}
+
+fn is_path(path: &str) -> bool {
+    let mut parts = path.split('.');
+    parts.next().is_some_and(is_identifier) && parts.all(is_identifier)
+}
+
+fn is_identifier(identifier: &str) -> bool {
+    let mut chars = identifier.chars();
+    let Some(first) = chars.next() else {
+        return false;
+    };
+    (first == '_' || first == '$' || first.is_ascii_alphabetic())
+        && chars.all(|ch| ch == '_' || ch == '$' || ch.is_ascii_alphanumeric())
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum DirectiveKind {
+    Repeat,
+    When,
+}
+
+impl DirectiveKind {
+    #[inline]
+    pub(super) fn from_tag_name(name: &str) -> Option<Self> {
+        match name {
+            F_REPEAT_NAME => Some(Self::Repeat),
+            F_WHEN_NAME => Some(Self::When),
+            _ => None,
+        }
+    }
+
+    #[inline]
+    pub(super) fn tag_name(self) -> &'static str {
+        match self {
+            Self::Repeat => F_REPEAT_NAME,
+            Self::When => F_WHEN_NAME,
+        }
+    }
+
+    #[inline]
+    pub(super) fn output_open(self) -> &'static str {
+        match self {
+            Self::Repeat => "<for each=\"",
+            Self::When => "<if condition=\"",
+        }
+    }
+
+    #[inline]
+    pub(super) fn output_close(self) -> &'static str {
+        match self {
+            Self::Repeat => "</for>",
+            Self::When => "</if>",
+        }
+    }
+}
diff --git a/crates/webui-parser/src/plugin/fast_convert/error.rs b/crates/webui-parser/src/plugin/fast_convert/error.rs
new file mode 100644
index 00000000..88ec4dc3
--- /dev/null
+++ b/crates/webui-parser/src/plugin/fast_convert/error.rs
@@ -0,0 +1,89 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+use std::fmt;
+
+/// FAST conversion failure and the source offset used for its diagnostic.
+#[derive(Debug)]
+pub(crate) struct ConvertError<'a> {
+    kind: ConvertErrorKind<'a>,
+    offset: usize,
+}
+
+impl<'a> ConvertError<'a> {
+    #[cold]
+    #[inline(never)]
+    pub(super) fn new(kind: ConvertErrorKind<'a>, offset: usize) -> Self {
+        Self { kind, offset }
+    }
+
+    #[inline]
+    pub(crate) fn kind(&self) -> &ConvertErrorKind<'a> {
+        &self.kind
+    }
+
+    #[inline]
+    pub(crate) fn offset(&self) -> usize {
+        self.offset
+    }
+}
+
+impl fmt::Display for ConvertError<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.kind {
+            ConvertErrorKind::MultipleFTemplates { count } => write!(
+                f,
+                "template validation error: expected exactly one '<f-template>' element, found {count}"
+            ),
+            ConvertErrorKind::MissingInnerTemplate => write!(
+                f,
+                "template validation error: '<f-template>' must contain exactly one inner '<template>' element"
+            ),
+            ConvertErrorKind::MultipleInnerTemplates { count } => write!(
+                f,
+                "template validation error: '<f-template>' must contain exactly one inner '<template>' element, found {count}"
+            ),
+            ConvertErrorKind::UnclosedElement { tag } => write!(
+                f,
+                "unclosed element '<{tag}>': no matching '</{tag}>' closing tag was found"
+            ),
+            ConvertErrorKind::UnclosedTag => {
+                f.write_str("unclosed tag: no closing '>' was found")
+            }
+            ConvertErrorKind::MissingValueAttribute { tag } => write!(
+                f,
+                "directive '<{tag}>' is missing a valid 'value=\"{{{{…}}}}\"' attribute"
+            ),
+            ConvertErrorKind::InvalidDirectiveValue { tag, value } => write!(
+                f,
+                "directive '<{tag}>' has invalid value '{}': expected 'value=\"{{{{…}}}}\"'",
+                value
+            ),
+            ConvertErrorKind::InvalidRepeatExpression { expr } => write!(
+                f,
+                "invalid repeat expression '{{{{{expr}}}}}': expected 'item in items' format"
+            ),
+            ConvertErrorKind::UnsupportedFAttribute { attribute } => {
+                write!(f, "unsupported f-* attribute '{attribute}'")
+            }
+            ConvertErrorKind::UnsupportedFElement { tag } => {
+                write!(f, "unsupported f-* element '<{tag}>'")
+            }
+        }
+    }
+}
+
+/// FAST conversion error categories used to select stable WebUI diagnostics.
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum ConvertErrorKind<'a> {
+    MultipleFTemplates { count: usize },
+    MissingInnerTemplate,
+    MultipleInnerTemplates { count: usize },
+    UnclosedElement { tag: &'a str },
+    UnclosedTag,
+    MissingValueAttribute { tag: &'static str },
+    InvalidDirectiveValue { tag: &'static str, value: &'a str },
+    InvalidRepeatExpression { expr: &'a str },
+    UnsupportedFAttribute { attribute: &'a str },
+    UnsupportedFElement { tag: &'a str },
+}
diff --git a/crates/webui-parser/src/plugin/fast_convert/scan.rs b/crates/webui-parser/src/plugin/fast_convert/scan.rs
new file mode 100644
index 00000000..cf14deca
--- /dev/null
+++ b/crates/webui-parser/src/plugin/fast_convert/scan.rs
@@ -0,0 +1,75 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+use crate::html_parser::{find_comment_close, find_tag_close};
+use std::ops::Range;
+
+/// Opening-tag scan result without allocating a collection of offsets.
+pub(super) struct NamedTagMatches {
+    pub(super) first: Option<usize>,
+    pub(super) count: usize,
+}
+
+/// Scan opening tags across a bounded source range, ignoring comments.
+pub(super) fn scan_named_open_tags(
+    source: &str,
+    range: Range<usize>,
+    target: &str,
+) -> NamedTagMatches {
+    let mut first = None;
+    let mut count = 0usize;
+    let mut cursor = range.start;
+
+    while cursor < range.end {
+        let Some(relative) = source[cursor..range.end].find('<') else {
+            break;
+        };
+        let start = cursor + relative;
+        let remaining = &source[start..range.end];
+        if remaining.starts_with("<!--") {
+            cursor = find_comment_close(remaining).map_or(range.end, |length| start + length);
+            continue;
+        }
+
+        if read_opening_tag_name(source, start, range.end)
+            .is_some_and(|name| name.eq_ignore_ascii_case(target))
+        {
+            first.get_or_insert(start);
+            count += 1;
+        }
+        cursor = find_tag_end(source, start, range.end).unwrap_or(start + 1);
+    }
+
+    NamedTagMatches { first, count }
+}
+
+/// Find the end after `>` for one tag without scanning beyond `range_end`.
+#[inline]
+pub(super) fn find_tag_end(source: &str, start: usize, range_end: usize) -> Option<usize> {
+    find_tag_close(&source[start..range_end]).map(|close| start + close + 1)
+}
+
+/// Read an opening tag name without requiring a terminating `>`.
+pub(super) fn read_opening_tag_name(source: &str, start: usize, range_end: usize) -> Option<&str> {
+    let bytes = source.as_bytes();
+    if bytes.get(start) != Some(&b'<') {
+        return None;
+    }
+    let mut cursor = start + 1;
+    if matches!(bytes.get(cursor), Some(b'/') | Some(b'!') | Some(b'?')) {
+        return None;
+    }
+    while cursor < range_end && bytes[cursor].is_ascii_whitespace() {
+        cursor += 1;
+    }
+
+    let name_start = cursor;
+    while cursor < range_end
+        && !bytes[cursor].is_ascii_whitespace()
+        && bytes[cursor] != b'>'
+        && bytes[cursor] != b'/'
+    {
+        cursor += 1;
+    }
+    (cursor != name_start).then_some(&source[name_start..cursor])
+}
diff --git a/crates/webui-parser/src/plugin/fast_shared.rs b/crates/webui-parser/src/plugin/fast_shared.rs
index 06f6437f..e1446bc1 100644
--- a/crates/webui-parser/src/plugin/fast_shared.rs
+++ b/crates/webui-parser/src/plugin/fast_shared.rs
@@ -6,48 +6,24 @@
 //! This module owns everything FAST-specific about turning an authored
 //! `<f-template>` component source into the WebUI parser view: scanning for the
 //! single `<f-template>` element, resolving its `name` (falling back to the
-//! filename-derived tag), invoking `microsoft-fast-convert`, retaining the
-//! authored inner `<template>` for the client artifact, and constructing FAST
+//! filename-derived tag), converting supported FAST directives, retaining the
+//! authored `<f-template>` body for the client artifact, and constructing FAST
 //! diagnostics. The FAST parser plugins expose it through the framework-neutral
 //! [`ParserPlugin::component_source_transform`](super::ParserPlugin::component_source_transform)
 //! hook; the parser core never references FAST.
 
+use super::fast_convert::{convert_template, ConvertError, ConvertErrorKind, F_TEMPLATE_NAME};
 use super::{ComponentSource, ComponentSourceResult, TransformedComponentSource};
 use crate::diagnostic::{codes, Diagnostic};
-use crate::html_parser::{Event, Walker};
 use crate::{ParserError, Result};
-use microsoft_fast_convert::{convert_template, ConvertError};
-use std::borrow::Cow;
-use std::ops::Range;
-
-/// Diagnostic code for a component source with multiple `<f-template>` blocks.
-const UNSUPPORTED_MULTIPLE_F_TEMPLATES: &str = "unsupported-multiple-f-templates";
-/// Diagnostic code for a FAST template that cannot be converted to WebUI syntax.
-const INVALID_FAST_TEMPLATE: &str = "invalid-fast-template";
-/// Placeholder `<f-template name>` supplied to the converter when the authored
-/// source omits a usable name; the resolved registry key is the filename.
-const CONVERTER_FALLBACK_NAME: &str = "webui-fallback";
-/// Target dialect requested from `microsoft-fast-convert`.
-const WEBUI_CONVERTER_SYNTAX: &str = "webui-prerelease";
-/// The FAST element name used by both the authoritative [`Walker`] match in
-/// [`find_f_template_source`] and the cheap byte precheck in
-/// [`contains_f_template_name`], preventing false negatives from name drift.
-const F_TEMPLATE_NAME: &str = "f-template";
-
-/// Located `<f-template>` element within an authored component source.
-struct FTemplateSource {
-    name: Option<String>,
-    start: usize,
-    inner: Range<usize>,
-}
 
 /// Component-source transform for FAST authored templates.
 ///
 /// Returns [`ComponentSourceResult::Unchanged`] when the source contains no
 /// `<f-template>`; otherwise converts the FAST declarative syntax to the WebUI
 /// parser view, resolves the registry key from the `<f-template name>`
-/// attribute (or the filename), and retains the authored inner `<template>` as
-/// the client artifact.
+/// attribute (or the filename), and retains the authored `<f-template>` body
+/// as the client artifact.
 ///
 /// A cheap byte precheck ([`contains_f_template_name`]) rules out sources that
 /// cannot possibly contain an `<f-template>` element, so ordinary FAST-free
@@ -65,20 +41,19 @@ pub(crate) fn transform_component_source(
         return Ok(ComponentSourceResult::Unchanged);
     }
 
-    let Some(found) = find_f_template_source(html_content) else {
+    let Some(converted) =
+        convert_template(html_content).map_err(|error| converter_error(html_content, &error))?
+    else {
         return Ok(ComponentSourceResult::Unchanged);
     };
 
-    let resolved_tag = found.name.as_deref().unwrap_or(source.tag_name).to_string();
-    let converter_input = converter_input(html_content, &found);
-    let converted = convert_template(&converter_input, WEBUI_CONVERTER_SYNTAX)
-        .map_err(|error| converter_error(html_content, found.start, error))?;
-    let artifact_content = html_content[found.inner].trim().to_string();
+    let resolved_tag = converted.name.unwrap_or(source.tag_name).to_string();
+    let artifact_content = html_content[converted.artifact].trim().to_string();
 
     Ok(ComponentSourceResult::Transformed(
         TransformedComponentSource {
             tag_name: resolved_tag,
-            parser_content: converted,
+            parser_content: converted.parser_content,
             artifact_content: Some(artifact_content),
         },
     ))
@@ -87,16 +62,14 @@ pub(crate) fn transform_component_source(
 /// Cheap case-insensitive precheck for the bare ASCII name `f-template`
 /// anywhere in `haystack`, without the surrounding `<` delimiter.
 ///
-/// The HTML [`Walker`] takes an opening element name to be the run of bytes
-/// after `<` (skipping ASCII whitespace) and matches it
-/// ASCII-case-insensitively, so every spelling it accepts contains these ten
-/// bytes verbatim, case aside. Searching for the bare name therefore has no
-/// false negatives, whereas searching for `"<f-template"` would. Non-ASCII
-/// bytes are compared without case folding, so UTF-8 input can neither panic
-/// nor be misread. False positives (the bytes appearing in text, comments,
-/// attributes, or longer names) only cost the walk that would have happened
-/// anyway: [`find_f_template_source`] remains authoritative and still reports
-/// `Unchanged`.
+/// The converter takes an opening element name to be the run of bytes after `<`
+/// (skipping ASCII whitespace) and matches it ASCII-case-insensitively, so every
+/// spelling it accepts contains these ten bytes verbatim, case aside. Searching
+/// for the bare name therefore has no false negatives, whereas searching for
+/// `"<f-template"` would. Non-ASCII bytes are compared without case folding, so
+/// UTF-8 input can neither panic nor be misread. False positives (the bytes
+/// appearing in text, comments, attributes, or longer names) only cost the
+/// authoritative conversion scan, which still reports `Unchanged`.
 #[inline]
 fn contains_f_template_name(haystack: &[u8]) -> bool {
     haystack
@@ -104,64 +77,14 @@ fn contains_f_template_name(haystack: &[u8]) -> bool {
         .any(|window| window.eq_ignore_ascii_case(F_TEMPLATE_NAME.as_bytes()))
 }
 
-/// Find the first `<f-template>` element anywhere in the authored source.
-fn find_f_template_source(html_content: &str) -> Option<FTemplateSource> {
-    let mut stack = Vec::with_capacity(1);
-    stack.push(0..html_content.len());
-
-    while let Some(range) = stack.pop() {
-        for event in Walker::new_range(html_content, range.start, range.end) {
-            let Event::Element(element) = event else {
-                continue;
-            };
-
-            if element.name().eq_ignore_ascii_case(F_TEMPLATE_NAME) {
-                return Some(FTemplateSource {
-                    name: element
-                        .attr("name")
-                        .map(str::trim)
-                        .filter(|name| !name.is_empty())
-                        .map(str::to_string),
-                    start: element.start,
-                    inner: element.inner(),
-                });
-            }
-
-            if !element.self_closing() && !element.is_void() {
-                stack.push(element.inner());
-            }
-        }
-    }
-
-    None
-}
-
-/// Build the converter input, injecting a placeholder name when the authored
-/// `<f-template>` omits a usable one so the converter's validation is satisfied
-/// without leaking the placeholder into the resolved registry key.
-fn converter_input<'a>(html_content: &'a str, source: &FTemplateSource) -> Cow<'a, str> {
-    if source.name.is_some() {
-        return Cow::Borrowed(html_content);
-    }
-
-    let mut normalized =
-        String::with_capacity(html_content.len() + CONVERTER_FALLBACK_NAME.len() + 20);
-    normalized.push_str(&html_content[..source.start]);
-    normalized.push_str("<f-template name=\"");
-    normalized.push_str(CONVERTER_FALLBACK_NAME);
-    normalized.push_str("\">");
-    normalized.push_str(&html_content[source.inner.start..]);
-    Cow::Owned(normalized)
-}
-
 /// Build a [`Diagnostic`] error from a converter failure.
 #[cold]
 #[inline(never)]
-fn converter_error(source: &str, offset: usize, error: ConvertError) -> ParserError {
-    if matches!(error, ConvertError::MultipleFTemplates { .. }) {
+fn converter_error(source: &str, error: &ConvertError<'_>) -> ParserError {
+    if matches!(error.kind(), ConvertErrorKind::MultipleFTemplates { .. }) {
         return Diagnostic::error("multiple <f-template> elements are not supported")
-            .code(UNSUPPORTED_MULTIPLE_F_TEMPLATES)
-            .at_offset(source, offset)
+            .code(codes::UNSUPPORTED_MULTIPLE_F_TEMPLATES)
+            .at_offset(source, error.offset())
             .snippet("<f-template>")
             .help(
                 "keep only one <f-template> per component file; multiple f-template blocks are not currently supported",
@@ -169,47 +92,76 @@ fn converter_error(source: &str, offset: usize, error: ConvertError) -> ParserEr
             .into();
     }
 
-    let help = match &error {
-        ConvertError::MissingFTemplateName | ConvertError::EmptyFTemplateName => {
-            "add a non-empty name attribute to <f-template>, for example <f-template name=\"my-component\">"
-        }
-        ConvertError::MissingInnerTemplate | ConvertError::MultipleInnerTemplates { .. } => {
+    let help = match error.kind() {
+        ConvertErrorKind::MissingInnerTemplate
+        | ConvertErrorKind::MultipleInnerTemplates { .. } => {
             "keep exactly one inner <template> element inside <f-template>"
         }
-        ConvertError::MissingValueAttribute { .. }
-        | ConvertError::InvalidDirectiveValue { .. } => {
+        ConvertErrorKind::MissingValueAttribute { .. }
+        | ConvertErrorKind::InvalidDirectiveValue { .. } => {
             "add the required value=\"{{expression}}\" attribute to the FAST directive"
         }
-        ConvertError::InvalidRepeatExpression { .. } => {
+        ConvertErrorKind::InvalidRepeatExpression { .. } => {
             "use an f-repeat expression in \"item in items\" form"
         }
-        ConvertError::UnclosedElement { .. } | ConvertError::UnclosedTag { .. } => {
+        ConvertErrorKind::UnclosedElement { .. } | ConvertErrorKind::UnclosedTag => {
             "close the reported FAST template element or opening tag"
         }
-        ConvertError::UnsupportedFAttribute { .. }
-        | ConvertError::UnsupportedFElement { .. } => {
+        ConvertErrorKind::UnsupportedFAttribute { .. }
+        | ConvertErrorKind::UnsupportedFElement { .. } => {
             "remove the unsupported FAST construct or replace it with supported declarative syntax"
         }
-        _ => "fix the reported FAST declarative template syntax",
+        ConvertErrorKind::MultipleFTemplates { .. } => {
+            "keep only one <f-template> per component file"
+        }
     };
 
     let code = if matches!(
-        error,
-        ConvertError::UnclosedElement { .. } | ConvertError::UnclosedTag { .. }
+        error.kind(),
+        ConvertErrorKind::UnclosedElement { .. } | ConvertErrorKind::UnclosedTag
     ) {
         codes::UNCLOSED_HTML_TAG
     } else {
-        INVALID_FAST_TEMPLATE
+        codes::INVALID_FAST_TEMPLATE
     };
 
     Diagnostic::error(format!("invalid FAST template: {error}"))
         .code(code)
-        .at_offset(source, offset)
-        .snippet("<f-template>")
+        .at_offset(source, error.offset())
+        .snippet(converter_error_snippet(error.kind()))
         .help(help)
         .into()
 }
 
+#[cold]
+#[inline(never)]
+fn converter_error_snippet(error: &ConvertErrorKind<'_>) -> String {
+    match error {
+        ConvertErrorKind::MultipleFTemplates { .. }
+        | ConvertErrorKind::MissingInnerTemplate
+        | ConvertErrorKind::MultipleInnerTemplates { .. } => "<f-template>".to_string(),
+        ConvertErrorKind::UnclosedElement { tag }
+        | ConvertErrorKind::MissingValueAttribute { tag }
+        | ConvertErrorKind::InvalidDirectiveValue { tag, .. }
+        | ConvertErrorKind::UnsupportedFElement { tag } => {
+            let mut snippet = String::with_capacity(tag.len() + 2);
+            snippet.push('<');
+            snippet.push_str(tag);
+            snippet.push('>');
+            snippet
+        }
+        ConvertErrorKind::InvalidRepeatExpression { expr } => {
+            let mut snippet = String::with_capacity(expr.len() + 4);
+            snippet.push_str("{{");
+            snippet.push_str(expr);
+            snippet.push_str("}}");
+            snippet
+        }
+        ConvertErrorKind::UnsupportedFAttribute { attribute } => attribute.to_string(),
+        ConvertErrorKind::UnclosedTag => "<".to_string(),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #![allow(clippy::disallowed_methods)]
@@ -277,6 +229,25 @@ mod tests {
         }
     }
 
+    #[test]
+    fn parser_extracts_inner_template_while_artifact_keeps_wrapper_body() {
+        let html = r#"<f-template name="named-card">before<template><span>{{label}}</span></template>after</f-template>"#;
+        let ComponentSourceResult::Transformed(result) =
+            transform("file-card", html).expect("transform")
+        else {
+            panic!("expected a transformed FAST source");
+        };
+
+        assert_eq!(
+            result.parser_content,
+            "<template><span>{{label}}</span></template>"
+        );
+        assert_eq!(
+            result.artifact_content.as_deref(),
+            Some("before<template><span>{{label}}</span></template>after")
+        );
+    }
+
     #[test]
     fn multiple_f_templates_are_rejected() {
         let err = transform(
@@ -288,7 +259,10 @@ mod tests {
         let ParserError::Template(diag) = err else {
             panic!("expected template diagnostic");
         };
-        assert_eq!(diag.error_code(), Some(UNSUPPORTED_MULTIPLE_F_TEMPLATES));
+        assert_eq!(
+            diag.error_code(),
+            Some(codes::UNSUPPORTED_MULTIPLE_F_TEMPLATES)
+        );
         assert!(diag.to_string().contains("not currently supported"));
     }
 
@@ -303,11 +277,153 @@ mod tests {
         let ParserError::Template(diag) = err else {
             panic!("expected template diagnostic");
         };
-        assert_eq!(diag.error_code(), Some(INVALID_FAST_TEMPLATE));
+        assert_eq!(diag.error_code(), Some(codes::INVALID_FAST_TEMPLATE));
         assert!(diag.to_string().contains("item in items"));
         assert!(diag.help_text().is_some());
     }
 
+    #[test]
+    fn converter_diagnostics_point_to_the_offending_construct() {
+        let repeat = transform(
+            "invalid-card",
+            "<f-template name=\"invalid-card\">\n  <template>\n    <f-repeat value=\"{{items}}\"></f-repeat>\n  </template>\n</f-template>",
+        )
+        .expect_err("invalid repeat should error");
+        let ParserError::Template(repeat_diag) = repeat else {
+            panic!("expected template diagnostic");
+        };
+        assert_eq!(repeat_diag.error_code(), Some(codes::INVALID_FAST_TEMPLATE));
+        assert_eq!(repeat_diag.position_line_column(), Some((3, 5)));
+        assert_eq!(repeat_diag.snippet_text(), Some("{{items}}"));
+
+        let attribute = transform(
+            "invalid-card",
+            "<f-template name=\"invalid-card\">\n  <template>\n    <span f-unknown=\"value\"></span>\n  </template>\n</f-template>",
+        )
+        .expect_err("unsupported FAST attribute should error");
+        let ParserError::Template(attribute_diag) = attribute else {
+            panic!("expected template diagnostic");
+        };
+        assert_eq!(
+            attribute_diag.error_code(),
+            Some(codes::INVALID_FAST_TEMPLATE)
+        );
+        assert_eq!(attribute_diag.position_line_column(), Some((3, 11)));
+        assert_eq!(attribute_diag.snippet_text(), Some("f-unknown"));
+    }
+
+    #[test]
+    fn missing_or_multiple_inner_templates_are_diagnostics() {
+        for html in [
+            r#"<f-template name="invalid-card"><span></span></f-template>"#,
+            r#"<f-template name="invalid-card"><template></template><template></template></f-template>"#,
+        ] {
+            let err = transform("invalid-card", html)
+                .expect_err("invalid inner template count should error");
+            let ParserError::Template(diag) = err else {
+                panic!("expected template diagnostic");
+            };
+            assert_eq!(diag.error_code(), Some(codes::INVALID_FAST_TEMPLATE));
+            assert_eq!(
+                diag.help_text(),
+                Some("keep exactly one inner <template> element inside <f-template>")
+            );
+        }
+    }
+
+    #[test]
+    fn invalid_directives_and_unsupported_fast_constructs_are_diagnostics() {
+        for html in [
+            r#"<f-template name="invalid-card"><template><f-when>shown</f-when></template></f-template>"#,
+            r#"<f-template name="invalid-card"><template><f-when value="visible">shown</f-when></template></f-template>"#,
+            r#"<f-template name="invalid-card"><template><span f-unknown="value"></span></template></f-template>"#,
+            r#"<f-template name="invalid-card"><template><f-choose></f-choose></template></f-template>"#,
+        ] {
+            let err =
+                transform("invalid-card", html).expect_err("invalid FAST construct should error");
+            let ParserError::Template(diag) = err else {
+                panic!("expected template diagnostic");
+            };
+            assert_eq!(diag.error_code(), Some(codes::INVALID_FAST_TEMPLATE));
+            assert!(diag.help_text().is_some());
+        }
+    }
+
+    #[test]
+    fn unclosed_fast_elements_and_tags_use_unclosed_html_diagnostic() {
+        for html in [
+            r#"<f-template name="invalid-card"><template><f-when value="{{visible}}"><span>shown</span></template></f-template>"#,
+            r#"<f-template name="invalid-card"><template><span title="unterminated></template></f-template>"#,
+            r#"<f-template name="invalid-card" /><template></template></f-template>"#,
+            r#"<f-template name="invalid-card"><template /></template></f-template>"#,
+        ] {
+            let err =
+                transform("invalid-card", html).expect_err("unclosed FAST source should error");
+            let ParserError::Template(diag) = err else {
+                panic!("expected template diagnostic");
+            };
+            assert_eq!(diag.error_code(), Some(codes::UNCLOSED_HTML_TAG));
+            assert_eq!(
+                diag.help_text(),
+                Some("close the reported FAST template element or opening tag")
+            );
+        }
+    }
+
+    #[test]
+    fn supported_fast_attributes_and_comments_are_preserved_for_parser_plugin() {
+        let html = r#"<f-template name="binding-card"><template><!-- <f-when value="{{ignored}}"> --><div f-ref="{root}" f-children="{children}" f-slotted="{slotted}">{{label}}</div></template></f-template>"#;
+        let ComponentSourceResult::Transformed(result) =
+            transform("file-card", html).expect("transform")
+        else {
+            panic!("expected a transformed FAST source");
+        };
+
+        assert_eq!(
+            result.parser_content,
+            r#"<template><!-- <f-when value="{{ignored}}"> --><div f-ref="{root}" f-children="{children}" f-slotted="{slotted}">{{label}}</div></template>"#
+        );
+    }
+
+    #[test]
+    fn repeat_alias_and_dotted_source_grammar_is_preserved() {
+        let html = r#"<f-template name="repeat-card"><template><f-repeat value="{{ $item in groups.items_2 }}"><span>{{$item.label}}</span></f-repeat></template></f-template>"#;
+        let ComponentSourceResult::Transformed(result) =
+            transform("file-card", html).expect("transform")
+        else {
+            panic!("expected a transformed FAST source");
+        };
+
+        assert_eq!(
+            result.parser_content,
+            r#"<template><for each="$item in groups.items_2"><span>{{$item.label}}</span></for></template>"#
+        );
+    }
+
+    #[test]
+    fn deeply_nested_fast_directives_convert_iteratively() {
+        const DEPTH: usize = 2_048;
+        let mut html = String::with_capacity(DEPTH * 48 + 128);
+        html.push_str(r#"<f-template name="deep-card"><template>"#);
+        for _ in 0..DEPTH {
+            html.push_str(r#"<f-when value="{{visible}}">"#);
+        }
+        html.push_str("<span>{{title}}</span>");
+        for _ in 0..DEPTH {
+            html.push_str("</f-when>");
+        }
+        html.push_str("</template></f-template>");
+
+        let converted = convert_template(&html)
+            .expect("convert deeply nested FAST directives")
+            .expect("f-template should be found");
+        assert_eq!(
+            converted.parser_content.matches("<if condition=").count(),
+            DEPTH
+        );
+        assert_eq!(converted.parser_content.matches("</if>").count(), DEPTH);
+    }
+
     #[test]
     fn precheck_matches_lower_upper_and_mixed_case_names() {
         for haystack in [
@@ -316,12 +432,14 @@ mod tests {
             "<F-template Name=\"card\"><template></template></f-Template>",
         ] {
             assert!(contains_f_template_name(haystack.as_bytes()));
-            assert!(find_f_template_source(haystack).is_some());
+            assert!(convert_template(haystack)
+                .expect("convert mixed-case f-template")
+                .is_some());
         }
     }
 
     #[test]
-    fn whitespace_after_opening_angle_bracket_passes_precheck_and_walker() {
+    fn whitespace_after_opening_angle_bracket_passes_precheck_and_converter() {
         let html =
             r#"< f-template name="card"><template><span>{{title}}</span></template></f-template>"#;
         assert!(contains_f_template_name(html.as_bytes()));
@@ -342,8 +460,10 @@ mod tests {
                 format!("<{whitespace}f-template name=\"card\"><template></template></f-template>");
             assert!(contains_f_template_name(html.as_bytes()));
             assert!(
-                find_f_template_source(&html).is_some(),
-                "walker rejected ASCII whitespace byte {:#04x}",
+                convert_template(&html)
+                    .expect("convert whitespace-prefixed f-template")
+                    .is_some(),
+                "converter rejected ASCII whitespace byte {:#04x}",
                 byte
             );
         }
@@ -370,11 +490,12 @@ mod tests {
             r#"<template><span>the f-template directive is unused here</span></template>"#,
             r#"<template><!-- f-template mentioned only in a comment --><span>{{title}}</span></template>"#,
             r#"<template><span data-note="f-template">{{title}}</span></template>"#,
+            r#"<template><span data-note="<f-template name='not-an-element'>">{{title}}</span></template>"#,
             r#"<template><f-templatex></f-templatex></template>"#,
         ] {
             // The bare bytes are present, so the precheck reports a possible
             // match, but no source contains an actual `<f-template>` element,
-            // so the authoritative walker still finds nothing.
+            // so the authoritative conversion scan still finds nothing.
             assert!(contains_f_template_name(html.as_bytes()));
             assert_eq!(
                 transform("plain-card", html).expect("transform"),
diff --git a/crates/webui-parser/src/plugin/mod.rs b/crates/webui-parser/src/plugin/mod.rs
index 163e8c28..f3c78610 100644
--- a/crates/webui-parser/src/plugin/mod.rs
+++ b/crates/webui-parser/src/plugin/mod.rs
@@ -8,6 +8,7 @@
 //! and emit per-element hydration metadata for the handler.
 
 pub mod fast;
+mod fast_convert;
 mod fast_shared;
 pub mod fast_v2;
 pub mod fast_v3;
diff --git a/docs/guide/concepts/plugins/index.md b/docs/guide/concepts/plugins/index.md
index 69194766..ec5fd8c8 100644
--- a/docs/guide/concepts/plugins/index.md
+++ b/docs/guide/concepts/plugins/index.md
@@ -132,25 +132,29 @@ are not currently supported and have a dedicated authoring diagnostic.
 
 WebUI uses two views of this source:
 
-- **SSR parse view:** WebUI adapts the source for `microsoft-fast-convert` with
-  the `webui-prerelease` target. When the authored name is absent or empty, the
-  adapter supplies a converter-only name without changing the filename-derived
-  component tag. The converter rewrites supported `f-repeat` and `f-when`
-  directives to WebUI `for` and `if` directives and unwraps their `value`
-  expressions. Text interpolation and boolean bindings remain for WebUI
-  parsing. Unsupported `f-*` constructs fail conversion instead of being
-  silently accepted. The FAST plugins' `classify_attribute` skips `@event`,
-  `:property`, `f-ref`, `f-slotted`, and `f-children` and counts each as a
-  binding, so hydration binding indexes stay aligned without any parser-core
-  marker.
-- **Client artifact view:** WebUI retains the authored inner template, including
-  its client bindings, and emits it inside the resolved `<f-template>` rather
-  than regenerating it from the SSR view. The artifact is normalized and still
-  receives normal wrapper handling, legal comment processing, and CSS injection
-  for the selected strategy. Plugins that return `None` from
+- **SSR parse view:** WebUI internally adapts supported FAST declarative
+  constructs into the WebUI parser view. It rewrites supported `f-repeat` and
+  `f-when` directives to WebUI `for` and `if` directives and unwraps their
+  `value` expressions. Text interpolation and boolean bindings remain available
+  to the WebUI parser. An absent or empty authored name continues to use the
+  filename-derived component tag. Unsupported `f-*` constructs fail conversion
+  instead of being silently accepted. The FAST plugins' `classify_attribute`
+  skips `@event`, `:property`, `f-ref`, `f-slotted`, and `f-children` and counts
+  each as a binding, so hydration binding indexes stay aligned without any
+  parser-core marker.
+- **Client artifact view:** WebUI retains the authored `<f-template>` body,
+  including its inner template and client bindings, and emits it inside the
+  resolved `<f-template>` rather than regenerating it from the SSR view. The
+  artifact is normalized and still receives normal wrapper handling, legal
+  comment processing, and CSS injection for the selected strategy. Plugins that
+  return `None` from
   `component_source_transform` never receive FAST artifacts; they parse the
   component's HTML unchanged.
 
+Multiple wrappers report `unsupported-multiple-f-templates`; malformed or
+unsupported FAST declarative syntax reports `invalid-fast-template`, while
+unclosed markup uses the shared `unclosed-html-tag` diagnostic.
+
 The deprecated `fast` selector aliases FAST 2. `fast`, `fast_v2`, and `fast_v3`
 all share this same transform, conversion, and retained-artifact path.