fix: emit hydration comments for bindings when state is missing (#71)

* fix: emit hydration comments for bindings when state is missing

Previously, process_signal and process_for_loop in webui-handler only
signal value or collection was found in state. If the value was missing,
the markers were silently skipped, leaving the client-side hydration
framework unable to locate and bind to those DOM positions.

This was inconsistent with process_if, which always emits markers
regardless of whether the condition references missing values.

The fix moves on_binding_start/on_binding_end calls outside the value
resolution check in process_signal, and replaces the early return in
process_for_loop with an empty Vec so markers are still written around
zero iterations.

Author: mohamedmansour

crates/webui-handler/src/lib.rs

@@ -299,19 +299,16 @@ impl WebUIHandler {
         let collection_name = &for_loop.collection;
 
         // If the collection is missing, treat it as empty (0 iterations) — matches NodeJS behavior.
-        let collection = match self.resolve_value(collection_name, context) {
-            Some(val) => val,
-            None => return Ok(()), // missing collection = no iterations
-        };
-
-        let items = match collection {
-            Value::Array(arr) => arr,
-            _ => {
+        // Hydration comments are always emitted regardless of collection presence.
+        let items = match self.resolve_value(collection_name, context) {
+            Some(Value::Array(arr)) => arr,
+            Some(_) => {
                 return Err(HandlerError::TypeError(format!(
                     "Collection '{}' is not an array",
                     collection_name
                 )))
             }
+            None => Vec::new(),
         };
 
         if let Some(p) = &mut self.plugin {
@@ -353,17 +350,17 @@ impl WebUIHandler {
         signal: &webui_protocol::WebUIFragmentSignal,
         context: &mut WebUIProcessContext,
     ) -> Result<()> {
-        if let Some(value) = self.resolve_value(&signal.value, context) {
-            if let Some(p) = &mut self.plugin {
-                p.on_binding_start(&signal.value, context.writer)?;
-            }
+        if let Some(p) = &mut self.plugin {
+            p.on_binding_start(&signal.value, context.writer)?;
+        }
 
+        if let Some(value) = self.resolve_value(&signal.value, context) {
             let content = self.format_signal_value(&value, signal.raw)?;
             context.writer.write(&content)?;
+        }
 
-            if let Some(p) = &mut self.plugin {
-                p.on_binding_end(&signal.value, context.writer)?;
-            }
+        if let Some(p) = &mut self.plugin {
+            p.on_binding_end(&signal.value, context.writer)?;
         }
         Ok(())
     }

crates/webui-handler/src/plugin/fast.rs

@@ -809,4 +809,151 @@ mod tests {
 
         assert_eq!(output, expected);
     }
+
+    #[test]
+    fn test_hydration_missing_signal_still_emits_markers() {
+        let mut fragments = HashMap::new();
+        fragments.insert(
+            "index.html".to_string(),
+            FragmentList {
+                fragments: vec![WebUIFragment::component("my-comp")],
+            },
+        );
+        fragments.insert(
+            "my-comp".to_string(),
+            FragmentList {
+                fragments: vec![
+                    WebUIFragment::raw("<p>"),
+                    WebUIFragment::signal("missing_field", false),
+                    WebUIFragment::raw("</p>"),
+                ],
+            },
+        );
+        let protocol = WebUIProtocol { fragments };
+        let state = test_json!({});
+        let output = render_with_plugin(&protocol, &state, Box::new(FastHydrationPlugin::new()));
+        // Hydration comments must be emitted even when signal is not found in state
+        assert!(
+            output.contains("<!--fe-b$$start$$0$$missing_field$$fe-b-->"),
+            "Expected binding start marker for missing signal, got: {output}"
+        );
+        assert!(
+            output.contains("<!--fe-b$$end$$0$$missing_field$$fe-b-->"),
+            "Expected binding end marker for missing signal, got: {output}"
+        );
+        // Start and end markers should be adjacent (no content between them)
+        assert!(output.contains(
+            "<!--fe-b$$start$$0$$missing_field$$fe-b--><!--fe-b$$end$$0$$missing_field$$fe-b-->"
+        ));
+    }
+
+    #[test]
+    fn test_hydration_missing_for_collection_still_emits_markers() {
+        let mut fragments = HashMap::new();
+        fragments.insert(
+            "index.html".to_string(),
+            FragmentList {
+                fragments: vec![WebUIFragment::component("my-comp")],
+            },
+        );
+        fragments.insert(
+            "my-comp".to_string(),
+            FragmentList {
+                fragments: vec![
+                    WebUIFragment::raw("<ul>"),
+                    WebUIFragment::for_loop("item", "missing_items", "loop-body"),
+                    WebUIFragment::raw("</ul>"),
+                ],
+            },
+        );
+        fragments.insert(
+            "loop-body".to_string(),
+            FragmentList {
+                fragments: vec![WebUIFragment::signal("item", false)],
+            },
+        );
+        let protocol = WebUIProtocol { fragments };
+        let state = test_json!({});
+        let output = render_with_plugin(&protocol, &state, Box::new(FastHydrationPlugin::new()));
+        // Hydration comments must be emitted even when collection is missing from state
+        assert!(
+            output.contains("<!--fe-b$$start$$0$$loop-body$$fe-b-->"),
+            "Expected binding start marker for missing collection, got: {output}"
+        );
+        assert!(
+            output.contains("<!--fe-b$$end$$0$$loop-body$$fe-b-->"),
+            "Expected binding end marker for missing collection, got: {output}"
+        );
+    }
+
+    #[test]
+    fn test_hydration_empty_string_signal_still_emits_markers() {
+        let mut fragments = HashMap::new();
+        fragments.insert(
+            "index.html".to_string(),
+            FragmentList {
+                fragments: vec![WebUIFragment::component("my-comp")],
+            },
+        );
+        fragments.insert(
+            "my-comp".to_string(),
+            FragmentList {
+                fragments: vec![
+                    WebUIFragment::raw("<p>"),
+                    WebUIFragment::signal("name", false),
+                    WebUIFragment::raw("</p>"),
+                ],
+            },
+        );
+        let protocol = WebUIProtocol { fragments };
+        let state = test_json!({"name": ""});
+        let output = render_with_plugin(&protocol, &state, Box::new(FastHydrationPlugin::new()));
+        assert!(
+            output.contains("<!--fe-b$$start$$0$$name$$fe-b-->"),
+            "Expected binding start marker for empty string signal, got: {output}"
+        );
+        assert!(
+            output.contains("<!--fe-b$$end$$0$$name$$fe-b-->"),
+            "Expected binding end marker for empty string signal, got: {output}"
+        );
+        assert!(output.contains("<!--fe-b$$start$$0$$name$$fe-b--><!--fe-b$$end$$0$$name$$fe-b-->"));
+    }
+
+    #[test]
+    fn test_hydration_empty_collection_still_emits_markers() {
+        let mut fragments = HashMap::new();
+        fragments.insert(
+            "index.html".to_string(),
+            FragmentList {
+                fragments: vec![WebUIFragment::component("my-comp")],
+            },
+        );
+        fragments.insert(
+            "my-comp".to_string(),
+            FragmentList {
+                fragments: vec![
+                    WebUIFragment::raw("<ul>"),
+                    WebUIFragment::for_loop("item", "items", "loop-body"),
+                    WebUIFragment::raw("</ul>"),
+                ],
+            },
+        );
+        fragments.insert(
+            "loop-body".to_string(),
+            FragmentList {
+                fragments: vec![WebUIFragment::signal("item", false)],
+            },
+        );
+        let protocol = WebUIProtocol { fragments };
+        let state = test_json!({"items": []});
+        let output = render_with_plugin(&protocol, &state, Box::new(FastHydrationPlugin::new()));
+        assert!(
+            output.contains("<!--fe-b$$start$$0$$loop-body$$fe-b-->"),
+            "Expected binding start marker for empty collection, got: {output}"
+        );
+        assert!(
+            output.contains("<!--fe-b$$end$$0$$loop-body$$fe-b-->"),
+            "Expected binding end marker for empty collection, got: {output}"
+        );
+    }
 }