Fix isomorphic SSR: revert inline opcodes, add named let compilation, fix cookie decode

Three bugs broke island SSR rendering of the home stepper widget:

1. Inline VM opcodes (OP_ADD..OP_DEC) broke JIT-compiled functions.
   The compiler emitted single-byte opcodes for first/rest/len/= etc.
   that produced wrong results in complex recursive code (sx-parse
   returned nil, split-tag produced 1 step instead of 16). Reverted
   compiler to use CALL_PRIM for all primitives. VM opcode handlers
   kept for future use.

2. Named let (let loop ((x init)) body) had no compiler support —
   silently produced broken bytecode. Added desugaring to letrec.

3. URL-encoded cookie values not decoded server-side. Client set-cookie
   uses encodeURIComponent but Werkzeug doesn't decode cookie values.
   Added unquote() in bridge cookie injection.

Also: call-lambda used eval_expr which copies Dict values (signals),
breaking mutations through aser lambda calls. Switched to cek_call.

Also: stepper preview now includes ~cssx/tw spreads for SSR styling.

Tests: 1317 JS, 1114 OCaml, 26 integration (2 pre-existing failures)

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

hosts/ocaml/bin/integration_tests.ml

@@ -217,12 +217,33 @@ let make_integration_env () =
   bind "scope-peek" (fun args -> match args with [String n] -> scope_peek n | _ -> Nil);
   bind "scope-emit!" (fun args -> match args with [String n; v] -> scope_emit n v | _ -> Nil);
   bind "emitted" (fun args -> match args with [String n] -> emitted n | _ -> List []);
+  bind "emit!" (fun args -> match args with [String n; v] -> scope_emit n v | _ -> Nil);
+  bind "scope-emitted" (fun args -> match args with [String n] -> emitted n | _ -> List []);
+  bind "collect!" (fun _args -> Nil);
+  bind "collected" (fun _args -> List []);
+  bind "clear-collected!" (fun _args -> Nil);
+  bind "scope-collected" (fun _args -> List []);
+  bind "scope-clear-collected!" (fun _args -> Nil);
+  bind "provide-push!" (fun args -> match args with [String n; v] -> scope_push n v | _ -> Nil);
+  bind "provide-pop!" (fun args -> match args with [String n] -> scope_pop n | _ -> Nil);
+  bind "context" (fun args -> match args with [String n] -> scope_peek n | [String n; _] -> scope_peek n | _ -> Nil);
+  bind "sx-context" (fun args -> match args with [String n] -> scope_peek n | [String n; _] -> scope_peek n | _ -> Nil);
   (* Also register as primitives for prim_call *)
   Sx_primitives.register "scope-push!" (fun args -> match args with [String n; v] -> scope_push n v | _ -> Nil);
   Sx_primitives.register "scope-pop!" (fun args -> match args with [String n] -> scope_pop n | _ -> Nil);
   Sx_primitives.register "scope-peek" (fun args -> match args with [String n] -> scope_peek n | _ -> Nil);
   Sx_primitives.register "scope-emit!" (fun args -> match args with [String n; v] -> scope_emit n v | _ -> Nil);
   Sx_primitives.register "emitted" (fun args -> match args with [String n] -> emitted n | _ -> List []);
+  Sx_primitives.register "emit!" (fun args -> match args with [String n; v] -> scope_emit n v | _ -> Nil);
+  Sx_primitives.register "scope-emitted" (fun args -> match args with [String n] -> emitted n | _ -> List []);
+  Sx_primitives.register "collect!" (fun _args -> Nil);
+  Sx_primitives.register "collected" (fun _args -> List []);
+  Sx_primitives.register "clear-collected!" (fun _args -> Nil);
+  Sx_primitives.register "scope-collected" (fun _args -> List []);
+  Sx_primitives.register "scope-clear-collected!" (fun _args -> Nil);
+  Sx_primitives.register "provide-push!" (fun args -> match args with [String n; v] -> scope_push n v | _ -> Nil);
+  Sx_primitives.register "provide-pop!" (fun args -> match args with [String n] -> scope_pop n | _ -> Nil);
+  Sx_primitives.register "context" (fun args -> match args with [String n] -> scope_peek n | [String n; _] -> scope_peek n | _ -> Nil);
 
   (* Render-mode flags *)
   ignore (env_bind env "*render-active*" (Bool false));
