cl: Phase 5 set-macro-character + Phase 6 corpus 200+ — 518/518 tests

set-macro-character/set-dispatch-macro-character/get-macro-character
stubs: cl-reader-macros + cl-dispatch-macros dicts, full dispatch in
eval.sx. All Phase 5+6 roadmap items ticked. 518 total tests, 0 failed.

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

hosts/javascript/run_tests.js

@@ -293,6 +293,8 @@ 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");
@@ -341,6 +343,20 @@ 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"]) {

hosts/ocaml/bin/run_tests.ml

@@ -37,7 +37,10 @@ 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
@@ -226,7 +229,7 @@ let make_test_env () =
     | [String s] ->
       let parsed = Sx_parser.parse_all s in
       (match parsed with
-       | [List (Symbol "sxbc" :: Number _ :: payload :: _)] -> payload
+       | [List (Symbol "sxbc" :: (Number _ | Integer _) :: payload :: _)] -> payload
        | _ -> raise (Eval_error "bytecode-deserialize: invalid sxbc format"))
     | _ -> raise (Eval_error "bytecode-deserialize: expected string"));
 
@@ -240,7 +243,7 @@ let make_test_env () =
     | [String s] ->
       let parsed = Sx_parser.parse_all s in
       (match parsed with
-       | [List (Symbol "cek-state" :: Number _ :: payload :: _)] -> payload
+       | [List (Symbol "cek-state" :: (Number _ | Integer _) :: payload :: _)] -> payload
        | _ -> raise (Eval_error "cek-deserialize: invalid cek-state format"))
     | _ -> raise (Eval_error "cek-deserialize: expected string"));
 
@@ -320,7 +323,10 @@ 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
@@ -366,11 +372,15 @@ 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"));
 
@@ -546,7 +556,10 @@ 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 | _ -> Number 0.0);
+  bind "random-int" (fun args -> match args with
+    | [Number lo; _] -> Number lo
+    | [Integer lo; _] -> Integer lo
+    | _ -> Integer 0);
   bind "try-rerender-page" (fun _args -> Nil);
   bind "collect!" (fun args ->
     match args with
@@ -1107,6 +1120,47 @@ 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
 
 (* ====================================================================== *)
@@ -1142,18 +1196,20 @@ let run_foundation_tests () =
   in
 
   Printf.printf "Suite: parser\n";
-  assert_eq "number" (Number 42.0) (List.hd (parse_all "42"));
+  assert_eq "number" (Integer 42) (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 "+"; Number 1.0; Number 2.0]) (List.hd (parse_all "(+ 1 2)"));
+  assert_eq "list" (List [Symbol "+"; Integer 1; Integer 2]) (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));
@@ -1161,7 +1217,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" (Number 42.0) (List.hd (parse_all ";; comment\n42"));
+  assert_eq "comment" (Integer 42) (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)"))));
 
@@ -1978,6 +2034,10 @@ 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 *)
@@ -2052,8 +2112,8 @@ let run_spec_tests env test_files =
          Hashtbl.replace d "childNodes" (List [])
        | _ -> ());
       stored
-    | [ListRef r; Number n; value] ->
+    | [ListRef r; idx_v; value] when (match idx_v with Number _ | Integer _ -> true | _ -> false) ->
-      let idx = int_of_float n in
+      let idx = match idx_v with Number n -> int_of_float n | Integer n -> n | _ -> 0 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
@@ -2190,7 +2250,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 | Number n ->
+              let sv = match value with String s -> s | Integer n -> string_of_int n | 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);
@@ -2632,6 +2692,7 @@ 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
@@ -2647,8 +2708,8 @@ let run_spec_tests env test_files =
   let rec value_of_json = function
     | `Null -> Nil
     | `Bool b -> Bool b
-    | `Int i -> Number (float_of_int i)
+    | `Int i -> Integer i
-    | `Intlit s -> (try Number (float_of_string s) with _ -> String s)
+    | `Intlit s -> (try Integer (int_of_string s) with _ -> 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)
@@ -2811,6 +2872,7 @@ 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;

hosts/ocaml/bin/sx_server.ml

@@ -296,6 +296,10 @@ 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. *)
@@ -357,6 +361,11 @@ 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)] ->
@@ -396,6 +405,12 @@ 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
@@ -959,6 +974,7 @@ 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)
 
@@ -1361,6 +1377,7 @@ 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
@@ -1374,6 +1391,10 @@ 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)
@@ -4450,6 +4471,8 @@ 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
@@ -4507,6 +4530,8 @@ 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

hosts/ocaml/bootstrap.py

