apl: merge architecture — Tcl/Prolog/CL/Smalltalk + spec updates

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/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/runtime.sx

@@ -0,0 +1,207 @@
+;; lib/common-lisp/tests/runtime.sx — tests for CL runtime layer
+
+(load "lib/common-lisp/runtime.sx")
+
+(defsuite
+  "cl-types"
+  (deftest "cl-null? nil" (assert= true (cl-null? nil)))
+  (deftest "cl-null? false" (assert= false (cl-null? false)))
+  (deftest
+    "cl-consp? pair"
+    (assert= true (cl-consp? (list 1 2))))
+  (deftest "cl-consp? nil" (assert= false (cl-consp? nil)))
+  (deftest "cl-listp? nil" (assert= true (cl-listp? nil)))
+  (deftest
+    "cl-listp? list"
+    (assert= true (cl-listp? (list 1 2))))
+  (deftest "cl-atom? nil" (assert= true (cl-atom? nil)))
+  (deftest "cl-atom? pair" (assert= false (cl-atom? (list 1))))
+  (deftest "cl-integerp?" (assert= true (cl-integerp? 42)))
+  (deftest "cl-floatp?" (assert= true (cl-floatp? 3.14)))
+  (deftest
+    "cl-characterp?"
+    (assert= true (cl-characterp? (integer->char 65))))
+  (deftest "cl-stringp?" (assert= true (cl-stringp? "hello")))
+  (deftest "cl-symbolp?" (assert= true (cl-symbolp? (quote foo)))))
+
+(defsuite
+  "cl-arithmetic"
+  (deftest "cl-mod" (assert= 1 (cl-mod 10 3)))
+  (deftest "cl-rem" (assert= 1 (cl-rem 10 3)))
+  (deftest
+    "cl-quotient"
+    (assert= 3 (cl-quotient 10 3)))
+  (deftest "cl-gcd" (assert= 4 (cl-gcd 12 8)))
+  (deftest "cl-lcm" (assert= 12 (cl-lcm 4 6)))
+  (deftest "cl-abs pos" (assert= 5 (cl-abs 5)))
+  (deftest "cl-abs neg" (assert= 5 (cl-abs -5)))
+  (deftest "cl-min" (assert= 2 (cl-min 2 7)))
+  (deftest "cl-max" (assert= 7 (cl-max 2 7)))
+  (deftest "cl-evenp? t" (assert= true (cl-evenp? 4)))
+  (deftest "cl-evenp? f" (assert= false (cl-evenp? 3)))
+  (deftest "cl-oddp? t" (assert= true (cl-oddp? 7)))
+  (deftest "cl-zerop?" (assert= true (cl-zerop? 0)))
+  (deftest "cl-plusp?" (assert= true (cl-plusp? 1)))
+  (deftest "cl-minusp?" (assert= true (cl-minusp? -1)))
+  (deftest "cl-signum pos" (assert= 1 (cl-signum 42)))
+  (deftest "cl-signum neg" (assert= -1 (cl-signum -7)))
+  (deftest "cl-signum zero" (assert= 0 (cl-signum 0))))
+
+(defsuite
+  "cl-chars"
+  (deftest
+    "cl-char-code"
+    (assert= 65 (cl-char-code (integer->char 65))))
+  (deftest "cl-code-char" (assert= true (char? (cl-code-char 65))))
+  (deftest
+    "cl-char-upcase"
+    (assert=
+      (integer->char 65)
+      (cl-char-upcase (integer->char 97))))
+  (deftest
+    "cl-char-downcase"
+    (assert=
+      (integer->char 97)
+      (cl-char-downcase (integer->char 65))))
+  (deftest
+    "cl-alpha-char-p"
+    (assert= true (cl-alpha-char-p (integer->char 65))))
+  (deftest
+    "cl-digit-char-p"
+    (assert= true (cl-digit-char-p (integer->char 48))))
+  (deftest
+    "cl-char=?"
+    (assert=
+      true
+      (cl-char=? (integer->char 65) (integer->char 65))))
+  (deftest
+    "cl-char<?"
+    (assert=
+      true
+      (cl-char<? (integer->char 65) (integer->char 90))))
+  (deftest
+    "cl-char space"
+    (assert= (integer->char 32) cl-char-space))
+  (deftest
+    "cl-char newline"
+    (assert= (integer->char 10) cl-char-newline)))
+
+(defsuite
+  "cl-format"
+  (deftest
+    "cl-format nil basic"
+    (assert= "hello" (cl-format nil "~a" "hello")))
+  (deftest
+    "cl-format nil number"
+    (assert= "42" (cl-format nil "~d" 42)))
+  (deftest
+    "cl-format nil hex"
+    (assert= "ff" (cl-format nil "~x" 255)))
+  (deftest
+    "cl-format nil template"
+    (assert= "x=3 y=4" (cl-format nil "x=~d y=~d" 3 4)))
+  (deftest "cl-format nil tilde" (assert= "a~b" (cl-format nil "a~~b"))))
+
+(defsuite
+  "cl-gensym"
+  (deftest
+    "cl-gensym returns symbol"
+    (assert= "symbol" (type-of (cl-gensym))))
+  (deftest "cl-gensym unique" (assert= false (= (cl-gensym) (cl-gensym)))))
+
+(defsuite
+  "cl-sets"
+  (deftest "cl-make-set empty" (assert= true (cl-set? (cl-make-set))))
+  (deftest
+    "cl-set-add/member"
+    (let
+      ((s (cl-make-set)))
+      (do
+        (cl-set-add s 1)
+        (assert= true (cl-set-memberp s 1)))))
+  (deftest
+    "cl-set-memberp false"
+    (assert= false (cl-set-memberp (cl-make-set) 42)))
+  (deftest
+    "cl-list->set"
+    (let
+      ((s (cl-list->set (list 1 2 3))))
+      (assert= true (cl-set-memberp s 2)))))
+
+(defsuite
+  "cl-lists"
+  (deftest
+    "cl-nth 0"
+    (assert=
+      1
+      (cl-nth 0 (list 1 2 3))))
+  (deftest
+    "cl-nth 2"
+    (assert=
+      3
+      (cl-nth 2 (list 1 2 3))))
+  (deftest
+    "cl-last"
+    (assert=
+      (list 3)
+      (cl-last (list 1 2 3))))
+  (deftest
+    "cl-butlast"
+    (assert=
+      (list 1 2)
+      (cl-butlast (list 1 2 3))))
+  (deftest
+    "cl-nthcdr 1"
+    (assert=
+      (list 2 3)
+      (cl-nthcdr 1 (list 1 2 3))))
+  (deftest
+    "cl-assoc hit"
+    (assert=
+      (list "b" 2)
+      (cl-assoc "b" (list (list "a" 1) (list "b" 2)))))
+  (deftest
+    "cl-assoc miss"
+    (assert= nil (cl-assoc "z" (list (list "a" 1)))))
+  (deftest
+    "cl-getf hit"
+    (assert= 42 (cl-getf (list "x" 42 "y" 99) "x")))
+  (deftest "cl-getf miss" (assert= nil (cl-getf (list "x" 42) "z")))
+  (deftest
+    "cl-adjoin new"
+    (assert=
+      (list 0 1 2)
+      (cl-adjoin 0 (list 1 2))))
+  (deftest
+    "cl-adjoin dup"
+    (assert=
+      (list 1 2)
+      (cl-adjoin 1 (list 1 2))))
+  (deftest
+    "cl-flatten"
+    (assert=
+      (list 1 2 3 4)
+      (cl-flatten (list 1 (list 2 3) 4))))
+  (deftest
+    "cl-member hit"
+    (assert=
+      (list 2 3)
+      (cl-member 2 (list 1 2 3))))
+  (deftest
+    "cl-member miss"
+    (assert=
+      nil
+      (cl-member 9 (list 1 2 3)))))
+
+(defsuite
+  "cl-radix"
+  (deftest "binary" (assert= "1010" (cl-format-binary 10)))
+  (deftest "octal" (assert= "17" (cl-format-octal 15)))
+  (deftest "hex" (assert= "ff" (cl-format-hex 255)))
+  (deftest "decimal" (assert= "42" (cl-format-decimal 42)))
+  (deftest
+    "n->s r16"
+    (assert= "1f" (cl-integer-to-string 31 16)))
+  (deftest
+    "s->n r16"
+    (assert= 31 (cl-string-to-integer "1f" 16))))

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/hyperscript/compiler.sx

@@ -48,6 +48,15 @@
                             prop
                             value))
                         (list (quote hs-query-all) (nth base-ast 1))))
+                    ((and (list? base-ast) (= (first base-ast) (quote query)))
+                      (list
+                        (quote dom-set-prop)
+                        (list
+                          (quote hs-named-target)
+                          (nth base-ast 1)
+                          (list (quote hs-query-first) (nth base-ast 1)))
+                        prop
+                        value))
                     ((and (list? base-ast) (= (first base-ast) dot-sym) (let ((inner (nth base-ast 1))) (and (list? inner) (= (first inner) (quote query)) (let ((s (nth inner 1))) (and (string? s) (> (len s) 0) (= (substring s 0 1) "."))))))
                       (let
                         ((inner (nth base-ast 1))
@@ -146,6 +155,14 @@
                           (nth prop-ast 1)
                           value)
                         (list (quote set!) (hs-to-sx target) value))))))
+              ((= th (quote query))
+                (list
+                  (quote hs-set-inner-html!)
+                  (list
+                    (quote hs-named-target)
+                    (nth target 1)
+                    (list (quote hs-query-first) (nth target 1)))
+                  value))
               (true (list (quote set!) (hs-to-sx target) value)))))))
     (define
       emit-on
@@ -274,17 +291,33 @@
           ((name (nth ast 1)) (rest-parts (rest (rest ast))))
           (cond
             ((and (= (len ast) 4) (list? (nth ast 2)) (= (first (nth ast 2)) (quote dict)))
-              (list
+              (let
-                (quote dom-dispatch)
+                ((tgt-ast (nth ast 3)))
-                (hs-to-sx (nth ast 3))
+                (list
-                name
+                  (quote dom-dispatch)
-                (hs-to-sx (nth ast 2))))
+                  (if
+                    (and (list? tgt-ast) (= (first tgt-ast) (quote query)))
+                    (list
+                      (quote hs-named-target)
+                      (nth tgt-ast 1)
+                      (list (quote hs-query-first) (nth tgt-ast 1)))
+                    (hs-to-sx tgt-ast))
+                  name
+                  (hs-to-sx (nth ast 2)))))
             ((= (len ast) 3)
-              (list
+              (let
-                (quote dom-dispatch)
+                ((tgt-ast (nth ast 2)))
-                (hs-to-sx (nth ast 2))
+                (list
-                name
+                  (quote dom-dispatch)
-                (list (quote dict) "sender" (quote me))))
+                  (if
+                    (and (list? tgt-ast) (= (first tgt-ast) (quote query)))
+                    (list
+                      (quote hs-named-target)
+                      (nth tgt-ast 1)
+                      (list (quote hs-query-first) (nth tgt-ast 1)))
+                    (hs-to-sx tgt-ast))
+                  name
+                  (list (quote dict) "sender" (quote me)))))
             (true
               (list
                 (quote dom-dispatch)
@@ -706,6 +739,33 @@
               (quote fn)
               (cons (quote me) (map make-symbol params))
               (cons (quote do) (map hs-to-sx body)))))))
+    (define
+      hs-safe-obj
+      (fn
+        (obj-ast)
+        (if
+          (and (list? obj-ast) (= (first obj-ast) (quote ref)))
+          (list (quote host-global) (nth obj-ast 1))
+          (if
+            (and (list? obj-ast) (= (first obj-ast) dot-sym))
+            (let
+              ((inner (nth obj-ast 1)) (prop (nth obj-ast 2)))
+              (list (quote host-get) (hs-safe-obj inner) prop))
+            (hs-to-sx obj-ast)))))
+    (define
+      hs-chain-name
+      (fn
+        (obj-ast)
+        (if
+          (and (list? obj-ast) (= (first obj-ast) (quote ref)))
+          (nth obj-ast 1)
+          (if
+            (and (list? obj-ast) (= (first obj-ast) dot-sym))
+            (str (hs-chain-name (nth obj-ast 1)) "." (nth obj-ast 2))
+            (if
+              (and (list? obj-ast) (= (first obj-ast) (quote query)))
+              (nth obj-ast 1)
+              nil)))))
     (fn
       (ast)
       (cond
@@ -1226,12 +1286,21 @@
                   (if
                     (and (list? raw-tgt) (= (first raw-tgt) (quote query)))
                     (list
-                      (quote for-each)
+                      (quote let)
                       (list
-                        (quote fn)
+                        (list
-                        (list (quote _el))
+                          (quote _tgt)
-                        (list (quote dom-add-class) (quote _el) (nth ast 1)))
+                          (list (quote hs-query-named-all) (nth raw-tgt 1))))
-                      (list (quote hs-query-all) (nth raw-tgt 1)))
+                      (list
+                        (quote for-each)
+                        (list
+                          (quote fn)
+                          (list (quote _el))
+                          (list
+                            (quote dom-add-class)
+                            (quote _el)
+                            (nth ast 1)))
+                        (quote _tgt)))
                     (list
                       (quote dom-add-class)
                       (hs-to-sx raw-tgt)
@@ -1244,14 +1313,20 @@
                   (nth ast 2)))
               ((= head (quote set-styles))
                 (let
-                  ((pairs (nth ast 1)) (tgt (hs-to-sx (nth ast 2))))
+                  ((pairs (nth ast 1)) (tgt-ast (nth ast 2)))
-                  (cons
+                  (let
-                    (quote do)
+                    ((tgt (if (and (list? tgt-ast) (= (first tgt-ast) (quote query))) (list (quote hs-named-target) (nth tgt-ast 1) (list (quote hs-query-first) (nth tgt-ast 1))) (hs-to-sx tgt-ast))))
-                    (map
+                    (cons
-                      (fn
+                      (quote do)
-                        (p)
+                      (map
-                        (list (quote dom-set-style) tgt (first p) (nth p 1)))
+                        (fn
-                      pairs))))
+                          (p)
+                          (list
+                            (quote dom-set-style)
+                            tgt
+                            (first p)
+                            (nth p 1)))
+                        pairs)))))
               ((= head (quote multi-add-class))
                 (let
                   ((target (hs-to-sx (nth ast 1)))
@@ -1349,15 +1424,21 @@
                   (if
                     (and (list? raw-tgt) (= (first raw-tgt) (quote query)))
                     (list
-                      (quote for-each)
+                      (quote let)
                       (list
-                        (quote fn)
-                        (list (quote _el))
                         (list
-                          (quote dom-remove-class)
+                          (quote _tgt)
-                          (quote _el)
+                          (list (quote hs-query-named-all) (nth raw-tgt 1))))
-                          (nth ast 1)))
+                      (list
-                      (list (quote hs-query-all) (nth raw-tgt 1)))
+                        (quote for-each)
+                        (list
+                          (quote fn)
+                          (list (quote _el))
+                          (list
+                            (quote dom-remove-class)
+                            (quote _el)
+                            (nth ast 1)))
+                        (quote _tgt)))
                     (list
                       (quote dom-remove-class)
                       (if (nil? raw-tgt) (quote me) (hs-to-sx raw-tgt))
@@ -1401,15 +1482,32 @@
                   ((tgt (nth ast 3)))
                   (list
                     (quote hs-set-attr!)
-                    (hs-to-sx tgt)
+                    (if
+                      (and (list? tgt) (= (first tgt) (quote query)))
+                      (list
+                        (quote hs-named-target)
+                        (nth tgt 1)
+                        (list (quote hs-query-first) (nth tgt 1)))
+                      (hs-to-sx tgt))
                     (nth ast 1)
                     (hs-to-sx (nth ast 2)))))
               ((= head (quote remove-value))
                 (let
-                  ((val (hs-to-sx (nth ast 1))) (tgt (nth ast 2)))
+                  ((val (hs-to-sx (nth ast 1))) (raw-tgt (nth ast 2)))
                   (emit-set
-                    tgt
+                    raw-tgt
-                    (list (quote hs-remove-from!) val (hs-to-sx tgt)))))
+                    (list
+                      (quote hs-remove-from!)
+                      val
+                      (if
+                        (and
+                          (list? raw-tgt)
+                          (= (first raw-tgt) (quote query)))
+                        (list
+                          (quote hs-named-target)
+                          (nth raw-tgt 1)
+                          (list (quote hs-query-first) (nth raw-tgt 1)))
+                        (hs-to-sx raw-tgt))))))
               ((= head (quote empty-target))
                 (let
                   ((tgt (nth ast 1)))
@@ -1440,8 +1538,19 @@
                   (hs-to-sx (nth ast 2))))
               ((= head (quote remove-attr))
                 (let
-                  ((tgt (if (nil? (nth ast 2)) (quote me) (hs-to-sx (nth ast 2)))))
+                  ((raw-tgt (nth ast 2)))
-                  (list (quote dom-remove-attr) tgt (nth ast 1))))
+                  (list
+                    (quote dom-remove-attr)
+                    (if
+                      (and
+                        (list? raw-tgt)
+                        (= (first raw-tgt) (quote query)))
+                      (list
+                        (quote hs-named-target)
+                        (nth raw-tgt 1)
+                        (list (quote hs-query-first) (nth raw-tgt 1)))
+                      (if (nil? raw-tgt) (quote me) (hs-to-sx raw-tgt)))
+                    (nth ast 1))))
               ((= head (quote remove-css))
                 (let
                   ((tgt (if (nil? (nth ast 2)) (quote me) (hs-to-sx (nth ast 2))))
@@ -1452,10 +1561,20 @@
                       (fn (p) (list (quote dom-set-style) tgt p ""))
                       props))))
               ((= head (quote toggle-class))
-                (list
+                (let
-                  (quote hs-toggle-class!)
+                  ((tgt-ast (nth ast 2)))
-                  (hs-to-sx (nth ast 2))
+                  (list
-                  (nth ast 1)))
+                    (quote hs-toggle-class!)
+                    (if
+                      (and
+                        (list? tgt-ast)
+                        (= (first tgt-ast) (quote query)))
+                      (list
+                        (quote hs-named-target)
+                        (nth tgt-ast 1)
+                        (list (quote hs-query-first) (nth tgt-ast 1)))
+                      (hs-to-sx tgt-ast))
+                    (nth ast 1))))
               ((= head (quote toggle-class-for))
                 (list
                   (quote do)
@@ -1510,11 +1629,21 @@
                       (hs-to-sx tgt-ast)
                       (hs-to-sx val-ast)))))
               ((= head (quote toggle-between))
-                (list
+                (let
-                  (quote hs-toggle-between!)
+                  ((tgt-ast (nth ast 3)))
-                  (hs-to-sx (nth ast 3))
+                  (list
-                  (nth ast 1)
+                    (quote hs-toggle-between!)
-                  (nth ast 2)))
+                    (if
+                      (and
+                        (list? tgt-ast)
+                        (= (first tgt-ast) (quote query)))
+                      (list
+                        (quote hs-named-target)
+                        (nth tgt-ast 1)
+                        (list (quote hs-query-first) (nth tgt-ast 1)))
+                      (hs-to-sx tgt-ast))
+                    (nth ast 1)
+                    (nth ast 2))))
               ((= head (quote toggle-style))
                 (let
                   ((raw-tgt (nth ast 2)))
@@ -1538,10 +1667,20 @@
                     (quote list)
                     (map hs-to-sx (slice ast 3 (len ast))))))
               ((= head (quote toggle-attr))
-                (list
+                (let
-                  (quote hs-toggle-attr!)
+                  ((tgt-ast (nth ast 2)))
-                  (hs-to-sx (nth ast 2))
+                  (list
-                  (nth ast 1)))
+                    (quote hs-toggle-attr!)
+                    (if
+                      (and
+                        (list? tgt-ast)
+                        (= (first tgt-ast) (quote query)))
+                      (list
+                        (quote hs-named-target)
+                        (nth tgt-ast 1)
+                        (list (quote hs-query-first) (nth tgt-ast 1)))
+                      (hs-to-sx tgt-ast))
+                    (nth ast 1))))
               ((= head (quote toggle-attr-between))
                 (list
                   (quote hs-toggle-attr-between!)
@@ -1575,7 +1714,22 @@
                       (emit-set
                         raw-tgt
                         (list (quote hs-put-at!) val pos (hs-to-sx raw-tgt))))
-                    (true (list (quote hs-put!) val pos (hs-to-sx raw-tgt))))))
+                    (true
+                      (let
+                        ((tgt-ast raw-tgt))
+                        (list
+                          (quote hs-put!)
+                          val
+                          pos
+                          (if
+                            (and
+                              (list? tgt-ast)
+                              (= (first tgt-ast) (quote query)))
+                            (list
+                              (quote hs-named-target)
+                              (nth tgt-ast 1)
+                              (list (quote hs-query-first) (nth tgt-ast 1)))
+                            (hs-to-sx tgt-ast))))))))
               ((= head (quote if))
                 (if
                   (> (len ast) 3)
@@ -1651,12 +1805,22 @@
                     (detail (if (= (len ast) 4) (nth ast 2) nil)))
                   (list
                     (quote dom-dispatch)
-                    (hs-to-sx tgt)
+                    (let
+                      ((tgt-ast tgt))
+                      (if
+                        (and
+                          (list? tgt-ast)
+                          (= (first tgt-ast) (quote query)))
+                        (list
+                          (quote hs-named-target)
+                          (nth tgt-ast 1)
+                          (list (quote hs-query-first) (nth tgt-ast 1)))
+                        (hs-to-sx tgt-ast)))
                     name
                     (if has-detail (hs-to-sx detail) nil))))
               ((= head (quote hide))
                 (let
-                  ((tgt (let ((raw-tgt (nth ast 1))) (if (and (list? raw-tgt) (= (first raw-tgt) (quote query))) (list (quote hs-query-all) (nth raw-tgt 1)) (hs-to-sx raw-tgt))))
+                  ((tgt (let ((raw-tgt (nth ast 1))) (if (and (list? raw-tgt) (= (first raw-tgt) (quote query))) (list (quote hs-query-named-all) (nth raw-tgt 1)) (hs-to-sx raw-tgt))))
                     (strategy (if (> (len ast) 2) (nth ast 2) "display"))
                     (when-cond (if (> (len ast) 3) (nth ast 3) nil)))
                   (if
@@ -1672,7 +1836,7 @@
                         (hs-to-sx when-cond))))))
               ((= head (quote show))
                 (let
-                  ((tgt (let ((raw-tgt (nth ast 1))) (if (and (list? raw-tgt) (= (first raw-tgt) (quote query))) (list (quote hs-query-all) (nth raw-tgt 1)) (hs-to-sx raw-tgt))))
+                  ((tgt (let ((raw-tgt (nth ast 1))) (if (and (list? raw-tgt) (= (first raw-tgt) (quote query))) (list (quote hs-query-named-all) (nth raw-tgt 1)) (hs-to-sx raw-tgt))))
                     (strategy (if (> (len ast) 2) (nth ast 2) "display"))
                     (when-cond (if (> (len ast) 3) (nth ast 3) nil)))
                   (if
@@ -1735,13 +1899,28 @@
               ((= head (quote call))
                 (let
                   ((raw-fn (nth ast 1))
-                    (fn-expr
-                      (if
-                        (string? raw-fn)
-                        (make-symbol raw-fn)
-                        (hs-to-sx raw-fn)))
                     (args (map hs-to-sx (rest (rest ast)))))
-                  (cons fn-expr args)))
+                  (if
+                    (and (list? raw-fn) (= (first raw-fn) (quote ref)))
+                    (let
+                      ((name (nth raw-fn 1)))
+                      (list
+                        (quote let)
+                        (list
+                          (list
+                            (quote __hs-fn)
+                            (list (quote host-global) name)))
+                        (cons
+                          (quote do)
+                          (list
+                            (list
+                              (quote if)
+                              (list (quote nil?) (quote __hs-fn))
+                              (list (quote raise) (str "'" name "' is null"))
+                              (cons (quote __hs-fn) args))))))
+                    (let
+                      ((fn-expr (if (string? raw-fn) (make-symbol raw-fn) (hs-to-sx raw-fn))))
+                      (cons fn-expr args)))))
               ((= head (quote return))
                 (let
                   ((val (nth ast 1)))
@@ -1754,7 +1933,22 @@
               ((= head (quote throw))
                 (list (quote raise) (hs-to-sx (nth ast 1))))
               ((= head (quote settle))
-                (list (quote hs-settle) (quote me)))
+                (let
+                  ((raw-tgt (nth ast 1)))
+                  (list
+                    (quote hs-settle)
+                    (if
+                      (nil? raw-tgt)
+                      (quote me)
+                      (if
+                        (and
+                          (list? raw-tgt)
+                          (= (first raw-tgt) (quote query)))
+                        (list
+                          (quote hs-named-target)
+                          (nth raw-tgt 1)
+                          (list (quote hs-query-first) (nth raw-tgt 1)))
+                        (hs-to-sx raw-tgt))))))
               ((= head (quote go))
                 (list (quote hs-navigate!) (hs-to-sx (nth ast 1))))
               ((= head (quote ask))
@@ -1874,7 +2068,11 @@
               ((= head (quote install))
                 (cons (quote hs-install) (map hs-to-sx (rest ast))))
               ((= head (quote measure))
-                (list (quote hs-measure) (hs-to-sx (nth ast 1))))
+                (let
+                  ((raw-tgt (nth ast 1)))
+                  (let
+                    ((compiled-tgt (if (and (list? raw-tgt) (= (first raw-tgt) (quote query))) (list (quote hs-named-target) (nth raw-tgt 1) (list (quote hs-query-first) (nth raw-tgt 1))) (hs-to-sx raw-tgt))))
+                    (list (quote hs-measure) compiled-tgt))))
               ((= head (quote increment!))
                 (if
                   (= (len ast) 3)

lib/hyperscript/parser.sx

@@ -2455,7 +2455,16 @@
               ((and (= typ "keyword") (= val "answer"))
                 (do (adv!) (parse-answer-cmd)))
               ((and (= typ "keyword") (= val "settle"))
-                (do (adv!) (list (quote settle))))
+                (do
+                  (adv!)
+                  (if
+                    (or
+                      (at-end?)
+                      (and
+                        (= (tp-type) "keyword")
+                        (or (= (tp-val) "then") (= (tp-val) "end"))))
+                    (list (quote settle))
+                    (list (quote settle) (parse-expr)))))
               ((and (= typ "keyword") (= val "go"))
                 (do (adv!) (parse-go-cmd)))
               ((and (= typ "keyword") (= val "return"))

lib/hyperscript/runtime.sx

@@ -12,37 +12,14 @@
 
 ;; Register an event listener. Returns unlisten function.
 ;; (hs-on target event-name handler) → unlisten-fn
-(begin
-  (define _hs-config-log-all false)
-  (define _hs-log-captured (list))
-  (define
-    hs-set-log-all!
-    (fn (flag) (set! _hs-config-log-all (if flag true false))))
-  (define hs-get-log-captured (fn () _hs-log-captured))
-  (define
-    hs-clear-log-captured!
-    (fn () (begin (set! _hs-log-captured (list)) nil)))
-  (define
-    hs-log-event!
-    (fn
-      (msg)
-      (when
-        _hs-config-log-all
-        (begin
-          (set! _hs-log-captured (append _hs-log-captured (list msg)))
-          (host-call (host-global "console") "log" msg)
-          nil)))))
-
-;; Register for every occurrence (no queuing — each fires independently).
-;; Stock hyperscript queues by default; "every" disables queuing.
 (define
   hs-each
   (fn
     (target action)
     (if (list? target) (for-each action target) (action target))))
 
-;; Run an initializer function immediately.
+;; Register for every occurrence (no queuing — each fires independently).
-;; (hs-init thunk) — called at element boot time
+;; Stock hyperscript queues by default; "every" disables queuing.
 (define
   hs-on
   (fn
@@ -55,17 +32,17 @@
         (dom-set-data target "hs-unlisteners" (append prev (list unlisten)))
         unlisten))))
 
+;; Run an initializer function immediately.
+;; (hs-init thunk) — called at element boot time
+(define
+  hs-on-every
+  (fn (target event-name handler) (dom-listen target event-name handler)))
+
 ;; ── Async / timing ──────────────────────────────────────────────
 
 ;; Wait for a duration in milliseconds.
 ;; In hyperscript, wait is async-transparent — execution pauses.
 ;; Here we use perform/IO suspension for true pause semantics.
-(define
-  hs-on-every
-  (fn (target event-name handler) (dom-listen target event-name handler)))
-
-;; Wait for a DOM event on a target.
-;; (hs-wait-for target event-name) — suspends until event fires
 (define
   hs-on-intersection-attach!
   (fn
@@ -81,15 +58,16 @@
           (host-call observer "observe" target)
           observer)))))
 
