Treat missing f-repeat lists as empty

Render zero iterations when an f-repeat list binding is absent while preserving errors for present non-array values. Update Rust and Node tests plus docs.

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

Author: janechu

crates/microsoft-fast-build/DESIGN.md

@@ -152,7 +152,7 @@ Both return `RenderError::EmptyBinding` for blank expressions and `RenderError::
 Callers decide how to handle unresolved values:
 - Content bindings (`{{expr}}` / `{{{expr}}}`) render an empty string.
 - HTML attribute bindings omit the entire attribute.
-- `<f-repeat>` still requires its list binding to resolve to an array; a missing list binding returns `RenderError::MissingState`.
+- `<f-repeat>` treats a missing list binding as an empty array and renders zero iterations; present non-array values return `RenderError::NotAnArray`.
 - `<f-when>` evaluates a missing binding as falsy.
 
 ### Loop variable scoping
@@ -198,7 +198,7 @@ Because `||` is sought before `&&`, the recursive split on `||` runs first. Each
 
 1. Extracts inner HTML and end position (same as `render_when`).
 2. Parses `value="{{item in items}}"` with `parse_repeat_expr` — expects exactly three whitespace-separated tokens where the middle is `"in"`.
-3. Resolves the list expression. Returns `RenderError::NotAnArray` if the value is not a `JsonValue::Array`.
+3. Resolves the list expression. Missing values are treated as an empty array. Present non-array values return `RenderError::NotAnArray`.
 4. For each item in the array, pushes `(var_name, item)` onto a new `loop_vars` vec and calls `render_node` on the inner template.
 5. Uses `Iterator::collect::<Result<String, _>>()` to short-circuit on the first error in any iteration.
 
@@ -557,6 +557,6 @@ A hand-rolled recursive-descent parser. No external crates.
 
 **Atomic tag processing for attribute bindings.** When a plain HTML opening tag in the literal region contains `{{expr}}` attribute values, those values are resolved and `data-fe-c` is injected into the tag as a whole before `next_directive` ever sees them. This prevents the `{{expr}}` inside attributes from being mistaken for content bindings. The cost is that `next_directive` is called once extra per tag iteration, but tags are short and rare enough that this has no meaningful performance impact.
 
-**`Result` throughout.** All render functions return `Result<_, RenderError>`. Errors propagate via `?` for malformed templates, invalid JSON, invalid repeat expressions, and missing/invalid required directive state. Missing optional values are handled by binding context: content bindings render empty output, attribute bindings omit the attribute, `<f-when>` treats the value as falsy, and `<f-repeat>` still errors when its list binding is missing or not an array.
+**`Result` throughout.** All render functions return `Result<_, RenderError>`. Errors propagate via `?` for malformed templates, invalid JSON, invalid repeat expressions, and invalid directive state. Missing optional values are handled by binding context: content bindings render empty output, attribute bindings omit the attribute, `<f-when>` treats the value as falsy, and `<f-repeat>` treats a missing list binding as an empty array while still erroring when a present value is not an array.
 
 **Left-to-right, first-match scanning.** Directives are found by searching for their literal opening strings. The earliest position wins. This is O(n×d) where n is the template length and d is the number of directive types — acceptable for the template sizes this crate targets.

crates/microsoft-fast-build/README.md

@@ -221,6 +221,7 @@ When `value` is a bare reference (e.g. `{{items}}`), the value is coerced to a b
 ```
 
 Inside `<f-repeat>`, `{{item}}` resolves to the current loop variable and `{{$index}}` resolves to the 0-based iteration index. Other bindings fall back to the root state (e.g. `{{title}}` above).
+If the list binding or dot path is missing, `<f-repeat>` treats it as an empty array and renders zero iterations. Present non-array values still return `RenderError::NotAnArray`.
 
 ```html
 <f-repeat value="{{row in rows}}">
@@ -594,7 +595,7 @@ All render functions return `Result<String, RenderError>`. `RenderError` is an e
 | `UnclosedBinding` | `{{` with no closing `}}` |
 | `UnclosedUnescapedBinding` | `{{{` with no closing `}}}` |
 | `EmptyBinding` | `{{}}` — blank expression |
-| `MissingState` | `<f-repeat>` list binding is absent from state |
+| `MissingState` | Required directive state is absent; missing `<f-repeat>` lists render zero iterations instead |
 | `UnclosedDirective` | `<f-when>` / `<f-repeat>` with no matching close tag |
 | `MissingValueAttribute` | Directive missing `value="{{…}}"` attribute |
 | `InvalidRepeatExpression` | Repeat value not in `item in list` format |
@@ -606,7 +607,7 @@ All render functions return `Result<String, RenderError>`. `RenderError` is an e
 Every error message includes a description of the problem and a snippet of the template near the error site to aid debugging:
 
 ```
