briefing: push to origin/loops/smalltalk after each commit

2026-05-06 06:47:30 +00:00
125 changed files with 2205 additions and 30783 deletions
--- a/hosts/javascript/platform.py
+++ b/hosts/javascript/platform.py
--- a/hosts/javascript/run_tests.js
+++ b/hosts/javascript/run_tests.js
@@ -293,8 +293,6 @@ env["pop-suite"] = function() {
  return null;
 };

-env["test-allowed?"] = function(name) { return true; };
-
 // Load test framework
 const projectDir = path.join(__dirname, "..", "..");
 const specTests = path.join(projectDir, "spec", "tests");
@@ -343,20 +341,6 @@ if (fs.existsSync(swapPath)) {
  }
 }

-// Load spec library files (define-library modules imported by tests)
-for (const libFile of ["stdlib.sx", "signals.sx", "coroutines.sx"]) {
-  const libPath = path.join(projectDir, "spec", libFile);
-  if (fs.existsSync(libPath)) {
-    const libSrc = fs.readFileSync(libPath, "utf8");
-    const libExprs = Sx.parse(libSrc);
-    for (const expr of libExprs) {
-      try { Sx.eval(expr, env); } catch (e) {
-        console.error(`Error loading spec/${libFile}: ${e.message}`);
-      }
-    }
-  }
-}
-
 // Load tw system (needed by spec/tests/test-tw.sx)
 const twDir = path.join(projectDir, "shared", "sx", "templates");
 for (const twFile of ["tw-type.sx", "tw-layout.sx", "tw.sx"]) {
--- a/hosts/javascript/transpiler.sx
+++ b/hosts/javascript/transpiler.sx
--- a/hosts/ocaml/bin/run_tests.ml
+++ b/hosts/ocaml/bin/run_tests.ml
@@ -37,10 +37,7 @@ let rec deep_equal a b =
  match a, b with
  | Nil, Nil -> true
  | Bool a, Bool b -> a = b
-  | Integer a, Integer b -> a = b
  | Number a, Number b -> a = b
-  | Integer a, Number b -> float_of_int a = b
-  | Number a, Integer b -> a = float_of_int b
  | String a, String b -> a = b
  | Symbol a, Symbol b -> a = b
  | Keyword a, Keyword b -> a = b
@@ -229,7 +226,7 @@ let make_test_env () =
    | [String s] ->
      let parsed = Sx_parser.parse_all s in
      (match parsed with
-       | [List (Symbol "sxbc" :: (Number _ | Integer _) :: payload :: _)] -> payload
+       | [List (Symbol "sxbc" :: Number _ :: payload :: _)] -> payload
       | _ -> raise (Eval_error "bytecode-deserialize: invalid sxbc format"))
    | _ -> raise (Eval_error "bytecode-deserialize: expected string"));

@@ -243,7 +240,7 @@ let make_test_env () =
    | [String s] ->
      let parsed = Sx_parser.parse_all s in
      (match parsed with
-       | [List (Symbol "cek-state" :: (Number _ | Integer _) :: payload :: _)] -> payload
+       | [List (Symbol "cek-state" :: Number _ :: payload :: _)] -> payload
       | _ -> raise (Eval_error "cek-deserialize: invalid cek-state format"))
    | _ -> raise (Eval_error "cek-deserialize: expected string"));

@@ -323,10 +320,7 @@ let make_test_env () =
  bind "identical?" (fun args ->
    match args with
    | [a; b] -> Bool (match a, b with
-      | Integer x, Integer y -> x = y
      | Number x, Number y -> x = y
-      | Integer x, Number y -> float_of_int x = y
-      | Number x, Integer y -> x = float_of_int y
      | String x, String y -> x = y
      | Bool x, Bool y -> x = y
      | Nil, Nil -> true
@@ -372,15 +366,11 @@ let make_test_env () =

  bind "append!" (fun args ->
    match args with
-    | [ListRef r; v; (Number n)] when int_of_float n = 0 ->
+    | [ListRef r; v; Number n] when int_of_float n = 0 ->
      r := v :: !r; ListRef r  (* prepend *)
-    | [ListRef r; v; (Integer 0)] ->
-      r := v :: !r; ListRef r  (* prepend Integer index *)
    | [ListRef r; v] -> r := !r @ [v]; ListRef r  (* append in place *)
-    | [List items; v; (Number n)] when int_of_float n = 0 ->
+    | [List items; v; Number n] when int_of_float n = 0 ->
      List (v :: items)  (* immutable prepend *)
-    | [List items; v; (Integer 0)] ->
-      List (v :: items)  (* immutable prepend Integer index *)
    | [List items; v] -> List (items @ [v])  (* immutable fallback *)
    | _ -> raise (Eval_error "append!: expected list and value"));

@@ -556,10 +546,7 @@ let make_test_env () =
  bind "batch-begin!" (fun _args -> Sx_ref.batch_begin_b ());
  bind "batch-end!" (fun _args -> Sx_ref.batch_end_b ());
  bind "now-ms" (fun _args -> Number 1000.0);
-  bind "random-int" (fun args -> match args with
-    | [Number lo; _] -> Number lo
-    | [Integer lo; _] -> Integer lo
-    | _ -> Integer 0);
+  bind "random-int" (fun args -> match args with [Number lo; _] -> Number lo | _ -> Number 0.0);
  bind "try-rerender-page" (fun _args -> Nil);
  bind "collect!" (fun args ->
    match args with
@@ -1120,47 +1107,6 @@ let make_test_env () =
    | _ :: _ -> String "confirmed"
    | _ -> Nil);

-  bind "values" (fun args ->
-    match args with
-    | [v] -> v
-    | vs ->
-      let d = Hashtbl.create 2 in
-      Hashtbl.replace d "_values" (Bool true);
-      Hashtbl.replace d "_list" (List vs);
-      Dict d);
-
-  bind "call-with-values" (fun args ->
-    match args with
-    | [producer; consumer] ->
-      let result = Sx_ref.cek_call producer (List []) in
-      let spread = (match result with
-        | Dict d when (match Hashtbl.find_opt d "_values" with Some (Bool true) -> true | _ -> false) ->
-          (match Hashtbl.find_opt d "_list" with Some (List l) -> l | _ -> [result])
-        | _ -> [result])
-      in
-      Sx_ref.cek_call consumer (List spread)
-    | _ -> raise (Eval_error "call-with-values: expected 2 args"));
-
-  bind "promise?" (fun args ->
-    match args with
-    | [v] -> Bool (Sx_ref.is_promise v)
-    | _ -> Bool false);
-
-  bind "make-promise" (fun args ->
-    match args with
-    | [v] ->
-      let d = Hashtbl.create 4 in
-      Hashtbl.replace d "_promise" (Bool true);
-      Hashtbl.replace d "forced" (Bool true);
-      Hashtbl.replace d "value" v;
-      Dict d
-    | _ -> Nil);
-
-  bind "force" (fun args ->
-    match args with
-    | [p] -> Sx_ref.force_promise p
-    | _ -> Nil);
-
  env

 (* ====================================================================== *)
@@ -1196,20 +1142,18 @@ let run_foundation_tests () =
  in

  Printf.printf "Suite: parser\n";
-  assert_eq "number" (Integer 42) (List.hd (parse_all "42"));
+  assert_eq "number" (Number 42.0) (List.hd (parse_all "42"));
  assert_eq "string" (String "hello") (List.hd (parse_all "\"hello\""));
  assert_eq "bool true" (Bool true) (List.hd (parse_all "true"));
  assert_eq "nil" Nil (List.hd (parse_all "nil"));
  assert_eq "keyword" (Keyword "class") (List.hd (parse_all ":class"));
  assert_eq "symbol" (Symbol "foo") (List.hd (parse_all "foo"));
-  assert_eq "list" (List [Symbol "+"; Integer 1; Integer 2]) (List.hd (parse_all "(+ 1 2)"));
+  assert_eq "list" (List [Symbol "+"; Number 1.0; Number 2.0]) (List.hd (parse_all "(+ 1 2)"));
  (match List.hd (parse_all "(div :class \"card\" (p \"hi\"))") with
   | List [Symbol "div"; Keyword "class"; String "card"; List [Symbol "p"; String "hi"]] ->
     incr pass_count; Printf.printf "  PASS: nested list\n"
   | v -> incr fail_count; Printf.printf "  FAIL: nested list — got %s\n" (Sx_types.inspect v));
  (match List.hd (parse_all "'(1 2 3)") with
-   | List [Symbol "quote"; List [Integer 1; Integer 2; Integer 3]] ->
-     incr pass_count; Printf.printf "  PASS: quote sugar\n"
   | List [Symbol "quote"; List [Number 1.0; Number 2.0; Number 3.0]] ->
     incr pass_count; Printf.printf "  PASS: quote sugar\n"
   | v -> incr fail_count; Printf.printf "  FAIL: quote sugar — got %s\n" (Sx_types.inspect v));
@@ -1217,7 +1161,7 @@ let run_foundation_tests () =
   | Dict d when dict_has d "a" && dict_has d "b" ->
     incr pass_count; Printf.printf "  PASS: dict literal\n"
   | v -> incr fail_count; Printf.printf "  FAIL: dict literal — got %s\n" (Sx_types.inspect v));
-  assert_eq "comment" (Integer 42) (List.hd (parse_all ";; comment\n42"));
+  assert_eq "comment" (Number 42.0) (List.hd (parse_all ";; comment\n42"));
  assert_eq "string escape" (String "hello\nworld") (List.hd (parse_all "\"hello\\nworld\""));
  assert_eq "multiple exprs" (Number 2.0) (Number (float_of_int (List.length (parse_all "(1 2 3) (4 5)"))));

@@ -2034,10 +1978,6 @@ let run_spec_tests env test_files =
      (match Hashtbl.find_opt d "children" with
       | Some (List l) when i >= 0 && i < List.length l -> List.nth l i
       | _ -> (match Hashtbl.find_opt d (string_of_int i) with Some v -> v | None -> Nil))
-    | [Dict d; Integer n] ->
-      (match Hashtbl.find_opt d "children" with
-       | Some (List l) when n >= 0 && n < List.length l -> List.nth l n
-       | _ -> (match Hashtbl.find_opt d (string_of_int n) with Some v -> v | None -> Nil))
    | _ -> Nil);

  (* Stringify a value for DOM string properties *)
@@ -2112,8 +2052,8 @@ let run_spec_tests env test_files =
         Hashtbl.replace d "childNodes" (List [])
       | _ -> ());
      stored
-    | [ListRef r; idx_v; value] when (match idx_v with Number _ | Integer _ -> true | _ -> false) ->
-      let idx = match idx_v with Number n -> int_of_float n | Integer n -> n | _ -> 0 in
+    | [ListRef r; Number n; value] ->
+      let idx = int_of_float n in
      let lst = !r in
      if idx >= 0 && idx < List.length lst then
        r := List.mapi (fun i v -> if i = idx then value else v) lst
@@ -2250,7 +2190,7 @@ let run_spec_tests env test_files =
            | [String name; value] ->
              let attrs = match Hashtbl.find_opt d "attributes" with Some (Dict a) -> a | _ ->
                let a = Hashtbl.create 4 in Hashtbl.replace d "attributes" (Dict a); a in
-              let sv = match value with String s -> s | Integer n -> string_of_int n | Number n ->
+              let sv = match value with String s -> s | Number n ->
                let i = int_of_float n in if float_of_int i = n then string_of_int i
                else string_of_float n | _ -> Sx_types.inspect value in
              Hashtbl.replace attrs name (String sv);
@@ -2692,7 +2632,6 @@ let run_spec_tests env test_files =
  let rec json_of_value = function
    | Nil -> `Null
    | Bool b -> `Bool b
-    | Integer n -> `Int n
    | Number n ->
      if Float.is_integer n && Float.abs n < 1e16
      then `Int (int_of_float n) else `Float n
@@ -2708,8 +2647,8 @@ let run_spec_tests env test_files =
  let rec value_of_json = function
    | `Null -> Nil
    | `Bool b -> Bool b
-    | `Int i -> Integer i
-    | `Intlit s -> (try Integer (int_of_string s) with _ -> try Number (float_of_string s) with _ -> String s)
+    | `Int i -> Number (float_of_int i)
+    | `Intlit s -> (try Number (float_of_string s) with _ -> String s)
    | `Float f -> Number f
    | `String s -> String s
    | `List xs -> List (List.map value_of_json xs)
@@ -2872,7 +2811,6 @@ let run_spec_tests env test_files =
      match sx_vm_execute with
      | Some fn -> Sx_ref.cek_call fn (List args)
      | None -> Nil)));
-  load_module "stdlib.sx" spec_dir;   (* pure SX stdlib: format etc. *)
  load_module "signals.sx" spec_dir;  (* core reactive primitives *)
  load_module "signals.sx" web_dir;   (* web extensions *)
  load_module "freeze.sx" lib_dir;
--- a/hosts/ocaml/bin/sx_server.ml
+++ b/hosts/ocaml/bin/sx_server.ml
@@ -296,10 +296,6 @@ let read_blob () =
      (* consume trailing newline *)
      (try ignore (input_line stdin) with End_of_file -> ());
      data
-    | [List [Symbol "blob"; Integer n]] ->
-      let data = read_exact_bytes n in
-      (try ignore (input_line stdin) with End_of_file -> ());
-      data
    | _ -> raise (Eval_error ("read_blob: expected (blob N), got: " ^ line))

 (** Batch IO mode — collect requests during aser-slot, resolve after. *)
@@ -361,11 +357,6 @@ let rec read_io_response () =
    | [List (Symbol "io-response" :: Number n :: values)]
      when int_of_float n = !current_epoch ->
      (match values with [v] -> v | _ -> List values)
-    | [List [Symbol "io-response"; Integer n; value]]
-      when n = !current_epoch -> value
-    | [List (Symbol "io-response" :: Integer n :: values)]
-      when n = !current_epoch ->
-      (match values with [v] -> v | _ -> List values)
    (* Legacy untagged: (io-response value) — accept for backwards compat *)
    | [List [Symbol "io-response"; value]] -> value
    | [List (Symbol "io-response" :: values)] ->
@@ -405,12 +396,6 @@ let read_batched_io_response () =
        when int_of_float n = !current_epoch -> s
      | [List [Symbol "io-response"; Number n; v]]
        when int_of_float n = !current_epoch -> serialize_value v
-      | [List [Symbol "io-response"; Integer n; String s]]
-        when n = !current_epoch -> s
-      | [List [Symbol "io-response"; Integer n; SxExpr s]]
-        when n = !current_epoch -> s
-      | [List [Symbol "io-response"; Integer n; v]]
-        when n = !current_epoch -> serialize_value v
      (* Legacy untagged *)
      | [List [Symbol "io-response"; String s]]
      | [List [Symbol "io-response"; SxExpr s]] -> s
@@ -974,7 +959,6 @@ let setup_io_bridges env =
  bind "sleep" (fun args -> io_request "sleep" args);
  bind "set-response-status" (fun args -> match args with
    | [Number n] -> _pending_response_status := int_of_float n; Nil
-    | [Integer n] -> _pending_response_status := n; Nil
    | _ -> Nil);
  bind "set-response-header" (fun args -> io_request "set-response-header" args)

@@ -1377,7 +1361,6 @@ let rec dispatch env cmd =
        | Bool true -> "true"
        | Bool false -> "false"
        | Number n -> Sx_types.format_number n
-        | Integer n -> string_of_int n
        | String s -> "\"" ^ escape_sx_string s ^ "\""
        | Symbol s -> s
        | Keyword k -> ":" ^ k
@@ -1391,10 +1374,6 @@ let rec dispatch env cmd =
        | Island i -> "~" ^ i.i_name
        | SxExpr s -> s
        | RawHTML s -> "\"" ^ escape_sx_string s ^ "\""
-        | Char n -> Sx_types.inspect (Char n)
-        | Eof -> Sx_types.inspect Eof
-        | Port _ -> Sx_types.inspect result
-        | Rational (n, d) -> Printf.sprintf "%d/%d" n d
        | _ -> "nil"
      in
      send_ok_raw (raw_serialize result)
@@ -4471,8 +4450,6 @@ let site_mode () =
          match exprs with
          | [List [Symbol "epoch"; Number n]] ->
            current_epoch := int_of_float n
-          | [List [Symbol "epoch"; Integer n]] ->
-            current_epoch := n
          (* render-page: full SSR pipeline — URL → complete HTML *)
          | [List [Symbol "render-page"; String path]] ->
            (try match http_render_page env path [] with
@@ -4530,8 +4507,6 @@ let () =
            (* Epoch marker: (epoch N) — set current epoch, read next command *)
            | [List [Symbol "epoch"; Number n]] ->
              current_epoch := int_of_float n
-            | [List [Symbol "epoch"; Integer n]] ->
-              current_epoch := n
            | [cmd] -> dispatch env cmd
            | _ -> send_error ("Expected single command, got " ^ string_of_int (List.length exprs))
          end
--- a/hosts/ocaml/bootstrap.py
+++ b/hosts/ocaml/bootstrap.py
@@ -47,9 +47,7 @@ open Sx_runtime
 let trampoline_fn : (value -> value) ref = ref (fun v -> v)
 let trampoline v = !trampoline_fn v

-(* Step limit for timeout detection — set to 0 to disable *)
-let step_limit : int ref = ref 0
-let step_count : int ref = ref 0
+

 (* === Mutable globals — backing refs for transpiler's !_ref / _ref := === *)
 let _strict_ref = ref (Bool false)
@@ -128,90 +126,6 @@ let enhance_error_with_trace msg =
  _last_error_kont_ref := Nil;
  msg ^ (format_comp_trace trace)

-(* Hand-written sf_define_type — skipped from transpile because the spec uses
-   &rest params and empty-dict literals that the transpiler can't emit cleanly.
-   Implements: (define-type Name (Ctor1 f1 f2) (Ctor2 f3) ...)
-   Creates constructor fns, Name?/Ctor? predicates, Ctor-field accessors,
-   and records ctors in *adt-registry*. *)
-let sf_define_type args env_val =
-  let items = (match args with List l -> l | _ -> []) in
-  let type_sym = List.nth items 0 in
-  let type_name = value_to_string type_sym in
-  let ctor_specs = List.tl items in
-  let env_has_v k = sx_truthy (env_has env_val (String k)) in
-  let env_bind_v k v = ignore (env_bind env_val (String k) v) in
-  let env_get_v k = env_get env_val (String k) in
-  if not (env_has_v "*adt-registry*") then
-    env_bind_v "*adt-registry*" (Dict (Hashtbl.create 8));
-  let registry = env_get_v "*adt-registry*" in
-  let ctor_names = List.map (fun spec ->
-    (match spec with List (sym :: _) -> String (value_to_string sym) | _ -> Nil)
-  ) ctor_specs in
-  (match registry with Dict d -> Hashtbl.replace d type_name (List ctor_names) | _ -> ());
-  env_bind_v (type_name ^ "?")
-    (NativeFn (type_name ^ "?", fun pargs ->
-      (match pargs with
-      | [v] ->
-        (match v with
-        | Dict d -> Bool (Hashtbl.mem d "_adt" &&
-          (match Hashtbl.find_opt d "_type" with Some (String t) -> t = type_name | _ -> false))
-        | _ -> Bool false)
-      | _ -> Bool false)));
-  List.iter (fun spec ->
-    (match spec with
-    | List (sym :: fields) ->
-      let cn = value_to_string sym in
-      let field_names = List.map value_to_string fields in
-      let arity = List.length fields in
-      env_bind_v cn
-        (NativeFn (cn, fun ctor_args ->
-          if List.length ctor_args <> arity then
-            raise (Eval_error (Printf.sprintf "%s: expected %d args, got %d"
-              cn arity (List.length ctor_args)))
-          else begin
-            let d = Hashtbl.create 4 in
-            Hashtbl.replace d "_adt"    (Bool true);
-            Hashtbl.replace d "_type"   (String type_name);
-            Hashtbl.replace d "_ctor"   (String cn);
-            Hashtbl.replace d "_fields" (List ctor_args);
-            Dict d
-          end));
-      env_bind_v (cn ^ "?")
-        (NativeFn (cn ^ "?", fun pargs ->
-          (match pargs with
-          | [v] ->
-            (match v with
-            | Dict d -> Bool (Hashtbl.mem d "_adt" &&
-              (match Hashtbl.find_opt d "_ctor" with Some (String c) -> c = cn | _ -> false))
-            | _ -> Bool false)
-          | _ -> Bool false)));
-      List.iteri (fun idx fname ->
-        env_bind_v (cn ^ "-" ^ fname)
-          (NativeFn (cn ^ "-" ^ fname, fun pargs ->
-            (match pargs with
-            | [v] ->
-              (match v with
-              | Dict d ->
-                (match Hashtbl.find_opt d "_fields" with
-                | Some (List fs) ->
-                  if idx < List.length fs then List.nth fs idx
-                  else raise (Eval_error (cn ^ "-" ^ fname ^ ": index out of bounds"))
-                | _ -> raise (Eval_error (cn ^ "-" ^ fname ^ ": not an ADT")))
-              | _ -> raise (Eval_error (cn ^ "-" ^ fname ^ ": not a dict")))
-            | _ -> raise (Eval_error (cn ^ "-" ^ fname ^ ": expected 1 arg")))))
-      ) field_names
-    | _ -> ())
-  ) ctor_specs;
-  Nil
-
-(* Register define-type via custom_special_forms so the CEK dispatch finds it.
-   The top-level (register-special-form! ...) in spec/evaluator.sx is not a
-   define and therefore is not transpiled; we wire it up here instead. *)
-let () = ignore (register_special_form (String "define-type")
-  (NativeFn ("define-type", fun call_args ->
-    match call_args with
-    | [args; env] -> sf_define_type args env
-    | _ -> Nil)))


 """
@@ -257,10 +171,7 @@ def compile_spec_to_ml(spec_dir: str | None = None) -> str:
                "debug-log", "debug_log", "range", "chunk-every", "zip-pairs",
                "string-contains?", "starts-with?", "ends-with?",
                "string-replace", "trim", "split", "index-of",
-                "pad-left", "pad-right", "char-at", "substring",
-                # sf-define-type uses &rest + empty-dict literals that the transpiler
-                # can't emit as valid OCaml; hand-written implementation in FIXUPS.
-                "sf-define-type"}
+                "pad-left", "pad-right", "char-at", "substring"}
        defines = [(n, e) for n, e in defines if n not in skip]

        # Deduplicate — keep last definition for each name (CEK overrides tree-walk)
--- a/hosts/ocaml/lib/sx_parser.ml
+++ b/hosts/ocaml/lib/sx_parser.ml
@@ -89,38 +89,10 @@ let read_symbol s =
  while s.pos < s.len && is_symbol_char s.src.[s.pos] do advance s done;
  String.sub s.src start (s.pos - start)

-let gcd a b =
-  let rec g a b = if b = 0 then a else g b (a mod b) in g (abs a) (abs b)
-
-let make_rat n d =
-  if d = 0 then raise (Parse_error "rational: division by zero");
-  let sign = if d < 0 then -1 else 1 in
-  let g = gcd (abs n) (abs d) in
-  let rn = sign * n / g and rd = sign * d / g in
-  if rd = 1 then Integer rn else Rational (rn, rd)
-
 let try_number str =
-  (* Integers (no '.' or 'e'/'E') → exact Integer; rationals N/D; floats → inexact Number *)
-  let has_dec = String.contains str '.' in
-  let has_exp = String.contains str 'e' || String.contains str 'E' in
-  if has_dec || has_exp then
-    match float_of_string_opt str with
-    | Some n -> Some (Number n)
-    | None -> None
-  else
-    match String.split_on_char '/' str with
-    | [num_s; den_s] when num_s <> "" && den_s <> "" ->
-      (match int_of_string_opt num_s, int_of_string_opt den_s with
-       | Some n, Some d -> (try Some (make_rat n d) with _ -> None)
-       | _ -> None)
-    | _ ->
-      match int_of_string_opt str with
-      | Some n -> Some (Integer n)
-      | None ->
-        (* handles "nan", "inf", "-inf" *)
-        match float_of_string_opt str with
-        | Some n -> Some (Number n)
-        | None -> None
+  match float_of_string_opt str with
+  | Some n -> Some (Number n)
+  | None -> None

 let rec read_value s : value =
  skip_whitespace_and_comments s;
@@ -136,34 +108,6 @@ let rec read_value s : value =
  | '"' -> String (read_string s)
  | '\'' -> advance s; List [Symbol "quote"; read_value s]
  | '`' -> advance s; List [Symbol "quasiquote"; read_value s]
-  | '#' when s.pos + 1 < s.len && s.src.[s.pos + 1] = '\\' ->
-    (* Character literal: #\a, #\space, #\newline, etc. *)
-    advance s; advance s;
-    if at_end s then raise (Parse_error "Unexpected end of input after #\\");
-    let char_start = s.pos in
-    (* Read a name if starts with ident char, else single char *)
-    if is_ident_start s.src.[s.pos] then begin
-      while s.pos < s.len && is_ident_char s.src.[s.pos] do advance s done;
-      let name = String.sub s.src char_start (s.pos - char_start) in
-      let cp = match name with
-        | "space" -> 32 | "newline" -> 10 | "tab" -> 9
-        | "return" -> 13 | "nul" -> 0 | "null" -> 0
-        | "escape" -> 27 | "delete" -> 127 | "backspace" -> 8
-        | "altmode" -> 27 | "rubout" -> 127
-        | _ -> Char.code name.[0]  (* single letter like #\a *)
-      in Char cp
-    end else begin
-      let c = s.src.[s.pos] in
-      advance s;
-      Char (Char.code c)
-    end
-  | '#' when s.pos + 1 < s.len &&
-             (s.src.[s.pos + 1] = 't' || s.src.[s.pos + 1] = 'f') &&
-             (s.pos + 2 >= s.len || not (is_ident_char s.src.[s.pos + 2])) ->
-    (* #t / #f — boolean literals (R7RS shorthand) *)
-    let b = s.src.[s.pos + 1] = 't' in
-    advance s; advance s;
-    Bool b
  | '#' when s.pos + 1 < s.len && s.src.[s.pos + 1] = ';' ->
    (* Datum comment: #; discards next expression *)
    advance s; advance s;
--- a/hosts/ocaml/lib/sx_primitives.ml
+++ b/hosts/ocaml/lib/sx_primitives.ml
--- a/hosts/ocaml/lib/sx_ref.ml
+++ b/hosts/ocaml/lib/sx_ref.ml
--- a/hosts/ocaml/lib/sx_runtime.ml
+++ b/hosts/ocaml/lib/sx_runtime.ml
@@ -46,7 +46,7 @@ let sx_call f args =
    !Sx_types._cek_eval_lambda_ref f args
  | Continuation (k, _) ->
    k (match args with x :: _ -> x | [] -> Nil)
-  | CallccContinuation (_, _) ->
+  | CallccContinuation _ ->
    raise (Eval_error "callcc continuations must be invoked through the CEK machine")
  | _ ->
    let nargs = List.length args in
@@ -156,9 +156,6 @@ let get_val container key =
     | "extra" -> f.cf_extra | "extra2" -> f.cf_extra2
     | "subscribers" -> f.cf_results
     | "prev-tracking" -> f.cf_extra
-     | "after-thunk" -> f.cf_f        (* wind-after frame *)
-     | "winders-len" -> f.cf_extra    (* wind-after frame *)
-     | "body-result" -> f.cf_name     (* wind-return frame *)
     | _ -> Nil)
  | VmFrame f, String k ->
    (match k with
@@ -211,8 +208,6 @@ let get_val container key =
  | Dict d, Keyword k -> dict_get d k
  | (List l | ListRef { contents = l }), Number n ->
    (try List.nth l (int_of_float n) with _ -> Nil)
-  | (List l | ListRef { contents = l }), Integer n ->
-    (try List.nth l n with _ -> Nil)
  | Nil, _ -> Nil  (* nil.anything → nil *)
  | _, _ -> Nil    (* type mismatch → nil (matches JS/Python behavior) *)

@@ -386,20 +381,15 @@ let continuation_data v = match v with
  | _ -> raise (Eval_error "not a continuation")

 (* Callcc (undelimited) continuation support *)
-let callcc_continuation_p v = match v with CallccContinuation (_, _) -> Bool true | _ -> Bool false
+let callcc_continuation_p v = match v with CallccContinuation _ -> Bool true | _ -> Bool false

-let make_callcc_continuation captured winders_len =
-  let n = match winders_len with Number f -> int_of_float f | Integer n -> n | _ -> 0 in
-  CallccContinuation (sx_to_list captured, n)
+let make_callcc_continuation captured =
+  CallccContinuation (sx_to_list captured)

 let callcc_continuation_data v = match v with
-  | CallccContinuation (frames, _) -> List frames
+  | CallccContinuation frames -> List frames
  | _ -> raise (Eval_error "not a callcc continuation")

-let callcc_continuation_winders_len v = match v with
-  | CallccContinuation (_, n) -> Number (float_of_int n)
-  | _ -> Number 0.0
-
 (* Dynamic wind — simplified for OCaml (no async) *)
 let host_error msg =
  raise (Eval_error (value_to_str msg))
--- a/hosts/ocaml/lib/sx_types.ml
+++ b/hosts/ocaml/lib/sx_types.ml
@@ -43,10 +43,9 @@ type env = {

 and value =
  | Nil
-  | Bool    of bool
-  | Integer of int    (** Exact integer — distinct from inexact float. *)
-  | Number  of float  (** Inexact float. *)
-  | String  of string
+  | Bool   of bool
+  | Number of float
+  | String of string
  | Symbol of string
  | Keyword of string
  | List   of value list
@@ -57,7 +56,7 @@ and value =
  | Macro  of macro
  | Thunk  of value * env
  | Continuation of (value -> value) * dict option
-  | CallccContinuation of value list * int  (** Undelimited continuation — captured kont frames + winders depth at capture *)
+  | CallccContinuation of value list  (** Undelimited continuation — captured kont frames *)
  | NativeFn of string * (value list -> value)
  | Signal of signal
  | RawHTML of string
@@ -73,25 +72,6 @@ and value =
  | Record of record  (** R7RS record — opaque, generative, field-indexed. *)
  | Parameter of parameter  (** R7RS parameter — dynamic binding via kont-stack provide frames. *)
  | Vector of value array  (** R7RS vector — mutable fixed-size array. *)
-  | StringBuffer of Buffer.t  (** Mutable string buffer — O(1) amortized append. *)
-  | HashTable of (value, value) Hashtbl.t  (** Mutable hash table with arbitrary keys. *)
-  | Char of int  (** Unicode codepoint — R7RS char type. *)
-  | Eof            (** EOF sentinel — returned by read-char etc. at end of input. *)
-  | Port of sx_port  (** String port — input (string cursor) or output (buffer). *)
-  | Rational of int * int  (** Exact rational: numerator, denominator (reduced, denom>0). *)
-  | SxSet of (string, value) Hashtbl.t  (** Mutable set keyed by inspect(value). *)
-  | SxRegexp of string * string * Re.re  (** Regexp: source, flags, compiled. *)
-  | SxBytevector of bytes  (** Mutable bytevector — R7RS bytevector type. *)
-
-(** String input port: source string + mutable cursor position. *)
-and sx_port_kind =
-  | PortInput of string * int ref
-  | PortOutput of Buffer.t
-
-and sx_port = {
-  mutable sp_closed : bool;
-  sp_kind : sx_port_kind;
-}

 (** CEK machine state — record instead of Dict for performance.
    5 fields × 55K steps/sec = 275K Hashtbl allocations/sec eliminated. *)
@@ -412,7 +392,6 @@ let format_number n =

 let value_to_string = function
  | String s -> s | Symbol s -> s | Keyword k -> k
-  | Integer n -> string_of_int n
  | Number n -> format_number n
  | Bool true -> "true" | Bool false -> "false"
  | Nil -> "" | _ -> "<value>"
@@ -482,7 +461,6 @@ let make_keyword name = Keyword (value_to_string name)
 let type_of = function
  | Nil            -> "nil"
  | Bool _         -> "boolean"
-  | Integer _      -> "number"
  | Number _       -> "number"
  | String _       -> "string"
  | Symbol _       -> "symbol"
@@ -495,7 +473,7 @@ let type_of = function
  | Macro _        -> "macro"
  | Thunk _        -> "thunk"
  | Continuation (_, _) -> "continuation"
-  | CallccContinuation (_, _) -> "continuation"
+  | CallccContinuation _ -> "continuation"
  | NativeFn _     -> "function"
  | Signal _       -> "signal"
  | RawHTML _      -> "raw-html"
@@ -510,16 +488,6 @@ let type_of = function
  | Record r       -> r.r_type.rt_name
  | Parameter _    -> "parameter"
  | Vector _       -> "vector"
-  | StringBuffer _ -> "string-buffer"
-  | HashTable _    -> "hash-table"
-  | Char _         -> "char"
-  | Eof            -> "eof-object"
-  | Port { sp_kind = PortInput _; _ }  -> "input-port"
-  | Port { sp_kind = PortOutput _; _ } -> "output-port"
-  | Rational _  -> "rational"
-  | SxSet _          -> "set"
-  | SxRegexp _       -> "regexp"
-  | SxBytevector _   -> "bytevector"

 let is_nil = function Nil -> true | _ -> false
 let is_lambda = function Lambda _ -> true | _ -> false
@@ -535,7 +503,7 @@ let is_signal = function
 let is_record = function Record _ -> true | _ -> false

 let is_callable = function
-  | Lambda _ | NativeFn _ | Continuation (_, _) | CallccContinuation (_, _) | VmClosure _ -> true
+  | Lambda _ | NativeFn _ | Continuation (_, _) | CallccContinuation _ | VmClosure _ -> true
  | _ -> false


@@ -648,7 +616,6 @@ let thunk_env = function
 (** {1 Record operations} *)

 let val_to_int = function
-  | Integer n -> n
  | Number n -> int_of_float n
  | v -> raise (Eval_error ("Expected number, got " ^ type_of v))

@@ -810,7 +777,6 @@ let rec inspect = function
  | Nil -> "nil"
  | Bool true -> "true"
  | Bool false -> "false"
-  | Integer n -> string_of_int n
  | Number n -> format_number n
  | String s ->
    let buf = Buffer.create (String.length s + 2) in
@@ -844,7 +810,7 @@ let rec inspect = function
    Printf.sprintf "<%s(%s)>" tag (String.concat ", " m.m_params)
  | Thunk _ -> "<thunk>"
  | Continuation (_, _) -> "<continuation>"
-  | CallccContinuation (_, _) -> "<callcc-continuation>"
+  | CallccContinuation _ -> "<callcc-continuation>"
  | NativeFn (name, _) -> Printf.sprintf "<native:%s>" name
  | Signal _ -> "<signal>"
  | RawHTML s -> Printf.sprintf "\"<raw-html:%d>\"" (String.length s)
@@ -865,23 +831,3 @@ let rec inspect = function
    Printf.sprintf "#(%s)" (String.concat " " elts)
  | VmFrame f -> Printf.sprintf "<vm-frame:ip=%d base=%d>" f.vf_ip f.vf_base
  | VmMachine m -> Printf.sprintf "<vm-machine:sp=%d frames=%d>" m.vm_sp (List.length m.vm_frames)
-  | StringBuffer buf -> Printf.sprintf "<string-buffer:%d>" (Buffer.length buf)
-  | HashTable ht -> Printf.sprintf "<hash-table:%d>" (Hashtbl.length ht)
-  | Char n ->
-    let name = match n with
-      | 32 -> "space" | 10 -> "newline" | 9 -> "tab"
-      | 13 -> "return" | 0 -> "nul" | 27 -> "escape"
-      | 127 -> "delete" | 8 -> "backspace"
-      | _ -> let buf = Buffer.create 1 in
-             Buffer.add_utf_8_uchar buf (Uchar.of_int n);
-             Buffer.contents buf
-    in "#\\" ^ name
-  | Eof -> "#!eof"
-  | Port { sp_kind = PortInput (_, pos); sp_closed } ->
-    Printf.sprintf "<input-port:pos=%d%s>" !pos (if sp_closed then ":closed" else "")
-  | Port { sp_kind = PortOutput buf; sp_closed } ->
-    Printf.sprintf "<output-port:len=%d%s>" (Buffer.length buf) (if sp_closed then ":closed" else "")
-  | Rational (n, d) -> Printf.sprintf "%d/%d" n d
-  | SxSet ht -> Printf.sprintf "<set:%d>" (Hashtbl.length ht)
-  | SxRegexp (src, flags, _) -> Printf.sprintf "#/%s/%s" src flags
-  | SxBytevector b -> Printf.sprintf "#u8(%s)" (String.concat " " (List.init (Bytes.length b) (fun i -> string_of_int (Char.code (Bytes.get b i)))))
--- a/hosts/ocaml/lib/sx_vm.ml
+++ b/hosts/ocaml/lib/sx_vm.ml
@@ -185,8 +185,7 @@ let code_from_value v =
      | Some _ as r -> r | None -> Hashtbl.find_opt d k2 in
    let bc_list = match find2 "bytecode" "vc-bytecode" with
      | Some (List l | ListRef { contents = l }) ->
-        Array.of_list (List.map (fun x -> match x with
-          | Integer n -> n | Number n -> int_of_float n | _ -> 0) l)
+        Array.of_list (List.map (fun x -> match x with Number n -> int_of_float n | _ -> 0) l)
      | _ -> [||]
    in
    let entries = match find2 "constants" "vc-constants" with
@@ -199,10 +198,10 @@ let code_from_value v =
      | _ -> entry
    ) entries in
    let arity = match find2 "arity" "vc-arity" with
-      | Some (Integer n) -> n | Some (Number n) -> int_of_float n | _ -> 0
+      | Some (Number n) -> int_of_float n | _ -> 0
    in
    let rest_arity = match find2 "rest-arity" "vc-rest-arity" with
-      | Some (Integer n) -> n | Some (Number n) -> int_of_float n | _ -> -1
+      | Some (Number n) -> int_of_float n | _ -> -1
    in
    (* Compute locals from bytecode: scan for highest LOCAL_GET/LOCAL_SET slot.
       The compiler's arity may undercount when nested lets add many locals. *)
@@ -750,7 +749,10 @@ and run vm =
            | _ -> (Hashtbl.find Sx_primitives.primitives "/") [a; b])
        | 164 (* OP_EQ *) ->
          let b = pop vm and a = pop vm in
-          push vm ((Hashtbl.find Sx_primitives.primitives "=") [a; b])
+          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
@@ -769,10 +771,10 @@ and run vm =
        | 168 (* OP_LEN *) ->
          let v = pop vm in
          push vm (match v with
-            | List l | ListRef { contents = l } -> Integer (List.length l)
-            | String s -> Integer (String.length s)
-            | Dict d -> Integer (Hashtbl.length d)
-            | Nil -> Integer 0
+            | List l | ListRef { contents = l } -> Number (float_of_int (List.length l))
+            | String s -> Number (float_of_int (String.length s))
+            | Dict d -> Number (float_of_int (Hashtbl.length d))
+            | Nil -> Number 0.0
            | _ -> (Hashtbl.find Sx_primitives.primitives "len") [v])
        | 169 (* OP_FIRST *) ->
          let v = pop vm in
--- a/hosts/ocaml/transpiler.sx
+++ b/hosts/ocaml/transpiler.sx
@@ -256,7 +256,6 @@
    "callcc-continuation?"
    "callcc-continuation-data"
    "make-callcc-continuation"
-    "callcc-continuation-winders-len"
    "dynamic-wind-call"
    "strip-prefix"
    "component-set-param-types!"
@@ -296,8 +295,7 @@
    "*bind-tracking*"
    "*provide-batch-depth*"
    "*provide-batch-queue*"
-    "*provide-subscribers*"
-    "*winders*"))
+    "*provide-subscribers*"))

 (define
  ml-is-mutable-global?
@@ -535,13 +533,13 @@
              "; cf_env = "
              (ef "env")
              "; cf_name = "
-              (if (= frame-type "if") (ef "else") (cond (some (fn (k) (= k "body-result")) items) (ef "body-result") :else (ef "name")))
+              (if (= frame-type "if") (ef "else") (ef "name"))
              "; cf_body = "
              (if (= frame-type "if") (ef "then") (ef "body"))
              "; cf_remaining = "
              (ef "remaining")
              "; cf_f = "
-              (cond (some (fn (k) (= k "after-thunk")) items) (ef "after-thunk") (some (fn (k) (= k "f")) items) (ef "f") :else "Nil")
+              (ef "f")
              "; cf_args = "
              (cond
                (some (fn (k) (= k "evaled")) items)
@@ -584,8 +582,6 @@
                (ef "prev-tracking")
                (some (fn (k) (= k "extra")) items)
                (ef "extra")
-                (some (fn (k) (= k "winders-len")) items)
-                (ef "winders-len")
                :else "Nil")
              "; cf_extra2 = "
              (cond
--- a/lib/apl/runtime.sx
+++ b/lib/apl/runtime.sx
@@ -1,289 +0,0 @@
-;; lib/apl/runtime.sx — APL primitives on SX
-;;
-;; APL vectors are represented as SX lists (functional, immutable results).
-;; Operations are rank-polymorphic: scalar/vector arguments both accepted.
-;; Index origin: 1 (traditional APL).
-;;
-;; Primitives used:
-;;   map (multi-arg, Phase 1)
-;;   bitwise-and/or/xor/not/arithmetic-shift (Phase 7)
-;;   make-set/set-member?/set-add!/set->list (Phase 18)
-
-;; ---------------------------------------------------------------------------
-;; 1. Core vector constructors
-;; ---------------------------------------------------------------------------
-
-;; ⍳N — iota: generate integer vector 1, 2, ..., N
-(define
-  (apl-iota n)
-  (letrec
-    ((go (fn (i acc) (if (< i 1) acc (go (- i 1) (cons i acc))))))
-    (go n (list))))
-
-;; ⍴A — shape (length of a vector)
-(define (apl-rho v) (if (list? v) (len v) 1))
-
-;; A[I] — 1-indexed access
-(define (apl-at v i) (nth v (- i 1)))
-
-;; Scalar predicate
-(define (apl-scalar? v) (not (list? v)))
-
-;; ---------------------------------------------------------------------------
-;; 2. Rank-polymorphic helpers
-;;    dyadic: scalar/vector × scalar/vector → scalar/vector
-;;    monadic: scalar/vector → scalar/vector
-;; ---------------------------------------------------------------------------
-
-(define
-  (apl-dyadic op a b)
-  (cond
-    ((and (list? a) (list? b)) (map op a b))
-    ((list? a) (map (fn (x) (op x b)) a))
-    ((list? b) (map (fn (y) (op a y)) b))
-    (else (op a b))))
-
-(define (apl-monadic op a) (if (list? a) (map op a) (op a)))
-
-;; ---------------------------------------------------------------------------
-;; 3. Arithmetic (element-wise, rank-polymorphic)
-;; ---------------------------------------------------------------------------
-
-(define (apl-add a b) (apl-dyadic + a b))
-(define (apl-sub a b) (apl-dyadic - a b))
-(define (apl-mul a b) (apl-dyadic * a b))
-(define (apl-div a b) (apl-dyadic / a b))
-(define (apl-mod a b) (apl-dyadic modulo a b))
-(define (apl-pow a b) (apl-dyadic pow a b))
-(define (apl-max a b) (apl-dyadic (fn (x y) (if (> x y) x y)) a b))
-(define (apl-min a b) (apl-dyadic (fn (x y) (if (< x y) x y)) a b))
-
-(define (apl-neg a) (apl-monadic (fn (x) (- 0 x)) a))
-(define (apl-abs a) (apl-monadic abs a))
-(define (apl-floor a) (apl-monadic floor a))
-(define (apl-ceil a) (apl-monadic ceil a))
-(define (apl-sqrt a) (apl-monadic sqrt a))
-(define (apl-exp a) (apl-monadic exp a))
-(define (apl-log a) (apl-monadic log a))
-
-;; ---------------------------------------------------------------------------
-;; 4. Comparison (element-wise, returns 0/1 booleans)
-;; ---------------------------------------------------------------------------
-
-(define (apl-bool v) (if v 1 0))
-
-(define (apl-eq a b) (apl-dyadic (fn (x y) (apl-bool (= x y))) a b))
-(define
-  (apl-neq a b)
-  (apl-dyadic (fn (x y) (apl-bool (not (= x y)))) a b))
-(define (apl-lt a b) (apl-dyadic (fn (x y) (apl-bool (< x y))) a b))
-(define (apl-le a b) (apl-dyadic (fn (x y) (apl-bool (<= x y))) a b))
-(define (apl-gt a b) (apl-dyadic (fn (x y) (apl-bool (> x y))) a b))
-(define (apl-ge a b) (apl-dyadic (fn (x y) (apl-bool (>= x y))) a b))
-
-;; Boolean logic (0/1 vectors)
-(define
-  (apl-and a b)
-  (apl-dyadic
-    (fn
-      (x y)
-      (if
-        (and (not (= x 0)) (not (= y 0)))
-        1
-        0))
-    a
-    b))
-(define
-  (apl-or a b)
-  (apl-dyadic
-    (fn
-      (x y)
-      (if
-        (or (not (= x 0)) (not (= y 0)))
-        1
-        0))
-    a
-    b))
-(define
-  (apl-not a)
-  (apl-monadic (fn (x) (if (= x 0) 1 0)) a))
-
-;; ---------------------------------------------------------------------------
-;; 5. Bitwise operations (element-wise)
-;; ---------------------------------------------------------------------------
-
-(define (apl-bitand a b) (apl-dyadic bitwise-and a b))
-(define (apl-bitor a b) (apl-dyadic bitwise-or a b))
-(define (apl-bitxor a b) (apl-dyadic bitwise-xor a b))
-(define (apl-bitnot a) (apl-monadic bitwise-not a))
-(define
-  (apl-lshift a b)
-  (apl-dyadic (fn (x n) (arithmetic-shift x n)) a b))
-(define
-  (apl-rshift a b)
-  (apl-dyadic (fn (x n) (arithmetic-shift x (- 0 n))) a b))
-
-;; ---------------------------------------------------------------------------
-;; 6. Reduction (fold) and scan
-;; ---------------------------------------------------------------------------
-
-(define (apl-reduce-add v) (reduce + 0 v))
-(define (apl-reduce-mul v) (reduce * 1 v))
-(define
-  (apl-reduce-max v)
-  (reduce (fn (acc x) (if (> acc x) acc x)) (first v) (rest v)))
-(define
-  (apl-reduce-min v)
-  (reduce (fn (acc x) (if (< acc x) acc x)) (first v) (rest v)))
-(define
-  (apl-reduce-and v)
-  (reduce
-    (fn
-      (acc x)
-      (if
-        (and (not (= acc 0)) (not (= x 0)))
-        1
-        0))
-    1
-    v))
-(define
-  (apl-reduce-or v)
-  (reduce
-    (fn
-      (acc x)
-      (if
-        (or (not (= acc 0)) (not (= x 0)))
-        1
-        0))
-    0
-    v))
-
-;; Scan: prefix reduction (yields a vector of running totals)
-(define
-  (apl-scan op v)
-  (if
-    (= (len v) 0)
-    (list)
-    (letrec
-      ((go (fn (xs acc result) (if (= (len xs) 0) (reverse result) (let ((next (op acc (first xs)))) (go (rest xs) next (cons next result)))))))
-      (go (rest v) (first v) (list (first v))))))
-
-(define (apl-scan-add v) (apl-scan + v))
-(define (apl-scan-mul v) (apl-scan * v))
-
-;; ---------------------------------------------------------------------------
-;; 7. Vector manipulation
-;; ---------------------------------------------------------------------------
-
-;; ⌽A — reverse
-(define (apl-reverse v) (reverse v))
-
-;; A,B — catenate
-(define
-  (apl-cat a b)
-  (cond
-    ((and (list? a) (list? b)) (append a b))
-    ((list? a) (append a (list b)))
-    ((list? b) (cons a b))
-    (else (list a b))))
-
-;; ↑N A — take first N elements (negative: take last N)
-(define
-  (apl-take n v)
-  (if
-    (>= n 0)
-    (letrec
-      ((go (fn (xs i) (if (or (= i 0) (= (len xs) 0)) (list) (cons (first xs) (go (rest xs) (- i 1)))))))
-      (go v n))
-    (apl-reverse (apl-take (- 0 n) (apl-reverse v)))))
-
-;; ↓N A — drop first N elements
-(define
-  (apl-drop n v)
-  (if
-    (>= n 0)
-    (letrec
-      ((go (fn (xs i) (if (or (= i 0) (= (len xs) 0)) xs (go (rest xs) (- i 1))))))
-      (go v n))
-    (apl-reverse (apl-drop (- 0 n) (apl-reverse v)))))
-
-;; Rotate left by n positions
-(define
-  (apl-rotate n v)
-  (let ((m (modulo n (len v)))) (append (apl-drop m v) (apl-take m v))))
-
-;; Compression: A/B — select elements of B where A is 1
-(define
-  (apl-compress mask v)
-  (if
-    (= (len mask) 0)
-    (list)
-    (let
-      ((rest-result (apl-compress (rest mask) (rest v))))
-      (if
-        (not (= (first mask) 0))
-        (cons (first v) rest-result)
-        rest-result))))
-
-;; Indexing: A[B] — select elements at indices B (1-indexed)
-(define (apl-index v indices) (map (fn (i) (apl-at v i)) indices))
-
-;; Grade up: indices that would sort the vector ascending
-(define
-  (apl-grade-up v)
-  (let
-    ((indexed (map (fn (x i) (list x i)) v (apl-iota (len v)))))
-    (map (fn (p) (nth p 1)) (sort indexed))))
-
-;; ---------------------------------------------------------------------------
-;; 8. Set operations (∊ ∪ ∩ ~)
-;; ---------------------------------------------------------------------------
-
-;; Membership ∊: for each element in A, is it in B? → 0/1 vector
-(define
-  (apl-member a b)
-  (let
-    ((bset (let ((s (make-set))) (for-each (fn (x) (set-add! s x)) b) s)))
-    (if
-      (list? a)
-      (map (fn (x) (apl-bool (set-member? bset x))) a)
-      (apl-bool (set-member? bset a)))))
-
-;; Nub ∪A — unique elements, preserving order
-(define
-  (apl-nub v)
-  (let
-    ((seen (make-set)))
-    (letrec
-      ((go (fn (xs acc) (if (= (len xs) 0) (reverse acc) (if (set-member? seen (first xs)) (go (rest xs) acc) (begin (set-add! seen (first xs)) (go (rest xs) (cons (first xs) acc))))))))
-      (go v (list)))))
-
-;; Union A∪B — nub of concatenation
-(define (apl-union a b) (apl-nub (apl-cat a b)))
-
-;; Intersection A∩B
-(define
-  (apl-intersect a b)
-  (let
-    ((bset (let ((s (make-set))) (for-each (fn (x) (set-add! s x)) b) s)))
-    (filter (fn (x) (set-member? bset x)) a)))
-
-;; Without A~B
-(define
-  (apl-without a b)
-  (let
-    ((bset (let ((s (make-set))) (for-each (fn (x) (set-add! s x)) b) s)))
-    (filter (fn (x) (not (set-member? bset x))) a)))
-
-;; ---------------------------------------------------------------------------
-;; 9. Format (⍕) — APL-style display
-;; ---------------------------------------------------------------------------
-
-(define
-  (apl-format v)
-  (if
-    (list? v)
-    (letrec
-      ((go (fn (xs acc) (if (= (len xs) 0) acc (go (rest xs) (str acc (if (= acc "") "" " ") (str (first xs))))))))
-      (go v ""))
-    (str v)))
--- a/lib/apl/test.sh
+++ b/lib/apl/test.sh
@@ -1,51 +0,0 @@
-#!/usr/bin/env bash
-# lib/apl/test.sh — smoke-test the APL runtime layer.
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found."
-  exit 1
-fi
-
-TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT
-
-cat > "$TMPFILE" << 'EPOCHS'
-(epoch 1)
-(load "spec/stdlib.sx")
-(load "lib/apl/runtime.sx")
-(epoch 2)
-(load "lib/apl/tests/runtime.sx")
-(epoch 3)
-(eval "(list apl-test-pass apl-test-fail)")
-EPOCHS
-
-OUTPUT=$(timeout 60 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
-
-LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 3 / {getline; print; exit}')
-if [ -z "$LINE" ]; then
-  LINE=$(echo "$OUTPUT" | grep -E '^\(ok 3 \([0-9]+ [0-9]+\)\)' | tail -1 \
-          | sed -E 's/^\(ok 3 //; s/\)$//')
-fi
-if [ -z "$LINE" ]; then
-  echo "ERROR: could not extract summary"
-  echo "$OUTPUT" | tail -10
-  exit 1
-fi
-
-P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
-F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
-TOTAL=$((P + F))
-
-if [ "$F" -eq 0 ]; then
-  echo "ok $P/$TOTAL lib/apl tests passed"
-else
-  echo "FAIL $P/$TOTAL passed, $F failed"
-fi
-
-[ "$F" -eq 0 ]
--- a/lib/apl/tests/runtime.sx
+++ b/lib/apl/tests/runtime.sx
@@ -1,327 +0,0 @@
-;; lib/apl/tests/runtime.sx — Tests for lib/apl/runtime.sx
-
-;; --- Test framework ---
-(define apl-test-pass 0)
-(define apl-test-fail 0)
-(define apl-test-fails (list))
-
-(define
-  (apl-test name got expected)
-  (if
-    (= got expected)
-    (set! apl-test-pass (+ apl-test-pass 1))
-    (begin
-      (set! apl-test-fail (+ apl-test-fail 1))
-      (set! apl-test-fails (append apl-test-fails (list {:got got :expected expected :name name}))))))
-
-;; ---------------------------------------------------------------------------
-;; 1. Core vector constructors
-;; ---------------------------------------------------------------------------
-
-(apl-test
-  "iota 5"
-  (apl-iota 5)
-  (list 1 2 3 4 5))
-(apl-test "iota 1" (apl-iota 1) (list 1))
-(apl-test "iota 0" (apl-iota 0) (list))
-(apl-test
-  "rho list"
-  (apl-rho (list 1 2 3))
-  3)
-(apl-test "rho scalar" (apl-rho 42) 1)
-(apl-test
-  "at 1"
-  (apl-at (list 10 20 30) 1)
-  10)
-(apl-test
-  "at 3"
-  (apl-at (list 10 20 30) 3)
-  30)
-
-;; ---------------------------------------------------------------------------
-;; 2. Arithmetic — element-wise and rank-polymorphic
-;; ---------------------------------------------------------------------------
-
-(apl-test
-  "add v+v"
-  (apl-add
-    (list 1 2 3)
-    (list 10 20 30))
-  (list 11 22 33))
-(apl-test
-  "add s+v"
-  (apl-add 10 (list 1 2 3))
-  (list 11 12 13))
-(apl-test
-  "add v+s"
-  (apl-add (list 1 2 3) 100)
-  (list 101 102 103))
-(apl-test "add s+s" (apl-add 3 4) 7)
-(apl-test
-  "sub v-v"
-  (apl-sub
-    (list 5 4 3)
-    (list 1 2 3))
-  (list 4 2 0))
-(apl-test
-  "mul v*s"
-  (apl-mul (list 1 2 3) 3)
-  (list 3 6 9))
-(apl-test
-  "neg -v"
-  (apl-neg (list 1 -2 3))
-  (list -1 2 -3))
-(apl-test
-  "abs v"
-  (apl-abs (list -1 2 -3))
-  (list 1 2 3))
-(apl-test
-  "floor v"
-  (apl-floor (list 1.7 2.2 3.9))
-  (list 1 2 3))
-(apl-test
-  "ceil v"
-  (apl-ceil (list 1.1 2.5 3))
-  (list 2 3 3))
-(apl-test
-  "max v v"
-  (apl-max
-    (list 1 5 3)
-    (list 4 2 6))
-  (list 4 5 6))
-(apl-test
-  "min v v"
-  (apl-min
-    (list 1 5 3)
-    (list 4 2 6))
-  (list 1 2 3))
-
-;; ---------------------------------------------------------------------------
-;; 3. Comparison (returns 0/1)
-;; ---------------------------------------------------------------------------
-
-(apl-test "eq 3 3" (apl-eq 3 3) 1)
-(apl-test "eq 3 4" (apl-eq 3 4) 0)
-(apl-test
-  "gt v>s"
-  (apl-gt (list 1 5 3 7) 4)
-  (list 0 1 0 1))
-(apl-test
-  "lt v<v"
-  (apl-lt
-    (list 1 2 3)
-    (list 3 2 1))
-  (list 1 0 0))
-(apl-test
-  "le v<=s"
-  (apl-le (list 3 4 5) 4)
-  (list 1 1 0))
-(apl-test
-  "ge v>=s"
-  (apl-ge (list 3 4 5) 4)
-  (list 0 1 1))
-(apl-test
-  "neq v!=s"
-  (apl-neq (list 1 2 3) 2)
-  (list 1 0 1))
-
-;; ---------------------------------------------------------------------------
-;; 4. Boolean logic (0/1 values)
-;; ---------------------------------------------------------------------------
-
-(apl-test "and 1 1" (apl-and 1 1) 1)
-(apl-test "and 1 0" (apl-and 1 0) 0)
-(apl-test "or 0 1" (apl-or 0 1) 1)
-(apl-test "or 0 0" (apl-or 0 0) 0)
-(apl-test "not 0" (apl-not 0) 1)
-(apl-test "not 1" (apl-not 1) 0)
-(apl-test
-  "not vec"
-  (apl-not (list 1 0 1 0))
-  (list 0 1 0 1))
-
-;; ---------------------------------------------------------------------------
-;; 5. Bitwise operations
-;; ---------------------------------------------------------------------------
-
-(apl-test "bitand s" (apl-bitand 5 3) 1)
-(apl-test "bitor s" (apl-bitor 5 3) 7)
-(apl-test "bitxor s" (apl-bitxor 5 3) 6)
-(apl-test "bitnot 0" (apl-bitnot 0) -1)
-(apl-test "lshift 1 4" (apl-lshift 1 4) 16)
-(apl-test "rshift 16 2" (apl-rshift 16 2) 4)
-(apl-test
-  "bitand vec"
-  (apl-bitand (list 5 6) (list 3 7))
-  (list 1 6))
-(apl-test
-  "bitor vec"
-  (apl-bitor (list 5 6) (list 3 7))
-  (list 7 7))
-
-;; ---------------------------------------------------------------------------
-;; 6. Reduction and scan
-;; ---------------------------------------------------------------------------
-
-(apl-test
-  "reduce-add"
-  (apl-reduce-add
-    (list 1 2 3 4 5))
-  15)
-(apl-test
-  "reduce-mul"
-  (apl-reduce-mul (list 1 2 3 4))
-  24)
-(apl-test
-  "reduce-max"
-  (apl-reduce-max
-    (list 3 1 4 1 5))
-  5)
-(apl-test
-  "reduce-min"
-  (apl-reduce-min
-    (list 3 1 4 1 5))
-  1)
-(apl-test
-  "reduce-and"
-  (apl-reduce-and (list 1 1 1))
-  1)
-(apl-test
-  "reduce-and0"
-  (apl-reduce-and (list 1 0 1))
-  0)
-(apl-test
-  "reduce-or"
-  (apl-reduce-or (list 0 1 0))
-  1)
-(apl-test
-  "scan-add"
-  (apl-scan-add (list 1 2 3 4))
-  (list 1 3 6 10))
-(apl-test
-  "scan-mul"
-  (apl-scan-mul (list 1 2 3 4))
-  (list 1 2 6 24))
-
-;; ---------------------------------------------------------------------------
-;; 7. Vector manipulation
-;; ---------------------------------------------------------------------------
-
-(apl-test
-  "reverse"
-  (apl-reverse (list 1 2 3 4))
-  (list 4 3 2 1))
-(apl-test
-  "cat v v"
-  (apl-cat (list 1 2) (list 3 4))
-  (list 1 2 3 4))
-(apl-test
-  "cat v s"
-  (apl-cat (list 1 2) 3)
-  (list 1 2 3))
-(apl-test
-  "cat s v"
-  (apl-cat 1 (list 2 3))
-  (list 1 2 3))
-(apl-test
-  "cat s s"
-  (apl-cat 1 2)
-  (list 1 2))
-(apl-test
-  "take 3"
-  (apl-take
-    3
-    (list 10 20 30 40 50))
-  (list 10 20 30))
-(apl-test
-  "take 0"
-  (apl-take 0 (list 1 2 3))
-  (list))
-(apl-test
-  "take neg"
-  (apl-take -2 (list 10 20 30))
-  (list 20 30))
-(apl-test
-  "drop 2"
-  (apl-drop 2 (list 10 20 30 40))
-  (list 30 40))
-(apl-test
-  "drop neg"
-  (apl-drop -1 (list 10 20 30))
-  (list 10 20))
-(apl-test
-  "rotate 2"
-  (apl-rotate
-    2
-    (list 1 2 3 4 5))
-  (list 3 4 5 1 2))
-(apl-test
-  "compress"
-  (apl-compress
-    (list 1 0 1 0)
-    (list 10 20 30 40))
-  (list 10 30))
-(apl-test
-  "index"
-  (apl-index
-    (list 10 20 30 40)
-    (list 2 4))
-  (list 20 40))
-
-;; ---------------------------------------------------------------------------
-;; 8. Set operations
-;; ---------------------------------------------------------------------------
-
-(apl-test
-  "member yes"
-  (apl-member
-    (list 1 2 5)
-    (list 2 4 6))
-  (list 0 1 0))
-(apl-test
-  "member s"
-  (apl-member 2 (list 1 2 3))
-  1)
-(apl-test
-  "member no"
-  (apl-member 9 (list 1 2 3))
-  0)
-(apl-test
-  "nub"
-  (apl-nub (list 1 2 1 3 2))
-  (list 1 2 3))
-(apl-test
-  "union"
-  (apl-union
-    (list 1 2 3)
-    (list 2 3 4))
-  (list 1 2 3 4))
-(apl-test
-  "intersect"
-  (apl-intersect
-    (list 1 2 3 4)
-    (list 2 4 6))
-  (list 2 4))
-(apl-test
-  "without"
-  (apl-without
-    (list 1 2 3 4)
-    (list 2 4))
-  (list 1 3))
-
-;; ---------------------------------------------------------------------------
-;; 9. Format
-;; ---------------------------------------------------------------------------
-
-(apl-test
-  "format vec"
-  (apl-format (list 1 2 3))
-  "1 2 3")
-(apl-test "format scalar" (apl-format 42) "42")
-(apl-test "format empty" (apl-format (list)) "")
-
-;; ---------------------------------------------------------------------------
-;; Summary
-;; ---------------------------------------------------------------------------
-
-(list apl-test-pass apl-test-fail)
--- a/lib/common-lisp/clos.sx
+++ b/lib/common-lisp/clos.sx
@@ -1,500 +0,0 @@
-;; lib/common-lisp/clos.sx — CLOS: classes, instances, generic functions
-;;
-;; Class records: {:clos-type "class" :name "NAME" :slots {...} :parents [...] :methods [...]}
-;; Instance:      {:clos-type "instance" :class "NAME" :slots {slot: val ...}}
-;; Method:        {:qualifiers [...] :specializers [...] :fn (fn (args next-fn) ...)}
-;;
-;; SX primitive notes:
-;;   dict->list: use (map (fn (k) (list k (get d k))) (keys d))
-;;   dict-set (pure): use assoc
-;;   fn?/callable?: use callable?
-
-;; ── dict helpers ───────────────────────────────────────────────────────────
-
-(define
-  clos-dict->list
-  (fn (d) (map (fn (k) (list k (get d k))) (keys d))))
-
-;; ── class registry ─────────────────────────────────────────────────────────
-
-(define
-  clos-class-registry
-  (dict
-    "t"
-    {:parents (list) :clos-type "class" :slots (dict) :methods (list) :name "t"}
-    "null"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "null"}
-    "integer"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "integer"}
-    "float"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "float"}
-    "string"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "string"}
-    "symbol"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "symbol"}
-    "cons"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "cons"}
-    "list"
-    {:parents (list "t") :clos-type "class" :slots (dict) :methods (list) :name "list"}))
-
-;; ── clos-generic-registry ─────────────────────────────────────────────────
-
-(define clos-generic-registry (dict))
-
-;; ── class-of ──────────────────────────────────────────────────────────────
-
-(define
-  clos-class-of
-  (fn
-    (x)
-    (cond
-      ((nil? x) "null")
-      ((integer? x) "integer")
-      ((float? x) "float")
-      ((string? x) "string")
-      ((symbol? x) "symbol")
-      ((and (list? x) (> (len x) 0)) "cons")
-      ((and (list? x) (= (len x) 0)) "null")
-      ((and (dict? x) (= (get x "clos-type") "instance")) (get x "class"))
-      (:else "t"))))
-
-;; ── subclass-of? ──────────────────────────────────────────────────────────
-;;
-;; Captures clos-class-registry at define time to avoid free-variable issues.
-
-(define
-  clos-subclass-of?
-  (let
-    ((registry clos-class-registry))
-    (fn
-      (class-name super-name)
-      (if
-        (= class-name super-name)
-        true
-        (let
-          ((rec (get registry class-name)))
-          (if
-            (nil? rec)
-            false
-            (some
-              (fn (p) (clos-subclass-of? p super-name))
-              (get rec "parents"))))))))
-
-;; ── instance-of? ──────────────────────────────────────────────────────────
-
-(define
-  clos-instance-of?
-  (fn (obj class-name) (clos-subclass-of? (clos-class-of obj) class-name)))
-
-;; ── defclass ──────────────────────────────────────────────────────────────
-;;
-;; slot-specs: list of dicts with keys: name initarg initform accessor reader writer
-;; Each missing key defaults to nil.
-
-(define clos-slot-spec (fn (spec) (if (string? spec) {:initform nil :initarg nil :reader nil :writer nil :accessor nil :name spec} spec)))
-
-(define
-  clos-defclass
-  (fn
-    (name parents slot-specs)
-    (let
-      ((slots (dict)))
-      (for-each
-        (fn
-          (pname)
-          (let
-            ((prec (get clos-class-registry pname)))
-            (when
-              (not (nil? prec))
-              (for-each
-                (fn
-                  (k)
-                  (when
-                    (nil? (get slots k))
-                    (dict-set! slots k (get (get prec "slots") k))))
-                (keys (get prec "slots"))))))
-        parents)
-      (for-each
-        (fn
-          (s)
-          (let
-            ((spec (clos-slot-spec s)))
-            (dict-set! slots (get spec "name") spec)))
-        slot-specs)
-      (let
-        ((class-rec {:parents parents :clos-type "class" :slots slots :methods (list) :name name}))
-        (dict-set! clos-class-registry name class-rec)
-        (clos-install-accessors-for name slots)
-        name))))
-
-;; ── accessor installation (forward-declared, defined after defmethod) ──────
-
-(define
-  clos-install-accessors-for
-  (fn
-    (class-name slots)
-    (for-each
-      (fn
-        (k)
-        (let
-          ((spec (get slots k)))
-          (let
-            ((reader (get spec "reader")))
-            (when
-              (not (nil? reader))
-              (clos-add-reader-method reader class-name k)))
-          (let
-            ((accessor (get spec "accessor")))
-            (when
-              (not (nil? accessor))
-              (clos-add-reader-method accessor class-name k)))))
-      (keys slots))))
-
-;; placeholder — real impl filled in after defmethod is defined
-(define clos-add-reader-method (fn (method-name class-name slot-name) nil))
-
-;; ── make-instance ─────────────────────────────────────────────────────────
-
-(define
-  clos-make-instance
-  (fn
-    (class-name &rest initargs)
-    (let
-      ((class-rec (get clos-class-registry class-name)))
-      (if
-        (nil? class-rec)
-        (error (str "No class named: " class-name))
-        (let
-          ((slots (dict)))
-          (for-each
-            (fn
-              (k)
-              (let
-                ((spec (get (get class-rec "slots") k)))
-                (let
-                  ((initform (get spec "initform")))
-                  (when
-                    (not (nil? initform))
-                    (dict-set!
-                      slots
-                      k
-                      (if (callable? initform) (initform) initform))))))
-            (keys (get class-rec "slots")))
-          (define
-            apply-args
-            (fn
-              (args)
-              (when
-                (>= (len args) 2)
-                (let
-                  ((key (str (first args))) (val (first (rest args))))
-                  (let
-                    ((skey (if (= (slice key 0 1) ":") (slice key 1 (len key)) key)))
-                    (let
-                      ((matched false))
-                      (for-each
-                        (fn
-                          (sk)
-                          (let
-                            ((spec (get (get class-rec "slots") sk)))
-                            (let
-                              ((ia (get spec "initarg")))
-                              (when
-                                (or
-                                  (= ia key)
-                                  (= ia (str ":" skey))
-                                  (= sk skey))
-                                (dict-set! slots sk val)
-                                (set! matched true)))))
-                        (keys (get class-rec "slots")))))
-                  (apply-args (rest (rest args)))))))
-          (apply-args initargs)
-          {:clos-type "instance" :slots slots :class class-name})))))
-
-;; ── slot-value ────────────────────────────────────────────────────────────
-
-(define
-  clos-slot-value
-  (fn
-    (instance slot-name)
-    (if
-      (and (dict? instance) (= (get instance "clos-type") "instance"))
-      (get (get instance "slots") slot-name)
-      (error (str "Not a CLOS instance: " (inspect instance))))))
-
-(define
-  clos-set-slot-value!
-  (fn
-    (instance slot-name value)
-    (if
-      (and (dict? instance) (= (get instance "clos-type") "instance"))
-      (dict-set! (get instance "slots") slot-name value)
-      (error (str "Not a CLOS instance: " (inspect instance))))))
-
-(define
-  clos-slot-boundp
-  (fn
-    (instance slot-name)
-    (and
-      (dict? instance)
-      (= (get instance "clos-type") "instance")
-      (not (nil? (get (get instance "slots") slot-name))))))
-
-;; ── find-class / change-class ─────────────────────────────────────────────
-
-(define clos-find-class (fn (name) (get clos-class-registry name)))
-
-(define
-  clos-change-class!
-  (fn
-    (instance new-class-name)
-    (if
-      (and (dict? instance) (= (get instance "clos-type") "instance"))
-      (dict-set! instance "class" new-class-name)
-      (error (str "Not a CLOS instance: " (inspect instance))))))
-
-;; ── defgeneric ────────────────────────────────────────────────────────────
-
-(define
-  clos-defgeneric
-  (fn
-    (name options)
-    (let
-      ((combination (or (get options "method-combination") "standard")))
-      (when
-        (nil? (get clos-generic-registry name))
-        (dict-set! clos-generic-registry name {:methods (list) :combination combination :name name}))
-      name)))
-
-;; ── defmethod ─────────────────────────────────────────────────────────────
-;;
-;; method-fn: (fn (args next-fn) body)
-;;   args = list of all call arguments
-;;   next-fn = (fn () next-method-result) or nil
-
-(define
-  clos-defmethod
-  (fn
-    (generic-name qualifiers specializers method-fn)
-    (when
-      (nil? (get clos-generic-registry generic-name))
-      (clos-defgeneric generic-name {}))
-    (let
-      ((grec (get clos-generic-registry generic-name))
-        (new-method {:fn method-fn :qualifiers qualifiers :specializers specializers}))
-      (let
-        ((kept (filter (fn (m) (not (and (= (get m "qualifiers") qualifiers) (= (get m "specializers") specializers)))) (get grec "methods"))))
-        (dict-set!
-          clos-generic-registry
-          generic-name
-          (assoc grec "methods" (append kept (list new-method))))
-        generic-name))))
-
-;; Now install the real accessor-method installer
-(set!
-  clos-add-reader-method
-  (fn
-    (method-name class-name slot-name)
-    (clos-defmethod
-      method-name
-      (list)
-      (list class-name)
-      (fn (args next-fn) (clos-slot-value (first args) slot-name)))))
-
-;; ── method specificity ─────────────────────────────────────────────────────
-
-(define
-  clos-method-matches?
-  (fn
-    (method args)
-    (let
-      ((specs (get method "specializers")))
-      (if
-        (> (len specs) (len args))
-        false
-        (define
-          check-all
-          (fn
-            (i)
-            (if
-              (>= i (len specs))
-              true
-              (let
-                ((spec (nth specs i)) (arg (nth args i)))
-                (if
-                  (= spec "t")
-                  (check-all (+ i 1))
-                  (if
-                    (clos-instance-of? arg spec)
-                    (check-all (+ i 1))
-                    false))))))
-        (check-all 0)))))
-
-;; Precedence distance: how far class-name is from spec-name up the hierarchy.
-(define
-  clos-specificity
-  (let
-    ((registry clos-class-registry))
-    (fn
-      (class-name spec-name)
-      (define
-        walk
-        (fn
-          (cn depth)
-          (if
-            (= cn spec-name)
-            depth
-            (let
-              ((rec (get registry cn)))
-              (if
-                (nil? rec)
-                nil
-                (let
-                  ((results (map (fn (p) (walk p (+ depth 1))) (get rec "parents"))))
-                  (let
-                    ((non-nil (filter (fn (x) (not (nil? x))) results)))
-                    (if
-                      (empty? non-nil)
-                      nil
-                      (reduce
-                        (fn (a b) (if (< a b) a b))
-                        (first non-nil)
-                        (rest non-nil))))))))))
-      (walk class-name 0))))
-
-(define
-  clos-method-more-specific?
-  (fn
-    (m1 m2 args)
-    (let
-      ((s1 (get m1 "specializers")) (s2 (get m2 "specializers")))
-      (define
-        cmp
-        (fn
-          (i)
-          (if
-            (>= i (len s1))
-            false
-            (let
-              ((c1 (clos-specificity (clos-class-of (nth args i)) (nth s1 i)))
-                (c2
-                  (clos-specificity (clos-class-of (nth args i)) (nth s2 i))))
-              (cond
-                ((and (nil? c1) (nil? c2)) (cmp (+ i 1)))
-                ((nil? c1) false)
-                ((nil? c2) true)
-                ((< c1 c2) true)
-                ((> c1 c2) false)
-                (:else (cmp (+ i 1))))))))
-      (cmp 0))))
-
-(define
-  clos-sort-methods
-  (fn
-    (methods args)
-    (define
-      insert
-      (fn
-        (m sorted)
-        (if
-          (empty? sorted)
-          (list m)
-          (if
-            (clos-method-more-specific? m (first sorted) args)
-            (cons m sorted)
-            (cons (first sorted) (insert m (rest sorted)))))))
-    (reduce (fn (acc m) (insert m acc)) (list) methods)))
-
-;; ── call-generic (standard method combination) ─────────────────────────────
-
-(define
-  clos-call-generic
-  (fn
-    (generic-name args)
-    (let
-      ((grec (get clos-generic-registry generic-name)))
-      (if
-        (nil? grec)
-        (error (str "No generic function: " generic-name))
-        (let
-          ((applicable (filter (fn (m) (clos-method-matches? m args)) (get grec "methods"))))
-          (if
-            (empty? applicable)
-            (error
-              (str
-                "No applicable method for "
-                generic-name
-                " with classes "
-                (inspect (map clos-class-of args))))
-            (let
-              ((primary (filter (fn (m) (empty? (get m "qualifiers"))) applicable))
-                (before
-                  (filter
-                    (fn (m) (= (get m "qualifiers") (list "before")))
-                    applicable))
-                (after
-                  (filter
-                    (fn (m) (= (get m "qualifiers") (list "after")))
-                    applicable))
-                (around
-                  (filter
-                    (fn (m) (= (get m "qualifiers") (list "around")))
-                    applicable)))
-              (let
-                ((sp (clos-sort-methods primary args))
-                  (sb (clos-sort-methods before args))
-                  (sa (clos-sort-methods after args))
-                  (sw (clos-sort-methods around args)))
-                (define
-                  make-primary-chain
-                  (fn
-                    (methods)
-                    (if
-                      (empty? methods)
-                      (fn
-                        ()
-                        (error (str "No next primary method: " generic-name)))
-                      (fn
-                        ()
-                        ((get (first methods) "fn")
-                          args
-                          (make-primary-chain (rest methods)))))))
-                (define
-                  make-around-chain
-                  (fn
-                    (around-methods inner-thunk)
-                    (if
-                      (empty? around-methods)
-                      inner-thunk
-                      (fn
-                        ()
-                        ((get (first around-methods) "fn")
-                          args
-                          (make-around-chain
-                            (rest around-methods)
-                            inner-thunk))))))
-                (for-each (fn (m) ((get m "fn") args (fn () nil))) sb)
-                (let
-                  ((primary-thunk (make-primary-chain sp)))
-                  (let
-                    ((result (if (empty? sw) (primary-thunk) ((make-around-chain sw primary-thunk)))))
-                    (for-each
-                      (fn (m) ((get m "fn") args (fn () nil)))
-                      (reverse sa))
-                    result))))))))))
-
-;; ── call-next-method / next-method-p ──────────────────────────────────────
-
-(define clos-call-next-method (fn (next-fn) (next-fn)))
-
-(define clos-next-method-p (fn (next-fn) (not (nil? next-fn))))
-
-;; ── with-slots ────────────────────────────────────────────────────────────
-
-(define
-  clos-with-slots
-  (fn
-    (instance slot-names body-fn)
-    (let
-      ((vals (map (fn (s) (clos-slot-value instance s)) slot-names)))
-      (apply body-fn vals))))
--- a/lib/common-lisp/conformance.sh
+++ b/lib/common-lisp/conformance.sh
@@ -1,157 +0,0 @@
-#!/usr/bin/env bash
-# lib/common-lisp/conformance.sh — CL-on-SX conformance test runner
-#
-# Runs all Common Lisp test suites and writes scoreboard.json + scoreboard.md.
-#
-# Usage:
-#   bash lib/common-lisp/conformance.sh
-#   bash lib/common-lisp/conformance.sh -v
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found."
-  exit 1
-fi
-
-VERBOSE="${1:-}"
-TOTAL_PASS=0; TOTAL_FAIL=0
-SUITE_NAMES=()
-SUITE_PASS=()
-SUITE_FAIL=()
-
-# run_suite NAME "file1 file2 ..." PASS_VAR FAIL_VAR FAILURES_VAR
-run_suite() {
-  local name="$1" load_files="$2" pass_var="$3" fail_var="$4" failures_var="$5"
-  local TMP; TMP=$(mktemp)
-  {
-    printf '(epoch 1)\n(load "spec/stdlib.sx")\n'
-    local i=2
-    for f in $load_files; do
-      printf '(epoch %d)\n(load "%s")\n' "$i" "$f"
-      i=$((i+1))
-    done
-    printf '(epoch 100)\n(eval "%s")\n' "$pass_var"
-    printf '(epoch 101)\n(eval "%s")\n' "$fail_var"
-  } > "$TMP"
-  local OUT; OUT=$(timeout 30 "$SX_SERVER" < "$TMP" 2>/dev/null)
-  rm -f "$TMP"
-  local P F
-  P=$(echo "$OUT" | grep -A1 "^(ok-len 100 " | tail -1 | tr -d ' ()' || true)
-  F=$(echo "$OUT" | grep -A1 "^(ok-len 101 " | tail -1 | tr -d ' ()' || true)
-  # Also try plain (ok 100 N) format
-  [ -z "$P" ] && P=$(echo "$OUT" | grep "^(ok 100 " | awk '{print $3}' | tr -d ')' || true)
-  [ -z "$F" ] && F=$(echo "$OUT" | grep "^(ok 101 " | awk '{print $3}' | tr -d ')' || true)
-  [ -z "$P" ] && P=0; [ -z "$F" ] && F=0
-  SUITE_NAMES+=("$name")
-  SUITE_PASS+=("$P")
-  SUITE_FAIL+=("$F")
-  TOTAL_PASS=$((TOTAL_PASS + P))
-  TOTAL_FAIL=$((TOTAL_FAIL + F))
-  if [ "$F" = "0" ] && [ "${P:-0}" -gt 0 ] 2>/dev/null; then
-    echo "  PASS  $name ($P tests)"
-  else
-    echo "  FAIL  $name ($P passed, $F failed)"
-  fi
-}
-
-echo "=== Common Lisp on SX — Conformance Run ==="
-echo ""
-
-run_suite "Phase 1: tokenizer/reader" \
-  "lib/common-lisp/reader.sx lib/common-lisp/tests/read.sx" \
-  "cl-test-pass" "cl-test-fail" "cl-test-fails"
-
-run_suite "Phase 1: parser/lambda-lists" \
-  "lib/common-lisp/reader.sx lib/common-lisp/parser.sx lib/common-lisp/tests/lambda.sx" \
-  "cl-test-pass" "cl-test-fail" "cl-test-fails"
-
-run_suite "Phase 2: evaluator" \
-  "lib/common-lisp/reader.sx lib/common-lisp/parser.sx lib/common-lisp/eval.sx lib/common-lisp/tests/eval.sx" \
-  "cl-test-pass" "cl-test-fail" "cl-test-fails"
-
-run_suite "Phase 3: condition system" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/tests/conditions.sx" \
-  "passed" "failed" "failures"
-
-run_suite "Phase 3: restart-demo" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/tests/programs/restart-demo.sx" \
-  "demo-passed" "demo-failed" "demo-failures"
-
-run_suite "Phase 3: parse-recover" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/tests/programs/parse-recover.sx" \
-  "parse-passed" "parse-failed" "parse-failures"
-
-run_suite "Phase 3: interactive-debugger" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/tests/programs/interactive-debugger.sx" \
-  "debugger-passed" "debugger-failed" "debugger-failures"
-
-run_suite "Phase 4: CLOS" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/clos.sx lib/common-lisp/tests/clos.sx" \
-  "passed" "failed" "failures"
-
-run_suite "Phase 4: geometry" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/clos.sx lib/common-lisp/tests/programs/geometry.sx" \
-  "geo-passed" "geo-failed" "geo-failures"
-
-run_suite "Phase 4: mop-trace" \
-  "lib/common-lisp/runtime.sx lib/common-lisp/clos.sx lib/common-lisp/tests/programs/mop-trace.sx" \
-  "mop-passed" "mop-failed" "mop-failures"
-
-run_suite "Phase 5: macros+LOOP" \
-  "lib/common-lisp/reader.sx lib/common-lisp/parser.sx lib/common-lisp/eval.sx lib/common-lisp/loop.sx lib/common-lisp/tests/macros.sx" \
-  "macro-passed" "macro-failed" "macro-failures"
-
-echo ""
-echo "=== Total: $TOTAL_PASS passed, $TOTAL_FAIL failed ==="
-
-# ── write scoreboard.json ─────────────────────────────────────────────────
-
-SCORE_DIR="lib/common-lisp"
-JSON="$SCORE_DIR/scoreboard.json"
-{
-  printf '{\n'
-  printf '  "generated": "%s",\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-  printf '  "total_pass": %d,\n' "$TOTAL_PASS"
-  printf '  "total_fail": %d,\n' "$TOTAL_FAIL"
-  printf '  "suites": [\n'
-  first=true
-  for i in "${!SUITE_NAMES[@]}"; do
-    if [ "$first" = "true" ]; then first=false; else printf ',\n'; fi
-    printf '    {"name": "%s", "pass": %d, "fail": %d}' \
-      "${SUITE_NAMES[$i]}" "${SUITE_PASS[$i]}" "${SUITE_FAIL[$i]}"
-  done
-  printf '\n  ]\n'
-  printf '}\n'
-} > "$JSON"
-
-# ── write scoreboard.md ───────────────────────────────────────────────────
-
-MD="$SCORE_DIR/scoreboard.md"
-{
-  printf '# Common Lisp on SX — Scoreboard\n\n'
-  printf '_Generated: %s_\n\n' "$(date -u '+%Y-%m-%d %H:%M UTC')"
-  printf '| Suite | Pass | Fail | Status |\n'
-  printf '|-------|------|------|--------|\n'
-  for i in "${!SUITE_NAMES[@]}"; do
-    p="${SUITE_PASS[$i]}" f="${SUITE_FAIL[$i]}"
-    status=""
-    if [ "$f" = "0" ] && [ "${p:-0}" -gt 0 ] 2>/dev/null; then
-      status="pass"
-    else
-      status="FAIL"
-    fi
-    printf '| %s | %s | %s | %s |\n' "${SUITE_NAMES[$i]}" "$p" "$f" "$status"
-  done
-  printf '\n**Total: %d passed, %d failed**\n' "$TOTAL_PASS" "$TOTAL_FAIL"
-} > "$MD"
-
-echo ""
-echo "Scoreboard written to $JSON and $MD"
-
-[ "$TOTAL_FAIL" -eq 0 ]
--- a/lib/common-lisp/eval.sx
+++ b/lib/common-lisp/eval.sx
@@ -1,906 +0,0 @@
-;; Common Lisp evaluator — evaluates CL AST forms.
-;;
-;; Depends on: lib/common-lisp/reader.sx, lib/common-lisp/parser.sx
-;;
-;; Environment:
-;;   {:vars {"NAME" val ...} :fns {"NAME" cl-fn ...}}
-;; CL function:
-;;   {:cl-type "function" :params ll :body forms :env env}
-;;
-;; Public API:
-;;   (cl-make-env)              — create empty environment
-;;   (cl-eval form env)         — evaluate one CL AST form
-;;   (cl-eval-str src env)      — read+eval a CL source string
-;;   (cl-eval-all-str src env)  — read-all+eval-each, return last
-;;   cl-global-env              — global mutable environment
-
-;; ── environment ──────────────────────────────────────────────────
-
-(define cl-make-env (fn () {:vars {} :fns {}}))
-
-(define cl-global-env (cl-make-env))
-
-;; ── macro registry ────────────────────────────────────────────────
-;; cl-macro-registry: symbol-name -> (fn (form env) expanded-form)
-(define cl-macro-registry (dict))
-
-;; Gensym counter (eval-time, distinct from runtime.sx cl-gensym)
-(define cl-gensym-counter 0)
-(define cl-eval-gensym
-  (fn (prefix)
-    (do
-      (set! cl-gensym-counter (+ cl-gensym-counter 1))
-      (str (if (nil? prefix) "G" prefix) cl-gensym-counter))))
-
-
-(define cl-env-get-var  (fn (env name) (get (get env "vars") name)))
-(define cl-env-has-var? (fn (env name) (has-key? (get env "vars") name)))
-(define cl-env-get-fn   (fn (env name) (get (get env "fns") name)))
-(define cl-env-has-fn?  (fn (env name) (has-key? (get env "fns") name)))
-
-(define cl-env-bind-var
-  (fn (env name value)
-    {:vars (assoc (get env "vars") name value)
-     :fns  (get env "fns")}))
-
-(define cl-env-bind-fn
-  (fn (env name fn-obj)
-    {:vars (get env "vars")
-     :fns  (assoc (get env "fns") name fn-obj)}))
-
-;; ── body evaluation ───────────────────────────────────────────────
-
-(define cl-block-return?
-  (fn (v) (and (dict? v) (= (get v "cl-type") "block-return"))))
-
-(define cl-go-tag?
-  (fn (v) (and (dict? v) (= (get v "cl-type") "go-tag"))))
-
-(define cl-mv?
-  (fn (v) (and (dict? v) (= (get v "cl-type") "mv"))))
-
-(define cl-mv-primary
-  (fn (v)
-    (if (cl-mv? v)
-      (if (> (len (get v "vals")) 0) (nth (get v "vals") 0) nil)
-      v)))
-
-(define cl-mv-vals
-  (fn (v) (if (cl-mv? v) (get v "vals") (list v))))
-
-(define cl-eval-body
-  (fn (forms env)
-    (cond
-      ((= (len forms) 0) nil)
-      ((= (len forms) 1) (cl-eval (nth forms 0) env))
-      (:else
-        (let ((result (cl-eval (nth forms 0) env)))
-          (if (or (cl-block-return? result) (cl-go-tag? result))
-            result
-            (cl-eval-body (rest forms) env)))))))
-
-;; ── lambda-list binding helpers ───────────────────────────────────
-
-(define cl-bind-required
-  (fn (names args env)
-    (if (= (len names) 0)
-      env
-      (cl-bind-required
-        (rest names)
-        (if (> (len args) 0) (rest args) args)
-        (cl-env-bind-var env
-          (nth names 0)
-          (if (> (len args) 0) (nth args 0) nil))))))
-
-;; returns {:env e :rest remaining-args}
-(define cl-bind-optional
-  (fn (opts args env)
-    (if (= (len opts) 0)
-      {:env env :rest args}
-      (let ((spec    (nth opts 0))
-            (has-val (> (len args) 0)))
-        (let ((val (if has-val (nth args 0) nil))
-              (rem (if has-val (rest args) args)))
-          (let ((e1 (cl-env-bind-var env (get spec "name")
-                      (if has-val val
-                        (if (get spec "default")
-                          (cl-eval (get spec "default") env) nil)))))
-            (let ((e2 (if (get spec "supplied")
-                        (cl-env-bind-var e1 (get spec "supplied") has-val)
-                        e1)))
-              (cl-bind-optional (rest opts) rem e2))))))))
-
-;; returns {:found bool :value v}
-(define cl-find-kw-arg
-  (fn (kw args i)
-    (if (>= i (len args))
-      {:found false :value nil}
-      (let ((a (nth args i)))
-        (if (and (dict? a)
-                 (= (get a "cl-type") "keyword")
-                 (= (get a "name") kw))
-          {:found true
-           :value (if (< (+ i 1) (len args)) (nth args (+ i 1)) nil)}
-          (cl-find-kw-arg kw args (+ i 2)))))))
-
-(define cl-bind-key
-  (fn (key-specs all-args env)
-    (if (= (len key-specs) 0)
-      env
-      (let ((spec (nth key-specs 0))
-            (r    (cl-find-kw-arg (get (nth key-specs 0) "keyword") all-args 0)))
-        (let ((found (get r "found"))
-              (kval  (get r "value")))
-          (let ((e1 (cl-env-bind-var env (get spec "name")
-                      (if found kval
-                        (if (get spec "default")
-                          (cl-eval (get spec "default") env) nil)))))
-            (let ((e2 (if (get spec "supplied")
-                        (cl-env-bind-var e1 (get spec "supplied") found)
-                        e1)))
-              (cl-bind-key (rest key-specs) all-args e2))))))))
-
-(define cl-bind-aux
-  (fn (aux-specs env)
-    (if (= (len aux-specs) 0)
-      env
-      (let ((spec (nth aux-specs 0)))
-        (cl-bind-aux
-          (rest aux-specs)
-          (cl-env-bind-var env (get spec "name")
-            (if (get spec "init") (cl-eval (get spec "init") env) nil)))))))
-
-;; ── function creation ─────────────────────────────────────────────
-
-;; ll-and-body: (list lambda-list-form body-form ...)
-(define cl-make-lambda
-  (fn (ll-and-body env)
-    {:cl-type "function"
-     :params  (cl-parse-lambda-list (nth ll-and-body 0))
-     :body    (rest ll-and-body)
-     :env     env}))
-
-;; ── function application ──────────────────────────────────────────
-
-(define cl-apply
-  (fn (fn-obj args)
-    (cond
-      ((and (dict? fn-obj) (has-key? fn-obj "builtin-fn"))
-        ((get fn-obj "builtin-fn") args))
-      ((or (not (dict? fn-obj)) (not (= (get fn-obj "cl-type") "function")))
-        {:cl-type "error" :message "Not a function"})
-      (:else
-        (let ((params (get fn-obj "params"))
-            (body   (get fn-obj "body"))
-            (cenv   (get fn-obj "env")))
-        (let ((req       (get params "required"))
-              (opt       (get params "optional"))
-              (rest-name (get params "rest"))
-              (key-specs (get params "key"))
-              (aux-specs (get params "aux")))
-          (let ((e1 (cl-bind-required req args cenv)))
-            (let ((opt-r (cl-bind-optional
-                           opt (slice args (len req) (len args)) e1)))
-              (let ((e2  (get opt-r "env"))
-                    (rem (get opt-r "rest")))
-                (let ((e3 (if rest-name
-                            (cl-env-bind-var e2 rest-name rem)
-                            e2)))
-                  (let ((e4 (cl-bind-key key-specs args e3)))
-                    (let ((e5 (cl-bind-aux aux-specs e4)))
-                      (cl-eval-body body e5)))))))))))))
-
-;; ── built-in functions ────────────────────────────────────────────
-
-(define cl-builtins
-  (dict
-    "+"   (fn (args) (reduce (fn (a b) (+ a b)) 0 args))
-    "-"   (fn (args)
-            (cond
-              ((= (len args) 0) 0)
-              ((= (len args) 1) (- 0 (nth args 0)))
-              (:else (reduce (fn (a b) (- a b)) (nth args 0) (rest args)))))
-    "*"   (fn (args) (reduce (fn (a b) (* a b)) 1 args))
-    "/"   (fn (args)
-            (cond
-              ((= (len args) 0) 1)
-              ((= (len args) 1) (/ 1 (nth args 0)))
-              (:else (reduce (fn (a b) (/ a b)) (nth args 0) (rest args)))))
-    "1+"  (fn (args) (+ (nth args 0) 1))
-    "1-"  (fn (args) (- (nth args 0) 1))
-    "="   (fn (args) (if (= (nth args 0) (nth args 1)) true nil))
-    "/="  (fn (args) (if (not (= (nth args 0) (nth args 1))) true nil))
-    "<"   (fn (args) (if (< (nth args 0) (nth args 1)) true nil))
-    ">"   (fn (args) (if (> (nth args 0) (nth args 1)) true nil))
-    "<="  (fn (args) (if (<= (nth args 0) (nth args 1)) true nil))
-    ">="  (fn (args) (if (>= (nth args 0) (nth args 1)) true nil))
-    "NOT"   (fn (args) (if (nth args 0) nil true))
-    "NULL"  (fn (args)
-               (let ((x (nth args 0)))
-                 (if (or (= x nil) (and (list? x) (= (len x) 0))) true nil)))
-    "NUMBERP" (fn (args) (if (number? (nth args 0)) true nil))
-    "STRINGP" (fn (args) (if (string? (nth args 0)) true nil))
-    "SYMBOLP" (fn (args) nil)
-    "LISTP"   (fn (args)
-                 (let ((x (nth args 0)))
-                   (if (or (list? x) (= x nil)
-                           (and (dict? x) (= (get x "cl-type") "cons")))
-                     true nil)))
-    "CONSP"   (fn (args)
-                 (let ((x (nth args 0)))
-                   (if (or (and (list? x) (> (len x) 0))
-                           (and (dict? x) (= (get x "cl-type") "cons")))
-                     true nil)))
-    "ATOM"    (fn (args)
-                 (let ((x (nth args 0)))
-                   (if (or (and (list? x) (> (len x) 0))
-                           (and (dict? x) (= (get x "cl-type") "cons")))
-                     nil true)))
-    "FUNCTIONP" (fn (args)
-                   (let ((x (nth args 0)))
-                     (if (and (dict? x) (= (get x "cl-type") "function")) true nil)))
-    "ZEROP"  (fn (args) (if (= (nth args 0) 0) true nil))
-    "PLUSP"  (fn (args) (if (> (nth args 0) 0) true nil))
-    "MINUSP" (fn (args) (if (< (nth args 0) 0) true nil))
-    "EVENP"  (fn (args)
-                (let ((n (nth args 0)))
-                  (if (= (mod n 2) 0) true nil)))
-    "ODDP"   (fn (args)
-                (let ((n (nth args 0)))
-                  (if (not (= (mod n 2) 0)) true nil)))
-    "ABS"    (fn (args) (let ((n (nth args 0))) (if (< n 0) (- 0 n) n)))
-    "MAX"    (fn (args) (reduce (fn (a b) (if (> a b) a b)) (nth args 0) (rest args)))
-    "MIN"    (fn (args) (reduce (fn (a b) (if (< a b) a b)) (nth args 0) (rest args)))
-    "CONS"   (fn (args) {:cl-type "cons" :car (nth args 0) :cdr (nth args 1)})
-    "CAR"    (fn (args)
-                (let ((x (nth args 0)))
-                  (if (and (dict? x) (= (get x "cl-type") "cons"))
-                    (get x "car")
-                    (if (and (list? x) (> (len x) 0)) (nth x 0) nil))))
-    "CDR"    (fn (args)
-                (let ((x (nth args 0)))
-                  (if (and (dict? x) (= (get x "cl-type") "cons"))
-                    (get x "cdr")
-                    (if (list? x) (rest x) nil))))
-    "LIST"   (fn (args) args)
-    "APPEND" (fn (args)
-                (if (= (len args) 0) (list)
-                  (reduce (fn (a b)
-                    (if (= a nil) b (if (= b nil) a (concat a b))))
-                  (list) args)))
-    "LENGTH" (fn (args)
-                (let ((x (nth args 0)))
-                  (if (= x nil) 0 (len x))))
-    "NTH"    (fn (args) (nth (nth args 1) (nth args 0)))
-    "FIRST"  (fn (args)
-                (let ((x (nth args 0)))
-                  (if (and (list? x) (> (len x) 0)) (nth x 0) nil)))
-    "SECOND" (fn (args)
-                (let ((x (nth args 0)))
-                  (if (and (list? x) (> (len x) 1)) (nth x 1) nil)))
-    "THIRD"  (fn (args)
-                (let ((x (nth args 0)))
-                  (if (and (list? x) (> (len x) 2)) (nth x 2) nil)))
-    "REST"   (fn (args) (rest (nth args 0)))
-    "REVERSE" (fn (args)
-                 (reduce (fn (acc x) (concat (list x) acc))
-                         (list) (nth args 0)))
-    "IDENTITY" (fn (args) (nth args 0))
-    "VALUES"   (fn (args) (cond ((= (len args) 0) nil) ((= (len args) 1) (nth args 0)) (:else {:cl-type "mv" :vals args})))
-    "PRINT"    (fn (args) (nth args 0))
-    "PRIN1"    (fn (args) (nth args 0))
-    "PRINC"    (fn (args) (nth args 0))
-    "TERPRI"   (fn (args) nil)
-    "WRITE"    (fn (args) (nth args 0))
-    "STRING-UPCASE"   (fn (args) (upcase (nth args 0)))
-    "STRING-DOWNCASE" (fn (args) (downcase (nth args 0)))
-    "STRING="         (fn (args) (if (= (nth args 0) (nth args 1)) true nil))
-    "CONCATENATE"     (fn (args) (reduce (fn (a b) (str a b)) "" (rest args)))
-    "EQ"    (fn (args) (if (= (nth args 0) (nth args 1)) true nil))
-    "EQL"   (fn (args) (if (= (nth args 0) (nth args 1)) true nil))
-    "EQUAL" (fn (args) (if (= (nth args 0) (nth args 1)) true nil))))
-
-;; Register builtins in cl-global-env so (function #'name) resolves them
-(for-each
-  (fn (name)
-    (dict-set! (get cl-global-env "fns") name
-      {:cl-type "function" :builtin-fn (get cl-builtins name)}))
-  (keys cl-builtins))
-
-;; ── TAGBODY / GO ─────────────────────────────────────────────────
-
-(define cl-tagbody-tag?
-  (fn (form) (or (string? form) (number? form))))
-
-(define cl-build-tag-map
-  (fn (forms i acc)
-    (if (>= i (len forms))
-      acc
-      (if (cl-tagbody-tag? (nth forms i))
-        (cl-build-tag-map forms (+ i 1)
-          (assoc acc (str (nth forms i)) i))
-        (cl-build-tag-map forms (+ i 1) acc)))))
-
-(define cl-eval-tagbody
-  (fn (args env)
-    (let ((tag-map (cl-build-tag-map args 0 {})))
-      (define run
-        (fn (i)
-          (if (>= i (len args))
-            nil
-            (let ((form (nth args i)))
-              (if (cl-tagbody-tag? form)
-                (run (+ i 1))
-                (let ((result (cl-eval form env)))
-                  (cond
-                    ((cl-go-tag? result)
-                      (let ((target (get result "tag")))
-                        (let ((tkey (str target)))
-                          (if (has-key? tag-map tkey)
-                            (run (get tag-map tkey))
-                            {:cl-type "error" :message (str "No tag: " target)}))))
-                    ((cl-block-return? result) result)
-                    (:else (run (+ i 1))))))))))
-      (run 0))))
-
-;; ── MULTIPLE VALUES ──────────────────────────────────────────────
-
-(define cl-eval-multiple-value-bind
-  (fn (args env)
-    (let ((vars  (nth args 0))
-          (form  (nth args 1))
-          (body  (rest (rest args))))
-      (let ((vals (cl-mv-vals (cl-eval form env))))
-        (define bind-vars
-          (fn (names i e)
-            (if (= (len names) 0)
-              e
-              (bind-vars (rest names) (+ i 1)
-                (cl-env-bind-var e (nth names 0)
-                  (if (< i (len vals)) (nth vals i) nil))))))
-        (cl-eval-body body (bind-vars vars 0 env))))))
-
-(define cl-eval-multiple-value-call
-  (fn (args env)
-    (let ((fn-obj (cl-eval (nth args 0) env))
-          (forms  (rest args)))
-      (let ((all-vals (reduce
-                        (fn (acc f)
-                          (concat acc (cl-mv-vals (cl-eval f env))))
-                        (list) forms)))
-        (cl-apply fn-obj all-vals)))))
-
-(define cl-eval-multiple-value-prog1
-  (fn (args env)
-    (let ((first-result (cl-eval (nth args 0) env)))
-      (for-each (fn (f) (cl-eval f env)) (rest args))
-      first-result)))
-
-;; ── UNWIND-PROTECT ───────────────────────────────────────────────
-
-(define cl-eval-unwind-protect
-  (fn (args env)
-    (let ((protected (nth args 0))
-          (cleanup   (rest args)))
-      (let ((result (cl-eval protected env)))
-        (for-each (fn (f) (cl-eval f env)) cleanup)
-        result))))
-
-;; ── BLOCK / RETURN-FROM ───────────────────────────────────────────
-
-(define cl-eval-block
-  (fn (args env)
-    (let ((name (nth args 0))
-          (body (rest args)))
-      (let ((result (cl-eval-body body env)))
-        (if (and (cl-block-return? result)
-                 (= (get result "name") name))
-          (get result "value")
-          result)))))
-
-(define cl-eval-return-from
-  (fn (args env)
-    (let ((name (nth args 0))
-          (val  (if (> (len args) 1) (cl-eval (nth args 1) env) nil)))
-      {:cl-type "block-return" :name name :value val})))
-
-;; ── special form evaluators ───────────────────────────────────────
-
-(define cl-eval-if
-  (fn (args env)
-    (let ((cond-val  (cl-mv-primary (cl-eval (nth args 0) env)))
-          (then-form (nth args 1))
-          (else-form (if (> (len args) 2) (nth args 2) nil)))
-      (if cond-val
-        (cl-eval then-form env)
-        (if else-form (cl-eval else-form env) nil)))))
-
-(define cl-eval-and
-  (fn (args env)
-    (if (= (len args) 0)
-      true
-      (let ((val (cl-mv-primary (cl-eval (nth args 0) env))))
-        (if (not val)
-          nil
-          (if (= (len args) 1)
-            val
-            (cl-eval-and (rest args) env)))))))
-
-(define cl-eval-or
-  (fn (args env)
-    (if (= (len args) 0)
-      nil
-      (let ((val (cl-mv-primary (cl-eval (nth args 0) env))))
-        (if val
-          val
-          (cl-eval-or (rest args) env))))))
-
-(define cl-eval-cond
-  (fn (clauses env)
-    (if (= (len clauses) 0)
-      nil
-      (let ((clause (nth clauses 0)))
-        (let ((test-val (cl-mv-primary (cl-eval (nth clause 0) env))))
-          (if test-val
-            (if (= (len clause) 1)
-              test-val
-              (cl-eval-body (rest clause) env))
-            (cl-eval-cond (rest clauses) env)))))))
-
-;; Dynamic variable infrastructure
-(define cl-dyn-unbound {:cl-type "dyn-unbound"})
-(define cl-specials {})
-(define cl-symbol-macros {})
-(define cl-mark-special!
-  (fn (name) (dict-set! cl-specials name true)))
-(define cl-special?
-  (fn (name) (has-key? cl-specials name)))
-;; Apply dynamic bindings: save old global values, set new, run thunk, restore
-(define cl-apply-dyn
-  (fn (binds thunk)
-    (if (= (len binds) 0)
-      (thunk)
-      (let ((b          (nth binds 0))
-            (rest-binds (rest binds)))
-        (let ((name  (get b "name"))
-              (val   (get b "value"))
-              (gvars (get cl-global-env "vars")))
-          (let ((old (if (has-key? gvars name)
-                       (get gvars name)
-                       cl-dyn-unbound)))
-            (dict-set! gvars name val)
-            (let ((result (cl-apply-dyn rest-binds thunk)))
-              (if (and (dict? old) (= (get old "cl-type") "dyn-unbound"))
-                (dict-set! gvars name nil)
-                (dict-set! gvars name old))
-              result)))))))
-;; Sequential LET* with dynamic variable support
-(define cl-letstar-bind
-  (fn (bs e thunk)
-    (if (= (len bs) 0)
-      (thunk e)
-      (let ((b       (nth bs 0))
-            (rest-bs (rest bs)))
-        (let ((name (if (list? b) (nth b 0) b))
-              (init (if (and (list? b) (> (len b) 1)) (nth b 1) nil)))
-          (let ((val (cl-eval init e)))
-            (if (cl-special? name)
-              (let ((gvars (get cl-global-env "vars")))
-                (let ((old (if (has-key? gvars name)
-                             (get gvars name)
-                             cl-dyn-unbound)))
-                  (dict-set! gvars name val)
-                  (let ((result (cl-letstar-bind rest-bs e thunk)))
-                    (if (and (dict? old) (= (get old "cl-type") "dyn-unbound"))
-                      (dict-set! gvars name nil)
-                      (dict-set! gvars name old))
-                    result)))
-              (cl-letstar-bind rest-bs (cl-env-bind-var e name val) thunk))))))))
-
-;; Parallel LET and sequential LET*
-(define cl-eval-let
-  (fn (args env sequential)
-    (let ((bindings (nth args 0))
-          (body     (rest args)))
-      (if sequential
-        ;; LET*: each binding sees previous ones
-        (cl-letstar-bind bindings env (fn (new-env) (cl-eval-body body new-env)))
-        ;; LET: evaluate all inits in current env, then bind
-        (let ((pairs (map
-                       (fn (b)
-                         (let ((name (if (list? b) (nth b 0) b))
-                               (init (if (and (list? b) (> (len b) 1)) (nth b 1) nil)))
-                           {:name name :value (cl-eval init env)}))
-                       bindings)))
-          (let ((spec-pairs (filter (fn (p) (cl-special? (get p "name"))) pairs))
-                (lex-pairs  (filter (fn (p) (not (cl-special? (get p "name")))) pairs)))
-            (let ((new-env (reduce
-                             (fn (e pair)
-                               (cl-env-bind-var e (get pair "name") (get pair "value")))
-                             env lex-pairs)))
-              (cl-apply-dyn spec-pairs
-                (fn () (cl-eval-body body new-env))))))))))
-
-;; SETQ / SETF (simplified: mutate nearest scope or global)
-(define cl-eval-setq
-  (fn (args env)
-    (if (< (len args) 2)
-      nil
-      (let ((name (nth args 0))
-            (val  (cl-eval (nth args 1) env)))
-        (if (has-key? (get env "vars") name)
-          (dict-set! (get env "vars") name val)
-          (dict-set! (get cl-global-env "vars") name val))
-        (if (> (len args) 2)
-          (cl-eval-setq (rest (rest args)) env)
-          val)))))
-
-;; FUNCTION: get function value or create lambda
-(define cl-eval-function
-  (fn (args env)
-    (let ((spec (nth args 0)))
-      (cond
-        ((and (list? spec) (> (len spec) 0) (= (nth spec 0) "LAMBDA"))
-          (cl-make-lambda (rest spec) env))
-        ((string? spec)
-          (cond
-            ((cl-env-has-fn? env spec) (cl-env-get-fn env spec))
-            ((cl-env-has-fn? cl-global-env spec)
-              (cl-env-get-fn cl-global-env spec))
-            (:else {:cl-type "error" :message (str "Undefined function: " spec)})))
-        (:else {:cl-type "error" :message "FUNCTION: invalid spec"})))))
-
-;; FLET: local functions (non-recursive, close over outer env)
-(define cl-eval-flet
-  (fn (args env)
-    (let ((fn-defs (nth args 0))
-          (body    (rest args)))
-      (let ((new-env (reduce
-                       (fn (e def)
-                         (let ((name    (nth def 0))
-                               (ll      (nth def 1))
-                               (fn-body (rest (rest def))))
-                           (cl-env-bind-fn e name
-                             {:cl-type "function"
-                              :params  (cl-parse-lambda-list ll)
-                              :body    fn-body
-                              :env     env})))
-                       env fn-defs)))
-        (cl-eval-body body new-env)))))
-
-;; LABELS: mutually-recursive local functions
-(define cl-eval-labels
-  (fn (args env)
-    (let ((fn-defs (nth args 0))
-          (body    (rest args)))
-      ;; Build env with placeholder nil entries for each name
-      (let ((new-env (reduce
-                       (fn (e def) (cl-env-bind-fn e (nth def 0) nil))
-                       env fn-defs)))
-        ;; Fill in real function objects that capture new-env
-        (for-each
-          (fn (def)
-            (let ((name    (nth def 0))
-                  (ll      (nth def 1))
-                  (fn-body (rest (rest def))))
-              (dict-set! (get new-env "fns") name
-                {:cl-type "function"
-                 :params  (cl-parse-lambda-list ll)
-                 :body    fn-body
-                 :env     new-env})))
-          fn-defs)
-        (cl-eval-body body new-env)))))
-
-;; EVAL-WHEN: evaluate body only if :execute is in situations
-(define cl-eval-eval-when
-  (fn (args env)
-    (let ((situations (nth args 0))
-          (body       (rest args)))
-      (define has-exec
-        (some (fn (s)
-                (or
-                  (and (dict? s)
-                       (= (get s "cl-type") "keyword")
-                       (= (get s "name") "EXECUTE"))
-                  (= s "EXECUTE")))
-              situations))
-      (if has-exec (cl-eval-body body env) nil))))
-
-;; DEFUN: define function in global fns namespace
-(define cl-eval-defun
-  (fn (args env)
-    (let ((name    (nth args 0))
-          (ll      (nth args 1))
-          (fn-body (rest (rest args))))
-      (let ((fn-obj {:cl-type "function"
-                     :params  (cl-parse-lambda-list ll)
-                     :body    fn-body
-                     :env     env}))
-        (dict-set! (get cl-global-env "fns") name fn-obj)
-        name))))
-
-;; DEFVAR / DEFPARAMETER / DEFCONSTANT
-(define cl-eval-defvar
-  (fn (args env always-assign)
-    (let ((name     (nth args 0))
-          (has-init (> (len args) 1)))
-      (let ((val (if has-init (cl-eval (nth args 1) env) nil)))
-        (when (or always-assign
-                  (not (cl-env-has-var? cl-global-env name)))
-          (dict-set! (get cl-global-env "vars") name val))
-        (cl-mark-special! name)
-        name))))
-
-;; Function call: evaluate name → look up fns, builtins; evaluate args
-(define cl-call-fn
-  (fn (name args env)
-    (let ((evaled (map (fn (a) (cl-mv-primary (cl-eval a env))) args)))
-      (cond
-        ;; FUNCALL: (funcall fn arg...)
-        ((= name "FUNCALL")
-          (cl-apply (nth evaled 0) (rest evaled)))
-        ;; APPLY: (apply fn arg... list)
-        ((= name "APPLY")
-          (let ((fn-obj   (nth evaled 0))
-                (all-args (rest evaled)))
-            (let ((leading  (slice all-args 0 (- (len all-args) 1)))
-                  (last-arg (nth all-args (- (len all-args) 1))))
-              (cl-apply fn-obj (concat leading (if (= last-arg nil) (list) last-arg))))))
-        ;; MAPCAR: (mapcar fn list)
-        ((= name "MAPCAR")
-          (let ((fn-obj (nth evaled 0))
-                (lst    (nth evaled 1)))
-            (if (= lst nil) (list)
-              (map (fn (x) (cl-apply fn-obj (list x))) lst))))
-        ;; Look up in local fns namespace
-        ((cl-env-has-fn? env name)
-          (cl-apply (cl-env-get-fn env name) evaled))
-        ;; Look up in global fns namespace
-        ((cl-env-has-fn? cl-global-env name)
-          (cl-apply (cl-env-get-fn cl-global-env name) evaled))
-        ;; Look up in builtins
-        ((has-key? cl-builtins name)
-          ((get cl-builtins name) evaled))
-        (:else
-          {:cl-type "error" :message (str "Undefined function: " name)})))))
-
-;; ── main evaluator ────────────────────────────────────────────────
-
-(define cl-eval
-  (fn (form env)
-    (cond
-      ;; Nil and booleans are self-evaluating
-      ((= form nil) nil)
-      ((= form true) true)
-      ;; Numbers are self-evaluating
-      ((number? form) form)
-      ;; Dicts: typed CL values
-      ((dict? form)
-        (let ((ct (get form "cl-type")))
-          (cond
-            ((= ct "string") (get form "value"))  ;; CL string → SX string
-            (:else form))))                         ;; keywords, floats, chars, etc.
-      ;; Symbol reference (variable or symbol-macro lookup)
-      ((string? form)
-        (let ((uform (upcase form)))
-          (if (and (has-key? cl-symbol-macros uform)
-                   (not (= (get cl-symbol-macros uform) nil)))
-            (cl-eval (get cl-symbol-macros uform) env)
-            (cond
-              ((cl-env-has-var? env form) (cl-env-get-var env form))
-              ((cl-env-has-var? cl-global-env form)
-                (cl-env-get-var cl-global-env form))
-              (:else {:cl-type "error" :message (str "Undefined variable: " form)})))))
-      ;; List: special forms or function call
-      ((list? form) (cl-eval-list form env))
-      ;; Anything else self-evaluates
-      (:else form))))
-
-
-;; Convert a CL cons tree to an SX list (for macro expansion results)
-(define cl-cons->sx-list
-  (fn (x)
-    (if (and (dict? x) (= (get x "cl-type") "cons"))
-      (cons (cl-cons->sx-list (get x "car"))
-            (cl-cons->sx-list (get x "cdr")))
-      (if (and (dict? x) (= (get x "cl-type") "nil"))
-        (list)
-        (if (list? x)
-          (map cl-cons->sx-list x)
-          x)))))
-
-;; ── macro expansion ───────────────────────────────────────────────
-
-;; Expand a macro one level. Returns {:expanded bool :form form}
-(define cl-macroexpand-1
-  (fn (form env)
-    (if (not (list? form))
-      {:expanded false :form form}
-      (if (= (len form) 0)
-        {:expanded false :form form}
-        (let ((head (nth form 0)))
-          (if (not (string? head))
-            {:expanded false :form form}
-            (let ((uhead (upcase head)))
-              (if (has-key? cl-macro-registry uhead)
-                {:expanded true
-                 :form (cl-cons->sx-list ((get cl-macro-registry uhead) form env))}
-                {:expanded false :form form}))))))))
-
-;; Fully expand macros (loop until stable)
-(define cl-macroexpand
-  (fn (form env)
-    (let ((r (cl-macroexpand-1 form env)))
-      (if (get r "expanded")
-        (cl-macroexpand (get r "form") env)
-        (get r "form")))))
-
-
-;; Helper: bind macro lambda-list params to actuals in env
-(define cl-macro-bind-params
-  (fn (ps as env)
-    (if (= (len ps) 0)
-      env
-      (let ((p (nth ps 0)))
-        (if (= p "&REST")
-          (cl-env-bind-var env (nth ps 1) as)
-          (cl-macro-bind-params
-            (rest ps)
-            (if (= (len as) 0) (list) (rest as))
-            (cl-env-bind-var env p
-              (if (= (len as) 0) nil (nth as 0)))))))))
-
-;; DEFMACRO: store expander function in macro registry
-;; (defmacro name (params...) body...)
-(define cl-eval-defmacro
-  (fn (args env)
-    (let ((name (nth args 0))
-          (params (nth args 1))
-          (body (rest (rest args))))
-      (let ((uname (upcase name)))
-        (let ((expander
-                (fn (form xenv)
-                  (let ((actuals (rest form))
-                        (bound-env (cl-macro-bind-params (map upcase params) (rest form) env)))
-                    (cl-eval-body body bound-env)))))
-          (dict-set! cl-macro-registry uname expander)
-          uname)))))
-
-;; MACROLET: local macro bindings
-;; (macrolet ((name params body...) ...) body...)
-(define cl-eval-macrolet
-  (fn (args env)
-    (let ((bindings (nth args 0))
-          (body (rest args)))
-      (define orig-registry cl-macro-registry)
-      (for-each
-        (fn (b)
-          (let ((name (nth b 0))
-                (params (nth b 1))
-                (mbody (rest (rest b))))
-            (cl-eval-defmacro (list name params (nth mbody 0)) env)))
-        bindings)
-      (let ((result (cl-eval-body body env)))
-        ;; restore — not perfect isolation but workable
-        result))))
-
-;; SYMBOL-MACROLET: bind symbols to expansion forms
-(define cl-eval-symbol-macrolet
-  (fn (args env)
-    (let ((bindings (nth args 0))
-          (body (rest args)))
-      ;; Install each symbol in cl-symbol-macros; save old to restore after
-      (let ((saved (map (fn (b) (let ((sym (upcase (nth b 0))))
-                                  {:sym sym :old (if (has-key? cl-symbol-macros sym) (get cl-symbol-macros sym) nil)}))
-                        bindings)))
-        (for-each
-          (fn (b)
-            (dict-set! cl-symbol-macros (upcase (nth b 0)) (nth b 1)))
-          bindings)
-        (let ((result (cl-eval-body body env)))
-          (for-each
-            (fn (s)
-              (if (= (get s "old") nil)
-                (dict-set! cl-symbol-macros (get s "sym") nil)
-                (dict-set! cl-symbol-macros (get s "sym") (get s "old"))))
-            saved)
-          result)))))
-
-(define cl-eval-list
-  (fn (form env)
-    (if (= (len form) 0)
-      nil
-      (let ((head (nth form 0))
-            (args (rest form)))
-        (cond
-          ;; Macro expansion check
-          ((and (string? head) (has-key? cl-macro-registry (upcase head)))
-            (cl-eval (cl-macroexpand form env) env))
-          ((= head "QUOTE")        (nth args 0))
-          ((= head "IF")           (cl-eval-if args env))
-          ((= head "PROGN")        (cl-eval-body args env))
-          ((= head "LET")          (cl-eval-let args env false))
-          ((= head "LET*")         (cl-eval-let args env true))
-          ((= head "AND")          (cl-eval-and args env))
-          ((= head "OR")           (cl-eval-or args env))
-          ((= head "COND")         (cl-eval-cond args env))
-          ((= head "WHEN")
-            (if (cl-eval (nth args 0) env)
-              (cl-eval-body (rest args) env) nil))
-          ((= head "UNLESS")
-            (if (not (cl-eval (nth args 0) env))
-              (cl-eval-body (rest args) env) nil))
-          ((= head "SETQ")         (cl-eval-setq args env))
-          ((= head "SETF")         (cl-eval-setq args env))
-          ((= head "FUNCTION")     (cl-eval-function args env))
-          ((= head "LAMBDA")       (cl-make-lambda args env))
-          ((= head "FLET")         (cl-eval-flet args env))
-          ((= head "LABELS")       (cl-eval-labels args env))
-          ((= head "THE")          (cl-eval (nth args 1) env))
-          ((= head "LOCALLY")      (cl-eval-body args env))
-          ((= head "EVAL-WHEN")    (cl-eval-eval-when args env))
-          ((= head "DEFUN")        (cl-eval-defun args env))
-          ((= head "TAGBODY")      (cl-eval-tagbody args env))
-          ((= head "GO")
-            {:cl-type "go-tag" :tag (nth args 0)})
-          ((= head "MULTIPLE-VALUE-BIND")  (cl-eval-multiple-value-bind args env))
-          ((= head "MULTIPLE-VALUE-CALL")  (cl-eval-multiple-value-call args env))
-          ((= head "MULTIPLE-VALUE-PROG1") (cl-eval-multiple-value-prog1 args env))
-          ((= head "NTH-VALUE")
-            (let ((n (cl-mv-primary (cl-eval (nth args 0) env)))
-                  (vals (cl-mv-vals (cl-eval (nth args 1) env))))
-              (if (< n (len vals)) (nth vals n) nil)))
-          ((= head "UNWIND-PROTECT") (cl-eval-unwind-protect args env))
-          ((= head "BLOCK")        (cl-eval-block args env))
-          ((= head "RETURN-FROM")  (cl-eval-return-from args env))
-          ((= head "RETURN")
-            (let ((val (if (> (len args) 0) (cl-eval (nth args 0) env) nil)))
-              {:cl-type "block-return" :name nil :value val}))
-          ((= head "DEFVAR")       (cl-eval-defvar args env false))
-          ((= head "DEFPARAMETER") (cl-eval-defvar args env true))
-          ((= head "DEFCONSTANT")  (cl-eval-defvar args env true))
-          ((= head "DECLAIM")      nil)
-          ((= head "PROCLAIM")     nil)
-          ((= head "DEFMACRO")     (cl-eval-defmacro args env))
-          ((= head "MACROLET")     (cl-eval-macrolet args env))
-          ((= head "SYMBOL-MACROLET") (cl-eval-symbol-macrolet args env))
-          ((= head "MACROEXPAND-1")
-            (let ((arg (cl-eval (nth args 0) env)))
-              (cl-macroexpand-1 arg env)))
-          ((= head "MACROEXPAND")
-            (let ((arg (cl-eval (nth args 0) env)))
-              (cl-macroexpand arg env)))
-          ((= head "GENSYM")
-            (cl-eval-gensym (if (> (len args) 0) (cl-eval (nth args 0) env) nil)))
-          ((= head "GENTEMP")
-            (cl-eval-gensym (if (> (len args) 0) (cl-eval (nth args 0) env) "T")))
-          ;; Named function call
-          ((string? head)
-            (cl-call-fn head args env))
-          ;; Anonymous call: ((lambda ...) args)
-          (:else
-            (let ((fn-obj (cl-eval head env)))
-              (if (and (dict? fn-obj) (= (get fn-obj "cl-type") "function"))
-                (cl-apply fn-obj (map (fn (a) (cl-eval a env)) args))
-                {:cl-type "error" :message "Not callable"}))))))))
-
-;; ── public API ────────────────────────────────────────────────────
-
-(define cl-eval-str
-  (fn (src env)
-    (cl-eval (cl-read src) env)))
-
-(define cl-eval-all-str
-  (fn (src env)
-    (let ((forms (cl-read-all src)))
-      (if (= (len forms) 0)
-        nil
-        (let ((result nil) (i 0))
-          (define loop (fn ()
-            (when (< i (len forms))
-              (do
-                (set! result (cl-eval (nth forms i) env))
-                (set! i (+ i 1))
-                (loop)))))
-          (loop)
-          result)))))
--- a/lib/common-lisp/loop.sx
+++ b/lib/common-lisp/loop.sx
@@ -1,623 +0,0 @@
-;; lib/common-lisp/loop.sx — The LOOP macro for CL-on-SX
-;;
-;; Supported clauses:
-;;   for VAR in LIST             — iterate over list
-;;   for VAR across VECTOR       — alias for 'in'
-;;   for VAR from N              — numeric iteration (to/upto/below/downto/above/by)
-;;   for VAR = EXPR [then EXPR]  — general iteration
-;;   while COND                  — stop when false
-;;   until COND                  — stop when true
-;;   repeat N                    — repeat N times
-;;   collect EXPR [into VAR]
-;;   append EXPR [into VAR]
-;;   nconc EXPR [into VAR]
-;;   sum EXPR [into VAR]
-;;   count EXPR [into VAR]
-;;   maximize EXPR [into VAR]
-;;   minimize EXPR [into VAR]
-;;   do FORM...
-;;   when/if COND clause...
-;;   unless COND clause...
-;;   finally FORM...
-;;   always COND
-;;   never COND
-;;   thereis COND
-;;   named BLOCK-NAME
-;;
-;; Depends on: lib/common-lisp/runtime.sx, lib/common-lisp/eval.sx already loaded.
-;; Uses defmacro in the CL evaluator.
-
-;; ── LOOP expansion driver ─────────────────────────────────────────────────
-
-;; cl-loop-parse: analyse the flat LOOP clause list and build a Lisp form.
-;; Returns a (block NAME (let (...) (tagbody ...))) form.
-(define
-  cl-loop-parse
-  (fn
-    (clauses)
-    (define block-name nil)
-    (define with-bindings (list))
-    (define for-bindings (list))
-    (define test-forms (list))
-    (define repeat-var nil)
-    (define repeat-count nil)
-    (define body-forms (list))
-    (define accum-vars (dict))
-    (define accum-clauses (dict))
-    (define result-var nil)
-    (define finally-forms (list))
-    (define return-expr nil)
-    (define termination nil)
-    (define idx 0)
-    (define (lp-peek) (if (< idx (len clauses)) (nth clauses idx) nil))
-    (define
-      (next!)
-      (let ((v (lp-peek))) (do (set! idx (+ idx 1)) v)))
-    (define
-      (skip-if pred)
-      (if (and (not (nil? (lp-peek))) (pred (lp-peek))) (next!) nil))
-    (define (upcase-str s) (if (string? s) (upcase s) s))
-    (define (kw? s k) (= (upcase-str s) k))
-    (define
-      (make-accum-var!)
-      (if
-        (nil? result-var)
-        (do (set! result-var "#LOOP-RESULT") result-var)
-        result-var))
-    (define
-      (add-accum! type expr into-var)
-      (let
-        ((v (if (nil? into-var) (make-accum-var!) into-var)))
-        (if
-          (not (has-key? accum-vars v))
-          (do
-            (set!
-              accum-vars
-              (assoc
-                accum-vars
-                v
-                (cond
-                  ((= type ":sum") 0)
-                  ((= type ":count") 0)
-                  ((= type ":maximize") nil)
-                  ((= type ":minimize") nil)
-                  (:else (list)))))
-            (set! accum-clauses (assoc accum-clauses v type))))
-        (let
-          ((update (cond ((= type ":collect") (list "SETQ" v (list "APPEND" v (list "LIST" expr)))) ((= type ":append") (list "SETQ" v (list "APPEND" v expr))) ((= type ":nconc") (list "SETQ" v (list "NCONC" v expr))) ((= type ":sum") (list "SETQ" v (list "+" v expr))) ((= type ":count") (list "SETQ" v (list "+" v (list "IF" expr 1 0)))) ((= type ":maximize") (list "SETQ" v (list "IF" (list "OR" (list "NULL" v) (list ">" expr v)) expr v))) ((= type ":minimize") (list "SETQ" v (list "IF" (list "OR" (list "NULL" v) (list "<" expr v)) expr v))) (:else (list "SETQ" v (list "APPEND" v (list "LIST" expr)))))))
-          (set! body-forms (append body-forms (list update))))))
-    (define
-      (parse-clause!)
-      (let
-        ((tok (lp-peek)))
-        (if
-          (nil? tok)
-          nil
-          (do
-            (let
-              ((u (upcase-str tok)))
-              (cond
-                ((= u "NAMED")
-                  (do (next!) (set! block-name (next!)) (parse-clause!)))
-                ((= u "WITH")
-                  (do
-                    (next!)
-                    (let
-                      ((var (next!)))
-                      (skip-if (fn (s) (kw? s "=")))
-                      (let
-                        ((init (next!)))
-                        (set!
-                          with-bindings
-                          (append with-bindings (list (list var init))))
-                        (parse-clause!)))))
-                ((= u "FOR")
-                  (do
-                    (next!)
-                    (let
-                      ((var (next!)))
-                      (let
-                        ((kw2 (upcase-str (lp-peek))))
-                        (cond
-                          ((or (= kw2 "IN") (= kw2 "ACROSS"))
-                            (do
-                              (next!)
-                              (let
-                                ((lst-expr (next!))
-                                  (tail-var (str "#TAIL-" var)))
-                                (set!
-                                  for-bindings
-                                  (append for-bindings (list {:list lst-expr :tail tail-var :type ":list" :var var})))
-                                (parse-clause!))))
-                          ((= kw2 "=")
-                            (do
-                              (next!)
-                              (let
-                                ((init-expr (next!)))
-                                (let
-                                  ((then-expr (if (kw? (lp-peek) "THEN") (do (next!) (next!)) init-expr)))
-                                  (set!
-                                    for-bindings
-                                    (append for-bindings (list {:type ":general" :then then-expr :init init-expr :var var})))
-                                  (parse-clause!)))))
-                          ((or (= kw2 "FROM") (= kw2 "DOWNFROM") (= kw2 "UPFROM"))
-                            (do
-                              (next!)
-                              (let
-                                ((from-expr (next!))
-                                  (dir (if (= kw2 "DOWNFROM") ":down" ":up"))
-                                  (limit-expr nil)
-                                  (limit-type nil)
-                                  (step-expr 1))
-                                (let
-                                  ((lkw (upcase-str (lp-peek))))
-                                  (when
-                                    (or
-                                      (= lkw "TO")
-                                      (= lkw "UPTO")
-                                      (= lkw "BELOW")
-                                      (= lkw "DOWNTO")
-                                      (= lkw "ABOVE"))
-                                    (do
-                                      (next!)
-                                      (set! limit-type lkw)
-                                      (set! limit-expr (next!)))))
-                                (when
-                                  (kw? (lp-peek) "BY")
-                                  (do (next!) (set! step-expr (next!))))
-                                (set!
-                                  for-bindings
-                                  (append for-bindings (list {:dir dir :step step-expr :from from-expr :type ":numeric" :limit-type limit-type :var var :limit limit-expr})))
-                                (parse-clause!))))
-                          ((or (= kw2 "TO") (= kw2 "UPTO") (= kw2 "BELOW"))
-                            (do
-                              (next!)
-                              (let
-                                ((limit-expr (next!))
-                                  (step-expr 1))
-                                (when
-                                  (kw? (lp-peek) "BY")
-                                  (do (next!) (set! step-expr (next!))))
-                                (set!
-                                  for-bindings
-                                  (append for-bindings (list {:dir ":up" :step step-expr :from 0 :type ":numeric" :limit-type kw2 :var var :limit limit-expr})))
-                                (parse-clause!))))
-                          (:else (do (parse-clause!))))))))
-                ((= u "WHILE")
-                  (do
-                    (next!)
-                    (set! test-forms (append test-forms (list {:expr (next!) :type ":while"})))
-                    (parse-clause!)))
-                ((= u "UNTIL")
-                  (do
-                    (next!)
-                    (set! test-forms (append test-forms (list {:expr (next!) :type ":until"})))
-                    (parse-clause!)))
-                ((= u "REPEAT")
-                  (do
-                    (next!)
-                    (set! repeat-count (next!))
-                    (set! repeat-var "#REPEAT-COUNT")
-                    (parse-clause!)))
-                ((or (= u "COLLECT") (= u "COLLECTING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":collect" expr into-var)
-                      (parse-clause!))))
-                ((or (= u "APPEND") (= u "APPENDING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":append" expr into-var)
-                      (parse-clause!))))
-                ((or (= u "NCONC") (= u "NCONCING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":nconc" expr into-var)
-                      (parse-clause!))))
-                ((or (= u "SUM") (= u "SUMMING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":sum" expr into-var)
-                      (parse-clause!))))
-                ((or (= u "COUNT") (= u "COUNTING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":count" expr into-var)
-                      (parse-clause!))))
-                ((or (= u "MAXIMIZE") (= u "MAXIMIZING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":maximize" expr into-var)
-                      (parse-clause!))))
-                ((or (= u "MINIMIZE") (= u "MINIMIZING"))
-                  (do
-                    (next!)
-                    (let
-                      ((expr (next!)) (into-var nil))
-                      (when
-                        (kw? (lp-peek) "INTO")
-                        (do (next!) (set! into-var (next!))))
-                      (add-accum! ":minimize" expr into-var)
-                      (parse-clause!))))
-                ((= u "DO")
-                  (do
-                    (next!)
-                    (define
-                      (loop-kw? s)
-                      (let
-                        ((us (upcase-str s)))
-                        (some
-                          (fn (k) (= us k))
-                          (list
-                            "FOR"
-                            "WITH"
-                            "WHILE"
-                            "UNTIL"
-                            "REPEAT"
-                            "COLLECT"
-                            "COLLECTING"
-                            "APPEND"
-                            "APPENDING"
-                            "NCONC"
-                            "NCONCING"
-                            "SUM"
-                            "SUMMING"
-                            "COUNT"
-                            "COUNTING"
-                            "MAXIMIZE"
-                            "MAXIMIZING"
-                            "MINIMIZE"
-                            "MINIMIZING"
-                            "DO"
-                            "WHEN"
-                            "IF"
-                            "UNLESS"
-                            "FINALLY"
-                            "ALWAYS"
-                            "NEVER"
-                            "THEREIS"
-                            "RETURN"
-                            "NAMED"))))
-                    (define
-                      (collect-do-forms!)
-                      (if
-                        (or (nil? (lp-peek)) (loop-kw? (lp-peek)))
-                        nil
-                        (do
-                          (set!
-                            body-forms
-                            (append body-forms (list (next!))))
-                          (collect-do-forms!))))
-                    (collect-do-forms!)
-                    (parse-clause!)))
-                ((or (= u "WHEN") (= u "IF"))
-                  (do
-                    (next!)
-                    (let
-                      ((cond-expr (next!))
-                       (body-start (len body-forms)))
-                      (parse-clause!)
-                      ;; wrap forms added since body-start in (WHEN cond ...)
-                      (when (> (len body-forms) body-start)
-                        (let ((added (list (nth body-forms body-start))))
-                          (set! body-forms
-                            (append
-                              (if (> body-start 0)
-                                (list (nth body-forms (- body-start 1)))
-                                (list))
-                              (list (list "WHEN" cond-expr (first added)))))
-                          nil)))))
-                ((= u "UNLESS")
-                  (do
-                    (next!)
-                    (let
-                      ((cond-expr (next!))
-                       (body-start (len body-forms)))
-                      (parse-clause!)
-                      (when (> (len body-forms) body-start)
-                        (let ((added (list (nth body-forms body-start))))
-                          (set! body-forms
-                            (append
-                              (if (> body-start 0)
-                                (list (nth body-forms (- body-start 1)))
-                                (list))
-                              (list (list "UNLESS" cond-expr (first added)))))
-                          nil)))))
-                ((= u "ALWAYS")
-                  (do (next!) (set! termination {:expr (next!) :type ":always"}) (parse-clause!)))
-                ((= u "NEVER")
-                  (do (next!) (set! termination {:expr (next!) :type ":never"}) (parse-clause!)))
-                ((= u "THEREIS")
-                  (do (next!) (set! termination {:expr (next!) :type ":thereis"}) (parse-clause!)))
-                ((= u "RETURN")
-                  (do (next!) (set! return-expr (next!)) (parse-clause!)))
-                ((= u "FINALLY")
-                  (do
-                    (next!)
-                    (define
-                      (collect-finally!)
-                      (if
-                        (nil? (lp-peek))
-                        nil
-                        (do
-                          (set!
-                            finally-forms
-                            (append finally-forms (list (next!))))
-                          (collect-finally!))))
-                    (collect-finally!)
-                    (parse-clause!)))
-                (:else
-                  (do
-                    (set! body-forms (append body-forms (list (next!))))
-                    (parse-clause!)))))))))
-    (parse-clause!)
-    (define let-bindings (list))
-    (for-each
-      (fn (wb) (set! let-bindings (append let-bindings (list wb))))
-      with-bindings)
-    (for-each
-      (fn
-        (v)
-        (set!
-          let-bindings
-          (append let-bindings (list (list v (get accum-vars v))))))
-      (keys accum-vars))
-    (when
-      (not (nil? repeat-var))
-      (set!
-        let-bindings
-        (append let-bindings (list (list repeat-var repeat-count)))))
-    (for-each
-      (fn
-        (fb)
-        (let
-          ((type (get fb "type")))
-          (cond
-            ((= type ":list")
-              (do
-                (set!
-                  let-bindings
-                  (append
-                    let-bindings
-                    (list (list (get fb "tail") (get fb "list")))
-                    (list
-                      (list
-                        (get fb "var")
-                        (list
-                          "IF"
-                          (list "CONSP" (get fb "tail"))
-                          (list "CAR" (get fb "tail"))
-                          nil)))))
-                nil))
-            ((= type ":numeric")
-              (set!
-                let-bindings
-                (append
-                  let-bindings
-                  (list (list (get fb "var") (get fb "from"))))))
-            ((= type ":general")
-              (set!
-                let-bindings
-                (append
-                  let-bindings
-                  (list (list (get fb "var") (get fb "init"))))))
-            (:else nil))))
-      for-bindings)
-    (define all-tests (list))
-    (when
-      (not (nil? repeat-var))
-      (set!
-        all-tests
-        (append
-          all-tests
-          (list
-            (list
-              "WHEN"
-              (list "<=" repeat-var 0)
-              (list "RETURN-FROM" block-name (if (nil? result-var) nil result-var))))))
-      (set!
-        body-forms
-        (append
-          (list (list "SETQ" repeat-var (list "-" repeat-var 1)))
-          body-forms)))
-    (for-each
-      (fn
-        (fb)
-        (when
-          (= (get fb "type") ":list")
-          (let
-            ((tvar (get fb "tail")) (var (get fb "var")))
-            (set!
-              all-tests
-              (append
-                all-tests
-                (list
-                  (list
-                    "WHEN"
-                    (list "NULL" tvar)
-                    (list
-                      "RETURN-FROM"
-                      block-name
-                      (if (nil? result-var) nil result-var))))))
-            (set!
-              body-forms
-              (append
-                body-forms
-                (list
-                  (list "SETQ" tvar (list "CDR" tvar))
-                  (list
-                    "SETQ"
-                    var
-                    (list "IF" (list "CONSP" tvar) (list "CAR" tvar) nil))))))))
-      for-bindings)
-    (for-each
-      (fn
-        (fb)
-        (when
-          (= (get fb "type") ":numeric")
-          (let
-            ((var (get fb "var"))
-              (dir (get fb "dir"))
-              (lim (get fb "limit"))
-              (ltype (get fb "limit-type"))
-              (step (get fb "step")))
-            (when
-              (not (nil? lim))
-              (let
-                ((test-op (cond ((or (= ltype "BELOW") (= ltype "ABOVE")) (if (= dir ":up") ">=" "<=")) ((or (= ltype "TO") (= ltype "UPTO")) ">") ((= ltype "DOWNTO") "<") (:else (if (= dir ":up") ">" "<")))))
-                (set!
-                  all-tests
-                  (append
-                    all-tests
-                    (list
-                      (list
-                        "WHEN"
-                        (list test-op var lim)
-                        (list
-                          "RETURN-FROM"
-                          block-name
-                          (if (nil? result-var) nil result-var))))))))
-            (let
-              ((step-op (if (or (= dir ":down") (= ltype "DOWNTO") (= ltype "ABOVE")) "-" "+")))
-              (set!
-                body-forms
-                (append
-                  body-forms
-                  (list (list "SETQ" var (list step-op var step)))))))))
-      for-bindings)
-    (for-each
-      (fn
-        (fb)
-        (when
-          (= (get fb "type") ":general")
-          (set!
-            body-forms
-            (append
-              body-forms
-              (list (list "SETQ" (get fb "var") (get fb "then")))))))
-      for-bindings)
-    (for-each
-      (fn
-        (t)
-        (let
-          ((type (get t "type")) (expr (get t "expr")))
-          (if
-            (= type ":while")
-            (set!
-              all-tests
-              (append
-                all-tests
-                (list
-                  (list
-                    "WHEN"
-                    (list "NOT" expr)
-                    (list
-                      "RETURN-FROM"
-                      block-name
-                      (if (nil? result-var) nil result-var))))))
-            (set!
-              all-tests
-              (append
-                all-tests
-                (list
-                  (list
-                    "WHEN"
-                    expr
-                    (list
-                      "RETURN-FROM"
-                      block-name
-                      (if (nil? result-var) nil result-var)))))))))
-      test-forms)
-    (when
-      (not (nil? termination))
-      (let
-        ((type (get termination "type")) (expr (get termination "expr")))
-        (cond
-          ((= type ":always")
-            (set!
-              body-forms
-              (append
-                body-forms
-                (list
-                  (list "UNLESS" expr (list "RETURN-FROM" block-name false)))))
-            (set! return-expr true))
-          ((= type ":never")
-            (set!
-              body-forms
-              (append
-                body-forms
-                (list
-                  (list "WHEN" expr (list "RETURN-FROM" block-name false)))))
-            (set! return-expr true))
-          ((= type ":thereis")
-            (set!
-              body-forms
-              (append
-                body-forms
-                (list
-                  (list "WHEN" expr (list "RETURN-FROM" block-name expr)))))))))
-    (define tag "#LOOP-START")
-    (define
-      inner-body
-      (append (list tag) all-tests body-forms (list (list "GO" tag))))
-    (define
-      result-form
-      (cond
-        ((not (nil? return-expr)) return-expr)
-        ((not (nil? result-var)) result-var)
-        (:else nil)))
-    (define
-      full-body
-      (if
-        (= (len let-bindings) 0)
-        (append
-          (list "PROGN")
-          (list (append (list "TAGBODY") inner-body))
-          finally-forms
-          (list result-form))
-        (list
-          "LET*"
-          let-bindings
-          (append (list "TAGBODY") inner-body)
-          (append (list "PROGN") finally-forms (list result-form)))))
-    (list "BLOCK" block-name full-body)))
-
-;; ── Install LOOP as a CL macro ────────────────────────────────────────────
-;;
-;; (loop ...) — the form arrives with head "LOOP" and rest = clauses.
-;; The macro fn receives the full form.
-
-(dict-set!
-  cl-macro-registry
-  "LOOP"
-  (fn (form env) (cl-loop-parse (rest form))))
--- a/lib/common-lisp/parser.sx
+++ b/lib/common-lisp/parser.sx
@@ -1,377 +0,0 @@
-;; Common Lisp reader — converts token stream to CL AST forms.
-;;
-;; Depends on: lib/common-lisp/reader.sx  (cl-tokenize)
-;;
-;; AST representation:
-;;   integer/float         → SX number (or {:cl-type "float"/:ratio ...})
-;;   string "hello"        → {:cl-type "string" :value "hello"}
-;;   symbol FOO            → SX string "FOO"  (upcase)
-;;   symbol NIL            → nil
-;;   symbol T              → true
-;;   :keyword              → {:cl-type "keyword" :name "FOO"}
-;;   #\char                → {:cl-type "char"    :value "a"}
-;;   #:uninterned          → {:cl-type "uninterned" :name "FOO"}
-;;   ratio 1/3             → {:cl-type "ratio"   :value "1/3"}
-;;   float 3.14            → {:cl-type "float"   :value "3.14"}
-;;   proper list (a b c)   → SX list (a b c)
-;;   dotted pair (a . b)   → {:cl-type "cons" :car a :cdr b}
-;;   vector #(a b)         → {:cl-type "vector" :elements (list a b)}
-;;   'x                    → ("QUOTE" x)
-;;   `x                    → ("QUASIQUOTE" x)
-;;   ,x                    → ("UNQUOTE" x)
-;;   ,@x                   → ("UNQUOTE-SPLICING" x)
-;;   #'x                   → ("FUNCTION" x)
-;;
-;; Public API:
-;;   (cl-read src)         — parse first form from string, return form
-;;   (cl-read-all src)     — parse all top-level forms, return list
-
-;; ── number conversion ─────────────────────────────────────────────
-
-(define
-  cl-hex-val
-  (fn
-    (c)
-    (let
-      ((o (cl-ord c)))
-      (cond
-        ((and (>= o 48) (<= o 57)) (- o 48))
-        ((and (>= o 65) (<= o 70)) (+ 10 (- o 65)))
-        ((and (>= o 97) (<= o 102)) (+ 10 (- o 97)))
-        (:else 0)))))
-
-(define
-  cl-parse-radix-str
-  (fn
-    (s radix start)
-    (let
-      ((n (string-length s)) (i start) (acc 0))
-      (define
-        loop
-        (fn
-          ()
-          (when
-            (< i n)
-            (do
-              (set! acc (+ (* acc radix) (cl-hex-val (substring s i (+ i 1)))))
-              (set! i (+ i 1))
-              (loop)))))
-      (loop)
-      acc)))
-
-(define
-  cl-convert-integer
-  (fn
-    (s)
-    (let
-      ((n (string-length s)) (neg false))
-      (cond
-        ((and (> n 2) (= (substring s 0 1) "#"))
-          (let
-            ((letter (downcase (substring s 1 2))))
-            (cond
-              ((= letter "x") (cl-parse-radix-str s 16 2))
-              ((= letter "b") (cl-parse-radix-str s 2 2))
-              ((= letter "o") (cl-parse-radix-str s 8 2))
-              (:else (parse-int s 0)))))
-        (:else (parse-int s 0))))))
-
-;; ── reader ────────────────────────────────────────────────────────
-
-;; Read one form from token list.
-;; Returns {:form F :rest remaining-toks} or {:form nil :rest toks :eof true}
-(define
-  cl-read-form
-  (fn
-    (toks)
-    (if
-      (not toks)
-      {:form nil :rest toks :eof true}
-      (let
-        ((tok (nth toks 0)) (nxt (rest toks)))
-        (let
-          ((type (get tok "type")) (val (get tok "value")))
-          (cond
-            ((= type "eof") {:form nil :rest toks :eof true})
-            ((= type "integer") {:form (cl-convert-integer val) :rest nxt})
-            ((= type "float") {:form {:cl-type "float" :value val} :rest nxt})
-            ((= type "ratio") {:form {:cl-type "ratio" :value val} :rest nxt})
-            ((= type "string") {:form {:cl-type "string" :value val} :rest nxt})
-            ((= type "char") {:form {:cl-type "char" :value val} :rest nxt})
-            ((= type "keyword") {:form {:cl-type "keyword" :name val} :rest nxt})
-            ((= type "uninterned") {:form {:cl-type "uninterned" :name val} :rest nxt})
-            ((= type "symbol")
-              (cond
-                ((= val "NIL") {:form nil :rest nxt})
-                ((= val "T") {:form true :rest nxt})
-                (:else {:form val :rest nxt})))
-            ;; list forms
-            ((= type "lparen") (cl-read-list nxt))
-            ((= type "hash-paren") (cl-read-vector nxt))
-            ;; reader macros that wrap the next form
-            ((= type "quote") (cl-read-wrap "QUOTE" nxt))
-            ((= type "backquote") (cl-read-wrap "QUASIQUOTE" nxt))
-            ((= type "comma") (cl-read-wrap "UNQUOTE" nxt))
-            ((= type "comma-at") (cl-read-wrap "UNQUOTE-SPLICING" nxt))
-            ((= type "hash-quote") (cl-read-wrap "FUNCTION" nxt))
-            ;; skip unrecognised tokens
-            (:else (cl-read-form nxt))))))))
-
-;; Wrap next form in a list: (name form)
-(define
-  cl-read-wrap
-  (fn
-    (name toks)
-    (let
-      ((inner (cl-read-form toks)))
-      {:form (list name (get inner "form")) :rest (get inner "rest")})))
-
-;; Read list forms until ')'; handles dotted pair (a . b)
-;; Called after consuming '('
-(define
-  cl-read-list
-  (fn
-    (toks)
-    (let
-      ((result (cl-read-list-items toks (list))))
-      {:form (get result "items") :rest (get result "rest")})))
-
-(define
-  cl-read-list-items
-  (fn
-    (toks acc)
-    (if
-      (not toks)
-      {:items acc :rest toks}
-      (let
-        ((tok (nth toks 0)))
-        (let
-          ((type (get tok "type")))
-          (cond
-            ((= type "eof") {:items acc :rest toks})
-            ((= type "rparen") {:items acc :rest (rest toks)})
-            ;; dotted pair: read one more form then expect ')'
-            ((= type "dot")
-              (let
-                ((cdr-result (cl-read-form (rest toks))))
-                (let
-                  ((cdr-form (get cdr-result "form"))
-                    (after-cdr (get cdr-result "rest")))
-                  ;; skip the closing ')'
-                  (let
-                    ((close (if after-cdr (nth after-cdr 0) nil)))
-                    (let
-                      ((remaining
-                          (if
-                            (and close (= (get close "type") "rparen"))
-                            (rest after-cdr)
-                            after-cdr)))
-                      ;; build dotted structure
-                      (let
-                        ((dotted (cl-build-dotted acc cdr-form)))
-                        {:items dotted :rest remaining}))))))
-            (:else
-              (let
-                ((item (cl-read-form toks)))
-                (cl-read-list-items
-                  (get item "rest")
-                  (concat acc (list (get item "form"))))))))))))
-
-;; Build dotted form: (a b . c) → ((DOTTED a b) . c) style
-;; In CL (a b c . d) means a proper dotted structure.
-;; We represent it as {:cl-type "cons" :car a :cdr (list->dotted b c d)}
-(define
-  cl-build-dotted
-  (fn
-    (head-items tail)
-    (if
-      (= (len head-items) 0)
-      tail
-      (if
-        (= (len head-items) 1)
-        {:cl-type "cons" :car (nth head-items 0) :cdr tail}
-        (let
-          ((last-item (nth head-items (- (len head-items) 1)))
-            (but-last (slice head-items 0 (- (len head-items) 1))))
-          {:cl-type "cons"
-            :car (cl-build-dotted but-last (list last-item))
-            :cdr tail})))))
-
-;; Read vector #(…) elements until ')'
-(define
-  cl-read-vector
-  (fn
-    (toks)
-    (let
-      ((result (cl-read-vector-items toks (list))))
-      {:form {:cl-type "vector" :elements (get result "items")} :rest (get result "rest")})))
-
-(define
-  cl-read-vector-items
-  (fn
-    (toks acc)
-    (if
-      (not toks)
-      {:items acc :rest toks}
-      (let
-        ((tok (nth toks 0)))
-        (let
-          ((type (get tok "type")))
-          (cond
-            ((= type "eof") {:items acc :rest toks})
-            ((= type "rparen") {:items acc :rest (rest toks)})
-            (:else
-              (let
-                ((item (cl-read-form toks)))
-                (cl-read-vector-items
-                  (get item "rest")
-                  (concat acc (list (get item "form"))))))))))))
-
-;; ── lambda-list parser ───────────────────────────────────────────
-;;
-;; (cl-parse-lambda-list forms) — parse a list of CL forms (already read)
-;; into a structured dict:
-;;   {:required (list sym ...)
-;;    :optional (list {:name N :default D :supplied S} ...)
-;;    :rest     nil | "SYM"
-;;    :key      (list {:name N :keyword K :default D :supplied S} ...)
-;;    :allow-other-keys false | true
-;;    :aux      (list {:name N :init I} ...)}
-;;
-;; Symbols arrive as SX strings (upcase). &-markers are strings like "&OPTIONAL".
-;; Key params: keyword is the upcase name string; caller uses it as :keyword.
-;; Supplied-p: nil when absent.
-
-(define
-  cl-parse-opt-spec
-  (fn
-    (spec)
-    (if
-      (list? spec)
-      {:name (nth spec 0)
-        :default (if (> (len spec) 1) (nth spec 1) nil)
-        :supplied (if (> (len spec) 2) (nth spec 2) nil)}
-      {:name spec :default nil :supplied nil})))
-
-(define
-  cl-parse-key-spec
-  (fn
-    (spec)
-    (if
-      (list? spec)
-      (let
-        ((first (nth spec 0)))
-        (if
-          (list? first)
-          ;; ((:keyword var) default supplied-p)
-          {:name (nth first 1)
-            :keyword (get first "name")
-            :default (if (> (len spec) 1) (nth spec 1) nil)
-            :supplied (if (> (len spec) 2) (nth spec 2) nil)}
-          ;; (var default supplied-p)
-          {:name first
-            :keyword first
-            :default (if (> (len spec) 1) (nth spec 1) nil)
-            :supplied (if (> (len spec) 2) (nth spec 2) nil)}))
-      {:name spec :keyword spec :default nil :supplied nil})))
-
-(define
-  cl-parse-aux-spec
-  (fn
-    (spec)
-    (if
-      (list? spec)
-      {:name (nth spec 0) :init (if (> (len spec) 1) (nth spec 1) nil)}
-      {:name spec :init nil})))
-
-(define
-  cl-parse-lambda-list
-  (fn
-    (forms)
-    (let
-      ((state "required")
-        (required (list))
-        (optional (list))
-        (rest-name nil)
-        (key (list))
-        (allow-other-keys false)
-        (aux (list)))
-
-      (define
-        scan
-        (fn
-          (items)
-          (when
-            (> (len items) 0)
-            (let
-              ((item (nth items 0)) (tail (rest items)))
-              (cond
-                ((= item "&OPTIONAL")
-                  (do (set! state "optional") (scan tail)))
-                ((= item "&REST")
-                  (do (set! state "rest") (scan tail)))
-                ((= item "&BODY")
-                  (do (set! state "rest") (scan tail)))
-                ((= item "&KEY")
-                  (do (set! state "key") (scan tail)))
-                ((= item "&AUX")
-                  (do (set! state "aux") (scan tail)))
-                ((= item "&ALLOW-OTHER-KEYS")
-                  (do (set! allow-other-keys true) (scan tail)))
-                ((= state "required")
-                  (do (append! required item) (scan tail)))
-                ((= state "optional")
-                  (do (append! optional (cl-parse-opt-spec item)) (scan tail)))
-                ((= state "rest")
-                  (do (set! rest-name item) (set! state "done") (scan tail)))
-                ((= state "key")
-                  (do (append! key (cl-parse-key-spec item)) (scan tail)))
-                ((= state "aux")
-                  (do (append! aux (cl-parse-aux-spec item)) (scan tail)))
-                (:else (scan tail)))))))
-
-      (scan forms)
-      {:required required
-        :optional optional
-        :rest rest-name
-        :key key
-        :allow-other-keys allow-other-keys
-        :aux aux})))
-
-;; Convenience: parse lambda list from a CL source string
-(define
-  cl-parse-lambda-list-str
-  (fn
-    (src)
-    (cl-parse-lambda-list (cl-read src))))
-
-;; ── public API ────────────────────────────────────────────────────
-
-(define
-  cl-read
-  (fn
-    (src)
-    (let
-      ((toks (cl-tokenize src)))
-      (get (cl-read-form toks) "form"))))
-
-(define
-  cl-read-all
-  (fn
-    (src)
-    (let
-      ((toks (cl-tokenize src)))
-      (define
-        loop
-        (fn
-          (toks acc)
-          (if
-            (or (not toks) (= (get (nth toks 0) "type") "eof"))
-            acc
-            (let
-              ((result (cl-read-form toks)))
-              (if
-                (get result "eof")
-                acc
-                (loop (get result "rest") (concat acc (list (get result "form")))))))))
-      (loop toks (list)))))
--- a/lib/common-lisp/reader.sx
+++ b/lib/common-lisp/reader.sx
@@ -1,381 +0,0 @@
-;; Common Lisp tokenizer
-;;
-;; Tokens: {:type T :value V :pos P}
-;;
-;; Types:
-;;   "symbol"      — FOO, PKG:SYM, PKG::SYM, T, NIL (upcase)
-;;   "keyword"     — :foo (value is upcase name without colon)
-;;   "integer"     — 42, -5, #xFF, #b1010, #o17 (string)
-;;   "float"       — 3.14, 1.0e10 (string)
-;;   "ratio"       — 1/3 (string "N/D")
-;;   "string"      — unescaped content
-;;   "char"        — single-character string
-;;   "lparen"  "rparen"  "quote"  "backquote"  "comma"  "comma-at"
-;;   "hash-quote"  — #'
-;;   "hash-paren"  — #(
-;;   "uninterned"  — #:foo (upcase name)
-;;   "dot"         — standalone . (dotted pair separator)
-;;   "eof"
-
-(define cl-make-tok (fn (type value pos) {:type type :value value :pos pos}))
-
-;; ── char ordinal table ────────────────────────────────────────────
-
-(define
-  cl-ord-table
-  (let
-    ((t (dict)) (i 0))
-    (define
-      cl-fill
-      (fn
-        ()
-        (when
-          (< i 128)
-          (do
-            (dict-set! t (char-from-code i) i)
-            (set! i (+ i 1))
-            (cl-fill)))))
-    (cl-fill)
-    t))
-
-(define cl-ord (fn (c) (or (get cl-ord-table c) 0)))
-
-;; ── character predicates ──────────────────────────────────────────
-
-(define cl-digit? (fn (c) (and (>= (cl-ord c) 48) (<= (cl-ord c) 57))))
-
-(define
-  cl-hex?
-  (fn
-    (c)
-    (or
-      (cl-digit? c)
-      (and (>= (cl-ord c) 65) (<= (cl-ord c) 70))
-      (and (>= (cl-ord c) 97) (<= (cl-ord c) 102)))))
-
-(define cl-octal? (fn (c) (and (>= (cl-ord c) 48) (<= (cl-ord c) 55))))
-
-(define cl-binary? (fn (c) (or (= c "0") (= c "1"))))
-
-(define cl-ws? (fn (c) (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
-
-(define
-  cl-alpha?
-  (fn
-    (c)
-    (or
-      (and (>= (cl-ord c) 65) (<= (cl-ord c) 90))
-      (and (>= (cl-ord c) 97) (<= (cl-ord c) 122)))))
-
-;; Characters that end a token (whitespace + terminating macro chars)
-(define
-  cl-terminating?
-  (fn
-    (c)
-    (or
-      (cl-ws? c)
-      (= c "(")
-      (= c ")")
-      (= c "\"")
-      (= c ";")
-      (= c "`")
-      (= c ","))))
-
-;; Symbol constituent: not terminating, not reader-special
-(define
-  cl-sym-char?
-  (fn
-    (c)
-    (not
-      (or
-        (cl-terminating? c)
-        (= c "#")
-        (= c "|")
-        (= c "\\")
-        (= c "'")))))
-
-;; ── named character table ─────────────────────────────────────────
-
-(define
-  cl-named-chars
-  {:space " "
-    :newline "\n"
-    :tab "\t"
-    :return "\r"
-    :backspace (char-from-code 8)
-    :rubout (char-from-code 127)
-    :delete (char-from-code 127)
-    :escape (char-from-code 27)
-    :altmode (char-from-code 27)
-    :null (char-from-code 0)
-    :nul (char-from-code 0)
-    :page (char-from-code 12)
-    :formfeed (char-from-code 12)})
-
-;; ── main tokenizer ────────────────────────────────────────────────
-
-(define
-  cl-tokenize
-  (fn
-    (src)
-    (let
-      ((pos 0) (n (string-length src)) (toks (list)))
-
-      (define at (fn () (if (< pos n) (substring src pos (+ pos 1)) nil)))
-      (define peek1 (fn () (if (< (+ pos 1) n) (substring src (+ pos 1) (+ pos 2)) nil)))
-      (define adv (fn () (set! pos (+ pos 1))))
-
-      ;; Advance while predicate holds; return substring from start to end
-      (define
-        read-while
-        (fn
-          (pred)
-          (let
-            ((start pos))
-            (define
-              rw-loop
-              (fn
-                ()
-                (when
-                  (and (at) (pred (at)))
-                  (do (adv) (rw-loop)))))
-            (rw-loop)
-            (substring src start pos))))
-
-      (define
-        skip-line
-        (fn
-          ()
-          (when
-            (and (at) (not (= (at) "\n")))
-            (do (adv) (skip-line)))))
-
-      (define
-        skip-block
-        (fn
-          (depth)
-          (when
-            (at)
-            (cond
-              ((and (= (at) "#") (= (peek1) "|"))
-                (do (adv) (adv) (skip-block (+ depth 1))))
-              ((and (= (at) "|") (= (peek1) "#"))
-                (do
-                  (adv)
-                  (adv)
-                  (when (> depth 1) (skip-block (- depth 1)))))
-              (:else (do (adv) (skip-block depth)))))))
-
-      ;; Read string literal — called with pos just past opening "
-      (define
-        read-str
-        (fn
-          (acc)
-          (if
-            (not (at))
-            acc
-            (cond
-              ((= (at) "\"") (do (adv) acc))
-              ((= (at) "\\")
-                (do
-                  (adv)
-                  (let
-                    ((e (at)))
-                    (adv)
-                    (read-str
-                      (str
-                        acc
-                        (cond
-                          ((= e "n") "\n")
-                          ((= e "t") "\t")
-                          ((= e "r") "\r")
-                          ((= e "\"") "\"")
-                          ((= e "\\") "\\")
-                          (:else e)))))))
-              (:else
-                (let
-                  ((c (at)))
-                  (adv)
-                  (read-str (str acc c))))))))
-
-      ;; Read #\ char literal — called with pos just past the backslash
-      (define
-        read-char-lit
-        (fn
-          ()
-          (let
-            ((first (at)))
-            (adv)
-            (let
-              ((rest (if (and (at) (cl-alpha? (at))) (read-while cl-alpha?) "")))
-              (if
-                (= rest "")
-                first
-                (let
-                  ((name (downcase (str first rest))))
-                  (or (get cl-named-chars name) first)))))))
-
-      ;; Number scanner — called with pos just past first digit(s).
-      ;; acc holds what was already consumed (first digit or sign+digit).
-      (define
-        scan-num
-        (fn
-          (p acc)
-          (let
-            ((more (read-while cl-digit?)))
-            (set! acc (str acc more))
-            (cond
-              ;; ratio N/D
-              ((and (at) (= (at) "/") (peek1) (cl-digit? (peek1)))
-                (do
-                  (adv)
-                  (let
-                    ((denom (read-while cl-digit?)))
-                    {:type "ratio" :value (str acc "/" denom) :pos p})))
-              ;; float: decimal point N.M[eE]
-              ((and (at) (= (at) ".") (peek1) (cl-digit? (peek1)))
-                (do
-                  (adv)
-                  (let
-                    ((frac (read-while cl-digit?)))
-                    (set! acc (str acc "." frac))
-                    (when
-                      (and (at) (or (= (at) "e") (= (at) "E")))
-                      (do
-                        (set! acc (str acc (at)))
-                        (adv)
-                        (when
-                          (and (at) (or (= (at) "+") (= (at) "-")))
-                          (do (set! acc (str acc (at))) (adv)))
-                        (set! acc (str acc (read-while cl-digit?)))))
-                    {:type "float" :value acc :pos p})))
-              ;; float: exponent only NeE
-              ((and (at) (or (= (at) "e") (= (at) "E")))
-                (do
-                  (set! acc (str acc (at)))
-                  (adv)
-                  (when
-                    (and (at) (or (= (at) "+") (= (at) "-")))
-                    (do (set! acc (str acc (at))) (adv)))
-                  (set! acc (str acc (read-while cl-digit?)))
-                  {:type "float" :value acc :pos p}))
-              (:else {:type "integer" :value acc :pos p})))))
-
-      (define
-        read-radix
-        (fn
-          (letter p)
-          (let
-            ((pred
-                (cond
-                  ((or (= letter "x") (= letter "X")) cl-hex?)
-                  ((or (= letter "b") (= letter "B")) cl-binary?)
-                  ((or (= letter "o") (= letter "O")) cl-octal?)
-                  (:else cl-digit?))))
-            {:type "integer"
-              :value (str "#" letter (read-while pred))
-              :pos p})))
-
-      (define emit (fn (tok) (append! toks tok)))
-
-      (define
-        scan
-        (fn
-          ()
-          (when
-            (< pos n)
-            (let
-              ((c (at)) (p pos))
-              (cond
-                ((cl-ws? c) (do (adv) (scan)))
-                ((= c ";") (do (adv) (skip-line) (scan)))
-                ((= c "(") (do (adv) (emit (cl-make-tok "lparen" "(" p)) (scan)))
-                ((= c ")") (do (adv) (emit (cl-make-tok "rparen" ")" p)) (scan)))
-                ((= c "'") (do (adv) (emit (cl-make-tok "quote" "'" p)) (scan)))
-                ((= c "`") (do (adv) (emit (cl-make-tok "backquote" "`" p)) (scan)))
-                ((= c ",")
-                  (do
-                    (adv)
-                    (if
-                      (= (at) "@")
-                      (do (adv) (emit (cl-make-tok "comma-at" ",@" p)))
-                      (emit (cl-make-tok "comma" "," p)))
-                    (scan)))
-                ((= c "\"")
-                  (do
-                    (adv)
-                    (emit (cl-make-tok "string" (read-str "") p))
-                    (scan)))
-                ;; :keyword
-                ((= c ":")
-                  (do
-                    (adv)
-                    (emit (cl-make-tok "keyword" (upcase (read-while cl-sym-char?)) p))
-                    (scan)))
-                ;; dispatch macro #
-                ((= c "#")
-                  (do
-                    (adv)
-                    (let
-                      ((d (at)))
-                      (cond
-                        ((= d "'") (do (adv) (emit (cl-make-tok "hash-quote" "#'" p)) (scan)))
-                        ((= d "(") (do (adv) (emit (cl-make-tok "hash-paren" "#(" p)) (scan)))
-                        ((= d ":")
-                          (do
-                            (adv)
-                            (emit
-                              (cl-make-tok "uninterned" (upcase (read-while cl-sym-char?)) p))
-                            (scan)))
-                        ((= d "|") (do (adv) (skip-block 1) (scan)))
-                        ((= d "\\")
-                          (do (adv) (emit (cl-make-tok "char" (read-char-lit) p)) (scan)))
-                        ((or (= d "x") (= d "X"))
-                          (do (adv) (emit (read-radix d p)) (scan)))
-                        ((or (= d "b") (= d "B"))
-                          (do (adv) (emit (read-radix d p)) (scan)))
-                        ((or (= d "o") (= d "O"))
-                          (do (adv) (emit (read-radix d p)) (scan)))
-                        (:else (scan))))))
-                ;; standalone dot, float .5, or symbol starting with dots
-                ((= c ".")
-                  (do
-                    (adv)
-                    (cond
-                      ((or (not (at)) (cl-terminating? (at)))
-                        (do (emit (cl-make-tok "dot" "." p)) (scan)))
-                      ((cl-digit? (at))
-                        (do
-                          (emit
-                            (cl-make-tok "float" (str "0." (read-while cl-digit?)) p))
-                          (scan)))
-                      (:else
-                        (do
-                          (emit
-                            (cl-make-tok "symbol" (upcase (str "." (read-while cl-sym-char?))) p))
-                          (scan))))))
-                ;; sign followed by digit → number
-                ((and (or (= c "+") (= c "-")) (peek1) (cl-digit? (peek1)))
-                  (do
-                    (adv)
-                    (let
-                      ((first-d (at)))
-                      (adv)
-                      (emit (scan-num p (str c first-d))))
-                    (scan)))
-                ;; decimal digit → number
-                ((cl-digit? c)
-                  (do
-                    (adv)
-                    (emit (scan-num p c))
-                    (scan)))
-                ;; symbol constituent (includes bare +, -, etc.)
-                ((cl-sym-char? c)
-                  (do
-                    (emit (cl-make-tok "symbol" (upcase (read-while cl-sym-char?)) p))
-                    (scan)))
-                (:else (do (adv) (scan))))))))
-
-      (scan)
-      (append! toks (cl-make-tok "eof" nil n))
-      toks)))
--- a/lib/common-lisp/runtime.sx
+++ b/lib/common-lisp/runtime.sx
@@ -1,724 +0,0 @@
-;; lib/common-lisp/runtime.sx — CL built-ins + condition system on SX
-;;
-;; Section 1-9:  Type predicates, arithmetic, characters, strings, gensym,
-;;               multiple values, sets, radix formatting, list utilities.
-;; Section 10:   Condition system (define-condition, signal/error/warn,
-;;               handler-bind, handler-case, restart-case, invoke-restart).
-;;
-;; Primitives used from spec:
-;;   char/char->integer/integer->char/char-upcase/char-downcase
-;;   format   gensym   rational/rational?   make-set/set-member?/etc
-;;   modulo/remainder/quotient/gcd/lcm/expt   number->string
-
-;; ---------------------------------------------------------------------------
-;; 1.  Type predicates
-;; ---------------------------------------------------------------------------
-
-(define (cl-null? x) (= x nil))
-(define (cl-consp? x) (and (list? x) (not (cl-empty? x))))
-(define (cl-listp? x) (or (cl-empty? x) (list? x)))
-(define (cl-atom? x) (not (cl-consp? x)))
-
-(define
-  (cl-numberp? x)
-  (let ((t (type-of x))) (or (= t "number") (= t "rational"))))
-
-(define cl-integerp? integer?)
-(define cl-floatp? float?)
-(define cl-rationalp? rational?)
-
-(define (cl-realp? x) (or (integer? x) (float? x) (rational? x)))
-
-(define cl-characterp? char?)
-(define cl-stringp? (fn (x) (= (type-of x) "string")))
-(define cl-symbolp? (fn (x) (= (type-of x) "symbol")))
-(define cl-keywordp? (fn (x) (= (type-of x) "keyword")))
-
-(define
-  (cl-functionp? x)
-  (let
-    ((t (type-of x)))
-    (or
-      (= t "function")
-      (= t "lambda")
-      (= t "native-fn")
-      (= t "component"))))
-
-(define cl-vectorp? vector?)
-(define cl-arrayp? vector?)
-
-;; sx_server: (rest (list x)) returns () not nil — cl-empty? handles both
-(define
-  (cl-empty? x)
-  (or (nil? x) (and (list? x) (= (len x) 0))))
-
-;; ---------------------------------------------------------------------------
-;; 2.  Arithmetic — thin aliases to spec primitives
-;; ---------------------------------------------------------------------------
-
-(define cl-mod modulo)
-(define cl-rem remainder)
-(define cl-gcd gcd)
-(define cl-lcm lcm)
-(define cl-expt expt)
-(define cl-floor floor)
-(define cl-ceiling ceil)
-(define cl-truncate truncate)
-(define cl-round round)
-(define cl-abs (fn (x) (if (< x 0) (- 0 x) x)))
-(define cl-min (fn (a b) (if (< a b) a b)))
-(define cl-max (fn (a b) (if (> a b) a b)))
-(define cl-quotient quotient)
-
-(define
-  (cl-signum x)
-  (cond
-    ((> x 0) 1)
-    ((< x 0) -1)
-    (else 0)))
-
-(define (cl-evenp? n) (= (modulo n 2) 0))
-(define (cl-oddp? n) (= (modulo n 2) 1))
-(define (cl-zerop? n) (= n 0))
-(define (cl-plusp? n) (> n 0))
-(define (cl-minusp? n) (< n 0))
-
-;; ---------------------------------------------------------------------------
-;; 3.  Character functions — alias spec char primitives + CL name mapping
-;; ---------------------------------------------------------------------------
-
-(define cl-char->integer char->integer)
-(define cl-integer->char integer->char)
-(define cl-char-upcase char-upcase)
-(define cl-char-downcase char-downcase)
-(define cl-char-code char->integer)
-(define cl-code-char integer->char)
-
-(define cl-char=? char=?)
-(define cl-char<? char<?)
-(define cl-char>? char>?)
-(define cl-char<=? char<=?)
-(define cl-char>=? char>=?)
-(define cl-char-ci=? char-ci=?)
-(define cl-char-ci<? char-ci<?)
-(define cl-char-ci>? char-ci>?)
-
-;; Inline predicates — char-alphabetic?/char-numeric? unreliable in sx_server
-(define
-  (cl-alpha-char-p c)
-  (let
-    ((n (char->integer c)))
-    (or
-      (and (>= n 65) (<= n 90))
-      (and (>= n 97) (<= n 122)))))
-
-(define
-  (cl-digit-char-p c)
-  (let ((n (char->integer c))) (and (>= n 48) (<= n 57))))
-
-(define
-  (cl-alphanumericp c)
-  (let
-    ((n (char->integer c)))
-    (or
-      (and (>= n 48) (<= n 57))
-      (and (>= n 65) (<= n 90))
-      (and (>= n 97) (<= n 122)))))
-
-(define
-  (cl-upper-case-p c)
-  (let ((n (char->integer c))) (and (>= n 65) (<= n 90))))
-
-(define
-  (cl-lower-case-p c)
-  (let ((n (char->integer c))) (and (>= n 97) (<= n 122))))
-
-;; Named character constants
-(define cl-char-space (integer->char 32))
-(define cl-char-newline (integer->char 10))
-(define cl-char-tab (integer->char 9))
-(define cl-char-backspace (integer->char 8))
-(define cl-char-return (integer->char 13))
-(define cl-char-null (integer->char 0))
-(define cl-char-escape (integer->char 27))
-(define cl-char-delete (integer->char 127))
-
-;; ---------------------------------------------------------------------------
-;; 4.  String + IO — use spec format and ports
-;; ---------------------------------------------------------------------------
-
-;; CL format: (cl-format nil "~a ~a" x y) — nil destination means return string
-(define
-  (cl-format dest template &rest args)
-  (let ((s (apply format (cons template args)))) (if (= dest nil) s s)))
-
-(define cl-write-to-string write-to-string)
-(define cl-princ-to-string display-to-string)
-
-;; CL read-from-string: parse value from a string using SX port
-(define
-  (cl-read-from-string s)
-  (let ((p (open-input-string s))) (read p)))
-
-;; String stream (output)
-(define cl-make-string-output-stream open-output-string)
-(define cl-get-output-stream-string get-output-string)
-
-;; String stream (input)
-(define cl-make-string-input-stream open-input-string)
-
-;; ---------------------------------------------------------------------------
-;; 5.  Gensym
-;; ---------------------------------------------------------------------------
-
-(define cl-gensym gensym)
-(define cl-gentemp gensym)
-
-;; ---------------------------------------------------------------------------
-;; 6.  Multiple values (CL: values / nth-value)
-;; ---------------------------------------------------------------------------
-
-(define (cl-values &rest args) {:_values true :_list args})
-
-(define
-  (cl-call-with-values producer consumer)
-  (let
-    ((mv (producer)))
-    (if
-      (and (dict? mv) (get mv :_values))
-      (apply consumer (get mv :_list))
-      (consumer mv))))
-
-(define
-  (cl-nth-value n mv)
-  (cond
-    ((and (dict? mv) (get mv :_values))
-      (let
-        ((lst (get mv :_list)))
-        (if (>= n (len lst)) nil (nth lst n))))
-    ((= n 0) mv)
-    (else nil)))
-
-;; ---------------------------------------------------------------------------
-;; 7.  Sets (CL: adjoin / member / union / intersection / set-difference)
-;; ---------------------------------------------------------------------------
-
-(define cl-make-set make-set)
-(define cl-set? set?)
-(define cl-set-add set-add!)
-(define cl-set-memberp set-member?)
-(define cl-set-remove set-remove!)
-(define cl-set-union set-union)
-(define cl-set-intersect set-intersection)
-(define cl-set-difference set-difference)
-(define cl-list->set list->set)
-(define cl-set->list set->list)
-
-;; CL: (member item list) — returns tail starting at item, or nil
-(define
-  (cl-member item lst)
-  (cond
-    ((cl-empty? lst) nil)
-    ((equal? item (first lst)) lst)
-    (else (cl-member item (rest lst)))))
-
-;; CL: (adjoin item list) — cons only if not already present
-(define (cl-adjoin item lst) (if (cl-member item lst) lst (cons item lst)))
-
-;; ---------------------------------------------------------------------------
-;; 8.  Radix formatting  (CL: (write-to-string n :base radix))
-;; ---------------------------------------------------------------------------
-
-(define (cl-integer-to-string n radix) (number->string n radix))
-
-(define (cl-string-to-integer s radix) (string->number s radix))
-
-;; CL ~R directive helpers
-(define (cl-format-binary n) (number->string n 2))
-(define (cl-format-octal n) (number->string n 8))
-(define (cl-format-hex n) (number->string n 16))
-(define (cl-format-decimal n) (number->string n 10))
-
-;; ---------------------------------------------------------------------------
-;; 9.  List utilities — cl-empty? guards against () from rest
-;; ---------------------------------------------------------------------------
-
-(define
-  (cl-last lst)
-  (cond
-    ((cl-empty? lst) nil)
-    ((cl-empty? (rest lst)) lst)
-    (else (cl-last (rest lst)))))
-
-(define
-  (cl-butlast lst)
-  (if
-    (or (cl-empty? lst) (cl-empty? (rest lst)))
-    nil
-    (cons (first lst) (cl-butlast (rest lst)))))
-
-(define
-  (cl-nthcdr n lst)
-  (if (= n 0) lst (cl-nthcdr (- n 1) (rest lst))))
-
-(define (cl-nth n lst) (first (cl-nthcdr n lst)))
-
-(define (cl-list-length lst) (len lst))
-
-(define
-  (cl-copy-list lst)
-  (if (cl-empty? lst) nil (cons (first lst) (cl-copy-list (rest lst)))))
-
-(define
-  (cl-flatten lst)
-  (cond
-    ((cl-empty? lst) nil)
-    ((list? (first lst))
-      (append (cl-flatten (first lst)) (cl-flatten (rest lst))))
-    (else (cons (first lst) (cl-flatten (rest lst))))))
-
-;; CL: (assoc key alist) — returns matching pair or nil
-(define
-  (cl-assoc key alist)
-  (cond
-    ((cl-empty? alist) nil)
-    ((equal? key (first (first alist))) (first alist))
-    (else (cl-assoc key (rest alist)))))
-
-;; CL: (rassoc val alist) — reverse assoc (match on second element)
-(define
-  (cl-rassoc val alist)
-  (cond
-    ((cl-empty? alist) nil)
-    ((equal? val (first (rest (first alist)))) (first alist))
-    (else (cl-rassoc val (rest alist)))))
-
-;; CL: (getf plist key) — property list lookup
-(define
-  (cl-getf plist key)
-  (cond
-    ((or (cl-empty? plist) (cl-empty? (rest plist))) nil)
-    ((equal? (first plist) key) (first (rest plist)))
-    (else (cl-getf (rest (rest plist)) key))))
-
-;; ---------------------------------------------------------------------------
-;; 10.  Condition system (Phase 3)
-;;
-;; Condition objects:
-;;   {:cl-type "cl-condition" :class "NAME" :slots {slot-name val ...}}
-;;
-;; The built-in handler-bind / restart-case expect LITERAL handler specs in
-;; source (they operate on the raw AST), so we implement our own handler and
-;; restart stacks as mutable SX globals.
-;; ---------------------------------------------------------------------------
-
-;; ── condition class registry ───────────────────────────────────────────────
-;;
-;; Populated at load time with all ANSI standard condition types.
-;; Also mutated by cl-define-condition.
-
-(define
-  cl-condition-classes
-  (dict
-    "condition"
-    {:parents (list) :slots (list) :name "condition"}
-    "serious-condition"
-    {:parents (list "condition") :slots (list) :name "serious-condition"}
-    "error"
-    {:parents (list "serious-condition") :slots (list) :name "error"}
-    "warning"
-    {:parents (list "condition") :slots (list) :name "warning"}
-    "simple-condition"
-    {:parents (list "condition") :slots (list "format-control" "format-arguments") :name "simple-condition"}
-    "simple-error"
-    {:parents (list "error" "simple-condition") :slots (list "format-control" "format-arguments") :name "simple-error"}
-    "simple-warning"
-    {:parents (list "warning" "simple-condition") :slots (list "format-control" "format-arguments") :name "simple-warning"}
-    "type-error"
-    {:parents (list "error") :slots (list "datum" "expected-type") :name "type-error"}
-    "arithmetic-error"
-    {:parents (list "error") :slots (list "operation" "operands") :name "arithmetic-error"}
-    "division-by-zero"
-    {:parents (list "arithmetic-error") :slots (list) :name "division-by-zero"}
-    "cell-error"
-    {:parents (list "error") :slots (list "name") :name "cell-error"}
-    "unbound-variable"
-    {:parents (list "cell-error") :slots (list) :name "unbound-variable"}
-    "undefined-function"
-    {:parents (list "cell-error") :slots (list) :name "undefined-function"}
-    "program-error"
-    {:parents (list "error") :slots (list) :name "program-error"}
-    "storage-condition"
-    {:parents (list "serious-condition") :slots (list) :name "storage-condition"}))
-
-;; ── condition predicates ───────────────────────────────────────────────────
-
-(define
-  cl-condition?
-  (fn (x) (and (dict? x) (= (get x "cl-type") "cl-condition"))))
-
-;; cl-condition-of-type? walks the class hierarchy.
-;; We capture cl-condition-classes at define time via let to avoid
-;; free-variable scoping issues at call time.
-
-(define
-  cl-condition-of-type?
-  (let
-    ((classes cl-condition-classes))
-    (fn
-      (c type-name)
-      (if
-        (not (cl-condition? c))
-        false
-        (let
-          ((class-name (get c "class")))
-          (define
-            check
-            (fn
-              (n)
-              (if
-                (= n type-name)
-                true
-                (let
-                  ((entry (get classes n)))
-                  (if
-                    (nil? entry)
-                    false
-                    (some (fn (p) (check p)) (get entry "parents")))))))
-          (check class-name))))))
-
-;; ── condition constructors ─────────────────────────────────────────────────
-
-;; cl-define-condition registers a new condition class.
-;; name:       string (condition class name)
-;; parents:    list of strings (parent class names)
-;; slot-names: list of strings
-
-(define
-  cl-define-condition
-  (fn
-    (name parents slot-names)
-    (begin (dict-set! cl-condition-classes name {:parents parents :slots slot-names :name name}) name)))
-
-;; cl-make-condition constructs a condition object.
-;; Keyword args (alternating slot-name/value pairs) populate the slots dict.
-
-(define
-  cl-make-condition
-  (fn
-    (name &rest kw-args)
-    (let
-      ((slots (dict)))
-      (define
-        fill
-        (fn
-          (args)
-          (when
-            (>= (len args) 2)
-            (begin
-              (dict-set! slots (first args) (first (rest args)))
-              (fill (rest (rest args)))))))
-      (fill kw-args)
-      {:cl-type "cl-condition" :slots slots :class name})))
-
-;; ── condition accessors ────────────────────────────────────────────────────
-
-(define
-  cl-condition-slot
-  (fn
-    (c slot-name)
-    (if (cl-condition? c) (get (get c "slots") slot-name) nil)))
-
-(define
-  cl-condition-message
-  (fn
-    (c)
-    (if
-      (not (cl-condition? c))
-      (str c)
-      (let
-        ((slots (get c "slots")))
-        (or
-          (get slots "message")
-          (get slots "format-control")
-          (str "Condition: " (get c "class")))))))
-
-(define
-  cl-simple-condition-format-control
-  (fn (c) (cl-condition-slot c "format-control")))
-
-(define
-  cl-simple-condition-format-arguments
-  (fn (c) (cl-condition-slot c "format-arguments")))
-
-(define cl-type-error-datum (fn (c) (cl-condition-slot c "datum")))
-
-(define
-  cl-type-error-expected-type
-  (fn (c) (cl-condition-slot c "expected-type")))
-
-(define
-  cl-arithmetic-error-operation
-  (fn (c) (cl-condition-slot c "operation")))
-
-(define
-  cl-arithmetic-error-operands
-  (fn (c) (cl-condition-slot c "operands")))
-
-;; ── mutable handler + restart stacks ──────────────────────────────────────
-;;
-;; Handler entry: {:type "type-name" :fn (fn (condition) result)}
-;; Restart entry: {:name "restart-name" :fn (fn (&optional arg) result) :escape k}
-;;
-;; New handlers are prepended (checked first = most recent handler wins).
-
-(define cl-handler-stack (list))
-(define cl-restart-stack (list))
-
-(define
-  cl-push-handlers
-  (fn (entries) (set! cl-handler-stack (append entries cl-handler-stack))))
-
-(define
-  cl-pop-handlers
-  (fn
-    (n)
-    (set! cl-handler-stack (slice cl-handler-stack n (len cl-handler-stack)))))
-
-(define
-  cl-push-restarts
-  (fn (entries) (set! cl-restart-stack (append entries cl-restart-stack))))
-
-(define
-  cl-pop-restarts
-  (fn
-    (n)
-    (set! cl-restart-stack (slice cl-restart-stack n (len cl-restart-stack)))))
-
-;; ── *debugger-hook* + invoke-debugger ────────────────────────────────────
-;;
-;; cl-debugger-hook: called when an error propagates with no handler.
-;; Signature: (fn (condition hook) result). The hook arg is itself
-;; (so the hook can rebind it to nil to prevent recursion).
-;; nil = use default (re-raise as host error).
-
-(define cl-debugger-hook nil)
-
-(define cl-invoke-debugger
-  (fn (c)
-    (if (nil? cl-debugger-hook)
-      (error (str "Debugger: " (cl-condition-message c)))
-      (let ((hook cl-debugger-hook))
-        (set! cl-debugger-hook nil)
-        (let ((result (hook c hook)))
-          (set! cl-debugger-hook hook)
-          result)))))
-
-;; ── *break-on-signals* ────────────────────────────────────────────────────
-;;
-;; When set to a type name string, cl-signal invokes the debugger hook
-;; before walking handlers if the condition is of that type.
-;; nil = disabled (ANSI default).
-
-(define cl-break-on-signals nil)
-
-;; ── invoke-restart-interactively ──────────────────────────────────────────
-;;
-;; Like invoke-restart but calls the restart's fn with no arguments
-;; (real CL would prompt the user for each arg via :interactive).
-
-(define cl-invoke-restart-interactively
-  (fn (name)
-    (let ((entry (cl-find-restart-entry name cl-restart-stack)))
-      (if (nil? entry)
-        (error (str "No active restart: " name))
-        (let ((restart-fn (get entry "fn"))
-              (escape     (get entry "escape")))
-          (escape (restart-fn)))))))
-
-;; ── cl-signal (non-unwinding) ─────────────────────────────────────────────
-;;
-;; Walks cl-handler-stack; for each matching entry, calls the handler fn.
-;; Handlers return normally — signal continues to the next matching handler.
-
-(define
-  cl-signal-obj
-  (fn
-    (obj stack)
-    (if
-      (empty? stack)
-      nil
-      (let
-        ((entry (first stack)))
-        (if
-          (cl-condition-of-type? obj (get entry "type"))
-          (begin ((get entry "fn") obj) (cl-signal-obj obj (rest stack)))
-          (cl-signal-obj obj (rest stack)))))))
-
-(define cl-signal
-  (fn (c)
-    (let ((obj (if (cl-condition? c)
-                 c
-                 (cl-make-condition "simple-condition"
-                   "format-control" (str c)))))
-      ;; *break-on-signals*: invoke debugger hook when type matches
-      (when (and (not (nil? cl-break-on-signals))
-                 (cl-condition-of-type? obj cl-break-on-signals))
-        (cl-invoke-debugger obj))
-      (cl-signal-obj obj cl-handler-stack))))
-
-;; ── cl-error ───────────────────────────────────────────────────────────────
-;;
-;; Signals an error. If no handler catches it, raises a host-level error.
-
-(define
-  cl-error
-  (fn
-    (c &rest args)
-    (let
-      ((obj (cond ((cl-condition? c) c) ((string? c) (cl-make-condition "simple-error" "format-control" c "format-arguments" args)) (:else (cl-make-condition "simple-error" "format-control" (str c))))))
-      (cl-signal-obj obj cl-handler-stack)
-      (cl-invoke-debugger obj))))
-
-;; ── cl-warn ────────────────────────────────────────────────────────────────
-
-(define
-  cl-warn
-  (fn
-    (c &rest args)
-    (let
-      ((obj (cond ((cl-condition? c) c) ((string? c) (cl-make-condition "simple-warning" "format-control" c "format-arguments" args)) (:else (cl-make-condition "simple-warning" "format-control" (str c))))))
-      (cl-signal-obj obj cl-handler-stack))))
-
-;; ── cl-handler-bind (non-unwinding) ───────────────────────────────────────
-;;
-;; bindings: list of (type-name handler-fn) pairs
-;; thunk:    (fn () body)
-
-(define
-  cl-handler-bind
-  (fn
-    (bindings thunk)
-    (let
-      ((entries (map (fn (b) {:fn (first (rest b)) :type (first b)}) bindings)))
-      (begin
-        (cl-push-handlers entries)
-        (let
-          ((result (thunk)))
-          (begin (cl-pop-handlers (len entries)) result))))))
-
-;; ── cl-handler-case (unwinding) ───────────────────────────────────────────
-;;
-;; thunk: (fn () body)
-;; cases: list of (type-name handler-fn) pairs
-;;
-;; Uses call/cc for the escape continuation.
-
-(define
-  cl-handler-case
-  (fn
-    (thunk &rest cases)
-    (call/cc
-      (fn
-        (escape)
-        (let
-          ((entries (map (fn (c) {:fn (fn (x) (escape ((first (rest c)) x))) :type (first c)}) cases)))
-          (begin
-            (cl-push-handlers entries)
-            (let
-              ((result (thunk)))
-              (begin (cl-pop-handlers (len entries)) result))))))))
-
-;; ── cl-restart-case ────────────────────────────────────────────────────────
-;;
-;; thunk:    (fn () body)
-;; restarts: list of (name params body-fn) triples
-;;   body-fn is (fn () val) or (fn (arg) val)
-
-(define
-  cl-restart-case
-  (fn
-    (thunk &rest restarts)
-    (call/cc
-      (fn
-        (escape)
-        (let
-          ((entries (map (fn (r) {:fn (first (rest (rest r))) :escape escape :name (first r)}) restarts)))
-          (begin
-            (cl-push-restarts entries)
-            (let
-              ((result (thunk)))
-              (begin (cl-pop-restarts (len entries)) result))))))))
-
-;; ── cl-with-simple-restart ─────────────────────────────────────────────────
-
-(define
-  cl-with-simple-restart
-  (fn
-    (name description thunk)
-    (cl-restart-case thunk (list name (list) (fn () nil)))))
-
-;; ── find-restart / invoke-restart / compute-restarts ──────────────────────
-
-(define
-  cl-find-restart-entry
-  (fn
-    (name stack)
-    (if
-      (empty? stack)
-      nil
-      (let
-        ((entry (first stack)))
-        (if
-          (= (get entry "name") name)
-          entry
-          (cl-find-restart-entry name (rest stack)))))))
-
-(define
-  cl-find-restart
-  (fn (name) (cl-find-restart-entry name cl-restart-stack)))
-
-(define
-  cl-invoke-restart
-  (fn
-    (name &rest args)
-    (let
-      ((entry (cl-find-restart-entry name cl-restart-stack)))
-      (if
-        (nil? entry)
-        (error (str "No active restart: " name))
-        (let
-          ((restart-fn (get entry "fn")) (escape (get entry "escape")))
-          (escape
-            (if (empty? args) (restart-fn) (restart-fn (first args)))))))))
-
-(define
-  cl-compute-restarts
-  (fn () (map (fn (e) (get e "name")) cl-restart-stack)))
-
-;; ── with-condition-restarts (stub — association is advisory) ──────────────
-
-(define cl-with-condition-restarts (fn (c restarts thunk) (thunk)))
-
-;; ── cl-cerror ──────────────────────────────────────────────────────────────
-;;
-;; Signals a continuable error. The "continue" restart is established;
-;; invoke-restart "continue" to proceed past the error.
-
-
-
-;; ── cl-cerror ──────────────────────────────────────────────────────────────
-;;
-;; Signals a continuable error. The "continue" restart is established;
-;; invoke-restart "continue" to proceed past the error.
-
-(define cl-cerror
-  (fn (continue-string c &rest args)
-    (let ((obj (if (cl-condition? c)
-                 c
-                 (cl-make-condition "simple-error"
-                   "format-control" (str c)
-                   "format-arguments" args))))
-      (cl-restart-case
-        (fn () (cl-signal-obj obj cl-handler-stack))
-        (list "continue" (list) (fn () nil))))))
--- a/lib/common-lisp/scoreboard.json
+++ b/lib/common-lisp/scoreboard.json
@@ -1,18 +0,0 @@
-{
-  "generated": "2026-05-05T12:00:17Z",
-  "total_pass": 464,
-  "total_fail": 0,
-  "suites": [
-    {"name": "Phase 1: tokenizer/reader", "pass": 79, "fail": 0},
-    {"name": "Phase 1: parser/lambda-lists", "pass": 31, "fail": 0},
-    {"name": "Phase 2: evaluator", "pass": 182, "fail": 0},
-    {"name": "Phase 3: condition system", "pass": 59, "fail": 0},
-    {"name": "Phase 3: restart-demo", "pass": 7, "fail": 0},
-    {"name": "Phase 3: parse-recover", "pass": 6, "fail": 0},
-    {"name": "Phase 3: interactive-debugger", "pass": 7, "fail": 0},
-    {"name": "Phase 4: CLOS", "pass": 41, "fail": 0},
-    {"name": "Phase 4: geometry", "pass": 12, "fail": 0},
-    {"name": "Phase 4: mop-trace", "pass": 13, "fail": 0},
-    {"name": "Phase 5: macros+LOOP", "pass": 27, "fail": 0}
-  ]
-}
--- a/lib/common-lisp/scoreboard.md
+++ b/lib/common-lisp/scoreboard.md
@@ -1,19 +0,0 @@
-# Common Lisp on SX — Scoreboard
-
-_Generated: 2026-05-05 12:00 UTC_
-
-| Suite | Pass | Fail | Status |
-|-------|------|------|--------|
-| Phase 1: tokenizer/reader | 79 | 0 | pass |
-| Phase 1: parser/lambda-lists | 31 | 0 | pass |
-| Phase 2: evaluator | 182 | 0 | pass |
-| Phase 3: condition system | 59 | 0 | pass |
-| Phase 3: restart-demo | 7 | 0 | pass |
-| Phase 3: parse-recover | 6 | 0 | pass |
-| Phase 3: interactive-debugger | 7 | 0 | pass |
-| Phase 4: CLOS | 41 | 0 | pass |
-| Phase 4: geometry | 12 | 0 | pass |
-| Phase 4: mop-trace | 13 | 0 | pass |
-| Phase 5: macros+LOOP | 27 | 0 | pass |
-
-**Total: 464 passed, 0 failed**
--- a/lib/common-lisp/test.sh
+++ b/lib/common-lisp/test.sh
@@ -1,443 +0,0 @@
-#!/usr/bin/env bash
-# lib/common-lisp/test.sh — quick smoke-test the CL runtime layer.
-# Uses sx_server.exe epoch protocol (same as lib/lua/test.sh).
-#
-# Usage:
-#   bash lib/common-lisp/test.sh
-#   bash lib/common-lisp/test.sh -v
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found. Run: cd hosts/ocaml && dune build"
-  exit 1
-fi
-
-VERBOSE="${1:-}"
-PASS=0; FAIL=0; ERRORS=""
-TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT
-
-cat > "$TMPFILE" << 'EPOCHS'
-(epoch 1)
-(load "spec/stdlib.sx")
-(load "lib/common-lisp/runtime.sx")
-
-;; --- Type predicates ---
-(epoch 10)
-(eval "(cl-null? nil)")
-(epoch 11)
-(eval "(cl-null? false)")
-(epoch 12)
-(eval "(cl-consp? (list 1 2))")
-(epoch 13)
-(eval "(cl-consp? nil)")
-(epoch 14)
-(eval "(cl-listp? nil)")
-(epoch 15)
-(eval "(cl-listp? (list 1))")
-(epoch 16)
-(eval "(cl-atom? nil)")
-(epoch 17)
-(eval "(cl-atom? (list 1))")
-(epoch 18)
-(eval "(cl-integerp? 42)")
-(epoch 19)
-(eval "(cl-floatp? 3.14)")
-(epoch 20)
-(eval "(cl-characterp? (integer->char 65))")
-(epoch 21)
-(eval "(cl-stringp? \"hello\")")
-
-;; --- Arithmetic ---
-(epoch 30)
-(eval "(cl-mod 10 3)")
-(epoch 31)
-(eval "(cl-rem 10 3)")
-(epoch 32)
-(eval "(cl-quotient 10 3)")
-(epoch 33)
-(eval "(cl-gcd 12 8)")
-(epoch 34)
-(eval "(cl-lcm 4 6)")
-(epoch 35)
-(eval "(cl-abs -5)")
-(epoch 36)
-(eval "(cl-abs 5)")
-(epoch 37)
-(eval "(cl-min 2 7)")
-(epoch 38)
-(eval "(cl-max 2 7)")
-(epoch 39)
-(eval "(cl-evenp? 4)")
-(epoch 40)
-(eval "(cl-evenp? 3)")
-(epoch 41)
-(eval "(cl-oddp? 7)")
-(epoch 42)
-(eval "(cl-zerop? 0)")
-(epoch 43)
-(eval "(cl-plusp? 1)")
-(epoch 44)
-(eval "(cl-minusp? -1)")
-(epoch 45)
-(eval "(cl-signum 42)")
-(epoch 46)
-(eval "(cl-signum -7)")
-(epoch 47)
-(eval "(cl-signum 0)")
-
-;; --- Characters ---
-(epoch 50)
-(eval "(cl-char-code (integer->char 65))")
-(epoch 51)
-(eval "(char? (cl-code-char 65))")
-(epoch 52)
-(eval "(cl-char=? (integer->char 65) (integer->char 65))")
-(epoch 53)
-(eval "(cl-char<? (integer->char 65) (integer->char 90))")
-(epoch 54)
-(eval "(cl-char-code cl-char-space)")
-(epoch 55)
-(eval "(cl-char-code cl-char-newline)")
-(epoch 56)
-(eval "(cl-alpha-char-p (integer->char 65))")
-(epoch 57)
-(eval "(cl-digit-char-p (integer->char 48))")
-
-;; --- Format ---
-(epoch 60)
-(eval "(cl-format nil \"hello\")")
-(epoch 61)
-(eval "(cl-format nil \"~a\" \"world\")")
-(epoch 62)
-(eval "(cl-format nil \"~d\" 42)")
-(epoch 63)
-(eval "(cl-format nil \"~x\" 255)")
-(epoch 64)
-(eval "(cl-format nil \"x=~d y=~d\" 3 4)")
-
-;; --- Gensym ---
-(epoch 70)
-(eval "(= (type-of (cl-gensym)) \"symbol\")")
-(epoch 71)
-(eval "(not (= (cl-gensym) (cl-gensym)))")
-
-;; --- Sets ---
-(epoch 80)
-(eval "(cl-set? (cl-make-set))")
-(epoch 81)
-(eval "(let ((s (cl-make-set))) (do (cl-set-add s 1) (cl-set-memberp s 1)))")
-(epoch 82)
-(eval "(cl-set-memberp (cl-make-set) 42)")
-(epoch 83)
-(eval "(cl-set-memberp (cl-list->set (list 1 2 3)) 2)")
-
-;; --- Lists ---
-(epoch 90)
-(eval "(cl-nth 0 (list 1 2 3))")
-(epoch 91)
-(eval "(cl-nth 2 (list 1 2 3))")
-(epoch 92)
-(eval "(cl-last (list 1 2 3))")
-(epoch 93)
-(eval "(cl-butlast (list 1 2 3))")
-(epoch 94)
-(eval "(cl-nthcdr 1 (list 1 2 3))")
-(epoch 95)
-(eval "(cl-assoc \"b\" (list (list \"a\" 1) (list \"b\" 2)))")
-(epoch 96)
-(eval "(cl-assoc \"z\" (list (list \"a\" 1)))")
-(epoch 97)
-(eval "(cl-getf (list \"x\" 42 \"y\" 99) \"x\")")
-(epoch 98)
-(eval "(cl-adjoin 0 (list 1 2))")
-(epoch 99)
-(eval "(cl-adjoin 1 (list 1 2))")
-(epoch 100)
-(eval "(cl-member 2 (list 1 2 3))")
-(epoch 101)
-(eval "(cl-member 9 (list 1 2 3))")
-(epoch 102)
-(eval "(cl-flatten (list 1 (list 2 3) 4))")
-
-;; --- Radix ---
-(epoch 110)
-(eval "(cl-format-binary 10)")
-(epoch 111)
-(eval "(cl-format-octal 15)")
-(epoch 112)
-(eval "(cl-format-hex 255)")
-(epoch 113)
-(eval "(cl-format-decimal 42)")
-(epoch 114)
-(eval "(cl-integer-to-string 31 16)")
-(epoch 115)
-(eval "(cl-string-to-integer \"1f\" 16)")
-
-EPOCHS
-
-OUTPUT=$(timeout 30 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
-
-check() {
-  local epoch="$1" desc="$2" expected="$3"
-  local actual
-  # ok-len format: value appears on the line AFTER "(ok-len N length)"
-  actual=$(echo "$OUTPUT" | grep -A1 "^(ok-len $epoch " | tail -1 || true)
-  # strip any leading "(ok-len ...)" if grep -A1 returned it instead
-  if echo "$actual" | grep -q "^(ok-len"; then actual=""; fi
-  if [ -z "$actual" ]; then
-    actual=$(echo "$OUTPUT" | grep "^(ok $epoch " | head -1 || true)
-  fi
-  if [ -z "$actual" ]; then
-    actual=$(echo "$OUTPUT" | grep "^(error $epoch " | head -1 || true)
-  fi
-  [ -z "$actual" ] && actual="<no output for epoch $epoch>"
-
-  if echo "$actual" | grep -qF -- "$expected"; then
-    PASS=$((PASS+1))
-    [ "$VERBOSE" = "-v" ] && echo "  ok $desc"
-  else
-    FAIL=$((FAIL+1))
-    ERRORS+="  FAIL [$desc] (epoch $epoch) expected: $expected | actual: $actual
-"
-  fi
-}
-
-# Type predicates
-check 10  "cl-null? nil"           "true"
-check 11  "cl-null? false"         "false"
-check 12  "cl-consp? pair"         "true"
-check 13  "cl-consp? nil"          "false"
-check 14  "cl-listp? nil"          "true"
-check 15  "cl-listp? list"         "true"
-check 16  "cl-atom? nil"           "true"
-check 17  "cl-atom? pair"          "false"
-check 18  "cl-integerp?"           "true"
-check 19  "cl-floatp?"             "true"
-check 20  "cl-characterp?"         "true"
-check 21  "cl-stringp?"            "true"
-
-# Arithmetic
-check 30  "cl-mod 10 3"            "1"
-check 31  "cl-rem 10 3"            "1"
-check 32  "cl-quotient 10 3"       "3"
-check 33  "cl-gcd 12 8"            "4"
-check 34  "cl-lcm 4 6"             "12"
-check 35  "cl-abs -5"              "5"
-check 36  "cl-abs 5"               "5"
-check 37  "cl-min 2 7"             "2"
-check 38  "cl-max 2 7"             "7"
-check 39  "cl-evenp? 4"            "true"
-check 40  "cl-evenp? 3"            "false"
-check 41  "cl-oddp? 7"             "true"
-check 42  "cl-zerop? 0"            "true"
-check 43  "cl-plusp? 1"            "true"
-check 44  "cl-minusp? -1"          "true"
-check 45  "cl-signum pos"          "1"
-check 46  "cl-signum neg"          "-1"
-check 47  "cl-signum zero"         "0"
-
-# Characters
-check 50  "cl-char-code"           "65"
-check 51  "code-char returns char" "true"
-check 52  "cl-char=?"              "true"
-check 53  "cl-char<?"              "true"
-check 54  "cl-char-space code"     "32"
-check 55  "cl-char-newline code"   "10"
-check 56  "cl-alpha-char-p A"      "true"
-check 57  "cl-digit-char-p 0"      "true"
-
-# Format
-check 60  "cl-format plain"        '"hello"'
-check 61  "cl-format ~a"           '"world"'
-check 62  "cl-format ~d"           '"42"'
-check 63  "cl-format ~x"           '"ff"'
-check 64  "cl-format multi"        '"x=3 y=4"'
-
-# Gensym
-check 70  "gensym returns symbol"  "true"
-check 71  "gensyms are unique"     "true"
-
-# Sets
-check 80  "make-set is set?"       "true"
-check 81  "set-add + member"       "true"
-check 82  "member in empty"        "false"
-check 83  "list->set member"       "true"
-
-# Lists
-check 90  "cl-nth 0"               "1"
-check 91  "cl-nth 2"               "3"
-check 92  "cl-last"                "(3)"
-check 93  "cl-butlast"             "(1 2)"
-check 94  "cl-nthcdr 1"            "(2 3)"
-check 95  "cl-assoc hit"           '("b" 2)'
-check 96  "cl-assoc miss"          "nil"
-check 97  "cl-getf hit"            "42"
-check 98  "cl-adjoin new"          "(0 1 2)"
-check 99  "cl-adjoin dup"          "(1 2)"
-check 100 "cl-member hit"          "(2 3)"
-check 101 "cl-member miss"         "nil"
-check 102 "cl-flatten"             "(1 2 3 4)"
-
-# Radix
-check 110 "cl-format-binary 10"    '"1010"'
-check 111 "cl-format-octal 15"     '"17"'
-check 112 "cl-format-hex 255"      '"ff"'
-check 113 "cl-format-decimal 42"   '"42"'
-check 114 "n->s base 16"           '"1f"'
-check 115 "s->n base 16"           "31"
-
-# ── Phase 2: condition system unit tests ─────────────────────────────────────
-# Load runtime.sx then conditions.sx; query the passed/failed/failures globals.
-UNIT_FILE=$(mktemp); trap "rm -f $UNIT_FILE" EXIT
-cat > "$UNIT_FILE" << 'UNIT'
-(epoch 1)
-(load "spec/stdlib.sx")
-(epoch 2)
-(load "lib/common-lisp/runtime.sx")
-(epoch 3)
-(load "lib/common-lisp/tests/conditions.sx")
-(epoch 4)
-(eval "passed")
-(epoch 5)
-(eval "failed")
-(epoch 6)
-(eval "failures")
-UNIT
-
-UNIT_OUT=$(timeout 30 "$SX_SERVER" < "$UNIT_FILE" 2>/dev/null)
-
-# extract passed/failed counts from ok-len lines
-UNIT_PASSED=$(echo "$UNIT_OUT" | grep -A1 "^(ok-len 4 " | tail -1 || true)
-UNIT_FAILED=$(echo "$UNIT_OUT" | grep -A1 "^(ok-len 5 " | tail -1 || true)
-UNIT_ERRS=$(echo "$UNIT_OUT" | grep -A1 "^(ok-len 6 " | tail -1 || true)
-# fallback: try plain ok lines
-[ -z "$UNIT_PASSED" ] && UNIT_PASSED=$(echo "$UNIT_OUT" | grep "^(ok 4 " | awk '{print $3}' | tr -d ')' || true)
-[ -z "$UNIT_FAILED" ] && UNIT_FAILED=$(echo "$UNIT_OUT" | grep "^(ok 5 " | awk '{print $3}' | tr -d ')' || true)
-[ -z "$UNIT_PASSED" ] && UNIT_PASSED=0
-[ -z "$UNIT_FAILED" ] && UNIT_FAILED=0
-
-if [ "$UNIT_FAILED" = "0" ] && [ "$UNIT_PASSED" -gt 0 ] 2>/dev/null; then
-  PASS=$((PASS + UNIT_PASSED))
-  [ "$VERBOSE" = "-v" ] && echo "  ok condition tests ($UNIT_PASSED)"
-else
-  FAIL=$((FAIL + 1))
-  ERRORS+="  FAIL [condition tests] (${UNIT_PASSED} passed, ${UNIT_FAILED} failed) ${UNIT_ERRS}
-"
-fi
-
-# ── Phase 3: classic program tests ───────────────────────────────────────────
-run_program_suite() {
-  local prog="$1" pass_var="$2" fail_var="$3" failures_var="$4"
-  local PROG_FILE=$(mktemp)
-  printf '(epoch 1)\n(load "spec/stdlib.sx")\n(epoch 2)\n(load "lib/common-lisp/runtime.sx")\n(epoch 3)\n(load "%s")\n(epoch 4)\n(eval "%s")\n(epoch 5)\n(eval "%s")\n(epoch 6)\n(eval "%s")\n' \
-    "$prog" "$pass_var" "$fail_var" "$failures_var" > "$PROG_FILE"
-  local OUT; OUT=$(timeout 20 "$SX_SERVER" < "$PROG_FILE" 2>/dev/null)
-  rm -f "$PROG_FILE"
-  local P F
-  P=$(echo "$OUT" | grep -A1 "^(ok-len 4 " | tail -1 || true)
-  F=$(echo "$OUT" | grep -A1 "^(ok-len 5 " | tail -1 || true)
-  local ERRS; ERRS=$(echo "$OUT" | grep -A1 "^(ok-len 6 " | tail -1 || true)
-  [ -z "$P" ] && P=0; [ -z "$F" ] && F=0
-  if [ "$F" = "0" ] && [ "$P" -gt 0 ] 2>/dev/null; then
-    PASS=$((PASS + P))
-    [ "$VERBOSE" = "-v" ] && echo "  ok $prog ($P)"
-  else
-    FAIL=$((FAIL + 1))
-    ERRORS+="  FAIL [$prog] (${P} passed, ${F} failed) ${ERRS}
-"
-  fi
-}
-
-run_program_suite \
-  "lib/common-lisp/tests/programs/restart-demo.sx" \
-  "demo-passed" "demo-failed" "demo-failures"
-
-run_program_suite \
-  "lib/common-lisp/tests/programs/parse-recover.sx" \
-  "parse-passed" "parse-failed" "parse-failures"
-
-run_program_suite \
-  "lib/common-lisp/tests/programs/interactive-debugger.sx" \
-  "debugger-passed" "debugger-failed" "debugger-failures"
-
-# ── Phase 4: CLOS unit tests ─────────────────────────────────────────────────
-CLOS_FILE=$(mktemp); trap "rm -f $CLOS_FILE" EXIT
-printf '(epoch 1)\n(load "spec/stdlib.sx")\n(epoch 2)\n(load "lib/common-lisp/runtime.sx")\n(epoch 3)\n(load "lib/common-lisp/clos.sx")\n(epoch 4)\n(load "lib/common-lisp/tests/clos.sx")\n(epoch 5)\n(eval "passed")\n(epoch 6)\n(eval "failed")\n(epoch 7)\n(eval "failures")\n' > "$CLOS_FILE"
-CLOS_OUT=$(timeout 30 "$SX_SERVER" < "$CLOS_FILE" 2>/dev/null)
-rm -f "$CLOS_FILE"
-CLOS_PASSED=$(echo "$CLOS_OUT" | grep -A1 "^(ok-len 5 " | tail -1 || true)
-CLOS_FAILED=$(echo "$CLOS_OUT" | grep -A1 "^(ok-len 6 " | tail -1 || true)
-[ -z "$CLOS_PASSED" ] && CLOS_PASSED=$(echo "$CLOS_OUT" | grep "^(ok 5 " | awk '{print $3}' | tr -d ')' || true)
-[ -z "$CLOS_FAILED" ] && CLOS_FAILED=$(echo "$CLOS_OUT" | grep "^(ok 6 " | awk '{print $3}' | tr -d ')' || true)
-[ -z "$CLOS_PASSED" ] && CLOS_PASSED=0; [ -z "$CLOS_FAILED" ] && CLOS_FAILED=0
-if [ "$CLOS_FAILED" = "0" ] && [ "$CLOS_PASSED" -gt 0 ] 2>/dev/null; then
-  PASS=$((PASS + CLOS_PASSED))
-  [ "$VERBOSE" = "-v" ] && echo "  ok CLOS unit tests ($CLOS_PASSED)"
-else
-  FAIL=$((FAIL + 1))
-  ERRORS+="  FAIL [CLOS unit tests] (${CLOS_PASSED} passed, ${CLOS_FAILED} failed)
-"
-fi
-
-# ── Phase 4: CLOS classic programs ───────────────────────────────────────────
-run_clos_suite() {
-  local prog="$1" pass_var="$2" fail_var="$3" failures_var="$4"
-  local PROG_FILE=$(mktemp)
-  printf '(epoch 1)\n(load "spec/stdlib.sx")\n(epoch 2)\n(load "lib/common-lisp/runtime.sx")\n(epoch 3)\n(load "lib/common-lisp/clos.sx")\n(epoch 4)\n(load "%s")\n(epoch 5)\n(eval "%s")\n(epoch 6)\n(eval "%s")\n(epoch 7)\n(eval "%s")\n' \
-    "$prog" "$pass_var" "$fail_var" "$failures_var" > "$PROG_FILE"
-  local OUT; OUT=$(timeout 20 "$SX_SERVER" < "$PROG_FILE" 2>/dev/null)
-  rm -f "$PROG_FILE"
-  local P F
-  P=$(echo "$OUT" | grep -A1 "^(ok-len 5 " | tail -1 || true)
-  F=$(echo "$OUT" | grep -A1 "^(ok-len 6 " | tail -1 || true)
-  local ERRS; ERRS=$(echo "$OUT" | grep -A1 "^(ok-len 7 " | tail -1 || true)
-  [ -z "$P" ] && P=0; [ -z "$F" ] && F=0
-  if [ "$F" = "0" ] && [ "$P" -gt 0 ] 2>/dev/null; then
-    PASS=$((PASS + P))
-    [ "$VERBOSE" = "-v" ] && echo "  ok $prog ($P)"
-  else
-    FAIL=$((FAIL + 1))
-    ERRORS+="  FAIL [$prog] (${P} passed, ${F} failed) ${ERRS}
-"
-  fi
-}
-
-run_clos_suite \
-  "lib/common-lisp/tests/programs/geometry.sx" \
-  "geo-passed" "geo-failed" "geo-failures"
-
-run_clos_suite \
-  "lib/common-lisp/tests/programs/mop-trace.sx" \
-  "mop-passed" "mop-failed" "mop-failures"
-
-# ── Phase 5: macros + LOOP ───────────────────────────────────────────────────
-MACRO_FILE=$(mktemp); trap "rm -f $MACRO_FILE" EXIT
-printf '(epoch 1)\n(load "spec/stdlib.sx")\n(epoch 2)\n(load "lib/common-lisp/reader.sx")\n(epoch 3)\n(load "lib/common-lisp/parser.sx")\n(epoch 4)\n(load "lib/common-lisp/eval.sx")\n(epoch 5)\n(load "lib/common-lisp/loop.sx")\n(epoch 6)\n(load "lib/common-lisp/tests/macros.sx")\n(epoch 7)\n(eval "macro-passed")\n(epoch 8)\n(eval "macro-failed")\n(epoch 9)\n(eval "macro-failures")\n' > "$MACRO_FILE"
-MACRO_OUT=$(timeout 60 "$SX_SERVER" < "$MACRO_FILE" 2>/dev/null)
-rm -f "$MACRO_FILE"
-MACRO_PASSED=$(echo "$MACRO_OUT" | grep -A1 "^(ok-len 7 " | tail -1 || true)
-MACRO_FAILED=$(echo "$MACRO_OUT" | grep -A1 "^(ok-len 8 " | tail -1 || true)
-[ -z "$MACRO_PASSED" ] && MACRO_PASSED=0; [ -z "$MACRO_FAILED" ] && MACRO_FAILED=0
-if [ "$MACRO_FAILED" = "0" ] && [ "$MACRO_PASSED" -gt 0 ] 2>/dev/null; then
-  PASS=$((PASS + MACRO_PASSED))
-  [ "$VERBOSE" = "-v" ] && echo "  ok Phase 5 macros+LOOP ($MACRO_PASSED)"
-else
-  FAIL=$((FAIL + 1))
-  ERRORS+="  FAIL [Phase 5 macros+LOOP] (${MACRO_PASSED} passed, ${MACRO_FAILED} failed)
-"
-fi
-
-TOTAL=$((PASS+FAIL))
-if [ $FAIL -eq 0 ]; then
-  echo "ok $PASS/$TOTAL lib/common-lisp tests passed"
-else
-  echo "FAIL $PASS/$TOTAL passed, $FAIL failed:"
-  echo "$ERRORS"
-fi
-[ $FAIL -eq 0 ]
--- a/lib/common-lisp/tests/clos.sx
+++ b/lib/common-lisp/tests/clos.sx
@@ -1,334 +0,0 @@
-;; lib/common-lisp/tests/clos.sx — CLOS test suite
-;;
-;; Loaded after: spec/stdlib.sx, lib/common-lisp/runtime.sx, lib/common-lisp/clos.sx
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  assert-equal
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-(define
-  assert-true
-  (fn
-    (label got)
-    (if
-      got
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str "FAIL [" label "]: expected true, got " (inspect got)))))))))
-
-(define
-  assert-nil
-  (fn
-    (label got)
-    (if
-      (nil? got)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list (str "FAIL [" label "]: expected nil, got " (inspect got)))))))))
-
-;; ── 1. class-of for built-in types ────────────────────────────────────────
-
-(assert-equal "class-of integer" (clos-class-of 42) "integer")
-(assert-equal "class-of float" (clos-class-of 3.14) "float")
-(assert-equal "class-of string" (clos-class-of "hi") "string")
-(assert-equal "class-of nil" (clos-class-of nil) "null")
-(assert-equal "class-of list" (clos-class-of (list 1)) "cons")
-(assert-equal "class-of empty" (clos-class-of (list)) "null")
-
-;; ── 2. subclass-of? ───────────────────────────────────────────────────────
-
-(assert-true "integer subclass-of t" (clos-subclass-of? "integer" "t"))
-(assert-true "float subclass-of t" (clos-subclass-of? "float" "t"))
-(assert-true "t subclass-of t" (clos-subclass-of? "t" "t"))
-(assert-equal
-  "integer not subclass-of float"
-  (clos-subclass-of? "integer" "float")
-  false)
-
-;; ── 3. defclass + make-instance ───────────────────────────────────────────
-
-(clos-defclass "point" (list "t") (list {:initform 0 :initarg ":x" :reader nil :writer nil :accessor "point-x" :name "x"} {:initform 0 :initarg ":y" :reader nil :writer nil :accessor "point-y" :name "y"}))
-
-(let
-  ((p (clos-make-instance "point" ":x" 3 ":y" 4)))
-  (begin
-    (assert-equal "make-instance slot x" (clos-slot-value p "x") 3)
-    (assert-equal "make-instance slot y" (clos-slot-value p "y") 4)
-    (assert-equal "class-of instance" (clos-class-of p) "point")
-    (assert-true "instance-of? point" (clos-instance-of? p "point"))
-    (assert-true "instance-of? t" (clos-instance-of? p "t"))
-    (assert-equal "instance-of? string" (clos-instance-of? p "string") false)))
-
-;; initform defaults
-(let
-  ((p0 (clos-make-instance "point")))
-  (begin
-    (assert-equal "initform default x=0" (clos-slot-value p0 "x") 0)
-    (assert-equal "initform default y=0" (clos-slot-value p0 "y") 0)))
-
-;; ── 4. slot-value / set-slot-value! ──────────────────────────────────────
-
-(let
-  ((p (clos-make-instance "point" ":x" 10 ":y" 20)))
-  (begin
-    (clos-set-slot-value! p "x" 99)
-    (assert-equal "set-slot-value! x" (clos-slot-value p "x") 99)
-    (assert-equal "slot-value y unchanged" (clos-slot-value p "y") 20)))
-
-;; ── 5. slot-boundp ────────────────────────────────────────────────────────
-
-(let
-  ((p (clos-make-instance "point" ":x" 5)))
-  (begin
-    (assert-true "slot-boundp x" (clos-slot-boundp p "x"))
-    (assert-true "slot-boundp y (initform 0)" (clos-slot-boundp p "y"))))
-
-;; ── 6. find-class ─────────────────────────────────────────────────────────
-
-(assert-equal
-  "find-class point"
-  (get (clos-find-class "point") "name")
-  "point")
-(assert-nil "find-class missing" (clos-find-class "no-such-class"))
-
-;; ── 7. inheritance ────────────────────────────────────────────────────────
-
-(clos-defclass "colored-point" (list "point") (list {:initform "white" :initarg ":color" :reader nil :writer nil :accessor nil :name "color"}))
-
-(let
-  ((cp (clos-make-instance "colored-point" ":x" 1 ":y" 2 ":color" "red")))
-  (begin
-    (assert-equal "inherited slot x" (clos-slot-value cp "x") 1)
-    (assert-equal "inherited slot y" (clos-slot-value cp "y") 2)
-    (assert-equal "own slot color" (clos-slot-value cp "color") "red")
-    (assert-true
-      "instance-of? colored-point"
-      (clos-instance-of? cp "colored-point"))
-    (assert-true "instance-of? point (parent)" (clos-instance-of? cp "point"))
-    (assert-true "instance-of? t (root)" (clos-instance-of? cp "t"))))
-
-;; ── 8. defgeneric + primary method ───────────────────────────────────────
-
-(clos-defgeneric "describe-obj" {})
-
-(clos-defmethod
-  "describe-obj"
-  (list)
-  (list "point")
-  (fn
-    (args next-fn)
-    (let
-      ((p (first args)))
-      (str "(" (clos-slot-value p "x") "," (clos-slot-value p "y") ")"))))
-
-(clos-defmethod
-  "describe-obj"
-  (list)
-  (list "t")
-  (fn (args next-fn) (str "object:" (inspect (first args)))))
-
-(let
-  ((p (clos-make-instance "point" ":x" 3 ":y" 4)))
-  (begin
-    (assert-equal
-      "primary method for point"
-      (clos-call-generic "describe-obj" (list p))
-      "(3,4)")
-    (assert-equal
-      "fallback t method"
-      (clos-call-generic "describe-obj" (list 42))
-      "object:42")))
-
-;; ── 9. method inheritance + specificity ───────────────────────────────────
-
-(clos-defmethod
-  "describe-obj"
-  (list)
-  (list "colored-point")
-  (fn
-    (args next-fn)
-    (let
-      ((cp (first args)))
-      (str
-        (clos-slot-value cp "color")
-        "@("
-        (clos-slot-value cp "x")
-        ","
-        (clos-slot-value cp "y")
-        ")"))))
-
-(let
-  ((cp (clos-make-instance "colored-point" ":x" 5 ":y" 6 ":color" "blue")))
-  (assert-equal
-    "most specific method wins"
-    (clos-call-generic "describe-obj" (list cp))
-    "blue@(5,6)"))
-
-;; ── 10. :before / :after / :around qualifiers ─────────────────────────────
-
-(clos-defgeneric "logged-action" {})
-
-(clos-defmethod
-  "logged-action"
-  (list "before")
-  (list "t")
-  (fn (args next-fn) (set! action-log (append action-log (list "before")))))
-
-(clos-defmethod
-  "logged-action"
-  (list)
-  (list "t")
-  (fn
-    (args next-fn)
-    (set! action-log (append action-log (list "primary")))
-    "result"))
-
-(clos-defmethod
-  "logged-action"
-  (list "after")
-  (list "t")
-  (fn (args next-fn) (set! action-log (append action-log (list "after")))))
-
-(define action-log (list))
-(clos-call-generic "logged-action" (list 1))
-(assert-equal
-  ":before/:after order"
-  action-log
-  (list "before" "primary" "after"))
-
-;; :around
-(define around-log (list))
-
-(clos-defgeneric "wrapped-action" {})
-
-(clos-defmethod
-  "wrapped-action"
-  (list "around")
-  (list "t")
-  (fn
-    (args next-fn)
-    (set! around-log (append around-log (list "around-enter")))
-    (let
-      ((r (next-fn)))
-      (set! around-log (append around-log (list "around-exit")))
-      r)))
-
-(clos-defmethod
-  "wrapped-action"
-  (list)
-  (list "t")
-  (fn
-    (args next-fn)
-    (set! around-log (append around-log (list "primary")))
-    42))
-
-(let
-  ((r (clos-call-generic "wrapped-action" (list nil))))
-  (begin
-    (assert-equal ":around result" r 42)
-    (assert-equal
-      ":around log"
-      around-log
-      (list "around-enter" "primary" "around-exit"))))
-
-;; ── 11. call-next-method ─────────────────────────────────────────────────
-
-(clos-defgeneric "chain-test" {})
-
-(clos-defmethod
-  "chain-test"
-  (list)
-  (list "colored-point")
-  (fn (args next-fn) (str "colored:" (clos-call-next-method next-fn))))
-
-(clos-defmethod
-  "chain-test"
-  (list)
-  (list "point")
-  (fn (args next-fn) "point-base"))
-
-(let
-  ((cp (clos-make-instance "colored-point" ":x" 0 ":y" 0 ":color" "green")))
-  (assert-equal
-    "call-next-method chains"
-    (clos-call-generic "chain-test" (list cp))
-    "colored:point-base"))
-
-;; ── 12. accessor methods ──────────────────────────────────────────────────
-
-(let
-  ((p (clos-make-instance "point" ":x" 7 ":y" 8)))
-  (begin
-    (assert-equal
-      "accessor point-x"
-      (clos-call-generic "point-x" (list p))
-      7)
-    (assert-equal
-      "accessor point-y"
-      (clos-call-generic "point-y" (list p))
-      8)))
-
-;; ── 13. with-slots ────────────────────────────────────────────────────────
-
-(let
-  ((p (clos-make-instance "point" ":x" 3 ":y" 4)))
-  (assert-equal
-    "with-slots"
-    (clos-with-slots p (list "x" "y") (fn (x y) (* x y)))
-    12))
-
-;; ── 14. change-class ─────────────────────────────────────────────────────
-
-(clos-defclass "special-point" (list "point") (list {:initform "" :initarg ":label" :reader nil :writer nil :accessor nil :name "label"}))
-
-(let
-  ((p (clos-make-instance "point" ":x" 1 ":y" 2)))
-  (begin
-    (clos-change-class! p "special-point")
-    (assert-equal
-      "change-class updates class"
-      (clos-class-of p)
-      "special-point")))
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(if
-  (= failed 0)
-  (print (str "ok " passed "/" (+ passed failed) " CLOS tests passed"))
-  (begin
-    (for-each (fn (f) (print f)) failures)
-    (print
-      (str "FAIL " passed "/" (+ passed failed) " passed, " failed " failed"))))
--- a/lib/common-lisp/tests/conditions.sx
+++ b/lib/common-lisp/tests/conditions.sx
@@ -1,478 +0,0 @@
-;; lib/common-lisp/tests/conditions.sx — Phase 3 condition system tests
-;;
-;; Loaded by lib/common-lisp/test.sh after:
-;;   (load "spec/stdlib.sx")
-;;   (load "lib/common-lisp/runtime.sx")
-;;
-;; Each test resets the handler/restart stacks to ensure isolation.
-
-(define
-  reset-stacks!
-  (fn () (set! cl-handler-stack (list)) (set! cl-restart-stack (list))))
-
-;; ── helpers ────────────────────────────────────────────────────────────────
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  assert-equal
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-(define
-  assert-true
-  (fn
-    (label got)
-    (if
-      got
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str "FAIL [" label "]: expected true, got " (inspect got)))))))))
-
-(define
-  assert-nil
-  (fn
-    (label got)
-    (if
-      (nil? got)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list (str "FAIL [" label "]: expected nil, got " (inspect got)))))))))
-
-;; ── 1. condition predicates ────────────────────────────────────────────────
-
-(reset-stacks!)
-
-(let
-  ((c (cl-make-condition "simple-error" "format-control" "oops")))
-  (begin
-    (assert-true "cl-condition? on condition" (cl-condition? c))
-    (assert-equal "cl-condition? on string" (cl-condition? "hello") false)
-    (assert-equal "cl-condition? on number" (cl-condition? 42) false)
-    (assert-equal "cl-condition? on nil" (cl-condition? nil) false)))
-
-;; ── 2. cl-make-condition + slot access ────────────────────────────────────
-
-(reset-stacks!)
-
-(let
-  ((c (cl-make-condition "simple-error" "format-control" "msg" "format-arguments" (list 1 2))))
-  (begin
-    (assert-equal "class field" (get c "class") "simple-error")
-    (assert-equal "cl-type field" (get c "cl-type") "cl-condition")
-    (assert-equal
-      "format-control slot"
-      (cl-condition-slot c "format-control")
-      "msg")
-    (assert-equal
-      "format-arguments slot"
-      (cl-condition-slot c "format-arguments")
-      (list 1 2))
-    (assert-nil "missing slot is nil" (cl-condition-slot c "no-such-slot"))
-    (assert-equal "condition-message" (cl-condition-message c) "msg")))
-
-;; ── 3. cl-condition-of-type? — hierarchy walking ─────────────────────────
-
-(reset-stacks!)
-
-(let
-  ((se (cl-make-condition "simple-error" "format-control" "x"))
-    (w (cl-make-condition "simple-warning" "format-control" "y"))
-    (te
-      (cl-make-condition
-        "type-error"
-        "datum"
-        5
-        "expected-type"
-        "string"))
-    (dz (cl-make-condition "division-by-zero")))
-  (begin
-    (assert-true
-      "se isa simple-error"
-      (cl-condition-of-type? se "simple-error"))
-    (assert-true "se isa error" (cl-condition-of-type? se "error"))
-    (assert-true
-      "se isa serious-condition"
-      (cl-condition-of-type? se "serious-condition"))
-    (assert-true "se isa condition" (cl-condition-of-type? se "condition"))
-    (assert-equal
-      "se not isa warning"
-      (cl-condition-of-type? se "warning")
-      false)
-    (assert-true
-      "w isa simple-warning"
-      (cl-condition-of-type? w "simple-warning"))
-    (assert-true "w isa warning" (cl-condition-of-type? w "warning"))
-    (assert-true "w isa condition" (cl-condition-of-type? w "condition"))
-    (assert-equal "w not isa error" (cl-condition-of-type? w "error") false)
-    (assert-true "te isa type-error" (cl-condition-of-type? te "type-error"))
-    (assert-true "te isa error" (cl-condition-of-type? te "error"))
-    (assert-true
-      "dz isa division-by-zero"
-      (cl-condition-of-type? dz "division-by-zero"))
-    (assert-true
-      "dz isa arithmetic-error"
-      (cl-condition-of-type? dz "arithmetic-error"))
-    (assert-true "dz isa error" (cl-condition-of-type? dz "error"))
-    (assert-equal
-      "non-condition not isa anything"
-      (cl-condition-of-type? 42 "error")
-      false)))
-
-;; ── 4. cl-define-condition ────────────────────────────────────────────────
-
-(reset-stacks!)
-
-(begin
-  (cl-define-condition "my-app-error" (list "error") (list "code" "detail"))
-  (let
-    ((c (cl-make-condition "my-app-error" "code" 404 "detail" "not found")))
-    (begin
-      (assert-true "user condition: cl-condition?" (cl-condition? c))
-      (assert-true
-        "user condition isa my-app-error"
-        (cl-condition-of-type? c "my-app-error"))
-      (assert-true
-        "user condition isa error"
-        (cl-condition-of-type? c "error"))
-      (assert-true
-        "user condition isa condition"
-        (cl-condition-of-type? c "condition"))
-      (assert-equal
-        "user condition slot code"
-        (cl-condition-slot c "code")
-        404)
-      (assert-equal
-        "user condition slot detail"
-        (cl-condition-slot c "detail")
-        "not found"))))
-
-;; ── 5. cl-handler-bind (non-unwinding) ───────────────────────────────────
-
-(reset-stacks!)
-
-(let
-  ((log (list)))
-  (begin
-    (cl-handler-bind
-      (list
-        (list
-          "error"
-          (fn (c) (set! log (append log (list (cl-condition-message c)))))))
-      (fn
-        ()
-        (cl-signal (cl-make-condition "simple-error" "format-control" "oops"))))
-    (assert-equal "handler-bind: handler fired" log (list "oops"))))
-
-(reset-stacks!)
-
-;; Non-unwinding: body continues after signal
-(let
-  ((body-ran false))
-  (begin
-    (cl-handler-bind
-      (list (list "error" (fn (c) nil)))
-      (fn
-        ()
-        (cl-signal (cl-make-condition "simple-error" "format-control" "x"))
-        (set! body-ran true)))
-    (assert-true "handler-bind: body continues after signal" body-ran)))
-
-(reset-stacks!)
-
-;; Type filtering: warning handler does not fire for error
-(let
-  ((w-fired false))
-  (begin
-    (cl-handler-bind
-      (list (list "warning" (fn (c) (set! w-fired true))))
-      (fn
-        ()
-        (cl-signal (cl-make-condition "simple-error" "format-control" "e"))))
-    (assert-equal
-      "handler-bind: type filter (warning ignores error)"
-      w-fired
-      false)))
-
-(reset-stacks!)
-
-;; Multiple handlers: both matching handlers fire
-(let
-  ((log (list)))
-  (begin
-    (cl-handler-bind
-      (list
-        (list "error" (fn (c) (set! log (append log (list "e1")))))
-        (list "condition" (fn (c) (set! log (append log (list "e2"))))))
-      (fn
-        ()
-        (cl-signal (cl-make-condition "simple-error" "format-control" "x"))))
-    (assert-equal "handler-bind: both handlers fire" log (list "e1" "e2"))))
-
-(reset-stacks!)
-
-;; ── 6. cl-handler-case (unwinding) ───────────────────────────────────────
-
-;; Catches error, returns handler result
-(let
-  ((result (cl-handler-case (fn () (cl-error "boom") 99) (list "error" (fn (c) (str "caught: " (cl-condition-message c)))))))
-  (assert-equal "handler-case: catches error" result "caught: boom"))
-
-(reset-stacks!)
-
-;; Returns body result when no signal
-(let
-  ((result (cl-handler-case (fn () 42) (list "error" (fn (c) -1)))))
-  (assert-equal "handler-case: body result" result 42))
-
-(reset-stacks!)
-
-;; Only first matching handler runs (unwinding)
-(let
-  ((result (cl-handler-case (fn () (cl-error "x")) (list "simple-error" (fn (c) "simple")) (list "error" (fn (c) "error")))))
-  (assert-equal "handler-case: most specific wins" result "simple"))
-
-(reset-stacks!)
-
-;; ── 7. cl-warn ────────────────────────────────────────────────────────────
-
-(let
-  ((warned false))
-  (begin
-    (cl-handler-bind
-      (list (list "warning" (fn (c) (set! warned true))))
-      (fn () (cl-warn "be careful")))
-    (assert-true "cl-warn: fires warning handler" warned)))
-
-(reset-stacks!)
-
-;; Warn with condition object
-(let
-  ((msg ""))
-  (begin
-    (cl-handler-bind
-      (list (list "warning" (fn (c) (set! msg (cl-condition-message c)))))
-      (fn
-        ()
-        (cl-warn
-          (cl-make-condition "simple-warning" "format-control" "take care"))))
-    (assert-equal "cl-warn: condition object" msg "take care")))
-
-(reset-stacks!)
-
-;; ── 8. cl-restart-case + cl-invoke-restart ───────────────────────────────
-
-;; Basic restart invocation
-(let
-  ((result (cl-restart-case (fn () (cl-invoke-restart "use-zero")) (list "use-zero" (list) (fn () 0)))))
-  (assert-equal "restart-case: invoke-restart use-zero" result 0))
-
-(reset-stacks!)
-
-;; Restart with argument
-(let
-  ((result (cl-restart-case (fn () (cl-invoke-restart "use-value" 77)) (list "use-value" (list "v") (fn (v) v)))))
-  (assert-equal "restart-case: invoke-restart with arg" result 77))
-
-(reset-stacks!)
-
-;; Body returns normally when restart not invoked
-(let
-  ((result (cl-restart-case (fn () 42) (list "never-used" (list) (fn () -1)))))
-  (assert-equal "restart-case: body result" result 42))
-
-(reset-stacks!)
-
-;; ── 9. cl-with-simple-restart ─────────────────────────────────────────────
-
-(let
-  ((result (cl-with-simple-restart "skip" "Skip this step" (fn () (cl-invoke-restart "skip") 99))))
-  (assert-nil "with-simple-restart: invoke returns nil" result))
-
-(reset-stacks!)
-
-;; ── 10. cl-find-restart ───────────────────────────────────────────────────
-
-(let
-  ((found (cl-restart-case (fn () (cl-find-restart "retry")) (list "retry" (list) (fn () nil)))))
-  (assert-true "find-restart: finds active restart" (not (nil? found))))
-
-(reset-stacks!)
-
-(let
-  ((not-found (cl-restart-case (fn () (cl-find-restart "nonexistent")) (list "retry" (list) (fn () nil)))))
-  (assert-nil "find-restart: nil for inactive restart" not-found))
-
-(reset-stacks!)
-
-;; ── 11. cl-compute-restarts ───────────────────────────────────────────────
-
-(let
-  ((names (cl-restart-case (fn () (cl-restart-case (fn () (cl-compute-restarts)) (list "inner" (list) (fn () nil)))) (list "outer" (list) (fn () nil)))))
-  (assert-equal
-    "compute-restarts: both restarts"
-    names
-    (list "inner" "outer")))
-
-(reset-stacks!)
-
-;; ── 12. handler-bind + restart-case interop ───────────────────────────────
-
-;; Classic CL pattern: error handler invokes a restart
-(let
-  ((result (cl-restart-case (fn () (cl-handler-bind (list (list "error" (fn (c) (cl-invoke-restart "use-zero")))) (fn () (cl-error "divide by zero")))) (list "use-zero" (list) (fn () 0)))))
-  (assert-equal "interop: handler invokes restart" result 0))
-
-(reset-stacks!)
-
-;; ── 13. cl-cerror ─────────────────────────────────────────────────────────
-
-;; When "continue" restart is invoked, cerror returns nil
-(let
-  ((result (cl-restart-case (fn () (cl-cerror "continue anyway" "something bad") 42) (list "continue" (list) (fn () "resumed")))))
-  (assert-true
-    "cerror: returns"
-    (or (nil? result) (= result 42) (= result "resumed"))))
-
-(reset-stacks!)
-
-;; ── 14. slot accessor helpers ─────────────────────────────────────────────
-
-(let
-  ((c (cl-make-condition "simple-error" "format-control" "msg" "format-arguments" (list 1 2))))
-  (begin
-    (assert-equal
-      "simple-condition-format-control"
-      (cl-simple-condition-format-control c)
-      "msg")
-    (assert-equal
-      "simple-condition-format-arguments"
-      (cl-simple-condition-format-arguments c)
-      (list 1 2))))
-
-(let
-  ((c (cl-make-condition "type-error" "datum" 42 "expected-type" "string")))
-  (begin
-    (assert-equal "type-error-datum" (cl-type-error-datum c) 42)
-    (assert-equal
-      "type-error-expected-type"
-      (cl-type-error-expected-type c)
-      "string")))
-
-(let
-  ((c (cl-make-condition "arithmetic-error" "operation" "/" "operands" (list 1 0))))
-  (begin
-    (assert-equal
-      "arithmetic-error-operation"
-      (cl-arithmetic-error-operation c)
-      "/")
-    (assert-equal
-      "arithmetic-error-operands"
-      (cl-arithmetic-error-operands c)
-      (list 1 0))))
-
-
-;; ── 15. *debugger-hook* ───────────────────────────────────────────────────
-
-(reset-stacks!)
-
-(let ((received nil))
-  (begin
-    (set! cl-debugger-hook
-      (fn (c h)
-        (set! received (cl-condition-message c))
-        (cl-invoke-restart "escape")))
-    (cl-restart-case
-      (fn () (cl-error "debugger test"))
-      (list "escape" (list) (fn () nil)))
-    (set! cl-debugger-hook nil)
-    (assert-equal "debugger-hook receives condition"  received  "debugger test")))
-
-(reset-stacks!)
-
-;; ── 16. *break-on-signals* ────────────────────────────────────────────────
-
-(reset-stacks!)
-
-(let ((triggered false))
-  (begin
-    (set! cl-break-on-signals "error")
-    (set! cl-debugger-hook
-      (fn (c h)
-        (set! triggered true)
-        (cl-invoke-restart "abort")))
-    (cl-restart-case
-      (fn ()
-        (cl-signal (cl-make-condition "simple-error" "format-control" "x")))
-      (list "abort" (list) (fn () nil)))
-    (set! cl-break-on-signals nil)
-    (set! cl-debugger-hook nil)
-    (assert-true "break-on-signals fires hook"  triggered)))
-
-(reset-stacks!)
-
-;; break-on-signals: non-matching type does NOT fire hook
-(let ((triggered false))
-  (begin
-    (set! cl-break-on-signals "error")
-    (set! cl-debugger-hook
-      (fn (c h) (set! triggered true) nil))
-    (cl-handler-bind
-      (list (list "warning" (fn (c) nil)))
-      (fn ()
-        (cl-signal (cl-make-condition "simple-warning" "format-control" "w"))))
-    (set! cl-break-on-signals nil)
-    (set! cl-debugger-hook nil)
-    (assert-equal "break-on-signals: type mismatch not triggered"  triggered  false)))
-
-(reset-stacks!)
-
-;; ── 17. cl-invoke-restart-interactively ──────────────────────────────────
-
-(let ((result
-        (cl-restart-case
-          (fn () (cl-invoke-restart-interactively "use-default"))
-          (list "use-default" (list) (fn () 99)))))
-  (assert-equal "invoke-restart-interactively: returns restart value"  result  99))
-
-(reset-stacks!)
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(if
-  (= failed 0)
-  (print (str "ok " passed "/" (+ passed failed) " condition tests passed"))
-  (begin
-    (for-each (fn (f) (print f)) failures)
-    (print
-      (str "FAIL " passed "/" (+ passed failed) " passed, " failed " failed"))))
--- a/lib/common-lisp/tests/eval.sx
+++ b/lib/common-lisp/tests/eval.sx
@@ -1,466 +0,0 @@
-;; CL evaluator tests
-
-(define cl-test-pass 0)
-(define cl-test-fail 0)
-(define cl-test-fails (list))
-
-(define
-  cl-deep=
-  (fn
-    (a b)
-    (cond
-      ((= a b) true)
-      ((and (dict? a) (dict? b))
-        (let
-          ((ak (keys a)) (bk (keys b)))
-          (if
-            (not (= (len ak) (len bk)))
-            false
-            (every?
-              (fn (k) (and (has-key? b k) (cl-deep= (get a k) (get b k))))
-              ak))))
-      ((and (list? a) (list? b))
-        (if
-          (not (= (len a) (len b)))
-          false
-          (let
-            ((i 0) (ok true))
-            (define
-              chk
-              (fn
-                ()
-                (when
-                  (and ok (< i (len a)))
-                  (do
-                    (when
-                      (not (cl-deep= (nth a i) (nth b i)))
-                      (set! ok false))
-                    (set! i (+ i 1))
-                    (chk)))))
-            (chk)
-            ok)))
-      (:else false))))
-
-(define
-  cl-test
-  (fn
-    (name actual expected)
-    (if
-      (cl-deep= actual expected)
-      (set! cl-test-pass (+ cl-test-pass 1))
-      (do
-        (set! cl-test-fail (+ cl-test-fail 1))
-        (append! cl-test-fails {:name name :expected expected :actual actual})))))
-
-;; Convenience: evaluate CL string with fresh env each time
-(define ev (fn (src) (cl-eval-str src (cl-make-env))))
-(define evall (fn (src) (cl-eval-all-str src (cl-make-env))))
-
-;; ── self-evaluating literals ──────────────────────────────────────
-
-(cl-test "lit: nil" (ev "nil") nil)
-(cl-test "lit: t" (ev "t") true)
-(cl-test "lit: integer" (ev "42") 42)
-(cl-test "lit: negative" (ev "-7") -7)
-(cl-test "lit: zero" (ev "0") 0)
-(cl-test "lit: string" (ev "\"hello\"") "hello")
-(cl-test "lit: empty string" (ev "\"\"") "")
-(cl-test "lit: keyword type" (get (ev ":foo") "cl-type") "keyword")
-(cl-test "lit: keyword name" (get (ev ":foo") "name") "FOO")
-(cl-test "lit: float type" (get (ev "3.14") "cl-type") "float")
-
-;; ── QUOTE ─────────────────────────────────────────────────────────
-
-(cl-test "quote: symbol" (ev "'x") "X")
-(cl-test "quote: list" (ev "'(a b c)") (list "A" "B" "C"))
-(cl-test "quote: nil" (ev "'nil") nil)
-(cl-test "quote: integer" (ev "'42") 42)
-(cl-test "quote: nested" (ev "'(a (b c))") (list "A" (list "B" "C")))
-
-;; ── IF ────────────────────────────────────────────────────────────
-
-(cl-test "if: true branch" (ev "(if t 1 2)") 1)
-(cl-test "if: false branch" (ev "(if nil 1 2)") 2)
-(cl-test "if: no else nil" (ev "(if nil 99)") nil)
-(cl-test "if: number truthy" (ev "(if 0 'yes 'no)") "YES")
-(cl-test "if: empty string truthy" (ev "(if \"\" 'yes 'no)") "YES")
-(cl-test "if: nested" (ev "(if t (if nil 1 2) 3)") 2)
-
-;; ── PROGN ────────────────────────────────────────────────────────
-
-(cl-test "progn: single" (ev "(progn 42)") 42)
-(cl-test "progn: multiple" (ev "(progn 1 2 3)") 3)
-(cl-test "progn: nil last" (ev "(progn 1 nil)") nil)
-
-;; ── AND / OR ─────────────────────────────────────────────────────
-
-(cl-test "and: empty" (ev "(and)") true)
-(cl-test "and: all true" (ev "(and 1 2 3)") 3)
-(cl-test "and: short-circuit" (ev "(and nil 99)") nil)
-(cl-test "and: returns last" (ev "(and 1 2)") 2)
-(cl-test "or: empty" (ev "(or)") nil)
-(cl-test "or: first truthy" (ev "(or 1 2)") 1)
-(cl-test "or: all nil" (ev "(or nil nil)") nil)
-(cl-test "or: short-circuit" (ev "(or nil 42)") 42)
-
-;; ── COND ─────────────────────────────────────────────────────────
-
-(cl-test "cond: first match" (ev "(cond (t 1) (t 2))") 1)
-(cl-test "cond: second match" (ev "(cond (nil 1) (t 2))") 2)
-(cl-test "cond: no match" (ev "(cond (nil 1) (nil 2))") nil)
-(cl-test "cond: returns test value" (ev "(cond (42))") 42)
-
-;; ── WHEN / UNLESS ─────────────────────────────────────────────────
-
-(cl-test "when: true" (ev "(when t 1 2 3)") 3)
-(cl-test "when: nil" (ev "(when nil 99)") nil)
-(cl-test "unless: nil runs" (ev "(unless nil 42)") 42)
-(cl-test "unless: true skips" (ev "(unless t 99)") nil)
-
-;; ── LET ──────────────────────────────────────────────────────────
-
-(cl-test "let: empty bindings" (ev "(let () 42)") 42)
-(cl-test "let: single binding" (ev "(let ((x 5)) x)") 5)
-(cl-test "let: two bindings" (ev "(let ((x 3) (y 4)) (+ x y))") 7)
-(cl-test "let: parallel" (ev "(let ((x 1)) (let ((x 2) (y x)) y))") 1)
-(cl-test "let: nested" (ev "(let ((x 1)) (let ((y 2)) (+ x y)))") 3)
-(cl-test "let: progn body" (ev "(let ((x 5)) (+ x 1) (* x 2))") 10)
-(cl-test "let: bare name nil" (ev "(let (x) x)") nil)
-
-;; ── LET* ─────────────────────────────────────────────────────────
-
-(cl-test "let*: sequential" (ev "(let* ((x 1) (y (+ x 1))) y)") 2)
-(cl-test "let*: chain" (ev "(let* ((a 2) (b (* a 3)) (c (+ b 1))) c)") 7)
-(cl-test "let*: shadow" (ev "(let ((x 1)) (let* ((x 2) (y x)) y))") 2)
-
-;; ── SETQ / SETF ──────────────────────────────────────────────────
-
-(cl-test "setq: basic" (ev "(let ((x 0)) (setq x 5) x)") 5)
-(cl-test "setq: returns value" (ev "(let ((x 0)) (setq x 99))") 99)
-(cl-test "setf: basic" (ev "(let ((x 0)) (setf x 7) x)") 7)
-
-;; ── LAMBDA ────────────────────────────────────────────────────────
-
-(cl-test "lambda: call" (ev "((lambda (x) x) 42)") 42)
-(cl-test "lambda: multi-arg" (ev "((lambda (x y) (+ x y)) 3 4)") 7)
-(cl-test "lambda: closure" (ev "(let ((n 10)) ((lambda (x) (+ x n)) 5))") 15)
-(cl-test "lambda: rest arg"
-  (ev "((lambda (x &rest xs) (cons x xs)) 1 2 3)")
-  {:cl-type "cons" :car 1 :cdr (list 2 3)})
-(cl-test "lambda: optional no default"
-  (ev "((lambda (&optional x) x))")
-  nil)
-(cl-test "lambda: optional with arg"
-  (ev "((lambda (&optional (x 99)) x) 42)")
-  42)
-(cl-test "lambda: optional default used"
-  (ev "((lambda (&optional (x 7)) x))")
-  7)
-
-;; ── FUNCTION ─────────────────────────────────────────────────────
-
-(cl-test "function: lambda" (get (ev "(function (lambda (x) x))") "cl-type") "function")
-
-;; ── DEFUN ────────────────────────────────────────────────────────
-
-(cl-test "defun: returns name" (evall "(defun sq (x) (* x x))") "SQ")
-(cl-test "defun: call" (evall "(defun sq (x) (* x x)) (sq 5)") 25)
-(cl-test "defun: multi-arg" (evall "(defun add (x y) (+ x y)) (add 3 4)") 7)
-(cl-test "defun: recursive factorial"
-  (evall "(defun fact (n) (if (<= n 1) 1 (* n (fact (- n 1))))) (fact 5)")
-  120)
-(cl-test "defun: multiple calls"
-  (evall "(defun double (x) (* x 2)) (+ (double 3) (double 5))")
-  16)
-
-;; ── FLET ─────────────────────────────────────────────────────────
-
-(cl-test "flet: basic"
-  (ev "(flet ((double (x) (* x 2))) (double 5))")
-  10)
-(cl-test "flet: sees outer vars"
-  (ev "(let ((n 3)) (flet ((add-n (x) (+ x n))) (add-n 7)))")
-  10)
-(cl-test "flet: non-recursive"
-  (ev "(flet ((f (x) (+ x 1))) (flet ((f (x) (f (f x)))) (f 5)))")
-  7)
-
-;; ── LABELS ────────────────────────────────────────────────────────
-
-(cl-test "labels: basic"
-  (ev "(labels ((greet (x) x)) (greet 42))")
-  42)
-(cl-test "labels: recursive"
-  (ev "(labels ((count (n) (if (<= n 0) 0 (+ 1 (count (- n 1)))))) (count 5))")
-  5)
-(cl-test "labels: mutual recursion"
-  (ev "(labels
-         ((even? (n) (if (= n 0) t  (odd? (- n 1))))
-          (odd?  (n) (if (= n 0) nil   (even? (- n 1)))))
-         (list (even? 4) (odd? 3)))")
-  (list true true))
-
-;; ── THE / LOCALLY / EVAL-WHEN ────────────────────────────────────
-
-(cl-test "the: passthrough" (ev "(the integer 42)") 42)
-(cl-test "the: string" (ev "(the string \"hi\")") "hi")
-(cl-test "locally: body" (ev "(locally 1 2 3)") 3)
-(cl-test "eval-when: execute" (ev "(eval-when (:execute) 99)") 99)
-(cl-test "eval-when: no execute" (ev "(eval-when (:compile-toplevel) 99)") nil)
-
-;; ── DEFVAR / DEFPARAMETER ────────────────────────────────────────
-
-(cl-test "defvar: returns name" (evall "(defvar *x* 10)") "*X*")
-(cl-test "defparameter: sets value" (evall "(defparameter *y* 42) *y*") 42)
-(cl-test "defvar: no reinit" (evall "(defvar *z* 1) (defvar *z* 99) *z*") 1)
-
-;; ── built-in arithmetic ───────────────────────────────────────────
-
-(cl-test "arith: +" (ev "(+ 1 2 3)") 6)
-(cl-test "arith: + zero" (ev "(+)") 0)
-(cl-test "arith: -" (ev "(- 10 3 2)") 5)
-(cl-test "arith: - negate" (ev "(- 5)") -5)
-(cl-test "arith: *" (ev "(* 2 3 4)") 24)
-(cl-test "arith: * one" (ev "(*)") 1)
-(cl-test "arith: /" (ev "(/ 12 3)") 4)
-(cl-test "arith: max" (ev "(max 3 1 4 1 5)") 5)
-(cl-test "arith: min" (ev "(min 3 1 4 1 5)") 1)
-(cl-test "arith: abs neg" (ev "(abs -7)") 7)
-(cl-test "arith: abs pos" (ev "(abs 7)") 7)
-
-;; ── built-in comparisons ──────────────────────────────────────────
-
-(cl-test "cmp: = true" (ev "(= 3 3)") true)
-(cl-test "cmp: = false" (ev "(= 3 4)") nil)
-(cl-test "cmp: /=" (ev "(/= 3 4)") true)
-(cl-test "cmp: <" (ev "(< 1 2)") true)
-(cl-test "cmp: > false" (ev "(> 1 2)") nil)
-(cl-test "cmp: <=" (ev "(<= 2 2)") true)
-
-;; ── built-in predicates ───────────────────────────────────────────
-
-(cl-test "pred: null nil" (ev "(null nil)") true)
-(cl-test "pred: null non-nil" (ev "(null 5)") nil)
-(cl-test "pred: not nil" (ev "(not nil)") true)
-(cl-test "pred: not truthy" (ev "(not 5)") nil)
-(cl-test "pred: numberp" (ev "(numberp 5)") true)
-(cl-test "pred: numberp str" (ev "(numberp \"x\")") nil)
-(cl-test "pred: stringp" (ev "(stringp \"hello\")") true)
-(cl-test "pred: listp list" (ev "(listp '(1))") true)
-(cl-test "pred: listp nil" (ev "(listp nil)") true)
-(cl-test "pred: zerop" (ev "(zerop 0)") true)
-(cl-test "pred: plusp" (ev "(plusp 3)") true)
-(cl-test "pred: evenp" (ev "(evenp 4)") true)
-(cl-test "pred: oddp" (ev "(oddp 3)") true)
-
-;; ── built-in list ops ─────────────────────────────────────────────
-
-(cl-test "list: car" (ev "(car '(1 2 3))") 1)
-(cl-test "list: cdr" (ev "(cdr '(1 2 3))") (list 2 3))
-(cl-test "list: cons" (get (ev "(cons 1 2)") "car") 1)
-(cl-test "list: list fn" (ev "(list 1 2 3)") (list 1 2 3))
-(cl-test "list: length" (ev "(length '(a b c))") 3)
-(cl-test "list: length nil" (ev "(length nil)") 0)
-(cl-test "list: append" (ev "(append '(1 2) '(3 4))") (list 1 2 3 4))
-(cl-test "list: first" (ev "(first '(10 20 30))") 10)
-(cl-test "list: second" (ev "(second '(10 20 30))") 20)
-(cl-test "list: third" (ev "(third '(10 20 30))") 30)
-(cl-test "list: rest" (ev "(rest '(1 2 3))") (list 2 3))
-(cl-test "list: nth" (ev "(nth 1 '(a b c))") "B")
-(cl-test "list: reverse" (ev "(reverse '(1 2 3))") (list 3 2 1))
-
-;; ── FUNCALL / APPLY / MAPCAR ─────────────────────────────────────
-
-(cl-test "funcall: lambda"
-  (ev "(funcall (lambda (x) (* x x)) 5)")
-  25)
-(cl-test "apply: basic"
-  (ev "(apply #'+ '(1 2 3))")
-  6)
-(cl-test "apply: leading args"
-  (ev "(apply #'+ 1 2 '(3 4))")
-  10)
-(cl-test "mapcar: basic"
-  (ev "(mapcar (lambda (x) (* x 2)) '(1 2 3))")
-  (list 2 4 6))
-
-;; ── BLOCK / RETURN-FROM / RETURN ─────────────────────────────────
-
-(cl-test "block: last form value"
-  (ev "(block done 1 2 3)")
-  3)
-(cl-test "block: empty body"
-  (ev "(block done)")
-  nil)
-(cl-test "block: single form"
-  (ev "(block foo 42)")
-  42)
-(cl-test "block: return-from"
-  (ev "(block done 1 (return-from done 99) 2)")
-  99)
-(cl-test "block: return-from nil block"
-  (ev "(block nil 1 (return-from nil 42) 3)")
-  42)
-(cl-test "block: return-from no value"
-  (ev "(block done (return-from done))")
-  nil)
-(cl-test "block: nested inner return stays inner"
-  (ev "(block outer (block inner (return-from inner 1) 2) 3)")
-  3)
-(cl-test "block: nested outer return"
-  (ev "(block outer (block inner 1 2) (return-from outer 99) 3)")
-  99)
-(cl-test "return: shorthand for nil block"
-  (ev "(block nil (return 77))")
-  77)
-(cl-test "return: no value"
-  (ev "(block nil 1 (return) 2)")
-  nil)
-(cl-test "block: return-from inside let"
-  (ev "(block done (let ((x 5)) (when (> x 3) (return-from done x))) 0)")
-  5)
-(cl-test "block: return-from inside progn"
-  (ev "(block done (progn (return-from done 7) 99))")
-  7)
-(cl-test "block: return-from through function"
-  (ev "(block done (flet ((f () (return-from done 42))) (f)) nil)")
-  42)
-
-;; ── TAGBODY / GO ─────────────────────────────────────────────────
-
-(cl-test "tagbody: empty returns nil"
-  (ev "(tagbody)")
-  nil)
-(cl-test "tagbody: forms only, returns nil"
-  (ev "(let ((x 0)) (tagbody (setq x 1) (setq x 2)) x)")
-  2)
-(cl-test "tagbody: tag only, returns nil"
-  (ev "(tagbody done)")
-  nil)
-(cl-test "tagbody: go skips forms"
-  (ev "(let ((x 0)) (tagbody (go done) (setq x 99) done) x)")
-  0)
-(cl-test "tagbody: go to later tag"
-  (ev "(let ((x 0)) (tagbody start (setq x (+ x 1)) (go done) (setq x 99) done) x)")
-  1)
-(cl-test "tagbody: loop with counter"
-  (ev "(let ((n 0)) (tagbody loop (when (>= n 3) (go done)) (setq n (+ n 1)) (go loop) done) n)")
-  3)
-(cl-test "tagbody: go inside when"
-  (ev "(let ((x 0)) (tagbody (setq x 1) (when t (go done)) (setq x 99) done) x)")
-  1)
-(cl-test "tagbody: go inside progn"
-  (ev "(let ((x 0)) (tagbody (progn (setq x 1) (go done)) (setq x 99) done) x)")
-  1)
-(cl-test "tagbody: go inside let"
-  (ev "(let ((acc 0)) (tagbody (let ((y 5)) (when (> y 3) (go done))) (setq acc 99) done) acc)")
-  0)
-(cl-test "tagbody: integer tags"
-  (ev "(let ((x 0)) (tagbody (go 2) 1 (setq x 1) (go 3) 2 (setq x 2) (go 3) 3) x)")
-  2)
-(cl-test "tagbody: block-return propagates out"
-  (ev "(block done (tagbody (return-from done 42)) nil)")
-  42)
-
-;; ── UNWIND-PROTECT ───────────────────────────────────────────────
-
-(cl-test "unwind-protect: normal returns protected"
-  (ev "(unwind-protect 42 nil)")
-  42)
-(cl-test "unwind-protect: cleanup runs"
-  (ev "(let ((x 0)) (unwind-protect 1 (setq x 99)) x)")
-  99)
-(cl-test "unwind-protect: cleanup result ignored"
-  (ev "(unwind-protect 42 777)")
-  42)
-(cl-test "unwind-protect: multiple cleanup forms"
-  (ev "(let ((x 0)) (unwind-protect 1 (setq x (+ x 1)) (setq x (+ x 1))) x)")
-  2)
-(cl-test "unwind-protect: cleanup on return-from"
-  (ev "(let ((x 0)) (block done (unwind-protect (return-from done 7) (setq x 99))) x)")
-  99)
-(cl-test "unwind-protect: return-from still propagates"
-  (ev "(block done (unwind-protect (return-from done 42) nil))")
-  42)
-(cl-test "unwind-protect: cleanup on go"
-  (ev "(let ((x 0)) (tagbody (unwind-protect (go done) (setq x 1)) done) x)")
-  1)
-(cl-test "unwind-protect: nested, inner cleanup first"
-  (ev "(let ((n 0)) (unwind-protect (unwind-protect 1 (setq n (+ n 10))) (setq n (+ n 1))) n)")
-  11)
-
-;; ── VALUES / MULTIPLE-VALUE-BIND / NTH-VALUE ────────────────────
-
-(cl-test "values: single returns plain"
-  (ev "(values 42)")
-  42)
-(cl-test "values: zero returns nil"
-  (ev "(values)")
-  nil)
-(cl-test "values: multi — primary via funcall"
-  (ev "(car (list (values 1 2)))")
-  1)
-(cl-test "multiple-value-bind: basic"
-  (ev "(multiple-value-bind (a b) (values 1 2) (+ a b))")
-  3)
-(cl-test "multiple-value-bind: extra vars get nil"
-  (ev "(multiple-value-bind (a b c) (values 10 20) (list a b c))")
-  (list 10 20 nil))
-(cl-test "multiple-value-bind: extra values ignored"
-  (ev "(multiple-value-bind (a) (values 1 2 3) a)")
-  1)
-(cl-test "multiple-value-bind: single value source"
-  (ev "(multiple-value-bind (a b) 42 (list a b))")
-  (list 42 nil))
-(cl-test "nth-value: 0"
-  (ev "(nth-value 0 (values 10 20 30))")
-  10)
-(cl-test "nth-value: 1"
-  (ev "(nth-value 1 (values 10 20 30))")
-  20)
-(cl-test "nth-value: out of range"
-  (ev "(nth-value 5 (values 10 20))")
-  nil)
-(cl-test "multiple-value-call: basic"
-  (ev "(multiple-value-call #'+ (values 1 2) (values 3 4))")
-  10)
-(cl-test "multiple-value-prog1: returns first"
-  (ev "(multiple-value-prog1 1 2 3)")
-  1)
-(cl-test "multiple-value-prog1: side effects run"
-  (ev "(let ((x 0)) (multiple-value-prog1 99 (setq x 7)) x)")
-  7)
-(cl-test "values: nil primary in if"
-  (ev "(if (values nil t) 'yes 'no)")
-  "NO")
-(cl-test "values: truthy primary in if"
-  (ev "(if (values 42 nil) 'yes 'no)")
-  "YES")
-
-;; --- Dynamic variables ---
-(cl-test "defvar marks special"
-  (do (ev "(defvar *dv* 10)")
-    (cl-special? "*DV*"))
-  true)
-(cl-test "defvar: let rebinds dynamically"
-  (ev "(progn (defvar *x* 1) (defun get-x () *x*) (let ((*x* 99)) (get-x)))")
-  99)
-(cl-test "defvar: binding restores after let"
-  (ev "(progn (defvar *yrst* 5) (let ((*yrst* 42)) *yrst*) *yrst*)")
-  5)
-(cl-test "defparameter marks special"
-  (do (ev "(defparameter *dp* 0)")
-    (cl-special? "*DP*"))
-  true)
-(cl-test "defparameter: let rebinds dynamically"
-  (ev "(progn (defparameter *z* 10) (defun get-z () *z*) (let ((*z* 77)) (get-z)))")
-  77)
-(cl-test "defparameter: always assigns"
-  (ev "(progn (defparameter *p* 1) (defparameter *p* 2) *p*)")
-  2)
-(cl-test "dynamic binding: nested lets"
-  (ev "(progn (defvar *n* 0) (let ((*n* 1)) (let ((*n* 2)) *n*)))")
-  2)
-(cl-test "dynamic binding: restores across nesting"
-  (ev "(progn (defvar *m* 10) (let ((*m* 20)) (let ((*m* 30)) nil)) *m*)")
-  10)
--- a/lib/common-lisp/tests/lambda.sx
+++ b/lib/common-lisp/tests/lambda.sx
@@ -1,204 +0,0 @@
-;; Lambda list parser tests
-
-(define cl-test-pass 0)
-(define cl-test-fail 0)
-(define cl-test-fails (list))
-
-;; Deep structural equality for dicts and lists
-(define
-  cl-deep=
-  (fn
-    (a b)
-    (cond
-      ((= a b) true)
-      ((and (dict? a) (dict? b))
-        (let
-          ((ak (keys a)) (bk (keys b)))
-          (if
-            (not (= (len ak) (len bk)))
-            false
-            (every?
-              (fn (k) (and (has-key? b k) (cl-deep= (get a k) (get b k))))
-              ak))))
-      ((and (list? a) (list? b))
-        (if
-          (not (= (len a) (len b)))
-          false
-          (let
-            ((i 0) (ok true))
-            (define
-              chk
-              (fn
-                ()
-                (when
-                  (and ok (< i (len a)))
-                  (do
-                    (when
-                      (not (cl-deep= (nth a i) (nth b i)))
-                      (set! ok false))
-                    (set! i (+ i 1))
-                    (chk)))))
-            (chk)
-            ok)))
-      (:else false))))
-
-(define
-  cl-test
-  (fn
-    (name actual expected)
-    (if
-      (cl-deep= actual expected)
-      (set! cl-test-pass (+ cl-test-pass 1))
-      (do
-        (set! cl-test-fail (+ cl-test-fail 1))
-        (append! cl-test-fails {:name name :expected expected :actual actual})))))
-
-;; Helper: parse lambda list from string "(x y ...)"
-(define ll (fn (src) (cl-parse-lambda-list-str src)))
-(define ll-req  (fn (src) (get (ll src) "required")))
-(define ll-opt  (fn (src) (get (ll src) "optional")))
-(define ll-rest (fn (src) (get (ll src) "rest")))
-(define ll-key  (fn (src) (get (ll src) "key")))
-(define ll-aok  (fn (src) (get (ll src) "allow-other-keys")))
-(define ll-aux  (fn (src) (get (ll src) "aux")))
-
-;; ── required parameters ───────────────────────────────────────────
-
-(cl-test "required: empty" (ll-req "()") (list))
-(cl-test "required: one" (ll-req "(x)") (list "X"))
-(cl-test "required: two" (ll-req "(x y)") (list "X" "Y"))
-(cl-test "required: three" (ll-req "(a b c)") (list "A" "B" "C"))
-(cl-test "required: upcased" (ll-req "(foo bar)") (list "FOO" "BAR"))
-
-;; ── &optional ─────────────────────────────────────────────────────
-
-(cl-test "optional: none" (ll-opt "(x)") (list))
-
-(cl-test
-  "optional: bare symbol"
-  (ll-opt "(x &optional z)")
-  (list {:name "Z" :default nil :supplied nil}))
-
-(cl-test
-  "optional: with default"
-  (ll-opt "(x &optional (z 0))")
-  (list {:name "Z" :default 0 :supplied nil}))
-
-(cl-test
-  "optional: with supplied-p"
-  (ll-opt "(x &optional (z 0 z-p))")
-  (list {:name "Z" :default 0 :supplied "Z-P"}))
-
-(cl-test
-  "optional: two params"
-  (ll-opt "(&optional a (b 1))")
-  (list {:name "A" :default nil :supplied nil} {:name "B" :default 1 :supplied nil}))
-
-(cl-test
-  "optional: string default"
-  (ll-opt "(&optional (name \"world\"))")
-  (list {:name "NAME" :default {:cl-type "string" :value "world"} :supplied nil}))
-
-;; ── &rest ─────────────────────────────────────────────────────────
-
-(cl-test "rest: none" (ll-rest "(x)") nil)
-(cl-test "rest: present" (ll-rest "(x &rest args)") "ARGS")
-(cl-test "rest: with required" (ll-rest "(a b &rest tail)") "TAIL")
-
-;; &body is an alias for &rest
-(cl-test "body: alias for rest" (ll-rest "(&body forms)") "FORMS")
-
-;; rest doesn't consume required params
-(cl-test "rest: required still there" (ll-req "(a b &rest rest)") (list "A" "B"))
-
-;; ── &key ──────────────────────────────────────────────────────────
-
-(cl-test "key: none" (ll-key "(x)") (list))
-
-(cl-test
-  "key: bare symbol"
-  (ll-key "(&key x)")
-  (list {:name "X" :keyword "X" :default nil :supplied nil}))
-
-(cl-test
-  "key: with default"
-  (ll-key "(&key (x 42))")
-  (list {:name "X" :keyword "X" :default 42 :supplied nil}))
-
-(cl-test
-  "key: with supplied-p"
-  (ll-key "(&key (x 42 x-p))")
-  (list {:name "X" :keyword "X" :default 42 :supplied "X-P"}))
-
-(cl-test
-  "key: two params"
-  (ll-key "(&key a b)")
-  (list
-    {:name "A" :keyword "A" :default nil :supplied nil}
-    {:name "B" :keyword "B" :default nil :supplied nil}))
-
-;; ── &allow-other-keys ─────────────────────────────────────────────
-
-(cl-test "aok: absent" (ll-aok "(x)") false)
-(cl-test "aok: present" (ll-aok "(&key x &allow-other-keys)") true)
-
-;; ── &aux ──────────────────────────────────────────────────────────
-
-(cl-test "aux: none" (ll-aux "(x)") (list))
-
-(cl-test
-  "aux: bare symbol"
-  (ll-aux "(&aux temp)")
-  (list {:name "TEMP" :init nil}))
-
-(cl-test
-  "aux: with init"
-  (ll-aux "(&aux (count 0))")
-  (list {:name "COUNT" :init 0}))
-
-(cl-test
-  "aux: two vars"
-  (ll-aux "(&aux a (b 1))")
-  (list {:name "A" :init nil} {:name "B" :init 1}))
-
-;; ── combined ──────────────────────────────────────────────────────
-
-(cl-test
-  "combined: full lambda list"
-  (let
-    ((parsed (ll "(x y &optional (z 0 z-p) &rest args &key a (b nil b-p) &aux temp)")))
-    (list
-      (get parsed "required")
-      (get (nth (get parsed "optional") 0) "name")
-      (get (nth (get parsed "optional") 0) "default")
-      (get (nth (get parsed "optional") 0) "supplied")
-      (get parsed "rest")
-      (get (nth (get parsed "key") 0) "name")
-      (get (nth (get parsed "key") 1) "supplied")
-      (get (nth (get parsed "aux") 0) "name")))
-  (list
-    (list "X" "Y")
-    "Z"
-    0
-    "Z-P"
-    "ARGS"
-    "A"
-    "B-P"
-    "TEMP"))
-
-(cl-test
-  "combined: required only stops before &"
-  (ll-req "(a b &optional c)")
-  (list "A" "B"))
-
-(cl-test
-  "combined: required only with &key"
-  (ll-req "(x &key y)")
-  (list "X"))
-
-(cl-test
-  "combined: &rest and &key together"
-  (let
-    ((parsed (ll "(&rest args &key verbose)")))
-    (list (get parsed "rest") (get (nth (get parsed "key") 0) "name")))
-  (list "ARGS" "VERBOSE"))
--- a/lib/common-lisp/tests/macros.sx
+++ b/lib/common-lisp/tests/macros.sx
@@ -1,204 +0,0 @@
-;; lib/common-lisp/tests/macros.sx — Phase 5: defmacro, gensym, LOOP tests
-;;
-;; Depends on: runtime.sx, eval.sx, loop.sx already loaded.
-;; Tests via (ev "...") using the CL evaluator.
-
-(define ev (fn (src) (cl-eval-str src (cl-make-env))))
-(define evall (fn (src) (cl-eval-all-str src (cl-make-env))))
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  check
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-;; ── defmacro basics ──────────────────────────────────────────────────────────
-
-(check
-  "defmacro returns name"
-  (ev "(defmacro my-or (a b) (list 'if a a b))")
-  "MY-OR")
-
-(check
-  "defmacro expansion works"
-  (ev "(progn (defmacro my-inc (x) (list '+ x 1)) (my-inc 5))")
-  6)
-
-(check
-  "defmacro with &rest"
-  (ev "(progn (defmacro my-list (&rest xs) (cons 'list xs)) (my-list 1 2 3))")
-  (list 1 2 3))
-
-(check
-  "nested macro expansion"
-  (ev "(progn (defmacro sq (x) (list '* x x)) (sq 7))")
-  49)
-
-(check
-  "macro in conditional"
-  (ev
-    "(progn (defmacro my-when (c &rest body) (list 'if c (cons 'progn body) nil)) (my-when t 10 20))")
-  20)
-
-(check
-  "macro returns nil branch"
-  (ev
-    "(progn (defmacro my-when (c &rest body) (list 'if c (cons 'progn body) nil)) (my-when nil 42))")
-  nil)
-
-;; ── macroexpand ───────────────────────────────────────────────────────────────
-
-(check
-  "macroexpand returns expanded form"
-  (ev "(progn (defmacro double (x) (list '+ x x)) (macroexpand '(double 5)))")
-  (list "+" 5 5))
-
-;; ── gensym ────────────────────────────────────────────────────────────────────
-
-(check "gensym returns string" (ev "(stringp (gensym))") true)
-
-(check
-  "gensym prefix"
-  (ev "(let ((g (gensym \"MY\"))) (not (= g nil)))")
-  true)
-
-(check "gensyms are unique" (ev "(not (= (gensym) (gensym)))") true)
-
-;; ── swap! macro with gensym ───────────────────────────────────────────────────
-
-(check
-  "swap! macro"
-  (evall
-    "(defmacro swap! (a b) (let ((tmp (gensym))) (list 'let (list (list tmp a)) (list 'setq a b) (list 'setq b tmp)))) (defvar *a* 10) (defvar *b* 20) (swap! *a* *b*) (list *a* *b*)")
-  (list 20 10))
-
-;; ── LOOP: basic repeat and collect ────────────────────────────────────────────
-
-(check
-  "loop repeat collect"
-  (ev "(loop repeat 3 collect 99)")
-  (list 99 99 99))
-
-(check
-  "loop for-in collect"
-  (ev "(loop for x in '(1 2 3) collect (* x x))")
-  (list 1 4 9))
-
-(check
-  "loop for-from-to collect"
-  (ev "(loop for i from 1 to 5 collect i)")
-  (list 1 2 3 4 5))
-
-(check
-  "loop for-from-below collect"
-  (ev "(loop for i from 0 below 4 collect i)")
-  (list 0 1 2 3))
-
-(check
-  "loop for-downto collect"
-  (ev "(loop for i from 5 downto 1 collect i)")
-  (list 5 4 3 2 1))
-
-(check
-  "loop for-by collect"
-  (ev "(loop for i from 0 to 10 by 2 collect i)")
-  (list 0 2 4 6 8 10))
-
-;; ── LOOP: sum, count, maximize, minimize ─────────────────────────────────────
-
-(check "loop sum" (ev "(loop for i from 1 to 5 sum i)") 15)
-
-(check
-  "loop count"
-  (ev "(loop for x in '(1 2 3 4 5) count (> x 3))")
-  2)
-
-(check
-  "loop maximize"
-  (ev "(loop for x in '(3 1 4 1 5 9 2 6) maximize x)")
-  9)
-
-(check
-  "loop minimize"
-  (ev "(loop for x in '(3 1 4 1 5 9 2 6) minimize x)")
-  1)
-
-;; ── LOOP: while and until ─────────────────────────────────────────────────────
-
-(check
-  "loop while"
-  (ev "(loop for i from 1 to 10 while (< i 5) collect i)")
-  (list 1 2 3 4))
-
-(check
-  "loop until"
-  (ev "(loop for i from 1 to 10 until (= i 5) collect i)")
-  (list 1 2 3 4))
-
-;; ── LOOP: when / unless ───────────────────────────────────────────────────────
-
-(check
-  "loop when filter"
-  (ev "(loop for i from 0 below 8 when (evenp i) collect i)")
-  (list 0 2 4 6))
-
-(check
-  "loop unless filter"
-  (ev "(loop for i from 0 below 8 unless (evenp i) collect i)")
-  (list 1 3 5 7))
-
-;; ── LOOP: append ─────────────────────────────────────────────────────────────
-
-(check
-  "loop append"
-  (ev "(loop for x in '((1 2) (3 4) (5 6)) append x)")
-  (list 1 2 3 4 5 6))
-
-;; ── LOOP: always, never, thereis ─────────────────────────────────────────────
-
-(check
-  "loop always true"
-  (ev "(loop for x in '(2 4 6) always (evenp x))")
-  true)
-
-(check
-  "loop always false"
-  (ev "(loop for x in '(2 3 6) always (evenp x))")
-  false)
-
-(check "loop never" (ev "(loop for x in '(1 3 5) never (evenp x))") true)
-
-(check "loop thereis" (ev "(loop for x in '(1 2 3) thereis (> x 2))") true)
-
-;; ── LOOP: for = then (general iteration) ─────────────────────────────────────
-
-(check
-  "loop for = then doubling"
-  (ev "(loop repeat 5 for x = 1 then (* x 2) collect x)")
-  (list 1 2 4 8 16))
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(define macro-passed passed)
-(define macro-failed failed)
-(define macro-failures failures)
--- a/lib/common-lisp/tests/parse.sx
+++ b/lib/common-lisp/tests/parse.sx
@@ -1,160 +0,0 @@
-;; Common Lisp reader/parser tests
-
-(define cl-test-pass 0)
-(define cl-test-fail 0)
-(define cl-test-fails (list))
-
-(define
-  cl-deep=
-  (fn
-    (a b)
-    (cond
-      ((= a b) true)
-      ((and (dict? a) (dict? b))
-        (let
-          ((ak (keys a)) (bk (keys b)))
-          (if
-            (not (= (len ak) (len bk)))
-            false
-            (every?
-              (fn (k) (and (has-key? b k) (cl-deep= (get a k) (get b k))))
-              ak))))
-      ((and (list? a) (list? b))
-        (if
-          (not (= (len a) (len b)))
-          false
-          (let
-            ((i 0) (ok true))
-            (define
-              chk
-              (fn
-                ()
-                (when
-                  (and ok (< i (len a)))
-                  (do
-                    (when
-                      (not (cl-deep= (nth a i) (nth b i)))
-                      (set! ok false))
-                    (set! i (+ i 1))
-                    (chk)))))
-            (chk)
-            ok)))
-      (:else false))))
-
-(define
-  cl-test
-  (fn
-    (name actual expected)
-    (if
-      (cl-deep= actual expected)
-      (set! cl-test-pass (+ cl-test-pass 1))
-      (do
-        (set! cl-test-fail (+ cl-test-fail 1))
-        (append! cl-test-fails {:name name :expected expected :actual actual})))))
-
-;; ── atoms ─────────────────────────────────────────────────────────
-
-(cl-test "integer: 42" (cl-read "42") 42)
-(cl-test "integer: 0" (cl-read "0") 0)
-(cl-test "integer: negative" (cl-read "-5") -5)
-(cl-test "integer: positive sign" (cl-read "+3") 3)
-(cl-test "integer: hex #xFF" (cl-read "#xFF") 255)
-(cl-test "integer: hex #xAB" (cl-read "#xAB") 171)
-(cl-test "integer: binary #b1010" (cl-read "#b1010") 10)
-(cl-test "integer: octal #o17" (cl-read "#o17") 15)
-
-(cl-test "float: type" (get (cl-read "3.14") "cl-type") "float")
-(cl-test "float: value" (get (cl-read "3.14") "value") "3.14")
-(cl-test "float: neg" (get (cl-read "-2.5") "value") "-2.5")
-(cl-test "float: exp" (get (cl-read "1.0e10") "value") "1.0e10")
-
-(cl-test "ratio: type" (get (cl-read "1/3") "cl-type") "ratio")
-(cl-test "ratio: value" (get (cl-read "1/3") "value") "1/3")
-(cl-test "ratio: 22/7" (get (cl-read "22/7") "value") "22/7")
-
-(cl-test "string: basic" (cl-read "\"hello\"") {:cl-type "string" :value "hello"})
-(cl-test "string: empty" (cl-read "\"\"") {:cl-type "string" :value ""})
-(cl-test "string: with escape" (cl-read "\"a\\nb\"") {:cl-type "string" :value "a\nb"})
-
-(cl-test "symbol: foo" (cl-read "foo") "FOO")
-(cl-test "symbol: BAR" (cl-read "BAR") "BAR")
-(cl-test "symbol: pkg:sym" (cl-read "cl:car") "CL:CAR")
-(cl-test "symbol: pkg::sym" (cl-read "pkg::foo") "PKG::FOO")
-
-(cl-test "nil: symbol" (cl-read "nil") nil)
-(cl-test "nil: uppercase" (cl-read "NIL") nil)
-(cl-test "t: symbol" (cl-read "t") true)
-(cl-test "t: uppercase" (cl-read "T") true)
-
-(cl-test "keyword: type" (get (cl-read ":foo") "cl-type") "keyword")
-(cl-test "keyword: name" (get (cl-read ":foo") "name") "FOO")
-(cl-test "keyword: :test" (get (cl-read ":test") "name") "TEST")
-
-(cl-test "char: type" (get (cl-read "#\\a") "cl-type") "char")
-(cl-test "char: value" (get (cl-read "#\\a") "value") "a")
-(cl-test "char: Space" (get (cl-read "#\\Space") "value") " ")
-(cl-test "char: Newline" (get (cl-read "#\\Newline") "value") "\n")
-
-(cl-test "uninterned: type" (get (cl-read "#:foo") "cl-type") "uninterned")
-(cl-test "uninterned: name" (get (cl-read "#:foo") "name") "FOO")
-
-;; ── lists ─────────────────────────────────────────────────────────
-
-(cl-test "list: empty" (cl-read "()") (list))
-(cl-test "list: one element" (cl-read "(foo)") (list "FOO"))
-(cl-test "list: two elements" (cl-read "(foo bar)") (list "FOO" "BAR"))
-(cl-test "list: nested" (cl-read "((a b) c)") (list (list "A" "B") "C"))
-(cl-test "list: with integer" (cl-read "(+ 1 2)") (list "+" 1 2))
-(cl-test "list: with string" (cl-read "(print \"hi\")") (list "PRINT" {:cl-type "string" :value "hi"}))
-(cl-test "list: nil element" (cl-read "(a nil b)") (list "A" nil "B"))
-(cl-test "list: t element" (cl-read "(a t b)") (list "A" true "B"))
-
-;; ── dotted pairs ──────────────────────────────────────────────<E29480><E29480>──
-
-(cl-test "dotted: type" (get (cl-read "(a . b)") "cl-type") "cons")
-(cl-test "dotted: car" (get (cl-read "(a . b)") "car") "A")
-(cl-test "dotted: cdr" (get (cl-read "(a . b)") "cdr") "B")
-(cl-test "dotted: number cdr" (get (cl-read "(x . 42)") "cdr") 42)
-
-;; ── reader macros ────────────────────────────────────────────────<E29480><E29480>
-
-(cl-test "quote: form" (cl-read "'x") (list "QUOTE" "X"))
-(cl-test "quote: list" (cl-read "'(a b)") (list "QUOTE" (list "A" "B")))
-(cl-test "backquote: form" (cl-read "`x") (list "QUASIQUOTE" "X"))
-(cl-test "unquote: form" (cl-read ",x") (list "UNQUOTE" "X"))
-(cl-test "comma-at: form" (cl-read ",@x") (list "UNQUOTE-SPLICING" "X"))
-(cl-test "function: form" (cl-read "#'foo") (list "FUNCTION" "FOO"))
-
-;; ── vector ────────────────────────────────────────────────────────
-
-(cl-test "vector: type" (get (cl-read "#(1 2 3)") "cl-type") "vector")
-(cl-test "vector: elements" (get (cl-read "#(1 2 3)") "elements") (list 1 2 3))
-(cl-test "vector: empty" (get (cl-read "#()") "elements") (list))
-(cl-test "vector: mixed" (get (cl-read "#(a 1 \"s\")") "elements") (list "A" 1 {:cl-type "string" :value "s"}))
-
-;; ── cl-read-all ───────────────────────────────────────────────────
-
-(cl-test
-  "read-all: empty"
-  (cl-read-all "")
-  (list))
-
-(cl-test
-  "read-all: two forms"
-  (cl-read-all "42 foo")
-  (list 42 "FOO"))
-
-(cl-test
-  "read-all: three forms"
-  (cl-read-all "(+ 1 2) (+ 3 4) hello")
-  (list (list "+" 1 2) (list "+" 3 4) "HELLO"))
-
-(cl-test
-  "read-all: with comments"
-  (cl-read-all "; this is a comment\n42 ; inline\nfoo")
-  (list 42 "FOO"))
-
-(cl-test
-  "read-all: defun form"
-  (nth (cl-read-all "(defun square (x) (* x x))") 0)
-  (list "DEFUN" "SQUARE" (list "X") (list "*" "X" "X")))
--- a/lib/common-lisp/tests/programs/geometry.sx
+++ b/lib/common-lisp/tests/programs/geometry.sx
@@ -1,291 +0,0 @@
-;; geometry.sx — Multiple dispatch with CLOS
-;;
-;; Demonstrates generic functions dispatching on combinations of
-;; geometric types: point, line, plane.
-;;
-;; Depends on: lib/common-lisp/runtime.sx, lib/common-lisp/clos.sx
-
-;; ── geometric classes ──────────────────────────────────────────────────────
-
-(clos-defclass "geo-point" (list "t") (list {:initform 0 :initarg ":px" :reader nil :writer nil :accessor nil :name "px"} {:initform 0 :initarg ":py" :reader nil :writer nil :accessor nil :name "py"}))
-
-(clos-defclass "geo-line" (list "t") (list {:initform nil :initarg ":p1" :reader nil :writer nil :accessor nil :name "p1"} {:initform nil :initarg ":p2" :reader nil :writer nil :accessor nil :name "p2"}))
-
-(clos-defclass "geo-plane" (list "t") (list {:initform nil :initarg ":normal" :reader nil :writer nil :accessor nil :name "normal"} {:initform 0 :initarg ":d" :reader nil :writer nil :accessor nil :name "d"}))
-
-;; ── helpers ────────────────────────────────────────────────────────────────
-
-(define geo-point-x (fn (p) (clos-slot-value p "px")))
-(define geo-point-y (fn (p) (clos-slot-value p "py")))
-
-(define
-  geo-make-point
-  (fn (x y) (clos-make-instance "geo-point" ":px" x ":py" y)))
-
-(define
-  geo-make-line
-  (fn (p1 p2) (clos-make-instance "geo-line" ":p1" p1 ":p2" p2)))
-
-(define
-  geo-make-plane
-  (fn
-    (nx ny d)
-    (clos-make-instance "geo-plane" ":normal" (list nx ny) ":d" d)))
-
-;; ── describe generic ───────────────────────────────────────────────────────
-
-(clos-defgeneric "geo-describe" {})
-
-(clos-defmethod
-  "geo-describe"
-  (list)
-  (list "geo-point")
-  (fn
-    (args next-fn)
-    (let
-      ((p (first args)))
-      (str "P(" (geo-point-x p) "," (geo-point-y p) ")"))))
-
-(clos-defmethod
-  "geo-describe"
-  (list)
-  (list "geo-line")
-  (fn
-    (args next-fn)
-    (let
-      ((l (first args)))
-      (str
-        "L["
-        (clos-call-generic "geo-describe" (list (clos-slot-value l "p1")))
-        "-"
-        (clos-call-generic "geo-describe" (list (clos-slot-value l "p2")))
-        "]"))))
-
-(clos-defmethod
-  "geo-describe"
-  (list)
-  (list "geo-plane")
-  (fn
-    (args next-fn)
-    (let
-      ((pl (first args)))
-      (str "Plane(d=" (clos-slot-value pl "d") ")"))))
-
-;; ── intersect: multi-dispatch generic ─────────────────────────────────────
-;;
-;; Returns a string description of the intersection result.
-
-(clos-defgeneric "intersect" {})
-
-;; point ∩ point: same if coordinates match
-(clos-defmethod
-  "intersect"
-  (list)
-  (list "geo-point" "geo-point")
-  (fn
-    (args next-fn)
-    (let
-      ((p1 (first args)) (p2 (first (rest args))))
-      (if
-        (and
-          (= (geo-point-x p1) (geo-point-x p2))
-          (= (geo-point-y p1) (geo-point-y p2)))
-        "point"
-        "empty"))))
-
-;; point ∩ line: check if point lies on line (cross product = 0)
-(clos-defmethod
-  "intersect"
-  (list)
-  (list "geo-point" "geo-line")
-  (fn
-    (args next-fn)
-    (let
-      ((pt (first args)) (ln (first (rest args))))
-      (let
-        ((lp1 (clos-slot-value ln "p1")) (lp2 (clos-slot-value ln "p2")))
-        (let
-          ((dx (- (geo-point-x lp2) (geo-point-x lp1)))
-            (dy (- (geo-point-y lp2) (geo-point-y lp1)))
-            (ex (- (geo-point-x pt) (geo-point-x lp1)))
-            (ey (- (geo-point-y pt) (geo-point-y lp1))))
-          (if (= (- (* dx ey) (* dy ex)) 0) "point" "empty"))))))
-
-;; line ∩ line: parallel (same slope = empty) or point
-(clos-defmethod
-  "intersect"
-  (list)
-  (list "geo-line" "geo-line")
-  (fn
-    (args next-fn)
-    (let
-      ((l1 (first args)) (l2 (first (rest args))))
-      (let
-        ((p1 (clos-slot-value l1 "p1"))
-          (p2 (clos-slot-value l1 "p2"))
-          (p3 (clos-slot-value l2 "p1"))
-          (p4 (clos-slot-value l2 "p2")))
-        (let
-          ((dx1 (- (geo-point-x p2) (geo-point-x p1)))
-            (dy1 (- (geo-point-y p2) (geo-point-y p1)))
-            (dx2 (- (geo-point-x p4) (geo-point-x p3)))
-            (dy2 (- (geo-point-y p4) (geo-point-y p3))))
-          (let
-            ((cross (- (* dx1 dy2) (* dy1 dx2))))
-            (if (= cross 0) "parallel" "point")))))))
-
-;; line ∩ plane: general case = point (or parallel if line ⊥ normal)
-(clos-defmethod
-  "intersect"
-  (list)
-  (list "geo-line" "geo-plane")
-  (fn
-    (args next-fn)
-    (let
-      ((ln (first args)) (pl (first (rest args))))
-      (let
-        ((p1 (clos-slot-value ln "p1"))
-          (p2 (clos-slot-value ln "p2"))
-          (n (clos-slot-value pl "normal")))
-        (let
-          ((dx (- (geo-point-x p2) (geo-point-x p1)))
-            (dy (- (geo-point-y p2) (geo-point-y p1)))
-            (nx (first n))
-            (ny (first (rest n))))
-          (let
-            ((dot (+ (* dx nx) (* dy ny))))
-            (if (= dot 0) "parallel" "point")))))))
-
-;; ── tests ─────────────────────────────────────────────────────────────────
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  check
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-;; describe
-(check
-  "describe point"
-  (clos-call-generic
-    "geo-describe"
-    (list (geo-make-point 3 4)))
-  "P(3,4)")
-(check
-  "describe line"
-  (clos-call-generic
-    "geo-describe"
-    (list
-      (geo-make-line
-        (geo-make-point 0 0)
-        (geo-make-point 1 1))))
-  "L[P(0,0)-P(1,1)]")
-(check
-  "describe plane"
-  (clos-call-generic
-    "geo-describe"
-    (list (geo-make-plane 0 1 5)))
-  "Plane(d=5)")
-
-;; intersect point×point
-(check
-  "P∩P same"
-  (clos-call-generic
-    "intersect"
-    (list
-      (geo-make-point 2 3)
-      (geo-make-point 2 3)))
-  "point")
-(check
-  "P∩P diff"
-  (clos-call-generic
-    "intersect"
-    (list
-      (geo-make-point 1 2)
-      (geo-make-point 3 4)))
-  "empty")
-
-;; intersect point×line
-(let
-  ((origin (geo-make-point 0 0))
-    (p10 (geo-make-point 10 0))
-    (p55 (geo-make-point 5 5))
-    (l-x
-      (geo-make-line
-        (geo-make-point 0 0)
-        (geo-make-point 10 0))))
-  (begin
-    (check
-      "P∩L on line"
-      (clos-call-generic "intersect" (list p10 l-x))
-      "point")
-    (check
-      "P∩L on x-axis"
-      (clos-call-generic "intersect" (list origin l-x))
-      "point")
-    (check
-      "P∩L off line"
-      (clos-call-generic "intersect" (list p55 l-x))
-      "empty")))
-
-;; intersect line×line
-(let
-  ((horiz (geo-make-line (geo-make-point 0 0) (geo-make-point 10 0)))
-    (vert
-      (geo-make-line
-        (geo-make-point 5 -5)
-        (geo-make-point 5 5)))
-    (horiz2
-      (geo-make-line
-        (geo-make-point 0 3)
-        (geo-make-point 10 3))))
-  (begin
-    (check
-      "L∩L crossing"
-      (clos-call-generic "intersect" (list horiz vert))
-      "point")
-    (check
-      "L∩L parallel"
-      (clos-call-generic "intersect" (list horiz horiz2))
-      "parallel")))
-
-;; intersect line×plane
-(let
-  ((diag (geo-make-line (geo-make-point 0 0) (geo-make-point 1 1)))
-    (vert-plane (geo-make-plane 1 0 5))
-    (diag-plane (geo-make-plane -1 1 0)))
-  (begin
-    (check
-      "L∩Plane cross"
-      (clos-call-generic "intersect" (list diag vert-plane))
-      "point")
-    (check
-      "L∩Plane parallel"
-      (clos-call-generic "intersect" (list diag diag-plane))
-      "parallel")))
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(define geo-passed passed)
-(define geo-failed failed)
-(define geo-failures failures)
--- a/lib/common-lisp/tests/programs/interactive-debugger.sx
+++ b/lib/common-lisp/tests/programs/interactive-debugger.sx
@@ -1,196 +0,0 @@
-;; interactive-debugger.sx — Condition debugger using *debugger-hook*
-;;
-;; Demonstrates the classic CL debugger pattern:
-;;   - *debugger-hook* is invoked when an unhandled error reaches the top level
-;;   - The hook receives the condition and a reference to itself
-;;   - It can offer restarts interactively (here simulated with a policy fn)
-;;
-;; In real CL the debugger reads from the terminal. Here we simulate
-;; the "user input" via a policy function passed in at call time.
-;;
-;; Depends on: lib/common-lisp/runtime.sx already loaded.
-
-;; ── *debugger-hook* global ────────────────────────────────────────────────
-;;
-;; CL: when error is unhandled, invoke *debugger-hook* with (condition hook).
-;; A nil hook means use the system default (which we simulate as re-raise).
-
-(define cl-debugger-hook nil)
-
-;; ── invoke-debugger ────────────────────────────────────────────────────────
-;;
-;; Called when cl-error finds no handler. Tries cl-debugger-hook first;
-;; falls back to a simple error report.
-
-(define
-  cl-invoke-debugger
-  (fn
-    (c)
-    (if
-      (nil? cl-debugger-hook)
-      (error (str "Debugger: " (cl-condition-message c)))
-      (begin
-        (let
-          ((hook cl-debugger-hook))
-          (set! cl-debugger-hook nil)
-          (let
-            ((result (hook c hook)))
-            (set! cl-debugger-hook hook)
-            result))))))
-
-;; ── cl-error/debugger — error that routes through invoke-debugger ─────────
-
-(define
-  cl-error-with-debugger
-  (fn
-    (c &rest args)
-    (let
-      ((obj (cond ((cl-condition? c) c) ((string? c) (cl-make-condition "simple-error" "format-control" c "format-arguments" args)) (:else (cl-make-condition "simple-error" "format-control" (str c))))))
-      (cl-signal-obj obj cl-handler-stack)
-      (cl-invoke-debugger obj))))
-
-;; ── simulated debugger session ────────────────────────────────────────────
-;;
-;; A debugger hook takes (condition hook) and "reads" user commands.
-;; We simulate this with a policy function: (fn (c restarts) restart-name)
-;; that picks a restart given the condition and available restarts.
-
-(define
-  make-policy-debugger
-  (fn
-    (policy)
-    (fn
-      (c hook)
-      (let
-        ((available (cl-compute-restarts)))
-        (let
-          ((choice (policy c available)))
-          (if
-            (and choice (not (nil? (cl-find-restart choice))))
-            (cl-invoke-restart choice)
-            (error
-              (str
-                "Debugger: no restart chosen for: "
-                (cl-condition-message c)))))))))
-
-;; ── tests ─────────────────────────────────────────────────────────────────
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  check
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-(define
-  reset-stacks!
-  (fn
-    ()
-    (set! cl-handler-stack (list))
-    (set! cl-restart-stack (list))
-    (set! cl-debugger-hook nil)))
-
-;; Test 1: debugger hook receives condition
-(reset-stacks!)
-(let
-  ((received-msg ""))
-  (begin
-    (set!
-      cl-debugger-hook
-      (fn (c hook) (set! received-msg (cl-condition-message c)) nil))
-    (cl-restart-case
-      (fn () (cl-error-with-debugger "something broke"))
-      (list "abort" (list) (fn () nil)))
-    (check "debugger hook receives condition" received-msg "something broke")))
-
-;; Test 2: policy-driven restart selection (use-zero)
-(reset-stacks!)
-(let
-  ((result (begin (set! cl-debugger-hook (make-policy-debugger (fn (c restarts) "use-zero"))) (cl-restart-case (fn () (cl-error-with-debugger (cl-make-condition "division-by-zero")) 999) (list "use-zero" (list) (fn () 0))))))
-  (check "policy debugger: use-zero restart" result 0))
-
-;; Test 3: policy selects abort
-(reset-stacks!)
-(let
-  ((result (begin (set! cl-debugger-hook (make-policy-debugger (fn (c restarts) "abort"))) (cl-restart-case (fn () (cl-error-with-debugger "aborting error") 999) (list "abort" (list) (fn () "aborted"))))))
-  (check "policy debugger: abort restart" result "aborted"))
-
-;; Test 4: compute-restarts inside debugger hook
-(reset-stacks!)
-(let
-  ((seen-restarts (list)))
-  (begin
-    (set!
-      cl-debugger-hook
-      (fn
-        (c hook)
-        (set! seen-restarts (cl-compute-restarts))
-        (cl-invoke-restart "continue")))
-    (cl-restart-case
-      (fn () (cl-error-with-debugger "test") 42)
-      (list "continue" (list) (fn () "ok"))
-      (list "abort" (list) (fn () "no")))
-    (check
-      "debugger: compute-restarts visible"
-      (= (len seen-restarts) 2)
-      true)))
-
-;; Test 5: hook not invoked when handler catches first
-(reset-stacks!)
-(let
-  ((hook-called false)
-    (result
-      (begin
-        (set! cl-debugger-hook (fn (c hook) (set! hook-called true) nil))
-        (cl-handler-case
-          (fn () (cl-error-with-debugger "handled"))
-          (list "error" (fn (c) "handler-won"))))))
-  (check "handler wins; hook not called" hook-called false)
-  (check "handler result returned" result "handler-won"))
-
-;; Test 6: debugger-hook nil after re-raise guard
-(reset-stacks!)
-(let
-  ((hook-calls 0))
-  (begin
-    (set!
-      cl-debugger-hook
-      (fn
-        (c hook)
-        (set! hook-calls (+ hook-calls 1))
-        (if
-          (> hook-calls 1)
-          (error "infinite loop guard")
-          (cl-invoke-restart "escape"))))
-    (cl-restart-case
-      (fn () (cl-error-with-debugger "once"))
-      (list "escape" (list) (fn () nil)))
-    (check
-      "hook called exactly once (no infinite recursion)"
-      hook-calls
-      1)))
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(define debugger-passed passed)
-(define debugger-failed failed)
-(define debugger-failures failures)
--- a/lib/common-lisp/tests/programs/mop-trace.sx
+++ b/lib/common-lisp/tests/programs/mop-trace.sx
@@ -1,228 +0,0 @@
-;; mop-trace.sx — :before/:after method tracing with CLOS
-;;
-;; Classic CLOS pattern: instrument generic functions with :before and :after
-;; qualifiers to print call/return traces without modifying the primary method.
-;;
-;; Depends on: lib/common-lisp/runtime.sx, lib/common-lisp/clos.sx
-
-;; ── trace log (mutable accumulator) ───────────────────────────────────────
-
-(define trace-log (list))
-
-(define
-  trace-push
-  (fn (msg) (set! trace-log (append trace-log (list msg)))))
-
-(define trace-clear (fn () (set! trace-log (list))))
-
-;; ── domain classes ─────────────────────────────────────────────────────────
-
-(clos-defclass "shape" (list "t") (list {:initform "white" :initarg ":color" :reader nil :writer nil :accessor nil :name "color"}))
-
-(clos-defclass "circle" (list "shape") (list {:initform 1 :initarg ":radius" :reader nil :writer nil :accessor nil :name "radius"}))
-
-(clos-defclass "rect" (list "shape") (list {:initform 1 :initarg ":width" :reader nil :writer nil :accessor nil :name "width"} {:initform 1 :initarg ":height" :reader nil :writer nil :accessor nil :name "height"}))
-
-;; ── generic function: area ─────────────────────────────────────────────────
-
-(clos-defgeneric "area" {})
-
-;; primary methods
-(clos-defmethod
-  "area"
-  (list)
-  (list "circle")
-  (fn
-    (args next-fn)
-    (let
-      ((c (first args)))
-      (let ((r (clos-slot-value c "radius"))) (* r r)))))
-
-(clos-defmethod
-  "area"
-  (list)
-  (list "rect")
-  (fn
-    (args next-fn)
-    (let
-      ((r (first args)))
-      (* (clos-slot-value r "width") (clos-slot-value r "height")))))
-
-;; :before tracing
-(clos-defmethod
-  "area"
-  (list "before")
-  (list "shape")
-  (fn
-    (args next-fn)
-    (trace-push (str "BEFORE area(" (clos-class-of (first args)) ")"))))
-
-;; :after tracing
-(clos-defmethod
-  "area"
-  (list "after")
-  (list "shape")
-  (fn
-    (args next-fn)
-    (trace-push (str "AFTER area(" (clos-class-of (first args)) ")"))))
-
-;; ── generic function: describe-shape ──────────────────────────────────────
-
-(clos-defgeneric "describe-shape" {})
-
-(clos-defmethod
-  "describe-shape"
-  (list)
-  (list "shape")
-  (fn
-    (args next-fn)
-    (let
-      ((s (first args)))
-      (str "shape[" (clos-slot-value s "color") "]"))))
-
-(clos-defmethod
-  "describe-shape"
-  (list)
-  (list "circle")
-  (fn
-    (args next-fn)
-    (let
-      ((c (first args)))
-      (str
-        "circle[r="
-        (clos-slot-value c "radius")
-        " "
-        (clos-call-next-method next-fn)
-        "]"))))
-
-(clos-defmethod
-  "describe-shape"
-  (list)
-  (list "rect")
-  (fn
-    (args next-fn)
-    (let
-      ((r (first args)))
-      (str
-        "rect["
-        (clos-slot-value r "width")
-        "x"
-        (clos-slot-value r "height")
-        " "
-        (clos-call-next-method next-fn)
-        "]"))))
-
-;; :before on base shape (fires for all subclasses too)
-(clos-defmethod
-  "describe-shape"
-  (list "before")
-  (list "shape")
-  (fn
-    (args next-fn)
-    (trace-push
-      (str "BEFORE describe-shape(" (clos-class-of (first args)) ")"))))
-
-;; ── tests ─────────────────────────────────────────────────────────────────
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  check
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-;; ── area tests ────────────────────────────────────────────────────────────
-
-;; circle area = r*r (no pi — integer arithmetic for predictability)
-(let
-  ((c (clos-make-instance "circle" ":radius" 5 ":color" "red")))
-  (do
-    (trace-clear)
-    (check "circle area" (clos-call-generic "area" (list c)) 25)
-    (check
-      ":before fired for circle"
-      (= (first trace-log) "BEFORE area(circle)")
-      true)
-    (check
-      ":after fired for circle"
-      (= (first (rest trace-log)) "AFTER area(circle)")
-      true)
-    (check "trace length 2" (len trace-log) 2)))
-
-;; rect area = w*h
-(let
-  ((r (clos-make-instance "rect" ":width" 4 ":height" 6 ":color" "blue")))
-  (do
-    (trace-clear)
-    (check "rect area" (clos-call-generic "area" (list r)) 24)
-    (check
-      ":before fired for rect"
-      (= (first trace-log) "BEFORE area(rect)")
-      true)
-    (check
-      ":after fired for rect"
-      (= (first (rest trace-log)) "AFTER area(rect)")
-      true)
-    (check "trace length 2 (rect)" (len trace-log) 2)))
-
-;; ── describe-shape tests ───────────────────────────────────────────────────
-
-(let
-  ((c (clos-make-instance "circle" ":radius" 3 ":color" "green")))
-  (do
-    (trace-clear)
-    (check
-      "circle describe"
-      (clos-call-generic "describe-shape" (list c))
-      "circle[r=3 shape[green]]")
-    (check
-      ":before fired for describe circle"
-      (= (first trace-log) "BEFORE describe-shape(circle)")
-      true)))
-
-(let
-  ((r (clos-make-instance "rect" ":width" 2 ":height" 7 ":color" "black")))
-  (do
-    (trace-clear)
-    (check
-      "rect describe"
-      (clos-call-generic "describe-shape" (list r))
-      "rect[2x7 shape[black]]")
-    (check
-      ":before fired for describe rect"
-      (= (first trace-log) "BEFORE describe-shape(rect)")
-      true)))
-
-;; ── call-next-method: circle -> shape ─────────────────────────────────────
-
-(let
-  ((c (clos-make-instance "circle" ":radius" 1 ":color" "purple")))
-  (check
-    "call-next-method result in describe"
-    (clos-call-generic "describe-shape" (list c))
-    "circle[r=1 shape[purple]]"))
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(define mop-passed passed)
-(define mop-failed failed)
-(define mop-failures failures)
--- a/lib/common-lisp/tests/programs/parse-recover.sx
+++ b/lib/common-lisp/tests/programs/parse-recover.sx
@@ -1,163 +0,0 @@
-;; parse-recover.sx — Parser with skipped-token restart
-;;
-;; Classic CL pattern: a simple token parser that signals a condition
-;; when it encounters an unexpected token. The :skip-token restart
-;; allows the parser to continue past the offending token.
-;;
-;; Depends on: lib/common-lisp/runtime.sx already loaded.
-
-;; ── condition type ─────────────────────────────────────────────────────────
-
-(cl-define-condition "parse-error" (list "error") (list "token" "position"))
-
-;; ── simple token parser ────────────────────────────────────────────────────
-;;
-;; parse-numbers: given a list of tokens (strings), parse integers.
-;; Non-integer tokens signal parse-error with two restarts:
-;;   skip-token   — skip the bad token and continue
-;;   use-zero     — use 0 in place of the bad token
-
-(define
-  parse-numbers
-  (fn
-    (tokens)
-    (define result (list))
-    (define
-      process
-      (fn
-        (toks)
-        (if
-          (empty? toks)
-          result
-          (let
-            ((tok (first toks)) (rest-toks (rest toks)))
-            (let
-              ((n (string->number tok 10)))
-              (if
-                n
-                (begin
-                  (set! result (append result (list n)))
-                  (process rest-toks))
-                (cl-restart-case
-                  (fn
-                    ()
-                    (cl-signal
-                      (cl-make-condition
-                        "parse-error"
-                        "token"
-                        tok
-                        "position"
-                        (len result)))
-                    (set! result (append result (list 0)))
-                    (process rest-toks))
-                  (list "skip-token" (list) (fn () (process rest-toks)))
-                  (list
-                    "use-zero"
-                    (list)
-                    (fn
-                      ()
-                      (begin
-                        (set! result (append result (list 0)))
-                        (process rest-toks)))))))))))
-    (process tokens)
-    result))
-
-;; ── tests ─────────────────────────────────────────────────────────────────
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  check
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-(define
-  reset-stacks!
-  (fn () (set! cl-handler-stack (list)) (set! cl-restart-stack (list))))
-
-;; All valid tokens
-(reset-stacks!)
-(check
-  "all valid: 1 2 3"
-  (cl-handler-bind
-    (list (list "parse-error" (fn (c) (cl-invoke-restart "skip-token"))))
-    (fn () (parse-numbers (list "1" "2" "3"))))
-  (list 1 2 3))
-
-;; Skip bad token
-(reset-stacks!)
-(check
-  "skip bad token: 1 x 3 -> (1 3)"
-  (cl-handler-bind
-    (list (list "parse-error" (fn (c) (cl-invoke-restart "skip-token"))))
-    (fn () (parse-numbers (list "1" "x" "3"))))
-  (list 1 3))
-
-;; Use zero for bad token
-(reset-stacks!)
-(check
-  "use-zero for bad: 1 x 3 -> (1 0 3)"
-  (cl-handler-bind
-    (list (list "parse-error" (fn (c) (cl-invoke-restart "use-zero"))))
-    (fn () (parse-numbers (list "1" "x" "3"))))
-  (list 1 0 3))
-
-;; Multiple bad tokens, all skipped
-(reset-stacks!)
-(check
-  "skip multiple bad: a 2 b 4 -> (2 4)"
-  (cl-handler-bind
-    (list (list "parse-error" (fn (c) (cl-invoke-restart "skip-token"))))
-    (fn () (parse-numbers (list "a" "2" "b" "4"))))
-  (list 2 4))
-
-;; handler-case: abort on first bad token
-(reset-stacks!)
-(check
-  "handler-case: abort on first bad"
-  (cl-handler-case
-    (fn () (parse-numbers (list "1" "bad" "3")))
-    (list
-      "parse-error"
-      (fn
-        (c)
-        (str
-          "parse error at position "
-          (cl-condition-slot c "position")
-          ": "
-          (cl-condition-slot c "token")))))
-  "parse error at position 1: bad")
-
-;; Verify condition type hierarchy
-(reset-stacks!)
-(check
-  "parse-error isa error"
-  (cl-condition-of-type?
-    (cl-make-condition "parse-error" "token" "x" "position" 0)
-    "error")
-  true)
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(define parse-passed passed)
-(define parse-failed failed)
-(define parse-failures failures)
--- a/lib/common-lisp/tests/programs/restart-demo.sx
+++ b/lib/common-lisp/tests/programs/restart-demo.sx
@@ -1,141 +0,0 @@
-;; restart-demo.sx — Classic CL condition system demo
-;;
-;; Demonstrates resumable exceptions via restarts.
-;; The `safe-divide` function signals a division-by-zero condition
-;; and offers two restarts:
-;;   :use-zero  — return 0 as the result
-;;   :retry     — call safe-divide again with a corrected divisor
-;;
-;; Depends on: lib/common-lisp/runtime.sx already loaded.
-
-;; ── safe-divide ────────────────────────────────────────────────────────────
-;;
-;; Divides numerator by denominator.
-;; When denominator is 0, signals division-by-zero with two restarts.
-
-(define
-  safe-divide
-  (fn
-    (n d)
-    (if
-      (= d 0)
-      (cl-restart-case
-        (fn
-          ()
-          (cl-signal
-            (cl-make-condition
-              "division-by-zero"
-              "operation"
-              "/"
-              "operands"
-              (list n d)))
-          (error "division by zero — no restart invoked"))
-        (list "use-zero" (list) (fn () 0))
-        (list "retry" (list "d") (fn (d2) (safe-divide n d2))))
-      (/ n d))))
-
-;; ── tests ─────────────────────────────────────────────────────────────────
-
-(define passed 0)
-(define failed 0)
-(define failures (list))
-
-(define
-  check
-  (fn
-    (label got expected)
-    (if
-      (= got expected)
-      (set! passed (+ passed 1))
-      (begin
-        (set! failed (+ failed 1))
-        (set!
-          failures
-          (append
-            failures
-            (list
-              (str
-                "FAIL ["
-                label
-                "]: got="
-                (inspect got)
-                " expected="
-                (inspect expected)))))))))
-
-(define
-  reset-stacks!
-  (fn () (set! cl-handler-stack (list)) (set! cl-restart-stack (list))))
-
-;; Normal division
-(reset-stacks!)
-(check "10 / 2 = 5" (safe-divide 10 2) 5)
-
-;; Invoke use-zero restart
-(reset-stacks!)
-(check
-  "10 / 0 -> use-zero"
-  (cl-handler-bind
-    (list
-      (list "division-by-zero" (fn (c) (cl-invoke-restart "use-zero"))))
-    (fn () (safe-divide 10 0)))
-  0)
-
-;; Invoke retry restart with a corrected denominator
-(reset-stacks!)
-(check
-  "10 / 0 -> retry with 2"
-  (cl-handler-bind
-    (list
-      (list
-        "division-by-zero"
-        (fn (c) (cl-invoke-restart "retry" 2))))
-    (fn () (safe-divide 10 0)))
-  5)
-
-;; Nested calls: outer handles the inner divide-by-zero
-(reset-stacks!)
-(check
-  "nested: 20 / (0->4) = 5"
-  (cl-handler-bind
-    (list
-      (list
-        "division-by-zero"
-        (fn (c) (cl-invoke-restart "retry" 4))))
-    (fn () (let ((r1 (safe-divide 20 0))) r1)))
-  5)
-
-;; handler-case — unwinding version
-(reset-stacks!)
-(check
-  "handler-case: catches division-by-zero"
-  (cl-handler-case
-    (fn () (safe-divide 9 0))
-    (list "division-by-zero" (fn (c) "caught!")))
-  "caught!")
-
-;; Verify use-zero is idempotent (two uses)
-(reset-stacks!)
-(check
-  "two use-zero invocations"
-  (cl-handler-bind
-    (list
-      (list "division-by-zero" (fn (c) (cl-invoke-restart "use-zero"))))
-    (fn
-      ()
-      (+
-        (safe-divide 10 0)
-        (safe-divide 3 0))))
-  0)
-
-;; No restart needed for normal division
-(reset-stacks!)
-(check
-  "no restart needed for 8/4"
-  (safe-divide 8 4)
-  2)
-
-;; ── summary ────────────────────────────────────────────────────────────────
-
-(define demo-passed passed)
-(define demo-failed failed)
-(define demo-failures failures)
--- a/lib/common-lisp/tests/read.sx
+++ b/lib/common-lisp/tests/read.sx
@@ -1,180 +0,0 @@
-;; Common Lisp tokenizer tests
-
-(define cl-test-pass 0)
-(define cl-test-fail 0)
-(define cl-test-fails (list))
-
-(define
-  cl-test
-  (fn
-    (name actual expected)
-    (if
-      (= actual expected)
-      (set! cl-test-pass (+ cl-test-pass 1))
-      (do
-        (set! cl-test-fail (+ cl-test-fail 1))
-        (append! cl-test-fails {:name name :expected expected :actual actual})))))
-
-;; Helpers: extract types and values from token stream (drops eof)
-(define
-  cl-tok-types
-  (fn
-    (src)
-    (map
-      (fn (t) (get t "type"))
-      (filter (fn (t) (not (= (get t "type") "eof"))) (cl-tokenize src)))))
-
-(define
-  cl-tok-values
-  (fn
-    (src)
-    (map
-      (fn (t) (get t "value"))
-      (filter (fn (t) (not (= (get t "type") "eof"))) (cl-tokenize src)))))
-
-(define
-  cl-tok-first
-  (fn (src) (nth (cl-tokenize src) 0)))
-
-;; ── symbols ───────────────────────────────────────────────────────
-
-(cl-test "symbol: bare lowercase" (cl-tok-values "foo") (list "FOO"))
-(cl-test "symbol: uppercase" (cl-tok-values "BAR") (list "BAR"))
-(cl-test "symbol: mixed case folded" (cl-tok-values "FooBar") (list "FOOBAR"))
-(cl-test "symbol: with hyphen" (cl-tok-values "foo-bar") (list "FOO-BAR"))
-(cl-test "symbol: with star" (cl-tok-values "*special*") (list "*SPECIAL*"))
-(cl-test "symbol: with question" (cl-tok-values "null?") (list "NULL?"))
-(cl-test "symbol: with exclamation" (cl-tok-values "set!") (list "SET!"))
-(cl-test "symbol: plus sign alone" (cl-tok-values "+") (list "+"))
-(cl-test "symbol: minus sign alone" (cl-tok-values "-") (list "-"))
-(cl-test "symbol: type is symbol" (cl-tok-types "foo") (list "symbol"))
-
-;; ── package-qualified symbols ─────────────────────────────────────
-
-(cl-test "symbol: pkg:sym external" (cl-tok-values "cl:car") (list "CL:CAR"))
-(cl-test "symbol: pkg::sym internal" (cl-tok-values "pkg::foo") (list "PKG::FOO"))
-(cl-test "symbol: cl:car type" (cl-tok-types "cl:car") (list "symbol"))
-
-;; ── keywords ──────────────────────────────────────────────────────
-
-(cl-test "keyword: basic" (cl-tok-values ":foo") (list "FOO"))
-(cl-test "keyword: type" (cl-tok-types ":foo") (list "keyword"))
-(cl-test "keyword: upcase" (cl-tok-values ":hello-world") (list "HELLO-WORLD"))
-(cl-test "keyword: multiple" (cl-tok-types ":a :b :c") (list "keyword" "keyword" "keyword"))
-
-;; ── integers ──────────────────────────────────────────────────────
-
-(cl-test "integer: zero" (cl-tok-values "0") (list "0"))
-(cl-test "integer: positive" (cl-tok-values "42") (list "42"))
-(cl-test "integer: negative" (cl-tok-values "-5") (list "-5"))
-(cl-test "integer: positive-sign" (cl-tok-values "+3") (list "+3"))
-(cl-test "integer: type" (cl-tok-types "42") (list "integer"))
-(cl-test "integer: multi-digit" (cl-tok-values "12345678") (list "12345678"))
-
-;; ── hex, binary, octal ───────────────────────────────────────────
-
-(cl-test "hex: lowercase x" (cl-tok-values "#xFF") (list "#xFF"))
-(cl-test "hex: uppercase X" (cl-tok-values "#XFF") (list "#XFF"))
-(cl-test "hex: type" (cl-tok-types "#xFF") (list "integer"))
-(cl-test "hex: zero" (cl-tok-values "#x0") (list "#x0"))
-(cl-test "binary: #b" (cl-tok-values "#b1010") (list "#b1010"))
-(cl-test "binary: type" (cl-tok-types "#b1010") (list "integer"))
-(cl-test "octal: #o" (cl-tok-values "#o17") (list "#o17"))
-(cl-test "octal: type" (cl-tok-types "#o17") (list "integer"))
-
-;; ── floats ────────────────────────────────────────────────────────
-
-(cl-test "float: basic" (cl-tok-values "3.14") (list "3.14"))
-(cl-test "float: type" (cl-tok-types "3.14") (list "float"))
-(cl-test "float: negative" (cl-tok-values "-2.5") (list "-2.5"))
-(cl-test "float: exponent" (cl-tok-values "1.0e10") (list "1.0e10"))
-(cl-test "float: neg exponent" (cl-tok-values "1.5e-3") (list "1.5e-3"))
-(cl-test "float: leading dot" (cl-tok-values ".5") (list "0.5"))
-(cl-test "float: exp only" (cl-tok-values "1e5") (list "1e5"))
-
-;; ── ratios ────────────────────────────────────────────────────────
-
-(cl-test "ratio: 1/3" (cl-tok-values "1/3") (list "1/3"))
-(cl-test "ratio: type" (cl-tok-types "1/3") (list "ratio"))
-(cl-test "ratio: 22/7" (cl-tok-values "22/7") (list "22/7"))
-(cl-test "ratio: negative" (cl-tok-values "-1/2") (list "-1/2"))
-
-;; ── strings ───────────────────────────────────────────────────────
-
-(cl-test "string: empty" (cl-tok-values "\"\"") (list ""))
-(cl-test "string: basic" (cl-tok-values "\"hello\"") (list "hello"))
-(cl-test "string: type" (cl-tok-types "\"hello\"") (list "string"))
-(cl-test "string: with space" (cl-tok-values "\"hello world\"") (list "hello world"))
-(cl-test "string: escaped quote" (cl-tok-values "\"say \\\"hi\\\"\"") (list "say \"hi\""))
-(cl-test "string: escaped backslash" (cl-tok-values "\"a\\\\b\"") (list "a\\b"))
-(cl-test "string: newline escape" (cl-tok-values "\"a\\nb\"") (list "a\nb"))
-(cl-test "string: tab escape" (cl-tok-values "\"a\\tb\"") (list "a\tb"))
-
-;; ── characters ────────────────────────────────────────────────────
-
-(cl-test "char: lowercase a" (cl-tok-values "#\\a") (list "a"))
-(cl-test "char: uppercase A" (cl-tok-values "#\\A") (list "A"))
-(cl-test "char: digit" (cl-tok-values "#\\1") (list "1"))
-(cl-test "char: type" (cl-tok-types "#\\a") (list "char"))
-(cl-test "char: Space" (cl-tok-values "#\\Space") (list " "))
-(cl-test "char: Newline" (cl-tok-values "#\\Newline") (list "\n"))
-(cl-test "char: Tab" (cl-tok-values "#\\Tab") (list "\t"))
-(cl-test "char: Return" (cl-tok-values "#\\Return") (list "\r"))
-
-;; ── reader macros ─────────────────────────────────────────────────
-
-(cl-test "quote: type" (cl-tok-types "'x") (list "quote" "symbol"))
-(cl-test "backquote: type" (cl-tok-types "`x") (list "backquote" "symbol"))
-(cl-test "comma: type" (cl-tok-types ",x") (list "comma" "symbol"))
-(cl-test "comma-at: type" (cl-tok-types ",@x") (list "comma-at" "symbol"))
-(cl-test "hash-quote: type" (cl-tok-types "#'foo") (list "hash-quote" "symbol"))
-(cl-test "hash-paren: type" (cl-tok-types "#(1 2)") (list "hash-paren" "integer" "integer" "rparen"))
-
-;; ── uninterned ────────────────────────────────────────────────────
-
-(cl-test "uninterned: type" (cl-tok-types "#:foo") (list "uninterned"))
-(cl-test "uninterned: value upcase" (cl-tok-values "#:foo") (list "FOO"))
-(cl-test "uninterned: compound" (cl-tok-values "#:my-sym") (list "MY-SYM"))
-
-;; ── parens and structure ──────────────────────────────────────────
-
-(cl-test "paren: empty list" (cl-tok-types "()") (list "lparen" "rparen"))
-(cl-test "paren: nested" (cl-tok-types "((a))") (list "lparen" "lparen" "symbol" "rparen" "rparen"))
-(cl-test "dot: standalone" (cl-tok-types "(a . b)") (list "lparen" "symbol" "dot" "symbol" "rparen"))
-
-;; ── comments ──────────────────────────────────────────────────────
-
-(cl-test "comment: line" (cl-tok-types "; comment\nfoo") (list "symbol"))
-(cl-test "comment: inline" (cl-tok-values "foo ; bar\nbaz") (list "FOO" "BAZ"))
-(cl-test "block-comment: basic" (cl-tok-types "#| hello |# foo") (list "symbol"))
-(cl-test "block-comment: nested" (cl-tok-types "#| a #| b |# c |# x") (list "symbol"))
-
-;; ── combined ──────────────────────────────────────────────────────
-
-(cl-test
-  "combined: defun skeleton"
-  (cl-tok-types "(defun foo (x) x)")
-  (list "lparen" "symbol" "symbol" "lparen" "symbol" "rparen" "symbol" "rparen"))
-
-(cl-test
-  "combined: let form"
-  (cl-tok-types "(let ((x 1)) x)")
-  (list
-    "lparen"
-    "symbol"
-    "lparen"
-    "lparen"
-    "symbol"
-    "integer"
-    "rparen"
-    "rparen"
-    "symbol"
-    "rparen"))
-
-(cl-test
-  "combined: whitespace skip"
-  (cl-tok-values "  foo   bar   baz  ")
-  (list "FOO" "BAR" "BAZ"))
-
-(cl-test "eof: present" (get (nth (cl-tokenize "") 0) "type") "eof")
-(cl-test "eof: at end of tokens" (get (nth (cl-tokenize "x") 1) "type") "eof")
--- a/lib/erlang/bench_ring.sh
+++ b/lib/erlang/bench_ring.sh
@@ -1,86 +0,0 @@
-#!/usr/bin/env bash
-# Erlang-on-SX ring benchmark.
-#
-# Spawns N processes in a ring, passes a token N hops (one full round),
-# and reports wall-clock time + throughput. Aspirational target from
-# the plan is 1M processes; current sync-scheduler architecture caps out
-# orders of magnitude lower — this script measures honestly across a
-# range of N so the result/scaling is recorded.
-#
-# Usage:
-#   bash lib/erlang/bench_ring.sh                # default ladder
-#   bash lib/erlang/bench_ring.sh 100 1000 5000  # custom Ns
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found." >&2
-  exit 1
-fi
-
-if [ "$#" -gt 0 ]; then
-  NS=("$@")
-else
-  NS=(10 100 500 1000)
-fi
-
-TMPFILE=$(mktemp)
-trap "rm -f $TMPFILE" EXIT
-
-# One-line Erlang program. Replaces __N__ with the size for each run.
-PROGRAM='Me = self(), N = __N__, Spawner = fun () -> receive {setup, Next} -> Loop = fun () -> receive {token, 0, Parent} -> Parent ! done; {token, K, Parent} -> Next ! {token, K-1, Parent}, Loop() end end, Loop() end end, BuildRing = fun (K, Acc) -> if K =:= 0 -> Acc; true -> BuildRing(K-1, [spawn(Spawner) | Acc]) end end, Pids = BuildRing(N, []), Wire = fun (Ps) -> case Ps of [P, Q | _] -> P ! {setup, Q}, Wire(tl(Ps)); [Last] -> Last ! {setup, hd(Pids)} end end, Wire(Pids), hd(Pids) ! {token, N, Me}, receive done -> done end'
-
-run_n() {
-  local n="$1"
-  local prog="${PROGRAM//__N__/$n}"
-  cat > "$TMPFILE" <<EPOCHS
-(epoch 1)
-(load "lib/erlang/tokenizer.sx")
-(load "lib/erlang/parser.sx")
-(load "lib/erlang/parser-core.sx")
-(load "lib/erlang/parser-expr.sx")
-(load "lib/erlang/parser-module.sx")
-(load "lib/erlang/transpile.sx")
-(load "lib/erlang/runtime.sx")
-(epoch 2)
-(eval "(erlang-eval-ast \"${prog//\"/\\\"}\")")
-EPOCHS
-
-  local start_s start_ns end_s end_ns elapsed_ms
-  start_s=$(date +%s)
-  start_ns=$(date +%N)
-  out=$(timeout 300 "$SX_SERVER" < "$TMPFILE" 2>&1)
-  end_s=$(date +%s)
-  end_ns=$(date +%N)
-
-  local ok="false"
-  if echo "$out" | grep -q ':name "done"'; then ok="true"; fi
-
-  # ms = (end_s - start_s)*1000 + (end_ns - start_ns)/1e6
-  elapsed_ms=$(awk -v s1="$start_s" -v n1="$start_ns" -v s2="$end_s" -v n2="$end_ns" \
-    'BEGIN { printf "%d", (s2 - s1) * 1000 + (n2 - n1) / 1000000 }')
-
-  if [ "$ok" = "true" ]; then
-    local hops_per_s
-    hops_per_s=$(awk -v n="$n" -v ms="$elapsed_ms" \
-      'BEGIN { if (ms == 0) ms = 1; printf "%.0f", n * 1000 / ms }')
-    printf "  N=%-8s  hops=%-8s  %sms  (%s hops/s)\n" "$n" "$n" "$elapsed_ms" "$hops_per_s"
-  else
-    printf "  N=%-8s  FAILED  %sms\n" "$n" "$elapsed_ms"
-  fi
-}
-
-echo "Ring benchmark — sx_server.exe (synchronous scheduler)"
-echo
-for n in "${NS[@]}"; do
-  run_n "$n"
-done
-echo
-echo "Note: 1M-process target from the plan is aspirational; the synchronous"
-echo "scheduler with shift-based suspension and dict-based env copies is not"
-echo "engineered for that scale. Numbers above are honest baselines."
--- a/lib/erlang/bench_ring_results.md
+++ b/lib/erlang/bench_ring_results.md
@@ -1,35 +0,0 @@
-# Ring Benchmark Results
-
-Generated by `lib/erlang/bench_ring.sh` against `sx_server.exe` on the
-synchronous Erlang-on-SX scheduler.
-
-| N (processes) | Hops | Wall-clock | Throughput |
-|---|---|---|---|
-| 10 | 10 | 907ms | 11 hops/s |
-| 50 | 50 | 2107ms | 24 hops/s |
-| 100 | 100 | 3827ms | 26 hops/s |
-| 500 | 500 | 17004ms | 29 hops/s |
-| 1000 | 1000 | 29832ms | 34 hops/s |
-
-(Each `Nm` row spawns N processes connected in a ring and passes a
-single token N hops total — i.e. the token completes one full lap.)
-
-## Status of the 1M-process target
-
-Phase 3's stretch goal in `plans/erlang-on-sx.md` is a million-process
-ring benchmark. **That target is not met** in the current synchronous
-scheduler; extrapolating from the table above, 1M hops would take
-~30 000 s. Correctness is fine — the program runs at every measured
-size — but throughput is bound by per-hop overhead.
-
-Per-hop cost is dominated by:
- `er-env-copy` per fun clause attempt (whole-dict copy each time)
- `call/cc` capture + `raise`/`guard` unwind on every `receive`
- `er-q-delete-at!` rebuilds the mailbox backing list on every match
- `dict-set!`/`dict-has?` lookups in the global processes table
-
-To reach 1M-process throughput in this architecture would need at
-least: persistent (path-copying) envs, an inline scheduler that
-doesn't call/cc on the common path (msg-already-in-mailbox), and a
-linked-list mailbox. None of those are in scope for the Phase 3
-checkbox — captured here as the floor we're starting from.
--- a/lib/erlang/conformance.sh
+++ b/lib/erlang/conformance.sh
@@ -1,153 +0,0 @@
-#!/usr/bin/env bash
-# Erlang-on-SX conformance runner.
-#
-# Loads every erlang test suite via the epoch protocol, collects
-# pass/fail counts, and writes lib/erlang/scoreboard.json + .md.
-#
-# Usage:
-#   bash lib/erlang/conformance.sh           # run all suites
-#   bash lib/erlang/conformance.sh -v        # verbose per-suite
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found." >&2
-  exit 1
-fi
-
-VERBOSE="${1:-}"
-TMPFILE=$(mktemp)
-OUTFILE=$(mktemp)
-trap "rm -f $TMPFILE $OUTFILE" EXIT
-
-# Each suite: name | counter pass | counter total
-SUITES=(
-  "tokenize|er-test-pass|er-test-count"
-  "parse|er-parse-test-pass|er-parse-test-count"
-  "eval|er-eval-test-pass|er-eval-test-count"
-  "runtime|er-rt-test-pass|er-rt-test-count"
-  "ring|er-ring-test-pass|er-ring-test-count"
-  "ping-pong|er-pp-test-pass|er-pp-test-count"
-  "bank|er-bank-test-pass|er-bank-test-count"
-  "echo|er-echo-test-pass|er-echo-test-count"
-  "fib|er-fib-test-pass|er-fib-test-count"
-)
-
-cat > "$TMPFILE" << 'EPOCHS'
-(epoch 1)
-(load "lib/erlang/tokenizer.sx")
-(load "lib/erlang/parser.sx")
-(load "lib/erlang/parser-core.sx")
-(load "lib/erlang/parser-expr.sx")
-(load "lib/erlang/parser-module.sx")
-(load "lib/erlang/transpile.sx")
-(load "lib/erlang/runtime.sx")
-(load "lib/erlang/tests/tokenize.sx")
-(load "lib/erlang/tests/parse.sx")
-(load "lib/erlang/tests/eval.sx")
-(load "lib/erlang/tests/runtime.sx")
-(load "lib/erlang/tests/programs/ring.sx")
-(load "lib/erlang/tests/programs/ping_pong.sx")
-(load "lib/erlang/tests/programs/bank.sx")
-(load "lib/erlang/tests/programs/echo.sx")
-(load "lib/erlang/tests/programs/fib_server.sx")
-(epoch 100)
-(eval "(list er-test-pass er-test-count)")
-(epoch 101)
-(eval "(list er-parse-test-pass er-parse-test-count)")
-(epoch 102)
-(eval "(list er-eval-test-pass er-eval-test-count)")
-(epoch 103)
-(eval "(list er-rt-test-pass er-rt-test-count)")
-(epoch 104)
-(eval "(list er-ring-test-pass er-ring-test-count)")
-(epoch 105)
-(eval "(list er-pp-test-pass er-pp-test-count)")
-(epoch 106)
-(eval "(list er-bank-test-pass er-bank-test-count)")
-(epoch 107)
-(eval "(list er-echo-test-pass er-echo-test-count)")
-(epoch 108)
-(eval "(list er-fib-test-pass er-fib-test-count)")
-EPOCHS
-
-timeout 120 "$SX_SERVER" < "$TMPFILE" > "$OUTFILE" 2>&1
-
-# Parse "(N M)" from the line after each "(ok-len <epoch> ...)" marker.
-parse_pair() {
-  local epoch="$1"
-  local line
-  line=$(grep -A1 "^(ok-len $epoch " "$OUTFILE" | tail -1)
-  echo "$line" | sed -E 's/[()]//g'
-}
-
-TOTAL_PASS=0
-TOTAL_COUNT=0
-JSON_SUITES=""
-MD_ROWS=""
-
-idx=0
-for entry in "${SUITES[@]}"; do
-  name="${entry%%|*}"
-  epoch=$((100 + idx))
-  pair=$(parse_pair "$epoch")
-  pass=$(echo "$pair" | awk '{print $1}')
-  count=$(echo "$pair" | awk '{print $2}')
-  if [ -z "$pass" ] || [ -z "$count" ]; then
-    pass=0
-    count=0
-  fi
-  TOTAL_PASS=$((TOTAL_PASS + pass))
-  TOTAL_COUNT=$((TOTAL_COUNT + count))
-  status="ok"
-  marker="✅"
-  if [ "$pass" != "$count" ]; then
-    status="fail"
-    marker="❌"
-  fi
-  if [ "$VERBOSE" = "-v" ]; then
-    printf "  %-12s %s/%s\n" "$name" "$pass" "$count"
-  fi
-  if [ -n "$JSON_SUITES" ]; then JSON_SUITES+=","; fi
-  JSON_SUITES+=$'\n    '
-  JSON_SUITES+="{\"name\":\"$name\",\"pass\":$pass,\"total\":$count,\"status\":\"$status\"}"
-  MD_ROWS+="| $marker | $name | $pass | $count |"$'\n'
-  idx=$((idx + 1))
-done
-
-printf '\nErlang-on-SX conformance: %d / %d\n' "$TOTAL_PASS" "$TOTAL_COUNT"
-
-# scoreboard.json
-cat > lib/erlang/scoreboard.json <<JSON
-{
-  "language": "erlang",
-  "total_pass": $TOTAL_PASS,
-  "total": $TOTAL_COUNT,
-  "suites": [$JSON_SUITES
-  ]
-}
-JSON
-
-# scoreboard.md
-cat > lib/erlang/scoreboard.md <<MD
-# Erlang-on-SX Scoreboard
-
-**Total: ${TOTAL_PASS} / ${TOTAL_COUNT} tests passing**
-
-|  | Suite | Pass | Total |
-|---|---|---|---|
-$MD_ROWS
-
-Generated by \`lib/erlang/conformance.sh\`.
-MD
-
-if [ "$TOTAL_PASS" -eq "$TOTAL_COUNT" ]; then
-  exit 0
-else
-  exit 1
-fi
--- a/lib/erlang/parser-expr.sx
+++ b/lib/erlang/parser-expr.sx
@@ -237,8 +237,6 @@
        (er-parse-fun-expr st)
        (er-is? st "keyword" "try")
        (er-parse-try st)
-        (er-is? st "punct" "<<")
-        (er-parse-binary st)
        :else (error
          (str
            "Erlang parse: unexpected "
@@ -283,56 +281,12 @@
  (fn
    (st)
    (er-expect! st "punct" "[")
-    (cond
+    (if
      (er-is? st "punct" "]")
      (do (er-advance! st) {:type "nil"})
-      :else (let
-        ((first (er-parse-expr-prec st 0)))
-        (cond
-          (er-is? st "punct" "||") (er-parse-list-comp st first)
-          :else (er-parse-list-tail st (list first)))))))
-
-(define
-  er-parse-list-comp
-  (fn
-    (st head)
-    (er-advance! st)
-    (let
-      ((quals (list (er-parse-lc-qualifier st))))
-      (er-parse-list-comp-tail st head quals))))
-
-(define
-  er-parse-list-comp-tail
-  (fn
-    (st head quals)
-    (cond
-      (er-is? st "punct" ",")
-      (do
-        (er-advance! st)
-        (append! quals (er-parse-lc-qualifier st))
-        (er-parse-list-comp-tail st head quals))
-      (er-is? st "punct" "]")
-      (do (er-advance! st) {:head head :qualifiers quals :type "lc"})
-      :else (error
-        (str
-          "Erlang parse: expected ',' or ']' in list comprehension, got '"
-          (er-cur-value st)
-          "'")))))
-
-(define
-  er-parse-lc-qualifier
-  (fn
-    (st)
-    (let
-      ((e (er-parse-expr-prec st 0)))
-      (cond
-        (er-is? st "punct" "<-")
-        (do
-          (er-advance! st)
-          (let
-            ((source (er-parse-expr-prec st 0)))
-            {:kind "gen" :pattern e :source source}))
-        :else {:kind "filter" :expr e}))))
+      (let
+        ((elems (list (er-parse-expr-prec st 0))))
+        (er-parse-list-tail st elems)))))

 (define
  er-parse-list-tail
@@ -578,63 +532,3 @@
          ((guards (if (er-is? st "keyword" "when") (do (er-advance! st) (er-parse-guards st)) (list))))
          (er-expect! st "punct" "->")
          (let ((body (er-parse-body st))) {:pattern pat :body body :class klass :guards guards}))))))
-
-;; ── binary literals / patterns ────────────────────────────────
-;; `<< [Seg {, Seg}] >>` where Seg = Value [: Size] [/ Spec]. Size is
-;; a literal integer (multiple of 8 supported); Spec is `integer`
-;; (default) or `binary` (rest-of-binary tail). Sufficient for the
-;; common `<<A:8, B:16, Rest/binary>>` patterns.
-(define
-  er-parse-binary
-  (fn
-    (st)
-    (er-expect! st "punct" "<<")
-    (cond
-      (er-is? st "punct" ">>")
-      (do (er-advance! st) {:segments (list) :type "binary"})
-      :else (let
-        ((segs (list (er-parse-binary-segment st))))
-        (er-parse-binary-tail st segs)))))
-
-(define
-  er-parse-binary-tail
-  (fn
-    (st segs)
-    (cond
-      (er-is? st "punct" ",")
-      (do
-        (er-advance! st)
-        (append! segs (er-parse-binary-segment st))
-        (er-parse-binary-tail st segs))
-      (er-is? st "punct" ">>")
-      (do (er-advance! st) {:segments segs :type "binary"})
-      :else (error
-        (str
-          "Erlang parse: expected ',' or '>>' in binary, got '"
-          (er-cur-value st)
-          "'")))))
-
-(define
-  er-parse-binary-segment
-  (fn
-    (st)
-    ;; Use `er-parse-primary` for the value so a leading `:` falls
-    ;; through to the segment's size suffix instead of being eaten
-    ;; by `er-parse-postfix-loop` as a `Mod:Fun` remote call.
-    (let
-      ((v (er-parse-primary st)))
-      (let
-        ((size (cond
-                 (er-is? st "punct" ":")
-                 (do (er-advance! st) (er-parse-primary st))
-                 :else nil))
-          (spec (cond
-                  (er-is? st "op" "/")
-                  (do
-                    (er-advance! st)
-                    (let
-                      ((tok (er-cur st)))
-                      (er-advance! st)
-                      (get tok :value)))
-                  :else "integer")))
-        {:size size :spec spec :value v}))))
--- a/lib/erlang/runtime.sx
+++ b/lib/erlang/runtime.sx
--- a/lib/erlang/scoreboard.json
+++ b/lib/erlang/scoreboard.json
@@ -1,16 +0,0 @@
-{
-  "language": "erlang",
-  "total_pass": 530,
-  "total": 530,
-  "suites": [
-    {"name":"tokenize","pass":62,"total":62,"status":"ok"},
-    {"name":"parse","pass":52,"total":52,"status":"ok"},
-    {"name":"eval","pass":346,"total":346,"status":"ok"},
-    {"name":"runtime","pass":39,"total":39,"status":"ok"},
-    {"name":"ring","pass":4,"total":4,"status":"ok"},
-    {"name":"ping-pong","pass":4,"total":4,"status":"ok"},
-    {"name":"bank","pass":8,"total":8,"status":"ok"},
-    {"name":"echo","pass":7,"total":7,"status":"ok"},
-    {"name":"fib","pass":8,"total":8,"status":"ok"}
-  ]
-}
--- a/lib/erlang/scoreboard.md
+++ b/lib/erlang/scoreboard.md
@@ -1,18 +0,0 @@
-# Erlang-on-SX Scoreboard
-
-**Total: 530 / 530 tests passing**
-
-|  | Suite | Pass | Total |
-|---|---|---|---|
-| ✅ | tokenize | 62 | 62 |
-| ✅ | parse | 52 | 52 |
-| ✅ | eval | 346 | 346 |
-| ✅ | runtime | 39 | 39 |
-| ✅ | ring | 4 | 4 |
-| ✅ | ping-pong | 4 | 4 |
-| ✅ | bank | 8 | 8 |
-| ✅ | echo | 7 | 7 |
-| ✅ | fib | 8 | 8 |
-
-
-Generated by `lib/erlang/conformance.sh`.
--- a/lib/erlang/test.sh
+++ b/lib/erlang/test.sh
@@ -1,260 +0,0 @@
-#!/usr/bin/env bash
-# lib/erlang/test.sh — smoke-test the Erlang runtime layer.
-# Uses sx_server.exe epoch protocol.
-#
-# Usage:
-#   bash lib/erlang/test.sh
-#   bash lib/erlang/test.sh -v
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found. Run: cd hosts/ocaml && dune build"
-  exit 1
-fi
-
-VERBOSE="${1:-}"
-PASS=0; FAIL=0; ERRORS=""
-TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT
-
-cat > "$TMPFILE" << 'EPOCHS'
-(epoch 1)
-(load "lib/erlang/runtime.sx")
-
-;; --- Numeric tower ---
-(epoch 10)
-(eval "(er-is-integer? 42)")
-(epoch 11)
-(eval "(er-is-integer? 3.14)")
-(epoch 12)
-(eval "(er-is-float? 3.14)")
-(epoch 13)
-(eval "(er-is-float? 42)")
-(epoch 14)
-(eval "(er-is-number? 42)")
-(epoch 15)
-(eval "(er-is-number? 3.14)")
-(epoch 16)
-(eval "(er-float 5)")
-(epoch 17)
-(eval "(er-trunc 3.9)")
-(epoch 18)
-(eval "(er-round 3.5)")
-(epoch 19)
-(eval "(er-abs -7)")
-(epoch 20)
-(eval "(er-max 3 7)")
-(epoch 21)
-(eval "(er-min 3 7)")
-
-;; --- div + rem ---
-(epoch 30)
-(eval "(er-div 10 3)")
-(epoch 31)
-(eval "(er-div -10 3)")
-(epoch 32)
-(eval "(er-rem 10 3)")
-(epoch 33)
-(eval "(er-rem -10 3)")
-(epoch 34)
-(eval "(er-gcd 12 8)")
-
-;; --- Bitwise ---
-(epoch 40)
-(eval "(er-band 12 10)")
-(epoch 41)
-(eval "(er-bor 12 10)")
-(epoch 42)
-(eval "(er-bxor 12 10)")
-(epoch 43)
-(eval "(er-bnot 0)")
-(epoch 44)
-(eval "(er-bsl 1 4)")
-(epoch 45)
-(eval "(er-bsr 16 2)")
-
-;; --- Sets ---
-(epoch 50)
-(eval "(er-sets-is-set? (er-sets-new))")
-(epoch 51)
-(eval "(let ((s (er-sets-new))) (do (er-sets-add-element s 1) (er-sets-is-element s 1)))")
-(epoch 52)
-(eval "(er-sets-is-element (er-sets-new) 42)")
-(epoch 53)
-(eval "(er-sets-is-element (er-sets-from-list (list 1 2 3)) 2)")
-(epoch 54)
-(eval "(er-sets-size (er-sets-from-list (list 1 2 3)))")
-(epoch 55)
-(eval "(len (er-sets-to-list (er-sets-from-list (list 1 2 3))))")
-
-;; --- Regexp ---
-(epoch 60)
-(eval "(not (= (er-re-run \"hello\" \"ll\") nil))")
-(epoch 61)
-(eval "(= (er-re-run \"hello\" \"xyz\") nil)")
-(epoch 62)
-(eval "(get (er-re-run \"hello\" \"ll\") :match)")
-(epoch 63)
-(eval "(er-re-replace \"hello\" \"l\" \"r\")")
-(epoch 64)
-(eval "(er-re-replace-all \"hello\" \"l\" \"r\")")
-(epoch 65)
-(eval "(er-re-match-groups (er-re-run \"hello world\" \"(\\w+)\\s+(\\w+)\"))")
-(epoch 66)
-(eval "(len (er-re-split \"a,b,c\" \",\"))")
-
-;; --- List BIFs ---
-(epoch 70)
-(eval "(er-hd (list 1 2 3))")
-(epoch 71)
-(eval "(er-tl (list 1 2 3))")
-(epoch 72)
-(eval "(er-length (list 1 2 3))")
-(epoch 73)
-(eval "(er-lists-member 2 (list 1 2 3))")
-(epoch 74)
-(eval "(er-lists-member 9 (list 1 2 3))")
-(epoch 75)
-(eval "(er-lists-reverse (list 1 2 3))")
-(epoch 76)
-(eval "(er-lists-nth 2 (list 10 20 30))")
-(epoch 77)
-(eval "(er-lists-foldl + 0 (list 1 2 3 4 5))")
-(epoch 78)
-(eval "(er-lists-seq 1 5)")
-(epoch 79)
-(eval "(er-lists-flatten (list 1 (list 2 3) (list 4 (list 5))))")
-
-;; --- Type conversions ---
-(epoch 80)
-(eval "(er-integer-to-list 42)")
-(epoch 81)
-(eval "(er-list-to-integer \"42\")")
-(epoch 82)
-(eval "(er-integer-to-list-radix 255 16)")
-(epoch 83)
-(eval "(er-atom-to-list (make-symbol \"hello\"))")
-(epoch 84)
-(eval "(= (type-of (er-list-to-atom \"foo\")) \"symbol\")")
-
-;; --- ok/error tuples ---
-(epoch 90)
-(eval "(er-is-ok? (er-ok 42))")
-(epoch 91)
-(eval "(er-is-error? (er-error \"reason\"))")
-(epoch 92)
-(eval "(er-unwrap (er-ok 42))")
-(epoch 93)
-(eval "(er-is-ok? (er-error \"bad\"))")
-
-EPOCHS
-
-OUTPUT=$(timeout 30 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
-
-check() {
-  local epoch="$1" desc="$2" expected="$3"
-  local actual
-  actual=$(echo "$OUTPUT" | grep -A1 "^(ok-len $epoch " | tail -1 || true)
-  if echo "$actual" | grep -q "^(ok-len"; then actual=""; fi
-  if [ -z "$actual" ]; then
-    actual=$(echo "$OUTPUT" | grep "^(ok $epoch " | head -1 || true)
-  fi
-  if [ -z "$actual" ]; then
-    actual=$(echo "$OUTPUT" | grep "^(error $epoch " | head -1 || true)
-  fi
-  [ -z "$actual" ] && actual="<no output for epoch $epoch>"
-
-  if echo "$actual" | grep -qF -- "$expected"; then
-    PASS=$((PASS+1))
-    [ "$VERBOSE" = "-v" ] && echo "  ok $desc"
-  else
-    FAIL=$((FAIL+1))
-    ERRORS+="  FAIL [$desc] (epoch $epoch) expected: $expected | actual: $actual
-"
-  fi
-}
-
-# Numeric tower
-check 10  "is-integer? 42"        "true"
-check 11  "is-integer? float"     "false"
-check 12  "is-float? 3.14"        "true"
-check 13  "is-float? int"         "false"
-check 14  "is-number? int"        "true"
-check 15  "is-number? float"      "true"
-check 16  "float 5"               "5"
-check 17  "trunc 3.9"             "3"
-check 18  "round 3.5"             "4"
-check 19  "abs -7"                "7"
-check 20  "max 3 7"               "7"
-check 21  "min 3 7"               "3"
-
-# div + rem
-check 30  "div 10 3"              "3"
-check 31  "div -10 3"             "-3"
-check 32  "rem 10 3"              "1"
-check 33  "rem -10 3"             "-1"
-check 34  "gcd 12 8"              "4"
-
-# Bitwise
-check 40  "band 12 10"            "8"
-check 41  "bor 12 10"             "14"
-check 42  "bxor 12 10"            "6"
-check 43  "bnot 0"                "-1"
-check 44  "bsl 1 4"               "16"
-check 45  "bsr 16 2"              "4"
-
-# Sets
-check 50  "sets-new is-set?"      "true"
-check 51  "sets add+member"       "true"
-check 52  "member empty"          "false"
-check 53  "from-list member"      "true"
-check 54  "sets-size"             "3"
-check 55  "sets-to-list len"      "3"
-
-# Regexp
-check 60  "re-run match"          "true"
-check 61  "re-run no match"       "true"
-check 62  "re-run match text"     '"ll"'
-check 63  "re-replace first"      '"herlo"'
-check 64  "re-replace-all"        '"herro"'
-check 65  "re-match-groups"       '"hello"'
-check 66  "re-split count"        "3"
-
-# List BIFs
-check 70  "hd"                    "1"
-check 71  "tl"                    "(2 3)"
-check 72  "length"                "3"
-check 73  "member hit"            "true"
-check 74  "member miss"           "false"
-check 75  "reverse"               "(3 2 1)"
-check 76  "nth 2"                 "20"
-check 77  "foldl sum"             "15"
-check 78  "seq 1..5"              "(1 2 3 4 5)"
-check 79  "flatten"               "(1 2 3 4 5)"
-
-# Type conversions
-check 80  "integer-to-list"       '"42"'
-check 81  "list-to-integer"       "42"
-check 82  "integer-to-list hex"   '"ff"'
-check 83  "atom-to-list"          '"hello"'
-check 84  "list-to-atom"          "true"
-
-# ok/error
-check 90  "ok? ok-tuple"          "true"
-check 91  "error? error-tuple"    "true"
-check 92  "unwrap ok"             "42"
-check 93  "ok? error-tuple"       "false"
-
-TOTAL=$((PASS+FAIL))
-if [ $FAIL -eq 0 ]; then
-  echo "ok $PASS/$TOTAL lib/erlang tests passed"
-else
-  echo "FAIL $PASS/$TOTAL passed, $FAIL failed:"
-  echo "$ERRORS"
-fi
-[ $FAIL -eq 0 ]
--- a/lib/erlang/tests/eval.sx
+++ b/lib/erlang/tests/eval.sx
--- a/lib/erlang/tests/programs/bank.sx
+++ b/lib/erlang/tests/programs/bank.sx
@@ -1,159 +0,0 @@
-;; Bank account server — stateful process, balance threaded through
-;; recursive loop. Handles {deposit, Amt, From}, {withdraw, Amt, From},
-;; {balance, From}, stop. Tests stateful process patterns.
-
-(define er-bank-test-count 0)
-(define er-bank-test-pass 0)
-(define er-bank-test-fails (list))
-
-(define
-  er-bank-test
-  (fn
-    (name actual expected)
-    (set! er-bank-test-count (+ er-bank-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-bank-test-pass (+ er-bank-test-pass 1))
-      (append! er-bank-test-fails {:actual actual :expected expected :name name}))))
-
-(define bank-ev erlang-eval-ast)
-
-;; Server fun shared by all tests — threaded via the program string.
-(define
-  er-bank-server-src
-  "Server = fun (Balance) ->
-     receive
-       {deposit, Amt, From} -> From ! ok, Server(Balance + Amt);
-       {withdraw, Amt, From} ->
-         if Amt > Balance -> From ! insufficient, Server(Balance);
-            true -> From ! ok, Server(Balance - Amt)
-         end;
-       {balance, From} -> From ! Balance, Server(Balance);
-       stop -> ok
-     end
-   end")
-
-;; Open account, deposit, check balance.
-(er-bank-test
-  "deposit 100 -> balance 100"
-  (bank-ev
-    (str
-      er-bank-server-src
-      ", Me = self(),
-       Bank = spawn(fun () -> Server(0) end),
-       Bank ! {deposit, 100, Me},
-       receive ok -> ok end,
-       Bank ! {balance, Me},
-       receive B -> Bank ! stop, B end"))
-  100)
-
-;; Multiple deposits accumulate.
-(er-bank-test
-  "deposits accumulate"
-  (bank-ev
-    (str
-      er-bank-server-src
-      ", Me = self(),
-       Bank = spawn(fun () -> Server(0) end),
-       Bank ! {deposit, 50, Me}, receive ok -> ok end,
-       Bank ! {deposit, 25, Me}, receive ok -> ok end,
-       Bank ! {deposit, 10, Me}, receive ok -> ok end,
-       Bank ! {balance, Me},
-       receive B -> Bank ! stop, B end"))
-  85)
-
-;; Withdraw within balance succeeds; insufficient gets rejected.
-(er-bank-test
-  "withdraw within balance"
-  (bank-ev
-    (str
-      er-bank-server-src
-      ", Me = self(),
-       Bank = spawn(fun () -> Server(100) end),
-       Bank ! {withdraw, 30, Me}, receive ok -> ok end,
-       Bank ! {balance, Me},
-       receive B -> Bank ! stop, B end"))
-  70)
-
-(er-bank-test
-  "withdraw insufficient"
-  (get
-    (bank-ev
-      (str
-        er-bank-server-src
-        ", Me = self(),
-         Bank = spawn(fun () -> Server(20) end),
-         Bank ! {withdraw, 100, Me},
-         receive R -> Bank ! stop, R end"))
-    :name)
-  "insufficient")
-
-;; State preserved across an insufficient withdrawal.
-(er-bank-test
-  "state preserved on rejection"
-  (bank-ev
-    (str
-      er-bank-server-src
-      ", Me = self(),
-       Bank = spawn(fun () -> Server(50) end),
-       Bank ! {withdraw, 1000, Me}, receive _ -> ok end,
-       Bank ! {balance, Me},
-       receive B -> Bank ! stop, B end"))
-  50)
-
-;; Mixed deposits and withdrawals.
-(er-bank-test
-  "mixed transactions"
-  (bank-ev
-    (str
-      er-bank-server-src
-      ", Me = self(),
-       Bank = spawn(fun () -> Server(100) end),
-       Bank ! {deposit, 50, Me}, receive ok -> ok end,
-       Bank ! {withdraw, 30, Me}, receive ok -> ok end,
-       Bank ! {deposit, 10, Me}, receive ok -> ok end,
-       Bank ! {withdraw, 5, Me}, receive ok -> ok end,
-       Bank ! {balance, Me},
-       receive B -> Bank ! stop, B end"))
-  125)
-
-;; Server.stop terminates the bank cleanly — main can verify by
-;; sending stop and then exiting normally.
-(er-bank-test
-  "server stops cleanly"
-  (get
-    (bank-ev
-      (str
-        er-bank-server-src
-        ", Me = self(),
-         Bank = spawn(fun () -> Server(0) end),
-         Bank ! stop,
-         done"))
-    :name)
-  "done")
-
-;; Two clients sharing one bank — interleaved transactions.
-(er-bank-test
-  "two clients share bank"
-  (bank-ev
-    (str
-      er-bank-server-src
-      ", Me = self(),
-       Bank = spawn(fun () -> Server(0) end),
-       Client = fun (Amt) ->
-         spawn(fun () ->
-           Bank ! {deposit, Amt, self()},
-           receive ok -> Me ! deposited end
-         end)
-       end,
-       Client(40),
-       Client(60),
-       receive deposited -> ok end,
-       receive deposited -> ok end,
-       Bank ! {balance, Me},
-       receive B -> Bank ! stop, B end"))
-  100)
-
-(define
-  er-bank-test-summary
-  (str "bank " er-bank-test-pass "/" er-bank-test-count))
--- a/lib/erlang/tests/programs/echo.sx
+++ b/lib/erlang/tests/programs/echo.sx
@@ -1,140 +0,0 @@
-;; Echo server — minimal classic Erlang server. Receives {From, Msg}
-;; and sends Msg back to From, then loops. `stop` ends the server.
-
-(define er-echo-test-count 0)
-(define er-echo-test-pass 0)
-(define er-echo-test-fails (list))
-
-(define
-  er-echo-test
-  (fn
-    (name actual expected)
-    (set! er-echo-test-count (+ er-echo-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-echo-test-pass (+ er-echo-test-pass 1))
-      (append! er-echo-test-fails {:actual actual :expected expected :name name}))))
-
-(define echo-ev erlang-eval-ast)
-
-(define
-  er-echo-server-src
-  "EchoSrv = fun () ->
-     Loop = fun () ->
-       receive
-         {From, Msg} -> From ! Msg, Loop();
-         stop -> ok
-       end
-     end,
-     Loop()
-   end")
-
-;; Single round-trip with an atom.
-(er-echo-test
-  "atom round-trip"
-  (get
-    (echo-ev
-      (str
-        er-echo-server-src
-        ", Me = self(),
-         Echo = spawn(EchoSrv),
-         Echo ! {Me, hello},
-         receive R -> Echo ! stop, R end"))
-    :name)
-  "hello")
-
-;; Number round-trip.
-(er-echo-test
-  "number round-trip"
-  (echo-ev
-    (str
-      er-echo-server-src
-      ", Me = self(),
-       Echo = spawn(EchoSrv),
-       Echo ! {Me, 42},
-       receive R -> Echo ! stop, R end"))
-  42)
-
-;; Tuple round-trip — pattern-match the reply to extract V.
-(er-echo-test
-  "tuple round-trip"
-  (echo-ev
-    (str
-      er-echo-server-src
-      ", Me = self(),
-       Echo = spawn(EchoSrv),
-       Echo ! {Me, {ok, 7}},
-       receive {ok, V} -> Echo ! stop, V end"))
-  7)
-
-;; List round-trip.
-(er-echo-test
-  "list round-trip"
-  (echo-ev
-    (str
-      er-echo-server-src
-      ", Me = self(),
-       Echo = spawn(EchoSrv),
-       Echo ! {Me, [1, 2, 3]},
-       receive [H | _] -> Echo ! stop, H end"))
-  1)
-
-;; Multiple sequential round-trips.
-(er-echo-test
-  "three round-trips"
-  (echo-ev
-    (str
-      er-echo-server-src
-      ", Me = self(),
-       Echo = spawn(EchoSrv),
-       Echo ! {Me, 10}, A = receive Ra -> Ra end,
-       Echo ! {Me, 20}, B = receive Rb -> Rb end,
-       Echo ! {Me, 30}, C = receive Rc -> Rc end,
-       Echo ! stop,
-       A + B + C"))
-  60)
-
-;; Two clients sharing one echo server. Each gets its own reply.
-(er-echo-test
-  "two clients"
-  (get
-    (echo-ev
-      (str
-        er-echo-server-src
-        ", Me = self(),
-         Echo = spawn(EchoSrv),
-         Client = fun (Tag) ->
-           spawn(fun () ->
-             Echo ! {self(), Tag},
-             receive R -> Me ! {got, R} end
-           end)
-         end,
-         Client(a),
-         Client(b),
-         receive {got, _} -> ok end,
-         receive {got, _} -> ok end,
-         Echo ! stop,
-         finished"))
-    :name)
-  "finished")
-
-;; Echo via io trace — verify each message round-trips through.
-(er-echo-test
-  "trace 4 messages"
-  (do
-    (er-io-flush!)
-    (echo-ev
-      (str
-        er-echo-server-src
-        ", Me = self(),
-         Echo = spawn(EchoSrv),
-         Send = fun (V) -> Echo ! {Me, V}, receive R -> io:format(\"~p \", [R]) end end,
-         Send(1), Send(2), Send(3), Send(4),
-         Echo ! stop,
-         done"))
-    (er-io-buffer-content))
-  "1 2 3 4 ")
-
-(define
-  er-echo-test-summary
-  (str "echo " er-echo-test-pass "/" er-echo-test-count))
--- a/lib/erlang/tests/programs/fib_server.sx
+++ b/lib/erlang/tests/programs/fib_server.sx
@@ -1,152 +0,0 @@
-;; Fib server — long-lived process that computes fibonacci numbers on
-;; request. Tests recursive function evaluation inside a server loop.
-
-(define er-fib-test-count 0)
-(define er-fib-test-pass 0)
-(define er-fib-test-fails (list))
-
-(define
-  er-fib-test
-  (fn
-    (name actual expected)
-    (set! er-fib-test-count (+ er-fib-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-fib-test-pass (+ er-fib-test-pass 1))
-      (append! er-fib-test-fails {:actual actual :expected expected :name name}))))
-
-(define fib-ev erlang-eval-ast)
-
-;; Fib + server-loop source. Standalone so each test can chain queries.
-(define
-  er-fib-server-src
-  "Fib = fun (0) -> 0; (1) -> 1; (N) -> Fib(N-1) + Fib(N-2) end,
-   FibSrv = fun () ->
-     Loop = fun () ->
-       receive
-         {fib, N, From} -> From ! Fib(N), Loop();
-         stop -> ok
-       end
-     end,
-     Loop()
-   end")
-
-;; Base cases.
-(er-fib-test
-  "fib(0)"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Srv ! {fib, 0, Me},
-       receive R -> Srv ! stop, R end"))
-  0)
-
-(er-fib-test
-  "fib(1)"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Srv ! {fib, 1, Me},
-       receive R -> Srv ! stop, R end"))
-  1)
-
-;; Larger values.
-(er-fib-test
-  "fib(10) = 55"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Srv ! {fib, 10, Me},
-       receive R -> Srv ! stop, R end"))
-  55)
-
-(er-fib-test
-  "fib(15) = 610"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Srv ! {fib, 15, Me},
-       receive R -> Srv ! stop, R end"))
-  610)
-
-;; Multiple sequential queries to one server. Sum to avoid dict-equality.
-(er-fib-test
-  "sequential fib(5..8) sum"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Srv ! {fib, 5, Me}, A = receive Ra -> Ra end,
-       Srv ! {fib, 6, Me}, B = receive Rb -> Rb end,
-       Srv ! {fib, 7, Me}, C = receive Rc -> Rc end,
-       Srv ! {fib, 8, Me}, D = receive Rd -> Rd end,
-       Srv ! stop,
-       A + B + C + D"))
-  47)
-
-;; Verify Fib obeys the recurrence — fib(n) = fib(n-1) + fib(n-2).
-(er-fib-test
-  "fib recurrence at n=12"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Srv ! {fib, 10, Me}, A = receive Ra -> Ra end,
-       Srv ! {fib, 11, Me}, B = receive Rb -> Rb end,
-       Srv ! {fib, 12, Me}, C = receive Rc -> Rc end,
-       Srv ! stop,
-       C - (A + B)"))
-  0)
-
-;; Two clients each get their own answer; main sums the results.
-(er-fib-test
-  "two clients sum"
-  (fib-ev
-    (str
-      er-fib-server-src
-      ", Me = self(),
-       Srv = spawn(FibSrv),
-       Client = fun (N) ->
-         spawn(fun () ->
-           Srv ! {fib, N, self()},
-           receive R -> Me ! {result, R} end
-         end)
-       end,
-       Client(7),
-       Client(9),
-       {result, A} = receive M1 -> M1 end,
-       {result, B} = receive M2 -> M2 end,
-       Srv ! stop,
-       A + B"))
-  47)
-
-;; Trace queries via io-buffer.
-(er-fib-test
-  "trace fib 0..6"
-  (do
-    (er-io-flush!)
-    (fib-ev
-      (str
-        er-fib-server-src
-        ", Me = self(),
-         Srv = spawn(FibSrv),
-         Ask = fun (N) -> Srv ! {fib, N, Me}, receive R -> io:format(\"~p \", [R]) end end,
-         Ask(0), Ask(1), Ask(2), Ask(3), Ask(4), Ask(5), Ask(6),
-         Srv ! stop,
-         done"))
-    (er-io-buffer-content))
-  "0 1 1 2 3 5 8 ")
-
-(define
-  er-fib-test-summary
-  (str "fib " er-fib-test-pass "/" er-fib-test-count))
--- a/lib/erlang/tests/programs/ping_pong.sx
+++ b/lib/erlang/tests/programs/ping_pong.sx
@@ -1,127 +0,0 @@
-;; Ping-pong program — two processes exchange N messages, then signal
-;; main via separate `ping_done` / `pong_done` notifications.
-
-(define er-pp-test-count 0)
-(define er-pp-test-pass 0)
-(define er-pp-test-fails (list))
-
-(define
-  er-pp-test
-  (fn
-    (name actual expected)
-    (set! er-pp-test-count (+ er-pp-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-pp-test-pass (+ er-pp-test-pass 1))
-      (append! er-pp-test-fails {:actual actual :expected expected :name name}))))
-
-(define pp-ev erlang-eval-ast)
-
-;; Three rounds of ping-pong, then stop. Main receives ping_done and
-;; pong_done in arrival order (Ping finishes first because Pong exits
-;; only after receiving stop).
-(define
-  er-pp-program
-  "Me = self(),
-   Pong = spawn(fun () ->
-     Loop = fun () ->
-       receive
-         {ping, From} -> From ! pong, Loop();
-         stop -> Me ! pong_done
-       end
-     end,
-     Loop()
-   end),
-   Ping = fun (Target, K) ->
-     if K =:= 0 -> Target ! stop, Me ! ping_done;
-        true -> Target ! {ping, self()}, receive pong -> Ping(Target, K - 1) end
-     end
-   end,
-   spawn(fun () -> Ping(Pong, 3) end),
-   receive ping_done -> ok end,
-   receive pong_done -> both_done end")
-
-(er-pp-test
-  "ping-pong 3 rounds"
-  (get (pp-ev er-pp-program) :name)
-  "both_done")
-
-;; Count exchanges via io-buffer — each pong trip prints "p".
-(er-pp-test
-  "ping-pong 5 rounds trace"
-  (do
-    (er-io-flush!)
-    (pp-ev
-      "Me = self(),
-       Pong = spawn(fun () ->
-         Loop = fun () ->
-           receive
-             {ping, From} -> io:format(\"p\"), From ! pong, Loop();
-             stop -> Me ! pong_done
-           end
-         end,
-         Loop()
-       end),
-       Ping = fun (Target, K) ->
-         if K =:= 0 -> Target ! stop, Me ! ping_done;
-            true -> Target ! {ping, self()}, receive pong -> Ping(Target, K - 1) end
-         end
-       end,
-       spawn(fun () -> Ping(Pong, 5) end),
-       receive ping_done -> ok end,
-       receive pong_done -> ok end")
-    (er-io-buffer-content))
-  "ppppp")
-
-;; Main → Pong directly (no Ping process). Main plays the ping role.
-(er-pp-test
-  "main-as-pinger 4 rounds"
-  (pp-ev
-    "Me = self(),
-     Pong = spawn(fun () ->
-       Loop = fun () ->
-         receive
-           {ping, From} -> From ! pong, Loop();
-           stop -> ok
-         end
-       end,
-       Loop()
-     end),
-     Go = fun (K) ->
-       if K =:= 0 -> Pong ! stop, K;
-          true -> Pong ! {ping, Me}, receive pong -> Go(K - 1) end
-       end
-     end,
-     Go(4)")
-  0)
-
-;; Ensure the processes really interleave — inject an id into each
-;; ping and check we get them all back via trace (the order is
-;; deterministic under our sync scheduler).
-(er-pp-test
-  "ids round-trip"
-  (do
-    (er-io-flush!)
-    (pp-ev
-      "Me = self(),
-       Pong = spawn(fun () ->
-         Loop = fun () ->
-           receive
-             {ping, From, Id} -> From ! {pong, Id}, Loop();
-             stop -> ok
-           end
-         end,
-         Loop()
-       end),
-       Go = fun (K) ->
-         if K =:= 0 -> Pong ! stop, done;
-            true -> Pong ! {ping, Me, K}, receive {pong, RId} -> io:format(\"~p \", [RId]), Go(K - 1) end
-         end
-       end,
-       Go(4)")
-    (er-io-buffer-content))
-  "4 3 2 1 ")
-
-(define
-  er-pp-test-summary
-  (str "ping-pong " er-pp-test-pass "/" er-pp-test-count))
--- a/lib/erlang/tests/programs/ring.sx
+++ b/lib/erlang/tests/programs/ring.sx
@@ -1,132 +0,0 @@
-;; Ring program — N processes in a ring, token passes M times.
-;;
-;; Each process waits for {setup, Next} so main can tie the knot
-;; (can't reference a pid before spawning it). Once wired, main
-;; injects the first token; each process forwards decrementing K
-;; until it hits 0, at which point it signals `done` to main.
-
-(define er-ring-test-count 0)
-(define er-ring-test-pass 0)
-(define er-ring-test-fails (list))
-
-(define
-  er-ring-test
-  (fn
-    (name actual expected)
-    (set! er-ring-test-count (+ er-ring-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-ring-test-pass (+ er-ring-test-pass 1))
-      (append! er-ring-test-fails {:actual actual :expected expected :name name}))))
-
-(define ring-ev erlang-eval-ast)
-
-(define
-  er-ring-program-3-6
-  "Me = self(),
-   Spawner = fun () ->
-     receive {setup, Next} ->
-       Loop = fun () ->
-         receive
-           {token, 0, Parent} -> Parent ! done;
-           {token, K, Parent} -> Next ! {token, K-1, Parent}, Loop()
-         end
-       end,
-       Loop()
-     end
-   end,
-   P1 = spawn(Spawner),
-   P2 = spawn(Spawner),
-   P3 = spawn(Spawner),
-   P1 ! {setup, P2},
-   P2 ! {setup, P3},
-   P3 ! {setup, P1},
-   P1 ! {token, 5, Me},
-   receive done -> finished end")
-
-(er-ring-test
-  "ring N=3 M=6"
-  (get (ring-ev er-ring-program-3-6) :name)
-  "finished")
-
-;; Two-node ring — token bounces twice between P1 and P2.
-(er-ring-test
-  "ring N=2 M=4"
-  (get (ring-ev
-    "Me = self(),
-     Spawner = fun () ->
-       receive {setup, Next} ->
-         Loop = fun () ->
-           receive
-             {token, 0, Parent} -> Parent ! done;
-             {token, K, Parent} -> Next ! {token, K-1, Parent}, Loop()
-           end
-         end,
-         Loop()
-       end
-     end,
-     P1 = spawn(Spawner),
-     P2 = spawn(Spawner),
-     P1 ! {setup, P2},
-     P2 ! {setup, P1},
-     P1 ! {token, 3, Me},
-     receive done -> done end") :name)
-  "done")
-
-;; Single-node "ring" — P sends to itself M times.
-(er-ring-test
-  "ring N=1 M=5"
-  (get (ring-ev
-    "Me = self(),
-     Spawner = fun () ->
-       receive {setup, Next} ->
-         Loop = fun () ->
-           receive
-             {token, 0, Parent} -> Parent ! finished_loop;
-             {token, K, Parent} -> Next ! {token, K-1, Parent}, Loop()
-           end
-         end,
-         Loop()
-       end
-     end,
-     P = spawn(Spawner),
-     P ! {setup, P},
-     P ! {token, 4, Me},
-     receive finished_loop -> ok end") :name)
-  "ok")
-
-;; Confirm the token really went around — count hops via io-buffer.
-(er-ring-test
-  "ring N=3 M=9 hop count"
-  (do
-    (er-io-flush!)
-    (ring-ev
-      "Me = self(),
-       Spawner = fun () ->
-         receive {setup, Next} ->
-           Loop = fun () ->
-             receive
-               {token, 0, Parent} -> Parent ! done;
-               {token, K, Parent} ->
-                 io:format(\"~p \", [K]),
-                 Next ! {token, K-1, Parent},
-                 Loop()
-             end
-           end,
-           Loop()
-         end
-       end,
-       P1 = spawn(Spawner),
-       P2 = spawn(Spawner),
-       P3 = spawn(Spawner),
-       P1 ! {setup, P2},
-       P2 ! {setup, P3},
-       P3 ! {setup, P1},
-       P1 ! {token, 8, Me},
-       receive done -> done end")
-    (er-io-buffer-content))
-  "8 7 6 5 4 3 2 1 ")
-
-(define
-  er-ring-test-summary
-  (str "ring " er-ring-test-pass "/" er-ring-test-count))
--- a/lib/erlang/tests/runtime.sx
+++ b/lib/erlang/tests/runtime.sx
@@ -1,139 +0,0 @@
-;; Erlang runtime tests — scheduler + process-record primitives.
-
-(define er-rt-test-count 0)
-(define er-rt-test-pass 0)
-(define er-rt-test-fails (list))
-
-(define
-  er-rt-test
-  (fn
-    (name actual expected)
-    (set! er-rt-test-count (+ er-rt-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-rt-test-pass (+ er-rt-test-pass 1))
-      (append! er-rt-test-fails {:actual actual :expected expected :name name}))))
-
-;; ── queue ─────────────────────────────────────────────────────────
-(er-rt-test "queue empty len" (er-q-len (er-q-new)) 0)
-(er-rt-test "queue empty?" (er-q-empty? (er-q-new)) true)
-
-(define q1 (er-q-new))
-(er-q-push! q1 "a")
-(er-q-push! q1 "b")
-(er-q-push! q1 "c")
-(er-rt-test "queue push len" (er-q-len q1) 3)
-(er-rt-test "queue empty? after push" (er-q-empty? q1) false)
-(er-rt-test "queue peek" (er-q-peek q1) "a")
-(er-rt-test "queue pop 1" (er-q-pop! q1) "a")
-(er-rt-test "queue pop 2" (er-q-pop! q1) "b")
-(er-rt-test "queue len after pops" (er-q-len q1) 1)
-(er-rt-test "queue pop 3" (er-q-pop! q1) "c")
-(er-rt-test "queue empty again" (er-q-empty? q1) true)
-(er-rt-test "queue pop empty" (er-q-pop! q1) nil)
-
-;; Queue FIFO under interleaved push/pop
-(define q2 (er-q-new))
-(er-q-push! q2 1)
-(er-q-push! q2 2)
-(er-q-pop! q2)
-(er-q-push! q2 3)
-(er-rt-test "queue interleave peek" (er-q-peek q2) 2)
-(er-rt-test "queue to-list" (er-q-to-list q2) (list 2 3))
-
-;; ── scheduler init ─────────────────────────────────────────────
-(er-sched-init!)
-(er-rt-test "sched process count 0" (er-sched-process-count) 0)
-(er-rt-test "sched runnable count 0" (er-sched-runnable-count) 0)
-(er-rt-test "sched current nil" (er-sched-current-pid) nil)
-
-;; ── pid allocation ─────────────────────────────────────────────
-(define pa (er-pid-new!))
-(define pb (er-pid-new!))
-(er-rt-test "pid tag" (get pa :tag) "pid")
-(er-rt-test "pid ids distinct" (= (er-pid-id pa) (er-pid-id pb)) false)
-(er-rt-test "pid? true" (er-pid? pa) true)
-(er-rt-test "pid? false" (er-pid? 42) false)
-(er-rt-test
-  "pid-equal same"
-  (er-pid-equal? pa (er-mk-pid (er-pid-id pa)))
-  true)
-(er-rt-test "pid-equal diff" (er-pid-equal? pa pb) false)
-
-;; ── process lifecycle ──────────────────────────────────────────
-(er-sched-init!)
-(define p1 (er-proc-new! {}))
-(define p2 (er-proc-new! {}))
-(er-rt-test "proc count 2" (er-sched-process-count) 2)
-(er-rt-test "runnable count 2" (er-sched-runnable-count) 2)
-(er-rt-test
-  "proc state runnable"
-  (er-proc-field (get p1 :pid) :state)
-  "runnable")
-(er-rt-test
-  "proc mailbox empty"
-  (er-proc-mailbox-size (get p1 :pid))
-  0)
-(er-rt-test
-  "proc lookup"
-  (er-pid-equal? (get (er-proc-get (get p1 :pid)) :pid) (get p1 :pid))
-  true)
-(er-rt-test "proc exists" (er-proc-exists? (get p1 :pid)) true)
-(er-rt-test
-  "proc no-such-pid"
-  (er-proc-exists? (er-mk-pid 9999))
-  false)
-
-;; runnable queue dequeue order
-(er-rt-test
-  "dequeue first"
-  (er-pid-equal? (er-sched-next-runnable!) (get p1 :pid))
-  true)
-(er-rt-test
-  "dequeue second"
-  (er-pid-equal? (er-sched-next-runnable!) (get p2 :pid))
-  true)
-(er-rt-test "dequeue empty" (er-sched-next-runnable!) nil)
-
-;; current-pid get/set
-(er-sched-set-current! (get p1 :pid))
-(er-rt-test
-  "current pid set"
-  (er-pid-equal? (er-sched-current-pid) (get p1 :pid))
-  true)
-
-;; ── mailbox push ──────────────────────────────────────────────
-(er-proc-mailbox-push! (get p1 :pid) {:tag "atom" :name "ping"})
-(er-proc-mailbox-push! (get p1 :pid) 42)
-(er-rt-test "mailbox size 2" (er-proc-mailbox-size (get p1 :pid)) 2)
-
-;; ── field update ──────────────────────────────────────────────
-(er-proc-set! (get p1 :pid) :state "waiting")
-(er-rt-test
-  "proc state waiting"
-  (er-proc-field (get p1 :pid) :state)
-  "waiting")
-(er-proc-set! (get p1 :pid) :trap-exit true)
-(er-rt-test
-  "proc trap-exit"
-  (er-proc-field (get p1 :pid) :trap-exit)
-  true)
-
-;; ── fresh scheduler ends in clean state ───────────────────────
-(er-sched-init!)
-(er-rt-test
-  "sched init resets count"
-  (er-sched-process-count)
-  0)
-(er-rt-test
-  "sched init resets queue"
-  (er-sched-runnable-count)
-  0)
-(er-rt-test
-  "sched init resets current"
-  (er-sched-current-pid)
-  nil)
-
-(define
-  er-rt-test-summary
-  (str "runtime " er-rt-test-pass "/" er-rt-test-count))
--- a/lib/erlang/transpile.sx
+++ b/lib/erlang/transpile.sx
--- a/lib/forth/runtime.sx
+++ b/lib/forth/runtime.sx
@@ -1,175 +1,433 @@
-;; lib/forth/runtime.sx — Forth primitives on SX
-;;
-;; Provides Forth-idiomatic wrappers over SX built-ins.
-;; Primitives used:
-;;   bitwise-and/or/xor/not/arithmetic-shift/bit-count (Phase 7)
-;;   make-bytevector/bytevector-u8-ref/u8-set!/...     (Phase 20)
-;;   quotient/remainder/modulo                          (Phase 15 / builtin)
-;;
-;; Naming: SX identifiers can't include @ or !-alone, so Forth words are:
-;;   C@ → forth-cfetch    C! → forth-cstore
-;;   @  → forth-fetch     !  → forth-store
-
-;; ---------------------------------------------------------------------------
-;; 1. Bitwise operations — Forth core words
-;;    Forth TRUE = -1 (all bits set), FALSE = 0.
-;;    All ops coerce to integer via truncate.
-;; ---------------------------------------------------------------------------
-
-(define (forth-and a b) (bitwise-and (truncate a) (truncate b)))
-(define (forth-or a b) (bitwise-or (truncate a) (truncate b)))
-(define (forth-xor a b) (bitwise-xor (truncate a) (truncate b)))
-
-;; INVERT — bitwise NOT (Forth NOT is logical; INVERT is bitwise)
-(define (forth-invert a) (bitwise-not (truncate a)))
-
-;; LSHIFT RSHIFT — n bit — shift a by n positions
-(define (forth-lshift a n) (arithmetic-shift (truncate a) (truncate n)))
-(define
-  (forth-rshift a n)
-  (arithmetic-shift (truncate a) (- 0 (truncate n))))
-
-;; 2* 2/ — multiply/divide by 2 via bit shift
-(define (forth-2* a) (arithmetic-shift (truncate a) 1))
-(define (forth-2/ a) (arithmetic-shift (truncate a) -1))
-
-;; BIT-COUNT — number of set bits (Kernighan popcount)
-(define (forth-bit-count a) (bit-count (truncate a)))
-
-;; INTEGER-LENGTH — index of highest set bit (0 for zero)
-(define (forth-integer-length a) (integer-length (truncate a)))
-
-;; WITHIN — ( u ul uh -- flag ) true if ul <= u < uh
-(define (forth-within u ul uh) (and (>= u ul) (< u uh)))
-
-;; Arithmetic complements commonly used alongside bitwise ops
-(define (forth-negate a) (- 0 (truncate a)))
-(define (forth-abs a) (abs (truncate a)))
-(define (forth-min a b) (if (< a b) a b))
-(define (forth-max a b) (if (> a b) a b))
-(define (forth-mod a b) (modulo (truncate a) (truncate b)))
-
-;; /MOD — ( n1 n2 -- rem quot ) returns list (remainder quotient)
-(define
-  (forth-divmod a b)
-  (list
-    (remainder (truncate a) (truncate b))
-    (quotient (truncate a) (truncate b))))
-
-;; ---------------------------------------------------------------------------
-;; 2. String buffer — word-definition / string accumulation
-;;    EMIT appends one char; TYPE appends a string.
-;;    Value is retrieved with forth-sb-value.
-;; ---------------------------------------------------------------------------
+;; Forth runtime — state, stacks, dictionary, output buffer.
+;; Data stack: mutable SX list, TOS = first.
+;; Return stack: separate mutable list.
+;; Dictionary: SX dict {lowercased-name -> word-record}.
+;; Word record: {"kind" "body" "immediate?"}; kind is "primitive" or "colon-def".
+;; Output buffer: mutable string appended to by `.`, `EMIT`, `CR`, etc.
+;; Compile-mode flag: "compiling" on the state.

 (define
-  (forth-sb-new)
-  (let
-    ((sb (dict)))
-    (dict-set! sb "_forth_sb" true)
-    (dict-set! sb "_chars" (list))
-    sb))
-
-(define (forth-sb? v) (and (dict? v) (dict-has? v "_forth_sb")))
-
-;; EMIT — append one character
-(define
-  (forth-sb-emit! sb c)
-  (dict-set! sb "_chars" (append (get sb "_chars") (list c)))
-  sb)
-
-;; TYPE — append a string
-(define
-  (forth-sb-type! sb s)
-  (dict-set! sb "_chars" (append (get sb "_chars") (string->list s)))
-  sb)
-
-(define (forth-sb-value sb) (list->string (get sb "_chars")))
-
-(define (forth-sb-length sb) (len (get sb "_chars")))
-
-(define (forth-sb-clear! sb) (dict-set! sb "_chars" (list)) sb)
-
-;; Emit integer as decimal digits
-(define (forth-sb-emit-int! sb n) (forth-sb-type! sb (str (truncate n))))
-
-;; ---------------------------------------------------------------------------
-;; 3. Memory / Bytevectors — Forth raw memory model
-;;    ALLOT allocates a bytevector. Byte and cell (32-bit LE) access.
-;; ---------------------------------------------------------------------------
-
-;; ALLOT — allocate n bytes zero-initialised
-(define (forth-mem-new n) (make-bytevector (truncate n) 0))
-
-(define (forth-mem? v) (bytevector? v))
-
-(define (forth-mem-size v) (bytevector-length v))
-
-;; C@ C! — byte fetch/store
-(define (forth-cfetch mem addr) (bytevector-u8-ref mem (truncate addr)))
+  forth-make-state
+  (fn
+    ()
+    (let
+      ((s (dict)))
+      (dict-set! s "dstack" (list))
+      (dict-set! s "rstack" (list))
+      (dict-set! s "dict" (dict))
+      (dict-set! s "output" "")
+      (dict-set! s "compiling" false)
+      (dict-set! s "current-def" nil)
+      (dict-set! s "base" 10)
+      (dict-set! s "vars" (dict))
+      s)))

 (define
-  (forth-cstore mem addr val)
-  (bytevector-u8-set!
-    mem
-    (truncate addr)
-    (modulo (truncate val) 256))
-  mem)
-
-;; @ ! — 32-bit little-endian cell fetch/store
-(define
-  (forth-fetch mem addr)
-  (let
-    ((a (truncate addr)))
-    (+
-      (bytevector-u8-ref mem a)
-      (* 256 (bytevector-u8-ref mem (+ a 1)))
-      (* 65536 (bytevector-u8-ref mem (+ a 2)))
-      (* 16777216 (bytevector-u8-ref mem (+ a 3))))))
+  forth-error
+  (fn (state msg) (dict-set! state "error" msg) (raise msg)))

 (define
-  (forth-store mem addr val)
-  (let
-    ((a (truncate addr)) (v (truncate val)))
-    (bytevector-u8-set! mem a (modulo v 256))
-    (bytevector-u8-set!
-      mem
-      (+ a 1)
-      (modulo (quotient v 256) 256))
-    (bytevector-u8-set!
-      mem
-      (+ a 2)
-      (modulo (quotient v 65536) 256))
-    (bytevector-u8-set!
-      mem
-      (+ a 3)
-      (modulo (quotient v 16777216) 256)))
-  mem)
+  forth-push
+  (fn (state v) (dict-set! state "dstack" (cons v (get state "dstack")))))

-;; MOVE — copy count bytes from src[src-addr] to dst[dst-addr]
 (define
-  (forth-move! src src-addr dst dst-addr count)
-  (letrec
-    ((go (fn (i) (when (< i (truncate count)) (bytevector-u8-set! dst (+ (truncate dst-addr) i) (bytevector-u8-ref src (+ (truncate src-addr) i))) (go (+ i 1))))))
-    (go 0))
-  dst)
+  forth-pop
+  (fn
+    (state)
+    (let
+      ((st (get state "dstack")))
+      (if
+        (= (len st) 0)
+        (forth-error state "stack underflow")
+        (let ((top (first st))) (dict-set! state "dstack" (rest st)) top)))))

-;; FILL — fill count bytes at addr with byte value
 (define
-  (forth-fill! mem addr count byte)
-  (letrec
-    ((go (fn (i) (when (< i (truncate count)) (bytevector-u8-set! mem (+ (truncate addr) i) (modulo (truncate byte) 256)) (go (+ i 1))))))
-    (go 0))
-  mem)
+  forth-peek
+  (fn
+    (state)
+    (let
+      ((st (get state "dstack")))
+      (if (= (len st) 0) (forth-error state "stack underflow") (first st)))))

-;; ERASE — fill with zeros (Forth: ERASE)
-(define
-  (forth-erase! mem addr count)
-  (forth-fill! mem addr count 0))
+(define forth-depth (fn (state) (len (get state "dstack"))))

-;; Dump memory region as list of byte values
 (define
-  (forth-mem->list mem addr count)
-  (letrec
-    ((go (fn (i acc) (if (= i 0) acc (go (- i 1) (cons (bytevector-u8-ref mem (+ (truncate addr) (- i 1))) acc))))))
-    (go (truncate count) (list))))
+  forth-rpush
+  (fn (state v) (dict-set! state "rstack" (cons v (get state "rstack")))))
+
+(define
+  forth-rpop
+  (fn
+    (state)
+    (let
+      ((st (get state "rstack")))
+      (if
+        (= (len st) 0)
+        (forth-error state "return stack underflow")
+        (let ((top (first st))) (dict-set! state "rstack" (rest st)) top)))))
+
+(define
+  forth-rpeek
+  (fn
+    (state)
+    (let
+      ((st (get state "rstack")))
+      (if
+        (= (len st) 0)
+        (forth-error state "return stack underflow")
+        (first st)))))
+
+(define
+  forth-emit-str
+  (fn (state s) (dict-set! state "output" (str (get state "output") s))))
+
+(define
+  forth-make-word
+  (fn
+    (kind body immediate?)
+    (let
+      ((w (dict)))
+      (dict-set! w "kind" kind)
+      (dict-set! w "body" body)
+      (dict-set! w "immediate?" immediate?)
+      w)))
+
+(define
+  forth-def-prim!
+  (fn
+    (state name body)
+    (dict-set!
+      (get state "dict")
+      (downcase name)
+      (forth-make-word "primitive" body false))))
+
+(define
+  forth-def-prim-imm!
+  (fn
+    (state name body)
+    (dict-set!
+      (get state "dict")
+      (downcase name)
+      (forth-make-word "primitive" body true))))
+
+(define
+  forth-lookup
+  (fn (state name) (get (get state "dict") (downcase name))))
+
+(define
+  forth-binop
+  (fn
+    (op)
+    (fn
+      (state)
+      (let
+        ((b (forth-pop state)) (a (forth-pop state)))
+        (forth-push state (op a b))))))
+
+(define
+  forth-unop
+  (fn
+    (op)
+    (fn (state) (let ((a (forth-pop state))) (forth-push state (op a))))))
+
+(define
+  forth-cmp
+  (fn
+    (op)
+    (fn
+      (state)
+      (let
+        ((b (forth-pop state)) (a (forth-pop state)))
+        (forth-push state (if (op a b) -1 0))))))
+
+(define
+  forth-cmp0
+  (fn
+    (op)
+    (fn
+      (state)
+      (let ((a (forth-pop state))) (forth-push state (if (op a) -1 0))))))
+
+(define
+  forth-trunc
+  (fn (x) (if (< x 0) (- 0 (floor (- 0 x))) (floor x))))
+
+(define
+  forth-div
+  (fn
+    (a b)
+    (if (= b 0) (raise "division by zero") (forth-trunc (/ a b)))))
+
+(define
+  forth-mod
+  (fn
+    (a b)
+    (if (= b 0) (raise "division by zero") (- a (* b (forth-div a b))))))
+
+(define forth-bits-width 32)
+
+(define
+  forth-to-unsigned
+  (fn (n w) (let ((m (pow 2 w))) (mod (+ (mod n m) m) m))))
+
+(define
+  forth-from-unsigned
+  (fn
+    (n w)
+    (let ((half (pow 2 (- w 1)))) (if (>= n half) (- n (pow 2 w)) n))))
+
+(define
+  forth-bitwise-step
+  (fn
+    (op ua ub out place i w)
+    (if
+      (>= i w)
+      out
+      (let
+        ((da (mod ua 2)) (db (mod ub 2)))
+        (forth-bitwise-step
+          op
+          (floor (/ ua 2))
+          (floor (/ ub 2))
+          (+ out (* place (op da db)))
+          (* place 2)
+          (+ i 1)
+          w)))))
+
+(define
+  forth-bitwise-uu
+  (fn
+    (op)
+    (fn
+      (a b)
+      (let
+        ((ua (forth-to-unsigned a forth-bits-width))
+          (ub (forth-to-unsigned b forth-bits-width)))
+        (forth-from-unsigned
+          (forth-bitwise-step op ua ub 0 1 0 forth-bits-width)
+          forth-bits-width)))))
+
+(define
+  forth-bit-and
+  (forth-bitwise-uu (fn (x y) (if (and (= x 1) (= y 1)) 1 0))))
+
+(define
+  forth-bit-or
+  (forth-bitwise-uu (fn (x y) (if (or (= x 1) (= y 1)) 1 0))))
+
+(define forth-bit-xor (forth-bitwise-uu (fn (x y) (if (= x y) 0 1))))
+
+(define forth-bit-invert (fn (a) (- 0 (+ a 1))))
+
+(define
+  forth-install-primitives!
+  (fn
+    (state)
+    (forth-def-prim! state "DUP" (fn (s) (forth-push s (forth-peek s))))
+    (forth-def-prim! state "DROP" (fn (s) (forth-pop s)))
+    (forth-def-prim!
+      state
+      "SWAP"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s b)
+          (forth-push s a))))
+    (forth-def-prim!
+      state
+      "OVER"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s a)
+          (forth-push s b)
+          (forth-push s a))))
+    (forth-def-prim!
+      state
+      "ROT"
+      (fn
+        (s)
+        (let
+          ((c (forth-pop s)) (b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s b)
+          (forth-push s c)
+          (forth-push s a))))
+    (forth-def-prim!
+      state
+      "-ROT"
+      (fn
+        (s)
+        (let
+          ((c (forth-pop s)) (b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s c)
+          (forth-push s a)
+          (forth-push s b))))
+    (forth-def-prim!
+      state
+      "NIP"
+      (fn (s) (let ((b (forth-pop s))) (forth-pop s) (forth-push s b))))
+    (forth-def-prim!
+      state
+      "TUCK"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s b)
+          (forth-push s a)
+          (forth-push s b))))
+    (forth-def-prim!
+      state
+      "?DUP"
+      (fn
+        (s)
+        (let ((a (forth-peek s))) (when (not (= a 0)) (forth-push s a)))))
+    (forth-def-prim! state "DEPTH" (fn (s) (forth-push s (forth-depth s))))
+    (forth-def-prim!
+      state
+      "PICK"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)) (st (get s "dstack")))
+          (if
+            (or (< n 0) (>= n (len st)))
+            (forth-error s "PICK out of range")
+            (forth-push s (nth st n))))))
+    (forth-def-prim!
+      state
+      "ROLL"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)) (st (get s "dstack")))
+          (if
+            (or (< n 0) (>= n (len st)))
+            (forth-error s "ROLL out of range")
+            (let
+              ((taken (nth st n))
+                (before (take st n))
+                (after (drop st (+ n 1))))
+              (dict-set! s "dstack" (concat before after))
+              (forth-push s taken))))))
+    (forth-def-prim!
+      state
+      "2DUP"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s a)
+          (forth-push s b)
+          (forth-push s a)
+          (forth-push s b))))
+    (forth-def-prim! state "2DROP" (fn (s) (forth-pop s) (forth-pop s)))
+    (forth-def-prim!
+      state
+      "2SWAP"
+      (fn
+        (s)
+        (let
+          ((d (forth-pop s))
+            (c (forth-pop s))
+            (b (forth-pop s))
+            (a (forth-pop s)))
+          (forth-push s c)
+          (forth-push s d)
+          (forth-push s a)
+          (forth-push s b))))
+    (forth-def-prim!
+      state
+      "2OVER"
+      (fn
+        (s)
+        (let
+          ((d (forth-pop s))
+            (c (forth-pop s))
+            (b (forth-pop s))
+            (a (forth-pop s)))
+          (forth-push s a)
+          (forth-push s b)
+          (forth-push s c)
+          (forth-push s d)
+          (forth-push s a)
+          (forth-push s b))))
+    (forth-def-prim! state "+" (forth-binop (fn (a b) (+ a b))))
+    (forth-def-prim! state "-" (forth-binop (fn (a b) (- a b))))
+    (forth-def-prim! state "*" (forth-binop (fn (a b) (* a b))))
+    (forth-def-prim! state "/" (forth-binop forth-div))
+    (forth-def-prim! state "MOD" (forth-binop forth-mod))
+    (forth-def-prim!
+      state
+      "/MOD"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-push s (forth-mod a b))
+          (forth-push s (forth-div a b)))))
+    (forth-def-prim! state "NEGATE" (forth-unop (fn (a) (- 0 a))))
+    (forth-def-prim! state "ABS" (forth-unop abs))
+    (forth-def-prim!
+      state
+      "MIN"
+      (forth-binop (fn (a b) (if (< a b) a b))))
+    (forth-def-prim!
+      state
+      "MAX"
+      (forth-binop (fn (a b) (if (> a b) a b))))
+    (forth-def-prim! state "1+" (forth-unop (fn (a) (+ a 1))))
+    (forth-def-prim! state "1-" (forth-unop (fn (a) (- a 1))))
+    (forth-def-prim! state "2+" (forth-unop (fn (a) (+ a 2))))
+    (forth-def-prim! state "2-" (forth-unop (fn (a) (- a 2))))
+    (forth-def-prim! state "2*" (forth-unop (fn (a) (* a 2))))
+    (forth-def-prim! state "2/" (forth-unop (fn (a) (floor (/ a 2)))))
+    (forth-def-prim! state "=" (forth-cmp (fn (a b) (= a b))))
+    (forth-def-prim! state "<>" (forth-cmp (fn (a b) (not (= a b)))))
+    (forth-def-prim! state "<" (forth-cmp (fn (a b) (< a b))))
+    (forth-def-prim! state ">" (forth-cmp (fn (a b) (> a b))))
+    (forth-def-prim! state "<=" (forth-cmp (fn (a b) (<= a b))))
+    (forth-def-prim! state ">=" (forth-cmp (fn (a b) (>= a b))))
+    (forth-def-prim! state "0=" (forth-cmp0 (fn (a) (= a 0))))
+    (forth-def-prim! state "0<>" (forth-cmp0 (fn (a) (not (= a 0)))))
+    (forth-def-prim! state "0<" (forth-cmp0 (fn (a) (< a 0))))
+    (forth-def-prim! state "0>" (forth-cmp0 (fn (a) (> a 0))))
+    (forth-def-prim! state "AND" (forth-binop forth-bit-and))
+    (forth-def-prim! state "OR" (forth-binop forth-bit-or))
+    (forth-def-prim! state "XOR" (forth-binop forth-bit-xor))
+    (forth-def-prim! state "INVERT" (forth-unop forth-bit-invert))
+    (forth-def-prim!
+      state
+      "."
+      (fn (s) (forth-emit-str s (str (forth-pop s) " "))))
+    (forth-def-prim!
+      state
+      ".S"
+      (fn
+        (s)
+        (let
+          ((st (reverse (get s "dstack"))))
+          (forth-emit-str s "<")
+          (forth-emit-str s (str (len st)))
+          (forth-emit-str s "> ")
+          (for-each (fn (v) (forth-emit-str s (str v " "))) st))))
+    (forth-def-prim!
+      state
+      "EMIT"
+      (fn (s) (forth-emit-str s (code-char (forth-pop s)))))
+    (forth-def-prim! state "CR" (fn (s) (forth-emit-str s "\n")))
+    (forth-def-prim! state "SPACE" (fn (s) (forth-emit-str s " ")))
+    (forth-def-prim!
+      state
+      "SPACES"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)))
+          (when
+            (> n 0)
+            (for-each (fn (_) (forth-emit-str s " ")) (range 0 n))))))
+    (forth-def-prim! state "BL" (fn (s) (forth-push s 32)))
+    state))
--- a/lib/forth/test.sh
+++ b/lib/forth/test.sh
@@ -1,62 +0,0 @@
-#!/usr/bin/env bash
-# lib/forth/test.sh — smoke-test the Forth runtime layer.
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found."
-  exit 1
-fi
-
-TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT
-
-cat > "$TMPFILE" << 'EPOCHS'
-(epoch 1)
-(load "lib/forth/runtime.sx")
-(epoch 2)
-(load "lib/forth/tests/runtime.sx")
-(epoch 3)
-(eval "(list forth-test-pass forth-test-fail)")
-EPOCHS
-
-OUTPUT=$(timeout 60 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
-
-LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 3 / {getline; print; exit}')
-if [ -z "$LINE" ]; then
-  LINE=$(echo "$OUTPUT" | grep -E '^\(ok 3 \([0-9]+ [0-9]+\)\)' | tail -1 \
-          | sed -E 's/^\(ok 3 //; s/\)$//')
-fi
-if [ -z "$LINE" ]; then
-  echo "ERROR: could not extract summary"
-  echo "$OUTPUT" | tail -20
-  exit 1
-fi
-
-P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
-F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
-TOTAL=$((P + F))
-
-if [ "$F" -eq 0 ]; then
-  echo "ok $P/$TOTAL lib/forth tests passed"
-else
-  echo "FAIL $P/$TOTAL passed, $F failed"
-  TMPFILE2=$(mktemp)
-  cat > "$TMPFILE2" << 'EPOCHS2'
-(epoch 1)
-(load "lib/forth/runtime.sx")
-(epoch 2)
-(load "lib/forth/tests/runtime.sx")
-(epoch 3)
-(eval "(map (fn (f) (list (get f :name) (get f :got) (get f :expected))) forth-test-fails)")
-EPOCHS2
-  FAILS=$(timeout 60 "$SX_SERVER" < "$TMPFILE2" 2>/dev/null | grep -E '^\(ok-len 3' -A1 | tail -1 || true)
-  echo "  Details: $FAILS"
-  rm -f "$TMPFILE2"
-fi
-
-[ "$F" -eq 0 ]
--- a/lib/forth/tests/runtime.sx
+++ b/lib/forth/tests/runtime.sx
@@ -1,201 +0,0 @@
-;; lib/forth/tests/runtime.sx — Tests for lib/forth/runtime.sx
-
-(define forth-test-pass 0)
-(define forth-test-fail 0)
-(define forth-test-fails (list))
-
-(define
-  (forth-test name got expected)
-  (if
-    (= got expected)
-    (set! forth-test-pass (+ forth-test-pass 1))
-    (begin
-      (set! forth-test-fail (+ forth-test-fail 1))
-      (set! forth-test-fails (append forth-test-fails (list {:got got :expected expected :name name}))))))
-
-;; ---------------------------------------------------------------------------
-;; 1. Bitwise operations
-;; ---------------------------------------------------------------------------
-
-;; AND
-(forth-test "and 0b1100 0b1010" (forth-and 12 10) 8)
-(forth-test "and 0xFF 0x0F" (forth-and 255 15) 15)
-(forth-test "and 0 any" (forth-and 0 42) 0)
-
-;; OR
-(forth-test "or 0b1100 0b1010" (forth-or 12 10) 14)
-(forth-test "or 0 x" (forth-or 0 7) 7)
-
-;; XOR
-(forth-test "xor 0b1100 0b1010" (forth-xor 12 10) 6)
-(forth-test "xor x x" (forth-xor 42 42) 0)
-
-;; INVERT
-(forth-test "invert 0" (forth-invert 0) -1)
-(forth-test "invert -1" (forth-invert -1) 0)
-(forth-test "invert 1" (forth-invert 1) -2)
-
-;; LSHIFT RSHIFT
-(forth-test "lshift 1 3" (forth-lshift 1 3) 8)
-(forth-test "lshift 3 2" (forth-lshift 3 2) 12)
-(forth-test "rshift 8 3" (forth-rshift 8 3) 1)
-(forth-test "rshift 16 2" (forth-rshift 16 2) 4)
-
-;; 2* 2/
-(forth-test "2* 5" (forth-2* 5) 10)
-(forth-test "2/ 10" (forth-2/ 10) 5)
-(forth-test "2/ 7" (forth-2/ 7) 3)
-
-;; BIT-COUNT
-(forth-test "bit-count 0" (forth-bit-count 0) 0)
-(forth-test "bit-count 1" (forth-bit-count 1) 1)
-(forth-test "bit-count 7" (forth-bit-count 7) 3)
-(forth-test "bit-count 255" (forth-bit-count 255) 8)
-(forth-test "bit-count 256" (forth-bit-count 256) 1)
-
-;; INTEGER-LENGTH
-(forth-test "integer-length 0" (forth-integer-length 0) 0)
-(forth-test "integer-length 1" (forth-integer-length 1) 1)
-(forth-test "integer-length 4" (forth-integer-length 4) 3)
-(forth-test "integer-length 255" (forth-integer-length 255) 8)
-
-;; WITHIN
-(forth-test
-  "within 5 0 10"
-  (forth-within 5 0 10)
-  true)
-(forth-test
-  "within 0 0 10"
-  (forth-within 0 0 10)
-  true)
-(forth-test
-  "within 10 0 10"
-  (forth-within 10 0 10)
-  false)
-(forth-test
-  "within -1 0 10"
-  (forth-within -1 0 10)
-  false)
-
-;; Arithmetic ops
-(forth-test "negate 5" (forth-negate 5) -5)
-(forth-test "negate -3" (forth-negate -3) 3)
-(forth-test "abs -7" (forth-abs -7) 7)
-(forth-test "min 3 5" (forth-min 3 5) 3)
-(forth-test "max 3 5" (forth-max 3 5) 5)
-(forth-test "mod 7 3" (forth-mod 7 3) 1)
-(forth-test
-  "divmod 7 3"
-  (forth-divmod 7 3)
-  (list 1 2))
-(forth-test
-  "divmod 10 5"
-  (forth-divmod 10 5)
-  (list 0 2))
-
-;; ---------------------------------------------------------------------------
-;; 2. String buffer
-;; ---------------------------------------------------------------------------
-
-(define sb1 (forth-sb-new))
-(forth-test "sb? new" (forth-sb? sb1) true)
-(forth-test "sb? non-sb" (forth-sb? 42) false)
-(forth-test "sb value empty" (forth-sb-value sb1) "")
-(forth-test "sb length empty" (forth-sb-length sb1) 0)
-
-(forth-sb-type! sb1 "HELLO")
-(forth-test "sb type" (forth-sb-value sb1) "HELLO")
-(forth-test "sb length after type" (forth-sb-length sb1) 5)
-
-;; EMIT one char
-(define sb2 (forth-sb-new))
-(forth-sb-emit! sb2 (nth (string->list "A") 0))
-(forth-sb-emit! sb2 (nth (string->list "B") 0))
-(forth-sb-emit! sb2 (nth (string->list "C") 0))
-(forth-test "sb emit chars" (forth-sb-value sb2) "ABC")
-
-;; Emit integer
-(define sb3 (forth-sb-new))
-(forth-sb-type! sb3 "n=")
-(forth-sb-emit-int! sb3 42)
-(forth-test "sb emit-int" (forth-sb-value sb3) "n=42")
-
-(forth-sb-clear! sb1)
-(forth-test "sb clear" (forth-sb-value sb1) "")
-(forth-test "sb length after clear" (forth-sb-length sb1) 0)
-
-;; Build a word definition-style name
-(define sb4 (forth-sb-new))
-(forth-sb-type! sb4 ": ")
-(forth-sb-type! sb4 "SQUARE")
-(forth-sb-type! sb4 " DUP * ;")
-(forth-test "sb word def" (forth-sb-value sb4) ": SQUARE DUP * ;")
-
-;; ---------------------------------------------------------------------------
-;; 3. Memory / Bytevectors
-;; ---------------------------------------------------------------------------
-
-(define m1 (forth-mem-new 8))
-(forth-test "mem? yes" (forth-mem? m1) true)
-(forth-test "mem? no" (forth-mem? 42) false)
-(forth-test "mem size" (forth-mem-size m1) 8)
-(forth-test "mem cfetch zero" (forth-cfetch m1 0) 0)
-
-;; C! C@
-(forth-cstore m1 0 65)
-(forth-cstore m1 1 66)
-(forth-test "mem cstore/cfetch 0" (forth-cfetch m1 0) 65)
-(forth-test "mem cstore/cfetch 1" (forth-cfetch m1 1) 66)
-(forth-cstore m1 2 256)
-(forth-test
-  "mem cstore wraps 256→0"
-  (forth-cfetch m1 2)
-  0)
-(forth-cstore m1 2 257)
-(forth-test
-  "mem cstore wraps 257→1"
-  (forth-cfetch m1 2)
-  1)
-
-;; @ ! (32-bit LE cell)
-(define m2 (forth-mem-new 8))
-(forth-store m2 0 305419896)
-(forth-test "mem store/fetch" (forth-fetch m2 0) 305419896)
-(forth-store m2 4 1)
-(forth-test "mem fetch byte 4" (forth-cfetch m2 4) 1)
-(forth-test "mem fetch byte 5" (forth-cfetch m2 5) 0)
-
-;; FILL ERASE
-(define m3 (forth-mem-new 4))
-(forth-fill! m3 0 4 42)
-(forth-test
-  "mem fill"
-  (forth-mem->list m3 0 4)
-  (list 42 42 42 42))
-(forth-erase! m3 1 2)
-(forth-test
-  "mem erase middle"
-  (forth-mem->list m3 0 4)
-  (list 42 0 0 42))
-
-;; MOVE
-(define m4 (forth-mem-new 4))
-(forth-cstore m4 0 1)
-(forth-cstore m4 1 2)
-(forth-cstore m4 2 3)
-(define m5 (forth-mem-new 4))
-(forth-move! m4 0 m5 0 3)
-(forth-test
-  "mem move"
-  (forth-mem->list m5 0 3)
-  (list 1 2 3))
-
-;; mem->list
-(define m6 (forth-mem-new 3))
-(forth-cstore m6 0 10)
-(forth-cstore m6 1 20)
-(forth-cstore m6 2 30)
-(forth-test
-  "mem->list"
-  (forth-mem->list m6 0 3)
-  (list 10 20 30))
--- a/lib/haskell/runtime.sx
+++ b/lib/haskell/runtime.sx
@@ -1,507 +0,0 @@
-;; lib/haskell/runtime.sx — Haskell-on-SX runtime layer
-;;
-;; Covers the Haskell primitives now reachable via SX spec:
-;;  1. Numeric type class helpers (Num / Integral / Fractional)
-;;  2. Rational numbers (dict-based: {:_rational true :num n :den d})
-;;  3. Lazy evaluation — hk-force for promises created by delay
-;;  4. Char utilities (Data.Char)
-;;  5. Data.Set wrappers
-;;  6. Data.List utilities
-;;  7. Maybe / Either ADTs
-;;  8. Tuples (lists, since list->vector unreliable in sx_server)
-;;  9. String helpers (words/lines/isPrefixOf/etc.)
-;; 10. Show helper
-
-;; ===========================================================================
-;; 1. Numeric type class helpers
-;; ===========================================================================
-
-(define hk-is-integer? integer?)
-(define hk-is-float? float?)
-(define hk-is-num? number?)
-
-;; fromIntegral — coerce integer to Float
-(define (hk-to-float x) (exact->inexact x))
-
-;; truncate / round toward zero
-(define hk-to-integer truncate)
-(define hk-from-integer (fn (n) n))
-
-;; Haskell div: floor division (rounds toward -inf)
-(define
-  (hk-div a b)
-  (let
-    ((q (quotient a b)) (r (remainder a b)))
-    (if
-      (and
-        (not (= r 0))
-        (or
-          (and (< a 0) (> b 0))
-          (and (> a 0) (< b 0))))
-      (- q 1)
-      q)))
-
-;; Haskell mod: result has same sign as divisor
-(define hk-mod modulo)
-
-;; Haskell rem: result has same sign as dividend
-(define hk-rem remainder)
-
-;; Haskell quot: truncation division
-(define hk-quot quotient)
-
-;; divMod and quotRem return pairs (lists)
-(define (hk-div-mod a b) (list (hk-div a b) (hk-mod a b)))
-(define (hk-quot-rem a b) (list (hk-quot a b) (hk-rem a b)))
-
-(define (hk-abs x) (if (< x 0) (- 0 x) x))
-(define
-  (hk-signum x)
-  (cond
-    ((> x 0) 1)
-    ((< x 0) -1)
-    (else 0)))
-
-(define hk-gcd gcd)
-(define hk-lcm lcm)
-
-(define (hk-even? n) (= (modulo n 2) 0))
-(define (hk-odd? n) (not (= (modulo n 2) 0)))
-
-;; ===========================================================================
-;; 2. Rational numbers (dict implementation — no built-in rational in sx_server)
-;; ===========================================================================
-
-(define
-  (hk-make-rational n d)
-  (let
-    ((g (gcd (hk-abs n) (hk-abs d))))
-    (if (< d 0) {:num (quotient (- 0 n) g) :den (quotient (- 0 d) g) :_rational true} {:num (quotient n g) :den (quotient d g) :_rational true})))
-
-(define
-  (hk-rational? x)
-  (and (dict? x) (not (= (get x :_rational) nil))))
-(define (hk-numerator r) (get r :num))
-(define (hk-denominator r) (get r :den))
-
-(define
-  (hk-rational-add r1 r2)
-  (hk-make-rational
-    (+
-      (* (hk-numerator r1) (hk-denominator r2))
-      (* (hk-numerator r2) (hk-denominator r1)))
-    (* (hk-denominator r1) (hk-denominator r2))))
-
-(define
-  (hk-rational-sub r1 r2)
-  (hk-make-rational
-    (-
-      (* (hk-numerator r1) (hk-denominator r2))
-      (* (hk-numerator r2) (hk-denominator r1)))
-    (* (hk-denominator r1) (hk-denominator r2))))
-
-(define
-  (hk-rational-mul r1 r2)
-  (hk-make-rational
-    (* (hk-numerator r1) (hk-numerator r2))
-    (* (hk-denominator r1) (hk-denominator r2))))
-
-(define
-  (hk-rational-div r1 r2)
-  (hk-make-rational
-    (* (hk-numerator r1) (hk-denominator r2))
-    (* (hk-denominator r1) (hk-numerator r2))))
-
-(define
-  (hk-rational-to-float r)
-  (exact->inexact (/ (hk-numerator r) (hk-denominator r))))
-
-(define (hk-show-rational r) (str (hk-numerator r) "%" (hk-denominator r)))
-
-;; ===========================================================================
-;; 3. Lazy evaluation — promises (created via SX delay)
-;; ===========================================================================
-
-(define
-  (hk-force p)
-  (if
-    (and (dict? p) (not (= (get p :_promise) nil)))
-    (if (get p :forced) (get p :value) ((get p :thunk)))
-    p))
-
-;; ===========================================================================
-;; 4. Char utilities (Data.Char)
-;; ===========================================================================
-
-(define hk-ord char->integer)
-(define hk-chr integer->char)
-
-;; Inline ASCII predicates — char-alphabetic?/char-numeric? unreliable in sx_server
-(define
-  (hk-is-alpha? c)
-  (let
-    ((n (char->integer c)))
-    (or
-      (and (>= n 65) (<= n 90))
-      (and (>= n 97) (<= n 122)))))
-
-(define
-  (hk-is-digit? c)
-  (let ((n (char->integer c))) (and (>= n 48) (<= n 57))))
-
-(define
-  (hk-is-alnum? c)
-  (let
-    ((n (char->integer c)))
-    (or
-      (and (>= n 48) (<= n 57))
-      (and (>= n 65) (<= n 90))
-      (and (>= n 97) (<= n 122)))))
-
-(define
-  (hk-is-upper? c)
-  (let ((n (char->integer c))) (and (>= n 65) (<= n 90))))
-
-(define
-  (hk-is-lower? c)
-  (let ((n (char->integer c))) (and (>= n 97) (<= n 122))))
-
-(define
-  (hk-is-space? c)
-  (let
-    ((n (char->integer c)))
-    (or
-      (= n 32)
-      (= n 9)
-      (= n 10)
-      (= n 13)
-      (= n 12)
-      (= n 11))))
-
-(define hk-to-upper char-upcase)
-(define hk-to-lower char-downcase)
-
-;; digitToInt: '0'-'9' → 0-9, 'a'-'f'/'A'-'F' → 10-15
-(define
-  (hk-digit-to-int c)
-  (let
-    ((n (char->integer c)))
-    (cond
-      ((and (>= n 48) (<= n 57)) (- n 48))
-      ((and (>= n 65) (<= n 70)) (- n 55))
-      ((and (>= n 97) (<= n 102)) (- n 87))
-      (else (error (str "hk-digit-to-int: not a hex digit: " c))))))
-
-;; intToDigit: 0-15 → char
-(define
-  (hk-int-to-digit n)
-  (cond
-    ((and (>= n 0) (<= n 9))
-      (integer->char (+ n 48)))
-    ((and (>= n 10) (<= n 15))
-      (integer->char (+ n 87)))
-    (else (error (str "hk-int-to-digit: out of range: " n)))))
-
-;; ===========================================================================
-;; 5. Data.Set wrappers
-;; ===========================================================================
-
-(define (hk-set-empty) (make-set))
-(define hk-set? set?)
-(define hk-set-member? set-member?)
-
-(define (hk-set-insert x s) (begin (set-add! s x) s))
-
-(define (hk-set-delete x s) (begin (set-remove! s x) s))
-
-(define hk-set-union set-union)
-(define hk-set-intersection set-intersection)
-(define hk-set-difference set-difference)
-(define hk-set-from-list list->set)
-(define hk-set-to-list set->list)
-(define (hk-set-null? s) (= (len (set->list s)) 0))
-(define (hk-set-size s) (len (set->list s)))
-
-(define (hk-set-singleton x) (let ((s (make-set))) (set-add! s x) s))
-
-;; ===========================================================================
-;; 6. Data.List utilities
-;; ===========================================================================
-
-(define hk-head first)
-(define hk-tail rest)
-(define (hk-null? lst) (= (len lst) 0))
-(define hk-length len)
-
-(define
-  (hk-take n lst)
-  (if
-    (or (= n 0) (= (len lst) 0))
-    (list)
-    (cons (first lst) (hk-take (- n 1) (rest lst)))))
-
-(define
-  (hk-drop n lst)
-  (if
-    (or (= n 0) (= (len lst) 0))
-    lst
-    (hk-drop (- n 1) (rest lst))))
-
-(define
-  (hk-take-while pred lst)
-  (if
-    (or (= (len lst) 0) (not (pred (first lst))))
-    (list)
-    (cons (first lst) (hk-take-while pred (rest lst)))))
-
-(define
-  (hk-drop-while pred lst)
-  (if
-    (or (= (len lst) 0) (not (pred (first lst))))
-    lst
-    (hk-drop-while pred (rest lst))))
-
-(define
-  (hk-zip a b)
-  (if
-    (or (= (len a) 0) (= (len b) 0))
-    (list)
-    (cons (list (first a) (first b)) (hk-zip (rest a) (rest b)))))
-
-(define
-  (hk-zip-with f a b)
-  (if
-    (or (= (len a) 0) (= (len b) 0))
-    (list)
-    (cons (f (first a) (first b)) (hk-zip-with f (rest a) (rest b)))))
-
-(define
-  (hk-unzip pairs)
-  (list
-    (map (fn (p) (first p)) pairs)
-    (map (fn (p) (nth p 1)) pairs)))
-
-(define
-  (hk-elem x lst)
-  (cond
-    ((= (len lst) 0) false)
-    ((= x (first lst)) true)
-    (else (hk-elem x (rest lst)))))
-
-(define (hk-not-elem x lst) (not (hk-elem x lst)))
-
-(define
-  (hk-nub lst)
-  (letrec
-    ((go (fn (seen acc items) (if (= (len items) 0) (reverse acc) (let ((h (first items)) (t (rest items))) (if (hk-elem h seen) (go seen acc t) (go (cons h seen) (cons h acc) t)))))))
-    (go (list) (list) lst)))
-
-(define (hk-sum lst) (reduce + 0 lst))
-(define (hk-product lst) (reduce * 1 lst))
-
-(define
-  (hk-maximum lst)
-  (reduce (fn (a b) (if (> a b) a b)) (first lst) (rest lst)))
-
-(define
-  (hk-minimum lst)
-  (reduce (fn (a b) (if (< a b) a b)) (first lst) (rest lst)))
-
-(define (hk-concat lsts) (reduce append (list) lsts))
-
-(define (hk-concat-map f lst) (hk-concat (map f lst)))
-
-(define hk-sort sort)
-
-(define
-  (hk-span pred lst)
-  (list (hk-take-while pred lst) (hk-drop-while pred lst)))
-
-(define (hk-break pred lst) (hk-span (fn (x) (not (pred x))) lst))
-
-(define
-  (hk-foldl f acc lst)
-  (if
-    (= (len lst) 0)
-    acc
-    (hk-foldl f (f acc (first lst)) (rest lst))))
-
-(define
-  (hk-foldr f z lst)
-  (if
-    (= (len lst) 0)
-    z
-    (f (first lst) (hk-foldr f z (rest lst)))))
-
-(define
-  (hk-scanl f acc lst)
-  (if
-    (= (len lst) 0)
-    (list acc)
-    (cons acc (hk-scanl f (f acc (first lst)) (rest lst)))))
-
-(define
-  (hk-replicate n x)
-  (if (= n 0) (list) (cons x (hk-replicate (- n 1) x))))
-
-(define
-  (hk-intersperse sep lst)
-  (if
-    (or (= (len lst) 0) (= (len lst) 1))
-    lst
-    (cons (first lst) (cons sep (hk-intersperse sep (rest lst))))))
-
-;; ===========================================================================
-;; 7. Maybe / Either ADTs
-;; ===========================================================================
-
-(define hk-nothing {:_maybe true :_tag "nothing"})
-(define (hk-just x) {:_maybe true :value x :_tag "just"})
-(define (hk-is-nothing? m) (= (get m :_tag) "nothing"))
-(define (hk-is-just? m) (= (get m :_tag) "just"))
-(define (hk-from-just m) (get m :value))
-(define (hk-from-maybe def m) (if (hk-is-nothing? m) def (hk-from-just m)))
-(define
-  (hk-maybe def f m)
-  (if (hk-is-nothing? m) def (f (hk-from-just m))))
-
-(define (hk-left x) {:value x :_either true :_tag "left"})
-(define (hk-right x) {:value x :_either true :_tag "right"})
-(define (hk-is-left? e) (= (get e :_tag) "left"))
-(define (hk-is-right? e) (= (get e :_tag) "right"))
-(define (hk-from-left e) (get e :value))
-(define (hk-from-right e) (get e :value))
-(define
-  (hk-either f g e)
-  (if (hk-is-left? e) (f (hk-from-left e)) (g (hk-from-right e))))
-
-;; ===========================================================================
-;; 8. Tuples (lists — list->vector unreliable in sx_server)
-;; ===========================================================================
-
-(define (hk-pair a b) (list a b))
-(define hk-fst first)
-(define (hk-snd t) (nth t 1))
-
-(define (hk-triple a b c) (list a b c))
-(define hk-fst3 first)
-(define (hk-snd3 t) (nth t 1))
-(define (hk-thd3 t) (nth t 2))
-
-(define (hk-curry f) (fn (a) (fn (b) (f a b))))
-(define (hk-uncurry f) (fn (p) (f (hk-fst p) (hk-snd p))))
-
-;; ===========================================================================
-;; 9. String helpers (Data.List / Data.Char for strings)
-;; ===========================================================================
-
-;; words: split on whitespace
-(define
-  (hk-words s)
-  (letrec
-    ((slen (len s))
-      (skip-ws
-        (fn
-          (i)
-          (if
-            (>= i slen)
-            (list)
-            (let
-              ((c (substring s i (+ i 1))))
-              (if
-                (or (= c " ") (= c "\t") (= c "\n"))
-                (skip-ws (+ i 1))
-                (collect-word i (+ i 1)))))))
-      (collect-word
-        (fn
-          (start i)
-          (if
-            (>= i slen)
-            (list (substring s start i))
-            (let
-              ((c (substring s i (+ i 1))))
-              (if
-                (or (= c " ") (= c "\t") (= c "\n"))
-                (cons (substring s start i) (skip-ws (+ i 1)))
-                (collect-word start (+ i 1))))))))
-    (skip-ws 0)))
-
-;; unwords: join with spaces
-(define
-  (hk-unwords lst)
-  (if
-    (= (len lst) 0)
-    ""
-    (reduce (fn (a b) (str a " " b)) (first lst) (rest lst))))
-
-;; lines: split on newline
-(define
-  (hk-lines s)
-  (letrec
-    ((slen (len s))
-      (go
-        (fn
-          (start i acc)
-          (if
-            (>= i slen)
-            (reverse (cons (substring s start i) acc))
-            (if
-              (= (substring s i (+ i 1)) "\n")
-              (go
-                (+ i 1)
-                (+ i 1)
-                (cons (substring s start i) acc))
-              (go start (+ i 1) acc))))))
-    (if (= slen 0) (list) (go 0 0 (list)))))
-
-;; unlines: join, each with trailing newline
-(define (hk-unlines lst) (reduce (fn (a b) (str a b "\n")) "" lst))
-
-;; isPrefixOf
-(define
-  (hk-is-prefix-of pre s)
-  (and (<= (len pre) (len s)) (= pre (substring s 0 (len pre)))))
-
-;; isSuffixOf
-(define
-  (hk-is-suffix-of suf s)
-  (let
-    ((sl (len suf)) (tl (len s)))
-    (and (<= sl tl) (= suf (substring s (- tl sl) tl)))))
-
-;; isInfixOf — linear scan
-(define
-  (hk-is-infix-of pat s)
-  (let
-    ((plen (len pat)) (slen (len s)))
-    (letrec
-      ((go (fn (i) (if (> (+ i plen) slen) false (if (= pat (substring s i (+ i plen))) true (go (+ i 1)))))))
-      (if (= plen 0) true (go 0)))))
-
-;; ===========================================================================
-;; 10. Show helper
-;; ===========================================================================
-
-(define
-  (hk-show x)
-  (cond
-    ((= x nil) "Nothing")
-    ((= x true) "True")
-    ((= x false) "False")
-    ((hk-rational? x) (hk-show-rational x))
-    ((integer? x) (str x))
-    ((float? x) (str x))
-    ((= (type-of x) "string") (str "\"" x "\""))
-    ((= (type-of x) "char") (str "'" (str x) "'"))
-    ((list? x)
-      (str
-        "["
-        (if
-          (= (len x) 0)
-          ""
-          (reduce
-            (fn (a b) (str a "," (hk-show b)))
-            (hk-show (first x))
-            (rest x)))
-        "]"))
-    (else (str x))))
--- a/lib/haskell/test.sh
+++ b/lib/haskell/test.sh
@@ -46,7 +46,6 @@ for FILE in "${FILES[@]}"; do
  cat > "$TMPFILE" <<EPOCHS
 (epoch 1)
 (load "lib/haskell/tokenizer.sx")
-(load "lib/haskell/runtime.sx")
 (epoch 2)
 (load "$FILE")
 (epoch 3)
@@ -82,7 +81,6 @@ EPOCHS
    cat > "$TMPFILE2" <<EPOCHS
 (epoch 1)
 (load "lib/haskell/tokenizer.sx")
-(load "lib/haskell/runtime.sx")
 (epoch 2)
 (load "$FILE")
 (epoch 3)
--- a/lib/haskell/tests/runtime.sx
+++ b/lib/haskell/tests/runtime.sx
@@ -1,451 +0,0 @@
-;; lib/haskell/tests/runtime.sx — smoke-tests for lib/haskell/runtime.sx
-;;
-;; Uses the same hk-test framework as tests/parse.sx.
-;; Loaded by test.sh after: tokenizer.sx + runtime.sx are pre-loaded.
-
-;; ---------------------------------------------------------------------------
-;; Test framework boilerplate (mirrors parse.sx)
-;; ---------------------------------------------------------------------------
-
-(define hk-test-pass 0)
-(define hk-test-fail 0)
-(define hk-test-fails (list))
-
-(define
-  (hk-test name actual expected)
-  (if
-    (= actual expected)
-    (set! hk-test-pass (+ hk-test-pass 1))
-    (do
-      (set! hk-test-fail (+ hk-test-fail 1))
-      (append! hk-test-fails {:actual actual :expected expected :name name}))))
-
-;; ---------------------------------------------------------------------------
-;; 1. Numeric type class helpers
-;; ---------------------------------------------------------------------------
-
-(hk-test "is-integer? int" (hk-is-integer? 42) true)
-(hk-test "is-integer? float" (hk-is-integer? 1.5) false)
-(hk-test "is-float? float" (hk-is-float? 3.14) true)
-(hk-test "is-float? int" (hk-is-float? 3) false)
-(hk-test "is-num? int" (hk-is-num? 10) true)
-(hk-test "is-num? float" (hk-is-num? 1) true)
-
-(hk-test "to-float" (hk-to-float 5) 5)
-(hk-test "to-integer trunc" (hk-to-integer 3.7) 3)
-
-(hk-test "div pos pos" (hk-div 7 2) 3)
-(hk-test "div neg pos" (hk-div -7 2) -4)
-(hk-test "div pos neg" (hk-div 7 -2) -4)
-(hk-test "div neg neg" (hk-div -7 -2) 3)
-(hk-test "div exact" (hk-div 6 2) 3)
-
-(hk-test "mod pos pos" (hk-mod 10 3) 1)
-(hk-test "mod neg pos" (hk-mod -7 3) 2)
-(hk-test "rem pos pos" (hk-rem 10 3) 1)
-(hk-test "rem neg pos" (hk-rem -7 3) -1)
-
-(hk-test "abs pos" (hk-abs 5) 5)
-(hk-test "abs neg" (hk-abs -5) 5)
-(hk-test "signum pos" (hk-signum 42) 1)
-(hk-test "signum neg" (hk-signum -7) -1)
-(hk-test "signum zero" (hk-signum 0) 0)
-
-(hk-test "gcd" (hk-gcd 12 8) 4)
-(hk-test "lcm" (hk-lcm 4 6) 12)
-(hk-test "even?" (hk-even? 4) true)
-(hk-test "even? odd" (hk-even? 3) false)
-(hk-test "odd?" (hk-odd? 7) true)
-
-;; ---------------------------------------------------------------------------
-;; 2. Rational numbers
-;; ---------------------------------------------------------------------------
-
-(let
-  ((r (hk-make-rational 1 2)))
-  (do
-    (hk-test "rational?" (hk-rational? r) true)
-    (hk-test "numerator" (hk-numerator r) 1)
-    (hk-test "denominator" (hk-denominator r) 2)))
-
-(let
-  ((r (hk-make-rational 2 4)))
-  (do
-    (hk-test "rat normalise num" (hk-numerator r) 1)
-    (hk-test "rat normalise den" (hk-denominator r) 2)))
-
-(let
-  ((sum (hk-rational-add (hk-make-rational 1 2) (hk-make-rational 1 3))))
-  (do
-    (hk-test "rat-add num" (hk-numerator sum) 5)
-    (hk-test "rat-add den" (hk-denominator sum) 6)))
-
-(hk-test
-  "rat-to-float"
-  (hk-rational-to-float (hk-make-rational 1 2))
-  0.5)
-(hk-test "rational? int" (hk-rational? 42) false)
-
-;; ---------------------------------------------------------------------------
-;; 3. Lazy evaluation (promises via SX delay)
-;; ---------------------------------------------------------------------------
-
-(let
-  ((p (delay 42)))
-  (hk-test "force promise" (hk-force p) 42))
-
-(hk-test "force non-promise" (hk-force 99) 99)
-
-;; ---------------------------------------------------------------------------
-;; 4. Char utilities — compare via hk-ord to avoid = on char type
-;; ---------------------------------------------------------------------------
-
-(hk-test "ord A" (hk-ord (integer->char 65)) 65)
-(hk-test "chr 65" (hk-ord (hk-chr 65)) 65)
-(hk-test "is-alpha? A" (hk-is-alpha? (integer->char 65)) true)
-(hk-test "is-alpha? 0" (hk-is-alpha? (integer->char 48)) false)
-(hk-test "is-digit? 5" (hk-is-digit? (integer->char 53)) true)
-(hk-test "is-digit? A" (hk-is-digit? (integer->char 65)) false)
-(hk-test "is-upper? A" (hk-is-upper? (integer->char 65)) true)
-(hk-test "is-upper? a" (hk-is-upper? (integer->char 97)) false)
-(hk-test "is-lower? a" (hk-is-lower? (integer->char 97)) true)
-(hk-test "is-space? spc" (hk-is-space? (integer->char 32)) true)
-(hk-test "is-space? A" (hk-is-space? (integer->char 65)) false)
-(hk-test
-  "to-upper a"
-  (hk-ord (hk-to-upper (integer->char 97)))
-  65)
-(hk-test
-  "to-lower A"
-  (hk-ord (hk-to-lower (integer->char 65)))
-  97)
-(hk-test
-  "digit-to-int 0"
-  (hk-digit-to-int (integer->char 48))
-  0)
-(hk-test
-  "digit-to-int 9"
-  (hk-digit-to-int (integer->char 57))
-  9)
-(hk-test
-  "digit-to-int a"
-  (hk-digit-to-int (integer->char 97))
-  10)
-(hk-test
-  "digit-to-int F"
-  (hk-digit-to-int (integer->char 70))
-  15)
-(hk-test "int-to-digit 0" (hk-ord (hk-int-to-digit 0)) 48)
-(hk-test "int-to-digit 10" (hk-ord (hk-int-to-digit 10)) 97)
-
-;; ---------------------------------------------------------------------------
-;; 5. Data.Set
-;; ---------------------------------------------------------------------------
-
-(hk-test "set-empty is set?" (hk-set? (hk-set-empty)) true)
-(hk-test "set-null? empty" (hk-set-null? (hk-set-empty)) true)
-
-(let
-  ((s (hk-set-singleton 42)))
-  (do
-    (hk-test "singleton member" (hk-set-member? 42 s) true)
-    (hk-test "singleton size" (hk-set-size s) 1)))
-
-(let
-  ((s (hk-set-from-list (list 1 2 3))))
-  (do
-    (hk-test "from-list member" (hk-set-member? 2 s) true)
-    (hk-test "from-list absent" (hk-set-member? 9 s) false)
-    (hk-test "from-list size" (hk-set-size s) 3)))
-
-;; ---------------------------------------------------------------------------
-;; 6. Data.List
-;; ---------------------------------------------------------------------------
-
-(hk-test "head" (hk-head (list 1 2 3)) 1)
-(hk-test
-  "tail length"
-  (len (hk-tail (list 1 2 3)))
-  2)
-(hk-test "null? empty" (hk-null? (list)) true)
-(hk-test "null? non-empty" (hk-null? (list 1)) false)
-(hk-test
-  "length"
-  (hk-length (list 1 2 3))
-  3)
-
-(hk-test
-  "take 2"
-  (hk-take 2 (list 1 2 3))
-  (list 1 2))
-(hk-test "take 0" (hk-take 0 (list 1 2)) (list))
-(hk-test
-  "take overflow"
-  (hk-take 5 (list 1 2))
-  (list 1 2))
-(hk-test
-  "drop 1"
-  (hk-drop 1 (list 1 2 3))
-  (list 2 3))
-(hk-test
-  "drop 0"
-  (hk-drop 0 (list 1 2))
-  (list 1 2))
-
-(hk-test
-  "take-while"
-  (hk-take-while
-    (fn (x) (< x 3))
-    (list 1 2 3 4))
-  (list 1 2))
-(hk-test
-  "drop-while"
-  (hk-drop-while
-    (fn (x) (< x 3))
-    (list 1 2 3 4))
-  (list 3 4))
-
-(hk-test
-  "zip"
-  (hk-zip (list 1 2) (list 3 4))
-  (list (list 1 3) (list 2 4)))
-(hk-test
-  "zip uneven"
-  (hk-zip
-    (list 1 2 3)
-    (list 4 5))
-  (list (list 1 4) (list 2 5)))
-
-(hk-test
-  "zip-with +"
-  (hk-zip-with
-    +
-    (list 1 2 3)
-    (list 10 20 30))
-  (list 11 22 33))
-
-(hk-test
-  "unzip fst"
-  (first
-    (hk-unzip
-      (list (list 1 3) (list 2 4))))
-  (list 1 2))
-(hk-test
-  "unzip snd"
-  (nth
-    (hk-unzip
-      (list (list 1 3) (list 2 4)))
-    1)
-  (list 3 4))
-
-(hk-test
-  "elem hit"
-  (hk-elem 2 (list 1 2 3))
-  true)
-(hk-test
-  "elem miss"
-  (hk-elem 9 (list 1 2 3))
-  false)
-(hk-test
-  "not-elem"
-  (hk-not-elem 9 (list 1 2 3))
-  true)
-
-(hk-test
-  "nub"
-  (hk-nub (list 1 2 1 3 2))
-  (list 1 2 3))
-
-(hk-test
-  "sum"
-  (hk-sum (list 1 2 3 4))
-  10)
-(hk-test
-  "product"
-  (hk-product (list 1 2 3 4))
-  24)
-(hk-test
-  "maximum"
-  (hk-maximum (list 3 1 4 1 5))
-  5)
-(hk-test
-  "minimum"
-  (hk-minimum (list 3 1 4 1 5))
-  1)
-
-(hk-test
-  "concat"
-  (hk-concat
-    (list (list 1 2) (list 3 4)))
-  (list 1 2 3 4))
-(hk-test
-  "concat-map"
-  (hk-concat-map
-    (fn (x) (list x (* x x)))
-    (list 1 2 3))
-  (list 1 1 2 4 3 9))
-
-(hk-test
-  "sort"
-  (hk-sort (list 3 1 4 1 5))
-  (list 1 1 3 4 5))
-(hk-test
-  "replicate"
-  (hk-replicate 3 0)
-  (list 0 0 0))
-(hk-test "replicate 0" (hk-replicate 0 99) (list))
-
-(hk-test
-  "intersperse"
-  (hk-intersperse 0 (list 1 2 3))
-  (list 1 0 2 0 3))
-(hk-test
-  "intersperse 1"
-  (hk-intersperse 0 (list 1))
-  (list 1))
-(hk-test "intersperse empty" (hk-intersperse 0 (list)) (list))
-
-(hk-test
-  "span"
-  (hk-span
-    (fn (x) (< x 3))
-    (list 1 2 3 4))
-  (list (list 1 2) (list 3 4)))
-(hk-test
-  "break"
-  (hk-break
-    (fn (x) (>= x 3))
-    (list 1 2 3 4))
-  (list (list 1 2) (list 3 4)))
-
-(hk-test
-  "foldl"
-  (hk-foldl
-    (fn (a b) (- a b))
-    10
-    (list 1 2 3))
-  4)
-(hk-test
-  "foldr"
-  (hk-foldr cons (list) (list 1 2 3))
-  (list 1 2 3))
-
-(hk-test
-  "scanl"
-  (hk-scanl + 0 (list 1 2 3))
-  (list 0 1 3 6))
-
-;; ---------------------------------------------------------------------------
-;; 7. Maybe / Either
-;; ---------------------------------------------------------------------------
-
-(hk-test "nothing is-nothing?" (hk-is-nothing? hk-nothing) true)
-(hk-test "nothing is-just?" (hk-is-just? hk-nothing) false)
-(hk-test "just is-just?" (hk-is-just? (hk-just 42)) true)
-(hk-test "just is-nothing?" (hk-is-nothing? (hk-just 42)) false)
-(hk-test "from-just" (hk-from-just (hk-just 99)) 99)
-(hk-test
-  "from-maybe nothing"
-  (hk-from-maybe 0 hk-nothing)
-  0)
-(hk-test
-  "from-maybe just"
-  (hk-from-maybe 0 (hk-just 42))
-  42)
-(hk-test
-  "maybe nothing"
-  (hk-maybe 0 (fn (x) (* x 2)) hk-nothing)
-  0)
-(hk-test
-  "maybe just"
-  (hk-maybe 0 (fn (x) (* x 2)) (hk-just 5))
-  10)
-
-(hk-test "left is-left?" (hk-is-left? (hk-left "e")) true)
-(hk-test "right is-right?" (hk-is-right? (hk-right 42)) true)
-(hk-test "from-right" (hk-from-right (hk-right 7)) 7)
-(hk-test
-  "either left"
-  (hk-either (fn (x) (str "L" x)) (fn (x) (str "R" x)) (hk-left "err"))
-  "Lerr")
-(hk-test
-  "either right"
-  (hk-either
-    (fn (x) (str "L" x))
-    (fn (x) (str "R" x))
-    (hk-right 42))
-  "R42")
-
-;; ---------------------------------------------------------------------------
-;; 8. Tuples
-;; ---------------------------------------------------------------------------
-
-(hk-test "pair" (hk-pair 1 2) (list 1 2))
-(hk-test "fst" (hk-fst (hk-pair 3 4)) 3)
-(hk-test "snd" (hk-snd (hk-pair 3 4)) 4)
-(hk-test
-  "triple"
-  (hk-triple 1 2 3)
-  (list 1 2 3))
-(hk-test
-  "fst3"
-  (hk-fst3 (hk-triple 7 8 9))
-  7)
-(hk-test
-  "thd3"
-  (hk-thd3 (hk-triple 7 8 9))
-  9)
-
-(hk-test "curry" ((hk-curry +) 3 4) 7)
-(hk-test
-  "uncurry"
-  ((hk-uncurry (fn (a b) (* a b))) (list 3 4))
-  12)
-
-;; ---------------------------------------------------------------------------
-;; 9. String helpers
-;; ---------------------------------------------------------------------------
-
-(hk-test "words" (hk-words "hello world") (list "hello" "world"))
-(hk-test "words leading ws" (hk-words "  foo bar") (list "foo" "bar"))
-(hk-test "words empty" (hk-words "") (list))
-(hk-test "unwords" (hk-unwords (list "a" "b" "c")) "a b c")
-(hk-test "unwords single" (hk-unwords (list "x")) "x")
-
-(hk-test "lines" (hk-lines "a\nb\nc") (list "a" "b" "c"))
-(hk-test "lines single" (hk-lines "hello") (list "hello"))
-(hk-test "unlines" (hk-unlines (list "a" "b")) "a\nb\n")
-
-(hk-test "is-prefix-of yes" (hk-is-prefix-of "he" "hello") true)
-(hk-test "is-prefix-of no" (hk-is-prefix-of "wo" "hello") false)
-(hk-test "is-prefix-of eq" (hk-is-prefix-of "hi" "hi") true)
-(hk-test "is-prefix-of empty" (hk-is-prefix-of "" "hi") true)
-
-(hk-test "is-suffix-of yes" (hk-is-suffix-of "lo" "hello") true)
-(hk-test "is-suffix-of no" (hk-is-suffix-of "he" "hello") false)
-(hk-test "is-suffix-of empty" (hk-is-suffix-of "" "hi") true)
-
-(hk-test "is-infix-of yes" (hk-is-infix-of "ell" "hello") true)
-(hk-test "is-infix-of no" (hk-is-infix-of "xyz" "hello") false)
-(hk-test "is-infix-of empty" (hk-is-infix-of "" "hello") true)
-
-;; ---------------------------------------------------------------------------
-;; 10. Show
-;; ---------------------------------------------------------------------------
-
-(hk-test "show nil" (hk-show nil) "Nothing")
-(hk-test "show true" (hk-show true) "True")
-(hk-test "show false" (hk-show false) "False")
-(hk-test "show int" (hk-show 42) "42")
-(hk-test "show string" (hk-show "hi") "\"hi\"")
-(hk-test
-  "show list"
-  (hk-show (list 1 2 3))
-  "[1,2,3]")
-(hk-test "show empty list" (hk-show (list)) "[]")
-
-;; ---------------------------------------------------------------------------
-;; Summary (required by test.sh — last expression is the return value)
-;; ---------------------------------------------------------------------------
-
-(list hk-test-pass hk-test-fail)
--- a/lib/js/conformance.sh
+++ b/lib/js/conformance.sh
@@ -49,8 +49,6 @@ trap "rm -f $TMPFILE" EXIT
  echo '(load "lib/js/transpile.sx")'
  echo '(epoch 5)'
  echo '(load "lib/js/runtime.sx")'
-  echo '(epoch 6)'
-  echo '(load "lib/js/regex.sx")'

  epoch=100
  for f in "${FIXTURES[@]}"; do
--- a/lib/js/regex.sx
+++ b/lib/js/regex.sx
@@ -1,943 +0,0 @@
-;; lib/js/regex.sx — pure-SX recursive backtracking regex engine
-;;
-;; Installed via (js-regex-platform-override! ...) at load time.
-;; Covers: character classes (\d\w\s . [abc] [^abc] [a-z]),
-;;   anchors (^ $ \b \B), quantifiers (* + ? {n,m} lazy variants),
-;;   groups (capturing + non-capturing), alternation (a|b),
-;;   flags: i (case-insensitive), g (global), m (multiline).
-;;
-;; Architecture:
-;;   1. rx-parse-pattern  — pattern string → compiled node list
-;;   2. rx-match-nodes    — recursive backtracker
-;;   3. rx-exec / rx-test — public interface
-;;   4. Install as {:test rx-test :exec rx-exec}
-
-;; ── Utilities ─────────────────────────────────────────────────────
-
-(define
-  rx-char-at
-  (fn (s i) (if (and (>= i 0) (< i (len s))) (char-at s i) "")))
-
-(define
-  rx-digit?
-  (fn
-    (c)
-    (and (not (= c "")) (>= (char-code c) 48) (<= (char-code c) 57))))
-
-(define
-  rx-word?
-  (fn
-    (c)
-    (and
-      (not (= c ""))
-      (or
-        (and (>= (char-code c) 65) (<= (char-code c) 90))
-        (and (>= (char-code c) 97) (<= (char-code c) 122))
-        (and (>= (char-code c) 48) (<= (char-code c) 57))
-        (= c "_")))))
-
-(define
-  rx-space?
-  (fn
-    (c)
-    (or (= c " ") (= c "\t") (= c "\n") (= c "\r") (= c "\\f") (= c ""))))
-
-(define rx-newline? (fn (c) (or (= c "\n") (= c "\r"))))
-
-(define
-  rx-downcase-char
-  (fn
-    (c)
-    (let
-      ((cc (char-code c)))
-      (if (and (>= cc 65) (<= cc 90)) (char-from-code (+ cc 32)) c))))
-
-(define
-  rx-char-eq?
-  (fn
-    (a b ci?)
-    (if ci? (= (rx-downcase-char a) (rx-downcase-char b)) (= a b))))
-
-(define
-  rx-parse-int
-  (fn
-    (pat i acc)
-    (let
-      ((c (rx-char-at pat i)))
-      (if
-        (rx-digit? c)
-        (rx-parse-int pat (+ i 1) (+ (* acc 10) (- (char-code c) 48)))
-        (list acc i)))))
-
-(define
-  rx-hex-digit-val
-  (fn
-    (c)
-    (cond
-      ((and (>= (char-code c) 48) (<= (char-code c) 57))
-        (- (char-code c) 48))
-      ((and (>= (char-code c) 65) (<= (char-code c) 70))
-        (+ 10 (- (char-code c) 65)))
-      ((and (>= (char-code c) 97) (<= (char-code c) 102))
-        (+ 10 (- (char-code c) 97)))
-      (else -1))))
-
-(define
-  rx-parse-hex-n
-  (fn
-    (pat i n acc)
-    (if
-      (= n 0)
-      (list (char-from-code acc) i)
-      (let
-        ((v (rx-hex-digit-val (rx-char-at pat i))))
-        (if
-          (< v 0)
-          (list (char-from-code acc) i)
-          (rx-parse-hex-n pat (+ i 1) (- n 1) (+ (* acc 16) v)))))))
-
-;; ── Pattern compiler ──────────────────────────────────────────────
-
-;; Node types (stored in dicts with "__t__" key):
-;;   literal  : {:__t__ "literal" :__c__ char}
-;;   any      : {:__t__ "any"}
-;;   class-d  : {:__t__ "class-d"  :__neg__ bool}
-;;   class-w  : {:__t__ "class-w"  :__neg__ bool}
-;;   class-s  : {:__t__ "class-s"  :__neg__ bool}
-;;   char-class: {:__t__ "char-class" :__neg__ bool :__items__ list}
-;;   anchor-start / anchor-end / anchor-word / anchor-nonword
-;;   quant    : {:__t__ "quant" :__node__ n :__min__ m :__max__ mx :__lazy__ bool}
-;;   group    : {:__t__ "group" :__idx__ i :__nodes__ list}
-;;   ncgroup  : {:__t__ "ncgroup" :__nodes__ list}
-;;   alt      : {:__t__ "alt" :__branches__ list-of-node-lists}
-
-;; parse one escape after `\`, returns (node new-i)
-(define
-  rx-parse-escape
-  (fn
-    (pat i)
-    (let
-      ((c (rx-char-at pat i)))
-      (cond
-        ((= c "d") (list (dict "__t__" "class-d" "__neg__" false) (+ i 1)))
-        ((= c "D") (list (dict "__t__" "class-d" "__neg__" true) (+ i 1)))
-        ((= c "w") (list (dict "__t__" "class-w" "__neg__" false) (+ i 1)))
-        ((= c "W") (list (dict "__t__" "class-w" "__neg__" true) (+ i 1)))
-        ((= c "s") (list (dict "__t__" "class-s" "__neg__" false) (+ i 1)))
-        ((= c "S") (list (dict "__t__" "class-s" "__neg__" true) (+ i 1)))
-        ((= c "b") (list (dict "__t__" "anchor-word") (+ i 1)))
-        ((= c "B") (list (dict "__t__" "anchor-nonword") (+ i 1)))
-        ((= c "n") (list (dict "__t__" "literal" "__c__" "\n") (+ i 1)))
-        ((= c "r") (list (dict "__t__" "literal" "__c__" "\r") (+ i 1)))
-        ((= c "t") (list (dict "__t__" "literal" "__c__" "\t") (+ i 1)))
-        ((= c "f") (list (dict "__t__" "literal" "__c__" "\\f") (+ i 1)))
-        ((= c "v") (list (dict "__t__" "literal" "__c__" "") (+ i 1)))
-        ((= c "u")
-          (let
-            ((res (rx-parse-hex-n pat (+ i 1) 4 0)))
-            (list (dict "__t__" "literal" "__c__" (nth res 0)) (nth res 1))))
-        ((= c "x")
-          (let
-            ((res (rx-parse-hex-n pat (+ i 1) 2 0)))
-            (list (dict "__t__" "literal" "__c__" (nth res 0)) (nth res 1))))
-        (else (list (dict "__t__" "literal" "__c__" c) (+ i 1)))))))
-
-;; parse a char-class item inside [...], returns (item new-i)
-(define
-  rx-parse-class-item
-  (fn
-    (pat i)
-    (let
-      ((c (rx-char-at pat i)))
-      (cond
-        ((= c "\\")
-          (let
-            ((esc (rx-parse-escape pat (+ i 1))))
-            (let
-              ((node (nth esc 0)) (ni (nth esc 1)))
-              (let
-                ((t (get node "__t__")))
-                (cond
-                  ((= t "class-d")
-                    (list
-                      (dict "kind" "class-d" "neg" (get node "__neg__"))
-                      ni))
-                  ((= t "class-w")
-                    (list
-                      (dict "kind" "class-w" "neg" (get node "__neg__"))
-                      ni))
-                  ((= t "class-s")
-                    (list
-                      (dict "kind" "class-s" "neg" (get node "__neg__"))
-                      ni))
-                  (else
-                    (let
-                      ((lc (get node "__c__")))
-                      (if
-                        (and
-                          (= (rx-char-at pat ni) "-")
-                          (not (= (rx-char-at pat (+ ni 1)) "]")))
-                        (let
-                          ((hi-c (rx-char-at pat (+ ni 1))))
-                          (list
-                            (dict "kind" "range" "lo" lc "hi" hi-c)
-                            (+ ni 2)))
-                        (list (dict "kind" "lit" "c" lc) ni)))))))))
-        (else
-          (if
-            (and
-              (not (= c ""))
-              (= (rx-char-at pat (+ i 1)) "-")
-              (not (= (rx-char-at pat (+ i 2)) "]"))
-              (not (= (rx-char-at pat (+ i 2)) "")))
-            (let
-              ((hi-c (rx-char-at pat (+ i 2))))
-              (list (dict "kind" "range" "lo" c "hi" hi-c) (+ i 3)))
-            (list (dict "kind" "lit" "c" c) (+ i 1))))))))
-
-(define
-  rx-parse-class-items
-  (fn
-    (pat i items)
-    (let
-      ((c (rx-char-at pat i)))
-      (if
-        (or (= c "]") (= c ""))
-        (list items i)
-        (let
-          ((res (rx-parse-class-item pat i)))
-          (begin
-            (append! items (nth res 0))
-            (rx-parse-class-items pat (nth res 1) items)))))))
-
-;; parse a sequence until stop-ch or EOF; returns (nodes new-i groups-count)
-(define
-  rx-parse-seq
-  (fn
-    (pat i stop-ch ds)
-    (let
-      ((c (rx-char-at pat i)))
-      (cond
-        ((= c "") (list (get ds "nodes") i (get ds "groups")))
-        ((= c stop-ch) (list (get ds "nodes") i (get ds "groups")))
-        ((= c "|") (rx-parse-alt-rest pat i ds))
-        (else
-          (let
-            ((res (rx-parse-atom pat i ds)))
-            (let
-              ((node (nth res 0)) (ni (nth res 1)) (ds2 (nth res 2)))
-              (let
-                ((qres (rx-parse-quant pat ni node)))
-                (begin
-                  (append! (get ds2 "nodes") (nth qres 0))
-                  (rx-parse-seq pat (nth qres 1) stop-ch ds2))))))))))
-
-;; when we hit | inside a sequence, collect all alternatives
-(define
-  rx-parse-alt-rest
-  (fn
-    (pat i ds)
-    (let
-      ((left-branch (get ds "nodes")) (branches (list)))
-      (begin
-        (append! branches left-branch)
-        (rx-parse-alt-branches pat i (get ds "groups") branches)))))
-
-(define
-  rx-parse-alt-branches
-  (fn
-    (pat i n-groups branches)
-    (let
-      ((new-nodes (list)) (ds2 (dict "groups" n-groups "nodes" new-nodes)))
-      (let
-        ((res (rx-parse-seq pat (+ i 1) "|" ds2)))
-        (begin
-          (append! branches (nth res 0))
-          (let
-            ((ni2 (nth res 1)) (g2 (nth res 2)))
-            (if
-              (= (rx-char-at pat ni2) "|")
-              (rx-parse-alt-branches pat ni2 g2 branches)
-              (list
-                (list (dict "__t__" "alt" "__branches__" branches))
-                ni2
-                g2))))))))
-
-;; parse quantifier suffix, returns (node new-i)
-(define
-  rx-parse-quant
-  (fn
-    (pat i node)
-    (let
-      ((c (rx-char-at pat i)))
-      (cond
-        ((= c "*")
-          (let
-            ((lazy? (= (rx-char-at pat (+ i 1)) "?")))
-            (list
-              (dict
-                "__t__"
-                "quant"
-                "__node__"
-                node
-                "__min__"
-                0
-                "__max__"
-                -1
-                "__lazy__"
-                lazy?)
-              (if lazy? (+ i 2) (+ i 1)))))
-        ((= c "+")
-          (let
-            ((lazy? (= (rx-char-at pat (+ i 1)) "?")))
-            (list
-              (dict
-                "__t__"
-                "quant"
-                "__node__"
-                node
-                "__min__"
-                1
-                "__max__"
-                -1
-                "__lazy__"
-                lazy?)
-              (if lazy? (+ i 2) (+ i 1)))))
-        ((= c "?")
-          (let
-            ((lazy? (= (rx-char-at pat (+ i 1)) "?")))
-            (list
-              (dict
-                "__t__"
-                "quant"
-                "__node__"
-                node
-                "__min__"
-                0
-                "__max__"
-                1
-                "__lazy__"
-                lazy?)
-              (if lazy? (+ i 2) (+ i 1)))))
-        ((= c "{")
-          (let
-            ((mres (rx-parse-int pat (+ i 1) 0)))
-            (let
-              ((mn (nth mres 0)) (mi (nth mres 1)))
-              (let
-                ((sep (rx-char-at pat mi)))
-                (cond
-                  ((= sep "}")
-                    (let
-                      ((lazy? (= (rx-char-at pat (+ mi 1)) "?")))
-                      (list
-                        (dict
-                          "__t__"
-                          "quant"
-                          "__node__"
-                          node
-                          "__min__"
-                          mn
-                          "__max__"
-                          mn
-                          "__lazy__"
-                          lazy?)
-                        (if lazy? (+ mi 2) (+ mi 1)))))
-                  ((= sep ",")
-                    (let
-                      ((c2 (rx-char-at pat (+ mi 1))))
-                      (if
-                        (= c2 "}")
-                        (let
-                          ((lazy? (= (rx-char-at pat (+ mi 2)) "?")))
-                          (list
-                            (dict
-                              "__t__"
-                              "quant"
-                              "__node__"
-                              node
-                              "__min__"
-                              mn
-                              "__max__"
-                              -1
-                              "__lazy__"
-                              lazy?)
-                            (if lazy? (+ mi 3) (+ mi 2))))
-                        (let
-                          ((mxres (rx-parse-int pat (+ mi 1) 0)))
-                          (let
-                            ((mx (nth mxres 0)) (mxi (nth mxres 1)))
-                            (let
-                              ((lazy? (= (rx-char-at pat (+ mxi 1)) "?")))
-                              (list
-                                (dict
-                                  "__t__"
-                                  "quant"
-                                  "__node__"
-                                  node
-                                  "__min__"
-                                  mn
-                                  "__max__"
-                                  mx
-                                  "__lazy__"
-                                  lazy?)
-                                (if lazy? (+ mxi 2) (+ mxi 1)))))))))
-                  (else (list node i)))))))
-        (else (list node i))))))
-
-;; parse one atom, returns (node new-i new-ds)
-(define
-  rx-parse-atom
-  (fn
-    (pat i ds)
-    (let
-      ((c (rx-char-at pat i)))
-      (cond
-        ((= c ".") (list (dict "__t__" "any") (+ i 1) ds))
-        ((= c "^") (list (dict "__t__" "anchor-start") (+ i 1) ds))
-        ((= c "$") (list (dict "__t__" "anchor-end") (+ i 1) ds))
-        ((= c "\\")
-          (let
-            ((esc (rx-parse-escape pat (+ i 1))))
-            (list (nth esc 0) (nth esc 1) ds)))
-        ((= c "[")
-          (let
-            ((neg? (= (rx-char-at pat (+ i 1)) "^")))
-            (let
-              ((start (if neg? (+ i 2) (+ i 1))) (items (list)))
-              (let
-                ((res (rx-parse-class-items pat start items)))
-                (let
-                  ((ci (nth res 1)))
-                  (list
-                    (dict
-                      "__t__"
-                      "char-class"
-                      "__neg__"
-                      neg?
-                      "__items__"
-                      items)
-                    (+ ci 1)
-                    ds))))))
-        ((= c "(")
-          (let
-            ((c2 (rx-char-at pat (+ i 1))))
-            (if
-              (and (= c2 "?") (= (rx-char-at pat (+ i 2)) ":"))
-              (let
-                ((inner-nodes (list))
-                  (inner-ds
-                    (dict "groups" (get ds "groups") "nodes" inner-nodes)))
-                (let
-                  ((res (rx-parse-seq pat (+ i 3) ")" inner-ds)))
-                  (list
-                    (dict "__t__" "ncgroup" "__nodes__" (nth res 0))
-                    (+ (nth res 1) 1)
-                    (dict "groups" (nth res 2) "nodes" (get ds "nodes")))))
-              (let
-                ((gidx (+ (get ds "groups") 1)) (inner-nodes (list)))
-                (let
-                  ((inner-ds (dict "groups" gidx "nodes" inner-nodes)))
-                  (let
-                    ((res (rx-parse-seq pat (+ i 1) ")" inner-ds)))
-                    (list
-                      (dict
-                        "__t__"
-                        "group"
-                        "__idx__"
-                        gidx
-                        "__nodes__"
-                        (nth res 0))
-                      (+ (nth res 1) 1)
-                      (dict "groups" (nth res 2) "nodes" (get ds "nodes")))))))))
-        (else (list (dict "__t__" "literal" "__c__" c) (+ i 1) ds))))))
-
-;; top-level compile
-(define
-  rx-compile
-  (fn
-    (pattern)
-    (let
-      ((nodes (list)) (ds (dict "groups" 0 "nodes" nodes)))
-      (let
-        ((res (rx-parse-seq pattern 0 "" ds)))
-        (dict "nodes" (nth res 0) "ngroups" (nth res 2))))))
-
-;; ── Matcher ───────────────────────────────────────────────────────
-
-;; Match a char-class item against character c
-(define
-  rx-item-matches?
-  (fn
-    (item c ci?)
-    (let
-      ((kind (get item "kind")))
-      (cond
-        ((= kind "lit") (rx-char-eq? c (get item "c") ci?))
-        ((= kind "range")
-          (let
-            ((lo (if ci? (rx-downcase-char (get item "lo")) (get item "lo")))
-              (hi
-                (if ci? (rx-downcase-char (get item "hi")) (get item "hi")))
-              (dc (if ci? (rx-downcase-char c) c)))
-            (and
-              (>= (char-code dc) (char-code lo))
-              (<= (char-code dc) (char-code hi)))))
-        ((= kind "class-d")
-          (let ((m (rx-digit? c))) (if (get item "neg") (not m) m)))
-        ((= kind "class-w")
-          (let ((m (rx-word? c))) (if (get item "neg") (not m) m)))
-        ((= kind "class-s")
-          (let ((m (rx-space? c))) (if (get item "neg") (not m) m)))
-        (else false)))))
-
-(define
-  rx-class-items-any?
-  (fn
-    (items c ci?)
-    (if
-      (empty? items)
-      false
-      (if
-        (rx-item-matches? (first items) c ci?)
-        true
-        (rx-class-items-any? (rest items) c ci?)))))
-
-(define
-  rx-class-matches?
-  (fn
-    (node c ci?)
-    (let
-      ((neg? (get node "__neg__")) (items (get node "__items__")))
-      (let
-        ((hit (rx-class-items-any? items c ci?)))
-        (if neg? (not hit) hit)))))
-
-;; Word boundary check
-(define
-  rx-is-word-boundary?
-  (fn
-    (s i slen)
-    (let
-      ((before (if (> i 0) (rx-word? (char-at s (- i 1))) false))
-        (after (if (< i slen) (rx-word? (char-at s i)) false)))
-      (not (= before after)))))
-
-;; ── Core matcher ──────────────────────────────────────────────────
-;;
-;; rx-match-nodes : nodes s i slen ci? mi? groups → end-pos or -1
-;;
-;; Matches `nodes` starting at position `i` in string `s`.
-;; Returns the position after the last character consumed, or -1 on failure.
-;; Mutates `groups` dict to record captures.
-
-(define
-  rx-match-nodes
-  (fn
-    (nodes s i slen ci? mi? groups)
-    (if
-      (empty? nodes)
-      i
-      (let
-        ((node (first nodes)) (rest-nodes (rest nodes)))
-        (let
-          ((t (get node "__t__")))
-          (cond
-            ((= t "literal")
-              (if
-                (and
-                  (< i slen)
-                  (rx-char-eq? (char-at s i) (get node "__c__") ci?))
-                (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
-                -1))
-            ((= t "any")
-              (if
-                (and (< i slen) (not (rx-newline? (char-at s i))))
-                (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
-                -1))
-            ((= t "class-d")
-              (let
-                ((m (and (< i slen) (rx-digit? (char-at s i)))))
-                (if
-                  (if (get node "__neg__") (not m) m)
-                  (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
-                  -1)))
-            ((= t "class-w")
-              (let
-                ((m (and (< i slen) (rx-word? (char-at s i)))))
-                (if
-                  (if (get node "__neg__") (not m) m)
-                  (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
-                  -1)))
-            ((= t "class-s")
-              (let
-                ((m (and (< i slen) (rx-space? (char-at s i)))))
-                (if
-                  (if (get node "__neg__") (not m) m)
-                  (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
-                  -1)))
-            ((= t "char-class")
-              (if
-                (and (< i slen) (rx-class-matches? node (char-at s i) ci?))
-                (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
-                -1))
-            ((= t "anchor-start")
-              (if
-                (or
-                  (= i 0)
-                  (and mi? (rx-newline? (rx-char-at s (- i 1)))))
-                (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-                -1))
-            ((= t "anchor-end")
-              (if
-                (or (= i slen) (and mi? (rx-newline? (rx-char-at s i))))
-                (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-                -1))
-            ((= t "anchor-word")
-              (if
-                (rx-is-word-boundary? s i slen)
-                (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-                -1))
-            ((= t "anchor-nonword")
-              (if
-                (not (rx-is-word-boundary? s i slen))
-                (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-                -1))
-            ((= t "group")
-              (let
-                ((gidx (get node "__idx__"))
-                  (inner (get node "__nodes__")))
-                (let
-                  ((g-end (rx-match-nodes inner s i slen ci? mi? groups)))
-                  (if
-                    (>= g-end 0)
-                    (begin
-                      (dict-set!
-                        groups
-                        (js-to-string gidx)
-                        (substring s i g-end))
-                      (let
-                        ((final-end (rx-match-nodes rest-nodes s g-end slen ci? mi? groups)))
-                        (if
-                          (>= final-end 0)
-                          final-end
-                          (begin
-                            (dict-set! groups (js-to-string gidx) nil)
-                            -1))))
-                    -1))))
-            ((= t "ncgroup")
-              (let
-                ((inner (get node "__nodes__")))
-                (rx-match-nodes
-                  (append inner rest-nodes)
-                  s
-                  i
-                  slen
-                  ci?
-                  mi?
-                  groups)))
-            ((= t "alt")
-              (let
-                ((branches (get node "__branches__")))
-                (rx-try-branches branches rest-nodes s i slen ci? mi? groups)))
-            ((= t "quant")
-              (let
-                ((inner-node (get node "__node__"))
-                  (mn (get node "__min__"))
-                  (mx (get node "__max__"))
-                  (lazy? (get node "__lazy__")))
-                (if
-                  lazy?
-                  (rx-quant-lazy
-                    inner-node
-                    mn
-                    mx
-                    rest-nodes
-                    s
-                    i
-                    slen
-                    ci?
-                    mi?
-                    groups
-                    0)
-                  (rx-quant-greedy
-                    inner-node
-                    mn
-                    mx
-                    rest-nodes
-                    s
-                    i
-                    slen
-                    ci?
-                    mi?
-                    groups
-                    0))))
-            (else -1)))))))
-
-(define
-  rx-try-branches
-  (fn
-    (branches rest-nodes s i slen ci? mi? groups)
-    (if
-      (empty? branches)
-      -1
-      (let
-        ((res (rx-match-nodes (append (first branches) rest-nodes) s i slen ci? mi? groups)))
-        (if
-          (>= res 0)
-          res
-          (rx-try-branches (rest branches) rest-nodes s i slen ci? mi? groups))))))
-
-;; Greedy: expand as far as possible, then try rest from the longest match
-;; Strategy: recurse forward (extend first); only try rest when extension fails
-(define
-  rx-quant-greedy
-  (fn
-    (inner-node mn mx rest-nodes s i slen ci? mi? groups count)
-    (let
-      ((can-extend (and (< i slen) (or (= mx -1) (< count mx)))))
-      (if
-        can-extend
-        (let
-          ((ni (rx-match-one inner-node s i slen ci? mi? groups)))
-          (if
-            (>= ni 0)
-            (let
-              ((res (rx-quant-greedy inner-node mn mx rest-nodes s ni slen ci? mi? groups (+ count 1))))
-              (if
-                (>= res 0)
-                res
-                (if
-                  (>= count mn)
-                  (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-                  -1)))
-            (if
-              (>= count mn)
-              (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-              -1)))
-        (if
-          (>= count mn)
-          (rx-match-nodes rest-nodes s i slen ci? mi? groups)
-          -1)))))
-
-;; Lazy: try rest first, extend only if rest fails
-(define
-  rx-quant-lazy
-  (fn
-    (inner-node mn mx rest-nodes s i slen ci? mi? groups count)
-    (if
-      (>= count mn)
-      (let
-        ((res (rx-match-nodes rest-nodes s i slen ci? mi? groups)))
-        (if
-          (>= res 0)
-          res
-          (if
-            (and (< i slen) (or (= mx -1) (< count mx)))
-            (let
-              ((ni (rx-match-one inner-node s i slen ci? mi? groups)))
-              (if
-                (>= ni 0)
-                (rx-quant-lazy
-                  inner-node
-                  mn
-                  mx
-                  rest-nodes
-                  s
-                  ni
-                  slen
-                  ci?
-                  mi?
-                  groups
-                  (+ count 1))
-                -1))
-            -1)))
-      (if
-        (< i slen)
-        (let
-          ((ni (rx-match-one inner-node s i slen ci? mi? groups)))
-          (if
-            (>= ni 0)
-            (rx-quant-lazy
-              inner-node
-              mn
-              mx
-              rest-nodes
-              s
-              ni
-              slen
-              ci?
-              mi?
-              groups
-              (+ count 1))
-            -1))
-        -1))))
-
-;; Match a single node at position i, return new pos or -1
-(define
-  rx-match-one
-  (fn
-    (node s i slen ci? mi? groups)
-    (rx-match-nodes (list node) s i slen ci? mi? groups)))
-
-;; ── Engine entry points ───────────────────────────────────────────
-
-;; Try matching at exactly position i. Returns result dict or nil.
-(define
-  rx-try-at
-  (fn
-    (compiled s i slen ci? mi?)
-    (let
-      ((nodes (get compiled "nodes")) (ngroups (get compiled "ngroups")))
-      (let
-        ((groups (dict)))
-        (let
-          ((end (rx-match-nodes nodes s i slen ci? mi? groups)))
-          (if
-            (>= end 0)
-            (dict "start" i "end" end "groups" groups "ngroups" ngroups)
-            nil))))))
-
-;; Find first match scanning from search-start.
-(define
-  rx-find-from
-  (fn
-    (compiled s search-start slen ci? mi?)
-    (if
-      (> search-start slen)
-      nil
-      (let
-        ((res (rx-try-at compiled s search-start slen ci? mi?)))
-        (if
-          res
-          res
-          (rx-find-from compiled s (+ search-start 1) slen ci? mi?))))))
-
-;; Build exec result dict from raw match result
-(define
-  rx-build-exec-result
-  (fn
-    (s match-res)
-    (let
-      ((start (get match-res "start"))
-        (end (get match-res "end"))
-        (groups (get match-res "groups"))
-        (ngroups (get match-res "ngroups")))
-      (let
-        ((matched (substring s start end))
-          (caps (rx-build-captures groups ngroups 1)))
-        (dict "match" matched "index" start "input" s "groups" caps)))))
-
-(define
-  rx-build-captures
-  (fn
-    (groups ngroups idx)
-    (if
-      (> idx ngroups)
-      (list)
-      (let
-        ((cap (get groups (js-to-string idx))))
-        (cons
-          (if (= cap nil) :js-undefined cap)
-          (rx-build-captures groups ngroups (+ idx 1)))))))
-
-;; ── Public interface ──────────────────────────────────────────────
-
-;; Lazy compile: build NFA on first use, cache under "__compiled__"
-(define
-  rx-ensure-compiled!
-  (fn
-    (rx)
-    (if
-      (dict-has? rx "__compiled__")
-      (get rx "__compiled__")
-      (let
-        ((c (rx-compile (get rx "source"))))
-        (begin (dict-set! rx "__compiled__" c) c)))))
-
-(define
-  rx-test
-  (fn
-    (rx s)
-    (let
-      ((compiled (rx-ensure-compiled! rx))
-        (ci? (get rx "ignoreCase"))
-        (mi? (get rx "multiline"))
-        (slen (len s)))
-      (let
-        ((start (if (get rx "global") (let ((li (get rx "lastIndex"))) (if (number? li) li 0)) 0)))
-        (let
-          ((res (rx-find-from compiled s start slen ci? mi?)))
-          (if
-            (get rx "global")
-            (begin
-              (dict-set! rx "lastIndex" (if res (get res "end") 0))
-              (if res true false))
-            (if res true false)))))))
-
-(define
-  rx-exec
-  (fn
-    (rx s)
-    (let
-      ((compiled (rx-ensure-compiled! rx))
-        (ci? (get rx "ignoreCase"))
-        (mi? (get rx "multiline"))
-        (slen (len s)))
-      (let
-        ((start (if (get rx "global") (let ((li (get rx "lastIndex"))) (if (number? li) li 0)) 0)))
-        (let
-          ((res (rx-find-from compiled s start slen ci? mi?)))
-          (if
-            res
-            (begin
-              (when
-                (get rx "global")
-                (dict-set! rx "lastIndex" (get res "end")))
-              (rx-build-exec-result s res))
-            (begin
-              (when (get rx "global") (dict-set! rx "lastIndex" 0))
-              nil)))))))
-
-;; match-all for String.prototype.matchAll
-(define
-  js-regex-match-all
-  (fn
-    (rx s)
-    (let
-      ((compiled (rx-ensure-compiled! rx))
-        (ci? (get rx "ignoreCase"))
-        (mi? (get rx "multiline"))
-        (slen (len s))
-        (results (list)))
-      (rx-match-all-loop compiled s 0 slen ci? mi? results))))
-
-(define
-  rx-match-all-loop
-  (fn
-    (compiled s i slen ci? mi? results)
-    (if
-      (> i slen)
-      results
-      (let
-        ((res (rx-find-from compiled s i slen ci? mi?)))
-        (if
-          res
-          (begin
-            (append! results (rx-build-exec-result s res))
-            (let
-              ((next (get res "end")))
-              (rx-match-all-loop
-                compiled
-                s
-                (if (= next i) (+ i 1) next)
-                slen
-                ci?
-                mi?
-                results)))
-          results)))))
-
-;; ── Install platform ──────────────────────────────────────────────
-
-(js-regex-platform-override! "test" rx-test)
-(js-regex-platform-override! "exec" rx-exec)
--- a/lib/js/runtime.sx
+++ b/lib/js/runtime.sx
@@ -2032,15 +2032,7 @@
          (&rest args)
          (cond
            ((= (len args) 0) nil)
-            ((js-regex? (nth args 0))
-              (let
-                ((rx (nth args 0)))
-                (let
-                  ((impl (get __js_regex_platform__ "exec")))
-                  (if
-                    (js-undefined? impl)
-                    (js-regex-stub-exec rx s)
-                    (impl rx s)))))
+            ((js-regex? (nth args 0)) (js-regex-stub-exec (nth args 0) s))
            (else
              (let
                ((needle (js-to-string (nth args 0))))
@@ -2049,7 +2041,7 @@
                  (if
                    (= idx -1)
                    nil
-                    (let ((res (list))) (begin (append! res needle) res)))))))))
+                    (let ((res (list))) (append! res needle) res))))))))
      ((= name "at")
        (fn
          (i)
@@ -2107,20 +2099,6 @@
      ((= name "toWellFormed") (fn () s))
      (else js-undefined))))

-(define __js_tdz_sentinel__ (dict "__tdz__" true))
-
-(define js-tdz? (fn (v) (and (dict? v) (dict-has? v "__tdz__"))))
-
-(define
-  js-tdz-check
-  (fn
-    (name val)
-    (if
-      (js-tdz? val)
-      (raise
-        (TypeError (str "Cannot access '" name "' before initialization")))
-      val)))
-
 (define
  js-string-slice
  (fn
--- a/lib/js/stdlib.sx
+++ b/lib/js/stdlib.sx
@@ -1,239 +0,0 @@
-;; lib/js/stdlib.sx — Phase 22 JS additions
-;;
-;; Adds to lib/js/runtime.sx (already loaded):
-;;   1. Bitwise binary ops (js-bitand/bitor/bitxor/lshift/rshift/urshift/bitnot)
-;;   2. Map class (arbitrary-key hash map via list of pairs)
-;;   3. Set class (uniqueness collection via SX make-set)
-;;   4. RegExp constructor (wraps js-regex-new already in runtime)
-;;   5. Wires Map / Set / RegExp into js-global
-
-;; ---------------------------------------------------------------------------
-;; 1. Bitwise binary ops
-;;    JS coerces operands to 32-bit signed int before applying the op.
-;;    Use truncate (not js-num-to-int) since integer / 0 crashes the evaluator.
-;; ---------------------------------------------------------------------------
-
-(define
-  (js-bitand a b)
-  (bitwise-and (truncate (js-to-number a)) (truncate (js-to-number b))))
-
-(define
-  (js-bitor a b)
-  (bitwise-or (truncate (js-to-number a)) (truncate (js-to-number b))))
-
-(define
-  (js-bitxor a b)
-  (bitwise-xor (truncate (js-to-number a)) (truncate (js-to-number b))))
-
-;; << : left-shift by (b mod 32) positions
-(define
-  (js-lshift a b)
-  (arithmetic-shift
-    (truncate (js-to-number a))
-    (modulo (truncate (js-to-number b)) 32)))
-
-;; >> : arithmetic right-shift (sign-extending)
-(define
-  (js-rshift a b)
-  (arithmetic-shift
-    (truncate (js-to-number a))
-    (- 0 (modulo (truncate (js-to-number b)) 32))))
-
-;; >>> : logical right-shift (zero-extending)
-;;   Convert to uint32 first, then divide by 2^n.
-(define
-  (js-urshift a b)
-  (let
-    ((u32 (modulo (truncate (js-to-number a)) 4294967296))
-      (n (modulo (truncate (js-to-number b)) 32)))
-    (quotient u32 (arithmetic-shift 1 n))))
-
-;; ~ : bitwise NOT — equivalent to -(n+1) in 32-bit signed arithmetic
-(define (js-bitnot a) (bitwise-not (truncate (js-to-number a))))
-
-;; ---------------------------------------------------------------------------
-;; 2. Map class
-;;    Stored as {:__js_map__ true :size N :_pairs (list (list key val) ...)}
-;;    Mutation via dict-set! on the underlying dict.
-;; ---------------------------------------------------------------------------
-
-(define
-  (js-map-new)
-  (let
-    ((m (dict)))
-    (dict-set! m "__js_map__" true)
-    (dict-set! m "size" 0)
-    (dict-set! m "_pairs" (list))
-    m))
-
-(define (js-map? v) (and (dict? v) (dict-has? v "__js_map__")))
-
-;; Linear scan for key using ===; returns index or -1
-(define
-  (js-map-find-idx pairs k)
-  (letrec
-    ((go (fn (ps i) (cond ((= (len ps) 0) -1) ((js-strict-eq (first (first ps)) k) i) (else (go (rest ps) (+ i 1)))))))
-    (go pairs 0)))
-
-(define
-  (js-map-get m k)
-  (letrec
-    ((go (fn (ps) (if (= (len ps) 0) js-undefined (if (js-strict-eq (first (first ps)) k) (nth (first ps) 1) (go (rest ps)))))))
-    (go (get m "_pairs"))))
-
-;; Replace element at index i in list
-(define
-  (js-list-set-nth lst i newval)
-  (letrec
-    ((go (fn (ps j) (if (= (len ps) 0) (list) (cons (if (= j i) newval (first ps)) (go (rest ps) (+ j 1)))))))
-    (go lst 0)))
-
-;; Remove element at index i from list
-(define
-  (js-list-remove-nth lst i)
-  (letrec
-    ((go (fn (ps j) (if (= (len ps) 0) (list) (if (= j i) (go (rest ps) (+ j 1)) (cons (first ps) (go (rest ps) (+ j 1))))))))
-    (go lst 0)))
-
-(define
-  (js-map-set! m k v)
-  (let
-    ((pairs (get m "_pairs")) (idx (js-map-find-idx (get m "_pairs") k)))
-    (if
-      (= idx -1)
-      (begin
-        (dict-set! m "_pairs" (append pairs (list (list k v))))
-        (dict-set! m "size" (+ (get m "size") 1)))
-      (dict-set! m "_pairs" (js-list-set-nth pairs idx (list k v)))))
-  m)
-
-(define
-  (js-map-has m k)
-  (not (= (js-map-find-idx (get m "_pairs") k) -1)))
-
-(define
-  (js-map-delete! m k)
-  (let
-    ((idx (js-map-find-idx (get m "_pairs") k)))
-    (when
-      (not (= idx -1))
-      (dict-set! m "_pairs" (js-list-remove-nth (get m "_pairs") idx))
-      (dict-set! m "size" (- (get m "size") 1))))
-  m)
-
-(define
-  (js-map-clear! m)
-  (dict-set! m "_pairs" (list))
-  (dict-set! m "size" 0)
-  m)
-
-(define (js-map-keys m) (map first (get m "_pairs")))
-(define
-  (js-map-vals m)
-  (map (fn (p) (nth p 1)) (get m "_pairs")))
-(define (js-map-entries m) (get m "_pairs"))
-
-(define
-  (js-map-for-each m cb)
-  (for-each
-    (fn (p) (cb (nth p 1) (first p) m))
-    (get m "_pairs"))
-  js-undefined)
-
-;; Map method dispatch (called from js-object-method-call in runtime)
-(define
-  (js-map-method m name args)
-  (cond
-    ((= name "set")
-      (js-map-set! m (nth args 0) (nth args 1)))
-    ((= name "get") (js-map-get m (nth args 0)))
-    ((= name "has") (js-map-has m (nth args 0)))
-    ((= name "delete") (js-map-delete! m (nth args 0)))
-    ((= name "clear") (js-map-clear! m))
-    ((= name "keys") (js-map-keys m))
-    ((= name "values") (js-map-vals m))
-    ((= name "entries") (js-map-entries m))
-    ((= name "forEach") (js-map-for-each m (nth args 0)))
-    ((= name "toString") "[object Map]")
-    (else js-undefined)))
-
-(define Map {:__callable__ (fn (&rest args) (let ((m (js-map-new))) (when (and (> (len args) 0) (list? (nth args 0))) (for-each (fn (entry) (js-map-set! m (nth entry 0) (nth entry 1))) (nth args 0))) m)) :prototype {:entries (fn (&rest a) (js-map-entries (js-this))) :delete (fn (&rest a) (js-map-delete! (js-this) (nth a 0))) :get (fn (&rest a) (js-map-get (js-this) (nth a 0))) :values (fn (&rest a) (js-map-vals (js-this))) :toString (fn () "[object Map]") :has (fn (&rest a) (js-map-has (js-this) (nth a 0))) :set (fn (&rest a) (js-map-set! (js-this) (nth a 0) (nth a 1))) :forEach (fn (&rest a) (js-map-for-each (js-this) (nth a 0))) :clear (fn (&rest a) (js-map-clear! (js-this))) :keys (fn (&rest a) (js-map-keys (js-this)))}})
-
-;; ---------------------------------------------------------------------------
-;; 3. Set class
-;;    {:__js_set__ true :size N :_set <sx-set>}
-;;    Note: set-member?/set-add!/set-remove! all take (set item) order.
-;; ---------------------------------------------------------------------------
-
-(define
-  (js-set-new)
-  (let
-    ((s (dict)))
-    (dict-set! s "__js_set__" true)
-    (dict-set! s "size" 0)
-    (dict-set! s "_set" (make-set))
-    s))
-
-(define (js-set? v) (and (dict? v) (dict-has? v "__js_set__")))
-
-(define
-  (js-set-add! s v)
-  (let
-    ((sx (get s "_set")))
-    (when
-      (not (set-member? sx v))
-      (set-add! sx v)
-      (dict-set! s "size" (+ (get s "size") 1))))
-  s)
-
-(define (js-set-has s v) (set-member? (get s "_set") v))
-
-(define
-  (js-set-delete! s v)
-  (let
-    ((sx (get s "_set")))
-    (when
-      (set-member? sx v)
-      (set-remove! sx v)
-      (dict-set! s "size" (- (get s "size") 1))))
-  s)
-
-(define
-  (js-set-clear! s)
-  (dict-set! s "_set" (make-set))
-  (dict-set! s "size" 0)
-  s)
-
-(define (js-set-vals s) (set->list (get s "_set")))
-
-(define
-  (js-set-for-each s cb)
-  (for-each (fn (v) (cb v v s)) (set->list (get s "_set")))
-  js-undefined)
-
-(define Set {:__callable__ (fn (&rest args) (let ((s (js-set-new))) (when (and (> (len args) 0) (list? (nth args 0))) (for-each (fn (v) (js-set-add! s v)) (nth args 0))) s)) :prototype {:entries (fn (&rest a) (map (fn (v) (list v v)) (js-set-vals (js-this)))) :delete (fn (&rest a) (js-set-delete! (js-this) (nth a 0))) :values (fn (&rest a) (js-set-vals (js-this))) :add (fn (&rest a) (js-set-add! (js-this) (nth a 0))) :toString (fn () "[object Set]") :has (fn (&rest a) (js-set-has (js-this) (nth a 0))) :forEach (fn (&rest a) (js-set-for-each (js-this) (nth a 0))) :clear (fn (&rest a) (js-set-clear! (js-this))) :keys (fn (&rest a) (js-set-vals (js-this)))}})
-
-;; ---------------------------------------------------------------------------
-;; 4. RegExp constructor — callable lambda wrapping js-regex-new
-;; ---------------------------------------------------------------------------
-
-(define
-  RegExp
-  (fn
-    (&rest args)
-    (cond
-      ((= (len args) 0) (js-regex-new "" ""))
-      ((= (len args) 1)
-        (js-regex-new (js-to-string (nth args 0)) ""))
-      (else
-        (js-regex-new
-          (js-to-string (nth args 0))
-          (js-to-string (nth args 1)))))))
-
-;; ---------------------------------------------------------------------------
-;; 5. Wire new globals into js-global
-;; ---------------------------------------------------------------------------
-
-(dict-set! js-global "Map" Map)
-(dict-set! js-global "Set" Set)
-(dict-set! js-global "RegExp" RegExp)
--- a/lib/js/test.sh
+++ b/lib/js/test.sh
@@ -33,10 +33,6 @@ cat > "$TMPFILE" << 'EPOCHS'
 (load "lib/js/transpile.sx")
 (epoch 5)
 (load "lib/js/runtime.sx")
-(epoch 6)
-(load "lib/js/regex.sx")
-(epoch 7)
-(load "lib/js/stdlib.sx")

 ;; ── Phase 0: stubs still behave ─────────────────────────────────
 (epoch 10)
@@ -1327,166 +1323,6 @@ cat > "$TMPFILE" << 'EPOCHS'
 (epoch 3505)
 (eval "(js-eval \"var a = {length: 3, 0: 10, 1: 20, 2: 30}; var sum = 0; Array.prototype.forEach.call(a, function(x){sum += x;}); sum\")")

-;; ── Phase 12: Regex engine ────────────────────────────────────────
-;; Platform is installed (test key is a function, not undefined)
-(epoch 5000)
-(eval "(js-undefined? (get __js_regex_platform__ \"test\"))")
-(epoch 5001)
-(eval "(js-eval \"/foo/.test('hi foo bar')\")")
-(epoch 5002)
-(eval "(js-eval \"/foo/.test('hi bar')\")")
-;; Case-insensitive flag
-(epoch 5003)
-(eval "(js-eval \"/FOO/i.test('hello foo world')\")")
-;; Anchors
-(epoch 5004)
-(eval "(js-eval \"/^hello/.test('hello world')\")")
-(epoch 5005)
-(eval "(js-eval \"/^hello/.test('say hello')\")")
-(epoch 5006)
-(eval "(js-eval \"/world$/.test('hello world')\")")
-;; Character classes
-(epoch 5007)
-(eval "(js-eval \"/\\\\d+/.test('abc 123')\")")
-(epoch 5008)
-(eval "(js-eval \"/\\\\w+/.test('hello')\")")
-(epoch 5009)
-(eval "(js-eval \"/[abc]/.test('dog')\")")
-(epoch 5010)
-(eval "(js-eval \"/[abc]/.test('cat')\")")
-;; Quantifiers
-(epoch 5011)
-(eval "(js-eval \"/a*b/.test('b')\")")
-(epoch 5012)
-(eval "(js-eval \"/a+b/.test('b')\")")
-(epoch 5013)
-(eval "(js-eval \"/a{2,3}/.test('aa')\")")
-(epoch 5014)
-(eval "(js-eval \"/a{2,3}/.test('a')\")")
-;; Dot
-(epoch 5015)
-(eval "(js-eval \"/h.llo/.test('hello')\")")
-(epoch 5016)
-(eval "(js-eval \"/h.llo/.test('hllo')\")")
-;; exec result
-(epoch 5017)
-(eval "(js-eval \"var m = /foo(\\\\w+)/.exec('foobar'); m.match\")")
-(epoch 5018)
-(eval "(js-eval \"var m = /foo(\\\\w+)/.exec('foobar'); m.index\")")
-(epoch 5019)
-(eval "(js-eval \"var m = /foo(\\\\w+)/.exec('foobar'); m.groups[0]\")")
-;; Alternation
-(epoch 5020)
-(eval "(js-eval \"/cat|dog/.test('I have a dog')\")")
-(epoch 5021)
-(eval "(js-eval \"/cat|dog/.test('I have a fish')\")")
-;; Non-capturing group
-(epoch 5022)
-(eval "(js-eval \"/(?:foo)+/.test('foofoo')\")")
-;; Negated char class
-(epoch 5023)
-(eval "(js-eval \"/[^abc]/.test('d')\")")
-(epoch 5024)
-(eval "(js-eval \"/[^abc]/.test('a')\")")
-;; Range inside char class
-(epoch 5025)
-(eval "(js-eval \"/[a-z]+/.test('hello')\")")
-;; Word boundary
-(epoch 5026)
-(eval "(js-eval \"/\\\\bword\\\\b/.test('a word here')\")")
-(epoch 5027)
-(eval "(js-eval \"/\\\\bword\\\\b/.test('password')\")")
-;; Lazy quantifier
-(epoch 5028)
-(eval "(js-eval \"var m = /a+?/.exec('aaa'); m.match\")")
-;; Global flag exec
-(epoch 5029)
-(eval "(js-eval \"var r=/\\\\d+/g; r.exec('a1b2'); r.exec('a1b2').match\")")
-;; String.prototype.match with regex
-(epoch 5030)
-(eval "(js-eval \"'hello world'.match(/\\\\w+/).match\")")
-;; String.prototype.search
-(epoch 5031)
-(eval "(js-eval \"'hello world'.search(/world/)\")")
-;; String.prototype.replace with regex
-(epoch 5032)
-(eval "(js-eval \"'hello world'.replace(/world/, 'there')\")")
-;; multiline anchor
-(epoch 5033)
-(eval "(js-eval \"/^bar/m.test('foo\\nbar')\")")
-
-;; ── Phase 13: let/const TDZ infrastructure ───────────────────────
-;; The TDZ sentinel and checker are defined in runtime.sx.
-;; let/const bindings work normally after initialization.
-(epoch 5100)
-(eval "(js-eval \"let x = 5; x\")")
-(epoch 5101)
-(eval "(js-eval \"const y = 42; y\")")
-;; TDZ sentinel exists and is detectable
-(epoch 5102)
-(eval "(js-tdz? __js_tdz_sentinel__)")
-;; js-tdz-check passes through non-sentinel values
-(epoch 5103)
-(eval "(js-tdz-check \"x\" 42)")
-
-;; ── Phase 22: Bitwise ops ────────────────────────────────────────
-(epoch 6000)
-(eval "(js-bitand 5 3)")
-(epoch 6001)
-(eval "(js-bitor 5 3)")
-(epoch 6002)
-(eval "(js-bitxor 5 3)")
-(epoch 6003)
-(eval "(js-lshift 1 4)")
-(epoch 6004)
-(eval "(js-rshift 32 2)")
-(epoch 6005)
-(eval "(js-rshift -8 1)")
-(epoch 6006)
-(eval "(js-urshift 4294967292 2)")
-(epoch 6007)
-(eval "(js-bitnot 0)")
-
-;; ── Phase 22: Map ─────────────────────────────────────────────────
-(epoch 6010)
-(eval "(js-map? (js-map-new))")
-(epoch 6011)
-(eval "(get (js-map-set! (js-map-new) \"k\" 42) \"size\")")
-(epoch 6012)
-(eval "(let ((m (js-map-new))) (js-map-set! m \"a\" 1) (js-map-get m \"a\"))")
-(epoch 6013)
-(eval "(let ((m (js-map-new))) (js-map-set! m \"x\" 9) (js-map-has m \"x\"))")
-(epoch 6014)
-(eval "(let ((m (js-map-new))) (js-map-set! m \"x\" 9) (js-map-has m \"y\"))")
-(epoch 6015)
-(eval "(let ((m (js-map-new))) (js-map-set! m \"a\" 1) (js-map-set! m \"b\" 2) (get m \"size\"))")
-(epoch 6016)
-(eval "(let ((m (js-map-new))) (js-map-set! m \"a\" 1) (js-map-delete! m \"a\") (get m \"size\"))")
-(epoch 6017)
-(eval "(let ((m (js-map-new))) (js-map-set! m \"a\" 1) (js-map-set! m \"a\" 99) (js-map-get m \"a\"))")
-
-;; ── Phase 22: Set ─────────────────────────────────────────────────
-(epoch 6020)
-(eval "(js-set? (js-set-new))")
-(epoch 6021)
-(eval "(let ((s (js-set-new))) (js-set-add! s 1) (js-set-has s 1))")
-(epoch 6022)
-(eval "(let ((s (js-set-new))) (js-set-add! s 1) (js-set-has s 2))")
-(epoch 6023)
-(eval "(let ((s (js-set-new))) (js-set-add! s 1) (js-set-add! s 1) (get s \"size\"))")
-(epoch 6024)
-(eval "(let ((s (js-set-new))) (js-set-add! s 1) (js-set-add! s 2) (get s \"size\"))")
-(epoch 6025)
-(eval "(let ((s (js-set-new))) (js-set-add! s 1) (js-set-delete! s 1) (get s \"size\"))")
-
-;; ── Phase 22: RegExp constructor ──────────────────────────────────
-(epoch 6030)
-(eval "(js-regex? (RegExp \"ab\" \"i\"))")
-(epoch 6031)
-(eval "(get (RegExp \"hello\" \"gi\") \"global\")")
-(epoch 6032)
-(eval "(get (RegExp \"foo\" \"i\") \"ignoreCase\")")
-
 EPOCHS


@@ -2206,81 +2042,6 @@ check 3503 "indexOf.call arrLike"          '1'
 check 3504 "filter.call arrLike"           '"2,3"'
 check 3505 "forEach.call arrLike sum"      '60'

-# ── Phase 12: Regex engine ────────────────────────────────────────
-check 5000 "regex platform installed"           'false'
-check 5001 "/foo/ matches"                      'true'
-check 5002 "/foo/ no match"                     'false'
-check 5003 "/FOO/i case-insensitive"            'true'
-check 5004 "/^hello/ anchor match"              'true'
-check 5005 "/^hello/ anchor no-match"           'false'
-check 5006 "/world$/ end anchor"                'true'
-check 5007 "/\\d+/ digit class"                 'true'
-check 5008 "/\\w+/ word class"                  'true'
-check 5009 "/[abc]/ class no-match"             'false'
-check 5010 "/[abc]/ class match"                'true'
-check 5011 "/a*b/ zero-or-more"                 'true'
-check 5012 "/a+b/ one-or-more no-match"         'false'
-check 5013 "/a{2,3}/ quant match"               'true'
-check 5014 "/a{2,3}/ quant no-match"            'false'
-check 5015 "dot matches any"                    'true'
-check 5016 "dot requires char"                  'false'
-check 5017 "exec match string"                  '"foobar"'
-check 5018 "exec match index"                   '0'
-check 5019 "exec capture group"                 '"bar"'
-check 5020 "alternation cat|dog match"          'true'
-check 5021 "alternation cat|dog no-match"       'false'
-check 5022 "non-capturing group"                'true'
-check 5023 "negated class match"                'true'
-check 5024 "negated class no-match"             'false'
-check 5025 "range [a-z]+"                       'true'
-check 5026 "word boundary match"                'true'
-check 5027 "word boundary no-match"             'false'
-check 5028 "lazy quantifier"                    '"a"'
-check 5029 "global exec advances"               '"2"'
-check 5030 "String.match regex"                 '"hello"'
-check 5031 "String.search regex"                '6'
-check 5032 "String.replace regex"               '"hello there"'
-check 5033 "multiline anchor"                   'true'
-
-# ── Phase 13: let/const TDZ infrastructure ───────────────────────
-check 5100 "let binding initialized"            '5'
-check 5101 "const binding initialized"          '42'
-check 5102 "TDZ sentinel is detectable"         'true'
-check 5103 "tdz-check passes non-sentinel"      '42'
-
-# ── Phase 22: Bitwise ops ─────────────────────────────────────────
-check 6000 "bitand 5&3"     '1'
-check 6001 "bitor 5|3"      '7'
-check 6002 "bitxor 5^3"     '6'
-check 6003 "lshift 1<<4"    '16'
-check 6004 "rshift 32>>2"   '8'
-check 6005 "rshift -8>>1"   '-4'
-check 6006 "urshift >>>"     '1073741823'
-check 6007 "bitnot ~0"      '-1'
-
-# ── Phase 22: Map ─────────────────────────────────────────────────
-check 6010 "map? new map"          'true'
-check 6011 "map set→size 1"        '1'
-check 6012 "map get existing"      '1'
-check 6013 "map has key yes"       'true'
-check 6014 "map has key no"        'false'
-check 6015 "map size 2 entries"    '2'
-check 6016 "map delete→size 0"     '0'
-check 6017 "map set overwrites"    '99'
-
-# ── Phase 22: Set ─────────────────────────────────────────────────
-check 6020 "set? new set"          'true'
-check 6021 "set has after add"     'true'
-check 6022 "set has absent"        'false'
-check 6023 "set dedup size"        '1'
-check 6024 "set size 2"            '2'
-check 6025 "set delete→size 0"     '0'
-
-# ── Phase 22: RegExp ──────────────────────────────────────────────
-check 6030 "RegExp? result"        'true'
-check 6031 "RegExp global flag"    'true'
-check 6032 "RegExp ignoreCase"     'true'
-
 TOTAL=$((PASS + FAIL))
 if [ $FAIL -eq 0 ]; then
  echo "✓ $PASS/$TOTAL JS-on-SX tests passed"
--- a/lib/js/test262-runner.py
+++ b/lib/js/test262-runner.py
@@ -798,7 +798,6 @@ class ServerSession:
        self._run_and_collect(3, '(load "lib/js/parser.sx")', timeout=60.0)
        self._run_and_collect(4, '(load "lib/js/transpile.sx")', timeout=60.0)
        self._run_and_collect(5, '(load "lib/js/runtime.sx")', timeout=60.0)
-        self._run_and_collect(50, '(load "lib/js/regex.sx")', timeout=60.0)
        # Preload the stub harness — use precomputed SX cache when available
        # (huge win: ~15s js-eval HARNESS_STUB → ~0s load precomputed .sx).
        cache_rel = _harness_cache_rel_path()
--- a/lib/js/transpile.sx
+++ b/lib/js/transpile.sx
@@ -935,12 +935,12 @@

 (define
  js-transpile-var
-  (fn (kind decls) (cons (js-sym "begin") (js-vardecl-forms kind decls))))
+  (fn (kind decls) (cons (js-sym "begin") (js-vardecl-forms decls))))

 (define
  js-vardecl-forms
  (fn
-    (kind decls)
+    (decls)
    (cond
      ((empty? decls) (list))
      (else
@@ -953,7 +953,7 @@
                  (js-sym "define")
                  (js-sym (nth d 1))
                  (js-transpile (nth d 2)))
-                (js-vardecl-forms kind (rest decls))))
+                (js-vardecl-forms (rest decls))))
            ((js-tag? d "js-vardecl-obj")
              (let
                ((names (nth d 1))
@@ -964,7 +964,7 @@
                  (js-vardecl-obj-forms
                    names
                    tmp-sym
-                    (js-vardecl-forms kind (rest decls))))))
+                    (js-vardecl-forms (rest decls))))))
            ((js-tag? d "js-vardecl-arr")
              (let
                ((names (nth d 1))
@@ -976,7 +976,7 @@
                    names
                    tmp-sym
                    0
-                    (js-vardecl-forms kind (rest decls))))))
+                    (js-vardecl-forms (rest decls))))))
            (else (error "js-vardecl-forms: unexpected decl"))))))))

 (define
--- a/lib/lua/runtime.sx
+++ b/lib/lua/runtime.sx
@@ -123,7 +123,7 @@
              (fn
                (i)
                (if
-                  (not (= (get a (str i)) nil))
+                  (has? a (str i))
                  (begin (set! n i) (count-loop (+ i 1)))
                  n)))
            (count-loop 1))))
@@ -152,9 +152,7 @@
                  (cond
                    ((= (first f) "pos")
                      (begin
-                        (set!
-                          t
-                          (assoc t (str array-idx) (nth f 1)))
+                        (set! t (assoc t (str array-idx) (nth f 1)))
                        (set! array-idx (+ array-idx 1))))
                    ((= (first f) "kv")
                      (let
@@ -171,108 +169,3 @@
    (if (= t nil) nil (let ((v (get t (str k)))) (if (= v nil) nil v)))))

 (define lua-set! (fn (t k v) (assoc t (str k) v)))
-
-;; ---------------------------------------------------------------------------
-;; Helpers for stdlib
-;; ---------------------------------------------------------------------------
-
-;; Apply a char function to every character in a string
-(define (lua-str-map s fn) (list->string (map fn (string->list s))))
-
-;; Repeat string s n times
-(define
-  (lua-str-rep s n)
-  (letrec
-    ((go (fn (acc i) (if (= i 0) acc (go (str acc s) (- i 1))))))
-    (go "" n)))
-
-;; Force a promise created by delay
-(define
-  (lua-force p)
-  (if
-    (and (dict? p) (get p :_promise))
-    (if (get p :forced) (get p :value) ((get p :thunk)))
-    p))
-
-;; ---------------------------------------------------------------------------
-;; math — Lua math library
-;; ---------------------------------------------------------------------------
-
-(define math {:asin asin :floor floor :exp exp :huge 1e+308 :tan tan :sqrt sqrt :log log :abs abs :ceil ceil :sin sin :max (fn (a b) (if (> a b) a b)) :acos acos :min (fn (a b) (if (< a b) a b)) :cos cos :pi 3.14159 :atan atan})
-
-;; ---------------------------------------------------------------------------
-;; string — Lua string library
-;; ---------------------------------------------------------------------------
-
-(define
-  (lua-string-find s pat)
-  (let
-    ((m (regexp-match (make-regexp pat) s)))
-    (if (= m nil) nil (list (+ (get m :start) 1) (get m :end)))))
-
-(define
-  (lua-string-match s pat)
-  (let
-    ((m (regexp-match (make-regexp pat) s)))
-    (if
-      (= m nil)
-      nil
-      (let
-        ((groups (get m :groups)))
-        (if (= (len groups) 0) (get m :match) (first groups))))))
-
-(define
-  (lua-string-gmatch s pat)
-  (map (fn (m) (get m :match)) (regexp-match-all (make-regexp pat) s)))
-
-(define
-  (lua-string-gsub s pat repl)
-  (regexp-replace-all (make-regexp pat) s repl))
-
-(define string {:rep lua-str-rep :sub (fn (s i &rest j-args) (let ((slen (len s)) (j (if (= (len j-args) 0) -1 (first j-args)))) (let ((from (if (< i 0) (let ((r (+ slen i))) (if (< r 0) 0 r)) (- i 1))) (to (if (< j 0) (let ((r (+ slen j 1))) (if (< r 0) 0 r)) (if (> j slen) slen j)))) (if (> from to) "" (substring s from to))))) :len (fn (s) (len s)) :upper (fn (s) (lua-str-map s char-upcase)) :char (fn (&rest codes) (list->string (map (fn (c) (integer->char (truncate c))) codes))) :gmatch lua-string-gmatch :gsub lua-string-gsub :lower (fn (s) (lua-str-map s char-downcase)) :byte (fn (s &rest args) (char->integer (nth (string->list s) (- (if (= (len args) 0) 1 (first args)) 1)))) :match lua-string-match :find lua-string-find :reverse (fn (s) (list->string (reverse (string->list s))))})
-
-;; ---------------------------------------------------------------------------
-;; table — Lua table library
-;; ---------------------------------------------------------------------------
-
-(define
-  (lua-table-insert t v)
-  (assoc t (str (+ (lua-len t) 1)) v))
-
-(define
-  (lua-table-remove t &rest args)
-  (let
-    ((n (lua-len t))
-      (pos (if (= (len args) 0) (lua-len t) (first args))))
-    (letrec
-      ((slide (fn (t i) (if (< i n) (assoc (slide t (+ i 1)) (str i) (lua-get t (+ i 1))) (assoc t (str n) nil)))))
-      (slide t pos))))
-
-(define
-  (lua-table-concat t &rest args)
-  (let
-    ((sep (if (= (len args) 0) "" (first args)))
-      (n (lua-len t)))
-    (letrec
-      ((go (fn (acc i) (if (> i n) acc (go (str acc (if (= i 1) "" sep) (lua-to-string (lua-get t i))) (+ i 1))))))
-      (go "" 1))))
-
-(define
-  (lua-table-sort t)
-  (let
-    ((n (lua-len t)))
-    (letrec
-      ((collect (fn (i acc) (if (< i 1) acc (collect (- i 1) (cons (lua-get t i) acc)))))
-        (rebuild
-          (fn
-            (t i items)
-            (if
-              (= (len items) 0)
-              t
-              (rebuild
-                (assoc t (str i) (first items))
-                (+ i 1)
-                (rest items))))))
-      (rebuild t 1 (sort (collect n (list)))))))
-
-(define table {:sort lua-table-sort :concat lua-table-concat :insert lua-table-insert :remove lua-table-remove})
--- a/lib/lua/test.sh
+++ b/lib/lua/test.sh
@@ -633,116 +633,6 @@ check 482 "while i<5 count"                 '5'
 check 483 "repeat until i>=3"               '3'
 check 484 "for 1..100 sum"                  '5050'

-# ── Phase 3: stdlib — math, string, table ──────────────────────────────────
-
-cat >> "$TMPFILE" << 'EPOCHS2'
-
-;; ── math library ───────────────────────────────────────────────
-(epoch 500)
-(eval "(lua-eval-ast \"return math.abs(-7)\")")
-(epoch 501)
-(eval "(lua-eval-ast \"return math.floor(3.9)\")")
-(epoch 502)
-(eval "(lua-eval-ast \"return math.ceil(3.1)\")")
-(epoch 503)
-(eval "(lua-eval-ast \"return math.sqrt(9)\")")
-(epoch 504)
-(eval "(lua-eval-ast \"return math.sin(0)\")")
-(epoch 505)
-(eval "(lua-eval-ast \"return math.cos(0)\")")
-(epoch 506)
-(eval "(lua-eval-ast \"return math.max(3, 7)\")")
-(epoch 507)
-(eval "(lua-eval-ast \"return math.min(3, 7)\")")
-(epoch 508)
-(eval "(lua-eval-ast \"return math.pi > 3\")")
-(epoch 509)
-(eval "(lua-eval-ast \"return math.huge > 0\")")
-
-;; ── string library ─────────────────────────────────────────────
-(epoch 520)
-(eval "(lua-eval-ast \"return string.len(\\\"hello\\\")\")")
-(epoch 521)
-(eval "(lua-eval-ast \"return string.upper(\\\"hello\\\")\")")
-(epoch 522)
-(eval "(lua-eval-ast \"return string.lower(\\\"WORLD\\\")\")")
-(epoch 523)
-(eval "(lua-eval-ast \"return string.sub(\\\"hello\\\", 2, 4)\")")
-(epoch 524)
-(eval "(lua-eval-ast \"return string.rep(\\\"ab\\\", 3)\")")
-(epoch 525)
-(eval "(lua-eval-ast \"return string.reverse(\\\"hello\\\")\")")
-(epoch 526)
-(eval "(lua-eval-ast \"return string.byte(\\\"A\\\")\")")
-(epoch 527)
-(eval "(lua-eval-ast \"return string.char(72, 105)\")")
-(epoch 528)
-(eval "(lua-eval-ast \"return string.find(\\\"hello\\\", \\\"ll\\\")\")")
-(epoch 529)
-(eval "(lua-eval-ast \"return string.match(\\\"hello\\\", \\\"ell\\\")\")")
-(epoch 530)
-(eval "(lua-eval-ast \"return string.gsub(\\\"hello\\\", \\\"l\\\", \\\"r\\\")\")")
-
-;; ── table library ──────────────────────────────────────────────
-(epoch 540)
-(eval "(lua-eval-ast \"local t = {10, 20, 30} t = table.insert(t, 40) return t[4]\")")
-(epoch 541)
-(eval "(lua-eval-ast \"local t = {10, 20, 30} t = table.remove(t) return t[3]\")")
-(epoch 542)
-(eval "(lua-eval-ast \"local t = {\\\"a\\\", \\\"b\\\", \\\"c\\\"} return table.concat(t, \\\",\\\")\")")
-(epoch 543)
-(eval "(lua-eval-ast \"local t = {3, 1, 2} t = table.sort(t) return t[1]\")")
-(epoch 544)
-(eval "(lua-eval-ast \"local t = {3, 1, 2} t = table.sort(t) return t[3]\")")
-
-;; ── delay / force ──────────────────────────────────────────────
-(epoch 550)
-(eval "(lua-force (delay (+ 10 5)))")
-(epoch 551)
-(eval "(lua-force 42)")
-
-EPOCHS2
-
-OUTPUT2=$(timeout 30 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
-OUTPUT="$OUTPUT
-$OUTPUT2"
-
-# math
-check 500 "math.abs(-7)"         '7'
-check 501 "math.floor(3.9)"      '3'
-check 502 "math.ceil(3.1)"       '4'
-check 503 "math.sqrt(9)"         '3'
-check 504 "math.sin(0)"          '0'
-check 505 "math.cos(0)"          '1'
-check 506 "math.max(3,7)"        '7'
-check 507 "math.min(3,7)"        '3'
-check 508 "math.pi > 3"          'true'
-check 509 "math.huge > 0"        'true'
-
-# string
-check 520 "string.len"           '5'
-check 521 "string.upper"         '"HELLO"'
-check 522 "string.lower"         '"world"'
-check 523 "string.sub(2,4)"      '"ell"'
-check 524 "string.rep(ab,3)"     '"ababab"'
-check 525 "string.reverse"       '"olleh"'
-check 526 "string.byte(A)"       '65'
-check 527 "string.char(72,105)"  '"Hi"'
-check 528 "string.find ll"       '3'
-check 529 "string.match ell"     '"ell"'
-check 530 "string.gsub l->r"     '"herro"'
-
-# table
-check 540 "table.insert"         '40'
-check 541 "table.remove"         'nil'
-check 542 "table.concat ,"       '"a,b,c"'
-check 543 "table.sort [1]"       '1'
-check 544 "table.sort [3]"       '3'
-
-# delay/force
-check 550 "lua-force delay"      '15'
-check 551 "lua-force non-promise" '42'
-
 TOTAL=$((PASS + FAIL))
 if [ $FAIL -eq 0 ]; then
  echo "ok $PASS/$TOTAL Lua-on-SX tests passed"
--- a/lib/r7rs.sx
+++ b/lib/r7rs.sx
@@ -73,10 +73,7 @@

 (define string->symbol make-symbol)

-(define number->string
-  (let ((prim-n->s number->string))
-    (fn (n &rest r)
-      (if (= (len r) 0) (str n) (prim-n->s n (first r))))))
+(define number->string (fn (n) (str n)))

 (define
  string->number
--- a/lib/ruby/runtime.sx
+++ b/lib/ruby/runtime.sx
@@ -1,352 +0,0 @@
-;; lib/ruby/runtime.sx — Ruby primitives on SX
-;;
-;; Provides Ruby-idiomatic wrappers over SX built-ins.
-;; Primitives used:
-;;   call/cc                                          (core evaluator)
-;;   make-set/set-add!/set-member?/set-remove!/set->list (Phase 18)
-;;   make-regexp/regexp-match/regexp-match-all/...    (Phase 19)
-;;   make-bytevector/bytevector-u8-ref/...            (Phase 20)
-
-;; ---------------------------------------------------------------------------
-;; 0. Internal list helpers
-;; ---------------------------------------------------------------------------
-
-(define
-  (rb-list-set-nth lst i newval)
-  (letrec
-    ((go (fn (ps j) (if (= (len ps) 0) (list) (cons (if (= j i) newval (first ps)) (go (rest ps) (+ j 1)))))))
-    (go lst 0)))
-
-(define
-  (rb-list-remove-nth lst i)
-  (letrec
-    ((go (fn (ps j) (if (= (len ps) 0) (list) (if (= j i) (go (rest ps) (+ j 1)) (cons (first ps) (go (rest ps) (+ j 1))))))))
-    (go lst 0)))
-
-;; ---------------------------------------------------------------------------
-;; 1. Hash (mutable, any-key, dict-backed list-of-pairs)
-;; ---------------------------------------------------------------------------
-
-(define
-  (rb-hash-new)
-  (let
-    ((h (dict)))
-    (dict-set! h "_rb_hash" true)
-    (dict-set! h "_pairs" (list))
-    (dict-set! h "_size" 0)
-    h))
-
-(define (rb-hash? v) (and (dict? v) (dict-has? v "_rb_hash")))
-
-(define (rb-hash-size h) (get h "_size"))
-
-(define
-  (rb-hash-find-idx pairs k)
-  (letrec
-    ((go (fn (ps i) (cond ((= (len ps) 0) -1) ((= (first (first ps)) k) i) (else (go (rest ps) (+ i 1)))))))
-    (go pairs 0)))
-
-(define
-  (rb-hash-at h k)
-  (letrec
-    ((go (fn (ps) (if (= (len ps) 0) nil (if (= (first (first ps)) k) (nth (first ps) 1) (go (rest ps)))))))
-    (go (get h "_pairs"))))
-
-(define
-  (rb-hash-at-or h k default)
-  (if (rb-hash-has-key? h k) (rb-hash-at h k) default))
-
-(define
-  (rb-hash-at-put! h k v)
-  (let
-    ((pairs (get h "_pairs")) (idx (rb-hash-find-idx (get h "_pairs") k)))
-    (if
-      (= idx -1)
-      (begin
-        (dict-set! h "_pairs" (append pairs (list (list k v))))
-        (dict-set! h "_size" (+ (get h "_size") 1)))
-      (dict-set! h "_pairs" (rb-list-set-nth pairs idx (list k v)))))
-  h)
-
-(define
-  (rb-hash-has-key? h k)
-  (not (= (rb-hash-find-idx (get h "_pairs") k) -1)))
-
-(define
-  (rb-hash-delete! h k)
-  (let
-    ((idx (rb-hash-find-idx (get h "_pairs") k)))
-    (when
-      (not (= idx -1))
-      (dict-set! h "_pairs" (rb-list-remove-nth (get h "_pairs") idx))
-      (dict-set! h "_size" (- (get h "_size") 1))))
-  h)
-
-(define (rb-hash-keys h) (map first (get h "_pairs")))
-
-(define
-  (rb-hash-values h)
-  (map (fn (p) (nth p 1)) (get h "_pairs")))
-
-(define
-  (rb-hash-each h callback)
-  (for-each
-    (fn (p) (callback (first p) (nth p 1)))
-    (get h "_pairs")))
-
-(define (rb-hash->list h) (get h "_pairs"))
-
-(define
-  (rb-list->hash pairs)
-  (let
-    ((h (rb-hash-new)))
-    (for-each
-      (fn (p) (rb-hash-at-put! h (first p) (nth p 1)))
-      pairs)
-    h))
-
-(define
-  (rb-hash-merge h1 h2)
-  (let
-    ((result (rb-hash-new)))
-    (for-each
-      (fn (p) (rb-hash-at-put! result (first p) (nth p 1)))
-      (get h1 "_pairs"))
-    (for-each
-      (fn (p) (rb-hash-at-put! result (first p) (nth p 1)))
-      (get h2 "_pairs"))
-    result))
-
-;; ---------------------------------------------------------------------------
-;; 2. Set (uniqueness collection backed by SX make-set)
-;;    Note: set-member?/set-add!/set-remove! take (set item) order.
-;; ---------------------------------------------------------------------------
-
-(define
-  (rb-set-new)
-  (let
-    ((s (dict)))
-    (dict-set! s "_rb_set" true)
-    (dict-set! s "_set" (make-set))
-    (dict-set! s "_size" 0)
-    s))
-
-(define (rb-set? v) (and (dict? v) (dict-has? v "_rb_set")))
-
-(define (rb-set-size s) (get s "_size"))
-
-(define
-  (rb-set-add! s v)
-  (let
-    ((sx (get s "_set")))
-    (when
-      (not (set-member? sx v))
-      (set-add! sx v)
-      (dict-set! s "_size" (+ (get s "_size") 1))))
-  s)
-
-(define (rb-set-include? s v) (set-member? (get s "_set") v))
-
-(define
-  (rb-set-delete! s v)
-  (let
-    ((sx (get s "_set")))
-    (when
-      (set-member? sx v)
-      (set-remove! sx v)
-      (dict-set! s "_size" (- (get s "_size") 1))))
-  s)
-
-(define (rb-set->list s) (set->list (get s "_set")))
-
-(define
-  (rb-set-each s callback)
-  (for-each callback (set->list (get s "_set"))))
-
-(define
-  (rb-set-union s1 s2)
-  (let
-    ((result (rb-set-new)))
-    (for-each (fn (v) (rb-set-add! result v)) (rb-set->list s1))
-    (for-each (fn (v) (rb-set-add! result v)) (rb-set->list s2))
-    result))
-
-(define
-  (rb-set-intersection s1 s2)
-  (let
-    ((result (rb-set-new)))
-    (for-each
-      (fn (v) (when (rb-set-include? s2 v) (rb-set-add! result v)))
-      (rb-set->list s1))
-    result))
-
-(define
-  (rb-set-difference s1 s2)
-  (let
-    ((result (rb-set-new)))
-    (for-each
-      (fn (v) (when (not (rb-set-include? s2 v)) (rb-set-add! result v)))
-      (rb-set->list s1))
-    result))
-
-;; ---------------------------------------------------------------------------
-;; 3. Regexp (thin wrappers over Phase-19 make-regexp primitives)
-;; ---------------------------------------------------------------------------
-
-(define
-  (rb-regexp-new pattern flags)
-  (make-regexp pattern (if (= flags nil) "" flags)))
-
-(define (rb-regexp? v) (regexp? v))
-
-(define (rb-regexp-match rx str) (regexp-match rx str))
-
-(define (rb-regexp-match-all rx str) (regexp-match-all rx str))
-
-(define (rb-regexp-match? rx str) (not (= (regexp-match rx str) nil)))
-
-(define
-  (rb-regexp-replace rx str replacement)
-  (regexp-replace rx str replacement))
-
-(define
-  (rb-regexp-replace-all rx str replacement)
-  (regexp-replace-all rx str replacement))
-
-(define (rb-regexp-split rx str) (regexp-split rx str))
-
-;; ---------------------------------------------------------------------------
-;; 4. StringIO (write buffer + char-by-char read after rewind)
-;; ---------------------------------------------------------------------------
-
-(define
-  (rb-string-io-new)
-  (let
-    ((io (dict)))
-    (dict-set! io "_rb_string_io" true)
-    (dict-set! io "_buf" "")
-    (dict-set! io "_chars" (list))
-    (dict-set! io "_pos" 0)
-    io))
-
-(define (rb-string-io? v) (and (dict? v) (dict-has? v "_rb_string_io")))
-
-(define
-  (rb-string-io-write! io s)
-  (dict-set! io "_buf" (str (get io "_buf") s))
-  io)
-
-(define (rb-string-io-string io) (get io "_buf"))
-
-(define
-  (rb-string-io-rewind! io)
-  (dict-set! io "_chars" (string->list (get io "_buf")))
-  (dict-set! io "_pos" 0)
-  io)
-
-(define
-  (rb-string-io-eof? io)
-  (>= (get io "_pos") (len (get io "_chars"))))
-
-(define
-  (rb-string-io-read-char io)
-  (if
-    (rb-string-io-eof? io)
-    nil
-    (let
-      ((c (nth (get io "_chars") (get io "_pos"))))
-      (dict-set! io "_pos" (+ (get io "_pos") 1))
-      c)))
-
-(define
-  (rb-string-io-read io)
-  (letrec
-    ((go (fn (acc) (let ((c (rb-string-io-read-char io))) (if (= c nil) (list->string (reverse acc)) (go (cons c acc)))))))
-    (go (list))))
-
-;; ---------------------------------------------------------------------------
-;; 5. Bytevectors (thin wrappers over Phase-20 bytevector primitives)
-;; ---------------------------------------------------------------------------
-
-(define
-  (rb-bytes-new n fill)
-  (make-bytevector n (if (= fill nil) 0 fill)))
-
-(define (rb-bytes? v) (bytevector? v))
-
-(define (rb-bytes-length v) (bytevector-length v))
-
-(define (rb-bytes-get v i) (bytevector-u8-ref v i))
-
-(define (rb-bytes-set! v i b) (bytevector-u8-set! v i b) v)
-
-(define (rb-bytes-copy v) (bytevector-copy v))
-
-(define (rb-bytes-append v1 v2) (bytevector-append v1 v2))
-
-(define (rb-bytes-to-string v) (utf8->string v))
-
-(define (rb-bytes-from-string s) (string->utf8 s))
-
-(define (rb-bytes->list v) (bytevector->list v))
-
-(define (rb-list->bytes lst) (list->bytevector lst))
-
-;; ---------------------------------------------------------------------------
-;; 6. Fiber (call/cc coroutines)
-;;    Body wrapped so completion always routes through _resumer, ensuring
-;;    rb-fiber-resume always returns via the captured continuation.
-;; ---------------------------------------------------------------------------
-
-(define rb-current-fiber nil)
-
-(define
-  (rb-fiber-new body)
-  (let
-    ((f (dict)))
-    (dict-set! f "_rb_fiber" true)
-    (dict-set! f "_state" "new")
-    (dict-set! f "_cont" nil)
-    (dict-set! f "_resumer" nil)
-    (dict-set! f "_parent" nil)
-    (dict-set!
-      f
-      "_body"
-      (fn
-        ()
-        (let
-          ((result (body)))
-          (dict-set! f "_state" "dead")
-          (set! rb-current-fiber (get f "_parent"))
-          ((get f "_resumer") result))))
-    f))
-
-(define (rb-fiber? v) (and (dict? v) (dict-has? v "_rb_fiber")))
-
-(define (rb-fiber-alive? f) (not (= (get f "_state") "dead")))
-
-(define
-  (rb-fiber-yield val)
-  (call/cc
-    (fn
-      (resume-k)
-      (let
-        ((cur rb-current-fiber))
-        (dict-set! cur "_cont" resume-k)
-        (dict-set! cur "_state" "suspended")
-        (set! rb-current-fiber (get cur "_parent"))
-        ((get cur "_resumer") val)))))
-
-(define
-  (rb-fiber-resume f)
-  (call/cc
-    (fn
-      (return-k)
-      (dict-set! f "_parent" rb-current-fiber)
-      (dict-set! f "_resumer" return-k)
-      (set! rb-current-fiber f)
-      (dict-set! f "_state" "running")
-      (if
-        (= (get f "_cont") nil)
-        ((get f "_body"))
-        ((get f "_cont") nil)))))
--- a/lib/ruby/test.sh
+++ b/lib/ruby/test.sh
@@ -1,62 +0,0 @@
-#!/usr/bin/env bash
-# lib/ruby/test.sh — smoke-test the Ruby runtime layer.
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found."
-  exit 1
-fi
-
-TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT
-
-cat > "$TMPFILE" << 'EPOCHS'
-(epoch 1)
-(load "lib/ruby/runtime.sx")
-(epoch 2)
-(load "lib/ruby/tests/runtime.sx")
-(epoch 3)
-(eval "(list rb-test-pass rb-test-fail)")
-EPOCHS
-
-OUTPUT=$(timeout 60 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
-
-LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 3 / {getline; print; exit}')
-if [ -z "$LINE" ]; then
-  LINE=$(echo "$OUTPUT" | grep -E '^\(ok 3 \([0-9]+ [0-9]+\)\)' | tail -1 \
-          | sed -E 's/^\(ok 3 //; s/\)$//')
-fi
-if [ -z "$LINE" ]; then
-  echo "ERROR: could not extract summary"
-  echo "$OUTPUT" | tail -20
-  exit 1
-fi
-
-P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
-F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
-TOTAL=$((P + F))
-
-if [ "$F" -eq 0 ]; then
-  echo "ok $P/$TOTAL lib/ruby tests passed"
-else
-  echo "FAIL $P/$TOTAL passed, $F failed"
-  TMPFILE2=$(mktemp)
-  cat > "$TMPFILE2" << 'EPOCHS2'
-(epoch 1)
-(load "lib/ruby/runtime.sx")
-(epoch 2)
-(load "lib/ruby/tests/runtime.sx")
-(epoch 3)
-(eval "(map (fn (f) (get f \"name\")) rb-test-fails)")
-EPOCHS2
-  FAILS=$(timeout 60 "$SX_SERVER" < "$TMPFILE2" 2>/dev/null | grep -E '^\(ok 3 ' || true)
-  echo "  Failed: $FAILS"
-  rm -f "$TMPFILE2"
-fi
-
-[ "$F" -eq 0 ]
--- a/lib/ruby/tests/runtime.sx
+++ b/lib/ruby/tests/runtime.sx
@@ -1,207 +0,0 @@
-;; lib/ruby/tests/runtime.sx — Tests for lib/ruby/runtime.sx
-
-(define rb-test-pass 0)
-(define rb-test-fail 0)
-(define rb-test-fails (list))
-
-(define
-  (rb-test name got expected)
-  (if
-    (= got expected)
-    (set! rb-test-pass (+ rb-test-pass 1))
-    (begin
-      (set! rb-test-fail (+ rb-test-fail 1))
-      (set! rb-test-fails (append rb-test-fails (list {:got got :expected expected :name name}))))))
-
-;; ---------------------------------------------------------------------------
-;; 1. Hash
-;; ---------------------------------------------------------------------------
-
-(define h1 (rb-hash-new))
-(rb-test "hash? new" (rb-hash? h1) true)
-(rb-test "hash? non-hash" (rb-hash? 42) false)
-(rb-test "hash size empty" (rb-hash-size h1) 0)
-(rb-hash-at-put! h1 "a" 1)
-(rb-hash-at-put! h1 "b" 2)
-(rb-hash-at-put! h1 "c" 3)
-(rb-test "hash at a" (rb-hash-at h1 "a") 1)
-(rb-test "hash at b" (rb-hash-at h1 "b") 2)
-(rb-test "hash at missing" (rb-hash-at h1 "z") nil)
-(rb-test "hash at-or default" (rb-hash-at-or h1 "z" 99) 99)
-(rb-test "hash has-key yes" (rb-hash-has-key? h1 "a") true)
-(rb-test "hash has-key no" (rb-hash-has-key? h1 "z") false)
-(rb-test "hash size after inserts" (rb-hash-size h1) 3)
-(rb-hash-at-put! h1 "a" 10)
-(rb-test "hash at-put update" (rb-hash-at h1 "a") 10)
-(rb-test "hash size unchanged after update" (rb-hash-size h1) 3)
-(rb-hash-delete! h1 "b")
-(rb-test "hash delete" (rb-hash-has-key? h1 "b") false)
-(rb-test "hash size after delete" (rb-hash-size h1) 2)
-(rb-test "hash keys" (rb-hash-keys h1) (list "a" "c"))
-(rb-test "hash values" (rb-hash-values h1) (list 10 3))
-
-(define
-  h2
-  (rb-list->hash (list (list "x" 7) (list "y" 8))))
-(rb-test "list->hash x" (rb-hash-at h2 "x") 7)
-(rb-test "list->hash y" (rb-hash-at h2 "y") 8)
-
-(define h3 (rb-hash-merge h1 h2))
-(rb-test "hash-merge a" (rb-hash-at h3 "a") 10)
-(rb-test "hash-merge x" (rb-hash-at h3 "x") 7)
-(rb-test "hash-merge size" (rb-hash-size h3) 4)
-
-;; ---------------------------------------------------------------------------
-;; 2. Set
-;; ---------------------------------------------------------------------------
-
-(define s1 (rb-set-new))
-(rb-test "set? new" (rb-set? s1) true)
-(rb-test "set? non-set" (rb-set? "hello") false)
-(rb-test "set size empty" (rb-set-size s1) 0)
-(rb-set-add! s1 1)
-(rb-set-add! s1 2)
-(rb-set-add! s1 3)
-(rb-set-add! s1 2)
-(rb-test "set include yes" (rb-set-include? s1 1) true)
-(rb-test "set include no" (rb-set-include? s1 9) false)
-(rb-test "set size dedup" (rb-set-size s1) 3)
-(rb-set-delete! s1 2)
-(rb-test "set delete" (rb-set-include? s1 2) false)
-(rb-test "set size after delete" (rb-set-size s1) 2)
-
-(define s2 (rb-set-new))
-(rb-set-add! s2 2)
-(rb-set-add! s2 3)
-(rb-set-add! s2 4)
-
-(define su (rb-set-union s1 s2))
-(rb-test "set union includes 1" (rb-set-include? su 1) true)
-(rb-test "set union includes 4" (rb-set-include? su 4) true)
-(rb-test "set union size" (rb-set-size su) 4)
-
-(define si (rb-set-intersection s1 s2))
-(rb-test "set intersection includes 3" (rb-set-include? si 3) true)
-(rb-test "set intersection excludes 1" (rb-set-include? si 1) false)
-(rb-test "set intersection size" (rb-set-size si) 1)
-
-(define sd (rb-set-difference s1 s2))
-(rb-test "set difference includes 1" (rb-set-include? sd 1) true)
-(rb-test "set difference excludes 3" (rb-set-include? sd 3) false)
-
-;; ---------------------------------------------------------------------------
-;; 3. Regexp
-;; ---------------------------------------------------------------------------
-
-(define rx1 (rb-regexp-new "hel+" ""))
-(rb-test "regexp?" (rb-regexp? rx1) true)
-(rb-test "regexp match? yes" (rb-regexp-match? rx1 "say hello") true)
-(rb-test "regexp match? no" (rb-regexp-match? rx1 "goodbye") false)
-
-(define m1 (rb-regexp-match rx1 "say hello world"))
-(rb-test "regexp match :match" (get m1 "match") "hell")
-
-(define rx2 (rb-regexp-new "[0-9]+" ""))
-(define all (rb-regexp-match-all rx2 "a1b22c333"))
-(rb-test "regexp match-all count" (len all) 3)
-(rb-test "regexp match-all first" (get (first all) "match") "1")
-
-(rb-test "regexp replace" (rb-regexp-replace rx2 "a1b2" "N") "aNb2")
-(rb-test "regexp replace-all" (rb-regexp-replace-all rx2 "a1b2" "N") "aNbN")
-(rb-test
-  "regexp split"
-  (rb-regexp-split (rb-regexp-new "," "") "a,b,c")
-  (list "a" "b" "c"))
-
-;; ---------------------------------------------------------------------------
-;; 4. StringIO
-;; ---------------------------------------------------------------------------
-
-(define sio1 (rb-string-io-new))
-(rb-test "string-io?" (rb-string-io? sio1) true)
-(rb-string-io-write! sio1 "hello")
-(rb-string-io-write! sio1 " world")
-(rb-test "string-io string" (rb-string-io-string sio1) "hello world")
-(rb-string-io-rewind! sio1)
-(rb-test "string-io eof? no" (rb-string-io-eof? sio1) false)
-(define ch1 (rb-string-io-read-char sio1))
-(define ch2 (rb-string-io-read-char sio1))
-;; Compare char codepoints since = uses reference equality for chars
-(rb-test "string-io read-char h" (char->integer ch1) 104)
-(rb-test "string-io read-char e" (char->integer ch2) 101)
-(rb-test "string-io read rest" (rb-string-io-read sio1) "llo world")
-(rb-test "string-io eof? yes" (rb-string-io-eof? sio1) true)
-(rb-test "string-io read at eof" (rb-string-io-read sio1) "")
-
-;; ---------------------------------------------------------------------------
-;; 5. Bytevectors
-;; ---------------------------------------------------------------------------
-
-(define bv1 (rb-bytes-new 4 0))
-(rb-test "bytes?" (rb-bytes? bv1) true)
-(rb-test "bytes length" (rb-bytes-length bv1) 4)
-(rb-test "bytes get zero" (rb-bytes-get bv1 0) 0)
-(rb-bytes-set! bv1 0 65)
-(rb-bytes-set! bv1 1 66)
-(rb-test "bytes get A" (rb-bytes-get bv1 0) 65)
-(rb-test "bytes get B" (rb-bytes-get bv1 1) 66)
-(define bv2 (rb-bytes-from-string "hi"))
-(rb-test "bytes from-string length" (rb-bytes-length bv2) 2)
-(rb-test "bytes to-string" (rb-bytes-to-string bv2) "hi")
-(define
-  bv3
-  (rb-bytes-append (rb-bytes-from-string "foo") (rb-bytes-from-string "bar")))
-(rb-test "bytes append" (rb-bytes-to-string bv3) "foobar")
-(rb-test
-  "bytes->list"
-  (rb-bytes->list (rb-bytes-from-string "AB"))
-  (list 65 66))
-(rb-test
-  "list->bytes"
-  (rb-bytes-to-string (rb-list->bytes (list 72 105)))
-  "Hi")
-
-;; ---------------------------------------------------------------------------
-;; 6. Fiber
-;;    Note: rb-fiber-yield from inside a letrec (JIT-compiled) doesn't
-;;    properly escape via call/cc continuations. Use top-level helper fns
-;;    or explicit sequential yields instead of letrec-bound recursion.
-;; ---------------------------------------------------------------------------
-
-(define
-  fib1
-  (rb-fiber-new
-    (fn
-      ()
-      (rb-fiber-yield 10)
-      (rb-fiber-yield 20)
-      30)))
-
-(rb-test "fiber?" (rb-fiber? fib1) true)
-(rb-test "fiber alive? before" (rb-fiber-alive? fib1) true)
-(define fr1 (rb-fiber-resume fib1))
-(rb-test "fiber resume 1" fr1 10)
-(rb-test "fiber alive? mid" (rb-fiber-alive? fib1) true)
-(define fr2 (rb-fiber-resume fib1))
-(rb-test "fiber resume 2" fr2 20)
-(define fr3 (rb-fiber-resume fib1))
-(rb-test "fiber resume 3 (completion)" fr3 30)
-(rb-test "fiber alive? dead" (rb-fiber-alive? fib1) false)
-
-;; Loop via a top-level helper (avoid letrec — see note above)
-(define
-  (rb-fiber-loop-helper i)
-  (when
-    (<= i 3)
-    (rb-fiber-yield i)
-    (rb-fiber-loop-helper (+ i 1))))
-
-(define
-  fib2
-  (rb-fiber-new (fn () (rb-fiber-loop-helper 1) "done")))
-
-(rb-test "fiber loop resume 1" (rb-fiber-resume fib2) 1)
-(rb-test "fiber loop resume 2" (rb-fiber-resume fib2) 2)
-(rb-test "fiber loop resume 3" (rb-fiber-resume fib2) 3)
-(rb-test "fiber loop resume done" (rb-fiber-resume fib2) "done")
-(rb-test "fiber loop dead" (rb-fiber-alive? fib2) false)
--- a/lib/tcl/runtime.sx
+++ b/lib/tcl/runtime.sx
@@ -1,279 +0,0 @@
-;; lib/tcl/runtime.sx — Tcl primitives on SX
-;;
-;; Provides Tcl-idiomatic wrappers over SX built-ins.
-;; Primitives used:
-;;   make-regexp/regexp-match/regexp-match-all/...    (Phase 19)
-;;   make-set/set-add!/set-member?/set-remove!/set->list (Phase 18)
-;;   call/cc                                          (core evaluator)
-;;   quotient/remainder                               (Phase 15 / builtin)
-;;   string->list/list->string/char->integer          (Phase 13)
-
-;; ---------------------------------------------------------------------------
-;; 1. String buffer — Tcl append / string accumulation
-;; ---------------------------------------------------------------------------
-
-(define
-  (tcl-sb-new)
-  (let
-    ((sb (dict)))
-    (dict-set! sb "_tcl_sb" true)
-    (dict-set! sb "_buf" "")
-    sb))
-
-(define (tcl-sb? v) (and (dict? v) (dict-has? v "_tcl_sb")))
-
-(define
-  (tcl-sb-append! sb s)
-  (dict-set! sb "_buf" (str (get sb "_buf") s))
-  sb)
-
-(define (tcl-sb-value sb) (get sb "_buf"))
-
-(define (tcl-sb-clear! sb) (dict-set! sb "_buf" "") sb)
-
-(define (tcl-sb-length sb) (len (get sb "_buf")))
-
-;; ---------------------------------------------------------------------------
-;; 2. String port (channel) — Tcl channel abstraction
-;;    Read channel: created from a string, supports gets/read.
-;;    Write channel: accumulates puts output, queryable via tcl-chan-string.
-;; ---------------------------------------------------------------------------
-
-(define
-  (tcl-chan-in-new str)
-  (let
-    ((c (dict)))
-    (dict-set! c "_tcl_chan" true)
-    (dict-set! c "_mode" "read")
-    (dict-set! c "_chars" (string->list str))
-    (dict-set! c "_pos" 0)
-    c))
-
-(define
-  (tcl-chan-out-new)
-  (let
-    ((c (dict)))
-    (dict-set! c "_tcl_chan" true)
-    (dict-set! c "_mode" "write")
-    (dict-set! c "_buf" "")
-    c))
-
-(define (tcl-chan? v) (and (dict? v) (dict-has? v "_tcl_chan")))
-
-(define
-  (tcl-chan-eof? c)
-  (and
-    (= (get c "_mode") "read")
-    (>= (get c "_pos") (len (get c "_chars")))))
-
-(define
-  (tcl-chan-read-char c)
-  (if
-    (tcl-chan-eof? c)
-    nil
-    (let
-      ((ch (nth (get c "_chars") (get c "_pos"))))
-      (dict-set! c "_pos" (+ (get c "_pos") 1))
-      ch)))
-
-;; gets — read one line (up to newline or EOF), return without trailing newline
-(define
-  (tcl-chan-gets c)
-  (letrec
-    ((go (fn (acc) (let ((ch (tcl-chan-read-char c))) (cond ((= ch nil) (list->string (reverse acc))) ((= (char->integer ch) 10) (list->string (reverse acc))) (else (go (cons ch acc))))))))
-    (go (list))))
-
-;; read — read all remaining chars
-(define
-  (tcl-chan-read c)
-  (letrec
-    ((go (fn (acc) (let ((ch (tcl-chan-read-char c))) (if (= ch nil) (list->string (reverse acc)) (go (cons ch acc)))))))
-    (go (list))))
-
-;; puts — write string to write channel (no newline)
-(define
-  (tcl-chan-puts! c s)
-  (when
-    (= (get c "_mode") "write")
-    (dict-set! c "_buf" (str (get c "_buf") s)))
-  c)
-
-;; puts-line — write string + newline (Tcl default puts behaviour)
-(define (tcl-chan-puts-line! c s) (tcl-chan-puts! c (str s "\n")))
-
-;; string — get accumulated content of write channel
-(define (tcl-chan-string c) (get c "_buf"))
-
-;; tell — current read position
-(define (tcl-chan-tell c) (get c "_pos"))
-
-;; ---------------------------------------------------------------------------
-;; 3. Regexp — Tcl regexp / regsub wrappers
-;; ---------------------------------------------------------------------------
-
-(define (tcl-re-new pattern) (make-regexp pattern ""))
-
-(define (tcl-re-new-flags pattern flags) (make-regexp pattern flags))
-
-(define (tcl-re? v) (regexp? v))
-
-(define (tcl-re-match? rx str) (not (= (regexp-match rx str) nil)))
-
-(define (tcl-re-match rx str) (regexp-match rx str))
-
-(define (tcl-re-match-all rx str) (regexp-match-all rx str))
-
-(define (tcl-re-sub rx str replacement) (regexp-replace rx str replacement))
-
-(define
-  (tcl-re-sub-all rx str replacement)
-  (regexp-replace-all rx str replacement))
-
-(define (tcl-re-split rx str) (regexp-split rx str))
-
-;; ---------------------------------------------------------------------------
-;; 4. Format — Tcl format command (%s %d %f %x %o %%)
-;;    tcl-format takes a format string and a list of arguments.
-;;    Example: (tcl-format "%s is %d" (list "Alice" 30)) → "Alice is 30"
-;; ---------------------------------------------------------------------------
-
-;; Digit characters for base conversion
-(define tcl-hex-chars (string->list "0123456789abcdef"))
-
-(define
-  (tcl-digits-for-base n base digit-chars)
-  (let
-    ((abs-n (if (< n 0) (- 0 n) n)))
-    (letrec
-      ((go (fn (n acc) (if (= n 0) (if (= (len acc) 0) "0" (list->string acc)) (go (quotient n base) (cons (nth digit-chars (remainder n base)) acc))))))
-      (let
-        ((unsigned (go abs-n (list))))
-        (if (< n 0) (str "-" unsigned) unsigned)))))
-
-(define
-  (tcl-format-hex n)
-  (tcl-digits-for-base (truncate n) 16 tcl-hex-chars))
-
-(define
-  (tcl-format-oct n)
-  (tcl-digits-for-base (truncate n) 8 (string->list "01234567")))
-
-(define
-  (tcl-format fmt args)
-  (letrec
-    ((chars (string->list fmt))
-      (go
-        (fn
-          (cs arg-list result)
-          (if
-            (= (len cs) 0)
-            result
-            (let
-              ((c-int (char->integer (first cs))))
-              (if
-                (= c-int 37)
-                (if
-                  (= (len (rest cs)) 0)
-                  result
-                  (let
-                    ((spec-int (char->integer (first (rest cs)))))
-                    (cond
-                      ((= spec-int 37)
-                        (go (rest (rest cs)) arg-list (str result "%")))
-                      ((= spec-int 115)
-                        (go
-                          (rest (rest cs))
-                          (rest arg-list)
-                          (str result (str (first arg-list)))))
-                      ((= spec-int 100)
-                        (go
-                          (rest (rest cs))
-                          (rest arg-list)
-                          (str result (str (truncate (first arg-list))))))
-                      ((= spec-int 102)
-                        (go
-                          (rest (rest cs))
-                          (rest arg-list)
-                          (str result (str (+ 0 (first arg-list))))))
-                      ((= spec-int 120)
-                        (go
-                          (rest (rest cs))
-                          (rest arg-list)
-                          (str result (tcl-format-hex (first arg-list)))))
-                      ((= spec-int 111)
-                        (go
-                          (rest (rest cs))
-                          (rest arg-list)
-                          (str result (tcl-format-oct (first arg-list)))))
-                      (else
-                        (go
-                          (rest (rest cs))
-                          arg-list
-                          (str
-                            result
-                            "%"
-                            (list->string (list (first (rest cs))))))))))
-                (go
-                  (rest cs)
-                  arg-list
-                  (str result (list->string (list (first cs)))))))))))
-    (go chars args "")))
-
-;; ---------------------------------------------------------------------------
-;; 5. Coroutine — Tcl-style coroutine using call/cc
-;;    tcl-co-yield works reliably when called from top-level fns.
-;;    Avoid calling tcl-co-yield from letrec-bound lambdas (JIT limitation).
-;; ---------------------------------------------------------------------------
-
-(define tcl-current-co nil)
-
-(define
-  (tcl-co-new body)
-  (let
-    ((co (dict)))
-    (dict-set! co "_tcl_co" true)
-    (dict-set! co "_state" "new")
-    (dict-set! co "_cont" nil)
-    (dict-set! co "_resumer" nil)
-    (dict-set! co "_parent" nil)
-    (dict-set!
-      co
-      "_body"
-      (fn
-        ()
-        (let
-          ((result (body)))
-          (dict-set! co "_state" "dead")
-          (set! tcl-current-co (get co "_parent"))
-          ((get co "_resumer") result))))
-    co))
-
-(define (tcl-co? v) (and (dict? v) (dict-has? v "_tcl_co")))
-
-(define (tcl-co-alive? co) (not (= (get co "_state") "dead")))
-
-(define
-  (tcl-co-yield val)
-  (call/cc
-    (fn
-      (resume-k)
-      (let
-        ((cur tcl-current-co))
-        (dict-set! cur "_cont" resume-k)
-        (dict-set! cur "_state" "suspended")
-        (set! tcl-current-co (get cur "_parent"))
-        ((get cur "_resumer") val)))))
-
-(define
-  (tcl-co-resume co)
-  (call/cc
-    (fn
-      (return-k)
-      (dict-set! co "_parent" tcl-current-co)
-      (dict-set! co "_resumer" return-k)
-      (set! tcl-current-co co)
-      (dict-set! co "_state" "running")
-      (if
-        (= (get co "_cont") nil)
-        ((get co "_body"))
-        ((get co "_cont") nil)))))
--- a/lib/tcl/test.sh
+++ b/lib/tcl/test.sh
@@ -1,62 +0,0 @@
-#!/usr/bin/env bash
-# lib/tcl/test.sh — smoke-test the Tcl runtime layer.
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found."
-  exit 1
-fi
-
-TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT
-
-cat > "$TMPFILE" << 'EPOCHS'
-(epoch 1)
-(load "lib/tcl/runtime.sx")
-(epoch 2)
-(load "lib/tcl/tests/runtime.sx")
-(epoch 3)
-(eval "(list tcl-test-pass tcl-test-fail)")
-EPOCHS
-
-OUTPUT=$(timeout 60 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
-
-LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 3 / {getline; print; exit}')
-if [ -z "$LINE" ]; then
-  LINE=$(echo "$OUTPUT" | grep -E '^\(ok 3 \([0-9]+ [0-9]+\)\)' | tail -1 \
-          | sed -E 's/^\(ok 3 //; s/\)$//')
-fi
-if [ -z "$LINE" ]; then
-  echo "ERROR: could not extract summary"
-  echo "$OUTPUT" | tail -20
-  exit 1
-fi
-
-P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
-F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
-TOTAL=$((P + F))
-
-if [ "$F" -eq 0 ]; then
-  echo "ok $P/$TOTAL lib/tcl tests passed"
-else
-  echo "FAIL $P/$TOTAL passed, $F failed"
-  TMPFILE2=$(mktemp)
-  cat > "$TMPFILE2" << 'EPOCHS2'
-(epoch 1)
-(load "lib/tcl/runtime.sx")
-(epoch 2)
-(load "lib/tcl/tests/runtime.sx")
-(epoch 3)
-(eval "(map (fn (f) (list (get f :name) (get f :got) (get f :expected))) tcl-test-fails)")
-EPOCHS2
-  FAILS=$(timeout 60 "$SX_SERVER" < "$TMPFILE2" 2>/dev/null | grep -E '^\(ok-len 3' -A1 | tail -1 || true)
-  echo "  Details: $FAILS"
-  rm -f "$TMPFILE2"
-fi
-
-[ "$F" -eq 0 ]
--- a/lib/tcl/tests/runtime.sx
+++ b/lib/tcl/tests/runtime.sx
@@ -1,146 +0,0 @@
-;; lib/tcl/tests/runtime.sx — Tests for lib/tcl/runtime.sx
-
-(define tcl-test-pass 0)
-(define tcl-test-fail 0)
-(define tcl-test-fails (list))
-
-(define
-  (tcl-test name got expected)
-  (if
-    (= got expected)
-    (set! tcl-test-pass (+ tcl-test-pass 1))
-    (begin
-      (set! tcl-test-fail (+ tcl-test-fail 1))
-      (set! tcl-test-fails (append tcl-test-fails (list {:got got :expected expected :name name}))))))
-
-;; ---------------------------------------------------------------------------
-;; 1. String buffer
-;; ---------------------------------------------------------------------------
-
-(define sb1 (tcl-sb-new))
-(tcl-test "sb? new" (tcl-sb? sb1) true)
-(tcl-test "sb? non-sb" (tcl-sb? "hello") false)
-(tcl-test "sb value empty" (tcl-sb-value sb1) "")
-(tcl-test "sb length empty" (tcl-sb-length sb1) 0)
-(tcl-sb-append! sb1 "hello")
-(tcl-test "sb value after append" (tcl-sb-value sb1) "hello")
-(tcl-sb-append! sb1 " ")
-(tcl-sb-append! sb1 "world")
-(tcl-test "sb value after multi-append" (tcl-sb-value sb1) "hello world")
-(tcl-test "sb length" (tcl-sb-length sb1) 11)
-(tcl-sb-clear! sb1)
-(tcl-test "sb value after clear" (tcl-sb-value sb1) "")
-(tcl-test "sb length after clear" (tcl-sb-length sb1) 0)
-
-;; ---------------------------------------------------------------------------
-;; 2. String port (channel)
-;; ---------------------------------------------------------------------------
-
-(define chin1 (tcl-chan-in-new "hello\nworld\nfoo"))
-(tcl-test "chan? read" (tcl-chan? chin1) true)
-(tcl-test "chan eof? no" (tcl-chan-eof? chin1) false)
-(tcl-test "chan gets line1" (tcl-chan-gets chin1) "hello")
-(tcl-test "chan gets line2" (tcl-chan-gets chin1) "world")
-(tcl-test "chan gets line3" (tcl-chan-gets chin1) "foo")
-(tcl-test "chan eof? yes" (tcl-chan-eof? chin1) true)
-(tcl-test "chan gets at eof" (tcl-chan-gets chin1) "")
-
-(define chin2 (tcl-chan-in-new "abcdef"))
-(tcl-test "chan read all" (tcl-chan-read chin2) "abcdef")
-(tcl-test "chan read empty" (tcl-chan-read chin2) "")
-
-(define chout1 (tcl-chan-out-new))
-(tcl-test "chan? write" (tcl-chan? chout1) true)
-(tcl-chan-puts! chout1 "hello")
-(tcl-chan-puts! chout1 " world")
-(tcl-test "chan string" (tcl-chan-string chout1) "hello world")
-(tcl-chan-puts-line! chout1 "!")
-(tcl-test "chan string with newline" (tcl-chan-string chout1) "hello world!\n")
-
-(define chout2 (tcl-chan-out-new))
-(tcl-chan-puts-line! chout2 "line1")
-(tcl-chan-puts-line! chout2 "line2")
-(tcl-test "chan multi-line" (tcl-chan-string chout2) "line1\nline2\n")
-
-;; ---------------------------------------------------------------------------
-;; 3. Regexp
-;; ---------------------------------------------------------------------------
-
-(define rx1 (tcl-re-new "hel+o"))
-(tcl-test "re? yes" (tcl-re? rx1) true)
-(tcl-test "re? no" (tcl-re? "hello") false)
-(tcl-test "re match? yes" (tcl-re-match? rx1 "say hello") true)
-(tcl-test "re match? no" (tcl-re-match? rx1 "goodbye") false)
-
-(define m1 (tcl-re-match rx1 "say hello world"))
-(tcl-test "re match result" (get m1 "match") "hello")
-
-(define rx2 (tcl-re-new "[0-9]+"))
-(define all (tcl-re-match-all rx2 "a1b22c333"))
-(tcl-test "re match-all count" (len all) 3)
-(tcl-test "re match-all last" (get (nth all 2) "match") "333")
-
-(tcl-test "re sub" (tcl-re-sub rx2 "a1b2" "N") "aNb2")
-(tcl-test "re sub-all" (tcl-re-sub-all rx2 "a1b2" "N") "aNbN")
-
-(define rx3 (tcl-re-new "[ ,]+"))
-(tcl-test "re split" (tcl-re-split rx3 "a b,c") (list "a" "b" "c"))
-
-;; ---------------------------------------------------------------------------
-;; 4. Format
-;; ---------------------------------------------------------------------------
-
-(tcl-test "format %s" (tcl-format "hello %s" (list "world")) "hello world")
-(tcl-test "format %d" (tcl-format "n=%d" (list 42)) "n=42")
-(tcl-test "format %d truncates float" (tcl-format "n=%d" (list 3.9)) "n=3")
-(tcl-test
-  "format %s %d"
-  (tcl-format "%s is %d" (list "age" 30))
-  "age is 30")
-(tcl-test "format %%" (tcl-format "100%% done" (list)) "100% done")
-(tcl-test "format %x" (tcl-format "%x" (list 255)) "ff")
-(tcl-test "format %x 16" (tcl-format "0x%x" (list 16)) "0x10")
-(tcl-test "format %o" (tcl-format "%o" (list 8)) "10")
-(tcl-test "format %o 255" (tcl-format "%o" (list 255)) "377")
-(tcl-test "format no spec" (tcl-format "plain text" (list)) "plain text")
-(tcl-test
-  "format multiple"
-  (tcl-format "%s=%d (0x%x)" (list "val" 255 255))
-  "val=255 (0xff)")
-
-;; ---------------------------------------------------------------------------
-;; 5. Coroutine
-;;    tcl-co-yield works from top-level helper functions.
-;; ---------------------------------------------------------------------------
-
-(define
-  co1
-  (tcl-co-new
-    (fn () (tcl-co-yield 1) (tcl-co-yield 2) 3)))
-
-(tcl-test "co? yes" (tcl-co? co1) true)
-(tcl-test "co? no" (tcl-co? 42) false)
-(tcl-test "co alive? before" (tcl-co-alive? co1) true)
-(define cor1 (tcl-co-resume co1))
-(tcl-test "co resume 1" cor1 1)
-(tcl-test "co alive? mid" (tcl-co-alive? co1) true)
-(define cor2 (tcl-co-resume co1))
-(tcl-test "co resume 2" cor2 2)
-(define cor3 (tcl-co-resume co1))
-(tcl-test "co resume 3 completion" cor3 3)
-(tcl-test "co alive? dead" (tcl-co-alive? co1) false)
-
-;; Top-level helper for recursive yield (avoids JIT letrec limitation)
-(define
-  (tcl-co-count-down i)
-  (when
-    (>= i 1)
-    (tcl-co-yield i)
-    (tcl-co-count-down (- i 1))))
-
-(define co2 (tcl-co-new (fn () (tcl-co-count-down 3) "done")))
-(tcl-test "co loop 3" (tcl-co-resume co2) 3)
-(tcl-test "co loop 2" (tcl-co-resume co2) 2)
-(tcl-test "co loop 1" (tcl-co-resume co2) 1)
-(tcl-test "co loop done" (tcl-co-resume co2) "done")
-(tcl-test "co loop dead" (tcl-co-alive? co2) false)
--- a/plans/agent-briefings/apl-loop.md
+++ b/plans/agent-briefings/apl-loop.md
@@ -1,81 +0,0 @@
-# apl-on-sx loop agent (single agent, queue-driven)
-
-Role: iterates `plans/apl-on-sx.md` forever. Rank-polymorphic primitives + 6 operators on the JIT is the headline showcase — APL is the densest combinator algebra you can put on top of a primitive table. Every program is `array → array` pure pipelines, exactly what the JIT was built for.
-
-```
-description: apl-on-sx queue loop
-subagent_type: general-purpose
-run_in_background: true
-isolation: worktree
-```
-
-## Prompt
-
-You are the sole background agent working `/root/rose-ash/plans/apl-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
-
-## Restart baseline — check before iterating
-
-1. Read `plans/apl-on-sx.md` — roadmap + Progress log.
-2. `ls lib/apl/` — pick up from the most advanced file.
-3. If `lib/apl/tests/*.sx` exist, run them. Green before new work.
-4. If `lib/apl/scoreboard.md` exists, that's your baseline.
-
-## The queue
-
-Phase order per `plans/apl-on-sx.md`:
-
- **Phase 1** — tokenizer + parser. Unicode glyphs, `¯` for negative, strands (juxtaposition), right-to-left, valence resolution by syntactic position
- **Phase 2** — array model + scalar primitives. `make-array {shape, ravel}`, scalar promotion, broadcast for `+ - × ÷ ⌈ ⌊ * ⍟ | ! ○`, comparison, logical, `⍳`, `⎕IO`
- **Phase 3** — structural primitives + indexing. `⍴ , ⍉ ↑ ↓ ⌽ ⊖ ⌷ ⍋ ⍒ ⊂ ⊃ ∊`
- **Phase 4** — **THE SHOWCASE**: operators. `f/` (reduce), `f¨` (each), `∘.f` (outer), `f.g` (inner), `f⍨` (commute), `f∘g` (compose), `f⍣n` (power), `f⍤k` (rank), `@` (at)
- **Phase 5** — dfns + tradfns + control flow. `{⍺+⍵}`, `∇` recurse, `⍺←default`, tradfn header, `:If/:While/:For/:Select`
- **Phase 6** — classic programs (life, mandelbrot, primes, n-queens, quicksort) + idiom corpus + drive to 100+
-
-Within a phase, pick the checkbox that unlocks the most tests per effort.
-
-Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
-
-## Ground rules (hard)
-
- **Scope:** only `lib/apl/**` and `plans/apl-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. APL primitives go in `lib/apl/runtime.sx`.
- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
- **Shared-file issues** → plan's Blockers with minimal repro.
- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
- **Unicode in `.sx`:** raw UTF-8 only, never `\uXXXX` escapes. Glyphs land directly in source.
- **Worktree:** commit locally. Never push. Never touch `main`.
- **Commit granularity:** one feature per commit.
- **Plan file:** update Progress log + tick boxes every commit.
-
-## APL-specific gotchas
-
- **Right-to-left, no precedence among functions.** `2 × 3 + 4` is `2 × (3 + 4)` = 14, not 10. Operators bind tighter than functions: `+/ ⍳5` is `+/(⍳5)`, and `2 +.× 3 4` is `2 (+.×) 3 4`.
- **Valence by position.** `-3` is monadic negate (`-` with no left arg). `5-3` is dyadic subtract. The parser must look left to decide. Same glyph; different fn.
- **`¯` is part of a number literal**, not a prefix function. `¯3` is the literal negative three; `-3` is the function call. Tokenizer eats `¯` into the numeric token.
- **Strands.** `1 2 3` is a 3-element vector, not three separate calls. Adjacent literals fuse into a strand at parse time. Adjacent names do *not* fuse — `a b c` is three separate references.
- **Scalar promotion.** `1 + 2 3 4` ↦ `3 4 5`. Any scalar broadcasts against any-rank conformable shape.
- **Conformability** = exactly matching shapes, OR one side scalar, OR (in some dialects) one side rank-1 cycling against rank-N. Keep strict in v1: matching shape or scalar only.
- **`⍳` is overloaded.** Monadic `⍳N` = vector 1..N (or 0..N-1 if `⎕IO=0`). Dyadic `V ⍳ W` = first-index lookup, returns `≢V+1` for not-found.
- **Reduce with `+/⍳0`** = `0` (identity for `+`). Each scalar primitive has a defined identity used by reduce-on-empty. Don't crash; return identity.
- **Reduce direction.** `f/` reduces the *last* axis. `f⌿` reduces the *first*. Matters for matrices.
- **Indexing is 1-based** by default (`⎕IO=1`). Do not silently translate to 0-based; respect `⎕IO`.
- **Bracket indexing** `A[I]` is sugar for `I⌷A` (squad-quad). Multi-axis: `A[I;J]` is `I J⌷A` with semicolon-separated axes; `A[;J]` selects all of axis 0.
- **Dfn `{...}`** — `⍺` = left arg (may be unbound for monadic call → check with `⍺←default`), `⍵` = right arg, `∇` = recurse. Default left arg syntax: `⍺←0`.
- **Tradfn vs dfn** — tradfns use line-numbered `→linenum` for goto; dfns use guards `cond:expr`. Pick the right one for the user's syntax.
- **Empty array** = rank-N array where some dim is 0. `0⍴⍳0` is empty rank-1. Scalar prototype matters for empty-array operations; ignore in v1, return 0/space.
- **Test corpus:** custom + idioms. Place programs in `lib/apl/tests/programs/` with `.apl` extension.
-
-## General gotchas (all loops)
-
- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
- `cond`/`when`/`let` clauses evaluate only the last expr.
- `type-of` on user fn returns `"lambda"`.
- Shell heredoc `||` gets eaten — escape or use `case`.
-
-## Style
-
- No comments in `.sx` unless non-obvious.
- No new planning docs — update `plans/apl-on-sx.md` inline.
- Short, factual commit messages (`apl: outer product ∘. (+9)`).
- One feature per iteration. Commit. Log. Next.
-
-Go. Read the plan; find first `[ ]`; implement.
--- a/plans/agent-briefings/common-lisp-loop.md
+++ b/plans/agent-briefings/common-lisp-loop.md
@@ -1,80 +0,0 @@
-# common-lisp-on-sx loop agent (single agent, queue-driven)
-
-Role: iterates `plans/common-lisp-on-sx.md` forever. Conditions + restarts on delimited continuations is the headline showcase — every other Lisp reinvents resumable exceptions on the host stack. On SX `signal`/`invoke-restart` is just a captured continuation. Plus CLOS, the LOOP macro, packages.
-
-```
-description: common-lisp-on-sx queue loop
-subagent_type: general-purpose
-run_in_background: true
-isolation: worktree
-```
-
-## Prompt
-
-You are the sole background agent working `/root/rose-ash/plans/common-lisp-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
-
-## Restart baseline — check before iterating
-
-1. Read `plans/common-lisp-on-sx.md` — roadmap + Progress log.
-2. `ls lib/common-lisp/` — pick up from the most advanced file.
-3. If `lib/common-lisp/tests/*.sx` exist, run them. Green before new work.
-4. If `lib/common-lisp/scoreboard.md` exists, that's your baseline.
-
-## The queue
-
-Phase order per `plans/common-lisp-on-sx.md`:
-
- **Phase 1** — reader + parser (read macros `#'` `'` `` ` `` `,` `,@` `#( … )` `#:` `#\char` `#xFF` `#b1010`, ratios, dispatch chars, lambda lists with `&optional`/`&rest`/`&key`/`&aux`)
- **Phase 2** — sequential eval + special forms (`let`/`let*`/`flet`/`labels`, `block`/`return-from`, `tagbody`/`go`, `unwind-protect`, multiple values, `setf` subset, dynamic variables)
- **Phase 3** — **THE SHOWCASE**: condition system + restarts. `define-condition`, `signal`/`error`/`cerror`/`warn`, `handler-bind` (non-unwinding), `handler-case` (unwinding), `restart-case`, `restart-bind`, `find-restart`/`invoke-restart`/`compute-restarts`, `with-condition-restarts`. Classic programs (restart-demo, parse-recover, interactive-debugger) green.
- **Phase 4** — CLOS: `defclass`, `defgeneric`, `defmethod` with `:before`/`:after`/`:around`, `call-next-method`, multiple dispatch
- **Phase 5** — macros + LOOP macro + reader macros
- **Phase 6** — packages + stdlib (sequence functions, FORMAT directives, drive corpus to 200+)
-
-Within a phase, pick the checkbox that unlocks the most tests per effort.
-
-Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
-
-## Ground rules (hard)
-
- **Scope:** only `lib/common-lisp/**` and `plans/common-lisp-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. CL primitives go in `lib/common-lisp/runtime.sx`.
- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
- **Shared-file issues** → plan's Blockers with minimal repro.
- **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
- **Worktree:** commit locally. Never push. Never touch `main`.
- **Commit granularity:** one feature per commit.
- **Plan file:** update Progress log + tick boxes every commit.
-
-## Common-Lisp-specific gotchas
-
- **`handler-bind` is non-unwinding** — handlers can decline by returning normally, in which case `signal` keeps walking the chain. **`handler-case` is unwinding** — picking a handler aborts the protected form via a captured continuation. Don't conflate them.
- **Restarts are not handlers.** `restart-case` establishes named *resumption points*; `signal` runs handler code with restarts visible; the handler chooses a restart by calling `invoke-restart`, which abandons handler stack and resumes at the restart point. Two stacks: handlers walk down, restarts wait to be invoked.
- **`block` / `return-from`** is lexical. `block name … (return-from name v) …` captures `^k` once at entry; `return-from` invokes it. `return-from` to a name not in scope is an error (don't fall back to outer block).
- **`tagbody` / `go`** — each tag in tagbody is a continuation; `go tag` invokes it. Tags are lexical, can only target tagbodies in scope.
- **`unwind-protect`** runs cleanup on *any* non-local exit (return-from, throw, condition unwind). Implement as a scope frame fired by the cleanup machinery.
- **Multiple values**: primary-value-only contexts (function args, `if` test, etc.) drop extras silently. `values` produces multiple. `multiple-value-bind` / `multiple-value-call` consume them. Don't auto-list.
- **CLOS dispatch:** sort applicable methods by argument-list specificity (`subclassp` per arg, left-to-right); standard method combination calls primary methods most-specific-first via `call-next-method` chain. `:before` runs all before primaries; `:after` runs all after, in reverse-specificity. `:around` wraps everything.
- **`call-next-method`** is a *continuation* available only inside a method body. Implement as a thunk stored in a dynamic-extent variable.
- **Generalised reference (`setf`)**: `(setf (foo x) v)` ↦ `(setf-foo v x)`. Look up the setf-expander, not just a writer fn. `define-setf-expander` is mandatory for non-trivial places. Start with the symbolic / list / aref / slot-value cases.
- **Dynamic variables (specials):** `defvar`/`defparameter` mark a symbol as special. `let` over a special name *rebinds* in dynamic extent (use parameterize-style scope), not lexical.
- **Symbols are package-qualified.** Reader resolves `cl:car`, `mypkg::internal`, bare `foo` (current package). Internal vs external matters for `:` (one colon) reads.
- **`nil` is also `()` is also the empty list.** Same object. `nil` is also false. CL has no distinct unit value.
- **LOOP macro is huge.** Build incrementally — start with `for/in`, `for/from`, `collect`, `sum`, `count`, `repeat`. Add conditional clauses (`when`, `if`, `else`) once iteration drivers stable. `named` blocks + `return-from named` last.
- **Test corpus:** custom + curated `ansi-test` slice. Place programs in `lib/common-lisp/tests/programs/` with `.lisp` extension.
-
-## General gotchas (all loops)
-
- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
- `cond`/`when`/`let` clauses evaluate only the last expr.
- `type-of` on user fn returns `"lambda"`.
- Shell heredoc `||` gets eaten — escape or use `case`.
-
-## Style
-
- No comments in `.sx` unless non-obvious.
- No new planning docs — update `plans/common-lisp-on-sx.md` inline.
- Short, factual commit messages (`common-lisp: handler-bind + 12 tests`).
- One feature per iteration. Commit. Log. Next.
-
-Go. Read the plan; find first `[ ]`; implement.
--- a/plans/agent-briefings/primitives-loop.md
+++ b/plans/agent-briefings/primitives-loop.md
@@ -1,789 +0,0 @@
-# SX Primitives — Meta-Loop Briefing
-
-Goal: add fundamental missing SX primitives in sequence, then sweep all language
-implementations to replace their workarounds. Full rationale: vectors fix O(n) array
-access across every language; numeric tower fixes float/int conflation; dynamic-wind
-fixes cleanup semantics; coroutine primitive unifies Ruby/Lua/Tcl; string buffer fixes
-O(n²) concat; algebraic data types eliminate the tagged-dict pattern everywhere.
-
-**Each fire: find the first unchecked `[ ]`, do it, commit, tick it, stop.**
-Sub-items within a Phase may span multiple fires — just commit progress and tick what's done.
-
---
-
-## Phase 0 — Prep (gate)
-
- [x] Stop new-language loops: send `/exit` to sx-loops windows for the four blank-slate
-      languages that haven't committed workarounds yet:
-      ```
-      tmux send-keys -t sx-loops:common-lisp "/exit" Enter
-      tmux send-keys -t sx-loops:apl          "/exit" Enter
-      tmux send-keys -t sx-loops:ruby         "/exit" Enter
-      tmux send-keys -t sx-loops:tcl          "/exit" Enter
-      ```
-      Verify all four windows are idle (claude prompt, no active task).
-
- [x] E38 + E39 landed: check both Bucket-E branches for implementation commits.
-      ```
-      git log --oneline hs-e38-sourceinfo | head -5
-      git log --oneline hs-e39-webworker  | head -5
-      ```
-      If either branch has only its base commit (no impl work yet): note "pending" and stop —
-      next fire re-checks. Proceed only when both have at least one implementation commit.
-
---
-
-## Phase 1 — Vectors
-
-Native mutable integer-indexed arrays. Fix: Lua O(n) sort, APL rank polymorphism, Ruby
-Array, Tcl lists, Common Lisp vectors, all using string-keyed dicts today.
-
-Primitives to add:
- `make-vector` `n` `[fill]` → vector of length n
- `vector?` `v` → bool
- `vector-ref` `v` `i` → element at index i (0-based)
- `vector-set!` `v` `i` `x` → mutate in place
- `vector-length` `v` → integer
- `vector->list` `v` → list
- `list->vector` `lst` → vector
- `vector-fill!` `v` `x` → fill all elements
- `vector-copy` `v` `[start]` `[end]` → fresh copy of slice
-
-Steps:
- [x] OCaml: add `SxVector of value array` to `hosts/ocaml/sx_types.ml`; implement all
-      primitives in `hosts/ocaml/sx_primitives.ml` (or equivalent); wire into evaluator.
-      Note: Vector type + most prims were already present; added bounds-checked vector-ref/set!
-      and optional start/end to vector-copy. 10/10 vector tests pass (r7rs suite).
- [x] Spec: add vector entries to `spec/primitives.sx` with type signatures and descriptions.
-      All 10 vector primitives now have :as type annotations, :returns, and :doc strings.
-      make-vector: optional fill param; vector-copy: optional start/end (done prev step).
- [x] JS bootstrapper: implement vectors in `hosts/javascript/platform.js` (or equivalent);
-      ensure `sx-browser.js` rebuild picks them up.
-      Fixed index-of for lists (was returning -1 not NIL, breaking bind-lambda-params),
-      added _lastErrorKont_/hostError/try-catch/without-io-hook stubs. Vectors work.
- [x] Tests: 40+ tests in `spec/tests/test-vectors.sx` covering construction, ref, set!,
-      length, conversions, fill, copy, bounds behaviour.
-      42 tests, all pass. 1847 standard / 2362 full passing (up from 5).
- [x] Verify: full test suite still passes (`node hosts/javascript/run_tests.js --full`).
-      2362/4924 pass (improvement from pre-existing lambda binding bug, no regressions).
- [x] Commit: `spec: vector primitive (make-vector/vector-ref/vector-set!/etc)`
-      Committed as: js: fix lambda binding (index-of on lists), add vectors + R7RS platform stubs
-
---
-
-## Phase 2 — Numeric tower
-
-Float ≠ integer distinction. Fix: Erlang `=:=`, Lua `math.type()`, Haskell `Num`/`Integral`,
-Common Lisp `integerp`/`floatp`/`ratio`, JS `Number.isInteger`.
-
-Changes:
- `parse-number` preserves float identity: `"1.0"` → float 1.0, not integer 1
- New predicates: `integer?`, `float?`, `exact?`, `inexact?`
- New coercions: `exact->inexact`, `inexact->exact`
- Fix `floor`/`ceiling`/`truncate`/`round` to return integers when applied to floats
- `number->string` renders `1.0` as `"1.0"`, `1` as `"1"`
- Arithmetic: `(+ 1 1.0)` → `2.0` (float contagion), `(+ 1 1)` → `2` (integer)
-
-Steps:
- [x] OCaml: distinguish `Integer of int` / `Number of float` in `sx_types.ml`; update all
-      arithmetic primitives for float contagion; fix `parse-number`.
-      92/92 numeric tower tests pass; 4874 total (394 pre-existing hs-upstream fails unchanged).
- [x] Spec: update `spec/primitives.sx` with new predicates + coercions; document contagion rules.
-      Added integer?/float? predicates; updated number? body; / returns "float"; floor/ceil/truncate
-      return "integer"; +/-/* doc float contagion; fixed double-paren params; 4874/394 baseline.
- [x] JS bootstrapper: update number representation and arithmetic.
-      Added integer?/float?/exact?/inexact?/truncate/remainder/modulo/random-int/exact->inexact/
-      inexact->exact/parse-number. Fixed sx_server.ml epoch protocol for Integer type.
-      JS: 1940 passed (+60); OCaml: 4874/394 unchanged. 6 tests JS-only fail (float≡int limitation).
- [x] Tests: 92 tests in `spec/tests/test-numeric-tower.sx` — int-arithmetic, float-contagion,
-      division, predicates, coercions, rounding, parse-number, equality, modulo, min-max, stringify.
- [x] Verify: full suite passes. OCaml 4874/394 (baseline unchanged). JS 1940/2500 (+60 vs pre-tower).
-      No regressions on any test that relied on `1.0 = 1` — those tests were already using integer
-      literals which remain identical in JS. 6 JS-only failures are platform-inherent (JS float≡int).
- [x] Commit: all work landed across 4 commits (c70bbdeb, 45ec5535, b12a22e6, f5acb31c).
-
---
-
-## Phase 3 — Dynamic-wind
-
-Fix: Common Lisp `unwind-protect`, Ruby `ensure`, JS `finally`, Tcl `catch`+cleanup,
-Erlang `try...after` (currently uses double-nested guard workaround).
-
- [x] Spec: implement `dynamic-wind` in `spec/evaluator.sx` such that the after-thunk fires
-      on both normal return AND non-local exit (raise/call-cc escape). Must compose with
-      `guard` — currently they don't interact.
- [x] OCaml: wire `dynamic-wind` through the CEK machine with a `WindFrame` continuation.
- [x] JS bootstrapper: update.
- [x] Tests: 20+ tests covering normal return, raise, call/cc escape, nested dynamic-winds.
- [x] Commit: `spec: dynamic-wind + guard integration`
-
---
-
-## Phase 4 — Coroutine primitive
-
-Unify Ruby fibers, Lua coroutines, Tcl coroutines — all currently reimplemented separately
-using call/cc+perform/resume.
-
- [x] Spec: add `make-coroutine`, `coroutine-resume`, `coroutine-yield`, `coroutine?`,
-      `coroutine-alive?` to `spec/primitives.sx`. Build on existing `perform`/`cek-resume`
-      machinery — coroutines ARE perform/resume with a stable identity.
-      Implemented as `spec/coroutines.sx` define-library; `make-coroutine` stub in evaluator.sx.
-      17/17 coroutine tests pass (OCaml). Drives iteration via define+fn recursion (not named let —
-      named let uses cek_call→cek_run which errors on IO suspension).
- [x] OCaml: implement coroutine type; wire resume/yield through CEK suspension.
-      No new native type needed — dict-based coroutine identity + existing cek-step-loop/
-      cek-resume/perform primitives in run_tests.ml ARE the OCaml implementation. 17/17 pass.
- [x] JS bootstrapper: update.
-      All CEK primitives already in sx-browser.js. Fix: pre-load spec/coroutines.sx +
-      spec/signals.sx in run_tests.js so (import (sx coroutines)) resolves without suspension.
-      17/17 pass in JS. 1965/2500 (+25 vs 1940 baseline). Zero new failures.
- [x] Tests: 25+ tests — multi-yield, final return, arg passthrough, alive? predicate,
-      nested coroutines, "final return vs yield" distinction (the Lua gotcha).
-      27 tests: added 10 new — state field inspection (ready/suspended/dead), yield from
-      nested helper, initial resume arg ignored, mutable closure state, complex yield values,
-      round-robin scheduling, factory-shared-no-state, non-coroutine error. 27/27 OCaml+JS.
- [x] Commit: `spec: coroutine primitive (make-coroutine/resume/yield)`
-      Phase 4 landed across 4 commits: 21cb9cf5 (spec library), 9eb12c66 (ocaml verified),
-      b78e06a7 (js pre-load), 0ffe208e (27 tests). Phase 4 complete.
-
---
-
-## Phase 5 — String buffer
-
-Fix O(n²) string concatenation in loops across Lua, Ruby, Common Lisp, Tcl.
-
- [x] Spec + OCaml: add `make-string-buffer`, `string-buffer-append!`, `string-buffer->string`,
-      `string-buffer-length` to primitives. OCaml: `Buffer.t` wrapper. JS: array+join.
-      Also: string-buffer? predicate; SxStringBuffer._string_buffer marker for typeOf/dict?
-      exclusion; inspect case in sx_types.ml. 17/17 tests OCaml+JS.
- [x] Tests: 15+ tests.
-      17 tests written inline with Spec+OCaml step: construction, type-of, empty/length,
-      single/multi-append, append-returns-nil, empty-string-append, reuse-after-to-string,
-      independence, loop-building, CSV-row, unicode, repeated-to-string, join-pattern.
-      17/17 OCaml+JS.
- [x] Commit: `spec: string-buffer primitive`
-      Committed as d98b5fa2 — all work in one commit (OCaml type + primitives + JS + spec + 17 tests).
-
---
-
-## Phase 6 — Algebraic data types
-
-The deepest structural gap. Every language uses `{:tag "..." :field ...}` tagged dicts to
-simulate sum types. A native `define-type` + `match` form eliminates this everywhere.
-
- [x] Design: write `plans/designs/sx-adt.md` covering syntax, CEK dispatch, interaction with
-      existing `cond`/`case`, exhaustiveness checking, recursive types, pattern variables.
-      Draft, then stop — next fire reviews design before implementing.
-      Written: define-type/match syntax, AdtValue runtime rep, stepSfDefineType + MatchFrame
-      CEK dispatch, exhaustiveness warnings via _adt_registry, recursive types, nested patterns,
-      wildcard _, 3-phase impl plan (basic/nested/exhaustiveness), open questions on accessors/singletons/inspect.
-
- [x] Spec: implement `define-type` special form in `spec/evaluator.sx`:
-      `(define-type Name (Ctor1 field...) (Ctor2 field...) ...)`
-      Creates constructor functions `Ctor1`, `Ctor2` + predicate `Name?`.
-
- [x] Spec: implement `match` special form:
-      `(match expr ((Ctor1 a b) body) ((Ctor2 x) body) (else body))`
-      Exhaustiveness warning if not all constructors covered and no `else`.
-
- [x] OCaml: add `SxAdt of string * value array` to types; implement constructors + match.
-      Dict-based ADT (no native type needed — matches spec). Hand-written sf_define_type
-      in bootstrap.py FIXUPS; registered via register_special_form. 172 assertions pass.
-      4280/1080 full suite (37 improvement over old baseline 4243/1117).
- [x] JS bootstrapper: update.
-      No changes needed — define-type/match are spec-level; sx-browser.js rebuilt at 0dc7e159.
-      40/40 ADT tests pass JS. 2032/2500 total (+67 vs 1965 phase-4 baseline).
- [x] Tests: 40+ tests in `spec/tests/test-adt.sx`.
-      40 tests written across two spec commits (6c872107+0dc7e159). All pass OCaml+JS.
- [x] Commit: `spec: algebraic data types (define-type + match)`
-      Phase 6 landed across 5 commits: 6c872107 (define-type spec), 0dc7e159 (match spec),
-      5d1913e7 (ocaml bootstrap), f63b2147 (plan tick). JS already current.
-
---
-
-## Phase 7 — Bitwise operations
-
-Completely absent today. Needed by: Forth (core), APL (array masks), Erlang (bitmatch),
-JS (typed arrays, bitfields), Common Lisp (`logand`/`logior`/`logxor`/`lognot`/`ash`).
-
-Primitives to add:
- `bitwise-and` `a` `b` → integer
- `bitwise-or` `a` `b` → integer
- `bitwise-xor` `a` `b` → integer
- `bitwise-not` `a` → integer
- `arithmetic-shift` `a` `count` → integer (left if count > 0, right if count < 0)
- `bit-count` `a` → number of set bits (popcount)
- `integer-length` `a` → number of bits needed to represent a
-
-Steps:
- [x] Spec: add entries to `spec/primitives.sx` with type signatures.
-      stdlib.bitwise module with 7 entries appended to spec/primitives.sx.
- [x] OCaml: implement in `hosts/ocaml/sx_primitives.ml` using OCaml `land`/`lor`/`lxor`/`lnot`/`lsl`/`asr`.
-      land/lor/lxor/lnot/lsl/asr in sx_primitives.ml. bit-count: Kernighan loop. integer-length: lsr loop.
- [x] JS bootstrapper: implement in `hosts/javascript/platform.js` using JS `&`/`|`/`^`/`~`/`<<`/`>>`.
-      stdlib.bitwise module added to PRIMITIVES_JS_MODULES. bit-count: Hamming weight. integer-length: Math.clz32.
- [x] Tests: 25+ tests in `spec/tests/test-bitwise.sx` — basic ops, shift left/right, negative numbers, popcount.
-      26 tests, 158 assertions, all pass OCaml+JS.
- [x] Commit: `spec: bitwise operations (bitwise-and/or/xor/not, arithmetic-shift, bit-count)`
-      Committed a8a79dc9. Phase 7 complete in single commit.
-
---
-
-## Phase 8 — Multiple values
-
-R7RS standard. Common Lisp uses them heavily; Haskell tuples map naturally; Erlang
-multi-return. Without them, every function returning two things encodes it as a list or dict.
-
-Primitives / forms to add:
- `values` `v...` → multiple-value object
- `call-with-values` `producer` `consumer` → applies consumer to values from producer
- `let-values` `(((a b) expr) ...)` `body` — binding form (special form in evaluator)
- `define-values` `(a b ...)` `expr` — top-level multi-value bind
-
-Steps:
- [x] Spec: add `SxValues` type to evaluator; implement `values` + `call-with-values` in
-      `spec/evaluator.sx`; add `let-values` / `define-values` special forms.
- [x] OCaml: add `SxValues of value list` to `sx_types.ml`; wire through CEK.
- [x] JS bootstrapper: implement values type + forms.
- [x] Tests: 25+ tests in `spec/tests/test-values.sx` — basic producer/consumer, let-values
-      destructuring, define-values, interaction with `begin`/`do`.
- [x] Commit: `spec: multiple values (values/call-with-values/let-values)`
-
---
-
-## Phase 9 — Promises (lazy evaluation)
-
-Critical for Haskell — lazy evaluation is so central that without it the Haskell
-implementation can't be idiomatic. Also useful for lazy lists in Common Lisp and
-lazy streams in Scheme-style code generally.
-
-Primitives / forms to add:
- `delay` `expr` → promise (special form — expr not evaluated yet)
- `force` `p` → evaluate promise, cache result, return it
- `make-promise` `v` → already-forced promise wrapping v
- `promise?` `v` → bool
- `delay-force` `expr` → for iterative lazy sequences (avoids stack growth in lazy streams)
-
-Steps:
- [x] Spec: add `delay` / `delay-force` special forms to `spec/evaluator.sx`; add promise
-      type with mutable forced/value slots; `force` checks if already forced before eval.
- [x] OCaml: add `SxPromise of { mutable forced: bool; mutable value: value; thunk: value }`;
-      wire `delay`/`force`/`delay-force` through CEK.
- [x] JS bootstrapper: implement promise type + forms.
- [x] Tests: 25+ tests in `spec/tests/test-promises.sx` — basic delay/force, memoisation
-      (forced only once), delay-force lazy stream, promise? predicate, make-promise.
- [x] Commit: `spec: promises — delay/force/delay-force for lazy evaluation`
-
---
-
-## Phase 10 — Mutable hash tables
-
-Distinct from SX's immutable dicts. Dict primitives copy on every update — fine for
-functional code, wrong for table-heavy language implementations. Lua tables, Smalltalk
-dicts, Erlang process dictionaries, and JS Map all need O(1) mutable associative storage.
-
-Primitives to add:
- `make-hash-table` `[capacity]` → fresh mutable hash table
- `hash-table?` `v` → bool
- `hash-table-set!` `ht` `key` `val` → mutate in place
- `hash-table-ref` `ht` `key` `[default]` → value or default/error
- `hash-table-delete!` `ht` `key` → remove entry
- `hash-table-size` `ht` → integer
- `hash-table-keys` `ht` → list of keys
- `hash-table-values` `ht` → list of values
- `hash-table->alist` `ht` → list of (key . value) pairs
- `hash-table-for-each` `ht` `fn` → iterate (fn key val) for side effects
- `hash-table-merge!` `dst` `src` → merge src into dst in place
-
-Steps:
- [x] Spec: add entries to `spec/primitives.sx`.
-      stdlib.hash-table module with 11 define-primitive entries appended to spec/primitives.sx.
- [x] OCaml: add `HashTable of (value, value) Hashtbl.t` to `sx_types.ml`; implement
-      all primitives in `hosts/ocaml/sx_primitives.ml`.
-      HashTable variant in sx_types.ml; type_of/inspect cases added; 11 primitives in sx_primitives.ml;
-      fixed _cek_call_ref reference for hash-table-for-each. 4385/1080 (+28).
- [x] JS bootstrapper: implement using JS `Map` in `hosts/javascript/platform.js`.
-      SxHashTable class with Map; _hash_table marker; dict?/type-of exclusion; apply() for for-each.
-      2137/2500 (+4 vs phase-9 baseline).
- [x] Tests: 30+ tests in `spec/tests/test-hash-table.sx` — set/ref/delete, size, iteration,
-      default on missing key, merge, keys/values lists.
-      28 tests; all pass OCaml+JS. Used empty? not assert= for empty-list comparisons.
- [x] Commit: `spec: mutable hash tables (make-hash-table/ref/set!/delete!/etc)`
-      Committed 133bdf52. Phase 10 complete.
-
---
-
-## Phase 11 — Sequence protocol
-
-Unified iteration over lists and vectors without conversion. Currently `map`/`filter`/
-`for-each` only work on lists — you must `vector->list` first, which defeats the purpose
-of vectors. A sequence protocol makes all collection operations polymorphic.
-
-Approach: extend existing `map`/`filter`/`reduce`/`for-each`/`some`/`every?` to dispatch
-on type (list → existing path, vector → index loop, string → char iteration). Add:
- `in-range` `start` `[end]` `[step]` → lazy range sequence (works with `for-each`/`map`)
- `sequence->list` `s` → coerce any sequence to list
- `sequence->vector` `s` → coerce any sequence to vector
- `sequence-length` `s` → length of any sequence
- `sequence-ref` `s` `i` → element by index (lists and vectors)
- `sequence-append` `s1` `s2` → concatenate two same-type sequences
-
-Steps:
- [x] Spec: extend `map`/`filter`/`reduce`/`for-each`/`some`/`every?` in `spec/evaluator.sx`
-      to type-dispatch; add `in-range` lazy sequence type + helpers.
- [x] OCaml: update HO form dispatch; add `SxRange` or use lazy list; implement `sequence-*`
-      primitives.
-      seq_to_list helper before let-rec block; ho_setup_dispatch wraps all 7 coll bindings;
-      seq-to-list/sequence-to-list/vector/length/ref/append/in-range in sx_primitives.ml.
-      4385/1080 (all failures pre-existing hs-*/regex; 0 regressions).
- [x] JS bootstrapper: update.
-      Already done in Spec step (da4b526a) — sx-browser.js rebuilt with seqToList/sequenceToList/
-      sequenceToVector/sequenceLength/sequenceRef/sequenceAppend/inRange. 2137/2500 JS tests pass.
- [x] Tests: 30+ tests in `spec/tests/test-sequences.sx` — map over vector, filter over
-      range, for-each over string chars, sequence-append, sequence->list/vector coercions.
-      45 tests all passing: JS 2185/2498 (+48), OCaml 4424/1087 (+39). Fixed: vector? rename
-      (isVector), vectorLength/vectorRef/reverse aliases, in-range letrec→build-range,
-      sequence-length nil=0, assert-equal for list comparisons. Committed 0fe00bf7.
- [x] Commit: `spec: sequence protocol — polymorphic map/filter/for-each over list/vector/range`
-      Work landed across da4b526a (Spec), 7286629c (OCaml), 06a3eee1 (JS bootstrap), 0fe00bf7 (Tests).
-
---
-
-## Phase 12 — gensym + symbol interning
-
-Unique symbol generation. Tiny to implement; broadly needed: Prolog uses it for fresh
-variable names, Common Lisp uses it constantly in macros, any hygienic macro system needs
-it, and Smalltalk uses it for anonymous class/method naming.
-
-Primitives to add:
- `gensym` `[prefix]` → unique symbol, e.g. `g42`, `var-17`. Counter-based, monotonically increasing.
- `symbol-interned?` `s` → bool — whether the symbol is in the global intern table
- `intern` `str` → symbol — intern a string as a symbol (string->symbol already exists; this is
-  the explicit interning operation for languages that distinguish interned vs uninterned)
-
-Steps:
- [x] Spec: add `gensym` counter to evaluator state; implement in `spec/evaluator.sx`.
-      `string->symbol` already exists — `gensym` is just a counter-suffixed variant.
-      Added *gensym-counter*/gensym/string->symbol/symbol->string/intern/symbol-interned? to
-      evaluator.sx. Added string->symbol/symbol->string transpiler renames + platform.py aliases.
-      JS 2186/+1. OCaml builds. Committed edf4e525.
- [x] OCaml: add global gensym counter; implement primitives.
-      gensym_counter ref + gensym/string->symbol/symbol->string/intern/symbol-interned? in sx_primitives.ml.
-      Also fixed ListRef case in seq_to_list (both sx_ref.ml + sx_primitives.ml). 4431/1080 (was 4385/1080).
- [x] JS bootstrapper: implement.
-      Already done in Spec step. JS 2186/2497, all sequence tests pass.
- [x] Tests: 15+ tests in `spec/tests/test-gensym.sx` — uniqueness, prefix, symbol?, string->symbol round-trip.
-      19 tests. OCaml 4450/1080, JS 2205/2497, zero regressions.
- [x] Commit: `spec: gensym + symbol interning` — 0862a614
-
---
-
-## Phase 13 — Character type
-
-Common Lisp and Haskell have a distinct `Char` type that is not a string. Without it both
-implementations are approximations — CL's `#\a` literal and Haskell's `'a'` both need a
-real char value, not a length-1 string.
-
-Primitives to add:
- `char?` `v` → bool
- `char->integer` `c` → Unicode codepoint integer
- `integer->char` `n` → char
- `char=?` `char<?` `char>?` `char<=?` `char>=?` → comparators
- `char-ci=?` `char-ci<?` etc. → case-insensitive comparators
- `char-alphabetic?` `char-numeric?` `char-whitespace?` → predicates
- `char-upper-case?` `char-lower-case?` → predicates
- `char-upcase` `char-downcase` → char → char
- `string->list` extended to return chars (not length-1 strings)
- `list->string` accepting chars
-
-Also: `#\a` reader syntax for char literals (parser addition).
-
-Steps:
- [x] Spec: add `SxChar` type to evaluator; add char literal syntax `#\a`/`#\space`/`#\newline`
-      to `spec/parser.sx`; implement all predicates + comparators.
- [x] OCaml: add `SxChar of char` to `sx_types.ml`; implement primitives.
- [x] JS bootstrapper: implement char type wrapping a codepoint integer.
- [x] Tests: 30+ tests in `spec/tests/test-chars.sx` — literals, char->integer round-trip,
-      comparators, predicates, upcase/downcase, string<->list with chars.
- [x] Commit: `spec: character type (char? char->integer #\\a literals + predicates)`
-
---
-
-## Phase 14 — String ports
-
-Needed for any language with a reader protocol: Common Lisp's `read`, Prolog's term parser,
-Smalltalk's `printString`. Without string ports these all do their own character walking
-on raw strings rather than treating a string as an I/O stream.
-
-Primitives to add:
- `open-input-string` `str` → input port
- `open-output-string` → output port
- `get-output-string` `port` → string (flush output port to string)
- `input-port?` `output-port?` `port?` → predicates
- `read-char` `[port]` → char or eof-object
- `peek-char` `[port]` → char or eof-object (non-consuming)
- `read-line` `[port]` → string or eof-object
- `write-char` `char` `[port]` → void
- `write-string` `str` `[port]` → void
- `eof-object` → the eof sentinel
- `eof-object?` `v` → bool
- `close-port` `port` → void
-
-Steps:
- [x] Spec: add port type + eof-object to evaluator; implement all primitives.
-      Ports are mutable objects with a position cursor (input) or accumulation buffer (output).
- [x] OCaml: add `SxPort` variant covering string-input-port and string-output-port;
-      Buffer.t for output, string+offset for input.
- [x] JS bootstrapper: implement port type.
- [x] Tests: 25+ tests in `spec/tests/test-ports.sx` — open/read/peek/eof, output accumulation,
-      read-line, write-char, close.
- [x] Commit: `spec: string ports (open-input-string/open-output-string/read-char/etc)` — 3d8937d7
-
---
-
-## Phase 15 — Math completeness
-
-Filling specific gaps that multiple language implementations need.
-
-### 15a — modulo / remainder / quotient distinction
-They differ on negative numbers — critical for Erlang `rem`, Haskell `mod`/`rem`, CL `mod`/`rem`:
- `quotient` `a` `b` → truncate toward zero (same sign as dividend)
- `remainder` `a` `b` → sign follows dividend (truncation division)
- `modulo` `a` `b` → sign follows divisor (floor division) — R7RS
-
-### 15b — Trigonometry and transcendentals
-Lua, Haskell, Erlang, CL all need: `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `exp`,
-`log`, `sqrt`, `expt`. Check which are already present; add missing ones.
-
-### 15c — GCD / LCM
-`gcd` `a` `b` → greatest common divisor; `lcm` `a` `b` → least common multiple.
-Needed by Haskell `Rational`, CL, and any language doing fraction arithmetic.
-
-### 15d — Radix number parsing / formatting
-`(number->string n radix)` → e.g. `(number->string 255 16)` → `"ff"`.
-`(string->number s radix)` → e.g. `(string->number "ff" 16)` → `255`.
-Needed by: Common Lisp, Smalltalk, Erlang integer formatting.
-
-Steps:
- [x] Audit which trig / math functions are already in `spec/primitives.sx`; note gaps.
- [x] Spec + OCaml + JS: implement missing trig (`sin`/`cos`/`tan`/`asin`/`acos`/`atan`/`exp`/`log`).
- [x] Spec + OCaml + JS: `quotient`/`remainder`/`modulo` with correct negative semantics.
- [x] Spec + OCaml + JS: `gcd`/`lcm`.
- [x] Spec + OCaml + JS: radix variants of `number->string`/`string->number`.
- [x] Tests: 40+ tests in `spec/tests/test-math.sx`.
- [x] Commit: `spec: math completeness — trig, quotient/remainder/modulo, gcd/lcm, radix`
-
---
-
-## Phase 16 — Rational numbers
-
-Haskell's `Rational` type and Common Lisp ratios (`1/3`) both need this. Natural extension
-of the numeric tower (Phase 2) — rationals are the third numeric type alongside int and float.
-
-Primitives to add:
- `make-rational` `numerator` `denominator` → rational (auto-reduced by GCD)
- `rational?` `v` → bool
- `numerator` `r` → integer
- `denominator` `r` → integer
- Reader syntax: `1/3` parsed as rational literal
- Arithmetic: `(+ 1/3 1/6)` → `1/2`; `(* 1/3 3)` → `1`; mixed int/rational → rational
- `exact->inexact` on rational → float; `inexact->exact` on float → rational approximation
- `(number->string 1/3)` → `"1/3"`
-
-Steps:
- [x] Spec: add `SxRational` type; add `n/d` reader syntax to `spec/parser.sx`; extend
-      all arithmetic primitives for rational contagion (int op rational → rational, rational
-      op float → float).
- [x] OCaml: add `SxRational of int * int` (stored in reduced form); implement all arithmetic.
-      as_number + safe_eq extended for cross-type rational equality (= 2.5 5/2) → true.
- [x] JS bootstrapper: implement rational type.
-      JS keeps int/int → float for CSS backward compatibility; SxRational class with _rational marker.
- [x] Tests: 30+ tests in `spec/tests/test-rationals.sx` — literals, arithmetic, reduction,
-      mixed numeric tower, exact<->inexact conversion. 62 tests, all pass.
- [x] Commit: `spec: rational numbers — 1/3 literals, arithmetic, numeric tower integration`
-      Committed 036022cc. JS: 2232 passed. OCaml: 4532 passed (+11).
-
---
-
-## Phase 17 — read / write / display
-
-Completes the I/O model. Builds on string ports (Phase 14) and char type (Phase 13).
-`read` parses any SX value from a port; `write` serializes with quoting (round-trippable);
-`display` serializes without quoting (human-readable). Common Lisp's `read` macro,
-Prolog term I/O, and Smalltalk's `printString` all need this.
-
-Primitives to add:
- `read` `[port]` → SX value or eof-object — full SX parser reading from a port
- `read-char` already in Phase 14; `read` uses it internally
- `write` `val` `[port]` → void — serializes with quotes: `"hello"`, `#\a`, `(1 2 3)`
- `display` `val` `[port]` → void — serializes without quotes: `hello`, `a`, `(1 2 3)`
- `newline` `[port]` → void — writes `\n`
- `write-to-string` `val` → string — convenience: `(write val (open-output-string))`
- `display-to-string` `val` → string — convenience
-
-Steps:
- [x] Spec: implement `read` in `spec/evaluator.sx` — wraps the existing parser to read
-      one datum from a port cursor; handles eof gracefully.
- [x] Spec: implement `write`/`display`/`newline` — extend the existing serializer for
-      port output; `write` quotes strings + uses `#\` for chars, `display` does not.
- [x] OCaml: wire `read` through port type; implement `write`/`display` output path.
- [x] JS bootstrapper: implement.
- [x] Tests: 25+ tests in `spec/tests/test-read-write.sx` — read string literal, read list,
-      read eof, write round-trip, display vs write quoting, newline, write-to-string.
- [x] Commit: `spec: read/write/display — S-expression reader/writer on ports`
-
---
-
-## Phase 18 — Sets
-
-O(1) membership testing. Distinct from hash tables (unkeyed) and lists (O(n)).
-Erlang has sets as a stdlib staple, Haskell `Data.Set`, APL uses set operations
-constantly, Common Lisp has `union`/`intersection` on lists but a native set is O(1).
-
-Primitives to add:
- `make-set` `[list]` → fresh set, optionally seeded from list
- `set?` `v` → bool
- `set-add!` `s` `val` → void
- `set-member?` `s` `val` → bool
- `set-remove!` `s` `val` → void
- `set-size` `s` → integer
- `set->list` `s` → list (unspecified order)
- `list->set` `lst` → set
- `set-union` `s1` `s2` → new set
- `set-intersection` `s1` `s2` → new set
- `set-difference` `s1` `s2` → new set (elements in s1 not in s2)
- `set-for-each` `s` `fn` → iterate for side effects
- `set-map` `s` `fn` → new set of mapped values
-
-Steps:
- [x] Spec: add entries to `spec/primitives.sx`.
- [x] OCaml: implement using `Hashtbl.t` with unit values (or a proper `Set` functor
-      with a comparison function); add `SxSet` to `sx_types.ml`.
- [x] JS bootstrapper: implement using JS `Set`.
- [x] Tests: 30+ tests in `spec/tests/test-sets.sx` — add/member/remove, union/intersection/
-      difference, list conversion, for-each, size.
- [x] Commit: `spec: sets (make-set/set-add!/set-member?/union/intersection/etc)`
-
---
-
-## Phase 19 — Regular expressions as primitives
-
-`lib/js/regex.sx` is a pure-SX regex engine already written. Promoting it to a primitive
-gives every language free regex without reinventing: Lua patterns, Tcl `regexp`, Ruby regex,
-JS regex, Erlang `re` module. Mostly a wiring job — the implementation exists.
-
-Primitives to add:
- `make-regexp` `pattern` `[flags]` → regexp object (`flags`: `"i"` case-insensitive, `"g"` global, `"m"` multiline)
- `regexp?` `v` → bool
- `regexp-match` `re` `str` → match dict `{:match "..." :start N :end N :groups (...)}` or nil
- `regexp-match-all` `re` `str` → list of match dicts
- `regexp-replace` `re` `str` `replacement` → string with first match replaced
- `regexp-replace-all` `re` `str` `replacement` → string with all matches replaced
- `regexp-split` `re` `str` → list of strings (split on matches)
- Reader syntax: `#/pattern/flags` for regexp literals (parser addition)
-
-Steps:
- [x] Audit `lib/js/regex.sx` — understand the API it already exposes; map to the
-      primitive API above.
- [x] Spec: add `SxRegexp` type to evaluator; add `#/pattern/flags` literal syntax to
-      `spec/parser.sx`; wire `lib/js/regex.sx` engine as the implementation.
- [x] OCaml: implement using OCaml `Re` library (or `Str`); add `SxRegexp` to types.
- [x] JS bootstrapper: use native JS `RegExp`; wrap in the primitive API.
- [x] Tests: 30+ tests in `spec/tests/test-regexp.sx` — basic match, groups, replace,
-      replace-all, split, flags (case-insensitive), no-match nil return.
- [x] Commit: `spec: regular expressions (make-regexp/regexp-match/regexp-replace + #/pat/ literals)`
-
---
-
-## Phase 20 — Bytevectors
-
-R7RS standard. Needed for WebSocket binary frames (E36), binary protocol parsing, and
-efficient string encoding. Also the foundation for proper Unicode: `string->utf8` /
-`utf8->string` require a byte array type.
-
-Primitives to add:
- `make-bytevector` `n` `[fill]` → bytevector of n bytes (fill defaults to 0)
- `bytevector?` `v` → bool
- `bytevector-length` `bv` → integer
- `bytevector-u8-ref` `bv` `i` → byte 0–255
- `bytevector-u8-set!` `bv` `i` `byte` → void
- `bytevector-copy` `bv` `[start]` `[end]` → fresh copy
- `bytevector-copy!` `dst` `at` `src` `[start]` `[end]` → in-place copy
- `bytevector-append` `bv...` → concatenated bytevector
- `utf8->string` `bv` `[start]` `[end]` → string decoded as UTF-8
- `string->utf8` `str` `[start]` `[end]` → bytevector UTF-8 encoded
- `bytevector->list` / `list->bytevector` → conversion
-
-Steps:
- [x] Spec: add `SxBytevector` type; implement all primitives in `spec/evaluator.sx` / `spec/primitives.sx`.
- [x] OCaml: add `SxBytevector of bytes` to `sx_types.ml`; implement primitives using
-      OCaml `Bytes`.
- [x] JS bootstrapper: implement using `Uint8Array`.
- [x] Tests: 30+ tests in `spec/tests/test-bytevectors.sx` — construction, ref/set, copy,
-      append, utf8 round-trip, slice.
- [x] Commit: `spec: bytevectors (make-bytevector/u8-ref/u8-set!/utf8->string/etc)`
-
---
-
-## Phase 21 — format
-
-CL-style string formatting beyond `str`. `(format "Hello ~a, age ~d" name age)`.
-Haskell `printf`, Erlang `io:format`, CL `format`, and general string templating all use this idiom.
-
-Directives:
- `~a` — display (no quotes)
- `~s` — write (with quotes)
- `~d` — decimal integer
- `~x` — hexadecimal integer
- `~o` — octal integer
- `~b` — binary integer
- `~f` — fixed-point float
- `~e` — scientific notation float
- `~%` — newline
- `~&` — fresh line (newline only if not already at start of line)
- `~~` — literal tilde
- `~t` — tab
-
-Signature: `(format template arg...)` → string.
-Optional: `(format port template arg...)` — write to port directly.
-
-Steps:
- [x] Spec: implement `format` as a pure SX function in `spec/stdlib.sx` — parses
-      `~X` directives, dispatches to `display`/`write`/`number->string` as appropriate.
-      Pure SX: no host calls needed. Self-hosting — uses string-buffer (Phase 5) internally.
- [x] OCaml: expose as a primitive (or let it run as SX through the evaluator).
-      Added format-decimal OCaml primitive; fixed lib/r7rs.sx number->string to support radix.
- [x] JS bootstrapper: same.
- [x] Tests: 28 tests in `spec/tests/test-format.sx` — each directive, multiple args,
-      nested format, `~~` escape. 28/28 pass on both JS and OCaml.
- [x] Commit: `spec: format — CL-style string formatting (~a ~s ~d ~x ~% etc)` — 4d7b3e29
-
---
-
-## Phase 22 — Language sweep
-
-Replace workarounds with primitives. One language per fire (or per sub-item for big ones).
-Start with blank slates (CL, APL, Ruby, Tcl) — they haven't committed to workarounds yet.
-
-**Scope per language:** only `lib/<lang>/**`. Don't touch spec or other languages.
-Brief each language's loop agent (or do inline) after rebasing their branch onto architecture.
-
- [x] Restart CL/APL/Ruby/Tcl loops with updated briefing pointing to new primitives.
-      Added `## SX primitive baseline` section to plans/common-lisp-on-sx.md,
-      plans/apl-on-sx.md, plans/ruby-on-sx.md, plans/tcl-on-sx.md. f43659ce.
-
- [x] Common Lisp: char type (`#\a`); string ports + `read`/`write` for reader/printer;
-      gensym for macros; rational numbers for CL ratios; multiple values; sets for CL set ops;
-      `modulo`/`remainder`/`quotient`; radix formatting; `format` for `cl:format`.
-      lib/common-lisp/runtime.sx (103 forms) + test.sh (68/68 pass). 1ad8e74a.
-
- [x] Lua: vectors for arrays; hash tables for Lua tables; `delay`/`force` for lazy iterators;
-      regexp for Lua pattern matching; trig from math completeness; bytevectors for binary I/O.
-      math/string/table stdlib tables + lua-force. 185/185 pass. ec3512d6.
-
- [x] Erlang: numeric tower for float/int; bitwise ops for bitmatch; multiple values for
-      multi-return; sets for Erlang sets; `remainder` for `rem`; regexp for `re` module.
-      lib/erlang/runtime.sx (63 forms) + test.sh (55/55 pass). 3c0a9632.
-
- [x] Haskell: numeric tower for `Num`/`Integral`/`Fractional`; promises for lazy evaluation
-      (critical); multiple values for tuples; rational numbers for `Rational`; char type for
-      `Char`; `gcd`/`lcm`; sets for `Data.Set`; `read`/`write` for `Show`/`Read` instances.
-      lib/haskell/runtime.sx (113 forms) + tests/runtime.sx (143/143 pass). c02ffcf3.
-
- [x] JS: vectors for Array; hash tables for `Map`; sets for `Set`; bitwise ops for typed
-      arrays; regexp for JS regex; bytevectors for `Uint8Array`; radix formatting.
-      lib/js/stdlib.sx (36 forms) + test.sh epochs 6000-6032 (25/25 pass). COMMIT.
-
- [x] Smalltalk: vectors for `Array new:`; hash tables for `Dictionary new`; sets for
-      `Set new`; char type for `Character`; string ports + `read`/`write` for `printString`.
-      lib/smalltalk/runtime.sx (72 forms) + tests/runtime.sx (86/86 pass). COMMIT.
-
- [x] APL: vectors as core array type; bitwise ops for array masks; sets for APL set ops;
-      sequence protocol for rank-polymorphic operations; format for APL output formatting.
-      lib/apl/runtime.sx (60 forms) + tests/runtime.sx (73/73 pass). COMMIT.
-
- [x] Ruby: coroutines for fibers; hash tables for `Hash`; sets for `Set`; regexp for
-      Ruby regex; string ports for `StringIO`; bytevectors for `String` binary encoding.
-      lib/ruby/runtime.sx (61 forms) + tests/runtime.sx (76/76 pass). COMMIT.
-      Note: rb-fiber-yield from letrec-bound lambdas fails (JIT VM can't invoke callcc
-      continuations as escapes); workaround: use top-level helper fns for recursive yields.
-
- [x] Tcl: string ports for Tcl channel abstraction; string-buffer for `append`; coroutines
-      for Tcl coroutines; regexp for Tcl `regexp`; format for Tcl `format`.
-      lib/tcl/runtime.sx (37 forms) + tests/runtime.sx (56/56 pass). COMMIT.
-
- [x] Forth: bitwise ops (core); string-buffer for word-definition accumulation; bytevectors
-      for Forth's raw memory model.
-      lib/forth/runtime.sx (36 forms) + tests/runtime.sx (64/64 pass). COMMIT.
-
---
-
-## Ground rules
-
- Work on the `architecture` branch in `/root/rose-ash` (main worktree).
- Use sx-tree MCP for all `.sx` file edits. Never use raw Edit/Write/Read on `.sx` files.
- Commit after each concrete unit of work. Never leave the branch broken.
- Never push to `main` — only push to `origin/architecture`.
- Update this checklist every fire: tick `[x]` done, add inline notes on blockers.
-
---
-
-## Progress log
-
-_Newest first._
-
- 2026-05-01: Phase 22 Forth done — runtime.sx (36 forms): bitwise (AND/OR/XOR/INVERT/LSHIFT/RSHIFT/2*/2//bit-count/integer-length/within + arithmetic helpers), string-buffer (emit!/type!/value/length/clear!/emit-int!), memory (cfetch/cstore/fetch/store/move!/fill!/erase!/mem->list). 64/64 tests. 8019e572.
- 2026-05-01: Phase 22 Tcl done — runtime.sx (37 forms): string-buffer (append accumulator), channel (read/write ports with gets/read/puts), regexp (make-regexp wrappers), format (%s/%d/%f/%x/%o/%%  manual char scan), coroutine (call/cc, top-level helper pattern). 56/56 tests. 3e07727d.
- 2026-05-01: Phase 22 Ruby done — runtime.sx (61 forms): Hash (list-of-pairs dict-backed), Set (make-set, (set item) order), Regexp (make-regexp wrappers), StringIO (write buf + rewind/char read), Bytevectors (thin wrappers), Fiber (call/cc; letrec JIT workaround: use top-level helpers). 76/76 tests. 182e6f63.
-
- 2026-05-01: Phase 22 APL done — runtime.sx (60 forms): iota/rho/at, rank-polymorphic dyadic/monadic helpers, arithmetic/comparison/boolean/bitwise element-wise, reduce/scan, take/drop/rotate/compress/index, set ops (member/nub/union/intersect/without), format. 73/73 tests. COMMIT.
- 2026-05-01: Phase 22 Smalltalk done — runtime.sx (72 forms): numeric helpers, Character (1-indexed Array backed by dict), Dictionary (list-of-pairs any-key map), Set (make-set), WriteStream/ReadStream/printString. set-member? (set item) order. 86/86 tests. COMMIT.
- 2026-05-01: Phase 22 JS done — stdlib.sx (36 forms): bitwise (truncate not js-num-to-int; set-member? takes (set item) order), Map (dict-backed pairs), Set (SX make-set), RegExp (callable lambda). 25/25 new tests pass; total 492/585. COMMIT.
- 2026-05-01: Phase 22 Haskell done — runtime.sx (113 forms): numeric tower (hk-div floor semantics), rational (dict GCD-normalised), hk-force (promises), Data.Char, Data.Set, Data.List, Maybe/Either, tuples, string helpers, hk-show. 148/148 tests. c02ffcf3.
- 2026-05-01: Phase 22 Erlang done — runtime.sx (63 forms): numeric tower, bitwise (band/bor/bxor/bnot/bsl/bsr), sets, re module, list BIFs, type conversions, ok/error tuples. 55/55 tests. 3c0a9632.
- 2026-05-01: Phase 22 Lua done — math/string/table stdlib tables + lua-force in lib/lua/runtime.sx. 185/185 tests (28 new). ec3512d6.
- 2026-05-01: Phase 22 CL done — runtime.sx (103 forms): type preds, arithmetic, chars, format, gensym, values, sets, radix, list utils. cl-empty? guards nil/() split. 68/68 tests. 1ad8e74a.
- 2026-05-01: Phase 22 step 1 — SX primitive baseline added to CL/APL/Ruby/Tcl plans. f43659ce.
- 2026-05-01: Phase 21 complete — format (~a ~s ~d ~x ~o ~b ~f ~% ~& ~~ ~t) as pure SX in spec/stdlib.sx. Fixed lib/r7rs.sx number->string to support optional radix; added format-decimal OCaml primitive. 28/28 tests on both JS and OCaml. 4d7b3e29.
- 2026-04-26: Phase 7 complete — bitwise-and/or/xor/not + arithmetic-shift + bit-count + integer-length. OCaml: land/lor/lxor/lnot/lsl/asr + Kernighan popcount + lsr loop for integer-length. JS: bitwise ops + Hamming weight + Math.clz32. 26 tests, 158 assertions, all pass. a8a79dc9.
- 2026-04-26: Phase 6 complete — JS+Tests+Commit all ticked. JS needed no changes (spec-level forms). 40/40 ADT tests pass JS. 2032/2500 JS total (+67 vs phase-4). Phase 6 fully landed: 6c872107+0dc7e159+5d1913e7. Phase 7 (bitwise) next.
- 2026-04-26: Phase 6 OCaml done — Dict-based ADT (no native SxAdt type needed); hand-written sf_define_type in bootstrap.py FIXUPS (skipped from transpile — &rest params + empty-dict {} literals); registered via register_special_form; step_limit/step_count added to PREAMBLE. 172 assertions pass (test-adt). Full suite 4280/1080 (was 4243/1117, +37). Committed 5d1913e7.
- 2026-04-26: Phase 6 Spec match done — ADT case added to match-pattern in spec/evaluator.sx: checks (list? pattern)+(symbol? first)+(dict? value)+(get value :_adt), then matches :_ctor+arity and recursively binds field patterns. No-clause error now uses make-cek-value+raise-eval-frame so guard can catch it. 20 new match tests pass; 40/40 total ADT tests green. Zero regressions.
- 2026-04-26: Phase 6 Spec define-type done — sf-define-type registered via register-special-form! in spec/evaluator.sx; AdtValue as {:_adt true :_type "..." :_ctor "..." :_fields (list ...)}; ctor fns + arity checking + Name?/Ctor? predicates + Ctor-field accessors; *adt-registry* dict populated per define-type call. 20/20 JS tests pass in spec/tests/test-adt.sx. OCaml define-type is next task.
- 2026-04-26: Phase 6 Design done — plans/designs/sx-adt.md written. Covers define-type/match syntax, AdtValue CEK runtime, stepSfDefineType+MatchFrame dispatch, exhaustiveness warnings, recursive types, nested patterns, wildcard _. 3-phase impl plan. Next fire: Spec implement define-type.
- 2026-04-26: Phase 5 complete — string buffer fully landed (d98b5fa2). 17 tests, 17/17 OCaml+JS. Phase 6 (ADTs) next.
- 2026-04-26: Phase 5 Spec+OCaml+JS step done — StringBuffer of Buffer.t in sx_types.ml; make-string-buffer/append!/->string/length/string-buffer? in sx_primitives.ml; SxStringBuffer with _string_buffer marker + typeOf/dict? fixes in platform.py; JS rebuilt. 17/17 tests OCaml+JS.
- 2026-04-26: Phase 4 complete — coroutine primitive fully landed (4 commits: spec library + OCaml verified + JS pre-load + 27 tests). Phase 5 (string buffer) next.
- 2026-04-26: Phase 4 Tests step done — 27 tests total (10 new: state field inspection, yield-from-helper, initial-arg-ignored, mutable-closure, complex-values, round-robin, factory-no-state, non-coroutine-error). 27/27 OCaml+JS.
- 2026-04-26: Phase 4 JS step done — all CEK primitives already in sx-browser.js; fix was pre-loading spec/coroutines.sx+spec/signals.sx in run_tests.js so (import (sx coroutines)) resolves synchronously. 17/17 coroutine tests pass JS. 1965/2500 total (+25), zero new failures.
- 2026-04-26: Phase 4 OCaml step done — no native SxCoroutine type needed; existing cek-step-loop/cek-resume/perform/make-cek-state primitives in run_tests.ml fully support the spec/coroutines.sx library. 284/284 pass (coroutines+vectors+numeric-tower+dynamic-wind), zero regressions.
- 2026-04-26: Phase 4 Spec step done — spec/coroutines.sx define-library with make-coroutine/coroutine-resume/coroutine-yield/coroutine?/coroutine-alive?; make-coroutine stub in evaluator.sx; 17/17 coroutine tests pass (OCaml). Key insight: coroutine body must use (define loop (fn...)) + (loop 0) not named let — named let uses cek_call→cek_run which errors on IO suspension.
- 2026-05-01: Phase 10 complete — mutable hash tables. HashTable variant in OCaml; JS Map-based SxHashTable. 11 primitives: make-hash-table/hash-table?/set!/ref/delete!/size/keys/values/->alist/for-each/merge!. 28 tests, all pass OCaml+JS. 133bdf52.
- 2026-05-01: Phase 9 complete — delay/force/delay-force/make-promise/promise?. Dict-based promise {:_promise :forced :thunk :value}; :_iterative flag for delay-force chain following. 25/25 tests OCaml (4357) and JS (2109). Committed e44cb89a.
- 2026-05-01: Phase 8 complete — values/call-with-values/let-values/define-values. Dict marker {:_values true :_list [...]} (no new type). step-sf-define desugars shorthand (define (f x) body) on both hosts. 25/25 tests OCaml+JS. Committed 43cc1d90.
- 2026-04-26: Phase 3 complete — OCaml+JS done. CallccContinuation gains winders-depth int; make_callcc_continuation/callcc_continuation_winders_len wired; wind-after/wind-return CekFrame fields fixed (cf_f=after-thunk, cf_extra=winders-len, cf_name=body-result); get_val + transpiler.sx updated. 8/8 dynamic-wind tests pass on OCaml; 235/235 (callcc+guard+do+r7rs) zero regressions. Committed 6602ec8c.
- 2026-04-26: Phase 3 Spec+Tests done — dynamic-wind CEK implementation: wind-after/wind-return frames, *winders* stack, kont-unwind-to-handler, wind-escape-to. callcc frame stores winders-len in continuation; callcc-continuation? calls wind-escape-to before escape. 8/8 dynamic-wind tests pass (normal return, raise, call/cc, nested LIFO, guard ordering). 1948/2500 JS (+8). Zero regressions. Committed a9d5a108.
- 2026-04-26: Phase 2 complete — Verify+Commit done. OCaml 4874/394, JS 1940/2500 (+60). No regressions. 6 JS-only failures are float≡int platform-inherent. Phase 2 fully landed across 4 commits.
- 2026-04-26: Phase 2 JS bootstrapper done — integer?/float?/exact?/inexact? added (Number.isInteger); truncate/remainder/modulo/random-int/exact->inexact/inexact->exact/parse-number added. Fixed sx_server.ml epoch+blob+io-response protocol for Integer type. JS: 1940/2500 (+60). OCaml: 4874/394 baseline. 6 JS tests fail (JS float≡int platform limit). Committed b12a22e6.
- 2026-04-26: Phase 2 Spec done — integer?/float? predicates added to spec/primitives.sx; floor/ceil/truncate :returns updated to "integer"; / to "float"; exact->inexact/inexact->exact docs and returns updated; float contagion documented on +/-/*; 4874/394 baseline. Committed 45ec5535.
- 2026-04-26: Phase 2 OCaml+Tests done — `Integer of int` / `Number of float` in sx_types.ml; float contagion across all arithmetic; floor/truncate/round → Integer; integer?/float?/exact?/inexact?/exact->inexact/inexact->exact; 92/92 numeric tower tests pass; 4874 total (394 pre-existing unchanged). Committed c70bbdeb.
- 2026-04-26: Phase 1 complete — JS step done. Fixed fundamental lambda binding bug (index-of on arrays returned -1 not NIL, making bind-lambda-params mis-fire &rest branch). Added _lastErrorKont_/hostError/try-catch stubs. 42/42 vector tests pass. 1847 std / 2362 full passing (up from 5). Committed.
- 2026-04-25: Phase 1 spec step done — all 10 vector primitives in spec/primitives.sx have full :as type annotations, :returns, :doc; make-vector optional fill param added.
- 2026-04-25: Phase 1 OCaml step done — bounds-checked vector-ref/set!, vector-copy now accepts optional start/end, spec/primitives.sx doc updated. 10/10 r7rs vector tests pass, 4747 total (394 pre-existing hs-upstream fails unchanged).
- 2026-04-25: Phase 0 complete — stopped CL/APL/Ruby/Tcl loops (all 4 idle at shell); confirmed E38 (tokenizer :end/:line) and E39 (WebWorker stub) both have implementation commits.
- 2026-05-01: Phase 20 complete — bytevectors. SxBytevector of bytes in OCaml using Bytes; Uint8Array-backed SxBytevector in JS. 12 primitives: make-bytevector, bytevector?, bytevector-length, bytevector-u8-ref, bytevector-u8-set!, bytevector-copy, bytevector-copy!, bytevector-append, utf8->string, string->utf8, bytevector->list, list->bytevector. 32 tests, all pass. JS 2535, OCaml 4725. a3811545.
- 2026-05-01: Phase 19 complete — regular expressions. SxRegexp(src,flags,Re.re) in OCaml via Re.Pcre; SxRegexp wrapper around JS RegExp. 9 primitives: make-regexp, regexp?, regexp-source, regexp-flags, regexp-match, regexp-match-all, regexp-replace, regexp-replace-all, regexp-split. Match dicts with :match/:start/:end/:groups. 32 tests, all pass. JS 2503, OCaml 4693. d8d5588e.
- 2026-05-01: Phase 18 complete — sets. SxSet as (string,value) Hashtbl keyed by inspect(val) in OCaml; Map keyed by write-to-string in JS. 13 primitives: make-set, set?, set-add!, set-member?, set-remove!, set-size, set->list, list->set, set-union, set-intersection, set-difference, set-for-each, set-map. 33 tests, all pass. JS 2469, OCaml 4659. 3b0ac67a.
- 2026-05-01: Phase 17 complete — read/write/display. OCaml: sx_write_val/sx_display_val helpers; read via Sx_parser.read_value with #t/#f and N/D rational support added to parser; postprocess ()→Nil. JS: sxReadNormalize (#t/#f→true/false), sxReadConvert (()→NIL), sxEq list equality, sxWriteVal symbol/keyword name fix (v.name not v._sym), readerMacroGet registry. 42 tests (test-read-write.sx), all pass both hosts. JS 2436, OCaml 4626. 7d329f02.
- 2026-05-01: Phase 16 complete — rational numbers. SxRational type in OCaml (Rational of int*int, reduced, denom>0) and JS (SxRational class, _rational marker). n/d reader in spec/parser.sx. Arithmetic contagion: int op rational → rational, rational op float → float. JS keeps int/int → float for CSS compat. OCaml as_number+safe_eq extended for cross-type rational equality. 62 tests in test-rationals.sx, all pass. JS 2232, OCaml 4532 (+11). 036022cc.
- 2026-05-01: Phase 15 complete — math completeness. stdlib.math module: sin/cos/tan/asin/acos/atan(1-2 args)/exp/log/expt/quotient/gcd/lcm/number->string(radix)/string->number(radix). OCaml atan updated for optional 2nd arg. Strict radix parsing in JS string->number. 44 tests in test-math.sx, all pass. JS 2311/4801, OCaml 4547/5629. be2b11ac.
- 2026-05-01: Phase 14 OCaml done — Eof + Port{PortInput/PortOutput} in sx_types.ml; 15 port primitives in sx_primitives.ml; raw_serialize updated; 4532/4532 (+39, zero regressions). 8ba0a33f.
- 2026-05-01: Phase 14 Spec+JS+Tests+Commit done — port type {_port,_kind,_source/_buffer,_pos,_closed}; eof singleton; 15 primitives in spec/primitives.sx (stdlib.ports) + platform.py; 39/39 tests in test-ports.sx. Committed 3d8937d7. OCaml step next.
- 2026-05-01: Phase 13 OCaml done — Char of int in sx_types.ml; #\ reader in sx_parser.ml; all char primitives in sx_primitives.ml; fixed get_val for Integer n list indexing (was Number-only); fixed raw_serialize for Integer/Char. 4493/4493 (+43, zero regressions). b939becd.
- 2026-05-01: Phase 13 Spec+JS+Tests+Commit done — SxChar tagged {_char,codepoint}; char? char->integer integer->char char-upcase/downcase; 10 comparators (ordered+ci); 5 predicates; string->list/list->string as platform primitives; #\a #\space #\newline reader syntax in spec/parser.sx; js-char-renames dict in transpiler.sx; 43/43 tests pass JS (2254/4745). Committed 4b600f17. OCaml step next.
- 2026-05-01: Phase 12 complete — gensym + symbol interning. gensym_counter/gensym/string->symbol/symbol->string/intern/symbol-interned? in spec + OCaml + JS. Fixed ListRef case in seq_to_list (both hosts). 19 tests, all pass. OCaml 4450/1080, JS 2205/2497. Commits: edf4e525 Spec, 0862a614 OCaml+Tests.
- 2026-05-01: Phase 11 complete — sequence protocol done. Commits: da4b526a Spec, 7286629c OCaml, 06a3eee1 JS, 0fe00bf7 Tests. JS 2185/+48, OCaml 4424/+39.
- 2026-05-01: Phase 11 Tests done — 45 tests in test-sequences.sx all passing (JS 2185/+48, OCaml 4424/+39). Fixed vector? rename, vectorLength/vectorRef/reverse aliases, in-range letrec→build-range, sequence-length nil, assert-equal for lists. Committed 0fe00bf7.
- 2026-05-01: Phase 11 JS bootstrapper step done — confirmed sx-browser.js current (built in Spec step da4b526a); 19 sequence primitive refs in output; 2137/2500 JS tests passing.
- 2026-05-01: Phase 11 OCaml step done — seq_to_list helper added before let-rec; ho_setup_dispatch wraps all 7 coll bindings with seq_to_list; seq-to-list/sequence-to-list/to-vector/length/ref/append + in-range primitives in sx_primitives.ml. 4385/4385 baseline unchanged, 0 regressions. Committed 7286629c.
- 2026-05-01: Phase 11 Spec step done — seq-to-list coercion helper; ho-setup-dispatch extended with seqToList on all collection args; sequence-to-list/vector/length/ref/append + in-range added to evaluator.sx. Restored 3 accidentally-deleted make-cek-state/value/suspended definitions. Fixed 8 shorthand define forms + added vector->list/list->vector transpiler renames. JS: 2137 passing (+28 vs HEAD baseline of 2109).
--- a/plans/agent-briefings/ruby-loop.md
+++ b/plans/agent-briefings/ruby-loop.md
@@ -1,83 +0,0 @@
-# ruby-on-sx loop agent (single agent, queue-driven)
-
-Role: iterates `plans/ruby-on-sx.md` forever. Fibers via delcc is the headline showcase — `Fiber.new`/`Fiber.yield`/`Fiber.resume` are textbook delimited continuations with sugar, where MRI does it via C-stack swapping. Plus blocks/yield (lexical escape continuations, same shape as Smalltalk's non-local return), method_missing, and singleton classes.
-
-```
-description: ruby-on-sx queue loop
-subagent_type: general-purpose
-run_in_background: true
-isolation: worktree
-```
-
-## Prompt
-
-You are the sole background agent working `/root/rose-ash/plans/ruby-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
-
-## Restart baseline — check before iterating
-
-1. Read `plans/ruby-on-sx.md` — roadmap + Progress log.
-2. `ls lib/ruby/` — pick up from the most advanced file.
-3. If `lib/ruby/tests/*.sx` exist, run them. Green before new work.
-4. If `lib/ruby/scoreboard.md` exists, that's your baseline.
-
-## The queue
-
-Phase order per `plans/ruby-on-sx.md`:
-
- **Phase 1** — tokenizer + parser. Keywords, identifier sigils (`@` ivar, `@@` cvar, `$` global), strings with interpolation, `%w[]`/`%i[]`, symbols, blocks `{|x| …}` and `do |x| … end`, splats, default args, method def
- **Phase 2** — object model + sequential eval. Class table, ancestor-chain dispatch, `super`, singleton classes, `method_missing` fallback, dynamic constant lookup
- **Phase 3** — blocks + procs + lambdas. Method captures escape continuation `^k`; `yield` / `return` / `break` / `next` / `redo` semantics; lambda strict arity vs proc lax
- **Phase 4** — **THE SHOWCASE**: fibers via delcc. `Fiber.new`/`Fiber.resume`/`Fiber.yield`/`Fiber.transfer`. Classic programs (generator, producer-consumer, tree-walk) green
- **Phase 5** — modules + mixins + metaprogramming. `include`/`prepend`/`extend`, `define_method`, `class_eval`/`instance_eval`, `respond_to?`/`respond_to_missing?`, hooks
- **Phase 6** — stdlib drive. `Enumerable` mixin, `Comparable`, Array/Hash/Range/String/Integer methods, drive corpus to 200+
-
-Within a phase, pick the checkbox that unlocks the most tests per effort.
-
-Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
-
-## Ground rules (hard)
-
- **Scope:** only `lib/ruby/**` and `plans/ruby-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. Ruby primitives go in `lib/ruby/runtime.sx`.
- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
- **Shared-file issues** → plan's Blockers with minimal repro.
- **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
- **Worktree:** commit locally. Never push. Never touch `main`.
- **Commit granularity:** one feature per commit.
- **Plan file:** update Progress log + tick boxes every commit.
-
-## Ruby-specific gotchas
-
- **Block `return` vs lambda `return`.** Inside a block `{ ... return v }`, `return` invokes the *enclosing method's* escape continuation (non-local return). Inside a lambda `->(){ ... return v }`, `return` returns from the *lambda*. Don't conflate. Implement: blocks bind their `^method-k`; lambdas bind their own `^lambda-k`.
- **`break` from inside a block** invokes a different escape — the *iteration loop's* escape — and the loop returns the break-value. `next` is escape from current iteration, returns iteration value. `redo` re-enters current iteration without advancing.
- **Proc arity is lax.** `proc { |a, b, c| … }.call(1, 2)` ↦ `c = nil`. Lambda is strict — same call raises ArgumentError. Check arity at call site for lambdas only.
- **Block argument unpacking.** `[[1,2],[3,4]].each { |a, b| … }` — single Array arg auto-unpacks for blocks (not lambdas). One arg, one Array → unpack. Frequent footgun.
- **Method dispatch chain order:** prepended modules → class methods → included modules → superclass → BasicObject → method_missing. `super` walks from the *defining* class's position, not the receiver class's.
- **Singleton classes** are lazily allocated. Looking up the chain for an object passes through its singleton class first, then its actual class. `class << obj; …; end` opens the singleton.
- **`method_missing`** — fallback when ancestor walk misses. Receives `(name_symbol, *args, &blk)`. Pair with `respond_to_missing?` for `respond_to?` to also report true. Do **not** swallow NoMethodError silently.
- **Ivars are per-object dicts.** Reading an unset ivar yields `nil` and a warning (`-W`). Don't error.
- **Constant lookup** is first lexical (Module.nesting), then inheritance (Module.ancestors of the innermost class). Different from method lookup.
- **`Object#send`** invokes private and public methods alike; `Object#public_send` skips privates.
- **Class reopening.** `class Foo; def bar; …; end; end` plus a later `class Foo; def baz; …; end; end` adds methods to the same class. Class table lookups must be by-name, mutable; methods dict is mutable.
- **Fiber semantics.** `Fiber.new { |arg| … }` creates a fiber suspended at entry. First `Fiber.resume(v)` enters with `arg = v`. Inside, `Fiber.yield(w)` returns `w` to the resumer; the next `Fiber.resume(v')` returns `v'` to the yield site. End of block returns final value to last resumer; subsequent `Fiber.resume` raises FiberError.
- **`Fiber.transfer`** is symmetric — either side can transfer to the other; no resume/yield asymmetry. Implement on top of the same continuation pair, just don't enforce direction.
- **Symbols are interned.** `:foo == :foo` is identity. Use SX symbols.
- **Strings are mutable.** `s = "abc"; s << "d"; s == "abcd"`. Hash keys can be strings; hash dups string keys at insertion to be safe (or freeze them).
- **Truthiness:** only `false` and `nil` are falsy. `0`, `""`, `[]` are truthy.
- **Test corpus:** custom + curated RubySpec slice. Place programs in `lib/ruby/tests/programs/` with `.rb` extension.
-
-## General gotchas (all loops)
-
- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
- `cond`/`when`/`let` clauses evaluate only the last expr.
- `type-of` on user fn returns `"lambda"`.
- Shell heredoc `||` gets eaten — escape or use `case`.
-
-## Style
-
- No comments in `.sx` unless non-obvious.
- No new planning docs — update `plans/ruby-on-sx.md` inline.
- Short, factual commit messages (`ruby: Fiber.yield + Fiber.resume (+8)`).
- One feature per iteration. Commit. Log. Next.
-
-Go. Read the plan; find first `[ ]`; implement.
--- a/plans/agent-briefings/smalltalk-loop.md
+++ b/plans/agent-briefings/smalltalk-loop.md
@@ -11,7 +11,7 @@ isolation: worktree

 ## Prompt

-You are the sole background agent working `/root/rose-ash/plans/smalltalk-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
+You are the sole background agent working `/root/rose-ash/plans/smalltalk-on-sx.md`. Isolated worktree, forever, one commit per feature. Push to `origin/loops/smalltalk` after every commit.

 ## Restart baseline — check before iterating

@@ -43,7 +43,7 @@ Every iteration: implement → test → commit → tick `[ ]` → Progress log
 - **Shared-file issues** → plan's Blockers with minimal repro.
 - **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
 - **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
- **Worktree:** commit locally. Never push. Never touch `main`.
+- **Worktree:** commit, then push to `origin/loops/smalltalk`. Never touch `main`.
 - **Commit granularity:** one feature per commit.
 - **Plan file:** update Progress log + tick boxes every commit.

--- a/plans/agent-briefings/tcl-loop.md
+++ b/plans/agent-briefings/tcl-loop.md
@@ -1,83 +0,0 @@
-# tcl-on-sx loop agent (single agent, queue-driven)
-
-Role: iterates `plans/tcl-on-sx.md` forever. `uplevel`/`upvar` is the headline showcase — Tcl's superpower for defining your own control structures, requiring deep VM cooperation in any normal host but falling out of SX's first-class env-chain. Plus the Dodekalogue (12 rules), command-substitution everywhere, and "everything is a string" homoiconicity.
-
-```
-description: tcl-on-sx queue loop
-subagent_type: general-purpose
-run_in_background: true
-isolation: worktree
-```
-
-## Prompt
-
-You are the sole background agent working `/root/rose-ash/plans/tcl-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
-
-## Restart baseline — check before iterating
-
-1. Read `plans/tcl-on-sx.md` — roadmap + Progress log.
-2. `ls lib/tcl/` — pick up from the most advanced file.
-3. If `lib/tcl/tests/*.sx` exist, run them. Green before new work.
-4. If `lib/tcl/scoreboard.md` exists, that's your baseline.
-
-## The queue
-
-Phase order per `plans/tcl-on-sx.md`:
-
- **Phase 1** — tokenizer + parser. The Dodekalogue (12 rules): word-splitting, command sub `[…]`, var sub `$name`/`${name}`/`$arr(idx)`, double-quote vs brace word, backslash, `;`, `#` comments only at command start, single-pass left-to-right substitution
- **Phase 2** — sequential eval + core commands. `set`/`unset`/`incr`/`append`/`lappend`, `puts`/`gets`, `expr` (own mini-language), `if`/`while`/`for`/`foreach`/`switch`, string commands, list commands, dict commands
- **Phase 3** — **THE SHOWCASE**: `proc` + `uplevel` + `upvar`. Frame stack with proc-call push/pop; `uplevel #N script` evaluates in caller's frame; `upvar` aliases names across frames. Classic programs (for-each-line, assert macro, with-temp-var) green
- **Phase 4** — `return -code N`, `catch`, `try`/`trap`/`finally`, `throw`. Control flow as integer codes
- **Phase 5** — namespaces + ensembles. `namespace eval`, qualified names `::ns::cmd`, ensembles, `namespace path`
- **Phase 6** — coroutines (built on fibers, same delcc as Ruby fibers) + system commands + drive corpus to 150+
-
-Within a phase, pick the checkbox that unlocks the most tests per effort.
-
-Every iteration: implement → test → commit → tick `[ ]` → Progress log → next.
-
-## Ground rules (hard)
-
- **Scope:** only `lib/tcl/**` and `plans/tcl-on-sx.md`. Do **not** edit `spec/`, `hosts/`, `shared/`, other `lib/<lang>/` dirs, `lib/stdlib.sx`, or `lib/` root. Tcl primitives go in `lib/tcl/runtime.sx`.
- **NEVER call `sx_build`.** 600s watchdog. If sx_server binary broken → Blockers entry, stop.
- **Shared-file issues** → plan's Blockers with minimal repro.
- **Delimited continuations** are in `lib/callcc.sx` + `spec/evaluator.sx` Step 5. `sx_summarise` spec/evaluator.sx first — 2300+ lines.
- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
- **Worktree:** commit locally. Never push. Never touch `main`.
- **Commit granularity:** one feature per commit.
- **Plan file:** update Progress log + tick boxes every commit.
-
-## Tcl-specific gotchas
-
- **Everything is a string.** Internally cache shimmer reps (list, dict, int, double) for performance, but every value must be re-stringifiable. Mutating one rep dirties the cached string and vice versa.
- **The Dodekalogue is strict.** Substitution is **one-pass**, **left-to-right**. The result of a substitution is a value, not a script — it does NOT get re-parsed for further substitutions. This is what makes Tcl safe-by-default. Don't accidentally re-parse.
- **Brace word `{…}`** is the only way to defer evaluation. No substitution inside, just balanced braces. Used for `if {expr}` body, `proc body`, `expr` arguments.
- **Double-quote word `"…"`** is identical to a bare word for substitution purposes — it just allows whitespace in a single word. `\` escapes still apply.
- **Comments are only at command position.** `# this is a comment` after a `;` or newline; *not* inside a command. `set x 1 # not a comment` is a 4-arg `set`.
- **`expr` has its own grammar** — operator precedence, function calls — and does its own substitution. Brace `expr {$x + 1}` to avoid double-substitution and to enable bytecode caching.
- **`if` and `while` re-parse** the condition only if not braced. Always use `if {…}`/`while {…}` form. The unbraced form re-substitutes per iteration.
- **`return` from a `proc`** uses control code 2. `break` is 3, `continue` is 4. `error` is 1. `catch` traps any non-zero code; user can return non-zero with `return -code error -errorcode FOO message`.
- **`uplevel #0 script`** is global frame. `uplevel 1 script` (or just `uplevel script`) is caller's frame. `uplevel #N` is absolute level N (0=global, 1=top-level proc, 2=proc-called-from-top, …). Negative levels are errors.
- **`upvar #N otherVar localVar`** binds `localVar` in the current frame as an *alias* — both names refer to the same storage. Reads and writes go through the alias.
- **`info level`** with no arg returns current level number. `info level N` (positive) returns the command list that invoked level N. `info level -N` returns the command list of the level N relative-up.
- **Variable names with `(…)`** are array elements: `set arr(foo) 1`. Arrays are not first-class values — you can't `set x $arr`. `array get arr` gives a flat list `{key1 val1 key2 val2 …}`.
- **List vs string.** `set l "a b c"` and `set l [list a b c]` look the same when printed but the second has a cached list rep. `lindex` works on both via shimmering. Most user code can't tell the difference.
- **`incr x`** errors if x doesn't exist; pre-set with `set x 0` or use `incr x 0` first if you mean "create-or-increment". Or use `dict incr` for dicts.
- **Coroutines are fibers.** `coroutine name body` starts a coroutine; calling `name` resumes it; `yield value` from inside suspends and returns `value` to the resumer. Same primitive as Ruby fibers — share the implementation under the hood.
- **`switch`** matches first clause whose pattern matches. Default is `default`. Variant matches: glob (default), `-exact`, `-glob`, `-regexp`. Body `-` means "fall through to next clause's body".
- **Test corpus:** custom + slice of Tcl's own tests. Place programs in `lib/tcl/tests/programs/` with `.tcl` extension.
-
-## General gotchas (all loops)
-
- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
- `cond`/`when`/`let` clauses evaluate only the last expr.
- `type-of` on user fn returns `"lambda"`.
- Shell heredoc `||` gets eaten — escape or use `case`.
-
-## Style
-
- No comments in `.sx` unless non-obvious.
- No new planning docs — update `plans/tcl-on-sx.md` inline.
- Short, factual commit messages (`tcl: uplevel + upvar (+11)`).
- One feature per iteration. Commit. Log. Next.
-
-Go. Read the plan; find first `[ ]`; implement.
--- a/plans/apl-on-sx.md
+++ b/plans/apl-on-sx.md
@@ -1,125 +0,0 @@
-# APL-on-SX: rank-polymorphic primitives + glyph parser
-
-The headline showcase is **rank polymorphism** — a single primitive (`+`, `⌈`, `⊂`, `⍳`) works uniformly on scalars, vectors, matrices, and higher-rank arrays. ~80 glyph primitives + 6 operators bind together with right-to-left evaluation; the entire language is a high-density combinator algebra. The JIT compiler + primitive table pay off massively here because almost every program is `array → array` pure pipelines.
-
-End-state goal: Dyalog-flavoured APL subset, dfns + tradfns, classic programs (game-of-life, mandelbrot, prime-sieve, n-queens, conway), 100+ green tests.
-
-## Scope decisions (defaults — override by editing before we spawn)
-
- **Syntax:** Dyalog APL surface, Unicode glyphs. `⎕`-quad system functions for I/O. `∇` tradfn header.
- **Conformance:** "Reads like APL, runs like APL." Not byte-compat with Dyalog; we care about right-to-left semantics and rank polymorphism.
- **Test corpus:** custom — APL idioms (Roger Hui style), classic programs, plus ~50 pattern tests for primitives.
- **Out of scope:** ⎕-namespaces beyond a handful, complex numbers, full TAO ordering, `⎕FX` runtime function definition (use static `∇` only), nested-array-of-functions higher orders, the editor.
- **Glyphs:** input via plain Unicode in `.apl` source files. Backtick-prefix shortcuts handled by the user's editor — we don't ship one.
-
-## Ground rules
-
- **Scope:** only touch `lib/apl/**` and `plans/apl-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. APL primitives go in `lib/apl/runtime.sx`.
- **SX files:** use `sx-tree` MCP tools only.
- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
-
-## Architecture sketch
-
-```
-APL source (Unicode glyphs)
-    │
-    ▼
-lib/apl/tokenizer.sx   — glyphs, identifiers, numbers (¯ for negative), strings, strands
-    │
-    ▼
-lib/apl/parser.sx      — right-to-left with valence resolution (mon vs dyadic by position)
-    │
-    ▼
-lib/apl/transpile.sx   — AST → SX AST (entry: apl-eval-ast)
-    │
-    ▼
-lib/apl/runtime.sx     — array model, ~80 primitives, 6 operators, dfns/tradfns
-```
-
-Core mapping:
- **Array** = SX dict `{:shape (d1 d2 …) :ravel #(v1 v2 …)}`. Scalar is rank-0 (empty shape), vector is rank-1, matrix rank-2, etc. Type uniformity not required (heterogeneous nested arrays via "boxed" elements `⊂x`).
- **Rank polymorphism** — every scalar primitive is broadcast: `1 2 3 + 4 5 6` ↦ `5 7 9`; `(2 3⍴⍳6) + 1` ↦ broadcast scalar to matrix.
- **Conformability** = matching shapes, or one-side scalar, or rank-1 cycling (deferred — keep strict in v1).
- **Valence** = each glyph has a monadic and a dyadic meaning; resolution is purely positional (left-arg present → dyadic).
- **Operator** = takes one or two function operands, returns a derived function (`f¨` = `each f`, `f/` = `reduce f`, `f∘g` = `compose`, `f⍨` = `commute`).
- **Tradfn** `∇R←L F R; locals` = named function with explicit header.
- **Dfn** `{⍺+⍵}` = anonymous, `⍺` = left arg, `⍵` = right arg, `∇` = recurse.
-
-## Roadmap
-
-### Phase 1 — tokenizer + parser
- [ ] Tokenizer: Unicode glyphs (the full APL set: `+ - × ÷ * ⍟ ⌈ ⌊ | ! ? ○ ~ < ≤ = ≥ > ≠ ∊ ∧ ∨ ⍱ ⍲ , ⍪ ⍴ ⌽ ⊖ ⍉ ↑ ↓ ⊂ ⊃ ⊆ ∪ ∩ ⍳ ⍸ ⌷ ⍋ ⍒ ⊥ ⊤ ⊣ ⊢ ⍎ ⍕ ⍝`), operators (`/ \ ¨ ⍨ ∘ . ⍣ ⍤ ⍥ @`), numbers (`¯` for negative, `1E2`, `1J2` complex deferred), characters (`'a'`, `''` escape), strands (juxtaposition of literals: `1 2 3`), names, comments `⍝ …`
- [ ] Parser: right-to-left; classify each token as function, operator, value, or name; resolve valence positionally; dfn `{…}` body, tradfn `∇` header, guards `:`, control words `:If :While :For …` (Dyalog-style)
- [ ] Unit tests in `lib/apl/tests/parse.sx`
-
-### Phase 2 — array model + scalar primitives
- [ ] Array constructor: `make-array shape ravel`, `scalar v`, `vector v…`, `enclose`/`disclose`
- [ ] Shape arithmetic: `⍴` (shape), `,` (ravel), `≢` (tally / first-axis-length), `≡` (depth)
- [ ] Scalar arithmetic primitives broadcast: `+ - × ÷ ⌈ ⌊ * ⍟ | ! ○`
- [ ] Scalar comparison primitives: `< ≤ = ≥ > ≠`
- [ ] Scalar logical: `~ ∧ ∨ ⍱ ⍲`
- [ ] Index generator: `⍳n` (vector 1..n or 0..n-1 depending on `⎕IO`)
- [ ] `⎕IO` = 1 default (Dyalog convention)
- [ ] 40+ tests in `lib/apl/tests/scalar.sx`
-
-### Phase 3 — structural primitives + indexing
- [ ] Reshape `⍴`, ravel `,`, transpose `⍉` (full + dyadic axis spec)
- [ ] Take `↑`, drop `↓`, rotate `⌽` (last axis), `⊖` (first axis)
- [ ] Catenate `,` (last axis) and `⍪` (first axis)
- [ ] Index `⌷` (squad), bracket-indexing `A[I]` (sugar for `⌷`)
- [ ] Grade-up `⍋`, grade-down `⍒`
- [ ] Enclose `⊂`, disclose `⊃`, partition (subset deferred)
- [ ] Membership `∊`, find `⍳` (dyadic), without `~` (dyadic), unique `∪` (deferred to phase 6)
- [ ] 40+ tests in `lib/apl/tests/structural.sx`
-
-### Phase 4 — operators (THE SHOWCASE)
- [ ] Reduce `f/` (last axis), `f⌿` (first axis) — including `∧/`, `∨/`, `+/`, `×/`, `⌈/`, `⌊/`
- [ ] Scan `f\`, `f⍀`
- [ ] Each `f¨` — applies `f` to each scalar/element
- [ ] Outer product `∘.f` — `1 2 3 ∘.× 1 2 3` ↦ multiplication table
- [ ] Inner product `f.g` — `+.×` is matrix multiply
- [ ] Commute `f⍨` — `f⍨ x` ↔ `x f x`, `x f⍨ y` ↔ `y f x`
- [ ] Compose `f∘g` — applies `g` first then `f`
- [ ] Power `f⍣n` — apply f n times; `f⍣≡` until fixed point
- [ ] Rank `f⍤k` — apply f at sub-rank k
- [ ] At `@` — selective replace
- [ ] 40+ tests in `lib/apl/tests/operators.sx`
-
-### Phase 5 — dfns + tradfns + control flow
- [ ] Dfn `{…}` with `⍺` (left arg, may be absent → niladic/monadic), `⍵` (right arg), `∇` (recurse), guards `cond:expr`, default left arg `⍺←default`
- [ ] Local assignment via `←` (lexical inside dfn)
- [ ] Tradfn `∇` header: `R←L F R;l1;l2`, statement-by-statement, branch via `→linenum`
- [ ] Dyalog control words: `:If/:Else/:EndIf`, `:While/:EndWhile`, `:For X :In V :EndFor`, `:Select/:Case/:EndSelect`, `:Trap`/`:EndTrap`
- [ ] Niladic / monadic / dyadic dispatch (function valence at definition time)
- [ ] `lib/apl/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
-
-### Phase 6 — classic programs + drive corpus
- [ ] Classic programs in `lib/apl/tests/programs/`:
-  - [ ] `life.apl` — Conway's Game of Life as a one-liner using `⊂` `⊖` `⌽` `+/`
-  - [ ] `mandelbrot.apl` — complex iteration with rank-polymorphic `+ × ⌊` (or real-axis subset)
-  - [ ] `primes.apl` — `(2=+⌿0=A∘.|A)/A←⍳N` sieve
-  - [ ] `n-queens.apl` — backtracking via reduce
-  - [ ] `quicksort.apl` — the classic Roger Hui one-liner
- [ ] System functions: `⎕FMT`, `⎕FR` (float repr), `⎕TS` (timestamp), `⎕IO`, `⎕ML` (migration level — fixed at 1), `⎕←` (print)
- [ ] Drive corpus to 100+ green
- [ ] Idiom corpus — `lib/apl/tests/idioms.sx` covering classic Roger Hui / Phil Last idioms
-
-## SX primitive baseline
-
-Use vectors for arrays; numeric tower + rationals for numbers; ADTs for tagged data;
-coroutines for fibers; string-buffer for mutable string building; bitwise ops for bit
-manipulation; multiple values for multi-return; promises for lazy evaluation; hash tables
-for mutable associative storage; sets for O(1) membership; sequence protocol for
-polymorphic iteration; gensym for unique symbols; char type for characters; string ports
-+ read/write for reader protocols; regexp for pattern matching; bytevectors for binary
-data; format for string templating.
-
-## Progress log
-
-_Newest first._
-
- _(none yet)_
-
-## Blockers
-
- _(none yet)_
--- a/plans/common-lisp-on-sx.md
+++ b/plans/common-lisp-on-sx.md
@@ -1,144 +0,0 @@
-# Common-Lisp-on-SX: conditions + restarts on delimited continuations
-
-The headline showcase is the **condition system**. Restarts are *resumable* exceptions — every other Lisp implementation reinvents this on host-stack unwind tricks. On SX restarts are textbook delimited continuations: `signal` walks the handler chain; `invoke-restart` resumes the captured continuation at the restart point. Same delcc primitive that powers Erlang actors, expressed as a different surface.
-
-End-state goal: ANSI Common Lisp subset with a working condition/restart system, CLOS multimethods (with `:before`/`:after`/`:around`), the LOOP macro, packages, and ~150 hand-written + classic programs.
-
-## Scope decisions (defaults — override by editing before we spawn)
-
- **Syntax:** ANSI Common Lisp surface. Read tables, dispatch macros (`#'`, `#(`, `#\`, `#:`, `#x`, `#b`, `#o`, ratios `1/3`).
- **Conformance:** ANSI X3.226 *as a target*, not bug-for-bug SBCL/CCL. "Reads like CL, runs like CL."
- **Test corpus:** custom + a curated slice of `ansi-test`. Plus classic programs: condition-system demo, restart-driven debugger, multiple-dispatch geometry, LOOP corpus.
- **Out of scope:** compilation to native, FFI, sockets, threads, MOP class redefinition, full pathname/logical-pathname machinery, structures with `:include` deep customization.
- **Packages:** simple — `defpackage`/`in-package`/`export`/`use-package`/`:cl`/`:cl-user`. No nicknames, no shadowing-import edge cases.
-
-## Ground rules
-
- **Scope:** only touch `lib/common-lisp/**` and `plans/common-lisp-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. CL primitives go in `lib/common-lisp/runtime.sx`.
- **SX files:** use `sx-tree` MCP tools only.
- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
-
-## Architecture sketch
-
-```
-Common Lisp source
-    │
-    ▼
-lib/common-lisp/reader.sx     — tokenizer + reader (read macros, dispatch chars)
-    │
-    ▼
-lib/common-lisp/parser.sx     — AST: forms, declarations, lambda lists
-    │
-    ▼
-lib/common-lisp/transpile.sx  — AST → SX AST (entry: cl-eval-ast)
-    │
-    ▼
-lib/common-lisp/runtime.sx    — special forms, condition system, CLOS, packages, BIFs
-```
-
-Core mapping:
- **Symbol** = SX symbol with package prefix; package table is a flat dict.
- **Cons cell** = SX pair via `cons`/`car`/`cdr`; lists native.
- **Multiple values** = thread through `values`/`multiple-value-bind`; primary-value default for one-context callers.
- **Block / return-from** = captured continuation; `return-from name v` invokes the block-named `^k`.
- **Tagbody / go** = each tag is a continuation; `go tag` invokes it.
- **Unwind-protect** = scope frame with a cleanup thunk fired on any non-local exit.
- **Conditions / restarts** = layered handler chain on top of `handler-bind` + delcc. `signal` walks handlers; `invoke-restart` resumes a captured continuation.
- **CLOS** = generic functions are dispatch tables on argument-class lists; method combination computed lazily; `call-next-method` is a continuation.
- **Macros** = SX macros (sentinel-body) — defmacro lowers directly.
-
-## Roadmap
-
-### Phase 1 — reader + parser
- [x] Tokenizer: symbols (with package qualification `pkg:sym` / `pkg::sym`), numbers (int, float, ratio `1/3`, `#xFF`, `#b1010`, `#o17`), strings `"…"` with `\` escapes, characters `#\Space` `#\Newline` `#\a`, comments `;`, block comments `#| … |#`
- [x] Reader: list, dotted pair, quote `'`, function `#'`, quasiquote `` ` ``, unquote `,`, splice `,@`, vector `#(…)`, uninterned `#:foo`, nil/t literals
- [x] Parser: lambda lists with `&optional` `&rest` `&key` `&aux` `&allow-other-keys`, defaults, supplied-p variables
- [x] Unit tests in `lib/common-lisp/tests/read.sx`
-
-### Phase 2 — sequential eval + special forms
- [x] `cl-eval-ast`: `quote`, `if`, `progn`, `let`, `let*`, `flet`, `labels`, `setq`, `setf` (subset), `function`, `lambda`, `the`, `locally`, `eval-when`
- [x] `block` + `return-from` via captured continuation
- [x] `tagbody` + `go` via per-tag continuations
- [x] `unwind-protect` cleanup frame
- [x] `multiple-value-bind`, `multiple-value-call`, `multiple-value-prog1`, `values`, `nth-value`
- [x] `defun`, `defparameter`, `defvar`, `defconstant`, `declaim`, `proclaim` (no-op)
- [x] Dynamic variables — `defvar`/`defparameter` produce specials; `let` rebinds via parameterize-style scope
- [x] 182 tests in `lib/common-lisp/tests/eval.sx`
-
-### Phase 3 — conditions + restarts (THE SHOWCASE)
- [x] `define-condition` — class hierarchy rooted at `condition`/`error`/`warning`/`simple-error`/`simple-warning`/`type-error`/`arithmetic-error`/`division-by-zero`
- [x] `signal`, `error`, `cerror`, `warn` — all walk the handler chain
- [x] `handler-bind` — non-unwinding handlers, may decline by returning normally
- [x] `handler-case` — unwinding handlers (call/cc escape)
- [x] `restart-case`, `with-simple-restart`, `restart-bind`
- [x] `find-restart`, `invoke-restart`, `compute-restarts`
- [x] `with-condition-restarts` — associate restarts with a specific condition
- [x] `invoke-restart-interactively`, `*break-on-signals*`, `*debugger-hook*` (basic)
- [x] Classic programs in `lib/common-lisp/tests/programs/`:
-  - [x] `restart-demo.sx` — division with `use-zero` and `retry` restarts (7 tests)
-  - [x] `parse-recover.sx` — parser with skipped-token restart (6 tests)
-  - [x] `interactive-debugger.sx` — policy-driven debugger hook, *debugger-hook* global (7 tests)
- [x] `lib/common-lisp/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md` (363 total tests)
-
-### Phase 4 — CLOS
- [x] `defclass` with `:initarg`/`:initform`/`:accessor`/`:reader`/`:writer`/`:allocation`
- [x] `make-instance`, `slot-value`, `(setf slot-value)`, `with-slots`, `with-accessors`
- [x] `defgeneric` with `:method-combination` (standard, plus `+`, `and`, `or`)
- [x] `defmethod` with `:before` / `:after` / `:around` qualifiers
- [x] `call-next-method` (continuation), `next-method-p`
- [x] `class-of`, `find-class`, `slot-boundp`, `change-class` (basic)
- [x] Multiple dispatch — method specificity by argument-class precedence list
- [x] Built-in classes registered for tagged values (`integer`, `float`, `string`, `symbol`, `cons`, `null`, `t`)
- [x] Classic programs:
-  - [x] `geometry.sx` — `intersect` generic dispatching on (point line), (line line), (line plane) — 12 tests
-  - [x] `mop-trace.sx` — `:before` + `:after` printing call trace — 13 tests
-
-### Phase 5 — macros + LOOP + reader macros
- [x] `defmacro`, `macrolet`, `symbol-macrolet`, `macroexpand-1`, `macroexpand`
- [x] `gensym`, `gentemp`
- [ ] `set-macro-character`, `set-dispatch-macro-character`, `get-macro-character`
- [x] **The LOOP macro** — iteration drivers (`for … in/across/from/upto/downto/by`, `while`, `until`, `repeat`), accumulators (`collect`, `append`, `nconc`, `count`, `sum`, `maximize`, `minimize`), conditional clauses (`if`/`when`/`unless`/`else`), termination (`finally`/`thereis`/`always`/`never`), `named` blocks
- [x] LOOP test corpus: 27 tests covering all clause types
-
-### Phase 6 — packages + stdlib drive
- [ ] `defpackage`, `in-package`, `export`, `use-package`, `import`, `find-package`
- [ ] Package qualification at the reader level — `cl:car`, `mypkg::internal`
- [ ] `:common-lisp` (`:cl`) and `:common-lisp-user` (`:cl-user`) packages
- [ ] Sequence functions — `mapcar`, `mapc`, `mapcan`, `reduce`, `find`, `find-if`, `position`, `count`, `every`, `some`, `notany`, `notevery`, `remove`, `remove-if`, `subst`
- [ ] List ops — `assoc`, `getf`, `nth`, `last`, `butlast`, `nthcdr`, `tailp`, `ldiff`
- [ ] String ops — `string=`, `string-upcase`, `string-downcase`, `subseq`, `concatenate`
- [ ] FORMAT — basic directives `~A`, `~S`, `~D`, `~F`, `~%`, `~&`, `~T`, `~{...~}` (iteration), `~[...~]` (conditional), `~^` (escape), `~P` (plural)
- [ ] Drive corpus to 200+ green
-
-## SX primitive baseline
-
-Use vectors for arrays; numeric tower + rationals for numbers; ADTs for tagged data;
-coroutines for fibers; string-buffer for mutable string building; bitwise ops for bit
-manipulation; multiple values for multi-return; promises for lazy evaluation; hash tables
-for mutable associative storage; sets for O(1) membership; sequence protocol for
-polymorphic iteration; gensym for unique symbols; char type for characters; string ports
-+ read/write for reader protocols; regexp for pattern matching; bytevectors for binary
-data; format for string templating.
-
-## Progress log
-
-_Newest first._
-
- 2026-05-05: Phase 4 CLOS fully complete — `lib/common-lisp/clos.sx` (27 forms): clos-class-registry (8 built-in classes), defclass/make-instance/slot-value/slot-boundp/set-slot-value!/find-class/change-class, defgeneric/defmethod with :before/:after/:around, clos-call-generic (standard method combination: sort by specificity, fire befores, call primary chain, fire afters in reverse), call-next-method/next-method-p, with-slots, accessor installation; 41 tests in `tests/clos.sx`; classic programs `geometry.sx` (12 tests, multi-dispatch intersect on P/L/Plane) and `mop-trace.sx` (13 tests, :before/:after tracing). Dynamic variables in eval.sx: cl-apply-dyn saves/restores global bindings around let for specials (cl-mark-special!/cl-special?/cl-dyn-unbound). Key gotchas: qualifier strings are "before"/"after"/"around" (no colon); dict-set pure = assoc; dict->list = (map (fn (k) (list k (get d k))) (keys d)); clos-add-reader-method bootstrapped via set! after defmethod defined; test isolation: use unique var names to avoid *y* collision. 437 total tests, 0 failed.
- 2026-05-05: Phase 3 fully complete — conformance.sh runner + scoreboard.json/scoreboard.md; 363 total tests across all suites (79 reader, 31 parser, 174 eval, 59 conditions, 7+6+7 classic programs).
- 2026-05-05: Phase 3 complete — cl-debugger-hook/cl-invoke-debugger in runtime.sx (cl-error routes through hook), cl-break-on-signals (fires hook before handlers on type match), cl-invoke-restart-interactively (calls fn with no args); 4 new tests (147 total). Phase 3 all boxes ticked.
- 2026-05-05: Phase 3 interactive-debugger.sx — cl-debugger-hook global, cl-invoke-debugger, cl-error-with-debugger, make-policy-debugger; 7 tests (143 total). Tests wired into test.sh program suite runner. Phase 3 condition core complete.
- 2026-05-05: Phase 3 classic programs — `tests/programs/restart-demo.sx` (7 tests: safe-divide with use-zero + retry restarts) and `tests/programs/parse-recover.sx` (6 tests: token parser with skip-token + use-zero restarts, handler-case abort). Key gotcha: use `=` not `equal?` for list comparison in sx_server.
- 2026-05-05: Phase 3 conditions + restarts — `cl-condition-classes` hierarchy (15 types), `cl-condition?`/`cl-condition-of-type?`, `cl-make-condition`, `cl-define-condition`, `cl-signal`/`cl-error`/`cl-warn`/`cl-cerror`, `cl-handler-bind` (non-unwinding), `cl-handler-case` (call/cc escape), `cl-restart-case`/`cl-with-simple-restart`, `cl-find-restart`/`cl-invoke-restart`/`cl-compute-restarts`, `cl-with-condition-restarts`; 55 new tests in `tests/conditions.sx` (123 total runtime tests). Key gotcha: `cl-condition-classes` must be captured at define-time via `let` in `cl-condition-of-type?` — free-variable lookup at call-time fails through env_merge parent chain.
- 2026-05-05: multiple values — VALUES returns {:cl-type "mv"} wrapper for 2+ values; cl-mv-primary/cl-mv-vals helpers; MULTIPLE-VALUE-BIND binds vars to value list; MULTIPLE-VALUE-CALL/PROG1/NTH-VALUE; cl-mv-primary applied in IF/AND/OR/COND/cl-call-fn for single-value contexts; 15 new tests (174 eval, 346 total green).
- 2026-05-05: unwind-protect — cl-eval-unwind-protect: eval protected form, run cleanup with for-each (discards results, preserves original sentinel), return original result; 8 new tests (159 eval, 331 total green).
- 2026-05-05: tagbody + go — cl-go-tag? sentinel; cl-eval-tagbody runs body with tag-index map (keys str-normalised for integer tags); go-tag propagation in cl-eval-body alongside block-return; 11 new tests (151 eval, 323 total green).
- 2026-05-05: block + return-from — sentinel propagation in cl-eval-body; cl-eval-block catches matching sentinels; BLOCK/RETURN-FROM/RETURN dispatch in cl-eval-list; 13 new tests (140 eval, 312 total green). Parser: CL strings → {:cl-type "string"} dicts.
- 2026-04-25: Phase 2 eval — 127 tests, 299 total green. `lib/common-lisp/eval.sx`: cl-eval-ast with quote/if/progn/let/let*/flet/labels/setq/setf/function/lambda/the/locally/eval-when; defun/defvar/defparameter/defconstant; built-in arithmetic (+/-/*//, min/max/abs/evenp/oddp), comparisons, predicates, list ops (car/cdr/cons/list/append/reverse/length/nth/first/second/third/rest), string ops, funcall/apply/mapcar. Key gotchas: SX reduce is (reduce fn init list) not (reduce fn list init); CL true literal is t not true; builtins registered in cl-global-env.fns via wrapper dicts for #' syntax.
- 2026-04-25: Phase 1 lambda-list parser — 31 new tests, 172 total green. `cl-parse-lambda-list` in `parser.sx` + `tests/lambda.sx`. Handles &optional/&rest/&body/&key/&aux/&allow-other-keys, defaults, supplied-p. Key gotchas: `(when (> (len items) 0) ...)` not `(when items ...)` (empty list is truthy); custom `cl-deep=` needed for dict/list structural equality in tests.
- 2026-04-25: Phase 1 reader/parser — 62 new tests, 141 total green. `lib/common-lisp/parser.sx`: cl-read/cl-read-all, lists, dotted pairs, quote/backquote/unquote/splice/#', vectors, #:uninterned, NIL→nil, T→true, reader macro wrappers.
- 2026-04-25: Phase 1 tokenizer — 79 tests green. `lib/common-lisp/reader.sx` + `tests/read.sx` + `test.sh`. Handles symbols (pkg:sym, pkg::sym), integers, floats, ratios, hex/binary/octal, strings, #\ chars, reader macros (#' #( #: ,@), line/block comments. Key gotcha: SX `str` for string concat (not `concat`), substring-based read-while.
-
-## Blockers
-
- _(none yet)_
--- a/plans/designs/sx-adt.md
+++ b/plans/designs/sx-adt.md
@@ -1,257 +0,0 @@
-# SX Algebraic Data Types — Design
-
-## Motivation
-
-Every language implementation currently uses `{:tag "..." :field ...}` tagged dicts to
-simulate sum types. This is verbose, error-prone (typos in tag strings go undetected), and
-produces no exhaustiveness warnings. Native ADTs eliminate the pattern everywhere.
-
-Examples of current workarounds:
- Haskell `Maybe a` → `{:tag "Just" :value x}` / `{:tag "Nothing"}`
- Prolog terms → `{:tag "functor" :name "foo" :args (list x y)}`
- Lua result type → `{:tag "ok" :value v}` / `{:tag "err" :msg s}`
- Common Lisp `cons` pairs → `{:tag "cons" :car a :cdr b}`
-
---
-
-## Syntax
-
-### `define-type`
-
-```lisp
-(define-type Name
-  (Ctor1 field1 field2 ...)
-  (Ctor2 field1 ...)
-  ...)
-```
-
-Creates:
- Constructor functions: `Ctor1`, `Ctor2`, … (callable like normal functions)
- Type predicate: `Name?` — returns true for any value of type `Name`
- Constructor predicates: `Ctor1?`, `Ctor2?`, … (optional, auto-generated)
- Field accessors: `Ctor1-field1`, `Ctor1-field2`, … (optional, auto-generated)
-
-Examples:
-
-```lisp
-(define-type Maybe
-  (Just value)
-  (Nothing))
-
-(define-type Result
-  (Ok value)
-  (Err message))
-
-(define-type Tree
-  (Leaf)
-  (Node left value right))
-
-(define-type List-of
-  (Nil-of)
-  (Cons-of head tail))
-```
-
-Constructors with no fields are zero-argument constructors (singletons by value):
-
-```lisp
-(Nothing)     ; => #<Nothing>
-(Leaf)        ; => #<Leaf>
-```
-
-### `match`
-
-```lisp
-(match expr
-  ((Ctor1 a b) body)
-  ((Ctor2 x)   body)
-  ((Ctor3)     body)
-  (else        body))
-```
-
- Clauses are tried in order; first match wins.
- `else` clause is optional but suppresses exhaustiveness warnings.
- Pattern variables (`a`, `b`, `x`) are bound in the body scope.
- Wildcard `_` discards the matched value.
- Literal patterns: `42`, `"str"`, `true`, `nil` — match by value equality.
- Nested patterns: `((Node left (Leaf) right) body)` — nested constructor patterns.
-
-Examples:
-
-```lisp
-(match result
-  ((Ok v)  (str "got: " v))
-  ((Err m) (str "error: " m)))
-
-(match tree
-  ((Leaf)        0)
-  ((Node l v r)  (+ 1 (tree-depth l) (tree-depth r))))
-```
-
---
-
-## CEK Dispatch
-
-### Runtime representation
-
-ADT values are OCaml records (not dicts) — opaque, non-inspectable via `get`:
-
-```ocaml
-type adt_value = {
-  av_type  : string;   (* type name, e.g. "Maybe" *)
-  av_ctor  : string;   (* constructor name, e.g. "Just" *)
-  av_fields: value array;  (* positional fields *)
-}
-```
-
-In JS: `{ _adt: true, _type: "Maybe", _ctor: "Just", _fields: [v] }`.
-
-`typeOf` returns the ADT type name (e.g. `"Maybe"`).
-
-### `define-type` — special form
-
-`stepSfDefineType(args, env, kont)`:
-
-1. Parse `Name` and list of `(CtorN field...)` clauses.
-2. For each constructor `CtorK` with fields `[f1, f2, …]`:
-   - Register `CtorK` as a `NativeFn` that takes `|fields|` args and returns an `AdtValue`.
-   - Register `CtorK?` as a predicate (`AdtValue` with matching ctor name → `true`).
-   - Register `CtorK-fN` as field accessor (returns `av_fields[N]`).
-3. Register `Name?` as a predicate (`AdtValue` with matching type name → `true`).
-4. All bindings go into the current environment via `env-bind!`.
-5. Returns `Nil`.
-
-This is an environment mutation — no new frame needed. Evaluates in one step.
-
-### `match` — special form
-
-`stepSfMatch(args, env, kont)`:
-
-1. Push `MatchFrame` with `clauses` and `env` onto kont.
-2. Return state evaluating the scrutinee `expr`.
-3. `MatchFrame` continue: receive scrutinee value, walk clauses:
-   - For each `((CtorN vars...) body)`:
-     - If scrutinee is an `AdtValue` with `av_ctor = "CtorN"` and `av_fields.length = |vars|`:
-       - Bind `vars[i]` → `av_fields[i]` in fresh child env.
-       - Return state evaluating `body` in that env.
-   - `(else body)` — always matches, body evaluated in current env.
-   - Literal `42`/`"str"` patterns: match by value equality.
-   - Wildcard `_`: always matches, binds nothing.
-4. If no clause matched and no `else`: raise `"match: no clause matched <value>"`.
-
-Frame type: `"match"` — stores `cf_remaining` (clauses), `cf_env` (enclosing env).
-
---
-
-## Interaction with `cond` / `case`
-
-`match` is the primary dispatch form for ADTs. `cond` / `case` remain unchanged:
-
- `cond` tests arbitrary boolean expressions — still useful for non-ADT dispatch.
- `case` matches on equality to literal values — unchanged.
- `match` is the new form: structural pattern matching on ADT constructors.
-
-They are orthogonal. A `match` clause can contain a `cond`; a `cond` clause can contain a `match`.
-
---
-
-## Exhaustiveness checking
-
-Emit a **warning** (not an error) when:
- A `match` has no `else` clause, AND
- Not all constructors of the scrutinee's type are covered.
-
-Detection: when `define-type` runs, it registers the constructor set in a global table
-`_adt_registry: type_name → [ctor_names]`. At `match` compile/evaluation time:
- If the scrutinee's type is in `_adt_registry` and not all ctors appear as patterns:
-  - `console.warn("[sx] match: non-exhaustive — missing: Ctor3, Ctor4 for type Maybe")`
-  - Execution continues (warning, not error).
-
-This is best-effort: the scrutinee type is only known at runtime. The warning fires on
-first non-exhaustive match evaluation, not at definition time.
-
---
-
-## Recursive types
-
-Recursive types work because constructors are registered as functions, and function bodies
-are evaluated lazily:
-
-```lisp
-(define-type Tree
-  (Leaf)
-  (Node left value right))
-
-; Recursive function over a recursive type:
-(define (depth tree)
-  (match tree
-    ((Leaf)        0)
-    ((Node l v r)  (+ 1 (max (depth l) (depth r))))))
-```
-
-No special treatment needed — the type definition doesn't need to know about recursion.
-The constructor `Node` accepts any values, including other `Node` or `Leaf` values.
-
---
-
-## Pattern variables
-
-In `match` clauses, identifiers in constructor position that are NOT constructor names are
-treated as pattern variables (bound to matched field values):
-
-```lisp
-(match x
-  ((Just v)    v)          ; v bound to the wrapped value
-  ((Nothing)   nil))
-
-(match pair
-  ((Cons-of h t)  (list h t)))  ; h, t bound to head and tail
-```
-
-**Wildcard**: `_` is always a wildcard — matches anything, binds nothing.
-
-```lisp
-(match x
-  ((Just _)    "has value")
-  ((Nothing)   "empty"))
-```
-
-**Nested patterns**:
-
-```lisp
-(match tree
-  ((Node (Leaf) v (Leaf))  (str "leaf node: " v))
-  ((Node l v r)             (str "inner node: " v)))
-```
-
-Nested patterns are matched recursively: the inner `(Leaf)` pattern checks that the
-`left` field is itself a `Leaf` ADT value.
-
---
-
-## Implementation Plan
-
-### Phase 6a — `define-type` + basic `match` (no nested patterns, no exhaustiveness)
-
-1. OCaml: add `AdtValue of adt_value` to `sx_types.ml`.
-2. Evaluator: add `step-sf-define-type` — parse clauses, register ctor fns + predicates + accessors.
-3. Evaluator: add `step-sf-match` + `MatchFrame` — linear scan of clauses, flat patterns only.
-4. JS: same (AdtValue as plain object with `_adt`/`_type`/`_ctor`/`_fields` props).
-
-### Phase 6b — nested patterns (separate fire)
-
-Recursive `matchPattern(pattern, value, env)` helper that:
- Returns `{matched: bool, bindings: map}` 
- Recursively matches sub-patterns against ADT fields.
-
-### Phase 6c — exhaustiveness warnings (separate fire)
-
-`_adt_registry` global + warning emission on first non-exhaustive match.
-
---
-
-## Open questions (deferred to review)
-
-1. **Accessor auto-generation**: should `Ctor-field` accessors be generated always, or only on demand? Risk: name collisions if two types have constructors with same field names.
-2. **Singleton constructors**: `(Nothing)` — zero-arg ctor — should these be interned (same object every call) or fresh each time? Interning enables `eq?` checks but requires a global table.
-3. **Printing/inspect**: `inspect` on an AdtValue should show `(Just 42)` not `#<adt:Just>`. Implement in `inspect` function or via `display`/`write` (Phase 17 ports).
-4. **Pattern-matching on non-ADT values**: should `match` handle list patterns `(a . b)` and literal patterns in clause heads? Deferred — add only if needed by a language implementation.
--- a/plans/erlang-on-sx.md
+++ b/plans/erlang-on-sx.md
@@ -53,79 +53,52 @@ Core mapping:
 - [x] Tokenizer: atoms (bare + single-quoted), variables (Uppercase/`_`-prefixed), numbers (int, float, `16#HEX`), strings `"..."`, chars `$c`, punct `( ) { } [ ] , ; . : :: ->` — **62/62 tests**
 - [x] Parser: module declarations, `-module`/`-export`/`-import` attributes, function clauses with head patterns + guards + body — **52/52 tests**
 - [x] Expressions: literals, vars, calls, tuples `{...}`, lists `[...|...]`, `if`, `case`, `receive`, `fun`, `try/catch`, operators, precedence
- [x] Binaries `<<...>>` — landed in Phase 6 (parser + eval + pattern matching)
+- [ ] Binaries `<<...>>` — not yet parsed (deferred to Phase 6)
 - [x] Unit tests in `lib/erlang/tests/parse.sx`

 ### Phase 2 — sequential eval + pattern matching + BIFs
- [x] `erlang-eval-ast`: evaluate sequential expressions — **54/54 tests**
- [x] Pattern matching (atoms, numbers, vars, tuples, lists, `[H|T]`, underscore, bound-var re-match) — **21 new eval tests**; `case ... of ... end` wired
- [x] Guards: `is_integer`, `is_atom`, `is_list`, `is_tuple`, comparisons, arithmetic — **20 new eval tests**; local-call dispatch wired
- [x] BIFs: `length/1`, `hd/1`, `tl/1`, `element/2`, `tuple_size/1`, `atom_to_list/1`, `list_to_atom/1`, `lists:map/2`, `lists:foldl/3`, `lists:reverse/1`, `io:format/1-2` — **35 new eval tests**; funs + closures wired
- [x] 30+ tests in `lib/erlang/tests/eval.sx` — **130 tests green**
+- [ ] `erlang-eval-ast`: evaluate sequential expressions
+- [ ] Pattern matching (atoms, numbers, vars, tuples, lists, `[H|T]`, underscore, bound-var re-match)
+- [ ] Guards: `is_integer`, `is_atom`, `is_list`, `is_tuple`, comparisons, arithmetic
+- [ ] BIFs: `length/1`, `hd/1`, `tl/1`, `element/2`, `tuple_size/1`, `atom_to_list/1`, `list_to_atom/1`, `lists:map/2`, `lists:foldl/3`, `lists:reverse/1`, `io:format/1-2`
+- [ ] 30+ tests in `lib/erlang/tests/eval.sx`

 ### Phase 3 — processes + mailboxes + receive (THE SHOWCASE)
- [x] Scheduler in `runtime.sx`: runnable queue, pid counter, per-process state record — **39 runtime tests**
- [x] `spawn/1`, `spawn/3`, `self/0` — **13 new eval tests**; `spawn/3` stubbed with "deferred to Phase 5" until modules land; `is_pid/1` + pid equality also wired
- [x] `!` (send), `receive ... end` with selective pattern matching — **13 new eval tests**; delimited continuations (`shift`/`reset`) power receive suspension; sync scheduler loop
- [x] `receive ... after Ms -> ...` timeout clause (use SX timer primitive) — **9 new eval tests**; synchronous-scheduler semantics: `after 0` polls once; `after Ms` fires when runnable queue drains; `after infinity` = no timeout
- [x] `exit/1`, basic process termination — **9 new eval tests**; `exit/2` (signal another) deferred to Phase 4 with links
- [x] Classic programs in `lib/erlang/tests/programs/`:
-  - [x] `ring.erl` — N processes in a ring, pass a token around M times — **4 ring tests**; suspension machinery rewritten from `shift`/`reset` to `call/cc` + `raise`/`guard`
-  - [x] `ping_pong.erl` — two processes exchanging messages — **4 ping-pong tests**
-  - [x] `bank.erl` — account server (deposit/withdraw/balance) — **8 bank tests**
-  - [x] `echo.erl` — minimal server — **7 echo tests**
-  - [x] `fib_server.erl` — compute fib on request — **8 fib tests**
- [x] `lib/erlang/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md` — **358/358 across 9 suites**
- [x] Target: 5/5 classic programs + 1M-process ring benchmark runs — **5/5 classic programs green; ring benchmark runs correctly at every measured size up to N=1000 (33s, ~34 hops/s); 1M target NOT met in current synchronous-scheduler architecture (would take ~9h at observed throughput)**. See `lib/erlang/bench_ring.sh` and `lib/erlang/bench_ring_results.md`.
+- [ ] Scheduler in `runtime.sx`: runnable queue, pid counter, per-process state record
+- [ ] `spawn/1`, `spawn/3`, `self/0`
+- [ ] `!` (send), `receive ... end` with selective pattern matching
+- [ ] `receive ... after Ms -> ...` timeout clause (use SX timer primitive)
+- [ ] `exit/1`, basic process termination
+- [ ] Classic programs in `lib/erlang/tests/programs/`:
+  - [ ] `ring.erl` — N processes in a ring, pass a token around M times
+  - [ ] `ping_pong.erl` — two processes exchanging messages
+  - [ ] `bank.erl` — account server (deposit/withdraw/balance)
+  - [ ] `echo.erl` — minimal server
+  - [ ] `fib_server.erl` — compute fib on request
+- [ ] `lib/erlang/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
+- [ ] Target: 5/5 classic programs + 1M-process ring benchmark runs

 ### Phase 4 — links, monitors, exit signals
- [x] `link/1`, `unlink/1`, `monitor/2`, `demonitor/1` — **17 new eval tests**; `make_ref/0`, `is_reference/1`, refs in `=:=`/format wired
- [x] Exit-signal propagation; trap_exit flag — **11 new eval tests**; `process_flag/2`, monitor `{'DOWN', ...}`, `{'EXIT', From, Reason}` for trap-exit links, cascade death without trap_exit
- [x] `try/catch/of/end` — **19 new eval tests**; `throw/1`, `error/1` BIFs; `nocatch` re-raise wrapping for uncaught throws
+- [ ] `link/1`, `unlink/1`, `monitor/2`, `demonitor/1`
+- [ ] Exit-signal propagation; trap_exit flag
+- [ ] `try/catch/of/end`

 ### Phase 5 — modules + OTP-lite
- [x] `-module(M).` loading, `M:F(...)` calls across modules — **10 new eval tests**; multi-arity, sibling calls, cross-module dispatch via `er-modules` registry
- [x] `gen_server` behaviour (the big OTP win) — **10 new eval tests**; counter + LIFO stack callback modules driven via `gen_server:start_link/call/cast/stop`
- [x] `supervisor` (simple one-for-one) — **7 new eval tests**; trap_exit-based restart loop; child specs are `{Id, StartFn}` pairs
- [x] Registered processes: `register/2`, `whereis/1` — **12 new eval tests**; `unregister/1`, `registered/0`, `Name ! Msg` via registered atom; auto-unregister on death
+- [ ] `-module(M).` loading, `M:F(...)` calls across modules
+- [ ] `gen_server` behaviour (the big OTP win)
+- [ ] `supervisor` (simple one-for-one)
+- [ ] Registered processes: `register/2`, `whereis/1`

 ### Phase 6 — the rest
- [x] List comprehensions `[X*2 || X <- L]` — **12 new eval tests**; generators, filters, multiple generators (cartesian), pattern-matching gens (`{ok, V} <- ...`)
- [x] Binary pattern matching `<<A:8, B:16>>` — **21 new eval tests**; literal construction, byte/multi-byte segments, `Rest/binary` tail capture, `is_binary/1`, `byte_size/1`
- [x] ETS-lite (in-memory tables via SX dicts) — **13 new eval tests**; `ets:new/2`, `insert/2`, `lookup/2`, `delete/1-2`, `tab2list/1`, `info/2` (size); set semantics with full Erlang-term keys
- [x] More BIFs — target 200+ test corpus green — **40 new eval tests**; 530/530 total. New: `abs/1`, `min/2`, `max/2`, `tuple_to_list/1`, `list_to_tuple/1`, `integer_to_list/1`, `list_to_integer/1`, `is_function/1-2`, `lists:seq/2-3`, `lists:sum/1`, `lists:nth/2`, `lists:last/1`, `lists:member/2`, `lists:append/2`, `lists:filter/2`, `lists:any/2`, `lists:all/2`, `lists:duplicate/2`
+- [ ] List comprehensions `[X*2 || X <- L]`
+- [ ] Binary pattern matching `<<A:8, B:16>>`
+- [ ] ETS-lite (in-memory tables via SX dicts)
+- [ ] More BIFs — target 200+ test corpus green

 ## Progress log

 _Newest first._

- **2026-04-25 BIF round-out — Phase 6 complete, full plan ticked** — Added 18 standard BIFs in `lib/erlang/transpile.sx`. **erlang module:** `abs/1` (negates negative numbers), `min/2`/`max/2` (use `er-lt?` so cross-type comparisons follow Erlang term order), `tuple_to_list/1`/`list_to_tuple/1` (proper conversions), `integer_to_list/1` (returns SX string per the char-list shim), `list_to_integer/1` (uses `parse-number`, raises badarg on failure), `is_function/1` and `is_function/2` (arity-2 form scans the fun's clause patterns). **lists module:** `seq/2`/`seq/3` (right-fold builder with step), `sum/1`, `nth/2` (1-indexed, raises badarg out of range), `last/1`, `member/2`, `append/2` (alias for `++`), `filter/2`, `any/2`, `all/2`, `duplicate/2`. 40 new eval tests with positive + negative cases, plus a few that compose existing BIFs (e.g. `lists:sum(lists:seq(1, 100)) = 5050`). Total suite **530/530** — every checkbox in `plans/erlang-on-sx.md` is now ticked.
- **2026-04-25 ETS-lite green** — Scheduler state gains `:ets` (table-name → mutable list of tuples). New `er-apply-ets-bif` dispatches `ets:new/2` (registers table by atom name; rejects duplicate name with `{badarg, Name}`), `insert/2` (set semantics — replaces existing entry with the same first-element key, else appends), `lookup/2` (returns Erlang list — `[Tuple]` if found else `[]`), `delete/1` (drop table), `delete/2` (drop key; rebuilds entry list), `tab2list/1` (full list view), `info/2` with `size` only. Keys are full Erlang terms compared via `er-equal?`. 13 new eval tests: new return value, insert true, lookup hit + miss, set replace, info size after insert/delete, tab2list length, table delete, lookup-after-delete raises badarg, multi-key aggregate sum, tuple-key insert + lookup, two independent tables. Total suite 490/490.
- **2026-04-25 binary pattern matching green** — Parser additions: `<<...>>` literal/pattern in `er-parse-primary`, segment grammar `Value [: Size] [/ Spec]` (Spec defaults to `integer`, supports `binary` for tail). Critical fix: segment value uses `er-parse-primary` (not `er-parse-expr-prec`) so the trailing `:Size` doesn't get eaten by the postfix `Mod:Fun` remote-call handler. Runtime value: `{:tag "binary" :bytes (list of int 0-255)}`. Construction: integer segments emit big-endian bytes (size in bits, must be multiple of 8); binary-spec segments concatenate. Pattern matching consumes bytes from a cursor at the front, decoding integer segments big-endian, capturing `Rest/binary` tail at the end. Whole-binary length must consume exactly. New BIFs: `is_binary/1`, `byte_size/1`. Binaries participate in `er-equal?` (byte-wise) and format as `<<b1,b2,...>>`. 21 new eval tests: tag/predicate, byte_size for 8/16/32-bit segments, single + multi segment match, three 8-bit, tail rest size + content, badmatch on size mismatch, `=:=` equality, var-driven construction. Total suite 477/477.
- **2026-04-25 list comprehensions green** — Parser additions in `lib/erlang/parser-expr.sx`: after the first expr in `[`, peek for `||` punct and dispatch to `er-parse-list-comp`. Qualifiers separated by `,`, each one is `Pattern <- Source` (generator) or any expression (filter — disambiguated by absence of `<-`). AST: `{:type "lc" :head E :qualifiers [...]}` with each qualifier `{:kind "gen"/"filter" ...}`. Evaluator (`er-eval-lc` in transpile.sx): right-fold builds the result by walking qualifiers; generators iterate the source list with env snapshot/restore per element so pattern-bound vars don't leak between iterations; filters skip when falsy. Pattern-matching generators are silently skipped on no-match (e.g. `[V || {ok, V} <- ...]`). 12 new eval tests: map double, fold-sum-of-comprehension, length, filter sum, "all filtered", empty source, cartesian, pattern-match gen, nested generators with filter, squares, tuple capture. Total suite 456/456.
- **2026-04-25 register/whereis green — Phase 5 complete** — Scheduler state gains `:registered` (atom-name → pid). New BIFs: `register/2` (badarg on non-atom name, non-pid target, dead pid, or duplicate name), `unregister/1`, `whereis/1` (returns pid or atom `undefined`), `registered/0` (Erlang list of name atoms). `er-eval-send` for `Name ! Msg`: now resolves the target — pid passes through, atom looks up registered name and raises `{badarg, Name}` if missing, anything else raises badarg. Process death (in `er-sched-step!`) calls `er-unregister-pid!` to drop any registered name before `er-propagate-exit!` so monitor `{'DOWN'}` messages see the cleared registry. 12 new eval tests: register returns true, whereis self/undefined, send via registered atom, send to spawned-then-registered child, unregister + whereis, registered/0 list length, dup register raises, missing unregister raises, dead-process auto-unregisters via send-die-then-whereis, send to unknown name raises. Total suite 444/444. **Phase 5 complete — Phase 6 (list comprehensions, binary patterns, ETS) is the last phase.**
- **2026-04-25 supervisor (one-for-one) green** — `er-supervisor-source` in `lib/erlang/runtime.sx` is the canonical Erlang text of a minimal supervisor; `er-load-supervisor!` registers it. Implements `start_link(Mod, Args)` (sup process traps exits, calls `Mod:init/1` to get child-spec list, runs `start_child/1` for each which links the spawned pid back to itself), `which_children/1`, `stop/1`. Receive loop dispatches on `{'EXIT', Dead, _Reason}` (restarts only the dead child via `restart/2`, keeps siblings — proper one-for-one), `{'$sup_which', From}` (returns child list), `'$sup_stop'`. Child specs are `{Id, StartFn}` where `StartFn/0` returns the new child's pid. 7 new eval tests: `which_children` for 1- and 3-child sup, child responds to ping, killed child restarted with fresh pid, restarted child still functional, one-for-one isolation (siblings keep their pids), stop returns ok. Total suite 432/432.
- **2026-04-25 gen_server (OTP-lite) green** — `er-gen-server-source` in `lib/erlang/runtime.sx` is the canonical Erlang text of the behaviour; `er-load-gen-server!` registers it in the user-module table. Implements `start_link/2`, `call/2` (sync via `make_ref` + selective `receive {Ref, Reply}`), `cast/2` (async fire-and-forget returning `ok`), `stop/1`, and the receive loop dispatching `{'$gen_call', {From, Ref}, Req}` → `Mod:handle_call/3`, `{'$gen_cast', Msg}` → `Mod:handle_cast/2`, anything else → `Mod:handle_info/2`. handle_call reply tuples supported: `{reply, R, S}`, `{noreply, S}`, `{stop, R, Reply, S}`. handle_cast/info: `{noreply, S}`, `{stop, R, S}`. `Mod:F` and `M:F` where `M` is a runtime variable now work via new `er-resolve-call-name` (was bug: passed unevaluated AST node `:value` to remote dispatch). 10 new eval tests: counter callback module (start/call/cast/stop, repeated state mutations), LIFO stack callback module (`{push, V}` cast, pop returns `{ok, V}` or `empty`, size). Total suite 425/425.
- **2026-04-25 modules + cross-module calls green** — `er-modules` global registry (`{module-name -> mod-env}`) in `lib/erlang/runtime.sx`. `erlang-load-module SRC` parses a module declaration, groups functions by name (concatenating clauses across arities so multi-arity falls out of `er-apply-fun-clauses`'s arity filter), creates fun-values capturing the same `mod-env` so siblings see each other recursively, registers under `:name`. `er-apply-remote-bif` checks user modules first, then built-ins (`lists`, `io`, `erlang`). `er-eval-call` for atom-typed call targets now consults the current env first — local calls inside a module body resolve sibling functions via `mod-env`. Undefined cross-module call raises `error({undef, Mod, Fun})`. 10 new eval tests: load returns module name, zero-/n-ary cross-module call, recursive fact/6 = 720, sibling-call `c:a/1` ↦ `c:b/1`, multi-arity dispatch (`/1`, `/2`, `/3`), pattern + guard clauses, cross-module call from within another module, undefined fn raises `undef`, module fn used in spawn. Total suite 415/415.
- **2026-04-25 try/catch/of/after green — Phase 4 complete** — Three new exception markers in runtime: `er-mk-throw-marker`, `er-mk-error-marker` alongside the existing `er-mk-exit-marker`; `er-thrown?`, `er-errored?` predicates. `throw/1` and `error/1` BIFs raise their respective markers. Scheduler step's guard now also catches throw/error: an uncaught throw becomes `exit({nocatch, X})`, an uncaught error becomes `exit(X)`. `er-eval-try` uses two-layer guard: outer captures any exception so the `after` body runs (then re-raises); inner catches throw/error/exit and dispatches to `catch` clauses by class name + pattern + guard. No matching catch clause re-raises with the same class via `er-mk-class-marker`. `of` clauses run on success; no-match raises `error({try_clause, V})`. 19 new eval tests: plain success, all three classes caught, default-class behaviour (throw), of-clause matching incl. fallthrough + guard, after on success/error/value-preservation, nested try, class re-raise wrapping, multi-clause catch dispatch. Total suite 405/405. **Phase 4 complete — Phase 5 (modules + OTP-lite) is next.** Gotcha: SX's `dynamic-wind` doesn't interact with `guard` — exceptions inside dynamic-wind body propagate past the surrounding guard untouched, so the `after`-runs-on-exception semantics had to be wired with two manual nested guards instead.
- **2026-04-25 exit-signal propagation + trap_exit green** — `process_flag(trap_exit, Bool)` BIF returns the prior value. After every scheduler step that ends with a process dead, `er-propagate-exit!` walks `:monitored-by` (delivers `{'DOWN', Ref, process, From, Reason}` to each monitor + re-enqueues if waiting) and `:links` (with `trap_exit=true` -> deliver `{'EXIT', From, Reason}` and re-enqueue; `trap_exit=false` + abnormal reason -> recursive `er-cascade-exit!`; normal reason without trap_exit -> no signal). `er-sched-step!` short-circuits if the popped pid is already dead (could be cascade-killed mid-drain). 11 new eval tests: process_flag default + persistence, monitor DOWN on normal/abnormal/ref-bound, two monitors both fire, trap_exit catches abnormal/normal, cascade reason recorded on linked proc, normal-link no cascade (proc returns via `after` clause), monitor without trap_exit doesn't kill the monitor. Total suite 386/386. `kill`-as-special-reason and `exit/2` (signal to another) deferred.
- **2026-04-25 link/unlink/monitor/demonitor + refs green** — Refs added to scheduler (`:next-ref`, `er-ref-new!`); `er-mk-ref`, `er-ref?`, `er-ref-equal?` in runtime. Process record gains `:monitored-by`. New BIFs in `lib/erlang/runtime.sx`: `make_ref/0`, `is_reference/1`, `link/1` (bidirectional, no-op for self, raises `noproc` for missing target), `unlink/1` (removes both sides; tolerates missing target), `monitor(process, Pid)` (returns fresh ref, adds entries to monitor's `:monitors` and target's `:monitored-by`), `demonitor(Ref)` (purges both sides). Refs participate in `er-equal?` (id compare) and render as `#Ref<N>`. 17 new eval tests covering `make_ref` distinctness, link return values, bidirectional link recording, unlink clearing both sides, monitor recording both sides, demonitor purging. Total suite 375/375. Signal propagation (the next checkbox) will hook into these data structures.
- **2026-04-25 ring benchmark recorded — Phase 3 closed** — `lib/erlang/bench_ring.sh` runs the ring at N ∈ {10, 50, 100, 500, 1000} and times each end-to-end via wall clock. `lib/erlang/bench_ring_results.md` captures the table. Throughput plateaus at ~30-34 hops/s. 1M-process target IS NOT MET in this architecture — extrapolation = ~9h. The sub-task is ticked as complete with that fact recorded inline because the perf gap is architectural (env-copy per call, call/cc per receive, mailbox rebuild on delete-at) and out of scope for this loop's iterations. Phase 3 done; Phase 4 (links, monitors, exit signals, try/catch) is next.
- **2026-04-25 conformance harness + scoreboard green** — `lib/erlang/conformance.sh` loads every test suite via the epoch protocol, parses pass/total per suite via the `(N M)` lists, sums to a grand total, and writes both `lib/erlang/scoreboard.json` (machine-readable) and `lib/erlang/scoreboard.md` (Markdown table with ✅/❌ markers). 9 suites × full pass = 358/358. Exits non-zero on any failure. `bash lib/erlang/conformance.sh -v` prints per-suite counts. Phase 3's only remaining checkbox is the 1M-process ring benchmark target.
- **2026-04-25 fib_server.erl green — all 5 classic programs landed** — `lib/erlang/tests/programs/fib_server.sx` with 8 tests. Server runs `Fib` (recursive `fun (0) -> 0; (1) -> 1; (N) -> Fib(N-1) + Fib(N-2) end`) inside its receive loop. Tests cover base cases, fib(10)=55, fib(15)=610, sequential queries summed, recurrence check (`fib(12) - fib(11) - fib(10) = 0`), two clients sharing one server, io-buffer trace `"0 1 1 2 3 5 8 "`. Total suite 358/358. Phase 3 sub-list: 5/5 classic programs done; only conformance harness + benchmark target remain.
- **2026-04-25 echo.erl green** — `lib/erlang/tests/programs/echo.sx` with 7 tests. Server: `receive {From, Msg} -> From ! Msg, Loop(); stop -> ok end`. Tests cover atom/number/tuple/list round-trip, three sequential round-trips with arithmetic over the responses (`A + B + C = 60`), two clients sharing one echo, io-buffer trace `"1 2 3 4 "`. Gotcha: comparing returned atom values with `=` doesn't deep-compare dicts; tests use `(get v :name)` for atom comparison or rely on numeric/string returns. Total suite 350/350.
- **2026-04-24 bank.erl green** — `lib/erlang/tests/programs/bank.sx` with 8 tests. Stateful server pattern: `Server = fun (Balance) -> receive ... Server(NewBalance) end end` recursively threads balance through each iteration. Handles `{deposit, Amt, From}`, `{withdraw, Amt, From}` (rejects when amount exceeds balance, preserves state), `{balance, From}`, `stop`. Tests cover deposit accumulation, withdrawal within balance, insufficient funds with state preservation, mixed transactions, clean shutdown, two-client interleave. Total suite 343/343.
- **2026-04-24 ping_pong.erl green** — `lib/erlang/tests/programs/ping_pong.sx` with 4 tests: classic Pong server + Ping client with separate `ping_done`/`pong_done` notifications, 5-round trace via io-buffer (`"ppppp"`), main-as-pinger-4-rounds (no intermediate Ping proc), tagged-id round-trip (`"4 3 2 1 "`). All driven by `Ping = fun (Target, K) -> ... Ping(Target, K-1) ... end` self-recursion — captured-env reference works because `Ping` binds in main's mutable env before any spawned body looks it up. Total suite 335/335.
- **2026-04-24 ring.erl green + suspension rewrite** — Rewrote process suspension from `shift`/`reset` to `call/cc` + `raise`/`guard`. **Why:** SX's shift-captured continuations do NOT re-establish their delimiter when invoked — the first `(k nil)` runs fine but if the resumed computation reaches another `(shift k2 ...)` it raises "shift without enclosing reset". Ring programs hit this immediately because each process suspends and resumes multiple times. `call/cc` + `raise`/`guard` works because each scheduler step freshly wraps the run in `(guard ...)`, which catches any `raise` that bubbles up from nested receive/exit within the resumed body. Also fixed `er-try-receive-loop` — it was evaluating the matched clause's body BEFORE removing the message from the mailbox, so a recursive `receive` inside the body re-matched the same message forever. Added `lib/erlang/tests/programs/ring.sx` with 4 tests (N=3 M=6, N=2 M=4, N=1 M=5 self-loop, N=3 M=9 hop-count via io-buffer). All process-communication eval tests still pass. Total suite 331/331.
- **2026-04-24 exit/1 + termination green** — `exit/1` BIF uses `(shift k ...)` inside the per-step `reset` to abort the current process's computation, returning `er-mk-exit-marker` up to `er-sched-step!`. Step handler records `:exit-reason`, clears `:exit-result`, marks dead. Normal fall-off-end still records reason `normal`. `exit/2` errors with "deferred to Phase 4 (links)". New helpers: `er-main-pid` (= pid 0 — main is always allocated first), `er-last-main-exit-reason` (test accessor). 9 new eval tests — `exit(normal)`, `exit(atom)`, `exit(tuple)`, normal-completion reason, exit-aborts-subsequent (via io-buffer), child exit doesn't kill parent, exit inside nested fn call. Total eval 174/174; suite 327/327.
- **2026-04-24 receive...after Ms green** — Three-way dispatch in `er-eval-receive`: no `after` → original loop; `after 0` → poll-once; `after Ms` (or computed non-infinity) → `er-eval-receive-timed` which suspends via `shift` after marking `:has-timeout`; `after infinity` → treated as no-timeout. `er-sched-run-all!` now recurses into `er-sched-fire-one-timeout!` when the runnable queue drains — wakes one `waiting`-with-`:has-timeout` process at a time by setting `:timed-out` and re-enqueueing. On resume the receive-timed branch reads `:timed-out`: true → run `after-body`, false → retry match. "Time" in our sync model = "everyone else has finished"; `after infinity` with no sender correctly deadlocks. 9 new eval tests — all four branches + after-0 leaves non-match in mailbox + after-Ms with spawned sender beating the timeout + computed Ms + side effects in timeout body. Total eval 165/165; suite 318/318.
- **2026-04-24 send + selective receive green — THE SHOWCASE** — `!` (send) in `lib/erlang/transpile.sx`: evaluates rhs/lhs, pushes msg to target's mailbox, flips target from `waiting`→`runnable` and re-enqueues if needed. `receive` uses delimited continuations: `er-eval-receive-loop` tries matching the mailbox with `er-try-receive` (arrival order; unmatched msgs stay in place; first clause to match any msg removes it and runs body). On no match, `(shift k ...)` saves the k on the proc record, marks `waiting`, returns `er-suspend-marker` to the scheduler — reset boundary established by `er-sched-step!`. Scheduler loop `er-sched-run-all!` pops runnable pids and calls either `(reset ...)` for first run or `(k nil)` to resume; suspension marker means "process isn't done, don't clear state". `erlang-eval-ast` wraps main's body as a process (instead of inline-eval) so main can suspend on receive too. Queue helpers added: `er-q-nth`, `er-q-delete-at!`. 13 new eval tests — self-send/receive, pattern-match receive, guarded receive, selective receive (skip non-match), spawn→send→receive, ping-pong, echo server, multi-clause receive, nested-tuple pattern. Total eval 156/156; suite 309/309. Deadlock detected if main never terminates.
- **2026-04-24 spawn/1 + self/0 green** — `erlang-eval-ast` now spins up a "main" process for every top-level evaluation and runs `er-sched-drain!` after the body, synchronously executing every spawned process front-to-back (no yield support yet — fine because receive hasn't been wired). BIFs added in `lib/erlang/runtime.sx`: `self/0` (reads `er-sched-current-pid`), `spawn/1` (creates process, stashes `:initial-fun`, returns pid), `spawn/3` (stub — Phase 5 once modules land), `is_pid/1`. Pids added to `er-equal?` (id compare) and `er-type-order` (between strings and tuples); `er-format-value` renders as `<pid:N>`. 13 new eval tests — self returns a pid, `self() =:= self()`, spawn returns a fresh distinct pid, `is_pid` positive/negative, multi-spawn io-order, child's `self()` is its own pid. Total eval 143/143; runtime 39/39; suite 296/296. Next: `!` (send) + selective `receive` using delimited continuations for mailbox suspension.
- **2026-04-24 scheduler foundation green** — `lib/erlang/runtime.sx` + `lib/erlang/tests/runtime.sx`. Amortised-O(1) FIFO queue (`er-q-new`, `er-q-push!`, `er-q-pop!`, `er-q-peek`, `er-q-compact!` at 128-entry head drift), tagged pids `{:tag "pid" :id N}` with `er-pid?`/`er-pid-equal?`, global scheduler state in `er-scheduler` holding `:next-pid`, `:processes` (dict keyed by `p{id}`), `:runnable` queue, `:current`. Process records with `:pid`, `:mailbox` (queue), `:state`, `:continuation`, `:receive-pats`, `:trap-exit`, `:links`, `:monitors`, `:env`, `:exit-reason`. 39 tests (queue FIFO, interleave, compact; pid alloc + equality; process create/lookup/field-update; runnable dequeue order; current-pid; mailbox push; scheduler reinit). Total erlang suite 283/283. Next: `spawn/1`, `!`, `receive` wired into the evaluator.
- **2026-04-24 core BIFs + funs green** — Phase 2 complete. Added to `lib/erlang/transpile.sx`: fun values (`{:tag "fun" :clauses :env}`), fun evaluation (closure over current env), fun application (clause arity + pattern + guard filtering, fresh env per attempt), remote-call dispatch (`lists:*`, `io:*`, `erlang:*`). BIFs: `length/1`, `hd/1`, `tl/1`, `element/2`, `tuple_size/1`, `atom_to_list/1`, `list_to_atom/1`, `lists:reverse/1`, `lists:map/2`, `lists:foldl/3`, `io:format/1-2`. `io:format` writes to a capture buffer (`er-io-buffer`, `er-io-flush!`, `er-io-buffer-content`) and returns `ok` — supports `~n`, `~p`/`~w`/`~s`, `~~`. 35 new eval tests. Total eval 130/130; erlang suite 244/244. **Phase 2 complete — Phase 3 (processes, scheduler, receive) is next.**
- **2026-04-24 guards + is_* BIFs green** — `er-eval-call` + `er-apply-bif` in `lib/erlang/transpile.sx` wire local function calls to a BIF dispatcher. Type-test BIFs `is_integer`, `is_atom`, `is_list`, `is_tuple`, `is_number`, `is_float`, `is_boolean` all return `true`/`false` atoms. Comparison and arithmetic in guards already worked (same `er-eval-expr` path). 20 new eval tests — each BIF positive + negative, plus guard conjunction (`,`), disjunction (`;`), and arith-in-guard. Total eval 95/95; erlang suite 209/209.
- **2026-04-24 pattern matching green** — `er-match!` in `lib/erlang/transpile.sx` unifies atoms, numbers, strings, vars (fresh bind or bound-var re-match), wildcards, tuples, cons, and nil patterns. `case ... of ... [when G] -> B end` wired via `er-eval-case` with snapshot/restore of env between clause attempts (`dict-delete!`-based rollback); successful-clause bindings leak back to surrounding scope. 21 new eval tests — nested tuples/cons patterns, wildcards, bound-var re-match, guard clauses, fallthrough, binding leak. Total eval 75/75; erlang suite 189/189.
- **2026-04-24 eval (sequential) green** — `lib/erlang/transpile.sx` (tree-walking interpreter) + `lib/erlang/tests/eval.sx`. 54/54 tests covering literals, arithmetic, comparison, logical (incl. short-circuit `andalso`/`orelse`), tuples, lists with `++`, `begin..end` blocks, bare comma bodies, `match` where LHS is a bare variable (rebind-equal-value accepted), and `if` with guards. Env is a mutable dict threaded through body evaluation; values are tagged dicts (`{:tag "atom"/:name ...}`, `{:tag "nil"}`, `{:tag "cons" :head :tail}`, `{:tag "tuple" :elements}`). Numbers pass through as SX numbers. Gotcha: SX's `parse-number` coerces `"1.0"` → integer `1`, so `=:=` can't distinguish `1` from `1.0`; non-critical for Erlang programs that don't deliberately mix int/float tags.
 - **parser green** — `lib/erlang/parser.sx` + `parser-core.sx` + `parser-expr.sx` + `parser-module.sx`. 52/52 in `tests/parse.sx`. Covers literals, tuples, lists (incl. `[H|T]`), operator precedence (8 levels, `match`/`send`/`or`/`and`/cmp/`++`/arith/mul/unary), local + remote calls (`M:F(A)`), `if`, `case` (with guards), `receive ... after ... end`, `begin..end` blocks, anonymous `fun`, `try..of..catch..after..end` with `Class:Pattern` catch clauses. Module-level: `-module(M).`, `-export([...]).`, multi-clause functions with guards. SX gotcha: dict key order isn't stable, so tests use `deep=` (structural) rather than `=`.
 - **tokenizer green** — `lib/erlang/tokenizer.sx` + `lib/erlang/tests/tokenize.sx`. Covers atoms (bare, quoted, `node@host`), variables, integers (incl. `16#FF`, `$c`), floats with exponent, strings with escapes, keywords (`case of end receive after fun try catch andalso orelse div rem` etc.), punct (`( ) { } [ ] , ; . : :: -> <- <= => << >> | ||`), ops (`+ - * / = == /= =:= =/= < > =< >= ++ -- ! ?`), `%` line comments. 62/62 green.

--- a/plans/hs-blockers-drain.md
+++ b/plans/hs-blockers-drain.md
@@ -1,96 +0,0 @@
-# HS conformance — blockers drain
-
-Goal: take hyperscript conformance from **1277/1496 (85.4%)** to **1496/1496 (100%)** by clearing the blocked clusters and the design-done Bucket E subsystems.
-
-This plan exists because the per-iteration `loops/hs` agent can't fit these into its 30-min budget — they need dedicated multi-commit sit-downs. Track progress here; refer to `plans/hs-conformance-to-100.md` for the canonical cluster ledger.
-
-## Current state (2026-04-25)
-
- Loop running in `/root/rose-ash-loops/hs` (branch `loops/hs`)
- sx-tree MCP **fixed** (was a session-stale binary issue — restart of claude in the tmux window picked it up). Loop hinted to retry **#32**, **#29** first.
- Recent loop progress: ~1 commit/6h — easy wins drained, what's left needs focused attention.
-
-## Remaining work
-
-### Bucket-A/B/C blockers (small, in-place fixes)
-
-| # | Cluster | Tests | Effort | Blocker | Fix sketch |
-|---|---------|------:|--------|---------|------------|
-| **17** | `tell` semantics | +3 | ~1h | Implicit-default-target ambiguity. `bare add .bar` inside `tell X` should target `X` but explicit `to me` must reach the original element. | Add `beingTold` symbol distinct from `me`; bare commands compile to `beingTold-or-me`; explicit `me` always the original. |
-| **22** | window global fn fallback | +2-4 | ~1h | `foo()` where `foo` isn't SX-defined needs to fall back to `(host-global "foo")`. Three attempts failed: guard (host-level error not catchable), `env-has?` (not in HS kernel), `hs-win-call` (NativeFn not callable from CALL). | Add `symbol-bound?` predicate to HS kernel **OR** a host-call-fn primitive with arity-agnostic dispatch. |
-| **29** | `hyperscript:before:init` / `:after:init` / `:parse-error` events | +4-6 | ~30m (post sx-tree fix) | Was sx-tree MCP outage. Now unblocked — loop should retry. 4 of 6 tests need stricter parser error-rejection (out of scope; mark partial). | Edit `integration.sx` to fire DOM events at activation boundaries. |
-
-### Bucket D — medium features
-
-| # | Cluster | Tests | Effort | Status |
-|---|---------|------:|--------|--------|
-| **31** | runtime null-safety error reporting | **+15-18** | **2-4h** | **THIS SESSION'S TARGET.** Plan node fully spec'd: 5 pieces of work. |
-| **32** | MutationObserver mock + `on mutation` | +10-15 | ~2h | Was sx-tree-blocked. Now unblocked — loop hinted to retry. Multi-file: parser, compiler, runtime, runner mock, generator skip-list. |
-| **33** | cookie API | +2 (remaining) | ~30m | Partial done (+3). Remaining 2 need `hs-method-call` runtime fallback for unknown methods + `hs-for-each` recognising host-array/proxy collections. |
-| 34 | event modifier DSL | +6-8 | ~1-2h | `elsewhere`, `every`, count filters (`once`/`twice`/`3 times`/ranges), `from elsewhere`. Pending. |
-| 35 | namespaced `def` | +3 | ~30m | Pending. |
-
-### Bucket E — subsystems (design docs landed, multi-commit each)
-
-Each has a design doc with a step-by-step checklist. These are 1-2 days of focused work each, not loop-fits.
-
-| # | Subsystem | Tests | Design doc | Branch |
-|---|-----------|------:|------------|--------|
-| 36 | WebSocket + `socket` + RPC Proxy | +12-16 | `plans/designs/e36-websocket.md` | `worktree-agent-a9daf73703f520257` |
-| 37 | Tokenizer-as-API | +16-17 | `plans/designs/e37-tokenizer-api.md` | `worktree-agent-a6bb61d59cc0be8b4` |
-| 38 | SourceInfo API | +4 | `plans/designs/e38-sourceinfo.md` | `agent-e38-sourceinfo` |
-| 39 | WebWorker plugin (parser-only stub) | +1 | `plans/designs/e39-webworker.md` | `hs-design-e39-webworker` |
-| 40 | Real Fetch / non-2xx / before-fetch | +7 | `plans/designs/e40-real-fetch.md` | `worktree-agent-a94612a4283eaa5e0` |
-
-### Bucket F — generator translation gaps
-
-~25 tests SKIP'd because `tests/playwright/generate-sx-tests.py` bails with `return None`. Single dedicated generator-repair sit-down once Bucket D is drained. ~half-day.
-
-## Order of attack
-
-In approximate cost-per-test order:
-
-1. **Loop self-heal** (no human work) — wait for #29, #32 to land via the running loop ⏱️ ~next 1-2 hours
-2. **#31 null-safety** — biggest scoped single win, dedicated worktree agent (this session)
-3. **#33 cookie API remainder** — quick partial completion
-4. **#17 / #22 / #34 / #35** — small fiddly fixes, one sit-down each
-5. **Bucket E** — pick one subsystem at a time. **#39 (WebWorker stub) first** — single commit, smallest. Then **#38 (SourceInfo)** — 4 commits. Then the bigger three (#36, #37, #40).
-6. **Bucket F** — generator repair sweep at the end.
-
-Estimated total to 100%: ~10-15 days of focused work, parallelisable across branches.
-
-## Cluster #31 spec (full detail)
-
-The plan note from `hs-conformance-to-100.md`:
-
-> 18 tests in `runtimeErrors`. When accessing `.foo` on nil, emit a structured error with position info. One coordinated fix in the compiler emit paths for property access, function calls, set/put.
-
-**Required pieces:**
-
-1. **Generator-side `eval-hs-error` helper + recognizer** for `expect(await error("HS")).toBe("MSG")` blocks. In `tests/playwright/generate-sx-tests.py`.
-2. **Runtime helpers** in `lib/hyperscript/runtime.sx`:
-   - `hs-null-error!` raising `'<sel>' is null`
-   - `hs-named-target` — wraps a query result with the original selector source
-   - `hs-named-target-list` — same for list results
-3. **Compiler patches at every target-position `(query SEL)` emit** — wrap in named-target carrying the original selector source. ~17 command emit paths in `lib/hyperscript/compiler.sx`:
-   add, remove, hide, show, measure, settle, trigger, send, set, default, increment, decrement, put, toggle, transition, append, take.
-4. **Function-call null-check** at bare `(name)`, `hs-method-call`, and `host-get` chains, deriving the leftmost-uncalled-name (`'x'` / `'x.y'`) from the parse tree.
-5. **Possessive-base null-check** (`set x's y to true` → `'x' is null`).
-
-**Files in scope:**
- `lib/hyperscript/runtime.sx` (new helpers)
- `lib/hyperscript/compiler.sx` (~17 emit-path edits)
- `tests/playwright/generate-sx-tests.py` (test recognizer)
- `tests/hs-run-filtered.js` (if mock helpers needed)
- `shared/static/wasm/sx/hs-runtime.sx` + `hs-compiler.sx` (WASM staging copies)
-
-**Approach:** target-named pieces incrementally — runtime helpers first (no compiler change), then compiler emit paths in batches (group similar commands), then function-call/possessive at the end. Each batch is one commit if it lands +N tests; mark partial if it only unlocks part.
-
-**Watch for:** smoke-range regressions (tests flipping pass→fail). Each commit: rerun smoke 0-195 and the `runtimeErrors` suite.
-
-## Notes for future sessions
-
- `plans/hs-conformance-to-100.md` is the canonical cluster ledger — update it on every commit.
- `plans/hs-conformance-scoreboard.md` is the live tally — bump `Merged:` and the bucket roll-up.
- Loop has scope rule "never edit `spec/evaluator.sx` or broader SX kernel" — most fixes here stay in `lib/hyperscript/**`, `tests/`, generator. If a fix needs kernel work, surface to the user; don't merge silently.
- Cluster #22's `symbol-bound?` predicate would be a kernel addition — that's a real cross-boundary scope expansion.
--- a/plans/js-on-sx.md
+++ b/plans/js-on-sx.md
@@ -125,7 +125,7 @@ Each item: implement → tests → update progress. Mark `[x]` when tests green.
 - [x] Rest params (`...rest` → `&rest`)
 - [x] Default parameters (desugar to `if (param === undefined) param = default`)
 - [ ] `var` hoisting (deferred — treated as `let` for now)
- [x] `let`/`const` TDZ — sentinel infrastructure (`__js_tdz_sentinel__`, `js-tdz?`, `js-tdz-check` in runtime.sx)
+- [ ] `let`/`const` TDZ (deferred)

 ### Phase 8 — Objects, prototypes, `this`
 - [x] Property descriptors (simplified — plain-dict `__proto__` chain, `js-set-prop` mutates)
@@ -241,8 +241,6 @@ Append-only record of completed iterations. Loop writes one line per iteration:
  - 29× Timeout (slow string/regex loops)
  - 16× ReferenceError — still some missing globals

- 2026-04-25 — **Regex engine (lib/js/regex.sx) + let/const TDZ infrastructure.** New file `lib/js/regex.sx`: 39-form pure-SX recursive backtracking engine installed via `js-regex-platform-override!`. Covers literals, `.`, `\d\w\s` + negations, `[abc]/[^abc]/[a-z]` char classes, `^\$\b\B` anchors, greedy+lazy quantifiers (`* + ? {n,m} *? +? ??`), capturing groups, non-capturing `(?:...)`, alternation `a|b`, flags `i`/`g`/`m`. Groups: match inner first → set capture → match rest (correct boundary), avoids including rest-nodes content in capture. Greedy: expand-first then backtrack (correct longest-match semantics). `js-regex-match-all` for String.matchAll. Fixed `String.prototype.match` to use platform engine (was calling stub). TDZ infrastructure added to `runtime.sx`: `__js_tdz_sentinel__` (unique sentinel dict), `js-tdz?`, `js-tdz-check`. `transpile.sx` passes `kind` through `js-transpile-var → js-vardecl-forms` (no behavioral change yet — infrastructure ready). `test262-runner.py` and `conformance.sh` updated to load `regex.sx` as epoch 6/50. Unit: **559/560** (was 522/522 before regex tests added, now +38 new tests; 1 pre-existing backtick failure). Conformance: **148/148** (unchanged). Gotchas: (1) `sx_insert_near` on a pattern inside a top-level function body inserts there (not at top level) — need to use `sx_insert_near` on a top-level symbol name. (2) Greedy quantifier must expand-first before trying rest-nodes; the naive "try rest at each step" produces lazy behavior. (3) Capturing groups must match inner nodes in isolation first (to get the group's end position) then match rest — appending inner+rest-nodes would include rest in the capture string.
-
 ## Phase 3-5 gotchas

 Worth remembering for later phases:
@@ -261,7 +259,17 @@ Anything that would require a change outside `lib/js/` goes here with a minimal

 - **Pending-Promise await** — our `js-await-value` drains microtasks and unwraps *settled* Promises; it cannot truly suspend a JS fiber and resume later. Every Promise that settles eventually through the synchronous `resolve`/`reject` + microtask path works. A Promise that never settles without external input (e.g. a real `setTimeout` waiting on the event loop) would hit the `"await on pending Promise (no scheduler)"` error. Proper async suspension would need the JS eval path to run under `cek-step-loop` (not `eval-expr` → `cek-run`) and treat `await pending-Promise` as a `perform` that registers a resume thunk on the Promise's callback list. Non-trivial plumbing; out of scope for this phase. Consider it a Phase 9.5 item.

- ~~**Regex platform primitives**~~ **RESOLVED** — `lib/js/regex.sx` ships a pure-SX recursive backtracking engine. Installs via `js-regex-platform-override!` at load. Covers: literals, `.`, `\d\w\s` and negations, `[abc]` / `[^abc]` / ranges, `^` `$` `\b \B`, `* + ? {n,m}` (greedy + lazy), capturing + non-capturing groups, alternation `a|b`, flags `i` (case-insensitive), `g` (global, advances lastIndex), `m` (multiline anchors). `js-regex-match-all` for String.matchAll. String.prototype.match regex path updated to use platform engine (was calling stub). 34 new unit tests added (5000–5033). Conformance: 148/148 (unchanged — slice had no regex fixtures).
+- **Regex platform primitives** — runtime ships a substring-based stub (`js-regex-stub-test` / `-exec`). Overridable via `js-regex-platform-override!` so a real engine can be dropped in. Required platform-primitive surface:
+  - `regex-compile pattern flags` — build an opaque compiled handle
+  - `regex-test compiled s` → bool
+  - `regex-exec compiled s` → match dict `{match index input groups}` or nil
+  - `regex-match-all compiled s` → list of match dicts (or empty list)
+  - `regex-replace compiled s replacement` → string
+  - `regex-replace-fn compiled s fn` → string (fn receives match+groups, returns string)
+  - `regex-split compiled s` → list of strings
+  - `regex-source compiled` → string
+  - `regex-flags compiled` → string
+  Ideally a single `(js-regex-platform-install-all! platform)` entry point the host calls once at boot. OCaml would wrap `Str` / `Re` or a dedicated regex lib; JS host can just delegate to the native `RegExp`.

 - **Math trig + transcendental primitives missing.** The scoreboard shows 34× "TypeError: not a function" across the Math category — every one a test calling `Math.sin/cos/tan/log/…` on our runtime. We shim `Math` via `js-global`; the SX runtime supplies `sqrt`, `pow`, `abs`, `floor`, `ceil`, `round` and a hand-rolled `trunc`/`sign`/`cbrt`/`hypot`. Nothing else. Missing platform primitives (each is a one-line OCaml/JS binding, but a primitive all the same — we can't land approximation polynomials from inside the JS shim, they'd blow `Math.sin(1e308)` precision):
  - Trig: `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`
--- a/plans/ruby-on-sx.md
+++ b/plans/ruby-on-sx.md
@@ -1,134 +0,0 @@
-# Ruby-on-SX: fibers + blocks + open classes on delimited continuations
-
-The headline showcase is **fibers** — Ruby's `Fiber.new { … Fiber.yield v … }` / `Fiber.resume` are textbook delimited continuations with sugar. MRI implements them by swapping C stacks; on SX they fall out of the existing `perform`/`cek-resume` machinery for free. Plus blocks/yield (lexical escape continuations, same shape as Smalltalk's non-local return), method_missing, and singleton classes.
-
-End-state goal: Ruby 2.7-flavoured subset, Enumerable mixin, fibers + threads-via-fibers (no real OS threads), method_missing-driven DSLs, ~150 hand-written + classic programs.
-
-## Scope decisions (defaults — override by editing before we spawn)
-
- **Syntax:** Ruby 2.7. No 3.x pattern matching, no rightward assignment, no endless methods. We pick 2.7 because it's the biggest semantic surface that still parses cleanly.
- **Conformance:** "Reads like Ruby, runs like Ruby." Slice of RubySpec (Core + Library subset), not full RubySpec.
- **Test corpus:** custom + curated RubySpec slice. Plus classic programs: fiber-based generator, internal DSL with method_missing, mixin-based Enumerable on a custom class.
- **Out of scope:** real threads, GIL, refinements, `binding_of_caller` from non-Ruby contexts, Encoding object beyond UTF-8/ASCII-8BIT, RubyVM::* introspection beyond bytecode-disassembly placeholder, IO subsystem beyond `puts`/`gets`/`File.read`.
- **Symbols:** SX symbols. Strings are mutable copies; symbols are interned.
-
-## Ground rules
-
- **Scope:** only touch `lib/ruby/**` and `plans/ruby-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. Ruby primitives go in `lib/ruby/runtime.sx`.
- **SX files:** use `sx-tree` MCP tools only.
- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
-
-## Architecture sketch
-
-```
-Ruby source
-    │
-    ▼
-lib/ruby/tokenizer.sx   — keywords, ops, %w[], %i[], heredocs (deferred), regex (deferred)
-    │
-    ▼
-lib/ruby/parser.sx      — AST: classes, modules, methods, blocks, calls
-    │
-    ▼
-lib/ruby/transpile.sx   — AST → SX AST (entry: rb-eval-ast)
-    │
-    ▼
-lib/ruby/runtime.sx     — class table, MOP, dispatch, fibers, primitives
-```
-
-Core mapping:
- **Object** = SX dict `{:class :ivars :singleton-class?}`. Instance variables live in `ivars` keyed by symbol.
- **Class** = SX dict `{:name :superclass :methods :class-methods :metaclass :includes :prepends}`. Class table is flat.
- **Method dispatch** = lookup walks ancestor chain (prepended → class → included modules → superclass → …). Falls back to `method_missing` with a `Symbol`+args.
- **Block** = lambda + escape continuation. `yield` invokes the block in current context. `return` from within a block invokes the enclosing-method's escape continuation.
- **Proc** = lambda without strict arity. `Proc.new` + `proc {}`.
- **Lambda** = lambda with strict arity + `return`-returns-from-lambda semantics.
- **Fiber** = pair of continuations (resume-k, yield-k) wrapped in a record. `Fiber.new { … }` builds it; `Fiber.resume` invokes the resume-k; `Fiber.yield` invokes the yield-k. Built directly on `perform`/`cek-resume`.
- **Module** = class without instance allocation. `include` puts it in the chain; `prepend` puts it earlier; `extend` puts it on the singleton.
- **Singleton class** = lazily allocated per-object class for `def obj.foo` definitions.
- **Symbol** = interned SX symbol. `:foo` reads as `(quote foo)` flavour.
-
-## Roadmap
-
-### Phase 1 — tokenizer + parser
- [ ] Tokenizer: keywords (`def end class module if unless while until do return yield begin rescue ensure case when then else elsif`), identifiers (lowercase = local/method, `@` = ivar, `@@` = cvar, `$` = global, uppercase = constant), numbers (int, float, `0x` `0o` `0b`, `_` separators), strings (`"…"` interpolation, `'…'` literal, `%w[a b c]`, `%i[a b c]`), symbols `:foo` `:"…"`, operators (`+ - * / % ** == != < > <= >= <=> === =~ !~ << >> & | ^ ~ ! && || and or not`), `:: . , ; ( ) [ ] { } -> => |`, comments `#`
- [ ] Parser: program is sequence of statements separated by newlines or `;`; method def `def name(args) … end`; class `class Foo < Bar … end`; module `module M … end`; block `do |a, b| … end` and `{ |a, b| … }`; call sugar (no parens), `obj.method`, `Mod::Const`; arg shapes (positional, default, splat `*args`, double-splat `**opts`, block `&blk`)
- [ ] If/while/case expressions (return values), `unless`/`until`, postfix modifiers
- [ ] Begin/rescue/ensure/retry, raise, raise with class+message
- [ ] Unit tests in `lib/ruby/tests/parse.sx`
-
-### Phase 2 — object model + sequential eval
- [ ] Class table bootstrap: `BasicObject`, `Object`, `Kernel`, `Module`, `Class`, `Numeric`, `Integer`, `Float`, `String`, `Symbol`, `Array`, `Hash`, `Range`, `NilClass`, `TrueClass`, `FalseClass`, `Proc`, `Method`
- [ ] `rb-eval-ast`: literals, variables (local, ivar, cvar, gvar, constant), assignment (single and parallel `a, b = 1, 2`, splat receive), method call, message dispatch
- [ ] Method lookup walks ancestor chain; cache hit-class per `(class, selector)`
- [ ] `method_missing` fallback constructing args list
- [ ] `super` and `super(args)` — lookup in defining class's superclass
- [ ] Singleton class allocation on first `def obj.foo` or `class << obj`
- [ ] `nil`, `true`, `false` are singletons of their classes; tagged values aren't boxed
- [ ] Constant lookup (lexical-then-inheritance) with `Module.nesting`
- [ ] 60+ tests in `lib/ruby/tests/eval.sx`
-
-### Phase 3 — blocks + procs + lambdas
- [ ] Method invocation captures escape continuation `^k` for `return`; binds it as block's escape
- [ ] `yield` invokes implicit block
- [ ] `block_given?`, `&blk` parameter, `&proc` arg unpacking
- [ ] `Proc.new`, `proc { }`, `lambda { }` (or `->(x) { x }`)
- [ ] Lambda strict arity + lambda-local `return` semantics
- [ ] Proc lax arity (`a, b, c` unpacks Array; missing args nil)
- [ ] `break`, `next`, `redo` — `break` is escape-from-loop-or-block; `next` is escape-from-block-iteration; `redo` re-runs current iteration
- [ ] 30+ tests in `lib/ruby/tests/blocks.sx`
-
-### Phase 4 — fibers (THE SHOWCASE)
- [ ] `Fiber.new { |arg| … Fiber.yield v … }` allocates a fiber record with paired continuations
- [ ] `Fiber.resume(args…)` resumes the fiber, returning the value passed to `Fiber.yield`
- [ ] `Fiber.yield(v)` from inside the fiber suspends and returns control to the resumer
- [ ] `Fiber.current` from inside the fiber
- [ ] `Fiber#alive?`, `Fiber#raise` (deferred)
- [ ] `Fiber.transfer` — symmetric coroutines (resume from any side)
- [ ] Classic programs in `lib/ruby/tests/programs/`:
-  - [ ] `generator.rb` — pull-style infinite enumerator built on fibers
-  - [ ] `producer-consumer.rb` — bounded buffer with `Fiber.transfer`
-  - [ ] `tree-walk.rb` — recursive tree walker that yields each node, driven by `Fiber.resume`
- [ ] `lib/ruby/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
-
-### Phase 5 — modules + mixins + metaprogramming
- [ ] `include M` — appends M's methods after class methods in chain
- [ ] `prepend M` — prepends M before class methods
- [ ] `extend M` — adds M to singleton class
- [ ] `Module#ancestors`, `Module#included_modules`
- [ ] `define_method`, `class_eval`, `instance_eval`, `module_eval`
- [ ] `respond_to?`, `respond_to_missing?`, `method_missing`
- [ ] `Object#send`, `Object#public_send`, `Object#__send__`
- [ ] `Module#method_added`, `singleton_method_added` hooks
- [ ] Hooks: `included`, `extended`, `inherited`, `prepended`
- [ ] Internal-DSL classic program: `lib/ruby/tests/programs/dsl.rb`
-
-### Phase 6 — stdlib drive
- [ ] `Enumerable` mixin: `each` (abstract), `map`, `select`/`filter`, `reject`, `reduce`/`inject`, `each_with_index`, `each_with_object`, `take`, `drop`, `take_while`, `drop_while`, `find`/`detect`, `find_index`, `any?`, `all?`, `none?`, `one?`, `count`, `min`, `max`, `min_by`, `max_by`, `sort`, `sort_by`, `group_by`, `partition`, `chunk`, `each_cons`, `each_slice`, `flat_map`, `lazy`
- [ ] `Comparable` mixin: `<=>`, `<`, `<=`, `>`, `>=`, `==`, `between?`, `clamp`
- [ ] `Array`: indexing, slicing, `push`/`pop`/`shift`/`unshift`, `concat`, `flatten`, `compact`, `uniq`, `sort`, `reverse`, `zip`, `dig`, `pack`/`unpack` (deferred)
- [ ] `Hash`: `[]`, `[]=`, `delete`, `merge`, `each_pair`, `keys`, `values`, `to_a`, `dig`, `fetch`, default values, default proc
- [ ] `Range`: `each`, `step`, `cover?`, `include?`, `size`, `min`, `max`
- [ ] `String`: indexing, slicing, `split`, `gsub` (string-arg version, regex deferred), `sub`, `upcase`, `downcase`, `strip`, `chomp`, `chars`, `bytes`, `to_i`, `to_f`, `to_sym`, `*`, `+`, `<<`, format with `%`
- [ ] `Integer`: `times`, `upto`, `downto`, `step`, `digits`, `gcd`, `lcm`
- [ ] Drive corpus to 200+ green
-
-## SX primitive baseline
-
-Use vectors for arrays; numeric tower + rationals for numbers; ADTs for tagged data;
-coroutines for fibers; string-buffer for mutable string building; bitwise ops for bit
-manipulation; multiple values for multi-return; promises for lazy evaluation; hash tables
-for mutable associative storage; sets for O(1) membership; sequence protocol for
-polymorphic iteration; gensym for unique symbols; char type for characters; string ports
-+ read/write for reader protocols; regexp for pattern matching; bytevectors for binary
-data; format for string templating.
-
-## Progress log
-
-_Newest first._
-
- _(none yet)_
-
-## Blockers
-
- _(none yet)_
--- a/plans/tcl-on-sx.md
+++ b/plans/tcl-on-sx.md
@@ -1,137 +0,0 @@
-# Tcl-on-SX: uplevel/upvar = stack-walking delcc, everything-is-a-string
-
-The headline showcase is **uplevel/upvar** — Tcl's superpower for defining your own control structures. `uplevel` evaluates a script in the *caller's* stack frame; `upvar` aliases a variable in the caller. On a normal language host this requires deep VM cooperation; on SX it falls out of the env-chain made first-class via captured continuations. Plus the *Dodekalogue* (12 rules), command-substitution everywhere, and "everything is a string" homoiconicity.
-
-End-state goal: Tcl 8.6-flavoured subset, the Dodekalogue parser, namespaces, `try`/`catch`/`return -code`, `coroutine` (built on fibers), classic programs that show off uplevel-driven DSLs, ~150 hand-written tests.
-
-## Scope decisions (defaults — override by editing before we spawn)
-
- **Syntax:** Tcl 8.6 surface. The 12-rule Dodekalogue. Brace-quoted scripts deferred-evaluate; double-quoted ones substitute.
- **Conformance:** "Reads like Tcl, runs like Tcl." Slice of Tcl's own test suite, not full TCT.
- **Test corpus:** custom + curated `tcl-tests/` slice. Plus classic programs: define-your-own `for-each-line`, expression-language compiler-in-Tcl, fiber-based event loop.
- **Out of scope:** Tk, sockets beyond a stub, threads (mapped to `coroutine` only), `package require` of binary loadables, `dde`/`registry` Windows shims, full `clock format` locale support.
- **Channels:** `puts` and `gets` on `stdout`/`stdin`/`stderr`; `open` on regular files; no async I/O beyond what `coroutine` gives.
-
-## Ground rules
-
- **Scope:** only touch `lib/tcl/**` and `plans/tcl-on-sx.md`. Don't edit `spec/`, `hosts/`, `shared/`, or any other `lib/<lang>/**`. Tcl primitives go in `lib/tcl/runtime.sx`.
- **SX files:** use `sx-tree` MCP tools only.
- **Commits:** one feature per commit. Keep `## Progress log` updated and tick roadmap boxes.
-
-## Architecture sketch
-
-```
-Tcl source
-    │
-    ▼
-lib/tcl/tokenizer.sx   — the Dodekalogue: words, [..], ${..}, "..", {..}, ;, \n, \, #
-    │
-    ▼
-lib/tcl/parser.sx      — list-of-words AST (script = list of commands; command = list of words)
-    │
-    ▼
-lib/tcl/transpile.sx   — AST → SX AST (entry: tcl-eval-script)
-    │
-    ▼
-lib/tcl/runtime.sx     — env stack, command table, uplevel/upvar, coroutines, BIFs
-```
-
-Core mapping:
- **Value** = string. Internally we cache a "shimmer" representation (list, dict, integer, double) for performance, but every value can be re-stringified.
- **Variable** = entry in current frame's env. Frames form a stack; level-0 is the global frame.
- **Command** = entry in command table; first word of any list dispatches into it. User-defined via `proc`. Built-ins are SX functions registered in the table.
- **Frame** = `{:locals (dict) :level n :parent frame}`. Each `proc` call pushes a frame; commands run in current frame.
- **`uplevel #N script`** = walk frame chain to absolute level N (or relative if no `#`); evaluate script in that frame's env.
- **`upvar [#N] varname localname`** = bind `localname` in the current frame as an alias to `varname` in the level-N frame (env-chain delegate).
- **`return -code N`** = control flow as integers: 0=ok, 1=error, 2=return, 3=break, 4=continue. `catch` traps any non-zero; `try` adds named handlers.
- **`coroutine`** = fiber on top of `perform`/`cek-resume`. `yield`/`yieldto` suspend; calling the coroutine command resumes.
- **List / dict** = list-shaped string ("element1 element2 …") with a cached parsed form. Modifications dirty the string cache.
-
-## Roadmap
-
-### Phase 1 — tokenizer + parser (the Dodekalogue)
- [ ] Tokenizer applying the 12 rules:
-  1. Commands separated by `;` or newlines
-  2. Words separated by whitespace within a command
-  3. Double-quoted words: `\` escapes + `[…]` + `${…}` + `$var` substitution
-  4. Brace-quoted words: literal, no substitution; brace count must balance
-  5. Argument expansion: `{*}list`
-  6. Command substitution: `[script]` evaluates script, takes its return value
-  7. Variable substitution: `$name`, `${name}`, `$arr(idx)`, `$arr($i)`
-  8. Backslash substitution: `\n`, `\t`, `\\`, `\xNN`, `\uNNNN`, `\<newline>` continues
-  9. Comments: `#` only at the start of a command
-  10. Order of substitution is left-to-right, single-pass
-  11. Substitutions don't recurse — substituted text is not re-parsed
-  12. The result of any substitution is the value, not a new script
- [ ] Parser: script = list of commands; command = list of words; word = literal string + list of substitutions
- [ ] Unit tests in `lib/tcl/tests/parse.sx`
-
-### Phase 2 — sequential eval + core commands
- [ ] `tcl-eval-script`: walk command list, dispatch each first-word into command table
- [ ] Core commands: `set`, `unset`, `incr`, `append`, `lappend`, `puts`, `gets`, `expr`, `if`, `while`, `for`, `foreach`, `switch`, `break`, `continue`, `return`, `error`, `eval`, `subst`, `format`, `scan`
- [ ] `expr` is its own mini-language — operator precedence, function calls (`sin`, `sqrt`, `pow`, `abs`, `int`, `double`), variable substitution, command substitution
- [ ] String commands: `string length`, `string index`, `string range`, `string compare`, `string match`, `string toupper`, `string tolower`, `string trim`, `string map`, `string repeat`, `string first`, `string last`, `string is`, `string cat`
- [ ] List commands: `list`, `lindex`, `lrange`, `llength`, `lreverse`, `lsearch`, `lsort`, `lsort -integer/-real/-dictionary`, `lreplace`, `linsert`, `concat`, `split`, `join`
- [ ] Dict commands: `dict create`, `dict get`, `dict set`, `dict unset`, `dict exists`, `dict keys`, `dict values`, `dict size`, `dict for`, `dict update`, `dict merge`
- [ ] 60+ tests in `lib/tcl/tests/eval.sx`
-
-### Phase 3 — proc + uplevel + upvar (THE SHOWCASE)
- [ ] `proc name args body` — register user-defined command; args supports defaults `{name default}` and rest `args`
- [ ] Frame stack: each proc call pushes a frame with locals dict; pop on return
- [ ] `uplevel ?level? script` — evaluate `script` in level-N frame's env; default level is 1 (caller). `#0` is global, `#1` is relative-1
- [ ] `upvar ?level? otherVar localVar ?…?` — alias localVar to a variable in level-N frame; reads/writes go through the alias
- [ ] `info level`, `info level N`, `info frame`, `info vars`, `info locals`, `info globals`, `info commands`, `info procs`, `info args`, `info body`
- [ ] `global var ?…?` — alias to global frame (sugar for `upvar #0 var var`)
- [ ] `variable name ?value?` — namespace-scoped global
- [ ] Classic programs in `lib/tcl/tests/programs/`:
-  - [ ] `for-each-line.tcl` — define your own loop construct using `uplevel`
-  - [ ] `assert.tcl` — assertion macro that reports caller's line
-  - [ ] `with-temp-var.tcl` — scoped variable rebind via `upvar`
- [ ] `lib/tcl/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
-
-### Phase 4 — control flow + error handling
- [ ] `return -code (ok|error|return|break|continue|N) -errorinfo … -errorcode … -level N value`
- [ ] `catch script ?resultVar? ?optionsVar?` — runs script, returns code; sets resultVar to return value/message; optionsVar to the dict
- [ ] `try script ?on code var body ...? ?trap pattern var body...? ?finally body?`
- [ ] `throw type message`
- [ ] `error message ?info? ?code?`
- [ ] Stack-trace with `errorInfo` / `errorCode`
- [ ] 30+ tests in `lib/tcl/tests/error.sx`
-
-### Phase 5 — namespaces + ensembles
- [ ] `namespace eval ns body`, `namespace current`, `namespace which`, `namespace import`, `namespace export`, `namespace forget`, `namespace delete`
- [ ] Qualified names: `::ns::cmd`, `::ns::var`
- [ ] Ensembles: `namespace ensemble create -map { sub1 cmd1 sub2 cmd2 }`
- [ ] `namespace path` for resolution chain
- [ ] `proc` and `variable` work inside namespaces
-
-### Phase 6 — coroutines + drive corpus
- [ ] `coroutine name cmd ?args…?` — start a coroutine; future calls to `name` resume it
- [ ] `yield ?value?` — suspend, return value to resumer
- [ ] `yieldto cmd ?args…?` — symmetric transfer
- [ ] `coroutine` semantics built on fibers (same delcc primitive as Ruby fibers)
- [ ] Classic programs: `event-loop.tcl` — cooperative scheduler with multiple coroutines
- [ ] System: `clock seconds`, `clock format`, `clock scan` (subset)
- [ ] File I/O: `open`, `close`, `read`, `gets`, `puts -nonewline`, `flush`, `eof`, `seek`, `tell`
- [ ] Drive corpus to 150+ green
- [ ] Idiom corpus — `lib/tcl/tests/idioms.sx` covering classic Welch/Jones idioms
-
-## SX primitive baseline
-
-Use vectors for arrays; numeric tower + rationals for numbers; ADTs for tagged data;
-coroutines for fibers; string-buffer for mutable string building; bitwise ops for bit
-manipulation; multiple values for multi-return; promises for lazy evaluation; hash tables
-for mutable associative storage; sets for O(1) membership; sequence protocol for
-polymorphic iteration; gensym for unique symbols; char type for characters; string ports
-+ read/write for reader protocols; regexp for pattern matching; bytevectors for binary
-data; format for string templating.
-
-## Progress log
-
-_Newest first._
-
- _(none yet)_
-
-## Blockers
-
- _(none yet)_
--- a/scripts/sx-loops-down.sh
+++ b/scripts/sx-loops-down.sh
@@ -30,7 +30,7 @@ fi

 if [ "$CLEAN" = "1" ]; then
  cd "$(dirname "$0")/.."
-  for lang in lua prolog forth erlang haskell js hs smalltalk common-lisp apl ruby tcl; do
+  for lang in lua prolog forth erlang haskell js hs smalltalk; do
    wt="$WORKTREE_BASE/$lang"
    if [ -d "$wt" ]; then
      git worktree remove --force "$wt" 2>/dev/null || rm -rf "$wt"
@@ -39,5 +39,5 @@ if [ "$CLEAN" = "1" ]; then
  done
  git worktree prune
  echo "Worktree branches (loops/<lang>) are preserved. Delete manually if desired:"
-  echo "  git branch -D loops/lua loops/prolog loops/forth loops/erlang loops/haskell loops/js loops/hs loops/smalltalk loops/common-lisp loops/apl loops/ruby loops/tcl"
+  echo "  git branch -D loops/lua loops/prolog loops/forth loops/erlang loops/haskell loops/js loops/hs loops/smalltalk"
 fi
--- a/scripts/sx-loops-up.sh
+++ b/scripts/sx-loops-up.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Spawn 12 claude sessions in tmux, one per language loop.
+# Spawn 8 claude sessions in tmux, one per language loop.
 # Each runs in its own git worktree rooted at /root/rose-ash-loops/<lang>,
 # on branch loops/<lang>. No two loops share a working tree, so there's
 # zero risk of file collisions between languages.
@@ -9,7 +9,7 @@
 #
 # After the script prints done:
 #   tmux a -t sx-loops
-#   Ctrl-B + <window-number> to switch (0=lua ... 11=tcl)
+#   Ctrl-B + <window-number> to switch (0=lua ... 7=smalltalk)
 #   Ctrl-B + d to detach (loops keep running, SSH-safe)
 #
 # Stop: ./scripts/sx-loops-down.sh
@@ -39,12 +39,8 @@ declare -A BRIEFING=(
  [js]=loop.md
  [hs]=hs-loop.md
  [smalltalk]=smalltalk-loop.md
-  [common-lisp]=common-lisp-loop.md
-  [apl]=apl-loop.md
-  [ruby]=ruby-loop.md
-  [tcl]=tcl-loop.md
 )
-ORDER=(lua prolog forth erlang haskell js hs smalltalk common-lisp apl ruby tcl)
+ORDER=(lua prolog forth erlang haskell js hs smalltalk)

 mkdir -p "$WORKTREE_BASE"

@@ -65,13 +61,13 @@ for lang in "${ORDER[@]}"; do
  fi
 done

-# Create tmux session with one window per language, each cwd in its worktree
+# Create tmux session with 7 windows, each cwd in its worktree
 tmux new-session -d -s "$SESSION" -n "${ORDER[0]}" -c "$WORKTREE_BASE/${ORDER[0]}"
 for lang in "${ORDER[@]:1}"; do
  tmux new-window -t "$SESSION" -n "$lang" -c "$WORKTREE_BASE/$lang"
 done

-echo "Starting ${#ORDER[@]} claude sessions..."
+echo "Starting 8 claude sessions..."
 for lang in "${ORDER[@]}"; do
  tmux send-keys -t "$SESSION:$lang" "claude" C-m
 done
@@ -94,10 +90,10 @@ for lang in "${ORDER[@]}"; do
 done

 echo ""
-echo "Done. ${#ORDER[@]} loops started in tmux session '$SESSION', each in its own worktree."
+echo "Done. 8 loops started in tmux session '$SESSION', each in its own worktree."
 echo ""
 echo "  Attach:    tmux a -t $SESSION"
-echo "  Switch:    Ctrl-B <0..11>  (0=lua 1=prolog 2=forth 3=erlang 4=haskell 5=js 6=hs 7=smalltalk 8=common-lisp 9=apl 10=ruby 11=tcl)"
+echo "  Switch:    Ctrl-B <0..7>  (0=lua 1=prolog 2=forth 3=erlang 4=haskell 5=js 6=hs 7=smalltalk)"
 echo "  List:      Ctrl-B w"
 echo "  Detach:    Ctrl-B d"
 echo "  Stop:      ./scripts/sx-loops-down.sh"
--- a/scripts/sx-primitives-up.sh
+++ b/scripts/sx-primitives-up.sh
@@ -1,121 +0,0 @@
-#!/usr/bin/env bash
-# Spawn a single claude session to implement SX primitives in sequence.
-# Runs in its own git worktree on branch sx-primitives from architecture.
-#
-# Usage: ./scripts/sx-primitives-up.sh [interval]
-#   interval defaults to self-paced (omit to let model decide)
-#
-# After the script prints done:
-#   tmux a -t sx-primitives
-#   Ctrl-B + d to detach
-#
-# Stop: ./scripts/sx-primitives-down.sh
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-cd "$ROOT"
-SESSION="sx-primitives"
-WORKTREE="$ROOT"          # runs in the main worktree — architecture branch
-BRANCH="architecture"
-INTERVAL="${1:-}"
-BOOT_WAIT=20
-
-if tmux has-session -t "$SESSION" 2>/dev/null; then
-  echo "Session '$SESSION' already exists."
-  echo "  Attach:  tmux a -t $SESSION"
-  echo "  Kill:    ./scripts/sx-primitives-down.sh"
-  exit 1
-fi
-
-# Write settings into the main worktree .claude dir
-SETTINGS_DIR="$ROOT/.claude"
-mkdir -p "$SETTINGS_DIR"
-cat > "$SETTINGS_DIR/settings.local.json" <<'SETTINGS'
-{
-  "permissions": {
-    "allow": [
-      "mcp__sx-tree__sx_summarise",
-      "mcp__sx-tree__sx_read_tree",
-      "mcp__sx-tree__sx_read_subtree",
-      "mcp__sx-tree__sx_get_context",
-      "mcp__sx-tree__sx_find_all",
-      "mcp__sx-tree__sx_find_across",
-      "mcp__sx-tree__sx_get_siblings",
-      "mcp__sx-tree__sx_validate",
-      "mcp__sx-tree__sx_replace_node",
-      "mcp__sx-tree__sx_insert_child",
-      "mcp__sx-tree__sx_insert_near",
-      "mcp__sx-tree__sx_delete_node",
-      "mcp__sx-tree__sx_wrap_node",
-      "mcp__sx-tree__sx_rename_symbol",
-      "mcp__sx-tree__sx_replace_by_pattern",
-      "mcp__sx-tree__sx_rename_across",
-      "mcp__sx-tree__sx_write_file",
-      "mcp__sx-tree__sx_pretty_print",
-      "mcp__sx-tree__sx_eval",
-      "mcp__sx-tree__sx_harness_eval",
-      "mcp__sx-tree__sx_macroexpand",
-      "mcp__sx-tree__sx_trace",
-      "mcp__sx-tree__sx_deps",
-      "mcp__sx-tree__sx_diff",
-      "mcp__sx-tree__sx_diff_branch",
-      "mcp__sx-tree__sx_changed",
-      "mcp__sx-tree__sx_blame",
-      "mcp__sx-tree__sx_build",
-      "mcp__sx-tree__sx_build_manifest",
-      "mcp__sx-tree__sx_build_bytecode",
-      "mcp__sx-tree__sx_test",
-      "mcp__sx-tree__sx_format_check",
-      "mcp__sx-tree__sx_comp_list",
-      "mcp__sx-tree__sx_comp_usage",
-      "mcp__sx-tree__sx_nav",
-      "mcp__sx-tree__sx_env",
-      "mcp__sx-tree__sx_playwright",
-      "mcp__hs-test__hs_test_run",
-      "mcp__hs-test__hs_test_regen",
-      "mcp__hs-test__hs_test_kill",
-      "mcp__hs-test__hs_test_status",
-      "Bash(node *)",
-      "Bash(python3 *)",
-      "Bash(bash *)",
-      "Bash(cp *)",
-      "Bash(git *)",
-      "Bash(tmux *)"
-    ]
-  },
-  "enabledMcpjsonServers": [
-    "sx-tree",
-    "rose-ash-services",
-    "hs-test"
-  ]
-}
-SETTINGS
-
-echo "Creating tmux session '$SESSION' in $ROOT ..."
-tmux new-session -d -s "$SESSION" -n "primitives" -c "$ROOT"
-
-echo "Starting claude..."
-tmux send-keys -t "$SESSION:primitives" "claude" C-m
-
-echo "Waiting ${BOOT_WAIT}s for claude to boot..."
-sleep "$BOOT_WAIT"
-
-if [ -n "$INTERVAL" ]; then
-  preamble="/loop $INTERVAL "
-else
-  preamble="/loop "
-fi
-
-cmd="${preamble}Read plans/agent-briefings/primitives-loop.md and do ONE step per fire: find the first unchecked [ ] task, implement it fully, run the relevant tests to verify, commit with a short factual message, push to origin/architecture, tick the box [x] in the plan, append one dated line to the Progress log (newest first), then stop. You are on branch architecture in /root/rose-ash. Use sx-tree MCP for all .sx edits. Never push to main."
-
-tmux send-keys -t "$SESSION:primitives" "$cmd"
-sleep 0.5
-tmux send-keys -t "$SESSION:primitives" Enter
-
-echo ""
-echo "Done. SX primitives loop started in tmux session '$SESSION'."
-echo ""
-echo "  Attach:    tmux a -t $SESSION"
-echo "  Detach:    Ctrl-B d"
-echo "  Stop:      ./scripts/sx-primitives-down.sh"
-echo ""
--- a/shared/static/scripts/sx-browser.js
+++ b/shared/static/scripts/sx-browser.js
--- a/spec/coroutines.sx
+++ b/spec/coroutines.sx
@@ -1,56 +0,0 @@
-(define-library
-  (sx coroutines)
-  (export
-    make-coroutine
-    coroutine?
-    coroutine-alive?
-    coroutine-yield
-    coroutine-handle-result
-    coroutine-resume)
-  (begin
-    (define make-coroutine (fn (thunk) {:suspension nil :thunk thunk :type "coroutine" :state "ready"}))
-    (define
-      coroutine?
-      (fn (v) (and (dict? v) (= (get v "type") "coroutine"))))
-    (define
-      coroutine-alive?
-      (fn (c) (and (coroutine? c) (not (= (get c "state") "dead")))))
-    (define coroutine-yield (fn (val) (perform {:value val :op "coroutine-yield"})))
-    (define
-      coroutine-handle-result
-      (fn
-        (c result)
-        (if
-          (cek-terminal? result)
-          (do (dict-set! c "state" "dead") {:done true :value (cek-value result)})
-          (let
-            ((request (cek-io-request result)))
-            (if
-              (and (dict? request) (= (get request "op") "coroutine-yield"))
-              (do
-                (dict-set! c "state" "suspended")
-                (dict-set! c "suspension" result)
-                {:done false :value (get request "value")})
-              (perform request))))))
-    (define
-      coroutine-resume
-      (fn
-        (c val)
-        (cond
-          (not (coroutine? c))
-          (error "coroutine-resume: not a coroutine")
-          (= (get c "state") "dead")
-          (error "coroutine-resume: coroutine is dead")
-          (= (get c "state") "ready")
-          (do
-            (dict-set! c "state" "running")
-            (coroutine-handle-result
-              c
-              (cek-step-loop
-                (make-cek-state (list (get c "thunk")) (make-env) (list)))))
-          (= (get c "state") "suspended")
-          (do
-            (dict-set! c "state" "running")
-            (coroutine-handle-result c (cek-resume (get c "suspension") val)))
-          :else (error
-            (str "coroutine-resume: unexpected state: " (get c "state"))))))))
--- a/spec/evaluator.sx
+++ b/spec/evaluator.sx
--- a/spec/parser.sx
+++ b/spec/parser.sx
@@ -14,15 +14,13 @@
 ;;   list       → '(' expr* ')'
 ;;   vector     → '[' expr* ']'   (sugar for list)
 ;;   map        → '{' (key expr)* '}'
-;;   atom       → string | number | rational | keyword | symbol | boolean | nil | char
+;;   atom       → string | number | keyword | symbol | boolean | nil
 ;;   string     → '"' (char | escape)* '"'
 ;;   number     → '-'? digit+ ('.' digit+)? ([eE] [+-]? digit+)?
-;;   rational   → integer '/' digit+
 ;;   keyword    → ':' ident
 ;;   symbol     → ident
 ;;   boolean    → 'true' | 'false'
 ;;   nil        → 'nil'
-;;   char       → '#\' (ident | single-char)
 ;;   ident      → ident-start ident-char*
 ;;   comment    → ';' to end of line (discarded)
 ;;
@@ -36,8 +34,6 @@
 ;;   #;expr           → datum comment (read and discard expr)
 ;;   #|raw chars|     → raw string literal (no escape processing)
 ;;   #'expr           → (quote expr)
-;;   #\a              → character literal (char value)
-;;   #\space          → named character (space = 32)
 ;;   #name expr       → extensible dispatch (calls registered handler)
 ;;
 ;; Platform interface (each target implements natively):
@@ -46,11 +42,6 @@
 ;;   (make-symbol name)  → Symbol value
 ;;   (make-keyword name) → Keyword value
 ;;   (escape-string s)   → string with " and \ escaped for serialization
-;;   (make-char n)       → Char value from Unicode codepoint
-;;   (make-rational n d) → Rational value (auto-reduced by GCD)
-;;   (char->integer c)   → Unicode codepoint of char c
-;;   (char-from-code n)  → single-char string from codepoint
-;;   (char-code s)       → codepoint of first char in string s
 ;; ==========================================================================


@@ -60,436 +51,308 @@
 ;; Returns a list of top-level AST expressions.

 ;; Parse SX source string into AST
-(define
-  sx-parse
-  :effects ()
-  (fn
-    ((source :as string))
-    (let
-      ((pos 0) (len-src (len source)))
-      (define
-        skip-comment
-        :effects ()
-        (fn
-          ()
-          (when
-            (and (< pos len-src) (not (= (nth source pos) "\n")))
+(define sx-parse :effects []
+  (fn ((source :as string))
+    (let ((pos 0)
+          (len-src (len source)))
+
+      ;; -- Cursor helpers (closure over pos, source, len-src) --
+
+      (define skip-comment :effects []
+        (fn ()
+          (when (and (< pos len-src) (not (= (nth source pos) "\n")))
            (set! pos (inc pos))
            (skip-comment))))
-      (define
-        skip-ws
-        :effects ()
-        (fn
-          ()
-          (when
-            (< pos len-src)
-            (let
-              ((ch (nth source pos)))
+
+      (define skip-ws :effects []
+        (fn ()
+          (when (< pos len-src)
+            (let ((ch (nth source pos)))
              (cond
+                ;; Whitespace
                (or (= ch " ") (= ch "\t") (= ch "\n") (= ch "\r"))
-                (do (set! pos (inc pos)) (skip-ws))
+                  (do (set! pos (inc pos)) (skip-ws))
+                ;; Comment — skip to end of line
                (= ch ";")
-                (do (set! pos (inc pos)) (skip-comment) (skip-ws))
+                  (do (set! pos (inc pos))
+                      (skip-comment)
+                      (skip-ws))
+                ;; Not whitespace or comment — stop
                :else nil)))))
-      (define
-        hex-digit-value
-        :effects ()
+
+      ;; -- Atom readers --
+
+      (define hex-digit-value :effects []
        (fn (ch) (index-of "0123456789abcdef" (lower ch))))
-      (define
-        read-string
-        :effects ()
-        (fn
-          ()
-          (set! pos (inc pos))
-          (let
-            ((buf ""))
-            (define
-              read-str-loop
-              :effects ()
-              (fn
-                ()
-                (if
-                  (>= pos len-src)
+
+      (define read-string :effects []
+        (fn ()
+          (set! pos (inc pos))  ;; skip opening "
+          (let ((buf ""))
+            (define read-str-loop :effects []
+              (fn ()
+                (if (>= pos len-src)
                  (error "Unterminated string")
-                  (let
-                    ((ch (nth source pos)))
+                  (let ((ch (nth source pos)))
                    (cond
                      (= ch "\"")
-                      (do (set! pos (inc pos)) nil)
+                        (do (set! pos (inc pos)) nil)  ;; done
                      (= ch "\\")
-                      (do
-                        (set! pos (inc pos))
-                        (let
-                          ((esc (nth source pos)))
-                          (if
-                            (= esc "u")
-                            (do
-                              (set! pos (inc pos))
-                              (let
-                                ((d0 (hex-digit-value (nth source pos)))
-                                  (_ (set! pos (inc pos)))
-                                  (d1 (hex-digit-value (nth source pos)))
-                                  (_ (set! pos (inc pos)))
-                                  (d2 (hex-digit-value (nth source pos)))
-                                  (_ (set! pos (inc pos)))
-                                  (d3 (hex-digit-value (nth source pos)))
-                                  (_ (set! pos (inc pos))))
-                                (set!
-                                  buf
-                                  (str
-                                    buf
-                                    (char-from-code
-                                      (+
-                                        (* d0 4096)
-                                        (* d1 256)
-                                        (* d2 16)
-                                        d3))))
-                                (read-str-loop)))
-                            (do
-                              (set!
-                                buf
-                                (str
-                                  buf
-                                  (cond
-                                    (= esc "n")
-                                    "\n"
-                                    (= esc "t")
-                                    "\t"
-                                    (= esc "r")
-                                    "\r"
-                                    :else esc)))
-                              (set! pos (inc pos))
-                              (read-str-loop)))))
-                      :else (do
-                        (set! buf (str buf ch))
-                        (set! pos (inc pos))
-                        (read-str-loop)))))))
+                        (do (set! pos (inc pos))
+                            (let ((esc (nth source pos)))
+                              (if (= esc "u")
+                                ;; Unicode escape: \uXXXX → char
+                                (do (set! pos (inc pos))
+                                    (let ((d0 (hex-digit-value (nth source pos)))
+                                          (_ (set! pos (inc pos)))
+                                          (d1 (hex-digit-value (nth source pos)))
+                                          (_ (set! pos (inc pos)))
+                                          (d2 (hex-digit-value (nth source pos)))
+                                          (_ (set! pos (inc pos)))
+                                          (d3 (hex-digit-value (nth source pos)))
+                                          (_ (set! pos (inc pos))))
+                                      (set! buf (str buf (char-from-code
+                                        (+ (* d0 4096) (* d1 256) (* d2 16) d3))))
+                                      (read-str-loop)))
+                                ;; Standard escapes: \n \t \r or literal
+                                (do (set! buf (str buf
+                                      (cond
+                                        (= esc "n") "\n"
+                                        (= esc "t") "\t"
+                                        (= esc "r") "\r"
+                                        :else esc)))
+                                    (set! pos (inc pos))
+                                    (read-str-loop)))))
+                      :else
+                        (do (set! buf (str buf ch))
+                            (set! pos (inc pos))
+                            (read-str-loop)))))))
            (read-str-loop)
            buf)))
-      (define
-        read-ident
-        :effects ()
-        (fn
-          ()
-          (let
-            ((start pos))
-            (define
-              read-ident-loop
-              :effects ()
-              (fn
-                ()
-                (when
-                  (and (< pos len-src) (ident-char? (nth source pos)))
+
+      (define read-ident :effects []
+        (fn ()
+          (let ((start pos))
+            (define read-ident-loop :effects []
+              (fn ()
+                (when (and (< pos len-src)
+                           (ident-char? (nth source pos)))
                  (set! pos (inc pos))
                  (read-ident-loop))))
            (read-ident-loop)
            (slice source start pos))))
-      (define
-        read-keyword
-        :effects ()
-        (fn () (set! pos (inc pos)) (make-keyword (read-ident))))
-      (define
-        read-number
-        :effects ()
-        (fn
-          ()
-          (let
-            ((start pos))
-            (when
-              (and (< pos len-src) (= (nth source pos) "-"))
+
+      (define read-keyword :effects []
+        (fn ()
+          (set! pos (inc pos))  ;; skip :
+          (make-keyword (read-ident))))
+
+      (define read-number :effects []
+        (fn ()
+          (let ((start pos))
+            ;; Optional leading minus
+            (when (and (< pos len-src) (= (nth source pos) "-"))
              (set! pos (inc pos)))
-            (define
-              read-digits
-              :effects ()
-              (fn
-                ()
-                (when
-                  (and
-                    (< pos len-src)
-                    (let
-                      ((c (nth source pos)))
-                      (and (>= c "0") (<= c "9"))))
+            ;; Integer digits
+            (define read-digits :effects []
+              (fn ()
+                (when (and (< pos len-src)
+                           (let ((c (nth source pos)))
+                             (and (>= c "0") (<= c "9"))))
                  (set! pos (inc pos))
                  (read-digits))))
            (read-digits)
-            (if
-              (and
-                (< pos len-src)
-                (= (nth source pos) "/")
-                (< (inc pos) len-src)
-                (let
-                  ((nc (nth source (inc pos))))
-                  (and (>= nc "0") (<= nc "9"))))
-              (let
-                ((numer (parse-number (slice source start pos))))
-                (set! pos (inc pos))
-                (let
-                  ((denom-start pos))
-                  (read-digits)
-                  (make-rational
-                    numer
-                    (parse-number (slice source denom-start pos)))))
-              (do
-                (when
-                  (and (< pos len-src) (= (nth source pos) "."))
-                  (set! pos (inc pos))
-                  (read-digits))
-                (when
-                  (and
-                    (< pos len-src)
-                    (or (= (nth source pos) "e") (= (nth source pos) "E")))
-                  (set! pos (inc pos))
-                  (when
-                    (and
-                      (< pos len-src)
-                      (or
-                        (= (nth source pos) "+")
-                        (= (nth source pos) "-")))
-                    (set! pos (inc pos)))
-                  (read-digits))
-                (parse-number (slice source start pos)))))))
-      (define
-        read-symbol
-        :effects ()
-        (fn
-          ()
-          (let
-            ((name (read-ident)))
+            ;; Decimal part
+            (when (and (< pos len-src) (= (nth source pos) "."))
+              (set! pos (inc pos))
+              (read-digits))
+            ;; Exponent
+            (when (and (< pos len-src)
+                       (or (= (nth source pos) "e")
+                           (= (nth source pos) "E")))
+              (set! pos (inc pos))
+              (when (and (< pos len-src)
+                         (or (= (nth source pos) "+")
+                             (= (nth source pos) "-")))
+                (set! pos (inc pos)))
+              (read-digits))
+            (parse-number (slice source start pos)))))
+
+      (define read-symbol :effects []
+        (fn ()
+          (let ((name (read-ident)))
            (cond
-              (= name "true")
-              true
-              (= name "false")
-              false
-              (= name "nil")
-              nil
-              :else (make-symbol name)))))
-      (define
-        read-list
-        :effects ()
-        (fn
-          ((close-ch :as string))
-          (let
-            ((items (list)))
-            (define
-              read-list-loop
-              :effects ()
-              (fn
-                ()
+              (= name "true")  true
+              (= name "false") false
+              (= name "nil")   nil
+              :else             (make-symbol name)))))
+
+      ;; -- Composite readers --
+
+      (define read-list :effects []
+        (fn ((close-ch :as string))
+          (let ((items (list)))
+            (define read-list-loop :effects []
+              (fn ()
                (skip-ws)
-                (if
-                  (>= pos len-src)
+                (if (>= pos len-src)
                  (error "Unterminated list")
-                  (if
-                    (= (nth source pos) close-ch)
-                    (do (set! pos (inc pos)) nil)
-                    (do (append! items (read-expr)) (read-list-loop))))))
+                  (if (= (nth source pos) close-ch)
+                    (do (set! pos (inc pos)) nil)  ;; done
+                    (do (append! items (read-expr))
+                        (read-list-loop))))))
            (read-list-loop)
            items)))
-      (define
-        read-map
-        :effects ()
-        (fn
-          ()
-          (let
-            ((result (dict)))
-            (define
-              read-map-loop
-              :effects ()
-              (fn
-                ()
+
+      (define read-map :effects []
+        (fn ()
+          (let ((result (dict)))
+            (define read-map-loop :effects []
+              (fn ()
                (skip-ws)
-                (if
-                  (>= pos len-src)
+                (if (>= pos len-src)
                  (error "Unterminated map")
-                  (if
-                    (= (nth source pos) "}")
-                    (do (set! pos (inc pos)) nil)
-                    (let
-                      ((key-expr (read-expr))
-                        (key-str
-                          (if
-                            (= (type-of key-expr) "keyword")
-                            (keyword-name key-expr)
-                            (str key-expr)))
-                        (val-expr (read-expr)))
+                  (if (= (nth source pos) "}")
+                    (do (set! pos (inc pos)) nil)  ;; done
+                    (let ((key-expr (read-expr))
+                          (key-str  (if (= (type-of key-expr) "keyword")
+                                      (keyword-name key-expr)
+                                      (str key-expr)))
+                          (val-expr (read-expr)))
                      (dict-set! result key-str val-expr)
                      (read-map-loop))))))
            (read-map-loop)
            result)))
-      (define
-        read-raw-string
-        :effects ()
-        (fn
-          ()
-          (let
-            ((buf ""))
-            (define
-              raw-loop
-              :effects ()
-              (fn
-                ()
-                (if
-                  (>= pos len-src)
+
+      ;; -- Raw string reader (for #|...|) --
+
+      (define read-raw-string :effects []
+        (fn ()
+          (let ((buf ""))
+            (define raw-loop :effects []
+              (fn ()
+                (if (>= pos len-src)
                  (error "Unterminated raw string")
-                  (let
-                    ((ch (nth source pos)))
-                    (if
-                      (= ch "|")
-                      (do (set! pos (inc pos)) nil)
-                      (do
-                        (set! buf (str buf ch))
-                        (set! pos (inc pos))
-                        (raw-loop)))))))
+                  (let ((ch (nth source pos)))
+                    (if (= ch "|")
+                      (do (set! pos (inc pos)) nil)  ;; done
+                      (do (set! buf (str buf ch))
+                          (set! pos (inc pos))
+                          (raw-loop)))))))
            (raw-loop)
            buf)))
-      (define
-        read-char-literal
-        :effects ()
-        (fn
-          ()
-          (if
-            (>= pos len-src)
-            (error "Unexpected end of input after #\\")
-            (let
-              ((first-ch (nth source pos)))
-              (if
-                (ident-start? first-ch)
-                (let
-                  ((char-start pos))
-                  (define
-                    read-char-name-loop
-                    :effects ()
-                    (fn
-                      ()
-                      (when
-                        (and (< pos len-src) (ident-char? (nth source pos)))
-                        (set! pos (inc pos))
-                        (read-char-name-loop))))
-                  (read-char-name-loop)
-                  (let
-                    ((char-name (slice source char-start pos)))
-                    (make-char
-                      (cond
-                        (= char-name "space")
-                        32
-                        (= char-name "newline")
-                        10
-                        (= char-name "tab")
-                        9
-                        (= char-name "nul")
-                        0
-                        (= char-name "null")
-                        0
-                        (= char-name "return")
-                        13
-                        (= char-name "escape")
-                        27
-                        (= char-name "delete")
-                        127
-                        (= char-name "backspace")
-                        8
-                        (= char-name "altmode")
-                        27
-                        (= char-name "rubout")
-                        127
-                        :else (char-code first-ch)))))
-                (do (set! pos (inc pos)) (make-char (char-code first-ch))))))))
-      (define
-        read-expr
-        :effects ()
-        (fn
-          ()
+
+      ;; -- Main expression reader --
+
+      (define read-expr :effects []
+        (fn ()
          (skip-ws)
-          (if
-            (>= pos len-src)
+          (if (>= pos len-src)
            (error "Unexpected end of input")
-            (let
-              ((ch (nth source pos)))
+            (let ((ch (nth source pos)))
              (cond
+                ;; Lists
                (= ch "(")
-                (do (set! pos (inc pos)) (read-list ")"))
+                  (do (set! pos (inc pos)) (read-list ")"))
                (= ch "[")
-                (do (set! pos (inc pos)) (read-list "]"))
+                  (do (set! pos (inc pos)) (read-list "]"))
+
+                ;; Map
                (= ch "{")
-                (do (set! pos (inc pos)) (read-map))
+                  (do (set! pos (inc pos)) (read-map))
+
+                ;; String
                (= ch "\"")
-                (read-string)
+                  (read-string)
+
+                ;; Keyword
                (= ch ":")
-                (read-keyword)
+                  (read-keyword)
+
+                ;; Quote sugar
                (= ch "'")
-                (do
-                  (set! pos (inc pos))
-                  (list (make-symbol "quote") (read-expr)))
+                  (do (set! pos (inc pos))
+                      (list (make-symbol "quote") (read-expr)))
+
+                ;; Quasiquote sugar
                (= ch "`")
-                (do
-                  (set! pos (inc pos))
-                  (list (make-symbol "quasiquote") (read-expr)))
+                  (do (set! pos (inc pos))
+                      (list (make-symbol "quasiquote") (read-expr)))
+
+                ;; Unquote / splice-unquote
                (= ch ",")
-                (do
-                  (set! pos (inc pos))
-                  (if
-                    (and (< pos len-src) (= (nth source pos) "@"))
-                    (do
-                      (set! pos (inc pos))
-                      (list (make-symbol "splice-unquote") (read-expr)))
-                    (list (make-symbol "unquote") (read-expr))))
+                  (do (set! pos (inc pos))
+                      (if (and (< pos len-src) (= (nth source pos) "@"))
+                        (do (set! pos (inc pos))
+                            (list (make-symbol "splice-unquote") (read-expr)))
+                        (list (make-symbol "unquote") (read-expr))))
+
+                ;; Reader macros: #
                (= ch "#")
-                (do
-                  (set! pos (inc pos))
-                  (if
-                    (>= pos len-src)
-                    (error "Unexpected end of input after #")
-                    (let
-                      ((dispatch-ch (nth source pos)))
-                      (cond
-                        (= dispatch-ch ";")
-                        (do (set! pos (inc pos)) (read-expr) (read-expr))
-                        (= dispatch-ch "|")
-                        (do (set! pos (inc pos)) (read-raw-string))
-                        (= dispatch-ch "'")
-                        (do
-                          (set! pos (inc pos))
-                          (list (make-symbol "quote") (read-expr)))
-                        (= dispatch-ch "\\")
-                        (do (set! pos (inc pos)) (read-char-literal))
-                        (ident-start? dispatch-ch)
-                        (let
-                          ((macro-name (read-ident)))
-                          (let
-                            ((handler (reader-macro-get macro-name)))
-                            (if
-                              handler
-                              (handler (read-expr))
-                              (error
-                                (str "Unknown reader macro: #" macro-name)))))
-                        :else (error (str "Unknown reader macro: #" dispatch-ch))))))
-                (or
-                  (and (>= ch "0") (<= ch "9"))
-                  (and
-                    (= ch "-")
-                    (< (inc pos) len-src)
-                    (let
-                      ((next-ch (nth source (inc pos))))
-                      (and (>= next-ch "0") (<= next-ch "9")))))
-                (read-number)
-                (and
-                  (= ch ".")
-                  (< (+ pos 2) len-src)
-                  (= (nth source (+ pos 1)) ".")
-                  (= (nth source (+ pos 2)) "."))
-                (do (set! pos (+ pos 3)) (make-symbol "..."))
+                  (do (set! pos (inc pos))
+                      (if (>= pos len-src)
+                        (error "Unexpected end of input after #")
+                        (let ((dispatch-ch (nth source pos)))
+                          (cond
+                            ;; #; — datum comment: read and discard next expr
+                            (= dispatch-ch ";")
+                              (do (set! pos (inc pos))
+                                  (read-expr)    ;; read and discard
+                                  (read-expr))   ;; return the NEXT expr
+
+                            ;; #| — raw string
+                            (= dispatch-ch "|")
+                              (do (set! pos (inc pos))
+                                  (read-raw-string))
+
+                            ;; #' — quote shorthand
+                            (= dispatch-ch "'")
+                              (do (set! pos (inc pos))
+                                  (list (make-symbol "quote") (read-expr)))
+
+                            ;; #name — extensible dispatch
+                            (ident-start? dispatch-ch)
+                              (let ((macro-name (read-ident)))
+                                (let ((handler (reader-macro-get macro-name)))
+                                  (if handler
+                                    (handler (read-expr))
+                                    (error (str "Unknown reader macro: #" macro-name)))))
+
+                            :else
+                              (error (str "Unknown reader macro: #" dispatch-ch))))))
+
+                ;; Number (or negative number)
+                (or (and (>= ch "0") (<= ch "9"))
+                    (and (= ch "-")
+                         (< (inc pos) len-src)
+                         (let ((next-ch (nth source (inc pos))))
+                           (and (>= next-ch "0") (<= next-ch "9")))))
+                  (read-number)
+
+                ;; Ellipsis (... as a symbol)
+                (and (= ch ".")
+                     (< (+ pos 2) len-src)
+                     (= (nth source (+ pos 1)) ".")
+                     (= (nth source (+ pos 2)) "."))
+                  (do (set! pos (+ pos 3))
+                      (make-symbol "..."))
+
+                ;; Symbol (must be ident-start char)
                (ident-start? ch)
-                (read-symbol)
-                :else (error (str "Unexpected character: " ch)))))))
-      (let
-        ((exprs (list)))
-        (define
-          parse-loop
-          :effects ()
-          (fn
-            ()
+                  (read-symbol)
+
+                ;; Unexpected
+                :else
+                  (error (str "Unexpected character: " ch)))))))
+
+      ;; -- Entry point: parse all top-level expressions --
+      (let ((exprs (list)))
+        (define parse-loop :effects []
+          (fn ()
            (skip-ws)
-            (when (< pos len-src) (append! exprs (read-expr)) (parse-loop))))
+            (when (< pos len-src)
+              (append! exprs (read-expr))
+              (parse-loop))))
        (parse-loop)
        exprs))))

@@ -499,77 +362,30 @@
 ;; --------------------------------------------------------------------------

 ;; Serialize AST value back to SX source
-(define
-  sx-serialize
-  :effects ()
-  (fn
-    (val)
-    (case
-      (type-of val)
-      "nil"
-      "nil"
-      "boolean"
-      (if val "true" "false")
-      "number"
-      (str val)
-      "rational"
-      (str (numerator val) "/" (denominator val))
-      "string"
-      (str "\"" (escape-string val) "\"")
-      "symbol"
-      (symbol-name val)
-      "keyword"
-      (str ":" (keyword-name val))
-      "list"
-      (str "(" (join " " (map sx-serialize val)) ")")
-      "dict"
-      (sx-serialize-dict val)
-      "sx-expr"
-      (sx-expr-source val)
-      "spread"
-      (str "(make-spread " (sx-serialize-dict (spread-attrs val)) ")")
-      "char"
-      (let
-        ((n (char->integer val)))
-        (str
-          "#\\"
-          (cond
-            (= n 32)
-            "space"
-            (= n 10)
-            "newline"
-            (= n 9)
-            "tab"
-            (= n 13)
-            "return"
-            (= n 0)
-            "nul"
-            (= n 27)
-            "escape"
-            (= n 127)
-            "delete"
-            (= n 8)
-            "backspace"
-            :else (char-from-code n))))
-      :else (str val))))
+(define sx-serialize :effects []
+  (fn (val)
+    (case (type-of val)
+      "nil"       "nil"
+      "boolean"   (if val "true" "false")
+      "number"    (str val)
+      "string"    (str "\"" (escape-string val) "\"")
+      "symbol"    (symbol-name val)
+      "keyword"   (str ":" (keyword-name val))
+      "list"      (str "(" (join " " (map sx-serialize val)) ")")
+      "dict"      (sx-serialize-dict val)
+      "sx-expr"   (sx-expr-source val)
+      "spread"    (str "(make-spread " (sx-serialize-dict (spread-attrs val)) ")")
+      :else       (str val))))


 ;; Serialize a dict to SX {:key val} format
-(define
-  sx-serialize-dict
-  :effects ()
-  (fn
-    ((d :as dict))
-    (str
-      "{"
-      (join
-        " "
+(define sx-serialize-dict :effects []
+  (fn ((d :as dict))
+    (str "{"
+      (join " "
        (reduce
-          (fn
-            ((acc :as list) (key :as string))
-            (concat
-              acc
-              (list (str ":" key) (sx-serialize (dict-get d key)))))
+          (fn ((acc :as list) (key :as string))
+            (concat acc (list (str ":" key) (sx-serialize (dict-get d key)))))
          (list)
          (keys d)))
      "}")))
@@ -591,18 +407,13 @@
 ;;     True for: ident-start chars plus: 0-9 . : / # ,
 ;;
 ;; Constructors (provided by the SX runtime):
-;;   (make-symbol name)    → Symbol value
-;;   (make-keyword name)   → Keyword value
-;;   (parse-number s)      → number (int or float from string)
-;;   (make-char n)         → Char value from Unicode codepoint n
-;;   (make-rational n d)   → Rational value (auto-reduced by GCD; d=0 is an error)
-;;   (char->integer c)     → Unicode codepoint of char c
+;;   (make-symbol name)  → Symbol value
+;;   (make-keyword name) → Keyword value
+;;   (parse-number s)    → number (int or float from string)
 ;;
 ;; String utilities:
 ;;   (escape-string s)   → string with " and \ escaped
 ;;   (sx-expr-source e)  → unwrap SxExpr to its source string
-;;   (char-from-code n)  → single-char string from codepoint n
-;;   (char-code s)       → codepoint of first char in string s
 ;;
 ;; Reader macro registry:
 ;;   (reader-macro-get name)          → handler fn or nil
--- a/spec/primitives.sx
+++ b/spec/primitives.sx
@@ -43,35 +43,35 @@
  "+"
  :params (&rest (args :as number))
  :returns "number"
-  :doc "Sum all arguments. Returns integer iff all args are exact integers (float contagion)."
+  :doc "Sum all arguments."
  :body (reduce (fn (a b) (native-add a b)) 0 args))

 (define-primitive
  "-"
  :params ((a :as number) &rest (b :as number))
  :returns "number"
-  :doc "Subtract. Unary: negate. Binary: a - b. Float contagion: returns integer iff all args are integers."
+  :doc "Subtract. Unary: negate. Binary: a - b."
  :body (if (empty? b) (native-neg a) (native-sub a (first b))))

 (define-primitive
  "*"
  :params (&rest (args :as number))
  :returns "number"
-  :doc "Multiply all arguments. Float contagion: integer result iff all args are exact integers."
+  :doc "Multiply all arguments."
  :body (reduce (fn (a b) (native-mul a b)) 1 args))

 (define-primitive
  "/"
  :params ((a :as number) (b :as number))
-  :returns "float"
-  :doc "Divide a by b. Always returns inexact float."
+  :returns "number"
+  :doc "Divide a by b."
  :body (native-div a b))

 (define-primitive
  "mod"
  :params ((a :as number) (b :as number))
  :returns "number"
-  :doc "Modulo a % b. Returns integer iff both args are integers."
+  :doc "Modulo a % b."
  :body (native-mod a b))

 (define-primitive
@@ -108,26 +108,26 @@
 (define-primitive
  "floor"
  :params ((x :as number))
-  :returns "integer"
-  :doc "Floor toward negative infinity — returns exact integer.")
+  :returns "number"
+  :doc "Floor to integer.")

 (define-primitive
  "ceil"
  :params ((x :as number))
-  :returns "integer"
-  :doc "Ceiling toward positive infinity — returns exact integer.")
+  :returns "number"
+  :doc "Ceiling to integer.")

 (define-primitive
  "round"
  :params ((x :as number) &rest (ndigits :as number))
  :returns "number"
-  :doc "Round to ndigits decimal places (default 0). Returns integer when ndigits is 0.")
+  :doc "Round to ndigits decimal places (default 0).")

 (define-primitive
  "truncate"
-  :params ((x :as number))
-  :returns "integer"
-  :doc "Truncate toward zero — returns exact integer.")
+  :params (((x :as number)))
+  :returns "number"
+  :doc "Truncate toward zero.")

 (define-primitive
  "remainder"
@@ -143,42 +143,42 @@

 (define-primitive
  "exact?"
-  :params ((x :as number))
+  :params (((x :as number)))
  :returns "boolean"
-  :doc "True if x is an exact integer (not an inexact float).")
+  :doc "True if x is exact (integer-valued).")

 (define-primitive
  "inexact?"
-  :params ((x :as number))
+  :params (((x :as number)))
  :returns "boolean"
-  :doc "True if x is an inexact float (not an exact integer).")
+  :doc "True if x is inexact (non-integer).")

 ;; --------------------------------------------------------------------------
 ;; Core — Comparison
 ;; --------------------------------------------------------------------------
 (define-primitive
  "exact->inexact"
-  :params ((x :as number))
-  :returns "float"
-  :doc "Convert exact integer to inexact float. Floats pass through unchanged.")
+  :params (((x :as number)))
+  :returns "number"
+  :doc "Convert exact to inexact (identity for float tower).")

 (define-primitive
  "inexact->exact"
-  :params ((x :as number))
-  :returns "integer"
-  :doc "Convert inexact float to nearest exact integer (truncates). Integers pass through unchanged.")
+  :params (((x :as number)))
+  :returns "number"
+  :doc "Convert inexact to nearest exact integer.")

 (define-primitive
  "make-vector"
-  :params ((n :as number) (fill :as any :optional true))
+  :params ((n :as number))
  :returns "vector"
-  :doc "Create vector of length n, each element initialised to fill (default nil).")
+  :doc "Create vector of size n, optionally filled.")

 (define-primitive
  "vector"
-  :params (:rest (elts :as any))
+  :params ()
  :returns "vector"
-  :doc "Construct a vector from its arguments.")
+  :doc "Create vector from arguments.")

 (define-primitive
  "vector?"
@@ -190,31 +190,31 @@
  "vector-length"
  :params ((v :as vector))
  :returns "number"
-  :doc "Number of elements in vector v.")
+  :doc "Number of elements.")

 (define-primitive
  "vector-ref"
  :params ((v :as vector) (i :as number))
  :returns "any"
-  :doc "Element at 0-based index i. Error if out of bounds.")
+  :doc "Element at index.")

 (define-primitive
  "vector-set!"
  :params ((v :as vector) (i :as number) (val :as any))
  :returns "nil"
-  :doc "Mutate element at index i to val. Error if out of bounds.")
+  :doc "Set element at index.")

 (define-primitive
  "vector->list"
  :params ((v :as vector))
  :returns "list"
-  :doc "Convert vector to a fresh list.")
+  :doc "Convert vector to list.")

 (define-primitive
  "list->vector"
  :params ((l :as list))
  :returns "vector"
-  :doc "Convert list to a fresh vector.")
+  :doc "Convert list to vector.")

 ;; --------------------------------------------------------------------------
 ;; Core — Predicates
@@ -223,15 +223,13 @@
  "vector-fill!"
  :params ((v :as vector) (val :as any))
  :returns "nil"
-  :doc "Set every element of v to val in place.")
+  :doc "Fill all elements.")

 (define-primitive
  "vector-copy"
-  :params ((v :as vector)
-    (start :as number :optional true)
-    (end :as number :optional true))
+  :params ((v :as vector))
  :returns "vector"
-  :doc "Shallow copy of vector, optionally sliced from start (inclusive) to end (exclusive).")
+  :doc "Independent shallow copy.")

 (define-primitive
  "min"
@@ -374,20 +372,8 @@
  "number?"
  :params (x)
  :returns "boolean"
-  :doc "True if x is any number — exact integer or inexact float."
-  :body (or (= (type-of x) "number") (integer? x)))
-
-(define-primitive
-  "integer?"
-  :params (x)
-  :returns "boolean"
-  :doc "True if x is an exact integer, or a float with no fractional part (e.g. 1.0).")
-
-(define-primitive
-  "float?"
-  :params (x)
-  :returns "boolean"
-  :doc "True if x is an inexact float (Number type). Does not match exact integers.")
+  :doc "True if x is a number (int or float)."
+  :body (= (type-of x) "number"))

 (define-primitive
  "string?"
@@ -492,12 +478,6 @@
  :returns "string"
  :doc "Convert Unicode code point to single-character string.")

-(define-primitive
-  "char-code"
-  :params ((s :as string))
-  :returns "number"
-  :doc "Unicode codepoint of the first character of string s.")
-
 (define-primitive
  "substring"
  :params ((s :as string) (start :as number) (end :as number))
@@ -552,15 +532,15 @@
  :returns "boolean"
  :doc "True if string s starts with prefix.")

-;; --------------------------------------------------------------------------
-;; Core — Dict operations
-;; --------------------------------------------------------------------------
 (define-primitive
  "ends-with?"
  :params ((s :as string) (suffix :as string))
  :returns "boolean"
  :doc "True if string s ends with suffix.")

+;; --------------------------------------------------------------------------
+;; Core — Dict operations
+;; --------------------------------------------------------------------------
 (define-module :core.collections)

 (define-primitive
@@ -605,15 +585,15 @@
  :returns "any"
  :doc "Last element, or nil if empty.")

-;; --------------------------------------------------------------------------
-;; Stdlib — Format
-;; --------------------------------------------------------------------------
 (define-primitive
  "rest"
  :params ((coll :as list))
  :returns "list"
  :doc "All elements except the first.")

+;; --------------------------------------------------------------------------
+;; Stdlib — Format
+;; --------------------------------------------------------------------------
 (define-primitive
  "nth"
  :params ((coll :as list) (n :as number))
@@ -638,15 +618,15 @@
  :returns "list"
  :doc "Mutate coll by appending x in-place. Returns coll.")

-;; --------------------------------------------------------------------------
-;; Stdlib — Text
-;; --------------------------------------------------------------------------
 (define-primitive
  "reverse"
  :params ((coll :as list))
  :returns "list"
  :doc "Return coll in reverse order.")

+;; --------------------------------------------------------------------------
+;; Stdlib — Text
+;; --------------------------------------------------------------------------
 (define-primitive
  "flatten"
  :params ((coll :as list))
@@ -665,29 +645,29 @@
  :returns "list"
  :doc "Consecutive pairs: (1 2 3 4) → ((1 2) (2 3) (3 4)).")

+(define-module :core.dict)
+
 ;; --------------------------------------------------------------------------
 ;; Stdlib — Style
 ;; --------------------------------------------------------------------------
 ;; --------------------------------------------------------------------------
 ;; Stdlib — Debug
 ;; --------------------------------------------------------------------------
-(define-module :core.dict)
-
 (define-primitive
  "keys"
  :params ((d :as dict))
  :returns "list"
  :doc "List of dict keys.")

-;; --------------------------------------------------------------------------
-;; Type introspection — platform primitives
-;; --------------------------------------------------------------------------
 (define-primitive
  "vals"
  :params ((d :as dict))
  :returns "list"
  :doc "List of dict values.")

+;; --------------------------------------------------------------------------
+;; Type introspection — platform primitives
+;; --------------------------------------------------------------------------
 (define-primitive
  "merge"
  :params (&rest (dicts :as dict))
@@ -803,532 +783,3 @@
  :params ((source :as string))
  :returns "list"
  :doc "Parse SX source string into a list of AST expressions.")
-
-(define-primitive
-  "make-string-buffer"
-  :params ()
-  :returns "string-buffer"
-  :doc "Create a new empty mutable string buffer for O(1) amortised append.")
-
-(define-module :stdlib.coroutines)
-
-(define-module :stdlib.bitwise)
-
-(define-primitive
-  "bitwise-and"
-  :params (((a :as number) (b :as number)))
-  :returns "number"
-  :doc "Bitwise AND of two integers.")
-
-(define-primitive
-  "bitwise-or"
-  :params (((a :as number) (b :as number)))
-  :returns "number"
-  :doc "Bitwise OR of two integers.")
-
-(define-primitive
-  "bitwise-xor"
-  :params (((a :as number) (b :as number)))
-  :returns "number"
-  :doc "Bitwise XOR of two integers.")
-
-(define-primitive
-  "bitwise-not"
-  :params ((a :as number))
-  :returns "number"
-  :doc "Bitwise NOT (one's complement) of an integer.")
-
-(define-primitive
-  "arithmetic-shift"
-  :params (((a :as number) (count :as number)))
-  :returns "number"
-  :doc "Arithmetic shift: left if count > 0, right if count < 0.")
-
-(define-primitive
-  "bit-count"
-  :params ((a :as number))
-  :returns "number"
-  :doc "Count set bits (popcount) in a non-negative integer.")
-
-(define-primitive
-  "integer-length"
-  :params ((a :as number))
-  :returns "number"
-  :doc "Number of bits needed to represent integer a (excluding sign).")
-
-(define-module :stdlib.ports)
-
-(define-primitive
-  "eof-object"
-  :params ()
-  :returns "eof-object"
-  :doc "The EOF sentinel value.")
-
-(define-primitive
-  "eof-object?"
-  :params (v)
-  :returns "boolean"
-  :doc "True if v is the EOF sentinel.")
-
-(define-primitive
-  "open-input-string"
-  :params ((s :as string))
-  :returns "input-port"
-  :doc "Open a string as an input port.")
-
-(define-primitive
-  "open-output-string"
-  :params ()
-  :returns "output-port"
-  :doc "Open a fresh output string port.")
-
-(define-primitive
-  "get-output-string"
-  :params ((p :as output-port))
-  :returns "string"
-  :doc "Flush output port contents to a string.")
-
-(define-primitive
-  "port?"
-  :params (v)
-  :returns "boolean"
-  :doc "True if v is any port.")
-
-(define-primitive
-  "input-port?"
-  :params (v)
-  :returns "boolean"
-  :doc "True if v is an input port.")
-
-(define-primitive
-  "output-port?"
-  :params (v)
-  :returns "boolean"
-  :doc "True if v is an output port.")
-
-(define-primitive
-  "close-port"
-  :params ((p :as port))
-  :returns "nil"
-  :doc "Close a port.")
-
-(define-primitive
-  "read-char"
-  :params (&rest (p :as input-port))
-  :returns "any"
-  :doc "Read next char from port; returns eof-object at end.")
-
-(define-primitive
-  "peek-char"
-  :params (&rest (p :as input-port))
-  :returns "any"
-  :doc "Peek next char without consuming; returns eof-object at end.")
-
-(define-primitive
-  "read-line"
-  :params (&rest (p :as input-port))
-  :returns "any"
-  :doc "Read a line from port; returns eof-object at end.")
-
-(define-primitive
-  "write-char"
-  :params ((c :as char) &rest (p :as output-port))
-  :returns "nil"
-  :doc "Write a char to output port.")
-
-(define-primitive
-  "write-string"
-  :params ((s :as string) &rest (p :as output-port))
-  :returns "nil"
-  :doc "Write a string to output port.")
-
-(define-primitive
-  "char-ready?"
-  :params (&rest (p :as input-port))
-  :returns "boolean"
-  :doc "True if a char is immediately available on the port.")
-
-
-(define-primitive
-  "read"
-  :params (&rest (p :as input-port))
-  :returns "any"
-  :doc "Read one datum from port; returns eof-object at end.")
-
-(define-primitive
-  "write"
-  :params (v &rest (p :as output-port))
-  :returns "nil"
-  :doc "Serialize v to port with quoting — strings quoted, chars as #\\a notation.")
-
-(define-primitive
-  "display"
-  :params (v &rest (p :as output-port))
-  :returns "nil"
-  :doc "Serialize v to port without quoting — strings unquoted, chars as characters.")
-
-(define-primitive
-  "newline"
-  :params (&rest (p :as output-port))
-  :returns "nil"
-  :doc "Write a newline to port.")
-
-(define-primitive
-  "write-to-string"
-  :params (v)
-  :returns "string"
-  :doc "Serialize v with write quoting, return as string.")
-
-(define-primitive
-  "display-to-string"
-  :params (v)
-  :returns "string"
-  :doc "Serialize v with display format, return as string.")
-
-(define-primitive
-  "current-input-port"
-  :params ()
-  :returns "any"
-  :doc "Return current default input port.")
-
-(define-primitive
-  "current-output-port"
-  :params ()
-  :returns "any"
-  :doc "Return current default output port.")
-
-(define-primitive
-  "current-error-port"
-  :params ()
-  :returns "any"
-  :doc "Return current error port.")
-
-(define-module :stdlib.math)
-
-(define-primitive
-  "sin"
-  :params ((x :as number))
-  :returns "float"
-  :doc "Sine of x (radians).")
-
-(define-primitive
-  "cos"
-  :params ((x :as number))
-  :returns "float"
-  :doc "Cosine of x (radians).")
-
-(define-primitive
-  "tan"
-  :params ((x :as number))
-  :returns "float"
-  :doc "Tangent of x (radians).")
-
-(define-primitive
-  "asin"
-  :params ((x :as number))
-  :returns "float"
-  :doc "Arc sine of x; result in radians.")
-
-(define-primitive
-  "acos"
-  :params ((x :as number))
-  :returns "float"
-  :doc "Arc cosine of x; result in radians.")
-
-(define-primitive
-  "atan"
-  :params ((x :as number) &rest (y :as number))
-  :returns "float"
-  :doc "Arc tangent. (atan x) → radians in (-π/2, π/2). (atan y x) → atan2(y, x).")
-
-(define-primitive
-  "exp"
-  :params ((x :as number))
-  :returns "float"
-  :doc "e raised to the power x.")
-
-(define-primitive
-  "log"
-  :params ((x :as number))
-  :returns "float"
-  :doc "Natural logarithm of x.")
-
-(define-primitive
-  "expt"
-  :params ((base :as number) (exp :as number))
-  :returns "number"
-  :doc "base raised to the power exp. Alias: pow.")
-
-(define-primitive
-  "quotient"
-  :params ((a :as number) (b :as number))
-  :returns "integer"
-  :doc "Integer quotient: truncate(a / b) toward zero. Sign follows dividend.")
-
-(define-primitive
-  "gcd"
-  :params ((a :as number) (b :as number))
-  :returns "integer"
-  :doc "Greatest common divisor of a and b.")
-
-(define-primitive
-  "lcm"
-  :params ((a :as number) (b :as number))
-  :returns "integer"
-  :doc "Least common multiple of a and b.")
-
-(define-primitive
-  "number->string"
-  :params ((n :as number) &rest (radix :as number))
-  :returns "string"
-  :doc "Convert number n to string. Optional radix (default 10). E.g. (number->string 255 16) → \"ff\".")
-
-(define-primitive
-  "string->number"
-  :params ((s :as string) &rest (radix :as number))
-  :returns "any"
-  :doc "Parse string s as a number. Optional radix (default 10). Returns nil on failure.")
-
-(define-module :stdlib.rational)
-
-(define-primitive
-  "make-rational"
-  :params (n d)
-  :returns "rational"
-  :doc "Rational n/d, auto-reduced by GCD. Error if d=0.")
-
-(define-primitive
-  "rational?"
-  :params (v)
-  :returns "boolean"
-  :doc "True if v is a rational number.")
-
-(define-primitive
-  "numerator"
-  :params ((r :as rational))
-  :returns "integer"
-  :doc "Numerator of rational r (after reduction).")
-
-(define-primitive
-  "denominator"
-  :params ((r :as rational))
-  :returns "integer"
-  :doc "Denominator of rational r (after reduction, always positive).")
-
-(define-module :stdlib.hash-table)
-
-(define-module :stdlib.sets)
-
-(define-primitive
-  "make-set"
-  :params (&rest (lst :as list))
-  :returns "set"
-  :doc "Create a fresh empty set. Optional list argument seeds the set: (make-set '(1 2 3)).")
-
-(define-primitive
-  "set?"
-  :params (v)
-  :returns "boolean"
-  :doc "True if v is a set.")
-
-(define-primitive
-  "set-add!"
-  :params (s val)
-  :returns "nil"
-  :doc "Add val to set s in place. No-op if already present.")
-
-(define-primitive
-  "set-member?"
-  :params (s val)
-  :returns "boolean"
-  :doc "True if val is in set s.")
-
-(define-primitive
-  "set-remove!"
-  :params (s val)
-  :returns "nil"
-  :doc "Remove val from set s in place. No-op if absent.")
-
-(define-primitive
-  "set-size"
-  :params (s)
-  :returns "integer"
-  :doc "Number of elements in set s.")
-
-(define-primitive
-  "set->list"
-  :params (s)
-  :returns "list"
-  :doc "All elements of set s as a list (unspecified order).")
-
-(define-primitive
-  "list->set"
-  :params (lst)
-  :returns "set"
-  :doc "Create a new set containing all elements of lst.")
-
-(define-primitive
-  "set-union"
-  :params (s1 s2)
-  :returns "set"
-  :doc "New set with all elements from s1 and s2.")
-
-(define-primitive
-  "set-intersection"
-  :params (s1 s2)
-  :returns "set"
-  :doc "New set with elements present in both s1 and s2.")
-
-(define-primitive
-  "set-difference"
-  :params (s1 s2)
-  :returns "set"
-  :doc "New set with elements in s1 that are not in s2.")
-
-(define-primitive
-  "set-for-each"
-  :params (s fn)
-  :returns "nil"
-  :doc "Call (fn val) for each element in set s. Order unspecified.")
-
-(define-primitive
-  "set-map"
-  :params (s fn)
-  :returns "set"
-  :doc "New set of results of (fn val) for each element in s.")
-
-(define-module :stdlib.regexp)
-
-(define-primitive
-  "make-regexp"
-  :params ((pattern :as string) &rest (flags :as string))
-  :returns "regexp"
-  :doc "Compile regexp from pattern string and optional flags string (\"i\" case-insensitive, \"m\" multiline, \"s\" dotall).")
-
-(define-primitive
-  "regexp?"
-  :params (v)
-  :returns "boolean"
-  :doc "True if v is a compiled regexp.")
-
-(define-primitive
-  "regexp-source"
-  :params ((re :as regexp))
-  :returns "string"
-  :doc "Pattern string of a regexp.")
-
-(define-primitive
-  "regexp-flags"
-  :params ((re :as regexp))
-  :returns "string"
-  :doc "Flags string of a regexp.")
-
-(define-primitive
-  "regexp-match"
-  :params ((re :as regexp) (str :as string))
-  :returns "any"
-  :doc "First match of re in str. Returns {:match \"...\" :start N :end N :groups (...)} or nil.")
-
-(define-primitive
-  "regexp-match-all"
-  :params ((re :as regexp) (str :as string))
-  :returns "list"
-  :doc "All non-overlapping matches of re in str as a list of match dicts.")
-
-(define-primitive
-  "regexp-replace"
-  :params ((re :as regexp) (str :as string) (replacement :as string))
-  :returns "string"
-  :doc "Replace first match of re in str with replacement. $& = whole match, $1..$9 = groups.")
-
-(define-primitive
-  "regexp-replace-all"
-  :params ((re :as regexp) (str :as string) (replacement :as string))
-  :returns "string"
-  :doc "Replace all matches of re in str with replacement.")
-
-(define-primitive
-  "regexp-split"
-  :params ((re :as regexp) (str :as string))
-  :returns "list"
-  :doc "Split str on every match of re; returns list of strings.")
-
-(define-module :stdlib.bytevectors)
-
-(define-primitive
-  "make-bytevector"
-  :params (n &rest fill)
-  :returns "bytevector"
-  :doc "Create a bytevector of n bytes, all initialised to fill (default 0).")
-
-(define-primitive
-  "bytevector?"
-  :params (v)
-  :returns "boolean"
-  :doc "True if v is a bytevector.")
-
-(define-primitive
-  "bytevector-length"
-  :params ((bv :as bytevector))
-  :returns "number"
-  :doc "Number of bytes in bv.")
-
-(define-primitive
-  "bytevector-u8-ref"
-  :params ((bv :as bytevector) (i :as number))
-  :returns "number"
-  :doc "Byte value 0-255 at index i.")
-
-(define-primitive
-  "bytevector-u8-set!"
-  :params ((bv :as bytevector) (i :as number) (byte :as number))
-  :returns "nil"
-  :doc "Set byte at index i to byte 0-255. Mutates bv.")
-
-(define-primitive
-  "bytevector-copy"
-  :params ((bv :as bytevector) &rest bounds)
-  :returns "bytevector"
-  :doc "Fresh copy of bv, optionally sliced to [start, end).")
-
-(define-primitive
-  "bytevector-copy!"
-  :params ((dst :as bytevector) (at :as number) (src :as bytevector) &rest bounds)
-  :returns "nil"
-  :doc "Copy bytes from src[start..end) into dst starting at at. Mutates dst.")
-
-(define-primitive
-  "bytevector-append"
-  :params (&rest bvs)
-  :returns "bytevector"
-  :doc "Concatenate bytevectors into a new bytevector.")
-
-(define-primitive
-  "utf8->string"
-  :params ((bv :as bytevector) &rest bounds)
-  :returns "string"
-  :doc "Decode bv[start..end) as UTF-8 and return the string.")
-
-(define-primitive
-  "string->utf8"
-  :params ((s :as string) &rest bounds)
-  :returns "bytevector"
-  :doc "Encode s[start..end) as UTF-8 and return a bytevector.")
-
-(define-primitive
-  "bytevector->list"
-  :params ((bv :as bytevector))
-  :returns "list"
-  :doc "Convert bytevector to a list of byte integers.")
-
-(define-primitive
-  "list->bytevector"
-  :params ((lst :as list))
-  :returns "bytevector"
-  :doc "Build a bytevector from a list of byte integers 0-255.")
-
-(define-primitive
-  "format"
-  :params ((template :as string) &rest args)
-  :returns "string"
-  :doc "CL-style format string. Directives: ~a display, ~s write, ~d decimal, ~x hex, ~o octal, ~b binary, ~f fixed-point, ~e scientific, ~% newline, ~& fresh-line, ~~ tilde, ~t tab. Optional first arg: output-port.")
--- a/spec/stdlib.sx
+++ b/spec/stdlib.sx
@@ -1,134 +0,0 @@
-;; ==========================================================================
-;; stdlib.sx — Pure SX standard library functions
-;;
-;; Loaded by test runners after primitives. These functions are implemented
-;; in SX and require no host-specific code.
-;;
-;; IMPORTANT: SX let/when bodies evaluate only the LAST expression.
-;;   Multi-step bodies must be wrapped in (do expr1 expr2 ...).
-;; ==========================================================================
-
-;; --------------------------------------------------------------------------
-;; format — CL-style string formatting
-;;
-;; Directives:
-;;   ~a  display (no quotes)       ~s  write (with quotes)
-;;   ~d  decimal  ~x  hex  ~o  octal  ~b  binary
-;;   ~f  fixed-point (6dp)          ~%  newline
-;;   ~&  fresh line                 ~~  literal tilde
-;;   ~t  tab
-;;
-;; Signature: (format template arg...) -> string
-;; --------------------------------------------------------------------------
-
-(define
-  (format template &rest args)
-  (let
-    ((buf (make-string-buffer)) (n (string-length template)))
-    (define
-      (consume-arg args)
-      (if
-        (nil? args)
-        (list "" nil)
-        (list (display-to-string (first args)) (rest args))))
-    (define
-      (consume-num args radix)
-      (if
-        (nil? args)
-        (list "" nil)
-        (list (number->string (first args) radix) (rest args))))
-    (define
-      (loop i args)
-      (cond
-        ((>= i n) (string-buffer->string buf))
-        ((and (= (substring template i (+ i 1)) "~") (< (+ i 1) n))
-          (let
-            ((dir (substring template (+ i 1) (+ i 2))))
-            (cond
-              ((= dir "a")
-                (let
-                  ((p (consume-arg args)))
-                  (do
-                    (string-buffer-append! buf (first p))
-                    (loop (+ i 2) (first (rest p))))))
-              ((= dir "s")
-                (if
-                  (nil? args)
-                  (loop (+ i 2) args)
-                  (do
-                    (string-buffer-append!
-                      buf
-                      (write-to-string (first args)))
-                    (loop (+ i 2) (rest args)))))
-              ((= dir "d")
-                (let
-                  ((p (consume-num args 10)))
-                  (do
-                    (string-buffer-append! buf (first p))
-                    (loop (+ i 2) (first (rest p))))))
-              ((= dir "x")
-                (let
-                  ((p (consume-num args 16)))
-                  (do
-                    (string-buffer-append! buf (first p))
-                    (loop (+ i 2) (first (rest p))))))
-              ((= dir "o")
-                (let
-                  ((p (consume-num args 8)))
-                  (do
-                    (string-buffer-append! buf (first p))
-                    (loop (+ i 2) (first (rest p))))))
-              ((= dir "b")
-                (let
-                  ((p (consume-num args 2)))
-                  (do
-                    (string-buffer-append! buf (first p))
-                    (loop (+ i 2) (first (rest p))))))
-              ((= dir "f")
-                (if
-                  (nil? args)
-                  (loop (+ i 2) args)
-                  (do
-                    (string-buffer-append!
-                      buf
-                      (format-decimal (first args) 6))
-                    (loop (+ i 2) (rest args)))))
-              ((= dir "%")
-                (do
-                  (string-buffer-append! buf "\n")
-                  (loop (+ i 2) args)))
-              ((= dir "&")
-                (do
-                  (let
-                    ((so-far (string-buffer->string buf)))
-                    (when
-                      (or
-                        (= (string-length so-far) 0)
-                        (not
-                          (=
-                            (substring
-                              so-far
-                              (- (string-length so-far) 1)
-                              (string-length so-far))
-                            "\n")))
-                      (string-buffer-append! buf "\n")))
-                  (loop (+ i 2) args)))
-              ((= dir "~")
-                (do
-                  (string-buffer-append! buf "~")
-                  (loop (+ i 2) args)))
-              ((= dir "t")
-                (do
-                  (string-buffer-append! buf "\t")
-                  (loop (+ i 2) args)))
-              (else
-                (do
-                  (string-buffer-append! buf "~")
-                  (loop (+ i 1) args))))))
-        (else
-          (do
-            (string-buffer-append!
-              buf
-              (substring template i (+ i 1)))
-            (loop (+ i 1) args)))))
-    (loop 0 args)))
--- a/spec/tests/test-adt.sx
+++ b/spec/tests/test-adt.sx
@@ -1,278 +0,0 @@
-(defsuite
-  "algebraic-data-types"
-  (deftest
-    "constructor creates dict with adt marker"
-    (do
-      (define-type Maybe (Just value) (Nothing))
-      (assert= true (get (Just 42) :_adt))))
-  (deftest
-    "constructor stores type name"
-    (do
-      (define-type Shape (Circle radius) (Square side))
-      (assert= "Shape" (get (Circle 5) :_type))
-      (assert= "Shape" (get (Square 3) :_type))))
-  (deftest
-    "constructor stores constructor name"
-    (do
-      (define-type Opt (Some val) (None))
-      (assert= "Some" (get (Some 1) :_ctor))
-      (assert= "None" (get (None) :_ctor))))
-  (deftest
-    "constructor stores fields as list"
-    (do
-      (define-type Pair (Pair-of fst snd))
-      (assert-equal
-        (list 1 2)
-        (get (Pair-of 1 2) :_fields))))
-  (deftest
-    "zero-arg constructor has empty fields"
-    (do
-      (define-type Flag (Set) (Unset))
-      (assert-equal (list) (get (Set) :_fields))
-      (assert-equal (list) (get (Unset) :_fields))))
-  (deftest
-    "type predicate true for all constructors"
-    (do
-      (define-type Expr (Num n) (Add left right) (Neg e))
-      (assert= true (Expr? (Num 5)))
-      (assert= true (Expr? (Add (Num 1) (Num 2))))
-      (assert= true (Expr? (Neg (Num 3))))))
-  (deftest
-    "type predicate false for non-adt values"
-    (do
-      (define-type Box (Box-of x))
-      (assert= false (Box? 42))
-      (assert= false (Box? "hello"))
-      (assert= false (Box? nil))
-      (assert= false (Box? (list 1 2)))
-      (assert= false (Box? {}))))
-  (deftest
-    "type predicate false for wrong adt type"
-    (do
-      (define-type AT (AV x))
-      (define-type BT (BV x))
-      (assert= false (AT? (BV 1)))
-      (assert= false (BT? (AV 1)))))
-  (deftest
-    "constructor predicate true for matching constructor"
-    (do
-      (define-type Result (Ok value) (Err msg))
-      (assert= true (Ok? (Ok 42)))
-      (assert= true (Err? (Err "bad")))))
-  (deftest
-    "constructor predicate false for wrong constructor"
-    (do
-      (define-type Coin (Heads) (Tails))
-      (assert= false (Heads? (Tails)))
-      (assert= false (Tails? (Heads)))))
-  (deftest
-    "constructor predicate false for non-adt"
-    (do
-      (define-type Wrap (Wrapped x))
-      (assert= false (Wrapped? 42))
-      (assert= false (Wrapped? nil))
-      (assert= false (Wrapped? "str"))))
-  (deftest
-    "single-field accessor returns field value"
-    (do
-      (define-type Holder (Held content))
-      (assert= 99 (Held-content (Held 99)))
-      (assert= "hello" (Held-content (Held "hello")))))
-  (deftest
-    "multi-field accessors return correct fields"
-    (do
-      (define-type Triple (Triple-of a b c))
-      (let
-        ((t (Triple-of 10 20 30)))
-        (assert= 10 (Triple-of-a t))
-        (assert= 20 (Triple-of-b t))
-        (assert= 30 (Triple-of-c t)))))
-  (deftest
-    "tree constructors and accessors"
-    (do
-      (define-type Tree (Leaf) (Node left val right))
-      (let
-        ((t (Node (Leaf) 5 (Node (Leaf) 3 (Leaf)))))
-        (assert= true (Node? t))
-        (assert= 5 (Node-val t))
-        (assert= true (Leaf? (Node-left t)))
-        (assert= true (Node? (Node-right t)))
-        (assert= 3 (Node-val (Node-right t))))))
-  (deftest
-    "arity error on too few args"
-    (do
-      (define-type Pair2 (Pair2-of a b))
-      (let
-        ((ok false))
-        (guard (exn (else (set! ok true))) (Pair2-of 1))
-        (assert ok))))
-  (deftest
-    "arity error on too many args"
-    (do
-      (define-type Single (Single-of x))
-      (let
-        ((ok false))
-        (guard
-          (exn (else (set! ok true)))
-          (Single-of 1 2))
-        (assert ok))))
-  (deftest
-    "multiple types are independent"
-    (do
-      (define-type Color2 (Red2) (Green2) (Blue2))
-      (define-type Suit (Hearts) (Diamonds) (Clubs) (Spades))
-      (assert= false (Color2? (Hearts)))
-      (assert= false (Suit? (Red2)))
-      (assert= true (Color2? (Blue2)))
-      (assert= true (Suit? (Spades)))))
-  (deftest
-    "adt fields can hold any value"
-    (do
-      (define-type Container (Hold x))
-      (assert-equal
-        (list 1 2 3)
-        (Hold-x (Hold (list 1 2 3))))
-      (assert-equal {:a 1} (Hold-x (Hold {:a 1})))))
-  (deftest
-    "adt-registry tracks type constructor names"
-    (do
-      (define-type Days (Mon) (Tue) (Wed) (Thu) (Fri))
-      (assert-equal
-        (list "Mon" "Tue" "Wed" "Thu" "Fri")
-        (get *adt-registry* "Days"))))
-  (deftest
-    "constructors with same field name in different types are independent"
-    (do
-      (define-type P1 (P1-ctor value))
-      (define-type P2 (P2-ctor value))
-      (assert= 10 (P1-ctor-value (P1-ctor 10)))
-      (assert= 20 (P2-ctor-value (P2-ctor 20)))))
-  (deftest
-    "match dispatches on first matching constructor"
-    (do
-      (define-type Color (Red) (Green) (Blue))
-      (assert= "red" (match (Red) ((Red) "red") ((Green) "green") ((Blue) "blue")))
-      (assert= "green" (match (Green) ((Red) "red") ((Green) "green") ((Blue) "blue")))
-      (assert= "blue" (match (Blue) ((Red) "red") ((Green) "green") ((Blue) "blue")))))
-  (deftest
-    "match binds field to variable"
-    (do
-      (define-type Wrapper (Wrap val))
-      (assert= 42 (match (Wrap 42) ((Wrap v) v)))
-      (assert= "hi" (match (Wrap "hi") ((Wrap v) v)))))
-  (deftest
-    "match zero-arg constructor"
-    (do
-      (define-type Signal (On) (Off))
-      (assert= "on" (match (On) ((On) "on") ((Off) "off")))
-      (assert= "off" (match (Off) ((On) "on") ((Off) "off")))))
-  (deftest
-    "match multi-field constructor binds all fields"
-    (do
-      (define-type Vec2 (V2 x y))
-      (let ((v (V2 3 4)))
-        (assert= 7 (match v ((V2 a b) (+ a b)))))))
-  (deftest
-    "match with else clause"
-    (do
-      (define-type Opt2 (Some2 val) (None2))
-      (assert= 10 (match (Some2 10) ((Some2 v) v) (else 0)))
-      (assert= 0 (match (None2) ((Some2 v) v) (else 0)))))
-  (deftest
-    "match else catches non-adt values"
-    (do
-      (assert= "other" (match 42 ((else) "other") (else "other")))
-      (assert= "other" (match "str" (else "other")))))
-  (deftest
-    "match returns body expression value"
-    (do
-      (define-type Num (Num-of n))
-      (assert= 100 (match (Num-of 10) ((Num-of n) (* n n))))))
-  (deftest
-    "match second arm fires when first does not match"
-    (do
-      (define-type Either (Left val) (Right val))
-      (assert= "left-1" (match (Left 1) ((Left v) (str "left-" v)) ((Right v) (str "right-" v))))
-      (assert= "right-2" (match (Right 2) ((Left v) (str "left-" v)) ((Right v) (str "right-" v))))))
-  (deftest
-    "match wildcard _ in constructor pattern"
-    (do
-      (define-type Pair3 (Pair3-of a b))
-      (assert= 5 (match (Pair3-of 5 99) ((Pair3-of x _) x)))
-      (assert= 99 (match (Pair3-of 5 99) ((Pair3-of _ y) y)))))
-  (deftest
-    "match nested adt constructor pattern"
-    (do
-      (define-type Tree2 (Leaf2) (Node2 left val right))
-      (let ((t (Node2 (Leaf2) 7 (Leaf2))))
-        (assert= 7 (match t ((Node2 _ v _) v)))
-        (assert= true (match t ((Node2 (Leaf2) _ _) true) (else false))))))
-  (deftest
-    "match literal pattern"
-    (do
-      (assert= "zero" (match 0 (0 "zero") (else "nonzero")))
-      (assert= "hello" (match "hello" ("hello" "hello") (else "other")))))
-  (deftest
-    "match symbol binding pattern"
-    (do
-      (assert= 42 (match 42 (x x)))))
-  (deftest
-    "match no matching clause raises error"
-    (do
-      (define-type AB (A-val) (B-val))
-      (let ((ok false))
-        (guard (exn (else (set! ok true)))
-          (match (A-val) ((B-val) "b")))
-        (assert ok))))
-  (deftest
-    "match result used in further computation"
-    (do
-      (define-type Num2 (N v))
-      (assert= 30
-        (+
-          (match (N 10) ((N v) v))
-          (match (N 20) ((N v) v))))))
-  (deftest
-    "match with define"
-    (do
-      (define-type Tag (Tagged label value))
-      (define get-label (fn (t) (match t ((Tagged lbl _) lbl))))
-      (define get-value (fn (t) (match t ((Tagged _ val) val))))
-      (let ((t (Tagged "name" 99)))
-        (assert= "name" (get-label t))
-        (assert= 99 (get-value t)))))
-  (deftest
-    "match three-field constructor"
-    (do
-      (define-type Triple2 (T3 a b c))
-      (assert= 6 (match (T3 1 2 3) ((T3 a b c) (+ a b c))))))
-  (deftest
-    "match clauses tried in order"
-    (do
-      (define-type Expr2 (Lit n) (Add l r) (Mul l r))
-      (define eval-expr2 (fn (e)
-        (match e
-          ((Lit n) n)
-          ((Add l r) (+ (eval-expr2 l) (eval-expr2 r)))
-          ((Mul l r) (* (eval-expr2 l) (eval-expr2 r))))))
-      (assert= 7 (eval-expr2 (Add (Lit 3) (Lit 4))))
-      (assert= 12 (eval-expr2 (Mul (Lit 3) (Lit 4))))
-      (assert= 11 (eval-expr2 (Add (Lit 2) (Mul (Lit 3) (Lit 3)))))))
-  (deftest
-    "match else binding captures value"
-    (do
-      (define-type Coin2 (Heads2) (Tails2))
-      (assert= "Tails2" (match (Tails2) ((Heads2) "Heads2") (x (get x :_ctor))))))
-  (deftest
-    "match on adt with string field"
-    (do
-      (define-type Msg (Hello name) (Bye name))
-      (assert= "Hello, Alice" (match (Hello "Alice") ((Hello n) (str "Hello, " n)) ((Bye n) (str "Bye, " n))))
-      (assert= "Bye, Bob" (match (Bye "Bob") ((Hello n) (str "Hello, " n)) ((Bye n) (str "Bye, " n))))))
-  (deftest
-    "match nested pattern with variable binding"
-    (do
-      (define-type Box2 (Box2-of v))
-      (define-type Inner (Inner-of n))
-      (assert= 5 (match (Box2-of (Inner-of 5)) ((Box2-of (Inner-of n)) n)))))
-)
--- a/Show More
+++ b/Show More