-;; Wait for CSS transitions/animations to settle on an element.
+;; Wait for a DOM event on a target.
+;; (hs-wait-for target event-name) — suspends until event fires
 (define hs-init (fn (thunk) (thunk)))
 
+;; Wait for CSS transitions/animations to settle on an element.
+(define hs-wait (fn (ms) (perform (list (quote io-sleep) ms))))
+
 ;; ── Class manipulation ──────────────────────────────────────────
 
 ;; Toggle a single class on an element.
-(define hs-wait (fn (ms) (perform (list (quote io-sleep) ms))))
-
-;; Toggle between two classes — exactly one is active at a time.
 (begin
   (define
     hs-wait-for
@@ -102,21 +80,19 @@
       (target event-name timeout-ms)
       (perform (list (quote io-wait-event) target event-name timeout-ms)))))
 
+;; Toggle between two classes — exactly one is active at a time.
+(define hs-settle (fn (target) (perform (list (quote io-settle) target))))
+
 ;; Take a class from siblings — add to target, remove from others.
 ;; (hs-take! target cls) — like radio button class behavior
-(define hs-settle (fn (target) (perform (list (quote io-settle) target))))
+(define
+  hs-toggle-class!
+  (fn (target cls) (host-call (host-get target "classList") "toggle" cls)))
 
 ;; ── DOM insertion ───────────────────────────────────────────────
 
 ;; Put content at a position relative to a target.
 ;; pos: "into" | "before" | "after"
-(define
-  hs-toggle-class!
-  (fn (target cls) (host-call (host-get target "classList") "toggle" cls)))
-
-;; ── Navigation / traversal ──────────────────────────────────────
-
-;; Navigate to a URL.
 (define
   hs-toggle-between!
   (fn
@@ -126,7 +102,9 @@
       (do (dom-remove-class target cls1) (dom-add-class target cls2))
       (do (dom-remove-class target cls2) (dom-add-class target cls1)))))
 
-;; Find next sibling matching a selector (or any sibling).
+;; ── Navigation / traversal ──────────────────────────────────────
+
+;; Navigate to a URL.
 (define
   hs-toggle-style!
   (fn
@@ -150,7 +128,7 @@
             (dom-set-style target prop "hidden")
             (dom-set-style target prop "")))))))
 
-;; Find previous sibling matching a selector.
+;; Find next sibling matching a selector (or any sibling).
 (define
   hs-toggle-style-between!
   (fn
@@ -162,7 +140,7 @@
         (dom-set-style target prop val2)
         (dom-set-style target prop val1)))))
 
-;; First element matching selector within a scope.
+;; Find previous sibling matching a selector.
 (define
   hs-toggle-style-cycle!
   (fn
@@ -183,7 +161,7 @@
             (true (find-next (rest remaining))))))
       (dom-set-style target prop (find-next vals)))))
 
-;; Last element matching selector.
+;; First element matching selector within a scope.
 (define
   hs-take!
   (fn
@@ -206,7 +184,8 @@
             (when with-cls (dom-remove-class target with-cls))))
         (let
           ((attr-val (if (> (len extra) 0) (first extra) nil))
-            (with-val (if (> (len extra) 1) (nth extra 1) nil)))
+            (with-val
+              (if (> (len extra) 1) (nth extra 1) nil)))
           (do
             (for-each
               (fn
@@ -223,7 +202,7 @@
               (dom-set-attr target name attr-val)
               (dom-set-attr target name ""))))))))
 
-;; First/last within a specific scope.
+;; Last element matching selector.
 (begin
   (define
     hs-element?
@@ -335,6 +314,7 @@
                 (dom-insert-adjacent-html target "beforeend" value)
                 (hs-boot-subtree! target)))))))))
 
+;; First/last within a specific scope.
 (define
   hs-add-to!
   (fn
@@ -347,9 +327,6 @@
           (append target (list value))))
       (true (do (host-call target "push" value) target)))))
 
-;; ── Iteration ───────────────────────────────────────────────────
-
-;; Repeat a thunk N times.
 (define
   hs-remove-from!
   (fn
@@ -357,9 +334,15 @@
     (if
       (list? target)
       (filter (fn (x) (not (= x value))) target)
-      (host-call target "splice" (host-call target "indexOf" value) 1))))
+      (host-call
+        target
+        "splice"
+        (host-call target "indexOf" value)
+        1))))
 
-;; Repeat forever (until break — relies on exception/continuation).
+;; ── Iteration ───────────────────────────────────────────────────
+
+;; Repeat a thunk N times.
 (define
   hs-splice-at!
   (fn
@@ -372,7 +355,10 @@
           ((i (if (< idx 0) (+ n idx) idx)))
           (cond
             ((or (< i 0) (>= i n)) target)
-            (true (concat (slice target 0 i) (slice target (+ i 1) n))))))
+            (true
+              (concat
+                (slice target 0 i)
+                (slice target (+ i 1) n))))))
       (do
         (when
           target
@@ -383,10 +369,7 @@
               (host-call target "splice" i 1))))
         target))))
 
-;; ── Fetch ───────────────────────────────────────────────────────
+;; Repeat forever (until break — relies on exception/continuation).
-
-;; Fetch a URL, parse response according to format.
-;; (hs-fetch url format) — format is "json" | "text" | "html"
 (define
   hs-index
   (fn
@@ -398,10 +381,10 @@
       ((string? obj) (nth obj key))
       (true (host-get obj key)))))
 
-;; ── Type coercion ───────────────────────────────────────────────
+;; ── Fetch ───────────────────────────────────────────────────────
 
-;; Coerce a value to a type by name.
+;; Fetch a URL, parse response according to format.
-;; (hs-coerce value type-name) — type-name is "Int", "Float", "String", etc.
+;; (hs-fetch url format) — format is "json" | "text" | "html"
 (define
   hs-put-at!
   (fn
@@ -423,10 +406,10 @@
                 ((= pos "start") (host-call target "unshift" value)))
               target)))))))
 
-;; ── Object creation ─────────────────────────────────────────────
+;; ── Type coercion ───────────────────────────────────────────────
 
-;; Make a new object of a given type.
+;; Coerce a value to a type by name.
-;; (hs-make type-name) — creates empty object/collection
+;; (hs-coerce value type-name) — type-name is "Int", "Float", "String", etc.
 (define
   hs-dict-without
   (fn
@@ -447,27 +430,27 @@
           (host-call (host-global "Reflect") "deleteProperty" out key)
           out)))))
 
-;; ── Behavior installation ───────────────────────────────────────
+;; ── Object creation ─────────────────────────────────────────────
 
-;; Install a behavior on an element.
+;; Make a new object of a given type.
-;; A behavior is a function that takes (me ...params) and sets up features.
+;; (hs-make type-name) — creates empty object/collection
-;; (hs-install behavior-fn me ...args)
 (define
   hs-set-on!
   (fn
     (props target)
     (for-each (fn (k) (host-set! target k (get props k))) (keys props))))
 
+;; ── Behavior installation ───────────────────────────────────────
+
+;; Install a behavior on an element.
+;; A behavior is a function that takes (me ...params) and sets up features.
+;; (hs-install behavior-fn me ...args)
+(define hs-navigate! (fn (url) (perform (list (quote io-navigate) url))))
+
 ;; ── Measurement ─────────────────────────────────────────────────
 
 ;; Measure an element's bounding rect, store as local variables.
 ;; Returns a dict with x, y, width, height, top, left, right, bottom.
-(define hs-navigate! (fn (url) (perform (list (quote io-navigate) url))))
-
-;; Return the current text selection as a string.  In the browser this is
-;; `window.getSelection().toString()`.  In the mock test runner, a test
-;; setup stashes the desired selection text at `window.__test_selection`
-;; and the fallback path returns that so tests can assert on the result.
 (define
   hs-ask
   (fn
@@ -476,11 +459,10 @@
       ((w (host-global "window")))
       (if w (host-call w "prompt" msg) nil))))
 
-
+;; Return the current text selection as a string.  In the browser this is
-;; ── Transition ──────────────────────────────────────────────────
+;; `window.getSelection().toString()`.  In the mock test runner, a test
-
+;; setup stashes the desired selection text at `window.__test_selection`
-;; Transition a CSS property to a value, optionally with duration.
+;; and the fallback path returns that so tests can assert on the result.
-;; (hs-transition target prop value duration)
 (define
   hs-answer
   (fn
@@ -489,6 +471,11 @@
       ((w (host-global "window")))
       (if w (if (host-call w "confirm" msg) yes-val no-val) no-val))))
 
+
+;; ── Transition ──────────────────────────────────────────────────
+
+;; Transition a CSS property to a value, optionally with duration.
+;; (hs-transition target prop value duration)
 (define
   hs-answer-alert
   (fn
@@ -643,25 +630,25 @@
       (hs-query-all sel)
       (host-call target "querySelectorAll" sel))))
 
-
-
-
-
 (define
   hs-list-set
   (fn
     (lst idx val)
     (append (take lst idx) (cons val (drop lst (+ idx 1))))))
 
+
+
+
+
 (define
   hs-to-number
   (fn (v) (if (number? v) v (or (parse-number (str v)) 0))))
-;; ── Sandbox/test runtime additions ──────────────────────────────
+
-;; Property access — dot notation and .length
 (define
   hs-query-first
   (fn (sel) (host-call (host-global "document") "querySelector" sel)))
-;; DOM query stub — sandbox returns empty list
+;; ── Sandbox/test runtime additions ──────────────────────────────
+;; Property access — dot notation and .length
 (define
   hs-query-last
   (fn
@@ -669,11 +656,9 @@
     (let
       ((all (dom-query-all (dom-body) sel)))
       (if (> (len all) 0) (nth all (- (len all) 1)) nil))))
-;; Method dispatch — obj.method(args)
+;; DOM query stub — sandbox returns empty list
 (define hs-first (fn (scope sel) (dom-query-all scope sel)))
-
+;; Method dispatch — obj.method(args)
-;; ── 0.9.90 features ─────────────────────────────────────────────
-;; beep! — debug logging, returns value unchanged
 (define
   hs-last
   (fn
@@ -681,7 +666,9 @@
     (let
       ((all (dom-query-all scope sel)))
       (if (> (len all) 0) (nth all (- (len all) 1)) nil))))
-;; Property-based is — check obj.key truthiness
+
+;; ── 0.9.90 features ─────────────────────────────────────────────
+;; beep! — debug logging, returns value unchanged
 (define
   hs-repeat-times
   (fn
@@ -699,7 +686,7 @@
               ((= signal "hs-continue") (do-repeat (+ i 1)))
               (true (do-repeat (+ i 1))))))))
     (do-repeat 0)))
-;; Array slicing (inclusive both ends)
+;; Property-based is — check obj.key truthiness
 (define
   hs-repeat-forever
   (fn
@@ -715,7 +702,7 @@
             ((= signal "hs-continue") (do-forever))
             (true (do-forever))))))
     (do-forever)))
-;; Collection: sorted by
+;; Array slicing (inclusive both ends)
 (define
   hs-repeat-while
   (fn
@@ -728,7 +715,7 @@
           ((= signal "hs-break") nil)
           ((= signal "hs-continue") (hs-repeat-while cond-fn thunk))
           (true (hs-repeat-while cond-fn thunk)))))))
-;; Collection: sorted by descending
+;; Collection: sorted by
 (define
   hs-repeat-until
   (fn
@@ -740,7 +727,7 @@
         ((= signal "hs-continue")
           (if (cond-fn) nil (hs-repeat-until cond-fn thunk)))
         (true (if (cond-fn) nil (hs-repeat-until cond-fn thunk)))))))
-;; Collection: split by
+;; Collection: sorted by descending
 (define
   hs-for-each
   (fn
@@ -760,7 +747,7 @@
                 ((= signal "hs-continue") (do-loop (rest remaining)))
                 (true (do-loop (rest remaining))))))))
       (do-loop items))))
-;; Collection: joined by
+;; Collection: split by
 (begin
   (define
     hs-append
@@ -788,7 +775,7 @@
         ((hs-element? target)
           (dom-insert-adjacent-html target "beforeend" (str value)))
         (true nil)))))
-
+;; Collection: joined by
 (define
   hs-sender
   (fn
@@ -1310,10 +1297,14 @@
                 ((ch (substring sel i (+ i 1))))
                 (cond
                   ((= ch ".")
-                    (do (flush!) (set! mode "class") (walk (+ i 1))))
+                    (do
+                      (flush!)
+                      (set! mode "class")
+                      (walk (+ i 1))))
                   ((= ch "#")
                     (do (flush!) (set! mode "id") (walk (+ i 1))))
-                  (true (do (set! cur (str cur ch)) (walk (+ i 1)))))))))
+                  (true
+                    (do (set! cur (str cur ch)) (walk (+ i 1)))))))))
         (walk 0)
         (flush!)
         {:tag tag :classes classes :id id}))))
@@ -1398,6 +1389,7 @@
   hs-strict-eq
   (fn (a b) (and (= (type-of a) (type-of b)) (= a b))))
 
+
 (define
   hs-eq-ignore-case
   (fn (a b) (= (downcase (str a)) (downcase (str b)))))
@@ -1438,7 +1430,10 @@
       ((and (dict? a) (dict? b))
         (let
           ((pos (host-call a "compareDocumentPosition" b)))
-          (if (number? pos) (not (= 0 (mod (/ pos 4) 2))) false)))
+          (if
+            (number? pos)
+            (not (= 0 (mod (/ pos 4) 2)))
+            false)))
       (true (< (str a) (str b))))))
 
 (define
@@ -1540,7 +1535,10 @@
       ((and (dict? a) (dict? b))
         (let
           ((pos (host-call a "compareDocumentPosition" b)))
-          (if (number? pos) (not (= 0 (mod (/ pos 4) 2))) false)))
+          (if
+            (number? pos)
+            (not (= 0 (mod (/ pos 4) 2)))
+            false)))
       (true (< (str a) (str b))))))
 
 (define
@@ -1591,7 +1589,9 @@
 
 (define
   hs-morph-char
-  (fn (s p) (if (or (< p 0) (>= p (string-length s))) nil (nth s p))))
+  (fn
+    (s p)
+    (if (or (< p 0) (>= p (string-length s))) nil (nth s p))))
 
 (define
   hs-morph-index-from
@@ -1619,7 +1619,10 @@
         (q)
         (let
           ((c (hs-morph-char s q)))
-          (if (and c (< (index-of stop c) 0)) (loop (+ q 1)) q))))
+          (if
+            (and c (< (index-of stop c) 0))
+            (loop (+ q 1))
+            q))))
     (let ((e (loop p))) (list (substring s p e) e))))
 
 (define
@@ -1661,7 +1664,9 @@
                                 (append
                                   acc
                                   (list
-                                    (list name (substring s (+ p4 1) close)))))))
+                                    (list
+                                      name
+                                      (substring s (+ p4 1) close)))))))
                           ((= c2 "'")
                             (let
                               ((close (hs-morph-index-from s "'" (+ p4 1))))
@@ -1671,7 +1676,9 @@
                                 (append
                                   acc
                                   (list
-                                    (list name (substring s (+ p4 1) close)))))))
+                                    (list
+                                      name
+                                      (substring s (+ p4 1) close)))))))
                           (true
                             (let
                               ((r2 (hs-morph-read-until s p4 " \t\n/>")))
@@ -1755,7 +1762,9 @@
               (for-each
                 (fn
                   (c)
-                  (when (> (string-length c) 0) (dom-add-class el c)))
+                  (when
+                    (> (string-length c) 0)
+                    (dom-add-class el c)))
                 (split v " ")))
             ((and keep-id (= n "id")) nil)
             (true (dom-set-attr el n v)))))
@@ -1856,7 +1865,8 @@
           ((parts (split resolved ":")))
           (let
             ((prop (first parts))
-              (val (if (> (len parts) 1) (nth parts 1) nil)))
+              (val
+                (if (> (len parts) 1) (nth parts 1) nil)))
             (cond
               ((and (not (= prop "display")) (not (= prop "opacity")) (not (= prop "visibility")) (not (= prop "hidden")) (not (= prop "class-hidden")) (not (= prop "class-invisible")) (not (= prop "class-opacity")) (not (= prop "details")) (not (= prop "dialog")) (dict-has? _hs-hide-strategies prop))
                 (let
@@ -1895,7 +1905,8 @@
           ((parts (split resolved ":")))
           (let
             ((prop (first parts))
-              (val (if (> (len parts) 1) (nth parts 1) nil)))
+              (val
+                (if (> (len parts) 1) (nth parts 1) nil)))
             (cond
               ((and (not (= prop "display")) (not (= prop "opacity")) (not (= prop "visibility")) (not (= prop "hidden")) (not (= prop "class-hidden")) (not (= prop "class-invisible")) (not (= prop "class-opacity")) (not (= prop "details")) (not (= prop "dialog")) (dict-has? _hs-hide-strategies prop))
                 (let
@@ -1999,10 +2010,14 @@
                             (if
                               (= depth 1)
                               j
-                              (find-close (+ j 1) (- depth 1)))
+                              (find-close
+                                (+ j 1)
+                                (- depth 1)))
                             (if
                               (= (nth raw j) "{")
-                              (find-close (+ j 1) (+ depth 1))
+                              (find-close
+                                (+ j 1)
+                                (+ depth 1))
                               (find-close (+ j 1) depth))))))
                     (let
                       ((close (find-close start 1)))
@@ -2093,7 +2108,10 @@
               (if
                 (= (len lst) 0)
                 -1
-                (if (= (first lst) item) i (idx-loop (rest lst) (+ i 1))))))
+                (if
+                  (= (first lst) item)
+                  i
+                  (idx-loop (rest lst) (+ i 1))))))
           (idx-loop obj 0)))
       (true nil))))
 
@@ -2179,7 +2197,8 @@
                 (cond
                   ((= end "hs-pick-end") n)
                   ((= end "hs-pick-start") 0)
-                  ((and (number? end) (< end 0)) (max 0 (+ n end)))
+                  ((and (number? end) (< end 0))
+                    (max 0 (+ n end)))
                   (true end))))
             (cond
               ((string? col) (slice col s e))
@@ -2466,6 +2485,50 @@
           ((nth entry 2) val)))
       _hs-dom-watchers)))
 
