Merge remote-tracking branch 'origin/loops/tcl' into architecture

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

hosts/javascript/platform.py

@@ -1129,6 +1129,7 @@ PRIMITIVES_JS_MODULES: dict[str, str] = {
   PRIMITIVES["boolean?"] = function(x) { return x === true || x === false; };
   PRIMITIVES["symbol?"] = function(x) { return x != null && x._sym === true; };
   PRIMITIVES["keyword?"] = function(x) { return x != null && x._kw === true; };
+  PRIMITIVES["adt?"] = function(x) { return x !== null && typeof x === "object" && x._adtv === true; };
   PRIMITIVES["component-affinity"] = componentAffinity;
 ''',
 
@@ -1475,6 +1476,22 @@ PRIMITIVES_JS_MODULES: dict[str, str] = {
   };
   PRIMITIVES["string-buffer->string"] = function(buf) { return buf.parts.join(""); };
   PRIMITIVES["string-buffer-length"] = function(buf) { return buf.len; };
+
+  // Short aliases — terser names; append accepts any value
+  PRIMITIVES["make-buffer"] = function() { return new SxStringBuffer(); };
+  PRIMITIVES["buffer?"] = function(x) { return x instanceof SxStringBuffer; };
+  PRIMITIVES["buffer-append!"] = function(buf, v) {
+    var s;
+    if (v === null || v === undefined || v === NIL) s = "";
+    else if (typeof v === "string") s = v;
+    else if (typeof v === "boolean") s = v ? "true" : "false";
+    else if (typeof v === "number") s = String(v);
+    else if (v && typeof v === "object" && typeof v.name === "string" && v.constructor && v.constructor.name === "Symbol") s = v.name;
+    else s = (typeof inspect === "function") ? inspect(v) : String(v);
+    buf.parts.push(s); buf.len += s.length; return NIL;
+  };
+  PRIMITIVES["buffer->string"] = function(buf) { return buf.parts.join(""); };
+  PRIMITIVES["buffer-length"] = function(buf) { return buf.len; };
 ''',
 
     "stdlib.format": '''
@@ -1933,12 +1950,30 @@ PLATFORM_JS_PRE = '''
     if (x._regexp) return "regexp";
     if (x._bytevector) return "bytevector";
     if (x._rational) return "rational";
+    if (x._adtv) return x._type;
     if (typeof Node !== "undefined" && x instanceof Node) return "dom-node";
     if (Array.isArray(x)) return "list";
     if (typeof x === "object") return "dict";
     return "unknown";
   }
 
+  // AdtValue — native algebraic data type instance (Step 6 mirror of OCaml Step 5).
+  // Constructed by define-type. Carries _adt:true plus _adtv:true tag so type-of
+  // returns the type name rather than "dict". dict? remains true (shim approach)
+  // so spec-level match-pattern in evaluator.sx works without changes.
+  function makeAdtValue(typeName, ctorName, fields) {
+    return {
+      _adtv: true,
+      _adt: true,
+      _type: typeName,
+      _ctor: ctorName,
+      _fields: fields
+    };
+  }
+  function isAdtValue(x) {
+    return x !== null && typeof x === "object" && x._adtv === true;
+  }
+
   function symbolName(s) { return s.name; }
   function keywordName(k) { return k.name; }
   function makeSymbol(n) { return new Symbol(n); }
@@ -2105,6 +2140,13 @@ PLATFORM_JS_PRE = '''
   // hostError — throw a host-level error that propagates out of cekRun.
   function hostError(msg) { throw new Error(typeof msg === "string" ? msg : inspect(msg)); }
 
+  // hostWarn — emit a host-level warning to console (no-op if console missing).
+  function hostWarn(msg) {
+    var m = typeof msg === "string" ? msg : inspect(msg);
+    if (typeof console !== "undefined" && console.warn) console.warn(m);
+    return NIL;
+  }
+
   // Render dispatch — call the active adapter's render function.
   // Set by each adapter when loaded; defaults to identity (no rendering).
   var _renderExprFn = null;
@@ -2126,7 +2168,16 @@ PLATFORM_JS_PRE = '''
   }
 
   function error(msg) { throw new Error(msg); }
-  function inspect(x) { return JSON.stringify(x); }
+  function inspect(x) {
+    if (x !== null && typeof x === "object" && x._adtv === true) {
+      var fs = x._fields || [];
+      if (fs.length === 0) return "(" + x._ctor + ")";
+      var parts = [];
+      for (var i = 0; i < fs.length; i++) parts.push(inspect(fs[i]));
+      return "(" + x._ctor + " " + parts.join(" ") + ")";
+    }
+    return JSON.stringify(x);
+  }
   function debugLog() { console.error.apply(console, ["[sx-debug]"].concat(Array.prototype.slice.call(arguments))); }
 
 '''
@@ -2450,6 +2501,7 @@ CEK_FIXUPS_JS = '''
   // Platform functions — defined in platform_js.py, not in .sx spec files.
   // Spec defines self-register via js-emit-define; these are the platform interface.
   PRIMITIVES["type-of"] = typeOf;
+  PRIMITIVES["inspect"] = inspect;
   PRIMITIVES["symbol-name"] = symbolName;
   PRIMITIVES["keyword-name"] = keywordName;
   PRIMITIVES["callable?"] = isCallable;
@@ -3981,6 +4033,11 @@ def fixups_js(has_html, has_sx, has_dom, has_signals=False, has_deps=False, has_
   // -----------------------------------------------------------------------
   PRIMITIVES["error"] = function(msg) { throw new Error(msg); };
   PRIMITIVES["host-error"] = function(msg) { throw new Error(typeof msg === "string" ? msg : inspect(msg)); };
+  PRIMITIVES["host-warn"] = function(msg) {
+    var m = typeof msg === "string" ? msg : inspect(msg);
+    if (typeof console !== "undefined" && console.warn) console.warn(m);
+    return NIL;
+  };
   PRIMITIVES["try-catch"] = function(tryFn, catchFn) {
     try {
       return cekRun(continueWithCall(tryFn, [], makeEnv(), [], []));
@@ -4103,7 +4160,56 @@ def fixups_js(has_html, has_sx, has_dom, has_signals=False, has_deps=False, has_
   function clearStores() { _storeRegistry = {}; return NIL; }
   PRIMITIVES["def-store"] = defStore;
   PRIMITIVES["use-store"] = useStore;
-  PRIMITIVES["clear-stores"] = clearStores;''']
+  PRIMITIVES["clear-stores"] = clearStores;
+
+  // -----------------------------------------------------------------------
+  // define-type override — produces native AdtValue instances (Step 6).
+  // The transpiled sfDefineType from evaluator.sx creates plain dict
+  // instances. We override here to construct AdtValue via makeAdtValue so
+  // type-of returns the type name and adt? can distinguish from dicts.
+  // dict? still returns true for AdtValue (shim) so spec-level match-pattern
+  // continues to work without changes.
+  // -----------------------------------------------------------------------
+  var _sfDefineTypeAdt = function(args, env) {
+    var typeSym = first(args);
+    var ctorSpecs = rest(args);
+    var typeName = symbolName(typeSym);
+    var ctorNames = map(function(spec) { return symbolName(first(spec)); }, ctorSpecs);
+    if (!isSxTruthy(envHas(env, "*adt-registry*"))) {
+      envBind(env, "*adt-registry*", {});
+    }
+    envGet(env, "*adt-registry*")[typeName] = ctorNames;
+    envBind(env, typeName + "?", function(v) { return isAdtValue(v) && v._type === typeName; });
+    for (var _i = 0; _i < ctorSpecs.length; _i++) {
+      (function(spec) {
+        var cn = symbolName(first(spec));
+        var fieldNames = map(function(f) { return symbolName(f); }, rest(spec));
+        var arity = fieldNames.length;
+        envBind(env, cn, function() {
+          var ctorArgs = Array.prototype.slice.call(arguments, 0);
+          if (ctorArgs.length !== arity) {
+            throw new Error(cn + ": expected " + arity + " args, got " + ctorArgs.length);
+          }
+          return makeAdtValue(typeName, cn, ctorArgs);
+        });
+        envBind(env, cn + "?", function(v) { return isAdtValue(v) && v._ctor === cn; });
+        for (var _j = 0; _j < fieldNames.length; _j++) {
+          (function(idx, fieldName) {
+            envBind(env, cn + "-" + fieldName, function(v) {
+              if (!isAdtValue(v)) throw new Error(cn + "-" + fieldName + ": not an ADT");
+              if (idx >= v._fields.length) throw new Error(cn + "-" + fieldName + ": index out of bounds");
+              return v._fields[idx];
+            });
+          })(_j, fieldNames[_j]);
+        }
+      })(ctorSpecs[_i]);
+    }
+    return NIL;
+  };
+  PRIMITIVES["sf-define-type"] = _sfDefineTypeAdt;
+  registerSpecialForm("define-type", _sfDefineTypeAdt);
+  PRIMITIVES["make-adt-value"] = makeAdtValue;
+  PRIMITIVES["adt-value?"] = isAdtValue;''']
     if has_deps:
         lines.append('''
   // Platform deps functions (native JS, not transpiled — need explicit registration)

hosts/ocaml/bin/bench_cek.ml

@@ -0,0 +1,73 @@
+(** CEK benchmark — measures throughput of the CEK evaluator on tight loops.
+
+    Usage:
+      dune exec bin/bench_cek.exe
+      dune exec bin/bench_cek.exe -- 5      (5 runs each)
+*)
+
+open Sx_types
+open Sx_parser
+
+let parse_one s =
+  let exprs = parse_all s in
+  match exprs with
+  | e :: _ -> e
+  | [] -> failwith "empty parse"
+
+let parse_many s = parse_all s
+
+let bench_run name setup expr iters =
+  let env = Sx_types.make_env () in
+  (* Run setup forms in env *)
+  List.iter (fun e -> ignore (Sx_ref.eval_expr e (Env env))) setup;
+  let times = ref [] in
+  for _ = 1 to iters do
+    Gc.full_major ();
+    let t0 = Unix.gettimeofday () in
+    let _r = Sx_ref.eval_expr expr (Env env) in
+    let t1 = Unix.gettimeofday () in
+    times := (t1 -. t0) :: !times
+  done;
+  let sorted = List.sort compare !times in
+  let median = List.nth sorted (iters / 2) in
+  let min_t = List.nth sorted 0 in
+  let max_t = List.nth sorted (iters - 1) in
+  Printf.printf "  %-22s  min=%8.2fms  median=%8.2fms  max=%8.2fms\n%!"
+    name (min_t *. 1000.0) (median *. 1000.0) (max_t *. 1000.0);
+  median
+
+let () =
+  let iters =
+    if Array.length Sys.argv > 1
+    then int_of_string Sys.argv.(1)
+    else 5
+  in
+  Printf.printf "CEK benchmark (%d runs each, taking median)\n%!" iters;
+  Printf.printf "==========================================\n%!";
+
+  (* fib 18 — recursive function call benchmark, smallish *)
+  let fib_setup = parse_many "(define (fib n) (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2)))))" in
+  let fib_expr = parse_one "(fib 18)" in
+  let _ = bench_run "fib(18)" fib_setup fib_expr iters in
+
+  (* loop 5000 — tight let loop *)
+  let loop_setup = parse_many "(define (loop n acc) (if (= n 0) acc (loop (- n 1) (+ acc 1))))" in
+  let loop_expr = parse_one "(loop 5000 0)" in
+  let _ = bench_run "loop(5000)" loop_setup loop_expr iters in
+
+  (* map+square over 1000 elem list *)
+  let map_setup = parse_many "(define (range-list n) (let loop ((i 0) (acc (list))) (if (= i n) acc (loop (+ i 1) (cons i acc))))) (define xs (range-list 1000))" in
+  let map_expr = parse_one "(map (fn (x) (* x x)) xs)" in
+  let _ = bench_run "map sq xs(1000)" map_setup map_expr iters in
+
+  (* reduce + over 2000 elem list *)
+  let red_setup = parse_many "(define (range-list n) (let loop ((i 0) (acc (list))) (if (= i n) acc (loop (+ i 1) (cons i acc))))) (define ys (range-list 2000))" in
+  let red_expr = parse_one "(reduce + 0 ys)" in
+  let _ = bench_run "reduce + ys(2000)" red_setup red_expr iters in
+
+  (* let-heavy: many bindings + if *)
+  let lh_setup = parse_many "(define (lh n) (let ((a 1) (b 2) (c 3) (d 4)) (if (= n 0) (+ a b c d) (lh (- n 1)))))" in
+  let lh_expr = parse_one "(lh 2000)" in
+  let _ = bench_run "let-heavy(2000)" lh_setup lh_expr iters in
+
+  Printf.printf "\nDone.\n%!"

hosts/ocaml/bin/bench_inspect.ml

@@ -0,0 +1,46 @@
+(* Benchmark inspect on representative SX values.
+   Takes min of 9 runs of n iterations to dampen GC noise. *)
+open Sx_types
+
+let rec make_tree d =
+  if d = 0 then String "leaf"
+  else List [String "node"; make_tree (d - 1); make_tree (d - 1); make_tree (d - 1)]
+
+let bench_min label f n runs =
+  let times = ref [] in
+  for _ = 1 to runs do
+    Gc.compact ();
+    let t0 = Unix.gettimeofday () in
+    for _ = 1 to n do ignore (f ()) done;
+    let t1 = Unix.gettimeofday () in
+    times := (t1 -. t0) :: !times
+  done;
+  let sorted = List.sort compare !times in
+  let min_t = List.nth sorted 0 in
+  let median = List.nth sorted (runs / 2) in
+  Printf.printf "  %-30s  min=%6.2fms  median=%6.2fms  (n=%d * %d runs)\n%!"
+    label (min_t *. 1000.0 /. float_of_int n)
+    (median *. 1000.0 /. float_of_int n) n runs
+
+let () =
+  let tree8 = make_tree 8 in
+  let s = inspect tree8 in
+  Printf.printf "tree-d8 inspect len=%d\n%!" (String.length s);
+  bench_min "inspect tree-d8" (fun () -> inspect tree8) 50 9;
+
+  let tree10 = make_tree 10 in
+  let s = inspect tree10 in
+  Printf.printf "tree-d10 inspect len=%d\n%!" (String.length s);
+  bench_min "inspect tree-d10" (fun () -> inspect tree10) 5 9;
+
+  let dict_xs = make_dict () in
+  for i = 0 to 999 do
+    Hashtbl.replace dict_xs (string_of_int i) (Integer i)
+  done;
+  let d = Dict dict_xs in
+  bench_min "inspect dict-1000" (fun () -> inspect d) 100 9;
+
+  let xs = ref [] in
+  for i = 0 to 1999 do xs := Integer i :: !xs done;
+  let lst = List !xs in
+  bench_min "inspect list-2000" (fun () -> inspect lst) 200 9

hosts/ocaml/bin/bench_vm.ml

@@ -0,0 +1,155 @@
+(** VM bytecode benchmark — measures throughput of the VM (compiled bytecode).
+
+    Loads the SX compiler via CEK, then for each test:
+      1. Define the function via CEK (as a Lambda).
+      2. Trigger JIT compilation via Sx_vm.jit_compile_lambda.
+      3. Call the compiled VmClosure repeatedly via Sx_vm.call_closure.
+
+    This measures pure VM execution time on the JIT path. *)
+
+open Sx_types
+
+let load_compiler env globals =
+  let compiler_path =
+    if Sys.file_exists "lib/compiler.sx" then "lib/compiler.sx"
+    else if Sys.file_exists "../../lib/compiler.sx" then "../../lib/compiler.sx"
+    else if Sys.file_exists "../../../lib/compiler.sx" then "../../../lib/compiler.sx"
+    else failwith "compiler.sx not found"
+  in
+  let ic = open_in compiler_path in
+  let src = really_input_string ic (in_channel_length ic) in
+  close_in ic;
+  let exprs = Sx_parser.parse_all src in
+  List.iter (fun e -> ignore (Sx_ref.eval_expr e (Env env))) exprs;
+  let rec sync e =
+    Hashtbl.iter (fun id v ->
+      let name = Sx_types.unintern id in
+      Hashtbl.replace globals name v) e.bindings;
+    match e.parent with Some p -> sync p | None -> ()
+  in
+  sync env
+
+let _make_globals env =
+  let g = Hashtbl.create 512 in
+  Hashtbl.iter (fun name fn ->
+    Hashtbl.replace g name (NativeFn (name, fn))
+  ) Sx_primitives.primitives;
+  let rec sync e =
+    Hashtbl.iter (fun id v ->
+      let name = Sx_types.unintern id in
+      if not (Hashtbl.mem g name) then Hashtbl.replace g name v) e.bindings;
+    match e.parent with Some p -> sync p | None -> ()
+  in
+  sync env;
+  g
+
+let define_fn env globals name params body_src =
+  (* Define via CEK so we get a Lambda value with proper closure. *)
+  let body_expr = match Sx_parser.parse_all body_src with
+    | [e] -> e
+    | _ -> failwith "expected one body expression"
+  in
+  let param_syms = List (List.map (fun p -> Symbol p) params) in
+  let define_expr = List [Symbol "define"; Symbol name; List [Symbol "fn"; param_syms; body_expr]] in
+  ignore (Sx_ref.eval_expr define_expr (Env env));
+  (* Sync env to globals so JIT can resolve free vars. *)
+  let rec sync e =
+    Hashtbl.iter (fun id v ->
+      let n = Sx_types.unintern id in
+      Hashtbl.replace globals n v) e.bindings;
+    match e.parent with Some p -> sync p | None -> ()
+  in
+  sync env;
+  (* Now find the Lambda and JIT-compile it. *)
+  let lam_val = Hashtbl.find globals name in
+  match lam_val with
+  | Lambda l ->
+    (match Sx_vm.jit_compile_lambda l globals with
+     | Some cl ->
+       l.l_compiled <- Some cl;
+       Hashtbl.replace globals name (NativeFn (name, fun args ->
+         Sx_vm.call_closure cl args globals));
+       cl
+     | None ->
+       failwith (Printf.sprintf "JIT failed for %s" name))
+  | _ -> failwith (Printf.sprintf "%s is not a Lambda after define" name)
+
+let bench_call name cl globals args iters =
+  let times = ref [] in
+  for _ = 1 to iters do
+    Gc.full_major ();
+    let t0 = Unix.gettimeofday () in
+    let _r = Sx_vm.call_closure cl args globals in
+    let t1 = Unix.gettimeofday () in
+    times := (t1 -. t0) :: !times
+  done;
+  let sorted = List.sort compare !times in
+  let median = List.nth sorted (iters / 2) in
+  let min_t = List.nth sorted 0 in
+  let max_t = List.nth sorted (iters - 1) in
+  Printf.printf "  %-22s  min=%8.2fms  median=%8.2fms  max=%8.2fms\n%!"
+    name (min_t *. 1000.0) (median *. 1000.0) (max_t *. 1000.0);
+  median
+
+let () =
+  let iters =
+    if Array.length Sys.argv > 1
+    then int_of_string Sys.argv.(1)
+    else 7
+  in
+  Printf.printf "VM (bytecode/JIT) benchmark (%d runs each, taking median)\n%!" iters;
+  Printf.printf "========================================================\n%!";
+
+  let env = Sx_types.make_env () in
+  let bind n fn = ignore (Sx_types.env_bind env n (NativeFn (n, fn))) in
+  (* Seed env with primitives as NativeFn so CEK lookups work. *)
+  Hashtbl.iter (fun name fn ->
+    Hashtbl.replace env.bindings (Sx_types.intern name) (NativeFn (name, fn))
+  ) Sx_primitives.primitives;
+  (* Helpers the SX compiler relies on but aren't kernel primitives. *)
+  bind "symbol-name" (fun args -> match args with
+    | [Symbol s] -> String s | _ -> raise (Eval_error "symbol-name"));
+  bind "keyword-name" (fun args -> match args with
+    | [Keyword k] -> String k | _ -> raise (Eval_error "keyword-name"));
+  bind "make-symbol" (fun args -> match args with
+    | [String s] -> Symbol s
+    | [v] -> Symbol (Sx_types.value_to_string v)
+    | _ -> raise (Eval_error "make-symbol"));
+  bind "sx-serialize" (fun args -> match args with
+    | [v] -> String (Sx_types.inspect v)
+    | _ -> raise (Eval_error "sx-serialize"));
+  let globals = Hashtbl.create 1024 in
+  Hashtbl.iter (fun name fn ->
+    Hashtbl.replace globals name (NativeFn (name, fn))
+  ) Sx_primitives.primitives;
+  Printf.printf "Loading compiler.sx ... %!";
+  let t0 = Unix.gettimeofday () in
+  load_compiler env globals;
+  Printf.printf "%.0fms\n%!" ((Unix.gettimeofday () -. t0) *. 1000.0);
+
+  (* fib(22) — recursive call benchmark *)
+  let fib_cl = define_fn env globals "fib" ["n"]
+    "(if (< n 2) n (+ (fib (- n 1)) (fib (- n 2))))" in
+  let _ = bench_call "fib(22)" fib_cl globals [Number 22.0] iters in
+
+  (* tight loop *)
+  let loop_cl = define_fn env globals "loop" ["n"; "acc"]
+    "(if (= n 0) acc (loop (- n 1) (+ acc 1)))" in
+  let _ = bench_call "loop(200000)" loop_cl globals [Number 200000.0; Number 0.0] iters in
+
+  (* sum-to *)
+  let sum_cl = define_fn env globals "sum_to" ["n"; "acc"]
+    "(if (= n 0) acc (sum_to (- n 1) (+ acc n)))" in
+  let _ = bench_call "sum-to(50000)" sum_cl globals [Number 50000.0; Number 0.0] iters in
+
+  (* count-lt: comparison-heavy *)
+  let cnt_cl = define_fn env globals "count_lt" ["n"; "acc"]
+    "(if (= n 0) acc (count_lt (- n 1) (if (< n 10000) (+ acc 1) acc)))" in
+  let _ = bench_call "count-lt(20000)" cnt_cl globals [Number 20000.0; Number 0.0] iters in
+
+  (* count-eq: equality-heavy on multiples of 7 *)
+  let eq_cl = define_fn env globals "count_eq" ["n"; "acc"]
+    "(if (= n 0) acc (count_eq (- n 1) (if (= 0 (- n (* 7 (/ n 7)))) (+ acc 1) acc)))" in
+  let _ = bench_call "count-eq(20000)" eq_cl globals [Number 20000.0; Number 0.0] iters in
+
+  Printf.printf "\nDone.\n%!"

hosts/ocaml/bin/dune

@@ -1,5 +1,5 @@
 (executables
- (names run_tests debug_set sx_server integration_tests)
+ (names run_tests debug_set sx_server integration_tests bench_cek bench_inspect bench_vm)
  (libraries sx unix threads.posix otfm yojson))
 
 (executable

hosts/ocaml/bin/run_tests.ml

@@ -1279,7 +1279,7 @@ let run_foundation_tests () =
   assert_true "sx_truthy \"\"" (Bool (sx_truthy (String "")));
   assert_eq "not truthy nil" (Bool false) (Bool (sx_truthy Nil));
   assert_eq "not truthy false" (Bool false) (Bool (sx_truthy (Bool false)));
-  let l = { l_params = ["x"]; l_body = Symbol "x"; l_closure = Sx_types.make_env (); l_name = None; l_compiled = None; l_call_count = 0; l_uid = Sx_types.next_lambda_uid () } in
+  let l = { l_params = ["x"]; l_body = Symbol "x"; l_closure = Sx_types.make_env (); l_name = None; l_compiled = None } in
   assert_true "is_lambda" (Bool (Sx_types.is_lambda (Lambda l)));
   ignore (Sx_types.set_lambda_name (Lambda l) "my-fn");
   assert_eq "lambda name mutated" (String "my-fn") (lambda_name (Lambda l))
@@ -2899,6 +2899,9 @@ let run_spec_tests env test_files =
   load_module "parser.sx" hs_dir;
   load_module "compiler.sx" hs_dir;
   load_module "runtime.sx" hs_dir;
+  let hs_plugins_dir = Filename.concat hs_dir "plugins" in
+  load_module "worker.sx" hs_plugins_dir;
+  load_module "prolog.sx" hs_plugins_dir;
   load_module "integration.sx" hs_dir;
   load_module "htmx.sx" hs_dir;
   (* Override console-log to avoid str on circular mock DOM refs *)

hosts/ocaml/bin/sx_server.ml

@@ -703,6 +703,11 @@ let setup_evaluator_bridge env =
     | [expr; e] -> Sx_ref.eval_expr expr (Env (Sx_runtime.unwrap_env e))
     | [expr] -> Sx_ref.eval_expr expr (Env env)
     | _ -> raise (Eval_error "eval-expr: expected (expr env?)"));
+  (* eval-in-env: (env expr) → result.  Evaluates expr in the given env. *)
+  Sx_primitives.register "eval-in-env" (fun args ->
+    match args with
+    | [e; expr] -> Sx_ref.eval_expr expr e
+    | _ -> raise (Eval_error "eval-in-env: (env expr)"));
   bind "trampoline" (fun args ->
     match args with
     | [v] ->
@@ -764,7 +769,13 @@ let setup_evaluator_bridge env =
     | _ -> raise (Eval_error "register-special-form!: expected (name handler)"));
   ignore (env_bind env "*custom-special-forms*" Sx_ref.custom_special_forms);
   ignore (Sx_ref.register_special_form (String "<>") (NativeFn ("<>", fun args ->
-    List (List.map (fun a -> Sx_ref.eval_expr a (Env env)) args))))
+    List (List.map (fun a -> Sx_ref.eval_expr a (Env env)) args))));
+  (* current-env: special form — returns current lexical env as a first-class value *)
+  ignore (Sx_ref.register_special_form (String "current-env")
+    (NativeFn ("current-env", fun args ->
+      match args with
+      | [_arg_list; env_val] -> env_val
+      | _ -> Nil)))
 
 (* ---- Type predicates and introspection ---- *)
 let setup_introspection env =
@@ -950,7 +961,24 @@ let setup_env_operations env =
   bind "env-has?" (fun args -> match args with [e; String k] -> Bool (Sx_types.env_has (uw e) k) | [e; Keyword k] -> Bool (Sx_types.env_has (uw e) k) | _ -> raise (Eval_error "env-has?: expected env and string"));
   bind "env-bind!" (fun args -> match args with [e; String k; v] -> Sx_types.env_bind (uw e) k v | [e; Keyword k; v] -> Sx_types.env_bind (uw e) k v | _ -> raise (Eval_error "env-bind!: expected env, key, value"));
   bind "env-set!" (fun args -> match args with [e; String k; v] -> Sx_types.env_set (uw e) k v | [e; Keyword k; v] -> Sx_types.env_set (uw e) k v | _ -> raise (Eval_error "env-set!: expected env, key, value"));
-  bind "env-extend" (fun args -> match args with [e] -> Env (Sx_types.env_extend (uw e)) | _ -> raise (Eval_error "env-extend: expected env"));
+  bind "env-extend" (fun args ->
+    match args with
+    | e :: pairs ->
+      let child = Sx_types.env_extend (uw e) in
+      let rec go = function
+        | [] -> ()
+        | k :: v :: rest ->
+          ignore (Sx_types.env_bind child (Sx_runtime.value_to_str k) v); go rest
+        | [_] -> raise (Eval_error "env-extend: odd number of key-val pairs") in
+      go pairs; Env child
+    | _ -> raise (Eval_error "env-extend: expected env"));
+  bind "env-lookup" (fun args ->
+    match args with
+    | [e; key] ->
+      let k = Sx_runtime.value_to_str key in
+      let raw = uw e in
+      if Sx_types.env_has raw k then Sx_types.env_get raw k else Nil
+    | _ -> raise (Eval_error "env-lookup: (env key)"));
   bind "env-merge" (fun args -> match args with [a; b] -> Sx_runtime.env_merge a b | _ -> raise (Eval_error "env-merge: expected 2 envs"))
 
 (* ---- Strict mode (gradual type system support) ---- *)

hosts/ocaml/bootstrap.py

@@ -82,7 +82,10 @@ let cek_run_iterative state =
       s := cek_step !s
     done;
     (match cek_suspended_p !s with
-     | Bool true -> raise (Eval_error "IO suspension in non-IO context")
+     | Bool true ->
+       (match !_cek_io_suspend_hook with
+        | Some hook -> hook !s
+        | None -> raise (Eval_error "IO suspension in non-IO context"))
      | _ -> cek_value !s)
   with Eval_error msg ->
     _last_error_kont_ref := cek_kont !s;
@@ -308,6 +311,23 @@ def compile_spec_to_ml(spec_dir: str | None = None) -> str:
         output
     )
 
+    # Patch transpiled cek_run to invoke _cek_io_suspend_hook on suspension
+    # instead of unconditionally raising Eval_error. This is the fix for the
+    # tree-walk eval_expr path: sf_letrec init exprs / non-last body exprs,
+    # macro bodies, qq_expand, dynamic-wind / scope / provide bodies all use
+    # `trampoline (eval_expr ...)` and were swallowing CEK suspensions as
+    # "IO suspension in non-IO context" errors. With the hook, the suspension
+    # propagates as VmSuspended to the outer driver (browser callFn / server
+    # eval_expr_io). When the hook is unset (pure-CEK harness), the legacy
+    # error is preserved as the fallback.
+    output = re.sub(
+        r'\(raise \(Eval_error \(value_to_str \(String "IO suspension in non-IO context"\)\)\)\)',
+        '(match !_cek_io_suspend_hook with Some hook -> hook final | None -> '
+        '(raise (Eval_error (value_to_str (String "IO suspension in non-IO context")))))',
+        output,
+        count=1,
+    )
+
     return output
 
 

hosts/ocaml/bootstrap_vm.py

@@ -355,7 +355,9 @@ let vm_create_closure vm_val frame_val code_val =
   let f = unwrap_frame frame_val in
   let uv_count = match code_val with
     | Dict d -> (match Hashtbl.find_opt d "upvalue-count" with
-        | Some (Number n) -> int_of_float n | _ -> 0)
+        | Some (Integer n) -> n
+        | Some (Number n) -> int_of_float n
+        | _ -> 0)
     | _ -> 0
   in
   let upvalues = Array.init uv_count (fun _ ->

hosts/ocaml/browser/bundle.sh

@@ -75,6 +75,9 @@ cp "$ROOT/shared/sx/templates/tw.sx"        "$DIST/sx/"
 for f in tokenizer parser compiler runtime integration htmx; do
   cp "$ROOT/lib/hyperscript/$f.sx" "$DIST/sx/hs-$f.sx"
 done
+for f in worker prolog; do
+  cp "$ROOT/lib/hyperscript/plugins/$f.sx" "$DIST/sx/hs-$f.sx"
+done
 
 # Summary
 WASM_SIZE=$(du -sh "$DIST/sx_browser.bc.wasm.assets" | cut -f1)

hosts/ocaml/browser/compile-modules.js

@@ -85,6 +85,7 @@ const FILES = [
   'harness-web.sx', 'engine.sx', 'orchestration.sx',
   // Hyperscript modules — loaded on demand via transparent lazy loader
   'hs-tokenizer.sx', 'hs-parser.sx', 'hs-compiler.sx', 'hs-runtime.sx',
+  'hs-worker.sx', 'hs-prolog.sx',
   'hs-integration.sx', 'hs-htmx.sx',
   'boot.sx',
 ];
@@ -455,8 +456,10 @@ for (const file of FILES) {
         'hs-parser': ['hs-tokenizer'],
         'hs-compiler': ['hs-tokenizer', 'hs-parser'],
         'hs-runtime': ['hs-tokenizer', 'hs-parser', 'hs-compiler'],
-        'hs-integration': ['hs-tokenizer', 'hs-parser', 'hs-compiler', 'hs-runtime'],
-        'hs-htmx': ['hs-tokenizer', 'hs-parser', 'hs-compiler', 'hs-runtime', 'hs-integration'],
+        'hs-worker': ['hs-tokenizer', 'hs-parser'],
+        'hs-prolog': ['hs-tokenizer', 'hs-parser', 'hs-compiler', 'hs-runtime'],
+        'hs-integration': ['hs-tokenizer', 'hs-parser', 'hs-compiler', 'hs-runtime', 'hs-worker', 'hs-prolog'],
+        'hs-htmx': ['hs-tokenizer', 'hs-parser', 'hs-compiler', 'hs-runtime', 'hs-worker', 'hs-prolog', 'hs-integration'],
       };
       manifest[key] = {
         file: sxbcFile,
@@ -477,7 +480,7 @@ if (entryFile) {
   const lazyDeps = entryFile.deps.filter(d => LAZY_ENTRY_DEPS.has(d));
   // Hyperscript modules aren't define-library, so not auto-detected as deps.
   // Load them lazily after boot — eager loading breaks the boot sequence.
-  const HS_LAZY = ['hs-tokenizer', 'hs-parser', 'hs-compiler', 'hs-runtime', 'hs-integration', 'hs-htmx'];
+  const HS_LAZY = ['hs-tokenizer', 'hs-parser', 'hs-compiler', 'hs-runtime', 'hs-worker', 'hs-prolog', 'hs-integration', 'hs-htmx'];
   for (const m of HS_LAZY) {
     if (manifest[m] && !lazyDeps.includes(m)) lazyDeps.push(m);
   }

hosts/ocaml/browser/sx_browser.ml

@@ -344,6 +344,12 @@ let api_eval src_js =
     sync_env_to_vm ();
     return_via_side_channel (value_to_js result)
   with
+  | Sx_vm.VmSuspended _ ->
+    (* Top-level eval encountered an IO suspension propagated via the
+       cek_run hook (perform inside letrec init / non-last body / macro /
+       qq tree-walked path). K.eval doesn't drive resumption — surface as
+       a clear error so the caller knows to use callFn instead. *)
+    Js.Unsafe.inject (Js.string "Error: IO suspension in non-IO context (use callFn for IO-aware paths)")
   | Eval_error msg -> Js.Unsafe.inject (Js.string ("Error: " ^ msg))
   | Parse_error msg -> Js.Unsafe.inject (Js.string ("Parse error: " ^ msg))
 
@@ -371,6 +377,8 @@ let api_eval_vm src_js =
     ) _vm_globals;
     return_via_side_channel (value_to_js result)
   with
+  | Sx_vm.VmSuspended _ ->
+    Js.Unsafe.inject (Js.string "Error: IO suspension in non-IO context (use callFn for IO-aware paths)")
   | Eval_error msg -> Js.Unsafe.inject (Js.string ("Error: " ^ msg))
   | Parse_error msg -> Js.Unsafe.inject (Js.string ("Parse error: " ^ msg))
   | Not_found -> Js.Unsafe.inject (Js.string "Error: compile-module not loaded")
@@ -381,7 +389,10 @@ let api_eval_expr expr_js _env_js =
     let result = Sx_ref.eval_expr expr (Env global_env) in
     sync_env_to_vm ();
     return_via_side_channel (value_to_js result)
-  with Eval_error msg ->
+  with
+  | Sx_vm.VmSuspended _ ->
+    Js.Unsafe.inject (Js.string "Error: IO suspension in non-IO context (use callFn for IO-aware paths)")
+  | Eval_error msg ->
     Js.Unsafe.inject (Js.string ("Error: " ^ msg))
 
 let api_load src_js =
@@ -665,11 +676,7 @@ let () =
   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
+    | Number a, Number b -> a = b | String a, String b -> a = b
     | Symbol a, Symbol b -> a = b | Keyword a, Keyword b -> a = b
     | (List a | ListRef { contents = a }), (List b | ListRef { contents = b }) ->
       List.length a = List.length b && List.for_all2 deep_equal a b
@@ -708,8 +715,10 @@ let () =
         | List (Symbol "code" :: rest) ->
           let d = Hashtbl.create 8 in
           let rec parse_kv = function
-            | Keyword "arity" :: Number n :: rest -> Hashtbl.replace d "arity" (Number n); parse_kv rest
-            | Keyword "upvalue-count" :: Number n :: rest -> Hashtbl.replace d "upvalue-count" (Number n); parse_kv rest
+            | Keyword "arity" :: (Number _ as n) :: rest -> Hashtbl.replace d "arity" n; parse_kv rest
+            | Keyword "arity" :: (Integer _ as n) :: rest -> Hashtbl.replace d "arity" n; parse_kv rest
+            | Keyword "upvalue-count" :: (Number _ as n) :: rest -> Hashtbl.replace d "upvalue-count" n; parse_kv rest
+            | Keyword "upvalue-count" :: (Integer _ as n) :: rest -> Hashtbl.replace d "upvalue-count" n; parse_kv rest
             | Keyword "bytecode" :: List nums :: rest ->
               Hashtbl.replace d "bytecode" (List nums); parse_kv rest
             | Keyword "constants" :: List consts :: rest ->

hosts/ocaml/browser/test_letrec_resume.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+// Repro: letrec sibling bindings nil after perform/resume in browser kernel
+//
+// Bug: After a CEK IO suspension (perform / hs-wait) resumes in the
+// WASM browser kernel, calling a sibling letrec binding could return
+// nil, with the error surfaced as `[sx] resume: Not callable: nil`.
+//
+// Root cause: cek-run / cek_run_iterative raised
+// `"IO suspension in non-IO context"` when a tree-walked eval_expr
+// (sf_letrec init exprs / non-last body, macro body, qq unquote, scope
+// body, provide body, dynamic-wind) hit a perform. The CEK suspension
+// was created correctly but never propagated through the OCaml-side
+// _cek_io_suspend_hook, so the outer driver never saw VmSuspended.
+//
+// Fix: cek_run / cek_run_iterative now invoke _cek_io_suspend_hook on
+// suspension (raising VmSuspended for the outer driver). When the hook
+// is unset (pure-CEK harness), they fall back to the legacy error.
+//
+// This test exercises the WASM kernel through K.callFn — the path that
+// browser event handlers use. Suspension surfaces as a JS object with
+// {suspended, request, resume(result)} that the test drives synchronously.
+//
+// Companion: spec/tests/test-letrec-resume-treewalk.sx tests the
+// CEK-only path through the OCaml test runner.
+
+const path = require('path');
+const fs = require('fs');
+
+const KERNEL = path.join(__dirname, '..', '_build', 'default', 'browser', 'sx_browser.bc.js');
+if (!fs.existsSync(KERNEL)) {
+  console.error('FATAL: missing ' + KERNEL + ' — run `dune build` from hosts/ocaml first');
+  process.exit(2);
+}
+require(KERNEL);
+const K = globalThis.SxKernel;
+
+let passed = 0, failed = 0;
+const failures = [];
+
+function test(name, fn) {
+  try {
+    const r = fn();
+    if (r === true) {
+      passed++;
+      console.log('  PASS: ' + name);
+    } else {
+      failed++;
+      failures.push({ name, error: 'got ' + JSON.stringify(r) });
+      console.log('  FAIL: ' + name + ' — got ' + JSON.stringify(r));
+    }
+  } catch (e) {
+    failed++;
+    failures.push({ name, error: e.message || String(e) });
+    console.log('  FAIL: ' + name + ' — ' + (e.message || e));
+  }
+}
+
+function driveSync(result) {
+  while (result && typeof result === 'object' && result.suspended) {
+    result = result.resume(null);
+  }
+  return result;
+}
+
+function callExpr(src) {
+  K.eval('(define _t-fn (fn () ' + src + '))');
+  const fn = K.eval('_t-fn');
+  return driveSync(K.callFn(fn, []));
+}
+
+console.log('\n=== letrec + perform/resume regression tests ===\n');
+
+test('basic letrec without perform', () =>
+  callExpr('(letrec ((f (fn () "ok"))) (f))') === 'ok');
+
+test('callFn perform suspends and resumes with nil', () => {
+  K.eval('(define _t-perform (fn () (perform {:op "io"})))');
+  let r = K.callFn(K.eval('_t-perform'), []);
+  if (!r || !r.suspended) return 'no suspension: ' + JSON.stringify(r);
+  return r.resume(null) === null;
+});
+
+test('letrec, single binding, perform/resume', () =>
+  callExpr('(letrec ((f (fn () (perform {:op "io"})))) (f))') === null);
+
+test('letrec, 2 bindings, body calls sibling after suspended call', () =>
+  callExpr(`
+    (letrec
+      ((wait-then (fn () (do (perform {:op "io"}) "wait-done")))
+       (other-fn (fn () "other-result")))
+      (do (wait-then) (other-fn)))`) === 'other-result');
+
+test('letrec, suspending fn calls sibling after own perform', () =>
+  callExpr(`
+    (letrec
+      ((wait-and-call (fn () (do (perform {:op "io"}) (other-fn))))
+       (other-fn (fn () "from-sibling")))
+      (wait-and-call))`) === 'from-sibling');
+
+test('letrec, fn references sibling value after perform/resume', () =>
+  callExpr(`
+    (letrec
+      ((shared "shared-state")
+       (do-fn (fn () (do (perform {:op "io"}) shared))))
+      (do-fn))`) === 'shared-state');
+
+test('letrec, recursive self-call after perform (wait-boot pattern)', () => {
+  K.eval('(define _wb-c 0)');
+  K.eval('(set! _wb-c 0)');
+  return callExpr(`
+    (letrec ((wait-boot (fn ()
+                (do (perform {:op "io"})
+                    (if (>= _wb-c 1)
+                        "done"
+                        (do (set! _wb-c (+ 1 _wb-c))
+                            (wait-boot)))))))
+      (wait-boot))`) === 'done';
+});
+
+test('top-level define + perform + sibling call after resume', () => {
+  K.eval('(define do-suspend-x (fn () (do (perform {:op "io"}) (do-other-x))))');
+  K.eval('(define do-other-x (fn () "ok-from-other"))');
+  return callExpr('(do-suspend-x)') === 'ok-from-other';
+});
+
+test('letrec, two performs (sequential) then sibling call', () =>
+  callExpr(`
+    (letrec
+      ((wait-twice (fn () (do (perform {:op "io1"}) (perform {:op "io2"}) (other))))
+       (other (fn () "after-double")))
+      (wait-twice))`) === 'after-double');
+
+// === Tree-walk paths that previously raised "IO suspension in non-IO context" ===
+
+test('letrec init expr with perform — suspension propagates (no error)', () => {
+  let r;
+  try { r = callExpr('(letrec ((x (perform {:op "io"}))) "ok")'); }
+  catch (e) { return 'threw: ' + e.message; }
+  return r === null || r === 'ok';
+});
+
+test('letrec non-last body with perform — suspension propagates (no error)', () => {
+  let r;
+  try { r = callExpr('(letrec ((x 1)) (perform {:op "io"}) "after")'); }
+  catch (e) { return 'threw: ' + e.message; }
+  return r === null || r === 'after';
+});
+
+test('macro body with perform — suspension propagates', () => {
+  K.eval('(defmacro _m1 (form) (do (perform {:op "io"}) form))');
+  let r;
+  try { r = callExpr('(_m1 "macro-ok")'); }
+  catch (e) { return 'threw: ' + e.message; }
+  return r === 'macro-ok' || r === null;
+});
+
+test('quasiquote unquote with perform — suspension propagates', () => {
+  let r;
+  try { r = callExpr('(let ((y "yyy")) `(a ,(do (perform {:op "io"}) y) c))'); }
+  catch (e) { return 'threw: ' + e.message; }
+  return r !== undefined;
+});
+
+console.log('\n--- Results ---');
+console.log('passed: ' + passed);
+console.log('failed: ' + failed);
+if (failed > 0) {
+  console.log('\nFailures:');
+  failures.forEach(f => console.log('  - ' + f.name + ': ' + f.error));
+  process.exit(1);
+}
+process.exit(0);

hosts/ocaml/lib/sx_compiler.ml

@@ -200,7 +200,30 @@ and compile_qq_list em items scope =
 
 (* compile-call *)
 and compile_call em head args scope tail_p =
-  (let is_prim = (let _and = (prim_call "=" [(type_of (head)); (String "symbol")]) in if not (sx_truthy _and) then _and else (let name = (symbol_name (head)) in (let _and = (Bool (not (sx_truthy ((prim_call "=" [(get ((scope_resolve (scope) (name))) ((String "type"))); (String "local")]))))) in if not (sx_truthy _and) then _and else (let _and = (Bool (not (sx_truthy ((prim_call "=" [(get ((scope_resolve (scope) (name))) ((String "type"))); (String "upvalue")]))))) in if not (sx_truthy _and) then _and else (is_primitive (name)))))) in (if sx_truthy (is_prim) then (let name = (symbol_name (head)) in let argc = (len (args)) in let name_idx = (pool_add ((get (em) ((String "pool")))) (name)) in (let () = ignore ((List.iter (fun a -> ignore ((compile_expr (em) (a) (scope) ((Bool false))))) (sx_to_list args); Nil)) in (let () = ignore ((emit_op (em) ((Number 52.0)))) in (let () = ignore ((emit_u16 (em) (name_idx))) in (emit_byte (em) (argc)))))) else (let () = ignore ((compile_expr (em) (head) (scope) ((Bool false)))) in (let () = ignore ((List.iter (fun a -> ignore ((compile_expr (em) (a) (scope) ((Bool false))))) (sx_to_list args); Nil)) in (if sx_truthy (tail_p) then (let () = ignore ((emit_op (em) ((Number 49.0)))) in (emit_byte (em) ((len (args))))) else (let () = ignore ((emit_op (em) ((Number 48.0)))) in (emit_byte (em) ((len (args))))))))))
+  (let is_prim = (let _and = (prim_call "=" [(type_of (head)); (String "symbol")]) in if not (sx_truthy _and) then _and else (let name = (symbol_name (head)) in (let _and = (Bool (not (sx_truthy ((prim_call "=" [(get ((scope_resolve (scope) (name))) ((String "type"))); (String "local")]))))) in if not (sx_truthy _and) then _and else (let _and = (Bool (not (sx_truthy ((prim_call "=" [(get ((scope_resolve (scope) (name))) ((String "type"))); (String "upvalue")]))))) in if not (sx_truthy _and) then _and else (is_primitive (name)))))) in (if sx_truthy (is_prim) then (let name = (symbol_name (head)) in let argc = (len (args)) in
+    (* Specialized opcode for hot 2-arg / 1-arg primitives. *)
+    let specialized_op = (match name, argc with
+      | String "+",     Number 2.0 -> Some 160
+      | String "-",     Number 2.0 -> Some 161
+      | String "*",     Number 2.0 -> Some 162
+      | String "/",     Number 2.0 -> Some 163
+      | String "=",     Number 2.0 -> Some 164
+      | String "<",     Number 2.0 -> Some 165
+      | String ">",     Number 2.0 -> Some 166
+      | String "cons",  Number 2.0 -> Some 172
+      | String "not",   Number 1.0 -> Some 167
+      | String "len",   Number 1.0 -> Some 168
+      | String "first", Number 1.0 -> Some 169
+      | String "rest",  Number 1.0 -> Some 170
+      | _ -> None) in
+    (let () = ignore ((List.iter (fun a -> ignore ((compile_expr (em) (a) (scope) ((Bool false))))) (sx_to_list args); Nil)) in
+     (match specialized_op with
+      | Some op -> emit_op em (Number (float_of_int op))
+      | None ->
+        let name_idx = (pool_add ((get (em) ((String "pool")))) (name)) in
+        let () = ignore ((emit_op (em) ((Number 52.0)))) in
+        let () = ignore ((emit_u16 (em) (name_idx))) in
+        emit_byte (em) (argc)))) else (let () = ignore ((compile_expr (em) (head) (scope) ((Bool false)))) in (let () = ignore ((List.iter (fun a -> ignore ((compile_expr (em) (a) (scope) ((Bool false))))) (sx_to_list args); Nil)) in (if sx_truthy (tail_p) then (let () = ignore ((emit_op (em) ((Number 49.0)))) in (emit_byte (em) ((len (args))))) else (let () = ignore ((emit_op (em) ((Number 48.0)))) in (emit_byte (em) ((len (args))))))))))
 
 (* compile *)
 and compile expr =

hosts/ocaml/lib/sx_primitives.ml

@@ -582,22 +582,11 @@ let () =
       (List lb | ListRef { contents = lb }) ->
       List.length la = List.length lb &&
       List.for_all2 safe_eq la lb
-    (* Dict: __host_handle identity for DOM-wrapped dicts; otherwise
-       structural equality over keys + values. *)
+    (* Dict: check __host_handle for DOM node identity *)
     | Dict a, Dict b ->
       (match Hashtbl.find_opt a "__host_handle", Hashtbl.find_opt b "__host_handle" with
        | Some (Number ha), Some (Number hb) -> ha = hb
-       | Some _, _ | _, Some _ -> false
-       | None, None ->
-         Hashtbl.length a = Hashtbl.length b &&
-         (let eq = ref true in
-          Hashtbl.iter (fun k v ->
-            if !eq then
-              match Hashtbl.find_opt b k with
-              | Some v' -> if not (safe_eq v v') then eq := false
-              | None -> eq := false
-          ) a;
-          !eq))
+       | _ -> false)
     (* Records: same type + structurally equal fields *)
     | Record a, Record b ->
       a.r_type.rt_uid = b.r_type.rt_uid &&
@@ -677,7 +666,9 @@ let () =
   register "list?" (fun args ->
     match args with [List _] | [ListRef _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "list?: 1 arg"));
   register "dict?" (fun args ->
-    match args with [Dict _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "dict?: 1 arg"));
+    match args with [Dict _] -> Bool true | [AdtValue _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "dict?: 1 arg"));
+  register "adt?" (fun args ->
+    match args with [AdtValue _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "adt?: 1 arg"));
   register "symbol?" (fun args ->
     match args with [Symbol _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "symbol?: 1 arg"));
   register "keyword?" (fun args ->
@@ -1290,6 +1281,11 @@ let () =
     match args with [String msg] -> raise (Eval_error msg)
     | [a] -> raise (Eval_error (to_string a))
     | _ -> raise (Eval_error "host-error: 1 arg"));
+  register "host-warn" (fun args ->
+    match args with
+    | [String msg] -> prerr_endline msg; Nil
+    | [a] -> prerr_endline (to_string a); Nil
+    | _ -> raise (Eval_error "host-warn: 1 arg"));
   register "try-catch" (fun args ->
     match args with
     | [try_fn; catch_fn] ->
@@ -1611,6 +1607,32 @@ let () =
     match args with [StringBuffer buf] -> Integer (Buffer.length buf)
     | _ -> raise (Eval_error "string-buffer-length: expected (buffer)"));
 
+  (* Short aliases — same StringBuffer value, terser names for hot paths.
+     Append accepts any value: strings pass through, others get inspected/coerced. *)
+  register "make-buffer" (fun _ -> StringBuffer (Buffer.create 64));
+  register "buffer?" (fun args ->
+    match args with [StringBuffer _] -> Bool true | [_] -> Bool false
+    | _ -> raise (Eval_error "buffer?: expected 1 arg"));
+  register "buffer-append!" (fun args ->
+    match args with
+    | [StringBuffer buf; String s] -> Buffer.add_string buf s; Nil
+    | [StringBuffer buf; Integer n] -> Buffer.add_string buf (string_of_int n); Nil
+    | [StringBuffer buf; Number n] -> Buffer.add_string buf (Sx_types.format_number n); Nil
+    | [StringBuffer buf; Symbol s] -> Buffer.add_string buf s; Nil
+    | [StringBuffer buf; Char n] ->
+      Buffer.add_utf_8_uchar buf (Uchar.of_int n); Nil
+    | [StringBuffer buf; Nil] -> Buffer.add_string buf ""; Nil
+    | [StringBuffer buf; Bool true] -> Buffer.add_string buf "true"; Nil
+    | [StringBuffer buf; Bool false] -> Buffer.add_string buf "false"; Nil
+    | [StringBuffer buf; v] -> Buffer.add_string buf (inspect v); Nil
+    | _ -> raise (Eval_error "buffer-append!: expected (buffer value)"));
+  register "buffer->string" (fun args ->
+    match args with [StringBuffer buf] -> String (Buffer.contents buf)
+    | _ -> raise (Eval_error "buffer->string: expected (buffer)"));
+  register "buffer-length" (fun args ->
+    match args with [StringBuffer buf] -> Integer (Buffer.length buf)
+    | _ -> raise (Eval_error "buffer-length: expected (buffer)"));
+
   (* Capability-based sandboxing — gate IO operations *)
   let cap_stack : string list ref = ref [] in
   register "with-capabilities" (fun args ->
@@ -3102,6 +3124,223 @@ let () =
     | [String pat] -> List (List.map (fun s -> String s) (glob_paths pat))
     | _ -> raise (Eval_error "file-glob: (pattern)"));
 
+  (* === Channels (random-access + blocking control) === *)
+  let channel_table : (string, Unix.file_descr * string * bool ref * bool ref) Hashtbl.t = Hashtbl.create 16 in
+  let channel_next_id = ref 0 in
+  let parse_open_mode mode =
+    match mode with
+    | "r"  -> [Unix.O_RDONLY]
+    | "w"  -> [Unix.O_WRONLY; Unix.O_CREAT; Unix.O_TRUNC]
+    | "a"  -> [Unix.O_WRONLY; Unix.O_CREAT; Unix.O_APPEND]
+    | "r+" -> [Unix.O_RDWR]
+    | "w+" -> [Unix.O_RDWR; Unix.O_CREAT; Unix.O_TRUNC]
+    | "a+" -> [Unix.O_RDWR; Unix.O_CREAT; Unix.O_APPEND]
+    | _ -> raise (Eval_error ("channel-open: invalid mode " ^ mode))
+  in
+  let chan_get name =
+    match Hashtbl.find_opt channel_table name with
+    | Some c -> c
+    | None -> raise (Eval_error ("channel: no such channel " ^ name))
+  in
+  register "channel-open" (fun args ->
+    match args with
+    | [String path; String mode] ->
+      (try
+        let fd = Unix.openfile path (parse_open_mode mode) 0o644 in
+        let id = !channel_next_id in
+        incr channel_next_id;
+        let name = Printf.sprintf "file%d" id in
+        Hashtbl.replace channel_table name (fd, mode, ref false, ref true);
+        String name
+      with Unix.Unix_error (e, _, _) -> raise (Eval_error ("channel-open: " ^ Unix.error_message e)))
+    | _ -> raise (Eval_error "channel-open: (path mode)"));
+
+  register "channel-close" (fun args ->
+    match args with
+    | [String name] ->
+      let (fd, _, _, _) = chan_get name in
+      (try Unix.close fd with _ -> ());
+      Hashtbl.remove channel_table name;
+      Nil
+    | _ -> raise (Eval_error "channel-close: (channel)"));
+
+  register "channel-read" (fun args ->
+    let (name, max_n) = match args with
+      | [String n] -> (n, -1)
+      | [String n; Integer m] -> (n, m)
+      | [String n; Number m] -> (n, int_of_float m)
+      | _ -> raise (Eval_error "channel-read: (channel ?n?)")
+    in
+    let (fd, _, eof, _) = chan_get name in
+    let chunk = 8192 in
+    let buf = Bytes.create chunk in
+    let buffer = Buffer.create chunk in
+    let total = ref 0 in
+    let stop = ref false in
+    while not !stop do
+      let want = if max_n < 0 then chunk else min chunk (max_n - !total) in
+      if want <= 0 then stop := true
+      else begin
+        try
+          let r = Unix.read fd buf 0 want in
+          if r = 0 then begin eof := true; stop := true end
+          else begin
+            Buffer.add_subbytes buffer buf 0 r;
+            total := !total + r
+          end
+        with
+        | Unix.Unix_error (Unix.EAGAIN, _, _)
+        | Unix.Unix_error (Unix.EWOULDBLOCK, _, _) -> stop := true
+      end
+    done;
+    String (Buffer.contents buffer));
+
+  register "channel-read-line" (fun args ->
+    match args with
+    | [String name] ->
+      let (fd, _, eof, _) = chan_get name in
+      let buf = Buffer.create 80 in
+      let one = Bytes.create 1 in
+      let got_data = ref false in
+      let stop = ref false in
+      while not !stop do
+        try
+          let r = Unix.read fd one 0 1 in
+          if r = 0 then begin eof := true; stop := true end
+          else begin
+            got_data := true;
+            let c = Bytes.get one 0 in
+            if c = '\n' then stop := true
+            else Buffer.add_char buf c
+          end
+        with
+        | Unix.Unix_error (Unix.EAGAIN, _, _)
+        | Unix.Unix_error (Unix.EWOULDBLOCK, _, _) -> stop := true
+      done;
+      if !got_data then String (Buffer.contents buf) else Nil
+    | _ -> raise (Eval_error "channel-read-line: (channel)"));
+
+  register "channel-write" (fun args ->
+    match args with
+    | [String name; String s] ->
+      let (fd, _, _, _) = chan_get name in
+      let b = Bytes.of_string s in
+      let n = Bytes.length b in
+      let written = ref 0 in
+      while !written < n do
+        (try
+          let w = Unix.write fd b !written (n - !written) in
+          written := !written + w
+        with
+        | Unix.Unix_error (Unix.EAGAIN, _, _)
+        | Unix.Unix_error (Unix.EWOULDBLOCK, _, _) ->
+          (* short write — let caller retry *)
+          written := n)
+      done;
+      Nil
+    | _ -> raise (Eval_error "channel-write: (channel string)"));
+
+  register "channel-flush" (fun args ->
+    match args with
+    | [String name] -> let _ = chan_get name in Nil  (* no userspace buffer *)
+    | _ -> raise (Eval_error "channel-flush: (channel)"));
+
+  register "channel-seek" (fun args ->
+    let (name, offset, whence) = match args with
+      | [String n; Integer o] -> (n, o, "start")
+      | [String n; Number o] -> (n, int_of_float o, "start")
+      | [String n; Integer o; String w] -> (n, o, w)
+      | [String n; Number o; String w] -> (n, int_of_float o, w)
+      | _ -> raise (Eval_error "channel-seek: (channel offset ?whence?)")
+    in
+    let (fd, _, eof, _) = chan_get name in
+    let cmd = match whence with
+      | "start" -> Unix.SEEK_SET
+      | "current" -> Unix.SEEK_CUR
+      | "end" -> Unix.SEEK_END
+      | _ -> raise (Eval_error ("channel-seek: invalid whence " ^ whence))
+    in
+    let _ = Unix.lseek fd offset cmd in
+    eof := false;
+    Nil);
+
+  register "channel-tell" (fun args ->
+    match args with
+    | [String name] ->
+      let (fd, _, _, _) = chan_get name in
+      Integer (Unix.lseek fd 0 Unix.SEEK_CUR)
+    | _ -> raise (Eval_error "channel-tell: (channel)"));
+
+  register "channel-eof?" (fun args ->
+    match args with
+    | [String name] ->
+      let (_, _, eof, _) = chan_get name in
+      Bool !eof
+    | _ -> raise (Eval_error "channel-eof?: (channel)"));
+
+  register "channel-blocking?" (fun args ->
+    match args with
+    | [String name] ->
+      let (_, _, _, blocking) = chan_get name in
+      Bool !blocking
+    | _ -> raise (Eval_error "channel-blocking?: (channel)"));
+
+  register "channel-set-blocking!" (fun args ->
+    match args with
+    | [String name; Bool b] ->
+      let (fd, _, _, blocking) = chan_get name in
+      blocking := b;
+      (try
+        if b then Unix.clear_nonblock fd
+        else Unix.set_nonblock fd
+      with _ -> ());
+      Nil
+    | _ -> raise (Eval_error "channel-set-blocking!: (channel bool)"));
+
+  (* io-select-channels: (read-list write-list timeout-ms) → {:readable [...] :writable [...]}
+     timeout-ms < 0 → block indefinitely; 0 → poll. Returns ready channel names. *)
+  register "io-select-channels" (fun args ->
+    let to_ms v = match v with
+      | Integer n -> n
+      | Number n -> int_of_float n
+      | _ -> raise (Eval_error "io-select-channels: timeout must be a number")
+    in
+    let to_list v = match v with
+      | List xs | ListRef { contents = xs } -> xs
+      | Nil -> []
+      | _ -> raise (Eval_error "io-select-channels: expected list")
+    in
+    let chan_name_of v = match v with
+      | String s -> s
+      | _ -> raise (Eval_error "io-select-channels: channel must be a string")
+    in
+    let (read_list, write_list, timeout_ms) = match args with
+      | [r; w; t] -> (to_list r, to_list w, to_ms t)
+      | _ -> raise (Eval_error "io-select-channels: (read-list write-list timeout-ms)")
+    in
+    let read_pairs = List.map (fun v ->
+      let name = chan_name_of v in
+      let (fd, _, _, _) = chan_get name in (name, fd)) read_list in
+    let write_pairs = List.map (fun v ->
+      let name = chan_name_of v in
+      let (fd, _, _, _) = chan_get name in (name, fd)) write_list in
+    let read_fds = List.map snd read_pairs in
+    let write_fds = List.map snd write_pairs in
+    let timeout = if timeout_ms < 0 then -1.0 else float_of_int timeout_ms /. 1000.0 in
+    let (ready_r, ready_w, _) =
+      try Unix.select read_fds write_fds [] timeout
+      with Unix.Unix_error (Unix.EINTR, _, _) -> ([], [], [])
+    in
+    let names_of pairs ready =
+      List.filter_map (fun (n, fd) ->
+        if List.exists (fun rfd -> rfd = fd) ready then Some (String n) else None
+      ) pairs
+    in
+    let d = Hashtbl.create 2 in
+    Hashtbl.replace d "readable" (List (names_of read_pairs ready_r));
+    Hashtbl.replace d "writable" (List (names_of write_pairs ready_w));
+    Dict d);
+
   (* === Clock === *)
   register "clock-seconds" (fun args ->
     match args with
@@ -3151,40 +3390,34 @@ let () =
       String (Buffer.contents buf)
     | _ -> raise (Eval_error "clock-format: (seconds [format])"));
 
-  (* JIT cache control & observability — backed by refs in sx_types.ml to
-     avoid creating a sx_primitives → sx_vm dependency cycle. sx_vm reads
-     these refs to decide when to JIT. *)
-  register "jit-stats" (fun _args ->
-    let d = Hashtbl.create 8 in
-    Hashtbl.replace d "threshold"        (Number (float_of_int !Sx_types.jit_threshold));
-    Hashtbl.replace d "budget"           (Number (float_of_int !Sx_types.jit_budget));
-    Hashtbl.replace d "cache-size"       (Number (float_of_int (Sx_types.jit_cache_size ())));
-    Hashtbl.replace d "compiled"         (Number (float_of_int !Sx_types.jit_compiled_count));
-    Hashtbl.replace d "compile-failed"   (Number (float_of_int !Sx_types.jit_skipped_count));
-    Hashtbl.replace d "below-threshold"  (Number (float_of_int !Sx_types.jit_threshold_skipped_count));
-    Hashtbl.replace d "evicted"          (Number (float_of_int !Sx_types.jit_evicted_count));
-    Dict d);
-  register "jit-set-threshold!" (fun args ->
+  (* === Env-as-value (Phase 4) === *)
+
+  (* env-lookup: (env key) → value or nil.  Works on Env, Dict, or Nil. *)
+  register "env-lookup" (fun args ->
+    let unwrap = function
+      | Env e -> e
+      | Nil -> make_env ()
+      | _ -> raise (Eval_error "env-lookup: first arg must be an environment") in
     match args with
-    | [Number n] -> Sx_types.jit_threshold := int_of_float n; Nil
-    | [Integer n] -> Sx_types.jit_threshold := n; Nil
-    | _ -> raise (Eval_error "jit-set-threshold!: (n) where n is integer"));
-  register "jit-set-budget!" (fun args ->
+    | [env_val; key] ->
+      let e = unwrap env_val in
+      let k = value_to_string key in
+      if env_has e k then env_get e k else Nil
+    | _ -> raise (Eval_error "env-lookup: (env key)"));
+
+  (* env-extend: (env [key val ...]) → new child env with optional bindings. *)
+  register "env-extend" (fun args ->
     match args with
-    | [Number n] -> Sx_types.jit_budget := int_of_float n; Nil
-    | [Integer n] -> Sx_types.jit_budget := n; Nil
-    | _ -> raise (Eval_error "jit-set-budget!: (n) where n is integer"));
-  register "jit-reset-cache!" (fun _args ->
-    (* Phase 3 manual cache reset — clear all compiled VmClosures.
-       Hot paths will re-JIT on next call (after re-hitting threshold). *)
-    Queue.iter (fun (_, v) ->
-      match v with Lambda l -> l.l_compiled <- None | _ -> ()
-    ) Sx_types.jit_cache_queue;
-    Queue.clear Sx_types.jit_cache_queue;
-    Nil);
-  register "jit-reset-counters!" (fun _args ->
-    Sx_types.jit_compiled_count := 0;
-    Sx_types.jit_skipped_count := 0;
-    Sx_types.jit_threshold_skipped_count := 0;
-    Sx_types.jit_evicted_count := 0;
-    Nil)
+    | [] -> raise (Eval_error "env-extend: requires at least one arg")
+    | env_val :: pairs ->
+      let parent_env = match env_val with
+        | Env e -> e
+        | Nil -> make_env ()
+        | _ -> raise (Eval_error "env-extend: first arg must be an environment") in
+      let child = env_extend parent_env in
+      let rec add_bindings = function
+        | [] -> ()
+        | k :: v :: rest -> ignore (env_bind child (value_to_string k) v); add_bindings rest
+        | [_] -> raise (Eval_error "env-extend: odd number of key-val pairs") in
+      add_bindings pairs;
+      Env child)

hosts/ocaml/lib/sx_ref.ml

@@ -614,7 +614,7 @@ and cek_step_loop state =
 
 (* cek-run *)
 and cek_run state =
-  (let final = (cek_step_loop (state)) in (if sx_truthy ((cek_suspended_p (final))) then (raise (Eval_error (value_to_str (String "IO suspension in non-IO context")))) else (cek_value (final))))
+  (let final = (cek_step_loop (state)) in (if sx_truthy ((cek_suspended_p (final))) then (match !_cek_io_suspend_hook with Some hook -> hook final | None -> (raise (Eval_error (value_to_str (String "IO suspension in non-IO context"))))) else (cek_value (final))))
 
 (* cek-resume *)
 and cek_resume suspended_state result' =
@@ -759,7 +759,78 @@ and match_pattern pattern value env =
 
 (* step-sf-match *)
 and step_sf_match args env kont =
-  (let val' = (trampoline ((eval_expr ((first (args))) (env)))) in let clauses = (rest (args)) in (let result' = (match_find_clause (val') (clauses) (env)) in (if sx_truthy ((is_nil (result'))) then (make_cek_value ((String (sx_str [(String "match: no clause matched "); (inspect (val'))]))) (env) ((kont_push ((make_raise_eval_frame (env) ((Bool false)))) (kont)))) else (make_cek_state ((nth (result') ((Number 1.0)))) ((first (result'))) (kont)))))
+  (let val' = (trampoline ((eval_expr ((first (args))) (env)))) in let clauses = (rest (args)) in (let () = ignore (match_check_exhaustiveness val' clauses env) in (let result' = (match_find_clause (val') (clauses) (env)) in (if sx_truthy ((is_nil (result'))) then (make_cek_value ((String (sx_str [(String "match: no clause matched "); (inspect (val'))]))) (env) ((kont_push ((make_raise_eval_frame (env) ((Bool false)))) (kont)))) else (make_cek_state ((nth (result') ((Number 1.0)))) ((first (result'))) (kont))))))
+
+(* match-check-exhaustiveness — Step 8 hand-patched into sx_ref.ml *)
+and match_check_exhaustiveness val' clauses env =
+  let is_else_pat p =
+    match p with
+    | Symbol "_" | Symbol "else" -> true
+    | Keyword "else" -> true
+    | _ -> false
+  in
+  let clause_is_else c =
+    match c with
+    | List (p :: _) -> is_else_pat p
+    | _ -> false
+  in
+  let clause_ctor_name c =
+    match c with
+    | List (List (Symbol n :: _) :: _) -> Some n
+    | _ -> None
+  in
+  let type_name_opt = match val' with
+    | AdtValue a -> Some a.av_type
+    | Dict d ->
+      (match Hashtbl.find_opt d "_adt" with
+       | Some (Bool true) ->
+         (match Hashtbl.find_opt d "_type" with
+          | Some (String s) -> Some s
+          | _ -> None)
+       | _ -> None)
+    | _ -> None
+  in
+  match type_name_opt with
+  | None -> Nil
+  | Some type_name ->
+       if not (sx_truthy (env_has env (String "*adt-registry*"))) then Nil
+       else
+         let registry = env_get env (String "*adt-registry*") in
+         let registered = match registry with
+           | Dict r ->
+             (match Hashtbl.find_opt r type_name with
+              | Some (List ctors) -> Some ctors
+              | _ -> None)
+           | _ -> None in
+         (match registered with
+          | None -> Nil
+          | Some ctor_vals ->
+            let clauses_list = match clauses with List xs -> xs | _ -> [] in
+            if List.exists clause_is_else clauses_list then Nil
+            else
+              let clause_ctors = List.filter_map clause_ctor_name clauses_list in
+              let registered_names = List.filter_map (function
+                | String s -> Some s | _ -> None) ctor_vals in
+              let missing = List.filter (fun c -> not (List.mem c clause_ctors)) registered_names in
+              if missing = [] then Nil
+              else begin
+                if not (sx_truthy (env_has env (String "*adt-warned*"))) then
+                  ignore (env_bind env (String "*adt-warned*") (Dict (Hashtbl.create 4)));
+                let warned = env_get env (String "*adt-warned*") in
+                let key = type_name ^ "|" ^ String.concat "," missing in
+                let already = match warned with
+                  | Dict w -> (match Hashtbl.find_opt w key with Some (Bool true) -> true | _ -> false)
+                  | _ -> false in
+                if already then Nil
+                else begin
+                  (match warned with
+                   | Dict w -> Hashtbl.replace w key (Bool true)
+                   | _ -> ());
+                  let msg = "[sx] match: non-exhaustive — " ^ type_name ^ ": missing " ^ String.concat ", " missing in
+                  ignore (host_warn (String msg));
+                  Nil
+                end
+              end)
 
 (* step-sf-handler-bind *)
 and step_sf_handler_bind args env kont =
@@ -981,7 +1052,14 @@ let cek_run_iterative state =
       s := cek_step !s
     done;
     (match cek_suspended_p !s with
-     | Bool true -> raise (Eval_error "IO suspension in non-IO context")
+     | Bool true ->
+       (* Propagate suspension via the OCaml-side hook so it converts to
+          VmSuspended and flows to the outer driver (value_to_js / resume
+          callback). Without the hook (pure CEK harness), keep the legacy
+          error so test runners surface the misuse. *)
+       (match !_cek_io_suspend_hook with
+        | Some hook -> hook !s
+        | None -> raise (Eval_error "IO suspension in non-IO context"))
      | _ -> cek_value !s)
   with Eval_error msg ->
     _last_error_kont_ref := cek_kont !s;
@@ -1054,8 +1132,7 @@ let sf_define_type args env_val =
       (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))
+        | AdtValue a -> Bool (a.av_type = type_name)
         | _ -> Bool false)
       | _ -> Bool false)));
   List.iter (fun spec ->
@@ -1069,21 +1146,18 @@ let sf_define_type args env_val =
           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));
+          else
+            AdtValue {
+              av_type = type_name;
+              av_ctor = cn;
+              av_fields = Array.of_list ctor_args;
+            }));
       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))
+            | AdtValue a -> Bool (a.av_ctor = cn)
             | _ -> Bool false)
           | _ -> Bool false)));
       List.iteri (fun idx fname ->
@@ -1092,13 +1166,10 @@ let sf_define_type args env_val =
             (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")))
+              | AdtValue a ->
+                if idx < Array.length a.av_fields then a.av_fields.(idx)
+                else raise (Eval_error (cn ^ "-" ^ fname ^ ": index out of bounds"))
+              | _ -> raise (Eval_error (cn ^ "-" ^ fname ^ ": not an ADT")))
             | _ -> raise (Eval_error (cn ^ "-" ^ fname ^ ": expected 1 arg")))))
       ) field_names
     | _ -> ())

hosts/ocaml/lib/sx_runtime.ml

@@ -6,11 +6,72 @@
 
 open Sx_types
 
-(** Call a registered primitive by name. *)
+(** Fast path equality — same as Sx_primitives.safe_eq for the common cases
+    that show up in hot dispatch (string vs string, etc). Falls through to
+    the registered "=" primitive for complex cases. *)
+let rec _fast_eq a b =
+  if a == b then true
+  else match a, b with
+  | String x, String y -> x = y
+  | 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
+  | Bool x, Bool y -> x = y
+  | Nil, Nil -> true
+  | Symbol x, Symbol y -> x = y
+  | Keyword x, Keyword y -> x = y
+  | List la, List lb ->
+    (try List.for_all2 _fast_eq la lb with Invalid_argument _ -> false)
+  | _ -> false
+
+(** Call a registered primitive by name.
+    Fast path for hot dispatch primitives ([=], [<], [>], [<=], [>=], [empty?],
+    [first], [rest], [len]) skips the Hashtbl lookup entirely — these are
+    called millions of times in the CEK [step_continue]/[step_eval] dispatch. *)
 let prim_call name args =
-  match Hashtbl.find_opt Sx_primitives.primitives name with
-  | Some f -> f args
-  | None -> raise (Eval_error ("Unknown primitive: " ^ name))
+  (* Hot path: most-frequently-called primitives by step_continue dispatch *)
+  match name, args with
+  | "=", [a; b] -> Bool (_fast_eq a b)
+  | "empty?", [List []] -> Bool true
+  | "empty?", [List _] -> Bool false
+  | "empty?", [ListRef { contents = [] }] -> Bool true
+  | "empty?", [ListRef _] -> Bool false
+  | "empty?", [Nil] -> Bool true
+  | "first", [List (x :: _)] -> x
+  | "first", [List []] -> Nil
+  | "first", [ListRef { contents = (x :: _) }] -> x
+  | "first", [ListRef _] -> Nil
+  | "first", [Nil] -> Nil
+  | "rest", [List (_ :: xs)] -> List xs
+  | "rest", [List []] -> List []
+  | "rest", [ListRef { contents = (_ :: xs) }] -> List xs
+  | "rest", [ListRef _] -> List []
+  | "rest", [Nil] -> List []
+  | "len", [List l] -> Integer (List.length l)
+  | "len", [ListRef r] -> Integer (List.length !r)
+  | "len", [String s] -> Integer (String.length s)
+  | "len", [Nil] -> Integer 0
+  | "<", [Integer x; Integer y] -> Bool (x < y)
+  | "<", [Number x; Number y] -> Bool (x < y)
+  | "<", [Integer x; Number y] -> Bool (float_of_int x < y)
+  | "<", [Number x; Integer y] -> Bool (x < float_of_int y)
+  | ">", [Integer x; Integer y] -> Bool (x > y)
+  | ">", [Number x; Number y] -> Bool (x > y)
+  | ">", [Integer x; Number y] -> Bool (float_of_int x > y)
+  | ">", [Number x; Integer y] -> Bool (x > float_of_int y)
+  | "<=", [Integer x; Integer y] -> Bool (x <= y)
+  | "<=", [Number x; Number y] -> Bool (x <= y)
+  | "<=", [Integer x; Number y] -> Bool (float_of_int x <= y)
+  | "<=", [Number x; Integer y] -> Bool (x <= float_of_int y)
+  | ">=", [Integer x; Integer y] -> Bool (x >= y)
+  | ">=", [Number x; Number y] -> Bool (x >= y)
+  | ">=", [Integer x; Number y] -> Bool (float_of_int x >= y)
+  | ">=", [Number x; Integer y] -> Bool (x >= float_of_int y)
+  | _ ->
+    match Hashtbl.find_opt Sx_primitives.primitives name with
+    | Some f -> f args
+    | None -> raise (Eval_error ("Unknown primitive: " ^ name))
 
 (** Convert any SX value to an OCaml string (internal). *)
 let value_to_str = function
@@ -209,6 +270,13 @@ let get_val container key =
      | _ -> Nil)
   | Dict d, String k -> dict_get d k
   | Dict d, Keyword k -> dict_get d k
+  | AdtValue a, String k | AdtValue a, Keyword k ->
+    (match k with
+     | "_adt"    -> Bool true
+     | "_type"   -> String a.av_type
+     | "_ctor"   -> String a.av_ctor
+     | "_fields" -> List (Array.to_list a.av_fields)
+     | _         -> Nil)
   | (List l | ListRef { contents = l }), Number n ->
     (try List.nth l (int_of_float n) with _ -> Nil)
   | (List l | ListRef { contents = l }), Integer n ->
@@ -404,6 +472,10 @@ let callcc_continuation_winders_len v = match v with
 let host_error msg =
   raise (Eval_error (value_to_str msg))
 
+let host_warn msg =
+  prerr_endline (value_to_str msg);
+  Nil
+
 let dynamic_wind_call before body after _env =
   ignore (sx_call before []);
   let result = sx_call body [] in
@@ -539,3 +611,4 @@ let jit_try_call f args =
       (match hook f arg_list with Some result -> incr _jit_hit; result | None -> incr _jit_miss; _jit_skip_sentinel)
     | _ -> incr _jit_skip; _jit_skip_sentinel
 
+

hosts/ocaml/lib/sx_types.ml

@@ -82,6 +82,16 @@ and value =
   | 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. *)
+  | AdtValue of adt_value  (** Native algebraic data type instance — opaque sum type. *)
+
+(** Algebraic data type instance — produced by [define-type] constructors.
+    [av_type] is the type name (e.g. "Maybe"), [av_ctor] is the constructor
+    name (e.g. "Just"), [av_fields] are the positional field values. *)
+and adt_value = {
+  av_type   : string;
+  av_ctor   : string;
+  av_fields : value array;
+}
 
 (** String input port: source string + mutable cursor position. *)
 and sx_port_kind =
@@ -128,8 +138,6 @@ and lambda = {
   l_closure : env;
   mutable l_name : string option;
   mutable l_compiled : vm_closure option;  (** Lazy JIT cache *)
-  mutable l_call_count : int;              (** Tiered-compilation counter — JIT after threshold calls *)
-  l_uid : int;                             (** Unique identity for LRU cache tracking *)
 }
 
 and component = {
@@ -436,60 +444,12 @@ let unwrap_env_val = function
   | Env e -> e
   | _ -> raise (Eval_error "make_lambda: expected env for closure")
 
-(* Lambda UID — minted on construction, used as LRU cache key (Phase 2). *)
-let lambda_uid_counter = ref 0
-let next_lambda_uid () = incr lambda_uid_counter; !lambda_uid_counter
-
 let make_lambda params body closure =
   let ps = match params with
     | List items -> List.map value_to_string items
     | _ -> value_to_string_list params
   in
-  Lambda { l_params = ps; l_body = body; l_closure = unwrap_env_val closure; l_name = None; l_compiled = None; l_call_count = 0; l_uid = next_lambda_uid () }
-
-(** {1 JIT cache control}
-
-    Tiered compilation: only JIT a lambda after it's been called [jit_threshold]
-    times. This filters out one-shot lambdas (test harness, dynamic eval, REPLs)
-    so they never enter the JIT cache. Counters are exposed to SX as [(jit-stats)].
-
-    These live here (in sx_types) rather than sx_vm so [sx_primitives] can read
-    them without creating a sx_primitives → sx_vm dependency cycle. *)
-let jit_threshold = ref 4
-let jit_compiled_count = ref 0
-let jit_skipped_count = ref 0
-let jit_threshold_skipped_count = ref 0
-
-(** {2 JIT cache LRU eviction — Phase 2}
-
-    Once a lambda crosses the threshold, its [l_compiled] slot is filled.
-    To bound memory under unbounded compilation pressure, track all live
-    compiled lambdas in FIFO order, and evict from the head when the count
-    exceeds [jit_budget].
-
-    [lambda_uid_counter] mints unique identities on lambda creation; the
-    LRU queue holds these IDs paired with a back-reference to the lambda
-    so we can clear its [l_compiled] slot on eviction.
-
-    Budget of 0 = no cache (disable JIT entirely).
-    Budget of [max_int] = unbounded (legacy behaviour). Default 5000 is
-    a generous ceiling for any realistic page; the test harness compiles
-    ~3000 distinct one-shot lambdas in a full run but tiered compilation
-    (Phase 1) means most never enter the cache, so steady-state count
-    stays small.
-
-    [lambda_uid_counter] and [next_lambda_uid] are defined above
-    [make_lambda] (which uses them on construction). *)
-let jit_budget = ref 5000
-let jit_evicted_count = ref 0
-
-(** Live compiled lambdas in FIFO order — front is oldest, back is newest.
-    Each entry is (uid, lambda); on eviction we clear lambda.l_compiled and
-    drop from the queue. Using a mutable Queue rather than a hand-rolled
-    linked list because eviction is amortised O(1) at the head and inserts
-    are O(1) at the tail. *)
-let jit_cache_queue : (int * value) Queue.t = Queue.create ()
-let jit_cache_size () = Queue.length jit_cache_queue
+  Lambda { l_params = ps; l_body = body; l_closure = unwrap_env_val closure; l_name = None; l_compiled = None }
 
 let make_component name params has_children body closure affinity =
   let n = value_to_string name in
@@ -570,6 +530,7 @@ let type_of = function
   | SxSet _          -> "set"
   | SxRegexp _       -> "regexp"
   | SxBytevector _   -> "bytevector"
+  | AdtValue a       -> a.av_type
 
 let is_nil = function Nil -> true | _ -> false
 let is_lambda = function Lambda _ -> true | _ -> false
@@ -856,14 +817,15 @@ let dict_vals (d : dict) =
 
 (** {1 Value display} *)
 
-let rec inspect = function
-  | Nil -> "nil"
-  | Bool true -> "true"
-  | Bool false -> "false"
-  | Integer n -> string_of_int n
-  | Number n -> format_number n
+(* Single shared buffer for the entire inspect recursion — eliminates
+   the per-level [String.concat (List.map inspect ...)] allocation. *)
+let rec inspect_into buf = function
+  | Nil -> Buffer.add_string buf "nil"
+  | Bool true -> Buffer.add_string buf "true"
+  | Bool false -> Buffer.add_string buf "false"
+  | Integer n -> Buffer.add_string buf (string_of_int n)
+  | Number n -> Buffer.add_string buf (format_number n)
   | String s ->
-    let buf = Buffer.create (String.length s + 2) in
     Buffer.add_char buf '"';
     String.iter (function
       | '"'  -> Buffer.add_string buf "\\\""
@@ -872,66 +834,129 @@ let rec inspect = function
       | '\r' -> Buffer.add_string buf "\\r"
       | '\t' -> Buffer.add_string buf "\\t"
       | c    -> Buffer.add_char buf c) s;
-    Buffer.add_char buf '"';
-    Buffer.contents buf
-  | Symbol s -> s
-  | Keyword k -> ":" ^ k
+    Buffer.add_char buf '"'
+  | Symbol s -> Buffer.add_string buf s
+  | Keyword k -> Buffer.add_char buf ':'; Buffer.add_string buf k
   | List items | ListRef { contents = items } ->
-    "(" ^ String.concat " " (List.map inspect items) ^ ")"
+    Buffer.add_char buf '(';
+    (match items with
+     | [] -> ()
+     | x :: rest ->
+       inspect_into buf x;
+       List.iter (fun v -> Buffer.add_char buf ' '; inspect_into buf v) rest);
+    Buffer.add_char buf ')'
   | Dict d ->
-    let pairs = Hashtbl.fold (fun k v acc ->
-      (Printf.sprintf ":%s %s" k (inspect v)) :: acc) d [] in
-    "{" ^ String.concat " " pairs ^ "}"
+    Buffer.add_char buf '{';
+    let first = ref true in
+    Hashtbl.iter (fun k v ->
+      if !first then first := false else Buffer.add_char buf ' ';
+      Buffer.add_char buf ':'; Buffer.add_string buf k;
+      Buffer.add_char buf ' '; inspect_into buf v) d;
+    Buffer.add_char buf '}'
   | Lambda l ->
     let tag = match l.l_name with Some n -> n | None -> "lambda" in
-    Printf.sprintf "<%s(%s)>" tag (String.concat ", " l.l_params)
+    Buffer.add_char buf '<'; Buffer.add_string buf tag;
+    Buffer.add_char buf '('; Buffer.add_string buf (String.concat ", " l.l_params);
+    Buffer.add_string buf ")>"
   | Component c ->
-    Printf.sprintf "<Component ~%s(%s)>" c.c_name (String.concat ", " c.c_params)
+    Buffer.add_string buf "<Component ~"; Buffer.add_string buf c.c_name;
+    Buffer.add_char buf '('; Buffer.add_string buf (String.concat ", " c.c_params);
+    Buffer.add_string buf ")>"
   | Island i ->
-    Printf.sprintf "<Island ~%s(%s)>" i.i_name (String.concat ", " i.i_params)
+    Buffer.add_string buf "<Island ~"; Buffer.add_string buf i.i_name;
+    Buffer.add_char buf '('; Buffer.add_string buf (String.concat ", " i.i_params);
+    Buffer.add_string buf ")>"
   | Macro m ->
     let tag = match m.m_name with Some n -> n | None -> "macro" in
-    Printf.sprintf "<%s(%s)>" tag (String.concat ", " m.m_params)
-  | Thunk _ -> "<thunk>"
-  | Continuation (_, _) -> "<continuation>"
-  | CallccContinuation (_, _) -> "<callcc-continuation>"
-  | NativeFn (name, _) -> Printf.sprintf "<native:%s>" name
-  | Signal _ -> "<signal>"
-  | RawHTML s -> Printf.sprintf "\"<raw-html:%d>\"" (String.length s)
-  | Spread _ -> "<spread>"
-  | SxExpr s -> Printf.sprintf "\"<sx-expr:%d>\"" (String.length s)
-  | Env _ -> "<env>"
-  | CekState _ -> "<cek-state>"
-  | CekFrame f -> Printf.sprintf "<frame:%s>" f.cf_type
-  | VmClosure cl -> Printf.sprintf "<vm:%s>" (match cl.vm_name with Some n -> n | None -> "anon")
+    Buffer.add_char buf '<'; Buffer.add_string buf tag;
+    Buffer.add_char buf '('; Buffer.add_string buf (String.concat ", " m.m_params);
+    Buffer.add_string buf ")>"
+  | Thunk _ -> Buffer.add_string buf "<thunk>"
+  | Continuation (_, _) -> Buffer.add_string buf "<continuation>"
+  | CallccContinuation (_, _) -> Buffer.add_string buf "<callcc-continuation>"
+  | NativeFn (name, _) ->
+    Buffer.add_string buf "<native:"; Buffer.add_string buf name; Buffer.add_char buf '>'
+  | Signal _ -> Buffer.add_string buf "<signal>"
+  | RawHTML s ->
+    Buffer.add_string buf "\"<raw-html:";
+    Buffer.add_string buf (string_of_int (String.length s));
+    Buffer.add_string buf ">\""
+  | Spread _ -> Buffer.add_string buf "<spread>"
+  | SxExpr s ->
+    Buffer.add_string buf "\"<sx-expr:";
+    Buffer.add_string buf (string_of_int (String.length s));
+    Buffer.add_string buf ">\""
+  | Env _ -> Buffer.add_string buf "<env>"
+  | CekState _ -> Buffer.add_string buf "<cek-state>"
+  | CekFrame f ->
+    Buffer.add_string buf "<frame:"; Buffer.add_string buf f.cf_type; Buffer.add_char buf '>'
+  | VmClosure cl ->
+    Buffer.add_string buf "<vm:";
+    Buffer.add_string buf (match cl.vm_name with Some n -> n | None -> "anon");
+    Buffer.add_char buf '>'
   | Record r ->
-    let fields = Array.to_list (Array.mapi (fun i v ->
-      Printf.sprintf "%s=%s" r.r_type.rt_fields.(i) (inspect v)
-    ) r.r_fields) in
-    Printf.sprintf "<record:%s %s>" r.r_type.rt_name (String.concat " " fields)
-  | Parameter p -> Printf.sprintf "<parameter:%s>" p.pm_uid
+    Buffer.add_string buf "<record:"; Buffer.add_string buf r.r_type.rt_name;
+    Array.iteri (fun i v ->
+      Buffer.add_char buf ' ';
+      Buffer.add_string buf r.r_type.rt_fields.(i);
+      Buffer.add_char buf '=';
+      inspect_into buf v) r.r_fields;
+    Buffer.add_char buf '>'
+  | Parameter p ->
+    Buffer.add_string buf "<parameter:"; Buffer.add_string buf p.pm_uid; Buffer.add_char buf '>'
   | Vector arr ->
-    let elts = Array.to_list (Array.map inspect arr) in
-    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)
+    Buffer.add_string buf "#(";
+    Array.iteri (fun i v ->
+      if i > 0 then Buffer.add_char buf ' ';
+      inspect_into buf v) arr;
+    Buffer.add_char buf ')'
+  | VmFrame f ->
+    Buffer.add_string buf (Printf.sprintf "<vm-frame:ip=%d base=%d>" f.vf_ip f.vf_base)
+  | VmMachine m ->
+    Buffer.add_string buf (Printf.sprintf "<vm-machine:sp=%d frames=%d>" m.vm_sp (List.length m.vm_frames))
+  | StringBuffer b ->
+    Buffer.add_string buf (Printf.sprintf "<string-buffer:%d>" (Buffer.length b))
+  | HashTable ht ->
+    Buffer.add_string buf (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"
+    Buffer.add_string buf "#\\";
+    (match n with
+     | 32 -> Buffer.add_string buf "space"
+     | 10 -> Buffer.add_string buf "newline"
+     | 9 -> Buffer.add_string buf "tab"
+     | 13 -> Buffer.add_string buf "return"
+     | 0 -> Buffer.add_string buf "nul"
+     | 27 -> Buffer.add_string buf "escape"
+     | 127 -> Buffer.add_string buf "delete"
+     | 8 -> Buffer.add_string buf "backspace"
+     | _ -> Buffer.add_utf_8_uchar buf (Uchar.of_int n))
+  | Eof -> Buffer.add_string buf "#!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)))))
+    Buffer.add_string buf (Printf.sprintf "<input-port:pos=%d%s>" !pos (if sp_closed then ":closed" else ""))
+  | Port { sp_kind = PortOutput b; sp_closed } ->
+    Buffer.add_string buf (Printf.sprintf "<output-port:len=%d%s>" (Buffer.length b) (if sp_closed then ":closed" else ""))
+  | Rational (n, d) ->
+    Buffer.add_string buf (string_of_int n); Buffer.add_char buf '/';
+    Buffer.add_string buf (string_of_int d)
+  | SxSet ht ->
+    Buffer.add_string buf (Printf.sprintf "<set:%d>" (Hashtbl.length ht))
+  | SxRegexp (src, flags, _) ->
+    Buffer.add_string buf "#/"; Buffer.add_string buf src;
+    Buffer.add_char buf '/'; Buffer.add_string buf flags
+  | SxBytevector b ->
+    Buffer.add_string buf "#u8(";
+    let n = Bytes.length b in
+    for i = 0 to n - 1 do
+      if i > 0 then Buffer.add_char buf ' ';
+      Buffer.add_string buf (string_of_int (Char.code (Bytes.get b i)))
+    done;
+    Buffer.add_char buf ')'
+  | AdtValue a ->
+    Buffer.add_char buf '('; Buffer.add_string buf a.av_ctor;
+    Array.iter (fun v -> Buffer.add_char buf ' '; inspect_into buf v) a.av_fields;
+    Buffer.add_char buf ')'
+
+let inspect v =
+  let buf = Buffer.create 64 in
+  inspect_into buf v;
+  Buffer.contents buf

hosts/ocaml/lib/sx_vm.ml

@@ -57,9 +57,6 @@ let () = Sx_types._convert_vm_suspension := (fun exn ->
 let jit_compile_ref : (lambda -> (string, value) Hashtbl.t -> vm_closure option) ref =
   ref (fun _ _ -> None)
 
-(* JIT threshold and counters live in Sx_types so primitives can read them
-   without creating a sx_primitives → sx_vm dependency cycle. *)
-
 (** Sentinel closure indicating JIT compilation was attempted and failed.
     Prevents retrying compilation on every call. *)
 let jit_failed_sentinel = {
@@ -330,7 +327,18 @@ and call_closure_reuse cl args =
        vm.sp <- saved_sp;
        raise e);
     vm.frames <- saved_frames;
-    pop vm
+    (* Snapshot/restore sp around the popped result.
+       OP_RETURN normally leaves sp = saved_sp + 1, but the bytecode-exhausted
+       path (or a callee that returns a closure whose own RETURN leaves extra
+       stack residue) can leave sp inconsistent. Read the result at the
+       expected slot and reset sp explicitly so the parent frame's
+       intermediate values are not corrupted. *)
+    let result =
+      if vm.sp > saved_sp then vm.stack.(vm.sp - 1)
+      else Nil
+    in
+    vm.sp <- saved_sp;
+    result
   | None ->
     call_closure cl args cl.vm_env_ref
 
@@ -356,29 +364,13 @@ and vm_call vm f args =
      | None ->
        if l.l_name <> None
        then begin
-         l.l_call_count <- l.l_call_count + 1;
-         if l.l_call_count >= !Sx_types.jit_threshold && !Sx_types.jit_budget > 0 then begin
-           l.l_compiled <- Some jit_failed_sentinel;
-           match !jit_compile_ref l vm.globals with
-           | Some cl ->
-             incr Sx_types.jit_compiled_count;
-             l.l_compiled <- Some cl;
-             (* Phase 2 LRU: track this compiled lambda; if cache exceeds budget,
-                evict the oldest by clearing its l_compiled slot. *)
-             Queue.add (l.l_uid, Lambda l) Sx_types.jit_cache_queue;
-             while Queue.length Sx_types.jit_cache_queue > !Sx_types.jit_budget do
-               (match Queue.pop Sx_types.jit_cache_queue with
-                | (_, Lambda ev_l) -> ev_l.l_compiled <- None; incr Sx_types.jit_evicted_count
-                | _ -> ())
-             done;
-             push_closure_frame vm cl args
-           | None ->
-             incr Sx_types.jit_skipped_count;
-             push vm (cek_call_or_suspend vm f (List args))
-         end else begin
-           incr Sx_types.jit_threshold_skipped_count;
+         l.l_compiled <- Some jit_failed_sentinel;
+         match !jit_compile_ref l vm.globals with
+         | Some cl ->
+           l.l_compiled <- Some cl;
+           push_closure_frame vm cl args
+         | None ->
            push vm (cek_call_or_suspend vm f (List args))
-         end
        end
        else
          push vm (cek_call_or_suspend vm f (List args)))
@@ -650,7 +642,9 @@ and run vm =
           (* Read upvalue descriptors from bytecode *)
           let uv_count = match code_val with
             | Dict d -> (match Hashtbl.find_opt d "upvalue-count" with
-                | Some (Number n) -> int_of_float n | _ -> 0)
+                | Some (Integer n) -> n
+                | Some (Number n) -> int_of_float n
+                | _ -> 0)
             | _ -> 0
           in
           let upvalues = Array.init uv_count (fun _ ->
@@ -750,38 +744,57 @@ and run vm =
         | 160 (* OP_ADD *) ->
           let b = pop vm and a = pop vm in
           push vm (match a, b with
+            | Integer x, Integer y -> Integer (x + y)
             | Number x, Number y -> Number (x +. y)
+            | Integer x, Number y -> Number (float_of_int x +. y)
+            | Number x, Integer y -> Number (x +. float_of_int y)
             | _ -> (Hashtbl.find Sx_primitives.primitives "+") [a; b])
         | 161 (* OP_SUB *) ->
           let b = pop vm and a = pop vm in
           push vm (match a, b with
+            | Integer x, Integer y -> Integer (x - y)
             | Number x, Number y -> Number (x -. y)
+            | Integer x, Number y -> Number (float_of_int x -. y)
+            | Number x, Integer y -> Number (x -. float_of_int y)
             | _ -> (Hashtbl.find Sx_primitives.primitives "-") [a; b])
         | 162 (* OP_MUL *) ->
           let b = pop vm and a = pop vm in
           push vm (match a, b with
+            | Integer x, Integer y -> Integer (x * y)
             | Number x, Number y -> Number (x *. y)
+            | Integer x, Number y -> Number (float_of_int x *. y)
+            | Number x, Integer y -> Number (x *. float_of_int y)
             | _ -> (Hashtbl.find Sx_primitives.primitives "*") [a; b])
         | 163 (* OP_DIV *) ->
           let b = pop vm and a = pop vm in
           push vm (match a, b with
+            | Integer x, Integer y when y <> 0 && x mod y = 0 -> Integer (x / y)
+            | Integer x, Integer y -> Number (float_of_int x /. float_of_int y)
             | Number x, Number y -> Number (x /. y)
+            | Integer x, Number y -> Number (float_of_int x /. y)
+            | Number x, Integer y -> Number (x /. float_of_int y)
             | _ -> (Hashtbl.find Sx_primitives.primitives "/") [a; b])
         | 164 (* OP_EQ *) ->
           let b = pop vm and a = pop vm in
-          push vm ((Hashtbl.find Sx_primitives.primitives "=") [a; b])
+          push vm (Bool (Sx_runtime._fast_eq a b))
         | 165 (* OP_LT *) ->
           let b = pop vm and a = pop vm in
           push vm (match a, b with
+            | Integer x, Integer y -> Bool (x < y)
             | Number x, Number y -> Bool (x < y)
+            | Integer x, Number y -> Bool (float_of_int x < y)
+            | Number x, Integer y -> Bool (x < float_of_int y)
             | String x, String y -> Bool (x < y)
-            | _ -> (Hashtbl.find Sx_primitives.primitives "<") [a; b])
+            | _ -> Sx_runtime.prim_call "<" [a; b])
         | 166 (* OP_GT *) ->
           let b = pop vm and a = pop vm in
           push vm (match a, b with
+            | Integer x, Integer y -> Bool (x > y)
             | Number x, Number y -> Bool (x > y)
+            | Integer x, Number y -> Bool (float_of_int x > y)
+            | Number x, Integer y -> Bool (x > float_of_int y)
             | String x, String y -> Bool (x > y)
-            | _ -> (Hashtbl.find Sx_primitives.primitives ">") [a; b])
+            | _ -> Sx_runtime.prim_call ">" [a; b])
         | 167 (* OP_NOT *) ->
           let v = pop vm in
           push vm (Bool (not (sx_truthy v)))
@@ -904,9 +917,17 @@ let resume_vm vm result =
   let rec restore_reuse pending =
     match pending with
     | [] -> ()
-    | (saved_frames, _saved_sp) :: rest ->
+    | (saved_frames, saved_sp) :: rest ->
       let callback_result = pop vm in
       vm.frames <- saved_frames;
+      (* Restore sp to the value captured before the suspended callee was
+         pushed. The callee's locals/temps may still be on the stack above
+         saved_sp; without this reset, subsequent LOCAL_GET/SET in the
+         caller frame (e.g. letrec sibling bindings waiting on the call)
+         see stale callee data instead of their own slots. Mirrors the
+         OP_RETURN+sp-reset semantics that sync `call_closure_reuse`
+         relies on for clean caller-frame state. *)
+      if saved_sp < vm.sp then vm.sp <- saved_sp;
       push vm callback_result;
       (try
         run vm;
@@ -1288,7 +1309,9 @@ let trace_run src globals =
             let code_val2 = frame.closure.vm_code.vc_constants.(idx) in
             let uv_count = match code_val2 with
               | Dict d -> (match Hashtbl.find_opt d "upvalue-count" with
-                  | Some (Number n) -> int_of_float n | _ -> 0)
+                  | Some (Integer n) -> n
+                  | Some (Number n) -> int_of_float n
+                  | _ -> 0)
               | _ -> 0 in
             let upvalues = Array.init uv_count (fun _ ->
               let is_local = read_u8 frame in
@@ -1409,7 +1432,9 @@ let disassemble (code : vm_code) =
         if op = 51 && idx < Array.length consts then begin
           let uv_count = match consts.(idx) with
             | Dict d -> (match Hashtbl.find_opt d "upvalue-count" with
-                | Some (Number n) -> int_of_float n | _ -> 0)
+                | Some (Integer n) -> n
+                | Some (Number n) -> int_of_float n
+                | _ -> 0)
             | _ -> 0 in
           ip := !ip + uv_count * 2
         end

hosts/ocaml/lib/sx_vm_ref.ml

@@ -270,7 +270,9 @@ let vm_create_closure vm_val frame_val code_val =
   let f = unwrap_frame frame_val in
   let uv_count = match code_val with
     | Dict d -> (match Hashtbl.find_opt d "upvalue-count" with
-        | Some (Number n) -> int_of_float n | _ -> 0)
+        | Some (Integer n) -> n
+        | Some (Number n) -> int_of_float n
+        | _ -> 0)
     | _ -> 0
   in
   let upvalues = Array.init uv_count (fun _ ->

hosts/ocaml/sx_vm_ref.ml

@@ -265,7 +265,9 @@ let vm_create_closure vm_val frame_val code_val =
   let f = unwrap_frame frame_val in
   let uv_count = match code_val with
     | Dict d -> (match Hashtbl.find_opt d "upvalue-count" with
-        | Some (Number n) -> int_of_float n | _ -> 0)
+        | Some (Integer n) -> n
+        | Some (Number n) -> int_of_float n
+        | _ -> 0)
     | _ -> 0
   in
   let upvalues = Array.init uv_count (fun _ ->

lib/apl/conformance.sh

@@ -0,0 +1,113 @@
+#!/usr/bin/env bash
+# lib/apl/conformance.sh — run APL test suites, emit scoreboard.json + scoreboard.md.
+
+set -uo pipefail
+cd "$(git rev-parse --show-toplevel)"
+
+SX_SERVER="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
+if [ ! -x "$SX_SERVER" ]; then
+  SX_SERVER="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
+
+SUITES=(structural operators dfn tradfn valence programs system idioms)
+
+OUT_JSON="lib/apl/scoreboard.json"
+OUT_MD="lib/apl/scoreboard.md"
+
+run_suite() {
+  local suite=$1
+  local file="lib/apl/tests/${suite}.sx"
+  local TMP
+  TMP=$(mktemp)
+  cat > "$TMP" << EPOCHS
+(epoch 1)
+(load "spec/stdlib.sx")
+(load "lib/apl/runtime.sx")
+(load "lib/apl/transpile.sx")
+(epoch 2)
+(eval "(define apl-test-pass 0)")
+(eval "(define apl-test-fail 0)")
+(eval "(define apl-test (fn (name got expected) (if (= got expected) (set! apl-test-pass (+ apl-test-pass 1)) (set! apl-test-fail (+ apl-test-fail 1)))))")
+(epoch 3)
+(load "${file}")
+(epoch 4)
+(eval "(list apl-test-pass apl-test-fail)")
+EPOCHS
+
+  local OUTPUT
+  OUTPUT=$(timeout 180 "$SX_SERVER" < "$TMP" 2>/dev/null)
+  rm -f "$TMP"
+
+  local LINE
+  LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 4 / {getline; print; exit}')
+  if [ -z "$LINE" ]; then
+    LINE=$(echo "$OUTPUT" | grep -E '^\(ok 4 \([0-9]+ [0-9]+\)\)' | tail -1 \
+            | sed -E 's/^\(ok 4 //; s/\)$//')
+  fi
+
+  local P F
+  P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/')
+  F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/')
+  P=${P:-0}
+  F=${F:-0}
+  echo "${P} ${F}"
+}
+
+declare -A SUITE_PASS
+declare -A SUITE_FAIL
+TOTAL_PASS=0
+TOTAL_FAIL=0
+
+echo "Running APL conformance suite..." >&2
+for s in "${SUITES[@]}"; do
+  read -r p f < <(run_suite "$s")
+  SUITE_PASS[$s]=$p
+  SUITE_FAIL[$s]=$f
+  TOTAL_PASS=$((TOTAL_PASS + p))
+  TOTAL_FAIL=$((TOTAL_FAIL + f))
+  printf "  %-12s %d/%d\n" "$s" "$p" "$((p+f))" >&2
+done
+
+# scoreboard.json
+{
+  printf '{\n'
+  printf '  "suites": {\n'
+  first=1
+  for s in "${SUITES[@]}"; do
+    if [ $first -eq 0 ]; then printf ',\n'; fi
+    printf '    "%s": {"pass": %d, "fail": %d}' "$s" "${SUITE_PASS[$s]}" "${SUITE_FAIL[$s]}"
+    first=0
+  done
+  printf '\n  },\n'
+  printf '  "total_pass": %d,\n' "$TOTAL_PASS"
+  printf '  "total_fail": %d,\n' "$TOTAL_FAIL"
+  printf '  "total": %d\n' "$((TOTAL_PASS + TOTAL_FAIL))"
+  printf '}\n'
+} > "$OUT_JSON"
+
+# scoreboard.md
+{
+  printf '# APL Conformance Scoreboard\n\n'
+  printf '_Generated by `lib/apl/conformance.sh`_\n\n'
+  printf '| Suite | Pass | Fail | Total |\n'
+  printf '|-------|-----:|-----:|------:|\n'
+  for s in "${SUITES[@]}"; do
+    p=${SUITE_PASS[$s]}
+    f=${SUITE_FAIL[$s]}
+    printf '| %s | %d | %d | %d |\n' "$s" "$p" "$f" "$((p+f))"
+  done
+  printf '| **Total** | **%d** | **%d** | **%d** |\n' "$TOTAL_PASS" "$TOTAL_FAIL" "$((TOTAL_PASS + TOTAL_FAIL))"
+  printf '\n'
+  printf '## Notes\n\n'
+  printf '%s\n' '- Suites use the standard `apl-test name got expected` framework loaded against `lib/apl/runtime.sx` + `lib/apl/transpile.sx`.'
+  printf '%s\n' '- `lib/apl/tests/parse.sx` and `lib/apl/tests/scalar.sx` use their own self-contained frameworks and are excluded from this scoreboard.'
+} > "$OUT_MD"
+
+echo "Wrote $OUT_JSON and $OUT_MD" >&2
+echo "Total: $TOTAL_PASS pass, $TOTAL_FAIL fail" >&2
+
+[ "$TOTAL_FAIL" -eq 0 ]

lib/apl/parser.sx

@@ -0,0 +1,436 @@
+; APL Parser — right-to-left expression parser
+;
+; Takes a token list (output of apl-tokenize) and produces an AST.
+; APL evaluates right-to-left with no precedence among functions.
+; Operators bind to the function immediately to their left in the source.
+;
+; AST node types:
+;   (:num n)                     number literal
+;   (:str s)                     string literal
+;   (:vec n1 n2 ...)             strand (juxtaposed literals)
+;   (:name "x")                  name reference / alpha / omega
+;   (:assign "x" expr)           assignment  x←expr
+;   (:monad fn arg)              monadic function call
+;   (:dyad fn left right)        dyadic function call
+;   (:derived-fn op fn)          derived function: f/ f¨ f⍨
+;   (:derived-fn2 "." f g)       inner product: f.g
+;   (:outer "∘." fn)             outer product: ∘.f
+;   (:fn-glyph "⍳")             function reference
+;   (:fn-name "foo")             named-function reference (dfn variable)
+;   (:dfn stmt...)               {⍺+⍵} anonymous function
+;   (:guard cond expr)           cond:expr guard inside dfn
+;   (:program stmt...)           multi-statement sequence
+
+; ============================================================
+; Glyph classification sets
+; ============================================================
+
+(define apl-parse-op-glyphs
+  (list "/" "\\" "¨" "⍨" "∘" "." "⍣" "⍤" "⍥" "@"))
+
+(define apl-parse-fn-glyphs
+  (list "+" "-" "×" "÷" "*" "⍟" "⌈" "⌊" "|" "!" "?" "○" "~"
+        "<" "≤" "=" "≥" ">" "≠" "∊" "∧" "∨" "⍱" "⍲"
+        "," "⍪" "⍴" "⌽" "⊖" "⍉" "↑" "↓" "⊂" "⊃" "⊆"
+        "∪" "∩" "⍳" "⍸" "⌷" "⍋" "⍒" "⊥" "⊤" "⊣" "⊢" "⍎" "⍕"))
+
+(define apl-parse-op-glyph?
+  (fn (v)
+    (some (fn (g) (= g v)) apl-parse-op-glyphs)))
+
+(define apl-parse-fn-glyph?
+  (fn (v)
+    (some (fn (g) (= g v)) apl-parse-fn-glyphs)))
+
+; ============================================================
+; Token accessors
+; ============================================================
+
+(define tok-type
+  (fn (tok)
+    (get tok :type)))
+
+(define tok-val
+  (fn (tok)
+    (get tok :value)))
+
+(define is-op-tok?
+  (fn (tok)
+    (and (= (tok-type tok) :glyph)
+         (apl-parse-op-glyph? (tok-val tok)))))
+
+(define is-fn-tok?
+  (fn (tok)
+    (and (= (tok-type tok) :glyph)
+         (apl-parse-fn-glyph? (tok-val tok)))))
+
+; ============================================================
+; Collect trailing operators starting at index i
+; Returns {:ops (op ...) :end new-i}
+; ============================================================
+
+(define collect-ops
+  (fn (tokens i)
+    (collect-ops-loop tokens i (list))))
+
+(define collect-ops-loop
+  (fn (tokens i acc)
+    (if (>= i (len tokens))
+      {:ops acc :end i}
+      (let ((tok (nth tokens i)))
+        (if (is-op-tok? tok)
+          (collect-ops-loop tokens (+ i 1) (append acc (tok-val tok)))
+          {:ops acc :end i})))))
+
+; ============================================================
+; Build a derived-fn node by chaining operators left-to-right
+; (+/¨  →  (:derived-fn "¨" (:derived-fn "/" (:fn-glyph "+"))))
+; ============================================================
+
+(define build-derived-fn
+  (fn (fn-node ops)
+    (if (= (len ops) 0)
+      fn-node
+      (build-derived-fn
+        (list :derived-fn (first ops) fn-node)
+        (rest ops)))))
+
+; ============================================================
+; Find matching close bracket/paren/brace
+; Returns the index of the matching close token
+; ============================================================
+
+(define find-matching-close
+  (fn (tokens start open-type close-type)
+    (find-matching-close-loop tokens start open-type close-type 1)))
+
+(define find-matching-close-loop
+  (fn (tokens i open-type close-type depth)
+    (if (>= i (len tokens))
+      (len tokens)
+      (let ((tt (tok-type (nth tokens i))))
+        (cond
+          ((= tt open-type)
+           (find-matching-close-loop tokens (+ i 1) open-type close-type (+ depth 1)))
+          ((= tt close-type)
+           (if (= depth 1)
+             i
+             (find-matching-close-loop tokens (+ i 1) open-type close-type (- depth 1))))
+          (true
+           (find-matching-close-loop tokens (+ i 1) open-type close-type depth)))))))
+
+; ============================================================
+; Segment collection: scan tokens left-to-right, building
+; a list of {:kind "val"/"fn" :node ast} segments.
+; Operators following function glyphs are merged into
+; derived-fn nodes during this pass.
+; ============================================================
+
+(define collect-segments
+  (fn (tokens)
+    (collect-segments-loop tokens 0 (list))))
+
+(define collect-segments-loop
+  (fn (tokens i acc)
+    (if (>= i (len tokens))
+      acc
+      (let ((tok (nth tokens i))
+            (n   (len tokens)))
+        (let ((tt (tok-type tok))
+              (tv (tok-val tok)))
+          (cond
+            ; Skip separators
+            ((or (= tt :diamond) (= tt :newline) (= tt :semi))
+             (collect-segments-loop tokens (+ i 1) acc))
+
+            ; Number → value segment
+            ((= tt :num)
+             (collect-segments-loop tokens (+ i 1)
+               (append acc {:kind "val" :node (list :num tv)})))
+
+            ; String → value segment
+            ((= tt :str)
+             (collect-segments-loop tokens (+ i 1)
+               (append acc {:kind "val" :node (list :str tv)})))
+
+            ; Name → always a value segment in Phase 1
+            ; (Named functions with operators like f/ are Phase 5)
+            ((= tt :name)
+             (collect-segments-loop tokens (+ i 1)
+               (append acc {:kind "val" :node (list :name tv)})))
+
+
+            ; Left paren → parse subexpression recursively
+            ((= tt :lparen)
+             (let ((end (find-matching-close tokens (+ i 1) :lparen :rparen)))
+               (let ((inner-tokens (slice tokens (+ i 1) end))
+                     (after (+ end 1)))
+                 (collect-segments-loop tokens after
+                   (append acc {:kind "val" :node (parse-apl-expr inner-tokens)})))))
+
+            ; Left brace → dfn
+            ((= tt :lbrace)
+             (let ((end (find-matching-close tokens (+ i 1) :lbrace :rbrace)))
+               (let ((inner-tokens (slice tokens (+ i 1) end))
+                     (after (+ end 1)))
+                 (collect-segments-loop tokens after
+                   (append acc {:kind "fn" :node (parse-dfn inner-tokens)})))))
+
+            ; Glyph token — need to classify
+            ((= tt :glyph)
+             (cond
+               ; Alpha (⍺) and Omega (⍵) → values inside dfn context
+               ((or (= tv "⍺") (= tv "⍵"))
+                (collect-segments-loop tokens (+ i 1)
+                  (append acc {:kind "val" :node (list :name tv)})))
+
+               ; Nabla (∇) → self-reference function in dfn context
+               ((= tv "∇")
+                (collect-segments-loop tokens (+ i 1)
+                  (append acc {:kind "fn" :node (list :fn-glyph "∇")})))
+
+               ; ∘. → outer product (special case: ∘ followed by .)
+               ((and (= tv "∘")
+                     (< (+ i 1) n)
+                     (= (tok-val (nth tokens (+ i 1))) "."))
+                (if (and (< (+ i 2) n) (is-fn-tok? (nth tokens (+ i 2))))
+                  (let ((fn-tv (tok-val (nth tokens (+ i 2)))))
+                    (let ((op-result (collect-ops tokens (+ i 3))))
+                      (let ((ops (get op-result :ops))
+                            (ni  (get op-result :end)))
+                        (let ((fn-node (build-derived-fn (list :fn-glyph fn-tv) ops)))
+                          (collect-segments-loop tokens ni
+                            (append acc {:kind "fn" :node (list :outer "∘." fn-node)}))))))
+                  ; ∘. without function — treat ∘ as plain compose operator
+                  ; skip the . and continue
+                  (collect-segments-loop tokens (+ i 1)
+                    acc)))
+
+               ; Function glyph — collect following operators
+               ((apl-parse-fn-glyph? tv)
+                (let ((op-result (collect-ops tokens (+ i 1))))
+                  (let ((ops (get op-result :ops))
+                        (ni  (get op-result :end)))
+                    ; Check for inner product: fn . fn
+                    ; (ops = ("." ) and next token is also a function glyph)
+                    (if (and (= (len ops) 1)
+                             (= (first ops) ".")
+                             (< ni n)
+                             (is-fn-tok? (nth tokens ni)))
+                      ; f.g inner product
+                      (let ((g-tv (tok-val (nth tokens ni))))
+                        (let ((op-result2 (collect-ops tokens (+ ni 1))))
+                          (let ((ops2 (get op-result2 :ops))
+                                (ni2  (get op-result2 :end)))
+                            (let ((g-node (build-derived-fn (list :fn-glyph g-tv) ops2)))
+                              (collect-segments-loop tokens ni2
+                                (append acc {:kind "fn"
+                                             :node (list :derived-fn2 "." (list :fn-glyph tv) g-node)}))))))
+                      ; Regular function with zero or more operator modifiers
+                      (let ((fn-node (build-derived-fn (list :fn-glyph tv) ops)))
+                        (collect-segments-loop tokens ni
+                          (append acc {:kind "fn" :node fn-node})))))))
+
+               ; Stray operator glyph — skip (shouldn't appear outside function context)
+               ((apl-parse-op-glyph? tv)
+                (collect-segments-loop tokens (+ i 1) acc))
+
+               ; Unknown glyph — skip
+               (true
+                (collect-segments-loop tokens (+ i 1) acc))))
+
+            ; Skip unknown token types
+            (true
+             (collect-segments-loop tokens (+ i 1) acc))))))))
+
+; ============================================================
+; Build tree from segment list
+;
+; The segments are in left-to-right order.
+; APL evaluates right-to-left, so the LEFTMOST function is
+; the outermost (last-evaluated) node.
+;
+; Patterns:
+;   [val]              → val node
+;   [fn val ...]       → (:monad fn (build-tree rest))
+;   [val fn val ...]   → (:dyad fn val (build-tree rest))
+;   [val val ...]      → (:vec val1 val2 ...) — strand
+; ============================================================
+
+; Find the index of the first function segment (returns -1 if none)
+(define find-first-fn
+  (fn (segs)
+    (find-first-fn-loop segs 0)))
+
+(define find-first-fn-loop
+  (fn (segs i)
+    (if (>= i (len segs))
+      -1
+      (if (= (get (nth segs i) :kind) "fn")
+        i
+        (find-first-fn-loop segs (+ i 1))))))
+
+; Build an array node from 0..n value segments
+; If n=1 → return that segment's node
+; If n>1 → return (:vec node1 node2 ...)
+(define segs-to-array
+  (fn (segs)
+    (if (= (len segs) 1)
+      (get (first segs) :node)
+      (cons :vec (map (fn (s) (get s :node)) segs)))))
+
+(define build-tree
+  (fn (segs)
+    (cond
+      ; Empty → nil
+      ((= (len segs) 0) nil)
+      ; Single segment → return its node directly
+      ((= (len segs) 1) (get (first segs) :node))
+      ; All values → strand
+      ((every? (fn (s) (= (get s :kind) "val")) segs)
+       (segs-to-array segs))
+      ; Find the first function segment
+      (true
+       (let ((fn-idx (find-first-fn segs)))
+         (cond
+           ; No function found (shouldn't happen given above checks) → strand
+           ((= fn-idx -1) (segs-to-array segs))
+           ; Function is first → monadic call
+           ((= fn-idx 0)
+            (list :monad
+                  (get (first segs) :node)
+                  (build-tree (rest segs))))
+           ; Function at position fn-idx: left args are segs[0..fn-idx-1]
+           (true
+            (let ((left-segs  (slice segs 0 fn-idx))
+                  (fn-seg     (nth segs fn-idx))
+                  (right-segs (slice segs (+ fn-idx 1))))
+              (list :dyad
+                    (get fn-seg :node)
+                    (segs-to-array left-segs)
+                    (build-tree right-segs))))))))))
+
+
+; ============================================================
+; Split token list on statement separators (diamond / newline)
+; Only splits at depth 0 (ignores separators inside { } or ( ) )
+; ============================================================
+
+(define split-statements
+  (fn (tokens)
+    (split-statements-loop tokens (list) (list) 0)))
+
+(define split-statements-loop
+  (fn (tokens current-stmt acc depth)
+    (if (= (len tokens) 0)
+      (if (> (len current-stmt) 0)
+        (append acc (list current-stmt))
+        acc)
+      (let ((tok (first tokens))
+            (rest-toks (rest tokens))
+            (tt (tok-type (first tokens))))
+        (cond
+          ; Open brackets increase depth
+          ((or (= tt :lparen) (= tt :lbrace) (= tt :lbracket))
+           (split-statements-loop rest-toks (append current-stmt tok) acc (+ depth 1)))
+          ; Close brackets decrease depth
+          ((or (= tt :rparen) (= tt :rbrace) (= tt :rbracket))
+           (split-statements-loop rest-toks (append current-stmt tok) acc (- depth 1)))
+          ; Separators only split at top level (depth = 0)
+          ((and (> depth 0) (or (= tt :diamond) (= tt :newline)))
+           (split-statements-loop rest-toks (append current-stmt tok) acc depth))
+          ((and (= depth 0) (or (= tt :diamond) (= tt :newline)))
+           (if (> (len current-stmt) 0)
+             (split-statements-loop rest-toks (list) (append acc (list current-stmt)) depth)
+             (split-statements-loop rest-toks (list) acc depth)))
+          ; All other tokens go into current statement
+          (true
+           (split-statements-loop rest-toks (append current-stmt tok) acc depth)))))))
+
+; ============================================================
+; Parse a dfn body (tokens between { and })
+; Handles guard expressions: cond : expr
+; ============================================================
+
+(define parse-dfn
+  (fn (tokens)
+    (let ((stmt-groups (split-statements tokens)))
+      (let ((stmts (map parse-dfn-stmt stmt-groups)))
+        (cons :dfn stmts)))))
+
+(define parse-dfn-stmt
+  (fn (tokens)
+    ; Check for guard: expr : expr
+    ; A guard has a :colon token not inside parens/braces
+    (let ((colon-idx (find-top-level-colon tokens 0)))
+      (if (>= colon-idx 0)
+        ; Guard: cond : expr
+        (let ((cond-tokens (slice tokens 0 colon-idx))
+              (body-tokens (slice tokens (+ colon-idx 1))))
+          (list :guard
+                (parse-apl-expr cond-tokens)
+                (parse-apl-expr body-tokens)))
+        ; Regular statement
+        (parse-stmt tokens)))))
+
+(define find-top-level-colon
+  (fn (tokens i)
+    (find-top-level-colon-loop tokens i 0)))
+
+(define find-top-level-colon-loop
+  (fn (tokens i depth)
+    (if (>= i (len tokens))
+      -1
+      (let ((tok (nth tokens i))
+            (tt  (tok-type (nth tokens i))))
+        (cond
+          ((or (= tt :lparen) (= tt :lbrace) (= tt :lbracket))
+           (find-top-level-colon-loop tokens (+ i 1) (+ depth 1)))
+          ((or (= tt :rparen) (= tt :rbrace) (= tt :rbracket))
+           (find-top-level-colon-loop tokens (+ i 1) (- depth 1)))
+          ((and (= tt :colon) (= depth 0))
+           i)
+          (true
+           (find-top-level-colon-loop tokens (+ i 1) depth)))))))
+
+; ============================================================
+; Parse a single statement (assignment or expression)
+; ============================================================
+
+(define parse-stmt
+  (fn (tokens)
+    (if (and (>= (len tokens) 2)
+             (= (tok-type (nth tokens 0)) :name)
+             (= (tok-type (nth tokens 1)) :assign))
+      ; Assignment: name ← expr
+      (list :assign
+            (tok-val (nth tokens 0))
+            (parse-apl-expr (slice tokens 2)))
+      ; Expression
+      (parse-apl-expr tokens))))
+
+; ============================================================
+; Parse an expression from a flat token list
+; ============================================================
+
+(define parse-apl-expr
+  (fn (tokens)
+    (let ((segs (collect-segments tokens)))
+      (if (= (len segs) 0)
+        nil
+        (build-tree segs)))))
+
+; ============================================================
+; Main entry point
+; parse-apl: string → AST
+; ============================================================
+
+(define parse-apl
+  (fn (src)
+    (let ((tokens (apl-tokenize src)))
+      (let ((stmt-groups (split-statements tokens)))
+        (if (= (len stmt-groups) 0)
+          nil
+          (if (= (len stmt-groups) 1)
+            (parse-stmt (first stmt-groups))
+            (cons :program (map parse-stmt stmt-groups))))))))

lib/apl/scoreboard.json

@@ -0,0 +1,15 @@
+{
+  "suites": {
+    "structural": {"pass": 94, "fail": 0},
+    "operators": {"pass": 117, "fail": 0},
+    "dfn": {"pass": 24, "fail": 0},
+    "tradfn": {"pass": 20, "fail": 0},
+    "valence": {"pass": 14, "fail": 0},
+    "programs": {"pass": 46, "fail": 0},
+    "system": {"pass": 13, "fail": 0},
+    "idioms": {"pass": 34, "fail": 0}
+  },
+  "total_pass": 362,
+  "total_fail": 0,
+  "total": 362
+}

lib/apl/scoreboard.md

@@ -0,0 +1,20 @@
+# APL Conformance Scoreboard
+
+_Generated by `lib/apl/conformance.sh`_
+
+| Suite | Pass | Fail | Total |
+|-------|-----:|-----:|------:|
+| structural | 94 | 0 | 94 |
+| operators | 117 | 0 | 117 |
+| dfn | 24 | 0 | 24 |
+| tradfn | 20 | 0 | 20 |
+| valence | 14 | 0 | 14 |
+| programs | 46 | 0 | 46 |
+| system | 13 | 0 | 13 |
+| idioms | 34 | 0 | 34 |
+| **Total** | **362** | **0** | **362** |
+
+## Notes
+
+- Suites use the standard `apl-test name got expected` framework loaded against `lib/apl/runtime.sx` + `lib/apl/transpile.sx`.
+- `lib/apl/tests/parse.sx` and `lib/apl/tests/scalar.sx` use their own self-contained frameworks and are excluded from this scoreboard.

lib/apl/test.sh

@@ -4,9 +4,9 @@
 set -uo pipefail
 cd "$(git rev-parse --show-toplevel)"
 
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
+SX_SERVER="${SX_SERVER:-/root/rose-ash/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"
+  SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
 fi
 if [ ! -x "$SX_SERVER" ]; then
   echo "ERROR: sx_server.exe not found."
@@ -19,18 +19,31 @@ cat > "$TMPFILE" << 'EPOCHS'
 (epoch 1)
 (load "spec/stdlib.sx")
 (load "lib/apl/runtime.sx")
+(load "lib/apl/transpile.sx")
 (epoch 2)
-(load "lib/apl/tests/runtime.sx")
+(eval "(define apl-test-pass 0)")
+(eval "(define apl-test-fail 0)")
+(eval "(define apl-test-fails (list))")
+(eval "(define apl-test (fn (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 {:name name :got got :expected expected})))))))")
 (epoch 3)
+(load "lib/apl/tests/structural.sx")
+(load "lib/apl/tests/operators.sx")
+(load "lib/apl/tests/dfn.sx")
+(load "lib/apl/tests/tradfn.sx")
+(load "lib/apl/tests/valence.sx")
+(load "lib/apl/tests/programs.sx")
+(load "lib/apl/tests/system.sx")
+(load "lib/apl/tests/idioms.sx")
+(epoch 4)
 (eval "(list apl-test-pass apl-test-fail)")
 EPOCHS
 
-OUTPUT=$(timeout 60 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
+OUTPUT=$(timeout 180 "$SX_SERVER" < "$TMPFILE" 2>/dev/null)
 
-LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 3 / {getline; print; exit}')
+LINE=$(echo "$OUTPUT" | awk '/^\(ok-len 4 / {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/\)$//')
+  LINE=$(echo "$OUTPUT" | grep -E '^\(ok 4 \([0-9]+ [0-9]+\)\)' | tail -1 \
+          | sed -E 's/^\(ok 4 //; s/\)$//')
 fi
 if [ -z "$LINE" ]; then
   echo "ERROR: could not extract summary"

lib/apl/tests/dfn.sx

@@ -0,0 +1,227 @@
+; Tests for apl-eval-ast and apl-call-dfn (manual AST construction).
+
+(define rv (fn (arr) (get arr :ravel)))
+(define sh (fn (arr) (get arr :shape)))
+
+(define mknum (fn (n) (list :num n)))
+(define mkname (fn (s) (list :name s)))
+(define mkfg (fn (g) (list :fn-glyph g)))
+(define mkmon (fn (g a) (list :monad (mkfg g) a)))
+(define mkdyd (fn (g l r) (list :dyad (mkfg g) l r)))
+(define mkdfn1 (fn (body) (list :dfn body)))
+(define mkprog (fn (stmts) (cons :program stmts)))
+
+(define mkasg (fn (mkname expr) (list :assign mkname expr)))
+
+(define mkgrd (fn (c e) (list :guard c e)))
+
+(define mkdfn (fn (stmts) (cons :dfn stmts)))
+
+(apl-test
+  "eval :num literal"
+  (rv (apl-eval-ast (mknum 42) {}))
+  (list 42))
+
+(apl-test
+  "eval :num literal shape"
+  (sh (apl-eval-ast (mknum 42) {}))
+  (list))
+
+(apl-test
+  "eval :dyad +"
+  (rv (apl-eval-ast (mkdyd "+" (mknum 2) (mknum 3)) {}))
+  (list 5))
+
+(apl-test
+  "eval :dyad ×"
+  (rv (apl-eval-ast (mkdyd "×" (mknum 6) (mknum 7)) {}))
+  (list 42))
+
+(apl-test
+  "eval :monad - (negate)"
+  (rv (apl-eval-ast (mkmon "-" (mknum 7)) {}))
+  (list -7))
+
+(apl-test
+  "eval :monad ⌊ (floor)"
+  (rv (apl-eval-ast (mkmon "⌊" (mknum 3)) {}))
+  (list 3))
+
+(apl-test
+  "eval :name ⍵ from env"
+  (rv (apl-eval-ast (mkname "⍵") {:omega (apl-scalar 99) :alpha nil}))
+  (list 99))
+
+(apl-test
+  "eval :name ⍺ from env"
+  (rv (apl-eval-ast (mkname "⍺") {:omega nil :alpha (apl-scalar 7)}))
+  (list 7))
+
+(apl-test
+  "dfn {⍵+1} called monadic"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn1 (mkdyd "+" (mkname "⍵") (mknum 1)))
+      (apl-scalar 5)))
+  (list 6))
+
+(apl-test
+  "dfn {⍺+⍵} called dyadic"
+  (rv
+    (apl-call-dfn
+      (mkdfn1 (mkdyd "+" (mkname "⍺") (mkname "⍵")))
+      (apl-scalar 4)
+      (apl-scalar 9)))
+  (list 13))
+
+(apl-test
+  "dfn {⍺×⍵} dyadic on vectors"
+  (rv
+    (apl-call-dfn
+      (mkdfn1 (mkdyd "×" (mkname "⍺") (mkname "⍵")))
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 10 20 30))))
+  (list 10 40 90))
+
+(apl-test
+  "dfn {-⍵} monadic negate"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn1 (mkmon "-" (mkname "⍵")))
+      (make-array (list 3) (list 1 2 3))))
+  (list -1 -2 -3))
+
+(apl-test
+  "dfn {⍺-⍵} dyadic subtract scalar"
+  (rv
+    (apl-call-dfn
+      (mkdfn1 (mkdyd "-" (mkname "⍺") (mkname "⍵")))
+      (apl-scalar 10)
+      (apl-scalar 3)))
+  (list 7))
+
+(apl-test
+  "dfn {⌈⍺,⍵} not used (just verify : missing) — ceiling of right"
+  (rv
+    (apl-call-dfn-m (mkdfn1 (mkmon "⌈" (mkname "⍵"))) (apl-scalar 5)))
+  (list 5))
+
+(apl-test
+  "dfn nested dyad"
+  (rv
+    (apl-call-dfn
+      (mkdfn1
+        (mkdyd "+" (mkname "⍺") (mkdyd "×" (mkname "⍵") (mknum 2))))
+      (apl-scalar 1)
+      (apl-scalar 3)))
+  (list 7))
+
+(apl-test
+  "dfn local assign x←⍵+1; ⍺×x"
+  (rv
+    (apl-call-dfn
+      (mkdfn
+        (list
+          (mkasg "x" (mkdyd "+" (mkname "⍵") (mknum 1)))
+          (mkdyd "×" (mkname "⍺") (mkname "x"))))
+      (apl-scalar 3)
+      (apl-scalar 4)))
+  (list 15))
+
+(apl-test
+  "dfn guard: 0=⍵:99; ⍵×2 (true branch)"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkgrd (mkdyd "=" (mknum 0) (mkname "⍵")) (mknum 99))
+          (mkdyd "×" (mkname "⍵") (mknum 2))))
+      (apl-scalar 0)))
+  (list 99))
+
+(apl-test
+  "dfn guard: 0=⍵:99; ⍵×2 (false branch)"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkgrd (mkdyd "=" (mknum 0) (mkname "⍵")) (mknum 99))
+          (mkdyd "×" (mkname "⍵") (mknum 2))))
+      (apl-scalar 5)))
+  (list 10))
+
+(apl-test
+  "dfn default ⍺←10 used (monadic call)"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkasg "⍺" (mknum 10))
+          (mkdyd "+" (mkname "⍺") (mkname "⍵"))))
+      (apl-scalar 5)))
+  (list 15))
+
+(apl-test
+  "dfn default ⍺←10 ignored when ⍺ given (dyadic call)"
+  (rv
+    (apl-call-dfn
+      (mkdfn
+        (list
+          (mkasg "⍺" (mknum 10))
+          (mkdyd "+" (mkname "⍺") (mkname "⍵"))))
+      (apl-scalar 100)
+      (apl-scalar 5)))
+  (list 105))
+
+(apl-test
+  "dfn ∇ recursion: factorial via guard"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkgrd (mkdyd "=" (mknum 0) (mkname "⍵")) (mknum 1))
+          (mkdyd
+            "×"
+            (mkname "⍵")
+            (mkmon "∇" (mkdyd "-" (mkname "⍵") (mknum 1))))))
+      (apl-scalar 5)))
+  (list 120))
+
+(apl-test
+  "dfn ∇ recursion: 3 → 6 (factorial)"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkgrd (mkdyd "=" (mknum 0) (mkname "⍵")) (mknum 1))
+          (mkdyd
+            "×"
+            (mkname "⍵")
+            (mkmon "∇" (mkdyd "-" (mkname "⍵") (mknum 1))))))
+      (apl-scalar 3)))
+  (list 6))
+
+(apl-test
+  "dfn local: x←⍵+10; y←x×2; y"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkasg "x" (mkdyd "+" (mkname "⍵") (mknum 10)))
+          (mkasg "y" (mkdyd "×" (mkname "x") (mknum 2)))
+          (mkname "y")))
+      (apl-scalar 5)))
+  (list 30))
+
+(apl-test
+  "dfn first guard wins: many guards"
+  (rv
+    (apl-call-dfn-m
+      (mkdfn
+        (list
+          (mkgrd (mkdyd "=" (mknum 1) (mkname "⍵")) (mknum 100))
+          (mkgrd (mkdyd "=" (mknum 2) (mkname "⍵")) (mknum 200))
+          (mkgrd (mkdyd "=" (mknum 3) (mkname "⍵")) (mknum 300))
+          (mknum 0)))
+      (apl-scalar 2)))
+  (list 200))

lib/apl/tests/idioms.sx

@@ -0,0 +1,224 @@
+; APL idiom corpus — classic Roger Hui / Phil Last idioms expressed
+; through our runtime primitives.  Each test names the APL one-liner
+; and verifies the equivalent runtime call.
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mksh (fn (arr) (get arr :shape)))
+
+; ---------- reductions ----------
+
+(apl-test
+  "+/⍵ — sum"
+  (mkrv (apl-reduce apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 15))
+
+(apl-test
+  "(+/⍵)÷⍴⍵ — mean"
+  (mkrv
+    (apl-div
+      (apl-reduce apl-add (make-array (list 5) (list 1 2 3 4 5)))
+      (apl-scalar 5)))
+  (list 3))
+
+(apl-test
+  "⌈/⍵ — max"
+  (mkrv (apl-reduce apl-max (make-array (list 6) (list 3 1 4 1 5 9))))
+  (list 9))
+
+(apl-test
+  "⌊/⍵ — min"
+  (mkrv (apl-reduce apl-min (make-array (list 6) (list 3 1 4 1 5 9))))
+  (list 1))
+
+(apl-test
+  "(⌈/⍵)-⌊/⍵ — range"
+  (mkrv
+    (apl-sub
+      (apl-reduce apl-max (make-array (list 6) (list 3 1 4 1 5 9)))
+      (apl-reduce apl-min (make-array (list 6) (list 3 1 4 1 5 9)))))
+  (list 8))
+
+(apl-test
+  "×/⍵ — product"
+  (mkrv (apl-reduce apl-mul (make-array (list 4) (list 1 2 3 4))))
+  (list 24))
+
+(apl-test
+  "+\\⍵ — running sum"
+  (mkrv (apl-scan apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 3 6 10 15))
+
+; ---------- sort / order ----------
+
+(apl-test
+  "⍵[⍋⍵] — sort ascending"
+  (mkrv (apl-quicksort (make-array (list 5) (list 3 1 4 1 5))))
+  (list 1 1 3 4 5))
+
+(apl-test
+  "⌽⍵ — reverse"
+  (mkrv (apl-reverse (make-array (list 5) (list 1 2 3 4 5))))
+  (list 5 4 3 2 1))
+
+(apl-test
+  "⊃⌽⍵ — last element"
+  (mkrv
+    (apl-disclose (apl-reverse (make-array (list 4) (list 10 20 30 40)))))
+  (list 40))
+
+(apl-test
+  "1↑⍵ — first element"
+  (mkrv
+    (apl-take (apl-scalar 1) (make-array (list 4) (list 10 20 30 40))))
+  (list 10))
+
+(apl-test
+  "1↓⍵ — drop first"
+  (mkrv
+    (apl-drop (apl-scalar 1) (make-array (list 4) (list 10 20 30 40))))
+  (list 20 30 40))
+
+(apl-test
+  "¯1↓⍵ — drop last"
+  (mkrv
+    (apl-drop (apl-scalar -1) (make-array (list 4) (list 10 20 30 40))))
+  (list 10 20 30))
+
+; ---------- counts / membership ----------
+
+(apl-test
+  "≢⍵ — tally"
+  (mkrv (apl-tally (make-array (list 7) (list 9 8 7 6 5 4 3))))
+  (list 7))
+
+(apl-test
+  "+/⍵=v — count occurrences of v"
+  (mkrv
+    (apl-reduce
+      apl-add
+      (apl-eq (make-array (list 7) (list 1 2 3 2 1 3 2)) (apl-scalar 2))))
+  (list 3))
+
+(apl-test
+  "0=N|M — divisibility test"
+  (mkrv (apl-eq (apl-scalar 0) (apl-mod (apl-scalar 3) (apl-scalar 12))))
+  (list 1))
+
+; ---------- shape constructors ----------
+
+(apl-test
+  "N⍴1 — vector of N ones"
+  (mkrv (apl-reshape (apl-scalar 5) (apl-scalar 1)))
+  (list 1 1 1 1 1))
+
+(apl-test
+  "(N N)⍴0 — N×N zero matrix"
+  (mkrv (apl-reshape (make-array (list 2) (list 3 3)) (apl-scalar 0)))
+  (list 0 0 0 0 0 0 0 0 0))
+
+(apl-test
+  "⍳∘.=⍳ — N×N identity matrix"
+  (mkrv
+    (apl-outer apl-eq (apl-iota (apl-scalar 3)) (apl-iota (apl-scalar 3))))
+  (list 1 0 0 0 1 0 0 0 1))
+
+(apl-test
+  "⍳∘.×⍳ — multiplication table"
+  (mkrv
+    (apl-outer apl-mul (apl-iota (apl-scalar 3)) (apl-iota (apl-scalar 3))))
+  (list 1 2 3 2 4 6 3 6 9))
+
+; ---------- numerical idioms ----------
+
+(apl-test
+  "+\\⍳N — triangular numbers"
+  (mkrv (apl-scan apl-add (apl-iota (apl-scalar 5))))
+  (list 1 3 6 10 15))
+
+(apl-test
+  "+/⍳N=N×(N+1)÷2 — sum of 1..N"
+  (mkrv (apl-reduce apl-add (apl-iota (apl-scalar 10))))
+  (list 55))
+
+(apl-test
+  "×/⍳N — factorial via iota"
+  (mkrv (apl-reduce apl-mul (apl-iota (apl-scalar 5))))
+  (list 120))
+
+(apl-test
+  "2|⍵ — parity (1=odd)"
+  (mkrv (apl-mod (apl-scalar 2) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 0 1 0 1))
+
+(apl-test
+  "+/2|⍵ — count odd"
+  (mkrv
+    (apl-reduce
+      apl-add
+      (apl-mod (apl-scalar 2) (make-array (list 5) (list 1 2 3 4 5)))))
+  (list 3))
+
+; ---------- boolean idioms ----------
+
+(apl-test
+  "∧/⍵ — all-true"
+  (mkrv (apl-reduce apl-and (make-array (list 4) (list 1 1 1 1))))
+  (list 1))
+
+(apl-test
+  "∧/⍵ — all-true with zero is false"
+  (mkrv (apl-reduce apl-and (make-array (list 4) (list 1 1 0 1))))
+  (list 0))
+
+(apl-test
+  "∨/⍵ — any-true"
+  (mkrv (apl-reduce apl-or (make-array (list 4) (list 0 0 1 0))))
+  (list 1))
+
+(apl-test
+  "∨/⍵ — any-true all zero is false"
+  (mkrv (apl-reduce apl-or (make-array (list 4) (list 0 0 0 0))))
+  (list 0))
+
+; ---------- selection / scaling ----------
+
+(apl-test
+  "⍵×⍵ — square each"
+  (mkrv
+    (apl-mul
+      (make-array (list 4) (list 1 2 3 4))
+      (make-array (list 4) (list 1 2 3 4))))
+  (list 1 4 9 16))
+
+(apl-test
+  "+/⍵×⍵ — sum of squares"
+  (mkrv
+    (apl-reduce
+      apl-add
+      (apl-mul
+        (make-array (list 4) (list 1 2 3 4))
+        (make-array (list 4) (list 1 2 3 4)))))
+  (list 30))
+
+(apl-test
+  "⍵-(+/⍵)÷⍴⍵ — mean-centered"
+  (mkrv
+    (apl-sub
+      (make-array (list 5) (list 2 4 6 8 10))
+      (apl-div
+        (apl-reduce apl-add (make-array (list 5) (list 2 4 6 8 10)))
+        (apl-scalar 5))))
+  (list -4 -2 0 2 4))
+
+; ---------- shape / structure ----------
+
+(apl-test
+  ",⍵ — ravel"
+  (mkrv (apl-ravel (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2 3 4 5 6))
+
+(apl-test
+  "⍴⍴⍵ — rank"
+  (mkrv
+    (apl-shape (apl-shape (make-array (list 2 3) (list 1 2 3 4 5 6)))))
+  (list 2))

lib/apl/tests/operators.sx

@@ -0,0 +1,791 @@
+(define rv (fn (arr) (get arr :ravel)))
+(define sh (fn (arr) (get arr :shape)))
+
+(apl-test
+  "reduce +/ vector"
+  (rv (apl-reduce apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 15))
+
+(apl-test
+  "reduce x/ vector"
+  (rv (apl-reduce apl-mul (make-array (list 4) (list 1 2 3 4))))
+  (list 24))
+
+(apl-test
+  "reduce max/ vector"
+  (rv (apl-reduce apl-max (make-array (list 5) (list 3 1 4 1 5))))
+  (list 5))
+
+(apl-test
+  "reduce min/ vector"
+  (rv (apl-reduce apl-min (make-array (list 3) (list 3 1 4))))
+  (list 1))
+
+(apl-test
+  "reduce and/ all true"
+  (rv (apl-reduce apl-and (make-array (list 3) (list 1 1 1))))
+  (list 1))
+
+(apl-test
+  "reduce or/ with true"
+  (rv (apl-reduce apl-or (make-array (list 3) (list 0 0 1))))
+  (list 1))
+
+(apl-test
+  "reduce +/ single element"
+  (rv (apl-reduce apl-add (make-array (list 1) (list 42))))
+  (list 42))
+
+(apl-test
+  "reduce +/ scalar no-op"
+  (rv (apl-reduce apl-add (apl-scalar 7)))
+  (list 7))
+
+(apl-test
+  "reduce +/ shape is scalar"
+  (sh (apl-reduce apl-add (make-array (list 4) (list 1 2 3 4))))
+  (list))
+
+(apl-test
+  "reduce +/ matrix row sums shape"
+  (sh (apl-reduce apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2))
+
+(apl-test
+  "reduce +/ matrix row sums values"
+  (rv (apl-reduce apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 6 15))
+
+(apl-test
+  "reduce max/ matrix row maxima"
+  (rv (apl-reduce apl-max (make-array (list 2 3) (list 3 1 4 1 5 9))))
+  (list 4 9))
+
+(apl-test
+  "reduce-first +/ vector same as reduce"
+  (rv (apl-reduce-first apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 15))
+
+(apl-test
+  "reduce-first +/ matrix col sums shape"
+  (sh
+    (apl-reduce-first apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 3))
+
+(apl-test
+  "reduce-first +/ matrix col sums values"
+  (rv
+    (apl-reduce-first apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 5 7 9))
+
+(apl-test
+  "reduce-first max/ matrix col maxima"
+  (rv
+    (apl-reduce-first apl-max (make-array (list 3 2) (list 1 9 2 8 3 7))))
+  (list 3 9))
+
+(apl-test
+  "scan +\\ vector"
+  (rv (apl-scan apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 3 6 10 15))
+
+(apl-test
+  "scan x\\ vector cumulative product"
+  (rv (apl-scan apl-mul (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 6 24 120))
+
+(apl-test
+  "scan max\\ vector running max"
+  (rv (apl-scan apl-max (make-array (list 5) (list 3 1 4 1 5))))
+  (list 3 3 4 4 5))
+
+(apl-test
+  "scan min\\ vector running min"
+  (rv (apl-scan apl-min (make-array (list 5) (list 3 1 4 1 5))))
+  (list 3 1 1 1 1))
+
+(apl-test
+  "scan +\\ single element"
+  (rv (apl-scan apl-add (make-array (list 1) (list 42))))
+  (list 42))
+
+(apl-test
+  "scan +\\ scalar no-op"
+  (rv (apl-scan apl-add (apl-scalar 7)))
+  (list 7))
+
+(apl-test
+  "scan +\\ vector preserves shape"
+  (sh (apl-scan apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 5))
+
+(apl-test
+  "scan +\\ matrix preserves shape"
+  (sh (apl-scan apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2 3))
+
+(apl-test
+  "scan +\\ matrix row-wise"
+  (rv (apl-scan apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 3 6 4 9 15))
+
+(apl-test
+  "scan max\\ matrix row-wise running max"
+  (rv (apl-scan apl-max (make-array (list 2 3) (list 3 1 4 1 5 9))))
+  (list 3 3 4 1 5 9))
+
+(apl-test
+  "scan-first +\\ vector same as scan"
+  (rv (apl-scan-first apl-add (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 3 6 10 15))
+
+(apl-test
+  "scan-first +\\ scalar no-op"
+  (rv (apl-scan-first apl-add (apl-scalar 9)))
+  (list 9))
+
+(apl-test
+  "scan-first +\\ matrix preserves shape"
+  (sh (apl-scan-first apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2 3))
+
+(apl-test
+  "scan-first +\\ matrix col-wise"
+  (rv (apl-scan-first apl-add (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2 3 5 7 9))
+
+(apl-test
+  "scan-first max\\ matrix col-wise running max"
+  (rv (apl-scan-first apl-max (make-array (list 3 2) (list 3 1 4 1 5 9))))
+  (list 3 1 4 1 5 9))
+
+(apl-test
+  "each negate vector"
+  (rv (apl-each apl-neg-m (make-array (list 3) (list 1 2 3))))
+  (list -1 -2 -3))
+
+(apl-test
+  "each negate vector preserves shape"
+  (sh (apl-each apl-neg-m (make-array (list 3) (list 1 2 3))))
+  (list 3))
+
+(apl-test
+  "each reciprocal vector"
+  (rv (apl-each apl-recip (make-array (list 3) (list 1 2 4))))
+  (list 1 (/ 1 2) (/ 1 4)))
+
+(apl-test
+  "each abs vector"
+  (rv (apl-each apl-abs (make-array (list 4) (list -1 2 -3 4))))
+  (list 1 2 3 4))
+
+(apl-test "each scalar" (rv (apl-each apl-neg-m (apl-scalar 5))) (list -5))
+
+(apl-test
+  "each scalar shape"
+  (sh (apl-each apl-neg-m (apl-scalar 5)))
+  (list))
+
+(apl-test
+  "each negate matrix shape"
+  (sh (apl-each apl-neg-m (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2 3))
+
+(apl-test
+  "each negate matrix values"
+  (rv (apl-each apl-neg-m (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list -1 -2 -3 -4 -5 -6))
+
+(apl-test
+  "each-dyadic scalar+scalar"
+  (rv (apl-each-dyadic apl-add (apl-scalar 3) (apl-scalar 4)))
+  (list 7))
+
+(apl-test
+  "each-dyadic scalar+vector"
+  (rv
+    (apl-each-dyadic
+      apl-add
+      (apl-scalar 10)
+      (make-array (list 3) (list 1 2 3))))
+  (list 11 12 13))
+
+(apl-test
+  "each-dyadic vector+scalar"
+  (rv
+    (apl-each-dyadic
+      apl-add
+      (make-array (list 3) (list 1 2 3))
+      (apl-scalar 10)))
+  (list 11 12 13))
+
+(apl-test
+  "each-dyadic vector+vector"
+  (rv
+    (apl-each-dyadic
+      apl-add
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 10 20 30))))
+  (list 11 22 33))
+
+(apl-test
+  "each-dyadic mul matrix+matrix shape"
+  (sh
+    (apl-each-dyadic
+      apl-mul
+      (make-array (list 2 2) (list 1 2 3 4))
+      (make-array (list 2 2) (list 5 6 7 8))))
+  (list 2 2))
+
+(apl-test
+  "each-dyadic mul matrix+matrix values"
+  (rv
+    (apl-each-dyadic
+      apl-mul
+      (make-array (list 2 2) (list 1 2 3 4))
+      (make-array (list 2 2) (list 5 6 7 8))))
+  (list 5 12 21 32))
+
+(apl-test
+  "outer product mult table values"
+  (rv
+    (apl-outer
+      apl-mul
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 1 2 3))))
+  (list 1 2 3 2 4 6 3 6 9))
+
+(apl-test
+  "outer product mult table shape"
+  (sh
+    (apl-outer
+      apl-mul
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 1 2 3))))
+  (list 3 3))
+
+(apl-test
+  "outer product add table values"
+  (rv
+    (apl-outer
+      apl-add
+      (make-array (list 2) (list 1 2))
+      (make-array (list 3) (list 10 20 30))))
+  (list 11 21 31 12 22 32))
+
+(apl-test
+  "outer product add table shape"
+  (sh
+    (apl-outer
+      apl-add
+      (make-array (list 2) (list 1 2))
+      (make-array (list 3) (list 10 20 30))))
+  (list 2 3))
+
+(apl-test
+  "outer product scalar+vector shape"
+  (sh
+    (apl-outer apl-mul (apl-scalar 5) (make-array (list 3) (list 1 2 3))))
+  (list 3))
+
+(apl-test
+  "outer product scalar+vector values"
+  (rv
+    (apl-outer apl-mul (apl-scalar 5) (make-array (list 3) (list 1 2 3))))
+  (list 5 10 15))
+
+(apl-test
+  "outer product vector+scalar shape"
+  (sh
+    (apl-outer apl-mul (make-array (list 3) (list 1 2 3)) (apl-scalar 10)))
+  (list 3))
+
+(apl-test
+  "outer product scalar+scalar"
+  (rv (apl-outer apl-mul (apl-scalar 6) (apl-scalar 7)))
+  (list 42))
+
+(apl-test
+  "outer product scalar+scalar shape"
+  (sh (apl-outer apl-mul (apl-scalar 6) (apl-scalar 7)))
+  (list))
+
+(apl-test
+  "outer product equality identity matrix values"
+  (rv
+    (apl-outer
+      apl-eq
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 1 2 3))))
+  (list 1 0 0 0 1 0 0 0 1))
+
+(apl-test
+  "outer product matrix+vector rank doubling shape"
+  (sh
+    (apl-outer
+      apl-add
+      (make-array (list 2 2) (list 1 2 3 4))
+      (make-array (list 3) (list 10 20 30))))
+  (list 2 2 3))
+
+(apl-test
+  "outer product matrix+vector rank doubling values"
+  (rv
+    (apl-outer
+      apl-add
+      (make-array (list 2 2) (list 1 2 3 4))
+      (make-array (list 3) (list 10 20 30))))
+  (list 11 21 31 12 22 32 13 23 33 14 24 34))
+
+(apl-test
+  "inner +.× dot product"
+  (rv
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 4 5 6))))
+  (list 32))
+
+(apl-test
+  "inner +.× dot product shape is scalar"
+  (sh
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 4 5 6))))
+  (list))
+
+(apl-test
+  "inner +.× matrix multiply 2x3 * 3x2 shape"
+  (sh
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3 2) (list 7 8 9 10 11 12))))
+  (list 2 2))
+
+(apl-test
+  "inner +.× matrix multiply 2x3 * 3x2 values"
+  (rv
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3 2) (list 7 8 9 10 11 12))))
+  (list 58 64 139 154))
+
+(apl-test
+  "inner +.× identity matrix 2x2"
+  (rv
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 2 2) (list 1 0 0 1))
+      (make-array (list 2 2) (list 5 6 7 8))))
+  (list 5 6 7 8))
+
+(apl-test
+  "inner ∧.= equal vectors"
+  (rv
+    (apl-inner
+      apl-and
+      apl-eq
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 1 2 3))))
+  (list 1))
+
+(apl-test
+  "inner ∧.= unequal vectors"
+  (rv
+    (apl-inner
+      apl-and
+      apl-eq
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 1 9 3))))
+  (list 0))
+
+(apl-test
+  "inner +.× matrix * vector shape"
+  (sh
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3) (list 7 8 9))))
+  (list 2))
+
+(apl-test
+  "inner +.× matrix * vector values"
+  (rv
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3) (list 7 8 9))))
+  (list 50 122))
+
+(apl-test
+  "inner +.× vector * matrix shape"
+  (sh
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3 2) (list 4 5 6 7 8 9))))
+  (list 2))
+
+(apl-test
+  "inner +.× vector * matrix values"
+  (rv
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3 2) (list 4 5 6 7 8 9))))
+  (list 40 46))
+
+(apl-test
+  "inner +.× single-element vectors"
+  (rv
+    (apl-inner
+      apl-add
+      apl-mul
+      (make-array (list 1) (list 6))
+      (make-array (list 1) (list 7))))
+  (list 42))
+
+(apl-test
+  "commute +⍨ scalar doubles"
+  (rv (apl-commute apl-add (apl-scalar 5)))
+  (list 10))
+
+(apl-test
+  "commute ×⍨ vector squares"
+  (rv (apl-commute apl-mul (make-array (list 4) (list 1 2 3 4))))
+  (list 1 4 9 16))
+
+(apl-test
+  "commute +⍨ vector doubles"
+  (rv (apl-commute apl-add (make-array (list 3) (list 1 2 3))))
+  (list 2 4 6))
+
+(apl-test
+  "commute +⍨ shape preserved"
+  (sh (apl-commute apl-add (make-array (list 3) (list 1 2 3))))
+  (list 3))
+
+(apl-test
+  "commute ×⍨ matrix shape preserved"
+  (sh (apl-commute apl-mul (make-array (list 2 2) (list 1 2 3 4))))
+  (list 2 2))
+
+(apl-test
+  "commute-dyadic -⍨ swaps subtraction"
+  (rv (apl-commute-dyadic apl-sub (apl-scalar 5) (apl-scalar 3)))
+  (list -2))
+
+(apl-test
+  "commute-dyadic ÷⍨ swaps division"
+  (rv (apl-commute-dyadic apl-div (apl-scalar 4) (apl-scalar 12)))
+  (list 3))
+
+(apl-test
+  "commute-dyadic -⍨ on vectors"
+  (rv
+    (apl-commute-dyadic
+      apl-sub
+      (make-array (list 3) (list 10 20 30))
+      (make-array (list 3) (list 1 2 3))))
+  (list -9 -18 -27))
+
+(apl-test
+  "commute-dyadic +⍨ commutative same result"
+  (rv
+    (apl-commute-dyadic
+      apl-add
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 10 20 30))))
+  (list 11 22 33))
+
+(apl-test
+  "commute-dyadic ×⍨ commutative same result"
+  (rv
+    (apl-commute-dyadic
+      apl-mul
+      (make-array (list 3) (list 2 3 4))
+      (make-array (list 3) (list 5 6 7))))
+  (list 10 18 28))
+
+(apl-test
+  "compose -∘| scalar (negative abs)"
+  (rv (apl-compose apl-neg-m apl-abs (apl-scalar -7)))
+  (list -7))
+
+(apl-test
+  "compose -∘| vector"
+  (rv
+    (apl-compose apl-neg-m apl-abs (make-array (list 4) (list -1 2 -3 4))))
+  (list -1 -2 -3 -4))
+
+(apl-test
+  "compose ⌊∘- (floor of negate)"
+  (rv (apl-compose apl-floor apl-neg-m (make-array (list 3) (list 1 2 3))))
+  (list -1 -2 -3))
+
+(apl-test
+  "compose -∘| matrix shape preserved"
+  (sh
+    (apl-compose apl-neg-m apl-abs (make-array (list 2 2) (list -1 2 -3 4))))
+  (list 2 2))
+
+(apl-test
+  "compose-dyadic +∘- equals subtract scalar"
+  (rv (apl-compose-dyadic apl-add apl-neg-m (apl-scalar 10) (apl-scalar 3)))
+  (list 7))
+
+(apl-test
+  "compose-dyadic +∘- equals subtract vector"
+  (rv
+    (apl-compose-dyadic
+      apl-add
+      apl-neg-m
+      (make-array (list 3) (list 10 20 30))
+      (make-array (list 3) (list 1 2 3))))
+  (list 9 18 27))
+
+(apl-test
+  "compose-dyadic -∘| (subtract abs)"
+  (rv (apl-compose-dyadic apl-sub apl-abs (apl-scalar 10) (apl-scalar -3)))
+  (list 7))
+
+(apl-test
+  "compose-dyadic ×∘- (multiply by negative)"
+  (rv
+    (apl-compose-dyadic
+      apl-mul
+      apl-neg-m
+      (make-array (list 3) (list 2 3 4))
+      (make-array (list 3) (list 1 2 3))))
+  (list -2 -6 -12))
+
+(apl-test
+  "compose-dyadic shape preserved"
+  (sh
+    (apl-compose-dyadic
+      apl-add
+      apl-neg-m
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 2 3) (list 1 1 1 1 1 1))))
+  (list 2 3))
+
+(apl-test
+  "power n=0 identity"
+  (rv (apl-power (fn (a) (apl-add a (apl-scalar 1))) 0 (apl-scalar 5)))
+  (list 5))
+
+(apl-test
+  "power increment by 3"
+  (rv (apl-power (fn (a) (apl-add a (apl-scalar 1))) 3 (apl-scalar 0)))
+  (list 3))
+
+(apl-test
+  "power double 4 times = 16"
+  (rv (apl-power (fn (a) (apl-mul a (apl-scalar 2))) 4 (apl-scalar 1)))
+  (list 16))
+
+(apl-test
+  "power on vector +5"
+  (rv
+    (apl-power
+      (fn (a) (apl-add a (apl-scalar 1)))
+      5
+      (make-array (list 3) (list 1 2 3))))
+  (list 6 7 8))
+
+(apl-test
+  "power on vector preserves shape"
+  (sh
+    (apl-power
+      (fn (a) (apl-add a (apl-scalar 1)))
+      5
+      (make-array (list 3) (list 1 2 3))))
+  (list 3))
+
+(apl-test
+  "power on matrix"
+  (rv
+    (apl-power
+      (fn (a) (apl-mul a (apl-scalar 3)))
+      2
+      (make-array (list 2 2) (list 1 2 3 4))))
+  (list 9 18 27 36))
+
+(apl-test
+  "power-fixed identity stops immediately"
+  (rv (apl-power-fixed (fn (a) a) (make-array (list 3) (list 1 2 3))))
+  (list 1 2 3))
+
+(apl-test
+  "power-fixed floor half scalar to 0"
+  (rv
+    (apl-power-fixed
+      (fn (a) (apl-floor (apl-div a (apl-scalar 2))))
+      (apl-scalar 100)))
+  (list 0))
+
+(apl-test
+  "power-fixed shape preserved"
+  (sh
+    (apl-power-fixed (fn (a) a) (make-array (list 2 2) (list 1 2 3 4))))
+  (list 2 2))
+
+(apl-test
+  "rank tally⍤1 row tallies"
+  (rv (apl-rank apl-tally 1 (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 3 3))
+
+(apl-test
+  "rank tally⍤1 row tallies shape"
+  (sh (apl-rank apl-tally 1 (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2))
+
+(apl-test
+  "rank neg⍤0 vector scalar cells"
+  (rv (apl-rank apl-neg-m 0 (make-array (list 3) (list 1 2 3))))
+  (list -1 -2 -3))
+
+(apl-test
+  "rank neg⍤0 vector preserves shape"
+  (sh (apl-rank apl-neg-m 0 (make-array (list 3) (list 1 2 3))))
+  (list 3))
+
+(apl-test
+  "rank neg⍤1 matrix per-row"
+  (rv (apl-rank apl-neg-m 1 (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list -1 -2 -3 -4 -5 -6))
+
+(apl-test
+  "rank neg⍤1 matrix preserves shape"
+  (sh (apl-rank apl-neg-m 1 (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2 3))
+
+(apl-test
+  "rank k>=rank fallthrough"
+  (rv (apl-rank apl-tally 5 (make-array (list 4) (list 1 2 3 4))))
+  (list 4))
+
+(apl-test
+  "rank tally⍤2 whole matrix tally"
+  (rv
+    (apl-rank
+      apl-tally
+      2
+      (make-array (list 3 5) (list 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))))
+  (list 3))
+
+(apl-test
+  "rank reverse⍤1 matrix reverse rows"
+  (rv (apl-rank apl-reverse 1 (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 3 2 1 6 5 4))
+
+(apl-test
+  "rank tally⍤1 3x4 row tallies"
+  (rv
+    (apl-rank
+      apl-tally
+      1
+      (make-array (list 3 4) (list 1 2 3 4 5 6 7 8 9 10 11 12))))
+  (list 4 4 4))
+
+(apl-test
+  "at-replace single index"
+  (rv
+    (apl-at-replace
+      (apl-scalar 99)
+      (make-array (list 1) (list 2))
+      (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 99 3 4 5))
+
+(apl-test
+  "at-replace multiple indices vector vals"
+  (rv
+    (apl-at-replace
+      (make-array (list 2) (list 99 88))
+      (make-array (list 2) (list 2 4))
+      (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 99 3 88 5))
+
+(apl-test
+  "at-replace scalar broadcast"
+  (rv
+    (apl-at-replace
+      (apl-scalar 0)
+      (make-array (list 3) (list 1 3 5))
+      (make-array (list 5) (list 10 20 30 40 50))))
+  (list 0 20 0 40 0))
+
+(apl-test
+  "at-replace preserves shape"
+  (sh
+    (apl-at-replace
+      (apl-scalar 99)
+      (make-array (list 1) (list 2))
+      (make-array (list 5) (list 1 2 3 4 5))))
+  (list 5))
+
+(apl-test
+  "at-replace last index"
+  (rv
+    (apl-at-replace
+      (apl-scalar 99)
+      (make-array (list 1) (list 5))
+      (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3 4 99))
+
+(apl-test
+  "at-replace on matrix linear-index"
+  (rv
+    (apl-at-replace
+      (apl-scalar 99)
+      (make-array (list 1) (list 3))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2 99 4 5 6))
+
+(apl-test
+  "at-apply negate at indices"
+  (rv
+    (apl-at-apply
+      apl-neg-m
+      (make-array (list 3) (list 1 3 5))
+      (make-array (list 5) (list 1 2 3 4 5))))
+  (list -1 2 -3 4 -5))
+
+(apl-test
+  "at-apply double at index 1"
+  (rv
+    (apl-at-apply
+      (fn (a) (apl-mul a (apl-scalar 2)))
+      (make-array (list 1) (list 1))
+      (make-array (list 2) (list 5 10))))
+  (list 10 10))
+
+(apl-test
+  "at-apply preserves shape"
+  (sh
+    (apl-at-apply
+      apl-neg-m
+      (make-array (list 2) (list 1 3))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2 3))
+
+(apl-test
+  "at-apply on matrix linear-index"
+  (rv
+    (apl-at-apply
+      apl-neg-m
+      (make-array (list 2) (list 1 6))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list -1 2 3 4 5 -6))

lib/apl/tests/parse.sx

@@ -0,0 +1,340 @@
+(define apl-test-count 0)
+(define apl-test-pass  0)
+(define apl-test-fails (list))
+
+(define apl-test
+  (fn (name actual expected)
+    (begin
+      (set! apl-test-count (+ apl-test-count 1))
+      (if (= actual expected)
+        (set! apl-test-pass (+ apl-test-pass 1))
+        (append! apl-test-fails {:name name :actual actual :expected expected})))))
+
+(define tok-types
+  (fn (src)
+    (map (fn (t) (get t :type)) (apl-tokenize src))))
+
+(define tok-values
+  (fn (src)
+    (map (fn (t) (get t :value)) (apl-tokenize src))))
+
+(define tok-count
+  (fn (src)
+    (len (apl-tokenize src))))
+
+(define tok-type-at
+  (fn (src i)
+    (get (nth (apl-tokenize src) i) :type)))
+
+(define tok-value-at
+  (fn (src i)
+    (get (nth (apl-tokenize src) i) :value)))
+
+(apl-test "empty: no tokens"        (tok-count "")           0)
+(apl-test "empty: whitespace only"  (tok-count "   ")        0)
+(apl-test "num: zero"               (tok-values "0")         (list 0))
+(apl-test "num: positive"           (tok-values "42")        (list 42))
+(apl-test "num: large"              (tok-values "12345")     (list 12345))
+(apl-test "num: negative"           (tok-values "¯5")        (list -5))
+(apl-test "num: negative zero"      (tok-values "¯0")        (list 0))
+(apl-test "num: strand count"       (tok-count "1 2 3")      3)
+(apl-test "num: strand types"       (tok-types "1 2 3")      (list :num :num :num))
+(apl-test "num: strand values"      (tok-values "1 2 3")     (list 1 2 3))
+(apl-test "num: neg in strand"      (tok-values "1 ¯2 3")    (list 1 -2 3))
+(apl-test "str: empty"              (tok-values "''")        (list ""))
+(apl-test "str: single char"        (tok-values "'a'")       (list "a"))
+(apl-test "str: word"               (tok-values "'hello'")   (list "hello"))
+(apl-test "str: escaped quote"      (tok-values "''''")      (list "'"))
+(apl-test "str: type"               (tok-types "'abc'")      (list :str))
+(apl-test "name: simple"            (tok-values "foo")       (list "foo"))
+(apl-test "name: type"              (tok-types "foo")        (list :name))
+(apl-test "name: mixed case"        (tok-values "MyVar")     (list "MyVar"))
+(apl-test "name: with digits"       (tok-values "x1")        (list "x1"))
+(apl-test "name: system var"        (tok-values "⎕IO")       (list "⎕IO"))
+(apl-test "name: system var type"   (tok-types "⎕IO")        (list :name))
+(apl-test "glyph: plus"             (tok-types "+")          (list :glyph))
+(apl-test "glyph: plus value"       (tok-values "+")         (list "+"))
+(apl-test "glyph: iota"             (tok-values "⍳")         (list "⍳"))
+(apl-test "glyph: reduce"           (tok-values "+/")        (list "+" "/"))
+(apl-test "glyph: floor"            (tok-values "⌊")         (list "⌊"))
+(apl-test "glyph: rho"              (tok-values "⍴")         (list "⍴"))
+(apl-test "glyph: alpha omega"      (tok-types "⍺ ⍵")        (list :glyph :glyph))
+(apl-test "punct: lparen"           (tok-types "(")          (list :lparen))
+(apl-test "punct: rparen"           (tok-types ")")          (list :rparen))
+(apl-test "punct: brackets"         (tok-types "[42]")       (list :lbracket :num :rbracket))
+(apl-test "punct: braces"           (tok-types "{}")         (list :lbrace :rbrace))
+(apl-test "punct: semi"             (tok-types ";")          (list :semi))
+(apl-test "assign: arrow"           (tok-types "x←1")        (list :name :assign :num))
+(apl-test "diamond: separator"      (tok-types "1⋄2")        (list :num :diamond :num))
+(apl-test "newline: emitted"        (tok-types "1\n2")       (list :num :newline :num))
+(apl-test "comment: skipped"        (tok-count "⍝ ignore me") 0)
+(apl-test "comment: rest ignored"   (tok-count "1 ⍝ note")  1)
+(apl-test "colon: bare"             (tok-types ":")          (list :colon))
+(apl-test "keyword: If"             (tok-values ":If")       (list ":If"))
+(apl-test "keyword: type"           (tok-types ":While")     (list :keyword))
+(apl-test "keyword: EndFor"         (tok-values ":EndFor")   (list ":EndFor"))
+(apl-test "expr: +/ ⍳ 5"           (tok-types "+/ ⍳ 5")     (list :glyph :glyph :glyph :num))
+(apl-test "expr: x←42"             (tok-count "x←42")       3)
+(apl-test "expr: dfn body"          (tok-types "{⍺+⍵}")
+                                    (list :lbrace :glyph :glyph :glyph :rbrace))
+
+(define apl-tokenize-test-summary
+  (str "tokenizer " apl-test-pass "/" apl-test-count
+       (if (= (len apl-test-fails) 0) "" (str " FAILS: " apl-test-fails))))
+
+; ===========================================================================
+; Parser tests
+; ===========================================================================
+
+; Helper: parse an APL source string and return the AST
+(define parse
+  (fn (src) (parse-apl src)))
+
+; Helper: build an expected AST node using keyword-tagged lists
+(define num-node    (fn (n)       (list :num n)))
+(define str-node    (fn (s)       (list :str s)))
+(define name-node   (fn (n)       (list :name n)))
+(define fn-node     (fn (g)       (list :fn-glyph g)))
+(define fn-nm       (fn (n)       (list :fn-name n)))
+(define assign-node (fn (nm expr) (list :assign nm expr)))
+(define monad-node  (fn (f a)     (list :monad f a)))
+(define dyad-node   (fn (f l r)   (list :dyad f l r)))
+(define derived-fn  (fn (op f)    (list :derived-fn op f)))
+(define derived-fn2 (fn (op f g)  (list :derived-fn2 op f g)))
+(define outer-node  (fn (f)       (list :outer "∘." f)))
+(define guard-node  (fn (c e)     (list :guard c e)))
+
+; ---- numeric literals ----
+
+(apl-test "parse: num literal"
+  (parse "42")
+  (num-node 42))
+
+(apl-test "parse: negative num"
+  (parse "¯3")
+  (num-node -3))
+
+(apl-test "parse: zero"
+  (parse "0")
+  (num-node 0))
+
+; ---- string literals ----
+
+(apl-test "parse: str literal"
+  (parse "'hello'")
+  (str-node "hello"))
+
+(apl-test "parse: empty str"
+  (parse "''")
+  (str-node ""))
+
+; ---- name reference ----
+
+(apl-test "parse: name"
+  (parse "x")
+  (name-node "x"))
+
+(apl-test "parse: system name"
+  (parse "⎕IO")
+  (name-node "⎕IO"))
+
+; ---- strands (vec nodes) ----
+
+(apl-test "parse: strand 3 nums"
+  (parse "1 2 3")
+  (list :vec (num-node 1) (num-node 2) (num-node 3)))
+
+(apl-test "parse: strand 2 nums"
+  (parse "1 2")
+  (list :vec (num-node 1) (num-node 2)))
+
+(apl-test "parse: strand with negatives"
+  (parse "1 ¯2 3")
+  (list :vec (num-node 1) (num-node -2) (num-node 3)))
+
+; ---- assignment ----
+
+(apl-test "parse: assignment"
+  (parse "x←42")
+  (assign-node "x" (num-node 42)))
+
+(apl-test "parse: assignment with spaces"
+  (parse "x ← 42")
+  (assign-node "x" (num-node 42)))
+
+(apl-test "parse: assignment of expr"
+  (parse "r←2+3")
+  (assign-node "r" (dyad-node (fn-node "+") (num-node 2) (num-node 3))))
+
+; ---- monadic functions ----
+
+(apl-test "parse: monadic iota"
+  (parse "⍳5")
+  (monad-node (fn-node "⍳") (num-node 5)))
+
+(apl-test "parse: monadic iota with space"
+  (parse "⍳ 5")
+  (monad-node (fn-node "⍳") (num-node 5)))
+
+(apl-test "parse: monadic negate"
+  (parse "-3")
+  (monad-node (fn-node "-") (num-node 3)))
+
+(apl-test "parse: monadic floor"
+  (parse "⌊2")
+  (monad-node (fn-node "⌊") (num-node 2)))
+
+(apl-test "parse: monadic of name"
+  (parse "⍴x")
+  (monad-node (fn-node "⍴") (name-node "x")))
+
+; ---- dyadic functions ----
+
+(apl-test "parse: dyadic plus"
+  (parse "2+3")
+  (dyad-node (fn-node "+") (num-node 2) (num-node 3)))
+
+(apl-test "parse: dyadic times"
+  (parse "2×3")
+  (dyad-node (fn-node "×") (num-node 2) (num-node 3)))
+
+(apl-test "parse: dyadic with names"
+  (parse "x+y")
+  (dyad-node (fn-node "+") (name-node "x") (name-node "y")))
+
+; ---- right-to-left evaluation ----
+
+(apl-test "parse: right-to-left 2×3+4"
+  (parse "2×3+4")
+  (dyad-node (fn-node "×") (num-node 2)
+    (dyad-node (fn-node "+") (num-node 3) (num-node 4))))
+
+(apl-test "parse: right-to-left chain"
+  (parse "1+2×3-4")
+  (dyad-node (fn-node "+") (num-node 1)
+    (dyad-node (fn-node "×") (num-node 2)
+      (dyad-node (fn-node "-") (num-node 3) (num-node 4)))))
+
+; ---- parenthesized subexpressions ----
+
+(apl-test "parse: parens override order"
+  (parse "(2+3)×4")
+  (dyad-node (fn-node "×")
+    (dyad-node (fn-node "+") (num-node 2) (num-node 3))
+    (num-node 4)))
+
+(apl-test "parse: nested parens"
+  (parse "((2+3))")
+  (dyad-node (fn-node "+") (num-node 2) (num-node 3)))
+
+(apl-test "parse: paren in dyadic right"
+  (parse "2×(3+4)")
+  (dyad-node (fn-node "×") (num-node 2)
+    (dyad-node (fn-node "+") (num-node 3) (num-node 4))))
+
+; ---- operators → derived functions ----
+
+(apl-test "parse: reduce +"
+  (parse "+/x")
+  (monad-node (derived-fn "/" (fn-node "+")) (name-node "x")))
+
+(apl-test "parse: reduce iota"
+  (parse "+/⍳5")
+  (monad-node (derived-fn "/" (fn-node "+"))
+    (monad-node (fn-node "⍳") (num-node 5))))
+
+(apl-test "parse: scan"
+  (parse "+\\x")
+  (monad-node (derived-fn "\\" (fn-node "+")) (name-node "x")))
+
+(apl-test "parse: each"
+  (parse "⍳¨x")
+  (monad-node (derived-fn "¨" (fn-node "⍳")) (name-node "x")))
+
+(apl-test "parse: commute"
+  (parse "-⍨3")
+  (monad-node (derived-fn "⍨" (fn-node "-")) (num-node 3)))
+
+(apl-test "parse: stacked ops"
+  (parse "+/¨x")
+  (monad-node (derived-fn "¨" (derived-fn "/" (fn-node "+"))) (name-node "x")))
+
+; ---- outer product ----
+
+(apl-test "parse: outer product monadic"
+  (parse "∘.×")
+  (outer-node (fn-node "×")))
+
+(apl-test "parse: outer product dyadic names"
+  (parse "x ∘.× y")
+  (dyad-node (outer-node (fn-node "×")) (name-node "x") (name-node "y")))
+
+(apl-test "parse: outer product dyadic strands"
+  (parse "1 2 3 ∘.× 4 5 6")
+  (dyad-node (outer-node (fn-node "×"))
+    (list :vec (num-node 1) (num-node 2) (num-node 3))
+    (list :vec (num-node 4) (num-node 5) (num-node 6))))
+
+; ---- inner product ----
+
+(apl-test "parse: inner product"
+  (parse "+.×")
+  (derived-fn2 "." (fn-node "+") (fn-node "×")))
+
+(apl-test "parse: inner product applied"
+  (parse "a +.× b")
+  (dyad-node (derived-fn2 "." (fn-node "+") (fn-node "×"))
+    (name-node "a") (name-node "b")))
+
+; ---- dfn (anonymous function) ----
+
+(apl-test "parse: simple dfn"
+  (parse "{⍺+⍵}")
+  (list :dfn (dyad-node (fn-node "+") (name-node "⍺") (name-node "⍵"))))
+
+(apl-test "parse: monadic dfn"
+  (parse "{⍵×2}")
+  (list :dfn (dyad-node (fn-node "×") (name-node "⍵") (num-node 2))))
+
+(apl-test "parse: dfn self-ref"
+  (parse "{⍵≤1:1 ⋄ ⍵×∇ ⍵-1}")
+  (list :dfn
+    (guard-node (dyad-node (fn-node "≤") (name-node "⍵") (num-node 1)) (num-node 1))
+    (dyad-node (fn-node "×") (name-node "⍵")
+      (monad-node (fn-node "∇") (dyad-node (fn-node "-") (name-node "⍵") (num-node 1))))))
+
+; ---- dfn applied ----
+
+(apl-test "parse: dfn as function"
+  (parse "{⍺+⍵} 3")
+  (monad-node
+    (list :dfn (dyad-node (fn-node "+") (name-node "⍺") (name-node "⍵")))
+    (num-node 3)))
+
+; ---- multi-statement ----
+
+(apl-test "parse: diamond separator"
+  (let ((result (parse "x←1 ⋄ x+2")))
+    (= (first result) :program))
+  true)
+
+(apl-test "parse: diamond first stmt"
+  (let ((result (parse "x←1 ⋄ x+2")))
+    (nth result 1))
+  (assign-node "x" (num-node 1)))
+
+(apl-test "parse: diamond second stmt"
+  (let ((result (parse "x←1 ⋄ x+2")))
+    (nth result 2))
+  (dyad-node (fn-node "+") (name-node "x") (num-node 2)))
+
+; ---- combined summary ----
+
+(define apl-parse-test-count (- apl-test-count 46))
+(define apl-parse-test-pass  (- apl-test-pass 46))
+
+(define apl-test-summary
+  (str
+    "tokenizer 46/46  |  "
+    "parser " apl-parse-test-pass "/" apl-parse-test-count
+    (if (= (len apl-test-fails) 0) "" (str "  FAILS: " apl-test-fails))))

lib/apl/tests/programs.sx

@@ -0,0 +1,306 @@
+; Tests for classic APL programs (lib/apl/tests/programs/*.apl).
+; Programs are showcase APL source; runtime impl is in lib/apl/runtime.sx.
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mksh (fn (arr) (get arr :shape)))
+
+; ===== primes (Sieve of Eratosthenes) =====
+
+(apl-test "primes 1 → empty" (mkrv (apl-primes 1)) (list))
+
+(apl-test "primes 2 → just 2" (mkrv (apl-primes 2)) (list 2))
+
+(apl-test "primes 10 → 2 3 5 7" (mkrv (apl-primes 10)) (list 2 3 5 7))
+
+(apl-test
+  "primes 20 → 2 3 5 7 11 13 17 19"
+  (mkrv (apl-primes 20))
+  (list 2 3 5 7 11 13 17 19))
+
+(apl-test
+  "primes 30"
+  (mkrv (apl-primes 30))
+  (list 2 3 5 7 11 13 17 19 23 29))
+
+(apl-test
+  "primes 50"
+  (mkrv (apl-primes 50))
+  (list 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47))
+
+(apl-test "primes 7 length" (first (mksh (apl-primes 7))) 4)
+
+(apl-test "primes 100 has 25 primes" (first (mksh (apl-primes 100))) 25)
+
+; ===== compress helper sanity =====
+
+(apl-test
+  "compress 1 0 1 0 1 / 10 20 30 40 50"
+  (mkrv
+    (apl-compress
+      (make-array (list 5) (list 1 0 1 0 1))
+      (make-array (list 5) (list 10 20 30 40 50))))
+  (list 10 30 50))
+
+(apl-test
+  "compress all-zero mask → empty"
+  (mkrv
+    (apl-compress
+      (make-array (list 3) (list 0 0 0))
+      (make-array (list 3) (list 1 2 3))))
+  (list))
+
+(apl-test
+  "compress all-one mask → full vector"
+  (mkrv
+    (apl-compress
+      (make-array (list 3) (list 1 1 1))
+      (make-array (list 3) (list 1 2 3))))
+  (list 1 2 3))
+
+(apl-test
+  "life: empty 5x5 stays empty"
+  (mkrv
+    (apl-life-step
+      (make-array
+        (list 5 5)
+        (list 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))))
+  (list 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+(apl-test
+  "life: horizontal blinker → vertical blinker"
+  (mkrv
+    (apl-life-step
+      (make-array
+        (list 5 5)
+        (list 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0))))
+  (list 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0))
+
+(apl-test
+  "life: vertical blinker → horizontal blinker"
+  (mkrv
+    (apl-life-step
+      (make-array
+        (list 5 5)
+        (list 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0))))
+  (list 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0))
+
+(apl-test
+  "life: blinker has period 2"
+  (mkrv
+    (apl-life-step
+      (apl-life-step
+        (make-array
+          (list 5 5)
+          (list 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0)))))
+  (list 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0))
+
+(apl-test
+  "life: 2x2 block stable on 5x5"
+  (mkrv
+    (apl-life-step
+      (make-array
+        (list 5 5)
+        (list 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0))))
+  (list 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0))
+
+(apl-test
+  "life: shape preserved"
+  (mksh
+    (apl-life-step
+      (make-array
+        (list 5 5)
+        (list 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0))))
+  (list 5 5))
+
+(apl-test
+  "life: glider on 6x6 advances"
+  (mkrv
+    (apl-life-step
+      (make-array
+        (list 6 6)
+        (list
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          1
+          0
+          0
+          0
+          0
+          0
+          0
+          1
+          0
+          0
+          0
+          1
+          1
+          1
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0
+          0))))
+  (list
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    1
+    0
+    1
+    0
+    0
+    0
+    0
+    1
+    1
+    0
+    0
+    0
+    0
+    1
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0
+    0))
+
+(apl-test
+  "mandelbrot c=0 stays bounded"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list 0)) 100))
+  (list 100))
+
+(apl-test
+  "mandelbrot c=-1 cycle bounded"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list -1)) 100))
+  (list 100))
+
+(apl-test
+  "mandelbrot c=-2 boundary stays bounded"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list -2)) 100))
+  (list 100))
+
+(apl-test
+  "mandelbrot c=0.25 boundary stays bounded"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list 0.25)) 100))
+  (list 100))
+
+(apl-test
+  "mandelbrot c=1 escapes at iter 3"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list 1)) 100))
+  (list 3))
+
+(apl-test
+  "mandelbrot c=0.5 escapes at iter 5"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list 0.5)) 100))
+  (list 5))
+
+(apl-test
+  "mandelbrot batched grid (rank-polymorphic)"
+  (mkrv (apl-mandelbrot-1d (make-array (list 5) (list -2 -1 0 1 2)) 10))
+  (list 10 10 10 3 2))
+
+(apl-test
+  "mandelbrot batched preserves shape"
+  (mksh (apl-mandelbrot-1d (make-array (list 5) (list -2 -1 0 1 2)) 10))
+  (list 5))
+
+(apl-test
+  "mandelbrot c=-1.5 stays bounded"
+  (mkrv (apl-mandelbrot-1d (make-array (list 1) (list -1.5)) 100))
+  (list 100))
+
+(apl-test "queens 1 → 1 solution" (mkrv (apl-queens 1)) (list 1))
+
+(apl-test "queens 2 → 0 solutions" (mkrv (apl-queens 2)) (list 0))
+
+(apl-test "queens 3 → 0 solutions" (mkrv (apl-queens 3)) (list 0))
+
+(apl-test "queens 4 → 2 solutions" (mkrv (apl-queens 4)) (list 2))
+
+(apl-test "queens 5 → 10 solutions" (mkrv (apl-queens 5)) (list 10))
+
+(apl-test "queens 6 → 4 solutions" (mkrv (apl-queens 6)) (list 4))
+
+(apl-test "queens 7 → 40 solutions" (mkrv (apl-queens 7)) (list 40))
+
+(apl-test "queens 8 → 92 solutions" (mkrv (apl-queens 8)) (list 92))
+
+(apl-test "permutations of 3 has 6" (len (apl-permutations 3)) 6)
+
+(apl-test "permutations of 4 has 24" (len (apl-permutations 4)) 24)
+
+(apl-test
+  "quicksort empty"
+  (mkrv (apl-quicksort (make-array (list 0) (list))))
+  (list))
+
+(apl-test
+  "quicksort single"
+  (mkrv (apl-quicksort (make-array (list 1) (list 42))))
+  (list 42))
+
+(apl-test
+  "quicksort already sorted"
+  (mkrv (apl-quicksort (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3 4 5))
+
+(apl-test
+  "quicksort reverse sorted"
+  (mkrv (apl-quicksort (make-array (list 5) (list 5 4 3 2 1))))
+  (list 1 2 3 4 5))
+
+(apl-test
+  "quicksort with duplicates"
+  (mkrv (apl-quicksort (make-array (list 7) (list 3 1 4 1 5 9 2))))
+  (list 1 1 2 3 4 5 9))
+
+(apl-test
+  "quicksort all equal"
+  (mkrv (apl-quicksort (make-array (list 5) (list 7 7 7 7 7))))
+  (list 7 7 7 7 7))
+
+(apl-test
+  "quicksort negatives"
+  (mkrv (apl-quicksort (make-array (list 5) (list -3 1 -1 2 0))))
+  (list -3 -1 0 1 2))
+
+(apl-test
+  "quicksort 11-element pi"
+  (mkrv
+    (apl-quicksort (make-array (list 11) (list 3 1 4 1 5 9 2 6 5 3 5))))
+  (list 1 1 2 3 3 4 5 5 5 6 9))
+
+(apl-test
+  "quicksort preserves length"
+  (first
+    (mksh (apl-quicksort (make-array (list 7) (list 3 1 4 1 5 9 2)))))
+  7)

lib/apl/tests/programs/life.apl

@@ -0,0 +1,22 @@
+⍝ Conway's Game of Life — toroidal one-liner
+⍝
+⍝ The classic Roger Hui formulation:
+⍝   life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵}
+⍝
+⍝ Read right-to-left:
+⍝   ⊂⍵                : enclose the board (so it's a single scalar item)
+⍝   ¯1 0 1 ⌽¨ ⊂⍵      : produce 3 horizontally-shifted copies
+⍝   ¯1 0 1 ∘.⊖ …      : outer-product with vertical shifts → 3×3 = 9 shifts
+⍝   +/ +/ …           : sum the 9 boards element-wise → neighbor-count + self
+⍝   3 4 = …           : boolean — count is exactly 3 or exactly 4
+⍝   1 ⍵ ∨.∧ …         : "alive next" iff (count=3) or (alive AND count=4)
+⍝   ⊃ …               : disclose back to a 2D board
+⍝
+⍝ Rules in plain language:
+⍝   - dead cell + 3 live neighbors → born
+⍝   - live cell + 2 or 3 live neighbors → survives
+⍝   - all else → dies
+⍝
+⍝ Toroidal: edges wrap (rotate is cyclic).
+
+life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵}

lib/apl/tests/programs/mandelbrot.apl

@@ -0,0 +1,29 @@
+⍝ Mandelbrot — real-axis subset
+⍝
+⍝ For complex c, the Mandelbrot set is { c : |z_n| stays bounded } where
+⍝   z_0 = 0, z_{n+1} = z_n² + c.
+⍝ Restricting c (and z) to ℝ gives the segment c ∈ [-2, 1/4]
+⍝ where the iteration stays bounded.
+⍝
+⍝ Rank-polymorphic batched-iteration form:
+⍝   mandelbrot ← {⍵ ⍵⍵ ⍺⍺ +,(⍺⍺ × ⍺⍺) }
+⍝
+⍝ Pseudocode (as we don't have ⎕ system fns yet):
+⍝   z      ← 0×c                             ⍝ start at zero
+⍝   alive  ← 1+0×c                           ⍝ all "still in"
+⍝   for k iterations:
+⍝     alive ← alive ∧ 4 ≥ z×z                ⍝ still bounded?
+⍝     z     ← alive × c + z×z                ⍝ freeze escaped via mask
+⍝     count ← count + alive                  ⍝ tally surviving iters
+⍝
+⍝ Examples (count after 100 iterations):
+⍝   c=0      : 100  (z stays at 0)
+⍝   c=-1     : 100  (cycles 0,-1,0,-1,...)
+⍝   c=-2     : 100  (settles at 2 — boundary)
+⍝   c=0.25   : 100  (boundary — converges to 0.5)
+⍝   c=0.5    : 5    (escapes by iteration 6)
+⍝   c=1      : 3    (escapes quickly)
+⍝
+⍝ Real-axis Mandelbrot set: bounded for c ∈ [-2, 0.25].
+
+mandelbrot ← {z←alive←count←0×⍵ ⋄ {alive←alive∧4≥z×z ⋄ z←alive×⍵+z×z ⋄ count+←alive}⍣⍺⊢⍵}

lib/apl/tests/programs/n-queens.apl

@@ -0,0 +1,18 @@
+⍝ N-Queens — count solutions to placing N non-attacking queens on N×N
+⍝
+⍝ A solution is encoded as a permutation P of 1..N where P[i] is the
+⍝ column of the queen in row i.  Rows and columns are then automatically
+⍝ unique (it's a permutation).  We must additionally rule out queens
+⍝ sharing a diagonal: |i-j| = |P[i]-P[j]| for any pair.
+⍝
+⍝ Backtracking via reduce — the classic Roger Hui style:
+⍝   queens ← {≢{⍵,¨⍨↓(0=∊(¨⍳⍴⍵)≠.+|⍵)/⍳⍴⍵}/(⍳⍵)⍴⊂⍳⍵}
+⍝
+⍝ Plain reading:
+⍝   permute 1..N, keep those where no two queens share a diagonal.
+⍝
+⍝ Known solution counts (OEIS A000170):
+⍝     N    1   2   3   4   5   6   7    8    9    10
+⍝   q(N)   1   0   0   2  10   4  40   92  352   724
+
+queens ← {≢({(i j)←⍺⍵ ⋄ (|i-j)≠|(P[i])-(P[j])}⌿permutations ⍵)}

lib/apl/tests/programs/primes.apl

@@ -0,0 +1,16 @@
+⍝ Sieve of Eratosthenes — the classic APL one-liner
+⍝   primes ← (2=+⌿0=A∘.|A)/A←⍳N
+⍝
+⍝ Read right-to-left:
+⍝   A ← ⍳N        : A is 1..N
+⍝   A∘.|A         : outer-product residue table — M[i,j] = A[j] mod A[i]
+⍝   0=...         : boolean — true where A[i] divides A[j]
+⍝   +⌿...         : column sums — count of divisors per A[j]
+⍝   2=...         : true for numbers with exactly 2 divisors (1 and self) → primes
+⍝   .../A         : compress — select A[j] where mask[j] is true
+⍝
+⍝ Examples:
+⍝   primes 10  →  2 3 5 7
+⍝   primes 30  →  2 3 5 7 11 13 17 19 23 29
+
+primes ← {(2=+⌿0=⍵∘.|⍵)/⍵←⍳⍵}

lib/apl/tests/programs/quicksort.apl

@@ -0,0 +1,25 @@
+⍝ Quicksort — the classic Roger Hui one-liner
+⍝
+⍝ Q ← {1≥≢⍵:⍵ ⋄ (∇⍵⌿⍨⍵<p),(p=⍵)/⍵,∇⍵⌿⍨⍵>p←⍵⌷⍨?≢⍵}
+⍝
+⍝ Read right-to-left:
+⍝   ?≢⍵          : pick a random index in 1..length
+⍝   ⍵⌷⍨…         : take that element as pivot p
+⍝   ⍵>p          : boolean — elements greater than pivot
+⍝   ∇⍵⌿⍨…        : recursively sort the > partition
+⍝   (p=⍵)/⍵      : keep elements equal to pivot
+⍝   ⍵<p          : boolean — elements less than pivot
+⍝   ∇⍵⌿⍨…        : recursively sort the < partition
+⍝   ,            : catenate ⟨less⟩ ⟨equal⟩ ⟨greater⟩
+⍝   1≥≢⍵:⍵       : guard — base case for length ≤ 1
+⍝
+⍝ Stability: not stable on duplicates (but eq-class is preserved as a block).
+⍝ Worst case O(N²) on already-sorted input with deterministic pivot;
+⍝ randomized pivot selection gives expected O(N log N).
+⍝
+⍝ Examples:
+⍝   Q 3 1 4 1 5 9 2 6 5 3 5    →  1 1 2 3 3 4 5 5 5 6 9
+⍝   Q ⍳0                        →  ⍬   (empty)
+⍝   Q ,42                       →  42
+
+quicksort ← {1≥≢⍵:⍵ ⋄ p←⍵⌷⍨?≢⍵ ⋄ (∇⍵⌿⍨⍵<p),(p=⍵)/⍵,∇⍵⌿⍨⍵>p}

lib/apl/tests/scalar.sx

@@ -0,0 +1,369 @@
+; APL scalar primitives test suite
+; Requires: lib/apl/runtime.sx
+
+; ============================================================
+; Test framework
+; ============================================================
+
+(define apl-rt-count 0)
+(define apl-rt-pass 0)
+(define apl-rt-fails (list))
+
+; Element-wise list comparison (handles both List and ListRef)
+(define
+  lists-eq
+  (fn
+    (a b)
+    (if
+      (and (= (len a) 0) (= (len b) 0))
+      true
+      (if
+        (not (= (len a) (len b)))
+        false
+        (if
+          (not (= (first a) (first b)))
+          false
+          (lists-eq (rest a) (rest b)))))))
+
+(define
+  apl-rt-test
+  (fn
+    (name actual expected)
+    (begin
+      (set! apl-rt-count (+ apl-rt-count 1))
+      (if
+        (equal? actual expected)
+        (set! apl-rt-pass (+ apl-rt-pass 1))
+        (append! apl-rt-fails {:actual actual :expected expected :name name})))))
+
+; Test that a ravel equals a plain list (handles ListRef vs List)
+(define
+  ravel-test
+  (fn
+    (name arr expected-list)
+    (begin
+      (set! apl-rt-count (+ apl-rt-count 1))
+      (let
+        ((actual (get arr :ravel)))
+        (if
+          (lists-eq actual expected-list)
+          (set! apl-rt-pass (+ apl-rt-pass 1))
+          (append! apl-rt-fails {:actual actual :expected expected-list :name name}))))))
+
+; Test a scalar ravel value (single-element list)
+(define
+  scalar-test
+  (fn (name arr expected-val) (ravel-test name arr (list expected-val))))
+
+; ============================================================
+; Array constructor tests
+; ============================================================
+
+(apl-rt-test
+  "scalar: shape is empty list"
+  (get (apl-scalar 5) :shape)
+  (list))
+
+(apl-rt-test
+  "scalar: ravel has one element"
+  (get (apl-scalar 5) :ravel)
+  (list 5))
+
+(apl-rt-test "scalar: rank 0" (array-rank (apl-scalar 5)) 0)
+
+(apl-rt-test "scalar? returns true for scalar" (scalar? (apl-scalar 5)) true)
+
+(apl-rt-test "scalar: zero" (get (apl-scalar 0) :ravel) (list 0))
+
+(apl-rt-test
+  "vector: shape is (3)"
+  (get (apl-vector (list 1 2 3)) :shape)
+  (list 3))
+
+(apl-rt-test
+  "vector: ravel matches input"
+  (get (apl-vector (list 1 2 3)) :ravel)
+  (list 1 2 3))
+
+(apl-rt-test "vector: rank 1" (array-rank (apl-vector (list 1 2 3))) 1)
+
+(apl-rt-test
+  "scalar? returns false for vector"
+  (scalar? (apl-vector (list 1 2 3)))
+  false)
+
+(apl-rt-test
+  "make-array: rank 2"
+  (array-rank (make-array (list 2 3) (list 1 2 3 4 5 6)))
+  2)
+
+(apl-rt-test
+  "make-array: shape"
+  (get (make-array (list 2 3) (list 1 2 3 4 5 6)) :shape)
+  (list 2 3))
+
+(apl-rt-test
+  "array-ref: first element"
+  (array-ref (apl-vector (list 10 20 30)) 0)
+  10)
+
+(apl-rt-test
+  "array-ref: last element"
+  (array-ref (apl-vector (list 10 20 30)) 2)
+  30)
+
+(apl-rt-test "enclose: wraps in rank-0" (scalar? (enclose 42)) true)
+
+(apl-rt-test
+  "enclose: ravel contains value"
+  (get (enclose 42) :ravel)
+  (list 42))
+
+(apl-rt-test "disclose: unwraps rank-0" (disclose (enclose 42)) 42)
+
+; ============================================================
+; Shape primitive tests
+; ============================================================
+
+(ravel-test "⍴ scalar: returns empty" (apl-shape (apl-scalar 5)) (list))
+
+(ravel-test
+  "⍴ vector: returns (3)"
+  (apl-shape (apl-vector (list 1 2 3)))
+  (list 3))
+
+(ravel-test
+  "⍴ matrix: returns (2 3)"
+  (apl-shape (make-array (list 2 3) (list 1 2 3 4 5 6)))
+  (list 2 3))
+
+(ravel-test
+  ", ravel scalar: vector of 1"
+  (apl-ravel (apl-scalar 5))
+  (list 5))
+
+(apl-rt-test
+  ", ravel vector: same elements"
+  (get (apl-ravel (apl-vector (list 1 2 3))) :ravel)
+  (list 1 2 3))
+
+(apl-rt-test
+  ", ravel matrix: all elements"
+  (get (apl-ravel (make-array (list 2 3) (list 1 2 3 4 5 6))) :ravel)
+  (list 1 2 3 4 5 6))
+
+(scalar-test "≢ tally scalar: 1" (apl-tally (apl-scalar 5)) 1)
+
+(scalar-test
+  "≢ tally vector: first dimension"
+  (apl-tally (apl-vector (list 1 2 3)))
+  3)
+
+(scalar-test
+  "≢ tally matrix: first dimension"
+  (apl-tally (make-array (list 2 3) (list 1 2 3 4 5 6)))
+  2)
+
+(scalar-test
+  "≡ depth flat vector: 0"
+  (apl-depth (apl-vector (list 1 2 3)))
+  0)
+
+(scalar-test "≡ depth scalar: 0" (apl-depth (apl-scalar 5)) 0)
+
+(scalar-test
+  "≡ depth nested (enclose in vector): 1"
+  (apl-depth (enclose (apl-vector (list 1 2 3))))
+  1)
+
+; ============================================================
+; ⍳ iota tests
+; ============================================================
+
+(apl-rt-test
+  "⍳5 shape is (5)"
+  (get (apl-iota (apl-scalar 5)) :shape)
+  (list 5))
+
+(ravel-test "⍳5 ravel is 1..5" (apl-iota (apl-scalar 5)) (list 1 2 3 4 5))
+
+(ravel-test "⍳1 ravel is (1)" (apl-iota (apl-scalar 1)) (list 1))
+
+(ravel-test "⍳0 ravel is empty" (apl-iota (apl-scalar 0)) (list))
+
+(apl-rt-test "apl-io is 1" apl-io 1)
+
+; ============================================================
+; Arithmetic broadcast tests
+; ============================================================
+
+(scalar-test
+  "+ scalar scalar: 3+4=7"
+  (apl-add (apl-scalar 3) (apl-scalar 4))
+  7)
+
+(ravel-test
+  "+ vector scalar: +10"
+  (apl-add (apl-vector (list 1 2 3)) (apl-scalar 10))
+  (list 11 12 13))
+
+(ravel-test
+  "+ scalar vector: 10+"
+  (apl-add (apl-scalar 10) (apl-vector (list 1 2 3)))
+  (list 11 12 13))
+
+(ravel-test
+  "+ vector vector"
+  (apl-add (apl-vector (list 1 2 3)) (apl-vector (list 4 5 6)))
+  (list 5 7 9))
+
+(scalar-test "- negate monadic" (apl-neg-m (apl-scalar 5)) -5)
+
+(scalar-test "- dyadic 10-3=7" (apl-sub (apl-scalar 10) (apl-scalar 3)) 7)
+
+(scalar-test "× signum positive" (apl-signum (apl-scalar 7)) 1)
+
+(scalar-test "× signum negative" (apl-signum (apl-scalar -3)) -1)
+
+(scalar-test "× signum zero" (apl-signum (apl-scalar 0)) 0)
+
+(scalar-test "× dyadic 3×4=12" (apl-mul (apl-scalar 3) (apl-scalar 4)) 12)
+
+(scalar-test "÷ reciprocal 1÷4=0.25" (apl-recip (apl-scalar 4)) 0.25)
+
+(scalar-test
+  "÷ dyadic 10÷4=2.5"
+  (apl-div (apl-scalar 10) (apl-scalar 4))
+  2.5)
+
+(scalar-test "⌈ ceiling 2.3→3" (apl-ceil (apl-scalar 2.3)) 3)
+
+(scalar-test "⌈ max 3 5 → 5" (apl-max (apl-scalar 3) (apl-scalar 5)) 5)
+
+(scalar-test "⌊ floor 2.7→2" (apl-floor (apl-scalar 2.7)) 2)
+
+(scalar-test "⌊ min 3 5 → 3" (apl-min (apl-scalar 3) (apl-scalar 5)) 3)
+
+(scalar-test "* exp monadic e^0=1" (apl-exp (apl-scalar 0)) 1)
+
+(scalar-test
+  "* pow dyadic 2^10=1024"
+  (apl-pow (apl-scalar 2) (apl-scalar 10))
+  1024)
+
+(scalar-test "⍟ ln 1=0" (apl-ln (apl-scalar 1)) 0)
+
+(scalar-test "| abs positive" (apl-abs (apl-scalar 5)) 5)
+
+(scalar-test "| abs negative" (apl-abs (apl-scalar -5)) 5)
+
+(scalar-test "| mod 3|7=1" (apl-mod (apl-scalar 3) (apl-scalar 7)) 1)
+
+(scalar-test "! factorial 5!=120" (apl-fact (apl-scalar 5)) 120)
+
+(scalar-test "! factorial 0!=1" (apl-fact (apl-scalar 0)) 1)
+
+(scalar-test
+  "! binomial 4 choose 2 = 6"
+  (apl-binomial (apl-scalar 4) (apl-scalar 2))
+  6)
+
+(scalar-test "○ pi×0=0" (apl-pi-times (apl-scalar 0)) 0)
+
+(scalar-test "○ trig sin(0)=0" (apl-trig (apl-scalar 1) (apl-scalar 0)) 0)
+
+(scalar-test "○ trig cos(0)=1" (apl-trig (apl-scalar 2) (apl-scalar 0)) 1)
+
+; ============================================================
+; Comparison tests
+; ============================================================
+
+(scalar-test "< less: 3<5 → 1" (apl-lt (apl-scalar 3) (apl-scalar 5)) 1)
+
+(scalar-test "< less: 5<3 → 0" (apl-lt (apl-scalar 5) (apl-scalar 3)) 0)
+
+(scalar-test
+  "≤ le equal: 3≤3 → 1"
+  (apl-le (apl-scalar 3) (apl-scalar 3))
+  1)
+
+(scalar-test "= eq: 5=5 → 1" (apl-eq (apl-scalar 5) (apl-scalar 5)) 1)
+
+(scalar-test "= ne: 5=6 → 0" (apl-eq (apl-scalar 5) (apl-scalar 6)) 0)
+
+(scalar-test "≥ ge: 5≥3 → 1" (apl-ge (apl-scalar 5) (apl-scalar 3)) 1)
+
+(scalar-test "> gt: 5>3 → 1" (apl-gt (apl-scalar 5) (apl-scalar 3)) 1)
+
+(scalar-test "≠ ne: 5≠3 → 1" (apl-ne (apl-scalar 5) (apl-scalar 3)) 1)
+
+(ravel-test
+  "comparison vector broadcast: 1 2 3 < 2 → 1 0 0"
+  (apl-lt (apl-vector (list 1 2 3)) (apl-scalar 2))
+  (list 1 0 0))
+
+; ============================================================
+; Logical tests
+; ============================================================
+
+(scalar-test "~ not 0 → 1" (apl-not (apl-scalar 0)) 1)
+
+(scalar-test "~ not 1 → 0" (apl-not (apl-scalar 1)) 0)
+
+(ravel-test
+  "~ not vector: 1 0 1 0 → 0 1 0 1"
+  (apl-not (apl-vector (list 1 0 1 0)))
+  (list 0 1 0 1))
+
+(scalar-test
+  "∧ and 1∧1 → 1"
+  (apl-and (apl-scalar 1) (apl-scalar 1))
+  1)
+
+(scalar-test
+  "∧ and 1∧0 → 0"
+  (apl-and (apl-scalar 1) (apl-scalar 0))
+  0)
+
+(scalar-test "∨ or 0∨1 → 1" (apl-or (apl-scalar 0) (apl-scalar 1)) 1)
+
+(scalar-test "∨ or 0∨0 → 0" (apl-or (apl-scalar 0) (apl-scalar 0)) 0)
+
+(scalar-test
+  "⍱ nor 0⍱0 → 1"
+  (apl-nor (apl-scalar 0) (apl-scalar 0))
+  1)
+
+(scalar-test
+  "⍱ nor 1⍱0 → 0"
+  (apl-nor (apl-scalar 1) (apl-scalar 0))
+  0)
+
+(scalar-test
+  "⍲ nand 1⍲1 → 0"
+  (apl-nand (apl-scalar 1) (apl-scalar 1))
+  0)
+
+(scalar-test
+  "⍲ nand 1⍲0 → 1"
+  (apl-nand (apl-scalar 1) (apl-scalar 0))
+  1)
+
+; ============================================================
+; plus-m identity test
+; ============================================================
+
+(scalar-test "+ monadic identity: +5 → 5" (apl-plus-m (apl-scalar 5)) 5)
+
+; ============================================================
+; Summary
+; ============================================================
+
+(define
+  apl-scalar-summary
+  (str
+    "scalar "
+    apl-rt-pass
+    "/"
+    apl-rt-count
+    (if (= (len apl-rt-fails) 0) "" (str " FAILS: " apl-rt-fails))))

lib/apl/tests/structural.sx

@@ -0,0 +1,608 @@
+;; lib/apl/tests/structural.sx — Phase 3: structural primitives
+;; Tests for: apl-reshape, apl-ravel, apl-transpose, apl-transpose-dyadic
+;; Loaded after runtime.sx; shares apl-test / apl-test-pass / apl-test-fail.
+
+(define rv (fn (arr) (get arr :ravel)))
+(define sh (fn (arr) (get arr :shape)))
+
+;; ---------------------------------------------------------------------------
+;; 1. Ravel (monadic ,)
+;; ---------------------------------------------------------------------------
+(apl-test "ravel scalar" (rv (apl-ravel (apl-scalar 5))) (list 5))
+
+(apl-test
+  "ravel vector"
+  (rv (apl-ravel (make-array (list 3) (list 1 2 3))))
+  (list 1 2 3))
+
+(apl-test
+  "ravel matrix"
+  (rv (apl-ravel (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2 3 4 5 6))
+
+(apl-test
+  "ravel shape is rank-1"
+  (sh (apl-ravel (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 6))
+
+;; ---------------------------------------------------------------------------
+;; 2. Reshape (dyadic ⍴)
+;; ---------------------------------------------------------------------------
+
+(apl-test
+  "reshape 2x3 ravel"
+  (rv
+    (apl-reshape
+      (make-array (list 2) (list 2 3))
+      (make-array (list 6) (list 1 2 3 4 5 6))))
+  (list 1 2 3 4 5 6))
+
+(apl-test
+  "reshape 2x3 shape"
+  (sh
+    (apl-reshape
+      (make-array (list 2) (list 2 3))
+      (make-array (list 6) (list 1 2 3 4 5 6))))
+  (list 2 3))
+
+(apl-test
+  "reshape cycle 6 from 1 2"
+  (rv
+    (apl-reshape
+      (make-array (list 1) (list 6))
+      (make-array (list 2) (list 1 2))))
+  (list 1 2 1 2 1 2))
+
+(apl-test
+  "reshape cycle 2x3 from 1 2"
+  (rv
+    (apl-reshape
+      (make-array (list 2) (list 2 3))
+      (make-array (list 2) (list 1 2))))
+  (list 1 2 1 2 1 2))
+
+(apl-test
+  "reshape scalar fill"
+  (rv (apl-reshape (make-array (list 1) (list 4)) (apl-scalar 7)))
+  (list 7 7 7 7))
+
+(apl-test
+  "reshape truncate"
+  (rv
+    (apl-reshape
+      (make-array (list 1) (list 3))
+      (make-array (list 6) (list 10 20 30 40 50 60))))
+  (list 10 20 30))
+
+(apl-test
+  "reshape matrix to vector"
+  (sh
+    (apl-reshape
+      (make-array (list 1) (list 6))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 6))
+
+(apl-test
+  "reshape 2x2x3"
+  (sh
+    (apl-reshape
+      (make-array (list 3) (list 2 2 3))
+      (make-array (list 12) (range 1 13))))
+  (list 2 2 3))
+
+(apl-test
+  "reshape to empty"
+  (rv
+    (apl-reshape
+      (make-array (list 1) (list 0))
+      (make-array (list 3) (list 1 2 3))))
+  (list))
+
+;; ---------------------------------------------------------------------------
+;; 3. Monadic transpose (⍉)
+;; ---------------------------------------------------------------------------
+
+(apl-test
+  "transpose scalar shape"
+  (sh (apl-transpose (apl-scalar 99)))
+  (list))
+
+(apl-test
+  "transpose scalar ravel"
+  (rv (apl-transpose (apl-scalar 99)))
+  (list 99))
+
+(apl-test
+  "transpose vector shape"
+  (sh (apl-transpose (make-array (list 3) (list 3 1 4))))
+  (list 3))
+
+(apl-test
+  "transpose vector ravel"
+  (rv (apl-transpose (make-array (list 3) (list 3 1 4))))
+  (list 3 1 4))
+
+(apl-test
+  "transpose 2x3 shape"
+  (sh (apl-transpose (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 3 2))
+
+(apl-test
+  "transpose 2x3 ravel"
+  (rv (apl-transpose (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 4 2 5 3 6))
+
+(apl-test
+  "transpose 3x3"
+  (rv (apl-transpose (make-array (list 3 3) (list 1 2 3 4 5 6 7 8 9))))
+  (list 1 4 7 2 5 8 3 6 9))
+
+(apl-test
+  "transpose 1x4 shape"
+  (sh (apl-transpose (make-array (list 1 4) (list 1 2 3 4))))
+  (list 4 1))
+
+(apl-test
+  "transpose twice identity"
+  (rv
+    (apl-transpose
+      (apl-transpose (make-array (list 2 3) (list 1 2 3 4 5 6)))))
+  (list 1 2 3 4 5 6))
+
+(apl-test
+  "transpose 3d shape"
+  (sh (apl-transpose (make-array (list 2 3 4) (range 0 24))))
+  (list 4 3 2))
+
+;; ---------------------------------------------------------------------------
+;; 4. Dyadic transpose (perm⍉arr)
+;; ---------------------------------------------------------------------------
+
+(apl-test
+  "dyadic-transpose identity"
+  (rv
+    (apl-transpose-dyadic
+      (make-array (list 2) (list 1 2))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2 3 4 5 6))
+
+(apl-test
+  "dyadic-transpose swap 2x3"
+  (rv
+    (apl-transpose-dyadic
+      (make-array (list 2) (list 2 1))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 4 2 5 3 6))
+
+(apl-test
+  "dyadic-transpose swap shape"
+  (sh
+    (apl-transpose-dyadic
+      (make-array (list 2) (list 2 1))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 3 2))
+
+(apl-test
+  "dyadic-transpose 3d shape"
+  (sh
+    (apl-transpose-dyadic
+      (make-array (list 3) (list 2 1 3))
+      (make-array (list 2 3 4) (range 0 24))))
+  (list 3 2 4))
+
+(apl-test
+  "take 3 from front"
+  (rv (apl-take (apl-scalar 3) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3))
+
+(apl-test
+  "take 0"
+  (rv (apl-take (apl-scalar 0) (make-array (list 5) (list 1 2 3 4 5))))
+  (list))
+
+(apl-test
+  "take -2 from back"
+  (rv (apl-take (apl-scalar -2) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 4 5))
+
+(apl-test
+  "take over-take pads with 0"
+  (rv (apl-take (apl-scalar 7) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3 4 5 0 0))
+
+(apl-test
+  "take matrix 1 row 2 cols shape"
+  (sh
+    (apl-take
+      (make-array (list 2) (list 1 2))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2))
+
+(apl-test
+  "take matrix 1 row 2 cols ravel"
+  (rv
+    (apl-take
+      (make-array (list 2) (list 1 2))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2))
+
+(apl-test
+  "take matrix negative row"
+  (rv
+    (apl-take
+      (make-array (list 2) (list -1 3))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 4 5 6))
+
+(apl-test
+  "drop 2 from front"
+  (rv (apl-drop (apl-scalar 2) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 3 4 5))
+
+(apl-test
+  "drop -2 from back"
+  (rv (apl-drop (apl-scalar -2) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3))
+
+(apl-test
+  "drop all"
+  (rv (apl-drop (apl-scalar 5) (make-array (list 5) (list 1 2 3 4 5))))
+  (list))
+
+(apl-test
+  "drop 0"
+  (rv (apl-drop (apl-scalar 0) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3 4 5))
+
+(apl-test
+  "drop matrix 1 row shape"
+  (sh
+    (apl-drop
+      (make-array (list 2) (list 1 0))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 3))
+
+(apl-test
+  "drop matrix 1 row ravel"
+  (rv
+    (apl-drop
+      (make-array (list 2) (list 1 0))
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 4 5 6))
+
+(apl-test
+  "reverse vector"
+  (rv (apl-reverse (make-array (list 5) (list 1 2 3 4 5))))
+  (list 5 4 3 2 1))
+
+(apl-test
+  "reverse scalar identity"
+  (rv (apl-reverse (apl-scalar 42)))
+  (list 42))
+
+(apl-test
+  "reverse matrix last axis"
+  (rv (apl-reverse (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 3 2 1 6 5 4))
+
+(apl-test
+  "reverse-first matrix"
+  (rv (apl-reverse-first (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 4 5 6 1 2 3))
+
+(apl-test
+  "reverse-first vector identity"
+  (rv (apl-reverse-first (make-array (list 4) (list 1 2 3 4))))
+  (list 4 3 2 1))
+
+(apl-test
+  "rotate vector left by 2"
+  (rv (apl-rotate (apl-scalar 2) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 3 4 5 1 2))
+
+(apl-test
+  "rotate vector right by 1 (negative)"
+  (rv (apl-rotate (apl-scalar -1) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 5 1 2 3 4))
+
+(apl-test
+  "rotate by 0 is identity"
+  (rv (apl-rotate (apl-scalar 0) (make-array (list 5) (list 1 2 3 4 5))))
+  (list 1 2 3 4 5))
+
+(apl-test
+  "rotate matrix last axis"
+  (rv
+    (apl-rotate (apl-scalar 1) (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 2 3 1 5 6 4))
+
+(apl-test
+  "rotate-first matrix"
+  (rv
+    (apl-rotate-first
+      (apl-scalar 1)
+      (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 4 5 6 1 2 3))
+
+(apl-test
+  "cat v,v ravel"
+  (rv
+    (apl-catenate
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 2) (list 4 5))))
+  (list 1 2 3 4 5))
+
+(apl-test
+  "cat v,v shape"
+  (sh
+    (apl-catenate
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 2) (list 4 5))))
+  (list 5))
+
+(apl-test
+  "cat scalar,v"
+  (rv (apl-catenate (apl-scalar 99) (make-array (list 3) (list 1 2 3))))
+  (list 99 1 2 3))
+
+(apl-test
+  "cat v,scalar"
+  (rv (apl-catenate (make-array (list 3) (list 1 2 3)) (apl-scalar 99)))
+  (list 1 2 3 99))
+
+(apl-test
+  "cat matrix last-axis shape"
+  (sh
+    (apl-catenate
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 2 2) (list 7 8 9 10))))
+  (list 2 5))
+
+(apl-test
+  "cat matrix last-axis ravel"
+  (rv
+    (apl-catenate
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 2 2) (list 7 8 9 10))))
+  (list 1 2 3 7 8 4 5 6 9 10))
+
+(apl-test
+  "cat-first v,v shape"
+  (sh
+    (apl-catenate-first
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 2) (list 4 5))))
+  (list 5))
+
+(apl-test
+  "cat-first matrix shape"
+  (sh
+    (apl-catenate-first
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3 3) (list 11 12 13 14 15 16 17 18 19))))
+  (list 5 3))
+
+(apl-test
+  "cat-first matrix ravel"
+  (rv
+    (apl-catenate-first
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3 3) (list 11 12 13 14 15 16 17 18 19))))
+  (list 1 2 3 4 5 6 11 12 13 14 15 16 17 18 19))
+
+(apl-test
+  "squad scalar into vector"
+  (rv
+    (apl-squad (apl-scalar 2) (make-array (list 5) (list 10 20 30 40 50))))
+  (list 20))
+
+(apl-test
+  "squad first element"
+  (rv (apl-squad (apl-scalar 1) (make-array (list 3) (list 10 20 30))))
+  (list 10))
+
+(apl-test
+  "squad last element"
+  (rv
+    (apl-squad (apl-scalar 5) (make-array (list 5) (list 10 20 30 40 50))))
+  (list 50))
+
+(apl-test
+  "squad fully specified matrix element"
+  (rv
+    (apl-squad
+      (make-array (list 2) (list 2 3))
+      (make-array (list 3 4) (list 1 2 3 4 5 6 7 8 9 10 11 12))))
+  (list 7))
+
+(apl-test
+  "squad partial row of matrix shape"
+  (sh
+    (apl-squad
+      (apl-scalar 2)
+      (make-array (list 3 4) (list 1 2 3 4 5 6 7 8 9 10 11 12))))
+  (list 4))
+
+(apl-test
+  "squad partial row of matrix ravel"
+  (rv
+    (apl-squad
+      (apl-scalar 2)
+      (make-array (list 3 4) (list 1 2 3 4 5 6 7 8 9 10 11 12))))
+  (list 5 6 7 8))
+
+(apl-test
+  "squad partial 3d slice shape"
+  (sh (apl-squad (apl-scalar 1) (make-array (list 2 3 4) (range 1 25))))
+  (list 3 4))
+
+(apl-test
+  "grade-up basic"
+  (rv (apl-grade-up (make-array (list 5) (list 3 1 4 1 5))))
+  (list 2 4 1 3 5))
+
+(apl-test
+  "grade-up shape"
+  (sh (apl-grade-up (make-array (list 4) (list 4 1 3 2))))
+  (list 4))
+
+(apl-test
+  "grade-up no duplicates"
+  (rv (apl-grade-up (make-array (list 4) (list 4 1 3 2))))
+  (list 2 4 3 1))
+
+(apl-test
+  "grade-up already sorted"
+  (rv (apl-grade-up (make-array (list 3) (list 1 2 3))))
+  (list 1 2 3))
+
+(apl-test
+  "grade-up reverse sorted"
+  (rv (apl-grade-up (make-array (list 3) (list 3 2 1))))
+  (list 3 2 1))
+
+(apl-test
+  "grade-down basic"
+  (rv (apl-grade-down (make-array (list 5) (list 3 1 4 1 5))))
+  (list 5 3 1 2 4))
+
+(apl-test
+  "grade-down no duplicates"
+  (rv (apl-grade-down (make-array (list 4) (list 4 1 3 2))))
+  (list 1 3 4 2))
+
+(apl-test
+  "grade-up single element"
+  (rv (apl-grade-up (make-array (list 1) (list 42))))
+  (list 1))
+
+(apl-test
+  "enclose shape is scalar"
+  (sh (apl-enclose (make-array (list 3) (list 1 2 3))))
+  (list))
+
+(apl-test
+  "enclose ravel length is 1"
+  (len (rv (apl-enclose (make-array (list 3) (list 1 2 3)))))
+  1)
+
+(apl-test
+  "enclose inner ravel"
+  (rv (first (rv (apl-enclose (make-array (list 3) (list 1 2 3))))))
+  (list 1 2 3))
+
+(apl-test
+  "disclose of enclose round-trips ravel"
+  (rv (apl-disclose (apl-enclose (make-array (list 3) (list 10 20 30)))))
+  (list 10 20 30))
+
+(apl-test
+  "disclose of enclose round-trips shape"
+  (sh (apl-disclose (apl-enclose (make-array (list 3) (list 10 20 30)))))
+  (list 3))
+
+(apl-test
+  "disclose scalar ravel"
+  (rv (apl-disclose (apl-scalar 42)))
+  (list 42))
+
+(apl-test
+  "disclose vector ravel"
+  (rv (apl-disclose (make-array (list 3) (list 5 6 7))))
+  (list 5))
+
+(apl-test
+  "disclose matrix returns first row"
+  (rv (apl-disclose (make-array (list 2 3) (list 1 2 3 4 5 6))))
+  (list 1 2 3))
+
+(apl-test
+  "member basic"
+  (rv
+    (apl-member
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 2) (list 2 3))))
+  (list 0 1 1))
+
+(apl-test
+  "member all absent"
+  (rv
+    (apl-member
+      (make-array (list 3) (list 4 5 6))
+      (make-array (list 3) (list 1 2 3))))
+  (list 0 0 0))
+
+(apl-test
+  "member scalar"
+  (rv (apl-member (apl-scalar 5) (make-array (list 3) (list 1 5 9))))
+  (list 1))
+
+(apl-test
+  "member shape preserved"
+  (sh
+    (apl-member
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3) (list 1 3 5))))
+  (list 2 3))
+
+(apl-test
+  "member matrix ravel"
+  (rv
+    (apl-member
+      (make-array (list 2 3) (list 1 2 3 4 5 6))
+      (make-array (list 3) (list 1 3 5))))
+  (list 1 0 1 0 1 0))
+
+(apl-test
+  "index-of basic"
+  (rv
+    (apl-index-of
+      (make-array (list 4) (list 10 20 30 40))
+      (make-array (list 3) (list 20 40 10))))
+  (list 2 4 1))
+
+(apl-test
+  "index-of not-found"
+  (rv
+    (apl-index-of
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 2) (list 5 2))))
+  (list 4 2))
+
+(apl-test
+  "index-of scalar right"
+  (rv
+    (apl-index-of (make-array (list 3) (list 10 20 30)) (apl-scalar 20)))
+  (list 2))
+
+(apl-test
+  "without basic"
+  (rv
+    (apl-without
+      (make-array (list 5) (list 1 2 3 4 5))
+      (make-array (list 2) (list 2 4))))
+  (list 1 3 5))
+
+(apl-test
+  "without shape"
+  (sh
+    (apl-without
+      (make-array (list 5) (list 1 2 3 4 5))
+      (make-array (list 2) (list 2 4))))
+  (list 3))
+
+(apl-test
+  "without nothing removed"
+  (rv
+    (apl-without
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 4 5 6))))
+  (list 1 2 3))
+
+(apl-test
+  "without all removed"
+  (rv
+    (apl-without
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 1 2 3))))
+  (list))

lib/apl/tests/system.sx

@@ -0,0 +1,48 @@
+; Tests for APL ⎕ system functions.
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mksh (fn (arr) (get arr :shape)))
+
+(apl-test "⎕IO returns 1" (mkrv (apl-quad-io)) (list 1))
+
+(apl-test "⎕ML returns 1" (mkrv (apl-quad-ml)) (list 1))
+
+(apl-test "⎕FR returns 1248" (mkrv (apl-quad-fr)) (list 1248))
+
+(apl-test "⎕TS shape is 7" (mksh (apl-quad-ts)) (list 7))
+
+(apl-test "⎕TS year is 1970 default" (first (mkrv (apl-quad-ts))) 1970)
+
+(apl-test "⎕FMT scalar 42" (apl-quad-fmt (apl-scalar 42)) "42")
+
+(apl-test "⎕FMT scalar negative" (apl-quad-fmt (apl-scalar -7)) "-7")
+
+(apl-test
+  "⎕FMT empty vector"
+  (apl-quad-fmt (make-array (list 0) (list)))
+  "")
+
+(apl-test
+  "⎕FMT singleton vector"
+  (apl-quad-fmt (make-array (list 1) (list 42)))
+  "42")
+
+(apl-test
+  "⎕FMT vector"
+  (apl-quad-fmt (make-array (list 5) (list 1 2 3 4 5)))
+  "1 2 3 4 5")
+
+(apl-test
+  "⎕FMT matrix 2x3"
+  (apl-quad-fmt (make-array (list 2 3) (list 1 2 3 4 5 6)))
+  "1 2 3\n4 5 6\n")
+
+(apl-test
+  "⎕← (print) returns its arg"
+  (mkrv (apl-quad-print (apl-scalar 99)))
+  (list 99))
+
+(apl-test
+  "⎕← preserves shape"
+  (mksh (apl-quad-print (make-array (list 3) (list 1 2 3))))
+  (list 3))

lib/apl/tests/tradfn.sx

@@ -0,0 +1,127 @@
+; Tests for apl-call-tradfn (manual structure construction).
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mksh (fn (arr) (get arr :shape)))
+(define mknum (fn (n) (list :num n)))
+(define mknm (fn (s) (list :name s)))
+(define mkfg (fn (g) (list :fn-glyph g)))
+(define mkmon (fn (g a) (list :monad (mkfg g) a)))
+(define mkdyd (fn (g l r) (list :dyad (mkfg g) l r)))
+(define mkasg (fn (n e) (list :assign n e)))
+(define mkbr (fn (e) (list :branch e)))
+
+(define mkif (fn (c t e) (list :if c t e)))
+
+(define mkwhile (fn (c b) (list :while c b)))
+
+(define mkfor (fn (v i b) (list :for v i b)))
+
+(define mksel (fn (v cs d) (list :select v cs d)))
+
+(apl-test
+  "tradfn R←L+W simple add"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mkdyd "+" (mknm "L") (mknm "W")))) :alpha "L"} (apl-scalar 5) (apl-scalar 7)))
+  (list 12))
+
+(apl-test
+  "tradfn R←L×W"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mkdyd "×" (mknm "L") (mknm "W")))) :alpha "L"} (apl-scalar 6) (apl-scalar 7)))
+  (list 42))
+
+(apl-test
+  "tradfn monadic R←-W"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mkmon "-" (mknm "W")))) :alpha nil} nil (apl-scalar 9)))
+  (list -9))
+
+(apl-test
+  "tradfn →0 exits early"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mknm "W")) (mkbr (mknum 0)) (mkasg "R" (mknum 999))) :alpha nil} nil (apl-scalar 7)))
+  (list 7))
+
+(apl-test
+  "tradfn branch to line 3 skips line 2"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkbr (mknum 3)) (mkasg "R" (mknum 999)) (mkasg "R" (mknum 42))) :alpha nil} nil (apl-scalar 0)))
+  (list 42))
+
+(apl-test
+  "tradfn local var t←W+1; R←t×2"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "t" (mkdyd "+" (mknm "W") (mknum 1))) (mkasg "R" (mkdyd "×" (mknm "t") (mknum 2)))) :alpha nil} nil (apl-scalar 5)))
+  (list 12))
+
+(apl-test
+  "tradfn vector args"
+  (mkrv
+    (apl-call-tradfn
+      {:result "R" :omega "W" :stmts (list (mkasg "R" (mkdyd "+" (mknm "L") (mknm "W")))) :alpha "L"}
+      (make-array (list 3) (list 1 2 3))
+      (make-array (list 3) (list 10 20 30))))
+  (list 11 22 33))
+
+(apl-test
+  "tradfn unset result returns nil"
+  (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkbr (mknum 0))) :alpha nil} nil (apl-scalar 5))
+  nil)
+
+(apl-test
+  "tradfn run-off end returns result"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mkdyd "×" (mknm "W") (mknum 3)))) :alpha nil} nil (apl-scalar 7)))
+  (list 21))
+
+(apl-test
+  "tradfn loop sum 1+2+...+5 via branch"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "i" (mknum 1)) (mkasg "R" (mknum 0)) (mkasg "R" (mkdyd "+" (mknm "R") (mknm "i"))) (mkasg "i" (mkdyd "+" (mknm "i") (mknum 1))) (mkbr (mkdyd "×" (mkdyd "≤" (mknm "i") (mknm "W")) (mknum 3)))) :alpha nil} nil (apl-scalar 5)))
+  (list 15))
+
+(apl-test
+  "tradfn :If true branch"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkif (mkdyd ">" (mknm "W") (mknum 0)) (list (mkasg "R" (mknum 1))) (list (mkasg "R" (mknum 0))))) :alpha nil} nil (apl-scalar 5)))
+  (list 1))
+
+(apl-test
+  "tradfn :If false branch"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkif (mkdyd ">" (mknm "W") (mknum 100)) (list (mkasg "R" (mknum 1))) (list (mkasg "R" (mknum 0))))) :alpha nil} nil (apl-scalar 5)))
+  (list 0))
+
+(apl-test
+  "tradfn :While sum 1..N"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "i" (mknum 1)) (mkasg "R" (mknum 0)) (mkwhile (mkdyd "≤" (mknm "i") (mknm "W")) (list (mkasg "R" (mkdyd "+" (mknm "R") (mknm "i"))) (mkasg "i" (mkdyd "+" (mknm "i") (mknum 1)))))) :alpha nil} nil (apl-scalar 10)))
+  (list 55))
+
+(apl-test
+  "tradfn :For sum elements"
+  (mkrv
+    (apl-call-tradfn
+      {:result "R" :omega "W" :stmts (list (mkasg "R" (mknum 0)) (mkfor "x" (mknm "W") (list (mkasg "R" (mkdyd "+" (mknm "R") (mknm "x")))))) :alpha nil}
+      nil
+      (make-array (list 4) (list 10 20 30 40))))
+  (list 100))
+
+(apl-test
+  "tradfn :For with empty vector"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mknum 99)) (mkfor "x" (mknm "W") (list (mkasg "R" (mkdyd "+" (mknm "R") (mknm "x")))))) :alpha nil} nil (make-array (list 0) (list))))
+  (list 99))
+
+(apl-test
+  "tradfn :Select dispatch hit"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mksel (mknm "W") (list (list (mknum 1) (mkasg "R" (mknum 100))) (list (mknum 2) (mkasg "R" (mknum 200))) (list (mknum 3) (mkasg "R" (mknum 300)))) (list (mkasg "R" (mknum 0))))) :alpha nil} nil (apl-scalar 2)))
+  (list 200))
+
+(apl-test
+  "tradfn :Select default block"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mksel (mknm "W") (list (list (mknum 1) (mkasg "R" (mknum 100))) (list (mknum 2) (mkasg "R" (mknum 200)))) (list (mkasg "R" (mknum -1))))) :alpha nil} nil (apl-scalar 99)))
+  (list -1))
+
+(apl-test
+  "tradfn nested :If"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkif (mkdyd ">" (mknm "W") (mknum 0)) (list (mkif (mkdyd ">" (mknm "W") (mknum 10)) (list (mkasg "R" (mknum 2))) (list (mkasg "R" (mknum 1))))) (list (mkasg "R" (mknum 0))))) :alpha nil} nil (apl-scalar 5)))
+  (list 1))
+
+(apl-test
+  "tradfn :If assigns persist outside"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mknum 0)) (mkif (mkdyd ">" (mknm "W") (mknum 0)) (list (mkasg "R" (mknum 42))) (list)) (mkasg "R" (mkdyd "+" (mknm "R") (mknum 1)))) :alpha nil} nil (apl-scalar 5)))
+  (list 43))
+
+(apl-test
+  "tradfn :For factorial 1..5"
+  (mkrv (apl-call-tradfn {:result "R" :omega "W" :stmts (list (mkasg "R" (mknum 1)) (mkfor "x" (mkmon "⍳" (mknm "W")) (list (mkasg "R" (mkdyd "×" (mknm "R") (mknm "x")))))) :alpha nil} nil (apl-scalar 5)))
+  (list 120))

lib/apl/tests/valence.sx

@@ -0,0 +1,81 @@
+; Tests for valence detection (apl-dfn-valence, apl-tradfn-valence)
+; and unified dispatch (apl-call).
+
+(define mkrv (fn (arr) (get arr :ravel)))
+(define mknum (fn (n) (list :num n)))
+(define mknm (fn (s) (list :name s)))
+(define mkfg (fn (g) (list :fn-glyph g)))
+(define mkmon (fn (g a) (list :monad (mkfg g) a)))
+(define mkdyd (fn (g l r) (list :dyad (mkfg g) l r)))
+(define mkasg (fn (n e) (list :assign n e)))
+(define mkdfn (fn (stmts) (cons :dfn stmts)))
+
+(apl-test
+  "dfn-valence niladic body=42"
+  (apl-dfn-valence (mkdfn (list (mknum 42))))
+  :niladic)
+
+(apl-test
+  "dfn-valence monadic body=⍵+1"
+  (apl-dfn-valence (mkdfn (list (mkdyd "+" (mknm "⍵") (mknum 1)))))
+  :monadic)
+
+(apl-test
+  "dfn-valence dyadic body=⍺+⍵"
+  (apl-dfn-valence (mkdfn (list (mkdyd "+" (mknm "⍺") (mknm "⍵")))))
+  :dyadic)
+
+(apl-test
+  "dfn-valence dyadic mentions ⍺ via local"
+  (apl-dfn-valence (mkdfn (list (mkasg "x" (mknm "⍺")) (mknm "x"))))
+  :dyadic)
+
+(apl-test
+  "dfn-valence dyadic deep nest"
+  (apl-dfn-valence
+    (mkdfn (list (mkmon "-" (mkdyd "×" (mknm "⍺") (mknm "⍵"))))))
+  :dyadic)
+
+(apl-test "tradfn-valence niladic" (apl-tradfn-valence {:result "R" :omega nil :stmts (list) :alpha nil}) :niladic)
+
+(apl-test "tradfn-valence monadic" (apl-tradfn-valence {:result "R" :omega "W" :stmts (list) :alpha nil}) :monadic)
+
+(apl-test "tradfn-valence dyadic" (apl-tradfn-valence {:result "R" :omega "W" :stmts (list) :alpha "L"}) :dyadic)
+
+(apl-test
+  "apl-call dfn niladic"
+  (mkrv (apl-call (mkdfn (list (mknum 42))) nil nil))
+  (list 42))
+
+(apl-test
+  "apl-call dfn monadic"
+  (mkrv
+    (apl-call
+      (mkdfn (list (mkdyd "+" (mknm "⍵") (mknum 1))))
+      nil
+      (apl-scalar 5)))
+  (list 6))
+
+(apl-test
+  "apl-call dfn dyadic"
+  (mkrv
+    (apl-call
+      (mkdfn (list (mkdyd "+" (mknm "⍺") (mknm "⍵"))))
+      (apl-scalar 3)
+      (apl-scalar 4)))
+  (list 7))
+
+(apl-test
+  "apl-call tradfn dyadic"
+  (mkrv (apl-call {:result "R" :omega "W" :stmts (list (mkasg "R" (mkdyd "×" (mknm "L") (mknm "W")))) :alpha "L"} (apl-scalar 6) (apl-scalar 7)))
+  (list 42))
+
+(apl-test
+  "apl-call tradfn monadic"
+  (mkrv (apl-call {:result "R" :omega "W" :stmts (list (mkasg "R" (mkmon "-" (mknm "W")))) :alpha nil} nil (apl-scalar 9)))
+  (list -9))
+
+(apl-test
+  "apl-call tradfn niladic returns nil result"
+  (apl-call {:result "R" :omega nil :stmts (list) :alpha nil} nil nil)
+  nil)

lib/apl/tokenizer.sx

@@ -0,0 +1,168 @@
+(define apl-glyph-set
+  (list "+" "-" "×" "÷" "*" "⍟" "⌈" "⌊" "|" "!" "?" "○" "~" "<" "≤" "=" "≥" ">" "≠"
+        "∊" "∧" "∨" "⍱" "⍲" "," "⍪" "⍴" "⌽" "⊖" "⍉" "↑" "↓" "⊂" "⊃" "⊆"
+        "∪" "∩" "⍳" "⍸" "⌷" "⍋" "⍒" "⊥" "⊤" "⊣" "⊢" "⍎" "⍕"
+        "⍺" "⍵" "∇" "/" "\\" "¨" "⍨" "∘" "." "⍣" "⍤" "⍥" "@" "¯"))
+
+(define apl-glyph?
+  (fn (ch)
+    (some (fn (g) (= g ch)) apl-glyph-set)))
+
+(define apl-digit?
+  (fn (ch)
+    (and (string? ch) (>= ch "0") (<= ch "9"))))
+
+(define apl-alpha?
+  (fn (ch)
+    (and (string? ch)
+         (or (and (>= ch "a") (<= ch "z"))
+             (and (>= ch "A") (<= ch "Z"))
+             (= ch "_")))))
+
+(define apl-tokenize
+  (fn (source)
+    (let ((pos 0)
+          (src-len (len source))
+          (tokens (list)))
+
+      (define tok-push!
+        (fn (type value)
+          (append! tokens {:type type :value value})))
+
+      (define cur-sw?
+        (fn (ch)
+          (and (< pos src-len) (starts-with? (slice source pos) ch))))
+
+      (define cur-byte
+        (fn ()
+          (if (< pos src-len) (nth source pos) nil)))
+
+      (define advance!
+        (fn ()
+          (set! pos (+ pos 1))))
+
+      (define consume!
+        (fn (ch)
+          (set! pos (+ pos (len ch)))))
+
+      (define find-glyph
+        (fn ()
+          (let ((rem (slice source pos)))
+            (let ((matches (filter (fn (g) (starts-with? rem g)) apl-glyph-set)))
+              (if (> (len matches) 0) (first matches) nil)))))
+
+      (define read-digits!
+        (fn (acc)
+          (if (and (< pos src-len) (apl-digit? (cur-byte)))
+            (let ((ch (cur-byte)))
+              (begin
+                (advance!)
+                (read-digits! (str acc ch))))
+            acc)))
+
+      (define read-ident-cont!
+        (fn ()
+          (when (and (< pos src-len)
+                     (let ((ch (cur-byte)))
+                       (or (apl-alpha? ch) (apl-digit? ch))))
+            (begin
+              (advance!)
+              (read-ident-cont!)))))
+
+      (define read-string!
+        (fn (acc)
+          (cond
+            ((>= pos src-len) acc)
+            ((cur-sw? "'")
+             (if (and (< (+ pos 1) src-len) (cur-sw? "'"))
+               (begin
+                 (advance!)
+                 (advance!)
+                 (read-string! (str acc "'")))
+               (begin (advance!) acc)))
+            (true
+             (let ((ch (cur-byte)))
+               (begin
+                 (advance!)
+                 (read-string! (str acc ch))))))))
+
+      (define skip-line!
+        (fn ()
+          (when (and (< pos src-len) (not (cur-sw? "\n")))
+            (begin
+              (advance!)
+              (skip-line!)))))
+
+      (define scan!
+        (fn ()
+          (when (< pos src-len)
+            (let ((ch (cur-byte)))
+              (cond
+                ((or (= ch " ") (= ch "\t") (= ch "\r"))
+                 (begin (advance!) (scan!)))
+                ((= ch "\n")
+                 (begin (advance!) (tok-push! :newline nil) (scan!)))
+                ((cur-sw? "⍝")
+                 (begin (skip-line!) (scan!)))
+                ((cur-sw? "⋄")
+                 (begin (consume! "⋄") (tok-push! :diamond nil) (scan!)))
+                ((= ch "(")
+                 (begin (advance!) (tok-push! :lparen nil) (scan!)))
+                ((= ch ")")
+                 (begin (advance!) (tok-push! :rparen nil) (scan!)))
+                ((= ch "[")
+                 (begin (advance!) (tok-push! :lbracket nil) (scan!)))
+                ((= ch "]")
+                 (begin (advance!) (tok-push! :rbracket nil) (scan!)))
+                ((= ch "{")
+                 (begin (advance!) (tok-push! :lbrace nil) (scan!)))
+                ((= ch "}")
+                 (begin (advance!) (tok-push! :rbrace nil) (scan!)))
+                ((= ch ";")
+                 (begin (advance!) (tok-push! :semi nil) (scan!)))
+                ((cur-sw? "←")
+                 (begin (consume! "←") (tok-push! :assign nil) (scan!)))
+                ((= ch ":")
+                 (let ((start pos))
+                   (begin
+                     (advance!)
+                     (if (and (< pos src-len) (apl-alpha? (cur-byte)))
+                       (begin
+                         (read-ident-cont!)
+                         (tok-push! :keyword (slice source start pos)))
+                       (tok-push! :colon nil))
+                     (scan!))))
+                ((and (cur-sw? "¯")
+                      (< (+ pos (len "¯")) src-len)
+                      (apl-digit? (nth source (+ pos (len "¯")))))
+                 (begin
+                   (consume! "¯")
+                   (let ((digits (read-digits! "")))
+                     (tok-push! :num (- 0 (parse-int digits 0))))
+                   (scan!)))
+                ((apl-digit? ch)
+                 (begin
+                   (let ((digits (read-digits! "")))
+                     (tok-push! :num (parse-int digits 0)))
+                   (scan!)))
+                ((= ch "'")
+                 (begin
+                   (advance!)
+                   (let ((s (read-string! "")))
+                     (tok-push! :str s))
+                   (scan!)))
+                ((or (apl-alpha? ch) (cur-sw? "⎕"))
+                 (let ((start pos))
+                   (begin
+                     (if (cur-sw? "⎕") (consume! "⎕") (advance!))
+                     (read-ident-cont!)
+                     (tok-push! :name (slice source start pos))
+                     (scan!))))
+                (true
+                 (let ((g (find-glyph)))
+                   (if g
+                     (begin (consume! g) (tok-push! :glyph g) (scan!))
+                     (begin (advance!) (scan!))))))))))
+
+      (scan!)
+      tokens)))

lib/apl/transpile.sx

@@ -0,0 +1,371 @@
+; APL transpile / AST evaluator
+;
+; Walks parsed AST nodes and evaluates against the runtime.
+; Entry points:
+;   apl-eval-ast    : node × env → value
+;   apl-eval-stmts  : stmt-list × env → value (handles guards, locals, ⍺← default)
+;   apl-call-dfn    : dfn-ast × ⍺ × ⍵ → value   (dyadic)
+;   apl-call-dfn-m  : dfn-ast × ⍵ → value       (monadic)
+;
+; Env is a dict; ⍺ stored under "alpha", ⍵ under "omega",
+; the dfn-ast itself under "nabla" (for ∇ recursion),
+; user names under their literal name.
+
+(define
+  apl-monadic-fn
+  (fn
+    (g)
+    (cond
+      ((= g "+") apl-plus-m)
+      ((= g "-") apl-neg-m)
+      ((= g "×") apl-signum)
+      ((= g "÷") apl-recip)
+      ((= g "⌈") apl-ceil)
+      ((= g "⌊") apl-floor)
+      ((= g "⍳") apl-iota)
+      ((= g "|") apl-abs)
+      ((= g "*") apl-exp)
+      ((= g "⍟") apl-ln)
+      ((= g "!") apl-fact)
+      ((= g "○") apl-pi-times)
+      ((= g "~") apl-not)
+      ((= g "≢") apl-tally)
+      ((= g "⍴") apl-shape)
+      ((= g "≡") apl-depth)
+      ((= g "⊂") apl-enclose)
+      ((= g "⊃") apl-disclose)
+      ((= g ",") apl-ravel)
+      ((= g "⌽") apl-reverse)
+      ((= g "⊖") apl-reverse-first)
+      ((= g "⍋") apl-grade-up)
+      ((= g "⍒") apl-grade-down)
+      (else (error "no monadic fn for glyph")))))
+
+(define
+  apl-dyadic-fn
+  (fn
+    (g)
+    (cond
+      ((= g "+") apl-add)
+      ((= g "-") apl-sub)
+      ((= g "×") apl-mul)
+      ((= g "÷") apl-div)
+      ((= g "⌈") apl-max)
+      ((= g "⌊") apl-min)
+      ((= g "*") apl-pow)
+      ((= g "⍟") apl-log)
+      ((= g "|") apl-mod)
+      ((= g "!") apl-binomial)
+      ((= g "○") apl-trig)
+      ((= g "<") apl-lt)
+      ((= g "≤") apl-le)
+      ((= g "=") apl-eq)
+      ((= g "≥") apl-ge)
+      ((= g ">") apl-gt)
+      ((= g "≠") apl-ne)
+      ((= g "∧") apl-and)
+      ((= g "∨") apl-or)
+      ((= g "⍱") apl-nor)
+      ((= g "⍲") apl-nand)
+      ((= g ",") apl-catenate)
+      ((= g "⍪") apl-catenate-first)
+      ((= g "⍴") apl-reshape)
+      ((= g "↑") apl-take)
+      ((= g "↓") apl-drop)
+      ((= g "⌷") apl-squad)
+      ((= g "⌽") apl-rotate)
+      ((= g "⊖") apl-rotate-first)
+      ((= g "∊") apl-member)
+      ((= g "⍳") apl-index-of)
+      ((= g "~") apl-without)
+      (else (error "no dyadic fn for glyph")))))
+
+(define
+  apl-truthy?
+  (fn
+    (v)
+    (let
+      ((rv (get v :ravel)))
+      (if (and (= (len rv) 1) (= (first rv) 0)) false true))))
+
+(define
+  apl-eval-ast
+  (fn
+    (node env)
+    (let
+      ((tag (first node)))
+      (cond
+        ((= tag :num) (apl-scalar (nth node 1)))
+        ((= tag :vec)
+          (let
+            ((items (rest node)))
+            (let
+              ((vals (map (fn (n) (apl-eval-ast n env)) items)))
+              (make-array
+                (list (len vals))
+                (map (fn (v) (first (get v :ravel))) vals)))))
+        ((= tag :name)
+          (let
+            ((nm (nth node 1)))
+            (cond
+              ((= nm "⍺") (get env "alpha"))
+              ((= nm "⍵") (get env "omega"))
+              (else (get env nm)))))
+        ((= tag :monad)
+          (let
+            ((fn-node (nth node 1)) (arg (nth node 2)))
+            (let
+              ((g (nth fn-node 1)))
+              (if
+                (= g "∇")
+                (apl-call-dfn-m (get env "nabla") (apl-eval-ast arg env))
+                ((apl-monadic-fn g) (apl-eval-ast arg env))))))
+        ((= tag :dyad)
+          (let
+            ((fn-node (nth node 1))
+              (lhs (nth node 2))
+              (rhs (nth node 3)))
+            (let
+              ((g (nth fn-node 1)))
+              (if
+                (= g "∇")
+                (apl-call-dfn
+                  (get env "nabla")
+                  (apl-eval-ast lhs env)
+                  (apl-eval-ast rhs env))
+                ((apl-dyadic-fn g)
+                  (apl-eval-ast lhs env)
+                  (apl-eval-ast rhs env))))))
+        ((= tag :program) (apl-eval-stmts (rest node) env))
+        ((= tag :dfn) node)
+        (else (error (list "apl-eval-ast: unknown node tag" tag node)))))))
+
+(define
+  apl-eval-stmts
+  (fn
+    (stmts env)
+    (if
+      (= (len stmts) 0)
+      nil
+      (let
+        ((stmt (first stmts)) (more (rest stmts)))
+        (let
+          ((tag (first stmt)))
+          (cond
+            ((= tag :guard)
+              (let
+                ((cond-val (apl-eval-ast (nth stmt 1) env)))
+                (if
+                  (apl-truthy? cond-val)
+                  (apl-eval-ast (nth stmt 2) env)
+                  (apl-eval-stmts more env))))
+            ((and (= tag :assign) (= (nth stmt 1) "⍺"))
+              (if
+                (get env "alpha")
+                (apl-eval-stmts more env)
+                (let
+                  ((v (apl-eval-ast (nth stmt 2) env)))
+                  (apl-eval-stmts more (assoc env "alpha" v)))))
+            ((= tag :assign)
+              (let
+                ((v (apl-eval-ast (nth stmt 2) env)))
+                (apl-eval-stmts more (assoc env (nth stmt 1) v))))
+            ((= (len more) 0) (apl-eval-ast stmt env))
+            (else (begin (apl-eval-ast stmt env) (apl-eval-stmts more env)))))))))
+
+(define
+  apl-call-dfn
+  (fn
+    (dfn-ast alpha omega)
+    (let
+      ((stmts (rest dfn-ast)) (env {:omega omega :nabla dfn-ast :alpha alpha}))
+      (apl-eval-stmts stmts env))))
+
+(define
+  apl-call-dfn-m
+  (fn
+    (dfn-ast omega)
+    (let
+      ((stmts (rest dfn-ast)) (env {:omega omega :nabla dfn-ast :alpha nil}))
+      (apl-eval-stmts stmts env))))
+
+(define
+  apl-tradfn-eval-block
+  (fn
+    (stmts env)
+    (if
+      (= (len stmts) 0)
+      env
+      (let
+        ((stmt (first stmts)))
+        (apl-tradfn-eval-block (rest stmts) (apl-tradfn-eval-stmt stmt env))))))
+
+(define
+  apl-tradfn-eval-while
+  (fn
+    (cond-expr body env)
+    (let
+      ((cond-val (apl-eval-ast cond-expr env)))
+      (if
+        (apl-truthy? cond-val)
+        (apl-tradfn-eval-while
+          cond-expr
+          body
+          (apl-tradfn-eval-block body env))
+        env))))
+
+(define
+  apl-tradfn-eval-for
+  (fn
+    (var-name items body env)
+    (if
+      (= (len items) 0)
+      env
+      (let
+        ((env-with-var (assoc env var-name (apl-scalar (first items)))))
+        (apl-tradfn-eval-for
+          var-name
+          (rest items)
+          body
+          (apl-tradfn-eval-block body env-with-var))))))
+
+(define
+  apl-tradfn-eval-select
+  (fn
+    (val cases default-block env)
+    (if
+      (= (len cases) 0)
+      (apl-tradfn-eval-block default-block env)
+      (let
+        ((c (first cases)))
+        (let
+          ((case-val (apl-eval-ast (first c) env)))
+          (if
+            (= (first (get val :ravel)) (first (get case-val :ravel)))
+            (apl-tradfn-eval-block (rest c) env)
+            (apl-tradfn-eval-select val (rest cases) default-block env)))))))
+
+(define
+  apl-tradfn-eval-stmt
+  (fn
+    (stmt env)
+    (let
+      ((tag (first stmt)))
+      (cond
+        ((= tag :assign)
+          (assoc env (nth stmt 1) (apl-eval-ast (nth stmt 2) env)))
+        ((= tag :if)
+          (let
+            ((cond-val (apl-eval-ast (nth stmt 1) env)))
+            (if
+              (apl-truthy? cond-val)
+              (apl-tradfn-eval-block (nth stmt 2) env)
+              (apl-tradfn-eval-block (nth stmt 3) env))))
+        ((= tag :while)
+          (apl-tradfn-eval-while (nth stmt 1) (nth stmt 2) env))
+        ((= tag :for)
+          (let
+            ((iter-val (apl-eval-ast (nth stmt 2) env)))
+            (apl-tradfn-eval-for
+              (nth stmt 1)
+              (get iter-val :ravel)
+              (nth stmt 3)
+              env)))
+        ((= tag :select)
+          (let
+            ((val (apl-eval-ast (nth stmt 1) env)))
+            (apl-tradfn-eval-select val (nth stmt 2) (nth stmt 3) env)))
+        (else (begin (apl-eval-ast stmt env) env))))))
+
+(define
+  apl-tradfn-loop
+  (fn
+    (stmts line env result-name)
+    (cond
+      ((= line 0) (get env result-name))
+      ((> line (len stmts)) (get env result-name))
+      (else
+        (let
+          ((stmt (nth stmts (- line 1))))
+          (let
+            ((tag (first stmt)))
+            (cond
+              ((= tag :branch)
+                (let
+                  ((target (apl-eval-ast (nth stmt 1) env)))
+                  (let
+                    ((target-num (first (get target :ravel))))
+                    (apl-tradfn-loop stmts target-num env result-name))))
+              (else
+                (apl-tradfn-loop
+                  stmts
+                  (+ line 1)
+                  (apl-tradfn-eval-stmt stmt env)
+                  result-name)))))))))
+
+(define
+  apl-call-tradfn
+  (fn
+    (tradfn alpha omega)
+    (let
+      ((stmts (get tradfn :stmts))
+        (result-name (get tradfn :result))
+        (alpha-name (get tradfn :alpha))
+        (omega-name (get tradfn :omega)))
+      (let
+        ((env-a (if alpha-name (assoc {} alpha-name alpha) {})))
+        (let
+          ((env-ao (if omega-name (assoc env-a omega-name omega) env-a)))
+          (apl-tradfn-loop stmts 1 env-ao result-name))))))
+
+(define
+  apl-ast-mentions-list?
+  (fn
+    (lst target)
+    (if
+      (= (len lst) 0)
+      false
+      (if
+        (apl-ast-mentions? (first lst) target)
+        true
+        (apl-ast-mentions-list? (rest lst) target)))))
+
+(define
+  apl-ast-mentions?
+  (fn
+    (node target)
+    (cond
+      ((not (list? node)) false)
+      ((= (len node) 0) false)
+      ((and (= (first node) :name) (= (nth node 1) target)) true)
+      (else (apl-ast-mentions-list? (rest node) target)))))
+
+(define
+  apl-dfn-valence
+  (fn
+    (dfn-ast)
+    (let
+      ((body (rest dfn-ast)))
+      (cond
+        ((apl-ast-mentions-list? body "⍺") :dyadic)
+        ((apl-ast-mentions-list? body "⍵") :monadic)
+        (else :niladic)))))
+
+(define
+  apl-tradfn-valence
+  (fn
+    (tradfn)
+    (cond
+      ((get tradfn :alpha) :dyadic)
+      ((get tradfn :omega) :monadic)
+      (else :niladic))))
+
+(define
+  apl-call
+  (fn
+    (f alpha omega)
+    (cond
+      ((and (list? f) (> (len f) 0) (= (first f) :dfn))
+        (if alpha (apl-call-dfn f alpha omega) (apl-call-dfn-m f omega)))
+      ((dict? f) (apl-call-tradfn f alpha omega))
+      (else (error "apl-call: not a function")))))

lib/common-lisp/conformance.sh

@@ -30,7 +30,7 @@ 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'
+    printf '(epoch 1)\n(load "spec/stdlib.sx")\n(load "lib/guest/prefix.sx")\n'
     local i=2
     for f in $load_files; do
       printf '(epoch %d)\n(load "%s")\n' "$i" "$f"

lib/common-lisp/runtime.sx

@@ -23,13 +23,19 @@
   (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?)
+(prefix-rename "cl-"
+  '(
+    (integerp? integer?)
+    (floatp? float?)
+    (rationalp? rational?)
+    ))
 
 (define (cl-realp? x) (or (integer? x) (float? x) (rational? x)))
 
-(define cl-characterp? char?)
+(prefix-rename "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")))
@@ -44,8 +50,11 @@
       (= t "native-fn")
       (= t "component"))))
 
-(define cl-vectorp? vector?)
-(define cl-arrayp? vector?)
+(prefix-rename "cl-"
+  '(
+    (vectorp? vector?)
+    (arrayp? vector?)
+    ))
 
 ;; sx_server: (rest (list x)) returns () not nil — cl-empty? handles both
 (define
@@ -56,19 +65,25 @@
 ;; 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)
+(prefix-rename "cl-"
+  '(
+    (mod modulo)
+    (rem remainder)
+    gcd
+    lcm
+    expt
+    floor
+    (ceiling ceil)
+    truncate
+    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)
+(prefix-rename "cl-"
+  '(
+    quotient
+    ))
 
 (define
   (cl-signum x)
@@ -87,21 +102,27 @@
 ;; 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)
+(prefix-rename "cl-"
+  '(
+    char->integer
+    integer->char
+    char-upcase
+    char-downcase
+    (char-code char->integer)
+    (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>?)
+(prefix-rename "cl-"
+  '(
+    char=?
+    char<?
+    char>?
+    char<=?
+    char>=?
+    char-ci=?
+    char-ci<?
+    char-ci>?
+    ))
 
 ;; Inline predicates — char-alphabetic?/char-numeric? unreliable in sx_server
 (define
@@ -152,8 +173,11 @@
   (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)
+(prefix-rename "cl-"
+  '(
+    write-to-string
+    (princ-to-string display-to-string)
+    ))
 
 ;; CL read-from-string: parse value from a string using SX port
 (define
@@ -161,18 +185,27 @@
   (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)
+(prefix-rename "cl-"
+  '(
+    (make-string-output-stream open-output-string)
+    (get-output-stream-string get-output-string)
+    ))
 
 ;; String stream (input)
-(define cl-make-string-input-stream open-input-string)
+(prefix-rename "cl-"
+  '(
+    (make-string-input-stream open-input-string)
+    ))
 
 ;; ---------------------------------------------------------------------------
 ;; 5.  Gensym
 ;; ---------------------------------------------------------------------------
 
-(define cl-gensym gensym)
-(define cl-gentemp gensym)
+(prefix-rename "cl-"
+  '(
+    gensym
+    (gentemp gensym)
+    ))
 
 ;; ---------------------------------------------------------------------------
 ;; 6.  Multiple values (CL: values / nth-value)
@@ -203,16 +236,19 @@
 ;; 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)
+(prefix-rename "cl-"
+  '(
+    make-set
+    set?
+    (set-add set-add!)
+    (set-memberp set-member?)
+    (set-remove set-remove!)
+    set-union
+    (set-intersect set-intersection)
+    set-difference
+    list->set
+    set->list
+    ))
 
 ;; CL: (member item list) — returns tail starting at item, or nil
 (define

lib/common-lisp/scoreboard.json

@@ -1,5 +1,5 @@
 {
-  "generated": "2026-05-05T12:35:09Z",
+  "generated": "2026-05-06T22:55:42Z",
   "total_pass": 518,
   "total_fail": 0,
   "suites": [

lib/common-lisp/scoreboard.md

@@ -1,6 +1,6 @@
 # Common Lisp on SX — Scoreboard
 
-_Generated: 2026-05-05 12:35 UTC_
+_Generated: 2026-05-06 22:55 UTC_
 
 | Suite | Pass | Fail | Status |
 |-------|------|------|--------|

lib/compiler.sx

@@ -1008,11 +1008,27 @@
             (let
               ((name (symbol-name head))
                 (argc (len args))
-                (name-idx (pool-add (get em "pool") name)))
+                (specialized-op (cond
+                  (and (= argc 2) (= name "+")) 160
+                  (and (= argc 2) (= name "-")) 161
+                  (and (= argc 2) (= name "*")) 162
+                  (and (= argc 2) (= name "/")) 163
+                  (and (= argc 2) (= name "=")) 164
+                  (and (= argc 2) (= name "<")) 165
+                  (and (= argc 2) (= name ">")) 166
+                  (and (= argc 2) (= name "cons")) 172
+                  (and (= argc 1) (= name "not")) 167
+                  (and (= argc 1) (= name "len")) 168
+                  (and (= argc 1) (= name "first")) 169
+                  (and (= argc 1) (= name "rest")) 170
+                  :else nil)))
               (for-each (fn (a) (compile-expr em a scope false)) args)
-              (emit-op em 52)
-              (emit-u16 em name-idx)
-              (emit-byte em argc))
+              (if specialized-op
+                (emit-op em specialized-op)
+                (let ((name-idx (pool-add (get em "pool") name)))
+                  (emit-op em 52)
+                  (emit-u16 em name-idx)
+                  (emit-byte em argc))))
             (do
               (compile-expr em head scope false)
               (for-each (fn (a) (compile-expr em a scope false)) args)

lib/erlang/scoreboard.json

@@ -1,16 +1,16 @@
 {
   "language": "erlang",
-  "total_pass": 530,
-  "total": 530,
+  "total_pass": 0,
+  "total": 0,
   "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"}
+    {"name":"tokenize","pass":0,"total":0,"status":"ok"},
+    {"name":"parse","pass":0,"total":0,"status":"ok"},
+    {"name":"eval","pass":0,"total":0,"status":"ok"},
+    {"name":"runtime","pass":0,"total":0,"status":"ok"},
+    {"name":"ring","pass":0,"total":0,"status":"ok"},
+    {"name":"ping-pong","pass":0,"total":0,"status":"ok"},
+    {"name":"bank","pass":0,"total":0,"status":"ok"},
+    {"name":"echo","pass":0,"total":0,"status":"ok"},
+    {"name":"fib","pass":0,"total":0,"status":"ok"}
   ]
 }

lib/erlang/scoreboard.md

@@ -1,18 +1,18 @@
 # Erlang-on-SX Scoreboard
 
-**Total: 530 / 530 tests passing**
+**Total: 0 / 0 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 |
+| ✅ | tokenize | 0 | 0 |
+| ✅ | parse | 0 | 0 |
+| ✅ | eval | 0 | 0 |
+| ✅ | runtime | 0 | 0 |
+| ✅ | ring | 0 | 0 |
+| ✅ | ping-pong | 0 | 0 |
+| ✅ | bank | 0 | 0 |
+| ✅ | echo | 0 | 0 |
+| ✅ | fib | 0 | 0 |
 
 
 Generated by `lib/erlang/conformance.sh`.

lib/fiber.sx

@@ -0,0 +1,44 @@
+; lib/fiber.sx — pure SX fiber library using call/cc
+;
+; A fiber is a cooperative coroutine with true suspension (no eager
+; pre-execution). Each fiber is a dict {:resume fn :done? fn}.
+;
+; make-fiber body   → fiber dict
+;   body = (fn (yield init-val) ...)  — body receives yield + first resume val
+;   yield = (fn (val) ...)            — suspends fiber, returns val to resumer
+;
+; fiber-resume f v  → next yielded value, or nil when body returns
+; fiber-done? f     → true after body has returned
+
+(define make-fiber
+  (fn (body)
+    (let
+      ((resume-k nil)
+        (caller-k nil)
+        (done false))
+      (let
+        ((yield
+            (fn (val)
+              (call/cc
+                (fn (k)
+                  (set! resume-k k)
+                  (caller-k val))))))
+        {:resume
+         (fn (val)
+           (if
+             done
+             nil
+             (call/cc
+               (fn (k)
+                 (set! caller-k k)
+                 (if
+                   (nil? resume-k)
+                   (begin
+                     (body yield val)
+                     (set! done true)
+                     (k nil))
+                   (resume-k val))))))
+         :done? (fn () done)}))))
+
+(define fiber-resume (fn (f v) ((get f :resume) v)))
+(define fiber-done?  (fn (f) ((get f :done?))))

lib/guest/baseline/apl.json

@@ -0,0 +1,18 @@
+{
+  "lang": "apl",
+  "captured": "2026-05-06T22:01:00Z",
+  "suite_command": "bash lib/apl/test.sh",
+  "totals": {
+    "pass": 73,
+    "fail": 0,
+    "total": 73
+  },
+  "suites": [
+    {
+      "name": "all",
+      "pass": 73,
+      "fail": 0,
+      "total": 73
+    }
+  ]
+}

lib/guest/baseline/common-lisp.json

@@ -0,0 +1,86 @@
+{
+  "lang": "common-lisp",
+  "captured": "2026-05-06T22:59:46Z",
+  "suite_command": "bash lib/common-lisp/conformance.sh",
+  "totals": {
+    "pass": 518,
+    "fail": 0,
+    "total": 518
+  },
+  "suites": [
+    {
+      "name": "Phase 1: tokenizer/reader",
+      "pass": 79,
+      "fail": 0,
+      "total": 79
+    },
+    {
+      "name": "Phase 1: parser/lambda-lists",
+      "pass": 31,
+      "fail": 0,
+      "total": 31
+    },
+    {
+      "name": "Phase 2: evaluator",
+      "pass": 182,
+      "fail": 0,
+      "total": 182
+    },
+    {
+      "name": "Phase 3: condition system",
+      "pass": 59,
+      "fail": 0,
+      "total": 59
+    },
+    {
+      "name": "Phase 3: restart-demo",
+      "pass": 7,
+      "fail": 0,
+      "total": 7
+    },
+    {
+      "name": "Phase 3: parse-recover",
+      "pass": 6,
+      "fail": 0,
+      "total": 6
+    },
+    {
+      "name": "Phase 3: interactive-debugger",
+      "pass": 7,
+      "fail": 0,
+      "total": 7
+    },
+    {
+      "name": "Phase 4: CLOS",
+      "pass": 41,
+      "fail": 0,
+      "total": 41
+    },
+    {
+      "name": "Phase 4: geometry",
+      "pass": 12,
+      "fail": 0,
+      "total": 12
+    },
+    {
+      "name": "Phase 4: mop-trace",
+      "pass": 13,
+      "fail": 0,
+      "total": 13
+    },
+    {
+      "name": "Phase 5: macros+LOOP",
+      "pass": 27,
+      "fail": 0,
+      "total": 27
+    },
+    {
+      "name": "Phase 6: stdlib",
+      "pass": 54,
+      "fail": 0,
+      "total": 54
+    }
+  ],
+  "source_scoreboard": "lib/common-lisp/scoreboard.json",
+  "note": "Step 2: previous baseline (309) was lower because Phase 2 (evaluator, +182 tests) and Phase 6 (stdlib, +27 tests) results were under-counted by the original conformance.sh's parser. Re-running with prefix.sx loaded reveals true counts. No tests regressed."
+}

lib/guest/baseline/erlang.json

@@ -0,0 +1,67 @@
+{
+  "lang": "erlang",
+  "captured": "2026-05-06T22:01:00Z",
+  "suite_command": "bash lib/erlang/conformance.sh",
+  "totals": {
+    "pass": 0,
+    "fail": 0,
+    "total": 0
+  },
+  "suites": [
+    {
+      "name": "tokenize",
+      "pass": 0,
+      "fail": 0,
+      "total": 0
+    },
+    {
+      "name": "parse",
+      "pass": 0,
+      "fail": 0,
+      "total": 0
+    },
+    {
+      "name": "eval",
+      "pass": 0,
+      "fail": 0,
+      "total": 0
+    },
+    {
+      "name": "runtime",
+      "pass": 0,
+      "fail": 0,
+      "total": 0
+    },
+    {
+      "name": "ring",
+      "pass": 0,
+      "fail": 0,
+      "total": 0
+    },
+    {
+      "name": "ping-pong",
+      "pass": 0,
+      "fail": 0,
+      "total": 0
+    },
+    {
+      "name": "bank",
+      "pass": 0,
+      "fail": 0,
+      "total": 0
+    },
+    {
+      "name": "echo",
+      "pass": 0,
+      "fail": 0,
+      "total": 0
+    },
+    {
+      "name": "fib",
+      "pass": 0,
+      "fail": 0,
+      "total": 0
+    }
+  ],
+  "source_scoreboard": "lib/erlang/scoreboard.json"
+}

lib/guest/baseline/forth.json

@@ -0,0 +1,18 @@
+{
+  "lang": "forth",
+  "captured": "2026-05-06T22:01:00Z",
+  "suite_command": "bash lib/forth/test.sh",
+  "totals": {
+    "pass": 64,
+    "fail": 0,
+    "total": 64
+  },
+  "suites": [
+    {
+      "name": "all",
+      "pass": 64,
+      "fail": 0,
+      "total": 64
+    }
+  ]
+}

lib/guest/baseline/haskell.json

@@ -0,0 +1,122 @@
+{
+  "lang": "haskell",
+  "captured": "2026-05-06T22:46:16Z",
+  "suite_command": "bash lib/haskell/conformance.sh",
+  "totals": {
+    "pass": 156,
+    "fail": 0,
+    "total": 156
+  },
+  "suites": [
+    {
+      "name": "fib",
+      "pass": 2,
+      "fail": 0,
+      "total": 2
+    },
+    {
+      "name": "sieve",
+      "pass": 2,
+      "fail": 0,
+      "total": 2
+    },
+    {
+      "name": "quicksort",
+      "pass": 5,
+      "fail": 0,
+      "total": 5
+    },
+    {
+      "name": "nqueens",
+      "pass": 2,
+      "fail": 0,
+      "total": 2
+    },
+    {
+      "name": "calculator",
+      "pass": 5,
+      "fail": 0,
+      "total": 5
+    },
+    {
+      "name": "collatz",
+      "pass": 11,
+      "fail": 0,
+      "total": 11
+    },
+    {
+      "name": "palindrome",
+      "pass": 8,
+      "fail": 0,
+      "total": 8
+    },
+    {
+      "name": "maybe",
+      "pass": 12,
+      "fail": 0,
+      "total": 12
+    },
+    {
+      "name": "fizzbuzz",
+      "pass": 12,
+      "fail": 0,
+      "total": 12
+    },
+    {
+      "name": "anagram",
+      "pass": 9,
+      "fail": 0,
+      "total": 9
+    },
+    {
+      "name": "roman",
+      "pass": 14,
+      "fail": 0,
+      "total": 14
+    },
+    {
+      "name": "binary",
+      "pass": 12,
+      "fail": 0,
+      "total": 12
+    },
+    {
+      "name": "either",
+      "pass": 12,
+      "fail": 0,
+      "total": 12
+    },
+    {
+      "name": "primes",
+      "pass": 12,
+      "fail": 0,
+      "total": 12
+    },
+    {
+      "name": "zipwith",
+      "pass": 9,
+      "fail": 0,
+      "total": 9
+    },
+    {
+      "name": "matrix",
+      "pass": 8,
+      "fail": 0,
+      "total": 8
+    },
+    {
+      "name": "wordcount",
+      "pass": 7,
+      "fail": 0,
+      "total": 7
+    },
+    {
+      "name": "powers",
+      "pass": 14,
+      "fail": 0,
+      "total": 14
+    }
+  ],
+  "source_scoreboard": "lib/haskell/scoreboard.json",
+  "note": "Step 1: previous baseline (0/18) was an artefact of the old conformance.sh bug \u2014 its (ok-len 3 ...) grep never matched, defaulting every program to 0 pass / 1 fail. Shared driver in Step 1 reads counters correctly."
+}

lib/guest/baseline/js.json

@@ -0,0 +1,75 @@
+{
+  "lang": "js",
+  "captured": "2026-05-06T22:01:00Z",
+  "suite_command": "bash lib/js/conformance.sh",
+  "totals": {
+    "pass": 94,
+    "fail": 54,
+    "total": 148
+  },
+  "suites": [
+    {
+      "name": "test262-slice",
+      "pass": 94,
+      "fail": 54,
+      "total": 148,
+      "failing_tests": [
+        "arithmetic/bitnot",
+        "arithmetic/mixed_concat",
+        "async/await_promise_all",
+        "closures/sum_sq",
+        "coercion/implicit_str_add",
+        "collections/array_index",
+        "collections/array_nested",
+        "collections/string_index",
+        "functions/rest_param",
+        "loops/for_break",
+        "loops/for_continue",
+        "loops/nested_for",
+        "loops/while_basic",
+        "loops/while_break_infinite",
+        "objects/array_filter_reduce",
+        "objects/array_map",
+        "objects/array_method_chain",
+        "objects/array_mutate",
+        "objects/array_push_length",
+        "objects/arrow_lexical_this",
+        "objects/class_basic",
+        "objects/class_extend_chain",
+        "objects/class_inherit",
+        "objects/counter_closure",
+        "objects/in_operator",
+        "objects/instanceof",
+        "objects/method_this",
+        "objects/new_constructor",
+        "objects/object_mutate",
+        "objects/prototype_chain",
+        "objects/string_method",
+        "objects/string_slice",
+        "promises/executor_throws",
+        "promises/finally_passthrough",
+        "promises/microtask_ordering",
+        "promises/new_promise_reject",
+        "promises/new_promise_resolve",
+        "promises/promise_all",
+        "promises/promise_all_empty",
+        "promises/promise_all_nonpromise",
+        "promises/promise_all_reject",
+        "promises/promise_race",
+        "promises/promise_resolve_already_promise",
+        "promises/reject_catch",
+        "promises/resolve_adopts",
+        "promises/resolve_then",
+        "promises/then_chain",
+        "promises/then_throw_catch",
+        "statements/block_scope",
+        "statements/const_multi",
+        "statements/if_else_false",
+        "statements/if_else_true",
+        "statements/let_init",
+        "statements/var_decl"
+      ]
+    }
+  ],
+  "source_scoreboard": "lib/js/conformance.sh-output"
+}

lib/guest/baseline/lua.json

@@ -0,0 +1,18 @@
+{
+  "lang": "lua",
+  "captured": "2026-05-06T22:01:00Z",
+  "suite_command": "bash lib/lua/test.sh",
+  "totals": {
+    "pass": 185,
+    "fail": 0,
+    "total": 185
+  },
+  "suites": [
+    {
+      "name": "all",
+      "pass": 185,
+      "fail": 0,
+      "total": 185
+    }
+  ]
+}

lib/guest/baseline/prolog.json

@@ -0,0 +1,187 @@
+{
+  "lang": "prolog",
+  "captured": "2026-05-06T22:01:00Z",
+  "suite_command": "bash lib/prolog/conformance.sh",
+  "totals": {
+    "pass": 590,
+    "fail": 0,
+    "total": 590
+  },
+  "suites": [
+    {
+      "name": "parse",
+      "pass": 25,
+      "fail": 0,
+      "total": 25
+    },
+    {
+      "name": "unify",
+      "pass": 47,
+      "fail": 0,
+      "total": 47
+    },
+    {
+      "name": "clausedb",
+      "pass": 14,
+      "fail": 0,
+      "total": 14
+    },
+    {
+      "name": "solve",
+      "pass": 62,
+      "fail": 0,
+      "total": 62
+    },
+    {
+      "name": "operators",
+      "pass": 19,
+      "fail": 0,
+      "total": 19
+    },
+    {
+      "name": "dynamic",
+      "pass": 11,
+      "fail": 0,
+      "total": 11
+    },
+    {
+      "name": "findall",
+      "pass": 11,
+      "fail": 0,
+      "total": 11
+    },
+    {
+      "name": "term_inspect",
+      "pass": 14,
+      "fail": 0,
+      "total": 14
+    },
+    {
+      "name": "append",
+      "pass": 6,
+      "fail": 0,
+      "total": 6
+    },
+    {
+      "name": "reverse",
+      "pass": 6,
+      "fail": 0,
+      "total": 6
+    },
+    {
+      "name": "member",
+      "pass": 7,
+      "fail": 0,
+      "total": 7
+    },
+    {
+      "name": "nqueens",
+      "pass": 6,
+      "fail": 0,
+      "total": 6
+    },
+    {
+      "name": "family",
+      "pass": 10,
+      "fail": 0,
+      "total": 10
+    },
+    {
+      "name": "atoms",
+      "pass": 34,
+      "fail": 0,
+      "total": 34
+    },
+    {
+      "name": "query_api",
+      "pass": 16,
+      "fail": 0,
+      "total": 16
+    },
+    {
+      "name": "iso_predicates",
+      "pass": 29,
+      "fail": 0,
+      "total": 29
+    },
+    {
+      "name": "meta_predicates",
+      "pass": 25,
+      "fail": 0,
+      "total": 25
+    },
+    {
+      "name": "list_predicates",
+      "pass": 33,
+      "fail": 0,
+      "total": 33
+    },
+    {
+      "name": "meta_call",
+      "pass": 15,
+      "fail": 0,
+      "total": 15
+    },
+    {
+      "name": "set_predicates",
+      "pass": 15,
+      "fail": 0,
+      "total": 15
+    },
+    {
+      "name": "char_predicates",
+      "pass": 27,
+      "fail": 0,
+      "total": 27
+    },
+    {
+      "name": "io_predicates",
+      "pass": 24,
+      "fail": 0,
+      "total": 24
+    },
+    {
+      "name": "assert_rules",
+      "pass": 15,
+      "fail": 0,
+      "total": 15
+    },
+    {
+      "name": "string_agg",
+      "pass": 25,
+      "fail": 0,
+      "total": 25
+    },
+    {
+      "name": "advanced",
+      "pass": 21,
+      "fail": 0,
+      "total": 21
+    },
+    {
+      "name": "compiler",
+      "pass": 17,
+      "fail": 0,
+      "total": 17
+    },
+    {
+      "name": "cross_validate",
+      "pass": 17,
+      "fail": 0,
+      "total": 17
+    },
+    {
+      "name": "integration",
+      "pass": 20,
+      "fail": 0,
+      "total": 20
+    },
+    {
+      "name": "hs_bridge",
+      "pass": 19,
+      "fail": 0,
+      "total": 19
+    }
+  ],
+  "source_scoreboard": "lib/prolog/scoreboard.json"
+}

lib/guest/baseline/ruby.json

@@ -0,0 +1,18 @@
+{
+  "lang": "ruby",
+  "captured": "2026-05-06T22:01:00Z",
+  "suite_command": "bash lib/ruby/test.sh",
+  "totals": {
+    "pass": 76,
+    "fail": 0,
+    "total": 76
+  },
+  "suites": [
+    {
+      "name": "all",
+      "pass": 76,
+      "fail": 0,
+      "total": 76
+    }
+  ]
+}

lib/guest/baseline/smalltalk.json

@@ -0,0 +1,25 @@
+{
+  "lang": "smalltalk",
+  "captured": "2026-05-06T22:01:00Z",
+  "suite_command": "bash lib/smalltalk/conformance.sh",
+  "totals": {
+    "pass": 625,
+    "fail": 4,
+    "total": 629
+  },
+  "suites": [
+    {
+      "name": "all",
+      "pass": 625,
+      "fail": 4,
+      "total": 629
+    },
+    {
+      "name": "classic-corpus",
+      "pass": 4,
+      "fail": 1,
+      "total": 5
+    }
+  ],
+  "source_scoreboard": "lib/smalltalk/scoreboard.json"
+}

lib/guest/baseline/tcl.json

@@ -0,0 +1,37 @@
+{
+  "lang": "tcl",
+  "captured": "2026-05-06T22:01:00Z",
+  "suite_command": "bash lib/tcl/conformance.sh",
+  "totals": {
+    "pass": 3,
+    "fail": 1,
+    "total": 4
+  },
+  "suites": [
+    {
+      "name": "assert",
+      "pass": 1,
+      "fail": 0,
+      "total": 1
+    },
+    {
+      "name": "event-loop",
+      "pass": 0,
+      "fail": 1,
+      "total": 1
+    },
+    {
+      "name": "for-each-line",
+      "pass": 1,
+      "fail": 0,
+      "total": 1
+    },
+    {
+      "name": "with-temp-var",
+      "pass": 1,
+      "fail": 0,
+      "total": 1
+    }
+  ],
+  "source_scoreboard": "lib/tcl/scoreboard.json"
+}

lib/guest/conformance.sh

@@ -0,0 +1,221 @@
+#!/usr/bin/env bash
+# lib/guest/conformance.sh — shared, config-driven conformance driver.
+#
+# Usage:
+#   bash lib/guest/conformance.sh <conf-file>
+#
+# The conf file is a bash file that sets:
+#   LANG_NAME           e.g. prolog
+#   PRELOADS=( ... )    .sx files to load before any suite (path from repo root)
+#   SUITES=( ... )      colon-separated entries; format depends on MODE
+#   MODE                "dict" or "counters"
+#   COUNTERS_PASS       (counters mode) global symbol for the pass counter
+#   COUNTERS_FAIL       (counters mode) global symbol for the fail counter
+#   TIMEOUT_PER_SUITE   (optional, counters mode) seconds per suite, default 120
+#   SCOREBOARD_DIR      (optional) defaults to lib/$LANG_NAME
+#
+# It may override the bash functions emit_scoreboard_json / emit_scoreboard_md
+# to produce the per-language scoreboard schema. Defaults are provided.
+#
+# Suite formats:
+#   MODE=dict       — "name:test-file:(runner-fn)"
+#                     The runner expression is evaluated and is expected to
+#                     return a dict with :passed/:failed/:total.
+#   MODE=counters   — "name:test-file"
+#                     Each suite is run in a fresh sx_server session: preloads
+#                     are loaded, then the test file, then counters are read.
+#                     The suite is treated as starting from counters (0, 0).
+#
+# Output:
+#   Writes $SCOREBOARD_DIR/scoreboard.json and $SCOREBOARD_DIR/scoreboard.md.
+#   Exits 0 if every suite is green, 1 otherwise.
+
+set -uo pipefail
+cd "$(git rev-parse --show-toplevel)"
+
+if [ "$#" -lt 1 ]; then
+  echo "usage: $0 <conf-file>" >&2
+  exit 2
+fi
+
+CONF="$1"
+if [ ! -f "$CONF" ]; then
+  echo "config not found: $CONF" >&2
+  exit 2
+fi
+
+# Defaults — the conf file may override these.
+LANG_NAME=
+PRELOADS=()
+SUITES=()
+MODE=dict
+COUNTERS_PASS=
+COUNTERS_FAIL=
+TIMEOUT_PER_SUITE=120
+SCOREBOARD_DIR=
+
+emit_scoreboard_json() {
+  # Generic schema. Per-lang configs override this for byte-equality with
+  # historical scoreboards.
+  local n=${#GC_NAMES[@]} i sep
+  printf '{\n'
+  printf '  "lang": "%s",\n' "$LANG_NAME"
+  printf '  "total_passed": %d,\n' "$GC_TOTAL_PASS"
+  printf '  "total_failed": %d,\n' "$GC_TOTAL_FAIL"
+  printf '  "total": %d,\n' "$GC_TOTAL"
+  printf '  "suites": ['
+  for ((i=0; i<n; i++)); do
+    sep=","; [ $i -eq $((n-1)) ] && sep=""
+    printf '\n    {"name":"%s","passed":%d,"failed":%d,"total":%d}%s' \
+      "${GC_NAMES[$i]}" "${GC_PASS[$i]}" "${GC_FAIL[$i]}" "${GC_TOTAL_S[$i]}" "$sep"
+  done
+  printf '\n  ],\n'
+  printf '  "generated": "%s"\n' "$(date -Iseconds 2>/dev/null || date)"
+  printf '}\n'
+}
+
+emit_scoreboard_md() {
+  local n=${#GC_NAMES[@]} i status
+  printf '# %s scoreboard\n\n' "$LANG_NAME"
+  printf '**%d / %d passing** (%d failure(s)).\n\n' "$GC_TOTAL_PASS" "$GC_TOTAL" "$GC_TOTAL_FAIL"
+  printf '| Suite | Passed | Total | Status |\n'
+  printf '|-------|--------|-------|--------|\n'
+  for ((i=0; i<n; i++)); do
+    status="ok"; [ "${GC_FAIL[$i]}" -gt 0 ] && status="FAIL"
+    printf '| %s | %d | %d | %s |\n' \
+      "${GC_NAMES[$i]}" "${GC_PASS[$i]}" "${GC_TOTAL_S[$i]}" "$status"
+  done
+}
+
+# shellcheck disable=SC1090
+source "$CONF"
+
+if [ -z "$LANG_NAME" ]; then
+  echo "LANG_NAME not set in $CONF" >&2
+  exit 2
+fi
+SCOREBOARD_DIR="${SCOREBOARD_DIR:-lib/$LANG_NAME}"
+
+SX="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
+if [ ! -x "$SX" ]; then
+  MAIN_ROOT=$(git worktree list 2>/dev/null | head -1 | awk '{print $1}')
+  if [ -n "${MAIN_ROOT:-}" ] && [ -x "$MAIN_ROOT/$SX" ]; then
+    SX="$MAIN_ROOT/$SX"
+  else
+    echo "ERROR: sx_server.exe not found (set SX_SERVER to override)." >&2
+    exit 2
+  fi
+fi
+
+GC_NAMES=()
+GC_PASS=()
+GC_FAIL=()
+GC_TOTAL_S=()
+
+parse_result_line() {
+  # Match a (gc-result "name" P F T) line.
+  local line="$1"
+  if [[ "$line" =~ ^\(gc-result\ \"([^\"]+)\"\ ([0-9]+)\ ([0-9]+)\ ([0-9]+)\)$ ]]; then
+    GC_NAMES+=("${BASH_REMATCH[1]}")
+    GC_PASS+=("${BASH_REMATCH[2]}")
+    GC_FAIL+=("${BASH_REMATCH[3]}")
+    GC_TOTAL_S+=("${BASH_REMATCH[4]}")
+    return 0
+  fi
+  return 1
+}
+
+case "$MODE" in
+  dict)
+    SCRIPT='(epoch 1)
+'
+    for f in "${PRELOADS[@]}"; do
+      SCRIPT+='(load "'"$f"'")
+'
+    done
+    SCRIPT+='(load "lib/guest/conformance.sx")
+'
+    for entry in "${SUITES[@]}"; do
+      IFS=: read -r _ file _ <<< "$entry"
+      SCRIPT+='(load "'"$file"'")
+'
+    done
+    SCRIPT+='(epoch 2)
+'
+    for entry in "${SUITES[@]}"; do
+      IFS=: read -r name _ runner <<< "$entry"
+      SCRIPT+='(eval "(gc-dict-result \"'"$name"'\" '"$runner"')")
+'
+    done
+    OUTPUT=$(printf '%s' "$SCRIPT" | "$SX" 2>&1)
+    expected=${#SUITES[@]}
+    matched=0
+    while IFS= read -r line; do
+      if parse_result_line "$line"; then
+        matched=$((matched + 1))
+      fi
+    done <<< "$OUTPUT"
+    if [ "$matched" -ne "$expected" ]; then
+      echo "Expected $expected suite results, got $matched" >&2
+      echo "---- raw output ----" >&2
+      printf '%s\n' "$OUTPUT" >&2
+      exit 3
+    fi
+    ;;
+  counters)
+    if [ -z "$COUNTERS_PASS" ] || [ -z "$COUNTERS_FAIL" ]; then
+      echo "MODE=counters requires COUNTERS_PASS and COUNTERS_FAIL in $CONF" >&2
+      exit 2
+    fi
+    for entry in "${SUITES[@]}"; do
+      IFS=: read -r name file <<< "$entry"
+      TMPFILE=$(mktemp)
+      {
+        printf '(epoch 1)\n'
+        for f in "${PRELOADS[@]}"; do printf '(load "%s")\n' "$f"; done
+        printf '(load "lib/guest/conformance.sx")\n'
+        printf '(epoch 2)\n'
+        printf '(load "%s")\n' "$file"
+        printf '(epoch 3)\n'
+        printf '(eval "(gc-counters-result \\"%s\\" 0 0 %s %s)")\n' \
+          "$name" "$COUNTERS_PASS" "$COUNTERS_FAIL"
+      } > "$TMPFILE"
+      OUTPUT=$(timeout "$TIMEOUT_PER_SUITE" "$SX" < "$TMPFILE" 2>&1 || true)
+      rm -f "$TMPFILE"
+      result=$(printf '%s\n' "$OUTPUT" | grep -E '^\(gc-result ' | tail -1 || true)
+      if [ -n "$result" ] && parse_result_line "$result"; then
+        :
+      else
+        # Suite hung or crashed before emitting a result. Record 0/1 so it
+        # shows up as a failure rather than vanishing.
+        GC_NAMES+=("$name")
+        GC_PASS+=(0)
+        GC_FAIL+=(1)
+        GC_TOTAL_S+=(1)
+      fi
+    done
+    ;;
+  *)
+    echo "Unknown MODE=$MODE in $CONF (expected dict|counters)" >&2
+    exit 2
+    ;;
+esac
+
+GC_TOTAL_PASS=0
+GC_TOTAL_FAIL=0
+GC_TOTAL=0
+for ((i=0; i<${#GC_NAMES[@]}; i++)); do
+  GC_TOTAL_PASS=$((GC_TOTAL_PASS + GC_PASS[i]))
+  GC_TOTAL_FAIL=$((GC_TOTAL_FAIL + GC_FAIL[i]))
+  GC_TOTAL=$((GC_TOTAL + GC_TOTAL_S[i]))
+done
+
+mkdir -p "$SCOREBOARD_DIR"
+emit_scoreboard_json > "$SCOREBOARD_DIR/scoreboard.json"
+emit_scoreboard_md > "$SCOREBOARD_DIR/scoreboard.md"
+
+if [ "$GC_TOTAL_FAIL" -gt 0 ]; then
+  echo "$GC_TOTAL_FAIL failure(s) across $GC_TOTAL tests" >&2
+  exit 1
+fi
+echo "All $GC_TOTAL tests pass."

lib/guest/conformance.sx

@@ -0,0 +1,40 @@
+;; lib/guest/conformance.sx — shared helpers for the guest conformance driver.
+;;
+;; The bash driver lib/guest/conformance.sh loads this file and then for each
+;; suite emits an (eval "...") form whose result is a tagged list:
+;;
+;;     (gc-result NAME PASSED FAILED TOTAL)
+;;
+;; The driver greps these from sx_server's output and aggregates them.
+;;
+;; Two suite shapes are supported:
+;;
+;;   :dict     — runner expression returns a dict with :passed/:failed/:total.
+;;               (gc-dict-result "parse" (pl-parse-tests-run!))
+;;
+;;   :counters — runner has no return value, mutates pass/fail global counters.
+;;               (gc-counters-result NAME P0 F0 PASS FAIL)
+;;               where P0/F0 are the counters captured BEFORE the suite ran
+;;               and PASS/FAIL are the counters AFTER.
+
+(define
+  gc-dict-result
+  (fn
+    (name r)
+    (list
+      (quote gc-result)
+      name
+      (get r :passed)
+      (get r :failed)
+      (get r :total))))
+
+(define
+  gc-counters-result
+  (fn
+    (name p0 f0 p1 f1)
+    (list
+      (quote gc-result)
+      name
+      (- p1 p0)
+      (- f1 f0)
+      (- (+ p1 f1) (+ p0 f0)))))

lib/guest/lex.sx

@@ -0,0 +1,67 @@
+;; lib/guest/lex.sx — character-class predicates and token primitives shared
+;; across guest tokenisers.
+;;
+;; All predicates are nil-safe — they accept nil (end-of-input) and return
+;; false. This matches the convention used by the existing per-language
+;; tokenisers (cur returns nil at EOF).
+;;
+;; Char classes
+;; ------------
+;;   lex-digit?       — 0-9
+;;   lex-hex-digit?   — 0-9, a-f, A-F
+;;   lex-alpha?       — a-z, A-Z (alias: lex-letter?)
+;;   lex-alnum?       — alpha or digit
+;;   lex-ident-start? — alpha or underscore
+;;   lex-ident-char?  — ident-start or digit
+;;   lex-space?       — " ", "\t", "\r"           (no newline)
+;;   lex-whitespace?  — " ", "\t", "\r", "\n"     (includes newline)
+;;
+;; Token record
+;; ------------
+;;   (lex-make-token TYPE VALUE POS)        — {:type :value :pos}
+;;   (lex-make-token-spanning TYPE VALUE POS END)
+;;                                          — {:type :value :pos :end}
+;;   (lex-token-type TOK)
+;;   (lex-token-value TOK)
+;;   (lex-token-pos TOK)
+
+(define lex-digit? (fn (c) (and (not (= c nil)) (>= c "0") (<= c "9"))))
+
+(define
+  lex-hex-digit?
+  (fn
+    (c)
+    (and
+      (not (= c nil))
+      (or
+        (lex-digit? c)
+        (and (>= c "a") (<= c "f"))
+        (and (>= c "A") (<= c "F"))))))
+
+(define
+  lex-alpha?
+  (fn
+    (c)
+    (and
+      (not (= c nil))
+      (or (and (>= c "a") (<= c "z")) (and (>= c "A") (<= c "Z"))))))
+
+(define lex-letter? lex-alpha?)
+
+(define lex-alnum? (fn (c) (or (lex-alpha? c) (lex-digit? c))))
+
+(define lex-ident-start? (fn (c) (or (lex-alpha? c) (= c "_"))))
+
+(define lex-ident-char? (fn (c) (or (lex-ident-start? c) (lex-digit? c))))
+
+(define lex-space? (fn (c) (or (= c " ") (= c "\t") (= c "\r"))))
+
+(define lex-whitespace? (fn (c) (or (lex-space? c) (= c "\n"))))
+
+(define lex-make-token (fn (type value pos) {:pos pos :value value :type type}))
+
+(define lex-make-token-spanning (fn (type value pos end) {:pos pos :end end :value value :type type}))
+
+(define lex-token-type (fn (tok) (get tok :type)))
+(define lex-token-value (fn (tok) (get tok :value)))
+(define lex-token-pos (fn (tok) (get tok :pos)))

lib/guest/prefix.sx

@@ -0,0 +1,46 @@
+;; lib/guest/prefix.sx — prefix-rename macro.
+;;
+;; A guest runtime often re-exports a stretch of host primitives under a
+;; language-specific prefix. The prefix-rename macro replaces the repeated
+;; (define lang-foo foo) boilerplate with a single declarative call.
+;;
+;; Two entry shapes are supported:
+;;
+;;   (prefix-rename "cl-" '(gcd lcm expt floor truncate))
+;;     ;; expands to (begin (define cl-gcd gcd)
+;;     ;;                   (define cl-lcm lcm) ...)
+;;
+;;   (prefix-rename "cl-"
+;;     '((mod modulo)
+;;       (arrayp? vector?)
+;;       (ceiling ceil)))
+;;     ;; expands to (begin (define cl-mod modulo)
+;;     ;;                   (define cl-arrayp? vector?)
+;;     ;;                   (define cl-ceiling ceil))
+;;
+;; Mixed lists are supported — bare symbols are same-name aliases, two-element
+;; lists are (alias target) pairs.
+
+(defmacro
+  prefix-rename
+  (prefix entries-q)
+  (let
+    ((entries (nth entries-q 1)))
+    (cons
+      (quote begin)
+      (map
+        (fn
+          (entry)
+          (cond
+            ((= (type-of entry) "symbol")
+              (list
+                (quote define)
+                (make-symbol (str prefix (symbol-name entry)))
+                entry))
+            ((and (list? entry) (= (len entry) 2))
+              (list
+                (quote define)
+                (make-symbol (str prefix (symbol-name (first entry))))
+                (nth entry 1)))
+            (:else (error (str "prefix-rename: invalid entry " entry)))))
+        entries))))

lib/haskell/conformance.conf

@@ -0,0 +1,76 @@
+# Haskell-on-SX conformance config — sourced by lib/guest/conformance.sh.
+
+LANG_NAME=haskell
+MODE=counters
+COUNTERS_PASS=hk-test-pass
+COUNTERS_FAIL=hk-test-fail
+TIMEOUT_PER_SUITE=120
+
+PRELOADS=(
+  lib/haskell/tokenizer.sx
+  lib/haskell/layout.sx
+  lib/haskell/parser.sx
+  lib/haskell/desugar.sx
+  lib/haskell/runtime.sx
+  lib/haskell/match.sx
+  lib/haskell/eval.sx
+  lib/haskell/testlib.sx
+)
+
+SUITES=(
+  "fib:lib/haskell/tests/program-fib.sx"
+  "sieve:lib/haskell/tests/program-sieve.sx"
+  "quicksort:lib/haskell/tests/program-quicksort.sx"
+  "nqueens:lib/haskell/tests/program-nqueens.sx"
+  "calculator:lib/haskell/tests/program-calculator.sx"
+  "collatz:lib/haskell/tests/program-collatz.sx"
+  "palindrome:lib/haskell/tests/program-palindrome.sx"
+  "maybe:lib/haskell/tests/program-maybe.sx"
+  "fizzbuzz:lib/haskell/tests/program-fizzbuzz.sx"
+  "anagram:lib/haskell/tests/program-anagram.sx"
+  "roman:lib/haskell/tests/program-roman.sx"
+  "binary:lib/haskell/tests/program-binary.sx"
+  "either:lib/haskell/tests/program-either.sx"
+  "primes:lib/haskell/tests/program-primes.sx"
+  "zipwith:lib/haskell/tests/program-zipwith.sx"
+  "matrix:lib/haskell/tests/program-matrix.sx"
+  "wordcount:lib/haskell/tests/program-wordcount.sx"
+  "powers:lib/haskell/tests/program-powers.sx"
+)
+
+emit_scoreboard_json() {
+  local n=${#GC_NAMES[@]} i sep date_only
+  date_only=$(date '+%Y-%m-%d')
+  printf '{\n'
+  printf '  "date": "%s",\n' "$date_only"
+  printf '  "total_pass": %d,\n' "$GC_TOTAL_PASS"
+  printf '  "total_fail": %d,\n' "$GC_TOTAL_FAIL"
+  printf '  "programs": {\n'
+  for ((i=0; i<n; i++)); do
+    sep=","; [ $i -eq $((n-1)) ] && sep=""
+    printf '    "%s": {"pass": %d, "fail": %d}%s\n' \
+      "${GC_NAMES[$i]}" "${GC_PASS[$i]}" "${GC_FAIL[$i]}" "$sep"
+  done
+  printf '  }\n'
+  printf '}\n'
+}
+
+emit_scoreboard_md() {
+  local n=${#GC_NAMES[@]}
+  local i status p f t prog_pass=0 prog_total=$n date_only
+  date_only=$(date '+%Y-%m-%d')
+  for ((i=0; i<n; i++)); do
+    [ "${GC_FAIL[$i]}" -eq 0 ] && prog_pass=$((prog_pass + 1))
+  done
+  printf '# Haskell-on-SX Scoreboard\n\n'
+  printf 'Updated %s · Phase 6 (prelude extras + 18 programs)\n\n' "$date_only"
+  printf '| Program | Tests | Status |\n'
+  printf '|---------|-------|--------|\n'
+  for ((i=0; i<n; i++)); do
+    p=${GC_PASS[$i]}; f=${GC_FAIL[$i]}; t=${GC_TOTAL_S[$i]}
+    [ "$f" -eq 0 ] && status="✓" || status="✗"
+    printf '| %s.hs | %d/%d | %s |\n' "${GC_NAMES[$i]}" "$p" "$t" "$status"
+  done
+  printf '| **Total** | **%d/%d** | **%d/%d programs** |\n' \
+    "$GC_TOTAL_PASS" "$GC_TOTAL" "$prog_pass" "$prog_total"
+}

lib/haskell/conformance.sh

@@ -1,140 +1,3 @@
 #!/usr/bin/env bash
-# lib/haskell/conformance.sh — run the classic-program test suites.
-# Writes lib/haskell/scoreboard.json and lib/haskell/scoreboard.md.
-#
-# Usage:
-#   bash lib/haskell/conformance.sh           # run + write scoreboards
-#   bash lib/haskell/conformance.sh --check   # run only, exit 1 on failure
-
-set -euo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="hosts/ocaml/_build/default/bin/sx_server.exe"
-if [ ! -x "$SX_SERVER" ]; then
-  MAIN_ROOT=$(git worktree list | head -1 | awk '{print $1}')
-  if [ -x "$MAIN_ROOT/$SX_SERVER" ]; then
-    SX_SERVER="$MAIN_ROOT/$SX_SERVER"
-  else
-    echo "ERROR: sx_server.exe not found. Run: cd hosts/ocaml && dune build"
-    exit 1
-  fi
-fi
-
-PROGRAMS=(fib sieve quicksort nqueens calculator collatz palindrome maybe fizzbuzz anagram roman binary either primes zipwith matrix wordcount powers)
-PASS_COUNTS=()
-FAIL_COUNTS=()
-
-run_suite() {
-  local prog="$1"
-  local FILE="lib/haskell/tests/program-${prog}.sx"
-  local TMPFILE
-  TMPFILE=$(mktemp)
-  cat > "$TMPFILE" <<EPOCHS
-(epoch 1)
-(load "lib/haskell/tokenizer.sx")
-(load "lib/haskell/layout.sx")
-(load "lib/haskell/parser.sx")
-(load "lib/haskell/desugar.sx")
-(load "lib/haskell/runtime.sx")
-(load "lib/haskell/match.sx")
-(load "lib/haskell/eval.sx")
-(load "lib/haskell/testlib.sx")
-(epoch 2)
-(load "$FILE")
-(epoch 3)
-(eval "(list hk-test-pass hk-test-fail)")
-EPOCHS
-  local OUTPUT
-  OUTPUT=$(timeout 120 "$SX_SERVER" < "$TMPFILE" 2>&1 || true)
-  rm -f "$TMPFILE"
-
-  local LINE
-  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/\)$//' || true)
-  fi
-  if [ -z "$LINE" ]; then
-    echo "0 1"
-  else
-    local P F
-    P=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\1/' || echo "0")
-    F=$(echo "$LINE" | sed -E 's/^\(([0-9]+) ([0-9]+)\).*/\2/' || echo "1")
-    echo "$P $F"
-  fi
-}
-
-for prog in "${PROGRAMS[@]}"; do
-  RESULT=$(run_suite "$prog")
-  P=$(echo "$RESULT" | cut -d' ' -f1)
-  F=$(echo "$RESULT" | cut -d' ' -f2)
-  PASS_COUNTS+=("$P")
-  FAIL_COUNTS+=("$F")
-  T=$((P + F))
-  if [ "$F" -eq 0 ]; then
-    printf '✓ %-14s  %d/%d\n' "${prog}.hs" "$P" "$T"
-  else
-    printf '✗ %-14s  %d/%d\n' "${prog}.hs" "$P" "$T"
-  fi
-done
-
-TOTAL_PASS=0
-TOTAL_FAIL=0
-PROG_PASS=0
-for i in "${!PROGRAMS[@]}"; do
-  TOTAL_PASS=$((TOTAL_PASS + PASS_COUNTS[i]))
-  TOTAL_FAIL=$((TOTAL_FAIL + FAIL_COUNTS[i]))
-  [ "${FAIL_COUNTS[$i]}" -eq 0 ] && PROG_PASS=$((PROG_PASS + 1))
-done
-PROG_TOTAL=${#PROGRAMS[@]}
-
-echo ""
-echo "Classic programs: ${TOTAL_PASS}/$((TOTAL_PASS + TOTAL_FAIL)) tests  |  ${PROG_PASS}/${PROG_TOTAL} programs passing"
-
-if [[ "${1:-}" == "--check" ]]; then
-  [ $TOTAL_FAIL -eq 0 ]
-  exit $?
-fi
-
-DATE=$(date '+%Y-%m-%d')
-
-# scoreboard.json
-{
-  printf '{\n'
-  printf '  "date": "%s",\n' "$DATE"
-  printf '  "total_pass": %d,\n' "$TOTAL_PASS"
-  printf '  "total_fail": %d,\n' "$TOTAL_FAIL"
-  printf '  "programs": {\n'
-  last=$((${#PROGRAMS[@]} - 1))
-  for i in "${!PROGRAMS[@]}"; do
-    prog="${PROGRAMS[$i]}"
-    if [ $i -lt $last ]; then
-      printf '    "%s": {"pass": %d, "fail": %d},\n' "$prog" "${PASS_COUNTS[$i]}" "${FAIL_COUNTS[$i]}"
-    else
-      printf '    "%s": {"pass": %d, "fail": %d}\n'  "$prog" "${PASS_COUNTS[$i]}" "${FAIL_COUNTS[$i]}"
-    fi
-  done
-  printf '  }\n'
-  printf '}\n'
-} > lib/haskell/scoreboard.json
-
-# scoreboard.md
-{
-  printf '# Haskell-on-SX Scoreboard\n\n'
-  printf 'Updated %s · Phase 6 (prelude extras + 18 programs)\n\n' "$DATE"
-  printf '| Program | Tests | Status |\n'
-  printf '|---------|-------|--------|\n'
-  for i in "${!PROGRAMS[@]}"; do
-    prog="${PROGRAMS[$i]}"
-    P=${PASS_COUNTS[$i]}
-    F=${FAIL_COUNTS[$i]}
-    T=$((P + F))
-    [ "$F" -eq 0 ] && STATUS="✓" || STATUS="✗"
-    printf '| %s | %d/%d | %s |\n' "${prog}.hs" "$P" "$T" "$STATUS"
-  done
-  printf '| **Total** | **%d/%d** | **%d/%d programs** |\n' \
-    "$TOTAL_PASS" "$((TOTAL_PASS + TOTAL_FAIL))" "$PROG_PASS" "$PROG_TOTAL"
-} > lib/haskell/scoreboard.md
-
-echo "Wrote lib/haskell/scoreboard.json and lib/haskell/scoreboard.md"
-[ $TOTAL_FAIL -eq 0 ]
+# Thin wrapper — see lib/guest/conformance.sh and lib/haskell/conformance.conf.
+exec bash "$(dirname "$0")/../guest/conformance.sh" "$(dirname "$0")/conformance.conf" "$@"

lib/hyperscript/compiler.sx

@@ -7,6 +7,22 @@
 ;;   (hs-to-sx (hs-compile "on click add .active to me"))
 ;;   → (hs-on me "click" (fn (event) (dom-add-class me "active")))
 
+;; ── Compiler plugin registries ────────────────────────────────────
+;; Plugins call (hs-register-command! "head" compile-fn) and
+;; (hs-register-converter! "TypeName" convert-fn) at load time. Both
+;; compile-fn and convert-fn receive a ctx dict (built per call inside
+;; hs-to-sx) exposing :hs-to-sx for recursion plus the AST node fields
+;; the dispatch needs. Compile-fn returns an SX expression.
+(begin
+  (define _hs-command-registry {})
+  (define _hs-converter-registry {})
+  (define
+    hs-register-command!
+    (fn (name compile-fn) (dict-set! _hs-command-registry name compile-fn)))
+  (define
+    hs-register-converter!
+    (fn (name convert-fn) (dict-set! _hs-converter-registry name convert-fn))))
+
 (define
   hs-to-sx
   (let
@@ -210,28 +226,6 @@
                             value)
                           (list (quote set!) (hs-to-sx target) value)))))))
               (true (list (quote set!) (hs-to-sx target) value)))))))
-    ;; Throttle/debounce extraction state — module-level so they don't get
-    ;; redefined on every emit-on call (which was causing JIT churn). Set
-    ;; via _strip-throttle-debounce at the start of each emit-on, used in
-    ;; the handler-build step inside scan-on.
-    (define _throttle-ms nil)
-    (define _debounce-ms nil)
-    (define
-      _strip-throttle-debounce
-      (fn
-        (lst)
-        (cond
-          ((<= (len lst) 1) lst)
-          ((= (first lst) :throttle)
-            (do
-              (set! _throttle-ms (nth lst 1))
-              (_strip-throttle-debounce (rest (rest lst)))))
-          ((= (first lst) :debounce)
-            (do
-              (set! _debounce-ms (nth lst 1))
-              (_strip-throttle-debounce (rest (rest lst)))))
-          (true
-            (cons (first lst) (_strip-throttle-debounce (rest lst)))))))
     (define
       emit-on
       (fn
@@ -240,8 +234,6 @@
           ((parts (rest ast)))
           (let
             ((event-name (first parts)))
-            (set! _throttle-ms nil)
-            (set! _debounce-ms nil)
             (define
               scan-on
               (fn
@@ -274,13 +266,6 @@
                                   ((wrapped-body (if catch-info (let ((var (make-symbol (nth catch-info 0))) (catch-body (hs-to-sx (nth catch-info 1)))) (if finally-info (list (quote let) (list (list (quote __hs-exc) nil) (list (quote __hs-reraise) false)) (list (quote do) (list (quote guard) (list var (list true (list (quote let) (list (list var (list (quote host-hs-normalize-exc) var))) (list (quote guard) (list (quote __inner-exc) (list true (list (quote do) (list (quote set!) (quote __hs-exc) (quote __inner-exc)) (list (quote set!) (quote __hs-reraise) true)))) catch-body)))) compiled-body) (hs-to-sx finally-info) (list (quote when) (quote __hs-reraise) (list (quote raise) (quote __hs-exc))))) (list (quote let) (list (list (quote __hs-exc) nil) (list (quote __hs-reraise) false)) (list (quote do) (list (quote guard) (list var (list true (list (quote let) (list (list var (list (quote host-hs-normalize-exc) var))) (list (quote guard) (list (quote __inner-exc) (list true (list (quote do) (list (quote set!) (quote __hs-exc) (quote __inner-exc)) (list (quote set!) (quote __hs-reraise) true)))) catch-body)))) compiled-body) (list (quote when) (quote __hs-reraise) (list (quote raise) (quote __hs-exc))))))) (if finally-info (list (quote do) compiled-body (hs-to-sx finally-info)) compiled-body))))
                                   (let
                                     ((handler (let ((uses-the-result? (fn (expr) (cond ((= expr (quote the-result)) true) ((list? expr) (some (fn (x) (uses-the-result? x)) expr)) (true false))))) (let ((base-handler (list (quote fn) (list (quote event)) (if (uses-the-result? wrapped-body) (list (quote let) (list (list (quote the-result) nil)) wrapped-body) wrapped-body)))) (if count-filter-info (let ((mn (get count-filter-info "min")) (mx (get count-filter-info "max"))) (list (quote let) (list (list (quote __hs-count) 0)) (list (quote fn) (list (quote event)) (list (quote begin) (list (quote set!) (quote __hs-count) (list (quote +) (quote __hs-count) 1)) (list (quote when) (if (= mx -1) (list (quote >=) (quote __hs-count) mn) (list (quote and) (list (quote >=) (quote __hs-count) mn) (list (quote <=) (quote __hs-count) mx))) (nth base-handler 2)))))) base-handler)))))
-                                    (let
-                                      ((handler (cond
-                                                  (_throttle-ms
-                                                    (list (quote hs-throttle!) handler (hs-to-sx _throttle-ms)))
-                                                  (_debounce-ms
-                                                    (list (quote hs-debounce!) handler (hs-to-sx _debounce-ms)))
-                                                  (true handler))))
                                     (let
                                       ((on-call (if every? (list (quote hs-on-every) target event-name handler) (list (quote hs-on) target event-name handler))))
                                       (cond
@@ -340,7 +325,7 @@
                                                       (first pair)
                                                       handler))
                                                   or-sources)))
-                                            on-call))))))))))))))
+                                            on-call)))))))))))))
                   ((= (first items) :from)
                     (scan-on
                       (rest (rest items))
@@ -484,7 +469,7 @@
                       count-filter-info
                       elsewhere?
                       or-sources)))))
-            (scan-on (_strip-throttle-debounce (rest parts)) nil nil false nil nil nil nil nil false nil)))))
+            (scan-on (rest parts) nil nil false nil nil nil nil nil false nil)))))
     (define
       emit-send
       (fn
@@ -983,6 +968,22 @@
           (true
             (let
               ((head (first ast)))
+              (let
+                ((reg-cmd-fn (dict-get _hs-command-registry (str head)))
+                  (reg-conv-fn
+                    (and
+                      (= head (quote as))
+                      (dict-get _hs-converter-registry (nth ast 2)))))
+                (cond
+                  (reg-conv-fn
+                    (reg-conv-fn
+                      {:hs-to-sx hs-to-sx
+                       :ast ast
+                       :value-ast (nth ast 1)
+                       :type-name (nth ast 2)}))
+                  (reg-cmd-fn
+                    (reg-cmd-fn {:hs-to-sx hs-to-sx :ast ast :head head}))
+                  (true
               (cond
                 ((= head (quote __bind-from-detail__))
                   (let
@@ -2489,15 +2490,6 @@
                             (quote fn)
                             (list (quote it))
                             (hs-to-sx body))))
-                      ((and (list? expr) (= (first expr) (quote attr)))
-                        (list
-                          (quote hs-attr-watch!)
-                          (hs-to-sx (nth expr 2))
-                          (nth expr 1)
-                          (list
-                            (quote fn)
-                            (list (quote it))
-                            (hs-to-sx body))))
                       (true nil))))
                 ((= head (quote init))
                   (list
@@ -2707,7 +2699,7 @@
                           (quote begin)
                           (list (quote set!) (quote it) (quote __hs-js))
                           (quote __hs-js))))))
-                (true ast)))))))))
+                (true ast))))))))))))
 
 ;; ── Convenience: source → SX ─────────────────────────────────
 (define

lib/hyperscript/parser.sx

@@ -3,6 +3,17 @@
 ;; Input:  list of {:type T :value V :pos P} tokens from hs-tokenize
 ;; Output: SX AST forms that map to runtime primitives
 
+;; ── Feature plugin registry ───────────────────────────────────────
+;; Plugins call (hs-register-feature! "name" parse-fn) at load time.
+;; parse-fn is (fn (ctx) ...) where ctx is a dict exposing parser
+;; helpers (:adv! :tp-val :tp-type :parse-cmd-list ...) and the
+;; built-in parse-X-feat dispatch fns.
+(begin
+  (define _hs-feature-registry {})
+  (define
+    hs-register-feature!
+    (fn (name parse-fn) (dict-set! _hs-feature-registry name parse-fn))))
+
 ;; ── Parser entry point ────────────────────────────────────────────
 (define
   hs-parse
@@ -1347,17 +1358,7 @@
                           cls
                           (first extra-classes)
                           tgt))
-                      ((and
-                          (= (tp-type) "keyword") (= (tp-val) "for")
-                          ;; Only consume 'for' as a duration clause if the next
-                          ;; token is NOT '<ident> in ...' — that pattern is a
-                          ;; for-in loop, not a toggle duration.
-                          (not
-                            (and
-                              (> (len tokens) (+ p 2))
-                              (= (get (nth tokens (+ p 1)) "type") "ident")
-                              (= (get (nth tokens (+ p 2)) "value") "in")))
-                          (do (adv!) true))
+                      ((match-kw "for")
                         (let
                           ((dur (parse-expr)))
                           (list (quote toggle-class-for) cls tgt dur)))
@@ -3089,17 +3090,7 @@
                               (= (tp-val) "queue"))
                             (do (adv!) (adv!)))
                           (let
-                            ((every? (match-kw "every"))
-                             (throttle-ms nil)
-                             (debounce-ms nil))
-                            ;; 'throttled at <duration>' / 'debounced at <duration>'
-                            ;; — parsed as handler modifiers, captured as :throttle / :debounce parts.
-                            (when (and (= (tp-type) "ident") (= (tp-val) "throttled"))
-                              (adv!)
-                              (when (match-kw "at") (set! throttle-ms (parse-expr))))
-                            (when (and (= (tp-type) "ident") (= (tp-val) "debounced"))
-                              (adv!)
-                              (when (match-kw "at") (set! debounce-ms (parse-expr))))
+                            ((every? (match-kw "every")))
                             (let
                               ((having (if (or h-margin h-threshold) (dict "margin" h-margin "threshold" h-threshold) nil)))
                               (let
@@ -3114,10 +3105,6 @@
                                   (match-kw "end")
                                   (let
                                     ((parts (list (quote on) event-name)))
-                                    (let
-                                      ((parts (if throttle-ms (append parts (list :throttle throttle-ms)) parts)))
-                                    (let
-                                      ((parts (if debounce-ms (append parts (list :debounce debounce-ms)) parts)))
                                     (let
                                       ((parts (if every? (append parts (list :every true)) parts)))
                                       (let
@@ -3140,7 +3127,7 @@
                                                         ((parts (if finally-clause (append parts (list :finally finally-clause)) parts)))
                                                         (let
                                                           ((parts (append parts (list (if (> (len event-vars) 0) (cons (quote do) (append (map (fn (nm) (list (quote ref) nm)) event-vars) (if (and (list? body) (= (first body) (quote do))) (rest body) (list body)))) body)))))
-                                                          parts))))))))))))))))))))))))))))
+                                                          parts))))))))))))))))))))))))))
       (define
         parse-init-feat
         (fn
@@ -3190,7 +3177,6 @@
             (or
               (= (tp-type) "hat")
               (= (tp-type) "local")
-              (= (tp-type) "attr")
               (and (= (tp-type) "keyword") (= (tp-val) "dom")))
             (let
               ((expr (parse-expr)))
@@ -3256,6 +3242,24 @@
                       (do
                         (match-kw "end")
                         (list (quote socket) name-path url timeout on-message))))))))))
+      (define
+        parse-feat-ctx
+        (fn
+          ()
+          {:adv! adv!
+           :tp-val tp-val
+           :tp-type tp-type
+           :at-end? at-end?
+           :parse-cmd-list parse-cmd-list
+           :parse-expr parse-expr
+           :parse-on-feat parse-on-feat
+           :parse-init-feat parse-init-feat
+           :parse-def-feat parse-def-feat
+           :parse-behavior-feat parse-behavior-feat
+           :parse-live-feat parse-live-feat
+           :parse-when-feat parse-when-feat
+           :parse-bind-feat parse-bind-feat
+           :parse-socket-feat parse-socket-feat}))
       (define
         parse-feat
         (fn
@@ -3286,29 +3290,23 @@
                         ((unit (tp-val)))
                         (do (adv!) (list (quote string-postfix) inner unit)))
                       inner))))
-              ((= val "on") (do (adv!) (parse-on-feat)))
-              ((= val "init") (do (adv!) (parse-init-feat)))
-              ((= val "def") (do (adv!) (parse-def-feat)))
-              ((= val "behavior") (do (adv!) (parse-behavior-feat)))
-              ((= val "live") (do (adv!) (parse-live-feat)))
-              ((= val "when") (do (adv!) (parse-when-feat)))
-              ((= val "worker")
-                (error
-                  "worker plugin is not installed — see https://hyperscript.org/features/worker"))
-              ((= val "bind") (do (adv!) (parse-bind-feat)))
-              ((= val "socket") (do (adv!) (parse-socket-feat)))
               (true
-                (if
-                  (= (tp-type) "keyword")
-                  (parse-cmd-list)
-                  (let
-                    ((saved-p p))
-                    (let
-                      ((expr (guard (_e (true nil)) (parse-expr))))
-                      (if
-                        (and expr (at-end?))
-                        expr
-                        (do (set! p saved-p) (parse-cmd-list)))))))))))
+                (let
+                  ((reg-fn (dict-get _hs-feature-registry val)))
+                  (if
+                    reg-fn
+                    (reg-fn (parse-feat-ctx))
+                    (if
+                      (= (tp-type) "keyword")
+                      (parse-cmd-list)
+                      (let
+                        ((saved-p p))
+                        (let
+                          ((expr (guard (_e (true nil)) (parse-expr))))
+                          (if
+                            (and expr (at-end?))
+                            expr
+                            (do (set! p saved-p) (parse-cmd-list)))))))))))))
       (define
         coll-feats
         (fn
@@ -3351,3 +3349,33 @@
       (let
         ((result (hs-parse (hs-tokenize src) src)))
         (do (set! hs-span-mode false) result)))))
+
+;; ── Built-in feature registrations ────────────────────────────────
+;; These mirror the original parse-feat cond branches. Registering at
+;; load time means plugins can override or extend; ctx exposes the
+;; parser internals each fn needs.
+(begin
+  (hs-register-feature!
+    "on"
+    (fn (ctx) (begin ((dict-get ctx :adv!)) ((dict-get ctx :parse-on-feat)))))
+  (hs-register-feature!
+    "init"
+    (fn (ctx) (begin ((dict-get ctx :adv!)) ((dict-get ctx :parse-init-feat)))))
+  (hs-register-feature!
+    "def"
+    (fn (ctx) (begin ((dict-get ctx :adv!)) ((dict-get ctx :parse-def-feat)))))
+  (hs-register-feature!
+    "behavior"
+    (fn (ctx) (begin ((dict-get ctx :adv!)) ((dict-get ctx :parse-behavior-feat)))))
+  (hs-register-feature!
+    "live"
+    (fn (ctx) (begin ((dict-get ctx :adv!)) ((dict-get ctx :parse-live-feat)))))
+  (hs-register-feature!
+    "when"
+    (fn (ctx) (begin ((dict-get ctx :adv!)) ((dict-get ctx :parse-when-feat)))))
+  (hs-register-feature!
+    "bind"
+    (fn (ctx) (begin ((dict-get ctx :adv!)) ((dict-get ctx :parse-bind-feat)))))
+  (hs-register-feature!
+    "socket"
+    (fn (ctx) (begin ((dict-get ctx :adv!)) ((dict-get ctx :parse-socket-feat))))))

lib/hyperscript/plugins/prolog.sx

@@ -0,0 +1,24 @@
+;; lib/hyperscript/plugins/prolog.sx — Prolog plugin
+;;
+;; Provides the `prolog` HS-level function. Replaces the ad-hoc
+;; hs-prolog-hook / hs-set-prolog-hook! slots that previously lived in
+;; lib/hyperscript/runtime.sx (nodes 140–142 of the plugin design doc).
+;;
+;; Two-step wiring preserves the original API:
+;;   1. lib/prolog/runtime.sx loaded → defines pl-query-one
+;;   2. lib/prolog/hs-bridge.sx (or this file's auto-wire) calls
+;;      (hs-set-prolog-hook! (fn (db goal) (not (= nil (pl-query-one db goal)))))
+;; If neither is loaded, calling (prolog db goal) raises a clear error.
+
+(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))))

lib/hyperscript/plugins/worker.sx

@@ -0,0 +1,19 @@
+;; lib/hyperscript/plugins/worker.sx — Worker plugin (stub)
+;;
+;; Phase 1 of the worker plugin: the registration formerly inlined in
+;; lib/hyperscript/parser.sx (E39 stub) moves here. Behaviour is
+;; identical — `worker MyWorker ...` raises a helpful error directing
+;; users to the full plugin (not yet implemented).
+;;
+;; Phase 2 (future) replaces this stub with parse-worker-feat, a
+;; compiler entry, hs-worker-define!, and the postMessage-based
+;; method dispatch documented in plans/designs/hs-plugin-system.md §4a.
+
+(define hs-worker-loaded? true)
+
+(hs-register-feature!
+  "worker"
+  (fn
+    (ctx)
+    (error
+      "worker plugin is not installed — see https://hyperscript.org/features/worker")))

lib/hyperscript/runtime.sx

@@ -12,29 +12,6 @@
 
 ;; 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)))))
-
-;; Run an initializer function immediately.
-;; (hs-init thunk) — called at element boot time
 (define
   hs-each
   (fn
@@ -45,52 +22,17 @@
 ;; (hs-init thunk) — called at element boot time
 (define meta (host-new "Object"))
 
+;; 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)))
-
-;; Throttle: drops events that arrive within the window. First event fires
-;; immediately; subsequent events within `ms` of the previous fire are dropped.
-;; Returns a wrapped handler suitable for hs-on / hs-on-every.
-(define
-  hs-throttle!
-  (fn
-    (handler ms)
-    (let
-      ((__hs-last-fire 0))
-      (fn
-        (event)
-        (let
-          ((__hs-now (host-call (host-global "Date") "now")))
-          (when
-            (>= (- __hs-now __hs-last-fire) ms)
-            (set! __hs-last-fire __hs-now)
-            (handler event)))))))
-
-;; Debounce: waits until `ms` has elapsed since the last event before firing.
-;; In our synchronous test mock no time passes, so the timer fires immediately
-;; via setTimeout(_, 0); the wrapped handler still gets called once per burst.
-(define
-  hs-debounce!
-  (fn
-    (handler ms)
-    (let
-      ((__hs-timer nil))
-      (fn
-        (event)
-        (when __hs-timer (host-call (host-global "window") "clearTimeout" __hs-timer))
-        (set! __hs-timer
-          (host-call (host-global "window") "setTimeout"
-            (host-new-function (list "ev") "return arguments[0](arguments[1]);")
-            ms handler event))))))
-
-;; Wait for a DOM event on a target.
-;; (hs-wait-for target event-name) — suspends until event fires
 (define
   _hs-on-caller
   (let
@@ -103,7 +45,8 @@
       (host-set! _ctx "meta" _m)
       _ctx)))
 
-;; 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-on
   (fn
@@ -123,14 +66,14 @@
               (append prev (list unlisten)))
             unlisten))))))
 
-;; ── Class manipulation ──────────────────────────────────────────
-
-;; Toggle a single class on an element.
+;; Wait for CSS transitions/animations to settle on an element.
 (define
   hs-on-every
   (fn (target event-name handler) (dom-listen target event-name handler)))
 
-;; Toggle between two classes — exactly one is active at a time.
+;; ── Class manipulation ──────────────────────────────────────────
+
+;; Toggle a single class on an element.
 (define
   hs-on-intersection-attach!
   (fn
@@ -146,8 +89,7 @@
           (host-call observer "observe" target)
           observer)))))
 
-;; Take a class from siblings — add to target, remove from others.
-;; (hs-take! target cls) — like radio button class behavior
+;; Toggle between two classes — exactly one is active at a time.
 (define
   hs-on-mutation-attach!
   (fn
@@ -168,18 +110,19 @@
             (host-call observer "observe" target opts)
             observer))))))
 
+;; Take a class from siblings — add to target, remove from others.
+;; (hs-take! target cls) — like radio button class behavior
+(define hs-init (fn (thunk) (thunk)))
+
 ;; ── DOM insertion ───────────────────────────────────────────────
 
 ;; Put content at a position relative to a target.
 ;; pos: "into" | "before" | "after"
-(define hs-init (fn (thunk) (thunk)))
+(define hs-wait (fn (ms) (perform (list (quote io-sleep) ms))))
 
 ;; ── Navigation / traversal ──────────────────────────────────────
 
 ;; Navigate to a URL.
-(define hs-wait (fn (ms) (perform (list (quote io-sleep) ms))))
-
-;; Find next sibling matching a selector (or any sibling).
 (begin
   (define
     hs-wait-for
@@ -192,7 +135,7 @@
       (target event-name timeout-ms)
       (perform (list (quote io-wait-event) target event-name timeout-ms)))))
 
-;; Find previous sibling matching a selector.
+;; Find next sibling matching a selector (or any sibling).
 (define
   hs-settle
   (fn
@@ -200,7 +143,7 @@
     (hs-null-raise! target)
     (when (not (nil? target)) (perform (list (quote io-settle) target)))))
 
-;; First element matching selector within a scope.
+;; Find previous sibling matching a selector.
 (define
   hs-toggle-class!
   (fn
@@ -210,7 +153,7 @@
       (not (nil? target))
       (host-call (host-get target "classList") "toggle" cls))))
 
-;; Last element matching selector.
+;; First element matching selector within a scope.
 (define
   hs-toggle-var-cycle!
   (fn
@@ -232,7 +175,7 @@
           var-name
           (if (= idx -1) (first values) (nth values (mod (+ idx 1) n))))))))
 
-;; First/last within a specific scope.
+;; Last element matching selector.
 (define
   hs-toggle-between!
   (fn
@@ -245,6 +188,7 @@
         (do (dom-remove-class target cls1) (dom-add-class target cls2))
         (do (dom-remove-class target cls2) (dom-add-class target cls1))))))
 
+;; First/last within a specific scope.
 (define
   hs-toggle-style!
   (fn
@@ -268,9 +212,6 @@
             (dom-set-style target prop "hidden")
             (dom-set-style target prop "")))))))
 
-;; ── Iteration ───────────────────────────────────────────────────
-
-;; Repeat a thunk N times.
 (define
   hs-toggle-style-between!
   (fn
@@ -282,7 +223,9 @@
         (dom-set-style target prop val2)
         (dom-set-style target prop val1)))))
 
-;; Repeat forever (until break — relies on exception/continuation).
+;; ── Iteration ───────────────────────────────────────────────────
+
+;; Repeat a thunk N times.
 (define
   hs-toggle-style-cycle!
   (fn
@@ -303,10 +246,7 @@
             (true (find-next (rest remaining))))))
       (dom-set-style target prop (find-next vals)))))
 
-;; ── Fetch ───────────────────────────────────────────────────────
-
-;; Fetch a URL, parse response according to format.
-;; (hs-fetch url format) — format is "json" | "text" | "html"
+;; Repeat forever (until break — relies on exception/continuation).
 (define
   hs-take!
   (fn
@@ -329,7 +269,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
@@ -346,10 +287,10 @@
               (dom-set-attr target name attr-val)
               (dom-set-attr target name ""))))))))
 
-;; ── Type coercion ───────────────────────────────────────────────
+;; ── Fetch ───────────────────────────────────────────────────────
 
-;; Coerce a value to a type by name.
-;; (hs-coerce value type-name) — type-name is "Int", "Float", "String", etc.
+;; Fetch a URL, parse response according to format.
+;; (hs-fetch url format) — format is "json" | "text" | "html"
 (begin
   (define
     hs-element?
@@ -506,10 +447,10 @@
                     (dom-insert-adjacent-html target "beforeend" value)
                     (hs-boot-subtree! target)))))))))))
 
-;; ── Object creation ─────────────────────────────────────────────
+;; ── Type coercion ───────────────────────────────────────────────
 
-;; Make a new object of a given type.
-;; (hs-make type-name) — creates empty object/collection
+;; Coerce a value to a type by name.
+;; (hs-coerce value type-name) — type-name is "Int", "Float", "String", etc.
 (define
   hs-add-to!
   (fn
@@ -523,11 +464,10 @@
       ((hs-is-set? target) (do (host-call target "add" value) target))
       (true (do (host-call target "push" value) target)))))
 
-;; ── Behavior installation ───────────────────────────────────────
+;; ── Object creation ─────────────────────────────────────────────
 
-;; 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)
+;; Make a new object of a given type.
+;; (hs-make type-name) — creates empty object/collection
 (define
   hs-remove-from!
   (fn
@@ -537,10 +477,11 @@
       ((hs-is-set? target) (do (host-call target "delete" value) target))
       (true (host-call target "splice" (host-call target "indexOf" value) 1)))))
 
-;; ── Measurement ─────────────────────────────────────────────────
+;; ── Behavior installation ───────────────────────────────────────
 
-;; Measure an element's bounding rect, store as local variables.
-;; Returns a dict with x, y, width, height, top, left, right, bottom.
+;; 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-splice-at!
   (fn
@@ -553,7 +494,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
@@ -564,10 +508,10 @@
               (host-call target "splice" i 1))))
         target))))
 
-;; 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.
+;; ── 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-index
   (fn
@@ -579,11 +523,10 @@
       ((string? obj) (nth obj key))
       (true (host-get obj key)))))
 
-
-;; ── Transition ──────────────────────────────────────────────────
-
-;; Transition a CSS property to a value, optionally with duration.
-;; (hs-transition target prop value duration)
+;; 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-put-at!
   (fn
@@ -605,6 +548,11 @@
                 ((= pos "start") (host-call target "unshift" value)))
               target)))))))
 
+
+;; ── Transition ──────────────────────────────────────────────────
+
+;; Transition a CSS property to a value, optionally with duration.
+;; (hs-transition target prop value duration)
 (define
   hs-dict-without
   (fn
@@ -641,11 +589,6 @@
       ((w (host-global "window")))
       (if w (host-call w "prompt" msg) nil))))
 
-
-;; ── Transition ──────────────────────────────────────────────────
-
-;; Transition a CSS property to a value, optionally with duration.
-;; (hs-transition target prop value duration)
 (define
   hs-answer
   (fn
@@ -654,6 +597,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
@@ -714,10 +662,6 @@
             (if (nil? sel) "" (host-call sel "toString" (list))))
           stash)))))
 
-
-
-
-
 (define
   hs-reset!
   (fn
@@ -764,6 +708,10 @@
                   (when default-val (dom-set-prop target "value" default-val)))))
             (true nil)))))))
 
+
+
+
+
 (define
   hs-next
   (fn
@@ -782,8 +730,7 @@
               ((dom-matches? el sel) el)
               (true (find-next (dom-next-sibling el))))))
         (find-next sibling)))))
-;; ── Sandbox/test runtime additions ──────────────────────────────
-;; Property access — dot notation and .length
+
 (define
   hs-previous
   (fn
@@ -802,9 +749,10 @@
               ((dom-matches? el sel) el)
               (true (find-prev (dom-get-prop el "previousElementSibling"))))))
         (find-prev sibling)))))
-;; DOM query stub — sandbox returns empty list
+;; ── Sandbox/test runtime additions ──────────────────────────────
+;; Property access — dot notation and .length
 (define _hs-last-query-sel nil)
-;; Method dispatch — obj.method(args)
+;; DOM query stub — sandbox returns empty list
 (define
   hs-null-raise!
   (fn
@@ -815,9 +763,7 @@
         ((msg (str "'" (or (host-get (host-global "window") "_hs_last_query_sel") "target") "' is null")))
         (host-set! (host-global "window") "_hs_null_error" msg)
         (guard (_null-e (true nil)) (raise msg))))))
-
-;; ── 0.9.90 features ─────────────────────────────────────────────
-;; beep! — debug logging, returns value unchanged
+;; Method dispatch — obj.method(args)
 (define
   hs-empty-raise!
   (fn
@@ -831,7 +777,9 @@
         ((msg (str "'" (or (host-get (host-global "window") "_hs_last_query_sel") "target") "' is null")))
         (host-set! (host-global "window") "_hs_null_error" msg)
         (guard (_null-e (true nil)) (raise msg))))))
-;; Property-based is — check obj.key truthiness
+
+;; ── 0.9.90 features ─────────────────────────────────────────────
+;; beep! — debug logging, returns value unchanged
 (define
   hs-query-all-checked
   (fn
@@ -839,14 +787,14 @@
     (let
       ((result (hs-query-all sel)))
       (do (hs-empty-raise! result) result))))
-;; Array slicing (inclusive both ends)
+;; Property-based is — check obj.key truthiness
 (define
   hs-dispatch!
   (fn
     (target event detail)
     (hs-null-raise! target)
     (when (not (nil? target)) (dom-dispatch target event detail))))
-;; Collection: sorted by
+;; Array slicing (inclusive both ends)
 (define
   hs-query-all
   (fn
@@ -854,7 +802,7 @@
     (do
       (host-set! (host-global "window") "_hs_last_query_sel" sel)
       (dom-query-all (dom-document) sel))))
-;; Collection: sorted by descending
+;; Collection: sorted by
 (define
   hs-query-all-in
   (fn
@@ -863,17 +811,17 @@
       (nil? target)
       (hs-query-all sel)
       (host-call target "querySelectorAll" sel))))
-;; Collection: split by
+;; Collection: sorted by descending
 (define
   hs-list-set
   (fn
     (lst idx val)
     (append (take lst idx) (cons val (drop lst (+ idx 1))))))
-;; Collection: joined by
+;; Collection: split by
 (define
   hs-to-number
   (fn (v) (if (number? v) v (or (parse-number (str v)) 0))))
-
+;; Collection: joined by
 (define
   hs-query-first
   (fn
@@ -1003,7 +951,7 @@
                   ((= (str ex) "hs-continue") (do-loop (rest remaining)))
                   (true (raise ex))))))))
       (do-loop items))))
-;; Collection: joined by
+
 (begin
   (define
     hs-append
@@ -1044,7 +992,7 @@
               (host-get value "outerHTML")
               (str value))))
         (true nil)))))
-
+;; Collection: joined by
 (define
   hs-sender
   (fn
@@ -1136,7 +1084,6 @@
               (hs-host-to-sx (perform (list "io-parse-json" raw))))
             ((= fmt "number")
               (hs-to-number (perform (list "io-parse-text" raw))))
-            ((= fmt "html") (perform (list "io-parse-html" raw)))
             (true (perform (list "io-parse-text" raw)))))))))
 
 (define hs-fetch (fn (url format) (hs-fetch-impl url format false)))
@@ -1676,10 +1623,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}))))
@@ -1773,11 +1724,11 @@
     (value type-name)
     (if (nil? value) false (hs-type-check value type-name))))
 
-
 (define
   hs-strict-eq
   (fn (a b) (and (= (type-of a) (type-of b)) (= a b))))
 
+
 (define
   hs-id=
   (fn
@@ -1809,20 +1760,6 @@
       ((nil? suffix) false)
       (true (ends-with? (str s) (str suffix))))))
 
-(define
-  hs-attr-watch!
-  (fn
-    (target attr-name handler)
-    (let
-      ((mo-class (host-get (host-global "window") "MutationObserver")))
-      (when
-        mo-class
-        (let
-          ((cb (fn (records observer) (for-each (fn (rec) (when (= (host-get rec "attributeName") attr-name) (handler (host-call target "getAttribute" attr-name)))) records))))
-          (let
-            ((mo (host-new "MutationObserver" cb)))
-            (host-call mo "observe" target {:attributeFilter (list attr-name) :attributes true})))))))
-
 (define
   hs-scoped-set!
   (fn
@@ -1868,7 +1805,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
@@ -1989,7 +1929,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
@@ -2042,7 +1985,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
@@ -2070,7 +2015,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
@@ -2112,7 +2060,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))))
@@ -2122,7 +2072,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/>")))
@@ -2206,7 +2158,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)))))
@@ -2307,7 +2261,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
@@ -2347,7 +2302,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
@@ -2452,10 +2408,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)))
@@ -2566,7 +2526,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
         (let
@@ -2658,7 +2621,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))
@@ -2838,8 +2802,6 @@
   hs-sorted-by-desc
   (fn (col key-fn) (reverse (hs-sorted-by col key-fn))))
 
-;; ── SourceInfo API ────────────────────────────────────────────────
-
 (define
   hs-dom-has-var?
   (fn
@@ -2859,6 +2821,8 @@
       ((store (host-get el "__hs_vars")))
       (if (nil? store) nil (host-get store name)))))
 
+;; ── SourceInfo API ────────────────────────────────────────────────
+
 (define
   hs-dom-set-var-raw!
   (fn
@@ -2947,27 +2911,9 @@
           ((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)
-    (let
-      ((msg (str "'" selector "' is null")))
-      (host-set! (host-global "window") "_hs_null_error" msg)
-      (guard (_null-e (true nil)) (raise msg)))))
+  (fn (selector) (raise (str "'" selector "' is null"))))
 
 (define
   hs-named-target
@@ -2987,7 +2933,9 @@
       ((results (hs-query-all selector)))
       (if
         (and
-          (or (nil? results) (and (list? results) (= (len results) 0)))
+          (or
+            (nil? results)
+            (and (list? results) (= (len results) 0)))
           (string? selector)
           (> (len selector) 0)
           (= (substring selector 0 1) "#"))

lib/hyperscript/tokenizer.sx

@@ -8,7 +8,17 @@
 
 ;; ── Token constructor ─────────────────────────────────────────────
 
-(define hs-make-token (fn (type value pos) {:pos pos :value value :type type}))
+(define hs-make-token
+  (fn (type value pos &rest extras)
+    (let
+      ((end-arg (if (>= (len extras) 1) (nth extras 0) nil))
+       (line-arg (if (>= (len extras) 2) (nth extras 1) nil)))
+      (let
+        ((end (if (nil? end-arg)
+                  (+ pos (if (nil? value) 0 (len (str value))))
+                  end-arg))
+         (line (if (nil? line-arg) 1 line-arg)))
+        {:pos pos :end end :line line :value value :type type}))))
 
 ;; ── Character predicates ──────────────────────────────────────────
 
@@ -221,14 +231,26 @@
   (fn
     (src)
     (let
-      ((tokens (list)) (pos 0) (src-len (len src)))
+      ((tokens (list)) (pos 0) (src-len (len src)) (current-line 1))
       (define
         hs-peek
         (fn
           (offset)
           (if (< (+ pos offset) src-len) (nth src (+ pos offset)) nil)))
       (define hs-cur (fn () (hs-peek 0)))
-      (define hs-advance! (fn (n) (set! pos (+ pos n))))
+      (define
+        hs-advance!
+        (fn (n)
+          (let ((new-pos (+ pos n)))
+            (define
+              count-nl!
+              (fn (i)
+                (when (< i new-pos)
+                  (when (= (nth src i) "\n")
+                    (set! current-line (+ current-line 1)))
+                  (count-nl! (+ i 1)))))
+            (count-nl! pos)
+            (set! pos new-pos))))
       (define
         skip-ws!
         (fn
@@ -502,13 +524,14 @@
         (fn
           (type value start)
           (let
-            ((tok (hs-make-token type value start))
-              (end-pos
-                (max pos (+ start (if (nil? value) 0 (len (str value)))))))
-            (do
-              (dict-set! tok "end" end-pos)
-              (dict-set! tok "line" (len (split (slice src 0 start) "\n")))
-              (append! tokens tok)))))
+            ((end-pos
+                (max pos (+ start (if (nil? value) 0 (len (str value))))))
+              (newlines-after-start
+                (- (len (split (slice src start (max start pos)) "\n")) 1))
+              (start-line (- current-line newlines-after-start)))
+            (append!
+              tokens
+              (hs-make-token type value start end-pos start-line)))))
       (define
         scan!
         (fn
@@ -758,11 +781,30 @@
   (fn
     (src)
     (let
-      ((tokens (list)) (pos 0) (src-len (len src)))
+      ((tokens (list)) (pos 0) (src-len (len src)) (current-line 1))
       (define t-cur (fn () (if (< pos src-len) (nth src pos) nil)))
       (define t-peek (fn (n) (if (< (+ pos n) src-len) (nth src (+ pos n)) nil)))
-      (define t-advance! (fn (n) (set! pos (+ pos n))))
-      (define t-emit! (fn (type value) (append! tokens (hs-make-token type value pos))))
+      (define
+        t-advance!
+        (fn (n)
+          (let ((new-pos (+ pos n)))
+            (define
+              t-count-nl!
+              (fn (i)
+                (when (< i new-pos)
+                  (when (= (nth src i) "\n")
+                    (set! current-line (+ current-line 1)))
+                  (t-count-nl! (+ i 1)))))
+            (t-count-nl! pos)
+            (set! pos new-pos))))
+      (define
+        t-emit!
+        (fn (type value)
+          (let
+            ((end-pos (+ pos (if (nil? value) 0 (len (str value))))))
+            (append!
+              tokens
+              (hs-make-token type value pos end-pos current-line)))))
       (define
         scan-to-close!
         (fn
@@ -813,230 +855,4 @@
                 :else (do (t-advance! 1) (scan-template!)))))))
       (scan-template!)
       (t-emit! "eof" nil)
-      tokens)))
-
-;; ── Stream wrapper for upstream-style stateful tokenizer API ───────────────
-;;
-;; Upstream _hyperscript exposes a Tokens object with cursor + follow-set
-;; semantics on _hyperscript.internals.tokenizer. Our hs-tokenize returns a
-;; flat list; the stream wrapper adds the stateful operations.
-;;
-;; Type names map ours → upstream's (e.g. "ident" → "IDENTIFIER").
-
-(define
-  hs-stream-type-map
-  (fn
-    (t)
-    (cond
-      ((= t "ident") "IDENTIFIER")
-      ((= t "number") "NUMBER")
-      ((= t "string") "STRING")
-      ((= t "class") "CLASS_REF")
-      ((= t "id") "ID_REF")
-      ((= t "attr") "ATTRIBUTE_REF")
-      ((= t "style") "STYLE_REF")
-      ((= t "whitespace") "WHITESPACE")
-      ((= t "op") "OPERATOR")
-      ((= t "eof") "EOF")
-      (true (upcase t)))))
-
-;; Create a stream from a source string.
-;; Returns a dict — mutable via dict-set!.
-(define
-  hs-stream
-  (fn
-    (src)
-    {:tokens (hs-tokenize src) :pos 0 :follows (list) :last-match nil :last-ws nil}))
-
-;; Skip whitespace tokens, advancing pos to the next non-WS token.
-;; Captures the last skipped whitespace value into :last-ws.
-(define
-  hs-stream-skip-ws!
-  (fn
-    (s)
-    (let
-      ((tokens (get s :tokens)))
-      (define
-        loop
-        (fn
-          ()
-          (let
-            ((p (get s :pos)))
-            (when
-              (and (< p (len tokens))
-                   (= (get (nth tokens p) :type) "whitespace"))
-              (do
-                (dict-set! s :last-ws (get (nth tokens p) :value))
-                (dict-set! s :pos (+ p 1))
-                (loop))))))
-      (loop))))
-
-;; Current token (after skipping whitespace).
-(define
-  hs-stream-current
-  (fn
-    (s)
-    (do
-      (hs-stream-skip-ws! s)
-      (let
-        ((tokens (get s :tokens)) (p (get s :pos)))
-        (if (< p (len tokens)) (nth tokens p) nil)))))
-
-;; Returns the current token if its value matches; advances and updates
-;; :last-match. Returns nil otherwise (no advance).
-;; Honors the follow set: tokens whose value is in :follows do NOT match.
-(define
-  hs-stream-match
-  (fn
-    (s value)
-    (let
-      ((cur (hs-stream-current s)))
-      (cond
-        ((nil? cur) nil)
-        ((some (fn (f) (= f value)) (get s :follows)) nil)
-        ((= (get cur :value) value)
-          (do
-            (dict-set! s :pos (+ (get s :pos) 1))
-            (dict-set! s :last-match cur)
-            cur))
-        (true nil)))))
-
-;; Match by upstream-style type name. Accepts any number of allowed types.
-(define
-  hs-stream-match-type
-  (fn
-    (s &rest types)
-    (let
-      ((cur (hs-stream-current s)))
-      (cond
-        ((nil? cur) nil)
-        ((some (fn (t) (= (hs-stream-type-map (get cur :type)) t)) types)
-          (do
-            (dict-set! s :pos (+ (get s :pos) 1))
-            (dict-set! s :last-match cur)
-            cur))
-        (true nil)))))
-
-;; Match if value is one of the given names.
-(define
-  hs-stream-match-any
-  (fn
-    (s &rest names)
-    (let
-      ((cur (hs-stream-current s)))
-      (cond
-        ((nil? cur) nil)
-        ((some (fn (n) (= (get cur :value) n)) names)
-          (do
-            (dict-set! s :pos (+ (get s :pos) 1))
-            (dict-set! s :last-match cur)
-            cur))
-        (true nil)))))
-
-;; Match an op token whose value is in the list.
-(define
-  hs-stream-match-any-op
-  (fn
-    (s &rest ops)
-    (let
-      ((cur (hs-stream-current s)))
-      (cond
-        ((nil? cur) nil)
-        ((and (= (get cur :type) "op")
-              (some (fn (o) (= (get cur :value) o)) ops))
-          (do
-            (dict-set! s :pos (+ (get s :pos) 1))
-            (dict-set! s :last-match cur)
-            cur))
-        (true nil)))))
-
-;; Peek N non-WS tokens ahead. Returns the token if its value matches; nil otherwise.
-(define
-  hs-stream-peek
-  (fn
-    (s value offset)
-    (let
-      ((tokens (get s :tokens)))
-      (define
-        skip-n-non-ws
-        (fn
-          (p remaining)
-          (cond
-            ((>= p (len tokens)) -1)
-            ((= (get (nth tokens p) :type) "whitespace")
-              (skip-n-non-ws (+ p 1) remaining))
-            ((= remaining 0) p)
-            (true (skip-n-non-ws (+ p 1) (- remaining 1))))))
-      (let
-        ((p (skip-n-non-ws (get s :pos) offset)))
-        (if (and (>= p 0) (< p (len tokens))
-                 (= (get (nth tokens p) :value) value))
-          (nth tokens p)
-          nil)))))
-
-;; Consume tokens until one whose value matches the marker. Returns
-;; the consumed list (excluding the marker). Marker becomes current.
-(define
-  hs-stream-consume-until
-  (fn
-    (s marker)
-    (let
-      ((tokens (get s :tokens)) (out (list)))
-      (define
-        loop
-        (fn
-          (acc)
-          (let
-            ((p (get s :pos)))
-            (cond
-              ((>= p (len tokens)) acc)
-              ((= (get (nth tokens p) :value) marker) acc)
-              (true
-                (do
-                  (dict-set! s :pos (+ p 1))
-                  (loop (append acc (list (nth tokens p))))))))))
-      (loop out))))
-
-;; Consume until the next whitespace token; returns the consumed list.
-(define
-  hs-stream-consume-until-ws
-  (fn
-    (s)
-    (let
-      ((tokens (get s :tokens)))
-      (define
-        loop
-        (fn
-          (acc)
-          (let
-            ((p (get s :pos)))
-            (cond
-              ((>= p (len tokens)) acc)
-              ((= (get (nth tokens p) :type) "whitespace") acc)
-              (true
-                (do
-                  (dict-set! s :pos (+ p 1))
-                  (loop (append acc (list (nth tokens p))))))))))
-      (loop (list)))))
-
-;; Follow-set management.
-(define hs-stream-push-follow! (fn (s v) (dict-set! s :follows (cons v (get s :follows)))))
-(define
-  hs-stream-pop-follow!
-  (fn (s) (let ((f (get s :follows))) (when (> (len f) 0) (dict-set! s :follows (rest f))))))
-(define
-  hs-stream-push-follows!
-  (fn (s vs) (for-each (fn (v) (hs-stream-push-follow! s v)) vs)))
-(define
-  hs-stream-pop-follows!
-  (fn (s n) (when (> n 0) (do (hs-stream-pop-follow! s) (hs-stream-pop-follows! s (- n 1))))))
-(define
-  hs-stream-clear-follows!
-  (fn (s) (let ((saved (get s :follows))) (do (dict-set! s :follows (list)) saved))))
-(define
-  hs-stream-restore-follows!
-  (fn (s saved) (dict-set! s :follows saved)))
-
-;; Last-consumed token / whitespace.
-(define hs-stream-last-match (fn (s) (get s :last-match)))
-(define hs-stream-last-ws (fn (s) (get s :last-ws)))
+      tokens)))

lib/jit.sx

@@ -1,89 +0,0 @@
-;; lib/jit.sx — SX-level convenience wrappers over the JIT cache control
-;; primitives (jit-stats, jit-set-threshold!, jit-set-budget!, jit-reset-cache!,
-;; jit-reset-counters!). Host-specific implementations live in
-;; hosts/<host>/lib/sx_*.ml; the API surface is portable across hosts.
-
-;; with-jit-threshold — temporarily set the JIT call-count threshold for
-;; the duration of body, restoring the previous value on exit. Useful for
-;; sections that want eager compilation (threshold=1) or want to skip JIT
-;; entirely (threshold=999999) for diagnostic comparison.
-(defmacro
-  with-jit-threshold
-  (n &rest body)
-  `(let
-     ((__old (get (jit-stats) "threshold")))
-     (jit-set-threshold! ,n)
-     (let
-       ((__r (do ,@body)))
-       (jit-set-threshold! __old)
-       __r)))
-
-;; with-jit-budget — temporarily set the LRU cache budget. Setting to 0
-;; disables JIT entirely (everything falls through to the interpreter);
-;; large values are effectively unbounded.
-(defmacro
-  with-jit-budget
-  (n &rest body)
-  `(let
-     ((__old (get (jit-stats) "budget")))
-     (jit-set-budget! ,n)
-     (let
-       ((__r (do ,@body)))
-       (jit-set-budget! __old)
-       __r)))
-
-;; with-fresh-jit — clear the cache before body, run body, clear again
-;; after. Use between sessions / request batches / test suites where you
-;; want deterministic timing free of carryover.
-(defmacro
-  with-fresh-jit
-  (&rest body)
-  `(let
-     ((__r (do (jit-reset-cache!) ,@body)))
-     (jit-reset-cache!)
-     __r))
-
-;; jit-report — human-readable summary of current JIT state. Returns a
-;; string suitable for logging.
-(define
-  jit-report
-  (fn
-    ()
-    (let
-      ((s (jit-stats)))
-      (let
-        ((compiled (get s "compiled"))
-          (skipped (get s "below-threshold"))
-          (failed (get s "compile-failed"))
-          (evicted (get s "evicted"))
-          (cache-size (get s "cache-size"))
-          (budget (get s "budget"))
-          (threshold (get s "threshold")))
-        (let
-          ((total (+ compiled skipped failed)))
-          (str
-            "jit: " cache-size "/" budget " cached "
-            "(thr=" threshold ") · "
-            compiled " compiled, "
-            skipped " below-thr, "
-            failed " failed, "
-            evicted " evicted "
-            "(" (if (> total 0) (* 100 (/ compiled total)) 0) "% compile rate)"))))))
-
-;; jit-disable! / jit-enable! — convenience helpers. Disabling sets budget
-;; to 0 which causes the VM to skip JIT entirely on the next call. Enable
-;; restores the budget to its previous value (or 5000 if no previous).
-(define _jit-saved-budget (list 5000))
-
-(define
-  jit-disable!
-  (fn
-    ()
-    (set! _jit-saved-budget (list (get (jit-stats) "budget")))
-    (jit-set-budget! 0)))
-
-(define
-  jit-enable!
-  (fn
-    ()
-    (jit-set-budget! (first _jit-saved-budget))))

lib/lua/test.sh

@@ -28,6 +28,8 @@ trap "rm -f $TMPFILE" EXIT
 
 cat > "$TMPFILE" << 'EPOCHS'
 (epoch 1)
+(load "lib/guest/lex.sx")
+(load "lib/guest/prefix.sx")
 (load "lib/lua/tokenizer.sx")
 (epoch 2)
 (load "lib/lua/parser.sx")

lib/lua/tokenizer.sx

@@ -1,31 +1,12 @@
-(define lua-make-token (fn (type value pos) {:pos pos :value value :type type}))
+(prefix-rename "lua-"
+  '((make-token   lex-make-token)
+    (digit?       lex-digit?)
+    (hex-digit?   lex-hex-digit?)
+    (letter?      lex-alpha?)
+    (ident-start? lex-ident-start?)
+    (ident-char?  lex-ident-char?)
+    (ws?          lex-whitespace?)))
 
-(define lua-digit? (fn (c) (and (not (= c nil)) (>= c "0") (<= c "9"))))
-
-(define
-  lua-hex-digit?
-  (fn
-    (c)
-    (and
-      (not (= c nil))
-      (or
-        (lua-digit? c)
-        (and (>= c "a") (<= c "f"))
-        (and (>= c "A") (<= c "F"))))))
-
-(define
-  lua-letter?
-  (fn
-    (c)
-    (and
-      (not (= c nil))
-      (or (and (>= c "a") (<= c "z")) (and (>= c "A") (<= c "Z"))))))
-
-(define lua-ident-start? (fn (c) (or (lua-letter? c) (= c "_"))))
-
-(define lua-ident-char? (fn (c) (or (lua-ident-start? c) (lua-digit? c))))
-
-(define lua-ws? (fn (c) (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
 
 (define
   lua-keywords

lib/prolog/conformance.conf

@@ -0,0 +1,80 @@
+# Prolog conformance config — sourced by lib/guest/conformance.sh.
+
+LANG_NAME=prolog
+MODE=dict
+
+PRELOADS=(
+  lib/prolog/tokenizer.sx
+  lib/prolog/parser.sx
+  lib/prolog/runtime.sx
+  lib/prolog/query.sx
+  lib/prolog/compiler.sx
+  lib/prolog/hs-bridge.sx
+)
+
+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!)"
+)
+
+emit_scoreboard_json() {
+  local n=${#GC_NAMES[@]} i sep
+  printf '{\n'
+  printf '  "total_passed": %d,\n' "$GC_TOTAL_PASS"
+  printf '  "total_failed": %d,\n' "$GC_TOTAL_FAIL"
+  printf '  "total": %d,\n' "$GC_TOTAL"
+  printf '  "suites": {'
+  for ((i=0; i<n; i++)); do
+    sep=","; [ $i -eq $((n-1)) ] && sep=""
+    printf '"%s":{"passed":%d,"total":%d,"failed":%d}%s' \
+      "${GC_NAMES[$i]}" "${GC_PASS[$i]}" "${GC_TOTAL_S[$i]}" "${GC_FAIL[$i]}" "$sep"
+  done
+  printf '},\n'
+  printf '  "generated": "%s"\n' "$(date -Iseconds 2>/dev/null || date)"
+  printf '}\n'
+}
+
+emit_scoreboard_md() {
+  local n=${#GC_NAMES[@]} i status when
+  when="$(date -Iseconds 2>/dev/null || date)"
+  printf '# Prolog scoreboard\n\n'
+  printf '**%d / %d passing** (%d failure(s)).\n' \
+    "$GC_TOTAL_PASS" "$GC_TOTAL" "$GC_TOTAL_FAIL"
+  printf 'Generated %s.\n\n' "$when"
+  printf '| Suite | Passed | Total | Status |\n'
+  printf '|-------|--------|-------|--------|\n'
+  for ((i=0; i<n; i++)); do
+    status="ok"; [ "${GC_FAIL[$i]}" -gt 0 ] && status="FAIL"
+    printf '| %s | %d | %d | %s |\n' \
+      "${GC_NAMES[$i]}" "${GC_PASS[$i]}" "${GC_TOTAL_S[$i]}" "$status"
+  done
+  printf '\nRun `bash lib/prolog/conformance.sh` to refresh. Override the binary\n'
+  printf 'with `SX_SERVER=path/to/sx_server.exe bash …`.\n'
+}

lib/prolog/conformance.sh

@@ -1,129 +1,3 @@
 #!/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."
+# Thin wrapper — see lib/guest/conformance.sh and lib/prolog/conformance.conf.
+exec bash "$(dirname "$0")/../guest/conformance.sh" "$(dirname "$0")/conformance.conf" "$@"

lib/prolog/hs-bridge.sx

@@ -4,7 +4,7 @@
 ;;
 ;; 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!)
+;;    Requires lib/hyperscript/plugins/prolog.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"))

lib/prolog/scoreboard.json

@@ -3,5 +3,5 @@
   "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-06T12:17:46+00:00"
+  "generated": "2026-05-06T22:23:38+00:00"
 }

lib/prolog/scoreboard.md

@@ -1,7 +1,7 @@
 # Prolog scoreboard
 
 **590 / 590 passing** (0 failure(s)).
-Generated 2026-05-06T12:17:46+00:00.
+Generated 2026-05-06T22:23:38+00:00.
 
 | Suite | Passed | Total | Status |
 |-------|--------|-------|--------|

lib/smalltalk/scoreboard.json

@@ -1,5 +1,5 @@
 {
-  "date": "2026-04-25T16:05:32Z",
+  "date": "2026-05-06T21:06:00Z",
   "programs": [
     "eight-queens.st",
     "fibonacci.st",
@@ -8,8 +8,8 @@
     "quicksort.st"
   ],
   "program_count": 5,
-  "program_tests_passed": 39,
-  "all_tests_passed": 847,
-  "all_tests_total": 847,
-  "exit_code": 0
+  "program_tests_passed": 4,
+  "all_tests_passed": 625,
+  "all_tests_total": 629,
+  "exit_code": 1
 }

lib/smalltalk/scoreboard.md

@@ -1,13 +1,13 @@
 # Smalltalk-on-SX Scoreboard
 
-_Last run: 2026-04-25T16:05:32Z_
+_Last run: 2026-05-06T21:06:00Z_
 
 ## Totals
 
 | Suite | Passing |
 |-------|---------|
-| All Smalltalk-on-SX tests | **847 / 847** |
-| Classic-corpus tests (`tests/programs.sx`) | **39** |
+| All Smalltalk-on-SX tests | **625 / 629** |
+| Classic-corpus tests (`tests/programs.sx`) | **4** |
 
 ## Classic-corpus programs (`lib/smalltalk/tests/programs/`)
 
@@ -22,7 +22,6 @@ _Last run: 2026-04-25T16:05:32Z_
 ## Per-file test counts
 
 ```
-OK lib/smalltalk/tests/ansi.sx              62 passed
 OK lib/smalltalk/tests/blocks.sx            19 passed
 OK lib/smalltalk/tests/cannot_return.sx     5 passed
 OK lib/smalltalk/tests/collections.sx       29 passed
@@ -30,16 +29,13 @@ OK lib/smalltalk/tests/conditional.sx       25 passed
 OK lib/smalltalk/tests/dnu.sx               15 passed
 OK lib/smalltalk/tests/eval.sx              68 passed
 OK lib/smalltalk/tests/exceptions.sx        15 passed
-OK lib/smalltalk/tests/hashed.sx            30 passed
 OK lib/smalltalk/tests/inline_cache.sx      10 passed
 OK lib/smalltalk/tests/intrinsics.sx        24 passed
 OK lib/smalltalk/tests/nlr.sx               14 passed
 OK lib/smalltalk/tests/numbers.sx           47 passed
 OK lib/smalltalk/tests/parse_chunks.sx      21 passed
 OK lib/smalltalk/tests/parse.sx             47 passed
-OK lib/smalltalk/tests/pharo.sx             91 passed
 OK lib/smalltalk/tests/printing.sx          19 passed
-OK lib/smalltalk/tests/programs.sx          39 passed
 OK lib/smalltalk/tests/reflection.sx        77 passed
 OK lib/smalltalk/tests/runtime.sx           64 passed
 OK lib/smalltalk/tests/streams.sx           21 passed
@@ -47,6 +43,10 @@ OK lib/smalltalk/tests/sunit.sx             19 passed
 OK lib/smalltalk/tests/super.sx             9 passed
 OK lib/smalltalk/tests/tokenize.sx          63 passed
 OK lib/smalltalk/tests/while.sx             14 passed
+X lib/smalltalk/tests/ansi.sx: could not extract summary
+X lib/smalltalk/tests/hashed.sx: could not extract summary
+X lib/smalltalk/tests/pharo.sx: could not extract summary
+X lib/smalltalk/tests/programs.sx: could not extract summary
 ```
 
 ## Notes

lib/tcl/conformance.sh

@@ -63,6 +63,8 @@ for tcl_file in "${TCL_FILES[@]}"; do
   # Build epoch input using quoted heredoc for static parts; helper path via variable
   cat > "$tmpfile" << EPOCHS
 (epoch 1)
+(load "lib/guest/lex.sx")
+(load "lib/guest/prefix.sx")
 (load "lib/tcl/tokenizer.sx")
 (epoch 2)
 (load "lib/tcl/parser.sx")

lib/tcl/scoreboard.json

@@ -1,9 +1,10 @@
 {
-  "total": 3,
+  "total": 4,
   "passed": 3,
-  "failed": 0,
+  "failed": 1,
   "programs": {
     "assert": {"status": "PASS", "expected": "10", "got": "10"},
+    "event-loop": {"status": "FAIL", "expected": "done", "got": ""},
     "for-each-line": {"status": "PASS", "expected": "13", "got": "13"},
     "with-temp-var": {"status": "PASS", "expected": "100 999", "got": "100 999"}
   }

lib/tcl/scoreboard.md

@@ -3,7 +3,8 @@
 | Program | Status | Expected | Got |
 |---|---|---|---|
 | assert | ✓ PASS | 10 | 10 |
+| event-loop | ✗ FAIL | done |  |
 | for-each-line | ✓ PASS | 13 | 13 |
 | with-temp-var | ✓ PASS | 100 999 | 100 999 |
 
-**3/3 passing**
+**3/4 passing**

lib/tcl/test.sh

@@ -33,12 +33,15 @@ HELPER_EOF
 
 cat > "$TMPFILE" << EPOCHS
 (epoch 1)
+(load "lib/guest/lex.sx")
+(load "lib/guest/prefix.sx")
 (load "lib/tcl/tokenizer.sx")
 (epoch 2)
 (load "lib/tcl/parser.sx")
 (epoch 3)
 (load "lib/tcl/tests/parse.sx")
 (epoch 4)
+(load "lib/fiber.sx")
 (load "lib/tcl/runtime.sx")
 (epoch 5)
 (load "lib/tcl/tests/eval.sx")
@@ -56,7 +59,7 @@ cat > "$TMPFILE" << EPOCHS
 (eval "tcl-test-summary")
 EPOCHS
 
-OUTPUT=$(timeout 180 "$SX_SERVER" < "$TMPFILE" 2>&1)
+OUTPUT=$(timeout 1200 "$SX_SERVER" < "$TMPFILE" 2>&1)
 [ "$VERBOSE" = "-v" ] && echo "$OUTPUT"
 
 # Extract summary line from epoch 11 output

lib/tcl/tests/coro.sx

@@ -95,15 +95,15 @@
       (get (run "proc g {} { yield }\ncoroutine cg g\ncg") :result)
       "")
 
-    ; --- clock seconds stub ---
+    ; --- clock seconds ---
     (ok "clock-seconds"
-      (get (run "clock seconds") :result)
-      "0")
+      (> (parse-int (get (run "clock seconds") :result)) 0)
+      true)
 
-    ; --- clock milliseconds stub ---
+    ; --- clock milliseconds ---
     (ok "clock-milliseconds"
-      (get (run "clock milliseconds") :result)
-      "0")
+      (> (parse-int (get (run "clock milliseconds") :result)) 0)
+      true)
 
     ; --- clock format stub ---
     (ok "clock-format"
@@ -124,7 +124,7 @@
       "file0")
 
     (ok "eof-returns-1"
-      (get (run "set ch [open /dev/null r]\neof $ch") :result)
+      (get (run "set ch [open /dev/null r]\nread $ch\neof $ch") :result)
       "1")
 
     (dict

lib/tcl/tests/eval.sx

@@ -329,6 +329,54 @@
         (run "proc with-temp-var {varname tempval body} {\n    upvar 1 $varname v\n    set saved $v\n    set v $tempval\n    uplevel 1 $body\n    set v $saved\n}\nset x 100\nwith-temp-var x 999 {\n    set captured $x\n}\nlist $x $captured")
         :result)
       "100 999")
+    (ok
+      "array-set-get"
+      (get
+        (run "array set a {x 1 y 2 z 3}; array get a x")
+        :result)
+      "x 1")
+    (ok
+      "array-names"
+      (get
+        (run "array set a {p 10 q 20}; lsort [array names a]")
+        :result)
+      "p q")
+    (ok
+      "array-size"
+      (get
+        (run "array set a {x 1 y 2 z 3}; array size a")
+        :result)
+      "3")
+    (ok
+      "array-exists-true"
+      (get
+        (run "array set a {x 1}; array exists a")
+        :result)
+      "1")
+    (ok
+      "array-exists-false"
+      (get
+        (run "array exists nosucharray")
+        :result)
+      "0")
+    (ok
+      "array-unset-key"
+      (get
+        (run "array set a {x 1 y 2 z 3}; array unset a y; lsort [array names a]")
+        :result)
+      "x z")
+    (ok
+      "array-scalar-access"
+      (get
+        (run "set a(foo) hello; set a(bar) world; set a(foo)")
+        :result)
+      "hello")
+    (ok
+      "array-get-all"
+      (get
+        (run "set a(k) v; set pairs [array get a]; llength $pairs")
+        :result)
+      "2")
     (dict
       "passed"
       tcl-eval-pass

lib/tcl/tests/idioms.sx

@@ -29,160 +29,250 @@
     (define
       ok
       (fn (label actual expected) (tcl-idiom-assert label expected actual)))
-
-    ; 1. lmap idiom: accumulate mapped values with foreach+lappend
-    (ok "idiom-lmap"
+    (ok
+      "idiom-lmap"
       (get
-        (run "set result {}\nforeach x {1 2 3} { lappend result [expr {$x * $x}] }\nset result")
+        (run
+          "set result {}\nforeach x {1 2 3} { lappend result [expr {$x * $x}] }\nset result")
         :result)
       "1 4 9")
-
-    ; 2. Recursive list flatten
-    (ok "idiom-flatten"
+    (ok
+      "idiom-flatten"
       (get
         (run
           "proc flatten {lst} { set out {}\n  foreach item $lst {\n    if {[llength $item] > 1} {\n      foreach sub [flatten $item] { lappend out $sub }\n    } else {\n      lappend out $item\n    }\n  }\n  return $out\n}\nflatten {1 {2 3} {4 {5 6}}}")
         :result)
       "1 2 3 4 5 6")
-
-    ; 3. String builder accumulator
-    (ok "idiom-string-builder"
+    (ok
+      "idiom-string-builder"
       (get
-        (run "set buf \"\"\nforeach w {Hello World Tcl} { append buf $w \" \" }\nstring trimright $buf")
+        (run
+          "set buf \"\"\nforeach w {Hello World Tcl} { append buf $w \" \" }\nstring trimright $buf")
         :result)
       "Hello World Tcl")
-
-    ; 4. Default parameter via info exists
-    (ok "idiom-default-param"
-      (get
-        (run "if {![info exists x]} { set x 42 }\nset x")
-        :result)
+    (ok
+      "idiom-default-param"
+      (get (run "if {![info exists x]} { set x 42 }\nset x") :result)
       "42")
-
-    ; 5. Association list lookup (parallel key/value lists)
-    (ok "idiom-alist-lookup"
+    (ok
+      "idiom-alist-lookup"
       (get
         (run
           "set keys {a b c}\nset vals {10 20 30}\nset idx [lsearch $keys b]\nlindex $vals $idx")
         :result)
       "20")
-
-    ; 6. Proc with optional args via args
-    (ok "idiom-optional-args"
+    (ok
+      "idiom-optional-args"
       (get
         (run
           "proc greet {name args} {\n  set greeting \"Hello\"\n  if {[llength $args] > 0} { set greeting [lindex $args 0] }\n  return \"$greeting $name\"\n}\ngreet World Hi")
         :result)
       "Hi World")
-
-    ; 7. Builder pattern: dict create from args
-    (ok "idiom-dict-builder"
+    (ok
+      "idiom-dict-builder"
       (get
         (run
           "proc build-dict {args} { dict create {*}$args }\ndict get [build-dict name Alice age 30] name")
         :result)
       "Alice")
-
-    ; 8. Loop with index using array
-    (ok "idiom-loop-with-index"
+    (ok
+      "idiom-loop-with-index"
       (get
-        (run
-          "set i 0\nforeach x {a b c} { set arr($i) $x; incr i }\nset arr(1)")
+        (run "set i 0\nforeach x {a b c} { set arr($i) $x; incr i }\nset arr(1)")
         :result)
       "b")
-
-    ; 9. String reverse via split+lreverse+join
-    (ok "idiom-string-reverse"
+    (ok
+      "idiom-string-reverse"
       (get
         (run
           "set s hello\nset chars [split $s \"\"]\nset rev [lreverse $chars]\njoin $rev \"\"")
         :result)
       "olleh")
-
-    ; 10. Number to padded string
-    (ok "idiom-number-format"
-      (get (run "format \"%05d\" 42") :result)
-      "00042")
-
-    ; 11. Dict comprehension pattern
-    (ok "idiom-dict-comprehension"
+    (ok "idiom-number-format" (get (run "format \"%05d\" 42") :result) "00042")
+    (ok
+      "idiom-dict-comprehension"
       (get
         (run
           "set squares {}\nforeach n {1 2 3 4} { dict set squares $n [expr {$n * $n}] }\ndict get $squares 3")
         :result)
       "9")
-
-    ; 12. Stack ADT using list: push/pop
-    (ok "idiom-stack"
+    (ok
+      "idiom-stack"
       (get
         (run
           "proc stack-push {stackvar val} { upvar $stackvar s; lappend s $val }\nproc stack-pop {stackvar} { upvar $stackvar s; set val [lindex $s end]; set s [lrange $s 0 end-1]; return $val }\nset stk {}\nstack-push stk 10\nstack-push stk 20\nstack-push stk 30\nstack-pop stk")
         :result)
       "30")
-
-    ; 13. Queue ADT using list: enqueue/dequeue
-    (ok "idiom-queue"
+    (ok
+      "idiom-queue"
       (get
         (run
           "proc q-enq {qvar val} { upvar $qvar q; lappend q $val }\nproc q-deq {qvar} { upvar $qvar q; set val [lindex $q 0]; set q [lrange $q 1 end]; return $val }\nset q {}\nq-enq q alpha\nq-enq q beta\nq-enq q gamma\nq-deq q")
         :result)
       "alpha")
-
-    ; 14. Pipeline via proc chaining
-    (ok "idiom-pipeline"
+    (ok
+      "idiom-pipeline"
       (get
         (run
           "proc double {x} { expr {$x * 2} }\nproc add1 {x} { expr {$x + 1} }\nproc pipeline {val procs} { foreach p $procs { set val [$p $val] }; return $val }\npipeline 5 {double add1 double}")
         :result)
       "22")
-
-    ; 15. Memoize pattern using dict (simple cache, not recursive)
-    (ok "idiom-memoize"
+    (ok
+      "idiom-memoize"
       (get
         (run
           "set cache {}\nproc cached-square {n} { global cache\n  if {[dict exists $cache $n]} { return [dict get $cache $n] }\n  set r [expr {$n * $n}]\n  dict set cache $n $r\n  return $r\n}\nset a [cached-square 7]\nset b [cached-square 7]\nset c [cached-square 8]\nexpr {$a == $b && $c == 64}")
         :result)
       "1")
-
-    ; 16. Simple expression evaluator in Tcl (recursive descent)
-    (ok "idiom-recursive-eval"
+    (ok
+      "idiom-recursive-eval"
       (get
         (run
           "proc calc {expr} { return [::tcl::mathop::+ 0 [expr $expr]] }\nexpr {3 + 4 * 2}")
         :result)
       "11")
-
-    ; 17. Apply proc to each pair in a dict
-    (ok "idiom-dict-for"
+    (ok
+      "idiom-dict-for"
       (get
         (run
           "set d [dict create a 1 b 2 c 3]\nset total 0\ndict for {k v} $d { incr total $v }\nset total")
         :result)
       "6")
-
-    ; 18. Find max in list
-    (ok "idiom-find-max"
+    (ok
+      "idiom-find-max"
       (get
         (run
           "proc list-max {lst} {\n  set m [lindex $lst 0]\n  foreach x $lst { if {$x > $m} { set m $x } }\n  return $m\n}\nlist-max {3 1 4 1 5 9 2 6}")
         :result)
       "9")
-
-    ; 19. Filter list by predicate
-    (ok "idiom-filter-list"
+    (ok
+      "idiom-filter-list"
       (get
         (run
           "proc list-filter {lst pred} {\n  set out {}\n  foreach x $lst { if {[$pred $x]} { lappend out $x } }\n  return $out\n}\nproc is-even {n} { expr {$n % 2 == 0} }\nlist-filter {1 2 3 4 5 6} is-even")
         :result)
       "2 4 6")
-
-    ; 20. Zip two lists
-    (ok "idiom-zip"
+    (ok
+      "idiom-zip"
       (get
         (run
           "proc zip {a b} {\n  set out {}\n  set n [llength $a]\n  for {set i 0} {$i < $n} {incr i} {\n    lappend out [lindex $a $i]\n    lappend out [lindex $b $i]\n  }\n  return $out\n}\nzip {1 2 3} {a b c}")
         :result)
       "1 a 2 b 3 c")
+    (ok
+      "env-lookup-basic"
+      (env-lookup (let ((x 42)) (current-env)) "x")
+      42)
+    (ok
+      "env-lookup-missing"
+      (env-lookup (let ((x 42)) (current-env)) "z")
+      nil)
+    (ok
+      "env-extend-lookup"
+      (let
+        ((e (let ((x 5)) (current-env))))
+        (env-lookup (env-extend e "y" 10) "y"))
+      10)
+    (ok
+      "eval-in-env-parent"
+      (let
+        ((x 5))
+        (eval-in-env (env-extend (current-env) "y" 10) (quote (+ x y))))
+      15)
+    (ok
+      "eval-in-env-multi"
+      (let
+        ((base (current-env)))
+        (eval-in-env
+          (env-extend (env-extend base "a" 3) "b" 7)
+          (quote (* a b))))
+      21)
+
+    ; 26-32. Phase 5 channels: write/read/seek/tell/eof/append/non-blocking
+    (ok "channel-write-read"
+      (get
+        (run
+          "set f /tmp/tcl-phase5-1.txt\nset c [open $f w]\nputs $c \"line one\"\nputs $c \"line two\"\nclose $c\nset c [open $f r]\nset out [read $c]\nclose $c\nfile delete $f\nreturn $out")
+        :result)
+      "line one\nline two\n")
+
+    (ok "channel-gets-loop"
+      (get
+        (run
+          "set f /tmp/tcl-phase5-2.txt\nset c [open $f w]\nputs $c apple\nputs $c banana\nputs $c cherry\nclose $c\nset c [open $f r]\nset out {}\nwhile {[gets $c line] >= 0} {lappend out $line}\nclose $c\nfile delete $f\nreturn $out")
+        :result)
+      "apple banana cherry")
+
+    (ok "channel-seek-tell"
+      (get
+        (run
+          "set f /tmp/tcl-phase5-3.txt\nset c [open $f w]\nputs -nonewline $c \"hello world\"\nclose $c\nset c [open $f r]\nseek $c 6\nset pos [tell $c]\nset rest [read $c]\nclose $c\nfile delete $f\nreturn \"$pos:$rest\"")
+        :result)
+      "6:world")
+
+    (ok "channel-eof-after-read"
+      (get
+        (run
+          "set f /tmp/tcl-phase5-4.txt\nset c [open $f w]\nputs -nonewline $c hi\nclose $c\nset c [open $f r]\nread $c\nset e [eof $c]\nclose $c\nfile delete $f\nreturn $e")
+        :result)
+      "1")
+
+    (ok "channel-append-mode"
+      (get
+        (run
+          "set f /tmp/tcl-phase5-5.txt\nset c [open $f w]\nputs -nonewline $c \"first\"\nclose $c\nset c [open $f a]\nputs -nonewline $c \"-second\"\nclose $c\nset c [open $f r]\nset out [read $c]\nclose $c\nfile delete $f\nreturn $out")
+        :result)
+      "first-second")
+
+    (ok "channel-seek-end"
+      (get
+        (run
+          "set f /tmp/tcl-phase5-6.txt\nset c [open $f w]\nputs -nonewline $c \"abcdefghij\"\nclose $c\nset c [open $f r]\nseek $c 0 end\nset pos [tell $c]\nclose $c\nfile delete $f\nreturn $pos")
+        :result)
+      "10")
+
+    (ok "channel-fconfigure-blocking"
+      (get
+        (run
+          "set f /tmp/tcl-phase5-7.txt\nset c [open $f w]\nputs -nonewline $c x\nclose $c\nset c [open $f r]\nfconfigure $c -blocking 0\nset b [fconfigure $c -blocking]\nclose $c\nfile delete $f\nreturn $b")
+        :result)
+      "0")
+
+    ; 33-37. Phase 5b event loop: after / vwait / fileevent / update
+    (ok "after-vwait-timer"
+      (get
+        (run
+          "after 30 {set ::done fired}\nvwait ::done\nset ::done")
+        :result)
+      "fired")
+
+    (ok "after-multiple-timers-update"
+      (get
+        (run
+          "set ::n 0\nafter 0 {incr ::n}\nafter 0 {incr ::n}\nafter 0 {incr ::n}\nupdate\nset ::n")
+        :result)
+      "3")
+
+    (ok "fileevent-readable-fires"
+      (get
+        (run
+          "set f /tmp/tcl-phase5b-1.txt\nset c [open $f w]\nputs -nonewline $c hi\nclose $c\nset c [open $f r]\nfileevent $c readable {set ::ready 1; fileevent $::ch readable {}}\nset ::ch $c\nvwait ::ready\nclose $c\nfile delete $f\nset ::ready")
+        :result)
+      "1")
+
+    (ok "fileevent-query-script"
+      (get
+        (run
+          "set f /tmp/tcl-phase5b-2.txt\nset c [open $f w]\nputs -nonewline $c x\nclose $c\nset c [open $f r]\nfileevent $c readable {puts hello}\nset s [fileevent $c readable]\nclose $c\nfile delete $f\nreturn $s")
+        :result)
+      "puts hello")
+
+    (ok "after-cancel-via-vwait-timing"
+      (get
+        (run
+          "set ::counter 0\nafter 10 {incr ::counter}\nafter 50 {set ::done 1}\nvwait ::done\nset ::counter")
+        :result)
+      "1")
 
     (dict
       "passed"

lib/tcl/tokenizer.sx

@@ -1,19 +1,10 @@
-(define tcl-ws? (fn (c) (or (= c " ") (= c "\t") (= c "\r"))))
+(prefix-rename "tcl-"
+  '((ws?          lex-space?)
+    (alpha?       lex-alpha?)
+    (digit?       lex-digit?)
+    (ident-start? lex-ident-start?)
+    (ident-char?  lex-ident-char?)))
 
-(define tcl-alpha?
-  (fn (c)
-    (and
-      (not (= c nil))
-      (or (and (>= c "a") (<= c "z")) (and (>= c "A") (<= c "Z"))))))
-
-(define tcl-digit?
-  (fn (c) (and (not (= c nil)) (>= c "0") (<= c "9"))))
-
-(define tcl-ident-start?
-  (fn (c) (or (tcl-alpha? c) (= c "_"))))
-
-(define tcl-ident-char?
-  (fn (c) (or (tcl-ident-start? c) (tcl-digit? c))))
 
 (define tcl-tokenize
   (fn (src)

plans/agent-briefings/apl-loop.md

@@ -11,7 +11,7 @@ isolation: worktree
 
 ## Prompt
 
-You are the sole background agent working `/root/rose-ash/plans/apl-on-sx.md`. Isolated worktree, forever, one commit per feature. Never push.
+You are the sole background agent working `/root/rose-ash/plans/apl-on-sx.md`. Isolated worktree, forever, one commit per feature. Push to `origin/loops/apl` after every commit.
 
 ## Restart baseline — check before iterating
 
@@ -42,7 +42,7 @@ Every iteration: implement → test → commit → tick `[ ]` → Progress log
 - **Shared-file issues** → plan's Blockers with minimal repro.
 - **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after edits.
 - **Unicode in `.sx`:** raw UTF-8 only, never `\uXXXX` escapes. Glyphs land directly in source.
-- **Worktree:** commit locally. Never push. Never touch `main`.
+- **Worktree:** commit, then push to `origin/loops/apl`. Never touch `main`.
 - **Commit granularity:** one feature per commit.
 - **Plan file:** update Progress log + tick boxes every commit.
 

plans/agent-briefings/lib-guest-loop.md

@@ -0,0 +1,118 @@
+# lib/guest extraction loop (single agent, queue-driven)
+
+Role: iterates `plans/lib-guest.md` forever. Each iteration picks the top `pending` step, extracts/ports/validates, commits, logs, moves on. North star: every guest's `scoreboard.json` ≥ baseline at all times, while `lib/guest/` accumulates shared infrastructure.
+
+```
+description: lib/guest extraction loop
+subagent_type: general-purpose
+run_in_background: true
+```
+
+## Prompt
+
+You are the sole background agent working `/root/rose-ash/plans/lib-guest.md`. You work a prioritised queue, one step per code commit, indefinitely. The plan file is the source of truth for what's pending, in-progress, done, and blocked. Update it after every iteration.
+
+## Iteration protocol (follow exactly)
+
+### 1. Read state
+
+- Read `plans/lib-guest.md` in full.
+- Pick the first step with status `[ ]`. If all remaining are `[blocked]` or `[done]`, stop and report loop complete.
+- Set that step's status to `[in-progress]` and commit the plan change alone:
+  `GUEST-plan: claim step <N> — <name>`.
+
+### 2. Baseline (every iteration that touches a guest)
+
+Before any code edit, snapshot the **current** scoreboard for every guest this step will touch (extraction consumers + canaries):
+
+```
+bash lib/<guest>/conformance.sh    # or test.sh
+cp lib/<guest>/scoreboard.json /tmp/baseline-<guest>-step<N>.json
+```
+
+If the step is Step 0, the snapshot itself is the work — copy each guest's `scoreboard.json` (or harvest pass/fail counts from `test.sh` for guests without a scoreboard) into `lib/guest/baseline/<lang>.json`, populate the table in `plans/lib-guest.md`, commit, done.
+
+### 3. Do the work
+
+For each step the protocol is:
+1. Read the relevant existing guest file(s) via `sx_read_subtree` to see exactly what shape needs extracting.
+2. Draft `lib/guest/<file>.sx` via `sx_write_file` (validates by parsing).
+3. Port the **first** consumer to use it. Run that guest's conformance. Must equal baseline.
+4. Port the **second** consumer (the two-language rule). Run that guest's conformance. Must equal baseline.
+5. If the second consumer needs escape hatches that the first didn't, the abstraction is wrong — **redesign before continuing**, don't paper over with alias chains or per-language flags.
+
+For Step 0 only: just snapshot, no extraction.
+
+### 4. Verify
+
+For every guest the step touched:
+
+```
+bash lib/<guest>/conformance.sh   # or test.sh
+diff lib/<guest>/scoreboard.json /tmp/baseline-<guest>-step<N>.json
+```
+
+**Abort rule:** if any touched guest's scoreboard regresses by ≥1 test, do NOT commit code. Revert with `git checkout -- lib/guest/ lib/<consumers>/`, mark the step `[blocked (<specific reason>)]` in the plan, commit the plan, move to the next step.
+
+### 5. Commit code
+
+One commit for the code:
+
+```
+GUEST: step <N> — <name>
+
+<2-4 lines on what was extracted, which two consumers were ported, baseline-equal verification.>
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
+```
+
+### 6. Update plan + commit
+
+In `plans/lib-guest.md`:
+- Change this step's status from `[in-progress]` to `[done]` (or `[partial — pending <consumer>]`).
+- Fill in the Commit and Delta columns of the progress log.
+- If you re-snapshotted any baseline, update the Baseline column.
+
+Commit: `GUEST-plan: log step <N> done`.
+
+### 7. Move on
+
+Go back to step 1. Continue until:
+- All steps are `[done]` or `[blocked]`, OR
+- You hit your iteration budget, OR
+- You encounter a substrate-level failure (build broken, sx_server.exe missing) — stop and report.
+
+## Ground rules
+
+- **Branch:** `architecture`. Commit locally. **Never push.** **Never touch `main`.**
+- **Scope:** ONLY `lib/guest/**`, `lib/{lua,prolog,haskell,common-lisp,tcl,erlang,smalltalk,forth,ruby,apl,js}/**`, `plans/lib-guest.md`, `plans/agent-briefings/lib-guest-loop.md`. NO `spec/`, `hosts/`, `web/`, `shared/`.
+- **SX files:** `sx-tree` MCP tools ONLY. Never `Edit`/`Read`/`Write` on `.sx`. `sx_validate` after every edit.
+- **OCaml build:** `sx_build target="ocaml"` MCP tool. Never raw `dune`.
+- **Two-language rule:** never merge an extraction until two guests consume it. Step 8 (HM) is the only exception, marked explicitly.
+- **No alias chains** to bridge naming drift between extraction and consumer — rename consumer-side or extraction-side, don't add a translation layer.
+- **No new planning docs** beyond updating the plan file.
+- **No comments in SX** unless non-obvious.
+- **Unicode in SX:** raw UTF-8, never `\uXXXX`.
+- **Hard timeout:** >45 min on a step → mark `blocked`, move on.
+- **Partial fixes are OK.** If you extract something and only the first consumer ports cleanly, mark `[partial — pending <second consumer>]`, commit, move on. The next iteration that lands the second consumer flips it to `[done]`.
+
+## Gotchas from past sessions
+
+- `env-bind!` creates a binding; `env-set!` mutates an existing one (walks scope chain). Macros that want to introduce names use `env-bind!`.
+- SX `do` is R7RS iteration, not a sequence form. Use `begin` for multi-expr bodies.
+- `cond` / `when` / `let` clause bodies eval only the last expr — wrap in `begin` for side-effects.
+- `list?` returns false on raw JS Arrays — host-side data must be SX-converted.
+- `make-symbol` builds an identifier symbol; `string->symbol` exists too — use whichever the surrounding code uses.
+- `sx_validate` after every edit. The hook will block raw `Edit`/`Write` on `.sx` anyway, but the validator catches subtree mistakes that parse-but-don't-mean-what-you-think.
+- Guest `conformance.sh` scripts use the epoch protocol against `sx_server.exe`. If the server isn't built, run `sx_build target="ocaml"` first.
+- Each guest's `scoreboard.json` schema differs slightly — normalise to `{:totals {:pass N :fail M} :suites [...]}` when writing `lib/guest/baseline/<lang>.json`.
+- `lib/parser-combinators.sx` exists and is unused by any guest. The new lex/Pratt kit may want to coexist with it, or supersede it — investigate before duplicating its functionality.
+- Prolog operator parsing is the stress test for Pratt — Prolog ops have variable precedence, `xfx`/`xfy`/`yfx` associativity classes, and user-definable ops at runtime. The Pratt kit must accommodate runtime registration, not just static tables.
+- Haskell layout is the stress test for whitespace-sensitive lexing — off-side rule, do/let/where/of opening blocks, semicolon insertion, brace insertion. Don't ship `lib/guest/layout.sx` unless the haskell scoreboard equals baseline.
+
+## Starting state
+
+- Branch: `architecture`. HEAD at or near `40f0e733`.
+- Canaries: **Lua** + **Prolog**.
+- Plan file at `plans/lib-guest.md`. Step 0 (baseline snapshot) is the first iteration.
+- `lib/guest/` does not yet exist — create it on the Step 0 commit.

plans/agent-briefings/sx-improvements-loop.md

@@ -0,0 +1,86 @@
+# sx-improvements loop agent
+
+Iterates `plans/sx-improvements.md` forever. One step per commit.
+
+```
+description: sx-improvements loop
+subagent_type: general-purpose
+run_in_background: true
+isolation: worktree
+```
+
+## Prompt
+
+You are the sole background agent iterating `plans/sx-improvements.md` on the `architecture` branch of `/root/rose-ash`. One step per commit, forever. Never push.
+
+## Restart baseline — check before each iteration
+
+1. Read `plans/sx-improvements.md` — find the first unchecked `[ ]` step in the progress log.
+2. Read the step's section in the plan for exact implementation details.
+3. Run the verification command for that step to confirm it currently fails.
+4. Implement. Verify. Commit. Tick the `[ ]` → `[x]` in the progress log. Next.
+
+## Test commands
+
+- **OCaml spec:** `sx_build target="ocaml"` then check `bin/run_tests.exe` output.
+- **JS spec (no DOM):** `node hosts/javascript/run_tests.js 2>&1 | tail -3`
+- **HyperScript kernel:** `node tests/hs-kernel-eval.js 2>&1 | tail -3`
+- **Baseline SX tests (non-HS):** `node hosts/javascript/run_tests.js 2>&1 | grep -v "hs-upstream\|hs-compat\|hs-dev" | grep "Results:"`
+
+Do NOT regress the pre-merge passing tests. After each step, confirm the count did not drop.
+
+## Ground rules (hard)
+
+- **Branch:** `architecture`. Never push. Never touch `main`.
+- **SX files:** `sx-tree` MCP tools ONLY (`sx_summarise`, `sx_read_subtree`, `sx_replace_node`, `sx_insert_child`, `sx_validate`). Read before edit. Validate after edit.
+- **Generated files:** NEVER edit `shared/static/wasm/sx/` or `shared/static/scripts/sx-*.js` directly. Rebuild via `sx_build`.
+- **HS mirror rule:** after editing any `lib/hyperscript/<f>.sx`, copy to `shared/static/wasm/sx/hs-<f>.sx` using `sx_write_file` with the same content.
+- **OCaml build:** `sx_build target="ocaml"` — never raw `dune exec`.
+- **JS build:** `sx_build target="js"`.
+- **One step per commit.** Tick the plan. Factual commit message.
+- **No new planning docs.** No comments in SX unless non-obvious.
+- **Unicode in SX:** raw UTF-8 only, never `\uXXXX` escapes.
+
+## Step-specific notes
+
+### Step 1 (JIT combinator bug)
+The bug is in `hosts/ocaml/lib/sx_vm.ml` — `call_closure_reuse` path strips locals when
+callee returns a closure. Look for the path where `call_closure_reuse` is invoked for a
+`VmClosure` return value. The fix is to not reuse frames when the call might return a
+closure, or to properly snapshot/restore `sp`. Check `spec/tests/test-parser-combinators.sx`
+for existing combinator tests; run `node tests/hs-kernel-eval.js` for the 11 failing HS tests.
+
+### Step 2 (letrec+resume)
+The bug is browser-only (`hosts/ocaml/browser/sx_browser.ml`). Write a minimal
+`spec/tests/test-letrec-resume.sx` that exercises `letrec` + `perform` + resume and
+verify it passes under `run_tests.exe` (OCaml server mode). Then check what
+`sx_browser.ml` does differently in the VmSuspension resume path.
+
+### Steps 3-4 (E38 source info)
+The API is already in `lib/hyperscript/runtime.sx`. The gap is in the tokenizer (no `:end`/`:line`)
+and some parser span completeness. Run the 4 sourceInfo tests to see exact failures:
+`node tests/hs-kernel-eval.js --suite sourceInfo` or grep results for `sourceInfo`.
+
+### Steps 5-8 (ADTs)
+Full spec in `plans/designs/sx-adt.md`. Implement in OCaml first (Step 5), then mirror
+to JS (Step 6). Steps 7-8 build on top. Write `spec/tests/test-adt.sx` from scratch —
+start with a `(define-type Maybe (Just value) (Nothing))` suite covering constructor,
+predicate, accessor, basic match, else clause.
+
+### Steps 9-11 (plugin system)
+Full spec in `plans/designs/hs-plugin-system.md`. The prolog hook migration (Step 11) is
+the most important for language-building — it's the pattern for all future embeds.
+
+### Steps 12-14 (performance)
+Profile first. Use `sx_harness_eval` to measure throughput on a tight loop before and
+after each change. Only commit if there's a measurable win (>10%).
+
+## General gotchas (all loops)
+
+- SX `do` is R7RS iteration. Use `begin` for multi-expr sequences.
+- `cond`/`when`/`let` bodies evaluate only the last expression.
+- `type-of` on a user-defined function returns `"lambda"`.
+- Shell heredoc `||` gets eaten — escape or use `case`.
+- `env-bind!` creates new bindings; `env-set!` mutates existing (walks scope chain).
+- After OCaml edits: the build takes ~2 min. Run `sx_build target="ocaml"` and wait.
+- After JS edits: retranspile with `sx_build target="js"` then re-run tests.

plans/apl-on-sx.md

@@ -48,61 +48,61 @@ Core mapping:
 ## Roadmap
 
 ### Phase 1 — tokenizer + parser
-- [ ] Tokenizer: Unicode glyphs (the full APL set: `+ - × ÷ * ⍟ ⌈ ⌊ | ! ? ○ ~ < ≤ = ≥ > ≠ ∊ ∧ ∨ ⍱ ⍲ , ⍪ ⍴ ⌽ ⊖ ⍉ ↑ ↓ ⊂ ⊃ ⊆ ∪ ∩ ⍳ ⍸ ⌷ ⍋ ⍒ ⊥ ⊤ ⊣ ⊢ ⍎ ⍕ ⍝`), operators (`/ \ ¨ ⍨ ∘ . ⍣ ⍤ ⍥ @`), numbers (`¯` for negative, `1E2`, `1J2` complex deferred), characters (`'a'`, `''` escape), strands (juxtaposition of literals: `1 2 3`), names, comments `⍝ …`
-- [ ] Parser: right-to-left; classify each token as function, operator, value, or name; resolve valence positionally; dfn `{…}` body, tradfn `∇` header, guards `:`, control words `:If :While :For …` (Dyalog-style)
-- [ ] Unit tests in `lib/apl/tests/parse.sx`
+- [x] Tokenizer: Unicode glyphs (the full APL set: `+ - × ÷ * ⍟ ⌈ ⌊ | ! ? ○ ~ < ≤ = ≥ > ≠ ∊ ∧ ∨ ⍱ ⍲ , ⍪ ⍴ ⌽ ⊖ ⍉ ↑ ↓ ⊂ ⊃ ⊆ ∪ ∩ ⍳ ⍸ ⌷ ⍋ ⍒ ⊥ ⊤ ⊣ ⊢ ⍎ ⍕ ⍝`), operators (`/ \ ¨ ⍨ ∘ . ⍣ ⍤ ⍥ @`), numbers (`¯` for negative, `1E2`, `1J2` complex deferred), characters (`'a'`, `''` escape), strands (juxtaposition of literals: `1 2 3`), names, comments `⍝ …`
+- [x] Parser: right-to-left; classify each token as function, operator, value, or name; resolve valence positionally; dfn `{…}` body, tradfn `∇` header, guards `:`; outer product `∘.f`, inner product `f.g`, derived fns `f/ f¨ f⍨ f⍣n`
+- [x] Unit tests in `lib/apl/tests/parse.sx`
 
 ### Phase 2 — array model + scalar primitives
-- [ ] Array constructor: `make-array shape ravel`, `scalar v`, `vector v…`, `enclose`/`disclose`
-- [ ] Shape arithmetic: `⍴` (shape), `,` (ravel), `≢` (tally / first-axis-length), `≡` (depth)
-- [ ] Scalar arithmetic primitives broadcast: `+ - × ÷ ⌈ ⌊ * ⍟ | ! ○`
-- [ ] Scalar comparison primitives: `< ≤ = ≥ > ≠`
-- [ ] Scalar logical: `~ ∧ ∨ ⍱ ⍲`
-- [ ] Index generator: `⍳n` (vector 1..n or 0..n-1 depending on `⎕IO`)
-- [ ] `⎕IO` = 1 default (Dyalog convention)
-- [ ] 40+ tests in `lib/apl/tests/scalar.sx`
+- [x] Array constructor: `make-array shape ravel`, `scalar v`, `vector v…`, `enclose`/`disclose`
+- [x] Shape arithmetic: `⍴` (shape), `,` (ravel), `≢` (tally / first-axis-length), `≡` (depth)
+- [x] Scalar arithmetic primitives broadcast: `+ - × ÷ ⌈ ⌊ * ⍟ | ! ○`
+- [x] Scalar comparison primitives: `< ≤ = ≥ > ≠`
+- [x] Scalar logical: `~ ∧ ∨ ⍱ ⍲`
+- [x] Index generator: `⍳n` (vector 1..n or 0..n-1 depending on `⎕IO`)
+- [x] `⎕IO` = 1 default (Dyalog convention)
+- [x] 40+ tests in `lib/apl/tests/scalar.sx`
 
 ### Phase 3 — structural primitives + indexing
-- [ ] Reshape `⍴`, ravel `,`, transpose `⍉` (full + dyadic axis spec)
-- [ ] Take `↑`, drop `↓`, rotate `⌽` (last axis), `⊖` (first axis)
-- [ ] Catenate `,` (last axis) and `⍪` (first axis)
-- [ ] Index `⌷` (squad), bracket-indexing `A[I]` (sugar for `⌷`)
-- [ ] Grade-up `⍋`, grade-down `⍒`
-- [ ] Enclose `⊂`, disclose `⊃`, partition (subset deferred)
-- [ ] Membership `∊`, find `⍳` (dyadic), without `~` (dyadic), unique `∪` (deferred to phase 6)
-- [ ] 40+ tests in `lib/apl/tests/structural.sx`
+- [x] Reshape `⍴`, ravel `,`, transpose `⍉` (full + dyadic axis spec)
+- [x] Take `↑`, drop `↓`, rotate `⌽` (last axis), `⊖` (first axis)
+- [x] Catenate `,` (last axis) and `⍪` (first axis)
+- [x] Index `⌷` (squad), bracket-indexing `A[I]` (sugar for `⌷`)
+- [x] Grade-up `⍋`, grade-down `⍒`
+- [x] Enclose `⊂`, disclose `⊃`, partition (subset deferred)
+- [x] Membership `∊`, find `⍳` (dyadic), without `~` (dyadic), unique `∪` (deferred to phase 6)
+- [x] 40+ tests in `lib/apl/tests/structural.sx`
 
 ### Phase 4 — operators (THE SHOWCASE)
-- [ ] Reduce `f/` (last axis), `f⌿` (first axis) — including `∧/`, `∨/`, `+/`, `×/`, `⌈/`, `⌊/`
-- [ ] Scan `f\`, `f⍀`
-- [ ] Each `f¨` — applies `f` to each scalar/element
-- [ ] Outer product `∘.f` — `1 2 3 ∘.× 1 2 3` ↦ multiplication table
-- [ ] Inner product `f.g` — `+.×` is matrix multiply
-- [ ] Commute `f⍨` — `f⍨ x` ↔ `x f x`, `x f⍨ y` ↔ `y f x`
-- [ ] Compose `f∘g` — applies `g` first then `f`
-- [ ] Power `f⍣n` — apply f n times; `f⍣≡` until fixed point
-- [ ] Rank `f⍤k` — apply f at sub-rank k
-- [ ] At `@` — selective replace
-- [ ] 40+ tests in `lib/apl/tests/operators.sx`
+- [x] Reduce `f/` (last axis), `f⌿` (first axis) — including `∧/`, `∨/`, `+/`, `×/`, `⌈/`, `⌊/`
+- [x] Scan `f\`, `f⍀`
+- [x] Each `f¨` — applies `f` to each scalar/element
+- [x] Outer product `∘.f` — `1 2 3 ∘.× 1 2 3` ↦ multiplication table
+- [x] Inner product `f.g` — `+.×` is matrix multiply
+- [x] Commute `f⍨` — `f⍨ x` ↔ `x f x`, `x f⍨ y` ↔ `y f x`
+- [x] Compose `f∘g` — applies `g` first then `f`
+- [x] Power `f⍣n` — apply f n times; `f⍣≡` until fixed point
+- [x] Rank `f⍤k` — apply f at sub-rank k
+- [x] At `@` — selective replace
+- [x] 40+ tests in `lib/apl/tests/operators.sx`
 
 ### Phase 5 — dfns + tradfns + control flow
-- [ ] Dfn `{…}` with `⍺` (left arg, may be absent → niladic/monadic), `⍵` (right arg), `∇` (recurse), guards `cond:expr`, default left arg `⍺←default`
-- [ ] Local assignment via `←` (lexical inside dfn)
-- [ ] Tradfn `∇` header: `R←L F R;l1;l2`, statement-by-statement, branch via `→linenum`
-- [ ] Dyalog control words: `:If/:Else/:EndIf`, `:While/:EndWhile`, `:For X :In V :EndFor`, `:Select/:Case/:EndSelect`, `:Trap`/`:EndTrap`
-- [ ] Niladic / monadic / dyadic dispatch (function valence at definition time)
-- [ ] `lib/apl/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
+- [x] Dfn `{…}` with `⍺` (left arg, may be absent → niladic/monadic), `⍵` (right arg), `∇` (recurse), guards `cond:expr`, default left arg `⍺←default`
+- [x] Local assignment via `←` (lexical inside dfn)
+- [x] Tradfn `∇` header: `R←L F R;l1;l2`, statement-by-statement, branch via `→linenum`
+- [x] Dyalog control words: `:If/:Else/:EndIf`, `:While/:EndWhile`, `:For X :In V :EndFor`, `:Select/:Case/:EndSelect`, `:Trap`/`:EndTrap` _(Trap deferred — no exception machinery yet)_
+- [x] Niladic / monadic / dyadic dispatch (function valence at definition time)
+- [x] `lib/apl/conformance.sh` + runner, `scoreboard.json` + `scoreboard.md`
 
 ### Phase 6 — classic programs + drive corpus
-- [ ] Classic programs in `lib/apl/tests/programs/`:
-  - [ ] `life.apl` — Conway's Game of Life as a one-liner using `⊂` `⊖` `⌽` `+/`
-  - [ ] `mandelbrot.apl` — complex iteration with rank-polymorphic `+ × ⌊` (or real-axis subset)
-  - [ ] `primes.apl` — `(2=+⌿0=A∘.|A)/A←⍳N` sieve
-  - [ ] `n-queens.apl` — backtracking via reduce
-  - [ ] `quicksort.apl` — the classic Roger Hui one-liner
-- [ ] System functions: `⎕FMT`, `⎕FR` (float repr), `⎕TS` (timestamp), `⎕IO`, `⎕ML` (migration level — fixed at 1), `⎕←` (print)
-- [ ] Drive corpus to 100+ green
-- [ ] Idiom corpus — `lib/apl/tests/idioms.sx` covering classic Roger Hui / Phil Last idioms
+- [x] Classic programs in `lib/apl/tests/programs/`:
+  - [x] `life.apl` — Conway's Game of Life as a one-liner using `⊂` `⊖` `⌽` `+/`
+  - [x] `mandelbrot.apl` — complex iteration with rank-polymorphic `+ × ⌊` (or real-axis subset)
+  - [x] `primes.apl` — `(2=+⌿0=A∘.|A)/A←⍳N` sieve
+  - [x] `n-queens.apl` — backtracking via reduce
+  - [x] `quicksort.apl` — the classic Roger Hui one-liner
+- [x] System functions: `⎕FMT`, `⎕FR` (float repr), `⎕TS` (timestamp), `⎕IO`, `⎕ML` (migration level — fixed at 1), `⎕←` (print)
+- [x] Drive corpus to 100+ green
+- [x] Idiom corpus — `lib/apl/tests/idioms.sx` covering classic Roger Hui / Phil Last idioms
 
 ## SX primitive baseline
 
@@ -118,7 +118,39 @@ data; format for string templating.
 
 _Newest first._
 
-- _(none yet)_
+- 2026-05-07: Phase 6 idiom corpus — lib/apl/tests/idioms.sx; 34 classic idioms (sum, mean, max/min/range, scan, sort, reverse, first/last, take/drop, tally, mod, identity matrix, mult-table, factorial, parity count, all/any, mean-centered, ravel, rank); **all unchecked items in plan now ticked**; 362/362
+- 2026-05-07: Phase 6 system fns + 100+ corpus — apl-quad-{io,ml,fr,ts,fmt,print}; ⎕FMT formats scalar/vector/matrix; ⎕TS returns 7-vector (epoch default); 328 tests >> 100 target; **drive-to-100 ticked**; +13 tests
+- 2026-05-07: Phase 6 quicksort — recursive less/eq/greater partition via apl-compress, deterministic-pivot variant; tests cover empty/single/sorted/reverse/duplicates/negatives; **all 5 classic programs done**; +9 tests; 315/315
+- 2026-05-07: Phase 6 n-queens — permutation enumerate + diagonal-conflict filter; counts q(1..8) = 1,0,0,2,10,4,40,92 (OEIS A000170); apl-permutations + apl-queens; bumped test timeout 60→180s for q(8); +10 tests; 306/306
+- 2026-05-07: Phase 6 mandelbrot real-axis — apl-mandelbrot-1d batched z=z²+c with permanent alive-mask; c∈{-2,-1,0,0.25} bounded, c=1→3, c=0.5→5, c=2→2; +9 tests; 296/296
+- 2026-05-07: Phase 6 life — Conway via 9-shift toroidal sum + alive-rule (cnt=3 OR alive∧cnt=4); apl-life-step + life.apl source; blinker oscillates, block stable, glider advances; +7 tests; 287/287
+- 2026-05-07: Phase 6 primes — sieve via outer-product residue + reduce-first + compress; apl-compress added; lib/apl/tests/programs/primes.apl source; +11 tests; 280/280
+- 2026-05-07: Phase 5 conformance.sh + scoreboard.{json,md} — per-suite runner; current snapshot 269/269; **Phase 5 complete**
+- 2026-05-07: Phase 5 valence dispatch — apl-dfn-valence (AST scan for ⍺/⍵), apl-tradfn-valence (slot check), apl-call unified entry; +14 tests; 269/269 tests
+- 2026-05-07: Phase 5 control words — :If/:Else, :While, :For/:In, :Select/:Case via apl-tradfn-eval-block/stmt threading env; :Trap deferred; +10 tests (sum loop, factorial, dispatch, nested); 255/255 tests
+- 2026-05-07: Phase 5 tradfn — apl-call-tradfn + apl-tradfn-loop; line-numbered stmts, :branch goto, →0 exits, locals; +10 tests including loop sum; 245/245 tests
+- 2026-05-07: Phase 5 dfn complete — apl-eval-stmts (guards, locals, ⍺←default), ∇ recursion via env "nabla"; +9 tests (factorial, guards, defaults, locals); 235/235 tests
+- 2026-05-07: Phase 5 dfn foundation — lib/apl/transpile.sx with apl-eval-ast (handles :num :vec :name :monad :dyad :program :dfn) + glyph→fn lookup tables; apl-call-dfn / apl-call-dfn-m bind ⍺/⍵; ∇/guards/defaults/locals pending; 226/226 tests
+- 2026-05-07: Phase 4 step 10 — at @ (apl-at-replace + apl-at-apply); linear-index lookup, scalar-vals broadcast; 211/211 tests
+- 2026-05-07: Phase 4 step 9 — rank f⍤k (apl-rank); cell decomposition + reassembly via frame/cell shapes; 201/201 tests
+- 2026-05-06: Phase 4 step 8 — power f⍣n (apl-power) + fixed-point f⍣≡ (apl-power-fixed); 191/191 tests
+- 2026-05-06: Phase 4 step 7 — compose f∘g (apl-compose monadic f∘g x, apl-compose-dyadic dyadic f x (g y)); 182/182 tests
+- 2026-05-06: Phase 4 step 6 — commute f⍨ (apl-commute monadic dup, apl-commute-dyadic swap); 173/173 tests
+- 2026-05-06: Phase 4 step 5 — inner product f.g (apl-inner); +.× matrix multiply, ∧.= equal-vectors; 163/163 tests
+- 2026-05-06: Phase 4 step 4 — outer product ∘.f (apl-outer); rank-doubling result shape = a-shape++b-shape; 151/151 tests
+- 2026-05-06: Phase 4 step 3 — each f¨ (monadic apl-each + dyadic apl-each-dyadic); scalar broadcast both sides; 139/139 tests
+- 2026-05-06: Phase 4 step 2 — scan f\ (last axis) + f⍀ (first axis); apl-scan/apl-scan-first; 125/125 tests
+- 2026-05-06: Phase 4 step 1 — reduce f/ (last axis) + f⌿ (first axis); apl-reduce/apl-reduce-first; 110/110 tests
+- 2026-05-06: Phase 3 complete — membership ∊, dyadic ⍳ (index-of), without ~ (index-of returns nil for not-found); 94/94 tests
+- 2026-05-06: Phase 3 step 6 — enclose ⊂ / disclose ⊃ (box/unbox, rank-0 detect via type-of); 82/82 tests
+- 2026-05-06: Phase 3 step 5 — grade-up ⍋ / grade-down ⍒ (stable insertion sort); 74/74 tests
+- 2026-05-06: Phase 3 step 4 — squad ⌷ (scalar/multi-dim/partial-slice); 66/66 tests
+- 2026-05-06: Phase 3 step 3 — catenate , (last axis, scalar promo) and first-axis; 59/59 tests
+- 2026-05-06: Phase 3 step 2 — take ↑ (multi-axis, pad), drop ↓, reverse/rotate ⌽⊖ (last+first axis); 50/50 tests
+- 2026-05-06: Phase 3 step 1 — reshape ⍴ (cycling), transpose ⍉ (monadic+dyadic); helpers apl-strides/flat->multi/multi->flat; 27/27 structural tests; lib/apl/tests/structural.sx
+- 2026-04-26: Phase 2 complete — array model + 7 scalar primitive groups; 82/82 tests; lib/apl/runtime.sx + lib/apl/tests/scalar.sx
+- 2026-04-26: parser (Phase 1 step 2) — 44/44 parser tests green (90/90 total); right-to-left segment algorithm; derived fns, outer/inner product, dfns with guards, strand handling; `lib/apl/parser.sx` + `lib/apl/tests/parse.sx`
+- 2026-04-25: tokenizer (Phase 1 step 1) — 46/46 tests green; Unicode-aware starts-with? scanner for multi-byte APL glyphs; `lib/apl/tokenizer.sx` + `lib/apl/tests/parse.sx`
 
 ## Blockers
 

plans/hs-conformance-scoreboard.md

@@ -3,49 +3,14 @@
 Live tally for `plans/hs-conformance-to-100.md`. Update after every cluster commit.
 
 ```
-Baseline:    1213/1496 (81.1%)  initial scrape
-Snapshot:    1514/1514          upstream sync 2026-05-08 (+18 new upstream tests)
-Conformance: 1514/1514 (100.0%) — zero skips, full upstream coverage
-Wall:        23m33s sequential (8 batches × 200) via tests/hs-run-batched.js
-Note: full-suite single-process is unreliable due to JIT cache saturation;
-      use hs-run-batched.js (fresh kernel per batch) for deterministic numbers.
-
-Cleared this session (18 → 0 skips):
-  - Toggle parser ambiguity (1)       → 2-token lookahead in parse-toggle
-  - Throttled-at modifier (1)         → parser + emit-on wrap + hs-throttle!/hs-debounce!
-  - Tokenizer-stream API (13)         → hs-stream wrapper + 15 stream primitives
-  - Template-component scope (2)      → manual bodies for enclosing-scope-via-$varname semantics
-  - Async event dispatch (1)          → manual body covers parse+compile+dispatch path
-  - Compiler perf (cross-cutting)     → hoist _strip-throttle-debounce to module level
-                                         (was JIT-recompiling per emit-on call)
+Baseline:   1213/1496 (81.1%)
+Merged:     1478/1496 (98.8%)   delta +265
+Worktree:   all landed
+Target:     1496/1496 (100.0%)
+Remaining:  18 (all SKIP/untranslated — no runtime failures)
+Note: step limit raised 200k→1M in 225fa2e8 revealed 70 previously-masked passes
 ```
 
-## Status: 1514/1514 ✓ — no remaining work in upstream conformance.
-
-### 2026-05-12 — kernel-eq + io-wait-event ABI fix-up
-
-The 100% claim held against the kernel as it was at 92619301. Subsequent
-commits (Phase 1+2+3 JIT, value-handle ABI, numeric tower) regressed three
-tests; all three are now fixed:
-
-  - arrayLiteral / arrays containing objects work — **fixed** in 4db1f85f
-    (deep_equal in sx_browser.ml had no Integer branch; safe_eq for Dict/Dict
-    only handled DOM handles, never structural). Suite back to 8/8.
-  - hs-upstream-wait / can wait on event or timeout 1 — **fixed** in cfbab3b2
-    (io-wait-event mock in test runner did `typeof timeout === 'number'`
-    on a value-handle, never triggering the timeout-wins branch). Suite 7/7.
-  - hs-upstream-wait / can wait on event or timeout 2 — same fix.
-
-75 tests in batch 150-225 still unverified (slow reactivity/runtime tests
-exceed 15min wall in the single-process runner; not a correctness issue —
-the parallel batched runner times those individual batches out, but the
-underlying tests pass when given enough time).
-
-Future architectural items NOT required for conformance, tracked for roadmap:
-  - True `<script type="text/hyperscript-template" component="...">` custom-element registrar
-  - True async kernel suspension for `repeat until event` (yielding to JS event loop)
-  - Parser fix for `from #<id-ref>` after `event NAME` in until-expressions
-
 ## Cluster ledger
 
 ### Bucket A — runtime fixes
@@ -136,13 +101,6 @@ Defer until A–D drain. Estimated ~25 recoverable tests.
 | F6 | `asyncError` rejected promise catch | done | +1 | — |
 | F7 | `hs-on` nil-target guard (skip-list rescue) | done | +1 | 1751cd05 |
 | F8 | `on EVENT from SRC or EVENT from SRC` multi-source | done | +1 | f1428009 |
-| F9 | `obj.method()` via host-call (T9 from plan) | done | +1 | hs-f |
-| F10 | `obj.method(promiseArg)` resolved sync (F2) | done | +1 | hs-f |
-| F11 | `obj.asyncMethod(promiseArg)` resolved sync (F3) | done | +1 | hs-f |
-| F12 | `fetch /url as html` → DocumentFragment via io-parse-html | done | +1 | hs-f |
-| F13 | `hs-null-error!` self-contained guard (avoid slow host_error path) | done | +3 | hs-f |
-| F14 | `when @attr changes` parser+compiler+runtime — MutationObserver wiring | done | +1 | hs-f |
-| F15 | def/default/empty suites: NO_STEP_LIMIT for legitimate scoped-var cascades | done | +N | hs-f |
 
 ## Buckets roll-up
 

plans/jit-cache-architecture.md

@@ -1,232 +0,0 @@
-# JIT Cache Architecture — Tiered + LRU + Reset API
-
-## Problem statement
-
-The OCaml WASM kernel JIT-compiles every lambda body on first call and caches
-the resulting `vm_closure` in a mutable slot on the lambda itself
-(`Lambda.l_compiled`, `Component.c_compiled`, `Island.i_compiled`). Cache
-growth is unbounded — there is no eviction, no threshold, no reset.
-
-**Where it bites today:** the HS conformance test harness compiles ~3000
-distinct one-shot HS source strings via `eval-hs` in a single process. Each
-compilation creates a fresh lambda → fresh `vm_closure`. After ~500 tests,
-allocation pressure / GC overhead dominates and tests that take 200ms in
-isolation start taking 30s.
-
-**Where it would bite in production:** a long-lived process that accepts
-arbitrary user-supplied SX (a scripting plugin host, a REPL service, an
-edge function with cold lambdas per request, an SPA visiting thousands of
-distinct routes). Today's SX apps don't hit this because they compile a
-fixed component set at boot and reuse it; the cache reaches steady state.
-
-## Architecture
-
-Three coordinated mechanisms, deployed in order:
-
-### 1. Tiered compilation — "filter what enters the cache"
-
-Most lambdas in our test harness are call-once-and-discard. They consume
-JIT compilation cost, occupy cache space, and never amortize. Solution:
-don't JIT until a lambda has been called K times.
-
-**OCaml changes:**
-
-```ocaml
-(* sx_types.ml *)
-type lambda = {
-  ...
-  mutable l_compiled  : vm_closure option;  (* unchanged *)
-  mutable l_call_count: int;                (* NEW *)
-}
-```
-
-```ocaml
-(* sx_vm.ml — in cek_call_or_suspend *)
-let jit_threshold = ref 4
-
-let maybe_jit lam =
-  match lam.l_compiled with
-  | Some _ -> ()  (* already compiled *)
-  | None ->
-    lam.l_call_count <- lam.l_call_count + 1;
-    if lam.l_call_count >= !jit_threshold then
-      lam.l_compiled <- !jit_compile_ref lam globals
-```
-
-**Tunable via primitive:** `(jit-set-threshold! N)` (default 4; 1 = old
-behavior; ∞ = disable JIT).
-
-**Expected impact:**
-- Cold lambdas (test harness, eval-hs throwaways) never enter the cache.
-- Hot lambdas (component renders, event handlers) hit the threshold within
-  a handful of calls and get full JIT speed.
-- Eliminates the test-harness pathology entirely without touching cache size.
-
-### 2. LRU eviction — "bound memory regardless of input"
-
-Even with tiered compilation, a long-lived process eventually compiles
-enough hot lambdas to exceed memory budget. Pure LRU eviction with a
-fixed budget gives a predictable ceiling.
-
-**OCaml changes:**
-
-```ocaml
-(* sx_jit_cache.ml — NEW module *)
-type cache_entry = {
-  closure : vm_closure;
-  mutable last_used : int;  (* generation counter *)
-  mutable pinned : bool;    (* hot-path opt-out *)
-}
-
-let cache : (int, cache_entry) Hashtbl.t = Hashtbl.create 256
-let mutable cache_budget = 5000   (* lambdas, not bytes — easy to reason about *)
-let mutable generation = 0
-
-let lookup lambda_id = ...
-let insert lambda_id closure = 
-  generation <- generation + 1;
-  Hashtbl.add cache lambda_id { closure; last_used = generation; pinned = false };
-  if Hashtbl.length cache > cache_budget then evict_oldest ()
-let pin lambda_id = ...
-```
-
-**Migration:** `Lambda.l_compiled` stops being a direct slot; it becomes
-a lookup against the central cache via `l_id` (each lambda already has
-a unique identity). Failed lookups fall through to the interpreter — same
-correctness semantics, just slower for evicted entries.
-
-**Tunable:** `(jit-set-budget! N)` (default 5000; 0 = disable cache).
-
-**Pinning:** `(jit-pin! 'fn-name)` keeps a function from ever being evicted.
-Use for stdlib helpers, hot rendering paths.
-
-### 3. Manual reset API — "escape hatch for app checkpoints"
-
-Some app patterns know exactly when their cache should be flushed:
-- A web server between request batches
-- An SPA on logout / navigation
-- A test runner between batches (yes, even with #1 + #2)
-- A REPL on `:reset`
-
-**Primitives:**
-
-| Primitive | Behavior |
-|-----------|----------|
-| `(jit-reset!)` | Drop all cache entries. Hot paths re-JIT on next call. |
-| `(jit-clear-cold!)` | Drop only entries that haven't been used in N generations. |
-| `(jit-stats)` | Returns dict: `{:size N :budget M :hits H :misses I :evictions E}`. |
-| `(jit-set-threshold! N)` | Raise/lower compilation threshold at runtime. |
-| `(jit-set-budget! N)` | Raise/lower cache size budget. |
-| `(jit-pin! sym)` | Pin a named function against eviction. |
-| `(jit-unpin! sym)` | Unpin. |
-
-All zero-cost when not called — just a few atomic counter increments.
-
-## Where it lives
-
-The JIT is host-specific (OCaml WASM kernel). The plan splits across
-three layers:
-
-```
-hosts/ocaml/lib/sx_jit_cache.ml      NEW — cache datastructure + LRU
-hosts/ocaml/lib/sx_vm.ml             Modified — call counter, lookup integration
-hosts/ocaml/lib/sx_types.ml          Modified — l_call_count field, l_id is global
-hosts/ocaml/lib/sx_primitives.ml     Modified — register jit-* primitives
-spec/primitives.sx                   Modified — declarative spec for jit-* primitives
-lib/jit.sx                            NEW — SX-level helpers + macros
-```
-
-**lib/jit.sx** would contain:
-
-```lisp
-;; Convenience: temporarily change threshold
-(define-macro (with-jit-threshold n & body)
-  `(let ((__old (jit-stats)))
-     (jit-set-threshold! ,n)
-     (let ((__r (do ,@body))) (jit-set-threshold! (get __old :threshold)) __r)))
-
-;; Convenience: drop cache before/after a block
-(define-macro (with-fresh-jit & body)
-  `(let ((__r (do (jit-reset!) ,@body))) (jit-reset!) __r))
-
-;; Monitoring helper for dev mode
-(define jit-report
-  (fn ()
-    (let ((s (jit-stats)))
-      (str "jit: " (get s :size) "/" (get s :budget) " entries, "
-           (get s :hits) " hits / " (get s :misses) " misses ("
-           (* 100 (/ (get s :hits) (max 1 (+ (get s :hits) (get s :misses)))))
-           "%)"))))
-```
-
-This is shared SX — every host language (HS, Common Lisp, Erlang, etc.)
-gets the same API for free.
-
-## Rollout
-
-**Phase 1: Tiered compilation — IMPLEMENTED (commit b9d63112)**
-- ✅ `l_call_count : int` field on lambda type (sx_types.ml)
-- ✅ Counter increment + threshold check in cek_call_or_suspend Lambda case (sx_vm.ml)
-- ✅ Module-level refs in sx_types: `jit_threshold` (default 4), `jit_compiled_count`,
-  `jit_skipped_count`, `jit_threshold_skipped_count`. Refs live in sx_types so
-  sx_primitives can read them without creating an import cycle.
-- ✅ Primitives: `jit-stats`, `jit-set-threshold!`, `jit-reset-counters!` (sx_primitives.ml)
-- Verified: 4771/1111 OCaml run_tests, identical to baseline — no regressions.
-
-**WASM rollout note:** The native binary has Phase 1 active. The browser
-WASM (`shared/static/wasm/sx_browser.bc.js`) needs to be rebuilt, but the
-new build uses a different value-wrapping ABI ({_type, __sx_handle} for
-numbers) incompatible with the current test runner (`tests/hs-run-filtered.js`).
-For now the test tree pins the pre-rewrite WASM. Resolving the ABI gap
-is a separate task — either update the test runner to unwrap, or expose
-a value-marshalling helper from the kernel.
-
-**Phase 2: LRU cache (3-5 days)**
-- Extract `Lambda.l_compiled` into central `sx_jit_cache.ml`
-- Add `l_id : int` (global, monotonic) to lambda type
-- Migrate all `vm_closure` accessors to go through cache
-- Add `jit-set-budget!`, `jit-pin!`, `jit-unpin!` primitives
-- Verify: same full-suite run with budget=100 — cache hit/miss ratio reasonable
-
-**Phase 3: Reset API + monitoring (1 day)**
-- Add `jit-reset!`, `jit-clear-cold!`, `jit-stats` primitives
-- Add `lib/jit.sx` SX-level wrappers
-- Integrate into HS test runner: call `jit-reset!` between batches as belt-and-suspenders
-- Document in CLAUDE.md / migration notes
-
-**Phase 4: Production hardening (incremental)**
-- Memory pressure hooks (browser `performance.measureUserAgentSpecificMemory`)
-- Bytecode interning (dedupe identical `vm_closure` bodies across lambdas)
-- Generational sweep on idle (browser `requestIdleCallback`)
-- These are nice-to-have, not required for correctness.
-
-## Testing
-
-Each phase ships with:
-- Unit tests in `spec/tests/test-jit-cache.sx` (new file)
-- Conformance must remain 100% per-suite
-- Wall-clock benchmark: full HS suite single-process before/after
-
-Phase 1 acceptance criterion: HS conformance suite completes in single
-process under 10 minutes wall time.
-
-Phase 2 acceptance: same as 1 but with budget=500. Cache size stays
-bounded throughout the run; hit rate >90% on hot paths.
-
-Phase 3 acceptance: `jit-reset!` between batches reduces test-harness
-wall time by >50% vs no reset (because hot stdlib stays cached, but
-test-specific lambdas don't accumulate).
-
-## Why this order
-
-Tiered compilation is the highest-leverage change — it solves the
-test-harness problem at the source (most lambdas never enter the
-cache) without touching cache machinery. LRU is the safety net
-(unbounded growth still possible if every lambda is hot, e.g., huge
-dynamic component graph). Reset is the escape hatch for situations
-neither mechanism can handle (logout, hard memory pressure, app
-restart without process restart).
-
-Doing them in reverse would invert the value — reset alone fixes
-nothing without app-level integration, and LRU without tiered
-compilation churns the cache constantly on cold lambdas.