fed-prims: diagnose fed-sx-m2 Blockers #4 — not a mutex bug, hand back to m2

Investigated the http-listen "handler-mutex deadlock" per
plans/agent-briefings/fed-prims-mutex-fix.md. Reproduced deterministically
(single kernel-route request returns empty reply while a non-kernel route
returns 200; also reproduced with a 3-line minimal echo gen_server).

Root cause is in the Erlang substrate, not the OCaml mutex: native
http-listen runs each handler on a fresh Thread.create outside any Erlang
scheduler step, so gen_server:call -> receive (which raises er-suspend-marker
expecting an enclosing er-sched-step-alive! guard + er-sched-run-all! pump)
can never complete.

Pattern A is inapplicable: the failure reproduces on a single request with
zero contention, so it is not a mutex-contention deadlock; the mutex is in
fact required and must stay. Sx_runtime.sx_call is fully synchronous and no
OCaml symbol reaches the SX-level scheduler, so there is no OCaml-only fix.
The correct fix is Pattern B done entirely in er-bif-http-listen
(lib/erlang/runtime.sx) — spawn the handler as an er-process and
er-sched-run-all! to completion — which is m2 / loops/erlang scope.

Doc-only: full diagnosis + concrete patch sketch added to the Blockers and
Progress log of plans/fed-sx-host-primitives.md. No bin/sx_server.ml change.

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

.claude/scheduled_tasks.lock

@@ -1 +1 @@
-{"sessionId":"bf20a443-9df8-4cb9-932e-8c6f4c4625c2","pid":1303602,"procStart":"253831081","acquiredAt":1779865895644}
+{"sessionId":"31c80255-eb92-43e4-8997-84ad84e27326","pid":90960,"procStart":"564684","acquiredAt":1777049890282}

.mcp.json

@@ -2,7 +2,7 @@
   "mcpServers": {
     "sx-tree": {
       "type": "stdio",
-      "command": "/root/rose-ash/hosts/ocaml/_build/default/bin/mcp_tree.exe"
+      "command": "./hosts/ocaml/_build/default/bin/mcp_tree.exe"
     },
     "rose-ash-services": {
       "type": "stdio",

hosts/ocaml/bin/run_tests.ml

@@ -1820,213 +1820,6 @@ let run_foundation_tests () =
      Printf.printf "  FAIL: invocation_count: %s\n"
        (match other with Some n -> string_of_int n | None -> "None"));
 
-  Printf.printf "\nSuite: extensions/erlang_ext (Phase 9h)\n";
-  (* Register the Erlang opcode namespace. Disjoint id range (200-217)
-     from test_ext (220/221) so they coexist. *)
-  Erlang_ext.register ();
-
-  (match prim [String "erlang.OP_PATTERN_TUPLE"] with
-   | Integer 222 ->
-     incr pass_count;
-     Printf.printf "  PASS: extension-opcode-id erlang.OP_PATTERN_TUPLE = 222\n"
-   | other ->
-     incr fail_count;
-     Printf.printf "  FAIL: erlang.OP_PATTERN_TUPLE: got %s\n"
-       (Sx_types.inspect other));
-
-  (match prim [String "erlang.OP_BIF_IS_TUPLE"] with
-   | Integer 239 ->
-     incr pass_count;
-     Printf.printf "  PASS: extension-opcode-id erlang.OP_BIF_IS_TUPLE = 239\n"
-   | other ->
-     incr fail_count;
-     Printf.printf "  FAIL: erlang.OP_BIF_IS_TUPLE: got %s\n"
-       (Sx_types.inspect other));
-
-  (match prim [String "erlang.OP_NONEXISTENT"] with
-   | Nil ->
-     incr pass_count;
-     Printf.printf "  PASS: unknown erlang opcode -> nil\n"
-   | other ->
-     incr fail_count;
-     Printf.printf "  FAIL: unknown erlang opcode: got %s\n"
-       (Sx_types.inspect other));
-
-  (* Phase 10b vertical slice: erlang.OP_BIF_LENGTH (230) is a REAL
-     handler. Build [CONST 0; OP_BIF_LENGTH; RETURN] with an Erlang
-     list [1,2,3] in the constant pool; expect Integer 3. Proves the
-     full path: bytecode -> Sx_vm extension fallthrough -> erlang_ext
-     handler -> correct stack result. *)
-  (let mk_dict kvs =
-     let h = Hashtbl.create 4 in
-     List.iter (fun (k, v) -> Hashtbl.replace h k v) kvs;
-     Sx_types.Dict h in
-   let er_nil = mk_dict [("tag", Sx_types.String "nil")] in
-   let er_cons hd tl =
-     mk_dict [("tag", Sx_types.String "cons");
-              ("head", hd); ("tail", tl)] in
-   let lst = er_cons (Sx_types.Integer 1)
-               (er_cons (Sx_types.Integer 2)
-                  (er_cons (Sx_types.Integer 3) er_nil)) in
-   let code = ({
-     vc_arity = 0; vc_rest_arity = -1; vc_locals = 0;
-     vc_bytecode = [| 1; 0; 0; 230; 50 |];
-     vc_constants = [| lst |];
-     vc_bytecode_list = None; vc_constants_list = None;
-   } : Sx_types.vm_code) in
-   let globals = Hashtbl.create 1 in
-   try
-     match Sx_vm.execute_module code globals with
-     | Integer 3 ->
-       incr pass_count;
-       Printf.printf "  PASS: erlang.OP_BIF_LENGTH [1,2,3] -> 3 (real handler, end-to-end)\n"
-     | other ->
-       incr fail_count;
-       Printf.printf "  FAIL: OP_BIF_LENGTH result: got %s\n"
-         (Sx_types.inspect other)
-   with exn ->
-     incr fail_count;
-     Printf.printf "  FAIL: OP_BIF_LENGTH raised: %s\n"
-       (Printexc.to_string exn));
-
-  (* More real handlers (Phase 10b batch): build a list/tuple constant
-     and exercise HD/TL/TUPLE_SIZE/IS_* end-to-end through the VM. *)
-  (let mk_dict kvs =
-     let h = Hashtbl.create 4 in
-     List.iter (fun (k, v) -> Hashtbl.replace h k v) kvs;
-     Sx_types.Dict h in
-   let er_nil = mk_dict [("tag", Sx_types.String "nil")] in
-   let er_cons hd tl = mk_dict [("tag", Sx_types.String "cons");
-                                ("head", hd); ("tail", tl)] in
-   let er_tuple es = mk_dict [("tag", Sx_types.String "tuple");
-                              ("elements", Sx_types.List es)] in
-   let er_atom nm = mk_dict [("tag", Sx_types.String "atom");
-                             ("name", Sx_types.String nm)] in
-   let lst3 = er_cons (Sx_types.Integer 7)
-                (er_cons (Sx_types.Integer 8)
-                   (er_cons (Sx_types.Integer 9) er_nil)) in
-   let tup3 = er_tuple [Sx_types.Integer 1; Sx_types.Integer 2;
-                        Sx_types.Integer 3] in
-   let run consts bc =
-     let code = ({
-       vc_arity = 0; vc_rest_arity = -1; vc_locals = 0;
-       vc_bytecode = bc; vc_constants = consts;
-       vc_bytecode_list = None; vc_constants_list = None;
-     } : Sx_types.vm_code) in
-     Sx_vm.execute_module code (Hashtbl.create 1) in
-   let nm = function
-     | Sx_types.Dict d ->
-       (match Hashtbl.find_opt d "name" with
-        | Some (Sx_types.String s) -> s | _ -> "?")
-     | _ -> "?" in
-   let check label want got =
-     if got = want then begin
-       incr pass_count;
-       Printf.printf "  PASS: %s\n" label
-     end else begin
-       incr fail_count;
-       Printf.printf "  FAIL: %s: got %s\n" label (Sx_types.inspect got)
-     end in
-   (* HD [7,8,9] -> 7 *)
-   check "OP_BIF_HD [7,8,9] -> 7" (Sx_types.Integer 7)
-     (run [| lst3 |] [| 1;0;0; 231; 50 |]);
-   (* TL [7,8,9] -> [8,9], check its HD = 8 *)
-   check "OP_BIF_TL then HD -> 8" (Sx_types.Integer 8)
-     (run [| lst3 |] [| 1;0;0; 232; 231; 50 |]);
-   (* TUPLE_SIZE {1,2,3} -> 3 *)
-   check "OP_BIF_TUPLE_SIZE {1,2,3} -> 3" (Sx_types.Integer 3)
-     (run [| tup3 |] [| 1;0;0; 234; 50 |]);
-   (* IS_INTEGER 42 -> true ; IS_INTEGER [..] -> false *)
-   (match run [| Sx_types.Integer 42 |] [| 1;0;0; 236; 50 |] with
-    | v when nm v = "true" ->
-      incr pass_count; Printf.printf "  PASS: OP_BIF_IS_INTEGER 42 -> true\n"
-    | v -> incr fail_count;
-      Printf.printf "  FAIL: IS_INTEGER 42: got %s\n" (Sx_types.inspect v));
-   (match run [| lst3 |] [| 1;0;0; 236; 50 |] with
-    | v when nm v = "false" ->
-      incr pass_count; Printf.printf "  PASS: OP_BIF_IS_INTEGER list -> false\n"
-    | v -> incr fail_count;
-      Printf.printf "  FAIL: IS_INTEGER list: got %s\n" (Sx_types.inspect v));
-   (* IS_ATOM atom -> true ; IS_LIST nil -> true ; IS_TUPLE tuple -> true *)
-   (match run [| er_atom "ok" |] [| 1;0;0; 237; 50 |] with
-    | v when nm v = "true" ->
-      incr pass_count; Printf.printf "  PASS: OP_BIF_IS_ATOM ok -> true\n"
-    | v -> incr fail_count;
-      Printf.printf "  FAIL: IS_ATOM: got %s\n" (Sx_types.inspect v));
-   (match run [| er_nil |] [| 1;0;0; 238; 50 |] with
-    | v when nm v = "true" ->
-      incr pass_count; Printf.printf "  PASS: OP_BIF_IS_LIST nil -> true\n"
-    | v -> incr fail_count;
-      Printf.printf "  FAIL: IS_LIST nil: got %s\n" (Sx_types.inspect v));
-   (match run [| tup3 |] [| 1;0;0; 239; 50 |] with
-    | v when nm v = "true" ->
-      incr pass_count; Printf.printf "  PASS: OP_BIF_IS_TUPLE {..} -> true\n"
-    | v -> incr fail_count;
-      Printf.printf "  FAIL: IS_TUPLE: got %s\n" (Sx_types.inspect v));
-   (match run [| tup3 |] [| 1;0;0; 238; 50 |] with
-    | v when nm v = "false" ->
-      incr pass_count; Printf.printf "  PASS: OP_BIF_IS_LIST tuple -> false\n"
-    | v -> incr fail_count;
-      Printf.printf "  FAIL: IS_LIST tuple: got %s\n" (Sx_types.inspect v));
-   (* ELEMENT: element(2, {1,2,3}) -> 2. Calling convention: push
-      Index then Tuple; opcode pops Tuple (TOS) then Index. *)
-   check "OP_BIF_ELEMENT element(2,{1,2,3}) -> 2" (Sx_types.Integer 2)
-     (run [| Sx_types.Integer 2; tup3 |] [| 1;0;0; 1;1;0; 233; 50 |]);
-   check "OP_BIF_ELEMENT element(1,{1,2,3}) -> 1" (Sx_types.Integer 1)
-     (run [| Sx_types.Integer 1; tup3 |] [| 1;0;0; 1;1;0; 233; 50 |]);
-   (* ELEMENT out of range raises *)
-   (let raised =
-      (try ignore (run [| Sx_types.Integer 9; tup3 |]
-                     [| 1;0;0; 1;1;0; 233; 50 |]); false
-       with Sx_types.Eval_error _ -> true) in
-    if raised then begin
-      incr pass_count;
-      Printf.printf "  PASS: OP_BIF_ELEMENT out-of-range raises\n"
-    end else begin
-      incr fail_count;
-      Printf.printf "  FAIL: OP_BIF_ELEMENT out-of-range should raise\n"
-    end);
-   (* LISTS_REVERSE [7,8,9] -> [9,8,7]; verify HD = 9 then HD of TL = 8 *)
-   check "OP_BIF_LISTS_REVERSE then HD -> 9" (Sx_types.Integer 9)
-     (run [| lst3 |] [| 1;0;0; 235; 231; 50 |]);
-   check "OP_BIF_LISTS_REVERSE then TL,HD -> 8" (Sx_types.Integer 8)
-     (run [| lst3 |] [| 1;0;0; 235; 232; 231; 50 |]);
-   (* reverse preserves length *)
-   check "OP_BIF_LISTS_REVERSE then LENGTH -> 3" (Sx_types.Integer 3)
-     (run [| lst3 |] [| 1;0;0; 235; 230; 50 |]));
-
-  (* A still-stubbed opcode (222 = erlang.OP_PATTERN_TUPLE) raises the
-     not-wired Eval_error — confirms the honest-failure path remains
-     for opcodes whose real handlers haven't landed. *)
-  (let globals = Hashtbl.create 1 in
-   try
-     ignore (Sx_vm.execute_module (make_bc_seq [| 222; 50 |]) globals);
-     incr fail_count;
-     Printf.printf "  FAIL: erlang.OP_PATTERN_TUPLE dispatch should have raised\n"
-   with
-   | Sx_types.Eval_error msg
-     when (let needle = "not yet wired" in
-           let nl = String.length needle and ml = String.length msg in
-           let rec scan i =
-             if i + nl > ml then false
-             else if String.sub msg i nl = needle then true
-             else scan (i + 1)
-           in scan 0) ->
-     incr pass_count;
-     Printf.printf "  PASS: erlang opcode dispatch raises not-wired error\n"
-   | exn ->
-     incr fail_count;
-     Printf.printf "  FAIL: unexpected exn: %s\n" (Printexc.to_string exn));
-
-  (match Erlang_ext.dispatch_count () with
-   | Some n when n >= 1 ->
-     incr pass_count;
-     Printf.printf "  PASS: erlang_ext state recorded %d dispatch(es)\n" n
-   | other ->
-     incr fail_count;
-     Printf.printf "  FAIL: dispatch_count: %s\n"
-       (match other with Some n -> string_of_int n | None -> "None"));
-
   Printf.printf "\nSuite: jit extension-opcode awareness\n";
   let scan = Sx_vm.bytecode_uses_extension_opcodes in
   let no_consts = [||] in

hosts/ocaml/bin/sx_server.ml

@@ -18,20 +18,6 @@
 
 open Sx_types
 
-(* Force-link Sx_vm_extensions so its module-init runs: installs the
-   extension dispatch fallthrough and registers the `extension-opcode-id`
-   SX primitive. Without a reference here OCaml dead-code-eliminates the
-   module from sx_server.exe (it's only otherwise reached from run_tests),
-   leaving guest-language opcode extensions (Erlang Phase 9, etc.)
-   invisible to the runtime. The applied call is a harmless lookup. *)
-let () = ignore (Sx_vm_extensions.id_of_name "")
-
-(* Register the Erlang opcode extension (Phase 9h) so
-   `extension-opcode-id "erlang.OP_*"` resolves to the host ids the SX
-   stub dispatcher consults. Guarded: a double-register raises Failure,
-   which we swallow so a re-entered server process doesn't die. *)
-let () = try Erlang_ext.register () with Failure _ -> ()
-
 (* ====================================================================== *)
 (* Font measurement via otfm — reads OpenType/TrueType font tables         *)
 (* ====================================================================== *)
@@ -855,6 +841,164 @@ let setup_evaluator_bridge env =
       done;
       Nil
     | _ -> raise (Eval_error "http-listen: (port handler)"));
+
+  (* fed-sx Milestone 1 client direction (Phase J). NATIVE ONLY —
+     Unix sockets + DNS; absent from the WASM kernel. HTTP/1.1
+     request: TCP connect, write request line + headers + body,
+     read status + headers + body, return {:status :headers :body}.
+     URL must be http://...; HTTPS is a later phase (needs TLS).
+     Body read: Content-Length first, else read to EOF (we send
+     Connection: close). Transfer-Encoding: chunked is rejected —
+     fed-sx Phase 8 wires this for inter-server POSTs which will
+     all carry Content-Length. *)
+  Sx_primitives.register "http-request" (fun args ->
+    let strip_cr s =
+      let n = String.length s in
+      if n > 0 && s.[n - 1] = '\r' then String.sub s 0 (n - 1) else s
+    in
+    match args with
+    | [String meth; String url; headers_v; body_v] ->
+      let body = match body_v with
+        | String s -> s
+        | Nil -> ""
+        | v -> Sx_types.value_to_string v in
+      let prefix = "http://" in
+      let plen = String.length prefix in
+      let ulen = String.length url in
+      if ulen < plen || String.sub url 0 plen <> prefix
+      then raise (Eval_error "http-request: URL must start with http://");
+      let rest = String.sub url plen (ulen - plen) in
+      let host_port, path =
+        match String.index_opt rest '/' with
+        | Some i ->
+          String.sub rest 0 i,
+          String.sub rest i (String.length rest - i)
+        | None -> rest, "/" in
+      if host_port = "" then
+        raise (Eval_error "http-request: missing host");
+      let host, port =
+        match String.index_opt host_port ':' with
+        | Some i ->
+          let h = String.sub host_port 0 i in
+          let ps = String.sub host_port (i + 1)
+                     (String.length host_port - i - 1) in
+          (h,
+           (try int_of_string ps with _ ->
+              raise (Eval_error "http-request: bad port")))
+        | None -> host_port, 80 in
+      let addr =
+        (try (Unix.gethostbyname host).h_addr_list.(0)
+         with Not_found ->
+           raise (Eval_error ("http-request: dns: " ^ host))) in
+      let sock = Unix.socket Unix.PF_INET Unix.SOCK_STREAM 0 in
+      let cleanup () = try Unix.close sock with _ -> () in
+      let result =
+        (try
+          (try Unix.connect sock (Unix.ADDR_INET (addr, port))
+           with Unix.Unix_error (e, _, _) ->
+             raise (Eval_error
+                      ("http-request: connect: " ^ Unix.error_message e)));
+          let oc = Unix.out_channel_of_descr sock in
+          let ic = Unix.in_channel_of_descr sock in
+          let buf = Buffer.create 256 in
+          Buffer.add_string buf
+            (Printf.sprintf "%s %s HTTP/1.1\r\n" meth path);
+          let host_hdr_sent = ref false in
+          let clen_sent = ref false in
+          let conn_sent = ref false in
+          (match headers_v with
+           | Dict h ->
+             Hashtbl.iter (fun k v ->
+               let kl = String.lowercase_ascii k in
+               if kl = "host" then host_hdr_sent := true;
+               if kl = "content-length" then clen_sent := true;
+               if kl = "connection" then conn_sent := true;
+               let vs = match v with
+                 | String s -> s
+                 | x -> Sx_types.value_to_string x in
+               Buffer.add_string buf
+                 (Printf.sprintf "%s: %s\r\n" k vs)) h
+           | Nil -> ()
+           | _ -> raise (Eval_error "http-request: headers must be dict"));
+          if not !host_hdr_sent then
+            Buffer.add_string buf
+              (Printf.sprintf "Host: %s\r\n" host_port);
+          if not !clen_sent then
+            Buffer.add_string buf
+              (Printf.sprintf "Content-Length: %d\r\n"
+                 (String.length body));
+          if not !conn_sent then
+            Buffer.add_string buf "Connection: close\r\n";
+          Buffer.add_string buf "\r\n";
+          Buffer.add_string buf body;
+          output_string oc (Buffer.contents buf);
+          flush oc;
+          let sl =
+            (try strip_cr (input_line ic)
+             with End_of_file ->
+               raise (Eval_error
+                        "http-request: connection closed before status")) in
+          let status =
+            match String.split_on_char ' ' sl with
+            | _ver :: code :: _ ->
+              (try int_of_string code with _ ->
+                 raise (Eval_error "http-request: bad status code"))
+            | _ -> raise (Eval_error "http-request: bad status line") in
+          let rhdrs = Sx_types.make_dict () in
+          let clen = ref (-1) in
+          let chunked = ref false in
+          let rec rdh () =
+            let h =
+              (try strip_cr (input_line ic)
+               with End_of_file -> "") in
+            if h = "" then ()
+            else begin
+              (match String.index_opt h ':' with
+               | Some i ->
+                 let name =
+                   String.lowercase_ascii
+                     (String.trim (String.sub h 0 i)) in
+                 let value =
+                   String.trim
+                     (String.sub h (i + 1)
+                        (String.length h - i - 1)) in
+                 Hashtbl.replace rhdrs name (String value);
+                 if name = "content-length" then
+                   (try clen := int_of_string value with _ -> ())
+                 else if name = "transfer-encoding" &&
+                         String.lowercase_ascii value = "chunked"
+                 then chunked := true
+               | None -> ());
+              rdh ()
+            end in
+          rdh ();
+          if !chunked then
+            raise (Eval_error
+                     "http-request: chunked transfer-encoding not supported");
+          let rbody =
+            if !clen >= 0 then begin
+              let b = Bytes.create !clen in
+              really_input ic b 0 !clen;
+              Bytes.unsafe_to_string b
+            end else begin
+              let b = Buffer.create 256 in
+              (try
+                 while true do
+                   Buffer.add_channel b ic 4096
+                 done; assert false
+               with End_of_file -> ());
+              Buffer.contents b
+            end in
+          let resp = Sx_types.make_dict () in
+          Hashtbl.replace resp "status" (Integer status);
+          Hashtbl.replace resp "headers" (Dict rhdrs);
+          Hashtbl.replace resp "body" (String rbody);
+          Dict resp
+        with e -> cleanup (); raise e) in
+      cleanup ();
+      result
+    | _ -> raise (Eval_error "http-request: (method url headers body)"));
+
   bind "trampoline" (fun args ->
     match args with
     | [v] ->

hosts/ocaml/bin/test_http_client.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+# Phase J test — native-only http-request client primitive.
+# Reuses Phase H's http-listen to spin up an echo server, then drives
+# a separate sx_server via the epoch protocol to issue http-request
+# calls and assert response shape + headers + body.
+set -u
+cd "$(dirname "$0")/.."
+
+SRV=_build/default/bin/sx_server.exe
+PORT=${HTTP_CLIENT_TEST_PORT:-8921}
+PASS=0
+FAIL=0
+ok()  { echo "  PASS: $1"; PASS=$((PASS+1)); }
+bad() { echo "  FAIL: $1 — $2"; FAIL=$((FAIL+1)); }
+
+if [ ! -x "$SRV" ]; then
+  echo "build sx_server.exe first (dune build bin/sx_server.exe)"; exit 1
+fi
+
+# /echo echoes method/path/query/body and reflects request X-Custom
+# back as response X-Got; /missing-test → 404.
+H='(begin (define (h req) (if (= (get req "path") "/echo") {:status 200 :headers {"X-Echo" (get req "method") "X-Got" (get (get req "headers") "x-custom")} :body (str "M=" (get req "method") " P=" (get req "path") " Q=" (get req "query") " B=" (get req "body"))} (if (= (get req "path") "/missing-test") {:status 404 :body "nope"} {:status 500 :body "err"}))) (http-listen '"$PORT"' h))'
+ESC=${H//\"/\\\"}
+
+{ printf '(epoch 1)\n(eval "%s")\n' "$ESC"; sleep 60; } | "$SRV" >/tmp/test_http_client_srv.out 2>&1 &
+SVPID=$!
+trap 'kill $SVPID 2>/dev/null; wait 2>/dev/null' EXIT
+
+up=0
+for _ in $(seq 1 50); do
+  curl -s -o /dev/null "http://127.0.0.1:$PORT/echo" 2>/dev/null && { up=1; break; }
+  sleep 0.2
+done
+[ "$up" = 1 ] || { echo "  FAIL: server did not start"; cat /tmp/test_http_client_srv.out; exit 1; }
+
+emit() {
+  # $1 = epoch num, $2 = raw SX form. Wraps in (eval "...") with quotes escaped.
+  local esc=${2//\"/\\\"}
+  printf '(epoch %s)\n(eval "%s")\n' "$1" "$esc"
+}
+
+DRV_OUT=/tmp/test_http_client_drv.out
+{
+  emit 1 '(let ((r (http-request "GET" "http://127.0.0.1:'"$PORT"'/echo?x=1" {} ""))) (str "S=" (get r "status") " E=" (get (get r "headers") "x-echo") " B=" (get r "body")))'
+  emit 2 '(let ((r (http-request "POST" "http://127.0.0.1:'"$PORT"'/echo" {} "hello"))) (str "S=" (get r "status") " B=" (get r "body")))'
+  emit 3 '(let ((r (http-request "GET" "http://127.0.0.1:'"$PORT"'/missing-test" {} ""))) (str "S=" (get r "status") " B=" (get r "body")))'
+  emit 4 '(let ((r (http-request "GET" "http://127.0.0.1:'"$PORT"'/echo" {"X-Custom" "myval"} ""))) (get (get r "headers") "x-got"))'
+  emit 5 '(http-request "GET" "ftp://nope" {} "")'
+  emit 6 '(let ((r (http-request "GET" "http://127.0.0.1:'"$PORT"'/echo" {} ""))) (get r "status"))'
+} | "$SRV" >"$DRV_OUT" 2>&1
+
+# eval results come back as (ok-len N L)\n<body>\n — grep the body content.
+grep -q '^"S=200 E=GET B=M=GET P=/echo Q=x=1 B="$' "$DRV_OUT" \
+  && ok "GET status + echo header + body" \
+  || bad "GET" "$(grep -A1 '^(ok-len 1 ' "$DRV_OUT" | tail -1)"
+
+grep -q '^"S=200 B=M=POST P=/echo Q= B=hello"$' "$DRV_OUT" \
+  && ok "POST body roundtrip" \
+  || bad "POST" "$(grep -A1 '^(ok-len 2 ' "$DRV_OUT" | tail -1)"
+
+grep -q '^"S=404 B=nope"$' "$DRV_OUT" \
+  && ok "404 status + body" \
+  || bad "404" "$(grep -A1 '^(ok-len 3 ' "$DRV_OUT" | tail -1)"
+
+grep -q '^"myval"$' "$DRV_OUT" \
+  && ok "custom request header reaches server" \
+  || bad "custom-header" "$(grep -A1 '^(ok-len 4 ' "$DRV_OUT" | tail -1)"
+
+R5=$(grep '^(error 5 ' "$DRV_OUT" | head -1)
+echo "$R5" | grep -q 'URL must start with http' \
+  && ok "non-http scheme rejected" \
+  || bad "bad-url" "$R5"
+
+# Status is an Integer (200), serialized bare without quotes.
+grep -q '^200$' "$DRV_OUT" \
+  && ok "response status is integer 200" \
+  || bad "status-integer" "$(grep -A1 '^(ok-len 6 ' "$DRV_OUT" | tail -1)"
+
+echo "Results: $PASS passed, $FAIL failed"
+[ "$FAIL" = 0 ]

hosts/ocaml/lib/extensions/erlang_ext.ml

@@ -1,278 +0,0 @@
-(** {1 [erlang_ext] — Erlang-on-SX VM opcode extension (Phase 9h)}
-
-    Registers the Erlang opcode namespace in [Sx_vm_extensions] so that
-    [extension-opcode-id "erlang.OP_*"] resolves to a stable id. The SX
-    stub dispatcher in [lib/erlang/vm/dispatcher.sx] consults these ids
-    (Phase 9i) and falls back to its own local ids when the host
-    extension is absent.
-
-    Opcode ids occupy 222-239 in the extension partition (200-247).
-    222+ is chosen to clear the test extensions' reserved ids
-    (test_reg 210/211, test_ext 220/221) so all three coexist in
-    run_tests; production sx_server only registers this one. Names
-    mirror the SX stub dispatcher exactly:
-
-    - 222 erlang.OP_PATTERN_TUPLE      - 231 erlang.OP_BIF_HD
-    - 223 erlang.OP_PATTERN_LIST       - 232 erlang.OP_BIF_TL
-    - 224 erlang.OP_PATTERN_BINARY     - 233 erlang.OP_BIF_ELEMENT
-    - 225 erlang.OP_PERFORM            - 234 erlang.OP_BIF_TUPLE_SIZE
-    - 226 erlang.OP_HANDLE             - 235 erlang.OP_BIF_LISTS_REVERSE
-    - 227 erlang.OP_RECEIVE_SCAN       - 236 erlang.OP_BIF_IS_INTEGER
-    - 228 erlang.OP_SPAWN              - 237 erlang.OP_BIF_IS_ATOM
-    - 229 erlang.OP_SEND               - 238 erlang.OP_BIF_IS_LIST
-    - 230 erlang.OP_BIF_LENGTH         - 239 erlang.OP_BIF_IS_TUPLE
-
-    {2 Handler status}
-
-    The bytecode compiler does not yet emit these opcodes — Erlang
-    programs run through the general CEK path and the working
-    specialization path is the SX stub dispatcher. So every handler
-    here raises a descriptive [Eval_error] rather than silently
-    corrupting the VM stack. This keeps the extension honest: the
-    namespace is registered and disassembles by name, [extension-opcode-id]
-    works, but actually dispatching an opcode (which only happens once a
-    future phase teaches the compiler to emit them) fails loudly with a
-    pointer to the phase that will wire it. Real stack-machine handlers
-    land alongside compiler emission in a later phase. *)
-
-open Sx_types
-
-(** Per-instance state: invocation counter, purely to exercise the
-    [extension_state] machinery (mirrors [test_ext]). *)
-type Sx_vm_extension.extension_state += ErlangExtState of {
-  mutable dispatched : int;
-}
-
-let not_wired name =
-  raise (Eval_error
-    (Printf.sprintf
-       "%s: bytecode emission not yet wired (Phase 9j) — \
-        Erlang runs via CEK; specialization path is the SX stub \
-        dispatcher in lib/erlang/vm/dispatcher.sx"
-       name))
-
-module M : Sx_vm_extension.EXTENSION = struct
-  let name = "erlang"
-  let init () = ErlangExtState { dispatched = 0 }
-
-  let opcodes st =
-    let bump () = match st with
-      | ErlangExtState s -> s.dispatched <- s.dispatched + 1
-      | _ -> ()
-    in
-    let op id nm =
-      (id, nm, (fun (_vm : Sx_vm.vm) (_frame : Sx_vm.frame) ->
-        bump (); not_wired nm))
-    in
-    (* Phase 10b vertical slice: one REAL register-machine handler.
-       erlang.OP_BIF_LENGTH (230) — pops an Erlang list off the VM
-       stack and pushes its length. Proves the full path works:
-       extension-opcode-id -> bytecode -> Sx_vm dispatch fallthrough
-       -> this handler -> correct stack result. The remaining 17
-       opcodes still raise not_wired until their handlers + compiler
-       emission land. Erlang lists are tagged dicts:
-         nil  = {"tag" -> String "nil"}
-         cons = {"tag" -> String "cons"; "head" -> v; "tail" -> v} *)
-    let er_tag d =
-      match Hashtbl.find_opt d "tag" with
-      | Some (String s) -> s | _ -> ""
-    in
-    let op_bif_length =
-      (230, "erlang.OP_BIF_LENGTH",
-       (fun (vm : Sx_vm.vm) (_frame : Sx_vm.frame) ->
-         bump ();
-         let v = Sx_vm.pop vm in
-         let rec walk acc node =
-           match node with
-           | Dict d ->
-             (match er_tag d with
-              | "nil" -> acc
-              | "cons" ->
-                (match Hashtbl.find_opt d "tail" with
-                 | Some t -> walk (acc + 1) t
-                 | None -> raise (Eval_error
-                     "erlang.OP_BIF_LENGTH: cons cell without :tail"))
-              | _ -> raise (Eval_error
-                  "erlang.OP_BIF_LENGTH: not a proper list"))
-           | _ -> raise (Eval_error
-               "erlang.OP_BIF_LENGTH: not a proper list")
-         in
-         Sx_vm.push vm (Integer (walk 0 v))))
-    in
-    (* Phase 10b — simple hot-BIF handlers. Erlang bool is the atom
-       {"tag"->"atom"; "name"->"true"|"false"}; mk_atom builds it. *)
-    let mk_atom nm =
-      let h = Hashtbl.create 2 in
-      Hashtbl.replace h "tag" (String "atom");
-      Hashtbl.replace h "name" (String nm);
-      Dict h
-    in
-    let er_bool b = mk_atom (if b then "true" else "false") in
-    let is_tag v t = match v with
-      | Dict d -> er_tag d = t
-      | _ -> false
-    in
-    let op_bif_hd =
-      (231, "erlang.OP_BIF_HD",
-       (fun (vm : Sx_vm.vm) _f ->
-         bump ();
-         match Sx_vm.pop vm with
-         | Dict d when er_tag d = "cons" ->
-           (match Hashtbl.find_opt d "head" with
-            | Some h -> Sx_vm.push vm h
-            | None -> raise (Eval_error "erlang.OP_BIF_HD: cons without :head"))
-         | _ -> raise (Eval_error "erlang.OP_BIF_HD: not a cons")))
-    in
-    let op_bif_tl =
-      (232, "erlang.OP_BIF_TL",
-       (fun (vm : Sx_vm.vm) _f ->
-         bump ();
-         match Sx_vm.pop vm with
-         | Dict d when er_tag d = "cons" ->
-           (match Hashtbl.find_opt d "tail" with
-            | Some t -> Sx_vm.push vm t
-            | None -> raise (Eval_error "erlang.OP_BIF_TL: cons without :tail"))
-         | _ -> raise (Eval_error "erlang.OP_BIF_TL: not a cons")))
-    in
-    let op_bif_tuple_size =
-      (234, "erlang.OP_BIF_TUPLE_SIZE",
-       (fun (vm : Sx_vm.vm) _f ->
-         bump ();
-         match Sx_vm.pop vm with
-         | Dict d when er_tag d = "tuple" ->
-           let n = match Hashtbl.find_opt d "elements" with
-             | Some (List es) -> List.length es
-             | Some (ListRef r) -> List.length !r
-             | _ -> raise (Eval_error
-                 "erlang.OP_BIF_TUPLE_SIZE: tuple without :elements")
-           in
-           Sx_vm.push vm (Integer n)
-         | _ -> raise (Eval_error "erlang.OP_BIF_TUPLE_SIZE: not a tuple")))
-    in
-    let op_bif_is_integer =
-      (236, "erlang.OP_BIF_IS_INTEGER",
-       (fun (vm : Sx_vm.vm) _f ->
-         bump ();
-         let v = Sx_vm.pop vm in
-         Sx_vm.push vm (er_bool (match v with Integer _ -> true | _ -> false))))
-    in
-    let op_bif_is_atom =
-      (237, "erlang.OP_BIF_IS_ATOM",
-       (fun (vm : Sx_vm.vm) _f ->
-         bump ();
-         let v = Sx_vm.pop vm in
-         Sx_vm.push vm (er_bool (is_tag v "atom"))))
-    in
-    let op_bif_is_list =
-      (238, "erlang.OP_BIF_IS_LIST",
-       (fun (vm : Sx_vm.vm) _f ->
-         bump ();
-         let v = Sx_vm.pop vm in
-         Sx_vm.push vm (er_bool (is_tag v "cons" || is_tag v "nil"))))
-    in
-    let op_bif_is_tuple =
-      (239, "erlang.OP_BIF_IS_TUPLE",
-       (fun (vm : Sx_vm.vm) _f ->
-         bump ();
-         let v = Sx_vm.pop vm in
-         Sx_vm.push vm (er_bool (is_tag v "tuple"))))
-    in
-    (* element/2 and lists:reverse/1 — pure stack transforms (no
-       bytecode operands). Calling convention: args pushed left→right,
-       so element/2 stack is [.. Index Tuple] (Tuple on top). Erlang
-       element/2 is 1-indexed. *)
-    let op_bif_element =
-      (233, "erlang.OP_BIF_ELEMENT",
-       (fun (vm : Sx_vm.vm) _f ->
-         bump ();
-         let tup = Sx_vm.pop vm in
-         let idx = Sx_vm.pop vm in
-         match tup, idx with
-         | Dict d, Integer i when er_tag d = "tuple" ->
-           let es = match Hashtbl.find_opt d "elements" with
-             | Some (List es) -> es
-             | Some (ListRef r) -> !r
-             | _ -> raise (Eval_error
-                 "erlang.OP_BIF_ELEMENT: tuple without :elements")
-           in
-           let n = List.length es in
-           if i < 1 || i > n then
-             raise (Eval_error
-               (Printf.sprintf
-                  "erlang.OP_BIF_ELEMENT: index %d out of range 1..%d" i n))
-           else
-             Sx_vm.push vm (List.nth es (i - 1))
-         | _, Integer _ ->
-           raise (Eval_error "erlang.OP_BIF_ELEMENT: 2nd arg not a tuple")
-         | _ ->
-           raise (Eval_error "erlang.OP_BIF_ELEMENT: 1st arg not an integer")))
-    in
-    let op_bif_lists_reverse =
-      (235, "erlang.OP_BIF_LISTS_REVERSE",
-       (fun (vm : Sx_vm.vm) _f ->
-         bump ();
-         let v = Sx_vm.pop vm in
-         let mk_nil () =
-           let h = Hashtbl.create 1 in
-           Hashtbl.replace h "tag" (String "nil"); Dict h in
-         let mk_cons hd tl =
-           let h = Hashtbl.create 3 in
-           Hashtbl.replace h "tag" (String "cons");
-           Hashtbl.replace h "head" hd;
-           Hashtbl.replace h "tail" tl;
-           Dict h in
-         let rec rev acc node =
-           match node with
-           | Dict d ->
-             (match er_tag d with
-              | "nil" -> acc
-              | "cons" ->
-                let hd = match Hashtbl.find_opt d "head" with
-                  | Some x -> x
-                  | None -> raise (Eval_error
-                      "erlang.OP_BIF_LISTS_REVERSE: cons without :head") in
-                let tl = match Hashtbl.find_opt d "tail" with
-                  | Some x -> x
-                  | None -> raise (Eval_error
-                      "erlang.OP_BIF_LISTS_REVERSE: cons without :tail") in
-                rev (mk_cons hd acc) tl
-              | _ -> raise (Eval_error
-                  "erlang.OP_BIF_LISTS_REVERSE: not a proper list"))
-           | _ -> raise (Eval_error
-               "erlang.OP_BIF_LISTS_REVERSE: not a proper list")
-         in
-         Sx_vm.push vm (rev (mk_nil ()) v)))
-    in
-    [
-      op 222 "erlang.OP_PATTERN_TUPLE";
-      op 223 "erlang.OP_PATTERN_LIST";
-      op 224 "erlang.OP_PATTERN_BINARY";
-      op 225 "erlang.OP_PERFORM";
-      op 226 "erlang.OP_HANDLE";
-      op 227 "erlang.OP_RECEIVE_SCAN";
-      op 228 "erlang.OP_SPAWN";
-      op 229 "erlang.OP_SEND";
-      op_bif_length;
-      op_bif_hd;
-      op_bif_tl;
-      op_bif_element;
-      op_bif_tuple_size;
-      op_bif_lists_reverse;
-      op_bif_is_integer;
-      op_bif_is_atom;
-      op_bif_is_list;
-      op_bif_is_tuple;
-    ]
-end
-
-(** Register [erlang] in [Sx_vm_extensions]. Idempotent only by failing
-    loudly — calling twice raises [Failure]. sx_server calls this once
-    at startup. *)
-let register () = Sx_vm_extensions.register (module M : Sx_vm_extension.EXTENSION)
-
-(** Read the dispatch counter from the live registry state. [None] if
-    [register] hasn't run. *)
-let dispatch_count () =
-  match Sx_vm_extensions.state_of_extension "erlang" with
-  | Some (ErlangExtState s) -> Some s.dispatched
-  | _ -> None

lib/acl/api.sx

@@ -1,45 +0,0 @@
-;; lib/acl/api.sx — public ACL surface over an implicit current db.
-;;
-;; Callers load a fact set once, then issue decisions without threading the db
-;; through every call. The current db is module state; (acl/load! facts) rebuilds
-;; it. This is the boundary the rest of rose-ash imports.
-
-(define acl-current-db nil)
-
-;; Replace the current fact base. Rebuilds the Datalog db under the active
-;; ruleset (see lib/acl/engine.sx).
-(define
-  acl/load!
-  (fn
-    (facts)
-    (do (set! acl-current-db (acl-build-db facts)) acl-current-db)))
-
-;; Ensure a db exists, building an empty one on first use.
-(define
-  acl-ensure-db!
-  (fn
-    ()
-    (do
-      (when
-        (= acl-current-db nil)
-        (set! acl-current-db (acl-build-db (list))))
-      acl-current-db)))
-
-;; Public decision against the current db (pure, no logging).
-(define
-  acl/permit?
-  (fn (subj act res) (acl-permit? (acl-ensure-db!) subj act res)))
-
-;; Decision-with-proof against the current db. See lib/acl/explain.sx.
-(define
-  acl/explain
-  (fn (subj act res) (acl-explain (acl-ensure-db!) subj act res)))
-
-;; Audited decision: logs the outcome to the append-only audit log and returns
-;; the boolean. See lib/acl/audit.sx.
-(define
-  acl/audit
-  (fn (subj act res) (acl-audit-decide! (acl-ensure-db!) subj act res)))
-
-;; Recent audited decisions (chronological).
-(define acl/audit-tail (fn (n) (acl-audit-tail n)))

lib/acl/audit.sx

@@ -1,110 +0,0 @@
-;; lib/acl/audit.sx — append-only decision log.
-;;
-;; Every decision routed through acl-audit-decide! is appended to an in-memory
-;; log with a monotonic sequence number (no wall-clock — deterministic and
-;; testable; a host can stamp time at the serializer boundary). The log is
-;; append-only: there is no mutate or delete, only append, tail, clear,
-;; snapshot/restore, and serialize-for-disk.
-
-(define acl-audit-log (list))
-(define acl-audit-seq 0)
-
-;; Copy a list into a fresh, append!-able list. `map`/`rest`-derived lists are
-;; NOT extensible by append! in this runtime (it silently no-ops), so the live
-;; log must always be a list built with `list` + `append!`.
-(define
-  acl-audit-copy
-  (fn
-    (xs)
-    (let
-      ((fresh (list)))
-      (do (for-each (fn (e) (append! fresh e)) xs) fresh))))
-
-(define
-  acl-audit-clear!
-  (fn
-    ()
-    (do (set! acl-audit-log (list)) (set! acl-audit-seq 0) nil)))
-
-;; Append a decision record. Returns the record.
-(define
-  acl-audit-record!
-  (fn
-    (subj act res allowed?)
-    (let
-      ((entry {:allowed? allowed? :act act :subj subj :res res :seq acl-audit-seq}))
-      (do
-        (set! acl-audit-seq (+ acl-audit-seq 1))
-        (append! acl-audit-log entry)
-        entry))))
-
-;; Decide against db, log the outcome, and return the boolean. This is the
-;; audited path; acl-permit? remains the pure, side-effect-free decision.
-(define
-  acl-audit-decide!
-  (fn
-    (db subj act res)
-    (let
-      ((allowed? (acl-permit? db subj act res)))
-      (do (acl-audit-record! subj act res allowed?) allowed?))))
-
-(define acl-audit-count (fn () (len acl-audit-log)))
-
-;; Most recent n entries (in chronological order). n >= log size returns all.
-(define
-  acl-audit-tail
-  (fn
-    (n)
-    (let
-      ((total (len acl-audit-log)))
-      (if
-        (<= total n)
-        acl-audit-log
-        (acl-audit-drop acl-audit-log (- total n))))))
-
-(define
-  acl-audit-drop
-  (fn
-    (xs k)
-    (if (<= k 0) xs (acl-audit-drop (rest xs) (- k 1)))))
-
-;; Structured snapshot for save/restore — a {:seq :entries} value carrying a
-;; copy of the log (so later appends don't mutate a held snapshot).
-(define acl-audit-snapshot (fn () {:seq acl-audit-seq :entries (acl-audit-copy acl-audit-log)}))
-
-;; Replace the live log from a snapshot. Restores both entries and the seq
-;; counter so subsequent records continue numbering correctly. The log is
-;; rebuilt as a fresh append!-able list (see acl-audit-copy).
-(define
-  acl-audit-restore!
-  (fn
-    (snap)
-    (do
-      (set! acl-audit-log (acl-audit-copy (get snap :entries)))
-      (set! acl-audit-seq (get snap :seq))
-      nil)))
-
-;; Serialize the whole log to a disk-ready string: one record per line,
-;; "seq\tsubj\tact\tres\tallowed?". A host writes this; structured reload is via
-;; snapshot/restore.
-(define
-  acl-audit-serialize
-  (fn
-    ()
-    (reduce
-      (fn
-        (acc e)
-        (str
-          acc
-          (get e :seq)
-          "\t"
-          (get e :subj)
-          "\t"
-          (get e :act)
-          "\t"
-          (get e :res)
-          "\t"
-          (get e :allowed?)
-          "\n"))
-      ""
-      acl-audit-log)))

lib/acl/conformance.conf

@@ -1,32 +0,0 @@
-# ACL conformance config — sourced by lib/guest/conformance.sh.
-
-LANG_NAME=acl
-MODE=dict
-
-PRELOADS=(
-  lib/datalog/tokenizer.sx
-  lib/datalog/parser.sx
-  lib/datalog/unify.sx
-  lib/datalog/db.sx
-  lib/datalog/builtins.sx
-  lib/datalog/aggregates.sx
-  lib/datalog/strata.sx
-  lib/datalog/eval.sx
-  lib/datalog/api.sx
-  lib/datalog/magic.sx
-  lib/acl/schema.sx
-  lib/acl/facts.sx
-  lib/acl/engine.sx
-  lib/acl/explain.sx
-  lib/acl/audit.sx
-  lib/acl/federation.sx
-  lib/acl/api.sx
-)
-
-SUITES=(
-  "direct:lib/acl/tests/direct.sx:(acl-direct-tests-run!)"
-  "inherit:lib/acl/tests/inherit.sx:(acl-inherit-tests-run!)"
-  "explain:lib/acl/tests/explain.sx:(acl-explain-tests-run!)"
-  "fed:lib/acl/tests/fed.sx:(acl-fed-tests-run!)"
-  "harden:lib/acl/tests/harden.sx:(acl-harden-tests-run!)"
-)

lib/acl/conformance.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-# Thin wrapper — see lib/guest/conformance.sh and lib/acl/conformance.conf.
-exec bash "$(dirname "$0")/../guest/conformance.sh" "$(dirname "$0")/conformance.conf" "$@"

lib/acl/engine.sx

@@ -1,72 +0,0 @@
-;; lib/acl/engine.sx — ACL ruleset + decision reducer over lib/datalog/.
-;;
-;; The engine is a thin layer: it owns the permit ruleset (SX data rules) and
-;; reduces a (subject, action, resource) decision to a Datalog query against a
-;; db built from EDB facts. The rule engine itself is Datalog's.
-;;
-;; Policy — inheritance + federation with deny-overrides:
-;;
-;;   eff_grant(S,A,R) :- grant(S,A,R).                         ; direct
-;;   eff_grant(S,A,R) :- member_of(S,G), eff_grant(G,A,R).     ; group/role chain
-;;   eff_grant(S,A,R) :- child_of(R,P), eff_grant(S,A,P).      ; resource tree
-;;   eff_grant(S,A,R) :- member_of(S,Role), role_grant(Role,A,R). ; role expansion
-;;   eff_grant(S,A,R) :- delegate(Peer,S,A,R),                 ; federated grant
-;;                       trust(Peer,L), level_covers(L,A).
-;;
-;;   eff_deny(S,A,R)  :- deny(S,A,R).                          ; direct
-;;   eff_deny(S,A,R)  :- member_of(S,G), eff_deny(G,A,R).      ; group chain
-;;   eff_deny(S,A,R)  :- child_of(R,P), eff_deny(S,A,P).       ; resource tree
-;;
-;;   permit(S,A,R)    :- eff_grant(S,A,R), not eff_deny(S,A,R).
-;;
-;; DENY-OVERRIDES: an effective deny anywhere in the inheritance closure of
-;; (S,A,R) defeats any effective grant — including federated grants. Deny
-;; inherits through the *same* group and resource chains as grant, so a
-;; group-level or ancestor-resource deny is authoritative for members/
-;; descendants. This is the principled, fail-safe reading of "deny wins".
-;;
-;; FEDERATION — non-transitive trust: a peer's `delegate` fact only grants if a
-;; *local* `trust(Peer, L)` exists AND that level `level_covers` the action.
-;; Trust is re-checked on every query (it is a body literal), never baked in at
-;; fact-ingestion time, so revoking trust or narrowing a level takes effect
-;; immediately on the next decision.
-;;
-;; Termination & stratification:
-;;   - eff_grant/eff_deny recurse only over member_of and child_of, which are
-;;     EDB relations with no function symbols, so the closure is finite (cyclic
-;;     membership/containment just reaches a fixpoint, never loops). The
-;;     federation rule is non-recursive.
-;;   - permit negates eff_deny; neither eff_grant nor eff_deny depends on
-;;     permit, so the program is stratifiable (permit sits in a higher stratum).
-
-(define
-  acl-rules
-  (quote
-    ((eff_grant S A R <- (grant S A R))
-      (eff_grant S A R <- (member_of S G) (eff_grant G A R))
-      (eff_grant S A R <- (child_of R P) (eff_grant S A P))
-      (eff_grant S A R <- (member_of S Role) (role_grant Role A R))
-      (eff_grant
-        S
-        A
-        R
-        <-
-        (delegate Peer S A R)
-        (trust Peer L)
-        (level_covers L A))
-      (eff_deny S A R <- (deny S A R))
-      (eff_deny S A R <- (member_of S G) (eff_deny G A R))
-      (eff_deny S A R <- (child_of R P) (eff_deny S A P))
-      (permit S A R <- (eff_grant S A R) {:neg (eff_deny S A R)}))))
-
-;; Build a Datalog db from a list of EDB facts under the ACL ruleset.
-(define acl-build-db (fn (facts) (dl-program-data facts acl-rules)))
-
-;; Core decision: does the db permit subject S to perform action A on
-;; resource R? Reduces to a ground Datalog query on the derived `permit`
-;; relation — non-empty result means permitted.
-(define
-  acl-permit?
-  (fn
-    (db subj act res)
-    (> (len (dl-query db (list (quote permit) subj act res))) 0)))

lib/acl/explain.sx

@@ -1,125 +0,0 @@
-;; lib/acl/explain.sx — proof-tree reconstruction over the saturated db.
-;;
-;; lib/datalog/ records derived facts but not their provenance, so the proof is
-;; reconstructed here by goal-directed search over the *saturated* db: for a
-;; ground goal we find the first ACL rule (in rule order) whose body holds, take
-;; the first solution binding its remaining variables, and recurse on each body
-;; literal. Negated literals are recorded as verified `:neg-ok` leaves.
-;;
-;; CANONICAL DERIVATION: the Datalog derivation graph is a DAG (a fact may hold
-;; many ways). We pick ONE canonical proof — first matching rule, first solution
-;; — matching the rule order in lib/acl/engine.sx (direct/EDB rules first). A
-;; depth cap guards against pathological cyclic data producing unbounded search.
-;;
-;; A proof node is one of:
-;;   {:fact <lit> :via "edb"}                       — base EDB fact
-;;   {:fact <lit> :rule <head> :body (<node|negleaf> ...)}  — derived
-;;   {:neg-ok <lit>}                                — negation verified to fail
-;;   {:fact <lit> :truncated true}                  — depth cap hit
-
-(define acl-proof-max-depth 64)
-
-;; Substitute a body literal, descending into {:neg ...} dicts (dl-apply-subst
-;; does not recurse into dicts, which would leak the neg's free vars).
-(define
-  acl-subst-lit
-  (fn
-    (lit s)
-    (if
-      (and (dict? lit) (has-key? lit :neg))
-      {:neg (dl-apply-subst (get lit :neg) s)}
-      (dl-apply-subst lit s))))
-
-(define
-  acl-lit-edb?
-  (fn
-    (lit)
-    (and
-      (list? lit)
-      (> (len lit) 0)
-      (symbol? (first lit))
-      (has-key? acl-edb-arity (symbol->string (first lit))))))
-
-(define
-  acl-subst-zip!
-  (fn
-    (d ks vs)
-    (when
-      (> (len ks) 0)
-      (do
-        (dict-set! d (symbol->string (first ks)) (first vs))
-        (acl-subst-zip! d (rest ks) (rest vs))))))
-
-;; Bind a rule head's variables to a ground goal's arguments (positional).
-(define
-  acl-bind-head
-  (fn
-    (head goal)
-    (let
-      ((d {}))
-      (do (acl-subst-zip! d (rest head) (rest goal)) d))))
-
-(define
-  acl-subst-union
-  (fn
-    (a b)
-    (let
-      ((d {}))
-      (do
-        (for-each (fn (k) (dict-set! d k (get a k))) (keys a))
-        (for-each (fn (k) (dict-set! d k (get b k))) (keys b))
-        d))))
-
-(define acl-prove (fn (db goal) (acl-prove-d db goal 0)))
-
-(define
-  acl-prove-d
-  (fn
-    (db goal depth)
-    (cond
-      ((> depth acl-proof-max-depth) {:truncated true :fact goal})
-      ((acl-lit-edb? goal)
-        (if (> (len (dl-query db goal)) 0) {:via "edb" :fact goal} nil))
-      (else (acl-prove-rules db goal acl-rules depth)))))
-
-(define
-  acl-prove-rules
-  (fn
-    (db goal rules depth)
-    (if
-      (= (len rules) 0)
-      nil
-      (let
-        ((p (dl-rule-from-list (first rules))))
-        (if
-          (= (first (get p :head)) (first goal))
-          (let
-            ((hs (acl-bind-head (get p :head) goal)))
-            (let
-              ((qbody (map (fn (l) (acl-subst-lit l hs)) (get p :body))))
-              (let
-                ((sols (dl-query db qbody)))
-                (if
-                  (> (len sols) 0)
-                  (acl-prove-build db goal p hs (first sols) depth)
-                  (acl-prove-rules db goal (rest rules) depth)))))
-          (acl-prove-rules db goal (rest rules) depth))))))
-
-(define
-  acl-prove-build
-  (fn
-    (db goal p hs sol depth)
-    (let ((full (acl-subst-union hs sol))) {:body (map (fn (l) (let ((g (acl-subst-lit l full))) (if (and (dict? g) (has-key? g :neg)) {:neg-ok (get g :neg)} (acl-prove-d db g (+ depth 1))))) (get p :body)) :rule (get p :head) :fact goal})))
-
-;; Public decision-with-proof. Returns:
-;;   {:allowed? <bool> :proof <node|nil> :reason <eff_deny proof|nil>}
-;; When permitted, :proof is the permit derivation. When denied, :proof is nil
-;; and :reason carries the blocking eff_deny proof if one exists (an explicit or
-;; inherited deny), else nil (simply no grant).
-(define
-  acl-explain
-  (fn
-    (db subj act res)
-    (let
-      ((proof (acl-prove db (list (quote permit) subj act res))))
-      (if (= proof nil) {:allowed? false :proof nil :reason (acl-prove db (list (quote eff_deny) subj act res))} {:allowed? true :proof proof :reason nil}))))

lib/acl/facts.sx

@@ -1,47 +0,0 @@
-;; lib/acl/facts.sx — EDB fact constructors.
-;;
-;; Each constructor returns a Datalog fact tuple (a list whose head is the
-;; predicate symbol). These are the only shapes lib/acl/engine.sx feeds to
-;; lib/datalog/.
-;;   Phase 1: actor/resource/grant/deny.
-;;   Phase 2: member_of (subject -> group/role), child_of (resource -> parent),
-;;            role_grant (role -> action,resource capability).
-;;   Phase 4: peer/trust/delegate/level_covers (federation).
-
-(define acl-actor (fn (id kind) (list (quote actor) id kind)))
-
-(define acl-resource-fact (fn (id kind) (list (quote resource) id kind)))
-
-(define acl-grant (fn (subj act res) (list (quote grant) subj act res)))
-
-(define acl-deny (fn (subj act res) (list (quote deny) subj act res)))
-
-;; subject S is a member of group/role G (one hop; transitivity is derived).
-(define acl-member-of (fn (subj grp) (list (quote member_of) subj grp)))
-
-;; resource R is a child of parent P (one hop; transitivity is derived).
-(define acl-child-of (fn (res parent) (list (quote child_of) res parent)))
-
-;; role confers capability (act on res) to every member of the role.
-(define
-  acl-role-grant
-  (fn (role act res) (list (quote role_grant) role act res)))
-
-;; --- federation ---
-
-;; a known peer instance at addr, of some kind (e.g. peer).
-(define acl-peer (fn (addr kind) (list (quote peer) addr kind)))
-
-;; local trust in a peer at a named level. Gates delegated grants at query time.
-(define acl-trust (fn (peer level) (list (quote trust) peer level)))
-
-;; a peer asserts that subject S may A on R. Only takes effect if local trust in
-;; that peer covers action A (see level_covers).
-(define
-  acl-delegate
-  (fn (peer subj act res) (list (quote delegate) peer subj act res)))
-
-;; local policy: trust `level` authorises delegated grants for action `act`.
-(define
-  acl-level-covers
-  (fn (level act) (list (quote level_covers) level act)))

lib/acl/federation.sx

@@ -1,61 +0,0 @@
-;; lib/acl/federation.sx — cross-instance ACL facts + revocation.
-;;
-;; fed-sx replicates ACL facts between instances; this module models the local
-;; side. A peer's authority arrives as `delegate(Peer, S, A, R)` facts, which
-;; only take effect when a local `trust(Peer, L)` and `level_covers(L, A)`
-;; authorise them (enforced by the engine rule, re-checked every query). The
-;; actual network transport is fed-sx's job and is mocked in tests as a dict.
-;;
-;; Trust is NOT transitive: trusting peer α does not extend to peers α trusts.
-;; Only delegate facts that α itself asserts, and that local trust covers, flow.
-
-;; Mock fed-sx pull: `transport` is a dict mapping a peer address (its string
-;; name) to the list of delegate facts that peer asserts. Returns the facts for
-;; `addr`, or an empty list if the peer is unknown / unreachable.
-(define
-  acl-fed-fetch
-  (fn
-    (transport addr)
-    (let
-      ((k (if (symbol? addr) (symbol->string addr) addr)))
-      (if (has-key? transport k) (get transport k) (list)))))
-
-;; Gather delegate facts from every peer in `addrs` via the transport.
-(define
-  acl-fed-collect
-  (fn
-    (transport addrs)
-    (let
-      ((acc (list)))
-      (do
-        (for-each
-          (fn
-            (addr)
-            (for-each
-              (fn (f) (append! acc f))
-              (acl-fed-fetch transport addr)))
-          addrs)
-        acc))))
-
-;; Build a db from local facts plus delegate facts pulled from `peers`. Local
-;; facts must include the `trust`/`level_covers` policy; replicated delegate
-;; facts are gated against it by the engine rule at query time.
-(define
-  acl-fed-build-db
-  (fn
-    (local-facts transport peers)
-    (let
-      ((all (list)))
-      (do
-        (for-each (fn (f) (append! all f)) local-facts)
-        (for-each
-          (fn (f) (append! all f))
-          (acl-fed-collect transport peers))
-        (acl-build-db all)))))
-
-;; Propagated revocation: retract a replicated fact (e.g. a peer's delegate, or
-;; local trust) from a live db. The next decision re-saturates and reflects it.
-(define acl-revoke! (fn (db fact) (do (dl-retract! db fact) db)))
-
-;; Propagated assertion: ingest a newly replicated fact into a live db.
-(define acl-fed-assert! (fn (db fact) (do (dl-assert! db fact) db)))

lib/acl/schema.sx

@@ -1,71 +0,0 @@
-;; lib/acl/schema.sx — ACL sorts and EDB predicate vocabulary.
-;;
-;; Datalog is untyped; this module is the schema-as-data layer. It declares
-;; the subject/resource/action sorts and the arity of every EDB predicate the
-;; ACL engine recognises, plus light validators. Facts that pass these checks
-;; are well-formed inputs to lib/acl/engine.sx.
-
-(define acl-subject-kinds (quote (user group role service)))
-(define acl-resource-kinds (quote (page post thread peer)))
-
-;; Actions are open-ended (a grant may name any action symbol), but these are
-;; the platform's well-known verbs.
-(define acl-actions (quote (read edit comment moderate federate)))
-
-;; EDB predicate name -> arity.
-;;   Phase 1: actor/resource/grant/deny.
-;;   Phase 2: member_of (subject->group/role), child_of (resource->parent),
-;;            role_grant (role->action,resource).
-;;   Phase 4: peer (addr->kind), trust (peer->level),
-;;            delegate (peer->subj,action,resource), level_covers (level->action).
-(define acl-edb-arity {:role_grant 3 :child_of 2 :trust 2 :peer 2 :actor 2 :level_covers 2 :delegate 4 :member_of 2 :deny 3 :grant 3 :resource 2})
-
-(define
-  acl-member?
-  (fn
-    (x xs)
-    (cond
-      ((= (len xs) 0) false)
-      ((= (first xs) x) true)
-      (else (acl-member? x (rest xs))))))
-
-(define acl-subject-kind? (fn (k) (acl-member? k acl-subject-kinds)))
-
-(define acl-resource-kind? (fn (k) (acl-member? k acl-resource-kinds)))
-
-(define acl-known-action? (fn (a) (acl-member? a acl-actions)))
-
-;; A fact is a list whose head is a predicate symbol. Valid when the predicate
-;; is known and the argument count matches the declared arity.
-(define
-  acl-fact-valid?
-  (fn
-    (f)
-    (and
-      (list? f)
-      (> (len f) 0)
-      (symbol? (first f))
-      (let
-        ((pred (symbol->string (first f))))
-        (and
-          (has-key? acl-edb-arity pred)
-          (= (- (len f) 1) (get acl-edb-arity pred)))))))
-
-;; Return the sublist of facts that fail acl-fact-valid?. Empty list means the
-;; whole set is well-formed. acl-build-db stays lenient (Datalog accepts any
-;; tuple, and custom action symbols are allowed); callers opt in to checking.
-(define
-  acl-validate-facts
-  (fn
-    (facts)
-    (let
-      ((bad (list)))
-      (do
-        (for-each
-          (fn (f) (when (not (acl-fact-valid? f)) (append! bad f)))
-          facts)
-        bad))))
-
-(define
-  acl-facts-valid?
-  (fn (facts) (= (len (acl-validate-facts facts)) 0)))

lib/acl/scoreboard.json

@@ -1,14 +0,0 @@
-{
-  "lang": "acl",
-  "total_passed": 145,
-  "total_failed": 0,
-  "total": 145,
-  "suites": [
-    {"name":"direct","passed":24,"failed":0,"total":24},
-    {"name":"inherit","passed":30,"failed":0,"total":30},
-    {"name":"explain","passed":35,"failed":0,"total":35},
-    {"name":"fed","passed":31,"failed":0,"total":31},
-    {"name":"harden","passed":25,"failed":0,"total":25}
-  ],
-  "generated": "2026-06-06T22:43:27+00:00"
-}

lib/acl/scoreboard.md

@@ -1,11 +0,0 @@
-# acl scoreboard
-
-**145 / 145 passing** (0 failure(s)).
-
-| Suite | Passed | Total | Status |
-|-------|--------|-------|--------|
-| direct | 24 | 24 | ok |
-| inherit | 30 | 30 | ok |
-| explain | 35 | 35 | ok |
-| fed | 31 | 31 | ok |
-| harden | 25 | 25 | ok |

lib/acl/tests/direct.sx

@@ -1,170 +0,0 @@
-;; lib/acl/tests/direct.sx — Phase 1: direct grants + deny-overrides.
-
-(define acl-dt-pass 0)
-(define acl-dt-fail 0)
-(define acl-dt-failures (list))
-
-(define
-  acl-dt-check!
-  (fn
-    (name got expected)
-    (if
-      (= got expected)
-      (set! acl-dt-pass (+ acl-dt-pass 1))
-      (do
-        (set! acl-dt-fail (+ acl-dt-fail 1))
-        (append!
-          acl-dt-failures
-          (str name "\n    expected: " expected "\n    got:      " got))))))
-
-;; A small fixture used by most cases: alice can read page1, is denied edit on
-;; page1, and a service may federate peer1.
-(define
-  acl-dt-fixture
-  (fn
-    ()
-    (acl-build-db
-      (list
-        (acl-actor (quote alice) (quote user))
-        (acl-actor (quote svc1) (quote service))
-        (acl-resource-fact (quote page1) (quote page))
-        (acl-resource-fact (quote peer1) (quote peer))
-        (acl-grant (quote alice) (quote read) (quote page1))
-        (acl-grant (quote alice) (quote edit) (quote page1))
-        (acl-deny (quote alice) (quote edit) (quote page1))
-        (acl-grant (quote svc1) (quote federate) (quote peer1))))))
-
-(define
-  acl-dt-run-all!
-  (fn
-    ()
-    (let
-      ((db (acl-dt-fixture)))
-      (do
-        (acl-dt-check!
-          "direct grant permits"
-          (acl-permit? db (quote alice) (quote read) (quote page1))
-          true)
-        (acl-dt-check!
-          "service grant permits federate"
-          (acl-permit? db (quote svc1) (quote federate) (quote peer1))
-          true)
-        (acl-dt-check!
-          "missing action denied"
-          (acl-permit? db (quote alice) (quote comment) (quote page1))
-          false)
-        (acl-dt-check!
-          "missing resource denied"
-          (acl-permit? db (quote alice) (quote read) (quote page2))
-          false)
-        (acl-dt-check!
-          "missing subject denied"
-          (acl-permit? db (quote bob) (quote read) (quote page1))
-          false)
-        (acl-dt-check!
-          "wrong subject for service grant denied"
-          (acl-permit? db (quote alice) (quote federate) (quote peer1))
-          false)
-        (acl-dt-check!
-          "grant plus deny -> deny wins"
-          (acl-permit? db (quote alice) (quote edit) (quote page1))
-          false)
-        (acl-dt-check!
-          "deny alone still denies"
-          (acl-permit?
-            (acl-build-db
-              (list (acl-deny (quote alice) (quote read) (quote page1))))
-            (quote alice)
-            (quote read)
-            (quote page1))
-          false)
-        (acl-dt-check!
-          "deny on edit does not block read"
-          (acl-permit? db (quote alice) (quote read) (quote page1))
-          true)
-        (acl-dt-check!
-          "empty db denies"
-          (acl-permit?
-            (acl-build-db (list))
-            (quote alice)
-            (quote read)
-            (quote page1))
-          false)
-        (let
-          ((db2 (acl-build-db (list (acl-grant (quote a) (quote read) (quote r)) (acl-grant (quote b) (quote read) (quote r)) (acl-deny (quote b) (quote read) (quote r))))))
-          (do
-            (acl-dt-check!
-              "subject a allowed"
-              (acl-permit? db2 (quote a) (quote read) (quote r))
-              true)
-            (acl-dt-check!
-              "subject b denied by override"
-              (acl-permit? db2 (quote b) (quote read) (quote r))
-              false)))
-        (let
-          ((db3 (acl-build-db (list (acl-actor (quote editors) (quote role)) (acl-grant (quote editors) (quote edit) (quote post1))))))
-          (acl-dt-check!
-            "role subject direct grant"
-            (acl-permit? db3 (quote editors) (quote edit) (quote post1))
-            true))
-        (do
-          (acl/load!
-            (list
-              (acl-grant (quote carol) (quote moderate) (quote thread1))))
-          (acl-dt-check!
-            "api permit via current db"
-            (acl/permit? (quote carol) (quote moderate) (quote thread1))
-            true)
-          (acl-dt-check!
-            "api deny via current db"
-            (acl/permit? (quote carol) (quote read) (quote thread1))
-            false))
-        (do
-          (acl/load! (list))
-          (acl-dt-check!
-            "api reload clears prior grants"
-            (acl/permit? (quote carol) (quote moderate) (quote thread1))
-            false))
-        (acl-dt-check!
-          "schema grant arity valid"
-          (acl-fact-valid? (acl-grant (quote x) (quote read) (quote y)))
-          true)
-        (acl-dt-check!
-          "schema bad arity invalid"
-          (acl-fact-valid? (list (quote grant) (quote x)))
-          false)
-        (acl-dt-check!
-          "schema unknown predicate invalid"
-          (acl-fact-valid? (list (quote frobnicate) (quote x)))
-          false)
-        (acl-dt-check!
-          "schema subject kind known"
-          (acl-subject-kind? (quote service))
-          true)
-        (acl-dt-check!
-          "schema resource kind unknown"
-          (acl-resource-kind? (quote galaxy))
-          false)
-        (acl-dt-check!
-          "schema known action"
-          (acl-known-action? (quote moderate))
-          true)
-        (acl-dt-check!
-          "grant constructor shape"
-          (acl-grant (quote u) (quote read) (quote p))
-          (list (quote grant) (quote u) (quote read) (quote p)))
-        (acl-dt-check!
-          "actor constructor shape"
-          (acl-actor (quote u) (quote user))
-          (list (quote actor) (quote u) (quote user)))))))
-
-(define
-  acl-direct-tests-run!
-  (fn
-    ()
-    (do
-      (set! acl-dt-pass 0)
-      (set! acl-dt-fail 0)
-      (set! acl-dt-failures (list))
-      (acl-dt-run-all!)
-      {:failures acl-dt-failures :total (+ acl-dt-pass acl-dt-fail) :passed acl-dt-pass :failed acl-dt-fail})))

lib/acl/tests/explain.sx

@@ -1,316 +0,0 @@
-;; lib/acl/tests/explain.sx — Phase 3: proof correctness + audit completeness.
-
-(define acl-et-pass 0)
-(define acl-et-fail 0)
-(define acl-et-failures (list))
-
-;; Name-based deep equality. The host `=` compares symbols by interned
-;; identity, which is unstable across substitution/saturation; comparing by
-;; name (as the datalog suite does) makes structural assertions deterministic.
-(define
-  acl-et-eq?
-  (fn
-    (a b)
-    (cond
-      ((and (list? a) (list? b))
-        (and (= (len a) (len b)) (acl-et-eq-l? a b 0)))
-      ((and (dict? a) (dict? b))
-        (let
-          ((ka (keys a)) (kb (keys b)))
-          (and (= (len ka) (len kb)) (acl-et-eq-d? a b ka 0))))
-      ((and (symbol? a) (symbol? b))
-        (= (symbol->string a) (symbol->string b)))
-      (else (= a b)))))
-
-(define
-  acl-et-eq-l?
-  (fn
-    (a b i)
-    (cond
-      ((>= i (len a)) true)
-      ((not (acl-et-eq? (nth a i) (nth b i))) false)
-      (else (acl-et-eq-l? a b (+ i 1))))))
-
-(define
-  acl-et-eq-d?
-  (fn
-    (a b ka i)
-    (cond
-      ((>= i (len ka)) true)
-      ((let ((k (nth ka i))) (not (acl-et-eq? (get a k) (get b k))))
-        false)
-      (else (acl-et-eq-d? a b ka (+ i 1))))))
-
-(define
-  acl-et-check!
-  (fn
-    (name got expected)
-    (if
-      (acl-et-eq? got expected)
-      (set! acl-et-pass (+ acl-et-pass 1))
-      (do
-        (set! acl-et-fail (+ acl-et-fail 1))
-        (append!
-          acl-et-failures
-          (str name "\n    expected: " expected "\n    got:      " got))))))
-
-;; --- proof-tree walkers ---
-
-;; True if EDB fact `target` appears as a base leaf anywhere in the proof.
-(define
-  acl-et-has-leaf?
-  (fn
-    (node target)
-    (cond
-      ((= node nil) false)
-      ((and (dict? node) (has-key? node :via))
-        (acl-et-eq? (get node :fact) target))
-      ((and (dict? node) (has-key? node :body))
-        (acl-et-any-leaf? (get node :body) target))
-      (else false))))
-
-(define
-  acl-et-any-leaf?
-  (fn
-    (nodes target)
-    (cond
-      ((= (len nodes) 0) false)
-      ((acl-et-has-leaf? (first nodes) target) true)
-      (else (acl-et-any-leaf? (rest nodes) target)))))
-
-;; True if the proof records a verified negation (deny did not fire).
-(define
-  acl-et-has-negok?
-  (fn
-    (node)
-    (cond
-      ((= node nil) false)
-      ((and (dict? node) (has-key? node :neg-ok)) true)
-      ((and (dict? node) (has-key? node :body))
-        (acl-et-any-negok? (get node :body)))
-      (else false))))
-
-(define
-  acl-et-any-negok?
-  (fn
-    (nodes)
-    (cond
-      ((= (len nodes) 0) false)
-      ((acl-et-has-negok? (first nodes)) true)
-      (else (acl-et-any-negok? (rest nodes))))))
-
-(define
-  acl-et-run-all!
-  (fn
-    ()
-    (do
-      (let
-        ((db (acl-build-db (list (acl-grant (quote u) (quote read) (quote p))))))
-        (let
-          ((e (acl-explain db (quote u) (quote read) (quote p))))
-          (do
-            (acl-et-check! "direct: allowed?" (get e :allowed?) true)
-            (acl-et-check!
-              "direct: proof root fact"
-              (get (get e :proof) :fact)
-              (list (quote permit) (quote u) (quote read) (quote p)))
-            (acl-et-check!
-              "direct: grant leaf present"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote grant) (quote u) (quote read) (quote p)))
-              true)
-            (acl-et-check!
-              "direct: negation verified"
-              (acl-et-has-negok? (get e :proof))
-              true)
-            (acl-et-check!
-              "direct: reason nil when allowed"
-              (get e :reason)
-              nil))))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-member-of (quote team) (quote org)) (acl-grant (quote org) (quote read) (quote doc))))))
-        (let
-          ((e (acl-explain db (quote alice) (quote read) (quote doc))))
-          (do
-            (acl-et-check! "group: allowed?" (get e :allowed?) true)
-            (acl-et-check!
-              "group: member_of alice leaf"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote member_of) (quote alice) (quote team)))
-              true)
-            (acl-et-check!
-              "group: member_of team leaf"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote member_of) (quote team) (quote org)))
-              true)
-            (acl-et-check!
-              "group: grant org leaf at base"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote grant) (quote org) (quote read) (quote doc)))
-              true))))
-      (let
-        ((db (acl-build-db (list (acl-child-of (quote sec) (quote book)) (acl-grant (quote u) (quote read) (quote book))))))
-        (let
-          ((e (acl-explain db (quote u) (quote read) (quote sec))))
-          (do
-            (acl-et-check! "resource: allowed?" (get e :allowed?) true)
-            (acl-et-check!
-              "resource: child_of leaf"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote child_of) (quote sec) (quote book)))
-              true)
-            (acl-et-check!
-              "resource: grant on parent leaf"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote grant) (quote u) (quote read) (quote book)))
-              true))))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote bob) (quote editor)) (acl-role-grant (quote editor) (quote edit) (quote page1))))))
-        (let
-          ((e (acl-explain db (quote bob) (quote edit) (quote page1))))
-          (do
-            (acl-et-check! "role: allowed?" (get e :allowed?) true)
-            (acl-et-check!
-              "role: member_of leaf"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list (quote member_of) (quote bob) (quote editor)))
-              true)
-            (acl-et-check!
-              "role: role_grant leaf"
-              (acl-et-has-leaf?
-                (get e :proof)
-                (list
-                  (quote role_grant)
-                  (quote editor)
-                  (quote edit)
-                  (quote page1)))
-              true))))
-      (let
-        ((db (acl-build-db (list (acl-grant (quote u) (quote edit) (quote p)) (acl-deny (quote u) (quote edit) (quote p))))))
-        (let
-          ((e (acl-explain db (quote u) (quote edit) (quote p))))
-          (do
-            (acl-et-check! "deny: not allowed" (get e :allowed?) false)
-            (acl-et-check! "deny: no proof" (get e :proof) nil)
-            (acl-et-check!
-              "deny: reason root is eff_deny"
-              (get (get e :reason) :fact)
-              (list (quote eff_deny) (quote u) (quote edit) (quote p)))
-            (acl-et-check!
-              "deny: reason has deny leaf"
-              (acl-et-has-leaf?
-                (get e :reason)
-                (list (quote deny) (quote u) (quote edit) (quote p)))
-              true))))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-grant (quote alice) (quote read) (quote doc)) (acl-deny (quote team) (quote read) (quote doc))))))
-        (let
-          ((e (acl-explain db (quote alice) (quote read) (quote doc))))
-          (do
-            (acl-et-check!
-              "inherited deny: not allowed"
-              (get e :allowed?)
-              false)
-            (acl-et-check!
-              "inherited deny: reason has member_of leaf"
-              (acl-et-has-leaf?
-                (get e :reason)
-                (list (quote member_of) (quote alice) (quote team)))
-              true)
-            (acl-et-check!
-              "inherited deny: reason has group deny leaf"
-              (acl-et-has-leaf?
-                (get e :reason)
-                (list (quote deny) (quote team) (quote read) (quote doc)))
-              true))))
-      (let
-        ((db (acl-build-db (list))))
-        (let
-          ((e (acl-explain db (quote u) (quote read) (quote p))))
-          (do
-            (acl-et-check! "no grant: not allowed" (get e :allowed?) false)
-            (acl-et-check! "no grant: proof nil" (get e :proof) nil)
-            (acl-et-check! "no grant: reason nil" (get e :reason) nil))))
-      (let
-        ((db (acl-build-db (list (acl-grant (quote u) (quote read) (quote p)) (acl-deny (quote u) (quote edit) (quote p))))))
-        (do
-          (acl-audit-clear!)
-          (acl-et-check! "audit: starts empty" (acl-audit-count) 0)
-          (acl-et-check!
-            "audit decide allowed returns true"
-            (acl-audit-decide! db (quote u) (quote read) (quote p))
-            true)
-          (acl-et-check!
-            "audit decide denied returns false"
-            (acl-audit-decide! db (quote u) (quote edit) (quote p))
-            false)
-          (acl-audit-decide! db (quote u) (quote comment) (quote p))
-          (acl-et-check!
-            "audit: count after three decisions"
-            (acl-audit-count)
-            3)
-          (acl-et-check!
-            "audit: tail size respects n"
-            (len (acl-audit-tail 2))
-            2)
-          (acl-et-check!
-            "audit: tail returns most recent"
-            (get (first (acl-audit-tail 1)) :act)
-            (quote comment))
-          (acl-et-check!
-            "audit: first record seq is 0"
-            (get (first (acl-audit-tail 3)) :seq)
-            0)
-          (acl-et-check!
-            "audit: allowed flag recorded"
-            (get (first (acl-audit-tail 3)) :allowed?)
-            true)
-          (acl-et-check!
-            "audit: serialize line count"
-            (len (acl-et-lines (acl-audit-serialize)))
-            3)
-          (acl-audit-clear!)
-          (acl-et-check!
-            "audit: clear resets count"
-            (acl-audit-count)
-            0))))))
-
-;; count newline-terminated lines in a serialized log
-(define acl-et-lines (fn (s) (acl-et-count-nl s 0 0)))
-(define
-  acl-et-count-nl
-  (fn
-    (s i n)
-    (if
-      (>= i (len s))
-      (if (= n 0) (list) (acl-et-rangelist n))
-      (acl-et-count-nl
-        s
-        (+ i 1)
-        (if (= (slice s i (+ i 1)) "\n") (+ n 1) n)))))
-(define
-  acl-et-rangelist
-  (fn
-    (n)
-    (if
-      (<= n 0)
-      (list)
-      (cons n (acl-et-rangelist (- n 1))))))
-
-(define
-  acl-explain-tests-run!
-  (fn
-    ()
-    (do
-      (set! acl-et-pass 0)
-      (set! acl-et-fail 0)
-      (set! acl-et-failures (list))
-      (acl-et-run-all!)
-      {:failures acl-et-failures :total (+ acl-et-pass acl-et-fail) :passed acl-et-pass :failed acl-et-fail})))

lib/acl/tests/fed.sx

@@ -1,273 +0,0 @@
-;; lib/acl/tests/fed.sx — Phase 4: federation (peer trust, delegation,
-;; cross-instance chains, revocation). fed-sx transport is mocked as a dict.
-
-(define acl-ft-pass 0)
-(define acl-ft-fail 0)
-(define acl-ft-failures (list))
-
-;; Name-based deep equality (host `=` compares symbols by unstable interned
-;; identity; see lib/acl/tests/explain.sx).
-(define
-  acl-ft-eq?
-  (fn
-    (a b)
-    (cond
-      ((and (list? a) (list? b))
-        (and (= (len a) (len b)) (acl-ft-eq-l? a b 0)))
-      ((and (symbol? a) (symbol? b))
-        (= (symbol->string a) (symbol->string b)))
-      (else (= a b)))))
-(define
-  acl-ft-eq-l?
-  (fn
-    (a b i)
-    (cond
-      ((>= i (len a)) true)
-      ((not (acl-ft-eq? (nth a i) (nth b i))) false)
-      (else (acl-ft-eq-l? a b (+ i 1))))))
-
-(define
-  acl-ft-check!
-  (fn
-    (name got expected)
-    (if
-      (acl-ft-eq? got expected)
-      (set! acl-ft-pass (+ acl-ft-pass 1))
-      (do
-        (set! acl-ft-fail (+ acl-ft-fail 1))
-        (append!
-          acl-ft-failures
-          (str name "\n    expected: " expected "\n    got:      " got))))))
-
-;; proof leaf walker (federated proofs reconstruct through the engine rule).
-(define
-  acl-ft-has-leaf?
-  (fn
-    (node target)
-    (cond
-      ((= node nil) false)
-      ((and (dict? node) (has-key? node :via))
-        (acl-ft-eq? (get node :fact) target))
-      ((and (dict? node) (has-key? node :body))
-        (acl-ft-any-leaf? (get node :body) target))
-      (else false))))
-(define
-  acl-ft-any-leaf?
-  (fn
-    (nodes target)
-    (cond
-      ((= (len nodes) 0) false)
-      ((acl-ft-has-leaf? (first nodes) target) true)
-      (else (acl-ft-any-leaf? (rest nodes) target)))))
-
-(define acl-ft-p? (fn (db s a r) (acl-permit? db s a r)))
-
-;; A standard federation fixture: local trusts peer alpha at "readonly", which
-;; covers read+comment. alpha delegates several capabilities to alice.
-(define
-  acl-ft-fixture
-  (fn
-    ()
-    (acl-build-db
-      (list
-        (acl-trust (quote alpha) (quote readonly))
-        (acl-level-covers (quote readonly) (quote read))
-        (acl-level-covers (quote readonly) (quote comment))
-        (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc))
-        (acl-delegate (quote alpha) (quote alice) (quote edit) (quote doc))))))
-
-(define
-  acl-ft-run-all!
-  (fn
-    ()
-    (do
-      (let
-        ((db (acl-ft-fixture)))
-        (do
-          (acl-ft-check!
-            "trusted delegate, level covers action -> permit"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-ft-check!
-            "trusted delegate, level does NOT cover action -> deny"
-            (acl-ft-p? db (quote alice) (quote edit) (quote doc))
-            false)
-          (acl-ft-check!
-            "delegated but action class uncovered (comment has no delegate)"
-            (acl-ft-p? db (quote alice) (quote comment) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-level-covers (quote readonly) (quote read)) (acl-delegate (quote beta) (quote bob) (quote read) (quote doc))))))
-        (acl-ft-check!
-          "untrusted peer delegate -> deny"
-          (acl-ft-p? db (quote bob) (quote read) (quote doc))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote readonly)) (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc))))))
-        (acl-ft-check!
-          "trust but no level_covers -> deny"
-          (acl-ft-p? db (quote alice) (quote read) (quote doc))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc)) (acl-delegate (quote beta) (quote bob) (quote read) (quote doc))))))
-        (do
-          (acl-ft-check!
-            "trust is per-peer: alpha's delegate applies"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-ft-check!
-            "trust not transitive: beta's delegate does not apply"
-            (acl-ft-p? db (quote bob) (quote read) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc)) (acl-deny (quote alice) (quote read) (quote doc))))))
-        (acl-ft-check!
-          "local deny overrides federated grant"
-          (acl-ft-p? db (quote alice) (quote read) (quote doc))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-member-of (quote alice) (quote team)) (acl-delegate (quote alpha) (quote team) (quote read) (quote doc))))))
-        (acl-ft-check!
-          "federated grant to group reaches member"
-          (acl-ft-p? db (quote alice) (quote read) (quote doc))
-          true))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-child-of (quote sec) (quote book)) (acl-delegate (quote alpha) (quote u) (quote read) (quote book))))))
-        (acl-ft-check!
-          "federated grant on parent resource reaches child"
-          (acl-ft-p? db (quote u) (quote read) (quote sec))
-          true))
-      (let
-        ((transport {:gamma (list (acl-delegate (quote gamma) (quote carol) (quote read) (quote post))) :alpha (list (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc)))}))
-        (do
-          (acl-ft-check!
-            "fetch known peer returns its delegates"
-            (len (acl-fed-fetch transport (quote alpha)))
-            1)
-          (acl-ft-check!
-            "fetch unknown peer returns empty"
-            (len (acl-fed-fetch transport (quote delta)))
-            0)
-          (acl-ft-check!
-            "collect across peers"
-            (len
-              (acl-fed-collect transport (list (quote alpha) (quote gamma))))
-            2)
-          (let
-            ((db (acl-fed-build-db (list (acl-trust (quote alpha) (quote readonly)) (acl-trust (quote gamma) (quote readonly)) (acl-level-covers (quote readonly) (quote read))) transport (list (quote alpha) (quote gamma)))))
-            (do
-              (acl-ft-check!
-                "fed-build-db: alpha delegate permits"
-                (acl-ft-p? db (quote alice) (quote read) (quote doc))
-                true)
-              (acl-ft-check!
-                "fed-build-db: gamma delegate permits"
-                (acl-ft-p? db (quote carol) (quote read) (quote post))
-                true)
-              (acl-ft-check!
-                "fed-build-db: untrusted action still denied"
-                (acl-ft-p? db (quote alice) (quote edit) (quote doc))
-                false)))))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc))))))
-        (do
-          (acl-ft-check!
-            "before revoke: permitted"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-revoke!
-            db
-            (acl-delegate
-              (quote alpha)
-              (quote alice)
-              (quote read)
-              (quote doc)))
-          (acl-ft-check!
-            "after delegate revoked: denied"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc))))))
-        (do
-          (acl-ft-check!
-            "before trust revoke: permitted"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-revoke! db (acl-trust (quote alpha) (quote full)))
-          (acl-ft-check!
-            "after trust revoked: denied"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote alice) (quote read) (quote doc))))))
-        (do
-          (acl-ft-check!
-            "delegate without trust: denied"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            false)
-          (acl-fed-assert! db (acl-trust (quote alpha) (quote full)))
-          (acl-ft-check!
-            "trust ingested then re-checked: permitted"
-            (acl-ft-p? db (quote alice) (quote read) (quote doc))
-            true)))
-      (let
-        ((db (acl-ft-fixture)))
-        (let
-          ((e (acl-explain db (quote alice) (quote read) (quote doc))))
-          (do
-            (acl-ft-check! "federated proof allowed?" (get e :allowed?) true)
-            (acl-ft-check!
-              "federated proof has delegate leaf"
-              (acl-ft-has-leaf?
-                (get e :proof)
-                (list
-                  (quote delegate)
-                  (quote alpha)
-                  (quote alice)
-                  (quote read)
-                  (quote doc)))
-              true)
-            (acl-ft-check!
-              "federated proof has trust leaf"
-              (acl-ft-has-leaf?
-                (get e :proof)
-                (list (quote trust) (quote alpha) (quote readonly)))
-              true)
-            (acl-ft-check!
-              "federated proof has level_covers leaf"
-              (acl-ft-has-leaf?
-                (get e :proof)
-                (list (quote level_covers) (quote readonly) (quote read)))
-              true))))
-      (acl-ft-check!
-        "schema delegate arity valid"
-        (acl-fact-valid?
-          (acl-delegate (quote p) (quote s) (quote a) (quote r)))
-        true)
-      (acl-ft-check!
-        "schema trust arity valid"
-        (acl-fact-valid? (acl-trust (quote p) (quote l)))
-        true)
-      (acl-ft-check!
-        "schema peer arity valid"
-        (acl-fact-valid? (acl-peer (quote p) (quote peer)))
-        true)
-      (acl-ft-check!
-        "schema level_covers arity valid"
-        (acl-fact-valid? (acl-level-covers (quote l) (quote read)))
-        true)
-      (acl-ft-check!
-        "schema delegate bad arity invalid"
-        (acl-fact-valid? (list (quote delegate) (quote p) (quote s)))
-        false))))
-
-(define
-  acl-fed-tests-run!
-  (fn
-    ()
-    (do
-      (set! acl-ft-pass 0)
-      (set! acl-ft-fail 0)
-      (set! acl-ft-failures (list))
-      (acl-ft-run-all!)
-      {:failures acl-ft-failures :total (+ acl-ft-pass acl-ft-fail) :passed acl-ft-pass :failed acl-ft-fail})))

lib/acl/tests/harden.sx

@@ -1,228 +0,0 @@
-;; lib/acl/tests/harden.sx — adversarial / cross-phase hardening.
-;;
-;; Diamond hierarchies, conflict resolution where deny must win through every
-;; path, chain inheritance, cycle termination, multi-peer delegation, fact
-;; validation, and audit save/restore.
-;;
-;; PROVER-FREE BY DESIGN: this suite calls only acl-permit? (which runs in
-;; compiled Datalog, safe at any depth) plus pure data ops — never acl-explain /
-;; acl-prove-d. The SX-side proof reconstructor recurses, and once the kernel
-;; JIT-compiles it (after the explain/fed suites warm the process) it loops on
-;; chains deeper than ~3 (substrate JIT bug — see plan Blockers). Proof
-;; reconstruction is covered by tests/explain.sx (and federated proofs by
-;; tests/fed.sx), both of which stay under the warm-process depth threshold.
-
-(define acl-hd-pass 0)
-(define acl-hd-fail 0)
-(define acl-hd-failures (list))
-
-(define
-  acl-hd-check!
-  (fn
-    (name got expected)
-    (if
-      (= got expected)
-      (set! acl-hd-pass (+ acl-hd-pass 1))
-      (do
-        (set! acl-hd-fail (+ acl-hd-fail 1))
-        (append!
-          acl-hd-failures
-          (str name "\n    expected: " expected "\n    got:      " got))))))
-
-(define acl-hd-p? (fn (db s a r) (acl-permit? db s a r)))
-
-(define
-  acl-hd-run-all!
-  (fn
-    ()
-    (do
-      (let
-        ((grant-deny (acl-build-db (list (acl-child-of (quote r) (quote p1)) (acl-child-of (quote r) (quote p2)) (acl-grant (quote u) (quote read) (quote p1)) (acl-deny (quote u) (quote read) (quote p2)))))
-          (both-grant
-            (acl-build-db
-              (list
-                (acl-child-of (quote r) (quote p1))
-                (acl-child-of (quote r) (quote p2))
-                (acl-grant (quote u) (quote read) (quote p1))
-                (acl-grant (quote u) (quote read) (quote p2))))))
-        (do
-          (acl-hd-check!
-            "diamond resource: grant+deny parents -> deny wins"
-            (acl-hd-p? grant-deny (quote u) (quote read) (quote r))
-            false)
-          (acl-hd-check!
-            "diamond resource: both grant -> permit"
-            (acl-hd-p? both-grant (quote u) (quote read) (quote r))
-            true)
-          (acl-hd-check!
-            "diamond resource: deny does not leak to other parent"
-            (acl-hd-p? grant-deny (quote u) (quote read) (quote p1))
-            true)))
-      (let
-        ((grant-deny (acl-build-db (list (acl-member-of (quote alice) (quote g1)) (acl-member-of (quote alice) (quote g2)) (acl-grant (quote g1) (quote read) (quote doc)) (acl-deny (quote g2) (quote read) (quote doc)))))
-          (both-grant
-            (acl-build-db
-              (list
-                (acl-member-of (quote alice) (quote g1))
-                (acl-member-of (quote alice) (quote g2))
-                (acl-grant (quote g1) (quote read) (quote doc))
-                (acl-grant (quote g2) (quote read) (quote doc))))))
-        (do
-          (acl-hd-check!
-            "diamond group: grant+deny groups -> deny wins"
-            (acl-hd-p? grant-deny (quote alice) (quote read) (quote doc))
-            false)
-          (acl-hd-check!
-            "diamond group: both grant -> permit"
-            (acl-hd-p? both-grant (quote alice) (quote read) (quote doc))
-            true)))
-      (let
-        ((chain (acl-build-db (list (acl-member-of (quote a0) (quote a1)) (acl-member-of (quote a1) (quote a2)) (acl-member-of (quote a2) (quote a3)) (acl-member-of (quote a3) (quote a4)) (acl-grant (quote a4) (quote read) (quote res)))))
-          (chain-deny
-            (acl-build-db
-              (list
-                (acl-member-of (quote a0) (quote a1))
-                (acl-member-of (quote a1) (quote a2))
-                (acl-member-of (quote a2) (quote a3))
-                (acl-member-of (quote a3) (quote a4))
-                (acl-grant (quote a4) (quote read) (quote res))
-                (acl-deny (quote a0) (quote read) (quote res))))))
-        (do
-          (acl-hd-check!
-            "chain: top-group grant reaches leaf member"
-            (acl-hd-p? chain (quote a0) (quote read) (quote res))
-            true)
-          (acl-hd-check!
-            "chain: intermediate also covered"
-            (acl-hd-p? chain (quote a2) (quote read) (quote res))
-            true)
-          (acl-hd-check!
-            "chain: leaf-member deny overrides top grant"
-            (acl-hd-p? chain-deny (quote a0) (quote read) (quote res))
-            false)
-          (acl-hd-check!
-            "chain: deny on leaf does not block sibling level"
-            (acl-hd-p? chain-deny (quote a1) (quote read) (quote res))
-            true)))
-      (let
-        ((self-member (acl-build-db (list (acl-member-of (quote a) (quote a)) (acl-grant (quote a) (quote read) (quote r)))))
-          (self-child
-            (acl-build-db
-              (list
-                (acl-child-of (quote r) (quote r))
-                (acl-grant (quote u) (quote read) (quote r)))))
-          (two-cycle
-            (acl-build-db
-              (list
-                (acl-member-of (quote x) (quote y))
-                (acl-member-of (quote y) (quote x))
-                (acl-grant (quote y) (quote read) (quote r))))))
-        (do
-          (acl-hd-check!
-            "self-membership cycle terminates and grants"
-            (acl-hd-p? self-member (quote a) (quote read) (quote r))
-            true)
-          (acl-hd-check!
-            "self-child cycle terminates and grants"
-            (acl-hd-p? self-child (quote u) (quote read) (quote r))
-            true)
-          (acl-hd-check!
-            "two-node membership cycle terminates"
-            (acl-hd-p? two-cycle (quote x) (quote read) (quote r))
-            true)))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-member-of (quote alice) (quote team)) (acl-delegate (quote alpha) (quote team) (quote read) (quote doc)) (acl-deny (quote alice) (quote read) (quote doc))))))
-        (acl-hd-check!
-          "federated group grant, local member deny -> deny wins"
-          (acl-hd-p? db (quote alice) (quote read) (quote doc))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote bob) (quote read) (quote doc)) (acl-delegate (quote beta) (quote bob) (quote read) (quote doc))))))
-        (acl-hd-check!
-          "two peers delegate, one trusted -> permit"
-          (acl-hd-p? db (quote bob) (quote read) (quote doc))
-          true))
-      (let
-        ((db (acl-build-db (list (acl-trust (quote alpha) (quote full)) (acl-trust (quote beta) (quote full)) (acl-level-covers (quote full) (quote read)) (acl-delegate (quote alpha) (quote bob) (quote read) (quote doc)) (acl-delegate (quote beta) (quote bob) (quote read) (quote doc))))))
-        (acl-hd-check!
-          "two peers both trusted -> permit"
-          (acl-hd-p? db (quote bob) (quote read) (quote doc))
-          true))
-      (let
-        ((empty (acl-build-db (list))))
-        (acl-hd-check!
-          "empty db: nothing permitted"
-          (acl-hd-p? empty (quote u) (quote read) (quote r))
-          false))
-      (do
-        (acl-hd-check!
-          "validate: clean set has no bad facts"
-          (len
-            (acl-validate-facts
-              (list
-                (acl-grant (quote u) (quote read) (quote p))
-                (acl-member-of (quote u) (quote g))
-                (acl-delegate (quote pe) (quote u) (quote read) (quote p)))))
-          0)
-        (acl-hd-check!
-          "validate: facts-valid? true on clean set"
-          (acl-facts-valid?
-            (list (acl-grant (quote u) (quote read) (quote p))))
-          true)
-        (acl-hd-check!
-          "validate: surfaces wrong-arity and unknown predicate"
-          (len
-            (acl-validate-facts
-              (list
-                (acl-grant (quote u) (quote read) (quote p))
-                (list (quote grant) (quote u))
-                (list (quote bogus) (quote x) (quote y)))))
-          2)
-        (acl-hd-check!
-          "validate: empty set is valid"
-          (acl-facts-valid? (list))
-          true))
-      (let
-        ((db (acl-build-db (list (acl-grant (quote u) (quote read) (quote p)) (acl-deny (quote u) (quote edit) (quote p))))))
-        (do
-          (acl-audit-clear!)
-          (acl-audit-decide! db (quote u) (quote read) (quote p))
-          (acl-audit-decide! db (quote u) (quote edit) (quote p))
-          (let
-            ((snap (acl-audit-snapshot)))
-            (do
-              (acl-audit-clear!)
-              (acl-hd-check!
-                "audit: cleared count is 0"
-                (acl-audit-count)
-                0)
-              (acl-audit-restore! snap)
-              (acl-hd-check!
-                "audit: restored count"
-                (acl-audit-count)
-                2)
-              (acl-hd-check!
-                "audit: restored last act"
-                (get (first (acl-audit-tail 1)) :act)
-                (quote edit))
-              (acl-audit-decide! db (quote u) (quote comment) (quote p))
-              (acl-hd-check!
-                "audit: seq continues after restore"
-                (get (first (acl-audit-tail 1)) :seq)
-                2)
-              (acl-hd-check!
-                "audit: snapshot is an immutable copy"
-                (len (get snap :entries))
-                2)
-              (acl-audit-clear!))))))))
-
-(define
-  acl-harden-tests-run!
-  (fn
-    ()
-    (do
-      (set! acl-hd-pass 0)
-      (set! acl-hd-fail 0)
-      (set! acl-hd-failures (list))
-      (acl-hd-run-all!)
-      {:failures acl-hd-failures :total (+ acl-hd-pass acl-hd-fail) :passed acl-hd-pass :failed acl-hd-fail})))

lib/acl/tests/inherit.sx

@@ -1,202 +0,0 @@
-;; lib/acl/tests/inherit.sx — Phase 2: inheritance (groups, resource trees,
-;; role expansion) with deny-overrides.
-
-(define acl-it-pass 0)
-(define acl-it-fail 0)
-(define acl-it-failures (list))
-
-(define
-  acl-it-check!
-  (fn
-    (name got expected)
-    (if
-      (= got expected)
-      (set! acl-it-pass (+ acl-it-pass 1))
-      (do
-        (set! acl-it-fail (+ acl-it-fail 1))
-        (append!
-          acl-it-failures
-          (str name "\n    expected: " expected "\n    got:      " got))))))
-
-(define acl-it-p? (fn (db s a r) (acl-permit? db s a r)))
-
-(define
-  acl-it-run-all!
-  (fn
-    ()
-    (do
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-grant (quote team) (quote read) (quote doc))))))
-        (do
-          (acl-it-check!
-            "group grant reaches member"
-            (acl-it-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-it-check!
-            "group grant: non-member excluded"
-            (acl-it-p? db (quote bob) (quote read) (quote doc))
-            false)
-          (acl-it-check!
-            "group grant: wrong action"
-            (acl-it-p? db (quote alice) (quote edit) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-member-of (quote team) (quote org)) (acl-member-of (quote org) (quote company)) (acl-grant (quote company) (quote read) (quote doc))))))
-        (do
-          (acl-it-check!
-            "deep nested group grant reaches leaf member"
-            (acl-it-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-it-check!
-            "intermediate group also covered"
-            (acl-it-p? db (quote team) (quote read) (quote doc))
-            true)
-          (acl-it-check!
-            "mid group org covered"
-            (acl-it-p? db (quote org) (quote read) (quote doc))
-            true)))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote a) (quote b)) (acl-member-of (quote b) (quote a)) (acl-grant (quote b) (quote read) (quote r))))))
-        (do
-          (acl-it-check!
-            "cyclic membership terminates and grants"
-            (acl-it-p? db (quote a) (quote read) (quote r))
-            true)
-          (acl-it-check!
-            "cyclic membership covers both"
-            (acl-it-p? db (quote b) (quote read) (quote r))
-            true)))
-      (let
-        ((db (acl-build-db (list (acl-child-of (quote sec) (quote chap)) (acl-child-of (quote chap) (quote book)) (acl-grant (quote u) (quote read) (quote book))))))
-        (do
-          (acl-it-check!
-            "parent grant reaches direct child"
-            (acl-it-p? db (quote u) (quote read) (quote chap))
-            true)
-          (acl-it-check!
-            "parent grant reaches deep descendant"
-            (acl-it-p? db (quote u) (quote read) (quote sec))
-            true)
-          (acl-it-check!
-            "parent grant covers parent itself"
-            (acl-it-p? db (quote u) (quote read) (quote book))
-            true)
-          (acl-it-check!
-            "child grant does not climb to parent"
-            (acl-it-p?
-              (acl-build-db
-                (list
-                  (acl-child-of (quote sec) (quote book))
-                  (acl-grant (quote u) (quote read) (quote sec))))
-              (quote u)
-              (quote read)
-              (quote book))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-child-of (quote post1) (quote board)) (acl-grant (quote team) (quote comment) (quote board))))))
-        (do
-          (acl-it-check!
-            "group + resource: member on child resource"
-            (acl-it-p? db (quote alice) (quote comment) (quote post1))
-            true)
-          (acl-it-check!
-            "group + resource: member on parent resource"
-            (acl-it-p? db (quote alice) (quote comment) (quote board))
-            true)))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote bob) (quote editor)) (acl-role-grant (quote editor) (quote edit) (quote page1)) (acl-role-grant (quote editor) (quote read) (quote page1))))))
-        (do
-          (acl-it-check!
-            "role confers edit to member"
-            (acl-it-p? db (quote bob) (quote edit) (quote page1))
-            true)
-          (acl-it-check!
-            "role confers read to member"
-            (acl-it-p? db (quote bob) (quote read) (quote page1))
-            true)
-          (acl-it-check!
-            "role: capability not in tuple denied"
-            (acl-it-p? db (quote bob) (quote moderate) (quote page1))
-            false)
-          (acl-it-check!
-            "role: non-member excluded"
-            (acl-it-p? db (quote eve) (quote edit) (quote page1))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote bob) (quote editor)) (acl-child-of (quote draft) (quote page1)) (acl-role-grant (quote editor) (quote edit) (quote page1))))))
-        (acl-it-check!
-          "role grant flows to child resource"
-          (acl-it-p? db (quote bob) (quote edit) (quote draft))
-          true))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-grant (quote team) (quote read) (quote doc)) (acl-deny (quote alice) (quote read) (quote doc))))))
-        (acl-it-check!
-          "explicit deny beats inherited group allow"
-          (acl-it-p? db (quote alice) (quote read) (quote doc))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-grant (quote alice) (quote read) (quote doc)) (acl-deny (quote team) (quote read) (quote doc))))))
-        (do
-          (acl-it-check!
-            "group deny inherits and overrides direct grant"
-            (acl-it-p? db (quote alice) (quote read) (quote doc))
-            false)
-          (acl-it-check!
-            "group deny: another member also blocked"
-            (acl-it-p? db (quote team) (quote read) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-child-of (quote sec) (quote book)) (acl-grant (quote u) (quote read) (quote sec)) (acl-deny (quote u) (quote read) (quote book))))))
-        (acl-it-check!
-          "ancestor deny overrides descendant grant"
-          (acl-it-p? db (quote u) (quote read) (quote sec))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-grant (quote team) (quote read) (quote doc)) (acl-grant (quote team) (quote edit) (quote doc)) (acl-deny (quote alice) (quote edit) (quote doc))))))
-        (do
-          (acl-it-check!
-            "deny on edit leaves inherited read intact"
-            (acl-it-p? db (quote alice) (quote read) (quote doc))
-            true)
-          (acl-it-check!
-            "deny on edit blocks edit"
-            (acl-it-p? db (quote alice) (quote edit) (quote doc))
-            false)))
-      (let
-        ((db (acl-build-db (list (acl-member-of (quote alice) (quote team)) (acl-deny (quote team) (quote read) (quote doc))))))
-        (acl-it-check!
-          "inherited deny, no grant: denied"
-          (acl-it-p? db (quote alice) (quote read) (quote doc))
-          false))
-      (let
-        ((db (acl-build-db (list (acl-child-of (quote a) (quote root)) (acl-child-of (quote b) (quote root)) (acl-grant (quote u) (quote read) (quote root)) (acl-deny (quote u) (quote read) (quote a))))))
-        (do
-          (acl-it-check!
-            "deny on sibling a blocks a"
-            (acl-it-p? db (quote u) (quote read) (quote a))
-            false)
-          (acl-it-check!
-            "deny on sibling a leaves b permitted"
-            (acl-it-p? db (quote u) (quote read) (quote b))
-            true)
-          (acl-it-check!
-            "root itself still permitted"
-            (acl-it-p? db (quote u) (quote read) (quote root))
-            true)))
-      (let
-        ((db (acl-build-db (list (acl-grant (quote x) (quote read) (quote y))))))
-        (acl-it-check!
-          "direct grant under inheritance ruleset"
-          (acl-it-p? db (quote x) (quote read) (quote y))
-          true)))))
-
-(define
-  acl-inherit-tests-run!
-  (fn
-    ()
-    (do
-      (set! acl-it-pass 0)
-      (set! acl-it-fail 0)
-      (set! acl-it-failures (list))
-      (acl-it-run-all!)
-      {:failures acl-it-failures :total (+ acl-it-pass acl-it-fail) :passed acl-it-pass :failed acl-it-fail})))

lib/apl/conformance.conf

@@ -1,63 +0,0 @@
-# APL conformance config — sourced by lib/guest/conformance.sh.
-
-LANG_NAME=apl
-MODE=counters
-COUNTERS_PASS=apl-test-pass
-COUNTERS_FAIL=apl-test-fail
-TIMEOUT_PER_SUITE=300
-
-PRELOADS=(
-  spec/stdlib.sx
-  lib/r7rs.sx
-  lib/apl/runtime.sx
-  lib/apl/tokenizer.sx
-  lib/apl/parser.sx
-  lib/apl/transpile.sx
-  lib/apl/test-harness.sx
-)
-
-SUITES=(
-  "structural:lib/apl/tests/structural.sx"
-  "operators:lib/apl/tests/operators.sx"
-  "dfn:lib/apl/tests/dfn.sx"
-  "tradfn:lib/apl/tests/tradfn.sx"
-  "valence:lib/apl/tests/valence.sx"
-  "programs:lib/apl/tests/programs.sx"
-  "system:lib/apl/tests/system.sx"
-  "idioms:lib/apl/tests/idioms.sx"
-  "eval-ops:lib/apl/tests/eval-ops.sx"
-  "pipeline:lib/apl/tests/pipeline.sx"
-)
-
-emit_scoreboard_json() {
-  local n=${#GC_NAMES[@]} i sep
-  printf '{\n'
-  printf '  "suites": {\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 '  "total_pass": %d,\n' "$GC_TOTAL_PASS"
-  printf '  "total_fail": %d,\n' "$GC_TOTAL_FAIL"
-  printf '  "total": %d\n' "$GC_TOTAL"
-  printf '}\n'
-}
-
-emit_scoreboard_md() {
-  local n=${#GC_NAMES[@]} i
-  printf '# APL Conformance Scoreboard\n\n'
-  printf '_Generated by `lib/apl/conformance.sh`_\n\n'
-  printf '| Suite | Pass | Fail | Total |\n'
-  printf '|-------|-----:|-----:|------:|\n'
-  for ((i=0; i<n; i++)); do
-    printf '| %s | %d | %d | %d |\n' \
-      "${GC_NAMES[$i]}" "${GC_PASS[$i]}" "${GC_FAIL[$i]}" "${GC_TOTAL_S[$i]}"
-  done
-  printf '| **Total** | **%d** | **%d** | **%d** |\n' "$GC_TOTAL_PASS" "$GC_TOTAL_FAIL" "$GC_TOTAL"
-  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.'
-}

lib/apl/conformance.sh

@@ -1,5 +1,116 @@
 #!/usr/bin/env bash
-# lib/apl/conformance.sh — APL conformance via the shared guest driver.
-# Config lives in lib/apl/conformance.conf (MODE=counters). Override the binary
-# with SX_SERVER=path/to/sx_server.exe bash lib/apl/conformance.sh
-exec bash "$(dirname "$0")/../guest/conformance.sh" "$(dirname "$0")/conformance.conf" "$@"
+# 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 eval-ops pipeline)
+
+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/r7rs.sx")
+(load "lib/apl/runtime.sx")
+(load "lib/apl/tokenizer.sx")
+(load "lib/apl/parser.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 300 "$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/scoreboard.json

@@ -9,9 +9,9 @@
     "system": {"pass": 13, "fail": 0},
     "idioms": {"pass": 64, "fail": 0},
     "eval-ops": {"pass": 14, "fail": 0},
-    "pipeline": {"pass": 152, "fail": 0}
+    "pipeline": {"pass": 40, "fail": 0}
   },
-  "total_pass": 562,
+  "total_pass": 450,
   "total_fail": 0,
-  "total": 562
+  "total": 450
 }

lib/apl/scoreboard.md

@@ -13,8 +13,8 @@ _Generated by `lib/apl/conformance.sh`_
 | system | 13 | 0 | 13 |
 | idioms | 64 | 0 | 64 |
 | eval-ops | 14 | 0 | 14 |
-| pipeline | 152 | 0 | 152 |
-| **Total** | **562** | **0** | **562** |
+| pipeline | 40 | 0 | 40 |
+| **Total** | **450** | **0** | **450** |
 
 ## Notes
 

lib/apl/test-harness.sx

@@ -1,15 +0,0 @@
-; lib/apl/test-harness.sx — counters + assertion fn for the shared conformance
-; driver (lib/guest/conformance.sh, MODE=counters). Loaded as a PRELOAD so each
-; suite starts from a fresh 0/0; suites call (apl-test name got expected).
-
-(define apl-test-pass 0)
-(define apl-test-fail 0)
-
-(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)))))

lib/commerce/api.sx

@@ -1,56 +0,0 @@
-;; lib/commerce/api.sx — public commerce surface.
-;;
-;; A session bundles a pricing context with a cart: {:ctx CTX :cart CART}.
-;; All operations are pure and return a new session. The total and the
-;; per-line breakdown are deterministic functions of (ctx, cart).
-;;
-;; commerce-checkout is a Phase-3 stub — the order lifecycle is a durable
-;; flow that suspends at the SumUp payment boundary.
-
-(define commerce-session (fn (ctx) {:cart empty-cart :ctx ctx}))
-
-(define commerce-ctx (fn (sess) (get sess :ctx)))
-(define commerce-cart (fn (sess) (get sess :cart)))
-(define commerce-lines (fn (sess) (cart-lines (get sess :cart))))
-(define commerce-count (fn (sess) (cart-count (get sess :cart))))
-
-(define
-  commerce-add
-  (fn
-    (sess sku variant qty)
-    (assoc sess :cart (cart-add (get sess :cart) sku variant qty))))
-
-(define
-  commerce-remove
-  (fn
-    (sess sku variant)
-    (assoc sess :cart (cart-remove (get sess :cart) sku variant))))
-
-(define
-  commerce-set-qty
-  (fn
-    (sess sku variant qty)
-    (assoc sess :cart (cart-set-qty (get sess :cart) sku variant qty))))
-
-;; True when the sku exists in the session's catalog snapshot.
-(define
-  commerce-can-add?
-  (fn (sess sku) (catalog-has? (ctx-catalog (get sess :ctx)) sku)))
-
-(define
-  commerce-total
-  (fn (sess) (cart-total (get sess :ctx) (get sess :cart))))
-
-;; Per-line audit breakdown — the "which line contributed what" view.
-(define
-  line-detail
-  (fn (ctx line) (let ((cat (ctx-catalog ctx))) {:sku (line-sku line) :unit (line-unit-price cat (line-sku line) (line-variant line)) :qty (line-qty line) :variant (line-variant line) :extended (line-extended cat line) :tax (line-tax ctx line)})))
-
-(define
-  commerce-explain
-  (fn
-    (sess)
-    (map (fn (l) (line-detail (get sess :ctx) l)) (get sess :cart))))
-
-;; Phase 3 — order lifecycle flow (reserve -> pay -> fulfil) lands here.
-(define commerce-checkout (fn (sess) {:note "order lifecycle flow lands in Phase 3" :phase 3 :status :not-implemented}))

lib/commerce/attribution.sx

@@ -1,100 +0,0 @@
-;; lib/commerce/attribution.sx — line-level discount attribution.
-;;
-;; The briefing's marquee backward query: "which line item triggered this
-;; discount?". promo.sx computes discount amounts at the class/order level;
-;; this layer answers the *scope* question relationally and in both directions:
-;;   forward  — which lines does code C touch?   (lines-for-code)
-;;   backward — which codes touch this line?     (codes-for-line)
-;; Both are the same relation promo-toucheso run with different vars bound.
-;;
-;; A :fixed promo is order-level (touches no single line); query those with
-;; order-level-codes. Only promos that actually apply (amount > 0) touch lines.
-
-;; Lines whose sku is in product-class `cls`.
-(define
-  class-lines
-  (fn
-    (ctx cart cls)
-    (filter
-      (fn (l) (= (catalog-class (ctx-catalog ctx) (line-sku l)) cls))
-      cart)))
-
-;; The lines a promo applies to (its scope). :fixed is order-level → no lines.
-(define
-  promo-lines
-  (fn
-    (ctx cart p)
-    (let
-      ((k (promo-kind p)))
-      (cond
-        ((= k :percent) (class-lines ctx cart (nth p 2)))
-        ((= k :member)
-          (if
-            (= (get ctx :customer) :member)
-            (class-lines ctx cart (nth p 2))
-            (list)))
-        ((= k :bundle)
-          (filter (fn (l) (= (line-sku l) (nth p 2))) cart))
-        (:else (list))))))
-
-;; Relation: promo `code` touches `line`. Only applying promos (amount > 0)
-;; touch anything, so an inapplicable promo contributes no pairs.
-(define
-  promo-toucheso
-  (fn
-    (ctx cart ruleset code line)
-    (fresh
-      (p)
-      (membero p ruleset)
-      (project
-        (p)
-        (if
-          (> (promo-amount ctx cart p) 0)
-          (mk-conj
-            (== code (promo-code p))
-            (membero line (promo-lines ctx cart p)))
-          fail)))))
-
-;; --- query helpers ---
-
-(define
-  lines-for-code
-  (fn
-    (ctx cart ruleset code)
-    (run* line (promo-toucheso ctx cart ruleset code line))))
-
-(define
-  codes-for-line
-  (fn
-    (ctx cart ruleset line)
-    (run* code (promo-toucheso ctx cart ruleset code line))))
-
-(define
-  line-touched-by?
-  (fn
-    (ctx cart ruleset code line)
-    (not
-      (empty?
-        (run
-          1
-          c
-          (mk-conj (promo-toucheso ctx cart ruleset code line) (== c true)))))))
-
-;; Applying order-level (:fixed) promos — discounts with no single line.
-(define
-  order-level-codes
-  (fn
-    (ctx cart ruleset)
-    (run*
-      code
-      (fresh
-        (p)
-        (membero p ruleset)
-        (project
-          (p)
-          (if
-            (and
-              (> (promo-amount ctx cart p) 0)
-              (= (promo-kind p) :fixed))
-            (== code (promo-code p))
-            fail))))))

lib/commerce/cart.sx

@@ -1,86 +0,0 @@
-;; lib/commerce/cart.sx — cart as an ordered list of line items.
-;;
-;; A cart is a native list of lines; a line is (list sku variant qty).
-;; All operations are pure: they return a new cart, never mutate. Line
-;; order is insertion order (stable) so totals are reproducible.
-;;
-;; cart-lineo is the relational view — because a line *is* a (sku variant qty)
-;; tuple, membero queries the cart directly, forward or backward.
-
-(define empty-cart (list))
-
-(define make-line (fn (sku variant qty) (list sku variant qty)))
-(define line-sku (fn (l) (nth l 0)))
-(define line-variant (fn (l) (nth l 1)))
-(define line-qty (fn (l) (nth l 2)))
-
-(define
-  same-line?
-  (fn
-    (l sku variant)
-    (and (= (line-sku l) sku) (= (line-variant l) variant))))
-
-(define
-  cart-qty
-  (fn
-    (cart sku variant)
-    (let
-      ((m (filter (fn (l) (same-line? l sku variant)) cart)))
-      (if (empty? m) 0 (line-qty (first m))))))
-
-(define
-  cart-remove
-  (fn
-    (cart sku variant)
-    (filter (fn (l) (not (same-line? l sku variant))) cart)))
-
-;; Add qty units; merges into an existing (sku,variant) line in place,
-;; otherwise appends a new line at the end.
-(define
-  cart-add
-  (fn
-    (cart sku variant qty)
-    (let
-      ((existing (cart-qty cart sku variant)))
-      (if
-        (= existing 0)
-        (append cart (list (make-line sku variant qty)))
-        (map
-          (fn
-            (l)
-            (if
-              (same-line? l sku variant)
-              (make-line sku variant (+ existing qty))
-              l))
-          cart)))))
-
-;; Set the absolute quantity; qty <= 0 removes the line.
-(define
-  cart-set-qty
-  (fn
-    (cart sku variant qty)
-    (if
-      (<= qty 0)
-      (cart-remove cart sku variant)
-      (if
-        (= (cart-qty cart sku variant) 0)
-        (append cart (list (make-line sku variant qty)))
-        (map
-          (fn
-            (l)
-            (if (same-line? l sku variant) (make-line sku variant qty) l))
-          cart)))))
-
-(define cart-empty? (fn (cart) (empty? cart)))
-(define cart-lines (fn (cart) cart))
-(define cart-skus (fn (cart) (map line-sku cart)))
-
-;; Total number of units across all lines.
-(define
-  cart-count
-  (fn (cart) (reduce (fn (acc l) (+ acc (line-qty l))) 0 cart)))
-
-;; Relational view of cart lines.
-(define
-  cart-lineo
-  (fn (cart sku variant qty) (membero (list sku variant qty) cart)))

lib/commerce/catalog.sx

@@ -1,83 +0,0 @@
-;; lib/commerce/catalog.sx — catalog snapshot + relational accessors.
-;;
-;; A catalog snapshot is an immutable dict:
-;;   {:products (list (list sku price class) ...)
-;;    :variants (list (list sku variant delta) ...)
-;;    :stock    (list (list sku variant qty) ...)}
-;;
-;; Money is integer minor units (pence/cents). class is a keyword product
-;; class consumed later by tax and promotion relations. delta is a signed
-;; price adjustment for a variant; qty is on-hand stock for (sku,variant).
-;;
-;; Accessor relations take the snapshot as the first argument and are fully
-;; multidirectional: (producto cat "widget" p c) binds p,c forward;
-;; (producto cat s 1000 c) enumerates every sku priced 1000 backward.
-
-(define empty-catalog {:products (list) :stock (list) :variants (list)})
-
-(define make-catalog (fn (products variants stock) {:products products :stock stock :variants variants}))
-
-(define cat-products (fn (cat) (get cat :products)))
-(define cat-variants (fn (cat) (get cat :variants)))
-(define cat-stock (fn (cat) (get cat :stock)))
-
-;; --- core fact relations ---
-
-(define
-  producto
-  (fn
-    (cat sku price class)
-    (membero (list sku price class) (get cat :products))))
-
-(define
-  varianto
-  (fn
-    (cat sku variant delta)
-    (membero (list sku variant delta) (get cat :variants))))
-
-(define
-  stocko
-  (fn
-    (cat sku variant qty)
-    (membero (list sku variant qty) (get cat :stock))))
-
-;; --- derived relations ---
-
-(define
-  priceo
-  (fn (cat sku price) (fresh (c) (producto cat sku price c))))
-
-(define
-  classo
-  (fn (cat sku class) (fresh (p) (producto cat sku p class))))
-
-;; Effective unit price of a (sku,variant): base + variant delta.
-(define
-  unit-priceo
-  (fn
-    (cat sku variant price)
-    (fresh
-      (base delta)
-      (priceo cat sku base)
-      (varianto cat sku variant delta)
-      (pluso-i base delta price))))
-
-;; --- deterministic lookups (first solution under fixed fact order) ---
-
-(define
-  catalog-price
-  (fn
-    (cat sku)
-    (let
-      ((rs (run 1 p (priceo cat sku p))))
-      (if (empty? rs) nil (first rs)))))
-
-(define
-  catalog-class
-  (fn
-    (cat sku)
-    (let
-      ((rs (run 1 c (classo cat sku c))))
-      (if (empty? rs) nil (first rs)))))
-
-(define catalog-has? (fn (cat sku) (not (nil? (catalog-price cat sku)))))

lib/commerce/conformance.sh

@@ -1,153 +0,0 @@
-#!/usr/bin/env bash
-# lib/commerce/conformance.sh — run commerce test suites in one sx_server
-# process per suite, emit scoreboard.json + scoreboard.md.
-#
-# commerce-on-sx builds pricing/promotion as miniKanren relations, so every
-# suite loads the miniKanren stack first, then the commerce modules.
-
-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=(catalog cart price api promo stack quote ledger order recon federation attribution payment window nettax stock refund integration)
-
-OUT_JSON="lib/commerce/scoreboard.json"
-OUT_MD="lib/commerce/scoreboard.md"
-
-run_suite() {
-  local suite=$1
-  local file="lib/commerce/tests/${suite}.sx"
-  local TMP
-  TMP=$(mktemp)
-  cat > "$TMP" << EPOCHS
-(epoch 1)
-(load "spec/stdlib.sx")
-(load "lib/r7rs.sx")
-(load "lib/guest/match.sx")
-(load "lib/minikanren/unify.sx")
-(load "lib/minikanren/stream.sx")
-(load "lib/minikanren/goals.sx")
-(load "lib/minikanren/fresh.sx")
-(load "lib/minikanren/conde.sx")
-(load "lib/minikanren/run.sx")
-(load "lib/minikanren/relations.sx")
-(load "lib/minikanren/project.sx")
-(load "lib/minikanren/intarith.sx")
-(load "lib/minikanren/matche.sx")
-(load "lib/minikanren/defrel.sx")
-(load "lib/persist/event.sx")
-(load "lib/persist/backend.sx")
-(load "lib/persist/log.sx")
-(load "lib/persist/kv.sx")
-(load "lib/persist/idempotency.sx")
-(load "lib/guest/lex.sx")
-(load "lib/guest/reflective/env.sx")
-(load "lib/guest/reflective/quoting.sx")
-(load "lib/scheme/parser.sx")
-(load "lib/scheme/eval.sx")
-(load "lib/scheme/runtime.sx")
-(load "lib/flow/spec.sx")
-(load "lib/flow/store.sx")
-(load "lib/flow/remote.sx")
-(load "lib/flow/host.sx")
-(load "lib/flow/api.sx")
-(load "lib/commerce/catalog.sx")
-(load "lib/commerce/cart.sx")
-(load "lib/commerce/price.sx")
-(load "lib/commerce/api.sx")
-(load "lib/commerce/promo.sx")
-(load "lib/commerce/stack.sx")
-(load "lib/commerce/quote.sx")
-(load "lib/commerce/window.sx")
-(load "lib/commerce/nettax.sx")
-(load "lib/commerce/stock.sx")
-(load "lib/commerce/ledger.sx")
-(load "lib/commerce/order.sx")
-(load "lib/commerce/refund.sx")
-(load "lib/commerce/payment.sx")
-(load "lib/commerce/recon.sx")
-(load "lib/commerce/federation.sx")
-(load "lib/commerce/attribution.sx")
-(epoch 2)
-(eval "(define ct-pass 0)")
-(eval "(define ct-fail 0)")
-(eval "(define ct-fails (list))")
-(eval "(define commerce-test (fn (name got expected) (if (= got expected) (set! ct-pass (+ ct-pass 1)) (begin (set! ct-fail (+ ct-fail 1)) (append! ct-fails name)))))")
-(epoch 3)
-(load "${file}")
-(epoch 4)
-(eval "(list ct-pass ct-fail)")
-(eval "ct-fails")
-EPOCHS
-
-  local OUTPUT
-  OUTPUT=$(timeout 560 "$SX_SERVER" < "$TMP" 2>/dev/null)
-  rm -f "$TMP"
-
-  # The (list ct-pass ct-fail) result follows its (ok-len 2 N) ack line.
-  local LINE
-  LINE=$(echo "$OUTPUT" | grep -oE '^\([0-9]+ [0-9]+\)$' | tail -1)
-  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 commerce 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
-
-{
-  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"
-
-{
-  printf '# commerce Conformance Scoreboard\n\n'
-  printf '_Generated by `lib/commerce/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))"
-} > "$OUT_MD"
-
-echo "Wrote $OUT_JSON and $OUT_MD" >&2
-echo "Total: $TOTAL_PASS pass, $TOTAL_FAIL fail" >&2
-
-[ "$TOTAL_FAIL" -eq 0 ]

lib/commerce/federation.sx

@@ -1,86 +0,0 @@
-;; lib/commerce/federation.sx — cross-instance catalog (federated marketplace).
-;;
-;; STUB: instances are registered in-process; there is no real network or
-;; ActivityPub transport here (that lives in the federation service). The point
-;; is the relational model: a federated catalog is just the UNION of each
-;; instance's product facts, tagged with origin, so the same miniKanren
-;; relations answer cross-instance questions — "which instances sell this sku?",
-;; "which is cheapest?" — as backward queries, no new query engine.
-
-(define federation-stub? true)
-
-(define make-federation (fn (instance cat) {:instances (list (list instance cat))}))
-
-(define
-  federation-add
-  (fn
-    (fed instance cat)
-    (assoc
-      fed
-      :instances (append (get fed :instances) (list (list instance cat))))))
-
-(define federation-instances (fn (fed) (map first (get fed :instances))))
-
-;; Flatten to (instance sku price class) origin-tagged tuples.
-(define
-  fed-products
-  (fn
-    (fed)
-    (reduce
-      (fn
-        (acc pair)
-        (let
-          ((instance (first pair)) (cat (nth pair 1)))
-          (append
-            acc
-            (map (fn (p) (cons instance p)) (get cat :products)))))
-      (list)
-      (get fed :instances))))
-
-;; --- relations over the federated catalog (multidirectional) ---
-
-(define
-  fed-producto
-  (fn
-    (fed instance sku price class)
-    (membero (list instance sku price class) (fed-products fed))))
-
-(define
-  fed-priceo
-  (fn
-    (fed instance sku price)
-    (fresh (c) (fed-producto fed instance sku price c))))
-
-;; --- query helpers ---
-
-;; Which instances carry a sku? (backward query)
-(define
-  instances-with-sku
-  (fn (fed sku) (run* inst (fresh (p c) (fed-producto fed inst sku p c)))))
-
-;; All (price instance) offers for a sku, in federation order.
-(define
-  sku-offers
-  (fn
-    (fed sku)
-    (run*
-      pair
-      (fresh
-        (inst p c)
-        (fed-producto fed inst sku p c)
-        (== pair (list p inst))))))
-
-;; Cheapest (price instance) for a sku — the deterministic selection layer.
-(define
-  cheapest-offer
-  (fn
-    (fed sku)
-    (let
-      ((offers (sku-offers fed sku)))
-      (if
-        (empty? offers)
-        nil
-        (reduce
-          (fn (best x) (if (< (first x) (first best)) x best))
-          (first offers)
-          offers)))))

lib/commerce/ledger.sx

@@ -1,176 +0,0 @@
-;; lib/commerce/ledger.sx — the order ledger as a persist event stream.
-;;
-;; Each order is an append-only stream "order/<id>" in a persist backend.
-;; Order state is never stored directly — it is a projection (fold) over the
-;; events, so the ledger is the single source of truth and replays identically.
-;;
-;; Lifecycle events:
-;;   :created   quote snapshot {:subtotal :discount :tax :total :codes ...}
-;;   :reserved  stock reserved
-;;   :paid      {:amount :ref}  — recorded idempotently on the payment ref
-;;   :fulfilled order shipped/delivered
-;;   :cancelled / :refunded
-;;
-;; Idempotency: the SumUp webhook can fire twice for one payment. order-pay
-;; uses persist/append-once keyed by the payment ref, so a replayed webhook
-;; yields the SAME :paid event without double-recording. Reconciliation then
-;; detects genuine mismatches (paid != ordered) across the whole ledger.
-
-(define order-stream (fn (order-id) (str "order/" order-id)))
-
-;; --- writes ---
-
-(define
-  order-create
-  (fn
-    (b order-id at quote)
-    (persist/append b (order-stream order-id) :created at quote)))
-
-(define
-  order-reserve
-  (fn
-    (b order-id at data)
-    (persist/append b (order-stream order-id) :reserved at data)))
-
-;; Idempotent on payment ref — a replayed webhook does not double-record.
-(define
-  order-pay
-  (fn
-    (b order-id ref at amount)
-    (persist/append-once b (order-stream order-id) ref :paid at {:amount amount :ref ref})))
-
-(define
-  order-fulfil
-  (fn
-    (b order-id at data)
-    (persist/append b (order-stream order-id) :fulfilled at data)))
-
-(define
-  order-cancel
-  (fn
-    (b order-id at reason)
-    (persist/append b (order-stream order-id) :cancelled at {:reason reason})))
-
-(define
-  order-refund
-  (fn
-    (b order-id ref at amount)
-    (persist/append-once
-      b
-      (order-stream order-id)
-      (str "refund/" ref)
-      :refunded at
-      {:amount amount :ref ref})))
-
-;; --- reads ---
-
-(define
-  order-events
-  (fn (b order-id) (persist/read b (order-stream order-id))))
-
-;; --- projections over an event list ---
-
-(define
-  order-status-of
-  (fn
-    (events)
-    (reduce
-      (fn
-        (st e)
-        (let
-          ((t (persist/event-type e)))
-          (cond
-            ((= t :created) :pending)
-            ((= t :reserved) :reserved)
-            ((= t :paid) :paid)
-            ((= t :fulfilled) :fulfilled)
-            ((= t :cancelled) :cancelled)
-            ((= t :refunded) :refunded)
-            (:else st))))
-      :new events)))
-
-(define
-  order-total-of
-  (fn
-    (events)
-    (let
-      ((created (filter (fn (e) (= (persist/event-type e) :created)) events)))
-      (if
-        (empty? created)
-        0
-        (get (persist/event-data (first created)) :total)))))
-
-(define
-  order-paid-amount-of
-  (fn
-    (events)
-    (reduce
-      (fn
-        (acc e)
-        (if
-          (= (persist/event-type e) :paid)
-          (+ acc (get (persist/event-data e) :amount))
-          acc))
-      0
-      events)))
-
-(define
-  order-refunded-amount-of
-  (fn
-    (events)
-    (reduce
-      (fn
-        (acc e)
-        (if
-          (= (persist/event-type e) :refunded)
-          (+ acc (get (persist/event-data e) :amount))
-          acc))
-      0
-      events)))
-
-;; Net settled = paid - refunded. Reconciliation compares this to the order
-;; total, but only once a payment exists.
-(define
-  order-recon-of
-  (fn
-    (events)
-    (let
-      ((net (- (order-paid-amount-of events) (order-refunded-amount-of events)))
-        (total (order-total-of events))
-        (has-paid (some (fn (e) (= (persist/event-type e) :paid)) events)))
-      (cond
-        ((not has-paid) :unpaid)
-        ((= net total) :ok)
-        ((< net total) :underpaid)
-        (:else :overpaid)))))
-
-;; --- backend-level helpers ---
-
-(define
-  order-status
-  (fn (b order-id) (order-status-of (order-events b order-id))))
-(define
-  order-total
-  (fn (b order-id) (order-total-of (order-events b order-id))))
-(define
-  order-paid
-  (fn (b order-id) (order-paid-amount-of (order-events b order-id))))
-(define
-  order-recon
-  (fn (b order-id) (order-recon-of (order-events b order-id))))
-
-(define order-ids (fn (b) (persist/backend-streams b)))
-
-;; Streams whose net payment does not match the order total (true mismatches,
-;; excluding orders that are simply not yet paid).
-(define
-  ledger-mismatches
-  (fn
-    (b)
-    (filter
-      (fn
-        (s)
-        (let
-          ((r (order-recon-of (persist/read b s))))
-          (or (= r :underpaid) (= r :overpaid))))
-      (persist/backend-streams b))))

lib/commerce/nettax.sx

@@ -1,80 +0,0 @@
-;; lib/commerce/nettax.sx — discount-aware tax (alternative policy).
-;;
-;; price.sx / quote.sx tax the GROSS per-line amounts (discount reduces payable
-;; but not the tax base). This module is the alternative explicit policy: tax the
-;; NET (post-discount) base. The basket-level discount is allocated across lines
-;; in proportion to each line's extended price, with a deterministic
-;; largest-remainder pass so per-line shares sum EXACTLY to the discount; tax is
-;; then charged on each line's net at its class rate.
-;;
-;; Both policies are reproducible from (ctx, cart, ruleset, exclusions); pick the
-;; one the jurisdiction requires. cart-quote-net mirrors cart-quote's shape.
-
-(define ct-sum (fn (xs) (reduce (fn (a x) (+ a x)) 0 xs)))
-
-;; Add 1 to the first `rem` elements (deterministic remainder distribution).
-(define
-  ct-add-rem
-  (fn
-    (xs rem)
-    (cond
-      ((empty? xs) (list))
-      ((> rem 0)
-        (cons
-          (+ (first xs) 1)
-          (ct-add-rem (rest xs) (- rem 1))))
-      (:else xs))))
-
-;; Per-line discount allocation (parallel to cart), summing exactly to
-;; total-discount, proportional to line-extended share.
-(define
-  allocate-discount
-  (fn
-    (cat cart total-discount)
-    (let
-      ((sub (cart-subtotal cat cart)))
-      (if
-        (= sub 0)
-        (map (fn (l) 0) cart)
-        (let
-          ((floors (map (fn (l) (quotient (* total-discount (line-extended cat l)) sub)) cart)))
-          (ct-add-rem floors (- total-discount (ct-sum floors))))))))
-
-;; Tax on one line's net (extended - allocated discount), clamped at 0.
-(define
-  net-line-tax
-  (fn
-    (ctx line alloc)
-    (let
-      ((cat (ctx-catalog ctx)))
-      (let
-        ((net (- (line-extended cat line) alloc)))
-        (apply-bps
-          (if (< net 0) 0 net)
-          (rate-bps
-            (get ctx :tax-rules)
-            (get ctx :jurisdiction)
-            (catalog-class cat (line-sku line))
-            (get ctx :customer)))))))
-
-(define
-  net-tax
-  (fn
-    (ctx cart allocations)
-    (ct-sum
-      (map (fn (line alloc) (net-line-tax ctx line alloc)) cart allocations))))
-
-;; Discount-aware quote: tax computed on the net (post-discount) base.
-(define
-  cart-quote-net
-  (fn
-    (ctx cart ruleset exclusions)
-    (let
-      ((cat (ctx-catalog ctx)))
-      (let
-        ((sub (cart-subtotal cat cart))
-          (disc (best-promo-discount ctx cart ruleset exclusions))
-          (codes (best-promo-codes ctx cart ruleset exclusions)))
-        (let
-          ((tax (net-tax ctx cart (allocate-discount cat cart disc))))
-          {:codes codes :subtotal sub :discount disc :total (+ (- sub disc) tax) :tax tax})))))

lib/commerce/order.sx

@@ -1,119 +0,0 @@
-;; lib/commerce/order.sx — order lifecycle as a durable flow-on-sx flow.
-;;
-;; The lifecycle (reserve -> await payment -> fulfil) is a Scheme flow running
-;; in the flow-on-sx guest (lib/flow). The flow is PURE ORCHESTRATION: it
-;; carries only the order-id and enforces step ordering + the suspension at the
-;; payment IO boundary. All IO/state lives in SX: the SX driver here services
-;; each flow request by appending to the persist ledger (ledger.sx).
-;;
-;;   reserve  -> SX appends :reserved, resumes  (synchronous host effect)
-;;   payment  -> flow stays SUSPENDED until the SumUp webhook resumes it
-;;   fulfil   -> SX appends :fulfilled, resumes (synchronous host effect)
-;;
-;; Durability: the flow's replay log is plain data (flow-store-export), so a
-;; suspended order survives a process restart — order-flow-restart! simulates
-;; that entirely Scheme-side. Idempotency: order-settle! only resumes a flow
-;; still waiting on payment, so a replayed webhook is a no-op at the flow level,
-;; and order-pay is idempotent at the ledger level.
-
-;; The flow definition (Scheme source). oid is in scope throughout the begin.
-(define
-  order-flow-src
-  "(defflow order-lifecycle (lambda (oid) (begin (request (quote reserve) oid) (request (quote payment) oid) (request (quote fulfil) oid))))")
-
-;; Build a flow env with the order flow registered. Never returns the env from
-;; an eval boundary (the env is large/cyclic — serializing it hangs).
-(define
-  order-make-env
-  (fn
-    ()
-    (let
-      ((env (flow-make-env)))
-      (begin (flow-run-in env order-flow-src) env))))
-
-;; --- thin Scheme bridge (string-interpolated flow ops) ---
-
-(define
-  order-flow-start
-  (fn
-    (env oid)
-    (flow-run-in env (str "(flow/start order-lifecycle \"" oid "\")"))))
-
-(define
-  order-flow-resume
-  (fn
-    (env id sym)
-    (flow-run-in env (str "(flow/resume " id " (quote " sym "))"))))
-
-(define
-  order-flow-status
-  (fn (env id) (flow-run-in env (str "(flow/status " id ")"))))
-(define
-  order-flow-result
-  (fn (env id) (flow-run-in env (str "(flow/result " id ")"))))
-
-;; The request kind the flow with this id is waiting on, or nil if it is not
-;; suspended on a host request (done / cancelled / unknown).
-(define
-  order-flow-waiting
-  (fn
-    (env id)
-    (let
-      ((reqs (flow-run-in env "(flow-host-requests)")))
-      (let
-        ((mine (filter (fn (r) (= (first r) id)) reqs)))
-        (if (empty? mine) nil (nth (first mine) 1))))))
-
-;; Id out of a (flow-suspended id tag) start/resume result.
-(define order-susp-id (fn (susp) (nth susp 1)))
-
-;; --- high-level lifecycle (flow + ledger composed) ---
-
-;; Create the order, start the flow, service the reserve step, and leave the
-;; flow suspended at payment. Returns the flow id (needed to settle later).
-(define
-  order-begin!
-  (fn
-    (env b oid at quote)
-    (begin
-      (order-create b oid at quote)
-      (let
-        ((id (order-susp-id (order-flow-start env oid))))
-        (begin
-          (order-reserve b oid (+ at 1) {})
-          (order-flow-resume env id :reserved)
-          id)))))
-
-;; Settle a payment: record it, resume the flow past payment, service fulfil.
-;; Idempotent — only acts when the flow is still waiting on payment, so a
-;; replayed webhook returns :already-settled without double-charging.
-(define
-  order-settle!
-  (fn
-    (env b id oid ref at amount)
-    (if
-      (= (order-flow-waiting env id) "payment")
-      (begin
-        (order-pay b oid ref at amount)
-        (order-flow-resume env id :paid)
-        (order-fulfil b oid (+ at 1) {})
-        (order-flow-resume env id :fulfilled)
-        :settled)
-      :already-settled)))
-
-;; Simulate a process restart: export the flow store, reset the runtime, reload
-;; the flow definition, reimport the store. Done entirely Scheme-side so the
-;; (large) store is never marshalled across the boundary. The persist ledger is
-;; a separate store and is unaffected. Suspended flows resume afterwards.
-(define
-  order-flow-restart!
-  (fn
-    (env)
-    (flow-run-in
-      env
-      (str
-        "(begin (define _saved (flow-store-export)) "
-        flow-reset-src
-        " "
-        order-flow-src
-        " (flow-store-import! _saved) #t)"))))

lib/commerce/payment.sx

@@ -1,41 +0,0 @@
-;; lib/commerce/payment.sx — provider-neutral payment-request envelope.
-;;
-;; The order flow (order.sx) suspends on `(request 'payment oid)` — it carries
-;; ONLY the order-id and calls no provider. This layer materialises, at the IO
-;; edge, the envelope a provider adapter needs to initiate payment:
-;;
-;;   {:order oid :amount <ledger total> :currency C :return-url U}
-;;
-;; amount comes from the ledger (the :created quote total); currency + return-url
-;; are host/provider config (legitimately host-supplied). The engine stays
-;; vendor-agnostic: SumUp/Stripe/etc. adapters consume this envelope, and
-;; order-settle!(ref, amount) is the vendor-neutral resume seam. No provider
-;; SDK, HTTP, or webhook parsing lives here — that is the orders service's job.
-
-(define payment-request (fn (b oid currency return-url) {:order oid :amount (order-total b oid) :return-url return-url :currency currency}))
-
-(define payment-request-order (fn (pr) (get pr :order)))
-(define payment-request-amount (fn (pr) (get pr :amount)))
-(define payment-request-currency (fn (pr) (get pr :currency)))
-(define payment-request-return-url (fn (pr) (get pr :return-url)))
-
-;; A Scheme string carried as a flow payload round-trips back to SX wrapped as
-;; {:scm-string "..."}; unwrap it to the bare order-id.
-(define
-  scm->string
-  (fn
-    (v)
-    (if (and (dict? v) (has-key? v :scm-string)) (get v :scm-string) v)))
-
-;; Host poller seam: every order currently suspended awaiting payment, each with
-;; its envelope. A provider adapter iterates these, initiates payment, and later
-;; calls order-settle! when the webhook arrives. Needs the flow env.
-(define
-  pending-payments
-  (fn
-    (env b currency return-url)
-    (let
-      ((reqs (flow-run-in env "(flow-host-requests)")))
-      (map
-        (fn (r) {:id (first r) :request (payment-request b (scm->string (nth r 2)) currency return-url)})
-        (filter (fn (r) (= (nth r 1) "payment")) reqs)))))

lib/commerce/price.sx

@@ -1,110 +0,0 @@
-;; lib/commerce/price.sx — deterministic subtotal + jurisdiction-relational tax.
-;;
-;; A pricing context bundles the inputs that make a total reproducible:
-;;   {:catalog CAT :tax-rules RULES :jurisdiction J :customer C}
-;; Same context + same cart => identical total, every run.
-;;
-;; Tax is NOT a hardcoded VAT rate. Rules are facts indexed by
-;;   (jurisdiction, product-class, customer-class) -> rate-bps
-;; where rate-bps is an integer in basis points (2000 = 20%). taxo queries
-;; them multidirectionally. Money stays in integer minor units; rounding is
-;; half-up per line via integer arithmetic only — never floats.
-
-(define
-  make-pricing-context
-  (fn (catalog tax-rules jurisdiction customer) {:customer customer :jurisdiction jurisdiction :catalog catalog :tax-rules tax-rules}))
-
-(define ctx-catalog (fn (ctx) (get ctx :catalog)))
-
-;; --- unit + line pricing ---
-
-;; Variant delta, defaulting to 0 when the (sku,variant) has no variant fact.
-(define
-  variant-delta
-  (fn
-    (cat sku variant)
-    (let
-      ((rs (run 1 d (varianto cat sku variant d))))
-      (if (empty? rs) 0 (first rs)))))
-
-;; Effective unit price = base price + variant delta. nil if sku unknown.
-(define
-  line-unit-price
-  (fn
-    (cat sku variant)
-    (let
-      ((base (catalog-price cat sku)))
-      (if (nil? base) nil (+ base (variant-delta cat sku variant))))))
-
-;; Extended (line) price = unit price * quantity.
-(define
-  line-extended
-  (fn
-    (cat line)
-    (*
-      (line-unit-price cat (line-sku line) (line-variant line))
-      (line-qty line))))
-
-(define
-  cart-subtotal
-  (fn
-    (cat cart)
-    (reduce (fn (acc l) (+ acc (line-extended cat l))) 0 cart)))
-
-;; --- tax (jurisdiction-relational) ---
-
-;; rules: (list (list jurisdiction class customer bps) ...)
-(define
-  taxo
-  (fn
-    (rules juris class cust bps)
-    (membero (list juris class cust bps) rules)))
-
-;; Deterministic rate lookup; 0 when no rule matches.
-(define
-  rate-bps
-  (fn
-    (rules juris class cust)
-    (let
-      ((rs (run 1 b (taxo rules juris class cust b))))
-      (if (empty? rs) 0 (first rs)))))
-
-;; Apply a basis-point rate to an integer amount, rounding half up.
-(define
-  apply-bps
-  (fn (amount bps) (quotient (+ (* amount bps) 5000) 10000)))
-
-(define
-  line-tax
-  (fn
-    (ctx line)
-    (let
-      ((cat (ctx-catalog ctx)))
-      (let
-        ((class (catalog-class cat (line-sku line))))
-        (apply-bps
-          (line-extended cat line)
-          (rate-bps
-            (get ctx :tax-rules)
-            (get ctx :jurisdiction)
-            class
-            (get ctx :customer)))))))
-
-(define
-  cart-tax
-  (fn
-    (ctx cart)
-    (reduce (fn (acc l) (+ acc (line-tax ctx l))) 0 cart)))
-
-;; --- total ---
-
-;; Returns {:subtotal :discounts :tax :total}. discounts is 0 until Phase 2.
-(define
-  cart-total
-  (fn
-    (ctx cart)
-    (let
-      ((cat (ctx-catalog ctx)))
-      (let
-        ((sub (cart-subtotal cat cart)) (tax (cart-tax ctx cart)))
-        {:subtotal sub :discounts 0 :total (+ sub tax) :tax tax}))))

lib/commerce/promo.sx

@@ -1,153 +0,0 @@
-;; lib/commerce/promo.sx — promotions as relations over the cart + catalog.
-;;
-;; A promo is a tagged tuple; the second field is always its code:
-;;   (:percent code class pct-bps)   pct-bps off every line of product-class
-;;   (:fixed   code threshold amount) amount off when subtotal >= threshold
-;;   (:bundle  code sku n)            every nth unit of sku is free
-;;   (:member  code class pct-bps)    like :percent, members only
-;;
-;; A ruleset is a list of promo tuples. The discount a promo yields on a
-;; given cart is a pure integer computation (minor units); the *enumeration*
-;; of which promos apply is relational, so promo-applieso runs forward
-;; ("which codes apply and for how much?") and backward ("which code yields
-;; this discount?"). Stacking precedence is a separate layer (stack.sx).
-
-(define promo-kind (fn (p) (nth p 0)))
-(define promo-code (fn (p) (nth p 1)))
-
-;; Extended price of all lines whose sku is in product-class `class`.
-(define
-  class-extended
-  (fn
-    (ctx cart class)
-    (let
-      ((cat (ctx-catalog ctx)))
-      (reduce
-        (fn
-          (acc l)
-          (if
-            (= (catalog-class cat (line-sku l)) class)
-            (+ acc (line-extended cat l))
-            acc))
-        0
-        cart))))
-
-(define
-  sku-qty
-  (fn
-    (cart sku)
-    (reduce
-      (fn (acc l) (if (= (line-sku l) sku) (+ acc (line-qty l)) acc))
-      0
-      cart)))
-
-;; --- per-type discount amounts (pure, integer minor units) ---
-
-(define
-  percent-amount
-  (fn
-    (ctx cart p)
-    (apply-bps
-      (class-extended ctx cart (nth p 2))
-      (nth p 3))))
-
-(define
-  fixed-amount
-  (fn
-    (ctx cart p)
-    (let
-      ((sub (cart-subtotal (ctx-catalog ctx) cart)))
-      (if
-        (>= sub (nth p 2))
-        (min (nth p 3) sub)
-        0))))
-
-(define
-  bundle-amount
-  (fn
-    (ctx cart p)
-    (let
-      ((sku (nth p 2)) (n (nth p 3)))
-      (let
-        ((free (quotient (sku-qty cart sku) n)))
-        (* free (catalog-price (ctx-catalog ctx) sku))))))
-
-(define
-  member-amount
-  (fn
-    (ctx cart p)
-    (if
-      (= (get ctx :customer) :member)
-      (apply-bps
-        (class-extended ctx cart (nth p 2))
-        (nth p 3))
-      0)))
-
-;; Discount this promo yields on this cart (0 if it does not apply).
-(define
-  promo-amount
-  (fn
-    (ctx cart p)
-    (let
-      ((k (promo-kind p)))
-      (cond
-        ((= k :percent) (percent-amount ctx cart p))
-        ((= k :fixed) (fixed-amount ctx cart p))
-        ((= k :bundle) (bundle-amount ctx cart p))
-        ((= k :member) (member-amount ctx cart p))
-        (:else 0)))))
-
-;; --- relational enumeration ---
-
-;; (code, amount) for every promo in the ruleset (amount may be 0).
-(define
-  promo-discounto
-  (fn
-    (ctx cart ruleset code amount)
-    (fresh
-      (p)
-      (membero p ruleset)
-      (project
-        (p)
-        (== code (promo-code p))
-        (== amount (promo-amount ctx cart p))))))
-
-;; (code, amount) restricted to promos that actually apply (amount > 0).
-(define
-  promo-applieso
-  (fn
-    (ctx cart ruleset code amount)
-    (fresh
-      (p)
-      (membero p ruleset)
-      (project
-        (p)
-        (if
-          (> (promo-amount ctx cart p) 0)
-          (mk-conj
-            (== code (promo-code p))
-            (== amount (promo-amount ctx cart p)))
-          fail)))))
-
-;; --- deterministic helpers ---
-
-;; List of (list code amount) for applicable promos, in ruleset order.
-(define
-  applicable-promos
-  (fn
-    (ctx cart ruleset)
-    (run*
-      pair
-      (fresh
-        (code amount)
-        (promo-applieso ctx cart ruleset code amount)
-        (== pair (list code amount))))))
-
-;; Discount for one code (0 if absent / inapplicable).
-(define
-  promo-amount-for
-  (fn
-    (ctx cart ruleset code)
-    (let
-      ((rs (run 1 a (promo-applieso ctx cart ruleset code a))))
-      (if (empty? rs) 0 (first rs)))))

lib/commerce/quote.sx

@@ -1,36 +0,0 @@
-;; lib/commerce/quote.sx — the final priced quote: price + promo + stacking.
-;;
-;; A quote is the deterministic composition of the pricing pipeline for a
-;; (context, cart, ruleset, exclusions) tuple:
-;;   {:subtotal S :discount D :tax T :total (S - D + T) :codes (...)}
-;;
-;; Tax policy (explicit, for the determinism contract): tax is computed on the
-;; GROSS per-line amounts (pre-discount), via price.sx cart-tax. The best
-;; promo stacking reduces the payable total but not the tax base. Same inputs
-;; always yield the same quote — this is the value the order flow carries.
-
-(define
-  cart-quote
-  (fn
-    (ctx cart ruleset exclusions)
-    (let
-      ((cat (ctx-catalog ctx)))
-      (let
-        ((sub (cart-subtotal cat cart))
-          (disc (best-promo-discount ctx cart ruleset exclusions))
-          (tax (cart-tax ctx cart))
-          (codes (best-promo-codes ctx cart ruleset exclusions)))
-        {:codes codes :subtotal sub :discount disc :total (+ (- sub disc) tax) :tax tax}))))
-
-(define quote-subtotal (fn (q) (get q :subtotal)))
-(define quote-discount (fn (q) (get q :discount)))
-(define quote-tax (fn (q) (get q :tax)))
-(define quote-total (fn (q) (get q :total)))
-(define quote-codes (fn (q) (get q :codes)))
-
-;; Session-level convenience (a session is {:ctx :cart}).
-(define
-  session-quote
-  (fn
-    (sess ruleset exclusions)
-    (cart-quote (get sess :ctx) (get sess :cart) ruleset exclusions)))

lib/commerce/recon.sx

@@ -1,100 +0,0 @@
-;; lib/commerce/recon.sx — reconciliation as relational queries over the ledger.
-;;
-;; The ledger (ledger.sx) is the source of truth; reconciliation projects it
-;; into per-order summary tuples and then asks miniKanren questions about them.
-;; "Which orders are overpaid?" / "which order settled to net N?" are backward
-;; queries (run*) over the same relation, not separate code paths.
-;;
-;; A summary tuple is positional:
-;;   (order-stream total paid refunded net status)
-;; net = paid - refunded; status = :unpaid|:ok|:underpaid|:overpaid.
-
-(define
-  order-summary
-  (fn
-    (b stream)
-    (let
-      ((events (persist/read b stream)))
-      (let
-        ((total (order-total-of events))
-          (paid (order-paid-amount-of events))
-          (refunded (order-refunded-amount-of events)))
-        (list
-          stream
-          total
-          paid
-          refunded
-          (- paid refunded)
-          (order-recon-of events))))))
-
-(define
-  ledger-summaries
-  (fn (b) (map (fn (s) (order-summary b s)) (persist/backend-streams b))))
-
-;; --- relations over the summary set ---
-
-(define
-  summaryo
-  (fn
-    (summaries id total paid refunded net status)
-    (membero (list id total paid refunded net status) summaries)))
-
-(define
-  recon-statuso
-  (fn
-    (summaries id status)
-    (fresh (t p r n) (summaryo summaries id t p r n status))))
-
-(define
-  neto
-  (fn
-    (summaries id net)
-    (fresh (t p r status) (summaryo summaries id t p r net status))))
-
-;; A mismatch is any order whose money does not reconcile (over or under).
-(define
-  mismatcho
-  (fn
-    (summaries id)
-    (fresh
-      (status)
-      (recon-statuso summaries id status)
-      (conde ((== status :underpaid)) ((== status :overpaid))))))
-
-;; --- deterministic query helpers (run* over the live ledger) ---
-
-(define
-  orders-with-status
-  (fn (b status) (run* id (recon-statuso (ledger-summaries b) id status))))
-
-(define overpaid-orders (fn (b) (orders-with-status b :overpaid)))
-(define underpaid-orders (fn (b) (orders-with-status b :underpaid)))
-(define settled-orders (fn (b) (orders-with-status b :ok)))
-(define unpaid-orders (fn (b) (orders-with-status b :unpaid)))
-
-(define
-  mismatched-orders
-  (fn (b) (run* id (mismatcho (ledger-summaries b) id))))
-
-;; Backward: which order(s) settled to a given net amount?
-(define
-  orders-with-net
-  (fn (b net) (run* id (neto (ledger-summaries b) id net))))
-
-;; Total signed discrepancy across the ledger (net - total over paid orders);
-;; 0 when every settled order reconciles exactly.
-(define
-  ledger-discrepancy
-  (fn
-    (b)
-    (reduce
-      (fn
-        (acc s)
-        (let
-          ((status (nth s 5)))
-          (if
-            (= status :unpaid)
-            acc
-            (+ acc (- (nth s 4) (nth s 1))))))
-      0
-      (ledger-summaries b))))

lib/commerce/refund.sx

@@ -1,97 +0,0 @@
-;; lib/commerce/refund.sx — refund lifecycle as a second flow-on-sx flow.
-;;
-;; A refund is request → approve → settle, with TWO genuine suspension points:
-;; approval (a human/policy decision) and settlement (the provider issuing the
-;; refund). Like order.sx the flow is pure orchestration carrying only the
-;; order-id; the SX driver does all ledger IO and reuses order.sx's generic flow
-;; helpers (order-flow-waiting/-resume/-status, order-susp-id).
-;;
-;;   refund-begin!   → ledger :refund-requested, flow suspends at 'approve
-;;   refund-approve! → resume past approval, flow suspends at 'settle
-;;   refund-settle!  → ledger :refunded (idempotent), flow completes
-;;   refund-reject!  → ledger :refund-rejected, flow cancelled
-;;
-;; Only :refunded moves the books (recon.sx), so a requested-but-unsettled or
-;; rejected refund leaves reconciliation unchanged.
-
-(define
-  refund-flow-src
-  "(defflow refund-lifecycle (lambda (oid) (begin (request (quote approve) oid) (request (quote settle) oid))))")
-
-(define
-  refund-make-env
-  (fn
-    ()
-    (let
-      ((env (flow-make-env)))
-      (begin (flow-run-in env refund-flow-src) env))))
-
-;; Register the refund flow into an existing (e.g. order) env.
-(define
-  refund-flow-load!
-  (fn (env) (begin (flow-run-in env refund-flow-src) env)))
-
-(define
-  refund-flow-start
-  (fn
-    (env oid)
-    (flow-run-in env (str "(flow/start refund-lifecycle \"" oid "\")"))))
-
-;; --- ledger writes ---
-
-(define
-  refund-request
-  (fn
-    (b oid ref at amount)
-    (persist/append-once
-      b
-      (order-stream oid)
-      (str "refund-req/" ref)
-      :refund-requested at
-      {:amount amount :ref ref})))
-
-;; --- lifecycle ---
-
-;; Open a refund: record the request, start the flow, suspend at approval.
-(define
-  refund-begin!
-  (fn
-    (env b oid ref at amount)
-    (begin
-      (refund-request b oid ref at amount)
-      (order-susp-id (refund-flow-start env oid)))))
-
-(define
-  refund-approve!
-  (fn
-    (env id)
-    (if
-      (= (order-flow-waiting env id) "approve")
-      (begin (order-flow-resume env id :approved) :approved)
-      :not-pending-approval)))
-
-(define
-  refund-reject!
-  (fn
-    (env b oid id at reason)
-    (if
-      (= (order-flow-waiting env id) "approve")
-      (begin
-        (persist/append b (order-stream oid) :refund-rejected at {:reason reason})
-        (flow-run-in env (str "(flow/cancel " id ")"))
-        :rejected)
-      :not-pending-approval)))
-
-;; Settle (provider issued the refund): idempotent — only acts while waiting on
-;; settle, so a replayed provider callback returns :already-settled.
-(define
-  refund-settle!
-  (fn
-    (env b id oid ref at amount)
-    (if
-      (= (order-flow-waiting env id) "settle")
-      (begin
-        (order-refund b oid ref at amount)
-        (order-flow-resume env id :settled)
-        :settled)
-      :already-settled)))

lib/commerce/scoreboard.json

@@ -1,25 +0,0 @@
-{
-  "suites": {
-    "catalog": {"pass": 16, "fail": 0},
-    "cart": {"pass": 18, "fail": 0},
-    "price": {"pass": 20, "fail": 0},
-    "api": {"pass": 12, "fail": 0},
-    "promo": {"pass": 17, "fail": 0},
-    "stack": {"pass": 16, "fail": 0},
-    "quote": {"pass": 13, "fail": 0},
-    "ledger": {"pass": 20, "fail": 0},
-    "order": {"pass": 22, "fail": 0},
-    "recon": {"pass": 20, "fail": 0},
-    "federation": {"pass": 12, "fail": 0},
-    "attribution": {"pass": 16, "fail": 0},
-    "payment": {"pass": 7, "fail": 0},
-    "window": {"pass": 19, "fail": 0},
-    "nettax": {"pass": 11, "fail": 0},
-    "stock": {"pass": 19, "fail": 0},
-    "refund": {"pass": 20, "fail": 0},
-    "integration": {"pass": 19, "fail": 0}
-  },
-  "total_pass": 297,
-  "total_fail": 0,
-  "total": 297
-}

lib/commerce/scoreboard.md

@@ -1,25 +0,0 @@
-# commerce Conformance Scoreboard
-
-_Generated by `lib/commerce/conformance.sh`_
-
-| Suite | Pass | Fail | Total |
-|-------|-----:|-----:|------:|
-| catalog | 16 | 0 | 16 |
-| cart | 18 | 0 | 18 |
-| price | 20 | 0 | 20 |
-| api | 12 | 0 | 12 |
-| promo | 17 | 0 | 17 |
-| stack | 16 | 0 | 16 |
-| quote | 13 | 0 | 13 |
-| ledger | 20 | 0 | 20 |
-| order | 22 | 0 | 22 |
-| recon | 20 | 0 | 20 |
-| federation | 12 | 0 | 12 |
-| attribution | 16 | 0 | 16 |
-| payment | 7 | 0 | 7 |
-| window | 19 | 0 | 19 |
-| nettax | 11 | 0 | 11 |
-| stock | 19 | 0 | 19 |
-| refund | 20 | 0 | 20 |
-| integration | 19 | 0 | 19 |
-| **Total** | **297** | **0** | **297** |

lib/commerce/stack.sx

@@ -1,121 +0,0 @@
-;; lib/commerce/stack.sx — promotion stacking precedence + best price.
-;;
-;; Per the miniKanren design rule, precedence is NOT encoded inside the promo
-;; rules. promo.sx enumerates which promos apply; this layer enumerates which
-;; *combinations* are legal and selects the best one by an explicit cost
-;; function (max total discount = min price).
-;;
-;; Exclusivity is a list of unordered code pairs that may not both apply:
-;;   exclusions = (list (list code-a code-b) ...)
-;; A stacking is a subset of applicable (code amount) pairs containing no
-;; excluded pair. valid-stackings enumerates them; best-stacking is the
-;; deterministic selection layer; stacking-by-totalo is the backward query
-;; ("which legal stacking yields this total discount?").
-
-(define
-  excluded-pair?
-  (fn
-    (exclusions a b)
-    (some
-      (fn
-        (p)
-        (or
-          (and (= (first p) a) (= (nth p 1) b))
-          (and (= (first p) b) (= (nth p 1) a))))
-      exclusions)))
-
-;; True when no two distinct codes in the list are mutually excluded.
-(define
-  compatible?
-  (fn
-    (exclusions codes)
-    (every?
-      (fn
-        (a)
-        (every?
-          (fn (b) (or (= a b) (not (excluded-pair? exclusions a b))))
-          codes))
-      codes)))
-
-;; All subsets of xs, preserving element order. 2^n entries.
-(define
-  powerset
-  (fn
-    (xs)
-    (if
-      (empty? xs)
-      (list (list))
-      (let
-        ((r (powerset (cdr xs))))
-        (append r (map (fn (s) (cons (first xs) s)) r))))))
-
-(define stacking-codes (fn (st) (map first st)))
-
-(define
-  stacking-total
-  (fn
-    (st)
-    (reduce (fn (acc pair) (+ acc (nth pair 1))) 0 st)))
-
-;; Every legal stacking of the applicable (code amount) pairs.
-(define
-  valid-stackings
-  (fn
-    (exclusions applicable)
-    (filter
-      (fn (st) (compatible? exclusions (stacking-codes st)))
-      (powerset applicable))))
-
-;; Deterministic selection: the legal stacking with the greatest total
-;; discount; ties keep the earlier (stable) candidate, so the result is a
-;; reproducible function of (exclusions, applicable).
-(define
-  best-stacking
-  (fn
-    (exclusions applicable)
-    (reduce
-      (fn
-        (best st)
-        (if (> (stacking-total st) (stacking-total best)) st best))
-      (list)
-      (valid-stackings exclusions applicable))))
-
-(define
-  best-discount
-  (fn
-    (exclusions applicable)
-    (stacking-total (best-stacking exclusions applicable))))
-
-(define
-  best-codes
-  (fn
-    (exclusions applicable)
-    (stacking-codes (best-stacking exclusions applicable))))
-
-;; Backward query: legal stackings (as code lists) whose total discount = D.
-(define
-  stacking-by-totalo
-  (fn
-    (stackings codes total)
-    (fresh
-      (st)
-      (membero st stackings)
-      (project
-        (st)
-        (mk-conj
-          (== codes (stacking-codes st))
-          (== total (stacking-total st)))))))
-
-;; --- top-level entry: best discount for a cart under a ruleset ---
-
-(define
-  best-promo-discount
-  (fn
-    (ctx cart ruleset exclusions)
-    (best-discount exclusions (applicable-promos ctx cart ruleset))))
-
-(define
-  best-promo-codes
-  (fn
-    (ctx cart ruleset exclusions)
-    (best-codes exclusions (applicable-promos ctx cart ruleset))))

lib/commerce/stock.sx

@@ -1,106 +0,0 @@
-;; lib/commerce/stock.sx — stock-constrained reservation.
-;;
-;; Reservation is a precondition the host checks BEFORE order-begin! (validate →
-;; begin), so the order flow stays pure orchestration. Availability is read
-;; relationally from the catalog stock facts (catalog.sx stocko); a stock view
-;; subtracts already-reserved quantities so concurrent orders can't over-reserve.
-;;
-;;   can-reserve? cat cart                  — every line fits available stock
-;;   reservation-shortfalls cat cart        — the lines that do not, with detail
-;;   effective-available cat reservations …  — availability net of reservations
-;;   sufficient-stocko cat sku variant qty  — relational "can supply qty?" query
-
-;; Deterministic on-hand stock for a (sku,variant); 0 if absent.
-(define
-  available-stock
-  (fn
-    (cat sku variant)
-    (let
-      ((rs (run 1 q (stocko cat sku variant q))))
-      (if (empty? rs) 0 (first rs)))))
-
-;; Units a line cannot fulfil from on-hand stock (0 if it fits).
-(define
-  line-shortfall
-  (fn
-    (cat line)
-    (let
-      ((short (- (line-qty line) (available-stock cat (line-sku line) (line-variant line)))))
-      (if (< short 0) 0 short))))
-
-(define
-  line-reservable?
-  (fn (cat line) (= (line-shortfall cat line) 0)))
-
-;; Lines that cannot be fully reserved, each with requested/available/short.
-(define
-  reservation-shortfalls
-  (fn
-    (cat cart)
-    (reduce
-      (fn
-        (acc line)
-        (let
-          ((short (line-shortfall cat line)))
-          (if (> short 0) (append acc (list {:requested (line-qty line) :available (available-stock cat (line-sku line) (line-variant line)) :sku (line-sku line) :variant (line-variant line) :short short})) acc)))
-      (list)
-      cart)))
-
-(define
-  can-reserve?
-  (fn (cat cart) (empty? (reservation-shortfalls cat cart))))
-
-;; Validate → reject; the host gates order-begin! on this.
-(define
-  reserve-check
-  (fn (cat cart) (if (can-reserve? cat cart) :ok {:shortfalls (reservation-shortfalls cat cart) :rejected :insufficient-stock})))
-
-;; --- reservation view (concurrent-safety) ---
-;; reservations: list of (sku variant qty) already held.
-
-(define
-  reserved-qty
-  (fn
-    (reservations sku variant)
-    (reduce
-      (fn
-        (acc r)
-        (if
-          (and (= (first r) sku) (= (nth r 1) variant))
-          (+ acc (nth r 2))
-          acc))
-      0
-      reservations)))
-
-;; On-hand minus already-reserved (clamped at 0).
-(define
-  effective-available
-  (fn
-    (cat reservations sku variant)
-    (let
-      ((eff (- (available-stock cat sku variant) (reserved-qty reservations sku variant))))
-      (if (< eff 0) 0 eff))))
-
-;; Can a line be reserved given existing reservations?
-(define
-  line-reservable-with?
-  (fn
-    (cat reservations line)
-    (<=
-      (line-qty line)
-      (effective-available
-        cat
-        reservations
-        (line-sku line)
-        (line-variant line)))))
-
-;; --- relational availability query (the showcase) ---
-
-;; Succeeds when on-hand stock for (sku,variant) covers qty. Multidirectional
-;; over the stock facts: "which variants of widget can supply 5?" is a backward
-;; query.
-(define
-  sufficient-stocko
-  (fn
-    (cat sku variant qty)
-    (fresh (avail) (stocko cat sku variant avail) (lteo-i qty avail))))

lib/commerce/tests/api.sx

@@ -1,73 +0,0 @@
-;; lib/commerce/tests/api.sx — public commerce session surface.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  acat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated))
-    (list (list "widget" :small -200))
-    (list)))
-
-(define
-  arules
-  (list
-    (list :uk :standard :guest 2000)
-    (list :uk :zero-rated :guest 0)))
-
-(define actx (make-pricing-context acat arules :uk :guest))
-(define sess0 (commerce-session actx))
-
-;; --- empty session ---
-
-(commerce-test "new-session-empty" (commerce-cart sess0) empty-cart)
-(commerce-test "new-count" (commerce-count sess0) 0)
-(commerce-test "new-total" (commerce-total sess0) {:subtotal 0 :discounts 0 :total 0 :tax 0})
-
-;; --- add + total ---
-
-(define
-  sess1
-  (commerce-add
-    (commerce-add sess0 "widget" :small 2)
-    "book"
-    :none 1))
-
-(commerce-test "add-count" (commerce-count sess1) 3)
-(commerce-test
-  "add-lines"
-  (commerce-lines sess1)
-  (list (list "widget" :small 2) (list "book" :none 1)))
-(commerce-test "add-total" (commerce-total sess1) {:subtotal 2400 :discounts 0 :total 2720 :tax 320})
-
-;; --- mutate ---
-
-(commerce-test
-  "set-qty"
-  (commerce-lines (commerce-set-qty sess1 "widget" :small 1))
-  (list (list "widget" :small 1) (list "book" :none 1)))
-
-(commerce-test
-  "remove"
-  (commerce-lines (commerce-remove sess1 "book" :none))
-  (list (list "widget" :small 2)))
-
-;; --- validation ---
-
-(commerce-test "can-add-yes" (commerce-can-add? sess0 "widget") true)
-(commerce-test "can-add-no" (commerce-can-add? sess0 "ghost") false)
-
-;; --- audit breakdown ---
-
-(commerce-test
-  "explain"
-  (commerce-explain sess1)
-  (list {:sku "widget" :unit 800 :qty 2 :variant :small :extended 1600 :tax 320} {:sku "book" :unit 800 :qty 1 :variant :none :extended 800 :tax 0}))
-
-;; --- checkout stub ---
-
-(commerce-test
-  "checkout-stub"
-  (get (commerce-checkout sess1) :status)
-  :not-implemented)

lib/commerce/tests/attribution.sx

@@ -1,124 +0,0 @@
-;; lib/commerce/tests/attribution.sx — line-level discount attribution.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "gizmo" 2000 :standard)
-      (list "book" 800 :zero-rated)
-      (list "tea" 1000 :reduced))
-    (list)
-    (list)))
-
-(define gctx (make-pricing-context pcat (list) :uk :guest))
-(define mctx (make-pricing-context pcat (list) :uk :member))
-
-(define
-  cart
-  (list
-    (list "widget" :none 2)
-    (list "gizmo" :none 1)
-    (list "book" :none 1)
-    (list "tea" :none 6)))
-
-(define
-  ruleset
-  (list
-    (list :percent "TEN" :standard 1000)
-    (list :percent "TWENTY" :standard 2000)
-    (list :bundle "B3T" "tea" 3)
-    (list :fixed "FIVE" 0 500)
-    (list :member "MEM" :standard 1500)))
-
-(define w-line (list "widget" :none 2))
-(define t-line (list "tea" :none 6))
-(define bk-line (list "book" :none 1))
-
-;; --- scope helpers ---
-
-(commerce-test
-  "class-lines-standard"
-  (class-lines gctx cart :standard)
-  (list (list "widget" :none 2) (list "gizmo" :none 1)))
-
-(commerce-test
-  "promo-lines-bundle"
-  (promo-lines gctx cart (list :bundle "B3T" "tea" 3))
-  (list (list "tea" :none 6)))
-
-(commerce-test
-  "promo-lines-fixed-none"
-  (promo-lines gctx cart (list :fixed "FIVE" 0 500))
-  (list))
-
-;; --- forward: which lines does a code touch? ---
-
-(commerce-test
-  "lines-for-ten"
-  (lines-for-code gctx cart ruleset "TEN")
-  (list (list "widget" :none 2) (list "gizmo" :none 1)))
-
-(commerce-test
-  "lines-for-bundle"
-  (lines-for-code gctx cart ruleset "B3T")
-  (list (list "tea" :none 6)))
-
-(commerce-test
-  "lines-for-fixed-empty"
-  (lines-for-code gctx cart ruleset "FIVE")
-  (list))
-(commerce-test
-  "lines-for-mem-guest-empty"
-  (lines-for-code gctx cart ruleset "MEM")
-  (list))
-
-;; --- backward: which codes touch this line? (the showcase) ---
-
-(commerce-test
-  "codes-for-widget-guest"
-  (codes-for-line gctx cart ruleset w-line)
-  (list "TEN" "TWENTY"))
-
-(commerce-test
-  "codes-for-tea"
-  (codes-for-line gctx cart ruleset t-line)
-  (list "B3T"))
-(commerce-test
-  "codes-for-book-none"
-  (codes-for-line gctx cart ruleset bk-line)
-  (list))
-
-;; member sees the member rate too
-(commerce-test
-  "codes-for-widget-member"
-  (codes-for-line mctx cart ruleset w-line)
-  (list "TEN" "TWENTY" "MEM"))
-
-(commerce-test
-  "lines-for-mem-member"
-  (lines-for-code mctx cart ruleset "MEM")
-  (list (list "widget" :none 2) (list "gizmo" :none 1)))
-
-;; --- predicate ---
-
-(commerce-test
-  "touched-yes"
-  (line-touched-by? gctx cart ruleset "TEN" w-line)
-  true)
-(commerce-test
-  "touched-no-wrong-class"
-  (line-touched-by? gctx cart ruleset "B3T" w-line)
-  false)
-(commerce-test
-  "touched-no-guest-mem"
-  (line-touched-by? gctx cart ruleset "MEM" w-line)
-  false)
-
-;; --- order-level (fixed) codes ---
-
-(commerce-test
-  "order-level"
-  (order-level-codes gctx cart ruleset)
-  (list "FIVE"))

lib/commerce/tests/cart.sx

@@ -1,103 +0,0 @@
-;; lib/commerce/tests/cart.sx — cart structure + line operations.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-;; --- add ---
-
-(commerce-test
-  "add-to-empty"
-  (cart-add empty-cart "widget" :small 2)
-  (list (list "widget" :small 2)))
-
-(commerce-test
-  "add-merges-same-line"
-  (cart-add
-    (cart-add empty-cart "widget" :small 2)
-    "widget"
-    :small 3)
-  (list (list "widget" :small 5)))
-
-(commerce-test
-  "add-different-variant-separate"
-  (cart-add
-    (cart-add empty-cart "widget" :small 2)
-    "widget"
-    :large 1)
-  (list (list "widget" :small 2) (list "widget" :large 1)))
-
-(commerce-test
-  "add-different-sku-separate"
-  (cart-add
-    (cart-add empty-cart "widget" :small 2)
-    "gadget"
-    :std 1)
-  (list (list "widget" :small 2) (list "gadget" :std 1)))
-
-(commerce-test
-  "add-preserves-order"
-  (cart-skus
-    (cart-add
-      (cart-add (cart-add empty-cart "a" :v 1) "b" :v 1)
-      "c"
-      :v 1))
-  (list "a" "b" "c"))
-
-;; --- qty queries ---
-
-(define
-  c2
-  (cart-add
-    (cart-add empty-cart "widget" :small 2)
-    "gadget"
-    :std 4))
-
-(commerce-test "cart-qty-found" (cart-qty c2 "widget" :small) 2)
-(commerce-test "cart-qty-missing" (cart-qty c2 "widget" :large) 0)
-(commerce-test "cart-count" (cart-count c2) 6)
-(commerce-test "cart-empty-yes" (cart-empty? empty-cart) true)
-(commerce-test "cart-empty-no" (cart-empty? c2) false)
-
-;; --- set-qty ---
-
-(commerce-test
-  "set-qty-existing"
-  (cart-set-qty c2 "widget" :small 10)
-  (list (list "widget" :small 10) (list "gadget" :std 4)))
-
-(commerce-test
-  "set-qty-new-line"
-  (cart-set-qty empty-cart "book" :std 3)
-  (list (list "book" :std 3)))
-
-(commerce-test
-  "set-qty-zero-removes"
-  (cart-set-qty c2 "widget" :small 0)
-  (list (list "gadget" :std 4)))
-
-;; --- remove ---
-
-(commerce-test
-  "remove-line"
-  (cart-remove c2 "gadget" :std)
-  (list (list "widget" :small 2)))
-
-(commerce-test
-  "remove-missing-noop"
-  (cart-remove c2 "nope" :std)
-  (list (list "widget" :small 2) (list "gadget" :std 4)))
-
-;; --- relational view ---
-
-(commerce-test
-  "cart-lineo-forward"
-  (run* q (cart-lineo c2 "gadget" :std q))
-  (list 4))
-
-(commerce-test
-  "cart-lineo-sku-by-qty-backward"
-  (run* sk (fresh (v) (cart-lineo c2 sk v 4)))
-  (list "gadget"))
-
-(commerce-test
-  "cart-lineo-all-skus"
-  (run* sk (fresh (v q) (cart-lineo c2 sk v q)))
-  (list "widget" "gadget"))

lib/commerce/tests/catalog.sx

@@ -1,93 +0,0 @@
-;; lib/commerce/tests/catalog.sx — catalog facts + relational accessors.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-;; Query vars avoid the name `s` (the run-n macro binds `s` internally).
-
-(define
-  cat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "gadget" 2500 :standard)
-      (list "book" 800 :zero-rated)
-      (list "tea" 1000 :reduced))
-    (list
-      (list "widget" :small -200)
-      (list "widget" :large 500)
-      (list "gadget" :std 0))
-    (list
-      (list "widget" :small 5)
-      (list "widget" :large 0)
-      (list "gadget" :std 12))))
-
-;; --- forward lookups ---
-
-(commerce-test
-  "price-forward"
-  (run* p (priceo cat "widget" p))
-  (list 1000))
-(commerce-test
-  "class-forward"
-  (run* c (classo cat "book" c))
-  (list :zero-rated))
-(commerce-test
-  "product-forward"
-  (run* q (fresh (p c) (producto cat "gadget" p c) (== q (list p c))))
-  (list (list 2500 :standard)))
-
-;; --- backward lookups (the showcase) ---
-
-(commerce-test
-  "sku-by-price-backward"
-  (run* sk (priceo cat sk 1000))
-  (list "widget" "tea"))
-
-(commerce-test
-  "sku-by-class-backward"
-  (run* sk (classo cat sk :standard))
-  (list "widget" "gadget"))
-
-(commerce-test
-  "all-prices"
-  (run* p (fresh (sk) (priceo cat sk p)))
-  (list 1000 2500 800 1000))
-
-;; --- variants + effective unit price ---
-
-(commerce-test
-  "variant-delta-forward"
-  (run* d (varianto cat "widget" :small d))
-  (list -200))
-
-(commerce-test
-  "unit-price-small"
-  (run* p (unit-priceo cat "widget" :small p))
-  (list 800))
-
-(commerce-test
-  "unit-price-large"
-  (run* p (unit-priceo cat "widget" :large p))
-  (list 1500))
-
-(commerce-test
-  "variant-by-delta-backward"
-  (run* v (varianto cat "widget" v -200))
-  (list :small))
-
-;; --- stock ---
-
-(commerce-test
-  "stock-forward"
-  (run* q (stocko cat "widget" :small q))
-  (list 5))
-
-(commerce-test
-  "in-stock-skus-backward"
-  (run* sk (fresh (v q) (stocko cat sk v q) (lto-i 0 q)))
-  (list "widget" "gadget"))
-
-;; --- deterministic helpers ---
-
-(commerce-test "catalog-price-helper" (catalog-price cat "gadget") 2500)
-(commerce-test "catalog-class-helper" (catalog-class cat "tea") :reduced)
-(commerce-test "catalog-has-yes" (catalog-has? cat "book") true)
-(commerce-test "catalog-has-no" (catalog-has? cat "nonesuch") false)

lib/commerce/tests/federation.sx

@@ -1,88 +0,0 @@
-;; lib/commerce/tests/federation.sx — federated catalog (out-of-scope stub).
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  cat-a
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated))
-    (list)
-    (list)))
-
-(define
-  cat-b
-  (make-catalog
-    (list
-      (list "widget" 900 :standard)
-      (list "tea" 1200 :reduced))
-    (list)
-    (list)))
-
-(define
-  cat-c
-  (make-catalog (list (list "widget" 1100 :standard)) (list) (list)))
-
-(define
-  fed
-  (federation-add
-    (federation-add (make-federation :alpha cat-a) :beta cat-b)
-    :gamma cat-c))
-
-;; --- structure ---
-
-(commerce-test "is-stub" federation-stub? true)
-(commerce-test
-  "instances"
-  (federation-instances fed)
-  (list :alpha :beta :gamma))
-(commerce-test "product-count" (len (fed-products fed)) 5)
-
-;; --- forward query ---
-
-(commerce-test
-  "price-at-instance"
-  (run* p (fed-priceo fed :beta "widget" p))
-  (list 900))
-
-;; --- backward queries (the showcase) ---
-
-(commerce-test
-  "instances-with-widget"
-  (instances-with-sku fed "widget")
-  (list :alpha :beta :gamma))
-
-(commerce-test
-  "instances-with-book"
-  (instances-with-sku fed "book")
-  (list :alpha))
-
-(commerce-test
-  "instances-with-tea"
-  (instances-with-sku fed "tea")
-  (list :beta))
-
-(commerce-test
-  "instance-by-price-backward"
-  (run* inst (fresh (c) (fed-producto fed inst "widget" 1100 c)))
-  (list :gamma))
-
-;; --- offers + cheapest (deterministic selection) ---
-
-(commerce-test
-  "widget-offers"
-  (sku-offers fed "widget")
-  (list
-    (list 1000 :alpha)
-    (list 900 :beta)
-    (list 1100 :gamma)))
-
-(commerce-test
-  "cheapest-widget"
-  (cheapest-offer fed "widget")
-  (list 900 :beta))
-(commerce-test
-  "cheapest-book"
-  (cheapest-offer fed "book")
-  (list 800 :alpha))
-(commerce-test "cheapest-missing" (cheapest-offer fed "ghost") nil)

lib/commerce/tests/integration.sx

@@ -1,104 +0,0 @@
-;; lib/commerce/tests/integration.sx — end-to-end composition proof.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-;;
-;; One narrative across every module: catalog → stock check → quote
-;; (promo+stack+tax) → order flow → payment envelope → settle → recon → refund.
-;; Proves the seams tie together with consistent numbers (the project's thesis:
-;; minikanren pricing + flow lifecycle + persist ledger compose).
-;; Builds one flow env with BOTH the order and refund flows.
-
-(define env (order-make-env))
-(define _rf (refund-flow-load! env))
-(define b (persist/mem-backend))
-
-(define
-  cat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated))
-    (list (list "widget" :small -200))
-    (list (list "widget" :small 10) (list "book" :none 5))))
-
-(define
-  rules
-  (list
-    (list :uk :standard :guest 2000)
-    (list :uk :zero-rated :guest 0)))
-
-(define ctx (make-pricing-context cat rules :uk :guest))
-
-(define
-  ruleset
-  (list
-    (list :percent "TEN" :standard 1000)
-    (list :fixed "FIVE" 0 50)))
-
-;; widget :small x2 → unit 800, extended 1600 (standard); book x1 → 800 (zero-rated)
-(define
-  cart
-  (list (list "widget" :small 2) (list "book" :none 1)))
-
-;; 1. stock gating passes (widget:small 10 >= 2)
-(commerce-test "int-can-reserve" (can-reserve? cat cart) true)
-
-;; 2. quote ties the whole pricing pipeline together
-;;    subtotal 2400; discount TEN 160 + FIVE 50 = 210; tax 1600@20% = 320;
-;;    total 2400 - 210 + 320 = 2510
-(define q (cart-quote ctx cart ruleset (list)))
-(commerce-test "int-quote-subtotal" (quote-subtotal q) 2400)
-(commerce-test "int-quote-discount" (quote-discount q) 210)
-(commerce-test "int-quote-tax" (quote-tax q) 320)
-(commerce-test "int-quote-total" (quote-total q) 2510)
-
-;; 3. attribution explains where the discount landed
-(commerce-test
-  "int-attribution"
-  (codes-for-line ctx cart ruleset (list "widget" :small 2))
-  (list "TEN"))
-(commerce-test
-  "int-order-level"
-  (order-level-codes ctx cart ruleset)
-  (list "FIVE"))
-
-;; 4. order carries the quote total into the ledger; suspends at payment
-(define oid "INT-1")
-(define id (order-begin! env b oid 1000 q))
-(commerce-test "int-order-total-from-quote" (order-total b oid) 2510)
-(commerce-test "int-waiting-payment" (order-flow-waiting env id) "payment")
-
-;; 5. the payment envelope reflects the quoted total
-(commerce-test
-  "int-payment-envelope"
-  (payment-request b oid :GBP "https://shop/return")
-  {:order "INT-1" :amount 2510 :return-url "https://shop/return" :currency :GBP})
-
-;; 6. settle the quoted amount → reconciles exactly
-(commerce-test
-  "int-settled"
-  (order-settle! env b id oid "pay-int" 1002 2510)
-  :settled)
-(commerce-test "int-status-fulfilled" (order-status b oid) :fulfilled)
-(commerce-test "int-recon-ok" (order-recon b oid) :ok)
-
-;; 7. partial refund via its own flow → recon moves to underpaid
-(define rid (refund-begin! env b oid "rf-int" 2000 510))
-(commerce-test "int-refund-approve" (refund-approve! env rid) :approved)
-(commerce-test
-  "int-refund-settle"
-  (refund-settle! env b rid oid "rf-int" 2001 510)
-  :settled)
-(commerce-test
-  "int-refunded-amount"
-  (order-refunded-amount-of (order-events b oid))
-  510)
-(commerce-test "int-recon-after-refund" (order-recon b oid) :underpaid)
-
-;; 8. ledger reconciliation flags the now-mismatched order
-(commerce-test
-  "int-mismatch"
-  (mismatched-orders b)
-  (list (order-stream "INT-1")))
-
-;; 9. distinct flow ids for the order and the refund
-(commerce-test "int-distinct-flow-ids" (not (= id rid)) true)

lib/commerce/tests/ledger.sx

@@ -1,80 +0,0 @@
-;; lib/commerce/tests/ledger.sx — order ledger on persist + idempotent recon.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define q1 {:codes (list) :subtotal 1000 :discount 0 :total 1200 :tax 200})
-
-;; --- lifecycle status projection ---
-
-(define b1 (persist/mem-backend))
-(define _c1 (order-create b1 "A1" 100 q1))
-(commerce-test "status-pending" (order-status b1 "A1") :pending)
-(define _r1 (order-reserve b1 "A1" 101 {:lines 2}))
-(commerce-test "status-reserved" (order-status b1 "A1") :reserved)
-(define _p1 (order-pay b1 "A1" "ref-1" 102 1200))
-(commerce-test "status-paid" (order-status b1 "A1") :paid)
-(define _f1 (order-fulfil b1 "A1" 103 {:carrier "post"}))
-(commerce-test "status-fulfilled" (order-status b1 "A1") :fulfilled)
-
-(commerce-test "total-projection" (order-total b1 "A1") 1200)
-(commerce-test "paid-projection" (order-paid b1 "A1") 1200)
-(commerce-test "recon-ok" (order-recon b1 "A1") :ok)
-(commerce-test "event-count" (len (order-events b1 "A1")) 4)
-
-;; --- idempotency: replayed webhook does not double-record ---
-
-(define b2 (persist/mem-backend))
-(define _c2 (order-create b2 "B1" 200 q1))
-(define _p2a (order-pay b2 "B1" "sumup-9" 201 1200))
-(define _p2b (order-pay b2 "B1" "sumup-9" 201 1200))
-(define _p2c (order-pay b2 "B1" "sumup-9" 201 1200))
-
-(commerce-test "idem-single-event" (len (order-events b2 "B1")) 2)
-(commerce-test "idem-paid-once" (order-paid b2 "B1") 1200)
-(commerce-test "idem-recon-ok" (order-recon b2 "B1") :ok)
-(commerce-test "idem-same-event" (= _p2a _p2c) true)
-
-;; --- mismatch detection ---
-
-(define bun (persist/mem-backend))
-(define _cu (order-create bun "U1" 300 q1))
-(commerce-test "unpaid-recon" (order-recon bun "U1") :unpaid)
-
-(define bup (persist/mem-backend))
-(define _cp (order-create bup "U2" 300 q1))
-(define _pp1 (order-pay bup "U2" "r-a" 301 1200))
-(define _pp2 (order-pay bup "U2" "r-b" 302 1200))
-(commerce-test "double-charge-overpaid" (order-recon bup "U2") :overpaid)
-(commerce-test "double-charge-amount" (order-paid bup "U2") 2400)
-
-(define bsh (persist/mem-backend))
-(define _cs (order-create bsh "U3" 400 q1))
-(define _ps (order-pay bsh "U3" "r-short" 401 1000))
-(commerce-test "underpaid-recon" (order-recon bsh "U3") :underpaid)
-
-;; --- refund (idempotent) reduces net ---
-
-(define brf (persist/mem-backend))
-(define _crf (order-create brf "R1" 500 q1))
-(define _prf (order-pay brf "R1" "p-1" 501 1200))
-(define _rf1 (order-refund brf "R1" "rf-1" 502 200))
-(define _rf2 (order-refund brf "R1" "rf-1" 502 200))
-(commerce-test "refund-idem-net" (order-recon brf "R1") :underpaid)
-(commerce-test "refund-idem-events" (len (order-events brf "R1")) 3)
-
-;; --- cross-ledger reconciliation ---
-
-(define bL (persist/mem-backend))
-(define _l1 (order-create bL "OK1" 600 q1))
-(define _l1p (order-pay bL "OK1" "ok-ref" 601 1200))
-(define _l2 (order-create bL "OVER1" 600 q1))
-(define _l2a (order-pay bL "OVER1" "o-a" 602 1200))
-(define _l2b (order-pay bL "OVER1" "o-b" 603 1200))
-(define _l3 (order-create bL "UNDER1" 600 q1))
-(define _l3p (order-pay bL "UNDER1" "u-ref" 604 900))
-(define _l4 (order-create bL "PENDING1" 600 q1))
-
-(commerce-test "ledger-order-count" (len (order-ids bL)) 4)
-(commerce-test
-  "ledger-mismatches"
-  (sort (ledger-mismatches bL))
-  (sort (list (order-stream "OVER1") (order-stream "UNDER1"))))

lib/commerce/tests/nettax.sx

@@ -1,92 +0,0 @@
-;; lib/commerce/tests/nettax.sx — discount-aware (net) tax policy.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "tea" 1000 :reduced))
-    (list)
-    (list)))
-
-(define
-  rules
-  (list
-    (list :uk :standard :guest 2000)
-    (list :uk :reduced :guest 500)))
-
-(define gctx (make-pricing-context pcat rules :uk :guest))
-
-;; widget x3 = 3000 (standard), tea x6 = 6000 (reduced); subtotal 9000
-(define
-  cart
-  (list (list "widget" :none 3) (list "tea" :none 6)))
-
-(define ruleset (list (list :percent "TEN" :standard 1000)))
-
-;; --- allocation: proportional, sums exactly to the discount ---
-
-(commerce-test
-  "allocate-even"
-  (allocate-discount pcat cart 300)
-  (list 100 200))
-(commerce-test
-  "allocate-sums-to-discount"
-  (ct-sum (allocate-discount pcat cart 300))
-  300)
-
-;; remainder distribution: 100 over (3000,6000)/9000 = (33,66) rem 1 -> (34,66)
-(commerce-test
-  "allocate-remainder"
-  (allocate-discount pcat cart 100)
-  (list 34 66))
-(commerce-test
-  "allocate-remainder-sums"
-  (ct-sum (allocate-discount pcat cart 100))
-  100)
-
-(commerce-test
-  "allocate-zero"
-  (allocate-discount pcat cart 0)
-  (list 0 0))
-(commerce-test
-  "allocate-empty"
-  (allocate-discount pcat empty-cart 0)
-  (list))
-
-;; --- net tax vs gross tax ---
-;; discount = TEN 10% of standard 3000 = 300, allocated (100 200).
-;; net: widget 2900@20%=580, tea 5800@5%=290 -> net tax 870 (gross was 900).
-
-(commerce-test
-  "net-quote"
-  (cart-quote-net gctx cart ruleset (list))
-  {:codes (list "TEN") :subtotal 9000 :discount 300 :total 9570 :tax 870})
-
-;; same cart through the gross policy taxes 900 (the documented default)
-(commerce-test
-  "gross-quote-for-contrast"
-  (quote-tax (cart-quote gctx cart ruleset (list)))
-  900)
-
-(commerce-test
-  "net-tax-lower"
-  (quote-tax (cart-quote-net gctx cart ruleset (list)))
-  870)
-
-;; --- no discount: net policy == gross policy ---
-
-(commerce-test
-  "no-discount-net-equals-gross"
-  (=
-    (cart-quote-net gctx cart (list) (list))
-    (cart-quote gctx cart (list) (list)))
-  true)
-
-;; --- empty cart ---
-
-(commerce-test
-  "net-empty"
-  (cart-quote-net gctx empty-cart ruleset (list))
-  {:codes (list) :subtotal 0 :discount 0 :total 0 :tax 0})

lib/commerce/tests/order.sx

@@ -1,74 +0,0 @@
-;; lib/commerce/tests/order.sx — order lifecycle as a flow-on-sx flow.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-;; Builds the (expensive) flow env once; all assertions share it.
-
-(define env (order-make-env))
-(define b (persist/mem-backend))
-(define q1 {:codes (list) :subtotal 1000 :discount 0 :total 1200 :tax 200})
-
-;; --- happy path: begin suspends at payment ---
-
-(define id1 (order-begin! env b "O1" 100 q1))
-
-(commerce-test "begin-status-reserved" (order-status b "O1") :reserved)
-(commerce-test "begin-waiting-payment" (order-flow-waiting env id1) "payment")
-(commerce-test "begin-not-yet-paid" (order-paid b "O1") 0)
-
-;; --- settle: payment webhook drives fulfilment ---
-
-(define s1 (order-settle! env b id1 "O1" "ref-1" 102 1200))
-
-(commerce-test "settle-result" s1 :settled)
-(commerce-test "settle-status-fulfilled" (order-status b "O1") :fulfilled)
-(commerce-test "settle-flow-done" (order-flow-status env id1) "done")
-(commerce-test "settle-recon-ok" (order-recon b "O1") :ok)
-(commerce-test "settle-event-count" (len (order-events b "O1")) 4)
-
-;; --- webhook replay: a second settle is a no-op ---
-
-(define s1b (order-settle! env b id1 "O1" "ref-1" 102 1200))
-
-(commerce-test "replay-already-settled" s1b :already-settled)
-(commerce-test
-  "replay-no-extra-events"
-  (len (order-events b "O1"))
-  4)
-(commerce-test "replay-recon-still-ok" (order-recon b "O1") :ok)
-
-;; --- a second order gets its own flow id and suspends independently ---
-
-(define id2 (order-begin! env b "O2" 200 q1))
-
-(commerce-test "second-distinct-id" (not (= id1 id2)) true)
-(commerce-test
-  "second-waiting-payment"
-  (order-flow-waiting env id2)
-  "payment")
-(commerce-test "first-unaffected" (order-status b "O1") :fulfilled)
-
-;; --- durability: a suspended order survives a process restart ---
-
-(define id3 (order-begin! env b "O3" 300 q1))
-(commerce-test "pre-restart-waiting" (order-flow-waiting env id3) "payment")
-
-(define _restart (order-flow-restart! env))
-
-(commerce-test
-  "post-restart-still-waiting"
-  (order-flow-waiting env id3)
-  "payment")
-(commerce-test "post-restart-ledger-intact" (order-status b "O3") :reserved)
-
-(define s3 (order-settle! env b id3 "O3" "ref-3" 302 1200))
-
-(commerce-test "post-restart-settled" s3 :settled)
-(commerce-test "post-restart-status" (order-status b "O3") :fulfilled)
-(commerce-test "post-restart-recon-ok" (order-recon b "O3") :ok)
-(commerce-test "post-restart-flow-done" (order-flow-status env id3) "done")
-
-;; --- payment-request envelope (provider-neutral) for the still-suspended O2 ---
-
-(commerce-test
-  "pending-payments-lists-suspended"
-  (pending-payments env b :GBP "https://shop/return")
-  (list {:id id2 :request {:order "O2" :amount 1200 :return-url "https://shop/return" :currency :GBP}}))

lib/commerce/tests/payment.sx

@@ -1,43 +0,0 @@
-;; lib/commerce/tests/payment.sx — provider-neutral payment-request envelope.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-;; Envelope construction is ledger-only (no flow env); pending-payments (which
-;; needs the flow env) is exercised in the order suite.
-
-(define q1 {:codes (list) :subtotal 1000 :discount 0 :total 1200 :tax 200})
-(define q2 {:codes (list) :subtotal 5000 :discount 500 :total 4500 :tax 0})
-
-(define b (persist/mem-backend))
-(define _c1 (order-create b "P1" 1 q1))
-(define _c2 (order-create b "P2" 1 q2))
-
-(commerce-test
-  "envelope"
-  (payment-request b "P1" :GBP "https://shop/return")
-  {:order "P1" :amount 1200 :return-url "https://shop/return" :currency :GBP})
-
-(commerce-test
-  "envelope-amount"
-  (payment-request-amount (payment-request b "P1" :GBP "x"))
-  1200)
-(commerce-test
-  "envelope-currency"
-  (payment-request-currency (payment-request b "P1" :GBP "x"))
-  :GBP)
-(commerce-test
-  "envelope-order"
-  (payment-request-order (payment-request b "P1" :GBP "x"))
-  "P1")
-(commerce-test
-  "envelope-return-url"
-  (payment-request-return-url (payment-request b "P1" :GBP "https://r"))
-  "https://r")
-
-;; amount tracks the ledger total, currency is per-call (provider/instance config)
-(commerce-test
-  "envelope-amount-2"
-  (payment-request-amount (payment-request b "P2" :EUR "x"))
-  4500)
-(commerce-test
-  "envelope-currency-2"
-  (payment-request-currency (payment-request b "P2" :EUR "x"))
-  :EUR)

lib/commerce/tests/price.sx

@@ -1,100 +0,0 @@
-;; lib/commerce/tests/price.sx — subtotal + jurisdiction-relational tax.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated)
-      (list "tea" 1000 :reduced))
-    (list
-      (list "widget" :small -200)
-      (list "widget" :large 500))
-    (list)))
-
-(define
-  rules
-  (list
-    (list :uk :standard :guest 2000)
-    (list :uk :reduced :guest 500)
-    (list :uk :zero-rated :guest 0)
-    (list :uk :standard :member 1000)
-    (list :ie :standard :guest 2300)))
-
-(define gctx (make-pricing-context pcat rules :uk :guest))
-(define mctx (make-pricing-context pcat rules :uk :member))
-
-;; --- unit + line pricing ---
-
-(commerce-test
-  "unit-price-variant"
-  (line-unit-price pcat "widget" :small)
-  800)
-(commerce-test
-  "unit-price-no-variant"
-  (line-unit-price pcat "widget" :none)
-  1000)
-(commerce-test "unit-price-unknown" (line-unit-price pcat "ghost" :none) nil)
-(commerce-test
-  "line-extended"
-  (line-extended pcat (list "widget" :small 2))
-  1600)
-
-;; --- subtotal ---
-
-(define
-  cart1
-  (list (list "widget" :small 2) (list "book" :none 1)))
-
-(commerce-test "subtotal" (cart-subtotal pcat cart1) 2400)
-(commerce-test "subtotal-empty" (cart-subtotal pcat empty-cart) 0)
-
-;; --- tax rate lookup (relational, both directions) ---
-
-(commerce-test
-  "rate-forward"
-  (rate-bps rules :uk :standard :guest)
-  2000)
-(commerce-test
-  "rate-missing"
-  (rate-bps rules :fr :standard :guest)
-  0)
-(commerce-test
-  "rate-juris-by-bps-backward"
-  (run* j (fresh (cust) (taxo rules j :standard cust 2300)))
-  (list :ie))
-(commerce-test
-  "rate-customer-by-bps-backward"
-  (run* cust (taxo rules :uk :standard cust 1000))
-  (list :member))
-
-;; --- apply-bps rounding (half up, integer only) ---
-
-(commerce-test "bps-exact" (apply-bps 1600 2000) 320)
-(commerce-test "bps-round-up" (apply-bps 799 2000) 160)
-(commerce-test "bps-zero" (apply-bps 800 0) 0)
-
-;; --- line + cart tax ---
-
-(commerce-test
-  "line-tax-standard"
-  (line-tax gctx (list "widget" :small 2))
-  320)
-(commerce-test
-  "line-tax-zero-rated"
-  (line-tax gctx (list "book" :none 1))
-  0)
-(commerce-test
-  "line-tax-member"
-  (line-tax mctx (list "widget" :small 2))
-  160)
-(commerce-test "cart-tax-guest" (cart-tax gctx cart1) 320)
-
-;; --- total dict (deterministic) ---
-
-(commerce-test "total-guest" (cart-total gctx cart1) {:subtotal 2400 :discounts 0 :total 2720 :tax 320})
-
-(commerce-test "total-member" (cart-total mctx cart1) {:subtotal 2400 :discounts 0 :total 2560 :tax 160})
-
-(commerce-test "total-empty" (cart-total gctx empty-cart) {:subtotal 0 :discounts 0 :total 0 :tax 0})

lib/commerce/tests/promo.sx

@@ -1,142 +0,0 @@
-;; lib/commerce/tests/promo.sx — promo rules + relational enumeration.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated)
-      (list "tea" 1000 :reduced))
-    (list)
-    (list)))
-
-(define gctx (make-pricing-context pcat (list) :uk :guest))
-(define mctx (make-pricing-context pcat (list) :uk :member))
-
-(define
-  cart
-  (list
-    (list "widget" :none 3)
-    (list "book" :none 1)
-    (list "tea" :none 6)))
-
-(define
-  ruleset
-  (list
-    (list :percent "TEN" :standard 1000)
-    (list :fixed "FIVER" 5000 500)
-    (list :bundle "B3T" "tea" 3)
-    (list :member "MEM" :standard 1500)))
-
-;; --- per-type amounts ---
-
-(commerce-test
-  "percent-amount"
-  (promo-amount gctx cart (list :percent "TEN" :standard 1000))
-  300)
-
-(commerce-test
-  "fixed-amount-met"
-  (promo-amount gctx cart (list :fixed "FIVER" 5000 500))
-  500)
-
-(commerce-test
-  "fixed-amount-not-met"
-  (promo-amount
-    gctx
-    (list (list "widget" :none 1))
-    (list :fixed "FIVER" 5000 500))
-  0)
-
-(commerce-test
-  "fixed-amount-capped"
-  (promo-amount
-    gctx
-    (list (list "book" :none 1))
-    (list :fixed "BIG" 0 9999))
-  800)
-
-(commerce-test
-  "bundle-amount"
-  (promo-amount gctx cart (list :bundle "B3T" "tea" 3))
-  2000)
-
-(commerce-test
-  "member-amount-guest"
-  (promo-amount gctx cart (list :member "MEM" :standard 1500))
-  0)
-
-(commerce-test
-  "member-amount-member"
-  (promo-amount mctx cart (list :member "MEM" :standard 1500))
-  450)
-
-;; --- relational enumeration: forward ---
-
-(commerce-test
-  "discounto-all-guest"
-  (run*
-    pair
-    (fresh
-      (code amount)
-      (promo-discounto gctx cart ruleset code amount)
-      (== pair (list code amount))))
-  (list
-    (list "TEN" 300)
-    (list "FIVER" 500)
-    (list "B3T" 2000)
-    (list "MEM" 0)))
-
-(commerce-test
-  "applicable-guest"
-  (applicable-promos gctx cart ruleset)
-  (list
-    (list "TEN" 300)
-    (list "FIVER" 500)
-    (list "B3T" 2000)))
-
-(commerce-test
-  "applicable-member"
-  (applicable-promos mctx cart ruleset)
-  (list
-    (list "TEN" 300)
-    (list "FIVER" 500)
-    (list "B3T" 2000)
-    (list "MEM" 450)))
-
-;; --- relational enumeration: backward (the showcase) ---
-
-(commerce-test
-  "code-by-discount-2000"
-  (run* code (promo-applieso gctx cart ruleset code 2000))
-  (list "B3T"))
-
-(commerce-test
-  "code-by-discount-500"
-  (run* code (promo-applieso gctx cart ruleset code 500))
-  (list "FIVER"))
-
-(commerce-test
-  "code-by-discount-none"
-  (run* code (promo-applieso gctx cart ruleset code 9999))
-  (list))
-
-;; --- deterministic helpers ---
-
-(commerce-test
-  "amount-for-ten"
-  (promo-amount-for gctx cart ruleset "TEN")
-  300)
-(commerce-test
-  "amount-for-mem-guest"
-  (promo-amount-for gctx cart ruleset "MEM")
-  0)
-(commerce-test
-  "amount-for-mem-member"
-  (promo-amount-for mctx cart ruleset "MEM")
-  450)
-(commerce-test
-  "amount-for-absent"
-  (promo-amount-for gctx cart ruleset "NOPE")
-  0)

lib/commerce/tests/quote.sx

@@ -1,108 +0,0 @@
-;; lib/commerce/tests/quote.sx — composed priced quote (price+promo+stacking).
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated)
-      (list "tea" 1000 :reduced))
-    (list)
-    (list)))
-
-(define
-  tax-rules
-  (list
-    (list :uk :standard :guest 2000)
-    (list :uk :reduced :guest 500)
-    (list :uk :zero-rated :guest 0)
-    (list :uk :standard :member 2000)
-    (list :uk :reduced :member 500)
-    (list :uk :zero-rated :member 0)))
-
-(define gctx (make-pricing-context pcat tax-rules :uk :guest))
-(define mctx (make-pricing-context pcat tax-rules :uk :member))
-
-(define
-  cart
-  (list
-    (list "widget" :none 3)
-    (list "book" :none 1)
-    (list "tea" :none 6)))
-
-(define
-  ruleset
-  (list
-    (list :percent "TEN" :standard 1000)
-    (list :percent "TWENTY" :standard 2000)
-    (list :fixed "FIVER" 5000 500)
-    (list :bundle "B3T" "tea" 3)
-    (list :member "MEM" :standard 2500)))
-
-(define
-  exclusions
-  (list (list "TEN" "TWENTY") (list "TEN" "MEM") (list "TWENTY" "MEM")))
-
-;; subtotal: 3000 + 800 + 6000 = 9800
-;; tax (gross): widget 600 + tea 300 + book 0 = 900
-;; guest discount: TWENTY 600 + FIVER 500 + B3T 2000 = 3100
-;; guest total: 9800 - 3100 + 900 = 7600
-
-(define gq (cart-quote gctx cart ruleset exclusions))
-
-(commerce-test "quote-subtotal" (quote-subtotal gq) 9800)
-(commerce-test "quote-tax" (quote-tax gq) 900)
-(commerce-test "quote-discount-guest" (quote-discount gq) 3100)
-(commerce-test "quote-total-guest" (quote-total gq) 7600)
-(commerce-test
-  "quote-codes-guest"
-  (quote-codes gq)
-  (list "TWENTY" "FIVER" "B3T"))
-
-(commerce-test "quote-full-guest" gq {:codes (list "TWENTY" "FIVER" "B3T") :subtotal 9800 :discount 3100 :total 7600 :tax 900})
-
-;; member discount: MEM 750 + FIVER 500 + B3T 2000 = 3250
-;; member total: 9800 - 3250 + 900 = 7450
-(define mq (cart-quote mctx cart ruleset exclusions))
-
-(commerce-test "quote-discount-member" (quote-discount mq) 3250)
-(commerce-test "quote-total-member" (quote-total mq) 7450)
-(commerce-test
-  "quote-codes-member"
-  (quote-codes mq)
-  (list "FIVER" "B3T" "MEM"))
-
-;; --- determinism: same inputs, identical quote ---
-
-(commerce-test
-  "quote-deterministic"
-  (=
-    (cart-quote gctx cart ruleset exclusions)
-    (cart-quote gctx cart ruleset exclusions))
-  true)
-
-;; --- no promos: discount 0, total = subtotal + tax ---
-
-(commerce-test
-  "quote-no-promos"
-  (cart-quote gctx cart (list) (list))
-  {:codes (list) :subtotal 9800 :discount 0 :total 10700 :tax 900})
-
-;; --- empty cart ---
-
-(commerce-test
-  "quote-empty"
-  (cart-quote gctx empty-cart ruleset exclusions)
-  {:codes (list) :subtotal 0 :discount 0 :total 0 :tax 0})
-
-;; --- session convenience ---
-
-(define
-  sess
-  (commerce-add (commerce-session gctx) "widget" :none 3))
-
-(commerce-test
-  "session-quote"
-  (quote-total (session-quote sess ruleset exclusions))
-  3000)

lib/commerce/tests/recon.sx

@@ -1,109 +0,0 @@
-;; lib/commerce/tests/recon.sx — reconciliation as relational ledger queries.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define q1 {:codes (list) :subtotal 1000 :discount 0 :total 1200 :tax 200})
-
-(define b (persist/mem-backend))
-
-;; OK1 — clean payment
-(define _ok (order-create b "OK1" 1 q1))
-(define _okp (order-pay b "OK1" "ok-ref" 2 1200))
-
-;; OVER1 — double charge under two different refs
-(define _ov (order-create b "OVER1" 1 q1))
-(define _ova (order-pay b "OVER1" "ov-a" 2 1200))
-(define _ovb (order-pay b "OVER1" "ov-b" 3 1200))
-
-;; UNDER1 — short payment
-(define _un (order-create b "UNDER1" 1 q1))
-(define _unp (order-pay b "UNDER1" "un-ref" 2 900))
-
-;; PART1 — paid in full, then partially refunded
-(define _pa (order-create b "PART1" 1 q1))
-(define _pap (order-pay b "PART1" "pa-ref" 2 1200))
-(define _par (order-refund b "PART1" "pa-rf" 3 200))
-
-;; REPLAY1 — webhook fires twice with the same ref (idempotent)
-(define _rp (order-create b "REPLAY1" 1 q1))
-(define _rpa (order-pay b "REPLAY1" "rp-ref" 2 1200))
-(define _rpb (order-pay b "REPLAY1" "rp-ref" 2 1200))
-
-;; PEND1 — created, not yet paid
-(define _pe (order-create b "PEND1" 1 q1))
-
-;; --- summaries ---
-
-(commerce-test "summary-count" (len (ledger-summaries b)) 6)
-(commerce-test
-  "summary-ok1"
-  (order-summary b "order/OK1")
-  (list "order/OK1" 1200 1200 0 1200 :ok))
-(commerce-test
-  "summary-part1"
-  (order-summary b "order/PART1")
-  (list "order/PART1" 1200 1200 200 1000 :underpaid))
-
-;; --- forward status query ---
-
-(commerce-test
-  "status-forward-ok"
-  (run* st (recon-statuso (ledger-summaries b) "order/OK1" st))
-  (list :ok))
-
-;; --- backward status queries (the showcase) ---
-
-(commerce-test
-  "settled"
-  (sort (settled-orders b))
-  (sort (list "order/OK1" "order/REPLAY1")))
-(commerce-test "overpaid" (overpaid-orders b) (list "order/OVER1"))
-(commerce-test
-  "underpaid"
-  (sort (underpaid-orders b))
-  (sort (list "order/UNDER1" "order/PART1")))
-(commerce-test "unpaid" (unpaid-orders b) (list "order/PEND1"))
-(commerce-test
-  "mismatched"
-  (sort (mismatched-orders b))
-  (sort (list "order/OVER1" "order/UNDER1" "order/PART1")))
-
-;; --- backward net-amount query ---
-
-(commerce-test
-  "net-1200"
-  (sort (orders-with-net b 1200))
-  (sort (list "order/OK1" "order/REPLAY1")))
-(commerce-test
-  "net-2400"
-  (orders-with-net b 2400)
-  (list "order/OVER1"))
-(commerce-test
-  "net-900"
-  (orders-with-net b 900)
-  (list "order/UNDER1"))
-
-;; --- discrepancy: +1200 (over) - 300 (under) - 200 (refund) = 700 ---
-
-(commerce-test "discrepancy" (ledger-discrepancy b) 700)
-
-;; --- double-charge guard ---
-
-(commerce-test "double-charge-detected" (order-recon b "OVER1") :overpaid)
-(commerce-test "double-charge-amount" (order-paid b "OVER1") 2400)
-
-;; --- partial refund ---
-
-(commerce-test "partial-refund-net" (order-recon b "PART1") :underpaid)
-(commerce-test
-  "partial-refund-amount"
-  (order-refunded-amount-of (order-events b "PART1"))
-  200)
-
-;; --- webhook replay: same ref twice records once ---
-
-(commerce-test
-  "replay-single-event"
-  (len (order-events b "REPLAY1"))
-  2)
-(commerce-test "replay-paid-once" (order-paid b "REPLAY1") 1200)
-(commerce-test "replay-settled" (order-recon b "REPLAY1") :ok)

lib/commerce/tests/refund.sx

@@ -1,78 +0,0 @@
-;; lib/commerce/tests/refund.sx — refund lifecycle as a flow-on-sx flow.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-;; Builds the (expensive) flow env once; all assertions share it.
-
-(define env (refund-make-env))
-(define b (persist/mem-backend))
-(define q1 {:codes (list) :subtotal 1000 :discount 0 :total 1200 :tax 200})
-
-;; a paid, fulfilled order to refund (set up directly via the ledger)
-(define _c (order-create b "O1" 1 q1))
-(define _p (order-pay b "O1" "pay-1" 2 1200))
-(commerce-test "setup-recon-ok" (order-recon b "O1") :ok)
-
-;; --- happy path: request -> approve -> settle ---
-
-(define rid (refund-begin! env b "O1" "rf-1" 10 500))
-
-(commerce-test "begin-waiting-approve" (order-flow-waiting env rid) "approve")
-(commerce-test
-  "begin-not-yet-refunded"
-  (order-refunded-amount-of (order-events b "O1"))
-  0)
-(commerce-test "begin-recon-unchanged" (order-recon b "O1") :ok)
-
-(define a1 (refund-approve! env rid))
-(commerce-test "approve-result" a1 :approved)
-(commerce-test "approve-waiting-settle" (order-flow-waiting env rid) "settle")
-
-(define s1 (refund-settle! env b rid "O1" "rf-1" 11 500))
-(commerce-test "settle-result" s1 :settled)
-(commerce-test "settle-flow-done" (order-flow-status env rid) "done")
-(commerce-test
-  "settle-refunded-amount"
-  (order-refunded-amount-of (order-events b "O1"))
-  500)
-;; net 1200 - 500 = 700 < total 1200 -> underpaid (partial refund)
-(commerce-test "settle-recon-underpaid" (order-recon b "O1") :underpaid)
-
-;; --- idempotent settle: replayed provider callback is a no-op ---
-
-(define s1b (refund-settle! env b rid "O1" "rf-1" 11 500))
-(commerce-test "replay-already-settled" s1b :already-settled)
-(commerce-test
-  "replay-refunded-once"
-  (order-refunded-amount-of (order-events b "O1"))
-  500)
-
-;; --- reject path: approval denied, books untouched ---
-
-(define _c2 (order-create b "O2" 1 q1))
-(define _p2 (order-pay b "O2" "pay-2" 2 1200))
-
-(define rid2 (refund-begin! env b "O2" "rf-2" 20 1200))
-(commerce-test
-  "reject-waiting-approve"
-  (order-flow-waiting env rid2)
-  "approve")
-
-(define j2 (refund-reject! env b "O2" rid2 21 "policy"))
-(commerce-test "reject-result" j2 :rejected)
-(commerce-test "reject-flow-not-waiting" (order-flow-waiting env rid2) nil)
-(commerce-test
-  "reject-no-refund"
-  (order-refunded-amount-of (order-events b "O2"))
-  0)
-(commerce-test "reject-recon-ok" (order-recon b "O2") :ok)
-
-;; settling a rejected/cancelled refund does nothing
-(define s2 (refund-settle! env b rid2 "O2" "rf-2" 22 1200))
-(commerce-test "reject-then-settle-noop" s2 :already-settled)
-(commerce-test
-  "reject-still-no-refund"
-  (order-refunded-amount-of (order-events b "O2"))
-  0)
-
-;; --- distinct flow ids ---
-
-(commerce-test "distinct-refund-ids" (not (= rid rid2)) true)

lib/commerce/tests/stack.sx

@@ -1,127 +0,0 @@
-;; lib/commerce/tests/stack.sx — stacking precedence, exclusivity, best price.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "book" 800 :zero-rated)
-      (list "tea" 1000 :reduced))
-    (list)
-    (list)))
-
-(define gctx (make-pricing-context pcat (list) :uk :guest))
-(define mctx (make-pricing-context pcat (list) :uk :member))
-
-(define
-  cart
-  (list
-    (list "widget" :none 3)
-    (list "book" :none 1)
-    (list "tea" :none 6)))
-
-(define
-  ruleset
-  (list
-    (list :percent "TEN" :standard 1000)
-    (list :percent "TWENTY" :standard 2000)
-    (list :fixed "FIVER" 5000 500)
-    (list :bundle "B3T" "tea" 3)
-    (list :member "MEM" :standard 2500)))
-
-;; The three standard-class discounts are mutually exclusive.
-(define
-  exclusions
-  (list (list "TEN" "TWENTY") (list "TEN" "MEM") (list "TWENTY" "MEM")))
-
-;; --- exclusivity predicates ---
-
-(commerce-test
-  "excluded-pair-direct"
-  (excluded-pair? exclusions "TEN" "TWENTY")
-  true)
-(commerce-test
-  "excluded-pair-symmetric"
-  (excluded-pair? exclusions "TWENTY" "TEN")
-  true)
-(commerce-test
-  "excluded-pair-none"
-  (excluded-pair? exclusions "TEN" "FIVER")
-  false)
-(commerce-test
-  "compatible-yes"
-  (compatible? exclusions (list "FIVER" "B3T" "TWENTY"))
-  true)
-(commerce-test
-  "compatible-no"
-  (compatible? exclusions (list "TEN" "TWENTY" "B3T"))
-  false)
-
-;; --- powerset + valid stackings ---
-
-(commerce-test
-  "powerset-size"
-  (len (powerset (list 1 2 3 4)))
-  16)
-
-(define gappl (applicable-promos gctx cart ruleset))
-
-(commerce-test "applicable-guest-count" (len gappl) 4)
-
-;; 16 subsets minus the 4 containing both TEN and TWENTY = 12 legal.
-(commerce-test
-  "valid-stackings-count"
-  (len (valid-stackings exclusions gappl))
-  12)
-
-(commerce-test
-  "stacking-total"
-  (stacking-total (list (list "TWENTY" 600) (list "B3T" 2000)))
-  2600)
-
-;; --- best price (deterministic selection) ---
-
-(commerce-test
-  "best-discount-guest"
-  (best-promo-discount gctx cart ruleset exclusions)
-  3100)
-(commerce-test
-  "best-codes-guest"
-  (best-promo-codes gctx cart ruleset exclusions)
-  (list "TWENTY" "FIVER" "B3T"))
-
-;; exclusivity holds: the cheaper conflicting code is dropped.
-(commerce-test
-  "best-excludes-ten"
-  (some
-    (fn (c) (= c "TEN"))
-    (best-promo-codes gctx cart ruleset exclusions))
-  false)
-
-;; --- member vs guest ---
-
-(commerce-test
-  "best-discount-member"
-  (best-promo-discount mctx cart ruleset exclusions)
-  3250)
-(commerce-test
-  "best-codes-member"
-  (best-promo-codes mctx cart ruleset exclusions)
-  (list "FIVER" "B3T" "MEM"))
-
-;; --- best price backward query (the showcase) ---
-
-(commerce-test
-  "stacking-by-total-backward"
-  (run*
-    codes
-    (stacking-by-totalo (valid-stackings exclusions gappl) codes 3100))
-  (list (list "TWENTY" "FIVER" "B3T")))
-
-;; --- edge: no applicable promos ---
-
-(commerce-test
-  "best-empty"
-  (best-promo-discount gctx empty-cart ruleset exclusions)
-  0)

lib/commerce/tests/stock.sx

@@ -1,122 +0,0 @@
-;; lib/commerce/tests/stock.sx — stock-constrained reservation.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  cat
-  (make-catalog
-    (list
-      (list "widget" 1000 :standard)
-      (list "gadget" 2500 :standard))
-    (list)
-    (list
-      (list "widget" :small 5)
-      (list "widget" :large 0)
-      (list "gadget" :std 12))))
-
-;; --- availability ---
-
-(commerce-test
-  "available-found"
-  (available-stock cat "widget" :small)
-  5)
-(commerce-test
-  "available-zero"
-  (available-stock cat "widget" :large)
-  0)
-(commerce-test
-  "available-absent"
-  (available-stock cat "widget" :none)
-  0)
-
-;; --- per-line reservability ---
-
-(commerce-test
-  "shortfall-fits"
-  (line-shortfall cat (list "widget" :small 5))
-  0)
-(commerce-test
-  "shortfall-over"
-  (line-shortfall cat (list "widget" :small 8))
-  3)
-(commerce-test
-  "reservable-yes"
-  (line-reservable? cat (list "gadget" :std 12))
-  true)
-(commerce-test
-  "reservable-no"
-  (line-reservable? cat (list "widget" :large 1))
-  false)
-
-;; --- cart-level reservation check ---
-
-(commerce-test
-  "can-reserve-yes"
-  (can-reserve?
-    cat
-    (list (list "widget" :small 5) (list "gadget" :std 2)))
-  true)
-
-(commerce-test
-  "can-reserve-no"
-  (can-reserve? cat (list (list "widget" :small 9)))
-  false)
-
-(commerce-test
-  "shortfalls-detail"
-  (reservation-shortfalls
-    cat
-    (list (list "widget" :small 9) (list "gadget" :std 2)))
-  (list {:requested 9 :available 5 :sku "widget" :variant :small :short 4}))
-
-(commerce-test
-  "reserve-check-ok"
-  (reserve-check cat (list (list "gadget" :std 1)))
-  :ok)
-
-(commerce-test
-  "reserve-check-rejected"
-  (reserve-check cat (list (list "widget" :large 1)))
-  {:shortfalls (list {:requested 1 :available 0 :sku "widget" :variant :large :short 1}) :rejected :insufficient-stock})
-
-;; --- reservation view: concurrent holds reduce availability ---
-
-(define held (list (list "widget" :small 3)))
-
-(commerce-test
-  "effective-after-hold"
-  (effective-available cat held "widget" :small)
-  2)
-(commerce-test
-  "effective-other-unaffected"
-  (effective-available cat held "gadget" :std)
-  12)
-(commerce-test
-  "reservable-with-fits"
-  (line-reservable-with? cat held (list "widget" :small 2))
-  true)
-(commerce-test
-  "reservable-with-over"
-  (line-reservable-with? cat held (list "widget" :small 3))
-  false)
-
-;; --- relational availability query (multidirectional) ---
-
-(commerce-test
-  "sufficient-forward"
-  (run*
-    x
-    (fresh () (sufficient-stocko cat "widget" :small 5) (== x true)))
-  (list true))
-
-(commerce-test
-  "sufficient-forward-over"
-  (run*
-    x
-    (fresh () (sufficient-stocko cat "widget" :small 6) (== x true)))
-  (list))
-
-;; backward: which variants of widget can supply 1 unit?
-(commerce-test
-  "variants-supplying-1"
-  (run* v (fresh (q) (stocko cat "widget" v q) (lteo-i 1 q)))
-  (list :small))

lib/commerce/tests/window.sx

@@ -1,112 +0,0 @@
-;; lib/commerce/tests/window.sx — time-windowed promotions.
-;; Uses (commerce-test name got expected) provided by conformance.sh.
-
-(define
-  pcat
-  (make-catalog (list (list "widget" 1000 :standard)) (list) (list)))
-
-(define gctx (make-pricing-context pcat (list) :uk :guest))
-(define cart (list (list "widget" :none 3)))
-
-(define ten (list :percent "TEN" :standard 1000))
-(define twenty (list :percent "TWENTY" :standard 2000))
-(define always (list :fixed "ALWAYS" 0 100))
-
-(define
-  windowed
-  (list
-    (windowed-promo ten 100 200)
-    (windowed-promo twenty 150 300)
-    (windowed-promo always nil nil)))
-
-(define exclusions (list (list "TEN" "TWENTY")))
-
-;; --- wp-active? boundaries (inclusive) ---
-
-(commerce-test
-  "active-at-from"
-  (wp-active? (windowed-promo ten 100 200) 100)
-  true)
-(commerce-test
-  "active-at-until"
-  (wp-active? (windowed-promo ten 100 200) 200)
-  true)
-(commerce-test
-  "inactive-before"
-  (wp-active? (windowed-promo ten 100 200) 99)
-  false)
-(commerce-test
-  "inactive-after"
-  (wp-active? (windowed-promo ten 100 200) 201)
-  false)
-(commerce-test
-  "open-ended-always"
-  (wp-active? (windowed-promo always nil nil) 99999)
-  true)
-(commerce-test
-  "open-lower"
-  (wp-active? (windowed-promo ten nil 200) 1)
-  true)
-(commerce-test
-  "open-upper"
-  (wp-active? (windowed-promo ten 100 nil) 99999)
-  true)
-
-;; --- active-ruleset filtering ---
-
-(commerce-test
-  "active-ruleset-120"
-  (active-ruleset windowed 120)
-  (list ten always))
-(commerce-test
-  "active-ruleset-160"
-  (active-ruleset windowed 160)
-  (list ten twenty always))
-(commerce-test
-  "active-ruleset-250"
-  (active-ruleset windowed 250)
-  (list twenty always))
-(commerce-test
-  "active-ruleset-50"
-  (active-ruleset windowed 50)
-  (list always))
-
-;; --- active-codes (backward query) ---
-
-(commerce-test
-  "active-codes-120"
-  (active-codes windowed 120)
-  (list "TEN" "ALWAYS"))
-(commerce-test
-  "active-codes-160"
-  (active-codes windowed 160)
-  (list "TEN" "TWENTY" "ALWAYS"))
-(commerce-test
-  "active-codes-50"
-  (active-codes windowed 50)
-  (list "ALWAYS"))
-
-;; --- windowed-quote: discount changes with time (deterministic) ---
-;; subtotal 3000, no tax. TEN=300, TWENTY=600, ALWAYS=100; TEN/TWENTY exclusive.
-
-(commerce-test
-  "quote-50"
-  (quote-discount (windowed-quote gctx cart windowed exclusions 50))
-  100)
-(commerce-test
-  "quote-120"
-  (quote-discount (windowed-quote gctx cart windowed exclusions 120))
-  400)
-(commerce-test
-  "quote-160"
-  (quote-discount (windowed-quote gctx cart windowed exclusions 160))
-  700)
-(commerce-test
-  "quote-250"
-  (quote-discount (windowed-quote gctx cart windowed exclusions 250))
-  700)
-
-(commerce-test
-  "quote-total-160"
-  (quote-total (windowed-quote gctx cart windowed exclusions 160))
-  2300)

lib/commerce/window.sx

@@ -1,55 +0,0 @@
-;; lib/commerce/window.sx — time-windowed promotions.
-;;
-;; A promo's validity window is kept SEPARATE from the promo tuple (so promo.sx
-;; is untouched): a windowed promo is (list promo from until) with inclusive
-;; integer timestamps (same time model as the ledger `at`). nil from = no lower
-;; bound; nil until = open-ended.
-;;
-;; `active-ruleset` filters a windowed ruleset to the plain promos live at a
-;; given time, which feeds straight into promo/stack/quote — so a datetime-aware
-;; quote is just the existing pipeline over the active set. Deterministic: the
-;; quote is a pure function of (ctx, cart, windowed-ruleset, exclusions, at).
-
-(define windowed-promo (fn (promo from until) (list promo from until)))
-
-(define wp-promo (fn (wp) (nth wp 0)))
-(define wp-from (fn (wp) (nth wp 1)))
-(define wp-until (fn (wp) (nth wp 2)))
-
-(define
-  wp-active?
-  (fn
-    (wp at)
-    (let
-      ((from (wp-from wp)) (until (wp-until wp)))
-      (and (or (nil? from) (>= at from)) (or (nil? until) (<= at until))))))
-
-;; Plain promo tuples live at time `at` — feed into cart-quote / best-promo-*.
-(define
-  active-ruleset
-  (fn
-    (windowed at)
-    (map wp-promo (filter (fn (wp) (wp-active? wp at)) windowed))))
-
-;; Relation: which promo codes are active at `at`? (backward query)
-(define
-  active-promoo
-  (fn
-    (windowed at code)
-    (fresh
-      (wp)
-      (membero wp windowed)
-      (project
-        (wp)
-        (if (wp-active? wp at) (== code (promo-code (wp-promo wp))) fail)))))
-
-(define
-  active-codes
-  (fn (windowed at) (run* code (active-promoo windowed at code))))
-
-;; Datetime-aware quote: the existing pipeline over the time-active ruleset.
-(define
-  windowed-quote
-  (fn
-    (ctx cart windowed exclusions at)
-    (cart-quote ctx cart (active-ruleset windowed at) exclusions)))

lib/erlang/bench_ring_results.md

@@ -33,54 +33,3 @@ least: persistent (path-copying) envs, an inline scheduler that
 doesn't call/cc on the common path (msg-already-in-mailbox), and a
 linked-list mailbox. None of those are in scope for the Phase 3
 checkbox — captured here as the floor we're starting from.
-
-## Phase 9 status (2026-05-14)
-
-Specialized opcodes 9b–9f landed as **stub dispatchers** in
-`lib/erlang/vm/dispatcher.sx`: `OP_PATTERN_TUPLE/LIST/BINARY`,
-`OP_PERFORM/HANDLE`, `OP_RECEIVE_SCAN`, `OP_SPAWN/SEND`, and ten
-`OP_BIF_*` hot dispatch entries. Each opcode's handler is a thin
-wrapper over the existing `er-match-*` / `er-bif-*` / runtime impls,
-so **the perf numbers above are unchanged** — same per-hop cost, same
-scheduler. The stubs exist to nail down opcode IDs, operand contracts,
-and tests against `er-match!` parity *before* 9a (the OCaml
-opcode-extension mechanism in `hosts/ocaml/evaluator/`) lands.
-
-When 9a integrates and the bytecode compiler can emit these opcodes
-at hot call sites, the real speedup story (~3000× ring throughput,
-~1000× spawn) starts. Until then this file documents the
-pre-integration ceiling. 72 vm-suite tests guard the stub correctness;
-full conformance is **709/709** with the stub infrastructure loaded.
-
-## Phase 9g — post-integration bench (2026-05-15)
-
-9a (vm-ext mechanism), 9h (`erlang_ext.ml` registering `erlang.OP_*`
-ids 222-239), and 9i (SX dispatcher consulting `extension-opcode-id`)
-are now integrated and built into `hosts/ocaml/_build/default/bin/sx_server.exe`.
-Re-ran the ring ladder on that binary:
-
-| N (processes) | Hops | Wall-clock | Throughput |
-|---|---|---|---|
-| 10 | 10 | 938ms | 11 hops/s |
-| 100 | 100 | 2772ms | 36 hops/s |
-| 500 | 500 | 14190ms | 35 hops/s |
-| 1000 | 1000 | 31814ms | 31 hops/s |
-
-**Numbers are unchanged from the pre-integration baseline** — and that
-is the expected, correct result. The opcode handlers (both the SX stub
-dispatcher and the OCaml `erlang_ext` module) wrap the existing
-`er-match-*` / `er-bif-*` / scheduler implementations 1-to-1, and the
-**bytecode compiler does not yet emit `erlang.OP_*` opcodes**, so every
-hop still goes through the general CEK path exactly as before. The
-unchanged numbers therefore double as a no-regression check: the full
-extension wiring (cherry-picked vm-ext A-E + force-link + erlang_ext +
-SX bridge) added zero per-hop cost. Conformance **715/715** on this
-binary.
-
-The ~3000×/~1000× targets remain gated on a **future phase (Phase 10 —
-bytecode emission)**: teach `lib/compiler.sx` (or the Erlang
-transpiler) to emit `erlang.OP_PATTERN_TUPLE` etc. at hot call sites,
-then give `erlang_ext.ml` real register-machine handlers instead of the
-current honest not-wired raise. That is a substantial standalone phase,
-tracked in `plans/erlang-on-sx.md`. 9g's deliverable — *honest
-measurement + recorded numbers on the integrated binary* — is complete.

lib/erlang/conformance.sh

@@ -36,8 +36,6 @@ SUITES=(
   "bank|er-bank-test-pass|er-bank-test-count"
   "echo|er-echo-test-pass|er-echo-test-count"
   "fib|er-fib-test-pass|er-fib-test-count"
-  "ffi|er-ffi-test-pass|er-ffi-test-count"
-  "vm|er-vm-test-pass|er-vm-test-count"
 )
 
 cat > "$TMPFILE" << 'EPOCHS'
@@ -58,9 +56,6 @@ cat > "$TMPFILE" << 'EPOCHS'
 (load "lib/erlang/tests/programs/bank.sx")
 (load "lib/erlang/tests/programs/echo.sx")
 (load "lib/erlang/tests/programs/fib_server.sx")
-(load "lib/erlang/vm/dispatcher.sx")
-(load "lib/erlang/tests/ffi.sx")
-(load "lib/erlang/tests/vm.sx")
 (epoch 100)
 (eval "(list er-test-pass er-test-count)")
 (epoch 101)
@@ -79,10 +74,6 @@ cat > "$TMPFILE" << 'EPOCHS'
 (eval "(list er-echo-test-pass er-echo-test-count)")
 (epoch 108)
 (eval "(list er-fib-test-pass er-fib-test-count)")
-(epoch 109)
-(eval "(list er-ffi-test-pass er-ffi-test-count)")
-(epoch 110)
-(eval "(list er-vm-test-pass er-vm-test-count)")
 EPOCHS
 
 timeout 600 "$SX_SERVER" < "$TMPFILE" > "$OUTFILE" 2>&1

lib/erlang/runtime.sx

@@ -853,112 +853,6 @@
 (define er-modules-get (fn () (nth er-modules 0)))
 (define er-modules-reset! (fn () (set-nth! er-modules 0 {})))
 
-(define er-mk-module-slot
-  (fn (mod-env old-env version)
-    {:current mod-env :old old-env :version version :tag "module"}))
-
-(define er-module-current-env (fn (slot) (get slot :current)))
-(define er-module-old-env (fn (slot) (get slot :old)))
-(define er-module-version (fn (slot) (get slot :version)))
-
-;; ── FFI BIF registry (Phase 8) ───────────────────────────────────
-;; Global dict from "Module/Name/Arity" key to {:module :name :arity :fn :pure?}.
-;; Replaces the giant cond chain in transpile.sx#er-apply-remote-bif over time —
-;; Phase 8 BIFs (crypto / cid / file / httpc / sqlite) all register here.
-(define er-bif-registry (list {}))
-(define er-bif-registry-get (fn () (nth er-bif-registry 0)))
-(define er-bif-registry-reset! (fn () (set-nth! er-bif-registry 0 {})))
-
-(define er-bif-key
-  (fn (module name arity)
-    (str module "/" name "/" arity)))
-
-(define er-register-bif!
-  (fn (module name arity sx-fn)
-    (dict-set! (er-bif-registry-get) (er-bif-key module name arity)
-      {:module module :name name :arity arity :fn sx-fn :pure? false})
-    (er-mk-atom "ok")))
-
-(define er-register-pure-bif!
-  (fn (module name arity sx-fn)
-    (dict-set! (er-bif-registry-get) (er-bif-key module name arity)
-      {:module module :name name :arity arity :fn sx-fn :pure? true})
-    (er-mk-atom "ok")))
-
-(define er-lookup-bif
-  (fn (module name arity)
-    (let ((reg (er-bif-registry-get)) (k (er-bif-key module name arity)))
-      (if (dict-has? reg k) (get reg k) nil))))
-
-(define er-list-bifs
-  (fn () (keys (er-bif-registry-get))))
-
-;; ── term marshalling (Phase 8) ───────────────────────────────────
-;; Bridge Erlang term values (tagged dicts) and SX-native values for
-;; FFI BIFs to call out into platform primitives. Conversions:
-;;
-;;   Erlang                          SX-native
-;;   ─────────────────────────       ────────────────
-;;   atom  {:tag "atom" :name S}  ↔  symbol (make-symbol S)
-;;   nil   {:tag "nil"}           ↔  '()
-;;   cons  {:tag "cons" :head :tail} →  list of marshalled elements
-;;   tuple {:tag "tuple" :elements} →  list of marshalled elements
-;;   binary {:tag "binary" :bytes} ↔ SX string
-;;   integer / float / boolean   ↔ passthrough
-;;   SX string on the way back   →  binary
-;;
-;; Pids, refs, funs pass through unchanged — they have no SX-native
-;; equivalent and are opaque to FFI primitives.
-
-(define er-cons-to-sx-list
-  (fn (v)
-    (cond
-      (er-nil? v) (list)
-      (er-cons? v)
-        (let ((tail (er-cons-to-sx-list (get v :tail)))
-              (head (er-to-sx (get v :head))))
-          (let ((out (list head)))
-            (for-each
-              (fn (i) (append! out (nth tail i)))
-              (range 0 (len tail)))
-            out))
-      :else (list v))))
-
-(define er-to-sx
-  (fn (v)
-    (cond
-      (er-atom? v) (make-symbol (get v :name))
-      (er-nil? v) (list)
-      (er-cons? v) (er-cons-to-sx-list v)
-      (er-tuple? v)
-        (let ((out (list)) (es (get v :elements)))
-          (for-each
-            (fn (i) (append! out (er-to-sx (nth es i))))
-            (range 0 (len es)))
-          out)
-      (er-binary? v) (list->string (map integer->char (get v :bytes)))
-      :else v)))
-
-(define er-of-sx
-  (fn (v)
-    (let ((ty (type-of v)))
-      (cond
-        (= ty "symbol") (er-mk-atom (str v))
-        (= ty "string") (er-mk-binary (map char->integer (string->list v)))
-        (= ty "list")
-          (let ((out (er-mk-nil)))
-            (for-each
-              (fn (i)
-                (set! out
-                  (er-mk-cons (er-of-sx (nth v (- (- (len v) 1) i))) out)))
-              (range 0 (len v)))
-            out)
-        (= ty "nil") (er-mk-nil)
-        :else v))))
-
-
-
-
 ;; Load an Erlang module declaration. Source must start with
 ;; `-module(Name).` and contain function definitions. Functions
 ;; sharing a name (different arities) get their clauses concatenated
@@ -1003,15 +897,7 @@
               ((all-clauses (get by-name k)))
               (er-env-bind! mod-env k (er-mk-fun all-clauses mod-env))))
           (keys by-name))
-        (let ((registry (er-modules-get)))
-          (if (dict-has? registry mod-name)
-            (let ((existing-slot (get registry mod-name)))
-              (dict-set! registry mod-name
-                (er-mk-module-slot mod-env
-                  (er-module-current-env existing-slot)
-                  (+ (er-module-version existing-slot) 1))))
-            (dict-set! registry mod-name
-              (er-mk-module-slot mod-env nil 1))))
+        (dict-set! (er-modules-get) mod-name mod-env)
         (er-mk-atom mod-name)))))
 
 (define
@@ -1019,7 +905,7 @@
   (fn
     (mod name vs)
     (let
-      ((mod-env (er-module-current-env (get (er-modules-get) mod))))
+      ((mod-env (get (er-modules-get) mod)))
       (if
         (not (dict-has? mod-env name))
         (raise
@@ -1303,325 +1189,16 @@
           :else (er-mk-atom "undefined")))
       :else (error "Erlang: ets:info: arity"))))
 
-
-
-;; ── file module (Phase 8 FFI) ────────────────────────────────────
-;; Synchronous file IO. Filenames must be SX strings (or Erlang
-;; binaries/char-code lists coercible to strings via er-source-to-string).
-;; Returns `{ok, Binary}` / `ok` on success, `{error, Reason}` on failure
-;; where Reason is one of `enoent`, `eacces`, `enotdir`, `posix_error`.
-
-(define er-classify-file-error
-  (fn (msg)
-    (let ((s (str msg)))
-      (cond
-        (string-contains? s "No such") (er-mk-atom "enoent")
-        (string-contains? s "Permission denied") (er-mk-atom "eacces")
-        (string-contains? s "Not a directory") (er-mk-atom "enotdir")
-        (string-contains? s "Is a directory") (er-mk-atom "eisdir")
-        :else (er-mk-atom "posix_error")))))
-
-(define er-bif-file-read-file
-  (fn (vs)
-    (let ((path (er-source-to-string (nth vs 0))))
-      (cond
-        (= path nil)
-          (er-mk-tuple (list (er-mk-atom "error") (er-mk-atom "badarg")))
-        :else
-          (let ((res (list nil)) (err (list nil)))
-            (guard (c (:else (set-nth! err 0 c)))
-              (set-nth! res 0 (file-read path)))
-            (cond
-              (not (= (nth err 0) nil))
-                (er-mk-tuple (list (er-mk-atom "error")
-                  (er-classify-file-error (nth err 0))))
-              :else
-                (er-mk-tuple (list (er-mk-atom "ok")
-                  (er-mk-binary (map char->integer (string->list (nth res 0)))))))))))) 
-
-(define er-bif-file-write-file
-  (fn (vs)
-    (let ((path (er-source-to-string (nth vs 0)))
-          (data (er-source-to-string (nth vs 1))))
-      (cond
-        (or (= path nil) (= data nil))
-          (er-mk-tuple (list (er-mk-atom "error") (er-mk-atom "badarg")))
-        :else
-          (let ((err (list nil)))
-            (guard (c (:else (set-nth! err 0 c)))
-              (file-write path data))
-            (cond
-              (not (= (nth err 0) nil))
-                (er-mk-tuple (list (er-mk-atom "error")
-                  (er-classify-file-error (nth err 0))))
-              :else (er-mk-atom "ok")))))))
-
-(define er-bif-file-delete
-  (fn (vs)
-    (let ((path (er-source-to-string (nth vs 0))))
-      (cond
-        (= path nil)
-          (er-mk-tuple (list (er-mk-atom "error") (er-mk-atom "badarg")))
-        :else
-          (let ((err (list nil)))
-            (guard (c (:else (set-nth! err 0 c)))
-              (file-delete path))
-            (cond
-              (not (= (nth err 0) nil))
-                (er-mk-tuple (list (er-mk-atom "error")
-                  (er-classify-file-error (nth err 0))))
-              :else (er-mk-atom "ok")))))))
-
-
-;; ── crypto / cid / file:list_dir (Phase 8 FFI — host primitives) ──
-;; Wired against loops/fed-prims host primitives (see plans Blockers
-;; "RESOLVED 2026-05-18"). Term marshalling at the boundary:
-;; Erlang binary/string/charlist -> SX byte-string via er-source-to-string;
-;; results -> Erlang binary via er-mk-binary.
-
-(define er-hexval
-  (fn (c)
-    (let ((v (char->integer c)))
-      (cond
-        (and (>= v 48) (<= v 57)) (- v 48)        ;; 0-9
-        (and (>= v 97) (<= v 102)) (+ 10 (- v 97)) ;; a-f
-        (and (>= v 65) (<= v 70)) (+ 10 (- v 65))  ;; A-F
-        :else 0))))
-
-(define er-hex->bytes
-  (fn (hex)
-    (let ((cs (string->list hex)) (out (list)) (n (string-length hex)))
-      (for-each
-        (fn (i)
-          (append! out
-            (+ (* 16 (er-hexval (nth cs (* i 2))))
-               (er-hexval (nth cs (+ (* i 2) 1))))))
-        (range 0 (truncate (/ n 2))))
-      out)))
-
-;; crypto:hash(Type, Data) -> raw digest binary. Type is an Erlang
-;; atom (sha256 | sha512 | sha3_256). Bad type / non-binary -> badarg.
-(define er-bif-crypto-hash
-  (fn (vs)
-    (let ((ty (nth vs 0)) (data (er-source-to-string (nth vs 1))))
-      (cond
-        (or (not (er-atom? ty)) (= data nil))
-          (raise (er-mk-error-marker (er-mk-atom "badarg")))
-        :else
-          (let ((name (get ty :name)))
-            (let ((hex (cond
-                         (= name "sha256") (crypto-sha256 data)
-                         (= name "sha512") (crypto-sha512 data)
-                         (= name "sha3_256") (crypto-sha3-256 data)
-                         :else nil)))
-              (cond
-                (= hex nil) (raise (er-mk-error-marker (er-mk-atom "badarg")))
-                :else (er-mk-binary (er-hex->bytes hex)))))))))
-
-;; cid:from_bytes(Bin) -> CIDv1 (raw codec 0x55, sha2-256 multihash)
-;; as an Erlang binary string.
-(define er-bif-cid-from-bytes
-  (fn (vs)
-    (let ((data (er-source-to-string (nth vs 0))))
-      (cond
-        (= data nil) (raise (er-mk-error-marker (er-mk-atom "badarg")))
-        :else
-          (let ((digest (er-hex->bytes (crypto-sha256 data))))
-            (let ((mh (list->string
-                        (map integer->char (append (list 18 32) digest)))))
-              (er-mk-binary
-                (map char->integer
-                  (string->list (cid-from-bytes 85 mh))))))))))
-
-;; cid:to_string(Term) -> canonical CIDv1 (dag-cbor) of the term,
-;; as an Erlang binary string.
-(define er-bif-cid-to-string
-  (fn (vs)
-    ;; Canonical CID of the term's stable string form. (cbor-encode
-    ;; rejects symbols, so er-to-sx of compound terms is unencodable;
-    ;; er-format-value yields a canonical SX string per term value.)
-    (er-mk-binary
-      (map char->integer
-        (string->list (cid-from-sx (er-format-value (nth vs 0))))))))
-
-;; file:list_dir(Path) -> {ok, [Binary]} | {error, Reason}
-(define er-bif-file-list-dir
-  (fn (vs)
-    (let ((path (er-source-to-string (nth vs 0))))
-      (cond
-        (= path nil)
-          (er-mk-tuple (list (er-mk-atom "error") (er-mk-atom "badarg")))
-        :else
-          (let ((res (list nil)) (err (list nil)))
-            (guard (c (:else (set-nth! err 0 c)))
-              (set-nth! res 0 (file-list-dir path)))
-            (cond
-              (not (= (nth err 0) nil))
-                (er-mk-tuple (list (er-mk-atom "error")
-                  (er-classify-file-error (nth err 0))))
-              :else
-                (er-mk-tuple (list (er-mk-atom "ok")
-                  (er-of-sx (nth res 0))))))))))
-
-;; ── builtin BIF registrations (Phase 8 migration) ────────────────
-;; Populates `er-bif-registry` with every existing built-in BIF. Each
-;; entry is keyed by "Module/Name/Arity"; multi-arity BIFs register
-;; once per arity. Called eagerly at the end of runtime.sx so the
-;; registry is ready before any erlang-eval-ast call.
-(define er-register-builtin-bifs!
-  (fn ()
-    ;; erlang module — type predicates (all pure)
-    (er-register-pure-bif! "erlang" "is_integer" 1 er-bif-is-integer)
-    (er-register-pure-bif! "erlang" "is_atom" 1 er-bif-is-atom)
-    (er-register-pure-bif! "erlang" "is_list" 1 er-bif-is-list)
-    (er-register-pure-bif! "erlang" "is_tuple" 1 er-bif-is-tuple)
-    (er-register-pure-bif! "erlang" "is_number" 1 er-bif-is-number)
-    (er-register-pure-bif! "erlang" "is_float" 1 er-bif-is-float)
-    (er-register-pure-bif! "erlang" "is_boolean" 1 er-bif-is-boolean)
-    (er-register-pure-bif! "erlang" "is_pid" 1 er-bif-is-pid)
-    (er-register-pure-bif! "erlang" "is_reference" 1 er-bif-is-reference)
-    (er-register-pure-bif! "erlang" "is_binary" 1 er-bif-is-binary)
-    (er-register-pure-bif! "erlang" "is_function" 1 er-bif-is-function)
-    (er-register-pure-bif! "erlang" "is_function" 2 er-bif-is-function)
-    ;; erlang module — pure data ops
-    (er-register-pure-bif! "erlang" "length" 1 er-bif-length)
-    (er-register-pure-bif! "erlang" "hd" 1 er-bif-hd)
-    (er-register-pure-bif! "erlang" "tl" 1 er-bif-tl)
-    (er-register-pure-bif! "erlang" "element" 2 er-bif-element)
-    (er-register-pure-bif! "erlang" "tuple_size" 1 er-bif-tuple-size)
-    (er-register-pure-bif! "erlang" "byte_size" 1 er-bif-byte-size)
-    (er-register-pure-bif! "erlang" "atom_to_list" 1 er-bif-atom-to-list)
-    (er-register-pure-bif! "erlang" "list_to_atom" 1 er-bif-list-to-atom)
-    (er-register-pure-bif! "erlang" "abs" 1 er-bif-abs)
-    (er-register-pure-bif! "erlang" "min" 2 er-bif-min)
-    (er-register-pure-bif! "erlang" "max" 2 er-bif-max)
-    (er-register-pure-bif! "erlang" "tuple_to_list" 1 er-bif-tuple-to-list)
-    (er-register-pure-bif! "erlang" "list_to_tuple" 1 er-bif-list-to-tuple)
-    (er-register-pure-bif! "erlang" "integer_to_list" 1 er-bif-integer-to-list)
-    (er-register-pure-bif! "erlang" "list_to_integer" 1 er-bif-list-to-integer)
-    ;; erlang module — process / runtime (side-effecting)
-    (er-register-bif! "erlang" "self" 0 er-bif-self)
-    (er-register-bif! "erlang" "spawn" 1 er-bif-spawn)
-    (er-register-bif! "erlang" "spawn" 3 er-bif-spawn)
-    (er-register-bif! "erlang" "exit" 1 er-bif-exit)
-    (er-register-bif! "erlang" "exit" 2 er-bif-exit)
-    (er-register-bif! "erlang" "make_ref" 0 er-bif-make-ref)
-    (er-register-bif! "erlang" "link" 1 er-bif-link)
-    (er-register-bif! "erlang" "unlink" 1 er-bif-unlink)
-    (er-register-bif! "erlang" "monitor" 2 er-bif-monitor)
-    (er-register-bif! "erlang" "demonitor" 1 er-bif-demonitor)
-    (er-register-bif! "erlang" "process_flag" 2 er-bif-process-flag)
-    (er-register-bif! "erlang" "register" 2 er-bif-register)
-    (er-register-bif! "erlang" "unregister" 1 er-bif-unregister)
-    (er-register-bif! "erlang" "whereis" 1 er-bif-whereis)
-    (er-register-bif! "erlang" "registered" 0 er-bif-registered)
-    ;; erlang module — exception raising (modelled as side-effecting)
-    (er-register-bif! "erlang" "throw" 1
-      (fn (vs) (raise (er-mk-throw-marker (er-bif-arg1 vs "throw")))))
-    (er-register-bif! "erlang" "error" 1
-      (fn (vs) (raise (er-mk-error-marker (er-bif-arg1 vs "error")))))
-    ;; lists module — all pure
-    (er-register-pure-bif! "lists" "reverse" 1 er-bif-lists-reverse)
-    (er-register-pure-bif! "lists" "map" 2 er-bif-lists-map)
-    (er-register-pure-bif! "lists" "foldl" 3 er-bif-lists-foldl)
-    (er-register-pure-bif! "lists" "seq" 2 er-bif-lists-seq)
-    (er-register-pure-bif! "lists" "seq" 3 er-bif-lists-seq)
-    (er-register-pure-bif! "lists" "sum" 1 er-bif-lists-sum)
-    (er-register-pure-bif! "lists" "nth" 2 er-bif-lists-nth)
-    (er-register-pure-bif! "lists" "last" 1 er-bif-lists-last)
-    (er-register-pure-bif! "lists" "member" 2 er-bif-lists-member)
-    (er-register-pure-bif! "lists" "append" 2 er-bif-lists-append)
-    (er-register-pure-bif! "lists" "filter" 2 er-bif-lists-filter)
-    (er-register-pure-bif! "lists" "any" 2 er-bif-lists-any)
-    (er-register-pure-bif! "lists" "all" 2 er-bif-lists-all)
-    (er-register-pure-bif! "lists" "duplicate" 2 er-bif-lists-duplicate)
-    ;; io module — side-effecting (writes to io buffer)
-    (er-register-bif! "io" "format" 1 er-bif-io-format)
-    (er-register-bif! "io" "format" 2 er-bif-io-format)
-    ;; ets module — side-effecting (mutates table state)
-    (er-register-bif! "ets" "new" 2 er-bif-ets-new)
-    (er-register-bif! "ets" "insert" 2 er-bif-ets-insert)
-    (er-register-bif! "ets" "lookup" 2 er-bif-ets-lookup)
-    (er-register-bif! "ets" "delete" 1 er-bif-ets-delete)
-    (er-register-bif! "ets" "delete" 2 er-bif-ets-delete)
-    (er-register-bif! "ets" "tab2list" 1 er-bif-ets-tab2list)
-    (er-register-bif! "ets" "info" 2 er-bif-ets-info)
-    ;; code module — side-effecting (mutates module registry, kills procs)
-    (er-register-bif! "code" "load_binary" 3 er-bif-code-load-binary)
-    (er-register-bif! "code" "purge" 1 er-bif-code-purge)
-    (er-register-bif! "code" "soft_purge" 1 er-bif-code-soft-purge)
-    (er-register-bif! "code" "which" 1 er-bif-code-which)
-    (er-register-bif! "code" "is_loaded" 1 er-bif-code-is-loaded)
-    (er-register-bif! "code" "all_loaded" 0 er-bif-code-all-loaded)
-    ;; file module
-    (er-register-bif! "file" "read_file" 1 er-bif-file-read-file)
-    (er-register-bif! "file" "write_file" 2 er-bif-file-write-file)
-    (er-register-bif! "file" "delete" 1 er-bif-file-delete)
-    ;; Phase 8 FFI — host-primitive BIFs (loops/fed-prims)
-    (er-register-pure-bif! "crypto" "hash" 2 er-bif-crypto-hash)
-    (er-register-pure-bif! "cid" "from_bytes" 1 er-bif-cid-from-bytes)
-    (er-register-pure-bif! "cid" "to_string" 1 er-bif-cid-to-string)
-
-;; ── binary_to_list / list_to_binary (Step 3b — term codec) ──────
-;; Standard Erlang semantics:
-;;   binary_to_list(<<B1,B2,...>>) -> [B1, B2, ...]   (Erlang cons of ints)
-;;   list_to_binary(IoList)        -> <<...>>         (flattens nested
-;;     iolists; elements are byte ints 0-255 or binaries)
-;; Bad arg / out-of-range byte / non-iolist element -> error:badarg.
-
-(define er-bif-binary-to-list
-  (fn (vs)
-    (let ((v (nth vs 0)))
-      (cond
-        (not (er-binary? v))
-          (raise (er-mk-error-marker (er-mk-atom "badarg")))
-        :else
-          (let ((bs (get v :bytes)) (out (er-mk-nil)))
-            (for-each
-              (fn (i)
-                (set! out (er-mk-cons (nth bs (- (- (len bs) 1) i)) out)))
-              (range 0 (len bs)))
-            out)))))
-
-;; Walk an Erlang iolist, appending bytes to `acc` (a mutable SX list).
-;; Accepts: nil, cons-of-X, binary, integer in 0..255. Anything else
-;; signals failure by setting (nth fail 0) to true.
-(define er-iolist-walk!
-  (fn (v acc fail)
+(define
+  er-apply-ets-bif
+  (fn
+    (name vs)
     (cond
-      (nth fail 0) nil
-      (er-nil? v) nil
-      (er-cons? v)
-        (do (er-iolist-walk! (get v :head) acc fail)
-            (er-iolist-walk! (get v :tail) acc fail))
-      (er-binary? v)
-        (for-each
-          (fn (i) (append! acc (nth (get v :bytes) i)))
-          (range 0 (len (get v :bytes))))
-      (= (type-of v) "number")
-        (cond
-          (and (>= v 0) (<= v 255)) (append! acc v)
-          :else (set-nth! fail 0 true))
-      :else (set-nth! fail 0 true))))
-
-(define er-bif-list-to-binary
-  (fn (vs)
-    (let ((v (nth vs 0)) (acc (list)) (fail (list false)))
-      (cond
-        (not (or (er-nil? v) (er-cons? v) (er-binary? v)))
-          (raise (er-mk-error-marker (er-mk-atom "badarg")))
-        :else
-          (do
-            (er-iolist-walk! v acc fail)
-            (cond
-              (nth fail 0)
-                (raise (er-mk-error-marker (er-mk-atom "badarg")))
-              :else (er-mk-binary acc)))))))
-
-    (er-register-bif! "file" "list_dir" 1 er-bif-file-list-dir)
-    (er-register-pure-bif! "erlang" "binary_to_list" 1 er-bif-binary-to-list)
-    (er-register-pure-bif! "erlang" "list_to_binary"  1 er-bif-list-to-binary)
-    (er-mk-atom "ok")))
-
-;; Register everything at load time.
-(er-register-builtin-bifs!)
+      (= name "new") (er-bif-ets-new vs)
+      (= name "insert") (er-bif-ets-insert vs)
+      (= name "lookup") (er-bif-ets-lookup vs)
+      (= name "delete") (er-bif-ets-delete vs)
+      (= name "tab2list") (er-bif-ets-tab2list vs)
+      (= name "info") (er-bif-ets-info vs)
+      :else (error
+        (str "Erlang: undefined 'ets:" name "/" (len vs) "'")))))

lib/erlang/scoreboard.json

@@ -1,18 +1,16 @@
 {
   "language": "erlang",
-  "total_pass": 761,
-  "total": 761,
+  "total_pass": 530,
+  "total": 530,
   "suites": [
     {"name":"tokenize","pass":62,"total":62,"status":"ok"},
     {"name":"parse","pass":52,"total":52,"status":"ok"},
-    {"name":"eval","pass":408,"total":408,"status":"ok"},
-    {"name":"runtime","pass":93,"total":93,"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":"ffi","pass":37,"total":37,"status":"ok"},
-    {"name":"vm","pass":78,"total":78,"status":"ok"}
+    {"name":"fib","pass":8,"total":8,"status":"ok"}
   ]
 }

lib/erlang/scoreboard.md

@@ -1,20 +1,18 @@
 # Erlang-on-SX Scoreboard
 
-**Total: 761 / 761 tests passing**
+**Total: 530 / 530 tests passing**
 
 |  | Suite | Pass | Total |
 |---|---|---|---|
 | ✅ | tokenize | 62 | 62 |
 | ✅ | parse | 52 | 52 |
-| ✅ | eval | 408 | 408 |
-| ✅ | runtime | 93 | 93 |
+| ✅ | eval | 346 | 346 |
+| ✅ | runtime | 39 | 39 |
 | ✅ | ring | 4 | 4 |
 | ✅ | ping-pong | 4 | 4 |
 | ✅ | bank | 8 | 8 |
 | ✅ | echo | 7 | 7 |
 | ✅ | fib | 8 | 8 |
-| ✅ | ffi | 37 | 37 |
-| ✅ | vm | 78 | 78 |
 
 
 Generated by `lib/erlang/conformance.sh`.

lib/erlang/tests/eval.sx

@@ -228,10 +228,9 @@
 (er-eval-test "tuple_size 0" (ev "tuple_size({})") 0)
 
 ;; ── BIFs: atom / list conversions ───────────────────────────────
-(er-eval-test "atom_to_list -> charlist length" (ev "length(atom_to_list(hello))") 5)
-(er-eval-test "atom_to_list -> head $h" (ev "hd(atom_to_list(hello))") 104)
+(er-eval-test "atom_to_list" (ev "atom_to_list(hello)") "hello")
 (er-eval-test "list_to_atom roundtrip"
-  (nm (ev "list_to_atom(atom_to_list(foo))")) "foo")  ;; round-trip via charlist
+  (nm (ev "list_to_atom(atom_to_list(foo))")) "foo")
 (er-eval-test "list_to_atom fresh"
   (nm (ev "list_to_atom(\"bar\")")) "bar")
 
@@ -1061,13 +1060,11 @@
 (er-eval-test "list_to_tuple roundtrip"
   (ev "tuple_size(list_to_tuple([10, 20, 30]))") 3)
 
-(er-eval-test "integer_to_list -> charlist length" (ev "length(integer_to_list(42))") 2)
-(er-eval-test "integer_to_list 42 head $4" (ev "hd(integer_to_list(42))") 52)
-(er-eval-test "integer_to_list neg -> charlist length" (ev "length(integer_to_list(-99))") 3)
-(er-eval-test "integer_to_list -99 head $-" (ev "hd(integer_to_list(-99))") 45)
+(er-eval-test "integer_to_list" (ev "integer_to_list(42)") "42")
+(er-eval-test "integer_to_list neg" (ev "integer_to_list(-99)") "-99")
 (er-eval-test "list_to_integer" (ev "list_to_integer(\"123\")") 123)
 (er-eval-test "list_to_integer roundtrip"
-  (ev "list_to_integer(integer_to_list(7))") 7)  ;; round-trip via charlist
+  (ev "list_to_integer(integer_to_list(7))") 7)
 
 (er-eval-test "is_function fun"
   (nm (ev "F = fun (X) -> X end, is_function(F)")) "true")
@@ -1128,258 +1125,6 @@
 (er-eval-test "lists:duplicate val"
   (nm (ev "hd(lists:duplicate(3, marker))")) "marker")
 
-
-;; ── Phase 7: code:load_binary/3 ───────────────────────────────
-(er-modules-reset!)
-
-(er-eval-test "code:load_binary ok tag"
-  (nm (ev "element(1, code:load_binary(cl1, \"cl1.erl\", \"-module(cl1). foo() -> 1.\"))"))
-  "module")
-(er-eval-test "code:load_binary ok name"
-  (nm (ev "element(2, code:load_binary(cl1, \"cl1.erl\", \"-module(cl1). foo() -> 1.\"))"))
-  "cl1")
-(er-eval-test "code:load_binary then call"
-  (ev "cl1:foo()") 1)
-
-(er-eval-test "code:load_binary reload v2"
-  (ev "code:load_binary(cl1, \"cl1.erl\", \"-module(cl1). foo() -> 99.\"), cl1:foo()")
-  99)
-
-(er-eval-test "code:load_binary name mismatch tag"
-  (nm (ev "element(1, code:load_binary(cl2, \"x.erl\", \"-module(other). f() -> 0.\"))"))
-  "error")
-(er-eval-test "code:load_binary name mismatch reason"
-  (nm (ev "element(2, code:load_binary(cl2, \"x.erl\", \"-module(other). f() -> 0.\"))"))
-  "module_name_mismatch")
-
-(er-eval-test "code:load_binary badfile on garbage"
-  (nm (ev "element(2, code:load_binary(cl3, \"x.erl\", \"this is not erlang\"))"))
-  "badfile")
-
-(er-eval-test "code:load_binary non-atom mod is badarg"
-  (nm (ev "element(2, code:load_binary(\"cl1\", \"x.erl\", \"-module(cl1). f() -> 0.\"))"))
-  "badarg")
-
-
-;; ── Phase 7: code:purge/1 + code:soft_purge/1 ───────────────────
-(er-modules-reset!)
-
-;; purge unknown module → false
-(er-eval-test "code:purge unknown"
-  (nm (ev "code:purge(nope)")) "false")
-
-;; load, then purge without old version → false (nothing to purge)
-(er-eval-test "code:purge no old"
-  (nm (ev "code:load_binary(pg1, \"pg1\", \"-module(pg1). v() -> 1.\"), code:purge(pg1)"))
-  "false")
-
-;; load v1, load v2 (creates :old), purge with no live procs → true
-(er-eval-test "code:purge after reload"
-  (nm (ev "code:load_binary(pg2, \"pg2\", \"-module(pg2). v() -> 1.\"), code:load_binary(pg2, \"pg2\", \"-module(pg2). v() -> 2.\"), code:purge(pg2)"))
-  "true")
-
-;; idempotent: purging again returns false (already purged)
-(er-eval-test "code:purge twice"
-  (nm (ev "code:load_binary(pg3, \"pg3\", \"-module(pg3). v() -> 1.\"), code:load_binary(pg3, \"pg3\", \"-module(pg3). v() -> 2.\"), code:purge(pg3), code:purge(pg3)"))
-  "false")
-
-;; purge returns true whenever an :old slot exists, regardless of process tracking
-;; (proper "kill lingering" semantics requires spawn/3 which is still stubbed)
-(er-eval-test "code:purge with old slot present"
-  (nm (ev "code:load_binary(pg4, \"pg4\", \"-module(pg4). loop() -> receive stop -> ok end.\"),
-           Pid = spawn(fun () -> pg4:loop() end),
-           code:load_binary(pg4, \"pg4\", \"-module(pg4). loop() -> receive stop -> done end.\"),
-           code:purge(pg4)"))
-  "true")
-
-;; soft_purge unknown → true (nothing to purge)
-(er-eval-test "code:soft_purge unknown"
-  (nm (ev "code:soft_purge(nope)")) "true")
-
-;; soft_purge with no old version → true
-(er-eval-test "code:soft_purge no old"
-  (nm (ev "code:load_binary(sp1, \"sp1\", \"-module(sp1). v() -> 1.\"), code:soft_purge(sp1)"))
-  "true")
-
-;; soft_purge with old + no lingering procs → true (clears :old)
-(er-eval-test "code:soft_purge clean"
-  (nm (ev "code:load_binary(sp2, \"sp2\", \"-module(sp2). v() -> 1.\"), code:load_binary(sp2, \"sp2\", \"-module(sp2). v() -> 2.\"), code:soft_purge(sp2)"))
-  "true")
-
-;; non-atom Mod is badarg (raise)
-(er-eval-test "code:purge badarg"
-  (nm (ev "try code:purge(\"str\") catch error:badarg -> ok end")) "ok")
-(er-eval-test "code:soft_purge badarg"
-  (nm (ev "try code:soft_purge(123) catch error:badarg -> ok end")) "ok")
-
-
-;; ── Phase 7: code:which/1 + code:is_loaded/1 + code:all_loaded/0 ──
-(er-modules-reset!)
-
-(er-eval-test "code:which non_existing"
-  (nm (ev "code:which(nope)")) "non_existing")
-
-(er-eval-test "code:which after load"
-  (nm (ev "code:load_binary(wh1, \"wh1\", \"-module(wh1). v() -> 1.\"), code:which(wh1)"))
-  "loaded")
-
-(er-eval-test "code:is_loaded missing"
-  (nm (ev "code:is_loaded(nope)")) "false")
-
-(er-eval-test "code:is_loaded tag"
-  (nm (ev "code:load_binary(il1, \"il1\", \"-module(il1). v() -> 1.\"), element(1, code:is_loaded(il1))"))
-  "file")
-
-(er-eval-test "code:is_loaded value"
-  (nm (ev "code:load_binary(il2, \"il2\", \"-module(il2). v() -> 1.\"), element(2, code:is_loaded(il2))"))
-  "loaded")
-
-(er-modules-reset!)
-(er-eval-test "code:all_loaded empty"
-  (ev "length(code:all_loaded())") 0)
-
-(er-modules-reset!)
-(er-eval-test "code:all_loaded count"
-  (ev "code:load_binary(al1, \"al1\", \"-module(al1). v() -> 1.\"),
-       code:load_binary(al2, \"al2\", \"-module(al2). v() -> 1.\"),
-       length(code:all_loaded())")
-  2)
-
-(er-eval-test "code:all_loaded first entry tag"
-  (nm (ev "code:load_binary(al3, \"al3\", \"-module(al3). v() -> 1.\"),
-           element(2, hd(code:all_loaded()))"))
-  "loaded")
-
-(er-eval-test "code:which badarg"
-  (nm (ev "try code:which(\"str\") catch error:badarg -> ok end")) "ok")
-(er-eval-test "code:is_loaded badarg"
-  (nm (ev "try code:is_loaded(123) catch error:badarg -> ok end")) "ok")
-
-
-;; ── Phase 7: hot-reload call dispatch semantics ──────────────────
-;; Cross-module M:F() calls always hit the CURRENT version;
-;; local F() calls inside a module body resolve through the env
-;; the function closed over (i.e. the version it was loaded with).
-
-(er-modules-reset!)
-
-;; M:F always hits current
-(er-eval-test "cross-mod after reload v2"
-  (ev "code:load_binary(hr1, \"hr1\", \"-module(hr1). f() -> 1.\"),
-       code:load_binary(hr1, \"hr1\", \"-module(hr1). f() -> 2.\"),
-       hr1:f()")
-  2)
-
-;; Local call inside reloaded module body resolves via fresh mod-env
-;; (a() does a local b(); b() got upgraded too)
-(er-eval-test "local call inside reloaded module body"
-  (ev "code:load_binary(hr2, \"hr2\", \"-module(hr2). a() -> b(). b() -> 1.\"),
-       code:load_binary(hr2, \"hr2\", \"-module(hr2). a() -> b(). b() -> 99.\"),
-       hr2:a()")
-  99)
-
-;; Fun captured BEFORE reload, with local-call body, keeps v1 semantics
-(er-eval-test "captured fun keeps closed-over env (local call)"
-  (ev "code:load_binary(hr3, \"hr3\", \"-module(hr3). get_fn() -> fun () -> b() end. b() -> 1.\"),
-       Fn = hr3:get_fn(),
-       code:load_binary(hr3, \"hr3\", \"-module(hr3). get_fn() -> fun () -> b() end. b() -> 99.\"),
-       Fn()")
-  1)
-
-;; Fun captured BEFORE reload, with CROSS-mod body, sees v2's current
-(er-eval-test "captured fun follows cross-mod to current"
-  (ev "code:load_binary(hr4, \"hr4\", \"-module(hr4). get_xref() -> fun () -> hr4:b() end. b() -> 1.\"),
-       Fn = hr4:get_xref(),
-       code:load_binary(hr4, \"hr4\", \"-module(hr4). get_xref() -> fun () -> hr4:b() end. b() -> 99.\"),
-       Fn()")
-  99)
-
-;; Two captured funs from two different vintages
-(er-eval-test "two funs from two vintages stay independent"
-  (ev "code:load_binary(hr5, \"hr5\", \"-module(hr5). gf() -> fun () -> v() end. v() -> 10.\"),
-       F1 = hr5:gf(),
-       code:load_binary(hr5, \"hr5\", \"-module(hr5). gf() -> fun () -> v() end. v() -> 20.\"),
-       F2 = hr5:gf(),
-       F1() + F2()")
-  30)
-
-;; Version slot bumps correctly when a captured fun stays alive
-(er-eval-test "version bumps despite captured funs"
-  (ev "code:load_binary(hr6, \"hr6\", \"-module(hr6). gf() -> fun () -> v() end. v() -> 1.\"),
-       _Pinned = hr6:gf(),
-       code:load_binary(hr6, \"hr6\", \"-module(hr6). gf() -> fun () -> v() end. v() -> 2.\"),
-       code:load_binary(hr6, \"hr6\", \"-module(hr6). gf() -> fun () -> v() end. v() -> 3.\"),
-       hr6:v()")
-  3)
-
-
-
-;; ── Phase 7 capstone: full hot-reload ladder ───────────────────
-;; Load v1 → spawn from inside module → load v2 → cross-mod hits v2 →
-;; local call inside v1 process still resolves v1 → soft_purge refuses
-;; while v1 procs alive → purge kills them.
-;;
-;; All stages must run in a single erlang-eval-ast call: each call resets
-;; the scheduler (er-sched-init!) so cross-call Pid handles would point at
-;; reaped processes.
-(er-modules-reset!)
-
-(define er-rt-cap-prog "code:load_binary(cap, \"cap.erl\", \"-module(cap). start() -> spawn(fun () -> loop() end). loop() -> receive {ping, From} -> From ! {pong, v1}, loop(); stop -> done end. tag() -> v1.\"), Tag1 = cap:tag(), Pid1 = cap:start(), code:load_binary(cap, \"cap.erl\", \"-module(cap). start() -> spawn(fun () -> loop() end). loop() -> receive {ping, From} -> From ! {pong, v2}, loop(); stop -> done end. tag() -> v2.\"), Tag2 = cap:tag(), _Pid2 = cap:start(), Soft1 = code:soft_purge(cap), Hard = code:purge(cap), Soft2 = code:soft_purge(cap), {Tag1, Tag2, Soft1, Hard, Soft2}")
-
-(define er-rt-cap-result (ev er-rt-cap-prog))
-
-(er-eval-test "capstone v1 tag direct"
-  (get (nth (get er-rt-cap-result :elements) 0) :name) "v1")
-
-(er-eval-test "capstone v2 tag"
-  (get (nth (get er-rt-cap-result :elements) 1) :name) "v2")
-
-(er-eval-test "capstone soft_purge while v1 alive = false"
-  (get (nth (get er-rt-cap-result :elements) 2) :name) "false")
-
-(er-eval-test "capstone hard purge = true"
-  (get (nth (get er-rt-cap-result :elements) 3) :name) "true")
-
-(er-eval-test "capstone soft_purge clean after hard = true"
-  (get (nth (get er-rt-cap-result :elements) 4) :name) "true")
-
-
-
-;; ── $X char literals (Step 3b substrate fix 2026-06-04) ──────────
-(er-eval-test "char $A" (ev "$A") 65)
-(er-eval-test "char $a" (ev "$a") 97)
-(er-eval-test "char $0 is digit, not escape-NUL" (ev "$0") 48)
-(er-eval-test "char $\\n is newline (10)" (ev "$\\n") 10)
-(er-eval-test "char $\\t is tab (9)" (ev "$\\t") 9)
-(er-eval-test "char $\\r is CR (13)" (ev "$\\r") 13)
-(er-eval-test "char $\\s is space (32)" (ev "$\\s") 32)
-(er-eval-test "char $\\0 is NUL (0)" (ev "$\\0") 0)
-(er-eval-test "char $\\\\ is backslash (92)" (ev "$\\\\") 92)
-(er-eval-test "[$h,$i] head is 104" (ev "hd([$h, $i])") 104)
-(er-eval-test "list_to_binary char-list -> bytes"
-  (ev "byte_size(list_to_binary([$f, $e, $d]))") 3)
-(er-eval-test "list_to_binary char-list round-trip"
-  (nm (ev "list_to_binary([$h, $i]) =:= <<104, 105>>")) "true")
-
-
-;; ── atom_to_list / integer_to_list charlist semantics (Step 3b substrate fix #3) ──
-(er-eval-test "atom_to_list hd is char code"
-  (ev "hd(atom_to_list(hi))") 104)
-(er-eval-test "atom_to_list maps to bytes via list_to_binary"
-  (ev "byte_size(list_to_binary(atom_to_list(hello)))") 5)
-(er-eval-test "atom_to_list -> list_to_binary -> bytes content"
-  (nm (ev "list_to_binary(atom_to_list(ok)) =:= <<111, 107>>")) "true")
-(er-eval-test "integer_to_list 12345 -> 5 chars"
-  (ev "length(integer_to_list(12345))") 5)
-(er-eval-test "integer_to_list -> bytes -> back"
-  (ev "list_to_integer(integer_to_list(99999))") 99999)
-(er-eval-test "list_to_atom from charlist"
-  (nm (ev "list_to_atom([$f, $o, $o])")) "foo")
-(er-eval-test "list_to_atom from SX-string back-compat"
-  (nm (ev "list_to_atom(\"bar\")")) "bar")
-(er-eval-test "list_to_integer from charlist"
-  (ev "list_to_integer([$1, $0, $0])") 100)
-
 (define
   er-eval-test-summary
   (str "eval " er-eval-test-pass "/" er-eval-test-count))

lib/erlang/tests/ffi.sx

@@ -1,223 +0,0 @@
-;; Phase 8 FFI BIF tests — one round-trip per BIF.
-;; Each BIF lives in lib/erlang/runtime.sx (registered with
-;; er-bif-registry) and wraps an SX-host primitive.
-
-(define er-ffi-test-count 0)
-(define er-ffi-test-pass 0)
-(define er-ffi-test-fails (list))
-
-(define
-  er-ffi-test
-  (fn
-    (name actual expected)
-    (set! er-ffi-test-count (+ er-ffi-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-ffi-test-pass (+ er-ffi-test-pass 1))
-      (append! er-ffi-test-fails {:name name :expected expected :actual actual}))))
-
-(define ffi-ev erlang-eval-ast)
-(define ffi-nm (fn (v) (get v :name)))
-
-;; ── file:read_file/1 + file:write_file/2 ────────────────────────
-(er-ffi-test
-  "file:write_file ok"
-  (ffi-nm (ffi-ev "file:write_file(\"/tmp/er-ffi-1.txt\", \"hello\")"))
-  "ok")
-
-(er-ffi-test
-  "file:read_file ok tag"
-  (ffi-nm (ffi-ev "element(1, file:read_file(\"/tmp/er-ffi-1.txt\"))"))
-  "ok")
-
-(er-ffi-test
-  "file:read_file payload is binary"
-  (ffi-nm
-    (ffi-ev
-      "case file:read_file(\"/tmp/er-ffi-1.txt\") of {ok, B} -> is_binary(B) end"))
-  "true")
-
-(er-ffi-test
-  "file:read_file content byte_size"
-  (ffi-ev
-    "case file:read_file(\"/tmp/er-ffi-1.txt\") of {ok, B} -> byte_size(B) end")
-  5)
-
-(er-ffi-test
-  "file:read_file missing enoent"
-  (ffi-nm (ffi-ev "element(2, file:read_file(\"/tmp/er-ffi-no-such-xyz\"))"))
-  "enoent")
-
-(er-ffi-test
-  "file:write_file bad path enoent"
-  (ffi-nm
-    (ffi-ev "element(2, file:write_file(\"/tmp/er-ffi-no-dir-xyz/x\", \"y\"))"))
-  "enoent")
-
-(er-ffi-test
-  "file:write_file binary payload"
-  (ffi-ev
-    "file:write_file(\"/tmp/er-ffi-2.bin\", <<1, 2, 3, 4, 5>>), case file:read_file(\"/tmp/er-ffi-2.bin\") of {ok, B} -> byte_size(B) end")
-  5)
-
-;; ── file:delete/1 ────────────────────────────────────────────────
-(er-ffi-test
-  "file:delete ok"
-  (ffi-nm
-    (ffi-ev
-      "file:write_file(\"/tmp/er-ffi-del.txt\", \"x\"), file:delete(\"/tmp/er-ffi-del.txt\")"))
-  "ok")
-
-(er-ffi-test
-  "file:read_file after delete enoent"
-  (ffi-nm
-    (ffi-ev
-      "file:write_file(\"/tmp/er-ffi-del2.txt\", \"x\"), file:delete(\"/tmp/er-ffi-del2.txt\"), element(2, file:read_file(\"/tmp/er-ffi-del2.txt\"))"))
-  "enoent")
-
-(er-ffi-test
-  "crypto:hash sha256 -> 32-byte binary"
-  (ffi-ev "byte_size(crypto:hash(sha256, <<97,98,99>>))")
-  32)
-
-(er-ffi-test
-  "crypto:hash sha512 -> 64-byte binary"
-  (ffi-ev "byte_size(crypto:hash(sha512, <<97,98,99>>))")
-  64)
-
-(er-ffi-test
-  "crypto:hash sha3_256 is_binary"
-  (ffi-nm (ffi-ev "is_binary(crypto:hash(sha3_256, <<120>>))"))
-  "true")
-
-(er-ffi-test
-  "crypto:hash deterministic"
-  (ffi-nm (ffi-ev "crypto:hash(sha256, <<97>>) =:= crypto:hash(sha256, <<97>>)"))
-  "true")
-
-(er-ffi-test
-  "crypto:hash distinct inputs distinct digests"
-  (ffi-nm (ffi-ev "crypto:hash(sha256, <<97>>) =/= crypto:hash(sha256, <<98>>)"))
-  "true")
-
-(er-ffi-test
-  "crypto:hash bad type -> error:badarg"
-  (ffi-nm (ffi-ev "try crypto:hash(md5, <<120>>) catch error:badarg -> ok end"))
-  "ok")
-
-(er-ffi-test
-  "cid:from_bytes is_binary"
-  (ffi-nm (ffi-ev "is_binary(cid:from_bytes(<<97,98,99>>))"))
-  "true")
-
-(er-ffi-test
-  "cid:from_bytes deterministic"
-  (ffi-nm (ffi-ev "cid:from_bytes(<<97,98,99>>) =:= cid:from_bytes(<<97,98,99>>)"))
-  "true")
-
-(er-ffi-test
-  "cid:from_bytes distinct inputs distinct CIDs"
-  (ffi-nm (ffi-ev "cid:from_bytes(<<97,98,99>>) =/= cid:from_bytes(<<97,98,100>>)"))
-  "true")
-
-(er-ffi-test
-  "cid:from_bytes non-binary -> error:badarg"
-  (ffi-nm (ffi-ev "try cid:from_bytes(42) catch error:badarg -> ok end"))
-  "ok")
-
-(er-ffi-test
-  "cid:to_string is_binary"
-  (ffi-nm (ffi-ev "is_binary(cid:to_string({ok, 42}))"))
-  "true")
-
-(er-ffi-test
-  "cid:to_string deterministic"
-  (ffi-nm (ffi-ev "cid:to_string(foo) =:= cid:to_string(foo)"))
-  "true")
-
-(er-ffi-test
-  "cid:to_string distinct terms distinct CIDs"
-  (ffi-nm (ffi-ev "cid:to_string(foo) =/= cid:to_string(bar)"))
-  "true")
-
-(er-ffi-test
-  "file:list_dir ok tag"
-  (ffi-nm (ffi-ev "element(1, file:list_dir(\"lib/erlang\"))"))
-  "ok")
-
-(er-ffi-test
-  "file:list_dir non-empty"
-  (ffi-nm (ffi-ev "case file:list_dir(\"lib/erlang\") of {ok, L} -> length(L) > 3 end"))
-  "true")
-
-(er-ffi-test
-  "file:list_dir entries are binaries"
-  (ffi-nm (ffi-ev "case file:list_dir(\"lib/erlang\") of {ok, L} -> is_binary(hd(L)) end"))
-  "true")
-
-(er-ffi-test
-  "file:list_dir missing enoent"
-  (ffi-nm (ffi-ev "element(2, file:list_dir(\"/no/such/dir/xyz\"))"))
-  "enoent")
-
-(er-ffi-test
-  "binary_to_list <<1,2,3>> length"
-  (ffi-ev "length(binary_to_list(<<1,2,3,4,5>>))")
-  5)
-
-(er-ffi-test
-  "binary_to_list hd byte"
-  (ffi-ev "hd(binary_to_list(<<7,8,9>>))")
-  7)
-
-(er-ffi-test
-  "binary_to_list empty -> []"
-  (ffi-nm (ffi-ev "case binary_to_list(<<>>) of [] -> empty end"))
-  "empty")
-
-(er-ffi-test
-  "list_to_binary flat list bytes"
-  (ffi-ev "byte_size(list_to_binary([1,2,3]))")
-  3)
-
-(er-ffi-test
-  "list_to_binary nested iolist"
-  (ffi-ev "byte_size(list_to_binary([1, <<2,3>>, [4, [5]]]))")
-  5)
-
-(er-ffi-test
-  "list_to_binary round-trip via binary_to_list"
-  (ffi-nm (ffi-ev "list_to_binary(binary_to_list(<<10,20,30>>)) =:= <<10,20,30>>"))
-  "true")
-
-(er-ffi-test
-  "binary_to_list non-binary -> error:badarg"
-  (ffi-nm (ffi-ev "try binary_to_list(42) catch error:badarg -> ok end"))
-  "ok")
-
-(er-ffi-test
-  "list_to_binary out-of-range byte -> error:badarg"
-  (ffi-nm (ffi-ev "try list_to_binary([300]) catch error:badarg -> ok end"))
-  "ok")
-
-(er-ffi-test
-  "list_to_binary non-iolist -> error:badarg"
-  (ffi-nm (ffi-ev "try list_to_binary(42) catch error:badarg -> ok end"))
-  "ok")
-
-;; ── Still deferred (no host primitive): httpc (HTTP client, v2),
-;; sqlite-* (v2 indexes). Assert NOT registered so a future iteration
-;; that wires them without updating this suite fails fast.
-(er-ffi-test
-  "httpc:request unregistered"
-  (er-lookup-bif "httpc" "request" 4)
-  nil)
-
-(er-ffi-test
-  "sqlite:exec unregistered"
-  (er-lookup-bif "sqlite" "exec" 2)
-  nil)
-
-(define
-  er-ffi-test-summary
-  (str "ffi " er-ffi-test-pass "/" er-ffi-test-count))

lib/erlang/tests/runtime.sx

@@ -134,144 +134,6 @@
   (er-sched-current-pid)
   nil)
 
-
-
-;; ── Phase 7: module-version slots ───────────────────────────────
-(er-modules-reset!)
-
-(define er-rt-slot1 (er-mk-module-slot (er-env-new) nil 1))
-(er-rt-test "slot tag"     (get er-rt-slot1 :tag)              "module")
-(er-rt-test "slot version" (er-module-version er-rt-slot1)     1)
-(er-rt-test "slot old nil" (er-module-old-env er-rt-slot1)     nil)
-(er-rt-test "slot current not nil" (= (er-module-current-env er-rt-slot1) nil) false)
-
-(erlang-load-module "-module(hr1). a() -> 1.")
-(define er-rt-reg (er-modules-get))
-(er-rt-test "registry has hr1"     (dict-has? er-rt-reg "hr1")                       true)
-(er-rt-test "v1 on first load"     (er-module-version (get er-rt-reg "hr1"))         1)
-(er-rt-test "v1 old is nil"        (er-module-old-env (get er-rt-reg "hr1"))         nil)
-(er-rt-test "v1 current not nil"   (= (er-module-current-env (get er-rt-reg "hr1")) nil) false)
-
-(define er-rt-env-v1 (er-module-current-env (get er-rt-reg "hr1")))
-(erlang-load-module "-module(hr1). a() -> 2.")
-(er-rt-test "v2 on second load"    (er-module-version (get er-rt-reg "hr1"))         2)
-(er-rt-test "v2 old is v1 env"     (er-module-old-env (get er-rt-reg "hr1"))         er-rt-env-v1)
-(er-rt-test "v2 current is new"    (= (er-module-current-env (get er-rt-reg "hr1")) er-rt-env-v1) false)
-
-(erlang-load-module "-module(hr1). a() -> 3.")
-(er-rt-test "v3 on third load"     (er-module-version (get er-rt-reg "hr1"))         3)
-
-(er-modules-reset!)
-(er-rt-test "registry-reset clears" (dict-has? (er-modules-get) "hr1")              false)
-
-
-
-
-;; ── Phase 8: FFI BIF registry ──────────────────────────────────
-(er-bif-registry-reset!)
-
-(er-rt-test "empty registry" (len (er-list-bifs)) 0)
-(er-rt-test "lookup miss" (er-lookup-bif "crypto" "hash" 2) nil)
-
-(er-register-bif! "fake" "echo" 1 (fn (vs) (nth vs 0)))
-(er-rt-test "register grows registry" (len (er-list-bifs)) 1)
-
-(define er-rt-bif-hit (er-lookup-bif "fake" "echo" 1))
-(er-rt-test "lookup hit module" (get er-rt-bif-hit :module) "fake")
-(er-rt-test "lookup hit name"   (get er-rt-bif-hit :name)   "echo")
-(er-rt-test "lookup hit arity"  (get er-rt-bif-hit :arity)  1)
-(er-rt-test "lookup hit pure?"  (get er-rt-bif-hit :pure?)  false)
-
-(er-rt-test "fn invocable" ((get er-rt-bif-hit :fn) (list 42)) 42)
-
-;; Re-register replaces (same key)
-(er-register-bif! "fake" "echo" 1 (fn (vs) "replaced"))
-(er-rt-test "re-register same key, count unchanged" (len (er-list-bifs)) 1)
-(er-rt-test "re-register replaces fn"
-  ((get (er-lookup-bif "fake" "echo" 1) :fn) (list 99)) "replaced")
-
-;; Pure variant
-(er-register-pure-bif! "fake" "pure" 2 (fn (vs) (+ (nth vs 0) (nth vs 1))))
-(er-rt-test "pure registered separately, count 2" (len (er-list-bifs)) 2)
-(er-rt-test "pure flag true"
-  (get (er-lookup-bif "fake" "pure" 2) :pure?) true)
-(er-rt-test "pure fn invocable"
-  ((get (er-lookup-bif "fake" "pure" 2) :fn) (list 7 8)) 15)
-
-;; Arity disambiguation: same module+name, different arity = distinct entries
-(er-register-bif! "fake" "echo" 2 (fn (vs) (list (nth vs 0) (nth vs 1))))
-(er-rt-test "arity disambiguation count" (len (er-list-bifs)) 3)
-(er-rt-test "arity-1 lookup still works"
-  ((get (er-lookup-bif "fake" "echo" 1) :fn) (list 11)) "replaced")
-(er-rt-test "arity-2 lookup independent"
-  (len ((get (er-lookup-bif "fake" "echo" 2) :fn) (list 1 2))) 2)
-
-;; Reset clears the registry
-(er-bif-registry-reset!)
-(er-rt-test "reset clears" (len (er-list-bifs)) 0)
-(er-rt-test "reset lookup nil" (er-lookup-bif "fake" "echo" 1) nil)
-
-
-
-;; ── Phase 8: term marshalling (er-to-sx / er-of-sx) ─────────────
-
-;; er-to-sx: Erlang → SX
-(er-rt-test "to-sx atom"      (er-to-sx (er-mk-atom "foo"))         (make-symbol "foo"))
-(er-rt-test "to-sx atom is symbol" (type-of (er-to-sx (er-mk-atom "x"))) "symbol")
-(er-rt-test "to-sx nil"       (er-to-sx (er-mk-nil))                (list))
-(er-rt-test "to-sx integer passthrough" (er-to-sx 42)               42)
-(er-rt-test "to-sx float passthrough"   (er-to-sx 3.14)             3.14)
-(er-rt-test "to-sx boolean passthrough" (er-to-sx true)             true)
-(er-rt-test "to-sx binary → string"
-  (er-to-sx (er-mk-binary (list 104 105 33))) "hi!")
-(er-rt-test "to-sx cons → list"
-  (er-to-sx (er-mk-cons 1 (er-mk-cons 2 (er-mk-cons 3 (er-mk-nil))))) (list 1 2 3))
-(er-rt-test "to-sx tuple → list"
-  (er-to-sx (er-mk-tuple (list 1 2 3))) (list 1 2 3))
-(er-rt-test "to-sx nested cons"
-  (er-to-sx (er-mk-cons (er-mk-atom "a") (er-mk-cons 7 (er-mk-nil))))
-  (list (make-symbol "a") 7))
-
-;; er-of-sx: SX → Erlang
-(er-rt-test "of-sx symbol"
-  (get (er-of-sx (make-symbol "ok")) :name) "ok")
-(er-rt-test "of-sx symbol is atom"
-  (er-atom? (er-of-sx (make-symbol "x"))) true)
-(er-rt-test "of-sx string is binary"
-  (er-binary? (er-of-sx "hi")) true)
-(er-rt-test "of-sx string bytes"
-  (get (er-of-sx "hi") :bytes) (list 104 105))
-(er-rt-test "of-sx integer passthrough"
-  (er-of-sx 42) 42)
-(er-rt-test "of-sx empty list → nil"
-  (er-nil? (er-of-sx (list))) true)
-(er-rt-test "of-sx list → cons chain length"
-  (er-list-length (er-of-sx (list 1 2 3 4))) 4)
-(er-rt-test "of-sx list head/tail"
-  (get (er-of-sx (list 10 20)) :head) 10)
-
-;; Round-trips
-(er-rt-test "rtrip integer" (er-to-sx (er-of-sx 99)) 99)
-(er-rt-test "rtrip atom"
-  (get (er-of-sx (er-to-sx (er-mk-atom "abc"))) :name) "abc")
-(er-rt-test "rtrip binary bytes"
-  (get (er-of-sx (er-to-sx (er-mk-binary (list 1 2 3)))) :bytes) (list 1 2 3))
-(er-rt-test "rtrip cons-of-ints length"
-  (er-list-length (er-of-sx (er-to-sx
-    (er-mk-cons 1 (er-mk-cons 2 (er-mk-cons 3 (er-mk-nil))))))) 3)
-
-;; Tuples don't round-trip exactly (er-to-sx flattens tuples to lists);
-;; documented one-way conversion.
-(er-rt-test "to-sx of tuple loses tag"
-  (er-cons? (er-of-sx (er-to-sx (er-mk-tuple (list 1 2 3))))) true)
-
-
-;; Re-populate built-in BIFs so subsequent test files (ring, ping-pong, etc.)
-;; can call length/spawn/etc. The migration onto the registry means a reset
-;; here would otherwise break the rest of the conformance suite.
-(er-register-builtin-bifs!)
-
-
 (define
   er-rt-test-summary
   (str "runtime " er-rt-test-pass "/" er-rt-test-count))

lib/erlang/tests/vm.sx

@@ -1,403 +0,0 @@
-;; Phase 9 — stub VM opcode dispatcher tests.
-;; Verifies the dispatcher shape (mirrors plans/sx-vm-opcode-extension.md
-;; for when 9a integrates) and the three pattern-match opcodes (9b)
-;; route to the correct er-match-* impl.
-
-(define er-vm-test-count 0)
-(define er-vm-test-pass 0)
-(define er-vm-test-fails (list))
-
-(define
-  er-vm-test
-  (fn
-    (name actual expected)
-    (set! er-vm-test-count (+ er-vm-test-count 1))
-    (if
-      (= actual expected)
-      (set! er-vm-test-pass (+ er-vm-test-pass 1))
-      (append! er-vm-test-fails {:name name :expected expected :actual actual}))))
-
-;; ── dispatcher core ─────────────────────────────────────────────
-(er-vm-test
-  "tuple opcode registered"
-  (= (er-vm-lookup-opcode-by-id 128) nil)
-  false)
-
-(er-vm-test
-  "tuple opcode name"
-  (get (er-vm-lookup-opcode-by-id 128) :name)
-  "OP_PATTERN_TUPLE")
-
-(er-vm-test
-  "list opcode by name"
-  (get (er-vm-lookup-opcode-by-name "OP_PATTERN_LIST") :id)
-  129)
-
-(er-vm-test
-  "binary opcode by name"
-  (get (er-vm-lookup-opcode-by-name "OP_PATTERN_BINARY") :id)
-  130)
-
-(er-vm-test "lookup miss by id" (er-vm-lookup-opcode-by-id 999) nil)
-
-(er-vm-test "lookup miss by name" (er-vm-lookup-opcode-by-name "OP_NOPE") nil)
-
-(er-vm-test
-  "opcode list has 3+"
-  (>= (len (er-vm-list-opcodes)) 3)
-  true)
-
-;; ── OP_PATTERN_TUPLE ────────────────────────────────────────────
-;; Pattern: {ok, X} matches value {ok, 42} → X bound to 42
-(define er-vm-t1-env (er-env-new))
-(define er-vm-t1-pat {:type "tuple" :elements (list {:type "atom" :value "ok"} {:name "X" :type "var"})})
-(define er-vm-t1-val (er-mk-tuple (list (er-mk-atom "ok") 42)))
-(er-vm-test
-  "OP_PATTERN_TUPLE match"
-  (er-vm-dispatch 128 (list er-vm-t1-pat er-vm-t1-val er-vm-t1-env))
-  true)
-(er-vm-test "OP_PATTERN_TUPLE binds var" (get er-vm-t1-env "X") 42)
-
-;; Same pattern against {error, ...} → false
-(define er-vm-t2-env (er-env-new))
-(define er-vm-t2-val (er-mk-tuple (list (er-mk-atom "error") 7)))
-(er-vm-test
-  "OP_PATTERN_TUPLE no-match"
-  (er-vm-dispatch 128 (list er-vm-t1-pat er-vm-t2-val er-vm-t2-env))
-  false)
-
-;; Wrong arity tuple — pattern has 2 elements, value has 3
-(define er-vm-t3-env (er-env-new))
-(define
-  er-vm-t3-val
-  (er-mk-tuple (list (er-mk-atom "ok") 1 2)))
-(er-vm-test
-  "OP_PATTERN_TUPLE arity mismatch"
-  (er-vm-dispatch 128 (list er-vm-t1-pat er-vm-t3-val er-vm-t3-env))
-  false)
-
-;; ── OP_PATTERN_LIST (cons) ──────────────────────────────────────
-;; Pattern: [H | T] matches [1, 2, 3] → H=1, T=[2,3]
-(define er-vm-l1-env (er-env-new))
-(define er-vm-l1-pat {:type "cons" :tail {:name "T" :type "var"} :head {:name "H" :type "var"}})
-(define
-  er-vm-l1-val
-  (er-mk-cons
-    1
-    (er-mk-cons 2 (er-mk-cons 3 (er-mk-nil)))))
-(er-vm-test
-  "OP_PATTERN_LIST match"
-  (er-vm-dispatch 129 (list er-vm-l1-pat er-vm-l1-val er-vm-l1-env))
-  true)
-(er-vm-test "OP_PATTERN_LIST binds head" (get er-vm-l1-env "H") 1)
-(er-vm-test
-  "OP_PATTERN_LIST tail is cons"
-  (er-cons? (get er-vm-l1-env "T"))
-  true)
-
-;; [H|T] against empty list → false
-(define er-vm-l2-env (er-env-new))
-(er-vm-test
-  "OP_PATTERN_LIST no-match on nil"
-  (er-vm-dispatch 129 (list er-vm-l1-pat (er-mk-nil) er-vm-l2-env))
-  false)
-
-;; ── OP_PATTERN_BINARY ───────────────────────────────────────────
-;; Pattern <<A:8>> against <<42>> → A bound to 42
-(define er-vm-b1-env (er-env-new))
-(define er-vm-b1-pat {:type "binary" :segments (list {:value {:name "A" :type "var"} :size {:type "integer" :value "8"} :spec "integer"})})
-(define er-vm-b1-val (er-mk-binary (list 42)))
-(er-vm-test
-  "OP_PATTERN_BINARY match"
-  (er-vm-dispatch 130 (list er-vm-b1-pat er-vm-b1-val er-vm-b1-env))
-  true)
-(er-vm-test
-  "OP_PATTERN_BINARY binds segment"
-  (get er-vm-b1-env "A")
-  42)
-
-;; Same pattern against wrong-size binary (2 bytes) → false
-(define er-vm-b2-env (er-env-new))
-(define er-vm-b2-val (er-mk-binary (list 42 99)))
-(er-vm-test
-  "OP_PATTERN_BINARY size mismatch"
-  (er-vm-dispatch 130 (list er-vm-b1-pat er-vm-b2-val er-vm-b2-env))
-  false)
-
-;; ── dispatch error path ────────────────────────────────────────
-(define er-vm-err-caught (list nil))
-(guard
-  (c (:else (set-nth! er-vm-err-caught 0 (str c))))
-  (er-vm-dispatch 999 (list)))
-(er-vm-test
-  "unknown opcode raises"
-  (string-contains? (str (nth er-vm-err-caught 0)) "unknown opcode")
-  true)
-
-
-;; ── Phase 9c — OP_PERFORM / OP_HANDLE ───────────────────────────
-(er-vm-test "perform opcode by id"
-  (get (er-vm-lookup-opcode-by-id 131) :name) "OP_PERFORM")
-(er-vm-test "handle opcode by id"
-  (get (er-vm-lookup-opcode-by-id 132) :name) "OP_HANDLE")
-
-(define er-vm-pf-caught (list nil))
-(guard (c (:else (set-nth! er-vm-pf-caught 0 c)))
-  (er-vm-dispatch 131 (list "yield" (list 42))))
-(er-vm-test "perform raises tagged"
-  (get (nth er-vm-pf-caught 0) :tag) "vm-effect")
-(er-vm-test "perform effect name"
-  (get (nth er-vm-pf-caught 0) :effect) "yield")
-(er-vm-test "perform args carried"
-  (nth (get (nth er-vm-pf-caught 0) :args) 0) 42)
-
-(er-vm-test "handle catches matching effect"
-  (er-vm-dispatch 132
-    (list
-      (fn () (er-vm-dispatch 131 (list "yield" (list 7))))
-      "yield"
-      (fn (args) (+ (nth args 0) 100))))
-  107)
-
-(er-vm-test "handle no-effect returns thunk result"
-  (er-vm-dispatch 132
-    (list
-      (fn () 99)
-      "yield"
-      (fn (args) "handler ran")))
-  99)
-
-(define er-vm-rt-caught (list nil))
-(guard (c (:else (set-nth! er-vm-rt-caught 0 c)))
-  (er-vm-dispatch 132
-    (list
-      (fn () (er-vm-dispatch 131 (list "other" (list))))
-      "yield"
-      (fn (args) "wrong"))))
-(er-vm-test "handle rethrows non-matching"
-  (get (nth er-vm-rt-caught 0) :effect) "other")
-
-(er-vm-test "nested handles separate effect names"
-  (er-vm-dispatch 132
-    (list
-      (fn ()
-        (er-vm-dispatch 132
-          (list
-            (fn () (er-vm-dispatch 131 (list "b" (list 5))))
-            "a"
-            (fn (args) "inner-handled"))))
-      "b"
-      (fn (args) (+ (nth args 0) 1000))))
-  1005)
-
-
-;; ── Phase 9d — OP_RECEIVE_SCAN ──────────────────────────────────
-(er-vm-test "receive-scan opcode by id"
-  (get (er-vm-lookup-opcode-by-id 133) :name) "OP_RECEIVE_SCAN")
-
-;; Pattern: receive {ok, X} -> X end  against mailbox [{error, 1}, {ok, 42}, foo]
-(define er-vm-r1-env (er-env-new))
-(define er-vm-r1-clauses
-  (list
-    {:pattern {:type "tuple"
-               :elements (list
-                 {:type "atom" :value "ok"}
-                 {:type "var" :name "X"})}
-     :guards (list)
-     :body (list {:type "var" :name "X"})}))
-(define er-vm-r1-mbox
-  (list
-    (er-mk-tuple (list (er-mk-atom "error") 1))
-    (er-mk-tuple (list (er-mk-atom "ok") 42))
-    (er-mk-atom "foo")))
-
-(define er-vm-r1-result
-  (er-vm-dispatch 133 (list er-vm-r1-clauses er-vm-r1-mbox er-vm-r1-env)))
-(er-vm-test "scan finds match"
-  (get er-vm-r1-result :matched) true)
-(er-vm-test "scan reports correct index"
-  (get er-vm-r1-result :index) 1)
-(er-vm-test "scan binds var"
-  (get er-vm-r1-env "X") 42)
-(er-vm-test "scan leaves body unevaluated"
-  (= (get er-vm-r1-result :body) nil) false)
-
-;; No match case
-(define er-vm-r2-env (er-env-new))
-(define er-vm-r2-mbox (list (er-mk-atom "nope") 99))
-(define er-vm-r2-result
-  (er-vm-dispatch 133 (list er-vm-r1-clauses er-vm-r2-mbox er-vm-r2-env)))
-(er-vm-test "scan no-match"
-  (get er-vm-r2-result :matched) false)
-(er-vm-test "scan no-match leaves env clean"
-  (dict-has? er-vm-r2-env "X") false)
-
-;; Empty mailbox
-(define er-vm-r3-result
-  (er-vm-dispatch 133 (list er-vm-r1-clauses (list) (er-env-new))))
-(er-vm-test "scan empty mailbox"
-  (get er-vm-r3-result :matched) false)
-
-;; First-match wins (arrival order)
-(define er-vm-r4-env (er-env-new))
-(define er-vm-r4-mbox
-  (list
-    (er-mk-tuple (list (er-mk-atom "ok") 1))
-    (er-mk-tuple (list (er-mk-atom "ok") 2))))
-(define er-vm-r4-result
-  (er-vm-dispatch 133 (list er-vm-r1-clauses er-vm-r4-mbox er-vm-r4-env)))
-(er-vm-test "scan first-match wins (index 0)"
-  (get er-vm-r4-result :index) 0)
-(er-vm-test "scan binds first match's var"
-  (get er-vm-r4-env "X") 1)
-
-
-;; ── Phase 9e — OP_SPAWN / OP_SEND ───────────────────────────────
-(er-vm-procs-reset!)
-
-(er-vm-test "spawn opcode by id"
-  (get (er-vm-lookup-opcode-by-id 134) :name) "OP_SPAWN")
-(er-vm-test "send opcode by id"
-  (get (er-vm-lookup-opcode-by-id 135) :name) "OP_SEND")
-
-(define er-vm-fn (fn () "body"))
-(define er-vm-p1 (er-vm-dispatch 134 (list er-vm-fn (list))))
-(define er-vm-p2 (er-vm-dispatch 134 (list er-vm-fn (list "arg"))))
-(er-vm-test "spawn returns pid 0 first"
-  er-vm-p1 0)
-(er-vm-test "spawn returns pid 1 second"
-  er-vm-p2 1)
-(er-vm-test "proc count is 2"
-  (er-vm-proc-count) 2)
-(er-vm-test "spawned proc state runnable"
-  (er-vm-proc-state er-vm-p1) "runnable")
-(er-vm-test "spawned proc mailbox empty"
-  (len (er-vm-proc-mailbox er-vm-p1)) 0)
-(er-vm-test "spawned proc has 8 registers"
-  (len (get (er-vm-proc-get er-vm-p1) :registers)) 8)
-
-;; OP_SEND appends to target's mailbox, preserves arrival order.
-(er-vm-test "send returns true on valid pid"
-  (er-vm-dispatch 135 (list er-vm-p1 "msg1")) true)
-(er-vm-dispatch 135 (list er-vm-p1 "msg2")
-)
-(er-vm-dispatch 135 (list er-vm-p1 "msg3"))
-(er-vm-test "mailbox length after 3 sends"
-  (len (er-vm-proc-mailbox er-vm-p1)) 3)
-(er-vm-test "mailbox preserves order — first"
-  (nth (er-vm-proc-mailbox er-vm-p1) 0) "msg1")
-(er-vm-test "mailbox preserves order — last"
-  (nth (er-vm-proc-mailbox er-vm-p1) 2) "msg3")
-
-;; send to nonexistent pid returns false (doesn't crash)
-(er-vm-test "send to unknown pid is false"
-  (er-vm-dispatch 135 (list 99999 "x")) false)
-
-;; Isolation: msgs to p1 don't appear in p2's mailbox
-(er-vm-test "isolation — p2 mailbox empty"
-  (len (er-vm-proc-mailbox er-vm-p2)) 0)
-
-;; reset clears
-(er-vm-procs-reset!)
-(er-vm-test "reset clears procs"
-  (er-vm-proc-count) 0)
-(er-vm-test "reset resets pid counter"
-  (er-vm-dispatch 134 (list er-vm-fn (list))) 0)
-
-
-;; ── Phase 9f — hot-BIF dispatch table ───────────────────────────
-;; Each opcode skips the registry lookup and calls the underlying
-;; er-bif-* directly. Verify each returns the same result as going
-;; through er-apply-bif.
-
-(er-vm-test "BIF_LENGTH opcode by id"
-  (get (er-vm-lookup-opcode-by-id 136) :name) "OP_BIF_LENGTH")
-(er-vm-test "BIF_LENGTH on 3-cons"
-  (er-vm-dispatch 136
-    (list (er-mk-cons 1 (er-mk-cons 2 (er-mk-cons 3 (er-mk-nil))))))
-  3)
-
-(er-vm-test "BIF_HD on cons"
-  (er-vm-dispatch 137 (list (er-mk-cons 99 (er-mk-nil)))) 99)
-
-(er-vm-test "BIF_TL is cons"
-  (er-cons? (er-vm-dispatch 138
-    (list (er-mk-cons 1 (er-mk-cons 2 (er-mk-nil)))))) true)
-
-(er-vm-test "BIF_ELEMENT pulls index"
-  (er-vm-dispatch 139 (list 2 (er-mk-tuple (list "a" "b" "c")))) "b")
-
-(er-vm-test "BIF_TUPLE_SIZE on 4-tuple"
-  (er-vm-dispatch 140 (list (er-mk-tuple (list 1 2 3 4)))) 4)
-
-(er-vm-test "BIF_LISTS_REVERSE preserves elements"
-  (er-list-length (er-vm-dispatch 141
-    (list (er-mk-cons 1 (er-mk-cons 2 (er-mk-cons 3 (er-mk-nil))))))) 3)
-
-(er-vm-test "BIF_LISTS_REVERSE actually reverses"
-  (get (er-vm-dispatch 141
-    (list (er-mk-cons 1 (er-mk-cons 2 (er-mk-cons 3 (er-mk-nil)))))) :head) 3)
-
-(er-vm-test "BIF_IS_INTEGER true on int"
-  (get (er-vm-dispatch 142 (list 42)) :name) "true")
-(er-vm-test "BIF_IS_INTEGER false on float"
-  (get (er-vm-dispatch 142 (list 3.14)) :name) "false")
-
-(er-vm-test "BIF_IS_ATOM true"
-  (get (er-vm-dispatch 143 (list (er-mk-atom "ok"))) :name) "true")
-(er-vm-test "BIF_IS_ATOM false on int"
-  (get (er-vm-dispatch 143 (list 7)) :name) "false")
-
-(er-vm-test "BIF_IS_LIST true on cons"
-  (get (er-vm-dispatch 144
-    (list (er-mk-cons 1 (er-mk-nil)))) :name) "true")
-(er-vm-test "BIF_IS_LIST true on nil"
-  (get (er-vm-dispatch 144 (list (er-mk-nil))) :name) "true")
-(er-vm-test "BIF_IS_LIST false on tuple"
-  (get (er-vm-dispatch 144 (list (er-mk-tuple (list)))) :name) "false")
-
-(er-vm-test "BIF_IS_TUPLE true"
-  (get (er-vm-dispatch 145 (list (er-mk-tuple (list 1)))) :name) "true")
-(er-vm-test "BIF_IS_TUPLE false on int"
-  (get (er-vm-dispatch 145 (list 5)) :name) "false")
-
-;; Sanity: total opcode count grew (3 patterns + perform + handle +
-;; receive-scan + spawn + send + 10 hot-BIFs = 16+ registered).
-(er-vm-test "opcode list has 16+"
-  (>= (len (er-vm-list-opcodes)) 16) true)
-
-
-;; ── Phase 9i — host opcode-id resolution ────────────────────────
-;; Requires a binary with the erlang_ext extension registered (9h).
-;; The loop runs conformance against exactly that binary.
-(er-vm-test "host id: OP_PATTERN_TUPLE = 222"
-  (er-vm-host-opcode-id "erlang.OP_PATTERN_TUPLE") 222)
-(er-vm-test "host id: OP_BIF_IS_TUPLE = 239"
-  (er-vm-host-opcode-id "erlang.OP_BIF_IS_TUPLE") 239)
-(er-vm-test "host id: unknown name -> nil"
-  (er-vm-host-opcode-id "erlang.OP_NOPE") nil)
-(er-vm-test "effective id prefers host when present"
-  (er-vm-effective-opcode-id "erlang.OP_BIF_LENGTH" 136) 230)
-(er-vm-test "effective id falls back to stub on nil"
-  (er-vm-effective-opcode-id "erlang.OP_NOPE" 999) 999)
-;; The full erlang.OP_* namespace resolves to the contiguous 222-239 block.
-(er-vm-test "host ids contiguous 222..239"
-  (let ((names (list "erlang.OP_PATTERN_TUPLE" "erlang.OP_PATTERN_LIST"
-                     "erlang.OP_PATTERN_BINARY" "erlang.OP_PERFORM"
-                     "erlang.OP_HANDLE" "erlang.OP_RECEIVE_SCAN"
-                     "erlang.OP_SPAWN" "erlang.OP_SEND"
-                     "erlang.OP_BIF_LENGTH" "erlang.OP_BIF_HD"
-                     "erlang.OP_BIF_TL" "erlang.OP_BIF_ELEMENT"
-                     "erlang.OP_BIF_TUPLE_SIZE" "erlang.OP_BIF_LISTS_REVERSE"
-                     "erlang.OP_BIF_IS_INTEGER" "erlang.OP_BIF_IS_ATOM"
-                     "erlang.OP_BIF_IS_LIST" "erlang.OP_BIF_IS_TUPLE"))
-        (ok (list true)))
-    (for-each
-      (fn (i)
-        (when (not (= (er-vm-host-opcode-id (nth names i)) (+ 222 i)))
-          (set-nth! ok 0 false)))
-      (range 0 (len names)))
-    (nth ok 0))
-  true)
-
-(define er-vm-test-summary (str "vm " er-vm-test-pass "/" er-vm-test-count))

lib/erlang/tokenizer.sx

@@ -229,37 +229,13 @@
                 (= ch "$")
                 (do
                   (er-advance! 1)
-                  ;; Emit the char's decimal code as the integer token value
-                  ;; (was: raw "$X" text — parse-number then returned nil).
-                  (let
-                    ((code (cond
-                       (>= pos src-len) 0
-                       (= (er-cur) "\\")
-                         (do
-                           (er-advance! 1)
-                           (let ((esc (if (< pos src-len) (er-cur) "")))
-                             (when (< pos src-len) (er-advance! 1))
-                             (cond
-                               (= esc "n")  10
-                               (= esc "t")  9
-                               (= esc "r")  13
-                               (= esc "s")  32
-                               (= esc "b")  8
-                               (= esc "e")  27
-                               (= esc "f")  12
-                               (= esc "v")  11
-                               (= esc "d")  127
-                               (= esc "0")  0
-                               (= esc "\\")  92
-                               (= esc "\"") 34
-                               (= esc "'")  39
-                               (= esc "")   0
-                               :else (char->integer (nth (string->list esc) 0)))))
-                       :else
-                         (let ((c (er-cur)))
-                           (er-advance! 1)
-                           (char->integer (nth (string->list c) 0))))))
-                    (er-emit! "integer" (str code) start))
+                  (if
+                    (and (< pos src-len) (= (er-cur) "\\"))
+                    (do
+                      (er-advance! 1)
+                      (when (< pos src-len) (er-advance! 1)))
+                    (when (< pos src-len) (er-advance! 1)))
+                  (er-emit! "integer" (slice src start pos) start)
                   (scan!))
                 (er-lower? ch)
                 (do

lib/erlang/transpile.sx

@@ -107,12 +107,7 @@
     (let
       ((ty (get node :type)))
       (cond
-        (= ty "integer")
-          (let ((n (parse-number (get node :value))))
-            (cond
-              (= n nil) (error (str "Erlang: invalid integer literal: "
-                                     (get node :value)))
-              :else (truncate n)))
+        (= ty "integer") (parse-number (get node :value))
         (= ty "float") (parse-number (get node :value))
         (= ty "atom") (er-mk-atom (get node :value))
         (= ty "string") (get node :value)
@@ -674,23 +669,96 @@
 
 (define
   er-apply-bif
-  (fn (name vs)
-    (let ((entry (er-lookup-bif "erlang" name (len vs))))
-      (if (not (= entry nil))
-        ((get entry :fn) vs)
-        (error (str "Erlang: undefined function '" name "/" (len vs) "'"))))))
+  (fn
+    (name vs)
+    (cond
+      (= name "is_integer") (er-bif-is-integer vs)
+      (= name "is_atom") (er-bif-is-atom vs)
+      (= name "is_list") (er-bif-is-list vs)
+      (= name "is_tuple") (er-bif-is-tuple vs)
+      (= name "is_number") (er-bif-is-number vs)
+      (= name "is_float") (er-bif-is-float vs)
+      (= name "is_boolean") (er-bif-is-boolean vs)
+      (= name "length") (er-bif-length vs)
+      (= name "hd") (er-bif-hd vs)
+      (= name "tl") (er-bif-tl vs)
+      (= name "element") (er-bif-element vs)
+      (= name "tuple_size") (er-bif-tuple-size vs)
+      (= name "atom_to_list") (er-bif-atom-to-list vs)
+      (= name "list_to_atom") (er-bif-list-to-atom vs)
+      (= name "is_pid") (er-bif-is-pid vs)
+      (= name "is_reference") (er-bif-is-reference vs)
+      (= name "is_binary") (er-bif-is-binary vs)
+      (= name "byte_size") (er-bif-byte-size vs)
+      (= name "abs") (er-bif-abs vs)
+      (= name "min") (er-bif-min vs)
+      (= name "max") (er-bif-max vs)
+      (= name "tuple_to_list") (er-bif-tuple-to-list vs)
+      (= name "list_to_tuple") (er-bif-list-to-tuple vs)
+      (= name "integer_to_list") (er-bif-integer-to-list vs)
+      (= name "list_to_integer") (er-bif-list-to-integer vs)
+      (= name "is_function") (er-bif-is-function vs)
+      (= name "self") (er-bif-self vs)
+      (= name "spawn") (er-bif-spawn vs)
+      (= name "exit") (er-bif-exit vs)
+      (= name "make_ref") (er-bif-make-ref vs)
+      (= name "link") (er-bif-link vs)
+      (= name "unlink") (er-bif-unlink vs)
+      (= name "monitor") (er-bif-monitor vs)
+      (= name "demonitor") (er-bif-demonitor vs)
+      (= name "process_flag") (er-bif-process-flag vs)
+      (= name "register") (er-bif-register vs)
+      (= name "unregister") (er-bif-unregister vs)
+      (= name "whereis") (er-bif-whereis vs)
+      (= name "registered") (er-bif-registered vs)
+      (= name "throw") (raise (er-mk-throw-marker (er-bif-arg1 vs "throw")))
+      (= name "error") (raise (er-mk-error-marker (er-bif-arg1 vs "error")))
+      :else (error
+        (str "Erlang: undefined function '" name "/" (len vs) "'")))))
 
 (define
   er-apply-remote-bif
-  (fn (mod name vs)
+  (fn
+    (mod name vs)
     (cond
       (dict-has? (er-modules-get) mod)
-        (er-apply-user-module mod name vs)
-      :else
-        (let ((entry (er-lookup-bif mod name (len vs))))
-          (if (not (= entry nil))
-            ((get entry :fn) vs)
-            (error (str "Erlang: undefined remote function '" mod ":" name "/" (len vs) "'")))))))
+      (er-apply-user-module mod name vs)
+      (= mod "lists") (er-apply-lists-bif name vs)
+      (= mod "io") (er-apply-io-bif name vs)
+      (= mod "erlang") (er-apply-bif name vs)
+      (= mod "ets") (er-apply-ets-bif name vs)
+      :else (error
+        (str "Erlang: undefined module '" mod "'")))))
+
+(define
+  er-apply-lists-bif
+  (fn
+    (name vs)
+    (cond
+      (= name "reverse") (er-bif-lists-reverse vs)
+      (= name "map") (er-bif-lists-map vs)
+      (= name "foldl") (er-bif-lists-foldl vs)
+      (= name "seq") (er-bif-lists-seq vs)
+      (= name "sum") (er-bif-lists-sum vs)
+      (= name "nth") (er-bif-lists-nth vs)
+      (= name "last") (er-bif-lists-last vs)
+      (= name "member") (er-bif-lists-member vs)
+      (= name "append") (er-bif-lists-append vs)
+      (= name "filter") (er-bif-lists-filter vs)
+      (= name "any") (er-bif-lists-any vs)
+      (= name "all") (er-bif-lists-all vs)
+      (= name "duplicate") (er-bif-lists-duplicate vs)
+      :else (error
+        (str "Erlang: undefined 'lists:" name "/" (len vs) "'")))))
+
+(define
+  er-apply-io-bif
+  (fn
+    (name vs)
+    (cond
+      (= name "format") (er-bif-io-format vs)
+      :else (error
+        (str "Erlang: undefined 'io:" name "/" (len vs) "'")))))
 
 (define
   er-bif-arg1
@@ -826,30 +894,16 @@
         (len (get v :elements))
         (error "Erlang: tuple_size: not a tuple")))))
 
-(define er-string->charlist
-  (fn (s)
-    (let ((cs (string->list s)) (out (er-mk-nil)))
-      (for-each
-        (fn (i)
-          (set! out (er-mk-cons
-                      (char->integer (nth cs (- (- (len cs) 1) i)))
-                      out)))
-        (range 0 (len cs)))
-      out)))
-
 (define
   er-bif-atom-to-list
   (fn
     (vs)
     (let
       ((v (er-bif-arg1 vs "atom_to_list")))
-      ;; Standard Erlang: atom_to_list/1 returns an Erlang charlist
-      ;; (list of integer char codes). Was: SX string of :name —
-      ;; unusable from Erlang-land for [Char|T] / ++ / binary segments.
       (if
         (er-atom? v)
-        (er-string->charlist (get v :name))
-        (raise (er-mk-error-marker (er-mk-atom "badarg")))))))
+        (get v :name)
+        (error "Erlang: atom_to_list: not an atom")))))
 
 (define
   er-bif-list-to-atom
@@ -857,11 +911,10 @@
     (vs)
     (let
       ((v (er-bif-arg1 vs "list_to_atom")))
-      ;; Accept Erlang charlist (cons of ints) or SX string.
-      (let ((s (er-source-to-string v)))
-        (cond
-          (= s nil) (raise (er-mk-error-marker (er-mk-atom "badarg")))
-          :else (er-mk-atom s))))))
+      (if
+        (= (type-of v) "string")
+        (er-mk-atom v)
+        (error "Erlang: list_to_atom: not a string")))))
 
 ;; ── lists module ─────────────────────────────────────────────────
 (define
@@ -1617,12 +1670,10 @@
     (vs)
     (let
       ((v (er-bif-arg1 vs "integer_to_list")))
-      ;; Standard Erlang: integer_to_list/1 returns an Erlang charlist
-      ;; (e.g. integer_to_list(42) -> [$4, $2] -> [52, 50]).
       (cond
         (not (= (type-of v) "number"))
         (raise (er-mk-error-marker (er-mk-atom "badarg")))
-        :else (er-string->charlist (str v))))))
+        :else (str v)))))
 
 (define
   er-bif-list-to-integer
@@ -1630,14 +1681,15 @@
     (vs)
     (let
       ((v (er-bif-arg1 vs "list_to_integer")))
-      ;; Accept Erlang charlist (cons of ints) or SX string.
-      (let ((s (er-source-to-string v)))
-        (cond
-          (= s nil) (raise (er-mk-error-marker (er-mk-atom "badarg")))
-          :else (let ((n (parse-number s)))
-            (cond
-              (= n nil) (raise (er-mk-error-marker (er-mk-atom "badarg")))
-              :else n)))))))
+      (cond
+        (not (= (type-of v) "string"))
+        (raise (er-mk-error-marker (er-mk-atom "badarg")))
+        :else (let
+          ((n (parse-number v)))
+          (cond
+            (= n nil)
+            (raise (er-mk-error-marker (er-mk-atom "badarg")))
+            :else n))))))
 
 (define
   er-bif-is-function
@@ -1859,180 +1911,3 @@
           (fn (_) (set! out (er-mk-cons v out)))
           (range 0 n))
         out))))
-
-
-;; ── code module (Phase 7 hot-reload) ─────────────────────────────
-(define er-source-walk-bytes!
-  (fn (n bytes-box)
-    (cond
-      (er-nil? n) true
-      (er-cons? n)
-        (let ((h (get n :head)))
-          (cond
-            (= (type-of h) "number")
-              (do (append! (nth bytes-box 0) h)
-                  (er-source-walk-bytes! (get n :tail) bytes-box))
-            :else (do (set-nth! bytes-box 0 nil) false)))
-      :else (do (set-nth! bytes-box 0 nil) false))))
-
-(define er-source-to-string
-  (fn (v)
-    (cond
-      (= (type-of v) "string") v
-      (er-binary? v) (list->string (map integer->char (get v :bytes)))
-      (or (er-nil? v) (er-cons? v))
-        (let ((box (list (list))))
-          (er-source-walk-bytes! v box)
-          (cond
-            (= (nth box 0) nil) nil
-            :else (list->string (map integer->char (nth box 0)))))
-      :else nil)))
-
-(define er-bif-code-load-binary
-  (fn (vs)
-    (let ((mod-arg (nth vs 0)) (src-arg (nth vs 2)))
-      (cond
-        (not (er-atom? mod-arg))
-          (er-mk-tuple (list (er-mk-atom "error") (er-mk-atom "badarg")))
-        :else
-          (let ((src-str (er-source-to-string src-arg)))
-            (cond
-              (= src-str nil)
-                (er-mk-tuple (list (er-mk-atom "error") (er-mk-atom "badarg")))
-              :else
-                (let ((result-box (list nil)) (failed-box (list false)))
-                  (guard
-                    (c (:else (set-nth! failed-box 0 true)))
-                    (set-nth! result-box 0 (erlang-load-module src-str)))
-                  (cond
-                    (nth failed-box 0)
-                      (er-mk-tuple
-                        (list (er-mk-atom "error") (er-mk-atom "badfile")))
-                    (not (= (get (nth result-box 0) :name) (get mod-arg :name)))
-                      (er-mk-tuple
-                        (list (er-mk-atom "error") (er-mk-atom "module_name_mismatch")))
-                    :else
-                      (er-mk-tuple (list (er-mk-atom "module") mod-arg))))))))))
-
-(define er-env-derived-from?
-  (fn (env target-env)
-    ;; Object-identity check, NOT value `=`. On evaluators where dict `=`
-    ;; is structural/deep, comparing closure envs (which are large and
-    ;; cyclic — a module fun's env references the fun) does not terminate.
-    ;; `identical?` is pointer identity on every host and is the actual
-    ;; intended semantics: "is this the same env object".
-    (cond
-      (identical? env target-env) true
-      :else
-        (let ((ks (keys env)) (found-ref (list false)))
-          (for-each
-            (fn (i)
-              (when (not (nth found-ref 0))
-                (let ((v (get env (nth ks i))))
-                  (when (and (er-fun? v) (identical? (get v :env) target-env))
-                    (set-nth! found-ref 0 true)))))
-            (range 0 (len ks)))
-          (nth found-ref 0)))))
-
-(define er-procs-on-env
-  (fn (target-env)
-    (let ((all-keys (keys (er-sched-processes)))
-          (matches (list)))
-      (for-each
-        (fn (i)
-          (let ((proc (get (er-sched-processes) (nth all-keys i))))
-            (let ((init-fun (get proc :initial-fun)))
-              (when (and (not (= init-fun nil))
-                         (er-fun? init-fun)
-                         (er-env-derived-from? (get init-fun :env) target-env)
-                         (not (= (get proc :state) "dead")))
-                (append! matches (get proc :pid))))))
-        (range 0 (len all-keys)))
-      matches)))
-
-(define er-bif-code-purge
-  (fn (vs)
-    (let ((mod-arg (nth vs 0)))
-      (cond
-        (not (er-atom? mod-arg))
-          (raise (er-mk-error-marker (er-mk-atom "badarg")))
-        :else
-          (let ((registry (er-modules-get)) (mod-name (get mod-arg :name)))
-            (cond
-              (not (dict-has? registry mod-name)) (er-mk-atom "false")
-              :else
-                (let ((slot (get registry mod-name)))
-                  (cond
-                    (= (er-module-old-env slot) nil) (er-mk-atom "false")
-                    :else
-                      (let ((procs (er-procs-on-env (er-module-old-env slot))))
-                        (for-each
-                          (fn (i) (er-cascade-exit! (nth procs i) (er-mk-atom "killed")))
-                          (range 0 (len procs)))
-                        (dict-set! registry mod-name
-                          (er-mk-module-slot (er-module-current-env slot) nil
-                            (er-module-version slot)))
-                        (er-mk-atom "true"))))))))))
-
-(define er-bif-code-soft-purge
-  (fn (vs)
-    (let ((mod-arg (nth vs 0)))
-      (cond
-        (not (er-atom? mod-arg))
-          (raise (er-mk-error-marker (er-mk-atom "badarg")))
-        :else
-          (let ((registry (er-modules-get)) (mod-name (get mod-arg :name)))
-            (cond
-              (not (dict-has? registry mod-name)) (er-mk-atom "true")
-              :else
-                (let ((slot (get registry mod-name)))
-                  (cond
-                    (= (er-module-old-env slot) nil) (er-mk-atom "true")
-                    :else
-                      (let ((procs (er-procs-on-env (er-module-old-env slot))))
-                        (cond
-                          (> (len procs) 0) (er-mk-atom "false")
-                          :else
-                            (do
-                              (dict-set! registry mod-name
-                                (er-mk-module-slot (er-module-current-env slot) nil
-                                  (er-module-version slot)))
-                              (er-mk-atom "true"))))))))))))
-
-(define er-bif-code-which
-  (fn (vs)
-    (let ((mod-arg (nth vs 0)))
-      (cond
-        (not (er-atom? mod-arg))
-          (raise (er-mk-error-marker (er-mk-atom "badarg")))
-        (dict-has? (er-modules-get) (get mod-arg :name))
-          (er-mk-atom "loaded")
-        :else (er-mk-atom "non_existing")))))
-
-(define er-bif-code-is-loaded
-  (fn (vs)
-    (let ((mod-arg (nth vs 0)))
-      (cond
-        (not (er-atom? mod-arg))
-          (raise (er-mk-error-marker (er-mk-atom "badarg")))
-        (dict-has? (er-modules-get) (get mod-arg :name))
-          (er-mk-tuple (list (er-mk-atom "file") (er-mk-atom "loaded")))
-        :else (er-mk-atom "false")))))
-
-(define er-bif-code-all-loaded
-  (fn (vs)
-    (let ((registry (er-modules-get))
-          (ks (keys (er-modules-get)))
-          (out (er-mk-nil)))
-      (for-each
-        (fn (i)
-          (let ((k (nth ks (- (- (len ks) 1) i))))
-            (set! out
-              (er-mk-cons
-                (er-mk-tuple
-                  (list (er-mk-atom k) (er-mk-atom "loaded")))
-                out))))
-        (range 0 (len ks)))
-      out)))
-
-

lib/erlang/vm/dispatcher.sx

@@ -1,313 +0,0 @@
-;; Erlang VM — stub opcode dispatcher (Phase 9).
-;;
-;; Mimics the OCaml-side EXTENSION shape from
-;; plans/sx-vm-opcode-extension.md so opcodes 9b-9g can be designed
-;; and tested in SX before 9a (`hosts/ocaml/`) lands the real
-;; registration plumbing. When 9a is available, these stubs become
-;; the cross-host SX-side mirror of the C/OCaml handlers and the
-;; bytecode compiler emits them directly.
-;;
-;; Opcode IDs follow the plan's tier partition:
-;;   0-127     reserved for SX core
-;;   128-199   guest extensions (e.g. erlang, lua)
-;;   200-247   port-/platform-specific
-;;
-;; Erlang owns 128-159 for now.
-
-(define er-vm-opcodes (list {}))
-
-(define er-vm-opcodes-get (fn () (nth er-vm-opcodes 0)))
-
-(define
-  er-vm-opcodes-reset!
-  (fn () (set-nth! er-vm-opcodes 0 {})))
-
-(define
-  er-vm-register-opcode!
-  (fn
-    (id name handler)
-    (dict-set! (er-vm-opcodes-get) (str id) {:name name :id id :handler handler})
-    (er-mk-atom "ok")))
-
-(define
-  er-vm-lookup-opcode-by-id
-  (fn
-    (id)
-    (let
-      ((reg (er-vm-opcodes-get)) (k (str id)))
-      (if (dict-has? reg k) (get reg k) nil))))
-
-(define
-  er-vm-lookup-opcode-by-name
-  (fn
-    (name)
-    (let
-      ((reg (er-vm-opcodes-get))
-        (ks (keys (er-vm-opcodes-get)))
-        (found (list nil)))
-      (for-each
-        (fn
-          (i)
-          (let
-            ((entry (get reg (nth ks i))))
-            (when
-              (= (get entry :name) name)
-              (set-nth! found 0 entry))))
-        (range 0 (len ks)))
-      (nth found 0))))
-
-(define er-vm-list-opcodes (fn () (keys (er-vm-opcodes-get))))
-
-;; ── Phase 9i — host opcode-id resolution ────────────────────────
-;; When the OCaml `erlang_ext` extension is registered (Phase 9h), the
-;; runtime exposes `extension-opcode-id` which maps an "erlang.OP_*"
-;; name to the host-assigned id (222-239). We consult it so the SX
-;; side and the OCaml side agree on ids; when it returns nil (name not
-;; registered) we fall back to the stub-local id.
-;;
-;; NOTE: this requires a binary with the VM extension mechanism (the
-;; vm-ext phase-A..E cherry-pick + Sx_vm_extensions force-link). The
-;; loop builds and runs against exactly that binary
-;; (hosts/ocaml/_build/default/bin/sx_server.exe). `extension-opcode-id`
-;; resolves lazily at call time, so merely loading this file is safe;
-;; only invoking the resolver on a binary that lacks the primitive
-;; would raise.
-
-(define er-vm-host-opcode-id
-  (fn (ext-name)
-    (extension-opcode-id ext-name)))
-
-(define er-vm-effective-opcode-id
-  (fn (ext-name stub-id)
-    (let ((host (extension-opcode-id ext-name)))
-      (cond
-        (= host nil) stub-id
-        :else host))))
-
-(define
-  er-vm-dispatch
-  (fn
-    (id operands)
-    (let
-      ((entry (er-vm-lookup-opcode-by-id id)))
-      (if
-        (= entry nil)
-        (error (str "Erlang VM: unknown opcode id " id))
-        ((get entry :handler) operands)))))
-
-(define
-  er-vm-dispatch-by-name
-  (fn
-    (name operands)
-    (let
-      ((entry (er-vm-lookup-opcode-by-name name)))
-      (if
-        (= entry nil)
-        (error (str "Erlang VM: unknown opcode name '" name "'"))
-        ((get entry :handler) operands)))))
-
-;; ── Phase 9c — effect opcodes (perform / handle) ────────────────
-;; Stub algebraic-effects-style operators. OP_PERFORM raises a tagged
-;; exception; OP_HANDLE wraps a thunk in `guard` and catches matching
-;; effects, passing the args to the handler. The real specialization
-;; (constant-time effect dispatch, single-shot vs multi-shot continuations)
-;; lands when 9a integrates.
-
-(define er-vm-effect-marker?
-  (fn (c effect-name)
-    (and (= (type-of c) "dict")
-         (= (get c :tag) "vm-effect")
-         (= (get c :effect) effect-name))))
-
-(define er-vm-op-perform
-  (fn (operands)
-    (raise {:tag "vm-effect" :effect (nth operands 0) :args (nth operands 1)})))
-
-(define er-vm-op-handle
-  (fn (operands)
-    (let ((thunk (nth operands 0))
-          (effect-name (nth operands 1))
-          (handler (nth operands 2))
-          (result (list nil))
-          (caught (list false))
-          (rethrow (list nil)))
-      (guard
-        (c
-          (:else
-            (cond
-              (er-vm-effect-marker? c effect-name)
-                (do (set-nth! caught 0 true)
-                    (set-nth! result 0 (handler (get c :args))))
-              :else (set-nth! rethrow 0 c))))
-        (set-nth! result 0 (thunk)))
-      (cond
-        (not (= (nth rethrow 0) nil)) (raise (nth rethrow 0))
-        :else (nth result 0)))))
-
-;; ── Phase 9d — receive scan opcode ────────────────────────────
-;; Selective receive primitive. Scans a mailbox value-list in arrival
-;; order; for each value, tries each clause's pattern (binding into
-;; env on success); on match returns `{:matched true :index N :body B}`
-;; — the caller decides what to do with the index (queue-delete) and
-;; the body (eval in the now-mutated env). On miss returns
-;; `{:matched false}`, the caller arranges suspension (via OP_PERFORM).
-;;
-;; Operands: (clauses mbox-list env)
-;;   clauses    — list of {:pattern :guards :body} dicts
-;;   mbox-list  — SX list of message values
-;;   env        — env dict (mutated on match)
-
-(define er-vm-receive-try-clauses
-  (fn (clauses msg env i)
-    (cond
-      (>= i (len clauses)) {:matched false}
-      :else
-        (let ((c (nth clauses i)) (snap (er-env-copy env)))
-          (cond
-            (and
-              (er-match! (get c :pattern) msg env)
-              (er-eval-guards (get c :guards) env))
-              {:matched true :body (get c :body)}
-            :else
-              (do (er-env-restore! env snap)
-                  (er-vm-receive-try-clauses clauses msg env (+ i 1))))))))
-
-(define er-vm-receive-scan-loop
-  (fn (clauses mbox env i)
-    (cond
-      (>= i (len mbox)) {:matched false}
-      :else
-        (let ((msg (nth mbox i))
-              (cr (er-vm-receive-try-clauses clauses msg env 0)))
-          (cond
-            (get cr :matched) {:matched true :index i :body (get cr :body)}
-            :else (er-vm-receive-scan-loop clauses mbox env (+ i 1)))))))
-
-(define er-vm-op-receive-scan
-  (fn (operands)
-    (er-vm-receive-scan-loop (nth operands 0) (nth operands 1) (nth operands 2) 0)))
-
-;; ── Phase 9e — spawn / send + lightweight scheduler ─────────────
-;; Stub register-machine process layout for the eventual fast scheduler.
-;; A VM-process is `{:id :registers :mailbox :state :initial-fn :initial-args}`.
-;; Registers is a vector (SX list, mutated via set-nth!) — fixed slot count
-;; per process so cells don't grow during execution. Mailbox is an SX list.
-;; State is one of "runnable" / "waiting" / "dead". This sits PARALLEL to
-;; the existing `er-scheduler` (which is the language-level scheduler) —
-;; the VM scheduler will eventually take over once 9a integrates and
-;; bytecode-compiled Erlang runs against it.
-
-(define er-vm-procs (list {}))
-(define er-vm-procs-get (fn () (nth er-vm-procs 0)))
-(define er-vm-procs-reset!
-  (fn () (do (set-nth! er-vm-procs 0 {}) (set-nth! er-vm-next-pid 0 0))))
-
-(define er-vm-next-pid (list 0))
-
-(define er-vm-proc-new!
-  (fn (initial-fn initial-args)
-    (let ((pid (nth er-vm-next-pid 0)))
-      (set-nth! er-vm-next-pid 0 (+ pid 1))
-      (let ((proc
-              {:id pid
-               :registers (list nil nil nil nil nil nil nil nil)
-               :mailbox (list)
-               :state "runnable"
-               :initial-fn initial-fn
-               :initial-args initial-args}))
-        (dict-set! (er-vm-procs-get) (str pid) proc)
-        pid))))
-
-(define er-vm-proc-get (fn (pid) (get (er-vm-procs-get) (str pid))))
-
-(define er-vm-proc-send!
-  (fn (pid msg)
-    (let ((proc (er-vm-proc-get pid)))
-      (cond
-        (= proc nil) false
-        :else
-          (do
-            (dict-set! proc :mailbox (append (get proc :mailbox) (list msg)))
-            (when (= (get proc :state) "waiting")
-              (dict-set! proc :state "runnable"))
-            true)))))
-
-(define er-vm-proc-mailbox (fn (pid) (get (er-vm-proc-get pid) :mailbox)))
-(define er-vm-proc-state (fn (pid) (get (er-vm-proc-get pid) :state)))
-(define er-vm-proc-count (fn () (len (keys (er-vm-procs-get)))))
-
-(define er-vm-op-spawn
-  (fn (operands)
-    (er-vm-proc-new! (nth operands 0) (nth operands 1))))
-
-(define er-vm-op-send
-  (fn (operands)
-    (er-vm-proc-send! (nth operands 0) (nth operands 1))))
-
-;; ── Phase 9f — hot-BIF dispatch table ──────────────────────────
-;; Specialized opcodes for the BIFs that the bytecode compiler emits
-;; on hot call sites. The handler is the underlying `er-bif-*` impl
-;; directly — same `(vs)` signature as the dispatcher uses for
-;; operands, so the cost is the opcode-id → handler hop with no
-;; registry-key string lookup. Cold BIFs continue going through the
-;; general path (`er-apply-bif` / `er-lookup-bif`).
-;;
-;; Opcodes 136-159 reserved for hot BIFs.
-
-;; ── Phase 9b — pattern-match opcodes ────────────────────────────
-;; Each handler takes a list (pattern-ast value env) and returns
-;; true/false, mutating env on success (same contract as the
-;; existing er-match-tuple / er-match-cons / er-match-binary).
-;; Wire these as wrappers for now; the real opcodes will eventually
-;; have register-machine semantics and skip the AST-walk overhead.
-
-(define
-  er-vm-register-erlang-opcodes!
-  (fn
-    ()
-    (er-vm-register-opcode!
-      128
-      "OP_PATTERN_TUPLE"
-      (fn
-        (operands)
-        (er-match-tuple
-          (nth operands 0)
-          (nth operands 1)
-          (nth operands 2))))
-    (er-vm-register-opcode!
-      129
-      "OP_PATTERN_LIST"
-      (fn
-        (operands)
-        (er-match-cons
-          (nth operands 0)
-          (nth operands 1)
-          (nth operands 2))))
-    (er-vm-register-opcode!
-      130
-      "OP_PATTERN_BINARY"
-      (fn
-        (operands)
-        (er-match-binary
-          (nth operands 0)
-          (nth operands 1)
-          (nth operands 2))))
-    (er-vm-register-opcode! 131 "OP_PERFORM" er-vm-op-perform)
-    (er-vm-register-opcode! 132 "OP_HANDLE" er-vm-op-handle)
-    (er-vm-register-opcode! 133 "OP_RECEIVE_SCAN" er-vm-op-receive-scan)
-    (er-vm-register-opcode! 134 "OP_SPAWN" er-vm-op-spawn)
-    (er-vm-register-opcode! 135 "OP_SEND" er-vm-op-send)
-    ;; Phase 9f — hot BIFs
-    (er-vm-register-opcode! 136 "OP_BIF_LENGTH"        er-bif-length)
-    (er-vm-register-opcode! 137 "OP_BIF_HD"            er-bif-hd)
-    (er-vm-register-opcode! 138 "OP_BIF_TL"            er-bif-tl)
-    (er-vm-register-opcode! 139 "OP_BIF_ELEMENT"       er-bif-element)
-    (er-vm-register-opcode! 140 "OP_BIF_TUPLE_SIZE"    er-bif-tuple-size)
-    (er-vm-register-opcode! 141 "OP_BIF_LISTS_REVERSE" er-bif-lists-reverse)
-    (er-vm-register-opcode! 142 "OP_BIF_IS_INTEGER"    er-bif-is-integer)
-    (er-vm-register-opcode! 143 "OP_BIF_IS_ATOM"       er-bif-is-atom)
-    (er-vm-register-opcode! 144 "OP_BIF_IS_LIST"       er-bif-is-list)
-    (er-vm-register-opcode! 145 "OP_BIF_IS_TUPLE"      er-bif-is-tuple)
-    (er-mk-atom "ok")))
-
-(er-vm-register-erlang-opcodes!)

lib/feed/acl.sx

@@ -1,38 +0,0 @@
-; feed/acl — per-viewer visibility filtering. The same candidate stream yields
-; different timelines for different viewers, so ACL is applied per request and
-; pre-ACL timelines are never cached.
-;
-; permit? is injected: (permit? viewer activity) -> bool. Wire a real acl-sx
-; predicate here; feed/permit-acl? is a self-contained default that reads an
-; optional :visible-to allowlist on the activity.
-;
-; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx
-; (feed/-elem?), lib/feed/rank.sx (feed/top).
-
-; default permit: actor always sees own activity; absent/nil :visible-to is
-; public; otherwise viewer must be in the allowlist.
-(define
-  feed/permit-acl?
-  (fn
-    (viewer a)
-    (or
-      (equal? viewer (get a :actor))
-      (let
-        ((allowed (get a :visible-to nil)))
-        (if (= allowed nil) true (feed/-elem? viewer allowed))))))
-
-(define feed/permit-public? (fn (viewer a) true))
-
-; filter a stream to what viewer may read
-(define
-  feed/visible
-  (fn
-    (stream viewer permit?)
-    (feed/filter stream (fn (a) (permit? viewer a)))))
-
-; the capstone: candidate stream -> ACL for viewer -> rank -> top-N
-(define
-  feed/timeline
-  (fn
-    (stream viewer permit? score-fn n)
-    (feed/top (feed/visible stream viewer permit?) score-fn n)))

lib/feed/aggregate.sx

@@ -1,62 +0,0 @@
-; feed/aggregate — group-by / counting via key-reduce. Keys must be strings
-; (dict keys), so composite keys (actor, day) are joined into one string.
-;
-; Requires: lib/feed/normalize.sx, lib/feed/stream.sx.
-
-; group activities into a dict: key-string -> (list of activities), order-preserving
-(define
-  feed/group-by
-  (fn
-    (stream key-fn)
-    (reduce
-      (fn
-        (g a)
-        (let
-          ((k (key-fn a)))
-          (assoc g k (append (get g k (list)) (list a)))))
-      {}
-      (feed/items stream))))
-
-; key-string -> count
-(define
-  feed/group-count
-  (fn
-    (stream key-fn)
-    (reduce
-      (fn
-        (g a)
-        (let
-          ((k (key-fn a)))
-          (assoc g k (+ (get g k 0) 1))))
-      {}
-      (feed/items stream))))
-
-; --- composite keys ---------------------------------------------------------
-
-(define feed/day (fn (at window) (floor (/ at window))))
-
-; (actor, day-bucket) -> "actor#day"
-(define
-  feed/actor-day-key
-  (fn
-    (window)
-    (fn
-      (a)
-      (string-append
-        (get a :actor)
-        "#"
-        (number->string (feed/day (get a :at) window))))))
-
-(define
-  feed/by-actor-day
-  (fn (stream window) (feed/group-count stream (feed/actor-day-key window))))
-
-; per-actor activity counts
-(define
-  feed/actor-counts
-  (fn (stream) (feed/group-count stream feed/actor)))
-
-; per-object activity counts (engagement)
-(define
-  feed/object-counts
-  (fn (stream) (feed/group-count stream feed/object)))

lib/feed/api.sx

@@ -1,24 +0,0 @@
-; feed/api — ergonomic API over the stream layer for non-APL callers.
-; A single mutable activity log; post appends, all returns it as a stream.
-;
-; Requires: lib/feed/normalize.sx, lib/feed/stream.sx (loaded by harness).
-
-(define feed/-log (list))
-
-; post — normalize then append. Returns the stored activity.
-(define
-  feed/post
-  (fn
-    (raw)
-    (let
-      ((a (feed/normalize raw)))
-      (begin (set! feed/-log (append feed/-log (list a))) a))))
-
-; all — the whole log as a stream (insertion order)
-(define feed/all (fn () (feed/stream feed/-log)))
-
-; reset! — clear the log (test hygiene)
-(define feed/reset! (fn () (begin (set! feed/-log (list)) nil)))
-
-; size — number of posted activities
-(define feed/size (fn () (len feed/-log)))

lib/feed/conformance.sh

@@ -1,125 +0,0 @@
-#!/usr/bin/env bash
-# lib/feed/conformance.sh — run feed 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=(basic fanout rank integration content notify home dedupe trending mute page thread)
-
-OUT_JSON="lib/feed/scoreboard.json"
-OUT_MD="lib/feed/scoreboard.md"
-
-run_suite() {
-  local suite=$1
-  local file="lib/feed/tests/${suite}.sx"
-  local TMP
-  TMP=$(mktemp)
-  cat > "$TMP" << EPOCHS
-(epoch 1)
-(load "spec/stdlib.sx")
-(load "lib/r7rs.sx")
-(load "lib/apl/runtime.sx")
-(load "lib/feed/normalize.sx")
-(load "lib/feed/stream.sx")
-(load "lib/feed/api.sx")
-(load "lib/feed/fanout.sx")
-(load "lib/feed/dedupe.sx")
-(load "lib/feed/aggregate.sx")
-(load "lib/feed/rank.sx")
-(load "lib/feed/acl.sx")
-(load "lib/feed/fed.sx")
-(load "lib/feed/content.sx")
-(load "lib/feed/notify.sx")
-(load "lib/feed/home.sx")
-(load "lib/feed/trending.sx")
-(load "lib/feed/mute.sx")
-(load "lib/feed/page.sx")
-(load "lib/feed/thread.sx")
-(epoch 2)
-(eval "(define feed-test-pass 0)")
-(eval "(define feed-test-fail 0)")
-(eval "(define feed-test (fn (name got expected) (if (= got expected) (set! feed-test-pass (+ feed-test-pass 1)) (set! feed-test-fail (+ feed-test-fail 1)))))")
-(epoch 3)
-(load "${file}")
-(epoch 4)
-(eval "(list feed-test-pass feed-test-fail)")
-EPOCHS
-
-  local OUTPUT
-  OUTPUT=$(timeout 300 "$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 feed 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 '# feed Conformance Scoreboard\n\n'
-  printf '_Generated by `lib/feed/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))"
-} > "$OUT_MD"
-
-echo "Wrote $OUT_JSON and $OUT_MD" >&2
-echo "Total: $TOTAL_PASS pass, $TOTAL_FAIL fail" >&2
-
-[ "$TOTAL_FAIL" -eq 0 ]

lib/feed/content.sx

@@ -1,68 +0,0 @@
-; feed/content — TF-IDF relevance over activity :tags. Rare tags carry more
-; signal, so an activity matching an uncommon tag ranks above one matching a
-; common tag. Composes with rank.sx: feed/tfidf-score is just another scorer.
-;
-; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx
-; (feed/-distinct), lib/feed/rank.sx (feed/rank).
-
-; document frequency: tag -> number of activities whose :tags contain it
-; (a tag repeated within one activity counts once toward df)
-(define
-  feed/tag-df
-  (fn
-    (stream)
-    (reduce
-      (fn
-        (df a)
-        (reduce
-          (fn (d t) (assoc d t (+ (get d t 0) 1)))
-          df
-          (feed/-distinct (get a :tags))))
-      {}
-      (feed/items stream))))
-
-; inverse document frequency: tag -> log(N / df)
-(define
-  feed/tag-idf
-  (fn
-    (stream)
-    (let
-      ((n (feed/count stream)) (df (feed/tag-df stream)))
-      (reduce
-        (fn (idf t) (assoc idf t (log (/ n (get df t)))))
-        {}
-        (keys df)))))
-
-; term frequency within one activity: tag -> occurrence count
-(define
-  feed/-tf
-  (fn
-    (a)
-    (reduce
-      (fn (tf t) (assoc tf t (+ (get tf t 0) 1)))
-      {}
-      (get a :tags))))
-
-; relevance of an activity to a query (list of tags) given precomputed idf:
-; sum over query tags of tf(tag in activity) * idf(tag in corpus)
-(define
-  feed/tfidf-score
-  (fn
-    (idf query)
-    (fn
-      (a)
-      (let
-        ((tf (feed/-tf a)))
-        (reduce
-          (fn
-            (acc t)
-            (+ acc (* (get tf t 0) (get idf t 0))))
-          0
-          query)))))
-
-; rank a stream by relevance to query tags (idf computed over the stream itself)
-(define
-  feed/by-relevance
-  (fn
-    (stream query)
-    (feed/rank stream (feed/tfidf-score (feed/tag-idf stream) query))))

lib/feed/dedupe.sx

@@ -1,76 +0,0 @@
-; feed/dedupe — collapse duplicate items, keeping first occurrence per key.
-; Each verb may want its own key (see briefing): "alice posted X" keys on
-; (actor verb object) — distinct per actor; "alice liked X / bob liked X"
-; collapse on (verb object) so the cross-actor likes fold into one.
-;
-; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx
-; (feed/-elem? lives in fanout.sx).
-
-; generic: dedupe a stream by key-fn, first occurrence wins (stable)
-(define
-  feed/-dedup-by
-  (fn
-    (items key-fn)
-    (get
-      (reduce
-        (fn
-          (st x)
-          (let
-            ((k (key-fn x)))
-            (if (feed/-elem? k (get st :seen)) st {:seen (append (get st :seen) (list k)) :out (append (get st :out) (list x))})))
-        {:seen (list) :out (list)}
-        items)
-      :out)))
-
-(define
-  feed/dedupe
-  (fn
-    (stream key-fn)
-    (feed/stream (feed/-dedup-by (feed/items stream) key-fn))))
-
-; --- keys -------------------------------------------------------------------
-
-(define
-  feed/activity-key
-  (fn (a) (list (get a :actor) (get a :verb) (get a :object))))
-
-; collapse cross-actor duplicates of the same verb+object (e.g. likes)
-(define feed/collapse-key (fn (a) (list (get a :verb) (get a :object))))
-
-; per-receiver inbox key — one inbox event per (receiver, actor, verb, object)
-(define
-  feed/event-key
-  (fn
-    (ev)
-    (let
-      ((a (get ev :activity)))
-      (list (get ev :to) (get a :actor) (get a :verb) (get a :object)))))
-
-; verbs whose duplicates collapse across actors (reactions, not authorship).
-; rebindable: callers can (set! feed/collapse-verbs ...) to tune the policy.
-(define
-  feed/collapse-verbs
-  (list "like" "favourite" "follow" "boost" "repost"))
-
-; per-verb key: collapse-verbs fold on (verb object); the rest key on
-; (actor verb object).
-(define
-  feed/smart-key
-  (fn
-    (a)
-    (if
-      (feed/-elem? (get a :verb) feed/collapse-verbs)
-      (feed/collapse-key a)
-      (feed/activity-key a))))
-
-; --- ready-made dedupers ----------------------------------------------------
-
-(define feed/dedupe-activities (fn (s) (feed/dedupe s feed/activity-key)))
-
-(define feed/dedupe-collapse (fn (s) (feed/dedupe s feed/collapse-key)))
-
-; verb-aware: reactions collapse cross-actor, posts stay distinct per actor
-(define feed/dedupe-smart (fn (s) (feed/dedupe s feed/smart-key)))
-
-; dedupe an inbox: at most one event per receiver per (actor verb object)
-(define feed/dedupe-inbox (fn (inbox) (feed/dedupe inbox feed/event-key)))

lib/feed/fanout.sx

@@ -1,114 +0,0 @@
-; feed/fanout — THE SHOWCASE. Fan activities out to followers via the APL outer
-; product (∘.×). activities ∘.× audience → an (activity × follower) matrix of
-; inbox events; flatten to a vector; guard-keep only real follow edges.
-;
-; Requires: lib/apl/runtime.sx, lib/feed/normalize.sx, lib/feed/stream.sx.
-;
-; NOTE: apl-outer's combiner result is run through (if (scalar? r) (disclose r) r).
-; A bare dict counts as a scalar (shape ()) and disclose nils it — so the combiner
-; must (enclose ...) its event dict; apl-outer then discloses it back intact.
-
-; --- graph: {followee -> (list of followers)} -------------------------------
-
-(define feed/followers (fn (graph user) (get graph user (list))))
-
-; build a graph from (follower followee) edges: "follower follows followee"
-(define
-  feed/follow-graph
-  (fn
-    (edges)
-    (reduce
-      (fn
-        (g e)
-        (let
-          ((follower (first e)) (followee (nth e 1)))
-          (assoc
-            g
-            followee
-            (append (feed/followers g followee) (list follower)))))
-      {}
-      edges)))
-
-; --- helpers ----------------------------------------------------------------
-
-; unwrap an apl-scalar (has :ravel) back to its value; pass activities through
-(define
-  feed/-val
-  (fn
-    (x)
-    (if (and (= (type-of x) "dict") (has-key? x :ravel)) (disclose x) x)))
-
-(define feed/-elem? (fn (x lst) (some (fn (y) (equal? x y)) lst)))
-
-(define
-  feed/-distinct
-  (fn
-    (lst)
-    (if
-      (= (len lst) 0)
-      (list)
-      (get (apl-unique (make-array (list (len lst)) lst)) :ravel))))
-
-; rank-2 matrix -> rank-1 stream of its ravel
-(define feed/-flatten (fn (arr) (feed/stream (get arr :ravel))))
-
-; distinct receivers across the whole graph, sorted for determinism
-; (dict key order is unspecified, so sort to pin audience/recipient ordering)
-(define
-  feed/audience
-  (fn
-    (graph)
-    (sort
-      (feed/-distinct
-        (reduce
-          (fn (acc k) (append acc (feed/followers graph k)))
-          (list)
-          (keys graph))))))
-
-; --- the outer product ------------------------------------------------------
-
-; one (activity, follower) inbox event, enclosed so apl-outer keeps the dict
-(define feed/-mk-event (fn (a f) (enclose {:activity (feed/-val a) :to (feed/-val f)})))
-
-; keep events where :to actually follows the activity's actor
-(define
-  feed/-edge?
-  (fn
-    (graph)
-    (fn
-      (ev)
-      (feed/-elem?
-        (get ev :to)
-        (feed/followers graph (get (get ev :activity) :actor))))))
-
-; fanout — activities ∘.× audience, flatten, guard-keep real edges
-(define
-  feed/fanout
-  (fn
-    (stream graph)
-    (let
-      ((matrix (apl-outer feed/-mk-event stream (feed/stream (feed/audience graph)))))
-      (feed/filter (feed/-flatten matrix) (feed/-edge? graph)))))
-
-; --- inbox queries ----------------------------------------------------------
-
-(define
-  feed/inbox-for
-  (fn
-    (inbox user)
-    (feed/filter inbox (fn (ev) (equal? (get ev :to) user)))))
-
-(define
-  feed/recipients
-  (fn
-    (inbox)
-    (feed/-distinct (map (fn (ev) (get ev :to)) (feed/items inbox)))))
-
-; the activities (unwrapped) destined for a user
-(define
-  feed/inbox-activities
-  (fn
-    (inbox user)
-    (map
-      (fn (ev) (get ev :activity))
-      (feed/items (feed/inbox-for inbox user)))))

lib/feed/fed.sx

@@ -1,60 +0,0 @@
-; feed/fed — federation. Outbound: a local post fans out, then splits into local
-; vs remote inboxes; remote events are handed to an injected send-fn. Inbound:
-; peer activities merge into the local stream, deduped. Backfill: pull peer
-; history via an injected fetch-fn and merge.
-;
-; remote? / send-fn / fetch-fn are injected so real fed-sx transport wires in here
-; without feed depending on it.
-;
-; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx,
-; lib/feed/dedupe.sx.
-
-; --- merge / ingest ---------------------------------------------------------
-
-(define
-  feed/merge
-  (fn (s1 s2) (feed/stream (append (feed/items s1) (feed/items s2)))))
-
-; merge a peer stream into local, dropping (actor verb object) duplicates
-(define
-  feed/ingest
-  (fn (local peer) (feed/dedupe-activities (feed/merge local peer))))
-
-; --- inbound ----------------------------------------------------------------
-
-; peer pushes raw activities to the local inbox; normalize + ingest
-(define
-  feed/inbound
-  (fn
-    (local raw-activities)
-    (feed/ingest local (feed/stream (map feed/normalize raw-activities)))))
-
-; backfill on subscribe: pull peer history via fetch-fn, normalize, ingest
-(define
-  feed/backfill
-  (fn (local fetch-fn peer-id) (feed/inbound local (fetch-fn peer-id))))
-
-; --- outbound ---------------------------------------------------------------
-
-; split an inbox into local vs remote deliveries by viewer-id predicate
-(define feed/partition-inbox (fn (inbox remote?) {:local (feed/filter inbox (fn (ev) (not (remote? (get ev :to))))) :remote (feed/filter inbox (fn (ev) (remote? (get ev :to))))}))
-
-; fan a stream out over the graph, then partition by locality
-(define
-  feed/federate
-  (fn
-    (stream graph remote?)
-    (feed/partition-inbox (feed/fanout stream graph) remote?)))
-
-; deliver: hand each remote event to send-fn, return the local inbox to enqueue
-(define
-  feed/deliver
-  (fn
-    (stream graph remote? send-fn)
-    (let
-      ((parts (feed/federate stream graph remote?)))
-      (begin
-        (for-each
-          (fn (ev) (send-fn (get ev :to) (get ev :activity)))
-          (feed/items (get parts :remote)))
-        (get parts :local)))))

lib/feed/home.sx

@@ -1,23 +0,0 @@
-; feed/home — the capstone. A user's home timeline is the whole pipeline as one
-; line: fan all activities out over the follow graph, take the events landing in
-; the viewer's inbox, dedupe cross-posts, apply the viewer's ACL, rank, take N.
-;
-; Requires: fanout.sx, dedupe.sx, acl.sx (feed/timeline), rank.sx, stream.sx.
-
-; the activities in a user's inbox, as a stream
-(define
-  feed/inbox-stream
-  (fn (inbox user) (feed/stream (feed/inbox-activities inbox user))))
-
-; fanout ∘ inbox ∘ dedupe ∘ ACL ∘ rank ∘ take
-(define
-  feed/home
-  (fn
-    (stream graph viewer permit? score-fn n)
-    (feed/timeline
-      (feed/dedupe-activities
-        (feed/inbox-stream (feed/fanout stream graph) viewer))
-      viewer
-      permit?
-      score-fn
-      n)))

lib/feed/mute.sx

@@ -1,44 +0,0 @@
-; feed/mute — viewer-controlled filtering. ACL (acl.sx) is author-controlled
-; visibility; mute is the reader's own preference: hide muted actors or tags.
-; Like ACL it is per-viewer and applied per request, never cached.
-;
-; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx
-; (feed/-elem?).
-
-; drop activities authored by a muted actor
-(define
-  feed/mute-actors
-  (fn
-    (stream actors)
-    (feed/filter
-      stream
-      (fn (a) (not (feed/-elem? (get a :actor) actors))))))
-
-; drop activities carrying any muted tag
-(define
-  feed/mute-tags
-  (fn
-    (stream tags)
-    (feed/filter
-      stream
-      (fn (a) (not (some (fn (t) (feed/-elem? t tags)) (get a :tags)))))))
-
-; drop activities about a muted object (thread mute)
-(define
-  feed/mute-objects
-  (fn
-    (stream objects)
-    (feed/filter
-      stream
-      (fn (a) (not (feed/-elem? (get a :object) objects))))))
-
-; apply a viewer preference bag: {:mute-actors (...) :mute-tags (...) :mute-objects (...)}
-(define
-  feed/apply-prefs
-  (fn
-    (stream prefs)
-    (feed/mute-objects
-      (feed/mute-tags
-        (feed/mute-actors stream (get prefs :mute-actors (list)))
-        (get prefs :mute-tags (list)))
-      (get prefs :mute-objects (list)))))

lib/feed/normalize.sx

@@ -1,31 +0,0 @@
-; feed/normalize — coerce arbitrary input into the canonical activity record.
-; An activity is a small dict {:actor :verb :object :at :tags}; a stream is an
-; APL vector of such dicts (see stream.sx). Extra keys on the raw input survive
-; (e.g. :visible-to for ACL, peer metadata for federation) — :tags is the
-; flexible bag but the record is not closed.
-
-(define feed/activity-keys (list :actor :verb :object :at :tags))
-
-(define
-  feed/normalize
-  (fn
-    (raw)
-    (let
-      ((d (if (= (type-of raw) "dict") raw {})))
-      (merge d {:actor (get d :actor "") :object (get d :object nil) :at (get d :at 0) :tags (let ((t (get d :tags (list)))) (if (list? t) t (list t))) :verb (get d :verb "post")}))))
-
-(define
-  feed/activity
-  (fn (actor verb object at tags) (feed/normalize {:actor actor :object object :at at :tags tags :verb verb})))
-
-(define feed/actor (fn (a) (get a :actor)))
-(define feed/verb (fn (a) (get a :verb)))
-(define feed/object (fn (a) (get a :object)))
-(define feed/at (fn (a) (get a :at)))
-(define feed/tags (fn (a) (get a :tags)))
-
-(define
-  feed/activity?
-  (fn
-    (a)
-    (and (= (type-of a) "dict") (has-key? a :actor) (has-key? a :verb))))

lib/feed/notify.sx

@@ -1,45 +0,0 @@
-; feed/notify — a notification feed is a thin layer over a recipient's inbox:
-; the events directed at a user, optionally verb-filtered, and a digest that
-; collapses "alice, bob and 1 other liked X" by (verb, object).
-;
-; Requires: lib/feed/normalize.sx, lib/feed/stream.sx, lib/feed/fanout.sx
-; (feed/inbox-for, feed/-elem?).
-
-; all inbox events for a user (their raw notifications)
-(define feed/notifications (fn (inbox user) (feed/inbox-for inbox user)))
-
-; restrict to notification-worthy verbs (e.g. (list "like" "reply" "follow"))
-(define
-  feed/notify-verbs
-  (fn
-    (inbox user verbs)
-    (feed/filter
-      (feed/inbox-for inbox user)
-      (fn (ev) (feed/-elem? (get (get ev :activity) :verb) verbs)))))
-
-; group key "verb|object" — deterministic, sortable
-(define
-  feed/-notify-key
-  (fn
-    (ev)
-    (let
-      ((a (get ev :activity)))
-      (string-append (get a :verb) "|" (get a :object)))))
-
-; digest: one entry per (verb, object) with the distinct actors and a count,
-; ordered by key for determinism.
-(define
-  feed/notify-digest
-  (fn
-    (inbox user)
-    (let
-      ((events (feed/items (feed/inbox-for inbox user))))
-      (let
-        ((groups (reduce (fn (g ev) (let ((a (get ev :activity)) (k (feed/-notify-key ev))) (let ((cur (get g k {:object (get a :object) :actors (list) :verb (get a :verb)}))) (assoc g k (assoc cur :actors (append (get cur :actors) (list (get a :actor)))))))) {} events)))
-        (map
-          (fn
-            (k)
-            (let
-              ((grp (get groups k)))
-              (assoc grp :count (len (get grp :actors)))))
-          (sort (keys groups)))))))

lib/feed/page.sx

@@ -1,50 +0,0 @@
-; feed/page — pagination. Offset/limit for indexed access, and cursor-based
-; (by :at) for recency feeds, which is stable under inserts: a cursor is the
-; :at of the last item seen, and the next page is the newest items older than it.
-;
-; Requires: lib/feed/stream.sx (feed/recent, feed/take, feed/filter).
-
-; --- offset / limit ---------------------------------------------------------
-
-(define
-  feed/page
-  (fn
-    (stream offset limit)
-    (feed/stream (take (drop (feed/items stream) offset) limit))))
-
-(define
-  feed/page-count
-  (fn (stream limit) (ceil (/ (feed/count stream) limit))))
-
-; --- cursor (recency feeds) -------------------------------------------------
-
-; activities strictly older than cursor (scroll down / load older)
-(define
-  feed/before
-  (fn
-    (stream cursor)
-    (feed/filter stream (fn (a) (< (get a :at) cursor)))))
-
-; activities strictly newer than cursor (load newer / "N new posts")
-(define
-  feed/after
-  (fn
-    (stream cursor)
-    (feed/filter stream (fn (a) (> (get a :at) cursor)))))
-
-; one page: the `limit` newest activities older than cursor, newest first
-(define
-  feed/page-before
-  (fn
-    (stream cursor limit)
-    (feed/take (feed/recent (feed/before stream cursor)) limit)))
-
-; cursor to fetch the next (older) page: :at of the last item of a page,
-; or nil when the page is empty (end of feed)
-(define
-  feed/next-cursor
-  (fn
-    (page)
-    (let
-      ((items (feed/items page)))
-      (if (= (len items) 0) nil (get (last items) :at)))))

lib/feed/rank.sx

@@ -1,92 +0,0 @@
-; feed/rank — scoring + ranking. Scorers are (activity -> number). Ranking is a
-; stable two-pass grade-down: first by :at descending (the tiebreak), then by
-; score descending — so ties resolve by recency, then by input order. Fully
-; deterministic on ties.
-;
-; Requires: lib/apl/runtime.sx, lib/feed/normalize.sx, lib/feed/stream.sx.
-
-; --- scorers ----------------------------------------------------------------
-
-; recency: half-life decay. score = 0.5 ^ (age / half-life). at==now -> 1.0.
-(define
-  feed/recency
-  (fn
-    (now half-life)
-    (fn (a) (expt 0.5 (/ (- now (get a :at)) half-life)))))
-
-; velocity: how many of this actor's activities fall in (at-window, at] —
-; a burst of recent activity scores higher.
-(define
-  feed/velocity
-  (fn
-    (stream window)
-    (fn
-      (a)
-      (len
-        (filter
-          (fn
-            (b)
-            (and
-              (equal? (get b :actor) (get a :actor))
-              (<= (get b :at) (get a :at))
-              (> (get b :at) (- (get a :at) window))))
-          (feed/items stream))))))
-
-; engagement: how many activities in the stream touch this activity's :object
-(define
-  feed/engagement
-  (fn
-    (stream)
-    (fn
-      (a)
-      (len
-        (filter
-          (fn (b) (equal? (get b :object) (get a :object)))
-          (feed/items stream))))))
-
-; composite: weighted sum. parts = (list (list weight scorer) ...)
-(define
-  feed/composite
-  (fn
-    (parts)
-    (fn
-      (a)
-      (reduce
-        (fn (acc p) (+ acc (* (first p) ((nth p 1) a))))
-        0
-        parts))))
-
-; --- ranking ----------------------------------------------------------------
-
-; stable reorder of items by key-fn, descending (grade-down is stable)
-(define
-  feed/-desc-by
-  (fn
-    (items key-fn)
-    (let
-      ((keys (make-array (list (len items)) (map key-fn items))))
-      (let
-        ((order (get (apl-grade-down keys) :ravel)))
-        (map (fn (i) (nth items (- i 1))) order)))))
-
-; rank by score descending; ties -> :at descending -> input order
-(define
-  feed/rank
-  (fn
-    (stream score-fn)
-    (let
-      ((by-at (feed/-desc-by (feed/items stream) feed/at)))
-      (feed/stream (feed/-desc-by by-at score-fn)))))
-
-; attach a :score to each activity (for inspection / debugging)
-(define
-  feed/with-scores
-  (fn
-    (stream score-fn)
-    (feed/stream
-      (map (fn (a) (assoc a :score (score-fn a))) (feed/items stream)))))
-
-; top-N ranked timeline
-(define
-  feed/top
-  (fn (stream score-fn n) (feed/take (feed/rank stream score-fn) n)))

lib/feed/scoreboard.json

@@ -1,19 +0,0 @@
-{
-  "suites": {
-    "basic": {"pass": 30, "fail": 0},
-    "fanout": {"pass": 29, "fail": 0},
-    "rank": {"pass": 24, "fail": 0},
-    "integration": {"pass": 22, "fail": 0},
-    "content": {"pass": 15, "fail": 0},
-    "notify": {"pass": 8, "fail": 0},
-    "home": {"pass": 6, "fail": 0},
-    "dedupe": {"pass": 9, "fail": 0},
-    "trending": {"pass": 11, "fail": 0},
-    "mute": {"pass": 9, "fail": 0},
-    "page": {"pass": 14, "fail": 0},
-    "thread": {"pass": 12, "fail": 0}
-  },
-  "total_pass": 189,
-  "total_fail": 0,
-  "total": 189
-}

lib/feed/scoreboard.md

@@ -1,19 +0,0 @@
-# feed Conformance Scoreboard
-
-_Generated by `lib/feed/conformance.sh`_
-
-| Suite | Pass | Fail | Total |
-|-------|-----:|-----:|------:|
-| basic | 30 | 0 | 30 |
-| fanout | 29 | 0 | 29 |
-| rank | 24 | 0 | 24 |
-| integration | 22 | 0 | 22 |
-| content | 15 | 0 | 15 |
-| notify | 8 | 0 | 8 |
-| home | 6 | 0 | 6 |
-| dedupe | 9 | 0 | 9 |
-| trending | 11 | 0 | 11 |
-| mute | 9 | 0 | 9 |
-| page | 14 | 0 | 14 |
-| thread | 12 | 0 | 12 |
-| **Total** | **189** | **0** | **189** |

lib/feed/stream.sx

@@ -1,75 +0,0 @@
-; feed/stream — a stream is an APL vector (rank-1 array) whose ravel holds
-; activity dicts. Operations lift APL primitives onto this shape: filter via
-; compress (/), sort via grade (⍋), take via ↑, reverse via ⌽.
-;
-; Requires: lib/apl/runtime.sx, lib/feed/normalize.sx (loaded by harness).
-
-(define feed/stream (fn (acts) (make-array (list (len acts)) acts)))
-
-(define feed/items (fn (s) (get s :ravel)))
-
-(define feed/count (fn (s) (len (get s :ravel))))
-
-(define feed/empty (feed/stream (list)))
-
-(define feed/empty? (fn (s) (= (feed/count s) 0)))
-
-; filter — bool mask ∘ compress. pred : activity -> truthy
-(define
-  feed/filter
-  (fn
-    (s pred)
-    (let
-      ((items (get s :ravel)))
-      (let
-        ((mask (make-array (list (len items)) (map (fn (a) (if (pred a) 1 0)) items))))
-        (apl-compress mask s)))))
-
-; sort-by — ascending, stable on ties (grade-up is stable). key-fn : activity -> number
-(define
-  feed/sort-by
-  (fn
-    (s key-fn)
-    (let
-      ((items (get s :ravel)))
-      (let
-        ((keys (make-array (list (len items)) (map key-fn items))))
-        (let
-          ((order (get (apl-grade-up keys) :ravel)))
-          (feed/stream (map (fn (i) (nth items (- i 1))) order)))))))
-
-(define feed/sort-by-at (fn (s) (feed/sort-by s feed/at)))
-
-; newest-first: ascending sort then reverse (⌽)
-(define feed/recent (fn (s) (apl-reverse (feed/sort-by-at s))))
-
-; take N (↑), clamped to stream length so it never over-takes/pads
-(define
-  feed/take
-  (fn
-    (s n)
-    (let
-      ((c (feed/count s)))
-      (if (>= n c) s (apl-take (apl-scalar n) s)))))
-
-(define feed/reverse (fn (s) (apl-reverse s)))
-
-; common predicates
-(define
-  feed/by-actor
-  (fn (s actor) (feed/filter s (fn (a) (equal? (get a :actor) actor)))))
-
-(define
-  feed/by-verb
-  (fn (s verb) (feed/filter s (fn (a) (equal? (get a :verb) verb)))))
-
-(define
-  feed/by-object
-  (fn
-    (s object)
-    (feed/filter s (fn (a) (equal? (get a :object) object)))))
-
-; activities at or after timestamp t
-(define
-  feed/since
-  (fn (s t) (feed/filter s (fn (a) (>= (get a :at) t)))))

lib/feed/tests/basic.sx

@@ -1,118 +0,0 @@
-; Phase 1 — normalize, stream ops, api. Uses the feed-test harness
-; (feed-test name got expected) provided by conformance.sh.
-
-; ---------- normalize ----------
-
-(feed-test
-  "normalize default actor"
-  (feed/actor (feed/normalize {}))
-  "")
-(feed-test
-  "normalize default verb"
-  (feed/verb (feed/normalize {}))
-  "post")
-(feed-test
-  "normalize default at"
-  (feed/at (feed/normalize {}))
-  0)
-(feed-test
-  "normalize default object"
-  (feed/object (feed/normalize {}))
-  nil)
-(feed-test
-  "normalize default tags"
-  (feed/tags (feed/normalize {}))
-  (list))
-(feed-test
-  "normalize keeps actor"
-  (feed/actor (feed/normalize {:actor "alice"}))
-  "alice")
-(feed-test
-  "normalize keeps verb"
-  (feed/verb (feed/normalize {:verb "like"}))
-  "like")
-(feed-test
-  "normalize scalar tag -> list"
-  (feed/tags (feed/normalize {:tags "x"}))
-  (list "x"))
-(feed-test
-  "normalize list tags kept"
-  (feed/tags (feed/normalize {:tags (list "a" "b")}))
-  (list "a" "b"))
-(feed-test
-  "activity constructor at"
-  (feed/at (feed/activity "a" "post" "o" 5 (list)))
-  5)
-(feed-test
-  "activity? on activity"
-  (feed/activity? (feed/normalize {:actor "a"}))
-  true)
-(feed-test "activity? on number" (feed/activity? 5) false)
-(feed-test "activity? on bare dict" (feed/activity? {:foo 1}) false)
-
-; ---------- stream ----------
-
-(define
-  S
-  (feed/stream
-    (list
-      (feed/activity "alice" "post" "p1" 30 (list))
-      (feed/activity "bob" "like" "p1" 10 (list))
-      (feed/activity "alice" "post" "p2" 20 (list)))))
-
-(feed-test "stream count" (feed/count S) 3)
-(feed-test "stream items len" (len (feed/items S)) 3)
-(feed-test
-  "sort-by-at actors asc"
-  (map feed/actor (feed/items (feed/sort-by-at S)))
-  (list "bob" "alice" "alice"))
-(feed-test
-  "recent newest first"
-  (map feed/at (feed/items (feed/recent S)))
-  (list 30 20 10))
-(feed-test
-  "take 2 of recent"
-  (feed/count (feed/take (feed/recent S) 2))
-  2)
-(feed-test
-  "take clamps past end"
-  (feed/count (feed/take S 10))
-  3)
-(feed-test
-  "by-actor alice count"
-  (feed/count (feed/by-actor S "alice"))
-  2)
-(feed-test
-  "by-verb like actor"
-  (map feed/actor (feed/items (feed/by-verb S "like")))
-  (list "bob"))
-(feed-test
-  "by-object p1 count"
-  (feed/count (feed/by-object S "p1"))
-  2)
-(feed-test
-  "since 20 count"
-  (feed/count (feed/since S 20))
-  2)
-(feed-test
-  "reverse ats"
-  (map feed/at (feed/items (feed/reverse S)))
-  (list 20 10 30))
-(feed-test "empty? on empty" (feed/empty? feed/empty) true)
-(feed-test
-  "empty? on filtered-out"
-  (feed/empty? (feed/by-actor S "zzz"))
-  true)
-
-; ---------- api ----------
-
-(feed/reset!)
-(feed/post {:actor "x" :at 1 :verb "post"})
-(feed/post {:actor "y" :at 2 :verb "like"})
-(feed-test "api size after posts" (feed/size) 2)
-(feed-test "api all count" (feed/count (feed/all)) 2)
-(feed-test
-  "post returns normalized verb"
-  (feed/verb (feed/post {:actor "z"}))
-  "post")
-(feed-test "api size after third post" (feed/size) 3)

lib/feed/tests/content.sx

@@ -1,85 +0,0 @@
-; Follow-up — TF-IDF content ranking over :tags. (feed-test name got expected)
-
-(define
-  corpus
-  (feed/stream
-    (list
-      (feed/normalize {:actor "u" :object "o1" :at 10 :tags (list "cats" "funny")})
-      (feed/normalize {:actor "u" :object "o2" :at 20 :tags (list "cats" "news")})
-      (feed/normalize {:actor "u" :object "o3" :at 30 :tags (list "politics" "news")})
-      (feed/normalize {:actor "u" :object "o4" :at 40 :tags (list "cats")}))))
-
-; ---------- document frequency ----------
-
-(feed-test "df cats" (get (feed/tag-df corpus) "cats") 3)
-(feed-test "df news" (get (feed/tag-df corpus) "news") 2)
-(feed-test "df funny" (get (feed/tag-df corpus) "funny") 1)
-(feed-test "df politics" (get (feed/tag-df corpus) "politics") 1)
-(feed-test "df full" (feed/tag-df corpus) {:news 2 :funny 1 :politics 1 :cats 3})
-
-; ---------- inverse document frequency ----------
-
-(feed-test
-  "idf news = log(4/2)"
-  (get (feed/tag-idf corpus) "news")
-  (log 2))
-(feed-test
-  "idf funny = log(4/1)"
-  (get (feed/tag-idf corpus) "funny")
-  (log 4))
-(feed-test
-  "rarer tag has higher idf"
-  (>
-    (get (feed/tag-idf corpus) "funny")
-    (get (feed/tag-idf corpus) "cats"))
-  true)
-
-; ---------- tf-idf scoring ----------
-
-(define idf (feed/tag-idf corpus))
-
-(feed-test
-  "score query funny on o1"
-  ((feed/tfidf-score idf (list "funny")) (feed/normalize {:actor "u" :object "x" :tags (list "cats" "funny")}))
-  (log 4))
-(feed-test
-  "score query funny on non-match"
-  ((feed/tfidf-score idf (list "funny")) (feed/normalize {:actor "u" :object "x" :tags (list "cats")}))
-  0)
-(feed-test
-  "unknown query tag scores 0"
-  ((feed/tfidf-score idf (list "zzz")) (feed/normalize {:actor "u" :object "x" :tags (list "cats")}))
-  0)
-
-; ---------- ranking by relevance ----------
-
-; query news: o2,o3 match (score log2), o1,o4 don't (0); ties break by :at desc
-(feed-test
-  "by-relevance news order"
-  (map
-    (fn (a) (get a :object))
-    (feed/items (feed/by-relevance corpus (list "news"))))
-  (list "o3" "o2" "o4" "o1"))
-
-; query funny: only o1 matches -> ranks first
-(feed-test
-  "by-relevance funny first"
-  (get
-    (nth (feed/items (feed/by-relevance corpus (list "funny"))) 0)
-    :object)
-  "o1")
-
-; query (cats news): o2 carries both tags -> highest combined tf-idf
-(feed-test
-  "by-relevance cats+news top"
-  (get
-    (nth
-      (feed/items (feed/by-relevance corpus (list "cats" "news")))
-      0)
-    :object)
-  "o2")
-
-(feed-test
-  "by-relevance preserves count"
-  (feed/count (feed/by-relevance corpus (list "cats")))
-  4)

lib/feed/tests/dedupe.sx

@@ -1,56 +0,0 @@
-; Follow-up — verb-aware (smart) dedupe. (feed-test name got expected)
-
-; reactions (like/follow) collapse cross-actor; posts stay distinct per actor
-(define
-  M
-  (feed/stream
-    (list
-      (feed/activity "alice" "like" "X" 1 (list))
-      (feed/activity "bob" "like" "X" 2 (list))
-      (feed/activity "alice" "post" "P" 3 (list))
-      (feed/activity "bob" "post" "P" 4 (list))
-      (feed/activity "alice" "follow" "C" 5 (list))
-      (feed/activity "bob" "follow" "C" 6 (list))))) ; collapses
-
-(feed-test
-  "smart dedupe total"
-  (feed/count (feed/dedupe-smart M))
-  4)
-(feed-test
-  "smart keeps both posts"
-  (feed/count (feed/by-verb (feed/dedupe-smart M) "post"))
-  2)
-(feed-test
-  "smart collapses likes to one"
-  (feed/count (feed/by-verb (feed/dedupe-smart M) "like"))
-  1)
-(feed-test
-  "smart collapses follows to one"
-  (feed/count (feed/by-verb (feed/dedupe-smart M) "follow"))
-  1)
-(feed-test
-  "collapsed like keeps first actor"
-  (map feed/actor (feed/items (feed/by-verb (feed/dedupe-smart M) "like")))
-  (list "alice"))
-
-; contrast: plain activity dedupe keeps cross-actor likes distinct
-(feed-test
-  "activity dedupe keeps both likes"
-  (feed/count (feed/by-verb (feed/dedupe-activities M) "like"))
-  2)
-
-; contrast: blanket collapse folds the two posts (same verb+object) too
-(feed-test
-  "collapse dedupe folds posts"
-  (feed/count (feed/by-verb (feed/dedupe-collapse M) "post"))
-  1)
-
-; smart-key dispatch
-(feed-test
-  "smart-key reaction -> (verb object)"
-  (feed/smart-key (feed/activity "alice" "like" "X" 0 (list)))
-  (list "like" "X"))
-(feed-test
-  "smart-key post -> (actor verb object)"
-  (feed/smart-key (feed/activity "alice" "post" "P" 0 (list)))
-  (list "alice" "post" "P"))

lib/feed/tests/fanout.sx

@@ -1,187 +0,0 @@
-; Phase 2 — fanout via outer product + dedupe. (feed-test name got expected)
-
-; ---------- graph ----------
-
-; edges: (follower followee). bob,carol follow alice; carol,dave follow bob.
-(define
-  G
-  (feed/follow-graph
-    (list
-      (list "bob" "alice")
-      (list "carol" "alice")
-      (list "carol" "bob")
-      (list "dave" "bob"))))
-
-(feed-test "followers alice" (feed/followers G "alice") (list "bob" "carol"))
-(feed-test "followers bob" (feed/followers G "bob") (list "carol" "dave"))
-(feed-test "followers unknown" (feed/followers G "zzz") (list))
-(feed-test "audience distinct" (feed/audience G) (list "bob" "carol" "dave"))
-
-; ---------- fanout ----------
-
-(define
-  S
-  (feed/stream
-    (list
-      (feed/activity "alice" "post" "p1" 10 (list))
-      (feed/activity "alice" "post" "p2" 20 (list))
-      (feed/activity "bob" "like" "p1" 30 (list)))))
-
-(define IB (feed/fanout S G))
-
-(feed-test "fanout total edges" (feed/count IB) 6)
-(feed-test
-  "inbox bob count"
-  (feed/count (feed/inbox-for IB "bob"))
-  2)
-(feed-test
-  "inbox carol count"
-  (feed/count (feed/inbox-for IB "carol"))
-  3)
-(feed-test
-  "inbox dave count"
-  (feed/count (feed/inbox-for IB "dave"))
-  1)
-(feed-test
-  "inbox alice (follows none)"
-  (feed/count (feed/inbox-for IB "alice"))
-  0)
-(feed-test
-  "recipients order"
-  (feed/recipients IB)
-  (list "bob" "carol" "dave"))
-(feed-test
-  "bob inbox objects"
-  (map (fn (a) (get a :object)) (feed/inbox-activities IB "bob"))
-  (list "p1" "p2"))
-(feed-test
-  "dave inbox objects"
-  (map (fn (a) (get a :object)) (feed/inbox-activities IB "dave"))
-  (list "p1"))
-(feed-test
-  "dave inbox verb"
-  (map (fn (a) (get a :verb)) (feed/inbox-activities IB "dave"))
-  (list "like"))
-
-; empty graph → no audience → no edges
-(feed-test
-  "empty graph fanout"
-  (feed/count (feed/fanout S {}))
-  0)
-
-; actor nobody follows produces no edges
-(define
-  Sghost
-  (feed/stream (list (feed/activity "ghost" "post" "g1" 5 (list)))))
-(feed-test
-  "unfollowed actor fanout"
-  (feed/count (feed/fanout Sghost G))
-  0)
-
-; ---------- high fanout (popular actor) ----------
-
-(define
-  Gstar
-  (feed/follow-graph
-    (list
-      (list "u1" "star")
-      (list "u2" "star")
-      (list "u3" "star")
-      (list "u4" "star")
-      (list "u5" "star"))))
-(define
-  Sstar
-  (feed/stream (list (feed/activity "star" "post" "s1" 1 (list)))))
-(feed-test
-  "star fanout count"
-  (feed/count (feed/fanout Sstar Gstar))
-  5)
-(feed-test "star audience size" (len (feed/audience Gstar)) 5)
-
-; ---------- mutual follow ----------
-
-(define Gmut (feed/follow-graph (list (list "a" "b") (list "b" "a"))))
-(define
-  Smut
-  (feed/stream
-    (list
-      (feed/activity "a" "post" "pa" 1 (list))
-      (feed/activity "b" "post" "pb" 2 (list)))))
-(define IBmut (feed/fanout Smut Gmut))
-(feed-test "mutual total" (feed/count IBmut) 2)
-(feed-test
-  "mutual a gets pb"
-  (map (fn (x) (get x :object)) (feed/inbox-activities IBmut "a"))
-  (list "pb"))
-(feed-test
-  "mutual b gets pa"
-  (map (fn (x) (get x :object)) (feed/inbox-activities IBmut "b"))
-  (list "pa"))
-
-; ---------- dedupe ----------
-
-(define
-  Sdup2
-  (feed/stream
-    (list
-      (feed/activity "alice" "post" "p1" 1 (list))
-      (feed/activity "alice" "post" "p1" 9 (list))
-      (feed/activity "alice" "post" "p2" 2 (list)))))
-(feed-test
-  "dedupe-activities collapses dup"
-  (feed/count (feed/dedupe-activities Sdup2))
-  2)
-(feed-test
-  "dedupe-activities keeps distinct"
-  (map
-    (fn (a) (get a :object))
-    (feed/items (feed/dedupe-activities Sdup2)))
-  (list "p1" "p2"))
-
-(define
-  Slikes
-  (feed/stream
-    (list
-      (feed/activity "alice" "like" "X" 1 (list))
-      (feed/activity "bob" "like" "X" 2 (list))
-      (feed/activity "carol" "like" "Y" 3 (list)))))
-(feed-test
-  "collapse cross-actor likes"
-  (feed/count (feed/dedupe-collapse Slikes))
-  2)
-(feed-test
-  "collapse keeps distinct objects"
-  (map
-    (fn (a) (get a :object))
-    (feed/items (feed/dedupe-collapse Slikes)))
-  (list "X" "Y"))
-
-(feed-test
-  "activity-key shape"
-  (feed/activity-key (feed/activity "a" "post" "o" 0 (list)))
-  (list "a" "post" "o"))
-(feed-test
-  "collapse-key shape"
-  (feed/collapse-key (feed/activity "a" "like" "o" 0 (list)))
-  (list "like" "o"))
-
-; cross-post: alice posts p1 twice → bob's inbox has it twice → dedupe-inbox → once
-(define
-  Scross
-  (feed/stream
-    (list
-      (feed/activity "alice" "post" "p1" 1 (list))
-      (feed/activity "alice" "post" "p1" 5 (list)))))
-(define IBcross (feed/fanout Scross G))
-(feed-test
-  "cross-post raw bob count"
-  (feed/count (feed/inbox-for IBcross "bob"))
-  2)
-(feed-test
-  "cross-post deduped bob count"
-  (feed/count (feed/inbox-for (feed/dedupe-inbox IBcross) "bob"))
-  1)
-(feed-test
-  "dedupe-inbox keeps distinct receivers"
-  (feed/count (feed/dedupe-inbox IBcross))
-  2)

lib/feed/tests/home.sx

@@ -1,73 +0,0 @@
-; Follow-up — feed/home capstone pipeline. (feed-test name got expected)
-
-; alice follows star and bob (edges: follower followee)
-(define
-  G
-  (feed/follow-graph (list (list "alice" "star") (list "alice" "bob"))))
-
-; star posts s1 then s2; bob posts b1; star re-posts s1 (cross-post dup);
-; zoe posts z1 (alice does NOT follow zoe)
-(define
-  S
-  (feed/stream
-    (list
-      (feed/activity "star" "post" "s1" 10 (list))
-      (feed/activity "star" "post" "s2" 20 (list))
-      (feed/activity "bob" "post" "b1" 15 (list))
-      (feed/activity "star" "post" "s1" 5 (list))
-      (feed/activity "zoe" "post" "z1" 30 (list)))))
-
-(define rec (feed/recency 100 10))
-
-(feed-test
-  "home count (deduped, followed only)"
-  (feed/count (feed/home S G "alice" feed/permit-public? rec 10))
-  3)
-
-(feed-test
-  "home order by recency"
-  (map
-    (fn (a) (get a :object))
-    (feed/items (feed/home S G "alice" feed/permit-public? rec 10)))
-  (list "s2" "b1" "s1"))
-
-(feed-test
-  "home excludes unfollowed zoe"
-  (feed/-elem?
-    "z1"
-    (map
-      (fn (a) (get a :object))
-      (feed/items (feed/home S G "alice" feed/permit-public? rec 10))))
-  false)
-
-(feed-test
-  "home top-2"
-  (map
-    (fn (a) (get a :object))
-    (feed/items (feed/home S G "alice" feed/permit-public? rec 2)))
-  (list "s2" "b1"))
-
-(feed-test
-  "home dedupes cross-post (one s1)"
-  (len
-    (filter
-      (fn (o) (equal? o "s1"))
-      (map
-        (fn (a) (get a :object))
-        (feed/items
-          (feed/home S G "alice" feed/permit-public? rec 10)))))
-  1)
-
-; ACL applied per-viewer in the home pipeline
-(define
-  Sacl
-  (feed/stream
-    (list (feed/normalize {:actor "star" :object "pub" :at 20}) (feed/normalize {:actor "star" :object "sec" :visible-to (list "carol") :at 25}))))
-(define Gacl (feed/follow-graph (list (list "alice" "star"))))
-
-(feed-test
-  "home hides activity alice not permitted"
-  (map
-    (fn (a) (get a :object))
-    (feed/items (feed/home Sacl Gacl "alice" feed/permit-acl? rec 10)))
-  (list "pub"))

lib/feed/tests/integration.sx

@@ -1,155 +0,0 @@
-; Phase 4 — visibility (ACL) + federation, and the end-to-end timeline.
-; (feed-test name got expected)
-
-; ---------- ACL visibility ----------
-; pub: public. sec: bob, allows carol. dm: frank, allows dave.
-
-(define
-  C
-  (feed/stream
-    (list
-      (feed/normalize {:actor "alice" :object "pub" :at 10})
-      (feed/normalize {:actor "bob" :object "sec" :visible-to (list "carol") :at 20})
-      (feed/normalize {:actor "frank" :object "dm" :visible-to (list "dave") :at 30}))))
-
-(feed-test
-  "public visible to anyone"
-  (feed/count (feed/visible C "zoe" feed/permit-acl?))
-  1)
-(feed-test
-  "carol sees allowlisted + public"
-  (feed/count (feed/visible C "carol" feed/permit-acl?))
-  2)
-(feed-test
-  "dave sees dm + public"
-  (feed/count (feed/visible C "dave" feed/permit-acl?))
-  2)
-(feed-test
-  "author always sees own private"
-  (feed/count (feed/visible C "frank" feed/permit-acl?))
-  2)
-(feed-test
-  "permit-public? lets all through"
-  (feed/count (feed/visible C "zoe" feed/permit-public?))
-  3)
-(feed-test
-  "visible objects for dave"
-  (map
-    (fn (a) (get a :object))
-    (feed/items (feed/visible C "dave" feed/permit-acl?)))
-  (list "pub" "dm"))
-
-; per-viewer: same stream, different timelines
-(feed-test
-  "zoe timeline differs from carol"
-  (not
-    (=
-      (feed/count (feed/visible C "zoe" feed/permit-acl?))
-      (feed/count (feed/visible C "carol" feed/permit-acl?))))
-  true)
-
-; ---------- federation: merge / ingest ----------
-
-(define
-  L
-  (feed/stream
-    (list
-      (feed/activity "alice" "post" "p1" 10 (list))
-      (feed/activity "alice" "post" "p2" 20 (list)))))
-(define
-  P
-  (feed/stream
-    (list
-      (feed/activity "alice" "post" "p2" 20 (list))
-      (feed/activity "peer" "post" "p9" 25 (list)))))
-
-(feed-test "merge concatenates" (feed/count (feed/merge L P)) 4)
-(feed-test
-  "ingest dedupes overlap"
-  (feed/count (feed/ingest L P))
-  3)
-
-(feed-test
-  "inbound normalizes + ingests"
-  (feed/count (feed/inbound L (list {:actor "peer" :object "p9" :at 25} {:actor "alice" :object "p1" :at 10})))
-  3)
-
-; backfill via injected fetch-fn
-(define peer-history (fn (peer-id) (list {:actor peer-id :object "h1" :at 1} {:actor peer-id :object "h2" :at 2})))
-(feed-test
-  "backfill merges peer history"
-  (feed/count (feed/backfill L peer-history "remote"))
-  4)
-(feed-test
-  "backfill objects present"
-  (map
-    (fn (a) (get a :object))
-    (feed/items
-      (feed/by-actor (feed/backfill L peer-history "remote") "remote")))
-  (list "h1" "h2"))
-
-; ---------- federation: outbound partition ----------
-
-; bob (local), alice@remote + carol@remote (remote) follow star
-(define
-  Gf
-  (feed/follow-graph
-    (list
-      (list "bob" "star")
-      (list "alice@remote" "star")
-      (list "carol@remote" "star"))))
-(define
-  Sf
-  (feed/stream (list (feed/activity "star" "post" "s1" 1 (list)))))
-(define
-  remote?
-  (fn (id) (feed/-elem? id (list "alice@remote" "carol@remote"))))
-(define parts (feed/federate Sf Gf remote?))
-
-(feed-test "local deliveries" (feed/count (get parts :local)) 1)
-(feed-test "remote deliveries" (feed/count (get parts :remote)) 2)
-(feed-test
-  "local recipient is bob"
-  (feed/recipients (get parts :local))
-  (list "bob"))
-
-; deliver: send-fn receives each remote event, local inbox returned
-(define sent (list))
-(define send-fn (fn (to act) (set! sent (append sent (list to)))))
-(define local-inbox (feed/deliver Sf Gf remote? send-fn))
-(feed-test "deliver returns local inbox" (feed/count local-inbox) 1)
-(feed-test "deliver sent to both remotes" (len sent) 2)
-(feed-test "deliver remote targets" sent (list "alice@remote" "carol@remote"))
-
-; ---------- end-to-end: federated, ACL-filtered, ranked timeline ----------
-
-(define
-  base
-  (feed/stream
-    (list
-      (feed/normalize {:actor "alice" :object "a1" :at 100})
-      (feed/normalize {:actor "bob" :object "b1" :visible-to (list "carol") :at 90})
-      (feed/normalize {:actor "eve" :object "e1" :visible-to (list "dave") :at 80}))))
-(define federated (feed/inbound base (list {:actor "peer" :object "x1" :at 110})))
-(define rec (feed/recency 120 10))
-(define
-  carol-tl
-  (feed/timeline federated "carol" feed/permit-acl? rec 3))
-
-; eve's :visible-to excludes carol -> filtered out; peer/alice public, bob allows carol
-(feed-test "carol federated timeline count" (feed/count carol-tl) 3)
-(feed-test
-  "carol timeline order (recency)"
-  (map (fn (a) (get a :object)) (feed/items carol-tl))
-  (list "x1" "a1" "b1"))
-(feed-test
-  "eve dm excluded from carol"
-  (feed/-elem? "e1" (map (fn (a) (get a :object)) (feed/items carol-tl)))
-  false)
-(feed-test
-  "dave sees eve dm not bob"
-  (map
-    (fn (a) (get a :object))
-    (feed/items
-      (feed/timeline federated "dave" feed/permit-acl? rec 5)))
-  (list "x1" "a1" "e1"))