Address fast-build PR feedback

Preserve static attribute raw values, keep omitted-state behavior explicit, and use entry-template WASM rendering in the CLI.

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

Author: janechu

change/@microsoft-fast-build-9d7b843d-87a6-4f82-9db2-039234d8ad6e.json

@@ -1,6 +1,6 @@
 {
-  "type": "minor",
-  "comment": "feat: allow fast-build rendering without state and omit missing bound attributes",
+  "type": "major",
+  "comment": "breaking: allow fast-build rendering without state; omitted CLI state no longer probes state.json",
   "packageName": "@microsoft/fast-build",
   "email": "7559015+janechu@users.noreply.github.com",
   "dependentChangeType": "none"

crates/microsoft-fast-build/DESIGN.md

@@ -54,7 +54,7 @@ render_template(template, state_str)
 | `json.rs` | Hand-rolled JSON parser producing `JsonValue` |
 | `locator.rs` | `Locator` struct — maps element names to template strings; glob scanner; `<f-template>` parser |
 | `error.rs` | `RenderError` enum with `Display` impl and helpers |
-| `wasm.rs` | WASM bindings (`#[cfg(target_arch = "wasm32")]`) — exposes `render`, `render_with_templates`, and `parse_f_templates` to JavaScript |
+| `wasm.rs` | WASM bindings (`#[cfg(target_arch = "wasm32")]`) — exposes `render`, `render_with_templates`, `render_entry_with_templates`, and `parse_f_templates` to JavaScript |
 
 ---
 
@@ -302,9 +302,10 @@ All render functions accept `config: Option<&RenderConfig>` as their last parame
 - `render_entry_template_with_locator(template, state_str, locator, config)`
 - `render_entry_template_with_locator_without_state(template, locator, config)`
 
-The `*_without_state` APIs render with an empty object root state. In WASM, the state parameter is optional for `render` and `render_with_templates`; omitted state also uses an empty object. `render_with_templates` accepts an `attribute_name_strategy` string parameter (`""`, `"none"`, or `"camelCase"`):
+The `*_without_state` APIs render with an empty object root state. In WASM, the state parameter is optional for `render`, `render_with_templates`, and `render_entry_with_templates`; omitted state also uses an empty object. The template-rendering WASM exports accept an `attribute_name_strategy` string parameter (`""`, `"none"`, or `"camelCase"`):
 
 - `render_with_templates(entry, templates_json, state?, attribute_name_strategy?)`
+- `render_entry_with_templates(entry, templates_json, state?, attribute_name_strategy?)`
 
 ---
 
@@ -461,12 +462,13 @@ Hand-rolled in `glob_match` → `match_segments` → `match_segment` → `match_
 
 ## WASM bindings — `wasm.rs`
 
-`wasm.rs` is compiled only for the `wasm32-unknown-unknown` target (`#[cfg(target_arch = "wasm32")]`). It exposes three functions to JavaScript via `wasm-bindgen`:
+`wasm.rs` is compiled only for the `wasm32-unknown-unknown` target (`#[cfg(target_arch = "wasm32")]`). It exposes four functions to JavaScript via `wasm-bindgen`:
 
 | Export | Signature | Description |
 |--------|-----------|-------------|
 | `render` | `(entry: &str, state?: string) → String` | Render a template with no custom elements; omitted state is `{}` |
-| `render_with_templates` | `(entry: &str, templates_json: &str, state?: string, attribute_name_strategy?: string) → String` | Render top-level entry HTML with a pre-built `{name: content}` templates map; omitted state is `{}` |
+| `render_with_templates` | `(entry: &str, templates_json: &str, state?: string, attribute_name_strategy?: string) → String` | Render a template with a pre-built `{name: content}` templates map using non-entry semantics; omitted state is `{}` |
+| `render_entry_with_templates` | `(entry: &str, templates_json: &str, state?: string, attribute_name_strategy?: string) → String` | Render top-level entry HTML with a pre-built `{name: content}` templates map; omitted state is `{}` |
 | `parse_f_templates` | `(html: &str) → String` | Parse `<f-template>` elements and return a JSON array |
 
 ### `parse_f_templates`
@@ -484,7 +486,11 @@ Calls `locator::parse_f_templates` (the same function used by `Locator::from_pat
 
 ### `render_with_templates`
 
-Accepts `templates_json` as a JSON object string mapping element names to raw template strings (the inner content already extracted from `<template>`). Constructs a `Locator::from_templates` map and calls `render_entry_template_with_locator` when state is provided, or the no-state equivalent when it is omitted. Root-level custom elements therefore receive the full root state with HTML attributes overlaid, matching CLI entry rendering.
+Accepts `templates_json` as a JSON object string mapping element names to raw template strings (the inner content already extracted from `<template>`). Constructs a `Locator::from_templates` map and calls `render_template_with_locator` when state is provided, or the no-state equivalent when it is omitted. This preserves the original non-entry semantics for existing JS consumers.
+
+### `render_entry_with_templates`
+
+Accepts the same arguments as `render_with_templates`, but calls `render_entry_template_with_locator` when state is provided, or the no-state equivalent when it is omitted. Root-level custom elements therefore receive entry opening-tag handling, matching CLI entry rendering.
 
 ---
 

crates/microsoft-fast-build/README.md

@@ -510,14 +510,16 @@ let result = render_template_with_locator(
 #### WASM / JavaScript API
 
 ```javascript
-const html = render_with_templates(
+const html = render_entry_with_templates(
     entry,
     templatesJson,
     stateJson,
     "camelCase"  // or "none"
 );
 ```
 
+Use `render_with_templates` for the original non-entry template-rendering semantics; use `render_entry_with_templates` for top-level entry HTML rendering.
+
 Passing `"none"` or `""` as the strategy uses the default behaviour.
 
 ---

crates/microsoft-fast-build/src/attribute.rs

@@ -274,9 +274,10 @@ pub(crate) fn resolve_attribute_bindings_in_tag(
     result.push('<');
     result.push_str(&tag_name);
 
-    for (name, value) in parse_element_attributes(tag) {
+    for attr in parse_element_attribute_parts(tag) {
+        let name = attr.name;
         if name.starts_with('?') {
-            if let Some(v) = value {
+            if let Some(v) = attr.value {
                 let trimmed = v.trim();
                 if trimmed.starts_with("{{") && trimmed.ends_with("}}") && trimmed.len() > 4 {
                     let expr = trimmed[2..trimmed.len() - 2].trim();
@@ -289,18 +290,19 @@ pub(crate) fn resolve_attribute_bindings_in_tag(
             continue;
         }
 
-        match value {
+        match attr.value {
             None => {
                 result.push(' ');
-                result.push_str(&name);
+                result.push_str(&attr.raw);
             }
             Some(v) if v.contains("{{") => {
                 if let Some(resolved) = resolve_attribute_value(&v, root, loop_vars) {
-                    result.push_str(&format!(" {}=\"{}\"", name, resolved));
+                    append_quoted_attribute(&mut result, &name, &resolved);
                 }
             }
-            Some(v) => {
-                result.push_str(&format!(" {}=\"{}\"", name, v));
+            Some(_) => {
+                result.push(' ');
+                result.push_str(&attr.raw);
             }
         }
     }
@@ -314,6 +316,23 @@ pub(crate) fn resolve_attribute_bindings_in_tag(
     result
 }
 
+pub(crate) fn append_quoted_attribute(out: &mut String, name: &str, value: &str) {
+    out.push(' ');
+    out.push_str(name);
+    out.push_str("=\"");
+    append_double_quote_escaped(out, value);
+    out.push('"');
+}
+
+fn append_double_quote_escaped(out: &mut String, value: &str) {
+    for ch in value.chars() {
+        match ch {
+            '"' => out.push_str("&quot;"),
+            _ => out.push(ch),
+        }
+    }
+}
+
 fn resolve_attribute_value(
     value: &str,
     root: &crate::json::JsonValue,
@@ -368,18 +387,18 @@ pub(crate) fn strip_client_only_attrs(tag: &str) -> String {
     };
 
     let mut out = format!("<{}", tag_name);
-    for (name, value) in parse_element_attributes(tag) {
-        if name.starts_with('@') || name.starts_with(':')
+    for attr in parse_element_attribute_parts(tag) {
+        let name = attr.name;
+        if name.starts_with('@')
+            || name.starts_with(':')
             || name.eq_ignore_ascii_case("f-ref")
             || name.eq_ignore_ascii_case("f-slotted")
             || name.eq_ignore_ascii_case("f-children")
         {
             continue;
         }
-        match value {
-            None => { out.push(' '); out.push_str(&name); }
-            Some(v) => out.push_str(&format!(" {}=\"{}\"", name, v)),
-        }
+        out.push(' ');
+        out.push_str(&attr.raw);
     }
 
     if is_self_closing {
@@ -448,6 +467,19 @@ fn is_skippable_tag(name: &str, locator: Option<&crate::locator::Locator>) -> bo
 /// Returns `(attribute_name, Option<value>)` — `None` value means boolean attribute.
 /// Handles double-quoted, single-quoted, and unquoted values.
 pub(crate) fn parse_element_attributes(open_tag: &str) -> Vec<(String, Option<String>)> {
+    parse_element_attribute_parts(open_tag)
+        .into_iter()
+        .map(|attr| (attr.name, attr.value))
+        .collect()
+}
+
+pub(crate) struct ParsedAttribute {
+    pub name: String,
+    pub value: Option<String>,
+    pub raw: String,
+}
+
+pub(crate) fn parse_element_attribute_parts(open_tag: &str) -> Vec<ParsedAttribute> {
     let mut attrs = Vec::new();
     let bytes = open_tag.as_bytes();
     let mut i = 0;
@@ -482,6 +514,7 @@ pub(crate) fn parse_element_attributes(open_tag: &str) -> Vec<(String, Option<St
         {
             i += 1;
         }
+        let name_end = i;
         let name = open_tag[name_start..i].to_string();
 
         if name.is_empty() {
@@ -497,7 +530,11 @@ pub(crate) fn parse_element_attributes(open_tag: &str) -> Vec<(String, Option<St
 
         if i >= bytes.len() || bytes[i] != b'=' {
             // Boolean attribute — no value.
-            attrs.push((name, None));
+            attrs.push(ParsedAttribute {
+                name,
+                value: None,
+                raw: open_tag[name_start..name_end].to_string(),
+            });
             continue;
         }
 
@@ -513,7 +550,11 @@ pub(crate) fn parse_element_attributes(open_tag: &str) -> Vec<(String, Option<St
         let (value, new_i) = parse_attribute_value(open_tag, bytes, i);
         i = new_i;
 
-        attrs.push((name, Some(value)));
+        attrs.push(ParsedAttribute {
+            name,
+            value: Some(value),
+            raw: open_tag[name_start..i].to_string(),
+        });
     }
 
     attrs
@@ -532,7 +573,7 @@ fn parse_attribute_value(open_tag: &str, bytes: &[u8], i: usize) -> (String, usi
     } else {
         let start = i;
         let mut end = i;
-        while end < bytes.len() && !bytes[end].is_ascii_whitespace() && bytes[end] != b'>' && bytes[end] != b'/' {
+        while end < bytes.len() && !bytes[end].is_ascii_whitespace() && bytes[end] != b'>' {
             end += 1;
         }
         (open_tag[start..end].to_string(), end)

crates/microsoft-fast-build/src/wasm.rs

@@ -1,10 +1,11 @@
-use wasm_bindgen::prelude::*;
-use std::collections::HashMap;
+use crate::config::{AttributeNameStrategy, RenderConfig};
 use crate::{
-    json, Locator, render_entry_template_with_locator, render_entry_with_locator_without_state,
-    render_template, render_template_without_state,
+    json, render_entry_template_with_locator, render_entry_template_with_locator_without_state,
+    render_template, render_template_with_locator, render_template_with_locator_without_state,
+    render_template_without_state, Locator,
 };
-use crate::config::{RenderConfig, AttributeNameStrategy};
+use std::collections::HashMap;
+use wasm_bindgen::prelude::*;
 
 /// Render a FAST HTML template with an optional JSON state string.
 /// Omitted state is treated as an empty object.
@@ -18,6 +19,34 @@ pub fn render(entry: &str, state: Option<String>) -> Result<String, JsValue> {
     .map_err(|e| JsValue::from_str(&e.to_string()))
 }
 
+/// Render a FAST HTML template with custom element templates and an optional JSON state string.
+/// Omitted state is treated as an empty object.
+///
+/// This preserves the original non-entry rendering semantics for this export.
+/// Use `render_entry_with_templates` for top-level entry HTML rendering.
+///
+/// `templates_json` is a JSON object mapping element names to their HTML template strings,
+/// e.g. `{"my-button": "<template>...</template>"}`.
+/// `attribute_name_strategy` controls attribute-to-property mapping: `"camelCase"` (default)
+/// or `"none"`. Pass an empty string for the default.
+/// Returns the rendered HTML or throws a JavaScript error.
+#[wasm_bindgen]
+pub fn render_with_templates(
+    entry: &str,
+    templates_json: &str,
+    state: Option<String>,
+    attribute_name_strategy: Option<String>,
+) -> Result<String, JsValue> {
+    let templates = parse_templates_map(templates_json)?;
+    let locator = Locator::from_templates(templates);
+    let config = build_config(attribute_name_strategy.as_deref())?;
+    match state {
+        Some(state) => render_template_with_locator(entry, &state, &locator, config.as_ref()),
+        None => render_template_with_locator_without_state(entry, &locator, config.as_ref()),
+    }
+    .map_err(|e| JsValue::from_str(&e.to_string()))
+}
+
 /// Render the top-level **entry HTML** with custom element templates and an optional JSON state string.
 /// Omitted state is treated as an empty object.
 /// Custom elements found at the root level of `entry` build child state from the full root
@@ -31,13 +60,18 @@ pub fn render(entry: &str, state: Option<String>) -> Result<String, JsValue> {
 /// or `"none"`. Pass an empty string for the default.
 /// Returns the rendered HTML or throws a JavaScript error.
 #[wasm_bindgen]
-pub fn render_with_templates(entry: &str, templates_json: &str, state: Option<String>, attribute_name_strategy: Option<String>) -> Result<String, JsValue> {
+pub fn render_entry_with_templates(
+    entry: &str,
+    templates_json: &str,
+    state: Option<String>,
+    attribute_name_strategy: Option<String>,
+) -> Result<String, JsValue> {
     let templates = parse_templates_map(templates_json)?;
     let locator = Locator::from_templates(templates);
     let config = build_config(attribute_name_strategy.as_deref())?;
     match state {
         Some(state) => render_entry_template_with_locator(entry, &state, &locator, config.as_ref()),
-        None => render_entry_with_locator_without_state(entry, &locator, config.as_ref()),
+        None => render_entry_template_with_locator_without_state(entry, &locator, config.as_ref()),
     }
     .map_err(|e| JsValue::from_str(&e.to_string()))
 }
@@ -68,29 +102,35 @@ fn escape_json_str(s: &str) -> String {
     let mut out = String::with_capacity(s.len());
     for c in s.chars() {
         match c {
-            '"'  => out.push_str("\\\""),
+            '"' => out.push_str("\\\""),
             '\\' => out.push_str("\\\\"),
             '\n' => out.push_str("\\n"),
             '\r' => out.push_str("\\r"),
             '\t' => out.push_str("\\t"),
-            c    => out.push(c),
+            c => out.push(c),
         }
     }
     out
 }
 
 fn parse_templates_map(templates_json: &str) -> Result<HashMap<String, String>, JsValue> {
-    let parsed = json::parse(templates_json)
-        .map_err(|e| JsValue::from_str(&format!("Failed to parse templates JSON: {}", e.message)))?;
+    let parsed = json::parse(templates_json).map_err(|e| {
+        JsValue::from_str(&format!("Failed to parse templates JSON: {}", e.message))
+    })?;
     match parsed {
         json::JsonValue::Object(obj) => {
             let mut map = HashMap::new();
             for (k, v) in obj {
                 match v {
-                    json::JsonValue::String(s) => { map.insert(k, s); }
-                    _ => return Err(JsValue::from_str(&format!(
-                        "Template value for '{}' must be a string", k
-                    ))),
+                    json::JsonValue::String(s) => {
+                        map.insert(k, s);
+                    }
+                    _ => {
+                        return Err(JsValue::from_str(&format!(
+                            "Template value for '{}' must be a string",
+                            k
+                        )))
+                    }
                 }
             }
             Ok(map)

crates/microsoft-fast-build/tests/edge_cases.rs

@@ -56,6 +56,40 @@ fn test_missing_regular_html_attribute_binding_is_omitted() {
     assert_eq!(result, "<div></div>");
 }
 
+#[test]
+fn test_missing_regular_html_attribute_preserves_static_value_with_quotes() {
+    let result = ok(r#"<div title='a "quote"' class="{{missing}}"></div>"#, "{}");
+    assert_eq!(result, r#"<div title='a "quote"'></div>"#);
+}
+
+#[test]
+fn test_unquoted_attribute_path_does_not_hide_later_binding() {
+    let result = ok(
+        r#"<img src=/assets/a.png alt="{{alt}}">"#,
+        r#"{"alt": "Logo"}"#,
+    );
+    assert_eq!(result, r#"<img src=/assets/a.png alt="Logo">"#);
+}
+
+#[test]
+fn test_bound_attribute_value_is_html_escaped() {
+    let result = ok(
+        r#"<div title="{{value}}"></div>"#,
+        r#"{"value": "a \"quote\" & <tag>"}"#,
+    );
+    assert_eq!(result, r#"<div title="a &quot;quote&quot; &amp; &lt;tag&gt;"></div>"#);
+}
+
+#[test]
+fn test_unquoted_attribute_path_with_missing_later_binding_is_omitted() {
+    let result = ok(r#"<img src=/assets/a.png alt="{{alt}}">"#, "{}");
+    assert_eq!(result, r#"<img src=/assets/a.png>"#);
+    assert!(
+        !result.contains("{{alt}}"),
+        "binding must not remain unresolved: {result}"
+    );
+}
+
 #[test]
 fn test_missing_dot_path_regular_html_attribute_with_empty_state_is_omitted() {
     let result = ok(r#"<div class="{{ foo.bar }}"></div>"#, "{}");