diff --git a/DESIGN.md b/DESIGN.md
index a7346dd9..ad5df438 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -1226,6 +1226,7 @@ pub trait ParserPlugin {
         component: &Component,
         processed_template: &str,
     ) -> Result<()>;
+    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>;
@@ -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.
+- **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**
@@ -1250,6 +1252,65 @@ 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 `fast`, `fast_v2`, and `fast_v3` parser implementations (selected as
+`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 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 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 FAST
+  declarative syntax.
+- Unsupported `f-*` elements or attributes and malformed directive expressions
+  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 `<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)
 for the WebUI Framework's public authoring model.
diff --git a/README.md b/README.md
index 427884b6..393c5680 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,31 @@
 - **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
+
+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
+multiple `<f-template>` blocks fail the build with an authoring diagnostic.
+
+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
+`<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
 
 ```bash
diff --git a/crates/webui-parser/benches/parser_bench.rs b/crates/webui-parser/benches/parser_bench.rs
index 7d7897bd..aaec25b1 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 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>");
+    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/component_registry.rs b/crates/webui-parser/src/component_registry.rs
index 1006b34e..28dbf883 100644
--- a/crates/webui-parser/src/component_registry.rs
+++ b/crates/webui-parser/src/component_registry.rs
@@ -6,6 +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::plugin::{ComponentSource, ComponentSourceResult, ComponentSourceTransform};
 use crate::{CssFallbackChain, CssParser, LegalComments, ParserError, Result};
 use std::collections::HashMap;
 #[cfg(feature = "fs")]
@@ -17,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.
 ///
 /// ```
