Merge branch 'worktree-cssx-components' into macros

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

shared/sx/async_eval.py

@@ -45,7 +45,7 @@ import contextvars
 import inspect
 from typing import Any
 
-from .types import Component, Keyword, Lambda, Macro, NIL, StyleValue, Symbol
+from .types import Component, Keyword, Lambda, Macro, NIL, Symbol
 
 # When True, _aser expands known components server-side instead of serializing
 # them for client rendering. Set during page slot evaluation so Python-only
@@ -425,11 +425,6 @@ async def _asf_defstyle(expr, env, ctx):
     return _sf_defstyle(expr, env)
 
 
-async def _asf_defkeyframes(expr, env, ctx):
-    from .evaluator import _sf_defkeyframes
-    return _sf_defkeyframes(expr, env)
-
-
 async def _asf_defmacro(expr, env, ctx):
     from .evaluator import _sf_defmacro
     return _sf_defmacro(expr, env)
@@ -568,7 +563,6 @@ _ASYNC_SPECIAL_FORMS: dict[str, Any] = {
     "fn": _asf_lambda,
     "define": _asf_define,
     "defstyle": _asf_defstyle,
-    "defkeyframes": _asf_defkeyframes,
     "defcomp": _asf_defcomp,
     "defmacro": _asf_defmacro,
     "defhandler": _asf_defhandler,
@@ -884,18 +878,6 @@ async def _arender_element(
             children.append(arg)
             i += 1
 
-    # Handle :style StyleValue — convert to class and register CSS rule
-    style_val = attrs.get("style")
-    if isinstance(style_val, StyleValue):
-        from .css_registry import register_generated_rule
-        register_generated_rule(style_val)
-        existing_class = attrs.get("class")
-        if existing_class and existing_class is not NIL and existing_class is not False:
-            attrs["class"] = f"{existing_class} {style_val.class_name}"
-        else:
-            attrs["class"] = style_val.class_name
-        del attrs["style"]
-
     class_val = attrs.get("class")
     if class_val is not None and class_val is not NIL and class_val is not False:
         collector = css_class_collector.get(None)
@@ -1120,7 +1102,6 @@ _ASYNC_RENDER_FORMS: dict[str, Any] = {
     "do": _arsf_begin,
     "define": _arsf_define,
     "defstyle": _arsf_define,
-    "defkeyframes": _arsf_define,
     "defcomp": _arsf_define,
     "defmacro": _arsf_define,
     "defhandler": _arsf_define,
@@ -1441,41 +1422,35 @@ async def _aser_call(
 
     try:
         parts = [name]
-        extra_class: str | None = None  # from :style StyleValue conversion
+        extra_class: str | None = None
         i = 0
         while i < len(args):
             arg = args[i]
             if isinstance(arg, Keyword) and i + 1 < len(args):
                 val = await _aser(args[i + 1], env, ctx)
                 if val is not NIL and val is not None:
-                    # :style StyleValue → convert to :class and register CSS
-                    if arg.name == "style" and isinstance(val, StyleValue):
-                        from .css_registry import register_generated_rule
-                        register_generated_rule(val)
-                        extra_class = val.class_name
-                    else:
-                        parts.append(f":{arg.name}")
-                        # Plain list → serialize for the client.
-                        # Rendered items (SxExpr) → wrap in (<> ...) fragment.
-                        # Data items (dicts, strings, numbers) → (list ...)
-                        # so the client gets an iterable array, not a
-                        # DocumentFragment that breaks map/filter.
-                        if isinstance(val, list):
-                            live = [v for v in val
-                                    if v is not NIL and v is not None]
-                            items = [serialize(v) for v in live]
-                            if not items:
-                                parts.append("nil")
-                            elif any(isinstance(v, SxExpr) for v in live):
-                                parts.append(
-                                    "(<> " + " ".join(items) + ")"
-                                )
-                            else:
-                                parts.append(
-                                    "(list " + " ".join(items) + ")"
-                                )
+                    parts.append(f":{arg.name}")
+                    # Plain list → serialize for the client.
+                    # Rendered items (SxExpr) → wrap in (<> ...) fragment.
+                    # Data items (dicts, strings, numbers) → (list ...)
+                    # so the client gets an iterable array, not a
+                    # DocumentFragment that breaks map/filter.
+                    if isinstance(val, list):
+                        live = [v for v in val
+                                if v is not NIL and v is not None]
+                        items = [serialize(v) for v in live]
+                        if not items:
+                            parts.append("nil")
+                        elif any(isinstance(v, SxExpr) for v in live):
+                            parts.append(
+                                "(<> " + " ".join(items) + ")"
+                            )
                         else:
-                            parts.append(serialize(val))
+                            parts.append(
+                                "(list " + " ".join(items) + ")"
+                            )
+                    else:
+                        parts.append(serialize(val))
                 i += 2
             else:
                 result = await _aser(arg, env, ctx)
@@ -1725,7 +1700,6 @@ _ASER_FORMS: dict[str, Any] = {
     "fn": _assf_lambda,
     "define": _assf_define,
     "defstyle": _assf_define,
-    "defkeyframes": _assf_define,
     "defcomp": _assf_define,
     "defmacro": _assf_define,
     "defhandler": _assf_define,