@@ -236,7 +257,7 @@ let make_integration_env () =
         "defstyle"; "defhandler"; "deftype"; "defeffect"; "defquery"; "defaction"; "defrelation"])
     | _ -> Bool false);
 
-  (* Signal stubs for SSR *)
+  (* Signal stubs for SSR — overridden when signals.sx is loaded *)
   bind "signal" (fun args -> match args with [v] -> v | _ -> Nil);
   bind "computed" (fun args -> match args with [f] -> Sx_runtime.sx_call f [] | _ -> Nil);
   bind "deref" (fun args -> match args with [v] -> v | _ -> Nil);
@@ -245,6 +266,85 @@ let make_integration_env () =
   bind "effect" (fun _args -> Nil);
   bind "batch" (fun _args -> Nil);
 
+  (* Type predicates — needed by adapter-sx.sx *)
+  bind "callable?" (fun args ->
+    match args with [NativeFn _] | [Lambda _] | [Component _] | [Island _] -> Bool true | _ -> Bool false);
+  bind "lambda?" (fun args -> match args with [Lambda _] -> Bool true | _ -> Bool false);
+  bind "macro?" (fun args -> match args with [Macro _] -> Bool true | _ -> Bool false);
+  bind "island?" (fun args -> match args with [Island _] -> Bool true | _ -> Bool false);
+  bind "component?" (fun args ->
+    match args with [Component _] | [Island _] -> Bool true | _ -> Bool false);
+  bind "spread?" (fun args -> match args with [Spread _] -> Bool true | _ -> Bool false);
+  bind "lambda-params" (fun args ->
+    match args with [Lambda l] -> List (List.map (fun s -> String s) l.l_params) | _ -> List []);
+  bind "lambda-body" (fun args -> match args with [Lambda l] -> l.l_body | _ -> Nil);
+  bind "lambda-closure" (fun args ->
+    match args with [Lambda l] -> Env l.l_closure | _ -> Dict (Hashtbl.create 0));
+  bind "component-name" (fun args ->
+    match args with [Component c] -> String c.c_name | [Island i] -> String i.i_name | _ -> String "");
+  bind "component-closure" (fun args ->
+    match args with [Component c] -> Env c.c_closure | [Island i] -> Env i.i_closure | _ -> Dict (Hashtbl.create 0));
+  bind "component-params" (fun args ->
+    match args with
+    | [Component c] -> List (List.map (fun s -> String s) c.c_params)
+    | [Island i] -> List (List.map (fun s -> String s) i.i_params)
+    | _ -> Nil);
+  bind "component-body" (fun args ->
+    match args with [Component c] -> c.c_body | [Island i] -> i.i_body | _ -> Nil);
+  bind "component-affinity" (fun args ->
+    match args with [Component c] -> String c.c_affinity
+    | [Island _] -> Nil | _ -> Nil);
+  bind "component-has-children?" (fun args ->
+    match args with
+    | [Component c] -> Bool (List.mem "children" c.c_params)
+    | [Island i] -> Bool (List.mem "children" i.i_params)
+    | _ -> Bool false);
+
+  (* Evaluator bridge — needed by adapter-sx.sx *)
+  bind "call-lambda" (fun args ->
+    match args with
+    | [fn_val; List call_args; Env _e] ->
+      Sx_ref.cek_call fn_val (List call_args)
+    | [fn_val; List call_args] ->
+      Sx_ref.cek_call fn_val (List call_args)
+    | _ -> raise (Eval_error "call-lambda: expected (fn args env?)"));
+  bind "cek-call" (fun args ->
+    match args with
+    | [fn_val; List call_args] -> Sx_ref.cek_call fn_val (List call_args)
+    | [fn_val; Nil] -> Sx_ref.cek_call fn_val (List [])
+    | [fn_val] -> Sx_ref.cek_call fn_val (List [])
+    | _ -> Nil);
+  bind "expand-macro" (fun args ->
+    match args with
+    | [Macro m; List macro_args; Env e] ->
+      let body_env = { bindings = Hashtbl.create 16; parent = Some e } in
+      List.iteri (fun i p ->
+        let v = if i < List.length macro_args then List.nth macro_args i else Nil in
+        Hashtbl.replace body_env.bindings p v
+      ) m.m_params;
+      Sx_ref.eval_expr m.m_body (Env body_env)
+    | _ -> raise (Eval_error "expand-macro: expected (macro args env)"));
+  bind "eval-expr" (fun args ->
+    match args with
+    | [expr; e] -> Sx_ref.eval_expr expr (Env (Sx_runtime.unwrap_env e))
+    | [expr] -> Sx_ref.eval_expr expr (Env env)
+    | _ -> raise (Eval_error "eval-expr: expected (expr env?)"));
+  bind "trampoline" (fun args ->
+    match args with
+    | [v] ->
+      let rec resolve v = match v with
+        | Thunk (body, closure_env) -> resolve (Sx_ref.eval_expr body (Env closure_env))
+        | _ -> v
+      in resolve v
+    | _ -> raise (Eval_error "trampoline: expected 1 arg"));
+  bind "expand-components?" (fun _args -> Bool false);
+  bind "register-special-form!" (fun args ->
+    match args with
+    | [String name; handler] ->
+      ignore (Sx_ref.register_special_form (String name) handler); Nil
+    | _ -> raise (Eval_error "register-special-form!: expected (name handler)"));
+  ignore (env_bind env "*custom-special-forms*" Sx_ref.custom_special_forms);
+
   (* DOM stubs *)
   bind "create-text-node" (fun args -> match args with [String s] -> String s | _ -> Nil);
   bind "create-fragment" (fun _args -> Nil);
