diff --git a/.github/workflows/README.md b/.github/workflows/README.md
index a9ead4a3386..45e7710da60 100644
--- a/.github/workflows/README.md
+++ b/.github/workflows/README.md
@@ -17,7 +17,7 @@ Nightly publishing is split into two coordinated jobs so that npm credentials ne
 
 - **`cd-github-releases.yml`** (GitHub Actions) runs nightly via cron (`0 8 * * *` UTC, ~12am PST) and on `workflow_dispatch`. It does **not** bump versions or push source changes to `main` — version bumps land on `main` through ordinary human-authored pull requests (for example, by running `npm run bump` locally and opening a PR). The cron is scheduled ~1 hour before the Azure CD pipeline (09:00 UTC) so any GitHub releases this job creates are picked up by that same night's publish run. The workflow has two jobs:
   1. **`detect`** — checks out `main` with `fetch-depth: 0` and runs [`build/scripts/create-github-releases.mjs --check-only`](../../build/scripts/create-github-releases.mjs). The script walks the workspaces tree (no `npm ci` required), computes `${name}_v${version}` for every non-private workspace, and emits `hasMissingReleases=true` if any of those git tags do not yet exist.
-  2. **`release`** runs only when missing releases exist. Installs Node, the Rust toolchain (for `cargo package`), and the npm workspace dependencies, builds the repo, then runs the script in default mode. For every missing release the script: packs the npm tarball into `publish_artifacts_npm/`, packs the paired Rust crate (if `crates/<crate-name>/Cargo.toml` exists) into `publish_artifacts_crates/`, and creates the GitHub release with both assets attached via `gh release create --target <sha>`. The `gh` CLI creates the git tag atomically with the release, so "tag exists" and "release exists" are always the same fact — a failed release is safely retried on the next workflow run, with no orphan tag stranded behind. The script errors if a paired crate's version does not match the npm package's version — but this is purely a safety net: the [`postbump` hook in `beachball.config.js`](../../beachball.config.js) rewrites the crate's `Cargo.toml` (and the matching entry in `Cargo.lock`) automatically whenever `npm run bump` bumps the paired npm package, so the two stay in sync from the same commit.
+  2. **`release`** runs only when missing releases exist. Installs Node, the Rust toolchain (for `cargo package`), and the npm workspace dependencies, builds the repo, then runs the script in default mode. For every missing release the script: packs the npm tarball into `publish_artifacts_npm/`, packs any paired Rust crates into `publish_artifacts_crates/`, and creates the GitHub release with all assets attached via `gh release create --target <sha>`. `@microsoft/fast-build` is a bundled release: it uses one npm package, one tag, and one GitHub release containing both `microsoft-fast-build` and `microsoft-fast-convert` crate assets. The `gh` CLI creates the git tag atomically with the release, so "tag exists" and "release exists" are always the same fact — a failed release is safely retried on the next workflow run, with no orphan tag stranded behind. The script errors if a paired crate's version does not match the npm package's version — but this is purely a safety net: the [`postbump` hook in `beachball.config.js`](../../beachball.config.js) rewrites each crate's `Cargo.toml` (and the matching entry in `Cargo.lock`) automatically whenever `npm run bump` bumps the paired npm package, so they stay in sync from the same commit.
 - **`azure-pipelines-cd.yml`** (Azure Pipelines) runs every night at **1am PST (`0 9 * * *` UTC)** with `always: true` so it still runs on no-op nights (it is checking external GitHub state, not repo commits). It is split into two stages so the heavy publish work is skipped on no-op nights:
   1. **`Check`** — runs [`build/scripts/download-github-releases.mjs --check-only`](../../build/scripts/download-github-releases.mjs). The script walks the current publishable workspaces, keeps only workspaces whose current `${name}_v${version}` release tag exists, filters out tags that already have a `deployed/<tag>` counterpart, and emits Azure Pipelines output variables for the overall deployment decision, npm dist-tag, and each package-specific release tag. No network calls to GitHub, npm, or crates.io are needed.
   2. **`Package`** — depends on `Check` and runs only when `needsDeployment == 'true'`. Conditional `DownloadGitHubRelease@0` tasks download undeployed release assets through the `fast` GitHub service connection, a shell step sorts them into `publish_artifacts_npm/` (`.tgz`) and `publish_artifacts_crates/` (`.crate`), configures npm to publish companion packages with the detected dist-tag, then `FAST.Release.PipelineTemplate.yml@fastPipelines` performs the actual `npm publish` / `cargo publish`. On success, the pipeline pushes a `deployed/<tag>` git marker tag for each release that was just published. The next nightly run will see those markers and skip the corresponding releases.
