OCaml VM browser: safe equality, thunk trampolining, platform functions, nav pipeline

Core runtime fixes:
- Safe equality (=, !=): physical equality for dicts/lambdas/signals,
  structural only for acyclic types. Prevents infinite loops on circular
  signal subscriber chains.
- contains?: same safe comparison (physical first, structural for simple types)
- Thunk trampolining in as_number and to_string: leaked thunks auto-resolve
  instead of showing <thunk> or erroring "Expected number, got thunk"
- Diagnostic first error: shows actual type received

Island hydration fixes:
- adapter-dom.sx: skip scope-emit for spreads inside islands (was tripling classes)
- schedule-idle: wrap callback to absorb requestIdleCallback deadline arg
- home-stepper: remove spread-specific highlighting (all tokens same style per step)

Platform functions (boot-helpers.sx):
- fetch-request: 3-arg interface (config, success-fn, error-fn) with promise chain
- build-request-body: form serialization for GET/POST
- strip-component-scripts / extract-response-css: SX text processing
- Navigation: bind-boost-link, bind-client-route-click via execute-request
- Loading state: show-indicator, disable-elements, clear-loading-state
- DOM extras: dom-remove, dom-attr-list (name/value pairs), dom-child-list (SX list),
  dom-is-active-element?, dom-is-input-element?, dom-is-child-of?, dom-on,
  dom-parse-html-document, dom-body-inner-html, create-script-clone
- All remaining stubs: csrf-token, loaded-component-names, observe-intersection,
  event-source-connect/listen, with-transition, cross-origin?, etc.

Navigation pipeline:
- browser-push-state/replace-state: accept 1-arg (URL only) or 3-arg
- boot.sx: wire popstate listener to handle-popstate
- URL updates working via handle-history + pushState fix

Morph debugging (WIP):
- dom-child-list returns proper SX list (was JS Array)
- dom-query accepts optional root element for scoped queries
- Navigation fetches and renders SX responses, URL updates, but morph
  doesn't replace content div (investigating dom-child-list on new elements)

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

hosts/ocaml/lib/sx_primitives.ml

@@ -24,12 +24,18 @@ let get_primitive name =
 
 (* --- Helpers --- *)
 
-let as_number = function
+(* Trampoline hook — set by sx_ref after initialization to break circular dep *)
+let trampoline_hook : (value -> value) ref = ref (fun v -> v)
+
+let rec as_number = function
   | Number n -> n
   | Bool true -> 1.0
   | Bool false -> 0.0
   | Nil -> 0.0
   | String s -> (match float_of_string_opt s with Some n -> n | None -> Float.nan)
+  | Thunk _ as t ->
+    (* Trampoline thunks — they shouldn't leak but sometimes do *)
+    as_number (!trampoline_hook t)
   | v -> raise (Eval_error ("Expected number, got " ^ type_of v ^ ": " ^ (match v with Dict d -> (match Hashtbl.find_opt d "__signal" with Some _ -> "signal{value=" ^ (match Hashtbl.find_opt d "value" with Some v' -> value_to_string v' | None -> "?") ^ "}" | None -> "dict") | _ -> "")))
 
 let as_string = function
@@ -47,7 +53,7 @@ let as_bool = function
   | Bool b -> b
   | v -> sx_truthy v
 
-let to_string = function
+let rec to_string = function
   | String s -> s
   | Number n ->
     if Float.is_integer n then string_of_int (int_of_float n)
@@ -57,6 +63,7 @@ let to_string = function
   | Nil -> ""
   | Symbol s -> s
   | Keyword k -> k
+  | Thunk _ as t -> to_string (!trampoline_hook t)
   | v -> inspect v
 
 let () =
@@ -132,19 +139,33 @@ let () =
     | _ -> Nil);
 
   (* === Comparison === *)
-  (* Normalize ListRef to List for structural equality *)
-  let rec normalize_for_eq = function
-    | ListRef { contents = items } -> List (List.map normalize_for_eq items)
-    | List items -> List (List.map normalize_for_eq items)
-    | v -> v
+  (* Safe equality: physical equality for potentially-circular types
+     (Dict, Lambda, Component, Island, Signal, NativeFn),
+     structural equality for acyclic types (Number, String, Bool, etc.).
+     Lists are compared element-wise recursively with the same safety. *)
+  let rec safe_eq a b =
+    if a == b then true  (* physical equality fast path *)
+    else match a, b with
+    | Number x, Number y -> x = y
+    | String x, String y -> x = y
+    | Bool x, Bool y -> x = y
+    | Nil, Nil -> true
+    | Symbol x, Symbol y -> x = y
+    | Keyword x, Keyword y -> x = y
+    | (List la | ListRef { contents = la }),
+      (List lb | ListRef { contents = lb }) ->
+      List.length la = List.length lb &&
+      List.for_all2 safe_eq la lb
+    (* Dict/Lambda/Component/Island/Signal/NativeFn: physical only *)
+    | _ -> false
   in
   register "=" (fun args ->
     match args with
-    | [a; b] -> Bool (normalize_for_eq a = normalize_for_eq b)
+    | [a; b] -> Bool (safe_eq a b)
     | _ -> raise (Eval_error "=: 2 args"));
   register "!=" (fun args ->
     match args with
-    | [a; b] -> Bool (normalize_for_eq a <> normalize_for_eq b)
+    | [a; b] -> Bool (not (safe_eq a b))
     | _ -> raise (Eval_error "!=: 2 args"));
   register "<" (fun args ->
     match args with
@@ -340,6 +361,7 @@ let () =
     match args with
     | [List (x :: _)] | [ListRef { contents = x :: _ }] -> x
     | [List []] | [ListRef { contents = [] }] -> Nil | [Nil] -> Nil
+    | [x] -> raise (Eval_error ("first: expected list, got " ^ inspect x))
     | _ -> raise (Eval_error "first: 1 list arg"));
   register "rest" (fun args ->
     match args with
@@ -396,7 +418,21 @@ let () =
   register "concat" (fun args -> List (List.concat_map as_list args));
   register "contains?" (fun args ->
     match args with
-    | [List l; item] | [ListRef { contents = l }; item] -> Bool (List.mem item l)
+    | [List l; item] | [ListRef { contents = l }; item] ->
+      (* Physical equality first (handles signals/dicts/closures safely),
+         structural fallback only for acyclic types (string/number/bool/nil/symbol/keyword) *)
+      let safe_eq a b =
+        a == b ||
+        (match a, b with
+         | Number x, Number y -> x = y
+         | String x, String y -> x = y
+         | Bool x, Bool y -> x = y
+         | Nil, Nil -> true
+         | Symbol x, Symbol y -> x = y
+         | Keyword x, Keyword y -> x = y
+         | _ -> false)
+      in
+      Bool (List.exists (fun x -> safe_eq x item) l)
     | [String s; String sub] ->
       let rec find i =
         if i + String.length sub > String.length s then false