fix: scope repeat hydration scan and add test cases

- Bound repeat hydration scan to this directive's content binding
  boundaries (via bindingViewBoundaries) to prevent scanning into
  sibling repeat blocks
- Fix comment on empty-item handling to match actual implementation
  full diagnostic property bag
- Add Rust tests: single-item repeat, many-item repeat (count-based
  assertions), and multiple attribute bindings on one element

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

Author: janechu

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

@@ -383,6 +383,92 @@ fn test_hydration_f_repeat_empty() {
     );
 }
 
+/// f-repeat with a single item: exactly one start/end pair.
+#[test]
+fn test_hydration_f_repeat_single_item() {
+    let locator = make_locator(&[(
+        "test-element",
+        "<ul><f-repeat value=\"{{item in list}}\"><li>{{item}}</li></f-repeat></ul>",
+    )]);
+    let root = hand_root(vec![(
+        "list",
+        arr_val(vec![str_val("Only")]),
+    )]);
+    let result = render_with_locator(
+        r#"<test-element list="{{list}}"></test-element>"#,
+        &root,
+        &locator,
+        None,
+    ).unwrap();
+
+    assert_eq!(
+        result.matches("<!--fe:r-->").count(),
+        1,
+        "expected one item start marker: {result}"
+    );
+    assert_eq!(
+        result.matches("<!--fe:/r-->").count(),
+        1,
+        "expected one item end marker: {result}"
+    );
+    assert!(result.contains("<!--fe:b-->Only<!--fe:/b-->"),
+        "item binding: {result}");
+}
+
+/// f-repeat with many items: marker counts match item count.
+#[test]
+fn test_hydration_f_repeat_many_items() {
+    let locator = make_locator(&[(
+        "test-element",
+        "<f-repeat value=\"{{item in list}}\"><span>{{item}}</span></f-repeat>",
+    )]);
+    let items: Vec<_> = (0..5).map(|i| str_val(&format!("Item{i}"))).collect();
+    let root = hand_root(vec![("list", arr_val(items))]);
+    let result = render_with_locator(
+        r#"<test-element list="{{list}}"></test-element>"#,
+        &root,
+        &locator,
+        None,
+    ).unwrap();
+
+    assert_eq!(
+        result.matches("<!--fe:r-->").count(),
+        5,
+        "expected five item start markers: {result}"
+    );
+    assert_eq!(
+        result.matches("<!--fe:/r-->").count(),
+        5,
+        "expected five item end markers: {result}"
+    );
+    for i in 0..5 {
+        assert!(result.contains(&format!("<!--fe:b-->Item{i}<!--fe:/b-->")),
+            "item {i} binding: {result}");
+    }
+}
+
+/// Multiple attribute bindings on one element: data-fe count reflects total.
+#[test]
+fn test_hydration_multiple_attr_bindings() {
+    let locator = make_locator(&[(
+        "test-element",
+        r#"<div class="{{cls}}" id="{{id}}" title="{{tip}}">text</div>"#,
+    )]);
+    let root = hand_root(vec![
+        ("cls", str_val("foo")),
+        ("id", str_val("bar")),
+        ("tip", str_val("baz")),
+    ]);
+    let result = render_with_locator(
+        r#"<test-element cls="{{cls}}" id="{{id}}" tip="{{tip}}"></test-element>"#,
+        &root,
+        &locator,
+        None,
+    ).unwrap();
+
+    assert!(result.contains(r#"data-fe="3""#), "three bindings: {result}");
+}
+
 // ── f-ref / f-slotted (single-brace directive attrs) ─────────────────────────
 
 /// `f-ref="{video}"` — single-brace attribute directive gets a compact marker

packages/fast-element/src/templating/repeat.ts

@@ -412,10 +412,18 @@ export class RepeatBehavior<TSource = any> implements ViewBehavior, Subscriber {
             serializer ?? (serializer = new XMLSerializer());
         this.views = new Array(itemCount);
 
+        // Determine the scan boundary for this repeat directive.
+        // Use the content binding boundaries (from the parent's fe:b/fe:/b
+        // markers) to avoid scanning into sibling repeat blocks.
+        const boundaries =
+            isHydratable(this.controller) &&
+            this.controller.bindingViewBoundaries[this.directive.targetNodeId];
+        const scanStop: Node | null = boundaries ? boundaries.first : null;
+
         let current = this.location.previousSibling;
         let itemIndex = itemCount - 1; // items render in order; walk backward
 
-        while (current !== null && itemIndex >= 0) {
+        while (current !== null && current !== scanStop && itemIndex >= 0) {
             if (!isCommentNode(current) || current.data !== "fe:/r") {
                 current = current.previousSibling;
                 continue;
@@ -425,17 +433,26 @@ export class RepeatBehavior<TSource = any> implements ViewBehavior, Subscriber {
             current.data = "";
             const end = current.previousSibling;
             if (!end) {
-                throw new Error(
+                throw new HydrationRepeatError(
                     `Error when hydrating inside "${
                         (this.location.getRootNode() as ShadowRoot).host.nodeName
                     }": end should never be null.`,
+                    {
+                        index: itemIndex,
+                        hydrationStage: "hydrateViews",
+                        itemsLength: itemCount,
+                        viewsState: this.views.map(v => (v ? "hydrated" : "empty")),
+                        rootNodeContent: getSerializer().serializeToString(
+                            this.location.getRootNode() as any,
+                        ),
+                    },
                 );
             }
 
             // Find matching start marker via balanced counting
             let start: Node | null = end;
             let depth = 0;
-            while (start !== null) {
+            while (start !== null && start !== scanStop) {
                 if (isCommentNode(start)) {
                     if (start.data === "fe:/r") {
                         depth++;
@@ -446,12 +463,11 @@ export class RepeatBehavior<TSource = any> implements ViewBehavior, Subscriber {
                             current = startMarker.previousSibling;
                             const itemStart = startMarker.nextSibling!;
 
-                            // When the item is empty (start and end markers
-                            // are adjacent), itemStart IS the cleared end
-                            // marker and end IS the cleared start marker —
-                            // an inverted range. Detect this by checking if
-                            // end precedes itemStart in sibling order, and
-                            // use itemStart as both first and last.
+                            // Empty item: start and end markers are adjacent
+                            // with no content between them. end === startMarker
+                            // because previousSibling of the end marker IS the
+                            // start marker. Use the cleared end marker comment
+                            // as both first and last for a valid single-node range.
                             const itemEnd = end === startMarker ? itemStart : end;
 
                             const view = template.hydrate(itemStart, itemEnd);
@@ -465,7 +481,7 @@ export class RepeatBehavior<TSource = any> implements ViewBehavior, Subscriber {
                 }
                 start = start.previousSibling;
             }
-            if (!start) {
+            if (!start || start === scanStop) {
                 throw new HydrationRepeatError(
                     `Error when hydrating inside "${
                         (this.location.getRootNode() as ShadowRoot).host.nodeName
@@ -500,10 +516,11 @@ export class RepeatBehavior<TSource = any> implements ViewBehavior, Subscriber {
             );
         }
 
-        // Overflow check: detect extra repeat markers beyond items.length
-        if (current !== null) {
+        // Overflow check: detect extra repeat markers beyond items.length,
+        // bounded to this directive's scan range.
+        if (current !== null && current !== scanStop) {
             let remaining: Node | null = current;
-            while (remaining !== null) {
+            while (remaining !== null && remaining !== scanStop) {
                 if (isCommentNode(remaining) && remaining.data === "fe:/r") {
                     throw new HydrationRepeatError(
                         `Error when hydrating inside "${