-missing state: '{{items}}' has no matching key in the provided state — template: "…<f-repeat value=\"{{item in items}}\">…"
+type error: '{{items}}' must resolve to a JSON array for use in <f-repeat> — template: "…<f-repeat value=\"{{item in items}}\">…"
 unclosed binding '{{name': no closing '}}' found to end the expression — template: "Hello {{name"
 duplicate template: element '<my-button>' is defined in multiple files: ./a/my-button.html, ./b/my-button.html
 ```

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

@@ -143,10 +143,10 @@ pub fn render_repeat(
             context: template_context(template, at),
         })?;
     match resolve_value(&list_expr, root, loop_vars) {
-        None => Err(RenderError::MissingState {
-            binding: list_expr,
-            context: template_context(template, at),
-        }),
+        None => {
+            let output = render_repeat_items(&inner, &[], &var_name, root, loop_vars, locator, hydration, config)?;
+            Ok((output, after))
+        }
         Some(JsonValue::Array(items)) => {
             let output = render_repeat_items(&inner, &items, &var_name, root, loop_vars, locator, hydration, config)?;
             Ok((output, after))

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

@@ -195,11 +195,11 @@ fn test_error_repeat_not_an_array_bool() {
 }
 
 #[test]
-fn test_error_repeat_missing_state() {
-    let e = err(r#"<f-repeat value="{{item in missing}}">{{item}}</f-repeat>"#, r#"{}"#);
+fn test_error_repeat_not_an_array_null() {
+    let e = err(r#"<f-repeat value="{{item in items}}">{{item}}</f-repeat>"#, r#"{"items": null}"#);
     let msg = e.to_string();
-    assert!(matches!(e, RenderError::MissingState { .. }), "wrong variant: {msg}");
-    assert!(msg.contains("missing"), "should name the binding: {msg}");
+    assert!(matches!(e, RenderError::NotAnArray { .. }), "wrong variant: {msg}");
+    assert!(msg.contains("items"), "should name the binding: {msg}");
 }
 
 // ── JSON parse errors ─────────────────────────────────────────────────────────

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

@@ -1,5 +1,6 @@
 mod common;
 use common::ok;
+use microsoft_fast_build::render_template_without_state;
 
 #[test]
 fn test_f_repeat_basic() {
@@ -24,3 +25,30 @@ fn test_f_repeat_root_access() {
         "<span>Items: a</span><span>Items: b</span>",
     );
 }
+
+#[test]
+fn test_f_repeat_missing_list_renders_empty() {
+    assert_eq!(
+        ok(r#"before<f-repeat value="{{item in items}}"><span>{{item}}</span></f-repeat>after"#, r#"{}"#),
+        "beforeafter",
+    );
+}
+
+#[test]
+fn test_f_repeat_missing_dot_path_list_renders_empty() {
+    assert_eq!(
+        ok(r#"<f-repeat value="{{item in items.list}}"><span>{{item}}</span></f-repeat>"#, r#"{}"#),
+        "",
+    );
+}
+
+#[test]
+fn test_f_repeat_without_state_renders_empty() {
+    let result = render_template_without_state(
+        r#"<f-repeat value="{{item in items}}"><span>{{item}}</span></f-repeat>"#,
+        None,
+    )
+    .expect("render without state");
+
+    assert_eq!(result, "");
+}

packages/fast-build/README.md

@@ -89,7 +89,7 @@ When a binding value is not present in state:
 
 - Content bindings render nothing, including unresolved dot paths: `<p>{{foo.bar}}</p>` becomes `<p></p>`.
 - Attribute bindings omit the entire attribute, including unresolved dot paths: `<div class="{{foo.bar}}"></div>` becomes `<div></div>`.
-- `<f-repeat>` still requires its list binding to resolve to an array and errors when the list is missing or not an array.
+- `<f-repeat>` treats a missing list binding, including unresolved dot paths, as an empty array and renders zero iterations. If the binding is present but is not an array, rendering still errors.
 
 ### Custom element templates
 

packages/fast-build/test/config.test.js

@@ -230,6 +230,16 @@ describe("no state behavior", () => {
         assert.equal(output, "<h1></h1><div></div>");
     });
 
+    it("treats missing f-repeat lists as empty when state is omitted", () => {
+        fs.writeFileSync(
+            path.join(dir, "entry.html"),
+            '<ul><f-repeat value="{{item in items}}"><li>{{item}}</li></f-repeat></ul>',
+        );
+        run(["--entry=entry.html", "--output=out.html"], dir);
+        const output = fs.readFileSync(path.join(dir, "out.html"), "utf8");
+        assert.equal(output, "<ul></ul>");
+    });
+
     it("ignores state.json when state is omitted", () => {
         fs.writeFileSync(
             path.join(dir, "entry.html"),
@@ -329,6 +339,22 @@ describe("WASM optional state", () => {
         );
     });
 
+    it("render treats missing f-repeat lists as empty arrays", () => {
+        assert.equal(
+            WASM.render(
+                '<f-repeat value="{{item in items}}"><span>{{item}}</span></f-repeat>',
+            ),
+            "",
+        );
+        assert.equal(
+            WASM.render(
+                '<f-repeat value="{{item in items.list}}"><span>{{item}}</span></f-repeat>',
+                "{}",
+            ),
+            "",
+        );
+    });
+
     it("render_with_templates accepts omitted state", () => {
         const result = WASM.render_with_templates(
             "<test-element></test-element>",