@@ -33,7 +33,7 @@ The `npm run checkchange` command runs `build/scripts/check-publish-pipeline.mjs
 When adding a new non-private workspace that should publish through CD:
 
 1. Ensure the workspace is included in the root `package.json` `workspaces` list and has a `name` and `version`.
-2. If the package has a paired crate, place it at `crates/<crate-name>/Cargo.toml`, where `<crate-name>` is the npm package name with the leading `@` removed and `/` replaced by `-`. For example, `@microsoft/fast-build` pairs with `crates/microsoft-fast-build/Cargo.toml`.
+2. If the package has paired crate assets, place each crate at `crates/<crate-name>/Cargo.toml`. By default, `<crate-name>` is the npm package name with the leading `@` removed and `/` replaced by `-`. `@microsoft/fast-build` is the special bundled release and pairs with both `crates/microsoft-fast-build/Cargo.toml` and `crates/microsoft-fast-convert/Cargo.toml`.
 3. Add package-specific output variables to the `Package` stage in `azure-pipelines-cd.yml`. The output prefix is generated from the npm package name by converting `@microsoft/<name>` to camel case. For example, `@microsoft/fast-foo` emits `fastFooNeedsDeployment` and `fastFooReleaseTag`.
 4. Add a conditional `DownloadGitHubRelease@0` task for the package using the `fast` GitHub service connection, `defaultVersionType: 'specificTag'`, and the package's `$(<prefix>ReleaseTag)` variable.
 5. Confirm the artifact sorting step still covers the package assets. Packages should attach `.tgz` assets, and paired crates should also attach `.crate` assets.
diff --git a/.github/workflows/ci-validate-rust.yml b/.github/workflows/ci-validate-rust.yml
index 1e610ff5227..cf0c088b449 100644
--- a/.github/workflows/ci-validate-rust.yml
+++ b/.github/workflows/ci-validate-rust.yml
@@ -23,7 +23,18 @@ on:
 jobs:
   test_rust:
     if: github.event_name != 'pull_request' || !github.event.pull_request.draft
+    name: test_rust (${{ matrix.crate }})
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - crate: microsoft-fast-build
+            manifest-path: crates/microsoft-fast-build/Cargo.toml
+            cache-workspace: crates/microsoft-fast-build
+          - crate: microsoft-fast-convert
+            manifest-path: crates/microsoft-fast-convert/Cargo.toml
+            cache-workspace: crates/microsoft-fast-convert
 
     steps:
     - uses: actions/checkout@v4
@@ -34,7 +45,7 @@ jobs:
     - name: Cache Rust build artifacts
       uses: Swatinem/rust-cache@v2
       with:
-        workspaces: crates/microsoft-fast-build
+        workspaces: ${{ matrix.cache-workspace }}
 
     - name: Run Rust tests
-      run: cargo test --manifest-path crates/microsoft-fast-build/Cargo.toml
+      run: cargo test --manifest-path ${{ matrix.manifest-path }}
diff --git a/beachball.config.js b/beachball.config.js
index da51b2dbeab..1f756bbd494 100644
--- a/beachball.config.js
+++ b/beachball.config.js
@@ -11,6 +11,14 @@ function npmNameToCrateName(npmName) {
     return npmName.replace(/^@/, "").replace(/\//g, "-");
 }
 
+const bundledCratesByPackage = new Map([
+    ["@microsoft/fast-build", ["microsoft-fast-build", "microsoft-fast-convert"]],
+]);
+
+function npmNameToCrateNames(npmName) {
+    return bundledCratesByPackage.get(npmName) ?? [npmNameToCrateName(npmName)];
+}
+
 /**
  * Rewrite the `version = "..."` line for a specific `[package]` or
  * `[[package]]` block (matched by the crate name) within Cargo TOML
@@ -66,8 +74,8 @@ function rewriteCargoVersion(content, crateName, newVersion, { manifest }) {
 }
 
 /**
- * Beachball `postbump` hook: when an npm package with a paired Rust
- * crate is bumped, rewrite the crate's `Cargo.toml` (and matching entry
+ * Beachball `postbump` hook: when an npm package with paired Rust
+ * crates is bumped, rewrite each crate's `Cargo.toml` (and matching entry
  * in `Cargo.lock`, if present) so the crate version stays in lock-step
  * with the npm version.
  *
@@ -75,32 +83,33 @@ function rewriteCargoVersion(content, crateName, newVersion, { manifest }) {
  * Cargo updates land in the same PR as the package.json bump.
  */
 function syncPairedCrateVersion(packagePath, name, version) {
-    const crateName = npmNameToCrateName(name);
-    const cargoTomlPath = join(__dirname, "crates", crateName, "Cargo.toml");
-    if (!existsSync(cargoTomlPath)) return;
-
-    const updatedToml = rewriteCargoVersion(
-        readFileSync(cargoTomlPath, "utf8"),
-        crateName,
-        version,
-        { manifest: true },
-    );
-    if (updatedToml !== null) {
-        writeFileSync(cargoTomlPath, updatedToml);
-        console.log(`[beachball] Synced ${cargoTomlPath} to ${version}`);
-    }
+    for (const crateName of npmNameToCrateNames(name)) {
+        const cargoTomlPath = join(__dirname, "crates", crateName, "Cargo.toml");
+        if (!existsSync(cargoTomlPath)) continue;
 
-    const cargoLockPath = join(__dirname, "crates", crateName, "Cargo.lock");
-    if (existsSync(cargoLockPath)) {
-        const updatedLock = rewriteCargoVersion(
-            readFileSync(cargoLockPath, "utf8"),
+        const updatedToml = rewriteCargoVersion(
+            readFileSync(cargoTomlPath, "utf8"),
             crateName,
             version,
-            { manifest: false },
+            { manifest: true },
         );
-        if (updatedLock !== null) {
-            writeFileSync(cargoLockPath, updatedLock);
-            console.log(`[beachball] Synced ${cargoLockPath} to ${version}`);
+        if (updatedToml !== null) {
+            writeFileSync(cargoTomlPath, updatedToml);
+            console.log(`[beachball] Synced ${cargoTomlPath} to ${version}`);
+        }
+
+        const cargoLockPath = join(__dirname, "crates", crateName, "Cargo.lock");
+        if (existsSync(cargoLockPath)) {
+            const updatedLock = rewriteCargoVersion(
+                readFileSync(cargoLockPath, "utf8"),
+                crateName,
+                version,
+                { manifest: false },
+            );
+            if (updatedLock !== null) {
+                writeFileSync(cargoLockPath, updatedLock);
+                console.log(`[beachball] Synced ${cargoLockPath} to ${version}`);
+            }
         }
     }
 }
diff --git a/build/scripts/create-github-releases.mjs b/build/scripts/create-github-releases.mjs
index 0765db880a6..669e5b04257 100644
--- a/build/scripts/create-github-releases.mjs
+++ b/build/scripts/create-github-releases.mjs
@@ -11,19 +11,20 @@
  *      workspace's `package.json` (no `node_modules` required, so the
  *      `--check-only` mode can run before `npm ci`).
  *   2. Skips workspaces whose package.json sets `private: true`.
- *   3. For each remaining workspace, looks for a paired Rust crate at
- *      `crates/<crate-name>/Cargo.toml`, where the crate name is derived
- *      from the npm name by dropping the leading `@` and replacing `/`
- *      with `-` (so `@microsoft/fast-build` -> `microsoft-fast-build`).
- *      When a pair exists, the script errors if the two versions are not
- *      identical, forcing the version-bump PR to keep them in sync.
+ *   3. For each remaining workspace, looks for paired Rust crates at
+ *      `crates/<crate-name>/Cargo.toml`. Most crate names are derived from
+ *      the npm name by dropping the leading `@` and replacing `/` with `-`;
+ *      `@microsoft/fast-build` bundles both `microsoft-fast-build` and
+ *      `microsoft-fast-convert` into the same release. When a pair exists,
+ *      the script errors if the two versions are not identical, forcing the
+ *      version-bump PR to keep them in sync.
  *   4. Computes `tag = ${name}_v${version}` (matching beachball's tag
  *      format) and skips the workspace if the git tag already exists
  *      (idempotent across re-runs).
  *   5. Otherwise (when not `--check-only`) packs the npm tarball into
  *      `publish_artifacts_npm/` with `npm pack`, optionally packs the
- *      paired crate into `publish_artifacts_crates/` with
- *      `cargo package`, and creates the GitHub release with both
+ *      paired crates into `publish_artifacts_crates/` with
+ *      `cargo package`, and creates the GitHub release with all
  *      assets attached (`gh release create --target <sha>`). The `gh`
  *      CLI creates the git tag atomically with the release, so the
  *      tag and the release exist if and only if each other does.
@@ -76,6 +77,14 @@ function npmNameToCrateName(npmName) {
     return npmName.replace(/^@/, "").replace(/\//g, "-");
 }
 
+const bundledCratesByPackage = new Map([
+    ["@microsoft/fast-build", ["microsoft-fast-build", "microsoft-fast-convert"]],
+]);
+
+function npmNameToCrateNames(npmName) {
+    return bundledCratesByPackage.get(npmName) ?? [npmNameToCrateName(npmName)];
+}
+
 function shouldSkipCrates() {
     return process.env.FAST_RELEASE_SKIP_CRATES === "true";
 }
@@ -96,6 +105,29 @@ function readCargoTomlVersion(cargoTomlPath) {
     return null;
 }
 
+function listPairedCrates(pkgName, pkgVersion) {
+    if (shouldSkipCrates()) return [];
+
+    const crates = [];
+    for (const crateName of npmNameToCrateNames(pkgName)) {
+        const cargoTomlPath = join("crates", crateName, "Cargo.toml");
+        if (!existsSync(cargoTomlPath)) continue;
+
+        const crateVersion = readCargoTomlVersion(cargoTomlPath);
+        if (crateVersion !== pkgVersion) {
+            throw new Error(
+                `Version mismatch for ${pkgName}: package.json is ${pkgVersion} ` +
+                    `but ${cargoTomlPath} is ${crateVersion}. ` +
+                    "Update one to match the other.",
+            );
+        }
+
+        crates.push({ crateName, cargoTomlPath });
+    }
+
+    return crates;
+}
+
 function listPublishableWorkspaces() {
     const rootPkg = JSON.parse(readFileSync("package.json", "utf8"));
     const patterns = rootPkg.workspaces || [];
@@ -123,25 +155,13 @@ function listPublishableWorkspaces() {
         if (pkg.private === true) continue;
         if (!pkg.name || !pkg.version) continue;
 
-        const crateName = npmNameToCrateName(pkg.name);
-        const cargoTomlPath = join("crates", crateName, "Cargo.toml");
-        const hasCrate = existsSync(cargoTomlPath) && !shouldSkipCrates();
-
-        if (hasCrate) {
-            const crateVersion = readCargoTomlVersion(cargoTomlPath);
-            if (crateVersion !== pkg.version) {
-                throw new Error(
-                    `Version mismatch for ${pkg.name}: package.json is ${pkg.version} but ${cargoTomlPath} is ${crateVersion}. Update one to match the other.`,
-                );
-            }
-        }
+        const crates = listPairedCrates(pkg.name, pkg.version);
 
         workspaces.push({
             location,
             name: pkg.name,
             version: pkg.version,
-            crateName: hasCrate ? crateName : null,
-            cargoTomlPath: hasCrate ? cargoTomlPath : null,
+            crates,
         });
     }
 
@@ -174,8 +194,11 @@ console.log(`Missing git tag / release: ${missing.length}`);
 
 if (missing.length > 0) {
     console.log("\nPackages that need a release:");
-    for (const { name, version, crateName } of missing) {
-        const suffix = crateName ? ` (+ crate ${crateName})` : "";
+    for (const { name, version, crates } of missing) {
+        const suffix =
+            crates.length > 0
+                ? ` (+ crates ${crates.map(crate => crate.crateName).join(", ")})`
+                : "";
         console.log(`  - ${name}@${version}${suffix}`);
     }
 }
@@ -201,7 +224,7 @@ mkdirSync(CRATES_DIR, { recursive: true });
 let created = 0;
 let hasErrors = false;
 
-for (const { name, version, location, crateName, cargoTomlPath } of missing) {
+for (const { name, version, location, crates } of missing) {
     const tag = `${name}_v${version}`;
     const assets = [];
 
@@ -216,7 +239,7 @@ for (const { name, version, location, crateName, cargoTomlPath } of missing) {
         ]);
         assets.push(join(NPM_DIR, JSON.parse(packJson)[0].filename));
 
-        if (cargoTomlPath) {
+        for (const { crateName, cargoTomlPath } of crates) {
             console.log(`Packaging crate ${crateName}@${version}...`);
             run(
                 "cargo",
@@ -251,7 +274,7 @@ for (const { name, version, location, crateName, cargoTomlPath } of missing) {
             "",
             "Version bumps were landed via a regular pull request. The attached",
             "assets will be downloaded and published to npm" +
-                (cargoTomlPath ? " and crates.io" : "") +
+                (crates.length > 0 ? " and crates.io" : "") +
                 " by the nightly Azure release pipeline.",
         ].join("\n");
 
diff --git a/build/scripts/download-github-releases.mjs b/build/scripts/download-github-releases.mjs
index 35234e5f518..bb4eeda8642 100644
--- a/build/scripts/download-github-releases.mjs
+++ b/build/scripts/download-github-releases.mjs
@@ -27,6 +27,11 @@
  * versions plus matching release tags. This keeps historical bare beachball tags
  * from being treated as deployable releases while still working on a
  * freshly-cloned 1ES agent with no `node_modules` or cargo registry.
+ *
+ * Most workspaces map to at most one crate by name convention.
+ * `@microsoft/fast-build` intentionally maps to both `microsoft-fast-build`
+ * and `microsoft-fast-convert`, but still uses one npm package release tag
+ * and one Azure download task.
  */
 
 import { execFileSync } from "node:child_process";
@@ -62,6 +67,14 @@ function npmNameToCrateName(npmName) {
     return npmName.replace(/^@/, "").replace(/\//g, "-");
 }
 
+const bundledCratesByPackage = new Map([
+    ["@microsoft/fast-build", ["microsoft-fast-build", "microsoft-fast-convert"]],
+]);
+
+function npmNameToCrateNames(npmName) {
+    return bundledCratesByPackage.get(npmName) ?? [npmNameToCrateName(npmName)];
+}
+
 function shouldSkipCrates() {
     return process.env.FAST_RELEASE_SKIP_CRATES === "true";
 }
@@ -88,6 +101,24 @@ function readCargoTomlVersion(cargoTomlPath) {
     return null;
 }
 
+function validatePairedCrates(pkgName, pkgVersion) {
+    if (shouldSkipCrates()) return;
+
+    for (const crateName of npmNameToCrateNames(pkgName)) {
+        const cargoTomlPath = join("crates", crateName, "Cargo.toml");
+        if (!existsSync(cargoTomlPath)) continue;
+
+        const crateVersion = readCargoTomlVersion(cargoTomlPath);
+        if (crateVersion !== pkgVersion) {
+            throw new Error(
+                `Version mismatch for ${pkgName}: package.json is ${pkgVersion} ` +
+                    `but ${cargoTomlPath} is ${crateVersion}. ` +
+                    "Update one to match the other.",
+            );
+        }
+    }
+}
+
 function listPublishableWorkspaces() {
     const rootPkg = JSON.parse(readFileSync("package.json", "utf8"));
     const patterns = rootPkg.workspaces || [];
@@ -115,18 +146,7 @@ function listPublishableWorkspaces() {
         if (pkg.private === true) continue;
         if (!pkg.name || !pkg.version) continue;
 
-        const crateName = npmNameToCrateName(pkg.name);
-        const cargoTomlPath = join("crates", crateName, "Cargo.toml");
-        const hasCrate = existsSync(cargoTomlPath) && !shouldSkipCrates();
-
-        if (hasCrate) {
-            const crateVersion = readCargoTomlVersion(cargoTomlPath);
-            if (crateVersion !== pkg.version) {
-                throw new Error(
-                    `Version mismatch for ${pkg.name}: package.json is ${pkg.version} but ${cargoTomlPath} is ${crateVersion}. Update one to match the other.`,
-                );
-            }
-        }
+        validatePairedCrates(pkg.name, pkg.version);
 
         workspaces.push({
             location,
diff --git a/change/@microsoft-fast-build-40280b6e-6a6e-4d63-92ce-3158204cb0e0.json b/change/@microsoft-fast-build-40280b6e-6a6e-4d63-92ce-3158204cb0e0.json
new file mode 100644
index 00000000000..44a4fb52a0c
--- /dev/null
+++ b/change/@microsoft-fast-build-40280b6e-6a6e-4d63-92ce-3158204cb0e0.json
@@ -0,0 +1,7 @@
+{
+  "type": "minor",
+  "comment": "Add FAST declarative template conversion to the fast CLI.",
+  "packageName": "@microsoft/fast-build",
+  "email": "7559015+janechu@users.noreply.github.com",
+  "dependentChangeType": "none"
+}
diff --git a/change/@microsoft-fast-element-37f5e2c1-9e6e-4fc8-aee0-2e7dfb2d5a15.json b/change/@microsoft-fast-element-37f5e2c1-9e6e-4fc8-aee0-2e7dfb2d5a15.json
new file mode 100644
index 00000000000..baca5688274
--- /dev/null
+++ b/change/@microsoft-fast-element-37f5e2c1-9e6e-4fc8-aee0-2e7dfb2d5a15.json
@@ -0,0 +1,7 @@
+{
+  "type": "none",
+  "comment": "Update WebUI integration fixtures to generate templates with fast convert.",
+  "packageName": "@microsoft/fast-element",
+  "email": "7559015+janechu@users.noreply.github.com",
+  "dependentChangeType": "none"
+}
diff --git a/crates/microsoft-fast-convert/Cargo.lock b/crates/microsoft-fast-convert/Cargo.lock
new file mode 100644
index 00000000000..45d3a0bf751
--- /dev/null
+++ b/crates/microsoft-fast-convert/Cargo.lock
@@ -0,0 +1,114 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "microsoft-fast-convert"
+version = "0.9.0"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "syn"
+version = "2.0.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b067c0c11094aef6b7a801c1e34a26affafdf3d051dba08456b868789aaf9a4"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167ce5e579f6bcf889c4f7175a8a5a585de84e8ff93976ce393efa5f2837aab1"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3997c7839262f4ef12cf90b818d6340c18e80f263f1a94bf157d0ec4420380e"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1b4cb0cc549fcf58d7dfc081778139b3d283a081644e833e84682ad71cea24"
+dependencies = [
+ "unicode-ident",
+]
diff --git a/crates/microsoft-fast-convert/Cargo.toml b/crates/microsoft-fast-convert/Cargo.toml
new file mode 100644
index 00000000000..0dc3fb33fee
--- /dev/null
+++ b/crates/microsoft-fast-convert/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "microsoft-fast-convert"
+version = "0.9.0"
+edition = "2021"
+description = "Converter for FAST declarative HTML templates into WebUI prerelease HTML or FAST v3 TypeScript templates."
+license = "MIT"
+readme = "README.md"
+homepage = "https://www.fast.design/"
+repository = "https://github.com/microsoft/fast"
+keywords = ["fast", "html", "template", "converter", "web-components"]
+categories = ["template-engine", "web-programming"]
+
+[lib]
+name = "microsoft_fast_convert"
+path = "src/lib.rs"
+crate-type = ["cdylib", "rlib"]
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasm-bindgen = "0.2"
diff --git a/crates/microsoft-fast-convert/DESIGN.md b/crates/microsoft-fast-convert/DESIGN.md
new file mode 100644
index 00000000000..4d1ade6d30c
--- /dev/null
+++ b/crates/microsoft-fast-convert/DESIGN.md
@@ -0,0 +1,55 @@
+# Design — microsoft-fast-convert
+
+`microsoft-fast-convert` converts from FAST declarative syntax only. It accepts one FAST `<f-template>` string, validates the supported subset, and emits either WebUI prerelease HTML or FAST v3 TypeScript source.
+
+## Pipeline
+
+```text
+convert_template(template, syntax)
+        │
+        ├─ parse syntax (`webui-prerelease` | `fast-v3-ts`)
+        ├─ validate one outer `<f-template name="…">`
+        ├─ extract exactly one inner `<template>`
+        └─ target converter
+```
+
+The implementation intentionally uses a small hand scanner instead of an HTML parser, matching the dependency style of `microsoft-fast-build`.
+
+## Modules
+
+| Module | Role |
+| --- | --- |
+| `lib.rs` | Public Rust API and crate exports |
+| `wasm.rs` | `wasm-bindgen` exports for Node (`convert_template`, `convert_syntax_metadata`) |
+| `error.rs` | `ConvertError` variants and context helpers |
+| `html.rs` | Tag, attribute, and `<f-template>` scanning utilities |
+| `expression.rs` | Limited declarative expression conversion for TypeScript output |
+| `converter.rs` | Syntax selection and dispatch after shared `<f-template>` validation |
+| `syntax/mod.rs` | Shared syntax-target helpers and exported syntax metadata |
+| `syntax/webui.rs` | `webui-prerelease` conversion pass |
+| `syntax/fast_v3_ts.rs` | `fast-v3-ts` conversion pass |
+
+Syntax-specific conversion logic lives under `syntax/` so new targets can be added
+without growing `converter.rs`. To add a syntax target, create a new module under
+`syntax/`, expose a `convert(&str) -> Result<String, ConvertError>` function, add the
+target's metadata (`name`, output `extension`, and default `suffix`) in that module,
+add the accepted syntax value to `converter.rs`, and route the new `Syntax` variant
+to the module. The `@microsoft/fast-build` CLI reads the exported WASM metadata, so
+syntax names, output extensions, and default suffixes should be defined in Rust only.
+
+## WebUI prerelease conversion
+
+The WebUI target unwraps the outer `<f-template>` and preserves the inner `<template>` element. It rewrites only structural FAST directives:
+
+- `<f-repeat value="{{item in items}}">` → `<for each="item in items">`
+- `<f-when value="{{condition}}">` → `<if condition="condition">`
+
+Other supported FAST attributes such as `@click`, `:prop`, `?bool`, `f-ref`, `f-children`, and `f-slotted` are preserved.
+
+## FAST v3 TypeScript conversion
+
+The TypeScript target always emits `export const template = html\`…\`;` and imports only helpers used by the converted template. It supports text and attribute bindings, `f-repeat`, `f-when`, `f-ref`, `f-children`, `f-slotted`, and event handler calls using `$e`/`$c`.
+
+Repeat bodies use the same local alias mapping as FAST declarative templates: `{{item.name}}` inside `item in items` becomes `x => x.name`. Event handlers inside repeats map root handlers through FAST's repeat context chain (`c.parent`, `c.parentContext.parent`, and so on).
+
+Literal template content is escaped for TypeScript template literals by escaping backticks, literal `${` sequences, and backslashes.
diff --git a/crates/microsoft-fast-convert/README.md b/crates/microsoft-fast-convert/README.md
new file mode 100644
index 00000000000..0970cd60dbc
--- /dev/null
+++ b/crates/microsoft-fast-convert/README.md
@@ -0,0 +1,39 @@
+# microsoft-fast-convert
+
+`microsoft-fast-convert` converts one FAST declarative HTML template string into another supported syntax. It is written in Rust and exposes both a Rust API and a `wasm-bindgen` API for Node tooling.
+
+## Supported targets
+
+- `webui-prerelease` — unwraps the outer `<f-template>` and emits a WebUI prerelease `<template>` string. It converts `<f-repeat>` to `<for>` and `<f-when>` to `<if>` while preserving other FAST attribute syntax that WebUI's FAST plugin expects.
+- `fast-v3-ts` — emits TypeScript source that imports FAST helpers and exports `template` as an `html` tagged template.
+
+## Rust usage
+
+```rust
+use microsoft_fast_convert::convert_template;
+
+let source = r#"<f-template name="my-element"><template>{{title}}</template></f-template>"#;
+let ts = convert_template(source, "fast-v3-ts")?;
+```
+
+The Rust API returns `Result<String, ConvertError>`.
+
+Syntax metadata is available through `syntax_metadata()`. The metadata includes each
+supported syntax name, required output extension, and default output suffix so package
+tooling can avoid duplicating target definitions.
+
+## WASM usage
+
+When built with `wasm-pack --target nodejs`, the crate exports:
+
+```ts
+convert_template(template: string, syntax: string): string
+convert_syntax_metadata(): string
+```
+
+`convert_syntax_metadata()` returns JSON metadata for supported syntax targets.
+Errors are raised as JavaScript exceptions with the `ConvertError` message.
+
+## Validation
+
+The converter validates that the input contains exactly one `<f-template name="…">` with a non-empty name and exactly one inner `<template>`. It validates supported syntax values, `<f-repeat>` and `<f-when>` `value="{{…}}"` expressions, supported `f-*` attributes, and the limited expression grammar used for `fast-v3-ts` output.
diff --git a/crates/microsoft-fast-convert/src/converter.rs b/crates/microsoft-fast-convert/src/converter.rs
new file mode 100644
index 00000000000..5b6394a9893
--- /dev/null
+++ b/crates/microsoft-fast-convert/src/converter.rs
@@ -0,0 +1,31 @@
+use crate::error::ConvertError;
+use crate::html::parse_template_document;
+use crate::syntax::{fast_v3_ts, webui};
+
+pub(crate) fn convert(template: &str, syntax: &str) -> Result<String, ConvertError> {
+    let syntax = Syntax::parse(syntax)?;
+    let parsed = parse_template_document(template)?;
+
+    match syntax {
+        Syntax::WebuiPrerelease => webui::convert(&parsed.template),
+        Syntax::FastV3Ts => fast_v3_ts::convert(&parsed.template),
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Syntax {
+    WebuiPrerelease,
+    FastV3Ts,
+}
+
+impl Syntax {
+    fn parse(value: &str) -> Result<Self, ConvertError> {
+        match value {
+            value if value == webui::METADATA.name => Ok(Self::WebuiPrerelease),
+            value if value == fast_v3_ts::METADATA.name => Ok(Self::FastV3Ts),
+            _ => Err(ConvertError::UnsupportedSyntax {
+                syntax: value.to_string(),
+            }),
+        }
+    }
+}
diff --git a/crates/microsoft-fast-convert/src/error.rs b/crates/microsoft-fast-convert/src/error.rs
new file mode 100644
index 00000000000..52dc9085fd9
--- /dev/null
+++ b/crates/microsoft-fast-convert/src/error.rs
@@ -0,0 +1,159 @@
+use std::fmt;
+
+/// An error encountered while converting a FAST declarative template.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ConvertError {
+    /// The requested target syntax is not supported.
+    UnsupportedSyntax { syntax: String },
+    /// No `<f-template>` element was present in the input.
+    MissingFTemplate,
+    /// More than one `<f-template>` element was present in the input.
+    MultipleFTemplates { count: usize },
+    /// The `<f-template>` element is missing a string-valued `name` attribute.
+    MissingFTemplateName,
+    /// The `<f-template name="…">` value is empty or whitespace.
+    EmptyFTemplateName,
+    /// The `<f-template>` element does not contain an inner `<template>` element.
+    MissingInnerTemplate,
+    /// The `<f-template>` element contains more than one inner `<template>` element.
+    MultipleInnerTemplates { count: usize },
+    /// An HTML element was not closed.
+    UnclosedElement { tag: String, context: String },
+    /// An opening tag was not terminated with `>`.
+    UnclosedTag { context: String },
+    /// A directive is missing its required `value="{{…}}"` attribute.
+    MissingValueAttribute { tag: String, context: String },
+    /// A directive `value` attribute is not wrapped in declarative binding delimiters.
+    InvalidDirectiveValue {
+        tag: String,
+        value: Option<String>,
+        context: String,
+    },
+    /// An `<f-repeat>` expression is not in `item in items` form.
+    InvalidRepeatExpression { expr: String, context: String },
+    /// A double-brace binding is not closed.
+    UnclosedBinding { context: String },
+    /// A double-brace binding has no expression.
+    EmptyBinding { context: String },
+    /// An `f-*` attribute is not supported by the converter.
+    UnsupportedFAttribute { attribute: String, context: String },
+    /// An `f-*` element is not supported by the converter.
+    UnsupportedFElement { tag: String, context: String },
+    /// A declarative expression is outside the supported converter grammar.
+    UnsupportedExpression {
+        expr: String,
+        reason: String,
+        context: String,
+    },
+    /// An event handler expression could not be converted.
+    UnsupportedEventHandler {
+        value: String,
+        reason: String,
+        context: String,
+    },
+}
+
+impl fmt::Display for ConvertError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::UnsupportedSyntax { syntax } => write!(
+                f,
+                "unsupported syntax '{syntax}': accepted values are {}",
+                crate::syntax::accepted_syntax_names()
+            ),
+            Self::MissingFTemplate => write!(
+                f,
+                "template validation error: expected exactly one '<f-template>' element"
+            ),
+            Self::MultipleFTemplates { count } => write!(
+                f,
+                "template validation error: expected exactly one '<f-template>' element, found {count}"
+            ),
+            Self::MissingFTemplateName => write!(
+                f,
+                "template validation error: '<f-template>' must include a string 'name' attribute"
+            ),
+            Self::EmptyFTemplateName => write!(
+                f,
+                "template validation error: '<f-template name>' cannot be empty"
+            ),
+            Self::MissingInnerTemplate => write!(
+                f,
+                "template validation error: '<f-template>' must contain exactly one inner '<template>' element"
+            ),
+            Self::MultipleInnerTemplates { count } => write!(
+                f,
+                "template validation error: '<f-template>' must contain exactly one inner '<template>' element, found {count}"
+            ),
+            Self::UnclosedElement { tag, context } => write!(
+                f,
+                "unclosed element '<{tag}>': no matching '</{tag}>' closing tag was found — template: \"{context}\""
+            ),
+            Self::UnclosedTag { context } => write!(
+                f,
+                "unclosed tag: no closing '>' was found — template: \"{context}\""
+            ),
+            Self::MissingValueAttribute { tag, context } => write!(
+                f,
+                "directive '<{tag}>' is missing a valid 'value=\"{{{{…}}}}\"' attribute — template: \"{context}\""
+            ),
+            Self::InvalidDirectiveValue { tag, value, context } => {
+                let value = value.as_deref().unwrap_or("");
+                write!(
+                    f,
+                    "directive '<{tag}>' has invalid value '{value}': expected 'value=\"{{{{…}}}}\"' — template: \"{context}\""
+                )
+            }
+            Self::InvalidRepeatExpression { expr, context } => write!(
+                f,
+                "invalid repeat expression '{{{{{expr}}}}}': expected 'item in items' format — template: \"{context}\""
+            ),
+            Self::UnclosedBinding { context } => write!(
+                f,
+                "unclosed binding '{{{{…': no closing '}}}}' found — template: \"{context}\""
+            ),
+            Self::EmptyBinding { context } => write!(
+                f,
+                "empty binding '{{{{}}}}': the expression between '{{{{' and '}}}}' cannot be empty — template: \"{context}\""
+            ),
+            Self::UnsupportedFAttribute { attribute, context } => write!(
+                f,
+                "unsupported f-* attribute '{attribute}' — template: \"{context}\""
+            ),
+            Self::UnsupportedFElement { tag, context } => write!(
+                f,
+                "unsupported f-* element '<{tag}>' — template: \"{context}\""
+            ),
+            Self::UnsupportedExpression { expr, reason, context } => write!(
+                f,
+                "unsupported expression '{{{{{expr}}}}}': {reason} — template: \"{context}\""
+            ),
+            Self::UnsupportedEventHandler { value, reason, context } => write!(
+                f,
+                "unsupported event handler '{{{value}}}': {reason} — template: \"{context}\""
+            ),
+        }
+    }
+}
+
+impl std::error::Error for ConvertError {}
+
+/// Extract a short snippet of `template` around `at` for use in error messages.
+pub(crate) fn template_context(template: &str, at: usize) -> String {
+    const PRE: usize = 20;
+    const POST: usize = 80;
+
+    let mut start = at.saturating_sub(PRE);
+    while start > 0 && !template.is_char_boundary(start) {
+        start -= 1;
+    }
+
+    let mut end = (at + POST).min(template.len());
+    while end < template.len() && !template.is_char_boundary(end) {
+        end += 1;
+    }
+
+    let prefix = if start > 0 { "…" } else { "" };
+    let suffix = if end < template.len() { "…" } else { "" };
+    format!("{prefix}{}{suffix}", &template[start..end])
+}
diff --git a/crates/microsoft-fast-convert/src/expression.rs b/crates/microsoft-fast-convert/src/expression.rs
new file mode 100644
index 00000000000..1e9f5519998
--- /dev/null
+++ b/crates/microsoft-fast-convert/src/expression.rs
@@ -0,0 +1,496 @@
+use crate::error::{template_context, ConvertError};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RepeatScope {
+    pub(crate) alias: String,
+}
+
+pub(crate) fn parse_repeat_expression(
+    expr: &str,
+    context: &str,
+    at: usize,
+) -> Result<(String, String), ConvertError> {
+    let parts: Vec<&str> = expr.split_whitespace().collect();
+    if parts.len() != 3 || parts[1] != "in" || !is_identifier(parts[0]) || !is_path(parts[2]) {
+        return Err(ConvertError::InvalidRepeatExpression {
+            expr: expr.to_string(),
+            context: template_context(context, at),
+        });
+    }
+
+    Ok((parts[0].to_string(), parts[2].to_string()))
+}
+
+pub(crate) fn expression_to_arrow(
+    expr: &str,
+    scopes: &[RepeatScope],
+    context: &str,
+    at: usize,
+) -> Result<String, ConvertError> {
+    Ok(format!(
+        "x => {}",
+        expression_to_js(expr, scopes, context, at)?
+    ))
+}
+
+pub(crate) fn event_handler_to_arrow(
+    value: &str,
+    scopes: &[RepeatScope],
+    context: &str,
+    at: usize,
+) -> Result<String, ConvertError> {
+    let expr = value.trim();
+    let open = expr
+        .find('(')
+        .ok_or_else(|| ConvertError::UnsupportedEventHandler {
+            value: value.to_string(),
+            reason: "expected a handler call such as 'handleClick($e)'".to_string(),
+            context: template_context(context, at),
+        })?;
+    if !expr.ends_with(')') {
+        return Err(ConvertError::UnsupportedEventHandler {
+            value: value.to_string(),
+            reason: "event handler calls must end with ')'".to_string(),
+            context: template_context(context, at),
+        });
+    }
+
+    let path = expr[..open].trim();
+    if !is_path(path) {
+        return Err(ConvertError::UnsupportedEventHandler {
+            value: value.to_string(),
+            reason: "handler name must be an identifier or dotted path".to_string(),
+            context: template_context(context, at),
+        });
+    }
+
+    let args = &expr[open + 1..expr.len() - 1];
+    let converted_args = split_arguments(args)
+        .into_iter()
+        .map(|arg| event_argument_to_js(arg, scopes, context, at))
+        .collect::<Result<Vec<_>, _>>()?;
+
+    Ok(format!(
+        "(x, c) => {}({})",
+        event_handler_target(path, scopes, context, at)?,
+        converted_args.join(", ")
+    ))
+}
+
+fn expression_to_js(
+    expr: &str,
+    scopes: &[RepeatScope],
+    context: &str,
+    at: usize,
+) -> Result<String, ConvertError> {
+    let expr = expr.trim();
+    if expr.is_empty() {
+        return Err(ConvertError::EmptyBinding {
+            context: template_context(context, at),
+        });
+    }
+
+    reject_known_unsupported(expr, context, at)?;
+
+    if let Some(inner) = strip_outer_parens(expr) {
+        return Ok(format!(
+            "({})",
+            expression_to_js(inner, scopes, context, at)?
+        ));
+    }
+
+    if let Some((idx, op)) = find_top_level_operator(expr, &["||"]) {
+        return binary_to_js(expr, idx, op, scopes, context, at);
+    }
+    if let Some((idx, op)) = find_top_level_operator(expr, &["&&"]) {
+        return binary_to_js(expr, idx, op, scopes, context, at);
+    }
+    if let Some((idx, op)) = find_top_level_operator(expr, &[">=", "<=", "==", "!=", ">", "<"]) {
+        return binary_to_js(expr, idx, op, scopes, context, at);
+    }
+
+    if let Some(inner) = expr.strip_prefix('!') {
+        let converted = expression_to_js(inner, scopes, context, at)?;
+        return if converted.contains(' ') {
+            Ok(format!("!({converted})"))
+        } else {
+            Ok(format!("!{converted}"))
+        };
+    }
+
+    if is_string_literal(expr)
+        || is_number_literal(expr)
+        || matches!(expr, "true" | "false" | "null")
+    {
+        return Ok(expr.to_string());
+    }
+
+    if is_path(expr) {
+        return path_to_js(expr, scopes, context, at, false);
+    }
+
+    let reason = if expr.contains('(') || expr.contains(')') {
+        "function calls and unsupported parenthesized expressions are not supported"
+    } else {
+        "expected an identifier, dotted path, literal, or supported operator expression"
+    };
+    Err(ConvertError::UnsupportedExpression {
+        expr: expr.to_string(),
+        reason: reason.to_string(),
+        context: template_context(context, at),
+    })
+}
+
+fn binary_to_js(
+    expr: &str,
+    idx: usize,
+    op: &str,
+    scopes: &[RepeatScope],
+    context: &str,
+    at: usize,
+) -> Result<String, ConvertError> {
+    let left = expression_to_js(&expr[..idx], scopes, context, at)?;
+    let right = expression_to_js(&expr[idx + op.len()..], scopes, context, at)?;
+    Ok(format!("{left} {op} {right}"))
+}
+
+fn reject_known_unsupported(expr: &str, context: &str, at: usize) -> Result<(), ConvertError> {
+    let reason = if expr.contains("?.") {
+        Some("optional chaining is not supported")
+    } else if expr.contains('[') || expr.contains(']') {
+        Some("bracket access is not supported")
+    } else if expr.contains("=>") {
+        Some("arrow functions are not supported")
+    } else {
+        None
+    };
+
+    if let Some(reason) = reason {
+        return Err(ConvertError::UnsupportedExpression {
+            expr: expr.to_string(),
+            reason: reason.to_string(),
+            context: template_context(context, at),
+        });
+    }
+
+    Ok(())
+}
+
+fn path_to_js(
+    path: &str,
+    scopes: &[RepeatScope],
+    context: &str,
+    at: usize,
+    allow_root_from_repeat: bool,
+) -> Result<String, ConvertError> {
+    let mut parts = path.split('.');
+    let head = parts.next().unwrap_or_default();
+    let rest = parts.collect::<Vec<_>>().join(".");
+
+    if let Some(current) = scopes.last() {
+        if head == current.alias {
+            return if rest.is_empty() {
+                Ok("x".to_string())
+            } else {
+                Ok(format!("x.{rest}"))
+            };
+        }
+
+        if scopes[..scopes.len() - 1]
+            .iter()
+            .any(|scope| scope.alias == head)
+        {
+            return Err(ConvertError::UnsupportedExpression {
+                expr: path.to_string(),
+                reason: "parent repeat aliases are not supported in bindings".to_string(),
+                context: template_context(context, at),
+            });
+        }
+
+        if allow_root_from_repeat {
+            return Ok(format!("{}.{}", repeat_parent_context(scopes.len()), path));
+        }
+
+        return Err(ConvertError::UnsupportedExpression {
+            expr: path.to_string(),
+            reason: "root access from inside f-repeat is not supported for bindings".to_string(),
+            context: template_context(context, at),
+        });
+    }
+
+    Ok(format!("x.{path}"))
+}
+
+fn event_handler_target(
+    path: &str,
+    scopes: &[RepeatScope],
+    context: &str,
+    at: usize,
+) -> Result<String, ConvertError> {
+    let mut parts = path.split('.');
+    let head = parts.next().unwrap_or_default();
+    let rest = parts.collect::<Vec<_>>().join(".");
+
+    if let Some(current) = scopes.last() {
+        if head == current.alias {
+            return if rest.is_empty() {
+                Ok("x".to_string())
+            } else {
+                Ok(format!("x.{rest}"))
+            };
+        }
+
+        if scopes[..scopes.len() - 1]
+            .iter()
+            .any(|scope| scope.alias == head)
+        {
+            return Err(ConvertError::UnsupportedEventHandler {
+                value: path.to_string(),
+                reason: "parent repeat aliases are not supported in event handler targets"
+                    .to_string(),
+                context: template_context(context, at),
+            });
+        }
+
+        return Ok(format!("{}.{}", repeat_parent_context(scopes.len()), path));
+    }
+
+    Ok(format!("x.{path}"))
+}
+
+fn event_argument_to_js(
+    arg: &str,
+    scopes: &[RepeatScope],
+    context: &str,
+    at: usize,
+) -> Result<String, ConvertError> {
+    let arg = arg.trim();
+    match arg {
+        "" => Ok(String::new()),
+        "$e" => Ok("c.event".to_string()),
+        "$c" => Ok("c".to_string()),
+        _ if is_path(arg) && !scopes.is_empty() => path_to_js(arg, scopes, context, at, true),
+        _ => expression_to_js(arg, scopes, context, at),
+    }
+}
+
+fn repeat_parent_context(depth: usize) -> String {
+    if depth == 0 {
+        return "x".to_string();
+    }
+
+    let mut out = String::from("c.");
+    for _ in 1..depth {
+        out.push_str("parentContext.");
+    }
+    out.push_str("parent");
+    out
+}
+
+fn split_arguments(args: &str) -> Vec<&str> {
+    let mut result = Vec::new();
+    let mut start = 0usize;
+    let mut depth = 0usize;
+    let mut quote: Option<u8> = None;
+    let mut escaped = false;
+    let bytes = args.as_bytes();
+    let mut i = 0usize;
+
+    while i < bytes.len() {
+        if let Some(active_quote) = quote {
+            if escaped {
+                escaped = false;
+            } else if bytes[i] == b'\\' {
+                escaped = true;
+            } else if bytes[i] == active_quote {
+                quote = None;
+            }
+            i += 1;
+            continue;
+        }
+
+        match bytes[i] {
+            b'"' | b'\'' => quote = Some(bytes[i]),
+            b'(' => depth += 1,
+            b')' if depth > 0 => depth -= 1,
+            b',' if depth == 0 => {
+                result.push(args[start..i].trim());
+                start = i + 1;
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+
+    let tail = args[start..].trim();
+    if !tail.is_empty() {
+        result.push(tail);
+    }
+    result
+}
+
+fn find_top_level_operator<'a>(expr: &str, ops: &[&'a str]) -> Option<(usize, &'a str)> {
+    let bytes = expr.as_bytes();
+    let mut depth = 0usize;
+    let mut quote: Option<u8> = None;
+    let mut escaped = false;
+    let mut i = 0usize;
+
+    while i < bytes.len() {
+        if let Some(active_quote) = quote {
+            if escaped {
+                escaped = false;
+            } else if bytes[i] == b'\\' {
+                escaped = true;
+            } else if bytes[i] == active_quote {
+                quote = None;
+            }
+            i += 1;
+            continue;
+        }
+
+        match bytes[i] {
+            b'"' | b'\'' => quote = Some(bytes[i]),
+            b'(' => depth += 1,
+            b')' if depth > 0 => depth -= 1,
+            _ if depth == 0 => {
+                for op in ops {
+                    if bytes[i..].starts_with(op.as_bytes()) {
+                        return Some((i, *op));
+                    }
+                }
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+
+    None
+}
+
+fn strip_outer_parens(expr: &str) -> Option<&str> {
+    if !expr.starts_with('(') || !expr.ends_with(')') {
+        return None;
+    }
+
+    let bytes = expr.as_bytes();
+    let mut depth = 0usize;
+    let mut quote: Option<u8> = None;
+    let mut escaped = false;
+
+    for (i, byte) in bytes.iter().enumerate() {
+        if let Some(active_quote) = quote {
+            if escaped {
+                escaped = false;
+            } else if *byte == b'\\' {
+                escaped = true;
+            } else if *byte == active_quote {
+                quote = None;
+            }
+            continue;
+        }
+
+        match *byte {
+            b'"' | b'\'' => quote = Some(*byte),
+            b'(' => depth += 1,
+            b')' => {
+                if depth == 0 {
+                    return None;
+                }
+                depth -= 1;
+                if depth == 0 && i != bytes.len() - 1 {
+                    return None;
+                }
+            }
+            _ => {}
+        }
+    }
+
+    if depth == 0 {
+        Some(&expr[1..expr.len() - 1])
+    } else {
+        None
+    }
+}
+
+fn is_string_literal(expr: &str) -> bool {
+    if expr.len() < 2 {
+        return false;
+    }
+    let bytes = expr.as_bytes();
+    let quote = bytes[0];
+    if quote != b'"' && quote != b'\'' || bytes[bytes.len() - 1] != quote {
+        return false;
+    }
+
+    let mut escaped = false;
+    for byte in &bytes[1..bytes.len() - 1] {
+        if escaped {
+            escaped = false;
+        } else if *byte == b'\\' {
+            escaped = true;
+        } else if *byte == quote {
+            return false;
+        }
+    }
+
+    !escaped
+}
+
+fn is_number_literal(expr: &str) -> bool {
+    if expr.is_empty() || !expr.chars().any(|ch| ch.is_ascii_digit()) {
+        return false;
+    }
+    expr.parse::<f64>().is_ok()
+        && expr
+            .chars()
+            .all(|ch| ch.is_ascii_digit() || matches!(ch, '.' | '-' | '+' | 'e' | 'E'))
+}
+
+pub(crate) fn is_path(expr: &str) -> bool {
+    let mut parts = expr.split('.');
+    let Some(first) = parts.next() else {
+        return false;
+    };
+    !first.is_empty()
+        && is_identifier(first)
+        && parts.all(|part| !part.is_empty() && is_identifier(part))
+}
+
+fn is_identifier(segment: &str) -> bool {
+    let mut chars = segment.chars();
+    let Some(first) = chars.next() else {
+        return false;
+    };
+    (first == '_' || first == '$' || first.is_ascii_alphabetic())
+        && chars.all(|ch| ch == '_' || ch == '$' || ch.is_ascii_alphanumeric())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parent_context_matches_declarative_repeat_chain() {
+        assert_eq!(repeat_parent_context(1), "c.parent");
+        assert_eq!(repeat_parent_context(2), "c.parentContext.parent");
+        assert_eq!(
+            repeat_parent_context(3),
+            "c.parentContext.parentContext.parent"
+        );
+    }
+
+    #[test]
+    fn operators_ignore_escaped_quotes_inside_string_literals() {
+        let output = expression_to_arrow(r#""a \" || b" || enabled"#, &[], "", 0).unwrap();
+
+        assert_eq!(output, r#"x => "a \" || b" || x.enabled"#);
+    }
+
+    #[test]
+    fn non_ascii_expressions_return_errors_without_panicking() {
+        let error = expression_to_arrow("é", &[], "", 0).unwrap_err();
+
+        assert!(error.to_string().contains("unsupported expression"));
+    }
+}
diff --git a/crates/microsoft-fast-convert/src/html.rs b/crates/microsoft-fast-convert/src/html.rs
new file mode 100644
index 00000000000..7dbcd2f82e2
--- /dev/null
+++ b/crates/microsoft-fast-convert/src/html.rs
@@ -0,0 +1,323 @@
+use crate::error::{template_context, ConvertError};
+
+#[derive(Debug, Clone)]
+pub(crate) struct ParsedTemplate {
+    pub(crate) _name: String,
+    pub(crate) template: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct ParsedAttribute {
+    pub(crate) name: String,
+    pub(crate) value: Option<String>,
+    pub(crate) raw: String,
+}
+
+pub(crate) fn parse_template_document(template: &str) -> Result<ParsedTemplate, ConvertError> {
+    let f_templates = find_open_tags(template, "f-template");
+    match f_templates.len() {
+        0 => return Err(ConvertError::MissingFTemplate),
+        1 => {}
+        count => return Err(ConvertError::MultipleFTemplates { count }),
+    }
+
+    let f_template_start = f_templates[0];
+    let f_template_end =
+        find_tag_end(template, f_template_start).ok_or_else(|| ConvertError::UnclosedTag {
+            context: template_context(template, f_template_start),
+        })?;
+    let f_template_tag = &template[f_template_start..f_template_end];
+    let name =
+        read_attribute_value(f_template_tag, "name").ok_or(ConvertError::MissingFTemplateName)?;
+    let name = name.trim();
+    if name.is_empty() {
+        return Err(ConvertError::EmptyFTemplateName);
+    }
+
+    let (f_template_close, _) = find_matching_close(template, f_template_start, "f-template")
+        .ok_or_else(|| ConvertError::UnclosedElement {
+            tag: "f-template".to_string(),
+            context: template_context(template, f_template_start),
+        })?;
+    let body = &template[f_template_end..f_template_close];
+
+    let inner_templates = find_open_tags(body, "template");
+    match inner_templates.len() {
+        0 => return Err(ConvertError::MissingInnerTemplate),
+        1 => {}
+        count => return Err(ConvertError::MultipleInnerTemplates { count }),
+    }
+
+    let inner_start = inner_templates[0];
+    let (_, inner_close_end) =
+        find_matching_close(body, inner_start, "template").ok_or_else(|| {
+            ConvertError::UnclosedElement {
+                tag: "template".to_string(),
+                context: template_context(body, inner_start),
+            }
+        })?;
+
+    Ok(ParsedTemplate {
+        _name: name.to_string(),
+        template: body[inner_start..inner_close_end].to_string(),
+    })
+}
+
+pub(crate) fn find_open_tags(template: &str, tag_name: &str) -> Vec<usize> {
+    let mut tags = Vec::new();
+    let mut pos = 0;
+
+    while let Some(relative) = template[pos..].find('<') {
+        let lt = pos + relative;
+        if template[lt..].starts_with("<!--") {
+            pos = find_comment_end(template, lt).unwrap_or(template.len());
+            continue;
+        }
+
+        match read_tag_name(template, lt) {
+            Some(name) => {
+                if name == tag_name {
+                    tags.push(lt);
+                }
+                pos = find_tag_end(template, lt).unwrap_or(lt + 1);
+            }
+            None => pos = lt + 1,
+        }
+    }
+
+    tags
+}
+
+pub(crate) fn find_matching_close(
+    template: &str,
+    open_start: usize,
+    tag_name: &str,
+) -> Option<(usize, usize)> {
+    let open_end = find_tag_end(template, open_start)?;
+    if is_self_closing_tag(&template[open_start..open_end]) {
+        return None;
+    }
+
+    let mut depth = 1usize;
+    let mut pos = open_end;
+
+    while let Some(relative) = template[pos..].find('<') {
+        let lt = pos + relative;
+        if template[lt..].starts_with("<!--") {
+            pos = find_comment_end(template, lt).unwrap_or(template.len());
+            continue;
+        }
+
+        if template[lt..].starts_with("</") {
+            if let Some(name) = read_closing_tag_name(template, lt) {
+                let close_end = find_tag_end(template, lt)?;
+                if name == tag_name {
+                    depth -= 1;
+                    if depth == 0 {
+                        return Some((lt, close_end));
+                    }
+                }
+                pos = close_end;
+            } else {
+                pos = lt + 1;
+            }
+            continue;
+        }
+
+        if let Some(name) = read_tag_name(template, lt) {
+            let tag_end = find_tag_end(template, lt)?;
+            if name == tag_name && !is_self_closing_tag(&template[lt..tag_end]) {
+                depth += 1;
+            }
+            pos = tag_end;
+        } else {
+            pos = lt + 1;
+        }
+    }
+
+    None
+}
+
+pub(crate) fn find_tag_end(template: &str, from: usize) -> Option<usize> {
+    let bytes = template.as_bytes();
+    let mut i = from;
+    let mut in_quote = false;
+    let mut quote_char = b'"';
+
+    while i < bytes.len() {
+        match bytes[i] {
+            c if in_quote && c == quote_char => in_quote = false,
+            b'"' | b'\'' if !in_quote => {
+                in_quote = true;
+                quote_char = bytes[i];
+            }
+            b'>' if !in_quote => return Some(i + 1),
+            _ => {}
+        }
+        i += 1;
+    }
+
+    None
+}
+
+pub(crate) fn read_tag_name(template: &str, lt_pos: usize) -> Option<String> {
+    let bytes = template.as_bytes();
+    let mut i = lt_pos;
+    if bytes.get(i) != Some(&b'<') {
+        return None;
+    }
+    i += 1;
+
+    if matches!(bytes.get(i), Some(b'/') | Some(b'!') | Some(b'?')) {
+        return None;
+    }
+
+    while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+        i += 1;
+    }
+
+    let start = i;
+    while i < bytes.len() && !bytes[i].is_ascii_whitespace() && bytes[i] != b'>' && bytes[i] != b'/'
+    {
+        i += 1;
+    }
+
+    if i == start {
+        None
+    } else {
+        Some(template[start..i].to_string())
+    }
+}
+
+fn read_closing_tag_name(template: &str, lt_pos: usize) -> Option<String> {
+    let bytes = template.as_bytes();
+    let mut i = lt_pos;
+    if bytes.get(i) != Some(&b'<') || bytes.get(i + 1) != Some(&b'/') {
+        return None;
+    }
+    i += 2;
+
+    while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+        i += 1;
+    }
+
+    let start = i;
+    while i < bytes.len() && !bytes[i].is_ascii_whitespace() && bytes[i] != b'>' && bytes[i] != b'/'
+    {
+        i += 1;
+    }
+
+    if i == start {
+        None
+    } else {
+        Some(template[start..i].to_string())
+    }
+}
+
+pub(crate) fn is_self_closing_tag(open_tag: &str) -> bool {
+    let trimmed = open_tag.trim_end();
+    trimmed.ends_with("/>")
+}
+
+pub(crate) fn parse_attributes(open_tag: &str) -> Vec<ParsedAttribute> {
+    let mut attrs = Vec::new();
+    let bytes = open_tag.as_bytes();
+    let mut i = 0;
+
+    if bytes.get(i) == Some(&b'<') {
+        i += 1;
+    }
+
+    while i < bytes.len() && !bytes[i].is_ascii_whitespace() && bytes[i] != b'>' && bytes[i] != b'/'
+    {
+        i += 1;
+    }
+
+    loop {
+        while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+            i += 1;
+        }
+
+        if i >= bytes.len() || bytes[i] == b'>' || bytes[i] == b'/' {
+            break;
+        }
+
+        let name_start = i;
+        while i < bytes.len()
+            && bytes[i] != b'='
+            && !bytes[i].is_ascii_whitespace()
+            && bytes[i] != b'>'
+            && bytes[i] != b'/'
+        {
+            i += 1;
+        }
+        let name_end = i;
+        let name = open_tag[name_start..name_end].to_string();
+        if name.is_empty() {
+            i += 1;
+            continue;
+        }
+
+        while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+            i += 1;
+        }
+
+        if i >= bytes.len() || bytes[i] != b'=' {
+            attrs.push(ParsedAttribute {
+                name,
+                value: None,
+                raw: open_tag[name_start..name_end].to_string(),
+            });
+            continue;
+        }
+
+        i += 1;
+        while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+            i += 1;
+        }
+
+        let (value, next) = parse_attribute_value(open_tag, bytes, i);
+        i = next;
+
+        attrs.push(ParsedAttribute {
+            name,
+            value: Some(value),
+            raw: open_tag[name_start..i].to_string(),
+        });
+    }
+
+    attrs
+}
+
+pub(crate) fn read_attribute_value(open_tag: &str, name: &str) -> Option<String> {
+    parse_attributes(open_tag)
+        .into_iter()
+        .find(|attr| attr.name == name)
+        .and_then(|attr| attr.value)
+}
+
+fn parse_attribute_value(open_tag: &str, bytes: &[u8], i: usize) -> (String, usize) {
+    if matches!(bytes.get(i), Some(b'"') | Some(b'\'')) {
+        let quote = bytes[i];
+        let start = i + 1;
+        let mut end = start;
+        while end < bytes.len() && bytes[end] != quote {
+            end += 1;
+        }
+        let value = open_tag[start..end].to_string();
+        (value, if end < bytes.len() { end + 1 } else { end })
+    } else {
+        let start = i;
+        let mut end = i;
+        while end < bytes.len() && !bytes[end].is_ascii_whitespace() && bytes[end] != b'>' {
+            end += 1;
+        }
+        (open_tag[start..end].to_string(), end)
+    }
+}
+
+fn find_comment_end(template: &str, start: usize) -> Option<usize> {
+    template[start..]
+        .find("-->")
+        .map(|relative| start + relative + 3)
+}
diff --git a/crates/microsoft-fast-convert/src/lib.rs b/crates/microsoft-fast-convert/src/lib.rs
new file mode 100644
index 00000000000..0eecd21d762
--- /dev/null
+++ b/crates/microsoft-fast-convert/src/lib.rs
@@ -0,0 +1,37 @@
+//! # microsoft-fast-convert
+//!
+//! Converts one FAST declarative HTML `<f-template>` string into either WebUI
+//! prerelease template HTML or FAST v3 TypeScript template source. The converter
+//! uses a focused hand scanner rather than constructing a DOM or depending on an
+//! HTML parser.
+
+mod converter;
+mod error;
+mod expression;
+mod html;
+mod syntax;
+#[cfg(target_arch = "wasm32")]
+mod wasm;
+
+pub use error::ConvertError;
+pub use syntax::SyntaxMetadata;
+
+/// Convert a FAST declarative template string to the requested syntax.
+///
+/// Supported syntax values are `webui-prerelease` and `fast-v3-ts`.
+pub fn convert_template(template: &str, syntax: &str) -> Result<String, ConvertError> {
+    converter::convert(template, syntax)
+}
+
+/// Metadata for all supported converter syntax targets.
+pub fn syntax_metadata() -> &'static [SyntaxMetadata] {
+    syntax::syntax_metadata()
+}
+
+/// JSON metadata for supported converter syntax targets.
+///
+/// This is intentionally hand-written to avoid adding a serialization
+/// dependency to the crate.
+pub fn syntax_metadata_json() -> String {
+    syntax::syntax_metadata_json()
+}
diff --git a/crates/microsoft-fast-convert/src/syntax/fast_v3_ts.rs b/crates/microsoft-fast-convert/src/syntax/fast_v3_ts.rs
new file mode 100644
index 00000000000..b65018410e7
--- /dev/null
+++ b/crates/microsoft-fast-convert/src/syntax/fast_v3_ts.rs
@@ -0,0 +1,426 @@
+use super::{required_binding_value, strip_single_brace, validate_directive_attrs};
+use crate::error::{template_context, ConvertError};
+use crate::expression::{
+    event_handler_to_arrow, expression_to_arrow, is_path, parse_repeat_expression, RepeatScope,
+};
+use crate::html::{
+    find_matching_close, find_tag_end, is_self_closing_tag, parse_attributes, read_tag_name,
+    ParsedAttribute,
+};
+use crate::syntax::SyntaxMetadata;
+
+pub(crate) const METADATA: SyntaxMetadata = SyntaxMetadata {
+    name: "fast-v3-ts",
+    extension: ".ts",
+    suffix: ".template.ts",
+};
+
+pub(crate) fn convert(template: &str) -> Result<String, ConvertError> {
+    let mut state = TsState::default();
+    let body = convert_segment(template, &mut state, &[])?;
+
+    let mut output = String::new();
+    output.push_str("import { html } from \"@microsoft/fast-element/html.js\";\n");
+    if state.repeat {
+        output.push_str("import { repeat } from \"@microsoft/fast-element/repeat.js\";\n");
+    }
+    if state.when {
+        output.push_str("import { when } from \"@microsoft/fast-element/when.js\";\n");
+    }
+    if state.ref_attr {
+        output.push_str("import { ref } from \"@microsoft/fast-element/ref.js\";\n");
+    }
+    if state.children {
+        output.push_str("import { children } from \"@microsoft/fast-element/children.js\";\n");
+    }
+    if state.slotted {
+        output.push_str("import { slotted } from \"@microsoft/fast-element/slotted.js\";\n");
+    }
+    output.push_str("\nexport const template = html`");
+    output.push_str(&body);
+    output.push_str("`;\n");
+
+    Ok(output)
+}
+
+#[derive(Default)]
+struct TsState {
+    repeat: bool,
+    when: bool,
+    ref_attr: bool,
+    children: bool,
+    slotted: bool,
+}
+
+fn convert_segment(
+    template: &str,
+    state: &mut TsState,
+    scopes: &[RepeatScope],
+) -> Result<String, ConvertError> {
+    let mut out = String::with_capacity(template.len());
+    let mut pos = 0usize;
+
+    while pos < template.len() {
+        if template[pos..].starts_with("<!--") {
+            if let Some(end) = template[pos..].find("-->") {
+                let end = pos + end + 3;
+                out.push_str(&escape_ts_literal(&template[pos..end]));
+                pos = end;
+                continue;
+            }
+        }
+
+        if template[pos..].starts_with("{{{") {
+            return Err(ConvertError::UnsupportedExpression {
+                expr: "{{{…}}}".to_string(),
+                reason:
+                    "triple-brace unescaped bindings are not supported by fast-v3-ts conversion"
+                        .to_string(),
+                context: template_context(template, pos),
+            });
+        }
+
+        if template[pos..].starts_with("{{") {
+            let (binding, next) = convert_text_binding(template, pos, scopes)?;
+            out.push_str(&binding);
+            pos = next;
+            continue;
+        }
+
+        if template[pos..].starts_with("</") {
+            let tag_end = find_tag_end(template, pos).ok_or_else(|| ConvertError::UnclosedTag {
+                context: template_context(template, pos),
+            })?;
+            out.push_str(&escape_ts_literal(&template[pos..tag_end]));
+            pos = tag_end;
+            continue;
+        }
+
+        if template[pos..].starts_with('<') {
+            if let Some(tag_name) = read_tag_name(template, pos) {
+                match tag_name.as_str() {
+                    "f-repeat" => {
+                        let (converted, next) = convert_repeat(template, pos, state, scopes)?;
+                        out.push_str(&converted);
+                        pos = next;
+                        continue;
+                    }
+                    "f-when" => {
+                        let (converted, next) = convert_when(template, pos, state, scopes)?;
+                        out.push_str(&converted);
+                        pos = next;
+                        continue;
+                    }
+                    _ if tag_name.starts_with("f-") => {
+                        return Err(ConvertError::UnsupportedFElement {
+                            tag: tag_name,
+                            context: template_context(template, pos),
+                        });
+                    }
+                    _ => {
+                        let (tag, next) = convert_open_tag(template, pos, state, scopes)?;
+                        out.push_str(&tag);
+                        pos = next;
+                        continue;
+                    }
+                }
+            }
+        }
+
+        let next_special = find_next_special(template, pos + 1).unwrap_or(template.len());
+        out.push_str(&escape_ts_literal(&template[pos..next_special]));
+        pos = next_special;
+    }
+
+    Ok(out)
+}
+
+fn convert_text_binding(
+    template: &str,
+    start: usize,
+    scopes: &[RepeatScope],
+) -> Result<(String, usize), ConvertError> {
+    let expr_start = start + 2;
+    let end = template[expr_start..]
+        .find("}}")
+        .map(|relative| expr_start + relative)
+        .ok_or_else(|| ConvertError::UnclosedBinding {
+            context: template_context(template, start),
+        })?;
+    let expr = template[expr_start..end].trim();
+    if expr.is_empty() {
+        return Err(ConvertError::EmptyBinding {
+            context: template_context(template, start),
+        });
+    }
+
+    Ok((
+        format!(
+            "${{{}}}",
+            expression_to_arrow(expr, scopes, template, start)?
+        ),
+        end + 2,
+    ))
+}
+
+fn convert_repeat(
+    template: &str,
+    start: usize,
+    state: &mut TsState,
+    scopes: &[RepeatScope],
+) -> Result<(String, usize), ConvertError> {
+    let tag_end = find_tag_end(template, start).ok_or_else(|| ConvertError::UnclosedTag {
+        context: template_context(template, start),
+    })?;
+    let open_tag = &template[start..tag_end];
+    validate_directive_attrs(open_tag, template, start)?;
+    let expr = required_binding_value(open_tag, "f-repeat", template, start)?;
+    let (alias, source) = parse_repeat_expression(&expr, template, start)?;
+    let selector = expression_to_arrow(&source, scopes, template, start)?;
+    let (close_start, close_end) =
+        find_matching_close(template, start, "f-repeat").ok_or_else(|| {
+            ConvertError::UnclosedElement {
+                tag: "f-repeat".to_string(),
+                context: template_context(template, start),
+            }
+        })?;
+
+    let mut child_scopes = scopes.to_vec();
+    child_scopes.push(RepeatScope { alias });
+    let inner = convert_segment(&template[tag_end..close_start], state, &child_scopes)?;
+    state.repeat = true;
+
+    Ok((
+        format!("${{repeat({selector}, x => html`{inner}`)}}"),
+        close_end,
+    ))
+}
+
+fn convert_when(
+    template: &str,
+    start: usize,
+    state: &mut TsState,
+    scopes: &[RepeatScope],
+) -> Result<(String, usize), ConvertError> {
+    let tag_end = find_tag_end(template, start).ok_or_else(|| ConvertError::UnclosedTag {
+        context: template_context(template, start),
+    })?;
+    let open_tag = &template[start..tag_end];
+    validate_directive_attrs(open_tag, template, start)?;
+    let expr = required_binding_value(open_tag, "f-when", template, start)?;
+    let condition = expression_to_arrow(&expr, scopes, template, start)?;
+    let (close_start, close_end) =
+        find_matching_close(template, start, "f-when").ok_or_else(|| {
+            ConvertError::UnclosedElement {
+                tag: "f-when".to_string(),
+                context: template_context(template, start),
+            }
+        })?;
+    let inner = convert_segment(&template[tag_end..close_start], state, scopes)?;
+    state.when = true;
+
+    Ok((format!("${{when({condition}, html`{inner}`)}}"), close_end))
+}
+
+fn convert_open_tag(
+    template: &str,
+    start: usize,
+    state: &mut TsState,
+    scopes: &[RepeatScope],
+) -> Result<(String, usize), ConvertError> {
+    let tag_end = find_tag_end(template, start).ok_or_else(|| ConvertError::UnclosedTag {
+        context: template_context(template, start),
+    })?;
+    let open_tag = &template[start..tag_end];
+    let tag_name = read_tag_name(template, start).unwrap_or_default();
+    let mut out = String::new();
+    out.push('<');
+    out.push_str(&tag_name);
+
+    for attr in parse_attributes(open_tag) {
+        append_converted_attribute(&mut out, attr, template, start, state, scopes)?;
+    }
+
+    if is_self_closing_tag(open_tag) {
+        out.push_str(" />");
+    } else {
+        out.push('>');
+    }
+
+    Ok((out, tag_end))
+}
+
+fn append_converted_attribute(
+    out: &mut String,
+    attr: ParsedAttribute,
+    template: &str,
+    at: usize,
+    state: &mut TsState,
+    scopes: &[RepeatScope],
+) -> Result<(), ConvertError> {
+    if attr.name.starts_with("f-") {
+        append_f_attribute(out, attr, template, at, state)?;
+        return Ok(());
+    }
+
+    if attr.name.starts_with('@') {
+        if let Some(value) = attr.value.as_deref() {
+            if let Some(handler) = strip_single_brace(value) {
+                let converted = event_handler_to_arrow(handler, scopes, template, at)?;
+                out.push_str(&format!(" {}=\"${{{converted}}}\"", attr.name));
+                return Ok(());
+            }
+        }
+    }
+
+    if let Some(value) = attr.value.as_deref() {
+        if value.contains("{{") {
+            let converted = convert_attribute_value(value, template, at, scopes)?;
+            out.push_str(&format!(" {}=\"{}\"", attr.name, converted));
+            return Ok(());
+        }
+    }
+
+    out.push(' ');
+    out.push_str(&escape_ts_literal(&attr.raw));
+    Ok(())
+}
+
+fn append_f_attribute(
+    out: &mut String,
+    attr: ParsedAttribute,
+    template: &str,
+    at: usize,
+    state: &mut TsState,
+) -> Result<(), ConvertError> {
+    let (helper, flag): (&str, fn(&mut TsState) -> &mut bool) = match attr.name.as_str() {
+        "f-ref" => ("ref", |state| &mut state.ref_attr),
+        "f-children" => ("children", |state| &mut state.children),
+        "f-slotted" => ("slotted", |state| &mut state.slotted),
+        _ => {
+            return Err(ConvertError::UnsupportedFAttribute {
+                attribute: attr.name,
+                context: template_context(template, at),
+            });
+        }
+    };
+
+    let value = attr
+        .value
+        .ok_or_else(|| ConvertError::UnsupportedFAttribute {
+            attribute: attr.name.clone(),
+            context: template_context(template, at),
+        })?;
+    let normalized = normalize_f_attribute_value(&value);
+    if normalized.is_empty() || !is_path(normalized) {
+        return Err(ConvertError::UnsupportedFAttribute {
+            attribute: attr.name,
+            context: template_context(template, at),
+        });
+    }
+
+    *flag(state) = true;
+    out.push_str(&format!(
+        " ${{{}(\"{}\")}}",
+        helper,
+        escape_js_string(normalized)
+    ));
+    Ok(())
+}
+
+fn convert_attribute_value(
+    value: &str,
+    template: &str,
+    at: usize,
+    scopes: &[RepeatScope],
+) -> Result<String, ConvertError> {
+    let mut out = String::new();
+    let mut pos = 0usize;
+
+    while pos < value.len() {
+        let Some(relative) = value[pos..].find("{{") else {
+            out.push_str(&escape_ts_attribute_literal(&value[pos..]));
+            break;
+        };
+        let start = pos + relative;
+        out.push_str(&escape_ts_attribute_literal(&value[pos..start]));
+
+        if value[start..].starts_with("{{{") {
+            return Err(ConvertError::UnsupportedExpression {
+                expr: "{{{…}}}".to_string(),
+                reason: "triple-brace unescaped bindings are not supported in attributes"
+                    .to_string(),
+                context: template_context(template, at),
+            });
+        }
+
+        let expr_start = start + 2;
+        let end = value[expr_start..]
+            .find("}}")
+            .map(|relative| expr_start + relative)
+            .ok_or_else(|| ConvertError::UnclosedBinding {
+                context: template_context(template, at),
+            })?;
+        let expr = value[expr_start..end].trim();
+        if expr.is_empty() {
+            return Err(ConvertError::EmptyBinding {
+                context: template_context(template, at),
+            });
+        }
+        out.push_str(&format!(
+            "${{{}}}",
+            expression_to_arrow(expr, scopes, template, at)?
+        ));
+        pos = end + 2;
+    }
+
+    Ok(out)
+}
+
+fn normalize_f_attribute_value(value: &str) -> &str {
+    strip_single_brace(value).unwrap_or(value).trim()
+}
+
+fn find_next_special(template: &str, from: usize) -> Option<usize> {
+    let lt = template[from..].find('<').map(|relative| from + relative);
+    let binding = template[from..].find("{{").map(|relative| from + relative);
+    [lt, binding].into_iter().flatten().min()
+}
+
+fn escape_ts_literal(value: &str) -> String {
+    let mut out = String::with_capacity(value.len());
+    let mut chars = value.chars().peekable();
+
+    while let Some(ch) = chars.next() {
+        match ch {
+            '`' => out.push_str("\\`"),
+            '\\' => out.push_str("\\\\"),
+            '$' if chars.peek() == Some(&'{') => {
+                out.push_str("\\${");
+                chars.next();
+            }
+            _ => out.push(ch),
+        }
+    }
+
+    out
+}
+
+fn escape_ts_attribute_literal(value: &str) -> String {
+    escape_ts_literal(&value.replace('"', "&quot;"))
+}
+
+fn escape_js_string(value: &str) -> String {
+    let mut out = String::with_capacity(value.len());
+    for ch in value.chars() {
+        match ch {
+            '\\' => out.push_str("\\\\"),
+            '"' => out.push_str("\\\""),
+            '\n' => out.push_str("\\n"),
+            '\r' => out.push_str("\\r"),
+            '\t' => out.push_str("\\t"),
+            _ => out.push(ch),
+        }
+    }
+    out
+}
diff --git a/crates/microsoft-fast-convert/src/syntax/mod.rs b/crates/microsoft-fast-convert/src/syntax/mod.rs
new file mode 100644
index 00000000000..5ff32feeeb8
--- /dev/null
+++ b/crates/microsoft-fast-convert/src/syntax/mod.rs
@@ -0,0 +1,117 @@
+pub(crate) mod fast_v3_ts;
+pub(crate) mod webui;
+
+use crate::error::{template_context, ConvertError};
+use crate::html::parse_attributes;
+
+/// Metadata for a supported converter syntax target.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct SyntaxMetadata {
+    /// Syntax value accepted by `convert_template`.
+    pub name: &'static str,
+    /// Required output extension for generated files.
+    pub extension: &'static str,
+    /// Default output suffix appended to the input basename.
+    pub suffix: &'static str,
+}
+
+const SYNTAX_METADATA: &[SyntaxMetadata] = &[webui::METADATA, fast_v3_ts::METADATA];
+
+pub fn syntax_metadata() -> &'static [SyntaxMetadata] {
+    SYNTAX_METADATA
+}
+
+pub(crate) fn accepted_syntax_names() -> String {
+    syntax_metadata()
+        .iter()
+        .map(|metadata| metadata.name)
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+pub fn syntax_metadata_json() -> String {
+    let mut out = String::from("[");
+    for (index, metadata) in syntax_metadata().iter().enumerate() {
+        if index > 0 {
+            out.push(',');
+        }
+        out.push_str("{\"syntax\":\"");
+        out.push_str(metadata.name);
+        out.push_str("\",\"extension\":\"");
+        out.push_str(metadata.extension);
+        out.push_str("\",\"suffix\":\"");
+        out.push_str(metadata.suffix);
+        out.push_str("\"}");
+    }
+    out.push(']');
+    out
+}
+
+pub(crate) fn required_binding_value(
+    open_tag: &str,
+    tag: &str,
+    template: &str,
+    at: usize,
+) -> Result<String, ConvertError> {
+    let value = parse_attributes(open_tag)
+        .into_iter()
+        .find(|attr| attr.name == "value")
+        .and_then(|attr| attr.value)
+        .ok_or_else(|| ConvertError::MissingValueAttribute {
+            tag: tag.to_string(),
+            context: template_context(template, at),
+        })?;
+
+    let trimmed = value.trim();
+    if !trimmed.starts_with("{{") || !trimmed.ends_with("}}") || trimmed.len() <= 4 {
+        return Err(ConvertError::InvalidDirectiveValue {
+            tag: tag.to_string(),
+            value: Some(value),
+            context: template_context(template, at),
+        });
+    }
+
+    let expr = trimmed[2..trimmed.len() - 2].trim();
+    if expr.is_empty() {
+        return Err(ConvertError::InvalidDirectiveValue {
+            tag: tag.to_string(),
+            value: Some(value),
+            context: template_context(template, at),
+        });
+    }
+
+    Ok(expr.to_string())
+}
+
+pub(crate) fn validate_directive_attrs(
+    open_tag: &str,
+    template: &str,
+    at: usize,
+) -> Result<(), ConvertError> {
+    for attr in parse_attributes(open_tag) {
+        if attr.name.starts_with("f-") {
+            return Err(ConvertError::UnsupportedFAttribute {
+                attribute: attr.name,
+                context: template_context(template, at),
+            });
+        }
+    }
+    Ok(())
+}
+
+pub(crate) fn is_supported_f_attribute(name: &str) -> bool {
+    matches!(name, "f-ref" | "f-children" | "f-slotted")
+}
+
+pub(crate) fn strip_single_brace(value: &str) -> Option<&str> {
+    let trimmed = value.trim();
+    if trimmed.starts_with('{')
+        && trimmed.ends_with('}')
+        && !trimmed.starts_with("{{")
+        && trimmed.len() >= 2
+    {
+        Some(trimmed[1..trimmed.len() - 1].trim())
+    } else {
+        None
+    }
+}
diff --git a/crates/microsoft-fast-convert/src/syntax/webui.rs b/crates/microsoft-fast-convert/src/syntax/webui.rs
new file mode 100644
index 00000000000..b6eddf2dc5b
--- /dev/null
+++ b/crates/microsoft-fast-convert/src/syntax/webui.rs
@@ -0,0 +1,124 @@
+use super::{is_supported_f_attribute, required_binding_value, validate_directive_attrs};
+use crate::error::{template_context, ConvertError};
+use crate::expression::parse_repeat_expression;
+use crate::html::{find_matching_close, find_tag_end, parse_attributes, read_tag_name};
+use crate::syntax::SyntaxMetadata;
+
+pub(crate) const METADATA: SyntaxMetadata = SyntaxMetadata {
+    name: "webui-prerelease",
+    extension: ".html",
+    suffix: ".webui.html",
+};
+
+pub(crate) fn convert(template: &str) -> Result<String, ConvertError> {
+    convert_segment(template)
+}
+
+fn convert_segment(template: &str) -> Result<String, ConvertError> {
+    let mut out = String::with_capacity(template.len());
+    let mut pos = 0usize;
+
+    while pos < template.len() {
+        if template[pos..].starts_with("<!--") {
+            if let Some(end) = template[pos..].find("-->") {
+                let end = pos + end + 3;
+                out.push_str(&template[pos..end]);
+                pos = end;
+                continue;
+            }
+        }
+
+        let Some(relative) = template[pos..].find('<') else {
+            out.push_str(&template[pos..]);
+            break;
+        };
+        let lt = pos + relative;
+        out.push_str(&template[pos..lt]);
+
+        let Some(tag_name) = read_tag_name(template, lt) else {
+            out.push('<');
+            pos = lt + 1;
+            continue;
+        };
+
+        match tag_name.as_str() {
+            "f-repeat" => {
+                let (converted, next) = convert_directive(template, lt, "f-repeat")?;
+                out.push_str(&converted);
+                pos = next;
+            }
+            "f-when" => {
+                let (converted, next) = convert_directive(template, lt, "f-when")?;
+                out.push_str(&converted);
+                pos = next;
+            }
+            _ if tag_name.starts_with("f-") => {
+                return Err(ConvertError::UnsupportedFElement {
+                    tag: tag_name,
+                    context: template_context(template, lt),
+                });
+            }
+            _ => {
+                let tag_end =
+                    find_tag_end(template, lt).ok_or_else(|| ConvertError::UnclosedTag {
+                        context: template_context(template, lt),
+                    })?;
+                validate_attributes(&template[lt..tag_end], template, lt)?;
+                out.push_str(&template[lt..tag_end]);
+                pos = tag_end;
+            }
+        }
+    }
+
+    Ok(out)
+}
+
+fn convert_directive(
+    template: &str,
+    start: usize,
+    tag: &str,
+) -> Result<(String, usize), ConvertError> {
+    let tag_end = find_tag_end(template, start).ok_or_else(|| ConvertError::UnclosedTag {
+        context: template_context(template, start),
+    })?;
+    let open_tag = &template[start..tag_end];
+    validate_directive_attrs(open_tag, template, start)?;
+    let expr = required_binding_value(open_tag, tag, template, start)?;
+
+    if tag == "f-repeat" {
+        parse_repeat_expression(&expr, template, start)?;
+    } else if expr.trim().is_empty() {
+        return Err(ConvertError::InvalidDirectiveValue {
+            tag: tag.to_string(),
+            value: Some(expr),
+            context: template_context(template, start),
+        });
+    }
+
+    let (close_start, close_end) =
+        find_matching_close(template, start, tag).ok_or_else(|| ConvertError::UnclosedElement {
+            tag: tag.to_string(),
+            context: template_context(template, start),
+        })?;
+    let inner = convert_segment(&template[tag_end..close_start])?;
+
+    let output = if tag == "f-repeat" {
+        format!("<for each=\"{}\">{inner}</for>", expr.trim())
+    } else {
+        format!("<if condition=\"{}\">{inner}</if>", expr.trim())
+    };
+
+    Ok((output, close_end))
+}
+
+fn validate_attributes(open_tag: &str, template: &str, at: usize) -> Result<(), ConvertError> {
+    for attr in parse_attributes(open_tag) {
+        if attr.name.starts_with("f-") && !is_supported_f_attribute(&attr.name) {
+            return Err(ConvertError::UnsupportedFAttribute {
+                attribute: attr.name,
+                context: template_context(template, at),
+            });
+        }
+    }
+    Ok(())
+}
diff --git a/crates/microsoft-fast-convert/src/wasm.rs b/crates/microsoft-fast-convert/src/wasm.rs
new file mode 100644
index 00000000000..9bb2c1c68b1
--- /dev/null
+++ b/crates/microsoft-fast-convert/src/wasm.rs
@@ -0,0 +1,13 @@
+use wasm_bindgen::prelude::*;
+
+/// Convert one FAST declarative template string to the requested syntax.
+#[wasm_bindgen]
+pub fn convert_template(template: &str, syntax: &str) -> Result<String, JsValue> {
+    crate::convert_template(template, syntax).map_err(|error| JsValue::from_str(&error.to_string()))
+}
+
+/// Return JSON metadata for all supported syntax targets.
+#[wasm_bindgen]
+pub fn convert_syntax_metadata() -> String {
+    crate::syntax_metadata_json()
+}
diff --git a/crates/microsoft-fast-convert/tests/conversions.rs b/crates/microsoft-fast-convert/tests/conversions.rs
new file mode 100644
index 00000000000..00a09170671
--- /dev/null
+++ b/crates/microsoft-fast-convert/tests/conversions.rs
@@ -0,0 +1,145 @@
+use microsoft_fast_convert::{convert_template, syntax_metadata, syntax_metadata_json};
+
+fn fast_template(inner: &str) -> String {
+    format!(r#"<f-template name="my-element">{inner}</f-template>"#)
+}
+
+#[test]
+fn exposes_syntax_metadata() {
+    let metadata = syntax_metadata();
+
+    assert_eq!(metadata.len(), 2);
+    assert_eq!(metadata[0].name, "webui-prerelease");
+    assert_eq!(metadata[0].extension, ".html");
+    assert_eq!(metadata[0].suffix, ".webui.html");
+    assert_eq!(metadata[1].name, "fast-v3-ts");
+    assert_eq!(metadata[1].extension, ".ts");
+    assert_eq!(metadata[1].suffix, ".template.ts");
+    assert_eq!(
+        syntax_metadata_json(),
+        r#"[{"syntax":"webui-prerelease","extension":".html","suffix":".webui.html"},{"syntax":"fast-v3-ts","extension":".ts","suffix":".template.ts"}]"#
+    );
+}
+
+#[test]
+fn webui_unwraps_template() {
+    let input = fast_template(r#"<template><span>{{name}}</span></template>"#);
+    let output = convert_template(&input, "webui-prerelease").unwrap();
+
+    assert_eq!(output, r#"<template><span>{{name}}</span></template>"#);
+}
+
+#[test]
+fn webui_converts_repeat_and_when() {
+    let input = fast_template(
+        r#"<template><f-repeat value="{{item in items}}"><f-when value="{{item.visible}}"><span>{{item.name}}</span></f-when></f-repeat></template>"#,
+    );
+    let output = convert_template(&input, "webui-prerelease").unwrap();
+
+    assert_eq!(
+        output,
+        r#"<template><for each="item in items"><if condition="item.visible"><span>{{item.name}}</span></if></for></template>"#
+    );
+}
+
+#[test]
+fn fast_v3_ts_converts_basic_text_and_attributes() {
+    let input = fast_template(r#"<template><h1 title="{{title}}">{{title}}</h1></template>"#);
+    let output = convert_template(&input, "fast-v3-ts").unwrap();
+
+    assert_eq!(
+        output,
+        "import { html } from \"@microsoft/fast-element/html.js\";\n\nexport const template = html`<template><h1 title=\"${x => x.title}\">${x => x.title}</h1></template>`;\n"
+    );
+}
+
+#[test]
+fn fast_v3_ts_converts_repeat() {
+    let input = fast_template(
+        r#"<template><f-repeat value="{{item in items}}"><span>{{item.name}}</span></f-repeat></template>"#,
+    );
+    let output = convert_template(&input, "fast-v3-ts").unwrap();
+
+    assert_eq!(
+        output,
+        "import { html } from \"@microsoft/fast-element/html.js\";\nimport { repeat } from \"@microsoft/fast-element/repeat.js\";\n\nexport const template = html`<template>${repeat(x => x.items, x => html`<span>${x => x.name}</span>`)}</template>`;\n"
+    );
+}
+
+#[test]
+fn fast_v3_ts_converts_when() {
+    let input = fast_template(
+        r#"<template><f-when value="{{isVisible && count > 0}}"><span>Shown</span></f-when></template>"#,
+    );
+    let output = convert_template(&input, "fast-v3-ts").unwrap();
+
+    assert_eq!(
+        output,
+        "import { html } from \"@microsoft/fast-element/html.js\";\nimport { when } from \"@microsoft/fast-element/when.js\";\n\nexport const template = html`<template>${when(x => x.isVisible && x.count > 0, html`<span>Shown</span>`)}</template>`;\n"
+    );
+}
+
+#[test]
+fn fast_v3_ts_converts_f_attribute_mappings() {
+    let input = fast_template(
+        r#"<template><h1 f-ref="title"></h1><slot f-slotted="{slottedNodes}"></slot><ul f-children="items"></ul></template>"#,
+    );
+    let output = convert_template(&input, "fast-v3-ts").unwrap();
+
+    assert_eq!(
+        output,
+        "import { html } from \"@microsoft/fast-element/html.js\";\nimport { ref } from \"@microsoft/fast-element/ref.js\";\nimport { children } from \"@microsoft/fast-element/children.js\";\nimport { slotted } from \"@microsoft/fast-element/slotted.js\";\n\nexport const template = html`<template><h1 ${ref(\"title\")}></h1><slot ${slotted(\"slottedNodes\")}></slot><ul ${children(\"items\")}></ul></template>`;\n"
+    );
+}
+
+#[test]
+fn fast_v3_ts_converts_event_e_and_c_arguments() {
+    let input = fast_template(
+        r#"<template><button @click="{handleClick($e)}" @mouseover="{handleOver($c)}"></button></template>"#,
+    );
+    let output = convert_template(&input, "fast-v3-ts").unwrap();
+
+    assert_eq!(
+        output,
+        "import { html } from \"@microsoft/fast-element/html.js\";\n\nexport const template = html`<template><button @click=\"${(x, c) => x.handleClick(c.event)}\" @mouseover=\"${(x, c) => x.handleOver(c)}\"></button></template>`;\n"
+    );
+}
+
+#[test]
+fn fast_v3_ts_maps_nested_repeat_event_parent_chain() {
+    let input = fast_template(
+        r#"<template><f-repeat value="{{item in items}}"><f-repeat value="{{child in item.children}}"><button @click="{handleClick($e)}">{{child.name}}</button></f-repeat></f-repeat></template>"#,
+    );
+    let output = convert_template(&input, "fast-v3-ts").unwrap();
+
+    assert_eq!(
+        output,
+        "import { html } from \"@microsoft/fast-element/html.js\";\nimport { repeat } from \"@microsoft/fast-element/repeat.js\";\n\nexport const template = html`<template>${repeat(x => x.items, x => html`${repeat(x => x.children, x => html`<button @click=\"${(x, c) => c.parentContext.parent.handleClick(c.event)}\">${x => x.name}</button>`)}`)}</template>`;\n"
+    );
+}
+
+#[test]
+fn fast_v3_ts_escapes_template_literal_content() {
+    let input = fast_template(
+        "<template><span data-text=\"a ` ${ b \\ c\">literal ` ${ \\</span></template>",
+    );
+    let output = convert_template(&input, "fast-v3-ts").unwrap();
+
+    assert_eq!(
+        output,
+        "import { html } from \"@microsoft/fast-element/html.js\";\n\nexport const template = html`<template><span data-text=\"a \\` \\${ b \\\\ c\">literal \\` \\${ \\\\</span></template>`;\n"
+    );
+}
+
+#[test]
+fn fast_v3_ts_converts_aspected_attribute_bindings() {
+    let input = fast_template(
+        r#"<template><input ?disabled="{{disabled}}" :value="{{value}}" /></template>"#,
+    );
+    let output = convert_template(&input, "fast-v3-ts").unwrap();
+
+    assert_eq!(
+        output,
+        "import { html } from \"@microsoft/fast-element/html.js\";\n\nexport const template = html`<template><input ?disabled=\"${x => x.disabled}\" :value=\"${x => x.value}\" /></template>`;\n"
+    );
+}
diff --git a/crates/microsoft-fast-convert/tests/errors.rs b/crates/microsoft-fast-convert/tests/errors.rs
new file mode 100644
index 00000000000..d3592a3f3b2
--- /dev/null
+++ b/crates/microsoft-fast-convert/tests/errors.rs
@@ -0,0 +1,99 @@
+use microsoft_fast_convert::{convert_template, ConvertError};
+
+fn fast_template(inner: &str) -> String {
+    format!(r#"<f-template name="my-element">{inner}</f-template>"#)
+}
+
+#[test]
+fn unknown_syntax_lists_accepted_values() {
+    let err = convert_template("", "unknown").unwrap_err();
+    assert!(matches!(err, ConvertError::UnsupportedSyntax { .. }));
+    assert!(err.to_string().contains("webui-prerelease"));
+    assert!(err.to_string().contains("fast-v3-ts"));
+}
+
+#[test]
+fn missing_f_template_is_rejected() {
+    let err = convert_template("<template></template>", "webui-prerelease").unwrap_err();
+    assert!(matches!(err, ConvertError::MissingFTemplate));
+}
+
+#[test]
+fn multiple_f_templates_are_rejected() {
+    let err = convert_template(
+        r#"<f-template name="one"><template></template></f-template><f-template name="two"><template></template></f-template>"#,
+        "webui-prerelease",
+    )
+    .unwrap_err();
+    assert!(matches!(err, ConvertError::MultipleFTemplates { count: 2 }));
+}
+
+#[test]
+fn empty_f_template_name_is_rejected() {
+    let err = convert_template(
+        r#"<f-template name=""><template></template></f-template>"#,
+        "webui-prerelease",
+    )
+    .unwrap_err();
+    assert!(matches!(err, ConvertError::EmptyFTemplateName));
+}
+
+#[test]
+fn missing_inner_template_is_rejected() {
+    let err = convert_template(
+        r#"<f-template name="my-element"><span></span></f-template>"#,
+        "webui-prerelease",
+    )
+    .unwrap_err();
+    assert!(matches!(err, ConvertError::MissingInnerTemplate));
+}
+
+#[test]
+fn multiple_inner_templates_are_rejected() {
+    let err = convert_template(
+        r#"<f-template name="my-element"><template></template><template></template></f-template>"#,
+        "webui-prerelease",
+    )
+    .unwrap_err();
+    assert!(matches!(
+        err,
+        ConvertError::MultipleInnerTemplates { count: 2 }
+    ));
+}
+
+#[test]
+fn invalid_repeat_value_is_rejected() {
+    let input = fast_template(r#"<template><f-repeat value="{{items}}"></f-repeat></template>"#);
+    let err = convert_template(&input, "webui-prerelease").unwrap_err();
+    assert!(matches!(err, ConvertError::InvalidRepeatExpression { .. }));
+}
+
+#[test]
+fn missing_when_value_is_rejected() {
+    let input = fast_template(r#"<template><f-when>Shown</f-when></template>"#);
+    let err = convert_template(&input, "fast-v3-ts").unwrap_err();
+    assert!(matches!(err, ConvertError::MissingValueAttribute { .. }));
+}
+
+#[test]
+fn unsupported_f_attribute_is_rejected() {
+    let input = fast_template(r#"<template><span f-unknown="value"></span></template>"#);
+    let err = convert_template(&input, "fast-v3-ts").unwrap_err();
+    assert!(matches!(err, ConvertError::UnsupportedFAttribute { .. }));
+}
+
+#[test]
+fn unsupported_expression_function_call_is_rejected() {
+    let input = fast_template(r#"<template>{{formatName(name)}}</template>"#);
+    let err = convert_template(&input, "fast-v3-ts").unwrap_err();
+    assert!(matches!(err, ConvertError::UnsupportedExpression { .. }));
+}
+
+#[test]
+fn root_binding_inside_repeat_is_rejected() {
+    let input = fast_template(
+        r#"<template><f-repeat value="{{item in items}}"><span>{{title}}</span></f-repeat></template>"#,
+    );
+    let err = convert_template(&input, "fast-v3-ts").unwrap_err();
+    assert!(matches!(err, ConvertError::UnsupportedExpression { .. }));
+}
diff --git a/packages/fast-build/DESIGN.md b/packages/fast-build/DESIGN.md
index e34c324c487..2e4b9eef350 100644
--- a/packages/fast-build/DESIGN.md
+++ b/packages/fast-build/DESIGN.md
@@ -6,13 +6,15 @@ This document describes the internal architecture of the `@microsoft/fast-build`
 
 ## High-level overview
 
-`@microsoft/fast-build` is a Node.js CLI tool that server-side renders FAST declarative HTML templates. It delegates all template rendering to a WebAssembly module compiled from the [`microsoft-fast-build`](../../crates/microsoft-fast-build) Rust crate. The Node.js layer is responsible only for:
+`@microsoft/fast-build` is a Node.js CLI tool that server-side renders FAST declarative HTML templates and converts FAST declarative template files to other supported syntaxes. It delegates template rendering to a WebAssembly module compiled from the [`microsoft-fast-build`](../../crates/microsoft-fast-build) Rust crate and conversion to the `microsoft-fast-convert` WASM module generated under `wasm/convert/`. The Node.js layer is responsible only for:
 
-1. Parsing CLI arguments and loading configuration
-2. Locating and parsing template HTML files (glob scanning + `<f-template>` extraction)
-3. Loading the entry HTML file and optional state JSON file
-4. Calling the WASM renderer in HTML or stream mode
-5. Writing the rendered output file or raw stream chunks to stdout
+1. Dispatching `fast build` and `fast convert`
+2. Parsing CLI arguments and loading configuration
+3. Locating and parsing template HTML files (glob scanning + `<f-template>` extraction)
+4. Loading the entry HTML file and optional state JSON file
+5. Calling the WASM renderer in HTML or stream mode
+6. Validating converter paths and calling the converter WASM
+7. Writing the rendered or converted output file, or raw stream chunks to stdout
 
 ```
 fast build [options]
@@ -28,7 +30,7 @@ fast build [options]
         ├─ resolveOption(args, config, …)     ← CLI args override config values
         ├─ resolveBooleanOption(args, config, "stream")
         │
-        ├─ wasm = require(WASM_MODULE)         ← load WASM first
+        ├─ wasm = require(BUILD_WASM_MODULE)   ← load WASM first
         │
         ├─ resolvePattern(pattern, wasm)  ← for each comma-separated --templates glob
         │       │
@@ -55,6 +57,24 @@ fast build [options]
               JSON.parse(chunksJson) → process.stdout.write(chunk)
 ```
 
+`fast convert` uses the same CLI/config merge pattern but loads `fast-convert.config.json` by default:
+
+```
+fast convert [options]
+        │
+        ▼
+  parseArgs(argv)        ← --syntax, --template, --output, --overwrite, --config
+        │
+        ├─ loadConfig(configPath)             ← load fast-convert.config.json
+        ├─ resolveOption(args, config, …)     ← CLI args override config values
+        ├─ resolvePresenceBooleanOption(args, config, "overwrite")
+        ├─ validate syntax/template/output paths and extensions
+        ├─ wasm = require(CONVERT_WASM_MODULE) ← load wasm/convert/microsoft_fast_convert.js
+        ├─ wasm.convert_template(templateHtml, syntax)
+        ▼
+  fs.writeFileSync(output, converted)
+```
+
 ---
 
 ## Module map
@@ -62,19 +82,22 @@ fast build [options]
 | File | Role |
 |------|------|
 | `bin/fast.js` | CLI entry point — argument parsing, config file loading, file I/O, template scanning, WASM dispatch |
+| `build-wasm.cjs` | Package build helper that builds the renderer WASM and converter WASM into `wasm/convert/` |
 | `wasm/microsoft_fast_build.js` | WASM-generated JS bindings for the Rust renderer |
 | `wasm/microsoft_fast_build_bg.wasm` | Compiled Rust renderer binary |
+| `wasm/convert/microsoft_fast_convert.js` | WASM-generated JS bindings for the Rust converter |
+| `wasm/convert/microsoft_fast_convert_bg.wasm` | Compiled Rust converter binary |
 
 ---
 
 ## Configuration file — `loadConfig`
 
-The CLI supports an optional JSON configuration file that provides default values for all build options. This avoids repeating long argument lists in scripts and CI pipelines.
+The CLI supports optional JSON configuration files that provide default values for command options. `fast build` loads `fast-build.config.json` by default. `fast convert` loads `fast-convert.config.json` by default. This avoids repeating long argument lists in scripts and CI pipelines.
 
 ### Resolution order
 
 1. If `--config=<path>` is provided, that file is loaded. An error is raised if the file does not exist.
-2. If `--config` is not provided, `fast-build.config.json` in the current working directory is loaded if it exists. If it does not exist, no config is applied (silent fallback).
+2. If `--config` is not provided, the command-specific default config in the current working directory is loaded if it exists. If it does not exist, no config is applied (silent fallback).
 
 ### Merge semantics
 
@@ -84,13 +107,13 @@ When a value is not provided by either source, built-in defaults apply (`index.h
 
 ### Path resolution
 
-File paths read from the config file (`entry`, `state`, `output`, `templates`) are resolved relative to the **config file's directory**, not the current working directory. This ensures configs work correctly regardless of where the CLI is invoked from.
+File paths read from the config file (`entry`, `state`, `output`, `templates`, and converter `template`) are resolved relative to the **config file's directory**, not the current working directory. This ensures configs work correctly regardless of where the CLI is invoked from.
 
 CLI-provided paths are resolved relative to the current working directory (the default Node.js behaviour).
 
 ### Validation
 
-The config file must be a JSON object. Each key must be one of the allowed option names (`entry`, `state`, `output`, `templates`, `attribute-name-strategy`, `stream`). Unknown keys and invalid value types produce an error referencing the config file path. Path and string options must be strings; `stream` must be a JSON boolean (`true` or `false`).
+The config file must be a JSON object. Build config keys must be one of `entry`, `state`, `output`, `templates`, `attribute-name-strategy`, or `stream`; `stream` must be a JSON boolean and other values must be strings. Convert config keys must be one of `syntax`, `template`, `output`, or `overwrite`; `overwrite` must be a JSON boolean and other values must be strings. Unknown keys and invalid value types produce an error referencing the config file path.
 
 ### Helpers
 
@@ -99,6 +122,7 @@ The config file must be a JSON object. Each key must be one of the allowed optio
 | `loadConfig(configPath)` | Reads, parses, and validates the config file. Returns `{ config, configDir }`. |
 | `resolveOption(args, config, configDir, key, defaultValue)` | Returns the CLI arg if present, otherwise the config value (with path resolution), otherwise the default. The caller separately tracks whether `state` was explicitly provided so an explicit missing state file errors while omitted state is passed through to WASM as `{}`. |
 | `resolveBooleanOption(args, config, key)` | Resolves boolean options such as `stream`, with CLI values taking precedence over config booleans. |
+| `resolvePresenceBooleanOption(args, config, key)` | Resolves presence-only booleans such as converter `overwrite`, where CLI presence always means `true`. |
 
 ---
 
@@ -153,9 +177,57 @@ This means exact file paths like `"./components/my-button.html"` are fully suppo
 
 ---
 
+## Converter output rules
+
+`fast convert` accepts a required source `template` and required target `syntax`.
+The source template path must exist, be a file, and use `.html`.
+
+| Syntax | Output extension | Default suffix |
+|--------|------------------|----------------|
+| `webui-prerelease` | `.html` | `.webui.html` |
+| `fast-v3-ts` | `.ts` | `.template.ts` |
+
+When `output` is omitted, the CLI writes next to the input template using the
+default suffix. When `output` is provided, every `*` is replaced with the input
+basename without its `.html` extension. CLI-provided `template`/`output` paths
+use normal current-working-directory resolution; config-provided paths are
+resolved relative to the config file before the default suffix or `*`
+replacement is applied.
+
+Before loading converter WASM, the CLI validates that:
+
+- The selected syntax is supported.
+- The output extension matches the selected syntax.
+- The output path is not a directory.
+- The output parent directory exists and is a directory.
+- An existing output file is only replaced when `--overwrite` is present or
+  config contains `"overwrite": true`.
+
+The converter WASM contract is `convert_template(template: string, syntax:
+string): string` plus `convert_syntax_metadata(): string`. Rust owns FAST
+declarative syntax validation, conversion semantics, accepted syntax names, output
+extensions, and default suffixes. The JavaScript layer reads syntax metadata from
+WASM and only handles CLI/config merging, path rules, and file I/O.
+
+---
+
+## Converter fixture validation
+
+Converter fixture inputs live under `test/fixtures/convert/`. Each fixture
+directory includes a committed `fast-convert.config.json`, and the fixture tests
+run `fast convert` from those directories without `--config` to verify default
+config discovery. The fixture configs write generated output to
+`test/.fixture-output/`, which is created and removed by the fixture test so
+converted `.html` and `.ts` outputs are not checked in. The
+`test:fixtures:convert` package script runs the fixture-only validation, and
+`test:node` includes it so CI validates both `webui-prerelease` and
+`fast-v3-ts` through the real `fast convert` CLI.
+
+---
+
 ## WASM integration
 
-Four WASM functions are available; the CLI uses the entry renderer when templates are loaded or streaming is requested:
+The build WASM module exposes four functions; the CLI uses the entry renderer when templates are loaded or streaming is requested:
 
 | Function | Used when |
 |----------|-----------|
@@ -168,6 +240,12 @@ Four WASM functions are available; the CLI uses the entry renderer when template
 
 See the [`microsoft-fast-build` DESIGN.md](../../crates/microsoft-fast-build/DESIGN.md) for details on the Rust rendering pipeline.
 
+The converter WASM module is loaded from
+`wasm/convert/microsoft_fast_convert.js` and must export
+`convert_template(template, syntax)`. It receives the source `.html` template
+contents and the selected syntax (`webui-prerelease` or `fast-v3-ts`) and returns
+the converted file contents, throwing on conversion or validation errors.
+
 ---
 
 ## Stream output
@@ -206,6 +284,15 @@ simulated streaming rather than a lazy Node.js `ReadableStream`.
 | `--templates` not provided | Warning to stderr in non-streaming mode; rendering continues without custom elements |
 | `--attribute-name-strategy` invalid value | Print error to stderr; exit code 1 |
 | `--stream` value is not `true`, `false`, or empty | Print error to stderr; exit code 1 |
+| Convert `--syntax` omitted or unsupported | Print error with supported syntaxes to stderr; exit code 1 |
+| Convert `--template` omitted | Print error to stderr; exit code 1 |
+| Convert template missing, not a file, or not `.html` | Print error to stderr; exit code 1 |
+| Convert output extension does not match syntax | Print error to stderr; exit code 1 |
+| Convert output parent directory missing or not a directory | Print error to stderr; exit code 1 |
+| Convert output path is a directory | Print error to stderr; exit code 1 |
+| Convert output exists without overwrite | Print error to stderr; exit code 1 |
+| Converter WASM export missing | Print error to stderr; exit code 1 |
+| Converter WASM throws | Print error to stderr; exit code 1 |
 | Pattern matches no files | Warning to stderr; pattern is skipped |
 | `<f-template>` without `name` | Warning to stderr; template is skipped |
 | Duplicate template name across files | Warning to stderr; later entry overwrites earlier |
diff --git a/packages/fast-build/README.md b/packages/fast-build/README.md
index a0ce4b069b0..1426b7ec79f 100644
--- a/packages/fast-build/README.md
+++ b/packages/fast-build/README.md
@@ -25,13 +25,14 @@ import { render } from '@microsoft/fast-build';
 
 ## CLI usage
 
-Once installed, the `fast` binary is available. Use the `build` subcommand to render an HTML template with an optional JSON state file:
+Once installed, the `fast` binary is available. Use the `build` subcommand to render an HTML template with an optional JSON state file, or `convert` to convert a FAST declarative HTML template to another supported syntax:
 
 ```shell
 fast build [options]
+fast convert [options]
 ```
 
-### Options
+### Build options
 
 | Option | Default | Description |
 |---|---|---|
@@ -196,6 +197,56 @@ fast build --config=configs/my-build.json
 
 All keys are optional. Only the following keys are allowed: `entry`, `state`, `output`, `templates`, `attribute-name-strategy`, and `stream`. Unknown keys produce an error. Values must be strings except `stream`, which must be a JSON boolean (`true` or `false`). If `state` is omitted, rendering uses `{}`; if `state` is present, the referenced file must exist. CLI arguments always override config values, including `--stream=false` overriding `"stream": true`.
 
+## Convert
+
+`fast convert` converts one FAST declarative template file at a time using the converter WASM module in `wasm/convert/`. Supported syntax names, output extensions, and default output suffixes are read from the converter WASM metadata so the Rust converter remains the source of truth for syntax targets.
+
+```shell
+fast convert --syntax=webui-prerelease --template=example.html
+fast convert --syntax=fast-v3-ts --template=example.html --output=../*.template.ts
+```
+
+### Convert options
+
+| Option | Default | Description |
+|---|---|---|
+| `--syntax="<syntax>"` | _(required)_ | Target syntax: `webui-prerelease` or `fast-v3-ts` |
+| `--template="<path>"` | _(required)_ | Source FAST declarative template. The file must use the `.html` extension. |
+| `--output="<path>"` | Next to `--template` | Output file path. `webui-prerelease` defaults to `*.webui.html`; `fast-v3-ts` defaults to `*.template.ts`. Any `*` in the output path is replaced with the input basename without extension. |
+| `--overwrite` | `false` | Allow replacing an existing output file. CLI presence always means `true`. |
+| `--config="<path>"` | `fast-convert.config.json` | Path to a JSON configuration file. If omitted, `fast-convert.config.json` in the current directory is used when present. CLI arguments take precedence over config values. |
+
+The source template must be `.html`. The output extension must match the selected syntax: `.html` for `webui-prerelease` and `.ts` for `fast-v3-ts`. The output parent directory must already exist, and an existing output file is rejected unless `--overwrite` or `"overwrite": true` is used.
+
+### Convert configuration file
+
+`fast-convert.config.json` follows the same precedence and path-resolution rules as `fast-build.config.json`: CLI arguments override config values, and `template`/`output` paths from config are resolved relative to the config file directory.
+
+```json
+{
+    "syntax": "fast-v3-ts",
+    "template": "src/example.html",
+    "output": "generated/*.template.ts",
+    "overwrite": false
+}
+```
+
+Only `syntax`, `template`, `output`, and `overwrite` are allowed. Values must be strings except `overwrite`, which must be a JSON boolean.
+
+### Running converter fixtures locally
+
+Build the package WASM, then run the fixture validation:
+
+```shell
+npm run build -w @microsoft/fast-build
+npm run test:fixtures:convert -w @microsoft/fast-build
+```
+
+The fixture tests run `fast convert` from fixture directories that contain
+`fast-convert.config.json`, so they verify the same default config discovery used
+by `fast build`. Generated fixture output is written under
+`packages/fast-build/test/.fixture-output/` and removed by the tests.
+
 ## Template syntax
 
 Template syntax follows the FAST declarative HTML format. See the
diff --git a/packages/fast-build/bin/fast.js b/packages/fast-build/bin/fast.js
index 8af02eb9077..4499b04c875 100755
--- a/packages/fast-build/bin/fast.js
+++ b/packages/fast-build/bin/fast.js
@@ -5,10 +5,15 @@
 const fs = require("fs");
 const path = require("path");
 
-const WASM_MODULE = path.join(__dirname, "../wasm/microsoft_fast_build.js");
-const DEFAULT_CONFIG_FILENAME = "fast-build.config.json";
-const VALUELESS_CLI_FLAGS = new Set(["stream"]);
-const ALLOWED_CONFIG_KEYS = new Set([
+const BUILD_WASM_MODULE = path.join(__dirname, "../wasm/microsoft_fast_build.js");
+const CONVERT_WASM_MODULE = path.join(
+    __dirname,
+    "../wasm/convert/microsoft_fast_convert.js",
+);
+const BUILD_DEFAULT_CONFIG_FILENAME = "fast-build.config.json";
+const CONVERT_DEFAULT_CONFIG_FILENAME = "fast-convert.config.json";
+const VALUELESS_CLI_FLAGS = new Set(["stream", "overwrite"]);
+const BUILD_ALLOWED_CONFIG_KEYS = new Set([
     "entry",
     "state",
     "output",
@@ -16,8 +21,18 @@ const ALLOWED_CONFIG_KEYS = new Set([
     "attribute-name-strategy",
     "stream",
 ]);
+const BUILD_BOOLEAN_CONFIG_KEYS = new Set(["stream"]);
+const CONVERT_ALLOWED_CONFIG_KEYS = new Set([
+    "syntax",
+    "template",
+    "output",
+    "overwrite",
+]);
+const CONVERT_BOOLEAN_CONFIG_KEYS = new Set(["overwrite"]);
+const CONFIG_PATH_KEYS = new Set(["entry", "state", "output", "templates", "template"]);
 
-/** @typedef {Record<string, string | boolean>} FastBuildConfig */
+/** @typedef {Record<string, string | boolean>} FastConfig */
+/** @typedef {{ syntax: string, extension: string, suffix: string }} ConvertSyntaxMetadata */
 
 /**
  * Parse CLI arguments of the form --key="value", --key=value, or supported
@@ -46,7 +61,7 @@ function parseArgs(argv) {
  * Resolve a boolean option, preferring CLI args over config values.
  * CLI values accept true, false, or an empty valueless flag.
  * @param {Record<string, string>} args - Parsed CLI arguments.
- * @param {FastBuildConfig} config - Parsed config file values.
+ * @param {FastConfig} config - Parsed config file values.
  * @param {string} key - The option key.
  * @returns {boolean}
  */
@@ -74,19 +89,46 @@ function resolveBooleanOption(args, config, key) {
 }
 
 /**
- * Load and validate a fast-build config file.
+ * Resolve a boolean option where CLI presence always means true.
+ * @param {Record<string, string>} args - Parsed CLI arguments.
+ * @param {FastConfig} config - Parsed config file values.
+ * @param {string} key - The option key.
+ * @returns {boolean}
+ */
+function resolvePresenceBooleanOption(args, config, key) {
+    if (Object.prototype.hasOwnProperty.call(args, key)) {
+        return true;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(config, key)) {
+        return config[key] === true;
+    }
+
+    return false;
+}
+
+/**
+ * Load and validate a CLI config file.
  *
  * - If `configPath` is provided, the file must exist (error if missing).
- * - If `configPath` is not provided, looks for `fast-build.config.json` in CWD.
+ * - If `configPath` is not provided, looks for `defaultFilename` in CWD.
  *   Returns an empty object if the default file does not exist.
  *
  * File paths in the returned config are resolved relative to the config
  * file's directory so that the caller can use them directly.
  *
  * @param {string | undefined} configPath - Explicit path from --config, if any.
- * @returns {{ config: FastBuildConfig, configDir: string | null }}
+ * @param {string} defaultFilename - Default config file to look up in CWD.
+ * @param {Set<string>} allowedKeys - Config keys accepted by the subcommand.
+ * @param {Set<string>} booleanKeys - Config keys that must be booleans.
+ * @returns {{ config: FastConfig, configDir: string | null }}
  */
-function loadConfig(configPath) {
+function loadConfig(
+    configPath,
+    defaultFilename = BUILD_DEFAULT_CONFIG_FILENAME,
+    allowedKeys = BUILD_ALLOWED_CONFIG_KEYS,
+    booleanKeys = BUILD_BOOLEAN_CONFIG_KEYS,
+) {
     /** @type {string} */
     let resolvedPath;
     /** @type {boolean} */
@@ -96,7 +138,7 @@ function loadConfig(configPath) {
         resolvedPath = path.resolve(configPath);
         isExplicit = true;
     } else {
-        resolvedPath = path.resolve(DEFAULT_CONFIG_FILENAME);
+        resolvedPath = path.resolve(defaultFilename);
         isExplicit = false;
     }
 
@@ -128,13 +170,13 @@ function loadConfig(configPath) {
     }
 
     for (const key of Object.keys(raw)) {
-        if (!ALLOWED_CONFIG_KEYS.has(key)) {
+        if (!allowedKeys.has(key)) {
             process.stderr.write(
-                `Error: Unknown key "${key}" in config file "${resolvedPath}". Allowed keys: ${[...ALLOWED_CONFIG_KEYS].join(", ")}.\n`
+                `Error: Unknown key "${key}" in config file "${resolvedPath}". Allowed keys: ${[...allowedKeys].join(", ")}.\n`
             );
             process.exit(1);
         }
-        if (key === "stream") {
+        if (booleanKeys.has(key)) {
             if (typeof raw[key] !== "boolean") {
                 process.stderr.write(
                     `Error: Value for "${key}" in config file "${resolvedPath}" must be a boolean.\n`
@@ -162,7 +204,7 @@ function loadConfig(configPath) {
  * CLI-derived paths are resolved relative to CWD (the default behaviour).
  *
  * @param {Record<string, string>} args - Parsed CLI arguments.
- * @param {FastBuildConfig} config - Parsed config file values.
+ * @param {FastConfig} config - Parsed config file values.
  * @param {string | null} configDir - Directory of the config file, or null.
  * @param {string} key - The option key.
  * @param {string} [defaultValue] - Fallback when neither source provides a value.
@@ -177,7 +219,7 @@ function resolveOption(args, config, configDir, key, defaultValue) {
         if (typeof value !== "string") {
             return defaultValue;
         }
-        const isFilePath = key === "entry" || key === "state" || key === "output" || key === "templates";
+        const isFilePath = CONFIG_PATH_KEYS.has(key);
         if (isFilePath && configDir !== null) {
             return path.resolve(configDir, value);
         }
@@ -330,9 +372,213 @@ function resolvePattern(pattern, wasm) {
     return results;
 }
 
+/**
+ * Load the converter WASM module and validate its required exports.
+ * @returns {object}
+ */
+function loadConvertWasm() {
+    const wasm = require(CONVERT_WASM_MODULE);
+    if (typeof wasm.convert_template !== "function") {
+        process.stderr.write(
+            "Error: Converter WASM module must export convert_template.\n",
+        );
+        process.exit(1);
+    }
+    if (typeof wasm.convert_syntax_metadata !== "function") {
+        process.stderr.write(
+            "Error: Converter WASM module must export convert_syntax_metadata.\n",
+        );
+        process.exit(1);
+    }
+    return wasm;
+}
+
+/**
+ * Load syntax metadata from the converter WASM module.
+ * @param {object} wasm
+ * @returns {Record<string, ConvertSyntaxMetadata>}
+ */
+function loadConvertSyntaxMetadata(wasm) {
+    let parsed;
+    try {
+        parsed = JSON.parse(wasm.convert_syntax_metadata());
+    } catch (e) {
+        process.stderr.write(`Error: Failed to parse converter syntax metadata: ${e.message}\n`);
+        process.exit(1);
+    }
+
+    if (!Array.isArray(parsed) || parsed.length === 0) {
+        process.stderr.write(
+            "Error: Converter syntax metadata must be a non-empty array.\n",
+        );
+        process.exit(1);
+    }
+
+    /** @type {Record<string, ConvertSyntaxMetadata>} */
+    const metadata = {};
+    for (const entry of parsed) {
+        if (
+            typeof entry !== "object" ||
+            entry === null ||
+            typeof entry.syntax !== "string" ||
+            typeof entry.extension !== "string" ||
+            typeof entry.suffix !== "string"
+        ) {
+            process.stderr.write(
+                "Error: Converter syntax metadata entries must include string syntax, extension, and suffix values.\n",
+            );
+            process.exit(1);
+        }
+        metadata[entry.syntax] = Object.freeze({
+            syntax: entry.syntax,
+            extension: entry.extension,
+            suffix: entry.suffix,
+        });
+    }
+    return Object.freeze(metadata);
+}
+
+/**
+ * @param {Record<string, ConvertSyntaxMetadata>} syntaxMetadata
+ * @returns {string}
+ */
+function convertSyntaxList(syntaxMetadata) {
+    return Object.keys(syntaxMetadata).join(", ");
+}
+
+/**
+ * Build the converter output path from an optional pattern.
+ * @param {string} template
+ * @param {string} syntax
+ * @param {string | undefined} outputPattern
+ * @param {Record<string, ConvertSyntaxMetadata>} syntaxMetadata
+ * @returns {string}
+ */
+function resolveConvertOutput(template, syntax, outputPattern, syntaxMetadata) {
+    const syntaxOptions = syntaxMetadata[syntax];
+    const basename = path.basename(template, path.extname(template));
+
+    if (outputPattern === undefined) {
+        return path.join(
+            path.dirname(template),
+            `${basename}${syntaxOptions.suffix}`,
+        );
+    }
+
+    return outputPattern.split("*").join(basename);
+}
+
+/**
+ * Validate the converter output path before writing.
+ * @param {string} output
+ * @param {string} syntax
+ * @param {boolean} overwrite
+ * @param {Record<string, ConvertSyntaxMetadata>} syntaxMetadata
+ */
+function validateConvertOutput(output, syntax, overwrite, syntaxMetadata) {
+    const syntaxOptions = syntaxMetadata[syntax];
+
+    if (fs.existsSync(output) && fs.statSync(output).isDirectory()) {
+        process.stderr.write(`Error: Output path "${output}" is a directory.\n`);
+        process.exit(1);
+    }
+
+    if (path.extname(output) !== syntaxOptions.extension) {
+        process.stderr.write(
+            `Error: Output file "${output}" must use the "${syntaxOptions.extension}" extension for syntax "${syntax}".\n`,
+        );
+        process.exit(1);
+    }
+
+    const outputParent = path.dirname(output) || ".";
+    if (!fs.existsSync(outputParent)) {
+        process.stderr.write(
+            `Error: Output parent directory "${outputParent}" not found.\n`,
+        );
+        process.exit(1);
+    }
+
+    if (!fs.statSync(outputParent).isDirectory()) {
+        process.stderr.write(
+            `Error: Output parent path "${outputParent}" is not a directory.\n`,
+        );
+        process.exit(1);
+    }
+
+    if (fs.existsSync(output) && !overwrite) {
+        process.stderr.write(
+            `Error: Output file "${output}" already exists. Use --overwrite to replace it.\n`,
+        );
+        process.exit(1);
+    }
+}
+
+async function runConvert(args) {
+    const { config, configDir } = loadConfig(
+        Object.prototype.hasOwnProperty.call(args, "config") ? args["config"] : undefined,
+        CONVERT_DEFAULT_CONFIG_FILENAME,
+        CONVERT_ALLOWED_CONFIG_KEYS,
+        CONVERT_BOOLEAN_CONFIG_KEYS,
+    );
+
+    const syntax = resolveOption(args, config, configDir, "syntax");
+    const template = resolveOption(args, config, configDir, "template");
+    const outputArg = resolveOption(args, config, configDir, "output");
+    const overwrite = resolvePresenceBooleanOption(args, config, "overwrite");
+    const wasm = loadConvertWasm();
+    const syntaxMetadata = loadConvertSyntaxMetadata(wasm);
+    const syntaxList = convertSyntaxList(syntaxMetadata);
+
+    if (!syntax) {
+        process.stderr.write(
+            `Error: Missing required --syntax. Expected one of: ${syntaxList}.\n`,
+        );
+        process.exit(1);
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(syntaxMetadata, syntax)) {
+        process.stderr.write(
+            `Error: Invalid --syntax "${syntax}". Expected one of: ${syntaxList}.\n`,
+        );
+        process.exit(1);
+    }
+
+    if (!template) {
+        process.stderr.write("Error: Missing required --template.\n");
+        process.exit(1);
+    }
+
+    if (path.extname(template) !== ".html") {
+        process.stderr.write(
+            `Error: Template file "${template}" must use the ".html" extension.\n`,
+        );
+        process.exit(1);
+    }
+
+    if (!fs.existsSync(template)) {
+        process.stderr.write(`Error: Template file "${template}" not found.\n`);
+        process.exit(1);
+    }
+
+    if (!fs.statSync(template).isFile()) {
+        process.stderr.write(`Error: Template path "${template}" is not a file.\n`);
+        process.exit(1);
+    }
+
+    const output = resolveConvertOutput(template, syntax, outputArg, syntaxMetadata);
+    validateConvertOutput(output, syntax, overwrite, syntaxMetadata);
+
+    const converted = wasm.convert_template(fs.readFileSync(template, "utf8"), syntax);
+    fs.writeFileSync(output, converted, "utf8");
+    process.stdout.write(`Converted: ${output}\n`);
+}
+
 async function runBuild(args) {
     const { config, configDir } = loadConfig(
-        Object.prototype.hasOwnProperty.call(args, "config") ? args["config"] : undefined
+        Object.prototype.hasOwnProperty.call(args, "config") ? args["config"] : undefined,
+        BUILD_DEFAULT_CONFIG_FILENAME,
+        BUILD_ALLOWED_CONFIG_KEYS,
+        BUILD_BOOLEAN_CONFIG_KEYS,
     );
 
     const templatesArg = resolveOption(args, config, configDir, "templates");
@@ -353,7 +599,7 @@ async function runBuild(args) {
     }
 
     // Load WASM module first — needed for both template parsing and rendering.
-    const wasm = require(WASM_MODULE);
+    const wasm = require(BUILD_WASM_MODULE);
 
     // Resolve template files
     const templatesMap = {};
@@ -465,41 +711,98 @@ async function runBuild(args) {
     process.stdout.write(`Built: ${output}\n`);
 }
 
+function writeGeneralUsage() {
+    process.stdout.write(
+        "Usage: fast <command> [options]\n\n" +
+        "Commands:\n" +
+        "  build     Render a FAST declarative HTML template.\n" +
+        "  convert   Convert a FAST declarative HTML template.\n\n" +
+        'Run "fast <command> --help" for command options.\n',
+    );
+}
+
+function writeBuildUsage() {
+    process.stdout.write(
+        "Usage: fast build [options]\n\n" +
+        "Options:\n" +
+        '  --templates="<glob>"   Glob pattern(s) for custom element template HTML files.\n' +
+        "                         Separate multiple patterns with commas.\n" +
+        '  --output="output.html" Output file path (default: output.html)\n' +
+        '  --entry="index.html"   Entry HTML template file (default: index.html)\n' +
+        '  --state="state.json"   State JSON file. If omitted, rendering uses\n' +
+        "                         an empty state object.\n" +
+        "  --stream[=true|false]  Write rendered HTML chunks to stdout instead\n" +
+        "                         of writing an output file.\n" +
+        '  --attribute-name-strategy="camelCase"\n' +
+        "                         Strategy for mapping attribute names to property names.\n" +
+        '                         "camelCase" (default) or "none".\n' +
+        '  --config="<path>"      Path to a fast-build config JSON file.\n' +
+        '                         Defaults to "fast-build.config.json" in the\n' +
+        "                         current directory if it exists. File paths in\n" +
+        "                         the config are resolved relative to the config\n" +
+        "                         file's directory. CLI arguments take precedence\n" +
+        "                         over config file values.\n",
+    );
+}
+
+function writeConvertUsage() {
+    const syntaxMetadata = loadConvertSyntaxMetadata(loadConvertWasm());
+    const syntaxList = convertSyntaxList(syntaxMetadata);
+    const defaultOutputs = Object.values(syntaxMetadata)
+        .map(metadata => `"*${metadata.suffix}" for ${metadata.syntax}`)
+        .join(" or\n                         ");
+
+    process.stdout.write(
+        "Usage: fast convert [options]\n\n" +
+        "Options:\n" +
+        `  --syntax="${syntaxList}"\n` +
+        "                         Required target syntax.\n" +
+        '  --template="<path>"    Required source FAST declarative .html file.\n' +
+        '  --output="<path>"      Output file path. Defaults next to --template\n' +
+        `                         as ${defaultOutputs}. Any "*" is\n` +
+        "                         replaced by the template basename.\n" +
+        "  --overwrite           Replace an existing output file.\n" +
+        '  --config="<path>"      Path to a fast-convert config JSON file.\n' +
+        '                         Defaults to "fast-convert.config.json" in the\n' +
+        "                         current directory if it exists. File paths in\n" +
+        "                         the config are resolved relative to the config\n" +
+        "                         file's directory. CLI arguments take precedence\n" +
+        "                         over config file values.\n",
+    );
+}
+
 async function main() {
     const argv = process.argv.slice(2);
     if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
-        process.stdout.write(
-            "Usage: fast build [options]\n\n" +
-            "Options:\n" +
-            '  --templates="<glob>"   Glob pattern(s) for custom element template HTML files.\n' +
-            '                         Separate multiple patterns with commas.\n' +
-            '  --output="output.html" Output file path (default: output.html)\n' +
-            '  --entry="index.html"   Entry HTML template file (default: index.html)\n' +
-            '  --state="state.json"   State JSON file. If omitted, rendering uses\n' +
-            '                         an empty state object.\n' +
-            '  --stream[=true|false]  Write rendered HTML chunks to stdout instead\n' +
-            '                         of writing an output file.\n' +
-            '  --attribute-name-strategy="camelCase"\n' +
-            '                         Strategy for mapping attribute names to property names.\n' +
-            '                         "camelCase" (default) or "none".\n' +
-            '  --config="<path>"      Path to a fast-build config JSON file.\n' +
-            '                         Defaults to "fast-build.config.json" in the\n' +
-            '                         current directory if it exists. File paths in\n' +
-            '                         the config are resolved relative to the config\n' +
-            '                         file\'s directory. CLI arguments take precedence\n' +
-            '                         over config file values.\n'
-        );
+        writeGeneralUsage();
         return;
     }
 
     const subcommand = argv[0];
-    if (subcommand !== "build") {
-        process.stderr.write(`Unknown subcommand: "${subcommand}". Expected "build".\n`);
-        process.exit(1);
+    if (subcommand === "build") {
+        if (argv[1] === "--help" || argv[1] === "-h") {
+            writeBuildUsage();
+            return;
+        }
+        const args = parseArgs(argv.slice(1));
+        await runBuild(args);
+        return;
+    }
+
+    if (subcommand === "convert") {
+        if (argv[1] === "--help" || argv[1] === "-h") {
+            writeConvertUsage();
+            return;
+        }
+        const args = parseArgs(argv.slice(1));
+        await runConvert(args);
+        return;
     }
 
-    const args = parseArgs(argv.slice(1));
-    await runBuild(args);
+    process.stderr.write(
+        `Unknown subcommand: "${subcommand}". Expected "build" or "convert".\n`,
+    );
+    process.exit(1);
 }
 
 main().catch((err) => {
diff --git a/packages/fast-build/build-wasm.cjs b/packages/fast-build/build-wasm.cjs
new file mode 100644
index 00000000000..59a893015ab
--- /dev/null
+++ b/packages/fast-build/build-wasm.cjs
@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+"use strict";
+
+const { execFileSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const packageDir = __dirname;
+const repoRoot = path.resolve(packageDir, "../..");
+
+/**
+ * @param {string} command
+ * @param {string[]} args
+ */
+function run(command, args) {
+    execFileSync(command, args, {
+        cwd: packageDir,
+        stdio: "inherit",
+    });
+}
+
+/**
+ * @param {string} crateName
+ * @param {string} outDir
+ * @param {boolean} required
+ */
+function buildCrate(crateName, outDir, required) {
+    const crateDir = path.join(repoRoot, "crates", crateName);
+    const manifest = path.join(crateDir, "Cargo.toml");
+
+    if (!fs.existsSync(manifest)) {
+        if (required) {
+            throw new Error(`Required crate manifest not found: ${manifest}`);
+        }
+
+        process.stdout.write(
+            `Skipping ${crateName} WASM build; ${path.relative(repoRoot, manifest)} not found.\n`,
+        );
+        return;
+    }
+
+    run("cargo", ["build", "--manifest-path", manifest]);
+    run("wasm-pack", ["build", "--target", "nodejs", crateDir, "--out-dir", outDir]);
+}
+
+buildCrate("microsoft-fast-build", path.join(packageDir, "wasm"), true);
+buildCrate("microsoft-fast-convert", path.join(packageDir, "wasm", "convert"), true);
diff --git a/packages/fast-build/package.json b/packages/fast-build/package.json
index d3518a4cfcd..bc77c617565 100644
--- a/packages/fast-build/package.json
+++ b/packages/fast-build/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@microsoft/fast-build",
   "version": "0.9.0",
-  "description": "CLI and Node.js API for server-side rendering of FAST declarative HTML templates.",
+  "description": "CLI and Node.js API for server-side rendering and converting FAST declarative HTML templates.",
   "author": {
     "name": "Microsoft",
     "url": "https://discord.gg/FcSNfg4"
@@ -19,6 +19,7 @@
   "exports": {
     "./bin/fast.js": "./bin/fast.js",
     "./wasm/microsoft_fast_build.js": "./wasm/microsoft_fast_build.js",
+    "./wasm/convert/microsoft_fast_convert.js": "./wasm/convert/microsoft_fast_convert.js",
     "./package.json": "./package.json"
   },
   "bin": {
@@ -30,11 +31,16 @@
     "wasm/microsoft_fast_build.js",
     "wasm/microsoft_fast_build_bg.wasm",
     "wasm/microsoft_fast_build.d.ts",
-    "wasm/microsoft_fast_build_bg.wasm.d.ts"
+    "wasm/microsoft_fast_build_bg.wasm.d.ts",
+    "wasm/convert/microsoft_fast_convert.js",
+    "wasm/convert/microsoft_fast_convert_bg.wasm",
+    "wasm/convert/microsoft_fast_convert.d.ts",
+    "wasm/convert/microsoft_fast_convert_bg.wasm.d.ts"
   ],
   "scripts": {
-    "build": "cargo build --manifest-path ../../crates/microsoft-fast-build/Cargo.toml && wasm-pack build --target nodejs ../../crates/microsoft-fast-build --out-dir ../../packages/fast-build/wasm",
-    "test:node": "node --test test/config.test.js"
+    "build": "node build-wasm.cjs",
+    "test:node": "node --test test/config.test.js test/fixtures/convert/convert-fixtures.test.js",
+    "test:fixtures:convert": "node --test test/fixtures/convert/convert-fixtures.test.js"
   },
   "engines": {
     "node": ">=22.18.0"
diff --git a/packages/fast-build/test/config.test.js b/packages/fast-build/test/config.test.js
index 95a9ff56ea1..f613b2fbd6a 100644
--- a/packages/fast-build/test/config.test.js
+++ b/packages/fast-build/test/config.test.js
@@ -1,27 +1,40 @@
 // @ts-check
 
-const { describe, it, beforeEach, afterEach } = require("node:test");
+const { describe, it, beforeEach, afterEach, after } = require("node:test");
 const assert = require("node:assert/strict");
 const { execFileSync } = require("node:child_process");
 const fs = require("node:fs");
 const path = require("node:path");
-const os = require("node:os");
 
 const FAST_BIN = path.resolve(__dirname, "../bin/fast.js");
 const WASM = require("../wasm/microsoft_fast_build.js");
 const WASM_MODULE = path.resolve(__dirname, "../wasm/microsoft_fast_build.js");
+const CONVERT_WASM_MODULE = path.resolve(
+    __dirname,
+    "../wasm/convert/microsoft_fast_convert.js",
+);
 const WASM_STUB = path.resolve(__dirname, "wasm-stub.cjs");
+const TEST_TEMP_ROOT = path.join(__dirname, ".test-output");
 
 function tmpDir() {
-    return fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "fast-build-test-")));
+    fs.mkdirSync(TEST_TEMP_ROOT, { recursive: true });
+    return fs.realpathSync(fs.mkdtempSync(path.join(TEST_TEMP_ROOT, "case-")));
 }
 
+after(() => {
+    fs.rmSync(TEST_TEMP_ROOT, { recursive: true, force: true });
+});
+
 function run(args, cwd) {
     return runNode(args, cwd);
 }
 
 function runNode(args, cwd, nodeArgs = [], env = process.env) {
-    return execFileSync(process.execPath, [...nodeArgs, FAST_BIN, "build", ...args], {
+    return runFast(["build", ...args], cwd, nodeArgs, env);
+}
+
+function runFast(args, cwd, nodeArgs = [], env = process.env) {
+    return execFileSync(process.execPath, [...nodeArgs, FAST_BIN, ...args], {
         cwd,
         encoding: "utf8",
         env,
@@ -30,12 +43,12 @@ function runNode(args, cwd, nodeArgs = [], env = process.env) {
 }
 
 function runWithStderr(args, cwd) {
+    return runFastWithStderr(["build", ...args], cwd);
+}
+
+function runFastWithStderr(args, cwd, nodeArgs = [], env = process.env) {
     try {
-        const stdout = execFileSync(process.execPath, [FAST_BIN, "build", ...args], {
-            cwd,
-            encoding: "utf8",
-            stdio: ["pipe", "pipe", "pipe"],
-        });
+        const stdout = runFast(args, cwd, nodeArgs, env);
         return { stdout, stderr: "", exitCode: 0 };
     } catch (e) {
         return {
@@ -60,6 +73,20 @@ function writeWasmStub(dir) {
     };
 }
 
+function writeConvertWasmStub(dir) {
+    const record = path.join(dir, "convert-wasm-calls.json");
+
+    return {
+        preload: WASM_STUB,
+        record,
+        env: {
+            ...process.env,
+            FAST_CONVERT_WASM_STUB_MODULE: CONVERT_WASM_MODULE,
+            FAST_BUILD_WASM_STUB_RECORD: record,
+        },
+    };
+}
+
 function runWithStubbedWasm(args, cwd) {
     const { preload, record, env } = writeWasmStub(cwd);
     const stdout = runNode(args, cwd, ["--require", preload], env);
@@ -68,6 +95,23 @@ function runWithStubbedWasm(args, cwd) {
     return { stdout, calls };
 }
 
+function runConvertWithStubbedWasm(args, cwd) {
+    const { preload, record, env } = writeConvertWasmStub(cwd);
+    const stdout = runFast(["convert", ...args], cwd, ["--require", preload], env);
+    const calls = JSON.parse(fs.readFileSync(record, "utf8"));
+
+    return { stdout, calls };
+}
+
+function runConvertWithStderr(args, cwd, stubWasm = false) {
+    if (!stubWasm) {
+        return runFastWithStderr(["convert", ...args], cwd);
+    }
+
+    const { preload, env } = writeConvertWasmStub(cwd);
+    return runFastWithStderr(["convert", ...args], cwd, ["--require", preload], env);
+}
+
 function writeFixture(dir, { entry, state, output, config, configName }) {
     fs.writeFileSync(
         path.join(dir, "entry.html"),
@@ -82,6 +126,339 @@ function writeFixture(dir, { entry, state, output, config, configName }) {
     }
 }
 
+describe("CLI help", () => {
+    it("lists both subcommands from top-level help", () => {
+        const stdout = runFast(["--help"], __dirname);
+
+        assert.ok(stdout.includes("build"));
+        assert.ok(stdout.includes("convert"));
+    });
+
+    it("prints build command help without dispatching to WASM", () => {
+        const stdout = runFast(["build", "--help"], __dirname);
+
+        assert.ok(stdout.includes("Usage: fast build"));
+        assert.ok(stdout.includes("--entry"));
+    });
+
+    it("prints convert command help from converter syntax metadata", () => {
+        const stdout = runFast(["convert", "--help"], __dirname);
+
+        assert.ok(stdout.includes("Usage: fast convert"));
+        assert.ok(stdout.includes("--syntax"));
+    });
+});
+
+describe("convert CLI", () => {
+    /** @type {string} */
+    let dir;
+
+    beforeEach(() => {
+        dir = tmpDir();
+    });
+
+    afterEach(() => {
+        fs.rmSync(dir, { recursive: true, force: true });
+    });
+
+    it("converts with CLI args and the default webui output suffix", () => {
+        fs.writeFileSync(
+            path.join(dir, "example.html"),
+            '<f-template name="my-el"><template>Hello</template></f-template>',
+        );
+
+        const { stdout, calls } = runConvertWithStubbedWasm(
+            ["--syntax=webui-prerelease", "--template=example.html"],
+            dir,
+        );
+        const output = fs.readFileSync(path.join(dir, "example.webui.html"), "utf8");
+
+        assert.equal(stdout, "Converted: example.webui.html\n");
+        assert.equal(
+            output,
+            'converted:webui-prerelease:<f-template name="my-el"><template>Hello</template></f-template>',
+        );
+        assert.deepEqual(calls, [
+            {
+                name: "convert_template",
+                template:
+                    '<f-template name="my-el"><template>Hello</template></f-template>',
+                syntax: "webui-prerelease",
+            },
+        ]);
+    });
+
+    it("converts with the generated converter WASM when available", {
+        skip: !fs.existsSync(CONVERT_WASM_MODULE),
+    }, () => {
+        fs.writeFileSync(
+            path.join(dir, "example.html"),
+            '<f-template name="my-el"><template>Hello</template></f-template>',
+        );
+
+        const stdout = runFast(
+            [
+                "convert",
+                "--syntax=webui-prerelease",
+                "--template=example.html",
+                "--output=actual.html",
+            ],
+            dir,
+        );
+
+        assert.equal(stdout, "Converted: actual.html\n");
+        assert.equal(
+            fs.readFileSync(path.join(dir, "actual.html"), "utf8"),
+            "<template>Hello</template>",
+        );
+    });
+
+    it("replaces * in output paths with the input basename", () => {
+        fs.mkdirSync(path.join(dir, "templates"));
+        fs.mkdirSync(path.join(dir, "generated"));
+        fs.writeFileSync(
+            path.join(dir, "templates", "card.html"),
+            '<f-template name="card"><template>Card</template></f-template>',
+        );
+
+        const { stdout } = runConvertWithStubbedWasm(
+            [
+                "--syntax=fast-v3-ts",
+                "--template=templates/card.html",
+                "--output=generated/*.template.ts",
+            ],
+            dir,
+        );
+
+        assert.equal(stdout, "Converted: generated/card.template.ts\n");
+        assert.ok(fs.existsSync(path.join(dir, "generated", "card.template.ts")));
+    });
+
+    it("loads config paths relative to the config file directory", () => {
+        const projectDir = path.join(dir, "project");
+        fs.mkdirSync(path.join(projectDir, "out"), { recursive: true });
+        fs.writeFileSync(
+            path.join(projectDir, "template.html"),
+            '<f-template name="configured"><template>Configured</template></f-template>',
+        );
+        fs.writeFileSync(
+            path.join(projectDir, "fast-convert.config.json"),
+            JSON.stringify({
+                syntax: "webui-prerelease",
+                template: "template.html",
+                output: "out/*.html",
+            }),
+        );
+
+        runConvertWithStubbedWasm(["--config=project/fast-convert.config.json"], dir);
+
+        assert.ok(fs.existsSync(path.join(projectDir, "out", "template.html")));
+    });
+
+    it("lets CLI args override config values", () => {
+        fs.mkdirSync(path.join(dir, "generated"));
+        fs.writeFileSync(
+            path.join(dir, "config.html"),
+            '<f-template name="config"><template>Config</template></f-template>',
+        );
+        fs.writeFileSync(
+            path.join(dir, "cli.html"),
+            '<f-template name="cli"><template>CLI</template></f-template>',
+        );
+        fs.writeFileSync(
+            path.join(dir, "fast-convert.config.json"),
+            JSON.stringify({
+                syntax: "webui-prerelease",
+                template: "config.html",
+                output: "config.webui.html",
+            }),
+        );
+
+        runConvertWithStubbedWasm(
+            [
+                "--syntax=fast-v3-ts",
+                "--template=cli.html",
+                "--output=generated/*.template.ts",
+            ],
+            dir,
+        );
+
+        assert.ok(fs.existsSync(path.join(dir, "generated", "cli.template.ts")));
+        assert.ok(!fs.existsSync(path.join(dir, "config.webui.html")));
+    });
+
+    it("prevents overwriting unless --overwrite is present", () => {
+        fs.writeFileSync(
+            path.join(dir, "example.html"),
+            '<f-template name="my-el"><template>Hello</template></f-template>',
+        );
+        fs.writeFileSync(path.join(dir, "example.webui.html"), "old");
+
+        const result = runConvertWithStderr(
+            ["--syntax=webui-prerelease", "--template=example.html"],
+            dir,
+        );
+
+        assert.equal(result.exitCode, 1);
+        assert.ok(result.stderr.includes("already exists"));
+        assert.equal(
+            fs.readFileSync(path.join(dir, "example.webui.html"), "utf8"),
+            "old",
+        );
+    });
+
+    it("uses --overwrite even when config overwrite is false", () => {
+        fs.writeFileSync(
+            path.join(dir, "example.html"),
+            '<f-template name="my-el"><template>Hello</template></f-template>',
+        );
+        fs.writeFileSync(path.join(dir, "example.webui.html"), "old");
+        fs.writeFileSync(
+            path.join(dir, "fast-convert.config.json"),
+            JSON.stringify({
+                syntax: "webui-prerelease",
+                template: "example.html",
+                overwrite: false,
+            }),
+        );
+
+        runConvertWithStubbedWasm(["--overwrite"], dir);
+
+        assert.notEqual(
+            fs.readFileSync(path.join(dir, "example.webui.html"), "utf8"),
+            "old",
+        );
+    });
+});
+
+describe("convert validation", () => {
+    /** @type {string} */
+    let dir;
+
+    beforeEach(() => {
+        dir = tmpDir();
+    });
+
+    afterEach(() => {
+        fs.rmSync(dir, { recursive: true, force: true });
+    });
+
+    it("requires syntax", () => {
+        const result = runConvertWithStderr(["--template=example.html"], dir);
+
+        assert.equal(result.exitCode, 1);
+        assert.ok(result.stderr.includes("Missing required --syntax"));
+    });
+
+    it("rejects invalid syntax", () => {
+        fs.writeFileSync(path.join(dir, "example.html"), "<template></template>");
+        const result = runConvertWithStderr(
+            ["--syntax=unknown", "--template=example.html"],
+            dir,
+        );
+
+        assert.equal(result.exitCode, 1);
+        assert.ok(result.stderr.includes("Invalid --syntax"));
+        assert.ok(result.stderr.includes("webui-prerelease"));
+        assert.ok(result.stderr.includes("fast-v3-ts"));
+    });
+
+    it("requires template", () => {
+        const result = runConvertWithStderr(["--syntax=webui-prerelease"], dir);
+
+        assert.equal(result.exitCode, 1);
+        assert.ok(result.stderr.includes("Missing required --template"));
+    });
+
+    it("requires an existing template file", () => {
+        const result = runConvertWithStderr(
+            ["--syntax=webui-prerelease", "--template=missing.html"],
+            dir,
+        );
+
+        assert.equal(result.exitCode, 1);
+        assert.ok(result.stderr.includes("Template file"));
+        assert.ok(result.stderr.includes("not found"));
+    });
+
+    it("requires an html template extension", () => {
+        fs.writeFileSync(path.join(dir, "example.txt"), "text");
+        const result = runConvertWithStderr(
+            ["--syntax=webui-prerelease", "--template=example.txt"],
+            dir,
+        );
+
+        assert.equal(result.exitCode, 1);
+        assert.ok(result.stderr.includes('must use the ".html" extension'));
+    });
+
+    it("rejects template directory paths", () => {
+        fs.mkdirSync(path.join(dir, "directory.html"));
+        const result = runConvertWithStderr(
+            ["--syntax=webui-prerelease", "--template=directory.html"],
+            dir,
+        );
+
+        assert.equal(result.exitCode, 1);
+        assert.ok(result.stderr.includes("is not a file"));
+    });
+
+    it("requires the output extension for the selected syntax", () => {
+        fs.writeFileSync(path.join(dir, "example.html"), "<template></template>");
+        const result = runConvertWithStderr(
+            ["--syntax=fast-v3-ts", "--template=example.html", "--output=example.html"],
+            dir,
+        );
+
+        assert.equal(result.exitCode, 1);
+        assert.ok(result.stderr.includes('must use the ".ts" extension'));
+    });
+
+    it("requires the output parent directory to exist", () => {
+        fs.writeFileSync(path.join(dir, "example.html"), "<template></template>");
+        const result = runConvertWithStderr(
+            [
+                "--syntax=webui-prerelease",
+                "--template=example.html",
+                "--output=missing/example.html",
+            ],
+            dir,
+        );
+
+        assert.equal(result.exitCode, 1);
+        assert.ok(result.stderr.includes("Output parent directory"));
+        assert.ok(result.stderr.includes("not found"));
+    });
+
+    it("rejects output directory paths", () => {
+        fs.writeFileSync(path.join(dir, "example.html"), "<template></template>");
+        fs.mkdirSync(path.join(dir, "output.html"));
+        const result = runConvertWithStderr(
+            [
+                "--syntax=webui-prerelease",
+                "--template=example.html",
+                "--output=output.html",
+            ],
+            dir,
+        );
+
+        assert.equal(result.exitCode, 1);
+        assert.ok(result.stderr.includes("is a directory"));
+    });
+
+    it("rejects non-boolean overwrite config values", () => {
+        fs.writeFileSync(
+            path.join(dir, "fast-convert.config.json"),
+            '{"overwrite":"true"}',
+        );
+        const result = runConvertWithStderr([], dir);
+
+        assert.equal(result.exitCode, 1);
+        assert.ok(result.stderr.includes('Value for "overwrite"'));
+        assert.ok(result.stderr.includes("must be a boolean"));
+    });
+});
+
 describe("config file loading", () => {
     /** @type {string} */
     let dir;
diff --git a/packages/fast-build/test/fixtures/convert/convert-fixtures.test.js b/packages/fast-build/test/fixtures/convert/convert-fixtures.test.js
new file mode 100644
index 00000000000..c39c775cf1d
--- /dev/null
+++ b/packages/fast-build/test/fixtures/convert/convert-fixtures.test.js
@@ -0,0 +1,223 @@
+// @ts-check
+
+const { after, beforeEach, describe, it } = require("node:test");
+const assert = require("node:assert/strict");
+const { execFileSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const fixturesDir = __dirname;
+const packageDir = path.resolve(fixturesDir, "../../..");
+const fastBin = path.join(packageDir, "bin", "fast.js");
+const outputRoot = path.join(packageDir, "test", ".fixture-output");
+const supportedTemplate = path.join(fixturesDir, "supported.html");
+const fixtureConfig = path.join(fixturesDir, "fast-convert.config.json");
+
+beforeEach(() => {
+    fs.rmSync(outputRoot, { recursive: true, force: true });
+    fs.mkdirSync(outputRoot, { recursive: true });
+});
+
+after(() => {
+    fs.rmSync(outputRoot, { recursive: true, force: true });
+});
+
+function outputDir(name) {
+    const dir = path.join(outputRoot, name);
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+
+function runConvert(args, cwd = packageDir) {
+    return execFileSync(process.execPath, [fastBin, "convert", ...args], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+}
+
+function runConvertWithStderr(args, cwd = packageDir) {
+    try {
+        const stdout = runConvert(args, cwd);
+        return { stdout, stderr: "", exitCode: 0 };
+    } catch (e) {
+        return {
+            stdout: e.stdout || "",
+            stderr: e.stderr || "",
+            exitCode: e.status,
+        };
+    }
+}
+
+function assertIncludes(output, expected) {
+    assert.ok(
+        output.includes(expected),
+        `Expected output to include:\n${expected}\n\nActual output:\n${output}`,
+    );
+}
+
+function assertWebuiOutput(output) {
+    assertIncludes(output, '<for each="item in items">');
+    assertIncludes(output, '<if condition="item.visible">');
+    assertIncludes(output, '<for each="child in item.children">');
+    assertIncludes(output, 'f-ref="root"');
+    assertIncludes(output, 'f-children="children"');
+    assertIncludes(output, 'f-slotted="{slottedNodes}"');
+    assertIncludes(output, '@click="{handleRoot($e, $c)}"');
+    assertIncludes(output, '@click="{handleChild($e, $c, child.id)}"');
+    assert.equal(output.includes("<f-repeat"), false);
+    assert.equal(output.includes("<f-when"), false);
+}
+
+function assertFastV3TsOutput(output) {
+    assertIncludes(output, 'import { html } from "@microsoft/fast-element/html.js";');
+    assertIncludes(output, 'import { repeat } from "@microsoft/fast-element/repeat.js";');
+    assertIncludes(output, 'import { when } from "@microsoft/fast-element/when.js";');
+    assertIncludes(output, 'import { ref } from "@microsoft/fast-element/ref.js";');
+    assertIncludes(
+        output,
+        'import { children } from "@microsoft/fast-element/children.js";',
+    );
+    assertIncludes(
+        output,
+        'import { slotted } from "@microsoft/fast-element/slotted.js";',
+    );
+    assertIncludes(output, 'title="${x => x.title}"');
+    assertIncludes(output, '?hidden="${x => x.hidden}"');
+    assertIncludes(output, ':value="${x => x.value}"');
+    assertIncludes(output, 'data-literal="literal \\${ value } \\`tick\\` \\\\ slash"');
+    assertIncludes(output, '${ref("root")}');
+    assertIncludes(output, '${children("children")}');
+    assertIncludes(output, '${slotted("slottedNodes")}');
+    assertIncludes(output, '@click="${(x, c) => x.handleRoot(c.event, c)}"');
+    assertIncludes(output, "${repeat(x => x.items, x => html`");
+    assertIncludes(output, "${when(x => x.visible, html`");
+    assertIncludes(output, "${repeat(x => x.children, x => html`");
+    assertIncludes(
+        output,
+        '@click="${(x, c) => c.parentContext.parent.handleChild(c.event, c, x.id)}"',
+    );
+    assertIncludes(output, "Literal \\${ sequence, \\`backtick\\`, and \\\\ backslash");
+    assert.equal(output.includes("<f-repeat"), false);
+    assert.equal(output.includes("<f-when"), false);
+}
+
+describe("fast convert fixtures", () => {
+    it("loads default fixture config and converts webui-prerelease output to a temp location", () => {
+        const configOutputDir = outputDir("config");
+
+        runConvert([], fixturesDir);
+
+        const outputPath = path.join(configOutputDir, "supported.html");
+        const output = fs.readFileSync(outputPath, "utf8");
+        assertWebuiOutput(output);
+        assert.equal(
+            fs.existsSync(path.join(fixturesDir, "supported.webui.html")),
+            false,
+        );
+        assert.equal(
+            fs.existsSync(path.join(fixturesDir, "supported.template.ts")),
+            false,
+        );
+    });
+
+    it("lets CLI args override fixture config values for fast-v3-ts", () => {
+        const cliOutputDir = outputDir("cli-precedence");
+        const outputPath = path.join(cliOutputDir, "supported.template.ts");
+
+        runConvert([
+            `--config=${fixtureConfig}`,
+            "--syntax=fast-v3-ts",
+            `--template=${supportedTemplate}`,
+            `--output=${path.join(cliOutputDir, "*.template.ts")}`,
+        ]);
+
+        assertFastV3TsOutput(fs.readFileSync(outputPath, "utf8"));
+        assert.equal(
+            fs.existsSync(path.join(outputRoot, "config", "supported.html")),
+            false,
+        );
+    });
+
+    it("validates overwrite before replacing generated fixture output", () => {
+        const overwriteOutputDir = outputDir("overwrite");
+        const outputPath = path.join(overwriteOutputDir, "supported.html");
+        fs.writeFileSync(outputPath, "stale output", "utf8");
+
+        const blocked = runConvertWithStderr([
+            "--syntax=webui-prerelease",
+            `--template=${supportedTemplate}`,
+            `--output=${outputPath}`,
+        ]);
+
+        assert.equal(blocked.exitCode, 1);
+        assertIncludes(blocked.stderr, "already exists");
+        assert.equal(fs.readFileSync(outputPath, "utf8"), "stale output");
+
+        runConvert([
+            "--syntax=webui-prerelease",
+            `--template=${supportedTemplate}`,
+            `--output=${outputPath}`,
+            "--overwrite",
+        ]);
+
+        assertWebuiOutput(fs.readFileSync(outputPath, "utf8"));
+    });
+
+    it("validates output extensions for fixture conversion", () => {
+        const extensionOutputDir = outputDir("extension");
+        const result = runConvertWithStderr([
+            "--syntax=fast-v3-ts",
+            `--template=${supportedTemplate}`,
+            `--output=${path.join(extensionOutputDir, "wrong.html")}`,
+        ]);
+
+        assert.equal(result.exitCode, 1);
+        assertIncludes(result.stderr, 'must use the ".ts" extension');
+    });
+
+    it("validates missing output parent directories for fixture conversion", () => {
+        const result = runConvertWithStderr([
+            "--syntax=webui-prerelease",
+            `--template=${supportedTemplate}`,
+            `--output=${path.join(outputRoot, "missing-parent", "supported.html")}`,
+        ]);
+
+        assert.equal(result.exitCode, 1);
+        assertIncludes(result.stderr, "Output parent directory");
+        assertIncludes(result.stderr, "not found");
+    });
+
+    for (const { name, outputExtension, expectedMessage } of [
+        {
+            name: "invalid-repeat",
+            outputExtension: ".html",
+            expectedMessage: "invalid repeat expression",
+        },
+        {
+            name: "unsupported-f-attribute",
+            outputExtension: ".ts",
+            expectedMessage: "unsupported f-* attribute",
+        },
+        {
+            name: "missing-inner-template",
+            outputExtension: ".html",
+            expectedMessage: "inner '<template>' element",
+        },
+    ]) {
+        it(`surfaces converter validation errors for ${name} using fixture config`, () => {
+            const fixtureDir = path.join(fixturesDir, "validation", name);
+            const validationOutputDir = outputDir("validation");
+            const result = runConvertWithStderr([], fixtureDir);
+
+            assert.equal(result.exitCode, 1);
+            assertIncludes(result.stderr, expectedMessage);
+            assert.equal(
+                fs.existsSync(
+                    path.join(validationOutputDir, `${name}${outputExtension}`),
+                ),
+                false,
+            );
+        });
+    }
+});
diff --git a/packages/fast-build/test/fixtures/convert/fast-convert.config.json b/packages/fast-build/test/fixtures/convert/fast-convert.config.json
new file mode 100644
index 00000000000..2f8dd069388
--- /dev/null
+++ b/packages/fast-build/test/fixtures/convert/fast-convert.config.json
@@ -0,0 +1,6 @@
+{
+    "syntax": "webui-prerelease",
+    "template": "supported.html",
+    "output": "../../.fixture-output/config/*.html",
+    "overwrite": false
+}
diff --git a/packages/fast-build/test/fixtures/convert/supported.html b/packages/fast-build/test/fixtures/convert/supported.html
new file mode 100644
index 00000000000..f6ac0604df9
--- /dev/null
+++ b/packages/fast-build/test/fixtures/convert/supported.html
@@ -0,0 +1,25 @@
+<f-template name="fixture-card">
+    <template>
+        <section
+            f-ref="root"
+            title="{{title}}"
+            ?hidden="{{hidden}}"
+            :value="{{value}}"
+            data-literal="literal ${ value } `tick` \ slash"
+        >
+            <button @click="{handleRoot($e, $c)}">Root {{title}}</button>
+            Literal ${ sequence, `backtick`, and \ backslash
+            <f-repeat value="{{item in items}}">
+                <article f-children="children">
+                    <h2>{{item.name}}</h2>
+                    <f-when value="{{item.visible}}">
+                        <slot f-slotted="{slottedNodes}">{{item.count}}</slot>
+                        <f-repeat value="{{child in item.children}}">
+                            <button @click="{handleChild($e, $c, child.id)}">{{child.label}}</button>
+                        </f-repeat>
+                    </f-when>
+                </article>
+            </f-repeat>
+        </section>
+    </template>
+</f-template>
diff --git a/packages/fast-build/test/fixtures/convert/validation/invalid-repeat/fast-convert.config.json b/packages/fast-build/test/fixtures/convert/validation/invalid-repeat/fast-convert.config.json
new file mode 100644
index 00000000000..73f61743f50
--- /dev/null
+++ b/packages/fast-build/test/fixtures/convert/validation/invalid-repeat/fast-convert.config.json
@@ -0,0 +1,6 @@
+{
+    "syntax": "webui-prerelease",
+    "template": "template.html",
+    "output": "../../../../.fixture-output/validation/invalid-repeat.html",
+    "overwrite": false
+}
diff --git a/packages/fast-build/test/fixtures/convert/validation/invalid-repeat/template.html b/packages/fast-build/test/fixtures/convert/validation/invalid-repeat/template.html
new file mode 100644
index 00000000000..92e0e9a06be
--- /dev/null
+++ b/packages/fast-build/test/fixtures/convert/validation/invalid-repeat/template.html
@@ -0,0 +1,5 @@
+<f-template name="invalid-repeat">
+    <template>
+        <f-repeat value="{{items}}"><span>{{item}}</span></f-repeat>
+    </template>
+</f-template>
diff --git a/packages/fast-build/test/fixtures/convert/validation/missing-inner-template/fast-convert.config.json b/packages/fast-build/test/fixtures/convert/validation/missing-inner-template/fast-convert.config.json
new file mode 100644
index 00000000000..522ae35a1ab
--- /dev/null
+++ b/packages/fast-build/test/fixtures/convert/validation/missing-inner-template/fast-convert.config.json
@@ -0,0 +1,6 @@
+{
+    "syntax": "webui-prerelease",
+    "template": "template.html",
+    "output": "../../../../.fixture-output/validation/missing-inner-template.html",
+    "overwrite": false
+}
diff --git a/packages/fast-build/test/fixtures/convert/validation/missing-inner-template/template.html b/packages/fast-build/test/fixtures/convert/validation/missing-inner-template/template.html
new file mode 100644
index 00000000000..9035a464bf9
--- /dev/null
+++ b/packages/fast-build/test/fixtures/convert/validation/missing-inner-template/template.html
@@ -0,0 +1,3 @@
+<f-template name="missing-inner">
+    <span>No inner template</span>
+</f-template>
diff --git a/packages/fast-build/test/fixtures/convert/validation/unsupported-f-attribute/fast-convert.config.json b/packages/fast-build/test/fixtures/convert/validation/unsupported-f-attribute/fast-convert.config.json
new file mode 100644
index 00000000000..39e2bdb844d
--- /dev/null
+++ b/packages/fast-build/test/fixtures/convert/validation/unsupported-f-attribute/fast-convert.config.json
@@ -0,0 +1,6 @@
+{
+    "syntax": "fast-v3-ts",
+    "template": "template.html",
+    "output": "../../../../.fixture-output/validation/unsupported-f-attribute.ts",
+    "overwrite": false
+}
diff --git a/packages/fast-build/test/fixtures/convert/validation/unsupported-f-attribute/template.html b/packages/fast-build/test/fixtures/convert/validation/unsupported-f-attribute/template.html
new file mode 100644
index 00000000000..11d1968fd9b
--- /dev/null
+++ b/packages/fast-build/test/fixtures/convert/validation/unsupported-f-attribute/template.html
@@ -0,0 +1,5 @@
+<f-template name="unsupported-attribute">
+    <template>
+        <span f-unknown="value"></span>
+    </template>
+</f-template>
diff --git a/packages/fast-build/test/wasm-stub.cjs b/packages/fast-build/test/wasm-stub.cjs
index 73a6cade7bf..62d5cb7262f 100644
--- a/packages/fast-build/test/wasm-stub.cjs
+++ b/packages/fast-build/test/wasm-stub.cjs
@@ -3,11 +3,13 @@
 
 const fs = require("node:fs");
 const Module = require("node:module");
+const path = require("node:path");
 
 const wasmPath = process.env.FAST_BUILD_WASM_STUB_MODULE;
+const convertWasmPath = process.env.FAST_CONVERT_WASM_STUB_MODULE;
 const recordPath = process.env.FAST_BUILD_WASM_STUB_RECORD;
 
-if (!wasmPath || !recordPath) {
+if ((!wasmPath && !convertWasmPath) || !recordPath) {
     throw new Error("WASM stub requires module and record paths.");
 }
 
@@ -57,15 +59,49 @@ const stub = {
     },
 };
 
+const convertStub = {
+    convert_syntax_metadata() {
+        return JSON.stringify([
+            {
+                syntax: "webui-prerelease",
+                extension: ".html",
+                suffix: ".webui.html",
+            },
+            {
+                syntax: "fast-v3-ts",
+                extension: ".ts",
+                suffix: ".template.ts",
+            },
+        ]);
+    },
+    convert_template(template, syntax) {
+        calls.push({ name: "convert_template", template, syntax });
+        return `converted:${syntax}:${template}`;
+    },
+};
+
 process.on("exit", () => {
     fs.writeFileSync(recordPath, JSON.stringify(calls));
 });
 
 const originalLoad = Module._load;
 Module._load = function (request, parent, isMain) {
+    if (path.isAbsolute(request)) {
+        const resolvedRequest = path.resolve(request);
+        if (wasmPath && resolvedRequest === wasmPath) {
+            return stub;
+        }
+        if (convertWasmPath && resolvedRequest === convertWasmPath) {
+            return convertStub;
+        }
+    }
+
     const resolved = Module._resolveFilename(request, parent, isMain);
-    if (resolved === wasmPath) {
+    if (wasmPath && resolved === wasmPath) {
         return stub;
     }
+    if (convertWasmPath && resolved === convertWasmPath) {
+        return convertStub;
+    }
     return originalLoad.call(this, request, parent, isMain);
 };
diff --git a/packages/fast-build/wasm/.npmignore b/packages/fast-build/wasm/.npmignore
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/packages/fast-build/wasm/convert/.npmignore b/packages/fast-build/wasm/convert/.npmignore
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/packages/fast-element/docs/declarative/design.md b/packages/fast-element/docs/declarative/design.md
index 0cdf79b9721..4772cff5f36 100644
--- a/packages/fast-element/docs/declarative/design.md
+++ b/packages/fast-element/docs/declarative/design.md
@@ -756,15 +756,20 @@ A separate integration test suite validates that `@microsoft/webui` can build an
 
 1. **Build** (`npm run build:fixtures:webui`) — runs
    `scripts/declarative/build-fixtures-with-webui.js`, which extracts
-   `<f-template>` elements, builds each fixture with `webui build --plugin=fast`,
-   renders the protocol with `state.json`, and writes the output alongside
-   `main.ts` and assets to `temp/integrations/webui/fixtures/`.
+   `<f-template>` elements, converts each component template with
+   `fast convert --syntax=webui-prerelease`, builds each fixture with
+   `webui build --plugin=fast`, renders the protocol with `state.json`, and
+   writes the output alongside `main.ts` and assets to
+   `temp/integrations/webui/fixtures/`.
 2. **Test** (`npm run test:webui-integration`) — builds the fixtures, then runs
    the same Playwright specs against the webui-rendered output served by a Vite
    dev server on port 5174 (configured in
    `playwright.declarative.webui.config.ts`).
 
-Run locally with `npm run test:webui-integration` or via the `ci-webui-integration.yml` GitHub Action on PRs and pushes to `main`.
+Fixtures that intentionally contain invalid FAST declarative templates are skipped in
+the WebUI build because `fast convert` validates and rejects them before WebUI
+renders. Run locally with `npm run test:webui-integration` or via the
+`ci-webui-integration.yml` GitHub Action on PRs and pushes to `main`.
 
 #### Skipped tests
 
diff --git a/packages/fast-element/scripts/declarative/build-fixtures-with-webui.js b/packages/fast-element/scripts/declarative/build-fixtures-with-webui.js
index ca7f93ad412..2de3175c0ec 100644
--- a/packages/fast-element/scripts/declarative/build-fixtures-with-webui.js
+++ b/packages/fast-element/scripts/declarative/build-fixtures-with-webui.js
@@ -13,6 +13,7 @@
  *      tests can run against the webui-rendered output via Vite.
  */
 
+import { execFileSync } from "node:child_process";
 import {
     copyFileSync,
     existsSync,
@@ -22,19 +23,22 @@ import {
     rmSync,
     writeFileSync,
 } from "node:fs";
+import { createRequire } from "node:module";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { build, render } from "@microsoft/webui";
-import {
-    convertToWebuiSyntax,
-    discoverFixtures,
-    extractFTemplates,
-} from "./build-fixtures.utilities.js";
+import { discoverFixtures, extractFTemplates } from "./build-fixtures.utilities.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const fastBin = require.resolve("@microsoft/fast-build/bin/fast.js");
+const fastBuildWasm = require(
+    require.resolve("@microsoft/fast-build/wasm/microsoft_fast_build.js"),
+);
 const fixturesDir = resolve(__dirname, "../../test/declarative/fixtures");
 const fixtures = discoverFixtures(fixturesDir);
 const outBase = resolve(__dirname, "../../temp/integrations/webui/fixtures");
+const skippedFixtures = new Set(["ecosystem/errors"]);
 
 // Files produced by the build or only needed for the build step.
 const buildOnlyFiles = new Set([
@@ -51,21 +55,44 @@ const buildOnlyFiles = new Set([
  */
 function buildFixture(fixtureName) {
     const fixtureDir = join(fixturesDir, fixtureName);
+    if (skippedFixtures.has(fixtureName)) {
+        process.stdout.write(
+            `Fixture "${fixtureName}" skipped for WebUI integration because it intentionally contains invalid FAST templates.\n`,
+        );
+        return;
+    }
+
     const buildDir = join(outBase, ".build", fixtureName);
+    const convertDir = join(outBase, ".convert", fixtureName);
     const buildOutDir = join(buildDir, "out");
     const fixtureOutDir = join(outBase, fixtureName);
 
     mkdirSync(buildDir, { recursive: true });
+    mkdirSync(convertDir, { recursive: true });
     mkdirSync(buildOutDir, { recursive: true });
     mkdirSync(fixtureOutDir, { recursive: true });
 
     // Extract individual component HTML files for webui discovery,
-    // converting FAST directives to webui syntax.
+    // converting FAST declarative syntax to webui syntax with fast convert.
     const templatesHtml = readFileSync(join(fixtureDir, "templates.html"), "utf8");
     const templates = extractFTemplates(templatesHtml);
 
-    for (const { name, content } of templates) {
-        writeFileSync(join(buildDir, `${name}.html`), convertToWebuiSyntax(content));
+    for (const { name, source } of templates) {
+        const convertInput = join(convertDir, `${name}.html`);
+        const convertOutput = join(buildDir, `${name}.html`);
+        writeFileSync(convertInput, fastBuildWasm.escape_code_samples(source));
+        execFileSync(
+            process.execPath,
+            [
+                fastBin,
+                "convert",
+                "--syntax=webui-prerelease",
+                `--template=${convertInput}`,
+                `--output=${convertOutput}`,
+                "--overwrite",
+            ],
+            { stdio: "inherit" },
+        );
     }
 
     // Prepare entry.html without script tags for webui build
@@ -130,6 +157,10 @@ function main() {
     if (existsSync(buildTmp)) {
         rmSync(buildTmp, { recursive: true });
     }
+    const convertTmp = join(outBase, ".convert");
+    if (existsSync(convertTmp)) {
+        rmSync(convertTmp, { recursive: true });
+    }
 }
 
 main();
diff --git a/packages/fast-element/scripts/declarative/build-fixtures.utilities.js b/packages/fast-element/scripts/declarative/build-fixtures.utilities.js
index 9cd37aa2bbd..a716a687b37 100644
--- a/packages/fast-element/scripts/declarative/build-fixtures.utilities.js
+++ b/packages/fast-element/scripts/declarative/build-fixtures.utilities.js
@@ -46,12 +46,11 @@ export function discoverFixtures(fixturesDir) {
 
 /**
  * Extract `<f-template name="X">` elements from an HTML string.
- * Returns an array of `{ name, content }` objects where `content`
- * is the inner HTML of the `<template>` child. When the `<template>`
- * element carries host-binding attributes (e.g. `@click`, `?disabled`),
- * those are preserved by wrapping the content in a `<template>` tag.
+ * Returns an array of `{ name, content, source }` objects where `content`
+ * is the inner HTML of the `<template>` child and `source` is the full
+ * `<f-template>` element for conversion with `fast convert`.
  * @param {string} html - Raw HTML containing `<f-template>` elements.
- * @returns {{ name: string, content: string }[]}
+ * @returns {{ name: string, content: string, source: string }[]}
  */
 export function extractFTemplates(html) {
     const results = [];
@@ -62,40 +61,17 @@ export function extractFTemplates(html) {
         const name = match[1];
         const attrs = match[2].trim();
         const inner = match[3].trim();
+        const source = match[0];
 
         if (attrs.length > 0) {
             results.push({
                 name,
                 content: `<template ${attrs}>${inner}</template>`,
+                source,
             });
         } else {
-            results.push({ name, content: inner });
+            results.push({ name, content: inner, source });
         }
     }
     return results;
 }
-
-/**
- * Convert FAST template directives to webui syntax.
- *
- * - `<f-when value="{{expr}}">` → `<if condition="expr">`
- * - `</f-when>` → `</if>`
- * - `<f-repeat value="{{item in list}}" ...>` → `<for each="item in list" ...>`
- * - `</f-repeat>` → `</for>`
- *
- * @param {string} html - Template HTML using FAST directive syntax.
- * @returns {string} Template HTML using webui directive syntax.
- */
-export function convertToWebuiSyntax(html) {
-    return html
-        .replace(
-            /<f-when\s+value="{{([\s\S]*?)}}"\s*>/g,
-            (_, expr) => `<if condition="${expr.trim()}">`,
-        )
-        .replace(/<\/f-when>/g, "</if>")
-        .replace(
-            /<f-repeat\s+value="{{([\s\S]*?)}}"([^>]*)>/g,
-            (_, expr, rest) => `<for each="${expr.trim()}"${rest}>`,
-        )
-        .replace(/<\/f-repeat>/g, "</for>");
-}
diff --git a/packages/fast-element/test/declarative/fixtures/WRITING_FIXTURES.md b/packages/fast-element/test/declarative/fixtures/WRITING_FIXTURES.md
index ac9a02e93b7..fa09ce098da 100644
--- a/packages/fast-element/test/declarative/fixtures/WRITING_FIXTURES.md
+++ b/packages/fast-element/test/declarative/fixtures/WRITING_FIXTURES.md
@@ -316,7 +316,7 @@ npm run build:fixtures:webui -w @microsoft/fast-element
 npm exec -w @microsoft/fast-element -- playwright test --config=playwright.declarative.webui.config.ts
 ```
 
-The webui build step (`scripts/build-fixtures-with-webui.js`) extracts `<f-template>` elements, builds each fixture with `webui build --plugin=fast`, renders the output with `state.json`, and writes the result to `temp/integrations/webui/fixtures/`. The existing Playwright specs then run against this output.
+The webui build step (`scripts/build-fixtures-with-webui.js`) extracts `<f-template>` elements, converts each component template with `fast convert --syntax=webui-prerelease`, builds each fixture with `webui build --plugin=fast`, renders the output with `state.json`, and writes the result to `temp/integrations/webui/fixtures/`. Fixtures that intentionally contain invalid FAST declarative templates are skipped because `fast convert` validates and rejects them before WebUI renders. The existing Playwright specs then run against this output.
 
 ---
 
diff --git a/packages/fast-element/test/declarative/fixtures/bindings/host/host.spec.ts b/packages/fast-element/test/declarative/fixtures/bindings/host/host.spec.ts
index 04655a9d2f7..557e932ed40 100644
--- a/packages/fast-element/test/declarative/fixtures/bindings/host/host.spec.ts
+++ b/packages/fast-element/test/declarative/fixtures/bindings/host/host.spec.ts
@@ -379,6 +379,11 @@ test.describe("Host Bindings Hydration", async () => {
         test("host-autofocus has author-provided autofocus and template-provided tabindex", async ({
             page,
         }) => {
+            test.skip(
+                !!process.env.FAST_WEBUI_INTEGRATION,
+                "WebUI does not propagate static inner <template> attributes to the host output",
+            );
+
             const hydrationCompleted = page.waitForFunction(
                 () => (window as any).hydrationCompleted === true,
             );
diff --git a/packages/fast-element/test/declarative/fixtures/ecosystem/errors/errors.spec.ts b/packages/fast-element/test/declarative/fixtures/ecosystem/errors/errors.spec.ts
index c9f441ec7fc..8bc7729c470 100644
--- a/packages/fast-element/test/declarative/fixtures/ecosystem/errors/errors.spec.ts
+++ b/packages/fast-element/test/declarative/fixtures/ecosystem/errors/errors.spec.ts
@@ -1,6 +1,11 @@
 import { expect, test } from "@playwright/test";
 
 test.describe("f-template errors", () => {
+    test.skip(
+        !!process.env.FAST_WEBUI_INTEGRATION,
+        "fast convert rejects invalid <f-template> fixtures before WebUI build",
+    );
+
     test.beforeEach(async ({ page }) => {
         await page.addInitScript(() => {
             (window as any).__errors = [];
@@ -14,10 +19,6 @@ test.describe("f-template errors", () => {
     });
 
     test("throws an error when no template element is present", async ({ page }) => {
-        test.skip(
-            !!process.env.FAST_WEBUI_INTEGRATION,
-            "WebUI does not render <f-template> without <template> child (see WEBUI_ISSUES.md #3)",
-        );
         await page.goto("/fixtures/ecosystem/errors/");
 
         await expect
diff --git a/packages/fast-element/test/declarative/fixtures/ecosystem/hydration-config/hydration-config.spec.ts b/packages/fast-element/test/declarative/fixtures/ecosystem/hydration-config/hydration-config.spec.ts
index 2f396784c77..e127edaef8f 100644
--- a/packages/fast-element/test/declarative/fixtures/ecosystem/hydration-config/hydration-config.spec.ts
+++ b/packages/fast-element/test/declarative/fixtures/ecosystem/hydration-config/hydration-config.spec.ts
@@ -4,6 +4,11 @@ test.describe("Hydration configuration", () => {
     test("hydrates declarative shadow DOM appended after completion", async ({
         page,
     }) => {
+        test.skip(
+            !!process.env.FAST_WEBUI_INTEGRATION,
+            "WebUI-rendered late Declarative Shadow DOM does not preserve this hydration marker attribute",
+        );
+
         await page.goto("/fixtures/ecosystem/hydration-config/");
         await page.waitForFunction(() => (window as any).hydrationCompleted === true);