@@ -360,13 +460,15 @@ let () =
 
   (* ================================================================== *)
   Printf.printf "\nSuite: SX adapter — components\n%!";
-  assert_no_error "defcomp + render" (fun () ->
-    ignore (Sx_ref.eval_expr
-      (List.hd (Sx_parser.parse_all "(defcomp ~test-card (&key title &rest children) (div :class \"card\" (h2 title) children))"))
-      (Env env));
-    sx_render_html "(~test-card :title \"Hi\" (p \"body\"))");
-  assert_contains "component renders div" "<div" (sx_render_html "(~test-card :title \"Hi\" (p \"body\"))");
-  assert_contains "component renders title" "Hi" (sx_render_html "(~test-card :title \"Hi\" (p \"body\"))");
+  (try
+    assert_no_error "defcomp + render" (fun () ->
+      ignore (Sx_ref.eval_expr
+        (List.hd (Sx_parser.parse_all "(defcomp ~test-card (&key title &rest children) (div :class \"card\" (h2 title) children))"))
+        (Env env));
+      sx_render_html "(~test-card :title \"Hi\" (p \"body\"))");
+    assert_contains "component renders div" "<div" (sx_render_html "(~test-card :title \"Hi\" (p \"body\"))");
+    assert_contains "component renders title" "Hi" (sx_render_html "(~test-card :title \"Hi\" (p \"body\"))")
+  with Eval_error msg -> incr fail_count; Printf.printf "  FAIL: components — %s\n%!" msg);
 
   (* ================================================================== *)
   Printf.printf "\nSuite: eval-expr with HTML tag functions\n%!";
@@ -375,6 +477,40 @@ let () =
   assert_no_error "eval (span) returns list" (fun () ->
     Sx_ref.eval_expr (List [Symbol "span"; String "text"]) (Env env));
 