@@ -94,6 +105,13 @@ pub struct ComponentRegistry {
     components: HashMap<String, Component>,
     /// Compiler-owned rendering policies kept outside the public component API.
     render_policies: HashMap<String, ComponentRenderPolicy>,
+    /// 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.
@@ -138,11 +156,55 @@ impl ComponentRegistry {
         Self {
             components: HashMap::new(),
             render_policies: 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 transforming their contents.
+    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> {
@@ -194,28 +256,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 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(tag_name) {
+        if self.components.contains_key(&resolved.tag_name) {
             return Err(ParserError::Component(format!(
                 "Component '{}' is already registered",
-                tag_name
+                resolved.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 +293,14 @@ 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(&resolved.tag_name, &resolved.parser_content)?;
+        Self::append_scoped_policy_css(&mut css_content, &render_policy, &resolved.tag_name);
 
         // Create and register the component
         let component = Component {
-            tag_name: tag_name.to_string(),
-            html_content,
+            tag_name: resolved.tag_name,
+            html_content: resolved.parser_content,
             css_content,
             css_definitions,
             css_fallback_chains,
@@ -251,8 +308,13 @@ 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(artifact) = resolved.artifact_content {
+            self.component_artifact_sources
+                .insert(component.tag_name.clone(), artifact);
+        }
+        self.components
+            .insert(component.tag_name.clone(), component);
         Ok(())
     }
 
@@ -268,19 +330,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 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(tag_name) {
+        if self.components.contains_key(&resolved.tag_name) {
             return Err(ParserError::Component(format!(
                 "Component '{}' is already registered",
-                tag_name
+                resolved.tag_name
             )));
         }
 
@@ -293,11 +350,12 @@ 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(&resolved.tag_name, &resolved.parser_content)?;
+        Self::append_scoped_policy_css(&mut css_content, &render_policy, &resolved.tag_name);
         let component: Component = Component {
-            tag_name: tag_name.to_string(),
-            html_content: html_content.to_string(),
+            tag_name: resolved.tag_name,
+            html_content: resolved.parser_content,
             css_content,
             css_definitions,
             css_fallback_chains,
@@ -306,11 +364,27 @@ 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(artifact) = resolved.artifact_content {
+            self.component_artifact_sources
+                .insert(component.tag_name.clone(), artifact);
+        }
+        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
+        )))
+    }
+
     /// 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 +423,16 @@ impl ComponentRegistry {
         self.components.get(tag_name)
     }
 
+    /// 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)
+    }
+
     /// Get all registered components.
     pub fn get_all(&self) -> impl Iterator<Item = &Component> {
         self.components.values()
@@ -437,6 +521,7 @@ impl ComponentRegistry {
 mod tests {
     use super::*;
     use crate::codes;
+    use crate::plugin::TransformedComponentSource;
     use webui_test_utils::TestFileSystem;
 
     #[test]
@@ -464,6 +549,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();
@@ -823,6 +935,133 @@ 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 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",
+                r#"<mock-template name="renamed-card"><template>x</template></mock-template>"#,
+                Some(".root { color: red; }"),
+                true,
+            ))
+            .expect("register");
+
+        assert!(!registry.contains("file-card"));
+        let component = registry.get("renamed-card").expect("component");
+        assert_eq!(component.tag_name, "renamed-card");
+        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 transform_returning_unchanged_preserves_source() {
+        let mut registry = ComponentRegistry::new();
+        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");
+
+        assert!(registry.contains("plain-card"));
+        assert_eq!(
+            registry
+                .get("plain-card")
+                .map(|component| component.html_content.as_str()),
+            Some(html)
+        );
+        assert_eq!(registry.component_artifact_source("plain-card"), None);
+    }
+
+    #[test]
+    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(
+                "file-card",
+                "<template>x</template>",
+                None,
+                true,
+            ))
+            .expect_err("failing transform should abort registration");
+
+        assert!(matches!(err, ParserError::Component(ref msg) if msg.contains("mock transform")));
+        assert!(!registry.contains("file-card"));
+        assert!(registry.is_empty());
+    }
+
+    #[test]
+    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(
+                "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!(
+            matches!(err, ParserError::Component(ref msg) if msg.contains("already registered"))
+        );
+    }
+
     #[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..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/lib.rs b/crates/webui-parser/src/lib.rs
index 5045390a..4a1cc5c5 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,
+    artifact_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);
@@ -927,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
@@ -2364,12 +2374,17 @@ 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 artifact_html = self
+                .component_registry
+                .component_artifact_source(element.name())
+                .map(str::to_string);
+            let built = self.build_component_templates(ComponentTemplateInput {
+                tag_name: element.name(),
+                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(),
+            })?;
 
             if let Some(ref mut p) = self.plugin {
                 p.register_component_template(element.name(), &component_data, built.artifact())?;
@@ -3121,13 +3136,18 @@ impl HtmlParser {
                 .help(self.unknown_component_help(component))
             })?
             .clone();
+        let artifact_html = self
+            .component_registry
+            .component_artifact_source(component)
+            .map(str::to_string);
 
-        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: &component_data.html_content,
+            artifact_html: artifact_html.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 +3182,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 +3217,13 @@ impl HtmlParser {
             CssStrategy::Module => None,
         };
 
-        let artifact_differs = 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,
@@ -3205,15 +3231,14 @@ impl HtmlParser {
             adopted_specifier,
             policy_wrapper,
         )?;
-        let artifact = 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 })
@@ -4026,6 +4051,249 @@ 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}" ?disabled="{{disabled}}" f-ref="{button}" 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;
+        // 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("@click")
+                        || raw.value.contains(":config")
+                        || raw.value.contains("f-ref")
+            )
+        }));
+
+        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(r#"?disabled="{{disabled}}""#));
+        assert!(template.contains(r#"f-ref="{button}""#));
+        assert!(template.contains(r#"title="{{title}}""#));
+        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]
+    #[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()));
+    }
+
+    #[test]
+    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(
+                "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", "<binding-card></binding-card>")
+            .expect("parse entry");
+        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!(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]
     fn test_shadow_dom_shell_fragment_graph_includes_child_components() {
         // Reproduces commerce app: mp-app has a shadow DOM template containing
@@ -5946,7 +6214,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,
+                artifact_html: None,
+                css_content: None,
+                artifact_needed: true,
+            })
             .expect("shadow policy wrapper should compile");
         assert_eq!(
             shadow_built.ssr,
@@ -5956,7 +6230,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,
+                artifact_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 +6296,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>"#,
+                artifact_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_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
new file mode 100644
index 00000000..e1446bc1
--- /dev/null
+++ b/crates/webui-parser/src/plugin/fast_shared.rs
@@ -0,0 +1,506 @@
+// 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), 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::{ParserError, Result};
+
+/// 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 `<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
+/// component sources never pay for the element walk.
+///
+/// # 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;
+    if !contains_f_template_name(html_content.as_bytes()) {
+        return Ok(ComponentSourceResult::Unchanged);
+    }
+
+    let Some(converted) =
+        convert_template(html_content).map_err(|error| converter_error(html_content, &error))?
+    else {
+        return Ok(ComponentSourceResult::Unchanged);
+    };
+
+    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,
+            artifact_content: Some(artifact_content),
+        },
+    ))
+}
+
+/// Cheap case-insensitive precheck for the bare ASCII name `f-template`
+/// anywhere in `haystack`, without the surrounding `<` delimiter.
+///
+/// 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
+        .windows(F_TEMPLATE_NAME.len())
+        .any(|window| window.eq_ignore_ascii_case(F_TEMPLATE_NAME.as_bytes()))
+}
+
+/// Build a [`Diagnostic`] error from a converter failure.
+#[cold]
+#[inline(never)]
+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(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",
+            )
+            .into();
+    }
+
+    let help = match error.kind() {
+        ConvertErrorKind::MissingInnerTemplate
+        | ConvertErrorKind::MultipleInnerTemplates { .. } => {
+            "keep exactly one inner <template> element inside <f-template>"
+        }
+        ConvertErrorKind::MissingValueAttribute { .. }
+        | ConvertErrorKind::InvalidDirectiveValue { .. } => {
+            "add the required value=\"{{expression}}\" attribute to the FAST directive"
+        }
+        ConvertErrorKind::InvalidRepeatExpression { .. } => {
+            "use an f-repeat expression in \"item in items\" form"
+        }
+        ConvertErrorKind::UnclosedElement { .. } | ConvertErrorKind::UnclosedTag => {
+            "close the reported FAST template element or opening tag"
+        }
+        ConvertErrorKind::UnsupportedFAttribute { .. }
+        | ConvertErrorKind::UnsupportedFElement { .. } => {
+            "remove the unsupported FAST construct or replace it with supported declarative syntax"
+        }
+        ConvertErrorKind::MultipleFTemplates { .. } => {
+            "keep only one <f-template> per component file"
+        }
+    };
+
+    let code = if matches!(
+        error.kind(),
+        ConvertErrorKind::UnclosedElement { .. } | ConvertErrorKind::UnclosedTag
+    ) {
+        codes::UNCLOSED_HTML_TAG
+    } else {
+        codes::INVALID_FAST_TEMPLATE
+    };
+
+    Diagnostic::error(format!("invalid FAST template: {error}"))
+        .code(code)
+        .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)]
+    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 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(
+            "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(codes::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(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 [
+            "<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!(convert_template(haystack)
+                .expect("convert mixed-case f-template")
+                .is_some());
+        }
+    }
+
+    #[test]
+    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()));
+
+        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!(
+                convert_template(&html)
+                    .expect("convert whitespace-prefixed f-template")
+                    .is_some(),
+                "converter 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><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 conversion scan still finds nothing.
+            assert!(contains_f_template_name(html.as_bytes()));
+            assert_eq!(
+                transform("plain-card", html).expect("transform"),
+                ComponentSourceResult::Unchanged
+            );
+        }
+    }
+}
diff --git a/crates/webui-parser/src/plugin/fast_v2.rs b/crates/webui-parser/src/plugin/fast_v2.rs
index cd639ec6..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,8 +86,13 @@ impl ParserPlugin for FastV2ParserPlugin {
         Ok(())
     }
 