+(define hs-prolog-hook nil)
+
+(define hs-set-prolog-hook! (fn (f) (set! hs-prolog-hook f)))
+
+(define
+  prolog
+  (fn
+    (db goal)
+    (if
+      (nil? hs-prolog-hook)
+      (raise "prolog hook not installed")
+      (hs-prolog-hook db goal))))
+
+(define
+  hs-null-error!
+  (fn (selector) (raise (str "'" selector "' is null"))))
+
+(define
+  hs-named-target
+  (fn (selector value) (if (nil? value) (hs-null-error! selector) value)))
+
+(define
+  hs-named-target-list
+  (fn
+    (selector values)
+    (if (nil? values) (hs-null-error! selector) values)))
+
+(define
+  hs-query-named-all
+  (fn
+    (selector)
+    (let
+      ((results (hs-query-all selector)))
+      (if
+        (and
+          (or
+            (nil? results)
+            (and (list? results) (= (len results) 0)))
+          (string? selector)
+          (> (len selector) 0)
+          (= (substring selector 0 1) "#"))
+        (hs-null-error! selector)
+        results))))
+
 (define
   hs-dom-is-ancestor?
   (fn

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/prolog/compiler.sx

@@ -0,0 +1,176 @@
+;; lib/prolog/compiler.sx — clause compiler: parse-AST clauses → SX closures
+;;
+;; Each compiled clause is a lambda (fn (goal trail db cut-box k) bool)
+;; that creates fresh vars, builds the instantiated head/body, and calls
+;; pl-unify! + pl-solve! directly — no AST walk at solve time.
+;;
+;; Usage:
+;;   (pl-db-load! db (pl-parse src))
+;;   (pl-compile-db! db)
+;;   ; pl-solve-user! in runtime.sx automatically prefers compiled clauses
+;;   (pl-solve-once! db goal trail)
+
+;; Collect unique variable names from a parse-AST clause into a dict.
+(define
+  pl-cmp-vars-into!
+  (fn
+    (ast seen)
+    (cond
+      ((not (list? ast)) nil)
+      ((empty? ast) nil)
+      ((= (first ast) "var")
+        (let
+          ((name (nth ast 1)))
+          (when
+            (and (not (= name "_")) (not (dict-has? seen name)))
+            (dict-set! seen name true))))
+      ((= (first ast) "compound")
+        (for-each (fn (a) (pl-cmp-vars-into! a seen)) (nth ast 2)))
+      ((= (first ast) "clause")
+        (begin
+          (pl-cmp-vars-into! (nth ast 1) seen)
+          (pl-cmp-vars-into! (nth ast 2) seen))))))
+
+;; Return list of unique var names in a clause (head + body, excluding _).
+(define
+  pl-cmp-collect-vars
+  (fn
+    (clause)
+    (let ((seen {})) (pl-cmp-vars-into! clause seen) (keys seen))))
+
+;; Create a fresh runtime var for each name in the list; return name->var dict.
+(define
+  pl-cmp-make-var-map
+  (fn
+    (var-names)
+    (let
+      ((m {}))
+      (for-each
+        (fn (name) (dict-set! m name (pl-mk-rt-var name)))
+        var-names)
+      m)))
+
+;; Instantiate a parse-AST term using a pre-built var-map.
+;; ("var" "_") always gets a fresh anonymous var.
+(define
+  pl-cmp-build-term
+  (fn
+    (ast var-map)
+    (cond
+      ((pl-var? ast) ast)
+      ((not (list? ast)) ast)
+      ((empty? ast) ast)
+      ((= (first ast) "var")
+        (let
+          ((name (nth ast 1)))
+          (if (= name "_") (pl-mk-rt-var "_") (dict-get var-map name))))
+      ((or (= (first ast) "atom") (= (first ast) "num") (= (first ast) "str"))
+        ast)
+      ((= (first ast) "compound")
+        (list
+          "compound"
+          (nth ast 1)
+          (map (fn (a) (pl-cmp-build-term a var-map)) (nth ast 2))))
+      ((= (first ast) "clause")
+        (list
+          "clause"
+          (pl-cmp-build-term (nth ast 1) var-map)
+          (pl-cmp-build-term (nth ast 2) var-map)))
+      (true ast))))
+
+;; Compile one parse-AST clause to a lambda.
+;; Pre-computes var names at compile time; creates fresh vars per call.
+(define
+  pl-compile-clause
+  (fn
+    (clause)
+    (let
+      ((var-names (pl-cmp-collect-vars clause))
+        (head-ast (nth clause 1))
+        (body-ast (nth clause 2)))
+      (fn
+        (goal trail db cut-box k)
+        (let
+          ((var-map (pl-cmp-make-var-map var-names)))
+          (let
+            ((fresh-head (pl-cmp-build-term head-ast var-map))
+              (fresh-body (pl-cmp-build-term body-ast var-map)))
+            (let
+              ((mark (pl-trail-mark trail)))
+              (if
+                (pl-unify! goal fresh-head trail)
+                (let
+                  ((r (pl-solve! db fresh-body trail cut-box k)))
+                  (if r true (begin (pl-trail-undo-to! trail mark) false)))
+                (begin (pl-trail-undo-to! trail mark) false)))))))))
+
+;; Try a list of compiled clause lambdas — same cut semantics as pl-try-clauses!.
+(define
+  pl-try-compiled-clauses!
+  (fn
+    (db
+      goal
+      trail
+      compiled-clauses
+      outer-cut-box
+      outer-was-cut
+      inner-cut-box
+      k)
+    (cond
+      ((empty? compiled-clauses) false)
+      (true
+        (let
+          ((r ((first compiled-clauses) goal trail db inner-cut-box k)))
+          (cond
+            (r true)
+            ((dict-get inner-cut-box :cut) false)
+            ((and (not outer-was-cut) (dict-get outer-cut-box :cut)) false)
+            (true
+              (pl-try-compiled-clauses!
+                db
+                goal
+                trail
+                (rest compiled-clauses)
+                outer-cut-box
+                outer-was-cut
+                inner-cut-box
+                k))))))))
+
+;; Compile all clauses in DB and store in :compiled table.
+;; After this call, pl-solve-user! will dispatch via compiled lambdas.
+;; Note: clauses assert!-ed after this call are not compiled.
+(define
+  pl-compile-db!
+  (fn
+    (db)
+    (let
+      ((src-table (dict-get db :clauses)) (compiled-table {}))
+      (for-each
+        (fn
+          (key)
+          (dict-set!
+            compiled-table
+            key
+            (map pl-compile-clause (dict-get src-table key))))
+        (keys src-table))
+      (dict-set! db :compiled compiled-table)
+      db)))
+
+;; Cross-validate: load src into both a plain and a compiled DB,
+;; run goal-str through each, return true iff solution counts match.
+;; Use this to keep the interpreter as the reference implementation.
+(define
+  pl-compiled-matches-interp?
+  (fn
+    (src goal-str)
+    (let
+      ((db-interp (pl-mk-db)) (db-comp (pl-mk-db)))
+      (pl-db-load! db-interp (pl-parse src))
+      (pl-db-load! db-comp (pl-parse src))
+      (pl-compile-db! db-comp)
+      (let
+        ((gi (pl-instantiate (pl-parse-goal goal-str) {}))
+          (gc (pl-instantiate (pl-parse-goal goal-str) {})))
+        (=
+          (pl-solve-count! db-interp gi (pl-mk-trail))
+          (pl-solve-count! db-comp gc (pl-mk-trail)))))))

lib/prolog/conformance.sh

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+# Run every Prolog test suite via sx_server and refresh scoreboard.{json,md}.
+# Exit 0 if all green, 1 if any failures.
+set -euo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+ROOT="$(cd "$HERE/../.." && pwd)"
+SX="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
+
+if [[ ! -x "$SX" ]]; then
+  echo "sx_server not found at $SX (set SX_SERVER env to override)" >&2
+  exit 2
+fi
+
+cd "$ROOT"
+
+# name : test-file : runner-fn
+SUITES=(
+  "parse:lib/prolog/tests/parse.sx:pl-parse-tests-run!"
+  "unify:lib/prolog/tests/unify.sx:pl-unify-tests-run!"
+  "clausedb:lib/prolog/tests/clausedb.sx:pl-clausedb-tests-run!"
+  "solve:lib/prolog/tests/solve.sx:pl-solve-tests-run!"
+  "operators:lib/prolog/tests/operators.sx:pl-operators-tests-run!"
+  "dynamic:lib/prolog/tests/dynamic.sx:pl-dynamic-tests-run!"
+  "findall:lib/prolog/tests/findall.sx:pl-findall-tests-run!"
+  "term_inspect:lib/prolog/tests/term_inspect.sx:pl-term-inspect-tests-run!"
+  "append:lib/prolog/tests/programs/append.sx:pl-append-tests-run!"
+  "reverse:lib/prolog/tests/programs/reverse.sx:pl-reverse-tests-run!"
+  "member:lib/prolog/tests/programs/member.sx:pl-member-tests-run!"
+  "nqueens:lib/prolog/tests/programs/nqueens.sx:pl-nqueens-tests-run!"
+  "family:lib/prolog/tests/programs/family.sx:pl-family-tests-run!"
+  "atoms:lib/prolog/tests/atoms.sx:pl-atom-tests-run!"
+  "query_api:lib/prolog/tests/query_api.sx:pl-query-api-tests-run!"
+  "iso_predicates:lib/prolog/tests/iso_predicates.sx:pl-iso-predicates-tests-run!"
+  "meta_predicates:lib/prolog/tests/meta_predicates.sx:pl-meta-predicates-tests-run!"
+  "list_predicates:lib/prolog/tests/list_predicates.sx:pl-list-predicates-tests-run!"
+  "meta_call:lib/prolog/tests/meta_call.sx:pl-meta-call-tests-run!"
+  "set_predicates:lib/prolog/tests/set_predicates.sx:pl-set-predicates-tests-run!"
+  "char_predicates:lib/prolog/tests/char_predicates.sx:pl-char-predicates-tests-run!"
+  "io_predicates:lib/prolog/tests/io_predicates.sx:pl-io-predicates-tests-run!"
+  "assert_rules:lib/prolog/tests/assert_rules.sx:pl-assert-rules-tests-run!"
+  "string_agg:lib/prolog/tests/string_agg.sx:pl-string-agg-tests-run!"
+  "advanced:lib/prolog/tests/advanced.sx:pl-advanced-tests-run!"
+  "compiler:lib/prolog/tests/compiler.sx:pl-compiler-tests-run!"
+  "cross_validate:lib/prolog/tests/cross_validate.sx:pl-cross-validate-tests-run!"
+  "integration:lib/prolog/tests/integration.sx:pl-integration-tests-run!"
+  "hs_bridge:lib/prolog/tests/hs_bridge.sx:pl-hs-bridge-tests-run!"
+)
+
+SCRIPT='(epoch 1)
+(load "lib/prolog/tokenizer.sx")
+(load "lib/prolog/parser.sx")
+(load "lib/prolog/runtime.sx")
+(load "lib/prolog/query.sx")
+(load "lib/prolog/compiler.sx")
+(load "lib/prolog/hs-bridge.sx")'
+for entry in "${SUITES[@]}"; do
+  IFS=: read -r _ file _ <<< "$entry"
+  SCRIPT+=$'\n(load "'"$file"$'")'
+done
+for entry in "${SUITES[@]}"; do
+  IFS=: read -r _ _ fn <<< "$entry"
+  SCRIPT+=$'\n(eval "('"$fn"$')")'
+done
+
+OUTPUT="$(printf '%s\n' "$SCRIPT" | "$SX" 2>&1)"
+
+mapfile -t LINES < <(printf '%s\n' "$OUTPUT" | grep -E '^\{:failed')
+
+if [[ ${#LINES[@]} -ne ${#SUITES[@]} ]]; then
+  echo "Expected ${#SUITES[@]} suite results, got ${#LINES[@]}" >&2
+  echo "---- raw output ----" >&2
+  printf '%s\n' "$OUTPUT" >&2
+  exit 3
+fi
+
+TOTAL_PASS=0
+TOTAL_FAIL=0
+TOTAL=0
+JSON_SUITES=""
+MD_ROWS=""
+
+for i in "${!SUITES[@]}"; do
+  IFS=: read -r name _ _ <<< "${SUITES[$i]}"
+  line="${LINES[$i]}"
+  passed=$(grep -oE ':passed [0-9]+' <<< "$line" | grep -oE '[0-9]+')
+  total=$(grep -oE ':total [0-9]+' <<< "$line" | grep -oE '[0-9]+')
+  failed=$(grep -oE ':failed [0-9]+' <<< "$line" | grep -oE '[0-9]+')
+  TOTAL_PASS=$((TOTAL_PASS + passed))
+  TOTAL_FAIL=$((TOTAL_FAIL + failed))
+  TOTAL=$((TOTAL + total))
+  status="ok"
+  [[ "$failed" -gt 0 ]] && status="FAIL"
+  [[ -n "$JSON_SUITES" ]] && JSON_SUITES+=","
+  JSON_SUITES+="\"$name\":{\"passed\":$passed,\"total\":$total,\"failed\":$failed}"
+  MD_ROWS+="| $name | $passed | $total | $status |"$'\n'
+done
+
+WHEN="$(date -Iseconds 2>/dev/null || date)"
+
+cat > "$HERE/scoreboard.json" <<JSON
+{
+  "total_passed": $TOTAL_PASS,
+  "total_failed": $TOTAL_FAIL,
+  "total": $TOTAL,
+  "suites": {$JSON_SUITES},
+  "generated": "$WHEN"
+}
+JSON
+
+cat > "$HERE/scoreboard.md" <<MD
+# Prolog scoreboard
+
+**$TOTAL_PASS / $TOTAL passing** ($TOTAL_FAIL failure(s)).
+Generated $WHEN.
+
+| Suite | Passed | Total | Status |
+|-------|--------|-------|--------|
+$MD_ROWS
+Run \`bash lib/prolog/conformance.sh\` to refresh. Override the binary
+with \`SX_SERVER=path/to/sx_server.exe bash …\`.
+MD
+
+if [[ "$TOTAL_FAIL" -gt 0 ]]; then
+  echo "$TOTAL_FAIL failure(s) across $TOTAL tests" >&2
+  exit 1
+fi
+
+echo "All $TOTAL tests pass."

lib/prolog/hs-bridge.sx

@@ -0,0 +1,84 @@
+;; lib/prolog/hs-bridge.sx — Prolog ↔ Hyperscript bridge
+;;
+;; Two complementary integration styles:
+;;
+;; 1. Hook style — for `prolog(db, "goal(args)")` call syntax in Hyperscript:
+;;      (pl-install-hs-hook!)   ;; call once at startup
+;;    Requires lib/hyperscript/runtime.sx (provides hs-set-prolog-hook!)
+;;
+;; 2. Factory style — for named conditions like `when allowed(user, action)`:
+;;      (define allowed (pl-hs-predicate/2 pl-db "allowed"))
+;;    No parser/compiler changes needed: Hyperscript compiles
+;;    `allowed(user, action)` to `(allowed user action)` — a plain SX call.
+;;
+;; Requires tokenizer.sx, parser.sx, runtime.sx, query.sx loaded first.
+
+;; --- Hook style ---
+
+(define
+  pl-install-hs-hook!
+  (fn
+    ()
+    (hs-set-prolog-hook!
+      (fn (db goal) (not (= nil (pl-query-one db goal)))))))
+
+;; --- Factory style ---
+
+;; Test whether a ground Prolog goal succeeds against db.
+;; Returns true/false (not a solution dict).
+(define
+  pl-hs-query
+  (fn (db goal-str) (not (nil? (pl-query-one db goal-str)))))
+
+;; Build a Prolog goal string from a predicate name and arg list.
+;; SX values: strings/keywords pass through; numbers are stringified via str.
+(define
+  pl-hs-build-goal
+  (fn
+    (pred-name args)
+    (str pred-name "(" (join ", " (map (fn (a) (str a)) args)) ")")))
+
+;; Return a 1-arg SX function that succeeds iff pred(a) holds in db.
+(define
+  pl-hs-predicate/1
+  (fn
+    (db pred-name)
+    (fn (a) (pl-hs-query db (pl-hs-build-goal pred-name (list a))))))
+
+;; Return a 2-arg SX function that succeeds iff pred(a, b) holds in db.
+(define
+  pl-hs-predicate/2
+  (fn
+    (db pred-name)
+    (fn (a b) (pl-hs-query db (pl-hs-build-goal pred-name (list a b))))))
+
+;; Return a 3-arg SX function that succeeds iff pred(a, b, c) holds in db.
+(define
+  pl-hs-predicate/3
+  (fn
+    (db pred-name)
+    (fn (a b c) (pl-hs-query db (pl-hs-build-goal pred-name (list a b c))))))
+
+;; Install every predicate in install-list as a named SX function backed by db.
+;; install-list: list of (name arity) pairs.
+;; Returns a dict {name → fn} for the caller to destructure.
+(define
+  pl-hs-install
+  (fn
+    (db install-list)
+    (reduce
+      (fn
+        (acc entry)
+        (let
+          ((pred-name (first entry)) (arity (nth entry 1)))
+          (dict-set!
+            acc
+            pred-name
+            (cond
+              ((= arity 1) (pl-hs-predicate/1 db pred-name))
+              ((= arity 2) (pl-hs-predicate/2 db pred-name))
+              ((= arity 3) (pl-hs-predicate/3 db pred-name))
+              (true (fn (a b) false))))
+          acc))
+      {}
+      install-list)))

lib/prolog/parser.sx

@@ -1,28 +1,20 @@
 ;; lib/prolog/parser.sx — tokens → Prolog AST
 ;;
-;; Phase 1 grammar (NO operator table yet):
+;; Phase 4 grammar (with operator table):
 ;;   Program      := Clause* EOF
-;;   Clause       := Term "." | Term ":-" Term "."
+;;   Clause       := Term[999] "." | Term[999] ":-" Term[1200] "."
-;;   Term         := Atom | Var | Number | String | Compound | List
+;;   Term[Pmax] uses precedence climbing on the operator table:
-;;   Compound     := atom "(" ArgList ")"
+;;     primary = Atom | Var | Number | String | Compound | List | "(" Term[1200] ")"
-;;   ArgList      := Term ("," Term)*
+;;     while next token is infix op `op` with prec(op) ≤ Pmax:
-;;   List         := "[" "]" | "[" Term ("," Term)* ("|" Term)? "]"
+;;       consume op; parse rhs at right-prec(op); fold into compound(op-name,[lhs,rhs])
 ;;
-;; Term AST shapes (all tagged lists for uniform dispatch):
+;; Op type → right-prec for op at precedence P:
-;;   ("atom"  name)            — atom
+;;   xfx → P-1   strict-both
-;;   ("var"   name)            — variable template (parser-time only)
+;;   xfy → P     right-associative
-;;   ("num"   value)           — integer or float
+;;   yfx → P-1   left-associative
-;;   ("str"   value)           — string literal
-;;   ("compound" functor args) — compound term, args is list of term-ASTs
-;;   ("cut")                   — the cut atom !
 ;;
-;; A clause is (list "clause" head body). A fact is head with body = ("atom" "true").
+;; AST shapes are unchanged — operators just become compound terms.
-;;
-;; The empty list is (atom "[]"). Cons is compound "." with two args:
-;; [1, 2, 3]   → .(1, .(2, .(3, [])))
-;; [H|T]       → .(H, T)
 
-;; ── Parser state helpers ────────────────────────────────────────────
 (define
   pp-peek
   (fn
@@ -66,7 +58,6 @@
             (if (= (get t :value) nil) "" (get t :value))
             "'"))))))
 
-;; ── AST constructors ────────────────────────────────────────────────
 (define pl-mk-atom (fn (name) (list "atom" name)))
 (define pl-mk-var (fn (name) (list "var" name)))
 (define pl-mk-num (fn (n) (list "num" n)))
@@ -74,18 +65,14 @@
 (define pl-mk-compound (fn (f args) (list "compound" f args)))
 (define pl-mk-cut (fn () (list "cut")))
 
-;; Term tag extractors
 (define pl-term-tag (fn (t) (if (list? t) (first t) nil)))
 (define pl-term-val (fn (t) (nth t 1)))
 (define pl-compound-functor (fn (t) (nth t 1)))
 (define pl-compound-args (fn (t) (nth t 2)))
 
-;; Empty-list atom and cons helpers
 (define pl-nil-term (fn () (pl-mk-atom "[]")))
-
 (define pl-mk-cons (fn (h t) (pl-mk-compound "." (list h t))))
 
-;; Build cons list from a list of terms + optional tail
 (define
   pl-mk-list-term
   (fn
@@ -95,9 +82,61 @@
       tail
       (pl-mk-cons (first items) (pl-mk-list-term (rest items) tail)))))
 
-;; ── Term parser ─────────────────────────────────────────────────────
+;; ── Operator table (Phase 4) ──────────────────────────────────────
+;; Each entry: (name precedence type). Type ∈ "xfx" "xfy" "yfx".
 (define
-  pp-parse-term
+  pl-op-table
+  (list
+    (list "," 1000 "xfy")
+    (list ";" 1100 "xfy")
+    (list "->" 1050 "xfy")
+    (list "=" 700 "xfx")
+    (list "\\=" 700 "xfx")
+    (list "is" 700 "xfx")
+    (list "<" 700 "xfx")
+    (list ">" 700 "xfx")
+    (list "=<" 700 "xfx")
+    (list ">=" 700 "xfx")
+    (list "+" 500 "yfx")
+    (list "-" 500 "yfx")
+    (list "*" 400 "yfx")
+    (list "/" 400 "yfx")
+    (list ":-" 1200 "xfx")
+    (list "mod" 400 "yfx")))
+
+(define
+  pl-op-find
+  (fn
+    (name table)
+    (cond
+      ((empty? table) nil)
+      ((= (first (first table)) name) (rest (first table)))
+      (true (pl-op-find name (rest table))))))
+
+(define pl-op-lookup (fn (name) (pl-op-find name pl-op-table)))
+
+;; Token → (name prec type) for known infix ops, else nil.
+(define
+  pl-token-op
+  (fn
+    (t)
+    (let
+      ((ty (get t :type)) (vv (get t :value)))
+      (cond
+        ((and (= ty "punct") (= vv ","))
+          (let
+            ((info (pl-op-lookup ",")))
+            (if (nil? info) nil (cons "," info))))
+        ((or (= ty "atom") (= ty "op"))
+          (let
+            ((info (pl-op-lookup vv)))
+            (if (nil? info) nil (cons vv info))))
+        (true nil)))))
+
+;; ── Term parser ─────────────────────────────────────────────────────
+;; Primary term: atom, var, num, str, compound (atom + paren), list, cut, parens.
+(define
+  pp-parse-primary
   (fn
     (st)
     (let
@@ -111,6 +150,12 @@
           ((and (= ty "op") (= vv "!"))
             (do (pp-advance! st) (pl-mk-cut)))
           ((and (= ty "punct") (= vv "[")) (pp-parse-list st))
+          ((and (= ty "punct") (= vv "("))
+            (do
+              (pp-advance! st)
+              (let
+                ((inner (pp-parse-term-prec st 1200)))
+                (do (pp-expect! st "punct" ")") inner))))
           ((= ty "atom")
             (do
               (pp-advance! st)
@@ -133,13 +178,51 @@
                 (if (= vv nil) "" vv)
                 "'"))))))))
 
-;; Parse one or more comma-separated terms (arguments).
+;; Operator-aware term parser: precedence climbing.
+(define
+  pp-parse-term-prec
+  (fn
+    (st max-prec)
+    (let ((left (pp-parse-primary st))) (pp-parse-op-rhs st left max-prec))))
+
+(define
+  pp-parse-op-rhs
+  (fn
+    (st left max-prec)
+    (let
+      ((op-info (pl-token-op (pp-peek st))))
+      (cond
+        ((nil? op-info) left)
+        (true
+          (let
+            ((name (first op-info))
+              (prec (nth op-info 1))
+              (ty (nth op-info 2)))
+            (cond
+              ((> prec max-prec) left)
+              (true
+                (let
+                  ((right-prec (if (= ty "xfy") prec (- prec 1))))
+                  (do
+                    (pp-advance! st)
+                    (let
+                      ((right (pp-parse-term-prec st right-prec)))
+                      (pp-parse-op-rhs
+                        st
+                        (pl-mk-compound name (list left right))
+                        max-prec))))))))))))
+
+;; Backwards-compat alias.
+(define pp-parse-term (fn (st) (pp-parse-term-prec st 999)))
+
+;; Args inside parens: parse at prec 999 so comma-as-operator (1000)
+;; is not consumed; the explicit comma loop handles separation.
 (define
   pp-parse-arg-list
   (fn
     (st)
     (let
-      ((first-arg (pp-parse-term st)) (args (list)))
+      ((first-arg (pp-parse-term-prec st 999)) (args (list)))
       (do
         (append! args first-arg)
         (define
@@ -150,12 +233,12 @@
               (pp-at? st "punct" ",")
               (do
                 (pp-advance! st)
-                (append! args (pp-parse-term st))
+                (append! args (pp-parse-term-prec st 999))
                 (loop)))))
         (loop)
         args))))
 
-;; Parse a [ ... ] list literal. Consumes the "[".
+;; List literal.
 (define
   pp-parse-list
   (fn
@@ -168,7 +251,7 @@
         (let
           ((items (list)))
           (do
-            (append! items (pp-parse-term st))
+            (append! items (pp-parse-term-prec st 999))
             (define
               comma-loop
               (fn
@@ -177,52 +260,17 @@
                   (pp-at? st "punct" ",")
                   (do
                     (pp-advance! st)
-                    (append! items (pp-parse-term st))
+                    (append! items (pp-parse-term-prec st 999))
                     (comma-loop)))))
             (comma-loop)
             (let
-              ((tail (if (pp-at? st "punct" "|") (do (pp-advance! st) (pp-parse-term st)) (pl-nil-term))))
+              ((tail (if (pp-at? st "punct" "|") (do (pp-advance! st) (pp-parse-term-prec st 999)) (pl-nil-term))))
               (do (pp-expect! st "punct" "]") (pl-mk-list-term items tail)))))))))
 
 ;; ── Body parsing ────────────────────────────────────────────────────
-;; A clause body is a comma-separated list of goals. We flatten into a
+;; A body is a single term parsed at prec 1200 — operator parser folds
-;; right-associative `,` compound: (A, B, C) → ','(A, ','(B, C))
+;; `,`, `;`, `->` automatically into right-associative compounds.
-;; If only one goal, it's that goal directly.
+(define pp-parse-body (fn (st) (pp-parse-term-prec st 1200)))
-(define
-  pp-parse-body
-  (fn
-    (st)
-    (let
-      ((first-goal (pp-parse-term st)) (rest-goals (list)))
-      (do
-        (define
-          gloop
-          (fn
-            ()
-            (when
-              (pp-at? st "punct" ",")
-              (do
-                (pp-advance! st)
-                (append! rest-goals (pp-parse-term st))
-                (gloop)))))
-        (gloop)
-        (if
-          (= (len rest-goals) 0)
-          first-goal
-          (pp-build-conj first-goal rest-goals))))))
-
-(define
-  pp-build-conj
-  (fn
-    (first-goal rest-goals)
-    (if
-      (= (len rest-goals) 0)
-      first-goal
-      (pl-mk-compound
-        ","
-        (list
-          first-goal
-          (pp-build-conj (first rest-goals) (rest rest-goals)))))))
 
 ;; ── Clause parsing ──────────────────────────────────────────────────
 (define
@@ -230,12 +278,11 @@
   (fn
     (st)
     (let
-      ((head (pp-parse-term st)))
+      ((head (pp-parse-term-prec st 999)))
       (let
         ((body (if (pp-at? st "op" ":-") (do (pp-advance! st) (pp-parse-body st)) (pl-mk-atom "true"))))
         (do (pp-expect! st "punct" ".") (list "clause" head body))))))
 
-;; Parse an entire program — returns list of clauses.
 (define
   pl-parse-program
   (fn
@@ -253,13 +300,9 @@
         (ploop)
         clauses))))
 
-;; Parse a single query term (no trailing "."). Returns the term.
 (define
   pl-parse-query
   (fn (tokens) (let ((st {:idx 0 :tokens tokens})) (pp-parse-body st))))
 
-;; Convenience: source → clauses
 (define pl-parse (fn (src) (pl-parse-program (pl-tokenize src))))
-
-;; Convenience: source → query term
 (define pl-parse-goal (fn (src) (pl-parse-query (pl-tokenize src))))

lib/prolog/query.sx

@@ -0,0 +1,114 @@
+;; lib/prolog/query.sx — high-level Prolog query API for SX/Hyperscript callers.
+;;
+;; Requires tokenizer.sx, parser.sx, runtime.sx to be loaded first.
+;;
+;; Public API:
+;;   (pl-load source-str)                → db
+;;   (pl-query-all db query-str)         → list of solution dicts {var-name → term-string}
+;;   (pl-query-one db query-str)         → first solution dict or nil
+;;   (pl-query source-str query-str)     → list of solution dicts (convenience)
+
+;; Collect variable name strings from a parse-time AST (pre-instantiation).
+;; Returns list of unique strings, excluding anonymous "_".
+(define
+  pl-query-extract-vars
+  (fn
+    (ast)
+    (let
+      ((seen {}))
+      (let
+        ((collect!
+          (fn
+            (t)
+            (cond
+              ((not (list? t)) nil)
+              ((empty? t) nil)
+              ((= (first t) "var")
+                (if
+                  (not (= (nth t 1) "_"))
+                  (dict-set! seen (nth t 1) true)
+                  nil))
+              ((= (first t) "compound")
+                (for-each collect! (nth t 2)))
+              (true nil)))))
+        (collect! ast)
+        (keys seen)))))
+
+;; Build a solution dict from a var-env after a successful solve.
+;; Maps each variable name string to its formatted term value.
+(define
+  pl-query-solution-dict
+  (fn
+    (var-names var-env)
+    (let
+      ((d {}))
+      (for-each
+        (fn (name) (dict-set! d name (pl-format-term (dict-get var-env name))))
+        var-names)
+      d)))
+
+;; Parse source-str and load clauses into a fresh DB.
+;; Returns the DB for reuse across multiple queries.
+(define
+  pl-load
+  (fn
+    (source-str)
+    (let
+      ((db (pl-mk-db)))
+      (if
+        (and (string? source-str) (not (= source-str "")))
+        (pl-db-load! db (pl-parse source-str))
+        nil)
+      db)))
+
+;; Run query-str against db, returning a list of solution dicts.
+;; Each dict maps variable name strings to their formatted term values.
+;; Returns an empty list if no solutions.
+(define
+  pl-query-all
+  (fn
+    (db query-str)
+    (let
+      ((parsed (pl-parse (str "q_ :- " query-str "."))))
+      (let
+        ((body-ast (nth (first parsed) 2)))
+        (let
+          ((var-names (pl-query-extract-vars body-ast))
+           (var-env {}))
+          (let
+            ((goal (pl-instantiate body-ast var-env))
+             (trail (pl-mk-trail))
+             (solutions (list)))
+            (let
+              ((mark (pl-trail-mark trail)))
+              (pl-solve!
+                db
+                goal
+                trail
+                {:cut false}
+                (fn
+                  ()
+                  (begin
+                    (append!
+                      solutions
+                      (pl-query-solution-dict var-names var-env))
+                    false)))
+              (pl-trail-undo-to! trail mark)
+              solutions)))))))
+
+;; Return the first solution dict, or nil if no solutions.
+(define
+  pl-query-one
+  (fn
+    (db query-str)
+    (let
+      ((all (pl-query-all db query-str)))
+      (if (empty? all) nil (first all)))))
+
+;; Convenience: parse source-str, then run query-str against it.
+;; Returns a list of solution dicts. Creates a fresh DB each call.
+(define
+  pl-query
+  (fn
+    (source-str query-str)
+    (pl-query-all (pl-load source-str) query-str)))

lib/prolog/scoreboard.json

@@ -0,0 +1,7 @@
+{
+  "total_passed": 590,
+  "total_failed": 0,
+  "total": 590,
+  "suites": {"parse":{"passed":25,"total":25,"failed":0},"unify":{"passed":47,"total":47,"failed":0},"clausedb":{"passed":14,"total":14,"failed":0},"solve":{"passed":62,"total":62,"failed":0},"operators":{"passed":19,"total":19,"failed":0},"dynamic":{"passed":11,"total":11,"failed":0},"findall":{"passed":11,"total":11,"failed":0},"term_inspect":{"passed":14,"total":14,"failed":0},"append":{"passed":6,"total":6,"failed":0},"reverse":{"passed":6,"total":6,"failed":0},"member":{"passed":7,"total":7,"failed":0},"nqueens":{"passed":6,"total":6,"failed":0},"family":{"passed":10,"total":10,"failed":0},"atoms":{"passed":34,"total":34,"failed":0},"query_api":{"passed":16,"total":16,"failed":0},"iso_predicates":{"passed":29,"total":29,"failed":0},"meta_predicates":{"passed":25,"total":25,"failed":0},"list_predicates":{"passed":33,"total":33,"failed":0},"meta_call":{"passed":15,"total":15,"failed":0},"set_predicates":{"passed":15,"total":15,"failed":0},"char_predicates":{"passed":27,"total":27,"failed":0},"io_predicates":{"passed":24,"total":24,"failed":0},"assert_rules":{"passed":15,"total":15,"failed":0},"string_agg":{"passed":25,"total":25,"failed":0},"advanced":{"passed":21,"total":21,"failed":0},"compiler":{"passed":17,"total":17,"failed":0},"cross_validate":{"passed":17,"total":17,"failed":0},"integration":{"passed":20,"total":20,"failed":0},"hs_bridge":{"passed":19,"total":19,"failed":0}},
+  "generated": "2026-05-06T08:29:09+00:00"
+}

lib/prolog/scoreboard.md

@@ -0,0 +1,39 @@
+# Prolog scoreboard
+
+**590 / 590 passing** (0 failure(s)).
+Generated 2026-05-06T08:29:09+00:00.
+
+| Suite | Passed | Total | Status |
+|-------|--------|-------|--------|
+| parse | 25 | 25 | ok |
+| unify | 47 | 47 | ok |
+| clausedb | 14 | 14 | ok |
+| solve | 62 | 62 | ok |
+| operators | 19 | 19 | ok |
+| dynamic | 11 | 11 | ok |
+| findall | 11 | 11 | ok |
+| term_inspect | 14 | 14 | ok |
+| append | 6 | 6 | ok |
+| reverse | 6 | 6 | ok |
+| member | 7 | 7 | ok |
+| nqueens | 6 | 6 | ok |
+| family | 10 | 10 | ok |
+| atoms | 34 | 34 | ok |
+| query_api | 16 | 16 | ok |
+| iso_predicates | 29 | 29 | ok |
+| meta_predicates | 25 | 25 | ok |
+| list_predicates | 33 | 33 | ok |
+| meta_call | 15 | 15 | ok |
+| set_predicates | 15 | 15 | ok |
+| char_predicates | 27 | 27 | ok |
+| io_predicates | 24 | 24 | ok |
+| assert_rules | 15 | 15 | ok |
+| string_agg | 25 | 25 | ok |
+| advanced | 21 | 21 | ok |
+| compiler | 17 | 17 | ok |
+| cross_validate | 17 | 17 | ok |
+| integration | 20 | 20 | ok |
+| hs_bridge | 19 | 19 | ok |
+
+Run `bash lib/prolog/conformance.sh` to refresh. Override the binary
+with `SX_SERVER=path/to/sx_server.exe bash …`.

lib/prolog/tests/advanced.sx

@@ -0,0 +1,254 @@
+;; lib/prolog/tests/advanced.sx — predsort/3, term_variables/2, arith extensions
+
+(define pl-adv-test-count 0)
+(define pl-adv-test-pass 0)
+(define pl-adv-test-fail 0)
+(define pl-adv-test-failures (list))
+
+(define
+  pl-adv-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-adv-test-count (+ pl-adv-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-adv-test-pass (+ pl-adv-test-pass 1))
+        (begin
+          (set! pl-adv-test-fail (+ pl-adv-test-fail 1))
+          (append!
+            pl-adv-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-adv-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-adv-db (pl-mk-db))
+;; Load a numeric comparator for predsort tests
+(pl-db-load!
+  pl-adv-db
+  (pl-parse
+    "cmp_num(Order, X, Y) :- (X < Y -> Order = '<' ; (X > Y -> Order = '>' ; Order = '='))."))
+
+;; ── Arithmetic extensions ──────────────────────────────────────────
+
+(define pl-adv-arith-env-1 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is floor(3.7)" pl-adv-arith-env-1)
+  (pl-mk-trail))
+(pl-adv-test!
+  "floor(3.7) = 3"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-1 "X")))
+  3)
+
+(define pl-adv-arith-env-2 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is ceiling(3.2)" pl-adv-arith-env-2)
+  (pl-mk-trail))
+(pl-adv-test!
+  "ceiling(3.2) = 4"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-2 "X")))
+  4)
+
+(define pl-adv-arith-env-3 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is truncate(3.9)" pl-adv-arith-env-3)
+  (pl-mk-trail))
+(pl-adv-test!
+  "truncate(3.9) = 3"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-3 "X")))
+  3)
+
+(define pl-adv-arith-env-4 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is truncate(0 - 3.9)" pl-adv-arith-env-4)
+  (pl-mk-trail))
+(pl-adv-test!
+  "truncate(0-3.9) = -3"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-4 "X")))
+  -3)
+
+(define pl-adv-arith-env-5 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is round(3.5)" pl-adv-arith-env-5)
+  (pl-mk-trail))
+(pl-adv-test!
+  "round(3.5) = 4"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-5 "X")))
+  4)
+
+(define pl-adv-arith-env-6 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is sqrt(4.0)" pl-adv-arith-env-6)
+  (pl-mk-trail))
+(pl-adv-test!
+  "sqrt(4.0) = 2"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-6 "X")))
+  2)
+
+(define pl-adv-arith-env-7 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is sign(0 - 5)" pl-adv-arith-env-7)
+  (pl-mk-trail))
+(pl-adv-test!
+  "sign(0-5) = -1"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-7 "X")))
+  -1)
+
+(define pl-adv-arith-env-8 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is sign(0)" pl-adv-arith-env-8)
+  (pl-mk-trail))
+(pl-adv-test!
+  "sign(0) = 0"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-8 "X")))
+  0)
+
+(define pl-adv-arith-env-9 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is sign(3)" pl-adv-arith-env-9)
+  (pl-mk-trail))
+(pl-adv-test!
+  "sign(3) = 1"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-9 "X")))
+  1)
+
+(define pl-adv-arith-env-10 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is pow(2, 3)" pl-adv-arith-env-10)
+  (pl-mk-trail))
+(pl-adv-test!
+  "pow(2,3) = 8"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-10 "X")))
+  8)
+
+(define pl-adv-arith-env-11 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is floor(0 - 3.7)" pl-adv-arith-env-11)
+  (pl-mk-trail))
+(pl-adv-test!
+  "floor(0-3.7) = -4"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-11 "X")))
+  -4)
+
+(define pl-adv-arith-env-12 {:X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "X is ceiling(0 - 3.2)" pl-adv-arith-env-12)
+  (pl-mk-trail))
+(pl-adv-test!
+  "ceiling(0-3.2) = -3"
+  (pl-num-val (pl-walk-deep (dict-get pl-adv-arith-env-12 "X")))
+  -3)
+
+;; ── term_variables/2 ──────────────────────────────────────────────
+
+(define pl-adv-tv-env-1 {:Vs (pl-mk-rt-var "Vs")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "term_variables(hello, Vs)" pl-adv-tv-env-1)
+  (pl-mk-trail))
+(pl-adv-test!
+  "term_variables(hello,Vs) -> []"
+  (pl-format-term (pl-walk-deep (dict-get pl-adv-tv-env-1 "Vs")))
+  "[]")
+
+(define pl-adv-tv-env-2 {:Vs (pl-mk-rt-var "Vs")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "term_variables(f(a, g(b)), Vs)" pl-adv-tv-env-2)
+  (pl-mk-trail))
+(pl-adv-test!
+  "term_variables(f(a,g(b)),Vs) -> []"
+  (pl-format-term (pl-walk-deep (dict-get pl-adv-tv-env-2 "Vs")))
+  "[]")
+
+(define pl-adv-tv-env-3 {:Y (pl-mk-rt-var "Y") :Vs (pl-mk-rt-var "Vs") :X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "term_variables(f(X, Y), Vs)" pl-adv-tv-env-3)
+  (pl-mk-trail))
+(pl-adv-test!
+  "term_variables(f(X,Y),Vs) has 2 vars"
+  (pl-list-length (pl-walk-deep (dict-get pl-adv-tv-env-3 "Vs")))
+  2)
+
+(define pl-adv-tv-env-4 {:Vs (pl-mk-rt-var "Vs") :X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "term_variables(X, Vs)" pl-adv-tv-env-4)
+  (pl-mk-trail))
+(pl-adv-test!
+  "term_variables(X,Vs) has 1 var"
+  (pl-list-length (pl-walk-deep (dict-get pl-adv-tv-env-4 "Vs")))
+  1)
+
+(define pl-adv-tv-env-5 {:Y (pl-mk-rt-var "Y") :Vs (pl-mk-rt-var "Vs") :X (pl-mk-rt-var "X")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "term_variables(foo(X, Y, X), Vs)" pl-adv-tv-env-5)
+  (pl-mk-trail))
+(pl-adv-test!
+  "term_variables(foo(X,Y,X),Vs) deduplicates X -> 2 vars"
+  (pl-list-length (pl-walk-deep (dict-get pl-adv-tv-env-5 "Vs")))
+  2)
+
+;; ── predsort/3 ────────────────────────────────────────────────────
+
+(define pl-adv-ps-env-1 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "predsort(cmp_num, [], R)" pl-adv-ps-env-1)
+  (pl-mk-trail))
+(pl-adv-test!
+  "predsort([]) -> []"
+  (pl-format-term (pl-walk-deep (dict-get pl-adv-ps-env-1 "R")))
+  "[]")
+
+(define pl-adv-ps-env-2 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "predsort(cmp_num, [1], R)" pl-adv-ps-env-2)
+  (pl-mk-trail))
+(pl-adv-test!
+  "predsort([1]) -> [1]"
+  (pl-format-term (pl-walk-deep (dict-get pl-adv-ps-env-2 "R")))
+  ".(1, [])")
+
+(define pl-adv-ps-env-3 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "predsort(cmp_num, [3,1,2], R)" pl-adv-ps-env-3)
+  (pl-mk-trail))
+(pl-adv-test!
+  "predsort([3,1,2]) -> [1,2,3]"
+  (pl-format-term (pl-walk-deep (dict-get pl-adv-ps-env-3 "R")))
+  ".(1, .(2, .(3, [])))")
+
+(define pl-adv-ps-env-4 {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-adv-db
+  (pl-adv-goal "predsort(cmp_num, [3,1,2,1,3], R)" pl-adv-ps-env-4)
+  (pl-mk-trail))
+(pl-adv-test!
+  "predsort([3,1,2,1,3]) dedup -> [1,2,3]"
+  (pl-format-term (pl-walk-deep (dict-get pl-adv-ps-env-4 "R")))
+  ".(1, .(2, .(3, [])))")
+
+;; ── Runner ─────────────────────────────────────────────────────────
+
+(define pl-advanced-tests-run! (fn () {:failed pl-adv-test-fail :passed pl-adv-test-pass :total pl-adv-test-count :failures pl-adv-test-failures}))

lib/prolog/tests/assert_rules.sx

@@ -0,0 +1,215 @@
+;; lib/prolog/tests/assert_rules.sx — assert/assertz/asserta with rule terms (head :- body)
+;; Tests that :- is in the op table (prec 1200 xfx) and pl-build-clause handles rule form.
+
+(define pl-ar-test-count 0)
+(define pl-ar-test-pass 0)
+(define pl-ar-test-fail 0)
+(define pl-ar-test-failures (list))
+
+(define
+  pl-ar-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-ar-test-count (+ pl-ar-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-ar-test-pass (+ pl-ar-test-pass 1))
+        (begin
+          (set! pl-ar-test-fail (+ pl-ar-test-fail 1))
+          (append!
+            pl-ar-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-ar-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+;; ── DB1: assertz a simple rule then query ──────────────────────────
+(define pl-ar-db1 (pl-mk-db))
+
+(pl-solve-once!
+  pl-ar-db1
+  (pl-ar-goal "assertz((double(X, Y) :- Y is X * 2))" {})
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "assertz rule: double(3, Y) succeeds"
+  (pl-solve-once!
+    pl-ar-db1
+    (pl-ar-goal "double(3, Y)" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-ar-env1 {})
+(pl-solve-once!
+  pl-ar-db1
+  (pl-ar-goal "double(3, Y)" pl-ar-env1)
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "assertz rule: double(3, Y) binds Y to 6"
+  (pl-num-val (pl-walk-deep (dict-get pl-ar-env1 "Y")))
+  6)
+
+(define pl-ar-env1b {})
+(pl-solve-once!
+  pl-ar-db1
+  (pl-ar-goal "double(10, Y)" pl-ar-env1b)
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "assertz rule: double(10, Y) yields 20"
+  (pl-num-val (pl-walk-deep (dict-get pl-ar-env1b "Y")))
+  20)
+
+;; ── DB2: assert a rule with multiple facts, count solutions ─────────
+(define pl-ar-db2 (pl-mk-db))
+
+(pl-solve-once!
+  pl-ar-db2
+  (pl-ar-goal "assert(fact(a))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db2
+  (pl-ar-goal "assert(fact(b))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db2
+  (pl-ar-goal "assertz((copy(X) :- fact(X)))" {})
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "rule copy/1 using fact/1: 2 solutions"
+  (pl-solve-count! pl-ar-db2 (pl-ar-goal "copy(X)" {}) (pl-mk-trail))
+  2)
+
+(define pl-ar-env2a {})
+(pl-solve-once! pl-ar-db2 (pl-ar-goal "copy(X)" pl-ar-env2a) (pl-mk-trail))
+
+(pl-ar-test!
+  "rule copy/1: first solution is a"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ar-env2a "X")))
+  "a")
+
+;; ── DB3: asserta rule is tried before existing clauses ─────────────
+(define pl-ar-db3 (pl-mk-db))
+
+(pl-solve-once!
+  pl-ar-db3
+  (pl-ar-goal "assert(ord(a))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db3
+  (pl-ar-goal "asserta((ord(b) :- true))" {})
+  (pl-mk-trail))
+
+(define pl-ar-env3 {})
+(pl-solve-once! pl-ar-db3 (pl-ar-goal "ord(X)" pl-ar-env3) (pl-mk-trail))
+
+(pl-ar-test!
+  "asserta rule ord(b) is tried before ord(a)"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ar-env3 "X")))
+  "b")
+
+(pl-ar-test!
+  "asserta: total solutions for ord/1 is 2"
+  (pl-solve-count! pl-ar-db3 (pl-ar-goal "ord(X)" {}) (pl-mk-trail))
+  2)
+
+;; ── DB4: rule with conjunction in body ─────────────────────────────
+(define pl-ar-db4 (pl-mk-db))
+
+(pl-solve-once!
+  pl-ar-db4
+  (pl-ar-goal "assert(num(1))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db4
+  (pl-ar-goal "assert(num(2))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db4
+  (pl-ar-goal "assertz((big(X) :- num(X), X > 1))" {})
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "conjunction in rule body: big(1) fails"
+  (pl-solve-once! pl-ar-db4 (pl-ar-goal "big(1)" {}) (pl-mk-trail))
+  false)
+
+(pl-ar-test!
+  "conjunction in rule body: big(2) succeeds"
+  (pl-solve-once! pl-ar-db4 (pl-ar-goal "big(2)" {}) (pl-mk-trail))
+  true)
+
+;; ── DB5: recursive rule ─────────────────────────────────────────────
+(define pl-ar-db5 (pl-mk-db))
+
+(pl-solve-once!
+  pl-ar-db5
+  (pl-ar-goal "assert((nat(0) :- true))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db5
+  (pl-ar-goal "assertz((nat(s(X)) :- nat(X)))" {})
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "recursive rule: nat(0) succeeds"
+  (pl-solve-once! pl-ar-db5 (pl-ar-goal "nat(0)" {}) (pl-mk-trail))
+  true)
+
+(pl-ar-test!
+  "recursive rule: nat(s(0)) succeeds"
+  (pl-solve-once!
+    pl-ar-db5
+    (pl-ar-goal "nat(s(0))" {})
+    (pl-mk-trail))
+  true)
+
+(pl-ar-test!
+  "recursive rule: nat(s(s(0))) succeeds"
+  (pl-solve-once!
+    pl-ar-db5
+    (pl-ar-goal "nat(s(s(0)))" {})
+    (pl-mk-trail))
+  true)
+
+(pl-ar-test!
+  "recursive rule: nat(bad) fails"
+  (pl-solve-once! pl-ar-db5 (pl-ar-goal "nat(bad)" {}) (pl-mk-trail))
+  false)
+
+;; ── DB6: rule with true body (explicit) ────────────────────────────
+(define pl-ar-db6 (pl-mk-db))
+
+(pl-solve-once!
+  pl-ar-db6
+  (pl-ar-goal "assertz((always(X) :- true))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-ar-db6
+  (pl-ar-goal "assert(always(extra))" {})
+  (pl-mk-trail))
+
+(pl-ar-test!
+  "rule body=true: always(foo) succeeds"
+  (pl-solve-once!
+    pl-ar-db6
+    (pl-ar-goal "always(foo)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-ar-test!
+  "rule body=true: always/1 has 2 clauses (1 rule + 1 fact)"
+  (pl-solve-count!
+    pl-ar-db6
+    (pl-ar-goal "always(X)" {})
+    (pl-mk-trail))
+  2)
+
+;; ── Runner ──────────────────────────────────────────────────────────
+(define pl-assert-rules-tests-run! (fn () {:failed pl-ar-test-fail :passed pl-ar-test-pass :total pl-ar-test-count :failures pl-ar-test-failures}))

lib/prolog/tests/atoms.sx

@@ -0,0 +1,305 @@
+;; lib/prolog/tests/atoms.sx — type predicates + string/atom built-ins
+
+(define pl-at-test-count 0)
+(define pl-at-test-pass 0)
+(define pl-at-test-fail 0)
+(define pl-at-test-failures (list))
+
+(define
+  pl-at-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-at-test-count (+ pl-at-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-at-test-pass (+ pl-at-test-pass 1))
+        (begin
+          (set! pl-at-test-fail (+ pl-at-test-fail 1))
+          (append!
+            pl-at-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-at-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-at-db (pl-mk-db))
+
+;; ── var/1 + nonvar/1 ──
+
+(pl-at-test!
+  "var(X) for unbound var"
+  (pl-solve-once! pl-at-db (pl-at-goal "var(X)" {}) (pl-mk-trail))
+  true)
+(pl-at-test!
+  "var(foo) fails"
+  (pl-solve-once! pl-at-db (pl-at-goal "var(foo)" {}) (pl-mk-trail))
+  false)
+(pl-at-test!
+  "nonvar(foo) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "nonvar(foo)" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "nonvar(X) for unbound var fails"
+  (pl-solve-once! pl-at-db (pl-at-goal "nonvar(X)" {}) (pl-mk-trail))
+  false)
+
+;; ── atom/1 ──
+
+(pl-at-test!
+  "atom(foo) succeeds"
+  (pl-solve-once! pl-at-db (pl-at-goal "atom(foo)" {}) (pl-mk-trail))
+  true)
+(pl-at-test!
+  "atom([]) succeeds"
+  (pl-solve-once! pl-at-db (pl-at-goal "atom([])" {}) (pl-mk-trail))
+  true)
+(pl-at-test!
+  "atom(42) fails"
+  (pl-solve-once! pl-at-db (pl-at-goal "atom(42)" {}) (pl-mk-trail))
+  false)
+(pl-at-test!
+  "atom(f(x)) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atom(f(x))" {})
+    (pl-mk-trail))
+  false)
+
+;; ── number/1 + integer/1 ──
+
+(pl-at-test!
+  "number(42) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "number(42)" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "number(foo) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "number(foo)" {})
+    (pl-mk-trail))
+  false)
+(pl-at-test!
+  "integer(7) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "integer(7)" {})
+    (pl-mk-trail))
+  true)
+
+;; ── compound/1 + callable/1 + atomic/1 ──
+
+(pl-at-test!
+  "compound(f(x)) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "compound(f(x))" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "compound(foo) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "compound(foo)" {})
+    (pl-mk-trail))
+  false)
+(pl-at-test!
+  "callable(foo) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "callable(foo)" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "callable(f(x)) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "callable(f(x))" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "callable(42) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "callable(42)" {})
+    (pl-mk-trail))
+  false)
+(pl-at-test!
+  "atomic(foo) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atomic(foo)" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "atomic(42) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atomic(42)" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "atomic(f(x)) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atomic(f(x))" {})
+    (pl-mk-trail))
+  false)
+
+;; ── is_list/1 ──
+
+(pl-at-test!
+  "is_list([]) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "is_list([])" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "is_list([1,2,3]) succeeds"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "is_list([1,2,3])" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "is_list(foo) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "is_list(foo)" {})
+    (pl-mk-trail))
+  false)
+
+;; ── atom_length/2 ──
+
+(define pl-at-env-al {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "atom_length(hello, N)" pl-at-env-al)
+  (pl-mk-trail))
+(pl-at-test!
+  "atom_length(hello, N) -> N=5"
+  (pl-num-val (pl-walk-deep (dict-get pl-at-env-al "N")))
+  5)
+(pl-at-test!
+  "atom_length empty atom"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atom_length('', 0)" {})
+    (pl-mk-trail))
+  true)
+
+;; ── atom_concat/3 ──
+
+(define pl-at-env-ac {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "atom_concat(foo, bar, X)" pl-at-env-ac)
+  (pl-mk-trail))
+(pl-at-test!
+  "atom_concat(foo, bar, X) -> X=foobar"
+  (pl-atom-name (pl-walk-deep (dict-get pl-at-env-ac "X")))
+  "foobar")
+
+(pl-at-test!
+  "atom_concat(foo, bar, foobar) check"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atom_concat(foo, bar, foobar)" {})
+    (pl-mk-trail))
+  true)
+(pl-at-test!
+  "atom_concat(foo, bar, foobaz) fails"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atom_concat(foo, bar, foobaz)" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-at-env-ac2 {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "atom_concat(foo, Y, foobar)" pl-at-env-ac2)
+  (pl-mk-trail))
+(pl-at-test!
+  "atom_concat(foo, Y, foobar) -> Y=bar"
+  (pl-atom-name (pl-walk-deep (dict-get pl-at-env-ac2 "Y")))
+  "bar")
+
+;; ── atom_chars/2 ──
+
+(define pl-at-env-ach {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "atom_chars(cat, Cs)" pl-at-env-ach)
+  (pl-mk-trail))
+(pl-at-test!
+  "atom_chars(cat, Cs) -> Cs=[c,a,t]"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "atom_chars(cat, [c,a,t])" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-at-env-ach2 {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "atom_chars(A, [h,i])" pl-at-env-ach2)
+  (pl-mk-trail))
+(pl-at-test!
+  "atom_chars(A, [h,i]) -> A=hi"
+  (pl-atom-name (pl-walk-deep (dict-get pl-at-env-ach2 "A")))
+  "hi")
+
+;; ── char_code/2 ──
+
+(define pl-at-env-cc {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "char_code(a, N)" pl-at-env-cc)
+  (pl-mk-trail))
+(pl-at-test!
+  "char_code(a, N) -> N=97"
+  (pl-num-val (pl-walk-deep (dict-get pl-at-env-cc "N")))
+  97)
+
+(define pl-at-env-cc2 {})
+(pl-solve-once!
+  pl-at-db
+  (pl-at-goal "char_code(C, 65)" pl-at-env-cc2)
+  (pl-mk-trail))
+(pl-at-test!
+  "char_code(C, 65) -> C='A'"
+  (pl-atom-name (pl-walk-deep (dict-get pl-at-env-cc2 "C")))
+  "A")
+
+;; ── number_codes/2 ──
+
+(pl-at-test!
+  "number_codes(42, [52,50])"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "number_codes(42, [52,50])" {})
+    (pl-mk-trail))
+  true)
+
+;; ── number_chars/2 ──
+
+(pl-at-test!
+  "number_chars(42, ['4','2'])"
+  (pl-solve-once!
+    pl-at-db
+    (pl-at-goal "number_chars(42, ['4','2'])" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-atom-tests-run! (fn () {:failed pl-at-test-fail :passed pl-at-test-pass :total pl-at-test-count :failures pl-at-test-failures}))

lib/prolog/tests/char_predicates.sx

@@ -0,0 +1,290 @@
+;; lib/prolog/tests/char_predicates.sx — char_type/2, upcase_atom/2, downcase_atom/2,
+;;   string_upper/2, string_lower/2
+
+(define pl-cp-test-count 0)
+(define pl-cp-test-pass 0)
+(define pl-cp-test-fail 0)
+(define pl-cp-test-failures (list))
+
+(define
+  pl-cp-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-cp-test-count (+ pl-cp-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-cp-test-pass (+ pl-cp-test-pass 1))
+        (begin
+          (set! pl-cp-test-fail (+ pl-cp-test-fail 1))
+          (append!
+            pl-cp-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-cp-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-cp-db (pl-mk-db))
+
+;; ─── char_type/2 — alpha ──────────────────────────────────────────
+
+(pl-cp-test!
+  "char_type(a, alpha) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(a, alpha)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "char_type('1', alpha) fails"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type('1', alpha)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-cp-test!
+  "char_type('A', alpha) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type('A', alpha)" {})
+    (pl-mk-trail))
+  true)
+
+;; ─── char_type/2 — alnum ─────────────────────────────────────────
+
+(pl-cp-test!
+  "char_type('5', alnum) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type('5', alnum)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "char_type(a, alnum) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(a, alnum)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "char_type(' ', alnum) fails"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(' ', alnum)" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── char_type/2 — digit ─────────────────────────────────────────
+
+(pl-cp-test!
+  "char_type('5', digit) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type('5', digit)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "char_type(a, digit) fails"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(a, digit)" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── char_type/2 — digit(Weight) ─────────────────────────────────
+
+(define pl-cp-env-dw {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "char_type('5', digit(N))" pl-cp-env-dw)
+  (pl-mk-trail))
+(pl-cp-test!
+  "char_type('5', digit(N)) -> N=5"
+  (pl-num-val (pl-walk-deep (dict-get pl-cp-env-dw "N")))
+  5)
+
+(define pl-cp-env-dw0 {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "char_type('0', digit(N))" pl-cp-env-dw0)
+  (pl-mk-trail))
+(pl-cp-test!
+  "char_type('0', digit(N)) -> N=0"
+  (pl-num-val (pl-walk-deep (dict-get pl-cp-env-dw0 "N")))
+  0)
+
+;; ─── char_type/2 — space/white ───────────────────────────────────
+
+(pl-cp-test!
+  "char_type(' ', space) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(' ', space)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "char_type(a, space) fails"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(a, space)" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── char_type/2 — upper(Lower) ──────────────────────────────────
+
+(define pl-cp-env-ul {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "char_type('A', upper(L))" pl-cp-env-ul)
+  (pl-mk-trail))
+(pl-cp-test!
+  "char_type('A', upper(L)) -> L=a"
+  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-ul "L")))
+  "a")
+
+(pl-cp-test!
+  "char_type(a, upper(L)) fails — not uppercase"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(a, upper(_))" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── char_type/2 — lower(Upper) ──────────────────────────────────
+
+(define pl-cp-env-lu {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "char_type(a, lower(U))" pl-cp-env-lu)
+  (pl-mk-trail))
+(pl-cp-test!
+  "char_type(a, lower(U)) -> U='A'"
+  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-lu "U")))
+  "A")
+
+;; ─── char_type/2 — ascii(Code) ───────────────────────────────────
+
+(define pl-cp-env-as {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "char_type(a, ascii(C))" pl-cp-env-as)
+  (pl-mk-trail))
+(pl-cp-test!
+  "char_type(a, ascii(C)) -> C=97"
+  (pl-num-val (pl-walk-deep (dict-get pl-cp-env-as "C")))
+  97)
+
+;; ─── char_type/2 — punct ─────────────────────────────────────────
+
+(pl-cp-test!
+  "char_type('.', punct) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type('.', punct)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "char_type(a, punct) fails"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "char_type(a, punct)" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── upcase_atom/2 ───────────────────────────────────────────────
+
+(define pl-cp-env-ua {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "upcase_atom(hello, X)" pl-cp-env-ua)
+  (pl-mk-trail))
+(pl-cp-test!
+  "upcase_atom(hello, X) -> X='HELLO'"
+  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-ua "X")))
+  "HELLO")
+
+(pl-cp-test!
+  "upcase_atom(hello, 'HELLO') succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "upcase_atom(hello, 'HELLO')" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "upcase_atom('Hello World', 'HELLO WORLD') succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "upcase_atom('Hello World', 'HELLO WORLD')" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "upcase_atom('', '') succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "upcase_atom('', '')" {})
+    (pl-mk-trail))
+  true)
+
+;; ─── downcase_atom/2 ─────────────────────────────────────────────
+
+(define pl-cp-env-da {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "downcase_atom('HELLO', X)" pl-cp-env-da)
+  (pl-mk-trail))
+(pl-cp-test!
+  "downcase_atom('HELLO', X) -> X=hello"
+  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-da "X")))
+  "hello")
+
+(pl-cp-test!
+  "downcase_atom('HELLO', hello) succeeds"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "downcase_atom('HELLO', hello)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-cp-test!
+  "downcase_atom(hello, hello) succeeds — already lowercase"
+  (pl-solve-once!
+    pl-cp-db
+    (pl-cp-goal "downcase_atom(hello, hello)" {})
+    (pl-mk-trail))
+  true)
+
+;; ─── string_upper/2 + string_lower/2 (aliases) ───────────────────
+
+(define pl-cp-env-su {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "string_upper(hello, X)" pl-cp-env-su)
+  (pl-mk-trail))
+(pl-cp-test!
+  "string_upper(hello, X) -> X='HELLO'"
+  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-su "X")))
+  "HELLO")
+
+(define pl-cp-env-sl {})
+(pl-solve-once!
+  pl-cp-db
+  (pl-cp-goal "string_lower('WORLD', X)" pl-cp-env-sl)
+  (pl-mk-trail))
+(pl-cp-test!
+  "string_lower('WORLD', X) -> X=world"
+  (pl-atom-name (pl-walk-deep (dict-get pl-cp-env-sl "X")))
+  "world")
+
+(define pl-char-predicates-tests-run! (fn () {:failed pl-cp-test-fail :passed pl-cp-test-pass :total pl-cp-test-count :failures pl-cp-test-failures}))

lib/prolog/tests/clausedb.sx

@@ -0,0 +1,99 @@
+;; lib/prolog/tests/clausedb.sx — Clause DB unit tests
+
+(define pl-db-test-count 0)
+(define pl-db-test-pass 0)
+(define pl-db-test-fail 0)
+(define pl-db-test-failures (list))
+
+(define
+  pl-db-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-db-test-count (+ pl-db-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-db-test-pass (+ pl-db-test-pass 1))
+        (begin
+          (set! pl-db-test-fail (+ pl-db-test-fail 1))
+          (append!
+            pl-db-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(pl-db-test!
+  "head-key atom arity 0"
+  (pl-head-key (nth (first (pl-parse "foo.")) 1))
+  "foo/0")
+
+(pl-db-test!
+  "head-key compound arity 2"
+  (pl-head-key (nth (first (pl-parse "bar(a, b).")) 1))
+  "bar/2")
+
+(pl-db-test!
+  "clause-key of :- clause"
+  (pl-clause-key (first (pl-parse "likes(mary, X) :- friendly(X).")))
+  "likes/2")
+
+(pl-db-test!
+  "empty db lookup returns empty list"
+  (len (pl-db-lookup (pl-mk-db) "parent/2"))
+  0)
+
+(define pl-db-t1 (pl-mk-db))
+(pl-db-load! pl-db-t1 (pl-parse "foo(a). foo(b). foo(c)."))
+
+(pl-db-test!
+  "three facts same functor"
+  (len (pl-db-lookup pl-db-t1 "foo/1"))
+  3)
+(pl-db-test!
+  "mismatching key returns empty"
+  (len (pl-db-lookup pl-db-t1 "foo/2"))
+  0)
+
+(pl-db-test!
+  "first clause has arg a"
+  (pl-atom-name
+    (first (pl-args (nth (first (pl-db-lookup pl-db-t1 "foo/1")) 1))))
+  "a")
+
+(pl-db-test!
+  "third clause has arg c"
+  (pl-atom-name
+    (first (pl-args (nth (nth (pl-db-lookup pl-db-t1 "foo/1") 2) 1))))
+  "c")
+
+(define pl-db-t2 (pl-mk-db))
+(pl-db-load! pl-db-t2 (pl-parse "foo. bar. foo. parent(a, b). parent(c, d)."))
+
+(pl-db-test!
+  "atom heads keyed as foo/0"
+  (len (pl-db-lookup pl-db-t2 "foo/0"))
+  2)
+(pl-db-test!
+  "atom heads keyed as bar/0"
+  (len (pl-db-lookup pl-db-t2 "bar/0"))
+  1)
+(pl-db-test!
+  "compound heads keyed as parent/2"
+  (len (pl-db-lookup pl-db-t2 "parent/2"))
+  2)
+
+(pl-db-test!
+  "lookup-goal extracts functor/arity"
+  (len
+    (pl-db-lookup-goal pl-db-t2 (nth (first (pl-parse "parent(X, Y).")) 1)))
+  2)
+
+(pl-db-test!
+  "lookup-goal on atom goal"
+  (len (pl-db-lookup-goal pl-db-t2 (nth (first (pl-parse "foo.")) 1)))
+  2)
+
+(pl-db-test!
+  "stored clause is clause form"
+  (first (first (pl-db-lookup pl-db-t2 "parent/2")))
+  "clause")
+
+(define pl-clausedb-tests-run! (fn () {:failed pl-db-test-fail :passed pl-db-test-pass :total pl-db-test-count :failures pl-db-test-failures}))

lib/prolog/tests/compiler.sx

@@ -0,0 +1,185 @@
+;; lib/prolog/tests/compiler.sx — compiled clause dispatch tests
+
+(define pl-cmp-test-count 0)
+(define pl-cmp-test-pass 0)
+(define pl-cmp-test-fail 0)
+(define pl-cmp-test-failures (list))
+
+(define
+  pl-cmp-test!
+  (fn
+    (name got expected)
+    (set! pl-cmp-test-count (+ pl-cmp-test-count 1))
+    (if
+      (= got expected)
+      (set! pl-cmp-test-pass (+ pl-cmp-test-pass 1))
+      (begin
+        (set! pl-cmp-test-fail (+ pl-cmp-test-fail 1))
+        (append! pl-cmp-test-failures name)))))
+
+;; Load src, compile, return DB.
+(define
+  pl-cmp-mk
+  (fn
+    (src)
+    (let
+      ((db (pl-mk-db)))
+      (pl-db-load! db (pl-parse src))
+      (pl-compile-db! db)
+      db)))
+
+;; Run goal string against compiled DB; return bool (instantiates vars).
+(define
+  pl-cmp-once
+  (fn
+    (db src)
+    (pl-solve-once!
+      db
+      (pl-instantiate (pl-parse-goal src) {})
+      (pl-mk-trail))))
+
+;; Count solutions for goal string against compiled DB.
+(define
+  pl-cmp-count
+  (fn
+    (db src)
+    (pl-solve-count!
+      db
+      (pl-instantiate (pl-parse-goal src) {})
+      (pl-mk-trail))))
+
+;; ── 1. Simple facts ──────────────────────────────────────────────
+
+(define pl-cmp-db1 (pl-cmp-mk "color(red). color(green). color(blue)."))
+
+(pl-cmp-test! "compiled fact hit" (pl-cmp-once pl-cmp-db1 "color(red)") true)
+(pl-cmp-test!
+  "compiled fact miss"
+  (pl-cmp-once pl-cmp-db1 "color(yellow)")
+  false)
+(pl-cmp-test! "compiled fact count" (pl-cmp-count pl-cmp-db1 "color(X)") 3)
+
+;; ── 2. Recursive rule: append ────────────────────────────────────
+
+(define
+  pl-cmp-db2
+  (pl-cmp-mk "append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R)."))
+
+(pl-cmp-test!
+  "compiled append build"
+  (pl-cmp-once pl-cmp-db2 "append([1,2],[3],[1,2,3])")
+  true)
+(pl-cmp-test!
+  "compiled append fail"
+  (pl-cmp-once pl-cmp-db2 "append([1,2],[3],[1,2])")
+  false)
+(pl-cmp-test!
+  "compiled append split count"
+  (pl-cmp-count pl-cmp-db2 "append(X, Y, [a,b])")
+  3)
+
+;; ── 3. Cut ───────────────────────────────────────────────────────
+
+(define
+  pl-cmp-db3
+  (pl-cmp-mk "first(X, [X|_]) :- !. first(X, [_|T]) :- first(X, T)."))
+
+(pl-cmp-test!
+  "compiled cut: only one solution"
+  (pl-cmp-count pl-cmp-db3 "first(X, [a,b,c])")
+  1)
+
+(let
+  ((db pl-cmp-db3) (trail (pl-mk-trail)) (env {}))
+  (let
+    ((x (pl-mk-rt-var "X")))
+    (dict-set! env "X" x)
+    (pl-solve-once!
+      db
+      (pl-instantiate (pl-parse-goal "first(X, [a,b,c])") env)
+      trail)
+    (pl-cmp-test!
+      "compiled cut: correct binding"
+      (pl-atom-name (pl-walk x))
+      "a")))
+
+;; ── 4. member ────────────────────────────────────────────────────
+
+(define
+  pl-cmp-db4
+  (pl-cmp-mk "member(X, [X|_]). member(X, [_|T]) :- member(X, T)."))
+
+(pl-cmp-test!
+  "compiled member hit"
+  (pl-cmp-once pl-cmp-db4 "member(b, [a,b,c])")
+  true)
+(pl-cmp-test!
+  "compiled member miss"
+  (pl-cmp-once pl-cmp-db4 "member(d, [a,b,c])")
+  false)
+(pl-cmp-test!
+  "compiled member count"
+  (pl-cmp-count pl-cmp-db4 "member(X, [a,b,c])")
+  3)
+
+;; ── 5. Arithmetic in body ────────────────────────────────────────
+
+(define pl-cmp-db5 (pl-cmp-mk "double(X, Y) :- Y is X * 2."))
+
+(let
+  ((db pl-cmp-db5) (trail (pl-mk-trail)) (env {}))
+  (let
+    ((y (pl-mk-rt-var "Y")))
+    (dict-set! env "Y" y)
+    (pl-solve-once!
+      db
+      (pl-instantiate (pl-parse-goal "double(5, Y)") env)
+      trail)
+    (pl-cmp-test! "compiled arithmetic in body" (pl-num-val (pl-walk y)) 10)))
+
+;; ── 6. Transitive ancestor ───────────────────────────────────────
+
+(define
+  pl-cmp-db6
+  (pl-cmp-mk
+    (str
+      "parent(a,b). parent(b,c). parent(c,d)."
+      "ancestor(X,Y) :- parent(X,Y)."
+      "ancestor(X,Y) :- parent(X,Z), ancestor(Z,Y).")))
+
+(pl-cmp-test!
+  "compiled ancestor direct"
+  (pl-cmp-once pl-cmp-db6 "ancestor(a,b)")
+  true)
+(pl-cmp-test!
+  "compiled ancestor 3-step"
+  (pl-cmp-once pl-cmp-db6 "ancestor(a,d)")
+  true)
+(pl-cmp-test!
+  "compiled ancestor fail"
+  (pl-cmp-once pl-cmp-db6 "ancestor(d,a)")
+  false)
+
+;; ── 7. Fallback: uncompiled predicate calls compiled sub-predicate
+
+(define
+  pl-cmp-db7
+  (let
+    ((db (pl-mk-db)))
+    (pl-db-load! db (pl-parse "q(1). q(2)."))
+    (pl-compile-db! db)
+    (pl-db-load! db (pl-parse "r(X) :- q(X)."))
+    db))
+
+(pl-cmp-test!
+  "uncompiled predicate resolves"
+  (pl-cmp-once pl-cmp-db7 "r(1)")
+  true)
+(pl-cmp-test!
+  "uncompiled calls compiled sub-pred count"
+  (pl-cmp-count pl-cmp-db7 "r(X)")
+  2)
+
+;; ── Runner ───────────────────────────────────────────────────────
+
+(define pl-compiler-tests-run! (fn () {:failed pl-cmp-test-fail :passed pl-cmp-test-pass :total pl-cmp-test-count :failures pl-cmp-test-failures}))

lib/prolog/tests/cross_validate.sx

@@ -0,0 +1,86 @@
+;; lib/prolog/tests/cross_validate.sx
+;; Verifies that the compiled solver produces the same solution counts as the
+;; interpreter for each classic program + built-in exercise.
+;; Interpreter is the reference: if they disagree, the compiler is wrong.
+
+(define pl-xv-test-count 0)
+(define pl-xv-test-pass 0)
+(define pl-xv-test-fail 0)
+(define pl-xv-test-failures (list))
+
+(define
+  pl-xv-test!
+  (fn
+    (name got expected)
+    (set! pl-xv-test-count (+ pl-xv-test-count 1))
+    (if
+      (= got expected)
+      (set! pl-xv-test-pass (+ pl-xv-test-pass 1))
+      (begin
+        (set! pl-xv-test-fail (+ pl-xv-test-fail 1))
+        (append! pl-xv-test-failures name)))))
+
+;; Shorthand: assert compiled result matches interpreter.
+(define
+  pl-xv-match!
+  (fn
+    (name src goal)
+    (pl-xv-test! name (pl-compiled-matches-interp? src goal) true)))
+
+;; ── 1. append/3 ─────────────────────────────────────────────────
+
+(define
+  pl-xv-append
+  "append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R).")
+
+(pl-xv-match! "append build 2+2" pl-xv-append "append([1,2],[3,4],X)")
+(pl-xv-match! "append split [a,b,c]" pl-xv-append "append(X, Y, [a,b,c])")
+(pl-xv-match! "append member-mode" pl-xv-append "append(_, [3], [1,2,3])")
+
+;; ── 2. member/2 ─────────────────────────────────────────────────
+
+(define pl-xv-member "member(X, [X|_]). member(X, [_|T]) :- member(X, T).")
+
+(pl-xv-match! "member check hit" pl-xv-member "member(b, [a,b,c])")
+(pl-xv-match! "member count" pl-xv-member "member(X, [a,b,c])")
+(pl-xv-match! "member empty" pl-xv-member "member(X, [])")
+
+;; ── 3. facts + transitive rules ─────────────────────────────────
+
+(define
+  pl-xv-ancestor
+  (str
+    "parent(a,b). parent(b,c). parent(c,d). parent(a,c)."
+    "ancestor(X,Y) :- parent(X,Y)."
+    "ancestor(X,Y) :- parent(X,Z), ancestor(Z,Y)."))
+
+(pl-xv-match! "ancestor direct" pl-xv-ancestor "ancestor(a,b)")
+(pl-xv-match! "ancestor transitive" pl-xv-ancestor "ancestor(a,d)")
+(pl-xv-match! "ancestor all from a" pl-xv-ancestor "ancestor(a,Y)")
+
+;; ── 4. cut semantics ────────────────────────────────────────────
+
+(define pl-xv-cut "first(X,[X|_]) :- !. first(X,[_|T]) :- first(X,T).")
+
+(pl-xv-match! "cut one solution" pl-xv-cut "first(X,[a,b,c])")
+(pl-xv-match! "cut empty list" pl-xv-cut "first(X,[])")
+
+;; ── 5. arithmetic ───────────────────────────────────────────────
+
+(define pl-xv-arith "sq(X,Y) :- Y is X * X. even(X) :- 0 is X mod 2.")
+
+(pl-xv-match! "sq(3,Y) count" pl-xv-arith "sq(3,Y)")
+(pl-xv-match! "sq(3,9) check" pl-xv-arith "sq(3,9)")
+(pl-xv-match! "even(4) check" pl-xv-arith "even(4)")
+(pl-xv-match! "even(3) check" pl-xv-arith "even(3)")
+
+;; ── 6. if-then-else ─────────────────────────────────────────────
+
+(define pl-xv-ite "classify(X, pos) :- X > 0, !. classify(_, nonpos).")
+
+(pl-xv-match! "classify positive" pl-xv-ite "classify(5, C)")
+(pl-xv-match! "classify zero" pl-xv-ite "classify(0, C)")
+
+;; ── Runner ───────────────────────────────────────────────────────
+
+(define pl-cross-validate-tests-run! (fn () {:failed pl-xv-test-fail :passed pl-xv-test-pass :total pl-xv-test-count :failures pl-xv-test-failures}))

lib/prolog/tests/dynamic.sx

@@ -0,0 +1,158 @@
+;; lib/prolog/tests/dynamic.sx — assert/asserta/assertz/retract.
+
+(define pl-dy-test-count 0)
+(define pl-dy-test-pass 0)
+(define pl-dy-test-fail 0)
+(define pl-dy-test-failures (list))
+
+(define
+  pl-dy-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-dy-test-count (+ pl-dy-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-dy-test-pass (+ pl-dy-test-pass 1))
+        (begin
+          (set! pl-dy-test-fail (+ pl-dy-test-fail 1))
+          (append!
+            pl-dy-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-dy-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+;; assertz then query
+(define pl-dy-db1 (pl-mk-db))
+(pl-solve-once!
+  pl-dy-db1
+  (pl-dy-goal "assertz(foo(1))" {})
+  (pl-mk-trail))
+(pl-dy-test!
+  "assertz(foo(1)) + foo(1)"
+  (pl-solve-once! pl-dy-db1 (pl-dy-goal "foo(1)" {}) (pl-mk-trail))
+  true)
+
+(pl-dy-test!
+  "after one assertz, foo/1 has 1 clause"
+  (pl-solve-count! pl-dy-db1 (pl-dy-goal "foo(X)" {}) (pl-mk-trail))
+  1)
+
+;; assertz appends — order preserved
+(define pl-dy-db2 (pl-mk-db))
+(pl-solve-once!
+  pl-dy-db2
+  (pl-dy-goal "assertz(p(1))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-dy-db2
+  (pl-dy-goal "assertz(p(2))" {})
+  (pl-mk-trail))
+(pl-dy-test!
+  "assertz twice — count 2"
+  (pl-solve-count! pl-dy-db2 (pl-dy-goal "p(X)" {}) (pl-mk-trail))
+  2)
+
+(define pl-dy-env-a {})
+(pl-solve-once! pl-dy-db2 (pl-dy-goal "p(X)" pl-dy-env-a) (pl-mk-trail))
+(pl-dy-test!
+  "assertz: first solution is the first asserted (1)"
+  (pl-num-val (pl-walk-deep (dict-get pl-dy-env-a "X")))
+  1)
+
+;; asserta prepends
+(define pl-dy-db3 (pl-mk-db))
+(pl-solve-once!
+  pl-dy-db3
+  (pl-dy-goal "assertz(p(1))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-dy-db3
+  (pl-dy-goal "asserta(p(99))" {})
+  (pl-mk-trail))
+(define pl-dy-env-b {})
+(pl-solve-once! pl-dy-db3 (pl-dy-goal "p(X)" pl-dy-env-b) (pl-mk-trail))
+(pl-dy-test!
+  "asserta: prepended clause is first solution"
+  (pl-num-val (pl-walk-deep (dict-get pl-dy-env-b "X")))
+  99)
+
+;; assert/1 = assertz/1
+(define pl-dy-db4 (pl-mk-db))
+(pl-solve-once!
+  pl-dy-db4
+  (pl-dy-goal "assert(g(7))" {})
+  (pl-mk-trail))
+(pl-dy-test!
+  "assert/1 alias"
+  (pl-solve-once! pl-dy-db4 (pl-dy-goal "g(7)" {}) (pl-mk-trail))
+  true)
+
+;; retract removes a fact
+(define pl-dy-db5 (pl-mk-db))
+(pl-solve-once!
+  pl-dy-db5
+  (pl-dy-goal "assertz(q(1))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-dy-db5
+  (pl-dy-goal "assertz(q(2))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-dy-db5
+  (pl-dy-goal "assertz(q(3))" {})
+  (pl-mk-trail))
+(pl-dy-test!
+  "before retract: 3 clauses"
+  (pl-solve-count! pl-dy-db5 (pl-dy-goal "q(X)" {}) (pl-mk-trail))
+  3)
+(pl-solve-once!
+  pl-dy-db5
+  (pl-dy-goal "retract(q(2))" {})
+  (pl-mk-trail))
+(pl-dy-test!
+  "after retract(q(2)): 2 clauses left"
+  (pl-solve-count! pl-dy-db5 (pl-dy-goal "q(X)" {}) (pl-mk-trail))
+  2)
+
+(define pl-dy-env-c {})
+(pl-solve-once! pl-dy-db5 (pl-dy-goal "q(X)" pl-dy-env-c) (pl-mk-trail))
+(pl-dy-test!
+  "after retract(q(2)): first remaining is 1"
+  (pl-num-val (pl-walk-deep (dict-get pl-dy-env-c "X")))
+  1)
+
+;; retract of non-existent
+(pl-dy-test!
+  "retract(missing(0)) on empty db fails"
+  (pl-solve-once!
+    (pl-mk-db)
+    (pl-dy-goal "retract(missing(0))" {})
+    (pl-mk-trail))
+  false)
+
+;; retract with unbound var matches first
+(define pl-dy-db6 (pl-mk-db))
+(pl-solve-once!
+  pl-dy-db6
+  (pl-dy-goal "assertz(r(11))" {})
+  (pl-mk-trail))
+(pl-solve-once!
+  pl-dy-db6
+  (pl-dy-goal "assertz(r(22))" {})
+  (pl-mk-trail))
+(define pl-dy-env-d {})
+(pl-solve-once!
+  pl-dy-db6
+  (pl-dy-goal "retract(r(X))" pl-dy-env-d)
+  (pl-mk-trail))
+(pl-dy-test!
+  "retract(r(X)) binds X to first match"
+  (pl-num-val (pl-walk-deep (dict-get pl-dy-env-d "X")))
+  11)
+
+(define pl-dynamic-tests-run! (fn () {:failed pl-dy-test-fail :passed pl-dy-test-pass :total pl-dy-test-count :failures pl-dy-test-failures}))

lib/prolog/tests/findall.sx

@@ -0,0 +1,167 @@
+;; lib/prolog/tests/findall.sx — findall/3, bagof/3, setof/3.
+
+(define pl-fb-test-count 0)
+(define pl-fb-test-pass 0)
+(define pl-fb-test-fail 0)
+(define pl-fb-test-failures (list))
+
+(define
+  pl-fb-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-fb-test-count (+ pl-fb-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-fb-test-pass (+ pl-fb-test-pass 1))
+        (begin
+          (set! pl-fb-test-fail (+ pl-fb-test-fail 1))
+          (append!
+            pl-fb-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-fb-term-to-sx
+  (fn
+    (t)
+    (cond
+      ((pl-num? t) (pl-num-val t))
+      ((pl-atom? t) (pl-atom-name t))
+      (true (list :complex)))))
+
+(define
+  pl-fb-list-walked
+  (fn
+    (w)
+    (cond
+      ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
+      ((and (pl-compound? w) (= (pl-fun w) ".") (= (len (pl-args w)) 2))
+        (cons
+          (pl-fb-term-to-sx (first (pl-args w)))
+          (pl-fb-list-walked (nth (pl-args w) 1))))
+      (true (list :not-list)))))
+
+(define pl-fb-list-to-sx (fn (t) (pl-fb-list-walked (pl-walk-deep t))))
+
+(define
+  pl-fb-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-fb-prog-src "member(X, [X|_]). member(X, [_|T]) :- member(X, T).")
+
+(define pl-fb-db (pl-mk-db))
+(pl-db-load! pl-fb-db (pl-parse pl-fb-prog-src))
+
+;; ── findall ──
+
+(define pl-fb-env-1 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal "findall(X, member(X, [a, b, c]), L)" pl-fb-env-1)
+  (pl-mk-trail))
+(pl-fb-test!
+  "findall member [a, b, c]"
+  (pl-fb-list-to-sx (dict-get pl-fb-env-1 "L"))
+  (list "a" "b" "c"))
+
+(define pl-fb-env-2 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal "findall(X, (member(X, [1, 2, 3]), X >= 2), L)" pl-fb-env-2)
+  (pl-mk-trail))
+(pl-fb-test!
+  "findall with comparison filter"
+  (pl-fb-list-to-sx (dict-get pl-fb-env-2 "L"))
+  (list 2 3))
+
+(define pl-fb-env-3 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal "findall(X, fail, L)" pl-fb-env-3)
+  (pl-mk-trail))
+(pl-fb-test!
+  "findall on fail succeeds with empty list"
+  (pl-fb-list-to-sx (dict-get pl-fb-env-3 "L"))
+  (list))
+
+(pl-fb-test!
+  "findall(X, fail, L) the goal succeeds"
+  (pl-solve-once!
+    pl-fb-db
+    (pl-fb-goal "findall(X, fail, L)" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-fb-env-4 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal
+    "findall(p(X, Y), (member(X, [1, 2]), member(Y, [a, b])), L)"
+    pl-fb-env-4)
+  (pl-mk-trail))
+(pl-fb-test!
+  "findall over compound template — count = 4"
+  (len (pl-fb-list-to-sx (dict-get pl-fb-env-4 "L")))
+  4)
+
+;; ── bagof ──
+
+(pl-fb-test!
+  "bagof succeeds when results exist"
+  (pl-solve-once!
+    pl-fb-db
+    (pl-fb-goal "bagof(X, member(X, [1, 2, 3]), L)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-fb-test!
+  "bagof fails on empty"
+  (pl-solve-once!
+    pl-fb-db
+    (pl-fb-goal "bagof(X, fail, L)" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-fb-env-5 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal "bagof(X, member(X, [c, a, b]), L)" pl-fb-env-5)
+  (pl-mk-trail))
+(pl-fb-test!
+  "bagof preserves order"
+  (pl-fb-list-to-sx (dict-get pl-fb-env-5 "L"))
+  (list "c" "a" "b"))
+
+;; ── setof ──
+
+(define pl-fb-env-6 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal "setof(X, member(X, [c, a, b, a, c]), L)" pl-fb-env-6)
+  (pl-mk-trail))
+(pl-fb-test!
+  "setof sorts + dedupes atoms"
+  (pl-fb-list-to-sx (dict-get pl-fb-env-6 "L"))
+  (list "a" "b" "c"))
+
+(pl-fb-test!
+  "setof fails on empty"
+  (pl-solve-once!
+    pl-fb-db
+    (pl-fb-goal "setof(X, fail, L)" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-fb-env-7 {})
+(pl-solve-once!
+  pl-fb-db
+  (pl-fb-goal "setof(X, member(X, [3, 1, 2, 1, 3]), L)" pl-fb-env-7)
+  (pl-mk-trail))
+(pl-fb-test!
+  "setof sorts + dedupes nums"
+  (pl-fb-list-to-sx (dict-get pl-fb-env-7 "L"))
+  (list 1 2 3))
+
+(define pl-findall-tests-run! (fn () {:failed pl-fb-test-fail :passed pl-fb-test-pass :total pl-fb-test-count :failures pl-fb-test-failures}))

lib/prolog/tests/hs_bridge.sx

@@ -0,0 +1,165 @@
+;; lib/prolog/tests/hs_bridge.sx — tests for Prolog↔Hyperscript bridge
+;;
+;; Verifies pl-hs-query, pl-hs-predicate/N, and pl-hs-install.
+;; Also demonstrates the end-to-end DSL pattern:
+;;   (define allowed (pl-hs-predicate/2 db "allowed"))
+;;   → (allowed "alice" "edit") is what Hyperscript compiles
+;;     `when allowed(alice, edit)` to.
+
+(define pl-hsb-test-count 0)
+(define pl-hsb-test-pass 0)
+(define pl-hsb-test-fail 0)
+(define pl-hsb-test-failures (list))
+
+(define
+  pl-hsb-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-hsb-test-count (+ pl-hsb-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-hsb-test-pass (+ pl-hsb-test-pass 1))
+        (begin
+          (set! pl-hsb-test-fail (+ pl-hsb-test-fail 1))
+          (append!
+            pl-hsb-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+;; ── shared KB ──
+
+(define
+  pl-hsb-perm-src
+  "role(alice, admin). role(bob, editor). role(charlie, viewer). permission(admin, read). permission(admin, write). permission(admin, delete). permission(editor, read). permission(editor, write). permission(viewer, read). allowed(U, A) :- role(U, R), permission(R, A).")
+
+(define pl-hsb-db (pl-load pl-hsb-perm-src))
+
+;; ── pl-hs-query ──
+
+(pl-hsb-test!
+  "pl-hs-query: ground fact succeeds"
+  (pl-hs-query pl-hsb-db "role(alice, admin)")
+  true)
+
+(pl-hsb-test!
+  "pl-hs-query: absent fact fails"
+  (pl-hs-query pl-hsb-db "role(alice, viewer)")
+  false)
+
+(pl-hsb-test!
+  "pl-hs-query: rule derivation succeeds"
+  (pl-hs-query pl-hsb-db "allowed(alice, delete)")
+  true)
+
+(pl-hsb-test!
+  "pl-hs-query: rule derivation fails"
+  (pl-hs-query pl-hsb-db "allowed(charlie, delete)")
+  false)
+
+(pl-hsb-test!
+  "pl-hs-query: arithmetic goal"
+  (pl-hs-query pl-hsb-db "X is 3 + 4, X = 7")
+  true)
+
+;; ── pl-hs-predicate/2 ──
+
+(define pl-hsb-allowed (pl-hs-predicate/2 pl-hsb-db "allowed"))
+
+(pl-hsb-test!
+  "predicate/2: alice can read"
+  (pl-hsb-allowed "alice" "read")
+  true)
+
+(pl-hsb-test!
+  "predicate/2: alice can delete"
+  (pl-hsb-allowed "alice" "delete")
+  true)
+
+(pl-hsb-test!
+  "predicate/2: charlie cannot write"
+  (pl-hsb-allowed "charlie" "write")
+  false)
+
+(pl-hsb-test!
+  "predicate/2: bob can write"
+  (pl-hsb-allowed "bob" "write")
+  true)
+
+(pl-hsb-test!
+  "predicate/2: unknown user fails"
+  (pl-hsb-allowed "eve" "read")
+  false)
+
+;; ── DSL simulation ──
+;; Hyperscript compiles `when allowed(user, action) then …`
+;; to `(allowed user action)` — a direct SX function call.
+;; Here we verify that pattern works end-to-end.
+
+(define pl-hsb-user "alice")
+(define pl-hsb-action "write")
+
+(pl-hsb-test!
+  "DSL simulation: (allowed user action) true path"
+  (pl-hsb-allowed pl-hsb-user pl-hsb-action)
+  true)
+
+(define pl-hsb-user2 "charlie")
+
+(pl-hsb-test!
+  "DSL simulation: (allowed user action) false path"
+  (pl-hsb-allowed pl-hsb-user2 pl-hsb-action)
+  false)
+
+;; ── pl-hs-predicate/1 ──
+
+(define pl-hsb-viewer-src "color(red). color(green). color(blue).")
+(define pl-hsb-color-db (pl-load pl-hsb-viewer-src))
+(define pl-hsb-color? (pl-hs-predicate/1 pl-hsb-color-db "color"))
+
+(pl-hsb-test! "predicate/1: color(red) succeeds" (pl-hsb-color? "red") true)
+
+(pl-hsb-test!
+  "predicate/1: color(purple) fails"
+  (pl-hsb-color? "purple")
+  false)
+
+;; ── pl-hs-predicate/3 ──
+
+(define pl-hsb-3ary-src "between_vals(X, Lo, Hi) :- X >= Lo, X =< Hi.")
+(define pl-hsb-3ary-db (pl-load pl-hsb-3ary-src))
+(define pl-hsb-in-range? (pl-hs-predicate/3 pl-hsb-3ary-db "between_vals"))
+
+(pl-hsb-test!
+  "predicate/3: 5 in range [1,10]"
+  (pl-hsb-in-range? "5" "1" "10")
+  true)
+
+(pl-hsb-test!
+  "predicate/3: 15 not in range [1,10]"
+  (pl-hsb-in-range? "15" "1" "10")
+  false)
+
+;; ── pl-hs-install ──
+
+(define
+  pl-hsb-installed
+  (pl-hs-install
+    pl-hsb-db
+    (list (list "allowed" 2) (list "role" 2) (list "permission" 2))))
+
+(pl-hsb-test!
+  "pl-hs-install: returns dict with allowed key"
+  (not (nil? (dict-get pl-hsb-installed "allowed")))
+  true)
+
+(pl-hsb-test!
+  "pl-hs-install: installed allowed fn works"
+  ((dict-get pl-hsb-installed "allowed") "alice" "delete")
+  true)
+
+(pl-hsb-test!
+  "pl-hs-install: installed role fn works"
+  ((dict-get pl-hsb-installed "role") "bob" "editor")
+  true)
+
+(define pl-hs-bridge-tests-run! (fn () {:failed pl-hsb-test-fail :passed pl-hsb-test-pass :total pl-hsb-test-count :failures pl-hsb-test-failures}))

lib/prolog/tests/integration.sx

@@ -0,0 +1,172 @@
+;; lib/prolog/tests/integration.sx — end-to-end integration tests via pl-query-* API
+;;
+;; Tests the full source→parse→load→solve pipeline with real programs.
+;; Covers: permission system, graph reachability, quicksort, fibonacci, dynamic KB.
+
+(define pl-int-test-count 0)
+(define pl-int-test-pass 0)
+(define pl-int-test-fail 0)
+(define pl-int-test-failures (list))
+
+(define
+  pl-int-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-int-test-count (+ pl-int-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-int-test-pass (+ pl-int-test-pass 1))
+        (begin
+          (set! pl-int-test-fail (+ pl-int-test-fail 1))
+          (append!
+            pl-int-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+;; ── Permission system ──
+;; role/2 + permission/2 facts, allowed/2 rule
+
+(define
+  pl-int-perm-src
+  "role(alice, admin). role(bob, editor). role(charlie, viewer). permission(admin, read). permission(admin, write). permission(admin, delete). permission(editor, read). permission(editor, write). permission(viewer, read). allowed(U, A) :- role(U, R), permission(R, A).")
+
+(define pl-int-perm-db (pl-load pl-int-perm-src))
+
+(pl-int-test!
+  "alice can read"
+  (len (pl-query-all pl-int-perm-db "allowed(alice, read)"))
+  1)
+
+(pl-int-test!
+  "alice can delete"
+  (len (pl-query-all pl-int-perm-db "allowed(alice, delete)"))
+  1)
+
+(pl-int-test!
+  "charlie cannot write"
+  (len (pl-query-all pl-int-perm-db "allowed(charlie, write)"))
+  0)
+
+(pl-int-test!
+  "alice has 3 permissions"
+  (len (pl-query-all pl-int-perm-db "allowed(alice, A)"))
+  3)
+
+(pl-int-test!
+  "only one user can delete"
+  (len (pl-query-all pl-int-perm-db "allowed(U, delete)"))
+  1)
+
+(pl-int-test!
+  "the deleter is alice"
+  (dict-get (first (pl-query-all pl-int-perm-db "allowed(U, delete)")) "U")
+  "alice")
+
+;; ── Graph reachability ──
+;; Directed edges; path/2 transitive closure via two clauses
+
+(define
+  pl-int-graph-src
+  "edge(a, b). edge(b, c). edge(c, d). edge(b, d). path(X, Y) :- edge(X, Y). path(X, Y) :- edge(X, Z), path(Z, Y).")
+
+(define pl-int-graph-db (pl-load pl-int-graph-src))
+
+(pl-int-test!
+  "direct edge a→b is a path"
+  (len (pl-query-all pl-int-graph-db "path(a, b)"))
+  1)
+
+(pl-int-test!
+  "transitive path a→c"
+  (len (pl-query-all pl-int-graph-db "path(a, c)"))
+  1)
+
+(pl-int-test!
+  "no path d→a (no back-edges)"
+  (len (pl-query-all pl-int-graph-db "path(d, a)"))
+  0)
+
+(pl-int-test!
+  "4 derivations from a (b,c,d via two routes to d)"
+  (len (pl-query-all pl-int-graph-db "path(a, Y)"))
+  4)
+
+;; ── Quicksort ──
+;; Partition-and-recurse; uses its own append/3 to avoid DB pollution
+
+(define
+  pl-int-qs-src
+  "partition(_, [], [], []). partition(Piv, [H|T], [H|Less], Greater) :- H =< Piv, !, partition(Piv, T, Less, Greater). partition(Piv, [H|T], Less, [H|Greater]) :- partition(Piv, T, Less, Greater). append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R). quicksort([], []). quicksort([H|T], Sorted) :- partition(H, T, Less, Greater), quicksort(Less, SL), quicksort(Greater, SG), append(SL, [H|SG], Sorted).")
+
+(define pl-int-qs-db (pl-load pl-int-qs-src))
+
+(pl-int-test!
+  "quicksort([]) = [] (ground check)"
+  (len (pl-query-all pl-int-qs-db "quicksort([], [])"))
+  1)
+
+(pl-int-test!
+  "quicksort([3,1,2]) = [1,2,3] (ground check)"
+  (len (pl-query-all pl-int-qs-db "quicksort([3,1,2], [1,2,3])"))
+  1)
+
+(pl-int-test!
+  "quicksort([5,3,1,4,2]) = [1,2,3,4,5] (ground check)"
+  (len (pl-query-all pl-int-qs-db "quicksort([5,3,1,4,2], [1,2,3,4,5])"))
+  1)
+
+(pl-int-test!
+  "quicksort([3,1,2], [3,1,2]) fails — unsorted order rejected"
+  (len (pl-query-all pl-int-qs-db "quicksort([3,1,2], [3,1,2])"))
+  0)
+
+;; ── Fibonacci ──
+;; Naive recursive; ground checks avoid list-format uncertainty
+
+(define
+  pl-int-fib-src
+  "fib(0, 0). fib(1, 1). fib(N, F) :- N > 1, N1 is N - 1, N2 is N - 2, fib(N1, F1), fib(N2, F2), F is F1 + F2.")
+
+(define pl-int-fib-db (pl-load pl-int-fib-src))
+
+(pl-int-test!
+  "fib(0, 0) succeeds"
+  (len (pl-query-all pl-int-fib-db "fib(0, 0)"))
+  1)
+
+(pl-int-test!
+  "fib(5, 5) succeeds"
+  (len (pl-query-all pl-int-fib-db "fib(5, 5)"))
+  1)
+
+(pl-int-test!
+  "fib(7, 13) succeeds"
+  (len (pl-query-all pl-int-fib-db "fib(7, 13)"))
+  1)
+
+;; ── Dynamic knowledge base ──
+;; Assert and retract facts; the DB dict is mutable so mutations persist
+
+(define pl-int-dyn-src "color(red). color(green). color(blue).")
+(define pl-int-dyn-db (pl-load pl-int-dyn-src))
+
+(pl-int-test!
+  "initial KB: 3 colors"
+  (len (pl-query-all pl-int-dyn-db "color(X)"))
+  3)
+
+(pl-int-test!
+  "after assert(color(yellow)): 4 colors"
+  (begin
+    (pl-query-all pl-int-dyn-db "assert(color(yellow))")
+    (len (pl-query-all pl-int-dyn-db "color(X)")))
+  4)
+
+(pl-int-test!
+  "after retract(color(red)): back to 3 colors"
+  (begin
+    (pl-query-all pl-int-dyn-db "retract(color(red))")
+    (len (pl-query-all pl-int-dyn-db "color(X)")))
+  3)
+
+(define pl-integration-tests-run! (fn () {:failed pl-int-test-fail :passed pl-int-test-pass :total pl-int-test-count :failures pl-int-test-failures}))

lib/prolog/tests/io_predicates.sx

@@ -0,0 +1,326 @@
+;; lib/prolog/tests/io_predicates.sx — term_to_atom/2, term_string/2,
+;;   with_output_to/2, writeln/1, format/1, format/2
+
+(define pl-io-test-count 0)
+(define pl-io-test-pass 0)
+(define pl-io-test-fail 0)
+(define pl-io-test-failures (list))
+
+(define
+  pl-io-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-io-test-count (+ pl-io-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-io-test-pass (+ pl-io-test-pass 1))
+        (begin
+          (set! pl-io-test-fail (+ pl-io-test-fail 1))
+          (append!
+            pl-io-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-io-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-io-db (pl-mk-db))
+
+;; helper: get output buffer after running a goal
+(define
+  pl-io-capture!
+  (fn
+    (goal)
+    (do
+      (pl-output-clear!)
+      (pl-solve-once! pl-io-db goal (pl-mk-trail))
+      pl-output-buffer)))
+
+;; ─── term_to_atom/2 — bound Term direction ─────────────────────────────────
+
+(pl-io-test!
+  "term_to_atom(foo(a,b), A) — compound"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_to_atom(foo(a,b), A)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
+  "foo(a, b)")
+
+(pl-io-test!
+  "term_to_atom(hello, A) — atom"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_to_atom(hello, A)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
+  "hello")
+
+(pl-io-test!
+  "term_to_atom(42, A) — number"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_to_atom(42, A)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
+  "42")
+
+(pl-io-test!
+  "term_to_atom(foo(a,b), 'foo(a, b)') — succeeds when Atom matches"
+  (pl-solve-once!
+    pl-io-db
+    (pl-io-goal "term_to_atom(foo(a,b), 'foo(a, b)')" {})
+    (pl-mk-trail))
+  true)
+
+(pl-io-test!
+  "term_to_atom(hello, world) — fails on mismatch"
+  (pl-solve-once!
+    pl-io-db
+    (pl-io-goal "term_to_atom(hello, world)" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── term_to_atom/2 — parse direction (Atom bound, Term unbound) ───────────
+
+(pl-io-test!
+  "term_to_atom(T, 'foo(a)') — parse direction gives compound"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_to_atom(T, 'foo(a)')" env)
+      (pl-mk-trail))
+    (let
+      ((t (pl-walk-deep (dict-get env "T"))))
+      (and (pl-compound? t) (= (pl-fun t) "foo"))))
+  true)
+
+(pl-io-test!
+  "term_to_atom(T, hello) — parse direction gives atom"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_to_atom(T, hello)" env)
+      (pl-mk-trail))
+    (let
+      ((t (pl-walk-deep (dict-get env "T"))))
+      (and (pl-atom? t) (= (pl-atom-name t) "hello"))))
+  true)
+
+;; ─── term_string/2 — alias ──────────────────────────────────────────────────
+
+(pl-io-test!
+  "term_string(bar(x), A) — same as term_to_atom"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_string(bar(x), A)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
+  "bar(x)")
+
+(pl-io-test!
+  "term_string(42, A) — number to string"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "term_string(42, A)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "A"))))
+  "42")
+
+;; ─── writeln/1 ─────────────────────────────────────────────────────────────
+
+(pl-io-test!
+  "writeln(hello) writes 'hello\n'"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), writeln(hello))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "hello
+")
+
+(pl-io-test!
+  "writeln(42) writes '42\n'"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), writeln(42))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "42
+")
+
+;; ─── with_output_to/2 ──────────────────────────────────────────────────────
+
+(pl-io-test!
+  "with_output_to(atom(X), write(foo)) — captures write output"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), write(foo))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "foo")
+
+(pl-io-test!
+  "with_output_to(atom(X), (write(a), write(b))) — concat output"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), (write(a), write(b)))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "ab")
+
+(pl-io-test!
+  "with_output_to(atom(X), nl) — captures newline"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), nl)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "
+")
+
+(pl-io-test!
+  "with_output_to(atom(X), true) — captures empty string"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), true)" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "")
+
+(pl-io-test!
+  "with_output_to(string(X), write(hello)) — string sink works"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(string(X), write(hello))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "hello")
+
+(pl-io-test!
+  "with_output_to(atom(X), fail) — fails when goal fails"
+  (pl-solve-once!
+    pl-io-db
+    (pl-io-goal "with_output_to(atom(X), fail)" {})
+    (pl-mk-trail))
+  false)
+
+;; ─── format/1 ──────────────────────────────────────────────────────────────
+
+(pl-io-test!
+  "format('hello~n') — tilde-n becomes newline"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format('hello~n'))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "hello
+")
+
+(pl-io-test!
+  "format('~~') — double tilde becomes single tilde"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format('~~'))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "~")
+
+(pl-io-test!
+  "format('abc') — plain text passes through"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format(abc))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "abc")
+
+;; ─── format/2 ──────────────────────────────────────────────────────────────
+
+(pl-io-test!
+  "format('~w+~w', [1,2]) — two ~w args"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format('~w+~w', [1,2]))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "1+2")
+
+(pl-io-test!
+  "format('hello ~a!', [world]) — ~a with atom arg"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format('hello ~a!', [world]))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "hello world!")
+
+(pl-io-test!
+  "format('n=~d', [42]) — ~d with integer arg"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format('n=~d', [42]))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "n=42")
+
+(pl-io-test!
+  "format('~w', [foo(a)]) — ~w with compound"
+  (let
+    ((env {}))
+    (pl-solve-once!
+      pl-io-db
+      (pl-io-goal "with_output_to(atom(X), format('~w', [foo(a)]))" env)
+      (pl-mk-trail))
+    (pl-atom-name (pl-walk-deep (dict-get env "X"))))
+  "foo(a)")
+
+(define
+  pl-io-predicates-tests-run!
+  (fn
+    ()
+    {:failed pl-io-test-fail
+      :passed pl-io-test-pass
+      :total pl-io-test-count
+      :failures pl-io-test-failures}))

lib/prolog/tests/iso_predicates.sx

@@ -0,0 +1,320 @@
+;; lib/prolog/tests/iso_predicates.sx — succ/2, plus/3, between/3, length/2, last/2, nth0/3, nth1/3, max/min arith
+
+(define pl-ip-test-count 0)
+(define pl-ip-test-pass 0)
+(define pl-ip-test-fail 0)
+(define pl-ip-test-failures (list))
+
+(define
+  pl-ip-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-ip-test-count (+ pl-ip-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-ip-test-pass (+ pl-ip-test-pass 1))
+        (begin
+          (set! pl-ip-test-fail (+ pl-ip-test-fail 1))
+          (append!
+            pl-ip-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-ip-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-ip-db (pl-mk-db))
+
+;; ── succ/2 ──
+
+(define pl-ip-env-s1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "succ(3, X)" pl-ip-env-s1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "succ(3, X) → X=4"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-s1 "X")))
+  4)
+
+(define pl-ip-env-s2 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "succ(0, X)" pl-ip-env-s2)
+  (pl-mk-trail))
+(pl-ip-test!
+  "succ(0, X) → X=1"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-s2 "X")))
+  1)
+
+(define pl-ip-env-s3 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "succ(X, 5)" pl-ip-env-s3)
+  (pl-mk-trail))
+(pl-ip-test!
+  "succ(X, 5) → X=4"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-s3 "X")))
+  4)
+
+(pl-ip-test!
+  "succ(X, 0) fails"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "succ(X, 0)" {})
+    (pl-mk-trail))
+  false)
+
+;; ── plus/3 ──
+
+(define pl-ip-env-p1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "plus(2, 3, X)" pl-ip-env-p1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "plus(2, 3, X) → X=5"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-p1 "X")))
+  5)
+
+(define pl-ip-env-p2 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "plus(2, X, 7)" pl-ip-env-p2)
+  (pl-mk-trail))
+(pl-ip-test!
+  "plus(2, X, 7) → X=5"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-p2 "X")))
+  5)
+
+(define pl-ip-env-p3 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "plus(X, 3, 7)" pl-ip-env-p3)
+  (pl-mk-trail))
+(pl-ip-test!
+  "plus(X, 3, 7) → X=4"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-p3 "X")))
+  4)
+
+(pl-ip-test!
+  "plus(0, 0, 0) succeeds"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "plus(0, 0, 0)" {})
+    (pl-mk-trail))
+  true)
+
+;; ── between/3 ──
+
+(pl-ip-test!
+  "between(1, 3, X): 3 solutions"
+  (pl-solve-count!
+    pl-ip-db
+    (pl-ip-goal "between(1, 3, X)" {})
+    (pl-mk-trail))
+  3)
+
+(pl-ip-test!
+  "between(1, 3, 2) succeeds"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "between(1, 3, 2)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-ip-test!
+  "between(1, 3, 5) fails"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "between(1, 3, 5)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-ip-test!
+  "between(5, 3, X): 0 solutions (empty range)"
+  (pl-solve-count!
+    pl-ip-db
+    (pl-ip-goal "between(5, 3, X)" {})
+    (pl-mk-trail))
+  0)
+
+(define pl-ip-env-b1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "between(1, 5, X)" pl-ip-env-b1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "between(1, 5, X): first solution X=1"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-b1 "X")))
+  1)
+
+(pl-ip-test!
+  "between + condition: between(1,5,X), X > 3 → 2 solutions"
+  (pl-solve-count!
+    pl-ip-db
+    (pl-ip-goal "between(1, 5, X), X > 3" {})
+    (pl-mk-trail))
+  2)
+
+;; ── length/2 ──
+
+(define pl-ip-env-l1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "length([1,2,3], N)" pl-ip-env-l1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "length([1,2,3], N) → N=3"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-l1 "N")))
+  3)
+
+(define pl-ip-env-l2 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "length([], N)" pl-ip-env-l2)
+  (pl-mk-trail))
+(pl-ip-test!
+  "length([], N) → N=0"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-l2 "N")))
+  0)
+
+(pl-ip-test!
+  "length([a,b], 2) check succeeds"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "length([a,b], 2)" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-ip-env-l3 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "length(L, 3)" pl-ip-env-l3)
+  (pl-mk-trail))
+(pl-ip-test!
+  "length(L, 3): L is a list of length 3"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "length(L, 3), is_list(L)" pl-ip-env-l3)
+    (pl-mk-trail))
+  true)
+
+;; ── last/2 ──
+
+(define pl-ip-env-la1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "last([1,2,3], X)" pl-ip-env-la1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "last([1,2,3], X) → X=3"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-la1 "X")))
+  3)
+
+(define pl-ip-env-la2 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "last([a], X)" pl-ip-env-la2)
+  (pl-mk-trail))
+(pl-ip-test!
+  "last([a], X) → X=a"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-la2 "X")))
+  "a")
+
+(pl-ip-test!
+  "last([], X) fails"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "last([], X)" {})
+    (pl-mk-trail))
+  false)
+
+;; ── nth0/3 ──
+
+(define pl-ip-env-n0 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "nth0(0, [a,b,c], X)" pl-ip-env-n0)
+  (pl-mk-trail))
+(pl-ip-test!
+  "nth0(0, [a,b,c], X) → X=a"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-n0 "X")))
+  "a")
+
+(define pl-ip-env-n1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "nth0(2, [a,b,c], X)" pl-ip-env-n1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "nth0(2, [a,b,c], X) → X=c"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-n1 "X")))
+  "c")
+
+(pl-ip-test!
+  "nth0(5, [a,b,c], X) fails"
+  (pl-solve-once!
+    pl-ip-db
+    (pl-ip-goal "nth0(5, [a,b,c], X)" {})
+    (pl-mk-trail))
+  false)
+
+;; ── nth1/3 ──
+
+(define pl-ip-env-n1a {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "nth1(1, [a,b,c], X)" pl-ip-env-n1a)
+  (pl-mk-trail))
+(pl-ip-test!
+  "nth1(1, [a,b,c], X) → X=a"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-n1a "X")))
+  "a")
+
+(define pl-ip-env-n1b {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "nth1(3, [a,b,c], X)" pl-ip-env-n1b)
+  (pl-mk-trail))
+(pl-ip-test!
+  "nth1(3, [a,b,c], X) → X=c"
+  (pl-atom-name (pl-walk-deep (dict-get pl-ip-env-n1b "X")))
+  "c")
+
+;; ── max/min in arithmetic ──
+
+(define pl-ip-env-m1 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "X is max(3, 5)" pl-ip-env-m1)
+  (pl-mk-trail))
+(pl-ip-test!
+  "X is max(3, 5) → X=5"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-m1 "X")))
+  5)
+
+(define pl-ip-env-m2 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "X is min(3, 5)" pl-ip-env-m2)
+  (pl-mk-trail))
+(pl-ip-test!
+  "X is min(3, 5) → X=3"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-m2 "X")))
+  3)
+
+(define pl-ip-env-m3 {})
+(pl-solve-once!
+  pl-ip-db
+  (pl-ip-goal "X is max(7, 2) + min(1, 4)" pl-ip-env-m3)
+  (pl-mk-trail))
+(pl-ip-test!
+  "X is max(7,2) + min(1,4) → X=8"
+  (pl-num-val (pl-walk-deep (dict-get pl-ip-env-m3 "X")))
+  8)
+
+(define pl-iso-predicates-tests-run! (fn () {:failed pl-ip-test-fail :passed pl-ip-test-pass :total pl-ip-test-count :failures pl-ip-test-failures}))

lib/prolog/tests/list_predicates.sx

@@ -0,0 +1,335 @@
+;; lib/prolog/tests/list_predicates.sx — ==/2, \==/2, flatten/2, numlist/3,
+;;   atomic_list_concat/2,3, sum_list/2, max_list/2, min_list/2, delete/3
+
+(define pl-lp-test-count 0)
+(define pl-lp-test-pass 0)
+(define pl-lp-test-fail 0)
+(define pl-lp-test-failures (list))
+
+(define
+  pl-lp-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-lp-test-count (+ pl-lp-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-lp-test-pass (+ pl-lp-test-pass 1))
+        (begin
+          (set! pl-lp-test-fail (+ pl-lp-test-fail 1))
+          (append!
+            pl-lp-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-lp-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-lp-db (pl-mk-db))
+
+;; ── ==/2 ───────────────────────────────────────────────────────────
+
+(pl-lp-test!
+  "==(a, a) succeeds"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "==(a, a)" {}) (pl-mk-trail))
+  true)
+
+(pl-lp-test!
+  "==(a, b) fails"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "==(a, b)" {}) (pl-mk-trail))
+  false)
+
+(pl-lp-test!
+  "==(1, 1) succeeds"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "==(1, 1)" {}) (pl-mk-trail))
+  true)
+
+(pl-lp-test!
+  "==(1, 2) fails"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "==(1, 2)" {}) (pl-mk-trail))
+  false)
+
+(pl-lp-test!
+  "==(f(a,b), f(a,b)) succeeds"
+  (pl-solve-once!
+    pl-lp-db
+    (pl-lp-goal "==(f(a,b), f(a,b))" {})
+    (pl-mk-trail))
+  true)
+
+(pl-lp-test!
+  "==(f(a,b), f(a,c)) fails"
+  (pl-solve-once!
+    pl-lp-db
+    (pl-lp-goal "==(f(a,b), f(a,c))" {})
+    (pl-mk-trail))
+  false)
+
+;; unbound var vs atom: fails (different tags)
+(pl-lp-test!
+  "==(X, a) fails (unbound var vs atom)"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "==(X, a)" {}) (pl-mk-trail))
+  false)
+
+;; two unbound vars with SAME name in same env share the same runtime var
+(define pl-lp-env-same-var {})
+(pl-lp-goal "==(X, X)" pl-lp-env-same-var)
+(pl-lp-test!
+  "==(X, X) succeeds (same runtime var)"
+  (pl-solve-once!
+    pl-lp-db
+    (pl-instantiate
+      (nth (first (pl-parse "g :- ==(X, X).")) 2)
+      pl-lp-env-same-var)
+    (pl-mk-trail))
+  true)
+
+;; ── \==/2 ──────────────────────────────────────────────────────────
+
+(pl-lp-test!
+  "\\==(a, b) succeeds"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "\\==(a, b)" {}) (pl-mk-trail))
+  true)
+
+(pl-lp-test!
+  "\\==(a, a) fails"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "\\==(a, a)" {}) (pl-mk-trail))
+  false)
+
+(pl-lp-test!
+  "\\==(X, a) succeeds (unbound var differs from atom)"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "\\==(X, a)" {}) (pl-mk-trail))
+  true)
+
+(pl-lp-test!
+  "\\==(1, 2) succeeds"
+  (pl-solve-once! pl-lp-db (pl-lp-goal "\\==(1, 2)" {}) (pl-mk-trail))
+  true)
+
+;; ── flatten/2 ──────────────────────────────────────────────────────
+
+(define pl-lp-env-fl1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "flatten([], F)" pl-lp-env-fl1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "flatten([], []) -> empty"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-fl1 "F")))
+  "[]")
+
+(define pl-lp-env-fl2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "flatten([1,2,3], F)" pl-lp-env-fl2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "flatten([1,2,3], F) -> [1,2,3]"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-fl2 "F")))
+  ".(1, .(2, .(3, [])))")
+
+(define pl-lp-env-fl3 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "flatten([1,[2,[3]],4], F)" pl-lp-env-fl3)
+  (pl-mk-trail))
+(pl-lp-test!
+  "flatten([1,[2,[3]],4], F) -> [1,2,3,4]"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-fl3 "F")))
+  ".(1, .(2, .(3, .(4, []))))")
+
+(define pl-lp-env-fl4 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "flatten([[a,b],[c]], F)" pl-lp-env-fl4)
+  (pl-mk-trail))
+(pl-lp-test!
+  "flatten([[a,b],[c]], F) -> [a,b,c]"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-fl4 "F")))
+  ".(a, .(b, .(c, [])))")
+
+;; ── numlist/3 ──────────────────────────────────────────────────────
+
+(define pl-lp-env-nl1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "numlist(1, 5, L)" pl-lp-env-nl1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "numlist(1,5,L) -> [1,2,3,4,5]"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-nl1 "L")))
+  ".(1, .(2, .(3, .(4, .(5, [])))))")
+
+(define pl-lp-env-nl2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "numlist(3, 3, L)" pl-lp-env-nl2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "numlist(3,3,L) -> [3]"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-nl2 "L")))
+  ".(3, [])")
+
+(pl-lp-test!
+  "numlist(5, 3, L) fails (Low > High)"
+  (pl-solve-once!
+    pl-lp-db
+    (pl-lp-goal "numlist(5, 3, L)" {})
+    (pl-mk-trail))
+  false)
+
+;; ── atomic_list_concat/2 ───────────────────────────────────────────
+
+(define pl-lp-env-alc1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "atomic_list_concat([a, b, c], R)" pl-lp-env-alc1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "atomic_list_concat([a,b,c], R) -> abc"
+  (pl-atom-name (pl-walk-deep (dict-get pl-lp-env-alc1 "R")))
+  "abc")
+
+(define pl-lp-env-alc2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "atomic_list_concat([hello, world], R)" pl-lp-env-alc2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "atomic_list_concat([hello,world], R) -> helloworld"
+  (pl-atom-name (pl-walk-deep (dict-get pl-lp-env-alc2 "R")))
+  "helloworld")
+
+;; ── atomic_list_concat/3 ───────────────────────────────────────────
+
+(define pl-lp-env-alcs1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "atomic_list_concat([a, b, c], '-', R)" pl-lp-env-alcs1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "atomic_list_concat([a,b,c], '-', R) -> a-b-c"
+  (pl-atom-name (pl-walk-deep (dict-get pl-lp-env-alcs1 "R")))
+  "a-b-c")
+
+(define pl-lp-env-alcs2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "atomic_list_concat([x], '-', R)" pl-lp-env-alcs2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "atomic_list_concat([x], '-', R) -> x (single element, no sep)"
+  (pl-atom-name (pl-walk-deep (dict-get pl-lp-env-alcs2 "R")))
+  "x")
+
+;; ── sum_list/2 ─────────────────────────────────────────────────────
+
+(define pl-lp-env-sl1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "sum_list([1,2,3], S)" pl-lp-env-sl1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "sum_list([1,2,3], S) -> 6"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-sl1 "S")))
+  6)
+
+(define pl-lp-env-sl2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "sum_list([10], S)" pl-lp-env-sl2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "sum_list([10], S) -> 10"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-sl2 "S")))
+  10)
+
+(define pl-lp-env-sl3 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "sum_list([], S)" pl-lp-env-sl3)
+  (pl-mk-trail))
+(pl-lp-test!
+  "sum_list([], S) -> 0"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-sl3 "S")))
+  0)
+
+;; ── max_list/2 ─────────────────────────────────────────────────────
+
+(define pl-lp-env-mx1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "max_list([3,1,4,1,5,9,2,6], M)" pl-lp-env-mx1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "max_list([3,1,4,1,5,9,2,6], M) -> 9"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-mx1 "M")))
+  9)
+
+(define pl-lp-env-mx2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "max_list([7], M)" pl-lp-env-mx2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "max_list([7], M) -> 7"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-mx2 "M")))
+  7)
+
+;; ── min_list/2 ─────────────────────────────────────────────────────
+
+(define pl-lp-env-mn1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "min_list([3,1,4,1,5,9,2,6], M)" pl-lp-env-mn1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "min_list([3,1,4,1,5,9,2,6], M) -> 1"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-mn1 "M")))
+  1)
+
+(define pl-lp-env-mn2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "min_list([5,2,8], M)" pl-lp-env-mn2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "min_list([5,2,8], M) -> 2"
+  (pl-num-val (pl-walk-deep (dict-get pl-lp-env-mn2 "M")))
+  2)
+
+;; ── delete/3 ───────────────────────────────────────────────────────
+
+(define pl-lp-env-del1 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "delete([1,2,3,2,1], 2, R)" pl-lp-env-del1)
+  (pl-mk-trail))
+(pl-lp-test!
+  "delete([1,2,3,2,1], 2, R) -> [1,3,1]"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-del1 "R")))
+  ".(1, .(3, .(1, [])))")
+
+(define pl-lp-env-del2 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "delete([a,b,c], d, R)" pl-lp-env-del2)
+  (pl-mk-trail))
+(pl-lp-test!
+  "delete([a,b,c], d, R) -> [a,b,c] (nothing deleted)"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-del2 "R")))
+  ".(a, .(b, .(c, [])))")
+
+(define pl-lp-env-del3 {})
+(pl-solve-once!
+  pl-lp-db
+  (pl-lp-goal "delete([], x, R)" pl-lp-env-del3)
+  (pl-mk-trail))
+(pl-lp-test!
+  "delete([], x, R) -> []"
+  (pl-format-term (pl-walk-deep (dict-get pl-lp-env-del3 "R")))
+  "[]")
+
+(define pl-list-predicates-tests-run! (fn () {:failed pl-lp-test-fail :passed pl-lp-test-pass :total pl-lp-test-count :failures pl-lp-test-failures}))

lib/prolog/tests/meta_call.sx

@@ -0,0 +1,197 @@
+;; lib/prolog/tests/meta_call.sx — forall/2, maplist/2, maplist/3, include/3, exclude/3
+(define pl-mc-test-count 0)
+(define pl-mc-test-pass 0)
+(define pl-mc-test-fail 0)
+(define pl-mc-test-failures (list))
+
+(define
+  pl-mc-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-mc-test-count (+ pl-mc-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-mc-test-pass (+ pl-mc-test-pass 1))
+        (begin
+          (set! pl-mc-test-fail (+ pl-mc-test-fail 1))
+          (append!
+            pl-mc-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-mc-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define
+  pl-mc-term-to-sx
+  (fn
+    (t)
+    (cond
+      ((pl-num? t) (pl-num-val t))
+      ((pl-atom? t) (pl-atom-name t))
+      (else t))))
+
+(define
+  pl-mc-list-sx
+  (fn
+    (t)
+    (let
+      ((w (pl-walk-deep t)))
+      (cond
+        ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
+        ((and (pl-compound? w) (= (pl-fun w) "."))
+          (cons
+            (pl-mc-term-to-sx (first (pl-args w)))
+            (pl-mc-list-sx (nth (pl-args w) 1))))
+        (else (list :not-list))))))
+
+(define pl-mc-db (pl-mk-db))
+
+(pl-db-load!
+  pl-mc-db
+  (pl-parse "member(X, [X|_]). member(X, [_|T]) :- member(X, T)."))
+
+(pl-db-load! pl-mc-db (pl-parse "double(X, Y) :- Y is X * 2."))
+
+(pl-db-load! pl-mc-db (pl-parse "even(X) :- 0 is X mod 2."))
+
+;; -- forall/2 --
+
+(pl-mc-test!
+  "forall(member(X,[2,4,6]), 0 is X mod 2) — all even"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "forall(member(X,[2,4,6]), 0 is X mod 2)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mc-test!
+  "forall(member(X,[2,3,6]), 0 is X mod 2) — 3 is odd, fails"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "forall(member(X,[2,3,6]), 0 is X mod 2)" {})
+    (pl-mk-trail))
+  false)
+
+(pl-mc-test!
+  "forall(member(_,[]), true) — vacuously true"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "forall(member(_,[]), true)" {})
+    (pl-mk-trail))
+  true)
+
+;; -- maplist/2 --
+
+(pl-mc-test!
+  "maplist(atom, [a,b,c]) — all atoms"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "maplist(atom, [a,b,c])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mc-test!
+  "maplist(atom, [a,1,c]) — 1 is not atom, fails"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "maplist(atom, [a,1,c])" {})
+    (pl-mk-trail))
+  false)
+
+(pl-mc-test!
+  "maplist(atom, []) — vacuously true"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "maplist(atom, [])" {})
+    (pl-mk-trail))
+  true)
+
+;; -- maplist/3 --
+
+(pl-mc-test!
+  "maplist(double, [1,2,3], [2,4,6]) — deterministic check"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "maplist(double, [1,2,3], [2,4,6])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mc-test!
+  "maplist(double, [1,2,3], [2,4,7]) — wrong result fails"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "maplist(double, [1,2,3], [2,4,7])" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-mc-env-ml3 {:L (pl-mk-rt-var "L")})
+(pl-solve-once!
+  pl-mc-db
+  (pl-mc-goal "maplist(double, [1,2,3], L)" pl-mc-env-ml3)
+  (pl-mk-trail))
+(pl-mc-test!
+  "maplist(double, [1,2,3], L) — L bound to [2,4,6]"
+  (pl-mc-list-sx (dict-get pl-mc-env-ml3 "L"))
+  (list 2 4 6))
+
+;; -- include/3 --
+
+(pl-mc-test!
+  "include(even, [1,2,3,4,5,6], [2,4,6])"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "include(even, [1,2,3,4,5,6], [2,4,6])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mc-test!
+  "include(even, [], [])"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "include(even, [], [])" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-mc-env-inc {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-mc-db
+  (pl-mc-goal "include(even, [1,2,3,4,5,6], R)" pl-mc-env-inc)
+  (pl-mk-trail))
+(pl-mc-test!
+  "include(even, [1,2,3,4,5,6], R) — R bound to [2,4,6]"
+  (pl-mc-list-sx (dict-get pl-mc-env-inc "R"))
+  (list 2 4 6))
+
+;; -- exclude/3 --
+
+(pl-mc-test!
+  "exclude(even, [1,2,3,4,5,6], [1,3,5])"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "exclude(even, [1,2,3,4,5,6], [1,3,5])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mc-test!
+  "exclude(even, [], [])"
+  (pl-solve-once!
+    pl-mc-db
+    (pl-mc-goal "exclude(even, [], [])" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-mc-env-exc {:R (pl-mk-rt-var "R")})
+(pl-solve-once!
+  pl-mc-db
+  (pl-mc-goal "exclude(even, [1,2,3,4,5,6], R)" pl-mc-env-exc)
+  (pl-mk-trail))
+(pl-mc-test!
+  "exclude(even, [1,2,3,4,5,6], R) — R bound to [1,3,5]"
+  (pl-mc-list-sx (dict-get pl-mc-env-exc "R"))
+  (list 1 3 5))
+
+(define pl-meta-call-tests-run! (fn () {:failed pl-mc-test-fail :passed pl-mc-test-pass :total pl-mc-test-count :failures pl-mc-test-failures}))

lib/prolog/tests/meta_predicates.sx

@@ -0,0 +1,252 @@
+;; lib/prolog/tests/meta_predicates.sx — \+/1, not/1, once/1, ignore/1, ground/1, sort/2, msort/2, atom_number/2, number_string/2
+
+(define pl-mp-test-count 0)
+(define pl-mp-test-pass 0)
+(define pl-mp-test-fail 0)
+(define pl-mp-test-failures (list))
+
+(define
+  pl-mp-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-mp-test-count (+ pl-mp-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-mp-test-pass (+ pl-mp-test-pass 1))
+        (begin
+          (set! pl-mp-test-fail (+ pl-mp-test-fail 1))
+          (append!
+            pl-mp-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-mp-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define pl-mp-db (pl-mk-db))
+(pl-db-load!
+  pl-mp-db
+  (pl-parse "member(X, [X|_]). member(X, [_|T]) :- member(X, T)."))
+
+;; -- \+/1 --
+
+(pl-mp-test!
+  "\\+(fail) succeeds"
+  (pl-solve-once! pl-mp-db (pl-mp-goal "\\+(fail)" {}) (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "\\+(true) fails"
+  (pl-solve-once! pl-mp-db (pl-mp-goal "\\+(true)" {}) (pl-mk-trail))
+  false)
+
+(pl-mp-test!
+  "\\+(member(d, [a,b,c])) succeeds"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "\\+(member(d, [a,b,c]))" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "\\+(member(a, [a,b,c])) fails"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "\\+(member(a, [a,b,c]))" {})
+    (pl-mk-trail))
+  false)
+
+(define pl-mp-env-neg {})
+(pl-solve-once!
+  pl-mp-db
+  (pl-mp-goal "\\+(X = 5)" pl-mp-env-neg)
+  (pl-mk-trail))
+(pl-mp-test!
+  "\\+(X=5) fails, X stays unbound (bindings undone)"
+  (nil? (pl-var-binding (dict-get pl-mp-env-neg "X")))
+  true)
+
+;; -- not/1 --
+
+(pl-mp-test!
+  "not(fail) succeeds"
+  (pl-solve-once! pl-mp-db (pl-mp-goal "not(fail)" {}) (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "not(true) fails"
+  (pl-solve-once! pl-mp-db (pl-mp-goal "not(true)" {}) (pl-mk-trail))
+  false)
+
+;; -- once/1 --
+
+(pl-mp-test!
+  "once(member(X,[1,2,3])) succeeds once"
+  (pl-solve-count!
+    pl-mp-db
+    (pl-mp-goal "once(member(X,[1,2,3]))" {})
+    (pl-mk-trail))
+  1)
+
+(define pl-mp-env-once {})
+(pl-solve-once!
+  pl-mp-db
+  (pl-mp-goal "once(member(X,[1,2,3]))" pl-mp-env-once)
+  (pl-mk-trail))
+(pl-mp-test!
+  "once(member(X,[1,2,3])): X=1 (first solution)"
+  (pl-num-val (pl-walk-deep (dict-get pl-mp-env-once "X")))
+  1)
+
+(pl-mp-test!
+  "once(fail) fails"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "once(fail)" {})
+    (pl-mk-trail))
+  false)
+
+;; -- ignore/1 --
+
+(pl-mp-test!
+  "ignore(true) succeeds"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "ignore(true)" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "ignore(fail) still succeeds"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "ignore(fail)" {})
+    (pl-mk-trail))
+  true)
+
+;; -- ground/1 --
+
+(pl-mp-test!
+  "ground(foo(1, a)) succeeds"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "ground(foo(1, a))" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "ground(foo(X, a)) fails (X unbound)"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "ground(foo(X, a))" {})
+    (pl-mk-trail))
+  false)
+
+(pl-mp-test!
+  "ground(42) succeeds"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "ground(42)" {})
+    (pl-mk-trail))
+  true)
+
+;; -- sort/2 --
+
+(pl-mp-test!
+  "sort([b,a,c], [a,b,c])"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "sort([b,a,c], [a,b,c])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "sort([b,a,a,c], [a,b,c]) (removes duplicates)"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "sort([b,a,a,c], [a,b,c])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "sort([], [])"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "sort([], [])" {})
+    (pl-mk-trail))
+  true)
+
+;; -- msort/2 --
+
+(pl-mp-test!
+  "msort([b,a,a,c], [a,a,b,c]) (keeps duplicates)"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "msort([b,a,a,c], [a,a,b,c])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-mp-test!
+  "msort([3,1,2,1], [1,1,2,3])"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "msort([3,1,2,1], [1,1,2,3])" {})
+    (pl-mk-trail))
+  true)
+
+;; -- atom_number/2 --
+
+(define pl-mp-env-an1 {})
+(pl-solve-once!
+  pl-mp-db
+  (pl-mp-goal "atom_number('42', N)" pl-mp-env-an1)
+  (pl-mk-trail))
+(pl-mp-test!
+  "atom_number('42', N) -> N=42"
+  (pl-num-val (pl-walk-deep (dict-get pl-mp-env-an1 "N")))
+  42)
+
+(define pl-mp-env-an2 {})
+(pl-solve-once!
+  pl-mp-db
+  (pl-mp-goal "atom_number(A, 7)" pl-mp-env-an2)
+  (pl-mk-trail))
+(pl-mp-test!
+  "atom_number(A, 7) -> A='7'"
+  (pl-atom-name (pl-walk-deep (dict-get pl-mp-env-an2 "A")))
+  "7")
+
+(pl-mp-test!
+  "atom_number(foo, N) fails (not a number)"
+  (pl-solve-once!
+    pl-mp-db
+    (pl-mp-goal "atom_number(foo, N)" {})
+    (pl-mk-trail))
+  false)
+
+;; -- number_string/2 --
+
+(define pl-mp-env-ns1 {})
+(pl-solve-once!
+  pl-mp-db
+  (pl-mp-goal "number_string(42, S)" pl-mp-env-ns1)
+  (pl-mk-trail))
+(pl-mp-test!
+  "number_string(42, S) -> S='42'"
+  (pl-atom-name (pl-walk-deep (dict-get pl-mp-env-ns1 "S")))
+  "42")
+
+(define pl-mp-env-ns2 {})
+(pl-solve-once!
+  pl-mp-db
+  (pl-mp-goal "number_string(N, '3.14')" pl-mp-env-ns2)
+  (pl-mk-trail))
+(pl-mp-test!
+  "number_string(N, '3.14') -> N=3.14"
+  (pl-num-val (pl-walk-deep (dict-get pl-mp-env-ns2 "N")))
+  3.14)
+
+(define pl-meta-predicates-tests-run! (fn () {:failed pl-mp-test-fail :passed pl-mp-test-pass :total pl-mp-test-count :failures pl-mp-test-failures}))

lib/prolog/tests/operators.sx

@@ -0,0 +1,193 @@
+;; lib/prolog/tests/operators.sx — operator-table parsing + comparison built-ins.
+
+(define pl-op-test-count 0)
+(define pl-op-test-pass 0)
+(define pl-op-test-fail 0)
+(define pl-op-test-failures (list))
+
+(define
+  pl-op-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-op-test-count (+ pl-op-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-op-test-pass (+ pl-op-test-pass 1))
+        (begin
+          (set! pl-op-test-fail (+ pl-op-test-fail 1))
+          (append!
+            pl-op-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define pl-op-empty-db (pl-mk-db))
+
+(define
+  pl-op-body
+  (fn (src) (nth (first (pl-parse (str "g :- " src "."))) 2)))
+
+(define pl-op-goal (fn (src env) (pl-instantiate (pl-op-body src) env)))
+
+;; ── parsing tests ──
+
+(pl-op-test!
+  "infix +"
+  (pl-op-body "a + b")
+  (list "compound" "+" (list (list "atom" "a") (list "atom" "b"))))
+
+(pl-op-test!
+  "infix * tighter than +"
+  (pl-op-body "a + b * c")
+  (list
+    "compound"
+    "+"
+    (list
+      (list "atom" "a")
+      (list "compound" "*" (list (list "atom" "b") (list "atom" "c"))))))
+
+(pl-op-test!
+  "parens override precedence"
+  (pl-op-body "(a + b) * c")
+  (list
+    "compound"
+    "*"
+    (list
+      (list "compound" "+" (list (list "atom" "a") (list "atom" "b")))
+      (list "atom" "c"))))
+
+(pl-op-test!
+  "+ is yfx (left-assoc)"
+  (pl-op-body "a + b + c")
+  (list
+    "compound"
+    "+"
+    (list
+      (list "compound" "+" (list (list "atom" "a") (list "atom" "b")))
+      (list "atom" "c"))))
+
+(pl-op-test!
+  "; is xfy (right-assoc)"
+  (pl-op-body "a ; b ; c")
+  (list
+    "compound"
+    ";"
+    (list
+      (list "atom" "a")
+      (list "compound" ";" (list (list "atom" "b") (list "atom" "c"))))))
+
+(pl-op-test!
+  "= folds at 700"
+  (pl-op-body "X = 5")
+  (list "compound" "=" (list (list "var" "X") (list "num" 5))))
+
+(pl-op-test!
+  "is + nests via 700>500>400"
+  (pl-op-body "X is 2 + 3 * 4")
+  (list
+    "compound"
+    "is"
+    (list
+      (list "var" "X")
+      (list
+        "compound"
+        "+"
+        (list
+          (list "num" 2)
+          (list "compound" "*" (list (list "num" 3) (list "num" 4))))))))
+
+(pl-op-test!
+  "< parses at 700"
+  (pl-op-body "2 < 3")
+  (list "compound" "<" (list (list "num" 2) (list "num" 3))))
+
+(pl-op-test!
+  "mod parses as yfx 400"
+  (pl-op-body "10 mod 3")
+  (list "compound" "mod" (list (list "num" 10) (list "num" 3))))
+
+(pl-op-test!
+  "comma in body folds right-assoc"
+  (pl-op-body "a, b, c")
+  (list
+    "compound"
+    ","
+    (list
+      (list "atom" "a")
+      (list "compound" "," (list (list "atom" "b") (list "atom" "c"))))))
+
+;; ── solver tests via infix ──
+
+(pl-op-test!
+  "X is 2 + 3 binds X = 5"
+  (let
+    ((env {}) (trail (pl-mk-trail)))
+    (begin
+      (pl-solve-once! pl-op-empty-db (pl-op-goal "X is 2 + 3" env) trail)
+      (pl-num-val (pl-walk-deep (dict-get env "X")))))
+  5)
+
+(pl-op-test!
+  "infix conjunction parses + solves"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "X = 5, X = 5" {})
+    (pl-mk-trail))
+  true)
+
+(pl-op-test!
+  "infix mismatch fails"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "X = 5, X = 6" {})
+    (pl-mk-trail))
+  false)
+
+(pl-op-test!
+  "infix disjunction picks left"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "true ; fail" {})
+    (pl-mk-trail))
+  true)
+
+(pl-op-test!
+  "2 < 5 succeeds"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "2 < 5" {})
+    (pl-mk-trail))
+  true)
+
+(pl-op-test!
+  "5 < 2 fails"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "5 < 2" {})
+    (pl-mk-trail))
+  false)
+
+(pl-op-test!
+  "5 >= 5 succeeds"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "5 >= 5" {})
+    (pl-mk-trail))
+  true)
+
+(pl-op-test!
+  "3 =< 5 succeeds"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "3 =< 5" {})
+    (pl-mk-trail))
+  true)
+
+(pl-op-test!
+  "infix < with arithmetic both sides"
+  (pl-solve-once!
+    pl-op-empty-db
+    (pl-op-goal "1 + 2 < 2 * 3" {})
+    (pl-mk-trail))
+  true)
+
+(define pl-operators-tests-run! (fn () {:failed pl-op-test-fail :passed pl-op-test-pass :total pl-op-test-count :failures pl-op-test-failures}))

lib/prolog/tests/programs/append.pl

@@ -0,0 +1,5 @@
+%% append/3 — list concatenation, classic Prolog
+%% Two clauses: empty-prefix base case + recursive cons-prefix.
+%% Bidirectional — works in all modes: build, check, split.
+append([], L, L).
+append([H|T], L, [H|R]) :- append(T, L, R).

lib/prolog/tests/programs/append.sx

@@ -0,0 +1,114 @@
+;; lib/prolog/tests/programs/append.sx — append/3 test runner
+;;
+;; Mirrors the Prolog source in append.pl (embedded as a string here because
+;; the SX runtime has no file-read primitive yet).
+
+(define pl-ap-test-count 0)
+(define pl-ap-test-pass 0)
+(define pl-ap-test-fail 0)
+(define pl-ap-test-failures (list))
+
+(define
+  pl-ap-test!
+  (fn
+    (name got expected)
+    (begin
+      (set! pl-ap-test-count (+ pl-ap-test-count 1))
+      (if
+        (= got expected)
+        (set! pl-ap-test-pass (+ pl-ap-test-pass 1))
+        (begin
+          (set! pl-ap-test-fail (+ pl-ap-test-fail 1))
+          (append!
+            pl-ap-test-failures
+            (str name "\n    expected: " expected "\n    got:      " got)))))))
+
+(define
+  pl-ap-term-to-sx
+  (fn
+    (t)
+    (cond
+      ((pl-num? t) (pl-num-val t))
+      ((pl-atom? t) (pl-atom-name t))
+      (true (list :complex)))))
+
+(define
+  pl-ap-list-walked
+  (fn
+    (w)
+    (cond
+      ((and (pl-atom? w) (= (pl-atom-name w) "[]")) (list))
+      ((and (pl-compound? w) (= (pl-fun w) ".") (= (len (pl-args w)) 2))
+        (cons
+          (pl-ap-term-to-sx (first (pl-args w)))
+          (pl-ap-list-walked (nth (pl-args w) 1))))
+      (true (list :not-list)))))
+
+(define pl-ap-list-to-sx (fn (t) (pl-ap-list-walked (pl-walk-deep t))))
+
+(define
+  pl-ap-goal
+  (fn
+    (src env)
+    (pl-instantiate (nth (first (pl-parse (str "g :- " src "."))) 2) env)))
+
+(define
+  pl-ap-prog-src
+  "append([], L, L). append([H|T], L, [H|R]) :- append(T, L, R).")
+
+(define pl-ap-db (pl-mk-db))
+
+(pl-db-load! pl-ap-db (pl-parse pl-ap-prog-src))
+
+(define pl-ap-env-1 {})
+(define pl-ap-goal-1 (pl-ap-goal "append([], [a, b], X)" pl-ap-env-1))
+(pl-solve-once! pl-ap-db pl-ap-goal-1 (pl-mk-trail))
+
+(pl-ap-test!
+  "append([], [a, b], X) → X = [a, b]"
+  (pl-ap-list-to-sx (dict-get pl-ap-env-1 "X"))
+  (list "a" "b"))
+
+(define pl-ap-env-2 {})
+(define pl-ap-goal-2 (pl-ap-goal "append([1, 2], [3, 4], X)" pl-ap-env-2))
+(pl-solve-once! pl-ap-db pl-ap-goal-2 (pl-mk-trail))
+
+(pl-ap-test!
+  "append([1, 2], [3, 4], X) → X = [1, 2, 3, 4]"
+  (pl-ap-list-to-sx (dict-get pl-ap-env-2 "X"))
+  (list 1 2 3 4))
+
+(pl-ap-test!
+  "append([1], [2, 3], [1, 2, 3]) succeeds"
+  (pl-solve-once!
+    pl-ap-db
+    (pl-ap-goal "append([1], [2, 3], [1, 2, 3])" {})
+    (pl-mk-trail))
+  true)
+
+(pl-ap-test!
+  "append([1, 2], [3], [1, 2, 4]) fails"
+  (pl-solve-once!
+    pl-ap-db
+    (pl-ap-goal "append([1, 2], [3], [1, 2, 4])" {})
+    (pl-mk-trail))
+  false)
+
+(pl-ap-test!
+  "append(X, Y, [1, 2, 3]) backtracks 4 times"
+  (pl-solve-count!
+    pl-ap-db
+    (pl-ap-goal "append(X, Y, [1, 2, 3])" {})
+    (pl-mk-trail))
+  4)
+
+(define pl-ap-env-6 {})
+(define pl-ap-goal-6 (pl-ap-goal "append(X, [3], [1, 2, 3])" pl-ap-env-6))
+(pl-solve-once! pl-ap-db pl-ap-goal-6 (pl-mk-trail))
+
+(pl-ap-test!
+  "append(X, [3], [1, 2, 3]) deduces X = [1, 2]"
+  (pl-ap-list-to-sx (dict-get pl-ap-env-6 "X"))
+  (list 1 2))
+
+(define pl-append-tests-run! (fn () {:failed pl-ap-test-fail :passed pl-ap-test-pass :total pl-ap-test-count :failures pl-ap-test-failures}))