fix(engine): close out the two pinned bugs from slices 1+2

1. Reactive class= binding (markup.py):
   - Passing a state proxy to classes= (or .classes(), or via the new
     class_name= React-style alias) now emits class="<current>" AND
     data-bind-class="<state.path>" at SSR — picked up by the existing
     ReactiveRegistry updater in client.py.
   - class_name= is honored as an alias because `class` is a Python keyword;
     it routes through the same reactive-binding path.
   - examples/reactivity.py:73 (b.div(class_name=UiState.theme, ...)) now
     does what its author intended.

2. Bundle generator handles nested defs (app.py):
   - _generate_bundle now textwrap.dedent()s the source returned by
     inspect.getsource() for both state classes and user functions, and
     filters decorator lines with .strip().startswith("@"). Nested
     @app.local / @app.client.* defs (factories, tests) now produce valid
     bundles.

Tests now positive on both behaviors; the two strict xfails are gone.
35 passed, 0 xfailed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: apiad

tests/test_engine.py

@@ -136,22 +136,9 @@ def home():
     compile(r.text, "<violetear-bundle>", "exec")
 
 
-@pytest.mark.xfail(
-    reason=(
-        "Bundle generator (_generate_bundle in app.py:632-634) filters decorator lines "
-        "with `c.startswith('@')` instead of `c.strip().startswith('@')`. When a client "
-        "function is defined nested inside another function, its source comes back "
-        "indented; the decorator line survives the filter and the bundle becomes invalid "
-        "Python. Also affects state classes (similar pattern at line 617 uses .strip() "
-        "for the decorator but still leaves class body indentation intact). Pinned as a "
-        "known limitation: real-world usage defines @app.client.* and @app.local at "
-        "module level, where this doesn't bite."
-    ),
-    strict=True,
-)
-def test_bundle_rejects_nested_defs():
-    """Pin the known limitation: the bundle generator only supports module-level
-    state classes and client functions; nested definitions produce invalid bundles."""
+def test_bundle_supports_nested_defs():
+    """Bundle generator dedents source so nested @app.local / @app.client defs
+    (e.g. inside factories or tests) produce valid Python."""
     app = App(title="Nested", version="t6")
 
     @app.local
@@ -169,22 +156,12 @@ def home():
 
     client = TestClient(app.api)
     r = client.get("/_violetear/bundle.py")
+    assert r.status_code == 200
     compile(r.text, "<violetear-bundle>", "exec")
 
 
-@pytest.mark.xfail(
-    reason=(
-        "examples/reactivity.py:73 uses class_name= on b.div(...). Element treats "
-        "that as a raw attr (rendered as class_name=\"...\" + data-bind-class_name=...) "
-        "instead of class=/data-bind-class. Reactive class bindings aren't supported "
-        "by markup.py: self._classes lives outside self._attrs, so the proxy-check at "
-        "render time never fires for the class= attribute. Pinned as a known gap "
-        "rather than silently fixed."
-    ),
-    strict=True,
-)
-def test_reactive_class_binding_emits_data_bind_class():
-    """Pin the known gap: there is no first-class way to reactively bind the class= attribute."""
+def test_reactive_class_binding_via_classes_kwarg():
+    """Passing a state proxy to classes= emits class= (static) + data-bind-class= (binding)."""
     app = App(title="Class Binding", version="t5")
 
     @app.local
@@ -196,11 +173,39 @@ class UiState:
     def home():
         doc = Document(title="x")
         with doc.body as b:
-            b.div(class_name=UiState.theme, id="app-container")
+            b.div(classes=UiState.theme, id="app-container")
         return doc
 
     client = TestClient(app.api)
     html = client.get("/").text
 
     assert 'class="light"' in html
     assert 'data-bind-class="UiState.theme"' in html
+
+
+def test_reactive_class_binding_via_class_name_alias():
+    """`class_name=` (React-style) is honored as an alias for `classes=`.
+
+    Pythonistas reach for class_name because `class` is a reserved keyword;
+    we accept it and route through the same reactive-binding path."""
+    app = App(title="Class Name Alias", version="t7")
+
+    @app.local
+    @dataclass
+    class UiState:
+        theme: str = "dark"
+
+    @app.view("/")
+    def home():
+        doc = Document(title="x")
+        with doc.body as b:
+            b.div(class_name=UiState.theme, id="x")
+        return doc
+
+    client = TestClient(app.api)
+    html = client.get("/").text
+
+    assert 'class="dark"' in html
+    assert 'data-bind-class="UiState.theme"' in html
+    # The alias should be consumed, not leaked as a literal HTML attribute.
+    assert "class_name=" not in html

violetear/app.py

@@ -605,9 +605,11 @@ def _generate_bundle(self) -> str:
             runtime_code = f.read()
 
         # 6. Generate State Classes (with dataclass re-application)
+        # dedent() lets us pull definitions from nested scopes (factories, tests)
+        # — without it, indentation from the source file leaks into the bundle.
         state_code = []
         for name, cls in self.client.state_classes.items():
-            source = inspect.getsource(cls)
+            source = dedent(inspect.getsource(cls))
             lines = source.split("\n")
 
             # Check for dataclass
@@ -630,8 +632,9 @@ def _generate_bundle(self) -> str:
         # 7. Extract User Functions
         user_code = []
         for name, func in self.client.code_functions.items():
-            code = inspect.getsource(func).split("\n")
-            code = [c for c in code if not c.startswith("@")]
+            source = dedent(inspect.getsource(func))
+            code = source.split("\n")
+            code = [c for c in code if not c.strip().startswith("@")]
             user_code.append("\n".join(code))
 
         # --- Safety Checks & Server Stubs ---

violetear/markup.py

@@ -76,7 +76,19 @@ def __init__(
         self._id = id
         self._text = text
 
-        if isinstance(classes, str):
+        # `class` is a Python keyword, so accept `class_name=` (React-style) as
+        # an alias for the `classes=` parameter when the caller didn't pass one.
+        if classes is None and "class_name" in attrs:
+            classes = attrs.pop("class_name")
+
+        # Reactive class binding: if `classes` is a state proxy, emit both the
+        # static value (split into the initial class list) and a `data-bind-class`
+        # attribute at render time. _class_binding holds the state path.
+        self._class_binding: str | None = None
+        if hasattr(classes, "_path") and hasattr(classes, "current_value"):
+            self._class_binding = classes._path
+            classes = str(classes.current_value).split()
+        elif isinstance(classes, str):
             classes = classes.split()
 
         self._classes = list(classes or [])
@@ -107,10 +119,16 @@ def id(self, id: str) -> Self:
         return self
 
     def classes(self, classes: Union[str, List[str]]) -> Self:
-        if isinstance(classes, str):
+        # Reactive binding: a state proxy passed here behaves like the ctor —
+        # captures the binding path and renders the current value as the
+        # initial class string.
+        if hasattr(classes, "_path") and hasattr(classes, "current_value"):
+            self._class_binding = classes._path
+            classes = str(classes.current_value).split()
+        elif isinstance(classes, str):
             classes = classes.split()
 
-        self._classes = classes
+        self._classes = list(classes)
         return self
 
     def style(self, style: Style) -> Self:
@@ -183,6 +201,9 @@ def _render(self, fp, indent: int):
             classes = " ".join(self._classes)
             parts.append(f'class="{classes}"')
 
+        if self._class_binding:
+            parts.append(f'data-bind-class="{self._class_binding}"')
+
         if self._style:
             parts.append(self._style.inline())