+    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"
@@ -726,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();
@@ -735,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 5b30ecb7..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,8 +86,13 @@ impl ParserPlugin for FastV3ParserPlugin {
         Ok(())
     }
 
+    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"
@@ -726,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();
@@ -735,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 2e549e21..f3c78610 100644
--- a/crates/webui-parser/src/plugin/mod.rs
+++ b/crates/webui-parser/src/plugin/mod.rs
@@ -8,6 +8,8 @@
 //! 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;
 pub mod webui;
@@ -153,6 +155,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,6 +243,18 @@ pub trait ParserPlugin {
         processed_template: &str,
     ) -> Result<()>;
 
+    /// Return a stateless transform applied to each component's authored source
+    /// before registry insertion, or `None` to store sources unchanged.
+    ///
+    /// 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.
     fn classify_attribute(&mut self, attr_name: &str) -> AttributeAction;
 
diff --git a/crates/webui/src/lib.rs b/crates/webui/src/lib.rs
index 893837c3..a3bb1df4 100644
--- a/crates/webui/src/lib.rs
+++ b/crates/webui/src/lib.rs
@@ -2540,6 +2540,65 @@ 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><plain-card></plain-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>"#,
+            ),
+            (
+                "plain-card.html",
+                r#"<template><if condition="visible"><span>{{label}}</span></if></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>"));
+            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}}">"#));
+        }
+    }
+
     #[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 91ca56a8..ec5fd8c8 100644
--- a/docs/guide/concepts/plugins/index.md
+++ b/docs/guide/concepts/plugins/index.md
@@ -93,6 +93,71 @@ use webui_handler::plugin::webui::WebUIHydrationPlugin;
 let handler = WebUIHandler::with_plugin(|| Box::new(WebUIHydrationPlugin::new()));
 ```
 
+### Using FAST Plugins
+
+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
+```
+
+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 -->
+<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 `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:** 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.
+
 ## Writing Custom Plugins
 
 To create a custom plugin, implement the `ParserPlugin` and/or `HandlerPlugin` traits:
@@ -113,6 +178,14 @@ pub trait ParserPlugin {
         processed_template: &str,
     ) -> Result<()>;
 
+    /// 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.
     fn classify_attribute(&mut self, attr_name: &str) -> AttributeAction;