+  (* ================================================================== *)
+  (* Regression: call-lambda re-evaluated Dict args through eval_expr,
+     which copies dicts.  Mutations inside the lambda (e.g. signal
+     reset!) operated on the copy, not the original.  This broke
+     island SSR where aser processes multi-body let forms. *)
+  Printf.printf "\nSuite: call-lambda dict identity (aser mode)\n%!";
+  let aser_eval src =
+    let exprs = Sx_parser.parse_all src in
+    let expr = match exprs with [e] -> e | _ -> Nil in
+    let call = List [Symbol "aser"; List [Symbol "quote"; expr]; Env env] in
+    match Sx_ref.eval_expr call (Env env) with
+    | String s | SxExpr s -> s
+    | v -> value_to_string v
+  in
+  assert_eq "lambda dict mutation in aser multi-body let"
+    "99"
+    (aser_eval
+      "(let ((mutate! (fn (d k v) (dict-set! d k v)))
+             (d (dict \"x\" 1)))
+         (mutate! d \"x\" 99)
+         (get d \"x\"))");
+  assert_eq "signal reset! in aser multi-body let"
+    "99"
+    (aser_eval
+      "(let ((s (signal 42)))
+         (reset! s 99)
+         (deref s))");
+  assert_eq "signal reset! then len of deref"
+    "3"
+    (aser_eval
+      "(let ((s (signal (list))))
+         (reset! s (list 1 2 3))
+         (len (deref s)))");
+
   (* ================================================================== *)
   Printf.printf "\n";
   Printf.printf "============================================================\n";

hosts/ocaml/bin/sx_server.ml

@@ -292,11 +292,15 @@ let setup_io_env env =
     | _ -> raise (Eval_error "ctx: expected 1 arg"));
 
   bind "call-lambda" (fun args ->
+    (* Use cek_call instead of eval_expr to avoid re-evaluating
+       already-evaluated args.  eval_expr copies Dict values (signals)
+       during evaluation, so mutations in the lambda body would affect
+       the copy, not the original. *)
     match args with
-    | [fn_val; List call_args; Env e] ->
-      Sx_ref.eval_expr (List (fn_val :: call_args)) (Env e)
+    | [fn_val; List call_args; Env _e] ->
+      Sx_ref.cek_call fn_val (List call_args)
     | [fn_val; List call_args] ->
-      Sx_ref.eval_expr (List (fn_val :: call_args)) (Env env)
+      Sx_ref.cek_call fn_val (List call_args)
     | _ -> raise (Eval_error "call-lambda: expected (fn args env?)"));
 
   (* Register HO forms as callable NativeFn — the CEK machine handles them
@@ -377,11 +381,15 @@ let setup_evaluator_bridge env =
       in resolve v
     | _ -> raise (Eval_error "trampoline: expected 1 arg"));
   bind "call-lambda" (fun args ->
+    (* Use cek_call instead of eval_expr to avoid re-evaluating
+       already-evaluated args.  eval_expr copies Dict values (signals)
+       during evaluation, so mutations in the lambda body would affect
+       the copy, not the original. *)
     match args with
-    | [fn_val; List call_args; Env e] ->
-      Sx_ref.eval_expr (List (fn_val :: call_args)) (Env e)
+    | [fn_val; List call_args; Env _e] ->
+      Sx_ref.cek_call fn_val (List call_args)
     | [fn_val; List call_args] ->
-      Sx_ref.eval_expr (List (fn_val :: call_args)) (Env env)
+      Sx_ref.cek_call fn_val (List call_args)
     | _ -> raise (Eval_error "call-lambda: expected (fn args env?)"));
   bind "cek-call" (fun args ->
     match args with

hosts/ocaml/lib/sx_vm.ml

@@ -418,7 +418,12 @@ and run vm =
           push vm (match a, b with Number x, Number y -> Number (x /. y) | _ -> Nil)
         | 164 (* OP_EQ *) ->
           let b = pop vm and a = pop vm in
-          push vm (Bool (a = b))
+          (* Must normalize ListRef→List before structural compare,
+             same as the "=" primitive in sx_primitives.ml *)
+          let rec norm = function
+            | ListRef { contents = l } -> List (List.map norm l)
+            | List l -> List (List.map norm l) | v -> v in
+          push vm (Bool (norm a = norm b))
         | 165 (* OP_LT *) ->
           let b = pop vm and a = pop vm in
           push vm (match a, b with Number x, Number y -> Bool (x < y) | String x, String y -> Bool (x < y) | _ -> Bool false)