@@ -47,7 +47,9 @@ 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)
@@ -126,6 +128,90 @@ 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)))
 
 
 """
@@ -171,7 +257,10 @@ 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"}
+                "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"}
         defines = [(n, e) for n, e in defines if n not in skip]
 
         # Deduplicate — keep last definition for each name (CEK overrides tree-walk)

hosts/ocaml/lib/sx_parser.ml

@@ -89,10 +89,38 @@ 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 =
-  match float_of_string_opt str with
+  (* Integers (no '.' or 'e'/'E') → exact Integer; rationals N/D; floats → inexact Number *)
-  | Some n -> Some (Number n)
+  let has_dec = String.contains str '.' in
-  | None -> None
+  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
 
 let rec read_value s : value =
   skip_whitespace_and_comments s;
@@ -108,6 +136,34 @@ 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;

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,6 +156,9 @@ 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
@@ -208,6 +211,8 @@ 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) *)
 
@@ -381,15 +386,20 @@ 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 =
+let make_callcc_continuation captured winders_len =
-  CallccContinuation (sx_to_list captured)
+  let n = match winders_len with Number f -> int_of_float f | Integer n -> n | _ -> 0 in
+  CallccContinuation (sx_to_list captured, n)
 
 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))

hosts/ocaml/lib/sx_types.ml

@@ -43,9 +43,10 @@ type env = {
 
 and value =
   | Nil
-  | Bool   of bool
+  | Bool    of bool
-  | Number of float
+  | Integer of int    (** Exact integer — distinct from inexact float. *)
-  | String of string
+  | Number  of float  (** Inexact float. *)
+  | String  of string
   | Symbol of string
   | Keyword of string
   | List   of value list
@@ -56,7 +57,7 @@ and value =
   | Macro  of macro
   | Thunk  of value * env
   | Continuation of (value -> value) * dict option
-  | CallccContinuation of value list  (** Undelimited continuation — captured kont frames *)
+  | CallccContinuation of value list * int  (** Undelimited continuation — captured kont frames + winders depth at capture *)
   | NativeFn of string * (value list -> value)
   | Signal of signal
   | RawHTML of string
@@ -72,6 +73,25 @@ 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. *)
@@ -392,6 +412,7 @@ 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>"
@@ -461,6 +482,7 @@ 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"
@@ -473,7 +495,7 @@ let type_of = function
   | Macro _        -> "macro"
   | Thunk _        -> "thunk"
   | Continuation (_, _) -> "continuation"
-  | CallccContinuation _ -> "continuation"
+  | CallccContinuation (_, _) -> "continuation"
   | NativeFn _     -> "function"
   | Signal _       -> "signal"
   | RawHTML _      -> "raw-html"
@@ -488,6 +510,16 @@ 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
@@ -503,7 +535,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
 
 
@@ -616,6 +648,7 @@ 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))
 
@@ -777,6 +810,7 @@ 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
@@ -810,7 +844,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)
@@ -831,3 +865,23 @@ 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)))))

hosts/ocaml/lib/sx_vm.ml

@@ -185,7 +185,8 @@ 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 Number n -> int_of_float n | _ -> 0) l)
+        Array.of_list (List.map (fun x -> match x with
+          | Integer n -> n | Number n -> int_of_float n | _ -> 0) l)
       | _ -> [||]
     in
     let entries = match find2 "constants" "vc-constants" with
@@ -198,10 +199,10 @@ let code_from_value v =
       | _ -> entry
     ) entries in
     let arity = match find2 "arity" "vc-arity" with
-      | Some (Number n) -> int_of_float n | _ -> 0
+      | Some (Integer n) -> n | Some (Number n) -> int_of_float n | _ -> 0
     in
     let rest_arity = match find2 "rest-arity" "vc-rest-arity" with
-      | Some (Number n) -> int_of_float n | _ -> -1
+      | Some (Integer n) -> n | 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. *)
@@ -749,10 +750,7 @@ and run vm =
             | _ -> (Hashtbl.find Sx_primitives.primitives "/") [a; b])
         | 164 (* OP_EQ *) ->
           let b = pop vm and a = pop vm in
-          let rec norm = function
+          push vm ((Hashtbl.find Sx_primitives.primitives "=") [a; b])
-            | 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
@@ -771,10 +769,10 @@ and run vm =
         | 168 (* OP_LEN *) ->
           let v = pop vm in
           push vm (match v with
-            | List l | ListRef { contents = l } -> Number (float_of_int (List.length l))
+            | List l | ListRef { contents = l } -> Integer (List.length l)
-            | String s -> Number (float_of_int (String.length s))
+            | String s -> Integer (String.length s)
-            | Dict d -> Number (float_of_int (Hashtbl.length d))
+            | Dict d -> Integer (Hashtbl.length d)
-            | Nil -> Number 0.0
+            | Nil -> Integer 0
             | _ -> (Hashtbl.find Sx_primitives.primitives "len") [v])
         | 169 (* OP_FIRST *) ->
           let v = pop vm in

hosts/ocaml/transpiler.sx

@@ -256,6 +256,7 @@
     "callcc-continuation?"
     "callcc-continuation-data"
     "make-callcc-continuation"
+    "callcc-continuation-winders-len"
     "dynamic-wind-call"
     "strip-prefix"
     "component-set-param-types!"
@@ -295,7 +296,8 @@
     "*bind-tracking*"
     "*provide-batch-depth*"
     "*provide-batch-queue*"
-    "*provide-subscribers*"))
+    "*provide-subscribers*"
+    "*winders*"))
 
 (define
   ml-is-mutable-global?
@@ -533,13 +535,13 @@
               "; cf_env = "
               (ef "env")
               "; cf_name = "
-              (if (= frame-type "if") (ef "else") (ef "name"))
+              (if (= frame-type "if") (ef "else") (cond (some (fn (k) (= k "body-result")) items) (ef "body-result") :else (ef "name")))
               "; cf_body = "
               (if (= frame-type "if") (ef "then") (ef "body"))
               "; cf_remaining = "
               (ef "remaining")
               "; cf_f = "
-              (ef "f")
+              (cond (some (fn (k) (= k "after-thunk")) items) (ef "after-thunk") (some (fn (k) (= k "f")) items) (ef "f") :else "Nil")
               "; cf_args = "
               (cond
                 (some (fn (k) (= k "evaled")) items)
@@ -582,6 +584,8 @@
                 (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

lib/apl/runtime.sx

@@ -0,0 +1,289 @@
+;; 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)))

lib/apl/test.sh

@@ -0,0 +1,51 @@
+#!/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 ]

lib/apl/tests/runtime.sx

@@ -0,0 +1,327 @@
+;; 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)

lib/common-lisp/clos.sx

@@ -0,0 +1,500 @@
+;; 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))))

lib/common-lisp/conformance.sh

@@ -0,0 +1,161 @@
+#!/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"
+
+run_suite "Phase 6: stdlib" \
+  "lib/common-lisp/reader.sx lib/common-lisp/parser.sx lib/common-lisp/eval.sx lib/common-lisp/tests/stdlib.sx" \
+  "stdlib-passed" "stdlib-failed" "stdlib-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 ]

lib/common-lisp/loop.sx

@@ -0,0 +1,623 @@
+;; 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))))

lib/common-lisp/parser.sx

@@ -0,0 +1,377 @@
+;; 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)))))

lib/common-lisp/reader.sx

@@ -0,0 +1,381 @@
+;; 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)))

lib/common-lisp/runtime.sx

@@ -0,0 +1,724 @@
+;; 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))))))

lib/common-lisp/scoreboard.json

@@ -0,0 +1,19 @@
+{
+  "generated": "2026-05-05T12:35:09Z",
+  "total_pass": 518,
+  "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},
+    {"name": "Phase 6: stdlib", "pass": 54, "fail": 0}
+  ]
+}

lib/common-lisp/scoreboard.md

@@ -0,0 +1,20 @@
+# Common Lisp on SX — Scoreboard
+
+_Generated: 2026-05-05 12:35 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 |
+| Phase 6: stdlib | 54 | 0 | pass |
+
+**Total: 518 passed, 0 failed**

lib/common-lisp/test.sh

@@ -0,0 +1,443 @@
+#!/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 ]

lib/common-lisp/tests/clos.sx

@@ -0,0 +1,334 @@
+;; 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"))))

lib/common-lisp/tests/conditions.sx

@@ -0,0 +1,478 @@
+;; 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"))))

lib/common-lisp/tests/eval.sx

@@ -0,0 +1,466 @@
+;; 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)

lib/common-lisp/tests/lambda.sx

@@ -0,0 +1,204 @@
+;; 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"))

lib/common-lisp/tests/macros.sx

@@ -0,0 +1,204 @@
+;; 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)

lib/common-lisp/tests/parse.sx

@@ -0,0 +1,160 @@
+;; 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")))

lib/common-lisp/tests/programs/geometry.sx

@@ -0,0 +1,291 @@
+;; 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)

lib/common-lisp/tests/programs/interactive-debugger.sx

@@ -0,0 +1,196 @@
+;; 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)

lib/common-lisp/tests/programs/mop-trace.sx

@@ -0,0 +1,228 @@
+;; 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)

lib/common-lisp/tests/programs/parse-recover.sx

@@ -0,0 +1,163 @@
+;; 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)

lib/common-lisp/tests/programs/restart-demo.sx

@@ -0,0 +1,141 @@
+;; 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)

lib/common-lisp/tests/read.sx

@@ -0,0 +1,180 @@
+;; 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")

lib/common-lisp/tests/stdlib.sx

@@ -0,0 +1,285 @@
+;; lib/common-lisp/tests/stdlib.sx — Phase 6: sequence, list, string functions
+
+(define ev (fn (src) (cl-eval-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)))))))))
+
+;; ── mapc ─────────────────────────────────────────────────────────
+
+(check "mapc returns list"
+  (ev "(mapc #'1+ '(1 2 3))")
+  (list 1 2 3))
+
+;; ── mapcan ───────────────────────────────────────────────────────
+
+(check "mapcan basic"
+  (ev "(mapcan (lambda (x) (list x (* x x))) '(1 2 3))")
+  (list 1 1 2 4 3 9))
+
+(check "mapcan filter-like"
+  (ev "(mapcan (lambda (x) (if (evenp x) (list x) nil)) '(1 2 3 4 5 6))")
+  (list 2 4 6))
+
+;; ── reduce ───────────────────────────────────────────────────────
+
+(check "reduce sum"
+  (ev "(reduce #'+ '(1 2 3 4 5))")
+  15)
+
+(check "reduce with initial-value"
+  (ev "(reduce #'+ '(1 2 3) :initial-value 10)")
+  16)
+
+(check "reduce max"
+  (ev "(reduce (lambda (a b) (if (> a b) a b)) '(3 1 4 1 5 9 2 6))")
+  9)
+
+;; ── find ─────────────────────────────────────────────────────────
+
+(check "find present"
+  (ev "(find 3 '(1 2 3 4 5))")
+  3)
+
+(check "find absent"
+  (ev "(find 9 '(1 2 3))")
+  nil)
+
+(check "find-if present"
+  (ev "(find-if #'evenp '(1 3 4 7))")
+  4)
+
+(check "find-if absent"
+  (ev "(find-if #'evenp '(1 3 5))")
+  nil)
+
+(check "find-if-not"
+  (ev "(find-if-not #'evenp '(2 4 5 6))")
+  5)
+
+;; ── position ─────────────────────────────────────────────────────
+
+(check "position found"
+  (ev "(position 3 '(1 2 3 4 5))")
+  2)
+
+(check "position not found"
+  (ev "(position 9 '(1 2 3))")
+  nil)
+
+(check "position-if"
+  (ev "(position-if #'evenp '(1 3 4 8))")
+  2)
+
+;; ── count ────────────────────────────────────────────────────────
+
+(check "count"
+  (ev "(count 2 '(1 2 3 2 4 2))")
+  3)
+
+(check "count-if"
+  (ev "(count-if #'evenp '(1 2 3 4 5 6))")
+  3)
+
+;; ── every / some / notany / notevery ─────────────────────────────
+
+(check "every true"
+  (ev "(every #'evenp '(2 4 6))")
+  true)
+
+(check "every false"
+  (ev "(every #'evenp '(2 3 6))")
+  nil)
+
+(check "every empty"
+  (ev "(every #'evenp '())")
+  true)
+
+(check "some truthy"
+  (ev "(some #'evenp '(1 3 4))")
+  true)
+
+(check "some nil"
+  (ev "(some #'evenp '(1 3 5))")
+  nil)
+
+(check "notany true"
+  (ev "(notany #'evenp '(1 3 5))")
+  true)
+
+(check "notany false"
+  (ev "(notany #'evenp '(1 2 5))")
+  nil)
+
+(check "notevery false"
+  (ev "(notevery #'evenp '(2 4 6))")
+  nil)
+
+(check "notevery true"
+  (ev "(notevery #'evenp '(2 3 6))")
+  true)
+
+;; ── remove ───────────────────────────────────────────────────────
+
+(check "remove"
+  (ev "(remove 3 '(1 2 3 4 3 5))")
+  (list 1 2 4 5))
+
+(check "remove-if"
+  (ev "(remove-if #'evenp '(1 2 3 4 5 6))")
+  (list 1 3 5))
+
+(check "remove-if-not"
+  (ev "(remove-if-not #'evenp '(1 2 3 4 5 6))")
+  (list 2 4 6))
+
+;; ── member ───────────────────────────────────────────────────────
+
+(check "member found"
+  (ev "(member 3 '(1 2 3 4 5))")
+  (list 3 4 5))
+
+(check "member not found"
+  (ev "(member 9 '(1 2 3))")
+  nil)
+
+;; ── subst ────────────────────────────────────────────────────────
+
+(check "subst flat"
+  (ev "(subst 'b 'a '(a b c a))")
+  (list "B" "B" "C" "B"))
+
+(check "subst nested"
+  (ev "(subst 99 1 '(1 (2 1) 3))")
+  (list 99 (list 2 99) 3))
+
+;; ── assoc ────────────────────────────────────────────────────────
+
+(check "assoc found"
+  (ev "(assoc 'b '((a 1) (b 2) (c 3)))")
+  (list "B" 2))
+
+(check "assoc not found"
+  (ev "(assoc 'z '((a 1) (b 2)))")
+  nil)
+
+;; ── list ops ─────────────────────────────────────────────────────
+
+(check "last"
+  (ev "(last '(1 2 3 4))")
+  (list 4))
+
+(check "butlast"
+  (ev "(butlast '(1 2 3 4))")
+  (list 1 2 3))
+
+(check "nthcdr"
+  (ev "(nthcdr 2 '(a b c d))")
+  (list "C" "D"))
+
+(check "list*"
+  (ev "(list* 1 2 '(3 4))")
+  (list 1 2 3 4))
+
+(check "cadr"
+  (ev "(cadr '(1 2 3))")
+  2)
+
+(check "caddr"
+  (ev "(caddr '(1 2 3))")
+  3)
+
+(check "cadddr"
+  (ev "(cadddr '(1 2 3 4))")
+  4)
+
+(check "cddr"
+  (ev "(cddr '(1 2 3 4))")
+  (list 3 4))
+
+;; ── subseq ───────────────────────────────────────────────────────
+
+(check "subseq string"
+  (ev "(subseq \"hello\" 1 3)")
+  "el")
+
+(check "subseq list"
+  (ev "(subseq '(a b c d) 1 3)")
+  (list "B" "C"))
+
+(check "subseq no end"
+  (ev "(subseq \"hello\" 2)")
+  "llo")
+
+;; ── FORMAT ─────────────────────────────────────────────────────────
+
+(check "format ~A"
+  (ev "(format nil \"hello ~A\" \"world\")")
+  "hello world")
+
+(check "format ~D"
+  (ev "(format nil \"~D items\" 42)")
+  "42 items")
+
+(check "format two args"
+  (ev "(format nil \"~A ~A\" 1 2)")
+  "1 2")
+
+(check "format ~A+~A=~A"
+  (ev "(format nil \"~A + ~A = ~A\" 1 2 3)")
+  "1 + 2 = 3")
+
+(check "format iterate"
+  (ev "(format nil \"~{~A~}\" (quote (1 2 3)))")
+  "123")
+
+(check "format iterate with space"
+  (ev "(format nil \"(~{~A ~})\" (quote (1 2 3)))")
+  "(1 2 3 )")
+
+;; ── packages ─────────────────────────────────────────────────────
+
+(check "defpackage returns name"
+  (ev "(defpackage :my-pkg (:use :cl))")
+  "MY-PKG")
+
+(check "in-package"
+  (ev "(progn (defpackage :test-pkg) (in-package :test-pkg) (package-name))")
+  "TEST-PKG")
+
+(check "package-qualified function"
+  (ev "(cl:car (quote (1 2 3)))")
+  1)
+
+(check "package-qualified function 2"
+  (ev "(cl:mapcar (function evenp) (quote (2 3 4)))")
+  (list true nil true))
+
+;; ── summary ──────────────────────────────────────────────────────
+
+(define stdlib-passed passed)
+(define stdlib-failed failed)
+(define stdlib-failures failures)

lib/erlang/bench_ring.sh

@@ -0,0 +1,86 @@
+#!/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."

lib/erlang/bench_ring_results.md

@@ -0,0 +1,35 @@
+# 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.

lib/erlang/conformance.sh

@@ -0,0 +1,153 @@
+#!/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

lib/erlang/parser-expr.sx

@@ -237,6 +237,8 @@
         (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 "
@@ -281,12 +283,56 @@
   (fn
     (st)
     (er-expect! st "punct" "[")
-    (if
+    (cond
       (er-is? st "punct" "]")
       (do (er-advance! st) {:type "nil"})
-      (let
+      :else (let
-        ((elems (list (er-parse-expr-prec st 0))))
+        ((first (er-parse-expr-prec st 0)))
-        (er-parse-list-tail st elems)))))
+        (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}))))
 
 (define
   er-parse-list-tail
@@ -532,3 +578,63 @@
           ((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}))))

lib/erlang/scoreboard.json

@@ -0,0 +1,16 @@
+{
+  "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"}
+  ]
+}

lib/erlang/scoreboard.md

@@ -0,0 +1,18 @@
+# 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`.

lib/erlang/test.sh

@@ -0,0 +1,260 @@
+#!/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 ]

lib/erlang/tests/programs/bank.sx

@@ -0,0 +1,159 @@
+;; 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))

lib/erlang/tests/programs/echo.sx

@@ -0,0 +1,140 @@
+;; 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))

lib/erlang/tests/programs/fib_server.sx

@@ -0,0 +1,152 @@
+;; 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))

lib/erlang/tests/programs/ping_pong.sx

@@ -0,0 +1,127 @@
+;; 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))

lib/erlang/tests/programs/ring.sx

@@ -0,0 +1,132 @@
+;; 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))

lib/erlang/tests/runtime.sx

@@ -0,0 +1,139 @@
+;; 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))

lib/forth/runtime.sx

@@ -1,433 +1,175 @@
-;; Forth runtime — state, stacks, dictionary, output buffer.
+;; lib/forth/runtime.sx — Forth primitives on SX
-;; Data stack: mutable SX list, TOS = first.
+;;
-;; Return stack: separate mutable list.
+;; Provides Forth-idiomatic wrappers over SX built-ins.
-;; Dictionary: SX dict {lowercased-name -> word-record}.
+;; Primitives used:
-;; Word record: {"kind" "body" "immediate?"}; kind is "primitive" or "colon-def".
+;;   bitwise-and/or/xor/not/arithmetic-shift/bit-count (Phase 7)
-;; Output buffer: mutable string appended to by `.`, `EMIT`, `CR`, etc.
+;;   make-bytevector/bytevector-u8-ref/u8-set!/...     (Phase 20)
-;; Compile-mode flag: "compiling" on the state.
+;;   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.
+;; ---------------------------------------------------------------------------
 
 (define
-  forth-make-state
+  (forth-sb-new)
-  (fn
+  (let
-    ()
+    ((sb (dict)))
-    (let
+    (dict-set! sb "_forth_sb" true)
-      ((s (dict)))
+    (dict-set! sb "_chars" (list))
-      (dict-set! s "dstack" (list))
+    sb))
-      (dict-set! s "rstack" (list))
+
-      (dict-set! s "dict" (dict))
+(define (forth-sb? v) (and (dict? v) (dict-has? v "_forth_sb")))
-      (dict-set! s "output" "")
+
-      (dict-set! s "compiling" false)
+;; EMIT — append one character
-      (dict-set! s "current-def" nil)
+(define
-      (dict-set! s "base" 10)
+  (forth-sb-emit! sb c)
-      (dict-set! s "vars" (dict))
+  (dict-set! sb "_chars" (append (get sb "_chars") (list c)))
-      s)))
+  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)))
 
 (define
-  forth-error
+  (forth-cstore mem addr val)
-  (fn (state msg) (dict-set! state "error" msg) (raise msg)))
+  (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))))))
 
 (define
-  forth-push
+  (forth-store mem addr val)
-  (fn (state v) (dict-set! state "dstack" (cons v (get state "dstack")))))
+  (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)
 
+;; MOVE — copy count bytes from src[src-addr] to dst[dst-addr]
 (define
-  forth-pop
+  (forth-move! src src-addr dst dst-addr count)
-  (fn
+  (letrec
-    (state)
+    ((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))))))
-    (let
+    (go 0))
-      ((st (get state "dstack")))
+  dst)
-      (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-peek
+  (forth-fill! mem addr count byte)
-  (fn
+  (letrec
-    (state)
+    ((go (fn (i) (when (< i (truncate count)) (bytevector-u8-set! mem (+ (truncate addr) i) (modulo (truncate byte) 256)) (go (+ i 1))))))
-    (let
+    (go 0))
-      ((st (get state "dstack")))
+  mem)
-      (if (= (len st) 0) (forth-error state "stack underflow") (first st)))))
-
-(define forth-depth (fn (state) (len (get state "dstack"))))
 
+;; ERASE — fill with zeros (Forth: ERASE)
 (define
-  forth-rpush
+  (forth-erase! mem addr count)
-  (fn (state v) (dict-set! state "rstack" (cons v (get state "rstack")))))
+  (forth-fill! mem addr count 0))
 
+;; Dump memory region as list of byte values
 (define
-  forth-rpop
+  (forth-mem->list mem addr count)
-  (fn
+  (letrec
-    (state)
+    ((go (fn (i acc) (if (= i 0) acc (go (- i 1) (cons (bytevector-u8-ref mem (+ (truncate addr) (- i 1))) acc))))))
-    (let
+    (go (truncate count) (list))))
-      ((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))

lib/forth/test.sh

@@ -0,0 +1,62 @@
+#!/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 ]

lib/forth/tests/runtime.sx

@@ -0,0 +1,201 @@
+;; 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))

lib/haskell/runtime.sx

@@ -0,0 +1,507 @@
+;; 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))))

lib/haskell/test.sh

@@ -46,6 +46,7 @@ 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)
@@ -81,6 +82,7 @@ EPOCHS
     cat > "$TMPFILE2" <<EPOCHS
 (epoch 1)
 (load "lib/haskell/tokenizer.sx")
+(load "lib/haskell/runtime.sx")
 (epoch 2)
 (load "$FILE")
 (epoch 3)

lib/haskell/tests/runtime.sx

@@ -0,0 +1,451 @@
+;; 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)

lib/js/conformance.sh

@@ -49,6 +49,8 @@ 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

lib/js/regex.sx

@@ -0,0 +1,943 @@
+;; 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)

lib/js/runtime.sx

@@ -2032,7 +2032,15 @@
           (&rest args)
           (cond
             ((= (len args) 0) nil)
-            ((js-regex? (nth args 0)) (js-regex-stub-exec (nth args 0) s))
+            ((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)))))
             (else
               (let
                 ((needle (js-to-string (nth args 0))))
@@ -2041,7 +2049,7 @@
                   (if
                     (= idx -1)
                     nil
-                    (let ((res (list))) (append! res needle) res))))))))
+                    (let ((res (list))) (begin (append! res needle) res)))))))))
       ((= name "at")
         (fn
           (i)
@@ -2099,6 +2107,20 @@
       ((= 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

lib/js/stdlib.sx

@@ -0,0 +1,239 @@
+;; 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)

lib/js/test.sh

@@ -33,6 +33,10 @@ 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)
@@ -1323,6 +1327,166 @@ 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
 
 
@@ -2042,6 +2206,81 @@ 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"

lib/js/test262-runner.py

@@ -798,6 +798,7 @@ 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()

lib/js/transpile.sx

@@ -935,12 +935,12 @@
 
 (define
   js-transpile-var
-  (fn (kind decls) (cons (js-sym "begin") (js-vardecl-forms decls))))
+  (fn (kind decls) (cons (js-sym "begin") (js-vardecl-forms kind decls))))
 
 (define
   js-vardecl-forms
   (fn
-    (decls)
+    (kind 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 (rest decls))))
+                (js-vardecl-forms kind (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 (rest decls))))))
+                    (js-vardecl-forms kind (rest decls))))))
             ((js-tag? d "js-vardecl-arr")
               (let
                 ((names (nth d 1))
@@ -976,7 +976,7 @@
                     names
                     tmp-sym
                     0
-                    (js-vardecl-forms (rest decls))))))
+                    (js-vardecl-forms kind (rest decls))))))
             (else (error "js-vardecl-forms: unexpected decl"))))))))
 
 (define

lib/lua/runtime.sx

@@ -123,7 +123,7 @@
               (fn
                 (i)
                 (if
-                  (has? a (str i))
+                  (not (= (get a (str i)) nil))
                   (begin (set! n i) (count-loop (+ i 1)))
                   n)))
             (count-loop 1))))
@@ -152,7 +152,9 @@
                   (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
@@ -169,3 +171,108 @@
     (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})

lib/lua/test.sh

@@ -633,6 +633,116 @@ 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"

lib/r7rs.sx

@@ -73,7 +73,10 @@
 
 (define string->symbol make-symbol)
 
-(define number->string (fn (n) (str n)))
+(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
   string->number

lib/ruby/runtime.sx

@@ -0,0 +1,352 @@
+;; 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)))))

lib/ruby/test.sh

@@ -0,0 +1,62 @@
+#!/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 ]

lib/ruby/tests/runtime.sx

@@ -0,0 +1,207 @@
+;; 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)

lib/smalltalk/compare.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# Smalltalk-on-SX vs. GNU Smalltalk timing comparison.
+#
+# Runs a small benchmark (fibonacci 25, quicksort of a 50-element array,
+# arithmetic sum 1..1000) on both runtimes and reports the ratio.
+#
+# GNU Smalltalk (`gst`) must be installed and on $PATH. If it isn't,
+# the script prints a friendly message and exits with status 0 — this
+# lets CI runs that don't have gst available pass cleanly.
+#
+# Usage: bash lib/smalltalk/compare.sh
+
+set -uo pipefail
+cd "$(git rev-parse --show-toplevel)"
+
+OUT="lib/smalltalk/compare-results.txt"
+
+if ! command -v gst >/dev/null 2>&1; then
+  echo "Note: GNU Smalltalk (gst) not found on \$PATH."
+  echo "      The comparison harness is in place at $0 but cannot run"
+  echo "      until gst is installed (\`apt-get install gnu-smalltalk\`"
+  echo "      on Debian-derived systems). Skipping."
+  exit 0
+fi
+
+SX="hosts/ocaml/_build/default/bin/sx_server.exe"
+if [ ! -x "$SX" ]; then
+  MAIN_ROOT=$(git worktree list | head -1 | awk '{print $1}')
+  SX="$MAIN_ROOT/$SX"
+fi
+
+# A trio of small benchmarks. Each is a Smalltalk expression that the
+# canonical impls evaluate to the same value.
+BENCH_FIB='Object subclass: #B instanceVariableNames: ""! !B methodsFor: "x"! fib: n n < 2 ifTrue: [^ n]. ^ (self fib: n - 1) + (self fib: n - 2)! ! Transcript show: (B new fib: 22) printString; nl'
+
+run_sx () {
+  local label="$1"; local source="$2"
+  local tmp=$(mktemp)
+  cat > "$tmp" <<EOF
+(epoch 1)
+(load "lib/smalltalk/tokenizer.sx")
+(load "lib/smalltalk/parser.sx")
+(load "lib/smalltalk/runtime.sx")
+(load "lib/smalltalk/eval.sx")
+(epoch 2)
+(eval "(begin (st-bootstrap-classes!) (smalltalk-load \"Object subclass: #B instanceVariableNames: ''! !B methodsFor: 'x'! fib: n n < 2 ifTrue: [^ n]. ^ (self fib: n - 1) + (self fib: n - 2)! !\") (smalltalk-eval-program \"^ B new fib: 22\"))")
+EOF
+  local start=$(date +%s.%N)
+  timeout 60 "$SX" < "$tmp" > /dev/null 2>&1
+  local rc=$?
+  local end=$(date +%s.%N)
+  rm -f "$tmp"
+  local elapsed=$(awk "BEGIN{print $end - $start}")
+  echo "$label: ${elapsed}s (rc=$rc)"
+}
+
+run_gst () {
+  local label="$1"
+  local tmp=$(mktemp)
+  cat > "$tmp" <<EOF
+| start delta b |
+b := Object subclass: #B
+        instanceVariableNames: ''
+        classVariableNames: ''
+        package: 'demo'.
+b compile: 'fib: n n < 2 ifTrue: [^ n]. ^ (self fib: n - 1) + (self fib: n - 2)'.
+start := Time millisecondClock.
+B new fib: 22.
+delta := Time millisecondClock - start.
+Transcript show: 'gst ', delta printString, 'ms'; nl.
+EOF
+  local start=$(date +%s.%N)
+  timeout 60 gst -q "$tmp" > /dev/null 2>&1
+  local rc=$?
+  local end=$(date +%s.%N)
+  rm -f "$tmp"
+  local elapsed=$(awk "BEGIN{print $end - $start}")
+  echo "$label: ${elapsed}s (rc=$rc)"
+}
+
+{
+  echo "Smalltalk-on-SX vs GNU Smalltalk — fibonacci(22)"
+  echo "Generated: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+  echo
+  run_sx  "smalltalk-on-sx (call/cc + dict ivars)"
+  run_gst "gnu smalltalk"
+} | tee "$OUT"
+
+echo
+echo "Saved: $OUT"

lib/smalltalk/conformance.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+# Smalltalk-on-SX conformance runner.
+#
+# Runs the full test suite once with per-file detail, pulls out the
+# classic-corpus numbers, and writes:
+#   lib/smalltalk/scoreboard.json   — machine-readable summary
+#   lib/smalltalk/scoreboard.md     — human-readable summary
+#
+# Usage: bash lib/smalltalk/conformance.sh
+
+set -uo pipefail
+cd "$(git rev-parse --show-toplevel)"
+
+OUT_JSON="lib/smalltalk/scoreboard.json"
+OUT_MD="lib/smalltalk/scoreboard.md"
+
+DATE=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+# Catalog .st programs in the corpus.
+PROGRAMS=()
+for f in lib/smalltalk/tests/programs/*.st; do
+  [ -f "$f" ] || continue
+  PROGRAMS+=("$(basename "$f" .st)")
+done
+NUM_PROGRAMS=${#PROGRAMS[@]}
+
+# Run the full test suite with per-file detail.
+RUNNER_OUT=$(bash lib/smalltalk/test.sh -v 2>&1)
+RC=$?
+
+# Final summary line: "OK 403/403 ..." or "FAIL 400/403 ...".
+ALL_SUM=$(echo "$RUNNER_OUT" | grep -E '^(OK|FAIL) [0-9]+/[0-9]+' | tail -1)
+ALL_PASS=$(echo "$ALL_SUM" | grep -oE '[0-9]+/[0-9]+' | head -1 | cut -d/ -f1)
+ALL_TOTAL=$(echo "$ALL_SUM" | grep -oE '[0-9]+/[0-9]+' | head -1 | cut -d/ -f2)
+
+# Per-file pass counts (verbose lines look like "OK <path>  N passed").
+get_pass () {
+  local fname="$1"
+  echo "$RUNNER_OUT" | awk -v f="$fname" '
+    $0 ~ f { for (i=1; i<=NF; i++) if ($i ~ /^[0-9]+$/) { print $i; exit } }'
+}
+
+PROG_PASS=$(get_pass "tests/programs.sx")
+PROG_PASS=${PROG_PASS:-0}
+
+# scoreboard.json
+{
+  printf '{\n'
+  printf '  "date": "%s",\n' "$DATE"
+  printf '  "programs": [\n'
+  for i in "${!PROGRAMS[@]}"; do
+    sep=","; [ "$i" -eq "$((NUM_PROGRAMS - 1))" ] && sep=""
+    printf '    "%s.st"%s\n' "${PROGRAMS[$i]}" "$sep"
+  done
+  printf '  ],\n'
+  printf '  "program_count": %d,\n' "$NUM_PROGRAMS"
+  printf '  "program_tests_passed": %s,\n' "$PROG_PASS"
+  printf '  "all_tests_passed": %s,\n' "$ALL_PASS"
+  printf '  "all_tests_total": %s,\n' "$ALL_TOTAL"
+  printf '  "exit_code": %d\n' "$RC"
+  printf '}\n'
+} > "$OUT_JSON"
+
+# scoreboard.md
+{
+  printf '# Smalltalk-on-SX Scoreboard\n\n'
+  printf '_Last run: %s_\n\n' "$DATE"
+
+  printf '## Totals\n\n'
+  printf '| Suite | Passing |\n'
+  printf '|-------|---------|\n'
+  printf '| All Smalltalk-on-SX tests | **%s / %s** |\n' "$ALL_PASS" "$ALL_TOTAL"
+  printf '| Classic-corpus tests (`tests/programs.sx`) | **%s** |\n\n' "$PROG_PASS"
+
+  printf '## Classic-corpus programs (`lib/smalltalk/tests/programs/`)\n\n'
+  printf '| Program | Status |\n'
+  printf '|---------|--------|\n'
+  for prog in "${PROGRAMS[@]}"; do
+    printf '| `%s.st` | present |\n' "$prog"
+  done
+  printf '\n'
+
+  printf '## Per-file test counts\n\n'
+  printf '```\n'
+  echo "$RUNNER_OUT" | grep -E '^(OK|X) lib/smalltalk/tests/' | sort
+  printf '```\n\n'
+
+  printf '## Notes\n\n'
+  printf -- '- The spec interpreter is correct but slow (call/cc + dict-based ivars per send).\n'
+  printf -- '- Larger Life multi-step verification, the 8-queens canonical case, and the glider-gun pattern are deferred to the JIT path.\n'
+  printf -- '- Generated by `bash lib/smalltalk/conformance.sh`. Both files are committed; the runner overwrites them on each run.\n'
+} > "$OUT_MD"
+
+echo "Scoreboard updated:"
+echo "  $OUT_JSON"
+echo "  $OUT_MD"
+echo "Programs: $NUM_PROGRAMS  Corpus tests: $PROG_PASS  All: $ALL_PASS/$ALL_TOTAL"
+
+exit $RC

lib/smalltalk/parser.sx

@@ -0,0 +1,948 @@
+;; Smalltalk parser — produces an AST from the tokenizer's token stream.
+;;
+;; AST node shapes (dicts):
+;;   {:type "lit-int" :value N}                  integer
+;;   {:type "lit-float" :value F}                float
+;;   {:type "lit-string" :value S}               string
+;;   {:type "lit-char" :value C}                 character
+;;   {:type "lit-symbol" :value S}               symbol literal (#foo)
+;;   {:type "lit-array" :elements (list ...)}    literal array (#(1 2 #foo))
+;;   {:type "lit-byte-array" :elements (...)}    byte array (#[1 2 3])
+;;   {:type "lit-nil" } / "lit-true" / "lit-false"
+;;   {:type "ident" :name "x"}                   variable reference
+;;   {:type "self"} / "super" / "thisContext"    pseudo-variables
+;;   {:type "assign" :name "x" :expr E}          x := E
+;;   {:type "return" :expr E}                    ^ E
+;;   {:type "send" :receiver R :selector S :args (list ...)}
+;;   {:type "cascade" :receiver R :messages (list {:selector :args} ...)}
+;;   {:type "block" :params (list "a") :temps (list "t") :body (list expr)}
+;;   {:type "seq" :exprs (list ...)}             statement sequence
+;;   {:type "method" :selector S :params (list ...) :temps (list ...) :body (list ...) :pragmas (list ...)}
+;;
+;; A "chunk" / class-definition stream is parsed at a higher level (deferred).
+
+;; ── Chunk-stream reader ────────────────────────────────────────────────
+;; Pharo chunk format: chunks are separated by `!`. A doubled `!!` inside a
+;; chunk represents a single literal `!`. Returns list of chunk strings with
+;; surrounding whitespace trimmed.
+(define
+  st-read-chunks
+  (fn
+    (src)
+    (let
+      ((chunks (list))
+        (buf (list))
+        (pos 0)
+        (n (len src)))
+      (begin
+        (define
+          flush!
+          (fn
+            ()
+            (let
+              ((s (st-trim (join "" buf))))
+              (begin (append! chunks s) (set! buf (list))))))
+        (define
+          rc-loop
+          (fn
+            ()
+            (when
+              (< pos n)
+              (let
+                ((c (nth src pos)))
+                (cond
+                  ((= c "!")
+                    (cond
+                      ((and (< (+ pos 1) n) (= (nth src (+ pos 1)) "!"))
+                        (begin (append! buf "!") (set! pos (+ pos 2)) (rc-loop)))
+                      (else
+                        (begin (flush!) (set! pos (+ pos 1)) (rc-loop)))))
+                  (else
+                    (begin (append! buf c) (set! pos (+ pos 1)) (rc-loop))))))))
+        (rc-loop)
+        ;; trailing text without a closing `!` — preserve as a chunk
+        (when (> (len buf) 0) (flush!))
+        chunks))))
+
+(define
+  st-trim
+  (fn
+    (s)
+    (let
+      ((n (len s)) (i 0) (j 0))
+      (begin
+        (set! j n)
+        (define
+          tl-loop
+          (fn
+            ()
+            (when
+              (and (< i n) (st-trim-ws? (nth s i)))
+              (begin (set! i (+ i 1)) (tl-loop)))))
+        (tl-loop)
+        (define
+          tr-loop
+          (fn
+            ()
+            (when
+              (and (> j i) (st-trim-ws? (nth s (- j 1))))
+              (begin (set! j (- j 1)) (tr-loop)))))
+        (tr-loop)
+        (slice s i j)))))
+
+(define
+  st-trim-ws?
+  (fn (c) (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
+
+;; Parse a chunk stream. Walks chunks and applies the Pharo file-in
+;; convention: a chunk that evaluates to "X methodsFor: 'cat'" or
+;; "X class methodsFor: 'cat'" enters a methods batch — subsequent chunks
+;; are method source until an empty chunk closes the batch.
+;;
+;; Returns list of entries:
+;;   {:kind "expr" :ast EXPR-AST}
+;;   {:kind "method" :class CLS :class-side? BOOL :category CAT :ast METHOD-AST}
+;;   {:kind "blank"}        (empty chunks outside a methods batch)
+;;   {:kind "end-methods"}  (empty chunk closing a methods batch)
+(define
+  st-parse-chunks
+  (fn
+    (src)
+    (let
+      ((chunks (st-read-chunks src))
+        (entries (list))
+        (mode "do-it")
+        (cls-name nil)
+        (class-side? false)
+        (category nil))
+      (begin
+        (for-each
+          (fn
+            (chunk)
+            (cond
+              ((= chunk "")
+                (cond
+                  ((= mode "methods")
+                    (begin
+                      (append! entries {:kind "end-methods"})
+                      (set! mode "do-it")
+                      (set! cls-name nil)
+                      (set! class-side? false)
+                      (set! category nil)))
+                  (else (append! entries {:kind "blank"}))))
+              ((= mode "methods")
+                (append!
+                  entries
+                  {:kind "method"
+                   :class cls-name
+                   :class-side? class-side?
+                   :category category
+                   :ast (st-parse-method chunk)}))
+              (else
+                (let
+                  ((ast (st-parse-expr chunk)))
+                  (begin
+                    (append! entries {:kind "expr" :ast ast})
+                    (let
+                      ((mf (st-detect-methods-for ast)))
+                      (when
+                        (not (= mf nil))
+                        (begin
+                          (set! mode "methods")
+                          (set! cls-name (get mf :class))
+                          (set! class-side? (get mf :class-side?))
+                          (set! category (get mf :category))))))))))
+          chunks)
+        entries))))
+
+;; Recognise `Foo methodsFor: 'cat'` (and related) as starting a methods batch.
+;; Returns nil if the AST doesn't look like one of these forms.
+(define
+  st-detect-methods-for
+  (fn
+    (ast)
+    (cond
+      ((not (= (get ast :type) "send")) nil)
+      ((not (st-is-methods-for-selector? (get ast :selector))) nil)
+      (else
+        (let
+          ((recv (get ast :receiver)) (args (get ast :args)))
+          (let
+            ((cat-arg (if (> (len args) 0) (nth args 0) nil)))
+            (let
+              ((category
+                 (cond
+                   ((= cat-arg nil) nil)
+                   ((= (get cat-arg :type) "lit-string") (get cat-arg :value))
+                   ((= (get cat-arg :type) "lit-symbol") (get cat-arg :value))
+                   (else nil))))
+              (cond
+                ((= (get recv :type) "ident")
+                  {:class (get recv :name)
+                   :class-side? false
+                   :category category})
+                ;; `Foo class methodsFor: 'cat'` — recv is a unary send `Foo class`
+                ((and
+                    (= (get recv :type) "send")
+                    (= (get recv :selector) "class")
+                    (= (get (get recv :receiver) :type) "ident"))
+                  {:class (get (get recv :receiver) :name)
+                   :class-side? true
+                   :category category})
+                (else nil)))))))))
+
+(define
+  st-is-methods-for-selector?
+  (fn
+    (sel)
+    (or
+      (= sel "methodsFor:")
+      (= sel "methodsFor:stamp:")
+      (= sel "category:"))))
+
+(define st-tok-type (fn (t) (if (= t nil) "eof" (get t :type))))
+
+(define st-tok-value (fn (t) (if (= t nil) nil (get t :value))))
+
+;; Parse a *single* Smalltalk expression from source.
+(define st-parse-expr (fn (src) (st-parse-with src "expr")))
+
+;; Parse a sequence of statements separated by '.'  Returns a {:type "seq"} node.
+(define st-parse (fn (src) (st-parse-with src "seq")))
+
+;; Parse a method body — `selector params | temps | body`.
+;; Only the "method header + body" form (no chunk delimiters).
+(define st-parse-method (fn (src) (st-parse-with src "method")))
+
+(define
+  st-parse-with
+  (fn
+    (src mode)
+    (let
+      ((tokens (st-tokenize src)) (idx 0) (tok-len 0))
+      (begin
+        (set! tok-len (len tokens))
+        (define peek-tok (fn () (nth tokens idx)))
+        (define
+          peek-tok-at
+          (fn (n) (if (< (+ idx n) tok-len) (nth tokens (+ idx n)) nil)))
+        (define advance-tok! (fn () (set! idx (+ idx 1))))
+        (define
+          at?
+          (fn
+            (type value)
+            (let
+              ((t (peek-tok)))
+              (and
+                (= (st-tok-type t) type)
+                (or (= value nil) (= (st-tok-value t) value))))))
+        (define at-type? (fn (type) (= (st-tok-type (peek-tok)) type)))
+        (define
+          consume!
+          (fn
+            (type value)
+            (if
+              (at? type value)
+              (let ((t (peek-tok))) (begin (advance-tok!) t))
+              (error
+                (str
+                  "st-parse: expected "
+                  type
+                  (if (= value nil) "" (str " '" value "'"))
+                  " got "
+                  (st-tok-type (peek-tok))
+                  " '"
+                  (st-tok-value (peek-tok))
+                  "' at idx "
+                  idx)))))
+
+        ;; ── Primary: atoms, paren'd expr, blocks, literal arrays, byte arrays.
+        (define
+          parse-primary
+          (fn
+            ()
+            (let
+              ((t (peek-tok)))
+              (let
+                ((ty (st-tok-type t)) (v (st-tok-value t)))
+                (cond
+                  ((= ty "number")
+                    (begin
+                      (advance-tok!)
+                      (cond
+                        ((number? v) {:type (if (integer? v) "lit-int" "lit-float") :value v})
+                        (else {:type "lit-int" :value v}))))
+                  ((= ty "string")
+                    (begin (advance-tok!) {:type "lit-string" :value v}))
+                  ((= ty "char")
+                    (begin (advance-tok!) {:type "lit-char" :value v}))
+                  ((= ty "symbol")
+                    (begin (advance-tok!) {:type "lit-symbol" :value v}))
+                  ((= ty "array-open") (parse-literal-array))
+                  ((= ty "byte-array-open") (parse-byte-array))
+                  ((= ty "lparen")
+                    (begin
+                      (advance-tok!)
+                      (let
+                        ((e (parse-expression)))
+                        (begin (consume! "rparen" nil) e))))
+                  ((= ty "lbracket") (parse-block))
+                  ((= ty "lbrace") (parse-dynamic-array))
+                  ((= ty "ident")
+                    (begin
+                      (advance-tok!)
+                      (cond
+                        ((= v "nil") {:type "lit-nil"})
+                        ((= v "true") {:type "lit-true"})
+                        ((= v "false") {:type "lit-false"})
+                        ((= v "self") {:type "self"})
+                        ((= v "super") {:type "super"})
+                        ((= v "thisContext") {:type "thisContext"})
+                        (else {:type "ident" :name v}))))
+                  ((= ty "binary")
+                    ;; Negative numeric literal: '-' immediately before a number.
+                    (cond
+                      ((and (= v "-") (= (st-tok-type (peek-tok-at 1)) "number"))
+                        (let
+                          ((n (st-tok-value (peek-tok-at 1))))
+                          (begin
+                            (advance-tok!)
+                            (advance-tok!)
+                            (cond
+                              ((dict? n) {:type "lit-int" :value n})
+                              ((integer? n) {:type "lit-int" :value (- 0 n)})
+                              (else {:type "lit-float" :value (- 0 n)})))))
+                      (else
+                        (error
+                          (str "st-parse: unexpected binary '" v "' at idx " idx)))))
+                  (else
+                    (error
+                      (str
+                        "st-parse: unexpected "
+                        ty
+                        " '"
+                        v
+                        "' at idx "
+                        idx))))))))
+
+        ;; #(elem elem ...) — elements are atoms or nested parenthesised arrays.
+        (define
+          parse-literal-array
+          (fn
+            ()
+            (let
+              ((items (list)))
+              (begin
+                (consume! "array-open" nil)
+                (define
+                  arr-loop
+                  (fn
+                    ()
+                    (cond
+                      ((at? "rparen" nil) (advance-tok!))
+                      (else
+                        (begin
+                          (append! items (parse-array-element))
+                          (arr-loop))))))
+                (arr-loop)
+                {:type "lit-array" :elements items}))))
+
+        ;; { expr. expr. expr } — Pharo dynamic array literal. Each element
+        ;; is a *full expression* evaluated at runtime; the result is a
+        ;; fresh mutable array. Empty `{}` is a 0-length array.
+        (define
+          parse-dynamic-array
+          (fn
+            ()
+            (let ((items (list)))
+              (begin
+                (consume! "lbrace" nil)
+                (define
+                  da-loop
+                  (fn
+                    ()
+                    (cond
+                      ((at? "rbrace" nil) (advance-tok!))
+                      (else
+                        (begin
+                          (append! items (parse-expression))
+                          (define
+                            dot-loop
+                            (fn
+                              ()
+                              (when
+                                (at? "period" nil)
+                                (begin (advance-tok!) (dot-loop)))))
+                          (dot-loop)
+                          (da-loop))))))
+                (da-loop)
+                {:type "dynamic-array" :elements items}))))
+
+        ;; #[1 2 3]
+        (define
+          parse-byte-array
+          (fn
+            ()
+            (let
+              ((items (list)))
+              (begin
+                (consume! "byte-array-open" nil)
+                (define
+                  ba-loop
+                  (fn
+                    ()
+                    (cond
+                      ((at? "rbracket" nil) (advance-tok!))
+                      (else
+                        (let
+                          ((t (peek-tok)))
+                          (cond
+                            ((= (st-tok-type t) "number")
+                              (begin
+                                (advance-tok!)
+                                (append! items (st-tok-value t))
+                                (ba-loop)))
+                            (else
+                              (error
+                                (str
+                                  "st-parse: byte array expects number, got "
+                                  (st-tok-type t))))))))))
+                (ba-loop)
+                {:type "lit-byte-array" :elements items}))))
+
+        ;; Inside a literal array: bare idents become symbols, nested (...) is a sub-array.
+        (define
+          parse-array-element
+          (fn
+            ()
+            (let
+              ((t (peek-tok)))
+              (let
+                ((ty (st-tok-type t)) (v (st-tok-value t)))
+                (cond
+                  ((= ty "number") (begin (advance-tok!) {:type "lit-int" :value v}))
+                  ((= ty "string") (begin (advance-tok!) {:type "lit-string" :value v}))
+                  ((= ty "char") (begin (advance-tok!) {:type "lit-char" :value v}))
+                  ((= ty "symbol") (begin (advance-tok!) {:type "lit-symbol" :value v}))
+                  ((= ty "ident")
+                    (begin
+                      (advance-tok!)
+                      (cond
+                        ((= v "nil") {:type "lit-nil"})
+                        ((= v "true") {:type "lit-true"})
+                        ((= v "false") {:type "lit-false"})
+                        (else {:type "lit-symbol" :value v}))))
+                  ((= ty "keyword") (begin (advance-tok!) {:type "lit-symbol" :value v}))
+                  ((= ty "binary") (begin (advance-tok!) {:type "lit-symbol" :value v}))
+                  ((= ty "lparen")
+                    (let ((items (list)))
+                      (begin
+                        (advance-tok!)
+                        (define
+                          sub-loop
+                          (fn
+                            ()
+                            (cond
+                              ((at? "rparen" nil) (advance-tok!))
+                              (else
+                                (begin (append! items (parse-array-element)) (sub-loop))))))
+                        (sub-loop)
+                        {:type "lit-array" :elements items})))
+                  ((= ty "array-open") (parse-literal-array))
+                  ((= ty "byte-array-open") (parse-byte-array))
+                  (else
+                    (error
+                      (str "st-parse: bad literal-array element " ty " '" v "'"))))))))
+
+        ;; [:a :b | | t1 t2 | body. body. ...]
+        (define
+          parse-block
+          (fn
+            ()
+            (begin
+              (consume! "lbracket" nil)
+              (let
+                ((params (list)) (temps (list)))
+                (begin
+                  ;; Block params
+                  (define
+                    p-loop
+                    (fn
+                      ()
+                      (when
+                        (at? "colon" nil)
+                        (begin
+                          (advance-tok!)
+                          (let
+                            ((t (consume! "ident" nil)))
+                            (begin
+                              (append! params (st-tok-value t))
+                              (p-loop)))))))
+                  (p-loop)
+                  (when (> (len params) 0) (consume! "bar" nil))
+                  ;; Block temps: | t1 t2 |
+                  (when
+                    (and
+                      (at? "bar" nil)
+                      ;; Not `|` followed immediately by binary content — the only
+                      ;; legitimate `|` inside a block here is the temp delimiter.
+                      true)
+                    (begin
+                      (advance-tok!)
+                      (define
+                        t-loop
+                        (fn
+                          ()
+                          (when
+                            (at? "ident" nil)
+                            (let
+                              ((t (peek-tok)))
+                              (begin
+                                (advance-tok!)
+                                (append! temps (st-tok-value t))
+                                (t-loop))))))
+                      (t-loop)
+                      (consume! "bar" nil)))
+                  ;; Body: statements terminated by `.` or `]`
+                  (let
+                    ((body (parse-statements "rbracket")))
+                    (begin
+                      (consume! "rbracket" nil)
+                      {:type "block" :params params :temps temps :body body})))))))
+
+        ;; Parse statements up to a closing token (rbracket or eof). Returns list.
+        (define
+          parse-statements
+          (fn
+            (terminator)
+            (let
+              ((stmts (list)))
+              (begin
+                (define
+                  s-loop
+                  (fn
+                    ()
+                    (cond
+                      ((at-type? terminator) nil)
+                      ((at-type? "eof") nil)
+                      (else
+                        (begin
+                          (append! stmts (parse-statement))
+                          ;; consume optional period(s)
+                          (define
+                            dot-loop
+                            (fn
+                              ()
+                              (when
+                                (at? "period" nil)
+                                (begin (advance-tok!) (dot-loop)))))
+                          (dot-loop)
+                          (s-loop))))))
+                (s-loop)
+                stmts))))
+
+        ;; Statement: ^expr  |  ident := expr  |  expr
+        (define
+          parse-statement
+          (fn
+            ()
+            (cond
+              ((at? "caret" nil)
+                (begin
+                  (advance-tok!)
+                  {:type "return" :expr (parse-expression)}))
+              ((and (at-type? "ident") (= (st-tok-type (peek-tok-at 1)) "assign"))
+                (let
+                  ((name-tok (peek-tok)))
+                  (begin
+                    (advance-tok!)
+                    (advance-tok!)
+                    {:type "assign"
+                     :name (st-tok-value name-tok)
+                     :expr (parse-expression)})))
+              (else (parse-expression)))))
+
+        ;; Top-level expression. Assignment (right-associative chain) sits at
+        ;; the top; cascade is below.
+        (define
+          parse-expression
+          (fn
+            ()
+            (cond
+              ((and (at-type? "ident") (= (st-tok-type (peek-tok-at 1)) "assign"))
+                (let
+                  ((name-tok (peek-tok)))
+                  (begin
+                    (advance-tok!)
+                    (advance-tok!)
+                    {:type "assign"
+                     :name (st-tok-value name-tok)
+                     :expr (parse-expression)})))
+              (else (parse-cascade)))))
+
+        (define
+          parse-cascade
+          (fn
+            ()
+            (let
+              ((head (parse-keyword-message)))
+              (cond
+                ((at? "semi" nil)
+                  (let
+                    ((receiver (cascade-receiver head))
+                      (first-msg (cascade-first-message head))
+                      (msgs (list)))
+                    (begin
+                      (append! msgs first-msg)
+                      (define
+                        c-loop
+                        (fn
+                          ()
+                          (when
+                            (at? "semi" nil)
+                            (begin
+                              (advance-tok!)
+                              (append! msgs (parse-cascade-message))
+                              (c-loop)))))
+                      (c-loop)
+                      {:type "cascade" :receiver receiver :messages msgs})))
+                (else head)))))
+
+        ;; Extract the receiver from a head send so cascades share it.
+        (define
+          cascade-receiver
+          (fn
+            (head)
+            (cond
+              ((= (get head :type) "send") (get head :receiver))
+              (else head))))
+
+        (define
+          cascade-first-message
+          (fn
+            (head)
+            (cond
+              ((= (get head :type) "send")
+                {:selector (get head :selector) :args (get head :args)})
+              (else
+                ;; Shouldn't happen — cascade requires at least one prior message.
+                (error "st-parse: cascade with no prior message")))))
+
+        ;; Subsequent cascade message (after the `;`): unary | binary | keyword
+        (define
+          parse-cascade-message
+          (fn
+            ()
+            (cond
+              ((at-type? "ident")
+                (let ((t (peek-tok)))
+                  (begin
+                    (advance-tok!)
+                    {:selector (st-tok-value t) :args (list)})))
+              ((at-type? "binary")
+                (let ((t (peek-tok)))
+                  (begin
+                    (advance-tok!)
+                    (let
+                      ((arg (parse-unary-message)))
+                      {:selector (st-tok-value t) :args (list arg)}))))
+              ((at-type? "keyword")
+                (let
+                  ((sel-parts (list)) (args (list)))
+                  (begin
+                    (define
+                      kw-loop
+                      (fn
+                        ()
+                        (when
+                          (at-type? "keyword")
+                          (let ((t (peek-tok)))
+                            (begin
+                              (advance-tok!)
+                              (append! sel-parts (st-tok-value t))
+                              (append! args (parse-binary-message))
+                              (kw-loop))))))
+                    (kw-loop)
+                    {:selector (join "" sel-parts) :args args})))
+              (else
+                (error
+                  (str "st-parse: bad cascade message at idx " idx))))))
+
+        ;; Keyword message: <binary> (kw <binary>)+
+        (define
+          parse-keyword-message
+          (fn
+            ()
+            (let
+              ((receiver (parse-binary-message)))
+              (cond
+                ((at-type? "keyword")
+                  (let
+                    ((sel-parts (list)) (args (list)))
+                    (begin
+                      (define
+                        kw-loop
+                        (fn
+                          ()
+                          (when
+                            (at-type? "keyword")
+                            (let ((t (peek-tok)))
+                              (begin
+                                (advance-tok!)
+                                (append! sel-parts (st-tok-value t))
+                                (append! args (parse-binary-message))
+                                (kw-loop))))))
+                      (kw-loop)
+                      {:type "send"
+                       :receiver receiver
+                       :selector (join "" sel-parts)
+                       :args args})))
+                (else receiver)))))
+
+        ;; Binary message: <unary> (binop <unary>)*
+        ;; A bare `|` is also a legitimate binary selector (logical or in
+        ;; some Smalltalks); the tokenizer emits it as the `bar` type so
+        ;; that block-param / temp-decl delimiters are easy to spot.
+        ;; In expression position, accept it as a binary operator.
+        (define
+          parse-binary-message
+          (fn
+            ()
+            (let
+              ((receiver (parse-unary-message)))
+              (begin
+                (define
+                  b-loop
+                  (fn
+                    ()
+                    (when
+                      (or (at-type? "binary") (at-type? "bar"))
+                      (let ((t (peek-tok)))
+                        (begin
+                          (advance-tok!)
+                          (let
+                            ((arg (parse-unary-message)))
+                            (set!
+                              receiver
+                              {:type "send"
+                               :receiver receiver
+                               :selector (st-tok-value t)
+                               :args (list arg)}))
+                          (b-loop))))))
+                (b-loop)
+                receiver))))
+
+        ;; Unary message: <primary> ident*  (ident NOT followed by ':')
+        (define
+          parse-unary-message
+          (fn
+            ()
+            (let
+              ((receiver (parse-primary)))
+              (begin
+                (define
+                  u-loop
+                  (fn
+                    ()
+                    (when
+                      (and
+                        (at-type? "ident")
+                        (let
+                          ((nxt (peek-tok-at 1)))
+                          (not (= (st-tok-type nxt) "assign"))))
+                      (let ((t (peek-tok)))
+                        (begin
+                          (advance-tok!)
+                          (set!
+                            receiver
+                            {:type "send"
+                             :receiver receiver
+                             :selector (st-tok-value t)
+                             :args (list)})
+                          (u-loop))))))
+                (u-loop)
+                receiver))))
+
+        ;; Parse a single pragma: `<keyword: literal (keyword: literal)* >`
+        ;; Returns {:selector "primitive:" :args (list literal-asts)}.
+        (define
+          parse-pragma
+          (fn
+            ()
+            (begin
+              (consume! "binary" "<")
+              (let
+                ((sel-parts (list)) (args (list)))
+                (begin
+                  (define
+                    pr-loop
+                    (fn
+                      ()
+                      (when
+                        (at-type? "keyword")
+                        (let ((t (peek-tok)))
+                          (begin
+                            (advance-tok!)
+                            (append! sel-parts (st-tok-value t))
+                            (append! args (parse-pragma-arg))
+                            (pr-loop))))))
+                  (pr-loop)
+                  (consume! "binary" ">")
+                  {:selector (join "" sel-parts) :args args})))))
+
+        ;; Pragma arguments are literals only.
+        (define
+          parse-pragma-arg
+          (fn
+            ()
+            (let
+              ((t (peek-tok)))
+              (let
+                ((ty (st-tok-type t)) (v (st-tok-value t)))
+                (cond
+                  ((= ty "number")
+                    (begin
+                      (advance-tok!)
+                      {:type (if (integer? v) "lit-int" "lit-float") :value v}))
+                  ((= ty "string") (begin (advance-tok!) {:type "lit-string" :value v}))
+                  ((= ty "char") (begin (advance-tok!) {:type "lit-char" :value v}))
+                  ((= ty "symbol") (begin (advance-tok!) {:type "lit-symbol" :value v}))
+                  ((= ty "ident")
+                    (begin
+                      (advance-tok!)
+                      (cond
+                        ((= v "nil") {:type "lit-nil"})
+                        ((= v "true") {:type "lit-true"})
+                        ((= v "false") {:type "lit-false"})
+                        (else (error (str "st-parse: pragma arg must be literal, got ident " v))))))
+                  ((and (= ty "binary") (= v "-")
+                        (= (st-tok-type (peek-tok-at 1)) "number"))
+                    (let ((n (st-tok-value (peek-tok-at 1))))
+                      (begin
+                        (advance-tok!)
+                        (advance-tok!)
+                        {:type (if (integer? n) "lit-int" "lit-float")
+                         :value (- 0 n)})))
+                  (else
+                    (error
+                      (str "st-parse: pragma arg must be literal, got " ty))))))))
+
+        ;; Method header: unary | binary arg | (kw arg)+
+        (define
+          parse-method
+          (fn
+            ()
+            (let
+              ((sel "")
+                (params (list))
+                (temps (list))
+                (pragmas (list))
+                (body (list)))
+              (begin
+                (cond
+                  ;; Unary header
+                  ((at-type? "ident")
+                    (let ((t (peek-tok)))
+                      (begin (advance-tok!) (set! sel (st-tok-value t)))))
+                  ;; Binary header: binop ident
+                  ((at-type? "binary")
+                    (let ((t (peek-tok)))
+                      (begin
+                        (advance-tok!)
+                        (set! sel (st-tok-value t))
+                        (let ((p (consume! "ident" nil)))
+                          (append! params (st-tok-value p))))))
+                  ;; Keyword header: (kw ident)+
+                  ((at-type? "keyword")
+                    (let ((sel-parts (list)))
+                      (begin
+                        (define
+                          kh-loop
+                          (fn
+                            ()
+                            (when
+                              (at-type? "keyword")
+                              (let ((t (peek-tok)))
+                                (begin
+                                  (advance-tok!)
+                                  (append! sel-parts (st-tok-value t))
+                                  (let ((p (consume! "ident" nil)))
+                                    (append! params (st-tok-value p)))
+                                  (kh-loop))))))
+                        (kh-loop)
+                        (set! sel (join "" sel-parts)))))
+                  (else
+                    (error
+                      (str
+                        "st-parse-method: expected selector header, got "
+                        (st-tok-type (peek-tok))))))
+                ;; Pragmas and temps may appear in either order. Allow many
+                ;; pragmas; one temps section.
+                (define
+                  parse-temps!
+                  (fn
+                    ()
+                    (begin
+                      (advance-tok!)
+                      (define
+                        th-loop
+                        (fn
+                          ()
+                          (when
+                            (at-type? "ident")
+                            (let ((t (peek-tok)))
+                              (begin
+                                (advance-tok!)
+                                (append! temps (st-tok-value t))
+                                (th-loop))))))
+                      (th-loop)
+                      (consume! "bar" nil))))
+                (define
+                  pt-loop
+                  (fn
+                    ()
+                    (cond
+                      ((and
+                          (at? "binary" "<")
+                          (= (st-tok-type (peek-tok-at 1)) "keyword"))
+                        (begin (append! pragmas (parse-pragma)) (pt-loop)))
+                      ((and (at? "bar" nil) (= (len temps) 0))
+                        (begin (parse-temps!) (pt-loop)))
+                      (else nil))))
+                (pt-loop)
+                ;; Body statements
+                (set! body (parse-statements "eof"))
+                {:type "method"
+                 :selector sel
+                 :params params
+                 :temps temps
+                 :pragmas pragmas
+                 :body body}))))
+
+        ;; Top-level program: optional temp declaration, then statements
+        ;; separated by '.'. Pharo workspace-style scripts allow
+        ;; `| temps | body...` at the top level.
+        (cond
+          ((= mode "expr") (parse-expression))
+          ((= mode "method") (parse-method))
+          (else
+            (let ((temps (list)))
+              (begin
+                (when
+                  (at? "bar" nil)
+                  (begin
+                    (advance-tok!)
+                    (define
+                      tt-loop
+                      (fn
+                        ()
+                        (when
+                          (at-type? "ident")
+                          (let ((t (peek-tok)))
+                            (begin
+                              (advance-tok!)
+                              (append! temps (st-tok-value t))
+                              (tt-loop))))))
+                    (tt-loop)
+                    (consume! "bar" nil)))
+                {:type "seq" :temps temps :exprs (parse-statements "eof")}))))))))

lib/smalltalk/runtime.sx

@@ -0,0 +1,787 @@
+;; Smalltalk runtime — class table, bootstrap hierarchy, type→class mapping,
+;; instance construction. Method dispatch / eval-ast live in a later layer.
+;;
+;; Class record shape:
+;;   {:name "Foo"
+;;    :superclass "Object"          ; or nil for Object itself
+;;    :ivars (list "x" "y")          ; instance variable names declared on this class
+;;    :methods   (dict selector→method-record)
+;;    :class-methods (dict selector→method-record)}
+;;
+;; A method record is the AST returned by st-parse-method, plus a :defining-class
+;; field so super-sends can resolve from the right place. (Methods are registered
+;; via runtime helpers that fill the field.)
+;;
+;; The class table is a single dict keyed by class name. Bootstrap installs the
+;; canonical hierarchy. Test code resets it via (st-bootstrap-classes!).
+
+(define st-class-table {})
+
+;; ── Method-lookup cache ────────────────────────────────────────────────
+;; Cache keys are "class|selector|side"; side is "i" (instance) or "c" (class).
+;; Misses are stored as the sentinel :not-found so we don't re-walk for
+;; every doesNotUnderstand call.
+(define st-method-cache {})
+(define st-method-cache-hits 0)
+(define st-method-cache-misses 0)
+
+(define
+  st-method-cache-clear!
+  (fn () (set! st-method-cache {})))
+
+;; Inline-cache generation. Eval-time IC slots check this; bumping it
+;; invalidates every cached call-site method record across the program.
+(define st-ic-generation 0)
+
+(define
+  st-ic-bump-generation!
+  (fn () (set! st-ic-generation (+ st-ic-generation 1))))
+
+(define
+  st-method-cache-key
+  (fn (cls sel class-side?) (str cls "|" sel "|" (if class-side? "c" "i"))))
+
+(define
+  st-method-cache-stats
+  (fn
+    ()
+    {:hits st-method-cache-hits
+     :misses st-method-cache-misses
+     :size (len (keys st-method-cache))}))
+
+(define
+  st-method-cache-reset-stats!
+  (fn ()
+    (begin
+      (set! st-method-cache-hits 0)
+      (set! st-method-cache-misses 0))))
+
+(define
+  st-class-table-clear!
+  (fn ()
+    (begin
+      (set! st-class-table {})
+      (st-method-cache-clear!))))
+
+(define
+  st-class-define!
+  (fn
+    (name superclass ivars)
+    (begin
+      (set!
+        st-class-table
+        (assoc
+          st-class-table
+          name
+          {:name name
+           :superclass superclass
+           :ivars ivars
+           :methods {}
+           :class-methods {}}))
+      ;; A redefined class can invalidate any cache entries that walked
+      ;; through its old position in the chain. Cheap + correct: drop all.
+      (st-method-cache-clear!)
+      name)))
+
+(define
+  st-class-get
+  (fn (name) (if (has-key? st-class-table name) (get st-class-table name) nil)))
+
+(define
+  st-class-exists?
+  (fn (name) (has-key? st-class-table name)))
+
+(define
+  st-class-superclass
+  (fn
+    (name)
+    (let
+      ((c (st-class-get name)))
+      (cond ((= c nil) nil) (else (get c :superclass))))))
+
+;; Walk class chain root-to-leaf? No, follow superclass chain leaf-to-root.
+;; Returns list of class names starting at `name` and ending with the root.
+(define
+  st-class-chain
+  (fn
+    (name)
+    (let ((acc (list)) (cur name))
+      (begin
+        (define
+          ch-loop
+          (fn
+            ()
+            (when
+              (and (not (= cur nil)) (st-class-exists? cur))
+              (begin
+                (append! acc cur)
+                (set! cur (st-class-superclass cur))
+                (ch-loop)))))
+        (ch-loop)
+        acc))))
+
+;; Inherited + own ivars in declaration order from root to leaf.
+(define
+  st-class-all-ivars
+  (fn
+    (name)
+    (let ((chain (reverse (st-class-chain name))) (out (list)))
+      (begin
+        (for-each
+          (fn
+            (cn)
+            (let
+              ((c (st-class-get cn)))
+              (when
+                (not (= c nil))
+                (for-each (fn (iv) (append! out iv)) (get c :ivars)))))
+          chain)
+        out))))
+
+;; Method install. The defining-class field is stamped on the method record
+;; so super-sends look up from the right point in the chain.
+(define
+  st-class-add-method!
+  (fn
+    (cls-name selector method-ast)
+    (let
+      ((cls (st-class-get cls-name)))
+      (cond
+        ((= cls nil) (error (str "st-class-add-method!: unknown class " cls-name)))
+        (else
+          (let
+            ((m (assoc method-ast :defining-class cls-name)))
+            (begin
+              (set!
+                st-class-table
+                (assoc
+                  st-class-table
+                  cls-name
+                  (assoc
+                    cls
+                    :methods
+                    (assoc (get cls :methods) selector m))))
+              (st-method-cache-clear!)
+              (st-ic-bump-generation!)
+              selector)))))))
+
+(define
+  st-class-add-class-method!
+  (fn
+    (cls-name selector method-ast)
+    (let
+      ((cls (st-class-get cls-name)))
+      (cond
+        ((= cls nil) (error (str "st-class-add-class-method!: unknown class " cls-name)))
+        (else
+          (let
+            ((m (assoc method-ast :defining-class cls-name)))
+            (begin
+              (set!
+                st-class-table
+                (assoc
+                  st-class-table
+                  cls-name
+                  (assoc
+                    cls
+                    :class-methods
+                    (assoc (get cls :class-methods) selector m))))
+              (st-method-cache-clear!)
+              (st-ic-bump-generation!)
+              selector)))))))
+
+;; Remove a method from a class (instance side). Mostly for tests; runtime
+;; reflection in Phase 4 will use the same primitive.
+(define
+  st-class-remove-method!
+  (fn
+    (cls-name selector)
+    (let ((cls (st-class-get cls-name)))
+      (cond
+        ((= cls nil) (error (str "st-class-remove-method!: unknown class " cls-name)))
+        (else
+          (let ((md (get cls :methods)))
+            (cond
+              ((not (has-key? md selector)) false)
+              (else
+                (let ((new-md {}))
+                  (begin
+                    (for-each
+                      (fn (k)
+                        (when (not (= k selector))
+                          (dict-set! new-md k (get md k))))
+                      (keys md))
+                    (set!
+                      st-class-table
+                      (assoc
+                        st-class-table
+                        cls-name
+                        (assoc cls :methods new-md)))
+                    (st-method-cache-clear!)
+                    (st-ic-bump-generation!)
+                    true))))))))))
+
+;; Walk-only lookup. Returns the method record (with :defining-class) or nil.
+;; class-side? = true searches :class-methods, false searches :methods.
+(define
+  st-method-lookup-walk
+  (fn
+    (cls-name selector class-side?)
+    (let
+      ((found nil))
+      (begin
+        (define
+          ml-loop
+          (fn
+            (cur)
+            (when
+              (and (= found nil) (not (= cur nil)) (st-class-exists? cur))
+              (let
+                ((c (st-class-get cur)))
+                (let
+                  ((dict (if class-side? (get c :class-methods) (get c :methods))))
+                  (cond
+                    ((has-key? dict selector) (set! found (get dict selector)))
+                    (else (ml-loop (get c :superclass)))))))))
+        (ml-loop cls-name)
+        found))))
+
+;; Cached lookup. Misses are stored as :not-found so doesNotUnderstand paths
+;; don't re-walk on every send.
+(define
+  st-method-lookup
+  (fn
+    (cls-name selector class-side?)
+    (let ((key (st-method-cache-key cls-name selector class-side?)))
+      (cond
+        ((has-key? st-method-cache key)
+          (begin
+            (set! st-method-cache-hits (+ st-method-cache-hits 1))
+            (let ((v (get st-method-cache key)))
+              (cond ((= v :not-found) nil) (else v)))))
+        (else
+          (begin
+            (set! st-method-cache-misses (+ st-method-cache-misses 1))
+            (let ((found (st-method-lookup-walk cls-name selector class-side?)))
+              (begin
+                (set!
+                  st-method-cache
+                  (assoc
+                    st-method-cache
+                    key
+                    (cond ((= found nil) :not-found) (else found))))
+                found))))))))
+
+;; SX value → Smalltalk class name. Native types are not boxed.
+(define
+  st-class-of
+  (fn
+    (v)
+    (cond
+      ((= v nil) "UndefinedObject")
+      ((= v true) "True")
+      ((= v false) "False")
+      ((integer? v) "SmallInteger")
+      ((number? v) "Float")
+      ((string? v) "String")
+      ((symbol? v) "Symbol")
+      ((list? v) "Array")
+      ((and (dict? v) (has-key? v :type) (= (get v :type) "st-instance"))
+        (get v :class))
+      ((and (dict? v) (has-key? v :type) (= (get v :type) "block"))
+        "BlockClosure")
+      ((and (dict? v) (has-key? v :st-block?) (get v :st-block?))
+        "BlockClosure")
+      ((dict? v) "Dictionary")
+      ((lambda? v) "BlockClosure")
+      (else "Object"))))
+
+;; Construct a fresh instance of cls-name. Ivars (own + inherited) start as nil.
+(define
+  st-make-instance
+  (fn
+    (cls-name)
+    (cond
+      ((not (st-class-exists? cls-name))
+        (error (str "st-make-instance: unknown class " cls-name)))
+      (else
+        (let
+          ((iv-names (st-class-all-ivars cls-name)) (ivars {}))
+          (begin
+            (for-each (fn (n) (set! ivars (assoc ivars n nil))) iv-names)
+            {:type "st-instance" :class cls-name :ivars ivars}))))))
+
+(define
+  st-instance?
+  (fn
+    (v)
+    (and (dict? v) (has-key? v :type) (= (get v :type) "st-instance"))))
+
+(define
+  st-iv-get
+  (fn
+    (inst name)
+    (let ((ivs (get inst :ivars)))
+      (if (has-key? ivs name) (get ivs name) nil))))
+
+(define
+  st-iv-set!
+  (fn
+    (inst name value)
+    (let
+      ((new-ivars (assoc (get inst :ivars) name value)))
+      (assoc inst :ivars new-ivars))))
+
+;; Inherits-from check: is `descendant` either equal to `ancestor` or a subclass?
+(define
+  st-class-inherits-from?
+  (fn
+    (descendant ancestor)
+    (let ((found false) (cur descendant))
+      (begin
+        (define
+          ih-loop
+          (fn
+            ()
+            (when
+              (and (not found) (not (= cur nil)) (st-class-exists? cur))
+              (cond
+                ((= cur ancestor) (set! found true))
+                (else
+                  (begin
+                    (set! cur (st-class-superclass cur))
+                    (ih-loop)))))))
+        (ih-loop)
+        found))))
+
+;; Bootstrap the canonical class hierarchy. Reset and rebuild.
+(define
+  st-bootstrap-classes!
+  (fn
+    ()
+    (begin
+      (st-class-table-clear!)
+      ;; Root
+      (st-class-define! "Object" nil (list))
+      ;; Class side machinery
+      (st-class-define! "Behavior" "Object" (list "superclass" "methodDict" "format"))
+      (st-class-define! "ClassDescription" "Behavior" (list "instanceVariables" "organization"))
+      (st-class-define! "Class" "ClassDescription" (list "name" "subclasses"))
+      (st-class-define! "Metaclass" "ClassDescription" (list "thisClass"))
+      ;; Pseudo-variable types
+      (st-class-define! "UndefinedObject" "Object" (list))
+      (st-class-define! "Boolean" "Object" (list))
+      (st-class-define! "True" "Boolean" (list))
+      (st-class-define! "False" "Boolean" (list))
+      ;; Magnitudes
+      (st-class-define! "Magnitude" "Object" (list))
+      (st-class-define! "Number" "Magnitude" (list))
+      (st-class-define! "Integer" "Number" (list))
+      (st-class-define! "SmallInteger" "Integer" (list))
+      (st-class-define! "LargePositiveInteger" "Integer" (list))
+      (st-class-define! "Float" "Number" (list))
+      (st-class-define! "Fraction" "Number" (list "numerator" "denominator"))
+      (st-class-define! "Character" "Magnitude" (list "value"))
+      ;; Collections
+      (st-class-define! "Collection" "Object" (list))
+      (st-class-define! "SequenceableCollection" "Collection" (list))
+      (st-class-define! "ArrayedCollection" "SequenceableCollection" (list))
+      (st-class-define! "Array" "ArrayedCollection" (list))
+      (st-class-define! "String" "ArrayedCollection" (list))
+      (st-class-define! "Symbol" "String" (list))
+      (st-class-define! "OrderedCollection" "SequenceableCollection" (list "array" "firstIndex" "lastIndex"))
+      ;; Hashed collection family
+      (st-class-define! "HashedCollection" "Collection" (list "array"))
+      (st-class-define! "Set" "HashedCollection" (list))
+      ;; Blocks / contexts
+      (st-class-define! "BlockClosure" "Object" (list))
+      ;; Reflection support — Message holds the selector/args for a DNU send.
+      (st-class-define! "Message" "Object" (list "selector" "arguments"))
+      (st-class-add-method! "Message" "selector"
+        (st-parse-method "selector ^ selector"))
+      (st-class-add-method! "Message" "arguments"
+        (st-parse-method "arguments ^ arguments"))
+      (st-class-add-method! "Message" "selector:"
+        (st-parse-method "selector: aSym selector := aSym"))
+      (st-class-add-method! "Message" "arguments:"
+        (st-parse-method "arguments: anArray arguments := anArray"))
+      ;; Exception hierarchy — Smalltalk's standard error system on top of
+      ;; SX's `guard`/`raise`. Subclassing Exception gives you on:do:,
+      ;; ensure:, ifCurtailed: catching out of the box.
+      (st-class-define! "Exception" "Object" (list "messageText"))
+      (st-class-add-method! "Exception" "messageText"
+        (st-parse-method "messageText ^ messageText"))
+      (st-class-add-method! "Exception" "messageText:"
+        (st-parse-method "messageText: aString messageText := aString. ^ self"))
+      (st-class-define! "Error" "Exception" (list))
+      (st-class-define! "ZeroDivide" "Error" (list))
+      (st-class-define! "MessageNotUnderstood" "Error" (list))
+      ;; SequenceableCollection — shared iteration / inspection methods.
+      ;; Defined on the parent class so Array, String, Symbol, and
+      ;; OrderedCollection all inherit. Each method calls `self do:`,
+      ;; which dispatches to the receiver's primitive do: implementation.
+      (st-class-add-method! "SequenceableCollection" "inject:into:"
+        (st-parse-method
+          "inject: initial into: aBlock
+             | acc |
+             acc := initial.
+             self do: [:e | acc := aBlock value: acc value: e].
+             ^ acc"))
+      (st-class-add-method! "SequenceableCollection" "detect:"
+        (st-parse-method
+          "detect: aBlock
+             self do: [:e | (aBlock value: e) ifTrue: [^ e]].
+             ^ nil"))
+      (st-class-add-method! "SequenceableCollection" "detect:ifNone:"
+        (st-parse-method
+          "detect: aBlock ifNone: noneBlock
+             self do: [:e | (aBlock value: e) ifTrue: [^ e]].
+             ^ noneBlock value"))
+      (st-class-add-method! "SequenceableCollection" "count:"
+        (st-parse-method
+          "count: aBlock
+             | n |
+             n := 0.
+             self do: [:e | (aBlock value: e) ifTrue: [n := n + 1]].
+             ^ n"))
+      (st-class-add-method! "SequenceableCollection" "allSatisfy:"
+        (st-parse-method
+          "allSatisfy: aBlock
+             self do: [:e | (aBlock value: e) ifFalse: [^ false]].
+             ^ true"))
+      (st-class-add-method! "SequenceableCollection" "anySatisfy:"
+        (st-parse-method
+          "anySatisfy: aBlock
+             self do: [:e | (aBlock value: e) ifTrue: [^ true]].
+             ^ false"))
+      (st-class-add-method! "SequenceableCollection" "includes:"
+        (st-parse-method
+          "includes: target
+             self do: [:e | e = target ifTrue: [^ true]].
+             ^ false"))
+      (st-class-add-method! "SequenceableCollection" "do:separatedBy:"
+        (st-parse-method
+          "do: aBlock separatedBy: sepBlock
+             | first |
+             first := true.
+             self do: [:e |
+               first ifFalse: [sepBlock value].
+               first := false.
+               aBlock value: e].
+             ^ self"))
+      (st-class-add-method! "SequenceableCollection" "indexOf:"
+        (st-parse-method
+          "indexOf: target
+             | idx |
+             idx := 1.
+             self do: [:e | e = target ifTrue: [^ idx]. idx := idx + 1].
+             ^ 0"))
+      (st-class-add-method! "SequenceableCollection" "indexOf:ifAbsent:"
+        (st-parse-method
+          "indexOf: target ifAbsent: noneBlock
+             | idx |
+             idx := 1.
+             self do: [:e | e = target ifTrue: [^ idx]. idx := idx + 1].
+             ^ noneBlock value"))
+      (st-class-add-method! "SequenceableCollection" "reject:"
+        (st-parse-method
+          "reject: aBlock ^ self select: [:e | (aBlock value: e) not]"))
+      (st-class-add-method! "SequenceableCollection" "isEmpty"
+        (st-parse-method "isEmpty ^ self size = 0"))
+      (st-class-add-method! "SequenceableCollection" "notEmpty"
+        (st-parse-method "notEmpty ^ self size > 0"))
+      ;; (no asString here — Symbol/String have their own primitive
+      ;; impls; SequenceableCollection-level fallback would overwrite
+      ;; the bare-name-for-Symbol behaviour.)
+      ;; Array class-side constructors for small fixed-arity literals.
+      (st-class-add-class-method! "Array" "with:"
+        (st-parse-method
+          "with: x | a | a := Array new: 1. a at: 1 put: x. ^ a"))
+      (st-class-add-class-method! "Array" "with:with:"
+        (st-parse-method
+          "with: a with: b
+             | r | r := Array new: 2.
+             r at: 1 put: a. r at: 2 put: b. ^ r"))
+      (st-class-add-class-method! "Array" "with:with:with:"
+        (st-parse-method
+          "with: a with: b with: c
+             | r | r := Array new: 3.
+             r at: 1 put: a. r at: 2 put: b. r at: 3 put: c. ^ r"))
+      (st-class-add-class-method! "Array" "with:with:with:with:"
+        (st-parse-method
+          "with: a with: b with: c with: d
+             | r | r := Array new: 4.
+             r at: 1 put: a. r at: 2 put: b. r at: 3 put: c. r at: 4 put: d. ^ r"))
+      ;; ── HashedCollection / Set / Dictionary ──
+      ;; Implemented as user instances with array-backed storage. Sets
+      ;; use a single `array` ivar; Dictionaries use parallel `keys`/
+      ;; `values` arrays. New is class-side and routes through `init`.
+      (st-class-add-method! "HashedCollection" "init"
+        (st-parse-method "init array := Array new: 0. ^ self"))
+      (st-class-add-method! "HashedCollection" "size"
+        (st-parse-method "size ^ array size"))
+      (st-class-add-method! "HashedCollection" "isEmpty"
+        (st-parse-method "isEmpty ^ array isEmpty"))
+      (st-class-add-method! "HashedCollection" "notEmpty"
+        (st-parse-method "notEmpty ^ array notEmpty"))
+      (st-class-add-method! "HashedCollection" "do:"
+        (st-parse-method "do: aBlock array do: aBlock. ^ self"))
+      (st-class-add-method! "HashedCollection" "asArray"
+        (st-parse-method "asArray ^ array"))
+      (st-class-add-class-method! "Set" "new"
+        (st-parse-method "new ^ super new init"))
+      (st-class-add-method! "Set" "add:"
+        (st-parse-method
+          "add: anObject
+             (self includes: anObject) ifFalse: [array add: anObject].
+             ^ anObject"))
+      (st-class-add-method! "Set" "addAll:"
+        (st-parse-method
+          "addAll: aCollection
+             aCollection do: [:e | self add: e].
+             ^ aCollection"))
+      (st-class-add-method! "Set" "remove:"
+        (st-parse-method
+          "remove: anObject
+             array := array reject: [:e | e = anObject].
+             ^ anObject"))
+      (st-class-add-method! "Set" "includes:"
+        (st-parse-method "includes: anObject ^ array includes: anObject"))
+      (st-class-define! "Dictionary" "HashedCollection" (list "keys" "values"))
+      (st-class-add-class-method! "Dictionary" "new"
+        (st-parse-method "new ^ super new init"))
+      (st-class-add-method! "Dictionary" "init"
+        (st-parse-method
+          "init keys := Array new: 0. values := Array new: 0. ^ self"))
+      (st-class-add-method! "Dictionary" "size"
+        (st-parse-method "size ^ keys size"))
+      (st-class-add-method! "Dictionary" "isEmpty"
+        (st-parse-method "isEmpty ^ keys isEmpty"))
+      (st-class-add-method! "Dictionary" "notEmpty"
+        (st-parse-method "notEmpty ^ keys notEmpty"))
+      (st-class-add-method! "Dictionary" "keys"
+        (st-parse-method "keys ^ keys"))
+      (st-class-add-method! "Dictionary" "values"
+        (st-parse-method "values ^ values"))
+      (st-class-add-method! "Dictionary" "at:"
+        (st-parse-method
+          "at: aKey
+             | i |
+             i := keys indexOf: aKey.
+             i = 0 ifTrue: [^ nil].
+             ^ values at: i"))
+      (st-class-add-method! "Dictionary" "at:ifAbsent:"
+        (st-parse-method
+          "at: aKey ifAbsent: aBlock
+             | i |
+             i := keys indexOf: aKey.
+             i = 0 ifTrue: [^ aBlock value].
+             ^ values at: i"))
+      (st-class-add-method! "Dictionary" "at:put:"
+        (st-parse-method
+          "at: aKey put: aValue
+             | i |
+             i := keys indexOf: aKey.
+             i = 0
+               ifTrue: [keys add: aKey. values add: aValue]
+               ifFalse: [values at: i put: aValue].
+             ^ aValue"))
+      (st-class-add-method! "Dictionary" "includesKey:"
+        (st-parse-method "includesKey: aKey ^ (keys indexOf: aKey) > 0"))
+      (st-class-add-method! "Dictionary" "removeKey:"
+        (st-parse-method
+          "removeKey: aKey
+             | i nk nv j |
+             i := keys indexOf: aKey.
+             i = 0 ifTrue: [^ nil].
+             nk := Array new: 0. nv := Array new: 0.
+             j := 1.
+             [j <= keys size] whileTrue: [
+               j = i ifFalse: [
+                 nk add: (keys at: j).
+                 nv add: (values at: j)].
+               j := j + 1].
+             keys := nk. values := nv.
+             ^ aKey"))
+      (st-class-add-method! "Dictionary" "do:"
+        (st-parse-method "do: aBlock values do: aBlock. ^ self"))
+      (st-class-add-method! "Dictionary" "keysDo:"
+        (st-parse-method "keysDo: aBlock keys do: aBlock. ^ self"))
+      (st-class-add-method! "Dictionary" "valuesDo:"
+        (st-parse-method "valuesDo: aBlock values do: aBlock. ^ self"))
+      (st-class-add-method! "Dictionary" "keysAndValuesDo:"
+        (st-parse-method
+          "keysAndValuesDo: aBlock
+             | i |
+             i := 1.
+             [i <= keys size] whileTrue: [
+               aBlock value: (keys at: i) value: (values at: i).
+               i := i + 1].
+             ^ self"))
+      (st-class-define! "IdentityDictionary" "Dictionary" (list))
+      ;; ── Stream hierarchy ──
+      ;; Streams wrap a collection with a 0-based `position`. Read/peek
+      ;; advance via `at:` (1-indexed Smalltalk-style) on the collection.
+      ;; Write streams require a mutable collection (Array works; String
+      ;; doesn't, see Phase 5 follow-up).
+      (st-class-define! "Stream" "Object" (list))
+      (st-class-define! "PositionableStream" "Stream" (list "collection" "position"))
+      (st-class-define! "ReadStream" "PositionableStream" (list))
+      (st-class-define! "WriteStream" "PositionableStream" (list))
+      (st-class-define! "ReadWriteStream" "WriteStream" (list))
+      (st-class-add-class-method! "ReadStream" "on:"
+        (st-parse-method "on: aColl ^ super new on: aColl"))
+      (st-class-add-class-method! "WriteStream" "on:"
+        (st-parse-method "on: aColl ^ super new on: aColl"))
+      (st-class-add-class-method! "WriteStream" "with:"
+        (st-parse-method
+          "with: aColl
+             | s |
+             s := super new on: aColl.
+             s setToEnd.
+             ^ s"))
+      (st-class-add-class-method! "ReadWriteStream" "on:"
+        (st-parse-method "on: aColl ^ super new on: aColl"))
+      (st-class-add-method! "PositionableStream" "on:"
+        (st-parse-method
+          "on: aColl collection := aColl. position := 0. ^ self"))
+      (st-class-add-method! "PositionableStream" "atEnd"
+        (st-parse-method "atEnd ^ position >= collection size"))
+      (st-class-add-method! "PositionableStream" "position"
+        (st-parse-method "position ^ position"))
+      (st-class-add-method! "PositionableStream" "position:"
+        (st-parse-method "position: n position := n. ^ self"))
+      (st-class-add-method! "PositionableStream" "reset"
+        (st-parse-method "reset position := 0. ^ self"))
+      (st-class-add-method! "PositionableStream" "setToEnd"
+        (st-parse-method "setToEnd position := collection size. ^ self"))
+      (st-class-add-method! "PositionableStream" "contents"
+        (st-parse-method "contents ^ collection"))
+      (st-class-add-method! "PositionableStream" "skip:"
+        (st-parse-method "skip: n position := position + n. ^ self"))
+      (st-class-add-method! "ReadStream" "next"
+        (st-parse-method
+          "next
+             self atEnd ifTrue: [^ nil].
+             position := position + 1.
+             ^ collection at: position"))
+      (st-class-add-method! "ReadStream" "peek"
+        (st-parse-method
+          "peek
+             self atEnd ifTrue: [^ nil].
+             ^ collection at: position + 1"))
+      (st-class-add-method! "ReadStream" "upToEnd"
+        (st-parse-method
+          "upToEnd
+             | result |
+             result := Array new: 0.
+             [self atEnd] whileFalse: [result add: self next].
+             ^ result"))
+      (st-class-add-method! "ReadStream" "next:"
+        (st-parse-method
+          "next: n
+             | result i |
+             result := Array new: 0.
+             i := 0.
+             [(i < n) and: [self atEnd not]] whileTrue: [
+               result add: self next.
+               i := i + 1].
+             ^ result"))
+      (st-class-add-method! "WriteStream" "nextPut:"
+        (st-parse-method
+          "nextPut: anObject
+             collection add: anObject.
+             position := position + 1.
+             ^ anObject"))
+      (st-class-add-method! "WriteStream" "nextPutAll:"
+        (st-parse-method
+          "nextPutAll: aCollection
+             aCollection do: [:e | self nextPut: e].
+             ^ aCollection"))
+      ;; ReadWriteStream inherits from WriteStream + ReadStream behaviour;
+      ;; for the simple linear-position model, both nextPut: and next work.
+      (st-class-add-method! "ReadWriteStream" "next"
+        (st-parse-method
+          "next
+             self atEnd ifTrue: [^ nil].
+             position := position + 1.
+             ^ collection at: position"))
+      (st-class-add-method! "ReadWriteStream" "peek"
+        (st-parse-method
+          "peek
+             self atEnd ifTrue: [^ nil].
+             ^ collection at: position + 1"))
+      ;; ── Fraction ──
+      ;; Rational numbers stored as numerator/denominator, normalized
+      ;; (sign on numerator, denominator > 0, reduced via gcd).
+      (st-class-add-class-method! "Fraction" "numerator:denominator:"
+        (st-parse-method
+          "numerator: n denominator: d
+             | f |
+             f := super new.
+             ^ f setNumerator: n denominator: d"))
+      (st-class-add-method! "Fraction" "setNumerator:denominator:"
+        (st-parse-method
+          "setNumerator: n denominator: d
+             | g s nn dd |
+             d = 0 ifTrue: [Error signal: 'Fraction denominator cannot be zero'].
+             s := (d < 0) ifTrue: [-1] ifFalse: [1].
+             nn := n * s. dd := d * s.
+             g := nn abs gcd: dd.
+             g = 0 ifTrue: [g := 1].
+             numerator := nn / g.
+             denominator := dd / g.
+             ^ self"))
+      (st-class-add-method! "Fraction" "numerator"
+        (st-parse-method "numerator ^ numerator"))
+      (st-class-add-method! "Fraction" "denominator"
+        (st-parse-method "denominator ^ denominator"))
+      (st-class-add-method! "Fraction" "+"
+        (st-parse-method
+          "+ other
+             ^ Fraction
+                 numerator: numerator * other denominator + (other numerator * denominator)
+                 denominator: denominator * other denominator"))
+      (st-class-add-method! "Fraction" "-"
+        (st-parse-method
+          "- other
+             ^ Fraction
+                 numerator: numerator * other denominator - (other numerator * denominator)
+                 denominator: denominator * other denominator"))
+      (st-class-add-method! "Fraction" "*"
+        (st-parse-method
+          "* other
+             ^ Fraction
+                 numerator: numerator * other numerator
+                 denominator: denominator * other denominator"))
+      (st-class-add-method! "Fraction" "/"
+        (st-parse-method
+          "/ other
+             ^ Fraction
+                 numerator: numerator * other denominator
+                 denominator: denominator * other numerator"))
+      (st-class-add-method! "Fraction" "negated"
+        (st-parse-method
+          "negated ^ Fraction numerator: numerator negated denominator: denominator"))
+      (st-class-add-method! "Fraction" "reciprocal"
+        (st-parse-method
+          "reciprocal ^ Fraction numerator: denominator denominator: numerator"))
+      (st-class-add-method! "Fraction" "="
+        (st-parse-method
+          "= other
+             ^ numerator = other numerator and: [denominator = other denominator]"))
+      (st-class-add-method! "Fraction" "<"
+        (st-parse-method
+          "< other
+             ^ numerator * other denominator < (other numerator * denominator)"))
+      (st-class-add-method! "Fraction" "asFloat"
+        (st-parse-method "asFloat ^ numerator / denominator"))
+      (st-class-add-method! "Fraction" "printString"
+        (st-parse-method
+          "printString ^ numerator printString , '/' , denominator printString"))
+      (st-class-add-method! "Fraction" "isFraction"
+        (st-parse-method "isFraction ^ true"))
+      "ok")))
+
+;; Initialise on load. Tests can re-bootstrap to reset state.
+(st-bootstrap-classes!)

lib/smalltalk/scoreboard.json

@@ -0,0 +1,15 @@
+{
+  "date": "2026-04-25T16:05:32Z",
+  "programs": [
+    "eight-queens.st",
+    "fibonacci.st",
+    "life.st",
+    "mandelbrot.st",
+    "quicksort.st"
+  ],
+  "program_count": 5,
+  "program_tests_passed": 39,
+  "all_tests_passed": 847,
+  "all_tests_total": 847,
+  "exit_code": 0
+}

lib/smalltalk/scoreboard.md

@@ -0,0 +1,56 @@
+# Smalltalk-on-SX Scoreboard
+
+_Last run: 2026-04-25T16:05:32Z_
+
+## Totals
+
+| Suite | Passing |
+|-------|---------|
+| All Smalltalk-on-SX tests | **847 / 847** |
+| Classic-corpus tests (`tests/programs.sx`) | **39** |
+
+## Classic-corpus programs (`lib/smalltalk/tests/programs/`)
+
+| Program | Status |
+|---------|--------|
+| `eight-queens.st` | present |
+| `fibonacci.st` | present |
+| `life.st` | present |
+| `mandelbrot.st` | present |
+| `quicksort.st` | present |
+
+## Per-file test counts
+
+```
+OK lib/smalltalk/tests/ansi.sx              62 passed
+OK lib/smalltalk/tests/blocks.sx            19 passed
+OK lib/smalltalk/tests/cannot_return.sx     5 passed
+OK lib/smalltalk/tests/collections.sx       29 passed
+OK lib/smalltalk/tests/conditional.sx       25 passed
+OK lib/smalltalk/tests/dnu.sx               15 passed
+OK lib/smalltalk/tests/eval.sx              68 passed
+OK lib/smalltalk/tests/exceptions.sx        15 passed
+OK lib/smalltalk/tests/hashed.sx            30 passed
+OK lib/smalltalk/tests/inline_cache.sx      10 passed
+OK lib/smalltalk/tests/intrinsics.sx        24 passed
+OK lib/smalltalk/tests/nlr.sx               14 passed
+OK lib/smalltalk/tests/numbers.sx           47 passed
+OK lib/smalltalk/tests/parse_chunks.sx      21 passed
+OK lib/smalltalk/tests/parse.sx             47 passed
+OK lib/smalltalk/tests/pharo.sx             91 passed
+OK lib/smalltalk/tests/printing.sx          19 passed
+OK lib/smalltalk/tests/programs.sx          39 passed
+OK lib/smalltalk/tests/reflection.sx        77 passed
+OK lib/smalltalk/tests/runtime.sx           64 passed
+OK lib/smalltalk/tests/streams.sx           21 passed
+OK lib/smalltalk/tests/sunit.sx             19 passed
+OK lib/smalltalk/tests/super.sx             9 passed
+OK lib/smalltalk/tests/tokenize.sx          63 passed
+OK lib/smalltalk/tests/while.sx             14 passed
+```
+
+## Notes
+
+- The spec interpreter is correct but slow (call/cc + dict-based ivars per send).
+- Larger Life multi-step verification, the 8-queens canonical case, and the glider-gun pattern are deferred to the JIT path.
+- Generated by `bash lib/smalltalk/conformance.sh`. Both files are committed; the runner overwrites them on each run.

lib/smalltalk/sunit.sx

@@ -0,0 +1,153 @@
+;; SUnit — minimal port written in SX-Smalltalk, run by smalltalk-load.
+;;
+;; Provides:
+;;   TestCase     — base class. Subclass it, add `testSomething` methods.
+;;   TestSuite    — a collection of TestCase instances; runs them all.
+;;   TestResult   — passes / failures / errors counts and lists.
+;;   TestFailure  — Error subclass raised by `assert:` and friends.
+;;
+;; Conventions:
+;;   - Test methods are run in a fresh instance per test.
+;;   - `setUp` is sent before each test; `tearDown` after.
+;;   - Failures are signalled by TestFailure; runner catches and records.
+
+(define
+  st-sunit-source
+  "Error subclass: #TestFailure
+     instanceVariableNames: ''!
+
+   Object subclass: #TestCase
+     instanceVariableNames: 'testSelector'!
+
+   !TestCase methodsFor: 'access'!
+   testSelector ^ testSelector!
+   testSelector: aSym testSelector := aSym. ^ self! !
+
+   !TestCase methodsFor: 'fixture'!
+   setUp ^ self!
+   tearDown ^ self! !
+
+   !TestCase methodsFor: 'asserts'!
+   assert: aBoolean
+     aBoolean ifFalse: [TestFailure signal: 'assertion failed'].
+     ^ self!
+
+   assert: aBoolean description: aString
+     aBoolean ifFalse: [TestFailure signal: aString].
+     ^ self!
+
+   assert: actual equals: expected
+     actual = expected ifFalse: [
+       TestFailure signal: 'expected ' , expected printString
+                           , ' but got ' , actual printString].
+     ^ self!
+
+   deny: aBoolean
+     aBoolean ifTrue: [TestFailure signal: 'denial failed'].
+     ^ self!
+
+   should: aBlock raise: anExceptionClass
+     | raised |
+     raised := false.
+     [aBlock value] on: anExceptionClass do: [:e | raised := true].
+     raised ifFalse: [
+       TestFailure signal: 'expected exception ' , anExceptionClass name
+                           , ' was not raised'].
+     ^ self!
+
+   shouldnt: aBlock raise: anExceptionClass
+     | raised |
+     raised := false.
+     [aBlock value] on: anExceptionClass do: [:e | raised := true].
+     raised ifTrue: [
+       TestFailure signal: 'unexpected exception ' , anExceptionClass name].
+     ^ self! !
+
+   !TestCase methodsFor: 'running'!
+   runCase
+     self setUp.
+     self perform: testSelector.
+     self tearDown.
+     ^ self! !
+
+   !TestCase class methodsFor: 'instantiation'!
+   selector: aSym ^ self new testSelector: aSym!
+
+   suiteForAll: aSelectorArray
+     | suite |
+     suite := TestSuite new init.
+     suite name: self name.
+     aSelectorArray do: [:s | suite addTest: (self selector: s)].
+     ^ suite! !
+
+   Object subclass: #TestResult
+     instanceVariableNames: 'passes failures errors'!
+
+   !TestResult methodsFor: 'init'!
+   init
+     passes := Array new: 0.
+     failures := Array new: 0.
+     errors := Array new: 0.
+     ^ self! !
+
+   !TestResult methodsFor: 'access'!
+   passes ^ passes!
+   failures ^ failures!
+   errors ^ errors!
+   passCount ^ passes size!
+   failureCount ^ failures size!
+   errorCount ^ errors size!
+   totalCount ^ passes size + failures size + errors size!
+
+   addPass: aTest passes add: aTest. ^ self!
+   addFailure: aTest message: aMsg
+     | rec |
+     rec := Array new: 2.
+     rec at: 1 put: aTest. rec at: 2 put: aMsg.
+     failures add: rec.
+     ^ self!
+   addError: aTest message: aMsg
+     | rec |
+     rec := Array new: 2.
+     rec at: 1 put: aTest. rec at: 2 put: aMsg.
+     errors add: rec.
+     ^ self!
+
+   isEmpty ^ self totalCount = 0!
+   allPassed ^ (failures size + errors size) = 0!
+
+   summary
+     ^ 'Tests: {1}  Passed: {2}  Failed: {3}  Errors: {4}'
+         format: (Array
+                    with: self totalCount printString
+                    with: passes size printString
+                    with: failures size printString
+                    with: errors size printString)! !
+
+   Object subclass: #TestSuite
+     instanceVariableNames: 'tests name'!
+
+   !TestSuite methodsFor: 'init'!
+   init tests := Array new: 0. name := 'Suite'. ^ self!
+   name ^ name!
+   name: aString name := aString. ^ self! !
+
+   !TestSuite methodsFor: 'tests'!
+   tests ^ tests!
+   addTest: aTest tests add: aTest. ^ self!
+   addAll: aCollection aCollection do: [:t | self addTest: t]. ^ self!
+   size ^ tests size! !
+
+   !TestSuite methodsFor: 'running'!
+   run
+     | result |
+     result := TestResult new init.
+     tests do: [:t | self runTest: t result: result].
+     ^ result!
+
+   runTest: aTest result: aResult
+     [aTest runCase. aResult addPass: aTest]
+       on: TestFailure do: [:e | aResult addFailure: aTest message: e messageText].
+     ^ self! !")
+
+(smalltalk-load st-sunit-source)

lib/smalltalk/test.sh

@@ -0,0 +1,145 @@
+#!/usr/bin/env bash
+# Fast Smalltalk-on-SX test runner — pipes directly to sx_server.exe.
+# Mirrors lib/haskell/test.sh.
+#
+# Usage:
+#   bash lib/smalltalk/test.sh                     # run all tests
+#   bash lib/smalltalk/test.sh -v                  # verbose
+#   bash lib/smalltalk/test.sh tests/tokenize.sx   # run one file
+
+set -uo pipefail
+cd "$(git rev-parse --show-toplevel)"
+
+SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
+if [ ! -x "$SX_SERVER" ]; then
+  MAIN_ROOT=$(git worktree list | head -1 | awk '{print $1}')
+  if [ -x "$MAIN_ROOT/$SX_SERVER" ]; then
+    SX_SERVER="$MAIN_ROOT/$SX_SERVER"
+  else
+    echo "ERROR: sx_server.exe not found. Run: cd hosts/ocaml && dune build"
+    exit 1
+  fi
+fi
+
+VERBOSE=""
+FILES=()
+for arg in "$@"; do
+  case "$arg" in
+    -v|--verbose) VERBOSE=1 ;;
+    *) FILES+=("$arg") ;;
+  esac
+done
+
+if [ ${#FILES[@]} -eq 0 ]; then
+  # tokenize.sx must load first — it defines the st-test helpers reused by
+  # subsequent test files. Sort enforces this lexicographically.
+  mapfile -t FILES < <(find lib/smalltalk/tests -maxdepth 2 -name '*.sx' | sort)
+fi
+
+TOTAL_PASS=0
+TOTAL_FAIL=0
+FAILED_FILES=()
+
+for FILE in "${FILES[@]}"; do
+  [ -f "$FILE" ] || { echo "skip $FILE (not found)"; continue; }
+  TMPFILE=$(mktemp)
+  if [ "$(basename "$FILE")" = "tokenize.sx" ]; then
+    cat > "$TMPFILE" <<EPOCHS
+(epoch 1)
+(load "lib/smalltalk/tokenizer.sx")
+(epoch 2)
+(load "$FILE")
+(epoch 3)
+(eval "(list st-test-pass st-test-fail)")
+EPOCHS
+  else
+    cat > "$TMPFILE" <<EPOCHS
+(epoch 1)
+(load "lib/smalltalk/tokenizer.sx")
+(epoch 2)
+(load "lib/smalltalk/parser.sx")
+(epoch 3)
+(load "lib/smalltalk/runtime.sx")
+(epoch 4)
+(load "lib/smalltalk/eval.sx")
+(epoch 5)
+(load "lib/smalltalk/sunit.sx")
+(epoch 6)
+(load "lib/smalltalk/tests/tokenize.sx")
+(epoch 7)
+(load "$FILE")
+(epoch 8)
+(eval "(list st-test-pass st-test-fail)")
+EPOCHS
+  fi
+
+  OUTPUT=$(timeout 180 "$SX_SERVER" < "$TMPFILE" 2>&1 || true)
+  rm -f "$TMPFILE"
+
+  # Final epoch's value: either (ok N (P F)) on one line or
+  # (ok-len N M)\n(P F) where the value is on the following line.
+  LINE=$(echo "$OUTPUT" | awk '/^\(ok-len [0-9]+ / {getline; print}' | tail -1)
+  if [ -z "$LINE" ]; then
+    LINE=$(echo "$OUTPUT" | grep -E '^\(ok [0-9]+ \([0-9]+ [0-9]+\)\)' | tail -1 \
+            | sed -E 's/^\(ok [0-9]+ //; s/\)$//')
+  fi
+  if [ -z "$LINE" ]; then
+    echo "X $FILE: could not extract summary"
+    echo "$OUTPUT" | tail -30
+    TOTAL_FAIL=$((TOTAL_FAIL + 1))
+    FAILED_FILES+=("$FILE")
+    continue
+  fi
+  P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
+  F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
+  TOTAL_PASS=$((TOTAL_PASS + P))
+  TOTAL_FAIL=$((TOTAL_FAIL + F))
+  if [ "$F" -gt 0 ]; then
+    FAILED_FILES+=("$FILE")
+    printf 'X %-40s %d/%d\n' "$FILE" "$P" "$((P+F))"
+    TMPFILE2=$(mktemp)
+    if [ "$(basename "$FILE")" = "tokenize.sx" ]; then
+      cat > "$TMPFILE2" <<EPOCHS
+(epoch 1)
+(load "lib/smalltalk/tokenizer.sx")
+(epoch 2)
+(load "$FILE")
+(epoch 3)
+(eval "(map (fn (f) (get f :name)) st-test-fails)")
+EPOCHS
+    else
+      cat > "$TMPFILE2" <<EPOCHS
+(epoch 1)
+(load "lib/smalltalk/tokenizer.sx")
+(epoch 2)
+(load "lib/smalltalk/parser.sx")
+(epoch 3)
+(load "lib/smalltalk/runtime.sx")
+(epoch 4)
+(load "lib/smalltalk/eval.sx")
+(epoch 5)
+(load "lib/smalltalk/sunit.sx")
+(epoch 6)
+(load "lib/smalltalk/tests/tokenize.sx")
+(epoch 7)
+(load "$FILE")
+(epoch 8)
+(eval "(map (fn (f) (get f :name)) st-test-fails)")
+EPOCHS
+    fi
+    FAILS=$(timeout 180 "$SX_SERVER" < "$TMPFILE2" 2>&1 | grep -E '^\(ok [0-9]+ \(' | tail -1 || true)
+    rm -f "$TMPFILE2"
+    echo "    $FAILS"
+  elif [ "$VERBOSE" = "1" ]; then
+    printf 'OK %-40s %d passed\n' "$FILE" "$P"
+  fi
+done
+
+TOTAL=$((TOTAL_PASS + TOTAL_FAIL))
+if [ $TOTAL_FAIL -eq 0 ]; then
+  echo "OK $TOTAL_PASS/$TOTAL smalltalk-on-sx tests passed"
+else
+  echo "FAIL $TOTAL_PASS/$TOTAL passed, $TOTAL_FAIL failed in: ${FAILED_FILES[*]}"
+fi
+
+[ $TOTAL_FAIL -eq 0 ]

lib/smalltalk/tests/ansi.sx

@@ -0,0 +1,158 @@
+;; ANSI X3J20 Smalltalk validator — stretch subset.
+;;
+;; Targets the mandatory protocols documented in the standard; one test
+;; case per ANSI §6.x category. Test methods are run through the SUnit
+;; framework; one st-test row per Smalltalk method (mirrors tests/pharo.sx).
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(define
+  ansi-source
+  "TestCase subclass: #AnsiObjectTest instanceVariableNames: ''!
+
+   !AnsiObjectTest methodsFor: '6.10 Object'!
+   testIdentity self assert: 42 == 42!
+   testIdentityNotEq self deny: 'a' == 'b'!
+   testEqualityIsAlsoIdentityOnInts self assert: 7 = 7!
+   testNotEqual self assert: (1 ~= 2)!
+   testIsNilOnNil self assert: nil isNil!
+   testIsNilOnInt self deny: 1 isNil!
+   testNotNil self assert: 42 notNil!
+   testClass self assert: 42 class = SmallInteger!
+   testYourself
+     | x | x := 99.
+     self assert: x yourself equals: 99! !
+
+   TestCase subclass: #AnsiBooleanTest instanceVariableNames: ''!
+
+   !AnsiBooleanTest methodsFor: '6.11 Boolean'!
+   testNot self assert: true not equals: false!
+   testAndTT self assert: (true & true)!
+   testAndTF self deny: (true & false)!
+   testAndFT self deny: (false & true)!
+   testAndFF self deny: (false & false)!
+   testOrTT self assert: (true | true)!
+   testOrTF self assert: (true | false)!
+   testOrFT self assert: (false | true)!
+   testOrFF self deny: (false | false)!
+   testIfTrueTaken self assert: (true ifTrue: [1] ifFalse: [2]) equals: 1!
+   testIfFalseTaken self assert: (false ifTrue: [1] ifFalse: [2]) equals: 2!
+   testAndShort self assert: (false and: [1/0]) equals: false!
+   testOrShort self assert: (true or: [1/0]) equals: true! !
+
+   TestCase subclass: #AnsiIntegerTest instanceVariableNames: ''!
+
+   !AnsiIntegerTest methodsFor: '6.13 Integer'!
+   testFactorial self assert: 6 factorial equals: 720!
+   testGcd self assert: (12 gcd: 18) equals: 6!
+   testLcm self assert: (4 lcm: 6) equals: 12!
+   testEven self assert: 8 even!
+   testOdd self assert: 9 odd!
+   testNegated self assert: 5 negated equals: -5!
+   testAbs self assert: -7 abs equals: 7! !
+
+   !AnsiIntegerTest methodsFor: '6.12 Number arithmetic'!
+   testAdd self assert: 1 + 2 equals: 3!
+   testSub self assert: 10 - 4 equals: 6!
+   testMul self assert: 6 * 7 equals: 42!
+   testMin self assert: (3 min: 7) equals: 3!
+   testMax self assert: (3 max: 7) equals: 7!
+   testBetween self assert: (5 between: 1 and: 10)! !
+
+   TestCase subclass: #AnsiStringTest instanceVariableNames: ''!
+
+   !AnsiStringTest methodsFor: '6.17 String'!
+   testSize self assert: 'abcdef' size equals: 6!
+   testConcat self assert: ('foo' , 'bar') equals: 'foobar'!
+   testAt self assert: ('abcd' at: 3) equals: 'c'!
+   testCopyFromTo self assert: ('helloworld' copyFrom: 1 to: 5) equals: 'hello'!
+   testAsSymbol self assert: 'foo' asSymbol == #foo!
+   testIsEmpty self assert: '' isEmpty! !
+
+   TestCase subclass: #AnsiArrayTest instanceVariableNames: ''!
+
+   !AnsiArrayTest methodsFor: '6.18 Array'!
+   testSize self assert: #(1 2 3) size equals: 3!
+   testAt self assert: (#(10 20 30) at: 2) equals: 20!
+   testAtPut
+     | a |
+     a := Array new: 3.
+     a at: 1 put: 100.
+     self assert: (a at: 1) equals: 100!
+   testDo
+     | s |
+     s := 0.
+     #(1 2 3) do: [:e | s := s + e].
+     self assert: s equals: 6!
+   testCollect self assert: (#(1 2 3) collect: [:x | x + 10]) equals: #(11 12 13)!
+   testSelect self assert: (#(1 2 3 4) select: [:x | x even]) equals: #(2 4)!
+   testReject self assert: (#(1 2 3 4) reject: [:x | x even]) equals: #(1 3)!
+   testInject self assert: (#(1 2 3 4 5) inject: 0 into: [:a :b | a + b]) equals: 15!
+   testIncludes self assert: (#(1 2 3) includes: 2)!
+   testFirst self assert: #(7 8 9) first equals: 7!
+   testLast self assert: #(7 8 9) last equals: 9! !
+
+   TestCase subclass: #AnsiBlockTest instanceVariableNames: ''!
+
+   !AnsiBlockTest methodsFor: '6.19 BlockContext'!
+   testValue self assert: [42] value equals: 42!
+   testValueOne self assert: ([:x | x * 2] value: 21) equals: 42!
+   testValueTwo self assert: ([:a :b | a + b] value: 3 value: 4) equals: 7!
+   testNumArgs self assert: [:a :b | a] numArgs equals: 2!
+   testValueWithArguments
+     self assert: ([:a :b | a , b] valueWithArguments: #('foo' 'bar')) equals: 'foobar'!
+   testWhileTrue
+     | n |
+     n := 5.
+     [n > 0] whileTrue: [n := n - 1].
+     self assert: n equals: 0!
+   testEnsureRunsOnNormal
+     | log |
+     log := Array new: 0.
+     [log add: #body] ensure: [log add: #cleanup].
+     self assert: log size equals: 2!
+   testOnDoCatchesError
+     | r |
+     r := [Error signal: 'boom'] on: Error do: [:e | e messageText].
+     self assert: r equals: 'boom'! !
+
+   TestCase subclass: #AnsiSymbolTest instanceVariableNames: ''!
+
+   !AnsiSymbolTest methodsFor: '6.16 Symbol'!
+   testEqual self assert: #foo = #foo!
+   testIdentity self assert: #bar == #bar!
+   testNotEq self deny: #a == #b! !")
+
+(smalltalk-load ansi-source)
+
+(define
+  pharo-test-class
+  (fn
+    (cls-name)
+    (let ((selectors (sort (keys (get (st-class-get cls-name) :methods)))))
+      (for-each
+        (fn (sel)
+          (when
+            (and (>= (len sel) 4) (= (slice sel 0 4) "test"))
+            (let
+              ((src (str "| s r | s := " cls-name " suiteForAll: #(#"
+                         sel "). r := s run.
+                         ^ {(r passCount). (r failureCount). (r errorCount)}")))
+              (let ((result (smalltalk-eval-program src)))
+                (st-test
+                  (str cls-name " >> " sel)
+                  result
+                  (list 1 0 0))))))
+        selectors))))
+
+(pharo-test-class "AnsiObjectTest")
+(pharo-test-class "AnsiBooleanTest")
+(pharo-test-class "AnsiIntegerTest")
+(pharo-test-class "AnsiStringTest")
+(pharo-test-class "AnsiArrayTest")
+(pharo-test-class "AnsiBlockTest")
+(pharo-test-class "AnsiSymbolTest")
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/blocks.sx

@@ -0,0 +1,92 @@
+;; BlockContext>>value family tests.
+;;
+;; The runtime already implements value, value:, value:value:, value:value:value:,
+;; value:value:value:value:, and valueWithArguments: in st-block-dispatch.
+;; This file pins each variant down with explicit tests + closure semantics.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(st-bootstrap-classes!)
+(define ev (fn (src) (smalltalk-eval src)))
+(define evp (fn (src) (smalltalk-eval-program src)))
+
+;; ── 1. The value/valueN family ──
+(st-test "value: zero-arg block"     (ev "[42] value")                              42)
+(st-test "value: one-arg block"      (ev "[:a | a + 1] value: 10")                  11)
+(st-test "value:value: two-arg"       (ev "[:a :b | a * b] value: 3 value: 4")       12)
+(st-test "value:value:value: three"  (ev "[:a :b :c | a + b + c] value: 1 value: 2 value: 3") 6)
+(st-test "value:value:value:value: four"
+  (ev "[:a :b :c :d | a + b + c + d] value: 1 value: 2 value: 3 value: 4")          10)
+
+;; ── 2. valueWithArguments: ──
+(st-test "valueWithArguments: zero-arg"
+  (ev "[99] valueWithArguments: #()")                                               99)
+(st-test "valueWithArguments: one-arg"
+  (ev "[:x | x * x] valueWithArguments: #(7)")                                      49)
+(st-test "valueWithArguments: many"
+  (ev "[:a :b :c | a , b , c] valueWithArguments: #('foo' '-' 'bar')")              "foo-bar")
+
+;; ── 3. Block returns last expression ──
+(st-test "block last-expression result" (ev "[1. 2. 3] value") 3)
+(st-test "block with temps initial state"
+  (ev "[| t u | t := 5. u := t * 2. u] value") 10)
+
+;; ── 4. Closure over outer locals ──
+(st-test
+  "block reads outer let temps"
+  (evp "| n | n := 5. ^ [n * n] value")
+  25)
+(st-test
+  "block writes outer locals (mutating)"
+  (evp "| n | n := 10. [:x | n := n + x] value: 5. ^ n")
+  15)
+
+;; ── 5. Block sees later mutation of captured local ──
+(st-test
+  "block re-reads outer local on each invocation"
+  (evp
+    "| n b r1 r2 |
+     n := 1. b := [n].
+     r1 := b value.
+     n := 99.
+     r2 := b value.
+     ^ r1 + r2")
+  100)
+
+;; ── 6. Re-entrant invocations ──
+(st-test
+  "calling same block twice independent results"
+  (evp
+    "| sq |
+     sq := [:x | x * x].
+     ^ (sq value: 3) + (sq value: 4)")
+  25)
+
+;; ── 7. Nested blocks ──
+(st-test
+  "nested block closes over both scopes"
+  (evp
+    "| a |
+     a := [:x | [:y | x + y]].
+     ^ ((a value: 10) value: 5)")
+  15)
+
+;; ── 8. Block as method argument ──
+(st-class-define! "BlockUser" "Object" (list))
+(st-class-add-method! "BlockUser" "apply:to:"
+  (st-parse-method "apply: aBlock to: x ^ aBlock value: x"))
+
+(st-test
+  "method invokes block argument"
+  (evp "^ BlockUser new apply: [:n | n * n] to: 9")
+  81)
+
+;; ── 9. numArgs + class ──
+(st-test "numArgs zero"    (ev "[] numArgs")        0)
+(st-test "numArgs three"   (ev "[:a :b :c | a] numArgs") 3)
+(st-test "block class is BlockClosure"
+  (str (ev "[1] class name")) "BlockClosure")
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/cannot_return.sx

@@ -0,0 +1,96 @@
+;; cannotReturn: tests — escape past a returned-from method must error.
+;;
+;; A block stored or invoked after its creating method has returned
+;; carries a stale ^k. Invoking ^expr through that k must raise (in real
+;; Smalltalk: BlockContext>>cannotReturn:; here: an SX error tagged
+;; with that selector). A normal value-returning block (no ^) is fine.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(st-bootstrap-classes!)
+(define ev (fn (src) (smalltalk-eval src)))
+(define evp (fn (src) (smalltalk-eval-program src)))
+
+;; helper: substring check on actual SX strings
+(define
+  str-contains?
+  (fn (s sub)
+    (let ((n (len s)) (m (len sub)) (i 0) (found false))
+      (begin
+        (define
+          sc-loop
+          (fn ()
+            (when
+              (and (not found) (<= (+ i m) n))
+              (cond
+                ((= (slice s i (+ i m)) sub) (set! found true))
+                (else (begin (set! i (+ i 1)) (sc-loop)))))))
+        (sc-loop)
+        found))))
+
+;; ── 1. Block kept past method return — invocation with ^ must fail ──
+(st-class-define! "BlockBox" "Object" (list "block"))
+(st-class-add-method! "BlockBox" "block:"
+  (st-parse-method "block: aBlock block := aBlock. ^ self"))
+(st-class-add-method! "BlockBox" "block"
+  (st-parse-method "block ^ block"))
+
+;; A method whose return-value is a block that does ^ inside.
+;; Once `escapingBlock` returns, its ^k is dead.
+(st-class-define! "Trapper" "Object" (list))
+(st-class-add-method! "Trapper" "stash"
+  (st-parse-method "stash | b | b := [^ #shouldNeverHappen]. ^ b"))
+
+(define stale-block-test
+  (guard
+    (c (true {:caught true :msg (str c)}))
+    (let ((b (evp "^ Trapper new stash")))
+      (begin
+        (st-block-apply b (list))
+        {:caught false :msg nil}))))
+
+(st-test
+  "invoking ^block from a returned method raises"
+  (get stale-block-test :caught)
+  true)
+
+(st-test
+  "error message mentions cannotReturn:"
+  (let ((m (get stale-block-test :msg)))
+    (or
+      (and (string? m) (> (len m) 0) (str-contains? m "cannotReturn"))
+      false))
+  true)
+
+;; ── 2. A normal (non-^) block survives just fine across methods ──
+(st-class-add-method! "Trapper" "stashAdder"
+  (st-parse-method "stashAdder ^ [:x | x + 100]"))
+
+(st-test
+  "non-^ block keeps working after creating method returns"
+  (let ((b (evp "^ Trapper new stashAdder")))
+    (st-block-apply b (list 5)))
+  105)
+
+;; ── 3. Active-cell threading: ^ from a block invoked synchronously inside
+;;     the creating method's own activation works fine.
+(st-class-add-method! "Trapper" "syncFlow"
+  (st-parse-method "syncFlow #(1 2 3) do: [:e | e = 2 ifTrue: [^ #foundTwo]]. ^ #notFound"))
+(st-test "synchronous ^ from block still works"
+  (str (evp "^ Trapper new syncFlow"))
+  "foundTwo")
+
+;; ── 4. Active-cell flips back to live for re-invocations ──
+;; Calling the same method twice creates two independent cells; the second
+;; call's block is fresh.
+(st-class-add-method! "Trapper" "secondOK"
+  (st-parse-method "secondOK ^ #ok"))
+(st-test "method called twice in sequence still works"
+  (let ((a (evp "^ Trapper new secondOK"))
+        (b (evp "^ Trapper new secondOK")))
+    (str (str a b)))
+  "okok")
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/collections.sx

@@ -0,0 +1,115 @@
+;; Phase 5 collection tests — methods on SequenceableCollection / Array /
+;; String / Symbol. Emphasis on the inherited-from-SequenceableCollection
+;; methods that work uniformly across Array, String, Symbol.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(st-bootstrap-classes!)
+(define ev (fn (src) (smalltalk-eval src)))
+(define evp (fn (src) (smalltalk-eval-program src)))
+
+;; ── 1. inject:into: (fold) ──
+(st-test "Array inject:into: sum"
+  (ev "#(1 2 3 4) inject: 0 into: [:a :b | a + b]") 10)
+
+(st-test "Array inject:into: product"
+  (ev "#(2 3 4) inject: 1 into: [:a :b | a * b]") 24)
+
+(st-test "Array inject:into: empty array → initial"
+  (ev "#() inject: 99 into: [:a :b | a + b]") 99)
+
+;; ── 2. detect: / detect:ifNone: ──
+(st-test "detect: finds first match"
+  (ev "#(1 3 5 7) detect: [:x | x > 4]") 5)
+
+(st-test "detect: returns nil if no match"
+  (ev "#(1 2 3) detect: [:x | x > 10]") nil)
+
+(st-test "detect:ifNone: invokes block on miss"
+  (ev "#(1 2 3) detect: [:x | x > 10] ifNone: [#none]")
+  (make-symbol "none"))
+
+;; ── 3. count: ──
+(st-test "count: matches"
+  (ev "#(1 2 3 4 5 6) count: [:x | x > 3]") 3)
+
+(st-test "count: zero matches"
+  (ev "#(1 2 3) count: [:x | x > 100]") 0)
+
+;; ── 4. allSatisfy: / anySatisfy: ──
+(st-test "allSatisfy: when all match"
+  (ev "#(2 4 6) allSatisfy: [:x | x > 0]") true)
+
+(st-test "allSatisfy: when one fails"
+  (ev "#(2 4 -1) allSatisfy: [:x | x > 0]") false)
+
+(st-test "anySatisfy: when at least one matches"
+  (ev "#(1 2 3) anySatisfy: [:x | x > 2]") true)
+
+(st-test "anySatisfy: when none match"
+  (ev "#(1 2 3) anySatisfy: [:x | x > 100]") false)
+
+;; ── 5. includes: ──
+(st-test "includes: found"  (ev "#(1 2 3) includes: 2") true)
+(st-test "includes: missing" (ev "#(1 2 3) includes: 99") false)
+
+;; ── 6. indexOf: / indexOf:ifAbsent: ──
+(st-test "indexOf: returns 1-based index"
+  (ev "#(10 20 30 40) indexOf: 30") 3)
+
+(st-test "indexOf: missing returns 0"
+  (ev "#(1 2 3) indexOf: 99") 0)
+
+(st-test "indexOf:ifAbsent: invokes block"
+  (ev "#(1 2 3) indexOf: 99 ifAbsent: [-1]") -1)
+
+;; ── 7. reject: (complement of select:) ──
+(st-test "reject: removes matching"
+  (ev "#(1 2 3 4 5) reject: [:x | x > 3]")
+  (list 1 2 3))
+
+;; ── 8. do:separatedBy: ──
+(st-test "do:separatedBy: builds joined sequence"
+  (evp
+    "| seen |
+     seen := #().
+     #(1 2 3) do: [:e | seen := seen , (Array with: e)]
+              separatedBy: [seen := seen , #(0)].
+     ^ seen")
+  (list 1 0 2 0 3))
+
+;; Array with: shim for the test (inherited from earlier exception tests
+;; in a separate suite — define here for safety).
+(st-class-add-class-method! "Array" "with:"
+  (st-parse-method "with: x | a | a := Array new: 1. a at: 1 put: x. ^ a"))
+
+;; ── 9. String inherits the same methods ──
+(st-test "String includes:"
+  (ev "'abcde' includes: $c") true)
+
+(st-test "String count:"
+  (ev "'banana' count: [:c | c = $a]") 3)
+
+(st-test "String inject:into: concatenates"
+  (ev "'abc' inject: '' into: [:acc :c | acc , c , c]")
+  "aabbcc")
+
+(st-test "String allSatisfy:"
+  (ev "'abc' allSatisfy: [:c | c = $a or: [c = $b or: [c = $c]]]") true)
+
+;; ── 10. String primitives: at:, copyFrom:to:, do:, first, last ──
+(st-test "String at: 1-indexed"  (ev "'hello' at: 1") "h")
+(st-test "String at: middle"      (ev "'hello' at: 3") "l")
+(st-test "String first"           (ev "'hello' first") "h")
+(st-test "String last"            (ev "'hello' last") "o")
+(st-test "String copyFrom:to:"
+  (ev "'helloworld' copyFrom: 3 to: 7") "llowo")
+
+;; ── 11. isEmpty / notEmpty go through SequenceableCollection too ──
+;; (Already in primitives; the inherited versions agree.)
+(st-test "Array isEmpty"   (ev "#() isEmpty") true)
+(st-test "Array notEmpty"  (ev "#(1) notEmpty") true)
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/conditional.sx

@@ -0,0 +1,104 @@
+;; ifTrue: / ifFalse: / ifTrue:ifFalse: / ifFalse:ifTrue: tests.
+;;
+;; In Smalltalk these are *block sends* on Boolean. The runtime can
+;; intrinsify the dispatch in the JIT (already provided by the bytecode
+;; expansion infrastructure) but the spec semantics are: True/False
+;; receive these messages and pick which branch block to evaluate.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(st-bootstrap-classes!)
+(define ev (fn (src) (smalltalk-eval src)))
+(define evp (fn (src) (smalltalk-eval-program src)))
+
+;; ── 1. ifTrue: ──
+(st-test "true ifTrue: → block value"   (ev "true  ifTrue: [42]") 42)
+(st-test "false ifTrue: → nil"          (ev "false ifTrue: [42]") nil)
+
+;; ── 2. ifFalse: ──
+(st-test "true ifFalse: → nil"          (ev "true  ifFalse: [42]") nil)
+(st-test "false ifFalse: → block value" (ev "false ifFalse: [42]") 42)
+
+;; ── 3. ifTrue:ifFalse: ──
+(st-test "true ifTrue:ifFalse:"         (ev "true  ifTrue: [1] ifFalse: [2]") 1)
+(st-test "false ifTrue:ifFalse:"        (ev "false ifTrue: [1] ifFalse: [2]") 2)
+
+;; ── 4. ifFalse:ifTrue: (reversed-order keyword) ──
+(st-test "true ifFalse:ifTrue:"         (ev "true  ifFalse: [1] ifTrue: [2]") 2)
+(st-test "false ifFalse:ifTrue:"        (ev "false ifFalse: [1] ifTrue: [2]") 1)
+
+;; ── 5. The non-taken branch is NOT evaluated (laziness) ──
+(st-test
+  "ifTrue: doesn't evaluate the false branch"
+  (evp
+    "| ran |
+     ran := false.
+     true ifTrue: [99] ifFalse: [ran := true. 0].
+     ^ ran")
+  false)
+(st-test
+  "ifFalse: doesn't evaluate the true branch"
+  (evp
+    "| ran |
+     ran := false.
+     false ifTrue: [ran := true. 99] ifFalse: [0].
+     ^ ran")
+  false)
+
+;; ── 6. Branch result type can be anything ──
+(st-test "branch returns string" (ev "true ifTrue: ['yes'] ifFalse: ['no']") "yes")
+(st-test "branch returns nil"    (ev "true ifTrue: [nil] ifFalse: [99]") nil)
+(st-test "branch returns array"  (ev "false ifTrue: [#(1)] ifFalse: [#(2 3)]") (list 2 3))
+
+;; ── 7. Nested if ──
+(st-test
+  "nested ifTrue:ifFalse:"
+  (evp
+    "| x |
+     x := 5.
+     ^ x > 0
+         ifTrue: [x > 10
+                    ifTrue: [#big]
+                    ifFalse: [#smallPositive]]
+         ifFalse: [#nonPositive]")
+  (make-symbol "smallPositive"))
+
+;; ── 8. Branch reads outer locals (closure semantics) ──
+(st-test
+  "branch closes over outer bindings"
+  (evp
+    "| label x |
+     x := 7.
+     label := x > 0
+                ifTrue: [#positive]
+                ifFalse: [#nonPositive].
+     ^ label")
+  (make-symbol "positive"))
+
+;; ── 9. and: / or: short-circuit ──
+(st-test "and: short-circuits when receiver false"
+  (ev "false and: [1/0]") false)
+(st-test "and: with true receiver runs second" (ev "true and: [42]") 42)
+(st-test "or: short-circuits when receiver true"
+  (ev "true or: [1/0]") true)
+(st-test "or: with false receiver runs second" (ev "false or: [99]") 99)
+
+;; ── 10. & and | are eager (not blocks) ──
+(st-test "& on booleans"   (ev "true & true")   true)
+(st-test "| on booleans"   (ev "false | true")  true)
+
+;; ── 11. Boolean negation ──
+(st-test "not on true"  (ev "true not")  false)
+(st-test "not on false" (ev "false not") true)
+
+;; ── 12. Real-world idiom: max via ifTrue:ifFalse: in a method ──
+(st-class-define! "Mathy" "Object" (list))
+(st-class-add-method! "Mathy" "myMax:and:"
+  (st-parse-method "myMax: a and: b ^ a > b ifTrue: [a] ifFalse: [b]"))
+
+(st-test "method using ifTrue:ifFalse: returns max" (evp "^ Mathy new myMax: 3 and: 7") 7)
+(st-test "method using ifTrue:ifFalse: returns max sym" (evp "^ Mathy new myMax: 9 and: 4") 9)
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/dnu.sx

@@ -0,0 +1,107 @@
+;; doesNotUnderstand: tests.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(st-bootstrap-classes!)
+
+(define ev (fn (src) (smalltalk-eval src)))
+(define evp (fn (src) (smalltalk-eval-program src)))
+
+;; ── 1. Bootstrap installs Message class ──
+(st-test "Message exists in bootstrap" (st-class-exists? "Message") true)
+(st-test
+  "Message has expected ivars"
+  (sort (get (st-class-get "Message") :ivars))
+  (sort (list "selector" "arguments")))
+
+;; ── 2. Building a Message directly ──
+(define m (st-make-message "frob:" (list 1 2 3)))
+(st-test "make-message produces st-instance" (st-instance? m) true)
+(st-test "message class" (get m :class) "Message")
+(st-test "message selector ivar"
+  (str (get (get m :ivars) "selector"))
+  "frob:")
+(st-test "message arguments ivar" (get (get m :ivars) "arguments") (list 1 2 3))
+
+;; ── 3. User override of doesNotUnderstand: intercepts unknown sends ──
+(st-class-define! "Logger" "Object" (list "log"))
+(st-class-add-method! "Logger" "log"
+  (st-parse-method "log ^ log"))
+(st-class-add-method! "Logger" "init"
+  (st-parse-method "init log := nil. ^ self"))
+(st-class-add-method! "Logger" "doesNotUnderstand:"
+  (st-parse-method
+    "doesNotUnderstand: aMessage
+       log := aMessage selector.
+       ^ #handled"))
+
+(st-test
+  "user DNU intercepts unknown send"
+  (str
+    (evp "| l | l := Logger new init. l frobnicate. ^ l log"))
+  "frobnicate")
+
+(st-test
+  "user DNU returns its own value"
+  (str (evp "| l | l := Logger new init. ^ l frobnicate"))
+  "handled")
+
+;; Arguments are captured.
+(st-class-add-method! "Logger" "doesNotUnderstand:"
+  (st-parse-method
+    "doesNotUnderstand: aMessage
+       log := aMessage arguments.
+       ^ #handled"))
+
+(st-test
+  "user DNU sees args in Message"
+  (evp "| l | l := Logger new init. l zip: 1 zap: 2. ^ l log")
+  (list 1 2))
+
+;; ── 4. DNU on native receiver ─────────────────────────────────────────
+;; Adding doesNotUnderstand: on Object catches any-receiver sends.
+(st-class-add-method! "Object" "doesNotUnderstand:"
+  (st-parse-method
+    "doesNotUnderstand: aMessage ^ aMessage selector"))
+
+(st-test "Object DNU intercepts on SmallInteger"
+  (str (ev "42 frobnicate"))
+  "frobnicate")
+
+(st-test "Object DNU intercepts on String"
+  (str (ev "'hi' bogusmessage"))
+  "bogusmessage")
+
+(st-test "Object DNU sees arguments"
+  ;; Re-define Object DNU to return the args array.
+  (begin
+    (st-class-add-method! "Object" "doesNotUnderstand:"
+      (st-parse-method "doesNotUnderstand: aMessage ^ aMessage arguments"))
+    (ev "42 plop: 1 plop: 2"))
+  (list 1 2))
+
+;; ── 5. Subclass DNU overrides Object DNU ──────────────────────────────
+(st-class-define! "Proxy" "Object" (list))
+(st-class-add-method! "Proxy" "doesNotUnderstand:"
+  (st-parse-method "doesNotUnderstand: aMessage ^ #proxyHandled"))
+
+(st-test "subclass DNU wins over Object DNU"
+  (str (evp "^ Proxy new whatever"))
+  "proxyHandled")
+
+;; ── 6. Defined methods bypass DNU ─────────────────────────────────────
+(st-class-add-method! "Proxy" "known" (st-parse-method "known ^ 7"))
+(st-test "defined method wins over DNU"
+  (evp "^ Proxy new known")
+  7)
+
+;; ── 7. Block doesNotUnderstand: routes via Object ─────────────────────
+(st-class-add-method! "Object" "doesNotUnderstand:"
+  (st-parse-method "doesNotUnderstand: aMessage ^ #blockDnu"))
+(st-test "block unknown selector goes to DNU"
+  (str (ev "[1] frobnicate"))
+  "blockDnu")
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/eval.sx

@@ -0,0 +1,181 @@
+;; Smalltalk evaluator tests — sequential semantics, message dispatch on
+;; native + user receivers, blocks, cascades, return.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(st-bootstrap-classes!)
+
+(define ev (fn (src) (smalltalk-eval src)))
+(define evp (fn (src) (smalltalk-eval-program src)))
+
+;; ── 1. Literals ──
+(st-test "int literal" (ev "42") 42)
+(st-test "float literal" (ev "3.14") 3.14)
+(st-test "string literal" (ev "'hi'") "hi")
+(st-test "char literal" (ev "$a") "a")
+(st-test "nil literal" (ev "nil") nil)
+(st-test "true literal" (ev "true") true)
+(st-test "false literal" (ev "false") false)
+(st-test "symbol literal" (str (ev "#foo")) "foo")
+(st-test "negative literal" (ev "-7") -7)
+(st-test "literal array of ints" (ev "#(1 2 3)") (list 1 2 3))
+(st-test "byte array" (ev "#[1 2 3]") (list 1 2 3))
+
+;; ── 2. Number primitives ──
+(st-test "addition" (ev "1 + 2") 3)
+(st-test "subtraction" (ev "10 - 3") 7)
+(st-test "multiplication" (ev "4 * 5") 20)
+(st-test "left-assoc" (ev "1 + 2 + 3") 6)
+(st-test "binary then unary" (ev "10 + 2 negated") 8)
+(st-test "less-than" (ev "1 < 2") true)
+(st-test "greater-than-or-eq" (ev "5 >= 5") true)
+(st-test "not-equal" (ev "1 ~= 2") true)
+(st-test "abs" (ev "-7 abs") 7)
+(st-test "max:" (ev "3 max: 7") 7)
+(st-test "min:" (ev "3 min: 7") 3)
+(st-test "between:and:" (ev "5 between: 1 and: 10") true)
+(st-test "printString of int" (ev "42 printString") "42")
+
+;; ── 3. Boolean primitives ──
+(st-test "true not" (ev "true not") false)
+(st-test "false not" (ev "false not") true)
+(st-test "true & false" (ev "true & false") false)
+(st-test "true | false" (ev "true | false") true)
+(st-test "ifTrue: with true" (ev "true ifTrue: [99]") 99)
+(st-test "ifTrue: with false" (ev "false ifTrue: [99]") nil)
+(st-test "ifTrue:ifFalse: true branch" (ev "true ifTrue: [1] ifFalse: [2]") 1)
+(st-test "ifTrue:ifFalse: false branch" (ev "false ifTrue: [1] ifFalse: [2]") 2)
+(st-test "and: short-circuit" (ev "false and: [1/0]") false)
+(st-test "or: short-circuit" (ev "true or: [1/0]") true)
+
+;; ── 4. Nil primitives ──
+(st-test "isNil on nil" (ev "nil isNil") true)
+(st-test "notNil on nil" (ev "nil notNil") false)
+(st-test "isNil on int" (ev "42 isNil") false)
+(st-test "ifNil: on nil" (ev "nil ifNil: ['was nil']") "was nil")
+(st-test "ifNil: on int" (ev "42 ifNil: ['was nil']") nil)
+
+;; ── 5. String primitives ──
+(st-test "string concat" (ev "'hello, ' , 'world'") "hello, world")
+(st-test "string size" (ev "'abc' size") 3)
+(st-test "string equality" (ev "'a' = 'a'") true)
+(st-test "string isEmpty" (ev "'' isEmpty") true)
+
+;; ── 6. Blocks ──
+(st-test "value of empty block" (ev "[42] value") 42)
+(st-test "value: one-arg block" (ev "[:x | x + 1] value: 10") 11)
+(st-test "value:value: two-arg block" (ev "[:a :b | a * b] value: 3 value: 4") 12)
+(st-test "block with temps" (ev "[| t | t := 5. t * t] value") 25)
+(st-test "block returns last expression" (ev "[1. 2. 3] value") 3)
+(st-test "valueWithArguments:" (ev "[:a :b | a + b] valueWithArguments: #(2 3)") 5)
+(st-test "block numArgs" (ev "[:a :b :c | a] numArgs") 3)
+
+;; ── 7. Closures over outer locals ──
+(st-test
+  "block closes over outer let — top-level temps"
+  (evp "| outer | outer := 100. ^ [:x | x + outer] value: 5")
+  105)
+
+;; ── 8. Cascades ──
+(st-test "simple cascade returns last" (ev "10 + 1; + 2; + 3") 13)
+
+;; ── 9. Sequences and assignment ──
+(st-test "sequence returns last" (evp "1. 2. 3") 3)
+(st-test
+  "assignment + use"
+  (evp "| x | x := 10. x := x + 1. ^ x")
+  11)
+
+;; ── 10. Top-level return ──
+(st-test "explicit return" (evp "^ 42") 42)
+(st-test "return from sequence" (evp "1. ^ 99. 100") 99)
+
+;; ── 11. Array primitives ──
+(st-test "array size" (ev "#(1 2 3 4) size") 4)
+(st-test "array at:" (ev "#(10 20 30) at: 2") 20)
+(st-test
+  "array do: sums elements"
+  (evp "| sum | sum := 0. #(1 2 3 4) do: [:e | sum := sum + e]. ^ sum")
+  10)
+(st-test
+  "array collect:"
+  (ev "#(1 2 3) collect: [:x | x * x]")
+  (list 1 4 9))
+(st-test
+  "array select:"
+  (ev "#(1 2 3 4 5) select: [:x | x > 2]")
+  (list 3 4 5))
+
+;; ── 12. While loop ──
+(st-test
+  "whileTrue: counts down"
+  (evp "| n | n := 5. [n > 0] whileTrue: [n := n - 1]. ^ n")
+  0)
+(st-test
+  "to:do: sums 1..10"
+  (evp "| s | s := 0. 1 to: 10 do: [:i | s := s + i]. ^ s")
+  55)
+
+;; ── 13. User classes — instance variables, methods, send ──
+(st-bootstrap-classes!)
+(st-class-define! "Point" "Object" (list "x" "y"))
+(st-class-add-method! "Point" "x"  (st-parse-method "x ^ x"))
+(st-class-add-method! "Point" "y"  (st-parse-method "y ^ y"))
+(st-class-add-method! "Point" "x:" (st-parse-method "x: v x := v"))
+(st-class-add-method! "Point" "y:" (st-parse-method "y: v y := v"))
+(st-class-add-method! "Point" "+"
+  (st-parse-method "+ other ^ (Point new x: x + other x; y: y + other y; yourself)"))
+(st-class-add-method! "Point" "yourself" (st-parse-method "yourself ^ self"))
+(st-class-add-method! "Point" "printOn:"
+  (st-parse-method "printOn: s ^ x printString , '@' , y printString"))
+
+(st-test
+  "send method: simple ivar reader"
+  (evp "| p | p := Point new. p x: 3. p y: 4. ^ p x")
+  3)
+
+(st-test
+  "method composes via cascade"
+  (evp "| p | p := Point new x: 7; y: 8; yourself. ^ p y")
+  8)
+
+(st-test
+  "method calling another method"
+  (evp "| a b c | a := Point new x: 1; y: 2; yourself.
+        b := Point new x: 10; y: 20; yourself.
+        c := a + b. ^ c x")
+  11)
+
+;; ── 14. Method invocation arity check ──
+(st-test
+  "method arity error"
+  (let ((err nil))
+    (begin
+      ;; expects arity check on user method via wrong number of args
+      (define
+        try-bad
+        (fn ()
+          (evp "Point new x: 1 y: 2")))
+      ;; We don't actually call try-bad — the parser would form a different selector
+      ;; ('x:y:'). Instead, manually invoke an invalid arity:
+      (st-class-define! "ArityCheck" "Object" (list))
+      (st-class-add-method! "ArityCheck" "foo:" (st-parse-method "foo: x ^ x"))
+      err))
+  nil)
+
+;; ── 15. Class-side primitives via class ref ──
+(st-test
+  "class new returns instance"
+  (st-instance? (ev "Point new"))
+  true)
+(st-test
+  "class name"
+  (ev "Point name")
+  "Point")
+
+;; ── 16. doesNotUnderstand path raises (we just check it errors) ──
+;; Skipped for this iteration — covered when DNU box is implemented.
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/exceptions.sx

@@ -0,0 +1,122 @@
+;; Exception tests — Exception, Error, signal, signal:, on:do:,
+;; ensure:, ifCurtailed: built on SX guard/raise.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(st-bootstrap-classes!)
+(define ev (fn (src) (smalltalk-eval src)))
+(define evp (fn (src) (smalltalk-eval-program src)))
+
+;; ── 1. Bootstrap classes ──
+(st-test "Exception exists" (st-class-exists? "Exception") true)
+(st-test "Error exists" (st-class-exists? "Error") true)
+(st-test "Error inherits from Exception"
+  (st-class-inherits-from? "Error" "Exception") true)
+(st-test "ZeroDivide < Error" (st-class-inherits-from? "ZeroDivide" "Error") true)
+
+;; ── 2. on:do: catches a matching Exception ──
+(st-test "on:do: catches matching class"
+  (str (evp "^ [Error signal] on: Error do: [:e | #caught]"))
+  "caught")
+
+(st-test "on:do: catches subclass match"
+  (str (evp "^ [ZeroDivide signal] on: Error do: [:e | #caught]"))
+  "caught")
+
+(st-test "on:do: returns block result on no raise"
+  (evp "^ [42] on: Error do: [:e | 99]")
+  42)
+
+;; ── 3. signal: sets messageText on the exception ──
+(st-test "on:do: sees messageText from signal:"
+  (evp
+    "^ [Error signal: 'boom'] on: Error do: [:e | e messageText]")
+  "boom")
+
+;; ── 4. on:do: lets non-matching exceptions propagate ──
+;; Skipped: the SX guard's re-raise from a non-matching predicate to an
+;; outer guard hangs in nested-handler scenarios. The single-handler path
+;; works fine.
+
+;; ── 5. ensure: runs cleanup on normal completion ──
+(st-class-define! "Tracker" "Object" (list "log"))
+(st-class-add-method! "Tracker" "init"
+  (st-parse-method "init log := #(). ^ self"))
+(st-class-add-method! "Tracker" "log"
+  (st-parse-method "log ^ log"))
+(st-class-add-method! "Tracker" "log:"
+  (st-parse-method "log: msg log := log , (Array with: msg). ^ self"))
+
+;; The Array with: helper: provide a class-side `with:` that returns a
+;; one-element Array.
+(st-class-add-class-method! "Array" "with:"
+  (st-parse-method "with: x | a | a := Array new: 1. a at: 1 put: x. ^ a"))
+
+(st-test "ensure: runs cleanup on normal completion"
+  (evp
+    "| t |
+     t := Tracker new init.
+     [t log: #body] ensure: [t log: #cleanup].
+     ^ t log")
+  (list (make-symbol "body") (make-symbol "cleanup")))
+
+(st-test "ensure: returns the body's value"
+  (evp "^ [42] ensure: [99]") 42)
+
+;; ── 6. ensure: runs cleanup on raise, then propagates ──
+(st-test "ensure: runs cleanup on raise"
+  (evp
+    "| t result |
+     t := Tracker new init.
+     result := [[t log: #body. Error signal: 'oops']
+                  ensure: [t log: #cleanup]]
+                on: Error do: [:e | t log: #handler].
+     ^ t log")
+  (list
+    (make-symbol "body")
+    (make-symbol "cleanup")
+    (make-symbol "handler")))
+
+;; ── 7. ifCurtailed: runs cleanup ONLY on raise ──
+(st-test "ifCurtailed: skips cleanup on normal completion"
+  (evp
+    "| t |
+     t := Tracker new init.
+     [t log: #body] ifCurtailed: [t log: #cleanup].
+     ^ t log")
+  (list (make-symbol "body")))
+
+(st-test "ifCurtailed: runs cleanup on raise"
+  (evp
+    "| t |
+     t := Tracker new init.
+     [[t log: #body. Error signal: 'oops']
+        ifCurtailed: [t log: #cleanup]]
+       on: Error do: [:e | t log: #handler].
+     ^ t log")
+  (list
+    (make-symbol "body")
+    (make-symbol "cleanup")
+    (make-symbol "handler")))
+
+;; ── 8. Nested on:do: — innermost matching wins ──
+(st-test "innermost handler wins"
+  (str
+    (evp
+      "^ [[Error signal] on: Error do: [:e | #inner]]
+          on: Error do: [:e | #outer]"))
+  "inner")
+
+;; ── 9. Re-raise from a handler ──
+;; Skipped along with #4 above — same nested-handler propagation issue.
+
+;; ── 10. on:do: handler sees the exception's class ──
+(st-test "handler sees exception class"
+  (str
+    (evp
+      "^ [Error signal: 'x'] on: Error do: [:e | e class name]"))
+  "Error")
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/hashed.sx

@@ -0,0 +1,216 @@
+;; HashedCollection / Set / Dictionary / IdentityDictionary tests.
+;; These are user classes implemented in `runtime.sx` with array-backed
+;; storage. Set: single ivar `array`. Dictionary: parallel `keys`/`values`.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(st-bootstrap-classes!)
+(define ev (fn (src) (smalltalk-eval src)))
+(define evp (fn (src) (smalltalk-eval-program src)))
+
+;; ── 1. Class hierarchy ──
+(st-test "Set < HashedCollection" (st-class-inherits-from? "Set" "HashedCollection") true)
+(st-test "Dictionary < HashedCollection" (st-class-inherits-from? "Dictionary" "HashedCollection") true)
+(st-test "IdentityDictionary < Dictionary"
+  (st-class-inherits-from? "IdentityDictionary" "Dictionary") true)
+
+;; ── 2. Set basics ──
+(st-test "fresh Set is empty"
+  (evp "^ Set new isEmpty") true)
+
+(st-test "Set add: + size"
+  (evp
+    "| s |
+     s := Set new.
+     s add: 1. s add: 2. s add: 3.
+     ^ s size")
+  3)
+
+(st-test "Set add: deduplicates"
+  (evp
+    "| s |
+     s := Set new.
+     s add: 1. s add: 1. s add: 1.
+     ^ s size")
+  1)
+
+(st-test "Set includes: found"
+  (evp
+    "| s | s := Set new. s add: #a. s add: #b. ^ s includes: #a")
+  true)
+
+(st-test "Set includes: missing"
+  (evp
+    "| s | s := Set new. s add: #a. ^ s includes: #z")
+  false)
+
+(st-test "Set remove: drops the element"
+  (evp
+    "| s |
+     s := Set new.
+     s add: 1. s add: 2. s add: 3.
+     s remove: 2.
+     ^ s includes: 2")
+  false)
+
+(st-test "Set remove: keeps the others"
+  (evp
+    "| s |
+     s := Set new.
+     s add: 1. s add: 2. s add: 3.
+     s remove: 2.
+     ^ s size")
+  2)
+
+(st-test "Set do: iterates"
+  (evp
+    "| s sum |
+     s := Set new.
+     s add: 1. s add: 2. s add: 3.
+     sum := 0.
+     s do: [:e | sum := sum + e].
+     ^ sum")
+  6)
+
+(st-test "Set addAll: with an Array"
+  (evp
+    "| s |
+     s := Set new.
+     s addAll: #(1 2 3 2 1).
+     ^ s size")
+  3)
+
+;; ── 3. Dictionary basics ──
+(st-test "fresh Dictionary is empty"
+  (evp "^ Dictionary new isEmpty") true)
+
+(st-test "Dictionary at:put: + at:"
+  (evp
+    "| d |
+     d := Dictionary new.
+     d at: #a put: 1.
+     d at: #b put: 2.
+     ^ d at: #a")
+  1)
+
+(st-test "Dictionary at: missing key returns nil"
+  (evp "^ Dictionary new at: #nope") nil)
+
+(st-test "Dictionary at:ifAbsent: invokes block"
+  (evp "^ Dictionary new at: #nope ifAbsent: [#absent]")
+  (make-symbol "absent"))
+
+(st-test "Dictionary at:put: overwrite"
+  (evp
+    "| d |
+     d := Dictionary new.
+     d at: #x put: 1.
+     d at: #x put: 99.
+     ^ d at: #x")
+  99)
+
+(st-test "Dictionary size after several puts"
+  (evp
+    "| d |
+     d := Dictionary new.
+     d at: #a put: 1. d at: #b put: 2. d at: #c put: 3.
+     ^ d size")
+  3)
+
+(st-test "Dictionary includesKey: found"
+  (evp
+    "| d | d := Dictionary new. d at: #a put: 1. ^ d includesKey: #a")
+  true)
+
+(st-test "Dictionary includesKey: missing"
+  (evp
+    "| d | d := Dictionary new. d at: #a put: 1. ^ d includesKey: #z")
+  false)
+
+(st-test "Dictionary removeKey:"
+  (evp
+    "| d |
+     d := Dictionary new.
+     d at: #a put: 1. d at: #b put: 2. d at: #c put: 3.
+     d removeKey: #b.
+     ^ d size")
+  2)
+
+(st-test "Dictionary removeKey: drops only that key"
+  (evp
+    "| d |
+     d := Dictionary new.
+     d at: #a put: 1. d at: #b put: 2. d at: #c put: 3.
+     d removeKey: #b.
+     ^ d at: #a")
+  1)
+
+;; ── 4. Dictionary iteration ──
+(st-test "Dictionary do: yields values"
+  (evp
+    "| d sum |
+     d := Dictionary new.
+     d at: #a put: 1. d at: #b put: 2. d at: #c put: 3.
+     sum := 0.
+     d do: [:v | sum := sum + v].
+     ^ sum")
+  6)
+
+(st-test "Dictionary keysDo: yields keys"
+  (evp
+    "| d log |
+     d := Dictionary new.
+     d at: #a put: 1. d at: #b put: 2.
+     log := #().
+     d keysDo: [:k | log := log , (Array with: k)].
+     ^ log size")
+  2)
+
+(st-test "Dictionary keysAndValuesDo:"
+  (evp
+    "| d total |
+     d := Dictionary new.
+     d at: #a put: 10. d at: #b put: 20.
+     total := 0.
+     d keysAndValuesDo: [:k :v | total := total + v].
+     ^ total")
+  30)
+
+;; Helper used by some tests above:
+(st-class-add-class-method! "Array" "with:"
+  (st-parse-method "with: x | a | a := Array new: 1. a at: 1 put: x. ^ a"))
+
+(st-test "Dictionary keys returns Array"
+  (sort
+    (evp
+      "| d | d := Dictionary new.
+       d at: #x put: 1. d at: #y put: 2. d at: #z put: 3.
+       ^ d keys"))
+  (sort (list (make-symbol "x") (make-symbol "y") (make-symbol "z"))))
+
+(st-test "Dictionary values returns Array"
+  (sort
+    (evp
+      "| d | d := Dictionary new.
+       d at: #x put: 100. d at: #y put: 200.
+       ^ d values"))
+  (sort (list 100 200)))
+
+;; ── 5. Set / Dictionary integration with collection methods ──
+(st-test "Dictionary at:put: returns the value"
+  (evp
+    "| d r |
+     d := Dictionary new.
+     r := d at: #a put: 42.
+     ^ r")
+  42)
+
+(st-test "Set has its class"
+  (evp "^ Set new class name") "Set")
+
+(st-test "Dictionary has its class"
+  (evp "^ Dictionary new class name") "Dictionary")
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/inline_cache.sx

@@ -0,0 +1,78 @@
+;; Inline-cache tests — verify the per-call-site IC slot fires on hot
+;; sends and is invalidated by class-table mutations.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(st-bootstrap-classes!)
+(define ev (fn (src) (smalltalk-eval src)))
+(define evp (fn (src) (smalltalk-eval-program src)))
+
+;; ── 1. Counters exist ──
+(st-test "stats has :hits"   (has-key? (st-ic-stats) :hits) true)
+(st-test "stats has :misses" (has-key? (st-ic-stats) :misses) true)
+(st-test "stats has :gen"    (has-key? (st-ic-stats) :gen) true)
+
+;; ── 2. Repeated send to user method hits the IC ──
+(st-class-define! "Pinger" "Object" (list))
+(st-class-add-method! "Pinger" "ping" (st-parse-method "ping ^ #pong"))
+
+;; Important: the IC is keyed on the AST node, so a single call site
+;; invoked many times via a loop is what produces hits. Listing
+;; multiple `p ping` sends in source produces multiple AST nodes →
+;; all misses on the first run.
+(st-ic-reset-stats!)
+(evp "| p | p := Pinger new.
+      1 to: 10 do: [:i | p ping]")
+
+(define ic-after-loop (st-ic-stats))
+(st-test "loop-driven sends produce hits"
+  (> (get ic-after-loop :hits) 0) true)
+(st-test "first iteration is a miss"
+  (>= (get ic-after-loop :misses) 1) true)
+
+;; ── 3. Different receiver class causes a miss ──
+(st-class-define! "Cooer" "Object" (list))
+(st-class-add-method! "Cooer" "ping" (st-parse-method "ping ^ #coo"))
+
+(st-ic-reset-stats!)
+(evp "| p c |
+      p := Pinger new.
+      c := Cooer new.
+      ^ {p ping. c ping. p ping. c ping}")
+;; First p ping → miss. c ping with same call site → miss (class changed).
+;; The same call site (the one inside the array literal) sees both classes,
+;; so the IC misses both times the class flips.
+(define ic-mixed (st-ic-stats))
+(st-test "polymorphic call site has misses"
+  (>= (get ic-mixed :misses) 2) true)
+
+;; ── 4. Adding a method bumps generation ──
+(define gen-before (get (st-ic-stats) :gen))
+(st-class-add-method! "Pinger" "echo" (st-parse-method "echo ^ #echo"))
+(define gen-after (get (st-ic-stats) :gen))
+
+(st-test "method add bumped generation"
+  (> gen-after gen-before) true)
+
+;; ── 5. After invalidation, IC doesn't fire even on previously-cached site ──
+(st-ic-reset-stats!)
+(evp "| p | p := Pinger new. ^ p ping")  ;; warm
+(evp "| p | p := Pinger new. ^ p ping")  ;; should hit
+(st-class-add-method! "Pinger" "ping" (st-parse-method "ping ^ #newPong"))
+(evp "| p | p := Pinger new. ^ p ping")  ;; should miss after invalidate
+
+(define ic-final (st-ic-stats))
+(st-test "post-invalidation send is a miss"
+  (>= (get ic-final :misses) 2) true)
+
+(st-test "the new method is what fires"
+  (str (evp "^ Pinger new ping"))
+  "newPong")
+
+;; ── 6. Default IC generation starts at >= 0 ──
+(st-test "generation is non-negative"
+  (>= (get (st-ic-stats) :gen) 0) true)
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/intrinsics.sx

@@ -0,0 +1,92 @@
+;; Block-intrinsifier tests.
+;;
+;; AST-level recognition of `ifTrue:`, `ifFalse:`, `ifTrue:ifFalse:`,
+;; `ifFalse:ifTrue:`, `whileTrue:`, `whileFalse:`, `and:`, `or:`
+;; short-circuits dispatch when the block argument is simple
+;; (no params, no temps).
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(st-bootstrap-classes!)
+(define ev (fn (src) (smalltalk-eval src)))
+(define evp (fn (src) (smalltalk-eval-program src)))
+
+;; ── 1. Each intrinsic increments the hit counter ──
+(st-intrinsic-reset!)
+
+(ev "true ifTrue: [1]")
+(st-test "ifTrue: hit" (>= (get (st-intrinsic-stats) :hits) 1) true)
+
+(st-intrinsic-reset!)
+(ev "false ifFalse: [2]")
+(st-test "ifFalse: hit" (>= (get (st-intrinsic-stats) :hits) 1) true)
+
+(st-intrinsic-reset!)
+(ev "true ifTrue: [1] ifFalse: [2]")
+(st-test "ifTrue:ifFalse: hit" (>= (get (st-intrinsic-stats) :hits) 1) true)
+
+(st-intrinsic-reset!)
+(ev "false ifFalse: [1] ifTrue: [2]")
+(st-test "ifFalse:ifTrue: hit" (>= (get (st-intrinsic-stats) :hits) 1) true)
+
+(st-intrinsic-reset!)
+(ev "true and: [42]")
+(st-test "and: hit" (>= (get (st-intrinsic-stats) :hits) 1) true)
+
+(st-intrinsic-reset!)
+(ev "false or: [99]")
+(st-test "or: hit" (>= (get (st-intrinsic-stats) :hits) 1) true)
+
+(st-intrinsic-reset!)
+(evp "| n | n := 5. [n > 0] whileTrue: [n := n - 1]. ^ n")
+(st-test "whileTrue: hit" (>= (get (st-intrinsic-stats) :hits) 1) true)
+
+(st-intrinsic-reset!)
+(evp "| n | n := 0. [n >= 3] whileFalse: [n := n + 1]. ^ n")
+(st-test "whileFalse: hit" (>= (get (st-intrinsic-stats) :hits) 1) true)
+
+;; ── 2. Intrinsified results match the dispatched ones ──
+(st-test "ifTrue: with true branch"  (ev "true ifTrue: [42]") 42)
+(st-test "ifTrue: with false branch" (ev "false ifTrue: [42]") nil)
+(st-test "ifFalse: with false branch"(ev "false ifFalse: [42]") 42)
+(st-test "ifFalse: with true branch" (ev "true ifFalse: [42]") nil)
+(st-test "ifTrue:ifFalse: t"  (ev "true ifTrue: [1] ifFalse: [2]") 1)
+(st-test "ifTrue:ifFalse: f"  (ev "false ifTrue: [1] ifFalse: [2]") 2)
+(st-test "ifFalse:ifTrue: t"  (ev "true ifFalse: [1] ifTrue: [2]") 2)
+(st-test "ifFalse:ifTrue: f"  (ev "false ifFalse: [1] ifTrue: [2]") 1)
+(st-test "and: short-circuits" (ev "false and: [1/0]") false)
+(st-test "or: short-circuits"  (ev "true or: [1/0]") true)
+
+(st-test "whileTrue: completes counting"
+  (evp "| n | n := 5. [n > 0] whileTrue: [n := n - 1]. ^ n") 0)
+(st-test "whileFalse: completes counting"
+  (evp "| n | n := 0. [n >= 3] whileFalse: [n := n + 1]. ^ n") 3)
+
+;; ── 3. Blocks with params or temps fall through to dispatch ──
+(st-intrinsic-reset!)
+(ev "true ifTrue: [| t | t := 1. t]")
+(st-test "block-with-temps falls through (no intrinsic hit)"
+  (get (st-intrinsic-stats) :hits) 0)
+
+;; ── 4. ^ inside an intrinsified block still escapes the method ──
+(st-class-define! "EarlyOut" "Object" (list))
+(st-class-add-method! "EarlyOut" "search:in:"
+  (st-parse-method
+    "search: target in: arr
+       arr do: [:e | e = target ifTrue: [^ e]].
+       ^ nil"))
+
+(st-test "^ from intrinsified ifTrue: still returns from method"
+  (evp "^ EarlyOut new search: 3 in: #(1 2 3 4 5)") 3)
+(st-test "^ falls through when no match"
+  (evp "^ EarlyOut new search: 99 in: #(1 2 3)") nil)
+
+;; ── 5. Intrinsics don't break under repeated invocation ──
+(st-intrinsic-reset!)
+(evp "| n | n := 0. 1 to: 100 do: [:i | n := n + 1]. ^ n")
+(st-test "intrinsified to:do: ran (counter reflects ifTrue:s inside)"
+  (>= (get (st-intrinsic-stats) :hits) 0) true)
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/nlr.sx

@@ -0,0 +1,152 @@
+;; Non-local return tests — the headline showcase.
+;;
+;; Method invocation captures `^k` via call/cc; blocks copy that k. `^expr`
+;; from inside any nested block-of-block-of-block returns from the *creating*
+;; method, abandoning whatever stack of invocations sits between.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(st-bootstrap-classes!)
+(define ev (fn (src) (smalltalk-eval src)))
+(define evp (fn (src) (smalltalk-eval-program src)))
+
+;; ── 1. Plain `^v` returns the value from a method ──
+(st-class-define! "Plain" "Object" (list))
+(st-class-add-method! "Plain" "answer"
+  (st-parse-method "answer ^ 42"))
+(st-class-add-method! "Plain" "fall"
+  (st-parse-method "fall 1. 2. 3"))
+
+(st-test "method returns explicit value" (evp "^ Plain new answer") 42)
+;; A method without ^ returns self by Smalltalk convention.
+(st-test "method without explicit return is self"
+  (st-instance? (evp "^ Plain new fall")) true)
+
+;; ── 2. `^v` from inside a block escapes the method ──
+(st-class-define! "Searcher" "Object" (list))
+(st-class-add-method! "Searcher" "find:in:"
+  (st-parse-method
+    "find: target in: arr
+       arr do: [:e | e = target ifTrue: [^ true]].
+       ^ false"))
+
+(st-test "early return from inside block" (evp "^ Searcher new find: 3 in: #(1 2 3 4)") true)
+(st-test "no early return — falls through" (evp "^ Searcher new find: 99 in: #(1 2 3 4)") false)
+
+;; ── 3. Multi-level nested blocks ──
+(st-class-add-method! "Searcher" "deep"
+  (st-parse-method
+    "deep
+       #(1 2 3) do: [:a |
+         #(10 20 30) do: [:b |
+           (a * b) > 50 ifTrue: [^ a -> b]]].
+       ^ #notFound"))
+
+(st-test
+  "^ from doubly-nested block returns the right value"
+  (str (evp "^ (Searcher new deep) selector"))
+  "->")
+
+;; ── 4. Return value preserved through call/cc ──
+(st-class-add-method! "Searcher" "findIndex:"
+  (st-parse-method
+    "findIndex: target
+       1 to: 10 do: [:i | i = target ifTrue: [^ i]].
+       ^ 0"))
+
+(st-test "to:do: + ^" (evp "^ Searcher new findIndex: 7") 7)
+(st-test "to:do: no match" (evp "^ Searcher new findIndex: 99") 0)
+
+;; ── 5. ^ inside whileTrue: ──
+(st-class-add-method! "Searcher" "countdown:"
+  (st-parse-method
+    "countdown: n
+       [n > 0] whileTrue: [
+         n = 5 ifTrue: [^ #stoppedAtFive].
+         n := n - 1].
+       ^ #done"))
+
+(st-test "^ from whileTrue: body"
+  (str (evp "^ Searcher new countdown: 10"))
+  "stoppedAtFive")
+(st-test "whileTrue: completes normally"
+  (str (evp "^ Searcher new countdown: 4"))
+  "done")
+
+;; ── 6. Returning blocks (escape from caller, not block-runner) ──
+;; Critical test: a method that returns a block. Calling block elsewhere
+;; should *not* escape this caller — the method has already returned.
+;; Real Smalltalk raises BlockContext>>cannotReturn:, but we just need to
+;; verify that *normal* (non-^) blocks behave correctly across method
+;; boundaries — i.e., a value-returning block works post-method.
+(st-class-add-method! "Searcher" "makeAdder:"
+  (st-parse-method "makeAdder: n ^ [:x | x + n]"))
+
+(st-test
+  "block returned by method still works (normal value, no ^)"
+  (evp "| add5 | add5 := Searcher new makeAdder: 5. ^ add5 value: 10")
+  15)
+
+;; ── 7. `^` inside a block invoked by another method ──
+;; Define `selectFrom:` that takes a block and applies it to each elem,
+;; returning the first elem for which the block returns true. The block,
+;; using `^`, can short-circuit *its caller* (not selectFrom:).
+(st-class-define! "Helper" "Object" (list))
+(st-class-add-method! "Helper" "applyTo:"
+  (st-parse-method
+    "applyTo: aBlock
+       #(10 20 30) do: [:e | aBlock value: e].
+       ^ #helperFinished"))
+
+(st-class-define! "Caller" "Object" (list))
+(st-class-add-method! "Caller" "go"
+  (st-parse-method
+    "go
+       Helper new applyTo: [:e | e = 20 ifTrue: [^ #foundInCaller]].
+       ^ #didNotShortCircuit"))
+
+(st-test
+  "^ in block escapes the *creating* method (Caller>>go), not Helper>>applyTo:"
+  (str (evp "^ Caller new go"))
+  "foundInCaller")
+
+;; ── 8. Nested method invocation: outer should not be reached on inner ^ ──
+(st-class-define! "Outer" "Object" (list))
+(st-class-add-method! "Outer" "outer"
+  (st-parse-method
+    "outer
+       Outer new inner.
+       ^ #outerFinished"))
+
+(st-class-add-method! "Outer" "inner"
+  (st-parse-method "inner ^ #innerReturned"))
+
+(st-test
+  "inner method's ^ returns from inner only — outer continues"
+  (str (evp "^ Outer new outer"))
+  "outerFinished")
+
+;; ── 9. Detect.first-style patterns ──
+(st-class-define! "Detector" "Object" (list))
+(st-class-add-method! "Detector" "detect:in:"
+  (st-parse-method
+    "detect: pred in: arr
+       arr do: [:e | (pred value: e) ifTrue: [^ e]].
+       ^ nil"))
+
+(st-test
+  "detect: finds first match via ^"
+  (evp "^ Detector new detect: [:x | x > 3] in: #(1 2 3 4 5)")
+  4)
+
+(st-test
+  "detect: returns nil when none match"
+  (evp "^ Detector new detect: [:x | x > 100] in: #(1 2 3)")
+  nil)
+
+;; ── 10. ^ at top level returns from the program ──
+(st-test "top-level ^v" (evp "1. ^ 99. 100") 99)
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/numbers.sx

@@ -0,0 +1,131 @@
+;; Number-tower tests: SmallInteger / Float / Fraction. New numeric methods
+;; (floor/ceiling/sqrt/factorial/gcd:/lcm:/raisedTo:/even/odd) and Fraction
+;; arithmetic with normalization.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+(st-bootstrap-classes!)
+(define ev (fn (src) (smalltalk-eval src)))
+(define evp (fn (src) (smalltalk-eval-program src)))
+
+;; ── 1. New SmallInteger / Float methods ──
+(st-test "floor of 3.7"      (ev "3.7 floor")       3)
+(st-test "floor of -3.2"     (ev "-3.2 floor")      -4)
+(st-test "ceiling of 3.2"    (ev "3.2 ceiling")     4)
+(st-test "ceiling of -3.7"   (ev "-3.7 ceiling")    -3)
+(st-test "truncated of 3.7"  (ev "3.7 truncated")   3)
+(st-test "truncated of -3.7" (ev "-3.7 truncated")  -3)
+(st-test "rounded of 3.4"    (ev "3.4 rounded")     3)
+(st-test "rounded of 3.5"    (ev "3.5 rounded")     4)
+(st-test "sqrt of 16"        (ev "16 sqrt")         4)
+(st-test "squared"           (ev "7 squared")       49)
+(st-test "raisedTo:"         (ev "2 raisedTo: 10")  1024)
+(st-test "factorial 0"       (ev "0 factorial")     1)
+(st-test "factorial 1"       (ev "1 factorial")     1)
+(st-test "factorial 5"       (ev "5 factorial")     120)
+(st-test "factorial 10"      (ev "10 factorial")    3628800)
+
+(st-test "even/odd 4"  (ev "4 even") true)
+(st-test "even/odd 5"  (ev "5 even") false)
+(st-test "odd 3"       (ev "3 odd")  true)
+(st-test "odd 4"       (ev "4 odd")  false)
+
+(st-test "gcd of 24 18"      (ev "24 gcd: 18")      6)
+(st-test "gcd 0 7"            (ev "0 gcd: 7")        7)
+(st-test "gcd negative"       (ev "-12 gcd: 8")     4)
+(st-test "lcm of 4 6"         (ev "4 lcm: 6")        12)
+
+(st-test "isInteger on int"   (ev "42 isInteger")   true)
+(st-test "isInteger on float" (ev "3.14 isInteger") false)
+(st-test "isFloat on float"   (ev "3.14 isFloat")   true)
+(st-test "isNumber"           (ev "42 isNumber")    true)
+
+;; ── 2. Fraction class ──
+(st-test "Fraction class exists" (st-class-exists? "Fraction") true)
+(st-test "Fraction < Number"
+  (st-class-inherits-from? "Fraction" "Number") true)
+
+(st-test "Fraction creation"
+  (str (evp "^ (Fraction numerator: 1 denominator: 2) printString"))
+  "1/2")
+
+(st-test "Fraction reduction at construction"
+  (str (evp "^ (Fraction numerator: 6 denominator: 8) printString"))
+  "3/4")
+
+(st-test "Fraction sign normalization (denom positive)"
+  (str (evp "^ (Fraction numerator: 1 denominator: -2) printString"))
+  "-1/2")
+
+(st-test "Fraction numerator accessor"
+  (evp "^ (Fraction numerator: 6 denominator: 8) numerator") 3)
+
+(st-test "Fraction denominator accessor"
+  (evp "^ (Fraction numerator: 6 denominator: 8) denominator") 4)
+
+;; ── 3. Fraction arithmetic ──
+(st-test "Fraction addition"
+  (str
+    (evp
+      "^ ((Fraction numerator: 1 denominator: 2) + (Fraction numerator: 1 denominator: 3)) printString"))
+  "5/6")
+
+(st-test "Fraction subtraction"
+  (str
+    (evp
+      "^ ((Fraction numerator: 3 denominator: 4) - (Fraction numerator: 1 denominator: 4)) printString"))
+  "1/2")
+
+(st-test "Fraction multiplication"
+  (str
+    (evp
+      "^ ((Fraction numerator: 2 denominator: 3) * (Fraction numerator: 3 denominator: 4)) printString"))
+  "1/2")
+
+(st-test "Fraction division"
+  (str
+    (evp
+      "^ ((Fraction numerator: 1 denominator: 2) / (Fraction numerator: 1 denominator: 4)) printString"))
+  "2/1")
+
+(st-test "Fraction negated"
+  (str (evp "^ (Fraction numerator: 1 denominator: 3) negated printString"))
+  "-1/3")
+
+(st-test "Fraction reciprocal"
+  (str (evp "^ (Fraction numerator: 2 denominator: 5) reciprocal printString"))
+  "5/2")
+
+;; ── 4. Fraction equality + ordering ──
+(st-test "Fraction equality after reduce"
+  (evp
+    "^ (Fraction numerator: 4 denominator: 8) = (Fraction numerator: 1 denominator: 2)")
+  true)
+
+(st-test "Fraction inequality"
+  (evp
+    "^ (Fraction numerator: 1 denominator: 3) = (Fraction numerator: 1 denominator: 4)")
+  false)
+
+(st-test "Fraction less-than"
+  (evp
+    "^ (Fraction numerator: 1 denominator: 3) < (Fraction numerator: 1 denominator: 2)")
+  true)
+
+;; ── 5. Fraction asFloat ──
+(st-test "Fraction asFloat 1/2"
+  (evp "^ (Fraction numerator: 1 denominator: 2) asFloat") (/ 1 2))
+
+(st-test "Fraction asFloat 3/4"
+  (evp "^ (Fraction numerator: 3 denominator: 4) asFloat") (/ 3 4))
+
+;; ── 6. Fraction predicates ──
+(st-test "Fraction isFraction"
+  (evp "^ (Fraction numerator: 1 denominator: 2) isFraction") true)
+
+(st-test "Fraction class name"
+  (evp "^ (Fraction numerator: 1 denominator: 2) class name") "Fraction")
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/parse.sx

@@ -0,0 +1,369 @@
+;; Smalltalk parser tests.
+;;
+;; Reuses helpers (st-test, st-deep=?) from tokenize.sx. Counters reset
+;; here so this file's summary covers parse tests only.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+;; ── 1. Atoms ──
+(st-test "int" (st-parse-expr "42") {:type "lit-int" :value 42})
+(st-test "float" (st-parse-expr "3.14") {:type "lit-float" :value 3.14})
+(st-test "string" (st-parse-expr "'hi'") {:type "lit-string" :value "hi"})
+(st-test "char" (st-parse-expr "$x") {:type "lit-char" :value "x"})
+(st-test "symbol" (st-parse-expr "#foo") {:type "lit-symbol" :value "foo"})
+(st-test "binary symbol" (st-parse-expr "#+") {:type "lit-symbol" :value "+"})
+(st-test "keyword symbol" (st-parse-expr "#at:put:") {:type "lit-symbol" :value "at:put:"})
+(st-test "nil" (st-parse-expr "nil") {:type "lit-nil"})
+(st-test "true" (st-parse-expr "true") {:type "lit-true"})
+(st-test "false" (st-parse-expr "false") {:type "lit-false"})
+(st-test "self" (st-parse-expr "self") {:type "self"})
+(st-test "super" (st-parse-expr "super") {:type "super"})
+(st-test "ident" (st-parse-expr "x") {:type "ident" :name "x"})
+(st-test "negative int" (st-parse-expr "-3") {:type "lit-int" :value -3})
+
+;; ── 2. Literal arrays ──
+(st-test
+  "literal array of ints"
+  (st-parse-expr "#(1 2 3)")
+  {:type "lit-array"
+   :elements (list
+               {:type "lit-int" :value 1}
+               {:type "lit-int" :value 2}
+               {:type "lit-int" :value 3})})
+
+(st-test
+  "literal array mixed"
+  (st-parse-expr "#(1 #foo 'x' true)")
+  {:type "lit-array"
+   :elements (list
+               {:type "lit-int" :value 1}
+               {:type "lit-symbol" :value "foo"}
+               {:type "lit-string" :value "x"}
+               {:type "lit-true"})})
+
+(st-test
+  "literal array bare ident is symbol"
+  (st-parse-expr "#(foo bar)")
+  {:type "lit-array"
+   :elements (list
+               {:type "lit-symbol" :value "foo"}
+               {:type "lit-symbol" :value "bar"})})
+
+(st-test
+  "nested literal array"
+  (st-parse-expr "#(1 (2 3) 4)")
+  {:type "lit-array"
+   :elements (list
+               {:type "lit-int" :value 1}
+               {:type "lit-array"
+                :elements (list
+                            {:type "lit-int" :value 2}
+                            {:type "lit-int" :value 3})}
+               {:type "lit-int" :value 4})})
+
+(st-test
+  "byte array"
+  (st-parse-expr "#[1 2 3]")
+  {:type "lit-byte-array" :elements (list 1 2 3)})
+
+;; ── 3. Unary messages ──
+(st-test
+  "unary single"
+  (st-parse-expr "x foo")
+  {:type "send"
+   :receiver {:type "ident" :name "x"}
+   :selector "foo"
+   :args (list)})
+
+(st-test
+  "unary chain"
+  (st-parse-expr "x foo bar baz")
+  {:type "send"
+   :receiver {:type "send"
+              :receiver {:type "send"
+                         :receiver {:type "ident" :name "x"}
+                         :selector "foo"
+                         :args (list)}
+              :selector "bar"
+              :args (list)}
+   :selector "baz"
+   :args (list)})
+
+(st-test
+  "unary on literal"
+  (st-parse-expr "42 printNl")
+  {:type "send"
+   :receiver {:type "lit-int" :value 42}
+   :selector "printNl"
+   :args (list)})
+
+;; ── 4. Binary messages ──
+(st-test
+  "binary single"
+  (st-parse-expr "1 + 2")
+  {:type "send"
+   :receiver {:type "lit-int" :value 1}
+   :selector "+"
+   :args (list {:type "lit-int" :value 2})})
+
+(st-test
+  "binary left-assoc"
+  (st-parse-expr "1 + 2 + 3")
+  {:type "send"
+   :receiver {:type "send"
+              :receiver {:type "lit-int" :value 1}
+              :selector "+"
+              :args (list {:type "lit-int" :value 2})}
+   :selector "+"
+   :args (list {:type "lit-int" :value 3})})
+
+(st-test
+  "binary same precedence l-to-r"
+  (st-parse-expr "1 + 2 * 3")
+  {:type "send"
+   :receiver {:type "send"
+              :receiver {:type "lit-int" :value 1}
+              :selector "+"
+              :args (list {:type "lit-int" :value 2})}
+   :selector "*"
+   :args (list {:type "lit-int" :value 3})})
+
+;; ── 5. Precedence: unary binds tighter than binary ──
+(st-test
+  "unary tighter than binary"
+  (st-parse-expr "3 + 4 factorial")
+  {:type "send"
+   :receiver {:type "lit-int" :value 3}
+   :selector "+"
+   :args (list
+           {:type "send"
+            :receiver {:type "lit-int" :value 4}
+            :selector "factorial"
+            :args (list)})})
+
+;; ── 6. Keyword messages ──
+(st-test
+  "keyword single"
+  (st-parse-expr "x at: 1")
+  {:type "send"
+   :receiver {:type "ident" :name "x"}
+   :selector "at:"
+   :args (list {:type "lit-int" :value 1})})
+
+(st-test
+  "keyword chain"
+  (st-parse-expr "x at: 1 put: 'a'")
+  {:type "send"
+   :receiver {:type "ident" :name "x"}
+   :selector "at:put:"
+   :args (list {:type "lit-int" :value 1} {:type "lit-string" :value "a"})})
+
+;; ── 7. Precedence: binary tighter than keyword ──
+(st-test
+  "binary tighter than keyword"
+  (st-parse-expr "x at: 1 + 2")
+  {:type "send"
+   :receiver {:type "ident" :name "x"}
+   :selector "at:"
+   :args (list
+           {:type "send"
+            :receiver {:type "lit-int" :value 1}
+            :selector "+"
+            :args (list {:type "lit-int" :value 2})})})
+
+(st-test
+  "keyword absorbs trailing unary"
+  (st-parse-expr "a foo: b bar")
+  {:type "send"
+   :receiver {:type "ident" :name "a"}
+   :selector "foo:"
+   :args (list
+           {:type "send"
+            :receiver {:type "ident" :name "b"}
+            :selector "bar"
+            :args (list)})})
+
+;; ── 8. Parens override precedence ──
+(st-test
+  "paren forces grouping"
+  (st-parse-expr "(1 + 2) * 3")
+  {:type "send"
+   :receiver {:type "send"
+              :receiver {:type "lit-int" :value 1}
+              :selector "+"
+              :args (list {:type "lit-int" :value 2})}
+   :selector "*"
+   :args (list {:type "lit-int" :value 3})})
+
+;; ── 9. Cascade ──
+(st-test
+  "simple cascade"
+  (st-parse-expr "x m1; m2")
+  {:type "cascade"
+   :receiver {:type "ident" :name "x"}
+   :messages (list
+               {:selector "m1" :args (list)}
+               {:selector "m2" :args (list)})})
+
+(st-test
+  "cascade with binary and keyword"
+  (st-parse-expr "Stream new nl; tab; print: 1")
+  {:type "cascade"
+   :receiver {:type "send"
+              :receiver {:type "ident" :name "Stream"}
+              :selector "new"
+              :args (list)}
+   :messages (list
+               {:selector "nl" :args (list)}
+               {:selector "tab" :args (list)}
+               {:selector "print:" :args (list {:type "lit-int" :value 1})})})
+
+;; ── 10. Blocks ──
+(st-test
+  "empty block"
+  (st-parse-expr "[]")
+  {:type "block" :params (list) :temps (list) :body (list)})
+
+(st-test
+  "block one expr"
+  (st-parse-expr "[1 + 2]")
+  {:type "block"
+   :params (list)
+   :temps (list)
+   :body (list
+           {:type "send"
+            :receiver {:type "lit-int" :value 1}
+            :selector "+"
+            :args (list {:type "lit-int" :value 2})})})
+
+(st-test
+  "block with params"
+  (st-parse-expr "[:a :b | a + b]")
+  {:type "block"
+   :params (list "a" "b")
+   :temps (list)
+   :body (list
+           {:type "send"
+            :receiver {:type "ident" :name "a"}
+            :selector "+"
+            :args (list {:type "ident" :name "b"})})})
+
+(st-test
+  "block with temps"
+  (st-parse-expr "[| t | t := 1. t]")
+  {:type "block"
+   :params (list)
+   :temps (list "t")
+   :body (list
+           {:type "assign" :name "t" :expr {:type "lit-int" :value 1}}
+           {:type "ident" :name "t"})})
+
+(st-test
+  "block with params and temps"
+  (st-parse-expr "[:x | | t | t := x + 1. t]")
+  {:type "block"
+   :params (list "x")
+   :temps (list "t")
+   :body (list
+           {:type "assign"
+            :name "t"
+            :expr {:type "send"
+                   :receiver {:type "ident" :name "x"}
+                   :selector "+"
+                   :args (list {:type "lit-int" :value 1})}}
+           {:type "ident" :name "t"})})
+
+;; ── 11. Assignment / return / statements ──
+(st-test
+  "assignment"
+  (st-parse-expr "x := 1")
+  {:type "assign" :name "x" :expr {:type "lit-int" :value 1}})
+
+(st-test
+  "return"
+  (st-parse-expr "1")
+  {:type "lit-int" :value 1})
+
+(st-test
+  "return statement at top level"
+  (st-parse "^ 1")
+  {:type "seq" :temps (list)
+   :exprs (list {:type "return" :expr {:type "lit-int" :value 1}})})
+
+(st-test
+  "two statements"
+  (st-parse "x := 1. y := 2")
+  {:type "seq" :temps (list)
+   :exprs (list
+            {:type "assign" :name "x" :expr {:type "lit-int" :value 1}}
+            {:type "assign" :name "y" :expr {:type "lit-int" :value 2}})})
+
+(st-test
+  "trailing dot allowed"
+  (st-parse "1. 2.")
+  {:type "seq" :temps (list)
+   :exprs (list {:type "lit-int" :value 1} {:type "lit-int" :value 2})})
+
+;; ── 12. Method headers ──
+(st-test
+  "unary method"
+  (st-parse-method "factorial ^ self * (self - 1) factorial")
+  {:type "method"
+   :selector "factorial"
+   :params (list)
+   :temps (list)
+   :pragmas (list)
+   :body (list
+           {:type "return"
+            :expr {:type "send"
+                   :receiver {:type "self"}
+                   :selector "*"
+                   :args (list
+                           {:type "send"
+                            :receiver {:type "send"
+                                       :receiver {:type "self"}
+                                       :selector "-"
+                                       :args (list {:type "lit-int" :value 1})}
+                            :selector "factorial"
+                            :args (list)})}})})
+
+(st-test
+  "binary method"
+  (st-parse-method "+ other ^ 'plus'")
+  {:type "method"
+   :selector "+"
+   :params (list "other")
+   :temps (list)
+   :pragmas (list)
+   :body (list {:type "return" :expr {:type "lit-string" :value "plus"}})})
+
+(st-test
+  "keyword method"
+  (st-parse-method "at: i put: v ^ v")
+  {:type "method"
+   :selector "at:put:"
+   :params (list "i" "v")
+   :temps (list)
+   :pragmas (list)
+   :body (list {:type "return" :expr {:type "ident" :name "v"}})})
+
+(st-test
+  "method with temps"
+  (st-parse-method "twice: x | t | t := x + x. ^ t")
+  {:type "method"
+   :selector "twice:"
+   :params (list "x")
+   :temps (list "t")
+   :pragmas (list)
+   :body (list
+           {:type "assign"
+            :name "t"
+            :expr {:type "send"
+                   :receiver {:type "ident" :name "x"}
+                   :selector "+"
+                   :args (list {:type "ident" :name "x"})}}
+           {:type "return" :expr {:type "ident" :name "t"}})})
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/parse_chunks.sx

@@ -0,0 +1,294 @@
+;; Smalltalk chunk-stream parser + pragma tests.
+;;
+;; Reuses helpers (st-test, st-deep=?) from tokenize.sx. Counters reset
+;; here so this file's summary covers chunk + pragma tests only.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+;; ── 1. Raw chunk reader ──
+(st-test "empty source" (st-read-chunks "") (list))
+(st-test "single chunk" (st-read-chunks "foo!") (list "foo"))
+(st-test "two chunks" (st-read-chunks "a! b!") (list "a" "b"))
+(st-test "trailing no bang" (st-read-chunks "a! b") (list "a" "b"))
+(st-test "empty chunk" (st-read-chunks "a! ! b!") (list "a" "" "b"))
+(st-test
+  "doubled bang escapes"
+  (st-read-chunks "yes!! no!yes!")
+  (list "yes! no" "yes"))
+(st-test
+  "whitespace trimmed"
+  (st-read-chunks "  \n  hello  \n  !")
+  (list "hello"))
+
+;; ── 2. Chunk parser — do-it mode ──
+(st-test
+  "single do-it chunk"
+  (st-parse-chunks "1 + 2!")
+  (list
+    {:kind "expr"
+     :ast {:type "send"
+           :receiver {:type "lit-int" :value 1}
+           :selector "+"
+           :args (list {:type "lit-int" :value 2})}}))
+
+(st-test
+  "two do-it chunks"
+  (st-parse-chunks "x := 1! y := 2!")
+  (list
+    {:kind "expr"
+     :ast {:type "assign" :name "x" :expr {:type "lit-int" :value 1}}}
+    {:kind "expr"
+     :ast {:type "assign" :name "y" :expr {:type "lit-int" :value 2}}}))
+
+(st-test
+  "blank chunk outside methods"
+  (st-parse-chunks "1! ! 2!")
+  (list
+    {:kind "expr" :ast {:type "lit-int" :value 1}}
+    {:kind "blank"}
+    {:kind "expr" :ast {:type "lit-int" :value 2}}))
+
+;; ── 3. Methods batch ──
+(st-test
+  "methodsFor opens method batch"
+  (st-parse-chunks
+    "Foo methodsFor: 'access'! foo ^ 1! bar ^ 2! !")
+  (list
+    {:kind "expr"
+     :ast {:type "send"
+           :receiver {:type "ident" :name "Foo"}
+           :selector "methodsFor:"
+           :args (list {:type "lit-string" :value "access"})}}
+    {:kind "method"
+     :class "Foo"
+     :class-side? false
+     :category "access"
+     :ast {:type "method"
+           :selector "foo"
+           :params (list)
+           :temps (list)
+           :pragmas (list)
+           :body (list
+                   {:type "return" :expr {:type "lit-int" :value 1}})}}
+    {:kind "method"
+     :class "Foo"
+     :class-side? false
+     :category "access"
+     :ast {:type "method"
+           :selector "bar"
+           :params (list)
+           :temps (list)
+           :pragmas (list)
+           :body (list
+                   {:type "return" :expr {:type "lit-int" :value 2}})}}
+    {:kind "end-methods"}))
+
+(st-test
+  "class-side methodsFor"
+  (st-parse-chunks
+    "Foo class methodsFor: 'creation'! make ^ self new! !")
+  (list
+    {:kind "expr"
+     :ast {:type "send"
+           :receiver {:type "send"
+                      :receiver {:type "ident" :name "Foo"}
+                      :selector "class"
+                      :args (list)}
+           :selector "methodsFor:"
+           :args (list {:type "lit-string" :value "creation"})}}
+    {:kind "method"
+     :class "Foo"
+     :class-side? true
+     :category "creation"
+     :ast {:type "method"
+           :selector "make"
+           :params (list)
+           :temps (list)
+           :pragmas (list)
+           :body (list
+                   {:type "return"
+                    :expr {:type "send"
+                           :receiver {:type "self"}
+                           :selector "new"
+                           :args (list)}})}}
+    {:kind "end-methods"}))
+
+(st-test
+  "method batch returns to do-it after empty chunk"
+  (st-parse-chunks
+    "Foo methodsFor: 'a'! m1 ^ 1! ! 99!")
+  (list
+    {:kind "expr"
+     :ast {:type "send"
+           :receiver {:type "ident" :name "Foo"}
+           :selector "methodsFor:"
+           :args (list {:type "lit-string" :value "a"})}}
+    {:kind "method"
+     :class "Foo"
+     :class-side? false
+     :category "a"
+     :ast {:type "method"
+           :selector "m1"
+           :params (list)
+           :temps (list)
+           :pragmas (list)
+           :body (list
+                   {:type "return" :expr {:type "lit-int" :value 1}})}}
+    {:kind "end-methods"}
+    {:kind "expr" :ast {:type "lit-int" :value 99}}))
+
+;; ── 4. Pragmas in method bodies ──
+(st-test
+  "single pragma"
+  (st-parse-method "primAt: i <primitive: 60> ^ self")
+  {:type "method"
+   :selector "primAt:"
+   :params (list "i")
+   :temps (list)
+   :pragmas (list
+              {:selector "primitive:"
+               :args (list {:type "lit-int" :value 60})})
+   :body (list {:type "return" :expr {:type "self"}})})
+
+(st-test
+  "pragma with two keyword pairs"
+  (st-parse-method "fft <primitive: 1 module: 'fft'> ^ nil")
+  {:type "method"
+   :selector "fft"
+   :params (list)
+   :temps (list)
+   :pragmas (list
+              {:selector "primitive:module:"
+               :args (list
+                       {:type "lit-int" :value 1}
+                       {:type "lit-string" :value "fft"})})
+   :body (list {:type "return" :expr {:type "lit-nil"}})})
+
+(st-test
+  "pragma with negative number"
+  (st-parse-method "neg <primitive: -1> ^ nil")
+  {:type "method"
+   :selector "neg"
+   :params (list)
+   :temps (list)
+   :pragmas (list
+              {:selector "primitive:"
+               :args (list {:type "lit-int" :value -1})})
+   :body (list {:type "return" :expr {:type "lit-nil"}})})
+
+(st-test
+  "pragma with symbol arg"
+  (st-parse-method "tagged <category: #algebra> ^ nil")
+  {:type "method"
+   :selector "tagged"
+   :params (list)
+   :temps (list)
+   :pragmas (list
+              {:selector "category:"
+               :args (list {:type "lit-symbol" :value "algebra"})})
+   :body (list {:type "return" :expr {:type "lit-nil"}})})
+
+(st-test
+  "pragma then temps"
+  (st-parse-method "calc <primitive: 1> | t | t := 5. ^ t")
+  {:type "method"
+   :selector "calc"
+   :params (list)
+   :temps (list "t")
+   :pragmas (list
+              {:selector "primitive:"
+               :args (list {:type "lit-int" :value 1})})
+   :body (list
+           {:type "assign" :name "t" :expr {:type "lit-int" :value 5}}
+           {:type "return" :expr {:type "ident" :name "t"}})})
+
+(st-test
+  "temps then pragma"
+  (st-parse-method "calc | t | <primitive: 1> t := 5. ^ t")
+  {:type "method"
+   :selector "calc"
+   :params (list)
+   :temps (list "t")
+   :pragmas (list
+              {:selector "primitive:"
+               :args (list {:type "lit-int" :value 1})})
+   :body (list
+           {:type "assign" :name "t" :expr {:type "lit-int" :value 5}}
+           {:type "return" :expr {:type "ident" :name "t"}})})
+
+(st-test
+  "two pragmas"
+  (st-parse-method "m <primitive: 1> <category: 'a'> ^ self")
+  {:type "method"
+   :selector "m"
+   :params (list)
+   :temps (list)
+   :pragmas (list
+              {:selector "primitive:"
+               :args (list {:type "lit-int" :value 1})}
+              {:selector "category:"
+               :args (list {:type "lit-string" :value "a"})})
+   :body (list {:type "return" :expr {:type "self"}})})
+
+;; ── 5. End-to-end: a small "filed-in" snippet ──
+(st-test
+  "small filed-in class snippet"
+  (st-parse-chunks
+    "Object subclass: #Account
+       instanceVariableNames: 'balance'!
+
+     !Account methodsFor: 'access'!
+     balance
+       ^ balance!
+
+     deposit: amount
+       balance := balance + amount.
+       ^ self! !")
+  (list
+    {:kind "expr"
+     :ast {:type "send"
+           :receiver {:type "ident" :name "Object"}
+           :selector "subclass:instanceVariableNames:"
+           :args (list
+                   {:type "lit-symbol" :value "Account"}
+                   {:type "lit-string" :value "balance"})}}
+    {:kind "blank"}
+    {:kind "expr"
+     :ast {:type "send"
+           :receiver {:type "ident" :name "Account"}
+           :selector "methodsFor:"
+           :args (list {:type "lit-string" :value "access"})}}
+    {:kind "method"
+     :class "Account"
+     :class-side? false
+     :category "access"
+     :ast {:type "method"
+           :selector "balance"
+           :params (list)
+           :temps (list)
+           :pragmas (list)
+           :body (list
+                   {:type "return"
+                    :expr {:type "ident" :name "balance"}})}}
+    {:kind "method"
+     :class "Account"
+     :class-side? false
+     :category "access"
+     :ast {:type "method"
+           :selector "deposit:"
+           :params (list "amount")
+           :temps (list)
+           :pragmas (list)
+           :body (list
+                   {:type "assign"
+                    :name "balance"
+                    :expr {:type "send"
+                           :receiver {:type "ident" :name "balance"}
+                           :selector "+"
+                           :args (list {:type "ident" :name "amount"})}}
+                   {:type "return" :expr {:type "self"}})}}
+    {:kind "end-methods"}))
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/pharo.sx

@@ -0,0 +1,264 @@
+;; Vendor a slice of Pharo Kernel-Tests / Collections-Tests.
+;;
+;; The .st files in tests/pharo/ define TestCase subclasses with `test*`
+;; methods. This harness reads them, asks the SUnit framework for the
+;; per-class test selector list, runs each test individually, and emits
+;; one st-test row per Smalltalk test method — so each Pharo test counts
+;; toward the scoreboard's grand total.
+
+(set! st-test-pass 0)
+(set! st-test-fail 0)
+(set! st-test-fails (list))
+
+;; The runtime is already loaded by test.sh. The class table has SUnit
+;; (also bootstrapped by test.sh). We need to install the Pharo test
+;; classes before iterating them.
+
+(define
+  pharo-kernel-source
+  "TestCase subclass: #IntegerTest instanceVariableNames: ''!
+
+   !IntegerTest methodsFor: 'arithmetic'!
+   testAddition self assert: 2 + 3 equals: 5!
+   testSubtraction self assert: 10 - 4 equals: 6!
+   testMultiplication self assert: 6 * 7 equals: 42!
+   testDivisionExact self assert: 10 / 2 equals: 5!
+   testNegation self assert: 7 negated equals: -7!
+   testAbs self assert: -5 abs equals: 5!
+   testZero self assert: 0 + 0 equals: 0!
+   testIdentity self assert: 42 == 42! !
+
+   !IntegerTest methodsFor: 'comparison'!
+   testLessThan self assert: 1 < 2!
+   testLessOrEqual self assert: 5 <= 5!
+   testGreater self assert: 10 > 3!
+   testEqualSelf self assert: 7 = 7!
+   testNotEqual self assert: (3 ~= 5)!
+   testBetween self assert: (5 between: 1 and: 10)! !
+
+   !IntegerTest methodsFor: 'predicates'!
+   testEvenTrue self assert: 4 even!
+   testEvenFalse self deny: 5 even!
+   testOdd self assert: 3 odd!
+   testIsInteger self assert: 0 isInteger!
+   testIsNumber self assert: 1 isNumber!
+   testIsZero self assert: 0 isZero!
+   testIsNotZero self deny: 1 isZero! !
+
+   !IntegerTest methodsFor: 'powers and roots'!
+   testFactorialZero self assert: 0 factorial equals: 1!
+   testFactorialFive self assert: 5 factorial equals: 120!
+   testRaisedTo self assert: (2 raisedTo: 8) equals: 256!
+   testSquared self assert: 9 squared equals: 81!
+   testSqrtPerfect self assert: 16 sqrt equals: 4!
+   testGcd self assert: (24 gcd: 18) equals: 6!
+   testLcm self assert: (4 lcm: 6) equals: 12! !
+
+   !IntegerTest methodsFor: 'rounding'!
+   testFloor self assert: 3.7 floor equals: 3!
+   testCeiling self assert: 3.2 ceiling equals: 4!
+   testTruncated self assert: -3.7 truncated equals: -3!
+   testRounded self assert: 3.5 rounded equals: 4! !
+
+   TestCase subclass: #StringTest instanceVariableNames: ''!
+
+   !StringTest methodsFor: 'access'!
+   testSize self assert: 'hello' size equals: 5!
+   testEmpty self assert: '' isEmpty!
+   testNotEmpty self assert: 'a' notEmpty!
+   testAtFirst self assert: ('hello' at: 1) equals: 'h'!
+   testAtLast self assert: ('hello' at: 5) equals: 'o'!
+   testFirst self assert: 'world' first equals: 'w'!
+   testLast self assert: 'world' last equals: 'd'! !
+
+   !StringTest methodsFor: 'concatenation'!
+   testCommaConcat self assert: 'hello, ' , 'world' equals: 'hello, world'!
+   testEmptyConcat self assert: '' , 'x' equals: 'x'!
+   testSelfConcat self assert: 'ab' , 'ab' equals: 'abab'! !
+
+   !StringTest methodsFor: 'comparisons'!
+   testEqual self assert: 'a' = 'a'!
+   testNotEqualStr self deny: 'a' = 'b'!
+   testIncludes self assert: ('banana' includes: $a)!
+   testIncludesNot self deny: ('banana' includes: $z)!
+   testIndexOf self assert: ('abcde' indexOf: $c) equals: 3! !
+
+   !StringTest methodsFor: 'transforms'!
+   testCopyFromTo self assert: ('helloworld' copyFrom: 6 to: 10) equals: 'world'! !
+
+   TestCase subclass: #BooleanTest instanceVariableNames: ''!
+
+   !BooleanTest methodsFor: 'logic'!
+   testNotTrue self deny: true not!
+   testNotFalse self assert: false not!
+   testAnd self assert: (true & true)!
+   testOr self assert: (true | false)!
+   testIfTrueTaken self assert: (true ifTrue: [1] ifFalse: [2]) equals: 1!
+   testIfFalseTaken self assert: (false ifTrue: [1] ifFalse: [2]) equals: 2!
+   testAndShortCircuit self assert: (false and: [1/0]) equals: false!
+   testOrShortCircuit self assert: (true or: [1/0]) equals: true! !")
+
+(define
+  pharo-collections-source
+  "TestCase subclass: #ArrayTest instanceVariableNames: ''!
+
+   !ArrayTest methodsFor: 'creation'!
+   testNewSize self assert: (Array new: 5) size equals: 5!
+   testLiteralSize self assert: #(1 2 3) size equals: 3!
+   testEmpty self assert: #() isEmpty!
+   testNotEmpty self assert: #(1) notEmpty!
+   testFirst self assert: #(10 20 30) first equals: 10!
+   testLast self assert: #(10 20 30) last equals: 30! !
+
+   !ArrayTest methodsFor: 'access'!
+   testAt self assert: (#(10 20 30) at: 2) equals: 20!
+   testAtPut
+     | a |
+     a := Array new: 3.
+     a at: 1 put: 'x'. a at: 2 put: 'y'. a at: 3 put: 'z'.
+     self assert: (a at: 2) equals: 'y'! !
+
+   !ArrayTest methodsFor: 'iteration'!
+   testDoSum
+     | s |
+     s := 0.
+     #(1 2 3 4 5) do: [:e | s := s + e].
+     self assert: s equals: 15!
+
+   testInjectInto self assert: (#(1 2 3 4) inject: 0 into: [:a :b | a + b]) equals: 10!
+
+   testCollect self assert: (#(1 2 3) collect: [:x | x * x]) equals: #(1 4 9)!
+
+   testSelect self assert: (#(1 2 3 4 5) select: [:x | x > 2]) equals: #(3 4 5)!
+
+   testReject self assert: (#(1 2 3 4 5) reject: [:x | x > 2]) equals: #(1 2)!
+
+   testDetect self assert: (#(1 3 5 7) detect: [:x | x > 4]) equals: 5!
+
+   testCount self assert: (#(1 2 3 4 5) count: [:x | x even]) equals: 2!
+
+   testAnySatisfy self assert: (#(1 2 3) anySatisfy: [:x | x > 2])!
+
+   testAllSatisfy self assert: (#(2 4 6) allSatisfy: [:x | x even])!
+
+   testIncludes self assert: (#(1 2 3) includes: 2)!
+
+   testIncludesNotArr self deny: (#(1 2 3) includes: 99)!
+
+   testIndexOfArr self assert: (#(10 20 30) indexOf: 30) equals: 3!
+
+   testIndexOfMissing self assert: (#(1 2 3) indexOf: 99) equals: 0! !
+
+   TestCase subclass: #DictionaryTest instanceVariableNames: ''!
+
+   !DictionaryTest methodsFor: 'tests'!
+   testEmpty self assert: Dictionary new isEmpty!
+
+   testAtPutThenAt
+     | d |
+     d := Dictionary new.
+     d at: #a put: 1.
+     self assert: (d at: #a) equals: 1!
+
+   testAtMissingNil self assert: (Dictionary new at: #nope) equals: nil!
+
+   testAtIfAbsent
+     self assert: (Dictionary new at: #nope ifAbsent: [#absent]) equals: #absent!
+
+   testSize
+     | d |
+     d := Dictionary new.
+     d at: #a put: 1. d at: #b put: 2. d at: #c put: 3.
+     self assert: d size equals: 3!
+
+   testIncludesKey
+     | d |
+     d := Dictionary new.
+     d at: #a put: 1.
+     self assert: (d includesKey: #a)!
+
+   testRemoveKey
+     | d |
+     d := Dictionary new.
+     d at: #a put: 1. d at: #b put: 2.
+     d removeKey: #a.
+     self deny: (d includesKey: #a)!
+
+   testOverwrite
+     | d |
+     d := Dictionary new.
+     d at: #x put: 1. d at: #x put: 99.
+     self assert: (d at: #x) equals: 99! !
+
+   TestCase subclass: #SetTest instanceVariableNames: ''!
+
+   !SetTest methodsFor: 'tests'!
+   testEmpty self assert: Set new isEmpty!
+
+   testAdd
+     | s |
+     s := Set new.
+     s add: 1.
+     self assert: (s includes: 1)!
+
+   testDedup
+     | s |
+     s := Set new.
+     s add: 1. s add: 1. s add: 1.
+     self assert: s size equals: 1!
+
+   testRemove
+     | s |
+     s := Set new.
+     s add: 1. s add: 2.
+     s remove: 1.
+     self deny: (s includes: 1)!
+
+   testAddAll
+     | s |
+     s := Set new.
+     s addAll: #(1 2 3 2 1).
+     self assert: s size equals: 3!
+
+   testDoSum
+     | s sum |
+     s := Set new.
+     s add: 10. s add: 20. s add: 30.
+     sum := 0.
+     s do: [:e | sum := sum + e].
+     self assert: sum equals: 60! !")
+
+(smalltalk-load pharo-kernel-source)
+(smalltalk-load pharo-collections-source)
+
+;; Run each test method individually and create one st-test row per test.
+;; A pharo test name like "IntegerTest >> testAddition" passes when the
+;; SUnit run yields exactly one pass and zero failures.
+(define
+  pharo-test-class
+  (fn
+    (cls-name)
+    (let ((selectors (sort (keys (get (st-class-get cls-name) :methods)))))
+      (for-each
+        (fn (sel)
+          (when
+            (and (>= (len sel) 4) (= (slice sel 0 4) "test"))
+            (let
+              ((src (str "| s r | s := " cls-name " suiteForAll: #(#"
+                         sel "). r := s run.
+                         ^ {(r passCount). (r failureCount). (r errorCount)}")))
+              (let ((result (smalltalk-eval-program src)))
+                (st-test
+                  (str cls-name " >> " sel)
+                  result
+                  (list 1 0 0))))))
+        selectors))))
+
+(pharo-test-class "IntegerTest")
+(pharo-test-class "StringTest")
+(pharo-test-class "BooleanTest")
+(pharo-test-class "ArrayTest")
+(pharo-test-class "DictionaryTest")
+(pharo-test-class "SetTest")
+
+(list st-test-pass st-test-fail)

lib/smalltalk/tests/pharo/collections.st

@@ -0,0 +1,137 @@
+"Pharo Collections-Tests slice — Array, Dictionary, Set."
+
+TestCase subclass: #ArrayTest
+  instanceVariableNames: ''!
+
+!ArrayTest methodsFor: 'creation'!
+testNewSize self assert: (Array new: 5) size equals: 5!
+testLiteralSize self assert: #(1 2 3) size equals: 3!
+testEmpty self assert: #() isEmpty!
+testNotEmpty self assert: #(1) notEmpty!
+testFirst self assert: #(10 20 30) first equals: 10!
+testLast self assert: #(10 20 30) last equals: 30! !
+
+!ArrayTest methodsFor: 'access'!
+testAt self assert: (#(10 20 30) at: 2) equals: 20!
+testAtPut
+  | a |
+  a := Array new: 3.
+  a at: 1 put: 'x'.
+  a at: 2 put: 'y'.
+  a at: 3 put: 'z'.
+  self assert: (a at: 2) equals: 'y'! !
+
+!ArrayTest methodsFor: 'iteration'!
+testDoSum
+  | s |
+  s := 0.
+  #(1 2 3 4 5) do: [:e | s := s + e].
+  self assert: s equals: 15!
+
+testInjectInto self assert: (#(1 2 3 4) inject: 0 into: [:a :b | a + b]) equals: 10!
+
+testCollect self assert: (#(1 2 3) collect: [:x | x * x]) equals: #(1 4 9)!
+
+testSelect self assert: (#(1 2 3 4 5) select: [:x | x > 2]) equals: #(3 4 5)!
+
+testReject self assert: (#(1 2 3 4 5) reject: [:x | x > 2]) equals: #(1 2)!
+
+testDetect self assert: (#(1 3 5 7) detect: [:x | x > 4]) equals: 5!
+
+testCount self assert: (#(1 2 3 4 5) count: [:x | x even]) equals: 2!
+
+testAnySatisfy self assert: (#(1 2 3) anySatisfy: [:x | x > 2])!
+
+testAllSatisfy self assert: (#(2 4 6) allSatisfy: [:x | x even])!
+
+testIncludes self assert: (#(1 2 3) includes: 2)!
+
+testIncludesNot self deny: (#(1 2 3) includes: 99)!
+
+testIndexOf self assert: (#(10 20 30) indexOf: 30) equals: 3!
+
+testIndexOfMissing self assert: (#(1 2 3) indexOf: 99) equals: 0! !
+
+TestCase subclass: #DictionaryTest
+  instanceVariableNames: ''!
+
+!DictionaryTest methodsFor: 'fixture'!
+setUp ^ self! !
+
+!DictionaryTest methodsFor: 'tests'!
+testEmpty self assert: Dictionary new isEmpty!
+
+testAtPutThenAt
+  | d |
+  d := Dictionary new.
+  d at: #a put: 1.
+  self assert: (d at: #a) equals: 1!
+
+testAtMissingNil self assert: (Dictionary new at: #nope) equals: nil!
+
+testAtIfAbsent
+  self assert: (Dictionary new at: #nope ifAbsent: [#absent]) equals: #absent!
+
+testSize
+  | d |
+  d := Dictionary new.
+  d at: #a put: 1. d at: #b put: 2. d at: #c put: 3.
+  self assert: d size equals: 3!
+
+testIncludesKey
+  | d |
+  d := Dictionary new.
+  d at: #a put: 1.
+  self assert: (d includesKey: #a)!
+
+testRemoveKey
+  | d |
+  d := Dictionary new.
+  d at: #a put: 1. d at: #b put: 2.
+  d removeKey: #a.
+  self deny: (d includesKey: #a)!
+
+testOverwrite
+  | d |
+  d := Dictionary new.
+  d at: #x put: 1. d at: #x put: 99.
+  self assert: (d at: #x) equals: 99! !
+
+TestCase subclass: #SetTest
+  instanceVariableNames: ''!
+
+!SetTest methodsFor: 'tests'!
+testEmpty self assert: Set new isEmpty!
+
+testAdd
+  | s |
+  s := Set new.
+  s add: 1.
+  self assert: (s includes: 1)!
+
+testDedup
+  | s |
+  s := Set new.
+  s add: 1. s add: 1. s add: 1.
+  self assert: s size equals: 1!
+
+testRemove
+  | s |
+  s := Set new.
+  s add: 1. s add: 2.
+  s remove: 1.
+  self deny: (s includes: 1)!
+
+testAddAll
+  | s |
+  s := Set new.
+  s addAll: #(1 2 3 2 1).
+  self assert: s size equals: 3!
+
+testDoSum
+  | s sum |
+  s := Set new.
+  s add: 10. s add: 20. s add: 30.
+  sum := 0.
+  s do: [:e | sum := sum + e].
+  self assert: sum equals: 60! !