OCaml evaluator for page dispatch + handler aser, 83/83 Playwright tests

Major architectural change: page function dispatch and handler execution
now go through the OCaml kernel instead of the Python bootstrapped evaluator.

OCaml integration:
- Page dispatch: bridge.eval() evaluates SX URL expressions (geography, marshes, etc.)
- Handler aser: bridge.aser() serializes handler responses as SX wire format
- _ensure_components loads all .sx files into OCaml kernel (spec, web adapter, handlers)
- defhandler/defpage registered as no-op special forms so handler files load
- helper IO primitive dispatches to Python page helpers + IO handlers
- ok-raw response format for SX wire format (no double-escaping)
- Natural list serialization in eval (no (list ...) wrapper)
- Clean pipe: _read_until_ok always sends io-response on error

SX adapter (aser):
- scope-emit!/scope-peek aliases to avoid CEK special form conflict
- aser-fragment/aser-call: strings starting with "(" pass through unserialized
- Registered cond-scheme?, is-else-clause?, primitive?, get-primitive in kernel
- random-int, parse-int as kernel primitives; json-encode, into via IO bridge

Handler migration:
- All IO calls converted to (helper "name" args...) pattern
- request-arg, request-form, state-get, state-set!, now, component-source etc.
- Fixed bare (effect ...) in island bodies leaking disposer functions as text
- Fixed lower-case → lower, ~search-results → ~examples/search-results

Reactive islands:
- sx-hydrate-islands called after client-side navigation swap
- force-dispose-islands-in for outerHTML swaps (clears hydration markers)
- clear-processed! platform primitive for re-hydration

Content restructuring:
- Design, event bridge, named stores, phase 2 consolidated into reactive overview
- Marshes split into overview + 5 example sub-pages
- Nav links use sx-get/sx-target for client-side navigation

Playwright test suite (sx/tests/test_demos.py):
- 83 tests covering hypermedia demos, reactive islands, marshes, spec explorer
- Server-side rendering, handler interactions, island hydration, navigation

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

shared/sx/handlers.py

@@ -137,36 +137,55 @@ async def execute_handler(
 
     1. Build env from component env + handler closure
     2. Bind handler params from args (typically request.args)
-    3. Evaluate via ``async_eval_to_sx`` (I/O inline, components serialized)
+    3. Evaluate via OCaml kernel (or Python fallback)
     4. Return ``SxExpr`` wire format
     """
     from .jinja_bridge import get_component_env, _get_request_context
     from .pages import get_page_helpers
+    from .parser import serialize
+    from .types import NIL, SxExpr
     import os
-    if os.environ.get("SX_USE_REF") == "1":
-        from .ref.async_eval_ref import async_eval_to_sx
-    else:
-        from .async_eval import async_eval_to_sx
-    from .types import NIL
 
     if args is None:
         args = {}
 
-    # Build environment
-    env = dict(get_component_env())
-    env.update(get_page_helpers(service_name))
-    env.update(handler_def.closure)
+    use_ocaml = os.environ.get("SX_USE_OCAML") == "1"
 
-    # Bind handler params from request args
-    for param in handler_def.params:
-        env[param] = args.get(param, args.get(param.replace("-", "_"), NIL))
+    if use_ocaml:
+        from .ocaml_bridge import get_bridge
 
-    # Get request context for I/O primitives
-    ctx = _get_request_context()
+        # Serialize handler body with bound params as a let expression
+        param_bindings = []
+        for param in handler_def.params:
+            val = args.get(param, args.get(param.replace("-", "_"), NIL))
+            param_bindings.append(f"({param} {serialize(val)})")
 
-    # Async eval → sx source — I/O primitives are awaited inline,
-    # but component/tag calls serialize to sx wire format (not HTML).
-    return await async_eval_to_sx(handler_def.body, env, ctx)
+        body_sx = serialize(handler_def.body)
+        if param_bindings:
+            sx_text = f"(let ({' '.join(param_bindings)}) {body_sx})"
+        else:
+            sx_text = body_sx
+
+        bridge = await get_bridge()
+        ocaml_ctx = {"_helper_service": service_name}
+        result_sx = await bridge.aser(sx_text, ctx=ocaml_ctx)
+        return SxExpr(result_sx or "")
+    else:
+        # Python fallback
+        if os.environ.get("SX_USE_REF") == "1":
+            from .ref.async_eval_ref import async_eval_to_sx
+        else:
+            from .async_eval import async_eval_to_sx
+
+        env = dict(get_component_env())
+        env.update(get_page_helpers(service_name))
+        env.update(handler_def.closure)
+
+        for param in handler_def.params:
+            env[param] = args.get(param, args.get(param.replace("-", "_"), NIL))
+
+        ctx = _get_request_context()
+        return await async_eval_to_sx(handler_def.body, env, ctx)
 
 
 # ---------------------------------------------------------------------------