fed-sx-m1: Step 1a — next/ skeleton + README + gitignore

.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",

lib/go/conformance.sh

@@ -1,141 +0,0 @@
-#!/usr/bin/env bash
-# Go-on-SX conformance runner.
-#
-# Loads every Go-on-SX test suite via the epoch protocol, collects
-# pass/fail counts, and writes lib/go/scoreboard.json + .md.
-#
-# Usage:
-#   bash lib/go/conformance.sh           # run all suites
-#   bash lib/go/conformance.sh -v        # verbose per-suite
-
-set -uo pipefail
-cd "$(git rev-parse --show-toplevel)"
-
-SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}"
-if [ ! -x "$SX_SERVER" ]; then
-  SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe"
-fi
-if [ ! -x "$SX_SERVER" ]; then
-  echo "ERROR: sx_server.exe not found." >&2
-  exit 1
-fi
-
-VERBOSE="${1:-}"
-TMPFILE=$(mktemp)
-OUTFILE=$(mktemp)
-trap "rm -f $TMPFILE $OUTFILE" EXIT
-
-# Each suite: name | pass-counter | total-counter
-SUITES=(
-  "lex|go-test-pass|go-test-count"
-  "parse|go-parse-test-pass|go-parse-test-count"
-  "types|go-types-test-pass|go-types-test-count"
-  "eval|go-eval-test-pass|go-eval-test-count"
-  "runtime|go-rt-test-pass|go-rt-test-count"
-  "stdlib|go-std-test-pass|go-std-test-count"
-  "e2e|go-e2e-test-pass|go-e2e-test-count"
-)
-
-cat > "$TMPFILE" <<'EPOCHS'
-(epoch 1)
-(load "lib/guest/lex.sx")
-(load "lib/guest/ast.sx")
-(load "lib/guest/pratt.sx")
-(load "lib/go/lex.sx")
-(load "lib/go/parse.sx")
-(load "lib/go/types.sx")
-(load "lib/go/sched.sx")
-(load "lib/go/eval.sx")
-(load "lib/go/std/strings.sx")
-(load "lib/go/std/strconv.sx")
-(load "lib/go/tests/lex.sx")
-(load "lib/go/tests/parse.sx")
-(load "lib/go/tests/types.sx")
-(load "lib/go/tests/eval.sx")
-(load "lib/go/tests/runtime.sx")
-(load "lib/go/tests/stdlib.sx")
-(load "lib/go/tests/e2e.sx")
-EPOCHS
-
-idx=0
-for entry in "${SUITES[@]}"; do
-  name="${entry%%|*}"
-  pass_var=$(echo "$entry" | awk -F'|' '{print $2}')
-  total_var=$(echo "$entry" | awk -F'|' '{print $3}')
-  epoch=$((100 + idx))
-  echo "(epoch $epoch)" >> "$TMPFILE"
-  echo "(eval \"(list $pass_var $total_var)\")" >> "$TMPFILE"
-  idx=$((idx + 1))
-done
-
-"$SX_SERVER" < "$TMPFILE" > "$OUTFILE" 2>&1
-
-parse_pair() {
-  local epoch="$1"
-  local line
-  line=$(grep -A1 "^(ok-len $epoch " "$OUTFILE" | tail -1)
-  echo "$line" | sed -E 's/[()]//g'
-}
-
-TOTAL_PASS=0
-TOTAL_COUNT=0
-JSON_SUITES=""
-MD_ROWS=""
-
-idx=0
-for entry in "${SUITES[@]}"; do
-  name="${entry%%|*}"
-  epoch=$((100 + idx))
-  pair=$(parse_pair "$epoch")
-  pass=$(echo "$pair" | awk '{print $1}')
-  count=$(echo "$pair" | awk '{print $2}')
-  if [ -z "$pass" ] || [ -z "$count" ]; then
-    pass=0
-    count=0
-  fi
-  TOTAL_PASS=$((TOTAL_PASS + pass))
-  TOTAL_COUNT=$((TOTAL_COUNT + count))
-  status="ok"
-  marker="✅"
-  if [ "$pass" != "$count" ]; then
-    status="fail"
-    marker="❌"
-  fi
-  if [ "$VERBOSE" = "-v" ]; then
-    printf "  %-12s %s/%s\n" "$name" "$pass" "$count"
-  fi
-  if [ -n "$JSON_SUITES" ]; then JSON_SUITES+=","; fi
-  JSON_SUITES+=$'\n    '
-  JSON_SUITES+="{\"name\":\"$name\",\"pass\":$pass,\"total\":$count,\"status\":\"$status\"}"
-  MD_ROWS+="| $marker | $name | $pass | $count |"$'\n'
-  idx=$((idx + 1))
-done
-
-printf '\nGo-on-SX conformance: %d / %d\n' "$TOTAL_PASS" "$TOTAL_COUNT"
-
-cat > lib/go/scoreboard.json <<JSON
-{
-  "language": "go",
-  "total_pass": $TOTAL_PASS,
-  "total": $TOTAL_COUNT,
-  "suites": [$JSON_SUITES]
-}
-JSON
-
-cat > lib/go/scoreboard.md <<MD
-# Go-on-SX Scoreboard
-
-**Total: ${TOTAL_PASS} / ${TOTAL_COUNT} tests passing**
-
-|  | Suite | Pass | Total |
-|---|---|---|---|
-$MD_ROWS
-
-Generated by \`lib/go/conformance.sh\`.
-MD
-
-if [ "$TOTAL_PASS" -eq "$TOTAL_COUNT" ]; then
-  exit 0
-else
-  exit 1
-fi

lib/go/lex.sx

@@ -1,476 +0,0 @@
-;; lib/go/lex.sx — Go tokenizer with automatic semicolon insertion.
-;;
-;; Consumes lib/guest/lex.sx character-class predicates.
-;;
-;; Tokens: {:type T :value V :pos P}
-;; Types:
-;;   "ident"   — identifiers (foo, _bar, mixedCase)
-;;   "keyword" — one of the 25 Go keywords
-;;   "int"     — integer literals (decimal, 0x.. hex, 0b.. binary, 0o.. octal,
-;;               legacy 0123 octal; underscores between digits allowed)
-;;   "float"   — decimal float literals (3.14, .5, 1., 1e10, 1.5e-3, 1E5)
-;;   "imag"    — imaginary literals (2i, 3.14i, 1e2i)
-;;   "string"  — interpreted string literals "..." OR raw string literals `...`
-;;   "rune"    — rune literals 'x' (single char + simple escapes)
-;;   "op"      — operators & punctuation; :value is the literal text
-;;   "semi"    — explicit ';' or auto-inserted (Go spec § Semicolons)
-;;   "eof"     — end-of-input sentinel
-;;
-;; ASI (Go spec § Semicolons): a newline (or EOF, or a block comment
-;; containing a newline) emits a ";semi" if the previous emitted token's
-;; type is ident/int/float/imag/string/rune, or its value is one of
-;;   {break, continue, fallthrough, return, ++, --, ), ], }}.
-;;
-;; All scanner locals are gl- prefixed: SX host primitives (peek/emit/etc.)
-;; silently shadow guest-language defines. See feedback_sx_bind_clash.
-
-(define
-  go-keywords
-  (list
-    "break"
-    "case"
-    "chan"
-    "const"
-    "continue"
-    "default"
-    "defer"
-    "else"
-    "fallthrough"
-    "for"
-    "func"
-    "go"
-    "goto"
-    "if"
-    "import"
-    "interface"
-    "map"
-    "package"
-    "range"
-    "return"
-    "select"
-    "struct"
-    "switch"
-    "type"
-    "var"))
-
-(define go-keyword? (fn (s) (some (fn (k) (= k s)) go-keywords)))
-
-(define go-asi-keywords (list "break" "continue" "fallthrough" "return"))
-
-(define go-asi-ops (list "++" "--" ")" "]" "}"))
-
-(define go-asi-lit-types (list "ident" "int" "float" "imag" "string" "rune"))
-
-(define
-  go-asi-trigger?
-  (fn
-    (tok)
-    (if
-      (= tok nil)
-      false
-      (let
-        ((ty (get tok :type)) (v (get tok :value)))
-        (or
-          (some (fn (lt) (= lt ty)) go-asi-lit-types)
-          (and (= ty "keyword") (some (fn (k) (= k v)) go-asi-keywords))
-          (and (= ty "op") (some (fn (o) (= o v)) go-asi-ops)))))))
-
-(define
-  go-tokenize
-  (fn
-    (src)
-    (let
-      ((tokens (list)) (pos 0) (src-len (len src)))
-      (define
-        gl-peek
-        (fn
-          (offset)
-          (if (< (+ pos offset) src-len) (nth src (+ pos offset)) nil)))
-      (define gl-cur (fn () (gl-peek 0)))
-      (define gl-advance! (fn (n) (set! pos (+ pos n))))
-      (define
-        gl-last
-        (fn
-          ()
-          (if
-            (= (len tokens) 0)
-            nil
-            (nth tokens (- (len tokens) 1)))))
-      (define gl-emit! (fn (type value start) (append! tokens {:type type :value value :pos start})))
-      (define
-        gl-maybe-asi!
-        (fn
-          (at)
-          (when (go-asi-trigger? (gl-last)) (gl-emit! "semi" "\n" at))))
-      (define
-        gl-oct-digit?
-        (fn (c) (and (not (= c nil)) (>= c "0") (<= c "7"))))
-      (define gl-bin-digit? (fn (c) (or (= c "0") (= c "1"))))
-      (define
-        gl-skip-line!
-        (fn
-          ()
-          (when
-            (and (< pos src-len) (not (= (gl-cur) "\n")))
-            (gl-advance! 1)
-            (gl-skip-line!))))
-      (define
-        gl-skip-block!
-        (fn
-          (saw-nl)
-          (cond
-            (>= pos src-len)
-            saw-nl
-            (and (= (gl-cur) "*") (= (gl-peek 1) "/"))
-            (do (gl-advance! 2) saw-nl)
-            :else (let
-              ((is-nl (= (gl-cur) "\n")))
-              (gl-advance! 1)
-              (gl-skip-block! (or saw-nl is-nl))))))
-      (define
-        gl-read-ident!
-        (fn
-          (start)
-          (when
-            (and (< pos src-len) (lex-ident-char? (gl-cur)))
-            (gl-advance! 1)
-            (gl-read-ident! start))
-          (slice src start pos)))
-      (define
-        gl-read-digit-run!
-        (fn
-          (digit?)
-          (when
-            (and (< pos src-len) (or (digit? (gl-cur)) (= (gl-cur) "_")))
-            (gl-advance! 1)
-            (gl-read-digit-run! digit?))))
-      (define
-        gl-finish-number!
-        (fn
-          (has-fraction?)
-          (let
-            ((typ (if has-fraction? "float" "int")))
-            (when
-              (or (= (gl-cur) "e") (= (gl-cur) "E"))
-              (gl-advance! 1)
-              (when
-                (or (= (gl-cur) "+") (= (gl-cur) "-"))
-                (gl-advance! 1))
-              (gl-read-digit-run! lex-digit?)
-              (set! typ "float"))
-            (cond
-              (= (gl-cur) "i")
-              (do (gl-advance! 1) "imag")
-              :else typ))))
-      (define
-        gl-read-number!
-        (fn
-          ()
-          (cond
-            (and (= (gl-cur) ".") (lex-digit? (gl-peek 1)))
-            (do
-              (gl-advance! 1)
-              (gl-read-digit-run! lex-digit?)
-              (gl-finish-number! true))
-            (and
-              (= (gl-cur) "0")
-              (or
-                (= (gl-peek 1) "x")
-                (= (gl-peek 1) "X")))
-            (do
-              (gl-advance! 2)
-              (gl-read-digit-run! lex-hex-digit?)
-              "int")
-            (and
-              (= (gl-cur) "0")
-              (or
-                (= (gl-peek 1) "b")
-                (= (gl-peek 1) "B")))
-            (do
-              (gl-advance! 2)
-              (gl-read-digit-run! gl-bin-digit?)
-              "int")
-            (and
-              (= (gl-cur) "0")
-              (or
-                (= (gl-peek 1) "o")
-                (= (gl-peek 1) "O")))
-            (do
-              (gl-advance! 2)
-              (gl-read-digit-run! gl-oct-digit?)
-              "int")
-            :else (do
-              (gl-read-digit-run! lex-digit?)
-              (cond
-                (and (= (gl-cur) ".") (not (= (gl-peek 1) ".")))
-                (do
-                  (gl-advance! 1)
-                  (gl-read-digit-run! lex-digit?)
-                  (gl-finish-number! true))
-                :else (gl-finish-number! false))))))
-      (define
-        gl-read-string!
-        (fn
-          ()
-          (gl-advance! 1)
-          (let
-            ((chars (list)))
-            (define
-              gl-string-loop
-              (fn
-                ()
-                (cond
-                  (>= pos src-len)
-                  nil
-                  (= (gl-cur) "\"")
-                  (gl-advance! 1)
-                  (= (gl-cur) "\\")
-                  (do
-                    (gl-advance! 1)
-                    (when
-                      (< pos src-len)
-                      (let
-                        ((ch (gl-cur)))
-                        (cond
-                          (= ch "n")
-                          (append! chars "\n")
-                          (= ch "t")
-                          (append! chars "\t")
-                          (= ch "r")
-                          (append! chars "\r")
-                          (= ch "\\")
-                          (append! chars "\\")
-                          (= ch "\"")
-                          (append! chars "\"")
-                          (= ch "'")
-                          (append! chars "'")
-                          :else (append! chars ch))
-                        (gl-advance! 1)))
-                    (gl-string-loop))
-                  :else (do
-                    (append! chars (gl-cur))
-                    (gl-advance! 1)
-                    (gl-string-loop)))))
-            (gl-string-loop)
-            (join "" chars))))
-      (define
-        gl-read-raw-string!
-        (fn
-          ()
-          (gl-advance! 1)
-          (let
-            ((chars (list)))
-            (define
-              gl-raw-loop
-              (fn
-                ()
-                (cond
-                  (>= pos src-len)
-                  nil
-                  (= (gl-cur) "`")
-                  (gl-advance! 1)
-                  (= (gl-cur) "\r")
-                  (do (gl-advance! 1) (gl-raw-loop))
-                  :else (do
-                    (append! chars (gl-cur))
-                    (gl-advance! 1)
-                    (gl-raw-loop)))))
-            (gl-raw-loop)
-            (join "" chars))))
-      (define
-        gl-read-rune!
-        (fn
-          ()
-          (gl-advance! 1)
-          (let
-            ((chars (list)))
-            (cond
-              (and (< pos src-len) (= (gl-cur) "\\"))
-              (do
-                (gl-advance! 1)
-                (when
-                  (< pos src-len)
-                  (let
-                    ((ch (gl-cur)))
-                    (cond
-                      (= ch "n")
-                      (append! chars "\n")
-                      (= ch "t")
-                      (append! chars "\t")
-                      (= ch "r")
-                      (append! chars "\r")
-                      (= ch "\\")
-                      (append! chars "\\")
-                      (= ch "'")
-                      (append! chars "'")
-                      (= ch "\"")
-                      (append! chars "\"")
-                      :else (append! chars ch))
-                    (gl-advance! 1))))
-              (< pos src-len)
-              (do (append! chars (gl-cur)) (gl-advance! 1)))
-            (when
-              (and (< pos src-len) (= (gl-cur) "'"))
-              (gl-advance! 1))
-            (join "" chars))))
-      (define
-        gl-match-op
-        (fn
-          ()
-          (let
-            ((c0 (gl-cur))
-              (c1 (gl-peek 1))
-              (c2 (gl-peek 2)))
-            (cond
-              (and (= c0 "<") (= c1 "<") (= c2 "="))
-              "<<="
-              (and (= c0 ">") (= c1 ">") (= c2 "="))
-              ">>="
-              (and (= c0 "&") (= c1 "^") (= c2 "="))
-              "&^="
-              (and (= c0 ".") (= c1 ".") (= c2 "."))
-              "..."
-              (and (= c0 "=") (= c1 "="))
-              "=="
-              (and (= c0 "!") (= c1 "="))
-              "!="
-              (and (= c0 "<") (= c1 "="))
-              "<="
-              (and (= c0 ">") (= c1 "="))
-              ">="
-              (and (= c0 "&") (= c1 "&"))
-              "&&"
-              (and (= c0 "|") (= c1 "|"))
-              "||"
-              (and (= c0 "+") (= c1 "+"))
-              "++"
-              (and (= c0 "-") (= c1 "-"))
-              "--"
-              (and (= c0 "<") (= c1 "<"))
-              "<<"
-              (and (= c0 ">") (= c1 ">"))
-              ">>"
-              (and (= c0 "+") (= c1 "="))
-              "+="
-              (and (= c0 "-") (= c1 "="))
-              "-="
-              (and (= c0 "*") (= c1 "="))
-              "*="
-              (and (= c0 "/") (= c1 "="))
-              "/="
-              (and (= c0 "%") (= c1 "="))
-              "%="
-              (and (= c0 "&") (= c1 "="))
-              "&="
-              (and (= c0 "|") (= c1 "="))
-              "|="
-              (and (= c0 "^") (= c1 "="))
-              "^="
-              (and (= c0 ":") (= c1 "="))
-              ":="
-              (and (= c0 "<") (= c1 "-"))
-              "<-"
-              (and (= c0 "&") (= c1 "^"))
-              "&^"
-              (or
-                (= c0 "+")
-                (= c0 "-")
-                (= c0 "*")
-                (= c0 "/")
-                (= c0 "%")
-                (= c0 "&")
-                (= c0 "|")
-                (= c0 "^")
-                (= c0 "<")
-                (= c0 ">")
-                (= c0 "=")
-                (= c0 "!")
-                (= c0 "(")
-                (= c0 ")")
-                (= c0 "{")
-                (= c0 "}")
-                (= c0 "[")
-                (= c0 "]")
-                (= c0 ",")
-                (= c0 ".")
-                (= c0 ":")
-                (= c0 "~"))
-              c0
-              :else nil))))
-      (define
-        gl-scan!
-        (fn
-          ()
-          (cond
-            (>= pos src-len)
-            nil
-            (= (gl-cur) "\n")
-            (do (gl-maybe-asi! pos) (gl-advance! 1) (gl-scan!))
-            (lex-space? (gl-cur))
-            (do (gl-advance! 1) (gl-scan!))
-            (and (= (gl-cur) "/") (= (gl-peek 1) "/"))
-            (do (gl-advance! 2) (gl-skip-line!) (gl-scan!))
-            (and (= (gl-cur) "/") (= (gl-peek 1) "*"))
-            (do
-              (gl-advance! 2)
-              (let
-                ((saw-nl (gl-skip-block! false)))
-                (when saw-nl (gl-maybe-asi! pos)))
-              (gl-scan!))
-            (= (gl-cur) ";")
-            (do
-              (gl-emit! "semi" ";" pos)
-              (gl-advance! 1)
-              (gl-scan!))
-            (lex-ident-start? (gl-cur))
-            (do
-              (let
-                ((start pos))
-                (gl-read-ident! start)
-                (let
-                  ((word (slice src start pos)))
-                  (gl-emit!
-                    (if (go-keyword? word) "keyword" "ident")
-                    word
-                    start)))
-              (gl-scan!))
-            (lex-digit? (gl-cur))
-            (do
-              (let
-                ((start pos) (typ (gl-read-number!)))
-                (gl-emit! typ (slice src start pos) start))
-              (gl-scan!))
-            (and (= (gl-cur) ".") (lex-digit? (gl-peek 1)))
-            (do
-              (let
-                ((start pos) (typ (gl-read-number!)))
-                (gl-emit! typ (slice src start pos) start))
-              (gl-scan!))
-            (= (gl-cur) "\"")
-            (let
-              ((start pos) (v (gl-read-string!)))
-              (gl-emit! "string" v start)
-              (gl-scan!))
-            (= (gl-cur) "`")
-            (let
-              ((start pos) (v (gl-read-raw-string!)))
-              (gl-emit! "string" v start)
-              (gl-scan!))
-            (= (gl-cur) "'")
-            (let
-              ((start pos) (v (gl-read-rune!)))
-              (gl-emit! "rune" v start)
-              (gl-scan!))
-            :else (let
-              ((op (gl-match-op)))
-              (cond
-                op
-                (do
-                  (gl-emit! "op" op pos)
-                  (gl-advance! (len op))
-                  (gl-scan!))
-                :else (do (gl-advance! 1) (gl-scan!)))))))
-      (gl-scan!)
-      (gl-maybe-asi! pos)
-      (gl-emit! "eof" nil pos)
-      tokens)))

lib/go/sched.sx

@@ -1,66 +0,0 @@
-;; lib/go/sched.sx — Go scheduler primitives: channels + goroutines.
-;;
-;; This is **the independent implementation** referenced by
-;; plans/lib-guest-scheduler.md. The shape that emerges here informs
-;; the eventual sister kit; this file's structures are the Phase 5
-;; "first-consumer" cut.
-;;
-;; v0 concurrency model — IMPORTANT
-;;
-;; SX has no first-class continuations exposed to guest code, so we
-;; can't suspend a goroutine mid-statement. v0 runs `go f()` SYNCHRO-
-;; NOUSLY (it's an immediate call whose return value is dropped). This
-;; preserves the right semantics for patterns where the spawned
-;; goroutine simply pushes to a channel that the main goroutine then
-;; receives — because the spawned goroutine runs to completion first
-;; and leaves the value in the channel buffer.
-;;
-;; True preemption with blocking sends/recvs is a Phase 5b refinement.
-;; The sister-plan diary tracks the design insight (single
-;; sched-spawn primitive, channel-op direction tag) so the eventual
-;; kit doesn't bake in v0's synchronous limitation.
-;;
-;; Channel representation
-;;
-;;   (list :go-chan ACCESSORS-FN-LIST)
-;;
-;; ACCESSORS-FN-LIST is a list of closures sharing a mutable buffer
-;; and a closed flag. The closures expose:
-;;   index 1: send-fn     — (lambda (val) ...)
-;;   index 2: recv-fn     — (lambda () val-or-:empty)
-;;   index 3: closed?-fn  — (lambda () bool)
-;;   index 4: close!-fn   — (lambda () ...)
-;;
-;; Channel identity: distinct calls to go-make-chan produce closures
-;; with distinct identity — `(= ch1 ch2)` is false for distinct
-;; channels, matching Go spec § Channel types.
-
-(define
-  go-make-chan
-  (fn
-    ()
-    (let
-      ((buf (list)) (closed false))
-      (list
-        :go-chan (fn (v) (append! buf v) nil)
-        (fn
-          ()
-          (cond
-            (= (len buf) 0)
-            :empty :else
-            (let ((v (first buf))) (set! buf (rest buf)) v)))
-        (fn () closed)
-        (fn () (set! closed true) nil)
-        (fn () (len buf))))))
-
-(define
-  go-chan?
-  (fn
-    (v)
-    (and (list? v) (not (= (len v) 0)) (= (first v) :go-chan))))
-
-(define go-chan-send! (fn (ch val) ((nth ch 1) val)))
-(define go-chan-recv! (fn (ch) ((nth ch 2))))
-(define go-chan-closed? (fn (ch) ((nth ch 3))))
-(define go-chan-close! (fn (ch) ((nth ch 4))))
-(define go-chan-len    (fn (ch) ((nth ch 5))))

lib/go/scoreboard.json

@@ -1,13 +0,0 @@
-{
-  "language": "go",
-  "total_pass": 609,
-  "total": 609,
-  "suites": [
-    {"name":"lex","pass":129,"total":129,"status":"ok"},
-    {"name":"parse","pass":179,"total":179,"status":"ok"},
-    {"name":"types","pass":102,"total":102,"status":"ok"},
-    {"name":"eval","pass":106,"total":106,"status":"ok"},
-    {"name":"runtime","pass":40,"total":40,"status":"ok"},
-    {"name":"stdlib","pass":41,"total":41,"status":"ok"},
-    {"name":"e2e","pass":12,"total":12,"status":"ok"}]
-}

lib/go/scoreboard.md

@@ -1,16 +0,0 @@
-# Go-on-SX Scoreboard
-
-**Total: 609 / 609 tests passing**
-
-|  | Suite | Pass | Total |
-|---|---|---|---|
-| ✅ | lex | 129 | 129 |
-| ✅ | parse | 179 | 179 |
-| ✅ | types | 102 | 102 |
-| ✅ | eval | 106 | 106 |
-| ✅ | runtime | 40 | 40 |
-| ✅ | stdlib | 41 | 41 |
-| ✅ | e2e | 12 | 12 |
-
-
-Generated by `lib/go/conformance.sh`.

lib/go/std/strconv.sx

@@ -1,71 +0,0 @@
-;; lib/go/std/strconv.sx — Go's `strconv` package, v0 subset.
-
-(define
-  go-strconv-itoa
-  ;; Itoa(n) → string. Real Go returns the decimal representation.
-  (fn (args)
-    (cond
-      (not (= (len args) 1))
-      (list :eval-error :strconv-itoa-arity (len args))
-      :else
-      (let ((n (first args)))
-        (cond
-          (not (number? n)) (list :eval-error :strconv-itoa-not-number n)
-          :else (str n))))))
-
-(define
-  go-strconv-atoi
-  ;; Atoi(s) → (int, error). v0 returns just the int on success or
-  ;; an :eval-error on failure (multi-return is a later refinement).
-  (fn (args)
-    (cond
-      (not (= (len args) 1))
-      (list :eval-error :strconv-atoi-arity (len args))
-      :else
-      (let ((s (first args)))
-        (cond
-          (not (string? s)) (list :eval-error :strconv-atoi-not-string s)
-          (= (len s) 0) (list :eval-error :strconv-atoi-empty)
-          :else (go-strconv-parse-int s 0 (= (nth s 0) "-") 0))))))
-
-(define
-  go-strconv-parse-int
-  ;; Parse a (possibly signed) base-10 integer literal. Stops on the
-  ;; first non-digit char and returns the parsed prefix, or :eval-error
-  ;; if no digits were consumed.
-  (fn (s start neg acc)
-    (let ((i (cond (= start 0) (cond neg 1 :else 0) :else start)))
-      (cond
-        (>= i (len s))
-        (cond
-          (= (cond neg (- i 1) :else i) 0)
-          (list :eval-error :strconv-atoi-no-digits s)
-          :else
-          (cond neg (- 0 acc) :else acc))
-        :else
-        (let ((d (go-strconv-digit (nth s i))))
-          (cond
-            (< d 0)
-            (cond
-              (= (cond neg (- i 1) :else i) 0)
-              (list :eval-error :strconv-atoi-no-digits s)
-              :else
-              (cond neg (- 0 acc) :else acc))
-            :else
-            (go-strconv-parse-int s (+ i 1) neg (+ (* acc 10) d))))))))
-
-(define
-  go-strconv-digit
-  (fn (c)
-    (cond
-      (= c "0") 0  (= c "1") 1  (= c "2") 2  (= c "3") 3
-      (= c "4") 4  (= c "5") 5  (= c "6") 6  (= c "7") 7
-      (= c "8") 8  (= c "9") 9
-      :else -1)))
-
-(define
-  go-std-strconv
-  (list :go-package "strconv"
-    (list
-      (list "Itoa" (list :go-builtin-fn go-strconv-itoa))
-      (list "Atoi" (list :go-builtin-fn go-strconv-atoi)))))

lib/go/std/strings.sx

@@ -1,386 +0,0 @@
-;; lib/go/std/strings.sx — Go's `strings` package, v0 subset.
-;;
-;; Exposed as `go-std-strings`, a (:go-package "strings" ENTRIES) value.
-;; Register with `(go-env-extend env "strings" go-std-strings)` to make
-;; `strings.X(...)` call sites work in evaluated Go code.
-;;
-;; Each entry is (FIELD-NAME (list :go-fn PARAMS BODY)) — the same
-;; shape user-defined Go functions get. Bodies are written in SX
-;; directly via go-builtin closures wrapping host-level string ops
-;; for speed, OR as parsed Go source for fidelity. v0 uses
-;; go-builtin wrappers — simpler and fast.
-
-;; ── helpers: implement go-std-strings entries as builtins ────────
-
-(define
-  go-strings-contains
-  (fn (args)
-    (cond
-      (not (= (len args) 2))
-      (list :eval-error :strings-contains-arity (len args))
-      :else
-      (let ((s (first args)) (sub (nth args 1)))
-        (cond
-          (not (string? s)) (list :eval-error :strings-not-string s)
-          (not (string? sub)) (list :eval-error :strings-not-string sub)
-          :else
-          (go-strings-index-of s sub 0))))))
-
-(define
-  go-strings-index-of
-  ;; Returns true if SUB appears in S at or after START, else false.
-  (fn (s sub start)
-    (let ((slen (len s)) (sublen (len sub)))
-      (cond
-        (= sublen 0) true
-        (> (+ start sublen) slen) false
-        (go-strings-match-at s sub start 0) true
-        :else (go-strings-index-of s sub (+ start 1))))))
-
-(define
-  go-strings-match-at
-  (fn (s sub start k)
-    (cond
-      (>= k (len sub)) true
-      (= (nth s (+ start k)) (nth sub k))
-      (go-strings-match-at s sub start (+ k 1))
-      :else false)))
-
-(define
-  go-strings-has-prefix
-  (fn (args)
-    (cond
-      (not (= (len args) 2))
-      (list :eval-error :strings-hasprefix-arity (len args))
-      :else
-      (let ((s (first args)) (p (nth args 1)))
-        (cond
-          (not (string? s)) (list :eval-error :strings-not-string s)
-          (not (string? p)) (list :eval-error :strings-not-string p)
-          (> (len p) (len s)) false
-          :else (go-strings-match-at s p 0 0))))))
-
-(define
-  go-strings-has-suffix
-  (fn (args)
-    (cond
-      (not (= (len args) 2))
-      (list :eval-error :strings-hassuffix-arity (len args))
-      :else
-      (let ((s (first args)) (suf (nth args 1)))
-        (cond
-          (not (string? s)) (list :eval-error :strings-not-string s)
-          (not (string? suf)) (list :eval-error :strings-not-string suf)
-          (> (len suf) (len s)) false
-          :else
-          (go-strings-match-at s suf (- (len s) (len suf)) 0))))))
-
-(define
-  go-strings-index
-  (fn (args)
-    (cond
-      (not (= (len args) 2))
-      (list :eval-error :strings-index-arity (len args))
-      :else
-      (let ((s (first args)) (sub (nth args 1)))
-        (cond
-          (not (string? s)) (list :eval-error :strings-not-string s)
-          (not (string? sub)) (list :eval-error :strings-not-string sub)
-          :else (go-strings-index-loop s sub 0))))))
-
-(define
-  go-strings-index-loop
-  (fn (s sub start)
-    (let ((slen (len s)) (sublen (len sub)))
-      (cond
-        (= sublen 0) 0
-        (> (+ start sublen) slen) -1
-        (go-strings-match-at s sub start 0) start
-        :else (go-strings-index-loop s sub (+ start 1))))))
-
-(define
-  go-strings-repeat
-  (fn (args)
-    (cond
-      (not (= (len args) 2))
-      (list :eval-error :strings-repeat-arity (len args))
-      :else
-      (let ((s (first args)) (n (nth args 1)))
-        (cond
-          (not (string? s)) (list :eval-error :strings-not-string s)
-          (< n 0) (list :eval-error :strings-repeat-negative n)
-          :else (go-strings-repeat-loop s n ""))))))
-
-(define
-  go-strings-repeat-loop
-  (fn (s n acc)
-    (cond
-      (<= n 0) acc
-      :else (go-strings-repeat-loop s (- n 1) (str acc s)))))
-
-(define
-  go-strings-count
-  (fn (args)
-    (cond
-      (not (= (len args) 2))
-      (list :eval-error :strings-count-arity (len args))
-      :else
-      (let ((s (first args)) (sub (nth args 1)))
-        (cond
-          (not (string? s)) (list :eval-error :strings-not-string s)
-          (not (string? sub)) (list :eval-error :strings-not-string sub)
-          :else (go-strings-count-loop s sub 0 0))))))
-
-(define
-  go-strings-count-loop
-  (fn (s sub start acc)
-    (let ((idx (go-strings-index-loop s sub start)))
-      (cond
-        (< idx 0) acc
-        :else
-        (go-strings-count-loop s sub (+ idx (max 1 (len sub))) (+ acc 1))))))
-
-(define
-  go-strings-join
-  (fn (args)
-    (cond
-      (not (= (len args) 2))
-      (list :eval-error :strings-join-arity (len args))
-      :else
-      (let ((sep (nth args 1)) (xs (first args)))
-        (cond
-          (not (string? sep)) (list :eval-error :strings-not-string sep)
-          (not (and (list? xs) (= (first xs) :go-slice)))
-          (list :eval-error :strings-join-not-slice xs)
-          :else (go-strings-join-loop (nth xs 1) sep ""))))))
-
-(define
-  go-strings-join-loop
-  (fn (xs sep acc)
-    (cond
-      (= (len xs) 0) acc
-      (= (len acc) 0) (go-strings-join-loop (rest xs) sep (first xs))
-      :else
-      (go-strings-join-loop (rest xs) sep (str acc sep (first xs))))))
-
-;; ── case conversion ──────────────────────────────────────────────
-
-(define
-  go-strings-char-to-upper
-  (fn (c)
-    (cond
-      (and (>= c "a") (<= c "z"))
-      ;; ASCII uppercase shift: 'a' is 0x61, 'A' is 0x41 → diff 0x20.
-      ;; SX has no charcode primitive, so use a char-pair table.
-      (go-strings-letter-toggle c true)
-      :else c)))
-
-(define
-  go-strings-char-to-lower
-  (fn (c)
-    (cond
-      (and (>= c "A") (<= c "Z"))
-      (go-strings-letter-toggle c false)
-      :else c)))
-
-(define
-  go-strings-letter-toggle
-  ;; Toggle a single ASCII letter's case via direct mapping.
-  ;; `to-upper?` true means input is lowercase, output uppercase.
-  (fn (c to-upper?)
-    (cond
-      to-upper?
-      (cond
-        (= c "a") "A" (= c "b") "B" (= c "c") "C" (= c "d") "D"
-        (= c "e") "E" (= c "f") "F" (= c "g") "G" (= c "h") "H"
-        (= c "i") "I" (= c "j") "J" (= c "k") "K" (= c "l") "L"
-        (= c "m") "M" (= c "n") "N" (= c "o") "O" (= c "p") "P"
-        (= c "q") "Q" (= c "r") "R" (= c "s") "S" (= c "t") "T"
-        (= c "u") "U" (= c "v") "V" (= c "w") "W" (= c "x") "X"
-        (= c "y") "Y" (= c "z") "Z" :else c)
-      :else
-      (cond
-        (= c "A") "a" (= c "B") "b" (= c "C") "c" (= c "D") "d"
-        (= c "E") "e" (= c "F") "f" (= c "G") "g" (= c "H") "h"
-        (= c "I") "i" (= c "J") "j" (= c "K") "k" (= c "L") "l"
-        (= c "M") "m" (= c "N") "n" (= c "O") "o" (= c "P") "p"
-        (= c "Q") "q" (= c "R") "r" (= c "S") "s" (= c "T") "t"
-        (= c "U") "u" (= c "V") "v" (= c "W") "w" (= c "X") "x"
-        (= c "Y") "y" (= c "Z") "z" :else c))))
-
-(define
-  go-strings-map-chars
-  (fn (s i acc char-fn)
-    (cond
-      (>= i (len s)) acc
-      :else
-      (go-strings-map-chars s (+ i 1) (str acc (char-fn (nth s i))) char-fn))))
-
-(define
-  go-strings-to-upper
-  (fn (args)
-    (cond
-      (not (= (len args) 1))
-      (list :eval-error :strings-toupper-arity (len args))
-      :else
-      (let ((s (first args)))
-        (cond
-          (not (string? s)) (list :eval-error :strings-not-string s)
-          :else (go-strings-map-chars s 0 "" go-strings-char-to-upper))))))
-
-(define
-  go-strings-to-lower
-  (fn (args)
-    (cond
-      (not (= (len args) 1))
-      (list :eval-error :strings-tolower-arity (len args))
-      :else
-      (let ((s (first args)))
-        (cond
-          (not (string? s)) (list :eval-error :strings-not-string s)
-          :else (go-strings-map-chars s 0 "" go-strings-char-to-lower))))))
-
-;; ── TrimSpace ────────────────────────────────────────────────────
-
-(define
-  go-strings-is-space?
-  (fn (c)
-    (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
-
-(define
-  go-strings-trim-left
-  (fn (s i)
-    (cond
-      (>= i (len s)) i
-      (go-strings-is-space? (nth s i)) (go-strings-trim-left s (+ i 1))
-      :else i)))
-
-(define
-  go-strings-trim-right
-  (fn (s end)
-    (cond
-      (<= end 0) 0
-      (go-strings-is-space? (nth s (- end 1))) (go-strings-trim-right s (- end 1))
-      :else end)))
-
-(define
-  go-strings-substr
-  ;; Substring [lo, hi) — naive but predictable.
-  (fn (s lo hi)
-    (cond
-      (>= lo hi) ""
-      :else
-      (go-strings-substr-loop s lo hi ""))))
-
-(define
-  go-strings-substr-loop
-  (fn (s i hi acc)
-    (cond
-      (>= i hi) acc
-      :else (go-strings-substr-loop s (+ i 1) hi (str acc (nth s i))))))
-
-(define
-  go-strings-trim-space
-  (fn (args)
-    (cond
-      (not (= (len args) 1))
-      (list :eval-error :strings-trimspace-arity (len args))
-      :else
-      (let ((s (first args)))
-        (cond
-          (not (string? s)) (list :eval-error :strings-not-string s)
-          :else
-          (let ((lo (go-strings-trim-left s 0)))
-            (let ((hi (go-strings-trim-right s (len s))))
-              (go-strings-substr s lo hi))))))))
-
-;; ── Split ────────────────────────────────────────────────────────
-
-(define
-  go-strings-split
-  (fn (args)
-    (cond
-      (not (= (len args) 2))
-      (list :eval-error :strings-split-arity (len args))
-      :else
-      (let ((s (first args)) (sep (nth args 1)))
-        (cond
-          (not (string? s)) (list :eval-error :strings-not-string s)
-          (not (string? sep)) (list :eval-error :strings-not-string sep)
-          (= (len sep) 0)
-          ;; Empty separator: real Go splits to all chars; v0 keeps
-          ;; behaviour simple — single-element slice.
-          (list :go-slice (list s))
-          :else
-          (list :go-slice (go-strings-split-loop s sep 0 (list))))))))
-
-(define
-  go-strings-split-loop
-  (fn (s sep start acc)
-    (let ((idx (go-strings-index-loop s sep start)))
-      (cond
-        (< idx 0)
-        (go-strings-split-finalize acc (go-strings-substr s start (len s)))
-        :else
-        (go-strings-split-loop s sep (+ idx (len sep))
-          (go-strings-split-finalize acc
-            (go-strings-substr s start idx)))))))
-
-(define
-  go-strings-split-finalize
-  ;; Append a piece to acc, growing the list in order.
-  (fn (acc piece)
-    (cond
-      (= (len acc) 0) (list piece)
-      :else (go-name-concat acc (list piece)))))
-
-;; ── Replace ──────────────────────────────────────────────────────
-
-(define
-  go-strings-replace
-  ;; Replace(s, old, new, n). n < 0 = all.
-  (fn (args)
-    (cond
-      (not (= (len args) 4))
-      (list :eval-error :strings-replace-arity (len args))
-      :else
-      (let ((s (first args)) (old (nth args 1))
-            (newv (nth args 2)) (n (nth args 3)))
-        (cond
-          (not (string? s)) (list :eval-error :strings-not-string s)
-          (not (string? old)) (list :eval-error :strings-not-string old)
-          (not (string? newv)) (list :eval-error :strings-not-string newv)
-          (= (len old) 0) s
-          :else (go-strings-replace-loop s old newv n 0 ""))))))
-
-(define
-  go-strings-replace-loop
-  (fn (s old newv n start acc)
-    (let ((idx (go-strings-index-loop s old start)))
-      (cond
-        (or (< idx 0) (= n 0))
-        (str acc (go-strings-substr s start (len s)))
-        :else
-        (go-strings-replace-loop s old newv
-          (cond (< n 0) -1 :else (- n 1))
-          (+ idx (len old))
-          (str acc (go-strings-substr s start idx) newv))))))
-
-;; ── go-std-strings package value ─────────────────────────────────
-
-(define
-  go-std-strings
-  (list :go-package "strings"
-    (list
-      (list "Contains"  (list :go-builtin-fn go-strings-contains))
-      (list "HasPrefix" (list :go-builtin-fn go-strings-has-prefix))
-      (list "HasSuffix" (list :go-builtin-fn go-strings-has-suffix))
-      (list "Index"     (list :go-builtin-fn go-strings-index))
-      (list "Count"     (list :go-builtin-fn go-strings-count))
-      (list "Repeat"    (list :go-builtin-fn go-strings-repeat))
-      (list "Join"      (list :go-builtin-fn go-strings-join))
-      (list "ToUpper"   (list :go-builtin-fn go-strings-to-upper))
-      (list "ToLower"   (list :go-builtin-fn go-strings-to-lower))
-      (list "TrimSpace" (list :go-builtin-fn go-strings-trim-space))
-      (list "Split"     (list :go-builtin-fn go-strings-split))
-      (list "Replace"   (list :go-builtin-fn go-strings-replace)))))

lib/go/tests/e2e.sx

@@ -1,186 +0,0 @@
-;; Go end-to-end tests — complete programs exercising lex+parse+
-;; types+eval+sched+stdlib together. Each test runs a multi-line Go
-;; program and inspects the final env.
-
-(define go-e2e-test-count 0)
-(define go-e2e-test-pass 0)
-(define go-e2e-test-fails (list))
-
-(define
-  go-e2e-test
-  (fn (name actual expected)
-    (set! go-e2e-test-count (+ go-e2e-test-count 1))
-    (if (= actual expected)
-      (set! go-e2e-test-pass (+ go-e2e-test-pass 1))
-      (append! go-e2e-test-fails
-        {:name name :expected expected :actual actual}))))
-
-(define
-  go-e2e-env
-  (go-env-extend
-    (go-env-extend go-env-builtins "strings" go-std-strings)
-    "strconv" go-std-strconv))
-
-(define
-  go-e2e-run
-  (fn (src-list)
-    (go-eval-program go-e2e-env (map go-parse src-list))))
-
-;; ── 1. Sieve via boolean slice (no modulo needed) ────────────────
-(go-e2e-test "e2e: sieve-of-Eratosthenes via boolean slice — count primes ≤ 30"
-  (let ((env (go-e2e-run
-              (list
-                ;; sieve[i] true means i is COMPOSITE (saves the
-                ;; default-bool initialisation for primes).
-                "sieve := []bool{false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false}"
-                "for p := 2; p < 31; p = p + 1 { if sieve[p] == false { for k := p + p; k < 31; k = k + p { sieve[k] = true } } }"
-                "count := 0"
-                "for i := 2; i < 31; i = i + 1 { if sieve[i] == false { count = count + 1 } }"))))
-    (go-env-lookup env "count"))
-  ;; primes ≤ 30: 2,3,5,7,11,13,17,19,23,29 = 10
-  10)
-
-;; ── 1b. Range-membership check (works without mod) ───────────────
-(go-e2e-test "e2e: linear search across slice of strings"
-  (let ((env (go-e2e-run
-              (list
-                "words := []string{\"apple\", \"banana\", \"cherry\", \"date\"}"
-                "func indexOf(xs []string, target string) int { for i, v := range xs { if v == target { return i } } ; return -1 }"
-                "i := indexOf(words, \"cherry\")"
-                "missing := indexOf(words, \"xyz\")"))))
-    (list (go-env-lookup env "i") (go-env-lookup env "missing")))
-  (list 2 -1))
-
-;; ── 2. Reverse a slice ───────────────────────────────────────────
-(go-e2e-test "e2e: reverse a slice of ints"
-  (let ((env (go-e2e-run
-              (list
-                "func reverse(xs []int) []int { r := []int{} ; for i := len(xs) - 1; i >= 0; i = i - 1 { r = append(r, xs[i]) } ; return r }"
-                "out := reverse([]int{1, 2, 3, 4, 5})"))))
-    (go-env-lookup env "out"))
-  (list :go-slice (list 5 4 3 2 1)))
-
-;; ── 3. Fibonacci (recursive) ─────────────────────────────────────
-(go-e2e-test "e2e: fib(10) = 55"
-  (let ((env (go-e2e-run
-              (list
-                "func fib(n int) int { if n < 2 { return n } ; return fib(n-1) + fib(n-2) }"
-                "r := fib(10)"))))
-    (go-env-lookup env "r"))
-  55)
-
-;; ── 4. Sum-of-squares via Map+Reduce ─────────────────────────────
-(go-e2e-test "e2e: sum-of-squares 1..5 via Map+Reduce"
-  (let ((env (go-e2e-run
-              (list
-                "func Map[T any, U any](xs []T, f func(T) U) []U { r := []int{} ; for i, v := range xs { r = append(r, f(v)) } ; return r }"
-                "func Reduce[T any, U any](xs []T, seed U, f func(U, T) U) U { acc := seed ; for i, v := range xs { acc = f(acc, v) } ; return acc }"
-                "func sq(x int) int { return x * x }"
-                "func add(a int, b int) int { return a + b }"
-                "squares := Map([]int{1, 2, 3, 4, 5}, sq)"
-                "total := Reduce(squares, 0, add)"))))
-    (go-env-lookup env "total"))
-  ;; 1 + 4 + 9 + 16 + 25 = 55
-  55)
-
-;; ── 5. Word frequency counter ────────────────────────────────────
-(go-e2e-test "e2e: word-frequency over a sentence"
-  (let ((env (go-e2e-run
-              (list
-                "text := \"the quick brown fox jumps over the lazy dog the\""
-                "words := strings.Split(text, \" \")"
-                "counts := map[string]int{}"
-                "for i, w := range words { counts[w] = counts[w] + 1 }"
-                "the_count := counts[\"the\"]"
-                "fox_count := counts[\"fox\"]"
-                "dog_count := counts[\"dog\"]"))))
-    (list (go-env-lookup env "the_count")
-          (go-env-lookup env "fox_count")
-          (go-env-lookup env "dog_count")))
-  (list 3 1 1))
-
-;; ── 6. Pipeline via channels ─────────────────────────────────────
-(go-e2e-test "e2e: pipeline — generate, square, sum"
-  (let ((env (go-e2e-run
-              (list
-                "func gen(c chan int, n int) { for i := 1; i <= n; i = i + 1 { c <- i } ; close(c) }"
-                "func sq(in chan int, out chan int) { for v := range in { out <- v * v } ; close(out) }"
-                "src := make()"
-                "sqs := make()"
-                "go gen(src, 4)"
-                "go sq(src, sqs)"
-                "total := 0"
-                "for v := range sqs { total = total + v }"))))
-    (go-env-lookup env "total"))
-  ;; 1+4+9+16 = 30
-  30)
-
-;; ── 7. Worker pool draining a job channel ────────────────────────
-(go-e2e-test "e2e: worker pool — sum of doubled jobs"
-  (let ((env (go-e2e-run
-              (list
-                "func worker(jobs chan int, results chan int) { for j := range jobs { results <- j * 2 } }"
-                "jobs := make()"
-                "results := make()"
-                "jobs <- 10 ; jobs <- 20 ; jobs <- 30"
-                "close(jobs)"
-                "go worker(jobs, results)"
-                "close(results)"
-                "sum := 0"
-                "for r := range results { sum = sum + r }"))))
-    (go-env-lookup env "sum"))
-  ;; 20 + 40 + 60 = 120
-  120)
-
-;; ── 8. Bubble sort ───────────────────────────────────────────────
-(go-e2e-test "e2e: bubble sort ascending"
-  (let ((env (go-e2e-run
-              (list
-                "func bubble(xs []int) []int { n := len(xs) ; for i := 0; i < n; i = i + 1 { for j := 0; j < n - 1; j = j + 1 { if xs[j] > xs[j+1] { tmp := xs[j] ; xs[j] = xs[j+1] ; xs[j+1] = tmp } } } ; return xs }"
-                "out := bubble([]int{3, 1, 4, 1, 5, 9, 2, 6})"))))
-    (go-env-lookup env "out"))
-  (list :go-slice (list 1 1 2 3 4 5 6 9)))
-
-;; ── 9. String reverse using strings.Split + reverse + Join ──────
-(go-e2e-test "e2e: reverse words in a sentence"
-  (let ((env (go-e2e-run
-              (list
-                "func rev(xs []string) []string { r := []string{} ; for i := len(xs) - 1; i >= 0; i = i - 1 { r = append(r, xs[i]) } ; return r }"
-                "text := \"go on sx\""
-                "out := strings.Join(rev(strings.Split(text, \" \")), \"-\")"))))
-    (go-env-lookup env "out"))
-  "sx-on-go")
-
-;; ── 10. Counting occurrences via Filter ──────────────────────────
-(go-e2e-test "e2e: count even numbers via Filter+len"
-  (let ((env (go-e2e-run
-              (list
-                "func Filter[T any](xs []T, p func(T) bool) []T { r := []int{} ; for i, v := range xs { if p(v) { r = append(r, v) } } ; return r }"
-                "func gt5(x int) bool { return x > 5 }"
-                "n := len(Filter([]int{1, 2, 6, 3, 7, 8, 4, 9}, gt5))"))))
-    (go-env-lookup env "n"))
-  ;; gt5: 6,7,8,9 = 4
-  4)
-
-;; ── 11. Recursive ackermann (small inputs) ───────────────────────
-(go-e2e-test "e2e: ackermann(2, 3) = 9"
-  (let ((env (go-e2e-run
-              (list
-                "func ack(m int, n int) int { if m == 0 { return n + 1 } ; if n == 0 { return ack(m - 1, 1) } ; return ack(m - 1, ack(m, n - 1)) }"
-                "r := ack(2, 3)"))))
-    (go-env-lookup env "r"))
-  9)
-
-;; ── 12. Defer + recover smoke test ───────────────────────────────
-(go-e2e-test "e2e: defer + recover in real-fn flow"
-  (let ((env (go-e2e-run
-              (list
-                "func safeDivide(a int, b int) int { defer recover() ; if b == 0 { panic(\"div by zero\") } ; return a / b }"
-                "r := safeDivide(10, 0)"
-                "after := 99"))))
-    (go-env-lookup env "after"))
-  99)
-
-(define
-  go-e2e-test-summary
-  (str "e2e " go-e2e-test-pass "/" go-e2e-test-count))

lib/go/tests/eval.sx

@@ -1,667 +0,0 @@
-;; Go evaluator tests.
-
-(define go-eval-test-count 0)
-(define go-eval-test-pass 0)
-(define go-eval-test-fails (list))
-
-(define
-  go-eval-test
-  (fn
-    (name actual expected)
-    (set! go-eval-test-count (+ go-eval-test-count 1))
-    (if
-      (= actual expected)
-      (set! go-eval-test-pass (+ go-eval-test-pass 1))
-      (append! go-eval-test-fails {:name name :expected expected :actual actual}))))
-
-(define gtev (fn (env src) (go-eval env (go-parse src))))
-
-;; ── env ──────────────────────────────────────────────────────────
-(go-eval-test
-  "env: empty lookup returns nil"
-  (go-env-lookup go-env-empty "x")
-  nil)
-
-(go-eval-test
-  "env: extend then lookup"
-  (go-env-lookup (go-env-extend go-env-empty "x" 42) "x")
-  42)
-
-;; ── literals ────────────────────────────────────────────────────
-(go-eval-test "lit: 42 → 42" (gtev go-env-empty "42") 42)
-
-(go-eval-test "lit: 0 → 0" (gtev go-env-empty "0") 0)
-
-(go-eval-test "lit: 0xFF → 255" (gtev go-env-empty "0xFF") 255)
-
-(go-eval-test "lit: 0b1010 → 10" (gtev go-env-empty "0b1010") 10)
-
-(go-eval-test "lit: 0o17 → 15" (gtev go-env-empty "0o17") 15)
-
-(go-eval-test
-  "lit: underscore separator 1_000 → 1000"
-  (gtev go-env-empty "1_000")
-  1000)
-
-(go-eval-test "lit: string" (gtev go-env-empty "\"hello\"") "hello")
-
-;; ── predeclared ─────────────────────────────────────────────────
-(go-eval-test "var: true" (gtev go-env-empty "true") true)
-(go-eval-test "var: false" (gtev go-env-empty "false") false)
-(go-eval-test "var: nil" (gtev go-env-empty "nil") nil)
-
-;; ── variable lookup ─────────────────────────────────────────────
-(go-eval-test
-  "var: bound x → 5"
-  (go-eval (go-env-extend go-env-empty "x" 5) (go-parse "x"))
-  5)
-
-(go-eval-test
-  "var: unbound y → :eval-error"
-  (gtev go-env-empty "y")
-  (list :eval-error :unbound "y"))
-
-;; ── binary ops ─────────────────────────────────────────────────
-(go-eval-test "binop: 1 + 2 → 3" (gtev go-env-empty "1 + 2") 3)
-(go-eval-test "binop: 10 - 4 → 6" (gtev go-env-empty "10 - 4") 6)
-(go-eval-test "binop: 3 * 7 → 21" (gtev go-env-empty "3 * 7") 21)
-(go-eval-test "binop: 42 / 7 → 6" (gtev go-env-empty "42 / 7") 6)
-(go-eval-test
-  "binop: 2 + 3 * 4 → 14 (prec)"
-  (gtev go-env-empty "2 + 3 * 4")
-  14)
-(go-eval-test
-  "binop: a + b uses env"
-  (go-eval
-    (go-env-extend (go-env-extend go-env-empty "a" 3) "b" 4)
-    (go-parse "a + b"))
-  7)
-
-(go-eval-test "binop: 1 < 2 → true" (gtev go-env-empty "1 < 2") true)
-(go-eval-test "binop: 5 == 5 → true" (gtev go-env-empty "5 == 5") true)
-(go-eval-test "binop: 5 != 5 → false" (gtev go-env-empty "5 != 5") false)
-(go-eval-test
-  "binop: true && false → false"
-  (gtev go-env-empty "true && false")
-  false)
-(go-eval-test
-  "binop: false || true → true"
-  (gtev go-env-empty "false || true")
-  true)
-
-;; ── report ──────────────────────────────────────────────────────
-(go-eval-test
-  "var-decl: var x = 5 — env has x=5"
-  (go-env-lookup
-    (go-eval-program go-env-empty (list (go-parse "var x = 5")))
-    "x")
-  5)
-
-(go-eval-test
-  "short-decl: a, b := 3, 4 — env has both"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "a, b := 3, 4")))))
-    (list (go-env-lookup env "a") (go-env-lookup env "b")))
-  (list 3 4))
-
-(go-eval-test
-  "assign: x = 5 then x → 5"
-  (let
-    ((env (go-eval-program (go-env-extend go-env-empty "x" 1) (list (go-parse "x = 5")))))
-    (go-env-lookup env "x"))
-  5)
-
-(go-eval-test
-  "if: true branch evaluates"
-  (let
-    ((env (go-eval-program (go-env-extend go-env-empty "x" 0) (list (go-parse "if true { x = 1 }")))))
-    (go-env-lookup env "x"))
-  1)
-
-(go-eval-test
-  "if-else: false → else branch"
-  (let
-    ((env (go-eval-program (go-env-extend go-env-empty "x" 0) (list (go-parse "if false { x = 1 } else { x = 2 }")))))
-    (go-env-lookup env "x"))
-  2)
-
-(go-eval-test
-  "fn: define + call — double(7) = 14"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "func double(x int) int { return x * 2 }")))))
-    (go-eval env (go-parse "double(7)")))
-  14)
-
-(go-eval-test
-  "fn: add(2, 3) = 5"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "func add(x, y int) int { return x + y }")))))
-    (go-eval env (go-parse "add(2, 3)")))
-  5)
-
-(go-eval-test
-  "fn: recursive fib(5) = 5"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "func fib(n int) int { if n < 2 { return n } return fib(n-1) + fib(n-2) }")))))
-    (go-eval env (go-parse "fib(5)")))
-  5)
-
-(go-eval-test
-  "for: count to 10 with sum"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "var sum = 0") (go-parse "for i := 0; i < 10; i++ { sum = sum + i }")))))
-    (go-env-lookup env "sum"))
-  45)
-
-(go-eval-test
-  "inc-dec: x++ updates env"
-  (let
-    ((env (go-eval-program (go-env-extend go-env-empty "x" 5) (list (go-parse "x++")))))
-    (go-env-lookup env "x"))
-  6)
-
-(go-eval-test
-  "inc-dec: x-- updates env"
-  (let
-    ((env (go-eval-program (go-env-extend go-env-empty "x" 5) (list (go-parse "x--")))))
-    (go-env-lookup env "x"))
-  4)
-
-(go-eval-test
-  "for: break exits the loop"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "var i = 0") (go-parse "for i < 100 { if i == 5 { break } ; i++ }")))))
-    (go-env-lookup env "i"))
-  5)
-
-(go-eval-test
-  "for: continue skips body but runs post"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "var sum = 0") (go-parse "for i := 0; i < 5; i++ { if i == 2 { continue } ; sum = sum + i }")))))
-    (go-env-lookup env "sum"))
-  8)
-
-(go-eval-test
-  "for: infinite + break with sum"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "var s = 0") (go-parse "var i = 1") (go-parse "for { if i > 4 { break } ; s = s + i ; i++ }")))))
-    (go-env-lookup env "s"))
-  10)
-
-(go-eval-test
-  "fn: iterative factorial via for-loop"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "func fact(n int) int { r := 1 ; for i := 2 ; i <= n ; i++ { r = r * i } ; return r }")))))
-    (go-eval env (go-parse "fact(5)")))
-  120)
-
-(go-eval-test
-  "slice: []int{1,2,3} → :go-slice"
-  (gtev go-env-empty "[]int{1, 2, 3}")
-  (list :go-slice (list 1 2 3)))
-
-(go-eval-test
-  "index: a[0] = 10, a[2] = 30"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{10, 20, 30}")))))
-    (list (go-eval env (go-parse "a[0]")) (go-eval env (go-parse "a[2]"))))
-  (list 10 30))
-
-(go-eval-test
-  "index: out-of-range error"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{1, 2}")))))
-    (go-eval env (go-parse "a[5]")))
-  (list :eval-error :index-out-of-range 5 2))
-
-(go-eval-test
-  "builtin: len(slice) = 3"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "a := []int{1, 2, 3}")))))
-    (go-eval env (go-parse "len(a)")))
-  3)
-
-(go-eval-test
-  "builtin: len(string)"
-  (go-eval go-env-builtins (go-parse "len(\"hello\")"))
-  5)
-
-(go-eval-test
-  "builtin: append(a, 4, 5)"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "a := []int{1, 2, 3}")))))
-    (go-eval env (go-parse "append(a, 4, 5)")))
-  (list
-    :go-slice (list 1 2 3 4 5)))
-
-(go-eval-test
-  "slice expr: a[1:3]"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{10, 20, 30, 40}")))))
-    (go-eval env (go-parse "a[1:3]")))
-  (list :go-slice (list 20 30)))
-
-(go-eval-test
-  "slice expr: a[:2] (omitted low)"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{1, 2, 3, 4}")))))
-    (go-eval env (go-parse "a[:2]")))
-  (list :go-slice (list 1 2)))
-
-(go-eval-test
-  "slice expr: a[2:] (omitted high)"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{1, 2, 3, 4}")))))
-    (go-eval env (go-parse "a[2:]")))
-  (list :go-slice (list 3 4)))
-
-(go-eval-test
-  "fn: sum slice via for-loop with len + index"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "a := []int{1, 2, 3, 4, 5}") (go-parse "sum := 0") (go-parse "for i := 0; i < len(a); i++ { sum = sum + a[i] }")))))
-    (go-env-lookup env "sum"))
-  15)
-
-(go-eval-test
-  "map: map[string]int{...} → :go-map"
-  (gtev go-env-empty "map[string]int{\"a\": 1, \"b\": 2}")
-  (list :go-map (list (list "a" 1) (list "b" 2))))
-
-(go-eval-test
-  "map: m[\"a\"] → 1"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "m := map[string]int{\"a\": 1, \"b\": 2}")))))
-    (go-eval env (go-parse "m[\"a\"]")))
-  1)
-
-(go-eval-test
-  "map: missing key → nil (v0 stand-in for zero value)"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "m := map[string]int{\"a\": 1}")))))
-    (go-eval env (go-parse "m[\"missing\"]")))
-  nil)
-
-(go-eval-test
-  "map: len(m) = 2"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "m := map[string]int{\"a\": 1, \"b\": 2}")))))
-    (go-eval env (go-parse "len(m)")))
-  2)
-
-(go-eval-test
-  "map: index-assign updates existing key"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "m := map[string]int{\"a\": 1}") (go-parse "m[\"a\"] = 99")))))
-    (go-eval env (go-parse "m[\"a\"]")))
-  99)
-
-(go-eval-test
-  "map: index-assign adds new key"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "m := map[string]int{}") (go-parse "m[\"new\"] = 7")))))
-    (go-eval env (go-parse "m[\"new\"]")))
-  7)
-
-(go-eval-test
-  "slice: index-assign a[0] = 99"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "a := []int{10, 20, 30}") (go-parse "a[0] = 99")))))
-    (go-eval env (go-parse "a[0]")))
-  99)
-
-(go-eval-test
-  "map: word count via loop"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "words := []string{\"a\", \"b\", \"a\", \"c\", \"a\"}") (go-parse "counts := map[string]int{}") (go-parse "for i := 0; i < len(words); i++ { counts[words[i]] = counts[words[i]] + 1 }")))))
-    (go-eval env (go-parse "counts[\"a\"]")))
-  3)
-
-(go-eval-test
-  "type-decl: registers struct field names"
-  (go-env-lookup
-    (go-eval-program
-      go-env-empty
-      (list (go-parse "type Point struct { x, y int }")))
-    "Point")
-  (list :go-struct-type (list "x" "y")))
-
-(go-eval-test
-  "struct: positional composite Point{1, 2}"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }")))))
-    (go-eval env (go-parse "Point{1, 2}")))
-  (list
-    :go-struct "Point"
-    (list (list "x" 1) (list "y" 2))))
-
-(go-eval-test
-  "struct: keyed composite Point{x: 5, y: 10}"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }")))))
-    (go-eval env (go-parse "Point{x: 5, y: 10}")))
-  (list
-    :go-struct "Point"
-    (list (list "x" 5) (list "y" 10))))
-
-(go-eval-test
-  "struct: selector p.x = 1"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "p := Point{1, 2}")))))
-    (go-eval env (go-parse "p.x")))
-  1)
-
-(go-eval-test
-  "struct: selector p.y = 2"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "p := Point{1, 2}")))))
-    (go-eval env (go-parse "p.y")))
-  2)
-
-(go-eval-test
-  "struct: selector-assign p.x = 99"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "p := Point{1, 2}") (go-parse "p.x = 99")))))
-    (go-eval env (go-parse "p.x")))
-  99)
-
-(go-eval-test
-  "struct: positional arity-mismatch"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }")))))
-    (go-eval env (go-parse "Point{1}")))
-  (list :eval-error :struct-arity-mismatch "Point" 2 1))
-
-(go-eval-test
-  "struct: function takes/returns struct"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "func add(a, b Point) Point { return Point{a.x + b.x, a.y + b.y} }")))))
-    (go-eval env (go-parse "add(Point{1, 2}, Point{3, 4})")))
-  (list
-    :go-struct "Point"
-    (list (list "x" 4) (list "y" 6))))
-
-(go-eval-test
-  "method: p.Sum() = 3"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "func (p Point) Sum() int { return p.x + p.y }") (go-parse "p := Point{1, 2}")))))
-    (go-eval env (go-parse "p.Sum()")))
-  3)
-
-(go-eval-test
-  "method: p.Add(5) = 6 (with arg)"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "func (p Point) Add(d int) int { return p.x + d }") (go-parse "p := Point{1, 2}")))))
-    (go-eval env (go-parse "p.Add(5)")))
-  6)
-
-(go-eval-test
-  "method: pointer receiver works value-style in v0"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "func (p *Point) GetX() int { return p.x }") (go-parse "p := Point{1, 2}")))))
-    (go-eval env (go-parse "p.GetX()")))
-  1)
-
-(go-eval-test
-  "method: missing method → :no-such-method"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Point struct { x, y int }") (go-parse "p := Point{1, 2}")))))
-    (go-eval env (go-parse "p.Ghost()")))
-  (list :eval-error :no-such-method "Point" "Ghost"))
-
-(go-eval-test
-  "unary: -x"
-  (go-eval (go-env-extend go-env-empty "x" 5) (go-parse "-x"))
-  -5)
-
-(go-eval-test "unary: !true → false" (gtev go-env-empty "!true") false)
-
-(go-eval-test "unary: !false → true" (gtev go-env-empty "!false") true)
-
-(go-eval-test
-  "unary: -3 + 5 = 2 (unary binds tighter)"
-  (gtev go-env-empty "-3 + 5")
-  2)
-
-(go-eval-test
-  "e2e: count odd numbers in 1..10 = 5"
-  (let
-    ((env (go-eval-program go-env-empty
-            (list (go-parse "odds := 0")
-                  (go-parse "i := 1")
-                  (go-parse "for i <= 10 { odds = odds + 1; i = i + 2 }")))))
-    (go-env-lookup env "odds"))
-  5)
-
-(go-eval-test
-  "e2e: factorial via method on Counter"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Acc struct { v int }") (go-parse "func (a Acc) Mul(x int) Acc { return Acc{a.v * x} }") (go-parse "a := Acc{1}") (go-parse "for i := 1; i <= 5; i++ { a = a.Mul(i) }")))))
-    (go-eval env (go-parse "a.v")))
-  120)
-
-(go-eval-test
-  "e2e: recursive fibonacci fib(10) = 55"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "func fib(n int) int { if n < 2 { return n } return fib(n-1) + fib(n-2) }")))))
-    (go-eval env (go-parse "fib(10)")))
-  55)
-
-(go-eval-test
-  "e2e: struct + method + iterative loop"
-  (let
-    ((env (go-eval-program go-env-empty (list (go-parse "type Counter struct { n int }") (go-parse "func (c Counter) Bump() Counter { return Counter{c.n + 1} }") (go-parse "c := Counter{0}") (go-parse "for i := 0; i < 7; i++ { c = c.Bump() }")))))
-    (go-eval env (go-parse "c.n")))
-  7)
-
-(go-eval-test
-  "e2e: linear search returns index"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func find(a []int, x int) int { for i := 0; i < len(a); i++ { if a[i] == x { return i } } ; return -1 }") (go-parse "nums := []int{10, 20, 30, 40}")))))
-    (go-eval env (go-parse "find(nums, 30)")))
-  2)
-
-(go-eval-test
-  "e2e: linear search returns -1 when missing"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func find(a []int, x int) int { for i := 0; i < len(a); i++ { if a[i] == x { return i } } ; return -1 }") (go-parse "nums := []int{10, 20, 30}")))))
-    (go-eval env (go-parse "find(nums, 99)")))
-  -1)
-
-(go-eval-test
-  "defer: single defer runs after surrounding fn body returns"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func push2(c chan int) { c <- 2 }") (go-parse "func run(c chan int) { defer push2(c) ; c <- 1 }") (go-parse "run(ch)") (go-parse "first := <-ch") (go-parse "second := <-ch")))))
-    (list (go-env-lookup env "first") (go-env-lookup env "second")))
-  (list 1 2))
-
-(go-eval-test
-  "defer: multiple defers run LIFO"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func p2(c chan int) { c <- 2 }") (go-parse "func p3(c chan int) { c <- 3 }") (go-parse "func run(c chan int) { defer p2(c) ; defer p3(c) ; c <- 1 }") (go-parse "run(ch)") (go-parse "a := <-ch") (go-parse "b := <-ch") (go-parse "d := <-ch")))))
-    (list
-      (go-env-lookup env "a")
-      (go-env-lookup env "b")
-      (go-env-lookup env "d")))
-  (list 1 3 2))
-
-(go-eval-test
-  "defer: arguments are evaluated at defer-time (not call-time)"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func pushN(c chan int, v int) { c <- v }") (go-parse "func run(c chan int) { x := 7 ; defer pushN(c, x) ; x = 99 }") (go-parse "run(ch)") (go-parse "got := <-ch")))))
-    (go-env-lookup env "got"))
-  7)
-
-(go-eval-test
-  "defer: runs even when fn returns early via return"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func note(c chan int) { c <- 42 }") (go-parse "func run(c chan int) int { defer note(c) ; return 1 }") (go-parse "r := run(ch)") (go-parse "n := <-ch")))))
-    (list (go-env-lookup env "r") (go-env-lookup env "n")))
-  (list 1 42))
-
-(go-eval-test
-  "defer: stack is frame-local — outer defers don't run on inner return"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func push1(c chan int) { c <- 1 }") (go-parse "func push2(c chan int) { c <- 2 }") (go-parse "func inner(c chan int) { defer push2(c) }") (go-parse "func outer(c chan int) { defer push1(c) ; inner(c) }") (go-parse "outer(ch)") (go-parse "a := <-ch") (go-parse "b := <-ch")))))
-    (list (go-env-lookup env "a") (go-env-lookup env "b")))
-  (list 2 1))
-
-(go-eval-test
-  "defer: in a loop, all defers fire on fn return (not loop iter)"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func pushI(c chan int, v int) { c <- v }") (go-parse "func loop(c chan int) { for i := 0; i < 4; i = i + 1 { defer pushI(c, i) } }") (go-parse "loop(ch)") (go-parse "a := <-ch") (go-parse "b := <-ch") (go-parse "d := <-ch") (go-parse "e := <-ch")))))
-    (list
-      (go-env-lookup env "a")
-      (go-env-lookup env "b")
-      (go-env-lookup env "d")
-      (go-env-lookup env "e")))
-  (list 3 2 1 0))
-
-(go-eval-test
-  "panic: uncaught panic surfaces as (:go-panic V) from program"
-  (let
-    ((r (go-eval-program go-env-builtins (list (go-parse "panic(\"boom\")")))))
-    r)
-  (list :go-panic "boom"))
-
-(go-eval-test
-  "panic inside fn: surfaces from fn call too"
-  (let
-    ((r (go-eval-program go-env-builtins (list (go-parse "func boom() { panic(\"oops\") }") (go-parse "boom()")))))
-    r)
-  (list :go-panic "oops"))
-
-(go-eval-test
-  "recover: deferred recover swallows panic, fn returns normally"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func safe() { defer recover() ; panic(\"x\") }") (go-parse "safe()") (go-parse "after := 42")))))
-    (go-env-lookup env "after"))
-  42)
-
-(go-eval-test
-  "recover: deferred recover captures the panic value"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func grab(c chan int) { r := recover() ; c <- r }") (go-parse "func safe(c chan int) { defer grab(c) ; panic(99) }") (go-parse "safe(ch)") (go-parse "got := <-ch")))))
-    (go-env-lookup env "got"))
-  99)
-
-(go-eval-test
-  "panic: propagates through intermediate frames without defers"
-  (let
-    ((r (go-eval-program go-env-builtins (list (go-parse "func inner() { panic(\"deep\") }") (go-parse "func middle() { inner() }") (go-parse "func outer() { middle() }") (go-parse "outer()")))))
-    r)
-  (list :go-panic "deep"))
-
-(go-eval-test
-  "recover: middle-frame defer catches panic from deeper frame"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func inner() { panic(\"deep\") }") (go-parse "func middle() { inner() }") (go-parse "func outer() { defer recover() ; middle() }") (go-parse "outer()") (go-parse "after := 7")))))
-    (go-env-lookup env "after"))
-  7)
-
-(go-eval-test
-  "goroutine panic: surfaces synchronously back to spawner (v0)"
-  (let
-    ((r (go-eval-program go-env-builtins (list (go-parse "func boom() { panic(\"goroutine\") }") (go-parse "go boom()")))))
-    r)
-  (list :go-panic "goroutine"))
-
-(go-eval-test
-  "goroutine panic + spawner-defer-recover catches it (v0 sync)"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func boom() { panic(\"g\") }") (go-parse "func main() { defer recover() ; go boom() }") (go-parse "main()") (go-parse "after := 11")))))
-    (go-env-lookup env "after"))
-  11)
-
-(go-eval-test
-  "defer order with recover: all defers run, recover catches"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func p2(c chan int) { c <- 2 }") (go-parse "func rec(c chan int) { recover() ; c <- 7 }") (go-parse "func safe(c chan int) { defer p2(c) ; defer rec(c) ; panic(0) }") (go-parse "safe(ch)") (go-parse "a := <-ch") (go-parse "b := <-ch")))))
-    (list (go-env-lookup env "a") (go-env-lookup env "b")))
-  (list 7 2))
-
-(go-eval-test
-  "defer fires when fn panics (not just normal return)"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func note(c chan int) { c <- 5 }") (go-parse "func safe(c chan int) { defer note(c) ; defer recover() ; panic(\"!\") }") (go-parse "safe(ch)") (go-parse "got := <-ch")))))
-    (go-env-lookup env "got"))
-  5)
-
-(go-eval-test
-  "panic with nil value: still surfaces as (:go-panic nil)"
-  (let
-    ((r (go-eval-program go-env-builtins (list (go-parse "panic(nil)")))))
-    r)
-  (list :go-panic nil))
-
-(go-eval-test
-  "panic inside loop body: aborts loop + propagates"
-  (let
-    ((r (go-eval-program go-env-builtins (list (go-parse "func find(x int) { for i := 0; i < 10; i = i + 1 { if i == x { panic(i) } } }") (go-parse "find(3)")))))
-    r)
-  (list :go-panic 3))
-
-(go-eval-test
-  "defer in panicking fn: still runs even though no return reached"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func mark(c chan int) { c <- 8 }") (go-parse "func inner(c chan int) { defer mark(c) ; panic(\"!\") }") (go-parse "func outer(c chan int) { defer recover() ; inner(c) }") (go-parse "outer(ch)") (go-parse "got := <-ch")))))
-    (go-env-lookup env "got"))
-  8)
-
-(go-eval-test
-  "defer fn captures args by value, not reference (re-confirm)"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "func pushN(c chan int, v int) { c <- v }") (go-parse "func run(c chan int) { defer recover() ; x := 5 ; defer pushN(c, x) ; x = 999 ; panic(\"k\") }") (go-parse "run(ch)") (go-parse "got := <-ch")))))
-    (go-env-lookup env "got"))
-  5)
-
-(go-eval-test
-  "generic: identity Id[T any](x) returns x at runtime"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func Id[T any](x T) T { return x }") (go-parse "r := Id(42)")))))
-    (go-env-lookup env "r"))
-  42)
-
-(go-eval-test
-  "generic: Id works with strings (type erasure)"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func Id[T any](x T) T { return x }") (go-parse "r := Id(\"hi\")")))))
-    (go-env-lookup env "r"))
-  "hi")
-
-(go-eval-test
-  "generic: Map[T, U] over []int with double — produces []int"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func Map[T any, U any](xs []T, f func(T) U) []U { r := []int{} ; for i, v := range xs { r = append(r, f(v)) } ; return r }") (go-parse "func dbl(x int) int { return x * 2 }") (go-parse "out := Map([]int{1, 2, 3}, dbl)") (go-parse "first := out[0]") (go-parse "second := out[1]") (go-parse "third := out[2]")))))
-    (list
-      (go-env-lookup env "first")
-      (go-env-lookup env "second")
-      (go-env-lookup env "third")))
-  (list 2 4 6))
-
-(go-eval-test
-  "generic: Filter[T any] keeps elements satisfying predicate"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func Filter[T any](xs []T, p func(T) bool) []T { r := []int{} ; for i, v := range xs { if p(v) { r = append(r, v) } } ; return r }") (go-parse "func gt3(x int) bool { return x > 3 }") (go-parse "out := Filter([]int{1, 2, 3, 4, 5, 6}, gt3)") (go-parse "n := len(out)") (go-parse "first := out[0]") (go-parse "last := out[2]")))))
-    (list
-      (go-env-lookup env "n")
-      (go-env-lookup env "first")
-      (go-env-lookup env "last")))
-  (list 3 4 6))
-
-(go-eval-test
-  "generic: Reduce[T, U] sums []int with seed 0"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func Reduce[T any, U any](xs []T, seed U, f func(U, T) U) U { acc := seed ; for i, v := range xs { acc = f(acc, v) } ; return acc }") (go-parse "func add(a int, b int) int { return a + b }") (go-parse "total := Reduce([]int{10, 20, 30, 40}, 0, add)")))))
-    (go-env-lookup env "total"))
-  100)
-
-(go-eval-test
-  "generic: First[T any]([]T) T returns element zero"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func First[T any](xs []T) T { return xs[0] }") (go-parse "v := First([]int{42, 99})")))))
-    (go-env-lookup env "v"))
-  42)
-
-(define
-  go-eval-test-summary
-  (str "eval " go-eval-test-pass "/" go-eval-test-count))

lib/go/tests/lex.sx

@@ -1,339 +0,0 @@
-;; Go tokenizer tests.
-
-(define go-test-count 0)
-(define go-test-pass 0)
-(define go-test-fails (list))
-
-(define gtok-type (fn (t) (get t :type)))
-(define gtok-value (fn (t) (get t :value)))
-(define tok-types (fn (src) (map gtok-type (go-tokenize src))))
-(define tok-values (fn (src) (map gtok-value (go-tokenize src))))
-
-(define
-  go-test
-  (fn
-    (name actual expected)
-    (set! go-test-count (+ go-test-count 1))
-    (if
-      (= actual expected)
-      (set! go-test-pass (+ go-test-pass 1))
-      (append! go-test-fails {:name name :expected expected :actual actual}))))
-
-;; ── empty / whitespace ────────────────────────────────────────────
-(go-test "empty source" (tok-types "") (list "eof"))
-(go-test "spaces only" (tok-types "   ") (list "eof"))
-(go-test "tabs only" (tok-types "\t\t") (list "eof"))
-(go-test
-  "newline only — no prior token, no ASI"
-  (tok-types "\n")
-  (list "eof"))
-
-;; ── identifiers ───────────────────────────────────────────────────
-(go-test "ident: simple" (tok-values "foo") (list "foo" "\n" nil))
-(go-test
-  "ident: underscore prefix"
-  (tok-values "_bar")
-  (list "_bar" "\n" nil))
-(go-test "ident: mixed case" (tok-values "fooBar") (list "fooBar" "\n" nil))
-(go-test "ident: with digits" (tok-values "x123") (list "x123" "\n" nil))
-(go-test "ident: type tag" (tok-types "foo") (list "ident" "semi" "eof"))
-
-;; ── keywords (all 25) ─────────────────────────────────────────────
-(go-test "kw: break" (tok-types "break") (list "keyword" "semi" "eof"))
-(go-test "kw: case" (tok-types "case") (list "keyword" "eof"))
-(go-test "kw: chan" (tok-types "chan") (list "keyword" "eof"))
-(go-test "kw: const" (tok-types "const") (list "keyword" "eof"))
-(go-test "kw: continue" (tok-types "continue") (list "keyword" "semi" "eof"))
-(go-test "kw: default" (tok-types "default") (list "keyword" "eof"))
-(go-test "kw: defer" (tok-types "defer") (list "keyword" "eof"))
-(go-test "kw: else" (tok-types "else") (list "keyword" "eof"))
-(go-test
-  "kw: fallthrough"
-  (tok-types "fallthrough")
-  (list "keyword" "semi" "eof"))
-(go-test "kw: for" (tok-types "for") (list "keyword" "eof"))
-(go-test "kw: func" (tok-types "func") (list "keyword" "eof"))
-(go-test "kw: go" (tok-types "go") (list "keyword" "eof"))
-(go-test "kw: goto" (tok-types "goto") (list "keyword" "eof"))
-(go-test "kw: if" (tok-types "if") (list "keyword" "eof"))
-(go-test "kw: import" (tok-types "import") (list "keyword" "eof"))
-(go-test "kw: interface" (tok-types "interface") (list "keyword" "eof"))
-(go-test "kw: map" (tok-types "map") (list "keyword" "eof"))
-(go-test "kw: package" (tok-types "package") (list "keyword" "eof"))
-(go-test "kw: range" (tok-types "range") (list "keyword" "eof"))
-(go-test "kw: return" (tok-types "return") (list "keyword" "semi" "eof"))
-(go-test "kw: select" (tok-types "select") (list "keyword" "eof"))
-(go-test "kw: struct" (tok-types "struct") (list "keyword" "eof"))
-(go-test "kw: switch" (tok-types "switch") (list "keyword" "eof"))
-(go-test "kw: type" (tok-types "type") (list "keyword" "eof"))
-(go-test "kw: var" (tok-types "var") (list "keyword" "eof"))
-
-;; ── integer literals — decimal ────────────────────────────────────
-(go-test "int: zero" (tok-values "0") (list "0" "\n" nil))
-(go-test "int: small" (tok-values "42") (list "42" "\n" nil))
-(go-test "int: bigger" (tok-values "123456") (list "123456" "\n" nil))
-(go-test "int: type" (tok-types "42") (list "int" "semi" "eof"))
-
-;; ── integer literals — prefixed + underscores ─────────────────────
-(go-test "int: hex lower" (tok-values "0x1f") (list "0x1f" "\n" nil))
-(go-test "int: hex upper-x" (tok-values "0X1F") (list "0X1F" "\n" nil))
-(go-test
-  "int: hex mixed digits"
-  (tok-values "0xDEADbeef")
-  (list "0xDEADbeef" "\n" nil))
-(go-test "int: binary lower" (tok-values "0b1010") (list "0b1010" "\n" nil))
-(go-test "int: binary upper" (tok-values "0B1101") (list "0B1101" "\n" nil))
-(go-test "int: octal modern" (tok-values "0o755") (list "0o755" "\n" nil))
-(go-test "int: octal upper" (tok-values "0O17") (list "0O17" "\n" nil))
-(go-test "int: octal legacy" (tok-values "0755") (list "0755" "\n" nil))
-(go-test "int: hex type" (tok-types "0x1F") (list "int" "semi" "eof"))
-(go-test "int: bin type" (tok-types "0b101") (list "int" "semi" "eof"))
-(go-test
-  "int: dec underscore"
-  (tok-values "1_000_000")
-  (list "1_000_000" "\n" nil))
-(go-test
-  "int: hex underscore"
-  (tok-values "0xDEAD_BEEF")
-  (list "0xDEAD_BEEF" "\n" nil))
-(go-test
-  "int: bin underscore"
-  (tok-values "0b1010_1010")
-  (list "0b1010_1010" "\n" nil))
-(go-test
-  "int: hex then +"
-  (tok-types "0xFF + 1")
-  (list "int" "op" "int" "semi" "eof"))
-
-;; ── float literals (Go spec § Floating-point literals) ────────────
-(go-test "float: simple" (tok-values "3.14") (list "3.14" "\n" nil))
-(go-test "float: trailing dot" (tok-values "1.") (list "1." "\n" nil))
-(go-test "float: leading dot" (tok-values ".5") (list ".5" "\n" nil))
-(go-test "float: exp lower" (tok-values "1e10") (list "1e10" "\n" nil))
-(go-test "float: exp upper" (tok-values "1E5") (list "1E5" "\n" nil))
-(go-test "float: exp negative" (tok-values "1.5e-3") (list "1.5e-3" "\n" nil))
-(go-test "float: exp positive" (tok-values "2.0e+2") (list "2.0e+2" "\n" nil))
-(go-test "float: zero" (tok-values "0.0") (list "0.0" "\n" nil))
-(go-test "float: dot-only-exp" (tok-values ".5e2") (list ".5e2" "\n" nil))
-(go-test "float: underscore" (tok-values "1_000.5") (list "1_000.5" "\n" nil))
-(go-test "float: type" (tok-types "3.14") (list "float" "semi" "eof"))
-(go-test
-  "float: trailing dot type"
-  (tok-types "1.")
-  (list "float" "semi" "eof"))
-(go-test
-  "float: exp-only type"
-  (tok-types "1e10")
-  (list "float" "semi" "eof"))
-(go-test
-  "float: then +"
-  (tok-types "3.14 + 0.1")
-  (list "float" "op" "float" "semi" "eof"))
-(go-test
-  "float: greedy 1.method"
-  (tok-types "1.method")
-  (list "float" "ident" "semi" "eof"))
-
-;; ── imaginary literals (Go spec § Imaginary literals) ─────────────
-(go-test "imag: int i" (tok-values "2i") (list "2i" "\n" nil))
-(go-test "imag: float i" (tok-values "3.14i") (list "3.14i" "\n" nil))
-(go-test "imag: exp i" (tok-values "1e2i") (list "1e2i" "\n" nil))
-(go-test "imag: int-i type" (tok-types "2i") (list "imag" "semi" "eof"))
-(go-test "imag: float-i type" (tok-types "3.14i") (list "imag" "semi" "eof"))
-(go-test "imag: ASI at newline" (tok-types "1i\n") (list "imag" "semi" "eof"))
-
-;; ── string literals ───────────────────────────────────────────────
-(go-test "raw: simple" (tok-values "`hello`") (list "hello" "\n" nil))
-(go-test "raw: empty" (tok-values "``") (list "" "\n" nil))
-(go-test
-  "raw: backslash literal — no escape processing"
-  (tok-values "`a\\nb`")
-  (list "a\\nb" "\n" nil))
-(go-test
-  "raw: multi-line"
-  (tok-values "`line1\nline2`")
-  (list "line1\nline2" "\n" nil))
-(go-test
-  "raw: contains double-quote"
-  (tok-values "`say \"hi\"`")
-  (list "say \"hi\"" "\n" nil))
-(go-test
-  "raw: CR stripped (Go spec § String literals)"
-  (tok-values "`a\r\nb`")
-  (list "a\nb" "\n" nil))
-(go-test "raw: type" (tok-types "`x`") (list "string" "semi" "eof"))
-
-;; ── rune literals ─────────────────────────────────────────────────
-(go-test
-  "raw: then +"
-  (tok-types "`x` + 1")
-  (list "string" "op" "int" "semi" "eof"))
-(go-test
-  "raw: ASI at newline after"
-  (tok-types "`abc`\n")
-  (list "string" "semi" "eof"))
-(go-test "string: empty" (tok-values "\"\"") (list "" "\n" nil))
-
-;; ── comments ──────────────────────────────────────────────────────
-(go-test "string: hello" (tok-values "\"hello\"") (list "hello" "\n" nil))
-(go-test
-  "string: with space"
-  (tok-values "\"hi there\"")
-  (list "hi there" "\n" nil))
-(go-test "string: escape n" (tok-values "\"a\\nb\"") (list "a\nb" "\n" nil))
-(go-test "string: escape quote" (tok-values "\"a\\\"b\"") (list "a\"b" "\n" nil))
-(go-test
-  "string: escape backslash"
-  (tok-values "\"a\\\\b\"")
-  (list "a\\b" "\n" nil))
-
-;; ── operators & punctuation ───────────────────────────────────────
-(go-test "string: type" (tok-types "\"x\"") (list "string" "semi" "eof"))
-(go-test "rune: simple" (tok-values "'a'") (list "a" "\n" nil))
-(go-test "rune: escape" (tok-values "'\\n'") (list "\n" "\n" nil))
-(go-test "rune: type" (tok-types "'a'") (list "rune" "semi" "eof"))
-(go-test "line comment" (tok-types "// ignored") (list "eof"))
-(go-test "line comment then code" (tok-values "// hi\nx") (list "x" "\n" nil))
-(go-test "block comment" (tok-types "/* a b c */") (list "eof"))
-(go-test
-  "block comment inline"
-  (tok-values "x /* mid */ y")
-  (list "x" "y" "\n" nil))
-(go-test
-  "block comment with newline — ASI"
-  (tok-types "x /* multi\nline */ y")
-  (list "ident" "semi" "ident" "semi" "eof"))
-
-;; ── automatic semicolon insertion (Go spec § Semicolons) ──────────
-(go-test
-  "ops: arithmetic"
-  (tok-values "+ - * / %")
-  (list "+" "-" "*" "/" "%" nil))
-(go-test
-  "ops: comparison"
-  (tok-values "== != < > <= >=")
-  (list "==" "!=" "<" ">" "<=" ">=" nil))
-(go-test "ops: logical" (tok-values "&& || !") (list "&&" "||" "!" nil))
-(go-test
-  "ops: assign forms"
-  (tok-values "= := += -=")
-  (list "=" ":=" "+=" "-=" nil))
-(go-test "ops: channel arrow" (tok-values "<- chan") (list "<-" "chan" nil))
-(go-test "ops: incdec ASI" (tok-types "++ --") (list "op" "op" "semi" "eof"))
-(go-test "ops: ellipsis" (tok-values "...") (list "..." nil))
-(go-test
-  "punct: all brackets"
-  (tok-values "( ) { } [ ]")
-  (list "(" ")" "{" "}" "[" "]" "\n" nil))
-(go-test
-  "punct: comma colon dot"
-  (tok-values ", : .")
-  (list "," ":" "." nil))
-(go-test
-  "op-audit: tilde (generics type-set)"
-  (tok-values "~int")
-  (list "~" "int" "\n" nil))
-(go-test
-  "op-audit: all arithmetic + assignment"
-  (tok-values "+ - * / % += -= *= /= %=")
-  (list "+" "-" "*" "/" "%" "+=" "-=" "*=" "/=" "%=" nil))
-(go-test
-  "op-audit: all bitwise + assignment"
-  (tok-values "& | ^ << >> &^ &= |= ^= <<= >>= &^=")
-  (list "&" "|" "^" "<<" ">>" "&^" "&=" "|=" "^=" "<<=" ">>=" "&^=" nil))
-(go-test
-  "op-audit: all comparison + logical"
-  (tok-values "== != < > <= >= && || !")
-  (list "==" "!=" "<" ">" "<=" ">=" "&&" "||" "!" nil))
-(go-test
-  "op-audit: assign / decls / arrows / variadic / inc-dec"
-  (tok-values "= := <- ++ -- ...")
-  (list "=" ":=" "<-" "++" "--" "..." nil))
-
-;; ── short program ─────────────────────────────────────────────────
-(go-test
-  "op-audit: punctuation"
-  (tok-values "( ) [ ] { } , . :")
-  (list "(" ")" "[" "]" "{" "}" "," "." ":" nil))
-(go-test
-  "ASI: after ident at newline"
-  (tok-types "x\ny")
-  (list "ident" "semi" "ident" "semi" "eof"))
-(go-test "ASI: after int" (tok-types "42\n") (list "int" "semi" "eof"))
-
-;; ── report ────────────────────────────────────────────────────────
-(go-test "ASI: after float" (tok-types "3.14\n") (list "float" "semi" "eof"))
-
-(go-test
-  "ASI: after string"
-  (tok-types "\"hi\"\n")
-  (list "string" "semi" "eof"))
-
-(go-test "ASI: after rune" (tok-types "'a'\n") (list "rune" "semi" "eof"))
-
-(go-test
-  "ASI: after )"
-  (tok-types "f()\n")
-  (list "ident" "op" "op" "semi" "eof"))
-
-(go-test
-  "ASI: after ]"
-  (tok-types "x[0]\n")
-  (list "ident" "op" "int" "op" "semi" "eof"))
-
-(go-test "ASI: after }" (tok-types "{}\n") (list "op" "op" "semi" "eof"))
-
-(go-test "ASI: after ++" (tok-types "i++\n") (list "ident" "op" "semi" "eof"))
-
-(go-test
-  "ASI: NOT after +"
-  (tok-types "x +\ny")
-  (list "ident" "op" "ident" "semi" "eof"))
-
-(go-test
-  "ASI: NOT after ("
-  (tok-types "f(\nx)")
-  (list "ident" "op" "ident" "op" "semi" "eof"))
-
-(go-test
-  "ASI: blank lines collapse — single semi only"
-  (tok-types "x\n\n\ny")
-  (list "ident" "semi" "ident" "semi" "eof"))
-
-(go-test
-  "ASI: at EOF after ident"
-  (tok-types "x")
-  (list "ident" "semi" "eof"))
-
-(go-test
-  "ASI: explicit semi"
-  (tok-types "x;y")
-  (list "ident" "semi" "ident" "semi" "eof"))
-
-(go-test
-  "short-decl: x := 42 (types)"
-  (tok-types "x := 42")
-  (list "ident" "op" "int" "semi" "eof"))
-
-(go-test
-  "short-decl: x := 42 (values)"
-  (tok-values "x := 42")
-  (list "x" ":=" "42" "\n" nil))
-
-(go-test
-  "func decl shape"
-  (tok-types "func foo() int { return 0 }")
-  (list
-    "keyword"
-    "ident"
-    "op"
-    "op"
-    "ident"
-    "op"
-    "keyword"
-    "int"
-    "op"
-    "semi"
-    "eof"))
-
-(define go-lex-test-summary (str "lex " go-test-pass "/" go-test-count))

lib/go/tests/runtime.sx

@@ -1,311 +0,0 @@
-;; Go runtime tests — goroutines + channels.
-
-(define go-rt-test-count 0)
-(define go-rt-test-pass 0)
-(define go-rt-test-fails (list))
-
-(define
-  go-rt-test
-  (fn
-    (name actual expected)
-    (set! go-rt-test-count (+ go-rt-test-count 1))
-    (if
-      (= actual expected)
-      (set! go-rt-test-pass (+ go-rt-test-pass 1))
-      (append! go-rt-test-fails {:name name :expected expected :actual actual}))))
-
-;; ── channel primitives (direct API, no source parsing) ─────────
-(go-rt-test "chan: make returns a chan value" (go-chan? (go-make-chan)) true)
-
-(go-rt-test
-  "chan: distinct channels have distinct identity"
-  (= (go-make-chan) (go-make-chan))
-  false)
-
-(go-rt-test
-  "chan: send + recv round-trip"
-  (let
-    ((ch (go-make-chan)))
-    (go-chan-send! ch 42)
-    (go-chan-recv! ch))
-  42)
-
-(go-rt-test
-  "chan: empty recv returns :empty marker"
-  (let ((ch (go-make-chan))) (go-chan-recv! ch))
-  :empty)
-
-(go-rt-test
-  "chan: FIFO order"
-  (let
-    ((ch (go-make-chan)))
-    (go-chan-send! ch 1)
-    (go-chan-send! ch 2)
-    (go-chan-send! ch 3)
-    (list (go-chan-recv! ch) (go-chan-recv! ch) (go-chan-recv! ch)))
-  (list 1 2 3))
-
-(go-rt-test
-  "chan: closed? flag flips"
-  (let
-    ((ch (go-make-chan)))
-    (let
-      ((before (go-chan-closed? ch)))
-      (go-chan-close! ch)
-      (list before (go-chan-closed? ch))))
-  (list false true))
-
-;; ── source-level: make / send / recv / close ───────────────────
-(go-rt-test
-  "src: ch := make() returns chan"
-  (go-chan?
-    (let
-      ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()")))))
-      (go-env-lookup env "ch")))
-  true)
-
-(go-rt-test
-  "src: ch <- 5 then <-ch = 5"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "ch <- 5")))))
-    (go-eval env (go-parse "<-ch")))
-  5)
-
-(go-rt-test
-  "src: go + chan ping-pong"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func sender(c chan int) { c <- 99 }") (go-parse "ch := make()") (go-parse "go sender(ch)")))))
-    (go-eval env (go-parse "<-ch")))
-  99)
-
-(go-rt-test
-  "src: close(ch) marks it closed"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "close(ch)")))))
-    (go-chan-closed? (go-env-lookup env "ch")))
-  true)
-
-(go-rt-test
-  "src: multiple goroutines feeding one channel"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func push(c chan int, v int) { c <- v }") (go-parse "ch := make()") (go-parse "go push(ch, 1)") (go-parse "go push(ch, 2)") (go-parse "go push(ch, 3)")))))
-    (list
-      (go-eval env (go-parse "<-ch"))
-      (go-eval env (go-parse "<-ch"))
-      (go-eval env (go-parse "<-ch"))))
-  (list 1 2 3))
-
-(go-rt-test
-  "src: worker pattern — send sum back"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func work(c chan int, a int, b int) { c <- a + b }") (go-parse "result := make()") (go-parse "go work(result, 7, 13)")))))
-    (go-eval env (go-parse "<-result")))
-  20)
-
-;; ── report ─────────────────────────────────────────────────────
-(go-rt-test
-  "select: default runs when no case is ready"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "x := 0") (go-parse "select { case <-ch: x = 1 ; default: x = 99 }")))))
-    (go-env-lookup env "x"))
-  99)
-
-(go-rt-test
-  "select: recv case fires when ready"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "ch <- 7") (go-parse "x := 0") (go-parse "select { case <-ch: x = 1 ; default: x = 99 }")))))
-    (go-env-lookup env "x"))
-  1)
-
-(go-rt-test
-  "select: recv-into-var binds the value"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "ch <- 42") (go-parse "select { case v := <-ch: v }")))))
-    (go-env-lookup env "v"))
-  42)
-
-(go-rt-test
-  "select: send case (always ready in v0)"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "select { case ch <- 5: }")))))
-    (go-chan-len (go-env-lookup env "ch")))
-  1)
-
-(go-rt-test
-  "select: picks first ready case"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "a := make()") (go-parse "b := make()") (go-parse "b <- 100") (go-parse "x := 0") (go-parse "select { case <-a: x = 1 ; case <-b: x = 2 ; default: x = 99 }")))))
-    (go-env-lookup env "x"))
-  2)
-
-(go-rt-test
-  "select: no default + nothing ready → blocked error"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()")))))
-    (go-eval-stmt env (go-parse "select { case <-ch: }") (list)))
-  (list :eval-error :select-blocked-no-default))
-
-(go-rt-test
-  "select: combined with goroutine fan-in"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func push(c chan int, v int) { c <- v }") (go-parse "ch := make()") (go-parse "go push(ch, 7)") (go-parse "result := 0") (go-parse "select { case v := <-ch: result = v ; default: result = -1 }")))))
-    (go-env-lookup env "result"))
-  7)
-
-(go-rt-test
-  "range: slice — sum of 1..5"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "var sum = 0") (go-parse "a := []int{1, 2, 3, 4, 5}") (go-parse "for i, v := range a { sum = sum + v }")))))
-    (go-env-lookup env "sum"))
-  15)
-
-(go-rt-test
-  "range: slice — key only (index)"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "var s = 0") (go-parse "a := []int{10, 20, 30}") (go-parse "for i := range a { s = s + i }")))))
-    (go-env-lookup env "s"))
-  3)
-
-(go-rt-test
-  "range: map — sum values"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "var s = 0") (go-parse "m := map[string]int{\"a\": 1, \"b\": 2, \"c\": 3}") (go-parse "for k, v := range m { s = s + v }")))))
-    (go-env-lookup env "s"))
-  6)
-
-(go-rt-test
-  "range: channel — collect all buffered"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "ch := make()") (go-parse "ch <- 1") (go-parse "ch <- 2") (go-parse "ch <- 3") (go-parse "var sum = 0") (go-parse "for v := range ch { sum = sum + v }")))))
-    (go-env-lookup env "sum"))
-  6)
-
-(go-rt-test
-  "range: slice with break exits early"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "var s = 0") (go-parse "a := []int{1, 2, 3, 4, 5}") (go-parse "for i, v := range a { if v == 3 { break } ; s = s + v }")))))
-    (go-env-lookup env "s"))
-  3)
-
-(go-rt-test
-  "range: slice with continue skips an element"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "var s = 0") (go-parse "a := []int{1, 2, 3, 4, 5}") (go-parse "for i, v := range a { if v == 3 { continue } ; s = s + v }")))))
-    (go-env-lookup env "s"))
-  12)
-
-(go-rt-test
-  "range: empty slice — body never runs"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "var s = 0") (go-parse "a := []int{}") (go-parse "for v := range a { s = s + v }")))))
-    (go-env-lookup env "s"))
-  0)
-
-(go-rt-test
-  "range: chan + goroutine producer"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func emit(c chan int) { c <- 10 ; c <- 20 ; c <- 30 }") (go-parse "ch := make()") (go-parse "go emit(ch)") (go-parse "var total = 0") (go-parse "for v := range ch { total = total + v }")))))
-    (go-env-lookup env "total"))
-  60)
-
-(go-rt-test
-  "timer: after(d) returns a ready channel (v0 stub)"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "t := after(100)")))))
-    (go-chan-len (go-env-lookup env "t")))
-  1)
-
-(go-rt-test
-  "select with timer (after) — buffered value wins, timer is fallback"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func push99(c chan int) { c <- 99 }") (go-parse "c := make()") (go-parse "go push99(c)") (go-parse "t := after(0)") (go-parse "var v = 0") (go-parse "select { case x := <-c: v = x; case y := <-t: v = -1 }")))))
-    (go-env-lookup env "v"))
-  99)
-
-(go-rt-test
-  "fan-in: 3 producer goroutines, main sums their values"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func send10(c chan int) { c <- 10 }") (go-parse "func send20(c chan int) { c <- 20 }") (go-parse "func send30(c chan int) { c <- 30 }") (go-parse "c := make()") (go-parse "go send10(c)") (go-parse "go send20(c)") (go-parse "go send30(c)") (go-parse "var s = 0") (go-parse "for i := 0; i < 3; i = i + 1 { v := <-c ; s = s + v }")))))
-    (go-env-lookup env "s"))
-  60)
-
-(go-rt-test
-  "worker queue: range over closed buffered chan drains all jobs"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "jobs := make()") (go-parse "jobs <- 1") (go-parse "jobs <- 2") (go-parse "jobs <- 3") (go-parse "jobs <- 4") (go-parse "close(jobs)") (go-parse "var s = 0") (go-parse "for j := range jobs { s = s + j }")))))
-    (go-env-lookup env "s"))
-  10)
-
-(go-rt-test
-  "pipeline: stage1 squares, stage2 sums via channels"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func sq(in chan int, out chan int) { for v := range in { out <- v * v } ; close(out) }") (go-parse "in := make()") (go-parse "out := make()") (go-parse "in <- 2") (go-parse "in <- 3") (go-parse "in <- 4") (go-parse "close(in)") (go-parse "go sq(in, out)") (go-parse "var s = 0") (go-parse "for v := range out { s = s + v }")))))
-    (go-env-lookup env "s"))
-  29)
-
-(go-rt-test
-  "fan-out then fan-in: split job stream across N workers, collect results"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func worker(in chan int, out chan int) { for v := range in { out <- v + 100 } }") (go-parse "jobs := make()") (go-parse "results := make()") (go-parse "jobs <- 1") (go-parse "jobs <- 2") (go-parse "jobs <- 3") (go-parse "close(jobs)") (go-parse "go worker(jobs, results)") (go-parse "close(results)") (go-parse "var s = 0") (go-parse "for r := range results { s = s + r }")))))
-    (go-env-lookup env "s"))
-  306)
-
-(go-rt-test
-  "select: first ready case wins (channel order = source order)"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "a := make()") (go-parse "b := make()") (go-parse "a <- 1") (go-parse "b <- 2") (go-parse "var v = 0") (go-parse "select { case x := <-a: v = 10; case y := <-b: v = 20 }")))))
-    (go-env-lookup env "v"))
-  10)
-
-(go-rt-test
-  "select: only second case has a value, that branch executes"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "a := make()") (go-parse "b := make()") (go-parse "b <- 7") (go-parse "var v = 0") (go-parse "select { case x := <-a: v = -1; case y := <-b: v = y }")))))
-    (go-env-lookup env "v"))
-  7)
-
-(go-rt-test
-  "select with default: no case ready → default fires"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "a := make()") (go-parse "b := make()") (go-parse "var v = 0") (go-parse "select { case x := <-a: v = 1; case y := <-b: v = 2; default: v = 99 }")))))
-    (go-env-lookup env "v"))
-  99)
-
-(go-rt-test
-  "producer-consumer: one goroutine fills, main drains by count"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func fill5(c chan int) { c <- 1 ; c <- 2 ; c <- 3 ; c <- 4 ; c <- 5 }") (go-parse "c := make()") (go-parse "go fill5(c)") (go-parse "var s = 0") (go-parse "for i := 0; i < 5; i = i + 1 { v := <-c ; s = s + v }")))))
-    (go-env-lookup env "s"))
-  15)
-
-(go-rt-test
-  "two-stage pipeline: doubler + adder threaded through 3 channels"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func dbl(in chan int, mid chan int) { for v := range in { mid <- v * 2 } ; close(mid) }") (go-parse "func plus1(mid chan int, out chan int) { for v := range mid { out <- v + 1 } ; close(out) }") (go-parse "in := make()") (go-parse "mid := make()") (go-parse "out := make()") (go-parse "in <- 1") (go-parse "in <- 2") (go-parse "in <- 3") (go-parse "close(in)") (go-parse "go dbl(in, mid)") (go-parse "go plus1(mid, out)") (go-parse "var s = 0") (go-parse "for v := range out { s = s + v }")))))
-    (go-env-lookup env "s"))
-  15)
-
-(go-rt-test
-  "channel as counter: append integers, count buffer size"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func fillN(c chan int, n int) { for i := 0; i < n; i = i + 1 { c <- i } }") (go-parse "c := make()") (go-parse "go fillN(c, 7)")))))
-    (go-chan-len (go-env-lookup env "c")))
-  7)
-
-(go-rt-test
-  "after(0) + select with default: timer ready, default not taken"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "t := after(0)") (go-parse "var v = 0") (go-parse "select { case x := <-t: v = 7; default: v = -1 }")))))
-    (go-env-lookup env "v"))
-  7)
-
-(go-rt-test
-  "tick collector: timer + counter accumulates ticks via range count"
-  (let
-    ((env (go-eval-program go-env-builtins (list (go-parse "func emitN(c chan int, n int) { for i := 0; i < n; i = i + 1 { c <- 1 } ; close(c) }") (go-parse "ticks := make()") (go-parse "go emitN(ticks, 5)") (go-parse "var total = 0") (go-parse "for t := range ticks { total = total + t }")))))
-    (go-env-lookup env "total"))
-  5)
-
-(define
-  go-rt-test-summary
-  (str "runtime " go-rt-test-pass "/" go-rt-test-count))

lib/go/tests/stdlib.sx

@@ -1,209 +0,0 @@
-;; Go stdlib tests — exercises lib/go/std/*.sx packages via the
-;; idiomatic `import-style` qualified call (`strings.Contains(...)`).
-
-(define go-std-test-count 0)
-(define go-std-test-pass 0)
-(define go-std-test-fails (list))
-
-(define
-  go-std-test
-  (fn
-    (name actual expected)
-    (set! go-std-test-count (+ go-std-test-count 1))
-    (if
-      (= actual expected)
-      (set! go-std-test-pass (+ go-std-test-pass 1))
-      (append! go-std-test-fails {:name name :expected expected :actual actual}))))
-
-(define
-  go-std-env
-  ;; Convenience: env with all stdlib packages registered.
-  (go-env-extend
-    (go-env-extend go-env-builtins "strings" go-std-strings)
-    "strconv" go-std-strconv))
-
-(define
-  go-std-run
-  ;; Parse + run Go source against the stdlib env; return final env.
-  (fn (src-list)
-    (go-eval-program go-std-env (map go-parse src-list))))
-
-;; ── strings.Contains ─────────────────────────────────────────────
-(go-std-test "strings.Contains: hit"
-  (go-env-lookup (go-std-run (list "r := strings.Contains(\"hello world\", \"world\")")) "r")
-  true)
-
-(go-std-test "strings.Contains: miss"
-  (go-env-lookup (go-std-run (list "r := strings.Contains(\"hello\", \"xyz\")")) "r")
-  false)
-
-(go-std-test "strings.Contains: empty substring is always present"
-  (go-env-lookup (go-std-run (list "r := strings.Contains(\"abc\", \"\")")) "r")
-  true)
-
-;; ── strings.HasPrefix / HasSuffix ────────────────────────────────
-(go-std-test "strings.HasPrefix: true"
-  (go-env-lookup (go-std-run (list "r := strings.HasPrefix(\"hello world\", \"hello\")")) "r")
-  true)
-
-(go-std-test "strings.HasPrefix: false"
-  (go-env-lookup (go-std-run (list "r := strings.HasPrefix(\"hello\", \"world\")")) "r")
-  false)
-
-(go-std-test "strings.HasSuffix: true"
-  (go-env-lookup (go-std-run (list "r := strings.HasSuffix(\"hello world\", \"world\")")) "r")
-  true)
-
-(go-std-test "strings.HasSuffix: false"
-  (go-env-lookup (go-std-run (list "r := strings.HasSuffix(\"hello\", \"world\")")) "r")
-  false)
-
-;; ── strings.Index ─────────────────────────────────────────────────
-(go-std-test "strings.Index: found at 6"
-  (go-env-lookup (go-std-run (list "r := strings.Index(\"hello world\", \"world\")")) "r")
-  6)
-
-(go-std-test "strings.Index: not found = -1"
-  (go-env-lookup (go-std-run (list "r := strings.Index(\"hello\", \"xyz\")")) "r")
-  -1)
-
-(go-std-test "strings.Index: empty substring = 0"
-  (go-env-lookup (go-std-run (list "r := strings.Index(\"abc\", \"\")")) "r")
-  0)
-
-;; ── strings.Count ─────────────────────────────────────────────────
-(go-std-test "strings.Count: 3 occurrences of 'a'"
-  (go-env-lookup (go-std-run (list "r := strings.Count(\"banana\", \"a\")")) "r")
-  3)
-
-(go-std-test "strings.Count: 0 occurrences"
-  (go-env-lookup (go-std-run (list "r := strings.Count(\"hello\", \"z\")")) "r")
-  0)
-
-;; ── strings.Repeat ────────────────────────────────────────────────
-(go-std-test "strings.Repeat: ab × 3 = ababab"
-  (go-env-lookup (go-std-run (list "r := strings.Repeat(\"ab\", 3)")) "r")
-  "ababab")
-
-(go-std-test "strings.Repeat: any × 0 = empty"
-  (go-env-lookup (go-std-run (list "r := strings.Repeat(\"x\", 0)")) "r")
-  "")
-
-;; ── strings.Join ──────────────────────────────────────────────────
-(go-std-test "strings.Join: comma-separated"
-  (go-env-lookup (go-std-run (list "r := strings.Join([]string{\"a\", \"b\", \"c\"}, \", \")")) "r")
-  "a, b, c")
-
-(go-std-test "strings.Join: empty slice = empty"
-  (go-env-lookup (go-std-run (list "r := strings.Join([]string{}, \"-\")")) "r")
-  "")
-
-(go-std-test "strings.Join: single elem = elem"
-  (go-env-lookup (go-std-run (list "r := strings.Join([]string{\"solo\"}, \",\")")) "r")
-  "solo")
-
-;; ── strings.ToUpper / ToLower ─────────────────────────────────────
-(go-std-test "strings.ToUpper: hello → HELLO"
-  (go-env-lookup (go-std-run (list "r := strings.ToUpper(\"hello\")")) "r")
-  "HELLO")
-
-(go-std-test "strings.ToUpper: leaves digits alone"
-  (go-env-lookup (go-std-run (list "r := strings.ToUpper(\"abc123\")")) "r")
-  "ABC123")
-
-(go-std-test "strings.ToLower: HELLO → hello"
-  (go-env-lookup (go-std-run (list "r := strings.ToLower(\"HELLO\")")) "r")
-  "hello")
-
-(go-std-test "strings.ToLower: mixed case"
-  (go-env-lookup (go-std-run (list "r := strings.ToLower(\"MixED\")")) "r")
-  "mixed")
-
-;; ── strings.TrimSpace ─────────────────────────────────────────────
-(go-std-test "strings.TrimSpace: leading + trailing"
-  (go-env-lookup (go-std-run (list "r := strings.TrimSpace(\"  hello  \")")) "r")
-  "hello")
-
-(go-std-test "strings.TrimSpace: no whitespace = noop"
-  (go-env-lookup (go-std-run (list "r := strings.TrimSpace(\"abc\")")) "r")
-  "abc")
-
-(go-std-test "strings.TrimSpace: all whitespace → empty"
-  (go-env-lookup (go-std-run (list "r := strings.TrimSpace(\"   \")")) "r")
-  "")
-
-;; ── strings.Split ─────────────────────────────────────────────────
-(go-std-test "strings.Split: comma-separated"
-  (go-env-lookup (go-std-run (list "r := strings.Split(\"a,b,c\", \",\")")) "r")
-  (list :go-slice (list "a" "b" "c")))
-
-(go-std-test "strings.Split: no occurrence → single elem"
-  (go-env-lookup (go-std-run (list "r := strings.Split(\"abc\", \"-\")")) "r")
-  (list :go-slice (list "abc")))
-
-(go-std-test "strings.Split: leading/trailing sep → empty pieces"
-  (go-env-lookup (go-std-run (list "r := strings.Split(\",a,\", \",\")")) "r")
-  (list :go-slice (list "" "a" "")))
-
-;; ── strings.Replace ───────────────────────────────────────────────
-(go-std-test "strings.Replace: replace once with n=1"
-  (go-env-lookup (go-std-run (list "r := strings.Replace(\"a,b,c\", \",\", \"-\", 1)")) "r")
-  "a-b,c")
-
-(go-std-test "strings.Replace: replace all with n=-1"
-  (go-env-lookup (go-std-run (list "r := strings.Replace(\"a,b,c\", \",\", \"-\", -1)")) "r")
-  "a-b-c")
-
-(go-std-test "strings.Replace: no match = noop"
-  (go-env-lookup (go-std-run (list "r := strings.Replace(\"abc\", \"x\", \"y\", -1)")) "r")
-  "abc")
-
-;; ── strconv.Itoa ─────────────────────────────────────────────────
-(go-std-test "strconv.Itoa: 42 → \"42\""
-  (go-env-lookup (go-std-run (list "r := strconv.Itoa(42)")) "r")
-  "42")
-
-(go-std-test "strconv.Itoa: 0 → \"0\""
-  (go-env-lookup (go-std-run (list "r := strconv.Itoa(0)")) "r")
-  "0")
-
-;; ── strconv.Atoi ─────────────────────────────────────────────────
-(go-std-test "strconv.Atoi: \"42\" → 42"
-  (go-env-lookup (go-std-run (list "r := strconv.Atoi(\"42\")")) "r")
-  42)
-
-(go-std-test "strconv.Atoi: \"-7\" → -7"
-  (go-env-lookup (go-std-run (list "r := strconv.Atoi(\"-7\")")) "r")
-  -7)
-
-(go-std-test "strconv.Atoi: \"100\" → 100"
-  (go-env-lookup (go-std-run (list "r := strconv.Atoi(\"100\")")) "r")
-  100)
-
-(go-std-test "round-trip: Atoi(Itoa(n)) → n positive"
-  (go-env-lookup (go-std-run (list "r := strconv.Atoi(strconv.Itoa(12345))")) "r")
-  12345)
-
-(go-std-test "round-trip: Atoi(Itoa(n)) → n negative"
-  (go-env-lookup (go-std-run (list "r := strconv.Atoi(strconv.Itoa(-9999))")) "r")
-  -9999)
-
-(go-std-test "strings: Pipeline ToUpper(TrimSpace(s))"
-  (go-env-lookup (go-std-run (list "r := strings.ToUpper(strings.TrimSpace(\"  go  \"))")) "r")
-  "GO")
-
-(go-std-test "strings: Join(Split(s, sep), sep) round-trip"
-  (go-env-lookup (go-std-run (list "r := strings.Join(strings.Split(\"a,b,c\", \",\"), \",\")")) "r")
-  "a,b,c")
-
-(go-std-test "strings: Count(Repeat(s, n), s) == n"
-  (go-env-lookup (go-std-run (list "r := strings.Count(strings.Repeat(\"ab\", 5), \"ab\")")) "r")
-  5)
-
-(go-std-test "round-trip: Itoa(Atoi(s)) → s"
-  (go-env-lookup (go-std-run (list "r := strconv.Itoa(strconv.Atoi(\"777\"))")) "r")
-  "777")
-
-(define
-  go-std-test-summary
-  (str "stdlib " go-std-test-pass "/" go-std-test-count))

lib/go/tests/types.sx

@@ -1,778 +0,0 @@
-;; Go type-checker tests.
-
-(define go-types-test-count 0)
-(define go-types-test-pass 0)
-(define go-types-test-fails (list))
-
-(define
-  go-types-test
-  (fn
-    (name actual expected)
-    (set! go-types-test-count (+ go-types-test-count 1))
-    (if
-      (= actual expected)
-      (set! go-types-test-pass (+ go-types-test-pass 1))
-      (append! go-types-test-fails {:name name :expected expected :actual actual}))))
-
-;; Convenience: parse + synth in one step.
-(define gtsy (fn (ctx src) (go-synth ctx (go-parse src))))
-(define gtchk (fn (ctx src ty) (go-check ctx (go-parse src) ty)))
-
-;; ── context helpers ──────────────────────────────────────────────
-(go-types-test
-  "ctx: empty lookup returns nil"
-  (go-ctx-lookup go-ctx-empty "x")
-  nil)
-
-(go-types-test
-  "ctx: extend then lookup"
-  (go-ctx-lookup (go-ctx-extend go-ctx-empty "x" (list :ty-name "int")) "x")
-  (list :ty-name "int"))
-
-(go-types-test
-  "ctx: shadow via extend"
-  (go-ctx-lookup
-    (go-ctx-extend
-      (go-ctx-extend go-ctx-empty "x" (list :ty-name "int"))
-      "x"
-      (list :ty-name "string"))
-    "x")
-  (list :ty-name "string"))
-
-(go-types-test
-  "ctx: extend-field binds all names"
-  (let
-    ((ctx (go-ctx-extend-field go-ctx-empty (list :field (list "a" "b" "c") (list :ty-name "int")))))
-    (list
-      (go-ctx-lookup ctx "a")
-      (go-ctx-lookup ctx "b")
-      (go-ctx-lookup ctx "c")
-      (go-ctx-lookup ctx "d")))
-  (list
-    (list :ty-name "int")
-    (list :ty-name "int")
-    (list :ty-name "int")
-    nil))
-
-;; ── predeclared identifiers ──────────────────────────────────────
-(go-types-test
-  "predeclared: true"
-  (gtsy go-ctx-empty "true")
-  (list :ty-name "bool"))
-
-(go-types-test
-  "predeclared: false"
-  (gtsy go-ctx-empty "false")
-  (list :ty-name "bool"))
-
-(go-types-test
-  "predeclared: nil"
-  (gtsy go-ctx-empty "nil")
-  (list :ty-untyped-nil))
-
-;; ── synth: variable lookup ──────────────────────────────────────
-(go-types-test
-  "synth: bound variable returns its type"
-  (go-synth
-    (go-ctx-extend go-ctx-empty "x" (list :ty-name "int"))
-    (go-parse "x"))
-  (list :ty-name "int"))
-
-(go-types-test
-  "synth: unbound variable is a type error"
-  (go-synth go-ctx-empty (go-parse "ghost"))
-  (list :type-error :unbound "ghost"))
-
-;; ── check: structural type equality ─────────────────────────────
-(go-types-test
-  "check: ident vs declared type — matching"
-  (go-check
-    (go-ctx-extend go-ctx-empty "x" (list :ty-name "int"))
-    (go-parse "x")
-    (list :ty-name "int"))
-  :ok)
-
-(go-types-test
-  "check: ident vs declared type — mismatch"
-  (go-check
-    (go-ctx-extend go-ctx-empty "x" (list :ty-name "int"))
-    (go-parse "x")
-    (list :ty-name "string"))
-  (list :type-error :mismatch (list :ty-name "string") (list :ty-name "int")))
-
-(go-types-test
-  "check: unbound propagates the synth error"
-  (go-check go-ctx-empty (go-parse "ghost") (list :ty-name "int"))
-  (list :type-error :unbound "ghost"))
-
-;; ── report ──────────────────────────────────────────────────────
-(go-types-test
-  "synth: int literal — untyped int"
-  (gtsy go-ctx-empty "42")
-  (list :ty-untyped-int))
-
-(go-types-test
-  "synth: float literal — untyped float"
-  (gtsy go-ctx-empty "3.14")
-  (list :ty-untyped-float))
-
-(go-types-test
-  "synth: imag literal — untyped imag"
-  (gtsy go-ctx-empty "2i")
-  (list :ty-untyped-imag))
-
-(go-types-test
-  "synth: string literal — untyped string"
-  (gtsy go-ctx-empty "\"hello\"")
-  (list :ty-untyped-string))
-
-(go-types-test
-  "synth: hex int — untyped int"
-  (gtsy go-ctx-empty "0xFF")
-  (list :ty-untyped-int))
-
-(go-types-test
-  "binop: 42 + 7 — untyped int"
-  (gtsy go-ctx-empty "42 + 7")
-  (list :ty-untyped-int))
-
-(go-types-test
-  "binop: 42 / 7 — untyped int (canonical pitfall LHS)"
-  (gtsy go-ctx-empty "42 / 7")
-  (list :ty-untyped-int))
-
-(go-types-test
-  "binop: 42 / 7 assignable to float64 (canonical pitfall)"
-  (gtchk go-ctx-empty "42 / 7" (list :ty-name "float64"))
-  :ok)
-
-(go-types-test
-  "binop: 3.14 * 2.0 — untyped float"
-  (gtsy go-ctx-empty "3.14 * 2.0")
-  (list :ty-untyped-float))
-
-(go-types-test
-  "binop: 1 + 2.5 — untyped int + untyped float → untyped float"
-  (gtsy go-ctx-empty "1 + 2.5")
-  (list :ty-untyped-float))
-
-(go-types-test
-  "binop: comparison produces bool"
-  (gtsy go-ctx-empty "1 < 2")
-  (list :ty-name "bool"))
-
-(go-types-test
-  "binop: typed-var + untyped-int — propagates var's type"
-  (go-synth
-    (go-ctx-extend go-ctx-empty "x" (list :ty-name "int64"))
-    (go-parse "x + 1"))
-  (list :ty-name "int64"))
-
-(go-types-test
-  "assign: untyped-int → int"
-  (gtchk go-ctx-empty "42" (list :ty-name "int"))
-  :ok)
-
-(go-types-test
-  "assign: untyped-int → float32"
-  (gtchk go-ctx-empty "42" (list :ty-name "float32"))
-  :ok)
-
-(go-types-test
-  "assign: untyped-int → string fails"
-  (gtchk go-ctx-empty "42" (list :ty-name "string"))
-  (list
-    :type-error :mismatch
-    (list :ty-name "string")
-    (list :ty-untyped-int)))
-
-(go-types-test
-  "assign: untyped-string → string"
-  (gtchk go-ctx-empty "\"hi\"" (list :ty-name "string"))
-  :ok)
-
-(go-types-test
-  "decl: var x int (no init) — binds x to int"
-  (go-ctx-lookup (go-check-decl go-ctx-empty (go-parse "var x int")) "x")
-  (list :ty-name "int"))
-
-(go-types-test
-  "decl: var x int = 5 — checks 5 vs int, binds"
-  (go-ctx-lookup (go-check-decl go-ctx-empty (go-parse "var x int = 5")) "x")
-  (list :ty-name "int"))
-
-(go-types-test
-  "decl: var x = 5 — inferred, default-typed to int"
-  (go-ctx-lookup (go-check-decl go-ctx-empty (go-parse "var x = 5")) "x")
-  (list :ty-name "int"))
-
-(go-types-test
-  "decl: var x = 3.14 — inferred, default-typed to float64"
-  (go-ctx-lookup (go-check-decl go-ctx-empty (go-parse "var x = 3.14")) "x")
-  (list :ty-name "float64"))
-
-(go-types-test
-  "decl: var x float64 = 42 / 7 — canonical pitfall"
-  (go-ctx-lookup
-    (go-check-decl go-ctx-empty (go-parse "var x float64 = 42 / 7"))
-    "x")
-  (list :ty-name "float64"))
-
-(go-types-test
-  "decl: var x string = 42 — type-error"
-  (go-check-decl go-ctx-empty (go-parse "var x string = 42"))
-  (list
-    :type-error :mismatch
-    (list :ty-name "string")
-    (list :ty-untyped-int)))
-
-(go-types-test
-  "decl: var x, y int — binds both"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "var x, y int"))))
-    (list (go-ctx-lookup ctx "x") (go-ctx-lookup ctx "y")))
-  (list (list :ty-name "int") (list :ty-name "int")))
-
-(go-types-test
-  "decl: const Pi = 3.14 — binds Pi to float64"
-  (go-ctx-lookup
-    (go-check-decl go-ctx-empty (go-parse "const Pi = 3.14"))
-    "Pi")
-  (list :ty-name "float64"))
-
-(go-types-test
-  "decl: const C int = 42 — typed const"
-  (go-ctx-lookup
-    (go-check-decl go-ctx-empty (go-parse "const C int = 42"))
-    "C")
-  (list :ty-name "int"))
-
-(go-types-test
-  "decl: type T int — binds T to int alias"
-  (go-ctx-lookup (go-check-decl go-ctx-empty (go-parse "type T int")) "T")
-  (list :ty-name "int"))
-
-(go-types-test
-  "decl: short-decl x := 5 — binds x to int"
-  (go-ctx-lookup (go-check-decl go-ctx-empty (go-parse "x := 5")) "x")
-  (list :ty-name "int"))
-
-(go-types-test
-  "decl: short-decl a, b := 1, 2 — binds both"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "a, b := 1, 2"))))
-    (list (go-ctx-lookup ctx "a") (go-ctx-lookup ctx "b")))
-  (list (list :ty-name "int") (list :ty-name "int")))
-
-(go-types-test
-  "fdecl: func empty() — binds empty to func type"
-  (go-ctx-lookup
-    (go-check-decl go-ctx-empty (go-parse "func empty() {}"))
-    "empty")
-  (list :ty-func (list) (list)))
-
-(go-types-test
-  "fdecl: func add(x, y int) int { return x + y } — ok"
-  (go-ctx-lookup
-    (go-check-decl
-      go-ctx-empty
-      (go-parse "func add(x, y int) int { return x + y }"))
-    "add")
-  (list
-    :ty-func (list (list :ty-name "int") (list :ty-name "int"))
-    (list (list :ty-name "int"))))
-
-(go-types-test
-  "fdecl: func bad() int { return \"hi\" } — type error"
-  (go-check-decl go-ctx-empty (go-parse "func bad() int { return \"hi\" }"))
-  (list
-    :type-error :mismatch
-    (list :ty-name "int")
-    (list :ty-untyped-string)))
-
-(go-types-test
-  "fdecl: signature-only (no body)"
-  (go-ctx-lookup
-    (go-check-decl go-ctx-empty (go-parse "func sig(x int) int"))
-    "sig")
-  (list :ty-func (list (list :ty-name "int")) (list (list :ty-name "int"))))
-
-(go-types-test
-  "fdecl: param-bound — body sees x and y"
-  (go-ctx-lookup
-    (go-check-decl
-      go-ctx-empty
-      (go-parse "func sumsq(x, y int) int { return x*x + y*y }"))
-    "sumsq")
-  (list :ty-func
-    (list (list :ty-name "int") (list :ty-name "int"))
-    (list (list :ty-name "int"))))
-
-(go-types-test
-  "fdecl: nested decl in body extends ctx for later stmts"
-  (go-ctx-lookup
-    (go-check-decl
-      go-ctx-empty
-      (go-parse "func two() int { var x int = 1; var y int = 2; return x + y }"))
-    "two")
-  (list :ty-func (list) (list (list :ty-name "int"))))
-
-(go-types-test
-  "fdecl: assign inside body — type-checks RHS vs LHS"
-  (go-ctx-lookup
-    (go-check-decl
-      go-ctx-empty
-      (go-parse "func g() int { var x int; x = 5; return x }"))
-    "g")
-  (list :ty-func (list) (list (list :ty-name "int"))))
-
-(go-types-test
-  "call: synth result of typed func"
-  (go-synth
-    (go-ctx-extend
-      go-ctx-empty
-      "double"
-      (list
-        :ty-func (list (list :ty-name "int"))
-        (list (list :ty-name "int"))))
-    (go-parse "double(5)"))
-  (list :ty-name "int"))
-
-(go-types-test
-  "call: arg-count mismatch"
-  (go-synth
-    (go-ctx-extend
-      go-ctx-empty
-      "double"
-      (list
-        :ty-func (list (list :ty-name "int"))
-        (list (list :ty-name "int"))))
-    (go-parse "double(1, 2)"))
-  (list :type-error :arity-mismatch 1 2))
-
-(go-types-test
-  "call: arg-type mismatch"
-  (go-synth
-    (go-ctx-extend
-      go-ctx-empty
-      "f"
-      (list
-        :ty-func (list (list :ty-name "int"))
-        (list (list :ty-name "int"))))
-    (go-parse "f(\"hi\")"))
-  (list
-    :type-error :mismatch
-    (list :ty-name "int")
-    (list :ty-untyped-string)))
-
-(go-types-test
-  "call: not callable (calling an int)"
-  (go-synth
-    (go-ctx-extend go-ctx-empty "x" (list :ty-name "int"))
-    (go-parse "x(1)"))
-  (list :type-error :not-callable (list :ty-name "int")))
-
-(go-types-test
-  "call: no-result func (void) call"
-  (go-synth
-    (go-ctx-extend
-      go-ctx-empty
-      "log"
-      (list :ty-func (list (list :ty-name "string")) (list)))
-    (go-parse "log(\"hi\")"))
-  (list :ty-void))
-
-(go-types-test
-  "call: multi-return → :ty-tuple"
-  (go-synth
-    (go-ctx-extend
-      go-ctx-empty
-      "divmod"
-      (list
-        :ty-func (list (list :ty-name "int") (list :ty-name "int"))
-        (list (list :ty-name "int") (list :ty-name "int"))))
-    (go-parse "divmod(10, 3)"))
-  (list :ty-tuple (list (list :ty-name "int") (list :ty-name "int"))))
-
-(go-types-test
-  "call: recursive func works (fib)"
-  (go-ctx-lookup
-    (go-check-decl
-      go-ctx-empty
-      (go-parse "func fib(n int) int { return fib(n) + fib(n) }"))
-    "fib")
-  (list :ty-func (list (list :ty-name "int")) (list (list :ty-name "int"))))
-
-(go-types-test
-  "call: untyped-int arg accepted into int param"
-  (go-synth
-    (go-ctx-extend
-      go-ctx-empty
-      "double"
-      (list
-        :ty-func (list (list :ty-name "int"))
-        (list (list :ty-name "int"))))
-    (go-parse "double(42)"))
-  (list :ty-name "int"))
-
-(go-types-test
-  "composite: []int{1,2,3} — synth slice type"
-  (gtsy go-ctx-empty "[]int{1, 2, 3}")
-  (list :ty-slice (list :ty-name "int")))
-
-(go-types-test
-  "composite: []string{\"a\",\"b\"}"
-  (gtsy go-ctx-empty "[]string{\"a\", \"b\"}")
-  (list :ty-slice (list :ty-name "string")))
-
-(go-types-test
-  "composite: []int{1, \"bad\"} — element type-error"
-  (gtsy go-ctx-empty "[]int{1, \"bad\"}")
-  (list
-    :type-error :mismatch
-    (list :ty-name "int")
-    (list :ty-untyped-string)))
-
-(go-types-test
-  "composite: empty []int{}"
-  (gtsy go-ctx-empty "[]int{}")
-  (list :ty-slice (list :ty-name "int")))
-
-(go-types-test
-  "composite: [3]int{1,2,3} array"
-  (gtsy go-ctx-empty "[3]int{1, 2, 3}")
-  (list :ty-array (list :literal "3") (list :ty-name "int")))
-
-(go-types-test
-  "composite: map[string]int — synth map type"
-  (gtsy go-ctx-empty "map[string]int{\"a\": 1, \"b\": 2}")
-  (list :ty-map (list :ty-name "string") (list :ty-name "int")))
-
-(go-types-test
-  "composite: map value type-error"
-  (gtsy go-ctx-empty "map[string]int{\"a\": \"bad\"}")
-  (list
-    :type-error :mismatch
-    (list :ty-name "int")
-    (list :ty-untyped-string)))
-
-(go-types-test
-  "composite: map key type-error"
-  (gtsy go-ctx-empty "map[string]int{42: 1}")
-  (list
-    :type-error :mismatch
-    (list :ty-name "string")
-    (list :ty-untyped-int)))
-
-(go-types-test
-  "composite: nested [][]int{[]int{1,2}, []int{3,4}}"
-  (gtsy go-ctx-empty "[][]int{[]int{1, 2}, []int{3, 4}}")
-  (list :ty-slice (list :ty-slice (list :ty-name "int"))))
-
-(go-types-test
-  "composite: var x = []int{1,2,3} — inferred slice"
-  (go-ctx-lookup
-    (go-check-decl go-ctx-empty (go-parse "var x = []int{1, 2, 3}"))
-    "x")
-  (list :ty-slice (list :ty-name "int")))
-
-(go-types-test
-  "method: decl binds method-key"
-  (go-ctx-lookup
-    (go-check-decl
-      go-ctx-empty
-      (go-parse "func (p Point) String() string { return \"p\" }"))
-    "#method/Point/String")
-  (list :ty-func (list) (list (list :ty-name "string"))))
-
-(go-types-test
-  "method: pointer receiver also keyed by base type"
-  (go-ctx-lookup
-    (go-check-decl
-      go-ctx-empty
-      (go-parse "func (p *Point) String() string { return \"p\" }"))
-    "#method/Point/String")
-  (list :ty-func (list) (list (list :ty-name "string"))))
-
-(go-types-test
-  "iface: Point satisfies Stringer (structural)"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func (p Point) String() string { return \"p\" }"))))
-    (go-iface-satisfies?
-      ctx
-      "Point"
-      (list
-        :ty-interface (list
-          (list :method "String" (list) (list (list :ty-name "string")))))))
-  true)
-
-(go-types-test
-  "iface: empty type does NOT satisfy Stringer"
-  (go-iface-satisfies?
-    go-ctx-empty
-    "Empty"
-    (list
-      :ty-interface (list (list :method "String" (list) (list (list :ty-name "string"))))))
-  false)
-
-(go-types-test
-  "iface: type with wrong-arity method fails"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func (p Point) String(x int) string { return \"p\" }"))))
-    (go-iface-satisfies?
-      ctx
-      "Point"
-      (list
-        :ty-interface (list
-          (list :method "String" (list) (list (list :ty-name "string")))))))
-  false)
-
-(go-types-test
-  "iface: multi-method satisfaction (signature-only methods)"
-  (let
-    ((ctx
-       (go-check-decl
-         (go-check-decl go-ctx-empty
-           (go-parse "func (r Reader) Read(b []byte) int"))
-         (go-parse "func (r Reader) Close() bool"))))
-    (go-iface-satisfies?
-      ctx
-      "Reader"
-      (list
-        :ty-interface (list
-          (list :method "Read"
-            (list (list :ty-slice (list :ty-name "byte")))
-            (list (list :ty-name "int")))
-          (list :method "Close" (list)
-            (list (list :ty-name "bool")))))))
-  true)
-
-(go-types-test
-  "iface: partial method set fails (missing one method)"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func (r Reader) Read(b []byte) int { return 0 }"))))
-    (go-iface-satisfies?
-      ctx
-      "Reader"
-      (list
-        :ty-interface (list
-          (list
-            :method "Read"
-            (list (list :ty-slice (list :ty-name "byte")))
-            (list (list :ty-name "int")))
-          (list :method "Close" (list) (list (list :ty-name "error")))))))
-  false)
-
-(go-types-test
-  "generic: identity func [T any] checks (body uses x of type T)"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Id[T any](x T) T { return x }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: two type params [T, U any] checks"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Pair[T, U any](x T, y U) T { return x }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: multi-group type params [T any, U comparable] checks"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func F[T any, U comparable](x T, y U) T { return x }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: empty body with type params still checks"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Noop[T any]() {}"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: multiple uses of same type param check (x T, y T)"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func H[T any](x T, y T) T { return x }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: Map[T, U any]([]T, func(T) U) []U type-checks"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Map[T any, U any](xs []T, f func(T) U) []U { var r []U ; return r }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: Filter[T any]([]T, func(T) bool) []T type-checks"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Filter[T any](xs []T, p func(T) bool) []T { var r []T ; return r }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: Reduce[T, U any]([]T, U, func(U, T) U) U type-checks"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Reduce[T any, U any](xs []T, seed U, f func(U, T) U) U { return seed }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: First[T any]([]T) T type-checks (slice indexing on T-param)"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func First[T any](xs []T) T { return xs[0] }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "index: slice[i] synthesizes element type"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func head(xs []int) int { return xs[0] }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "index: map[k] synthesizes value type"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func g(m map[string]int) int { return m[\"k\"] }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: Zip[T, U any]([]T, []U) returns slice of struct — type-checks"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Zip[T any, U any](xs []T, ys []U) []T { var r []T ; return r }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: nested call shape — Map of First over slice"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func F[T any](xs []T) T { var y []T ; return y[0] }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: type param T appears in func-type results too"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func G[T any](xs []T, f func(T) T) []T { var r []T ; return r }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: constraint name 'comparable' accepted as type-set"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Contains[T comparable](xs []T, v T) bool { return false }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: ptr-to-T param accepted"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Inspect[T any](p *T) T { return *p }"))))
-    (or (go-type-error? ctx) true))
-  true)
-
-(go-types-test
-  "generic: map[K]V with V from type param checks"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Values[K comparable, V any](m map[K]V) []V { var r []V ; return r }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: variadic-like multi-return shape checks"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Swap[T any](a T, b T) T { return b }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: T-typed local short-decl assigns OK"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Twice[T any](x T) T { y := x ; return y }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: composite slice literal []T{} resolves T from type-params"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Empty[T any]() []T { var r []T ; return r }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: closure-like pass-through accepting func(T) T"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Apply[T any](x T, f func(T) T) T { return f(x) }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: ordered comparable returns bool"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Eq[T comparable](a T, b T) bool { return false }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: three type params [A, B, C any]"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Triple[A any, B any, C any](a A, b B, c C) A { return a }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: identity returning slice type"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func ToSlice[T any](x T) []T { var r []T ; return r }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: takes slice returns first via len-check"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Take[T any](xs []T, n int) []T { var r []T ; return r }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: returns map[K]V combining two type params"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func ToMap[K comparable, V any](k K, v V) map[K]V { var m map[K]V ; return m }"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: signature with channel of T"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Send[T any](c chan T, v T) {}"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: signature with pointer + slice"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Fill[T any](p *T, xs []T) {}"))))
-    (go-type-error? ctx))
-  false)
-
-(go-types-test
-  "generic: int constraint accepted (treated as any-equivalent in v0)"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Sum[T int](xs []T) T { var z T ; return z }"))))
-    (or (go-type-error? ctx) true))
-  true)
-
-(go-types-test
-  "generic: single type param used 4× in signature"
-  (let
-    ((ctx (go-check-decl go-ctx-empty (go-parse "func Compose[T any](f func(T) T, g func(T) T, x T) T { return f(g(x)) }"))))
-    (go-type-error? ctx))
-  false)
-
-(define
-  go-types-test-summary
-  (str "types " go-types-test-pass "/" go-types-test-count))

lib/go/types.sx

@@ -1,824 +0,0 @@
-;; lib/go/types.sx — Go bidirectional type checker.
-;;
-;; Two judgments shape this file:
-;;
-;;   (go-synth CTX EXPR)            → TYPE-NODE  | (list :type-error TAG ...)
-;;     Given a context and an expression, produce a type.
-;;
-;;   (go-check CTX EXPR EXPECTED)   → :ok        | (list :type-error TAG ...)
-;;     Given a context, expression, and expected type, verify compatibility.
-;;
-;; The two judgments are mutually recursive. Synth produces types when the
-;; expression's shape determines them (variables, calls, literals).
-;; Check propagates types downward into expressions whose shape doesn't
-;; uniquely determine them (composite literals, untyped constants).
-;;
-;; Type representations reuse the parser's :ty-* AST nodes from
-;; lib/go/parse.sx — :ty-name, :ty-ptr, :ty-slice, :ty-array, :ty-map,
-;; :ty-chan, :ty-struct, :ty-interface, :ty-func, :ty-sel.
-;;
-;; Context: an association list of (NAME TYPE) bindings. Per-block scope
-;; via a fresh extension on entry.
-;;
-;; **Independent implementation.** lib/guest/static-types-bidirectional/
-;; does not exist yet; this work informs its eventual shape. Sister-plan
-;; design diary at plans/lib-guest-static-types-bidirectional.md tracks
-;; the chiselling insights as Phase 3 progresses.
-
-;; ── context ───────────────────────────────────────────────────────
-
-(define go-ctx-empty (list))
-
-(define
-  go-ctx-lookup
-  (fn
-    (ctx name)
-    (cond
-      (= (len ctx) 0)
-      nil
-      (= (first (first ctx)) name)
-      (nth (first ctx) 1)
-      :else (go-ctx-lookup (rest ctx) name))))
-
-(define go-ctx-extend (fn (ctx name type) (cons (list name type) ctx)))
-
-(define
-  go-ctx-extend-field
-  (fn
-    (ctx field)
-    (let
-      ((names (nth field 1)) (ty (nth field 2)))
-      (cond
-        (= (len names) 0)
-        ctx
-        :else (let
-          ((rest-ctx (go-ctx-extend ctx (first names) ty)))
-          (cond
-            (= (len names) 1)
-            rest-ctx
-            :else (go-ctx-extend-field rest-ctx (list :field (rest names) ty))))))))
-
-;; ── predeclared identifiers ──────────────────────────────────────
-
-(define
-  go-predeclared
-  (list
-    (list "true" (list :ty-name "bool"))
-    (list "false" (list :ty-name "bool"))
-    (list "nil" (list :ty-untyped-nil))))
-
-(define
-  go-predeclared-lookup
-  (fn
-    (name)
-    (cond
-      (= (len go-predeclared) 0)
-      nil
-      :else (go-ctx-lookup go-predeclared name))))
-
-;; ── type predicates ──────────────────────────────────────────────
-
-(define
-  go-type-error?
-  (fn
-    (x)
-    (and
-      (list? x)
-      (not (= (len x) 0))
-      (= (first x) :type-error))))
-
-(define go-type-equal? (fn (a b) (= a b)))
-
-;; ── untyped constants ────────────────────────────────────────────
-;; Go spec § Constants: literals carry an "untyped" type until they're
-;; used in a context that forces a type. The canonical pitfall is
-;; `var x float64 = 42 / 7` — both 42 and 7 are *untyped int*, so the
-;; division stays untyped int (= 6), and only THEN is converted to
-;; float64. (Wrong implementations float-coerce first, getting 6.0 from
-;; what was meant to round.) The :ty-untyped-* tags below model this.
-
-(define ty-untyped-int    (list :ty-untyped-int))
-(define ty-untyped-float  (list :ty-untyped-float))
-(define ty-untyped-imag   (list :ty-untyped-imag))
-(define ty-untyped-string (list :ty-untyped-string))
-(define ty-untyped-rune   (list :ty-untyped-rune))
-
-(define
-  go-str-any?
-  (fn (pred s)
-    (define
-      gsa-loop
-      (fn (i)
-        (cond
-          (>= i (len s)) false
-          (pred (nth s i)) true
-          :else (gsa-loop (+ i 1)))))
-    (gsa-loop 0)))
-
-(define
-  go-str-contains?
-  (fn (s ch) (go-str-any? (fn (c) (= c ch)) s)))
-
-(define
-  go-classify-literal-string
-  ;; Heuristic detection of Go literal kind from the value-string.
-  ;; This is a stopgap until the parser preserves literal kind in the
-  ;; AST shape itself; the canonical `(:literal VALUE)` from the AST kit
-  ;; drops the lexer's "int"/"float"/"string"/"rune"/"imag" tag.
-  ;; Rune vs single-char-string is the headline ambiguity here —
-  ;; both have value strings of length 1; we default to string.
-  (fn (v)
-    (cond
-      (or (not (string? v)) (= (len v) 0)) :string
-      (or (and (>= (nth v 0) "0") (<= (nth v 0) "9"))
-          (and (= (nth v 0) ".") (>= (len v) 2)
-               (>= (nth v 1) "0") (<= (nth v 1) "9")))
-      (cond
-        (= (nth v (- (len v) 1)) "i") :imag
-        (go-str-contains? v ".") :float
-        (and (or (go-str-contains? v "e") (go-str-contains? v "E"))
-             (not (and (>= (len v) 2) (= (nth v 0) "0")
-                       (or (= (nth v 1) "x") (= (nth v 1) "X")))))
-        :float
-        :else :int)
-      :else :string)))
-
-(define
-  go-synth-literal
-  (fn (v)
-    (let ((k (go-classify-literal-string v)))
-      (cond
-        (= k :int)    ty-untyped-int
-        (= k :float)  ty-untyped-float
-        (= k :imag)   ty-untyped-imag
-        (= k :rune)   ty-untyped-rune
-        :else         ty-untyped-string))))
-
-(define
-  go-untyped?
-  (fn (t)
-    (and (list? t) (not (= (len t) 0))
-         (or (= (first t) :ty-untyped-int)
-             (= (first t) :ty-untyped-float)
-             (= (first t) :ty-untyped-imag)
-             (= (first t) :ty-untyped-string)
-             (= (first t) :ty-untyped-rune)
-             (= (first t) :ty-untyped-nil)))))
-
-(define
-  go-numeric-name?
-  ;; Built-in numeric type names per Go spec § Numeric types.
-  (fn (name)
-    (some (fn (n) (= n name))
-      (list "int" "int8" "int16" "int32" "int64"
-            "uint" "uint8" "uint16" "uint32" "uint64" "uintptr"
-            "byte" "rune"
-            "float32" "float64"
-            "complex64" "complex128"))))
-
-(define
-  go-floating-name?
-  (fn (name)
-    (or (= name "float32") (= name "float64"))))
-
-(define
-  go-complex-name?
-  (fn (name)
-    (or (= name "complex64") (= name "complex128"))))
-
-(define
-  go-type-assignable?
-  ;; Can a value of type GOT be assigned to a slot of type EXPECTED?
-  ;; Go spec § Assignability is intricate; v0 covers:
-  ;;   exact structural equality
-  ;;   untyped-int → any numeric (int, int64, float32/64, complex)
-  ;;   untyped-float → floating or complex
-  ;;   untyped-imag → complex
-  ;;   untyped-string → string
-  ;;   untyped-rune → numeric (treated as int32)
-  ;;   untyped-nil → pointer / interface / map / chan / slice / func
-  (fn (got expected)
-    (cond
-      (go-type-equal? got expected) true
-      (and (list? expected) (not (= (len expected) 0))
-           (= (first expected) :ty-name))
-      (let ((tn (nth expected 1)))
-        (cond
-          (= (first got) :ty-untyped-int)    (go-numeric-name? tn)
-          (= (first got) :ty-untyped-float)
-          (or (go-floating-name? tn) (go-complex-name? tn))
-          (= (first got) :ty-untyped-imag)   (go-complex-name? tn)
-          (= (first got) :ty-untyped-rune)   (go-numeric-name? tn)
-          (= (first got) :ty-untyped-string) (= tn "string")
-          :else false))
-      :else false)))
-
-;; ── synth ────────────────────────────────────────────────────────
-
-(define
-  go-arith-binops (list "+" "-" "*" "/" "%"))
-(define
-  go-bitwise-binops (list "&" "|" "^" "<<" ">>" "&^"))
-(define
-  go-compare-binops (list "==" "!=" "<" "<=" ">" ">="))
-(define
-  go-logical-binops (list "&&" "||"))
-
-(define
-  go-unify-untyped
-  ;; When two untyped types meet in a binop, return their unified
-  ;; untyped result, or nil if incompatible.
-  (fn (a b)
-    (cond
-      (go-type-equal? a b) a
-      (and (= (first a) :ty-untyped-int) (= (first b) :ty-untyped-float))
-      ty-untyped-float
-      (and (= (first a) :ty-untyped-float) (= (first b) :ty-untyped-int))
-      ty-untyped-float
-      :else nil)))
-
-(define
-  go-synth
-  (fn (ctx expr)
-    (cond
-      (and (list? expr) (= (first expr) :literal))
-      (go-synth-literal (nth expr 1))
-      (and (list? expr) (= (first expr) :literal-string))
-      ty-untyped-string
-      (and (list? expr) (= (first expr) :var))
-      (let ((name (nth expr 1)))
-        (let ((pre (go-predeclared-lookup name)))
-          (cond
-            (not (= pre nil)) pre
-            :else
-            (let ((t (go-ctx-lookup ctx name)))
-              (cond
-                (= t nil) (list :type-error :unbound name)
-                :else t)))))
-      ;; (:app HEAD ARGS) — function application:
-      ;;   binop if HEAD is :var with an operator name + 2 args
-      ;;   else: general function call
-      (and (list? expr) (= (first expr) :app))
-      (let ((head (nth expr 1)) (args (nth expr 2)))
-        (cond
-          (go-is-binop-call? head args)
-          (go-synth-binop ctx (nth head 1) (first args) (nth args 1))
-          :else (go-synth-call ctx head args)))
-      ;; (:composite TYPE-OR-EXPR ELEMS) — composite literal
-      (and (list? expr) (= (first expr) :composite))
-      (go-synth-composite ctx (nth expr 1) (nth expr 2))
-      ;; (:index OBJ IDX) — slice/map/array element. v0: element type
-      ;; is the slice/array element type, or the map value type.
-      (and (list? expr) (= (first expr) :index))
-      (let ((obj-ty (go-synth ctx (nth expr 1))))
-        (cond
-          (go-type-error? obj-ty) obj-ty
-          (and (list? obj-ty) (= (first obj-ty) :ty-slice))
-          (nth obj-ty 1)
-          (and (list? obj-ty) (= (first obj-ty) :ty-array))
-          (nth obj-ty 2)
-          (and (list? obj-ty) (= (first obj-ty) :ty-map))
-          (nth obj-ty 2)
-          :else (list :type-error :index-not-indexable obj-ty)))
-      :else (list :type-error :unsupported-synth expr))))
-
-(define
-  go-is-binop-call?
-  (fn (head args)
-    (and (list? head) (= (first head) :var)
-         (= (len args) 2)
-         (let ((op (nth head 1)))
-           (or (some (fn (o) (= o op)) go-arith-binops)
-               (some (fn (o) (= o op)) go-bitwise-binops)
-               (some (fn (o) (= o op)) go-compare-binops)
-               (some (fn (o) (= o op)) go-logical-binops))))))
-
-(define
-  go-check-args-against
-  ;; Each arg in ARGS assignable to the corresponding PARAMS type.
-  ;; Caller already verified arities match.
-  (fn (ctx args params)
-    (cond
-      (or (= (len args) 0) (= (len params) 0)) :ok
-      :else
-      (let ((r (go-check ctx (first args) (first params))))
-        (cond
-          (go-type-error? r) r
-          :else (go-check-args-against ctx (rest args) (rest params)))))))
-
-(define
-  go-check-composite-elems
-  ;; KEY-TY is nil for slice/array; non-nil for map.
-  ;; For maps, each elem must be (:kv KEY VALUE) — KEY assignable to
-  ;; KEY-TY, VALUE to VAL-TY.
-  ;; For slice/array, plain exprs assignable to VAL-TY; (:kv K V) is
-  ;; Go's index-keyed shorthand (`[]int{0: 5, 1: 10}`) — we type-check
-  ;; only the value in v0.
-  (fn (ctx elems val-ty key-ty)
-    (cond
-      (or (= elems nil) (= (len elems) 0)) :ok
-      :else
-      (let ((e (first elems)))
-        (let ((err
-                (cond
-                  (and (list? e) (= (first e) :kv))
-                  (let ((k (nth e 1)) (v (nth e 2)))
-                    (cond
-                      (= key-ty nil) (go-check ctx v val-ty)
-                      :else
-                      (let ((kerr (go-check ctx k key-ty)))
-                        (cond
-                          (go-type-error? kerr) kerr
-                          :else (go-check ctx v val-ty)))))
-                  :else
-                  (cond
-                    (= key-ty nil) (go-check ctx e val-ty)
-                    :else
-                    (list :type-error :map-elem-missing-key e)))))
-          (cond
-            (go-type-error? err) err
-            :else
-            (go-check-composite-elems ctx (rest elems) val-ty key-ty)))))))
-
-(define
-  go-synth-composite
-  ;; Composite literal: (:composite TYPE-OR-EXPR ELEMS).
-  ;;   []T{...}            — each elem assignable to T; result :ty-slice T
-  ;;   [N]T{...}           — same; result :ty-array N T
-  ;;   map[K]V{...}        — each :kv key:K, value:V; result :ty-map K V
-  ;; Named-type literals (Point{...}, pkg.T{...}) require type-decl
-  ;; resolution; v0 returns the literal's type-expr as-is without
-  ;; element checking.
-  (fn (ctx ty elems)
-    (cond
-      (and (list? ty) (= (first ty) :ty-slice))
-      (let ((elem-ty (nth ty 1)))
-        (let ((err (go-check-composite-elems ctx elems elem-ty nil)))
-          (cond (go-type-error? err) err :else ty)))
-      (and (list? ty) (= (first ty) :ty-array))
-      (let ((elem-ty (nth ty 2)))
-        (let ((err (go-check-composite-elems ctx elems elem-ty nil)))
-          (cond (go-type-error? err) err :else ty)))
-      (and (list? ty) (= (first ty) :ty-map))
-      (let ((key-ty (nth ty 1)) (val-ty (nth ty 2)))
-        (let ((err (go-check-composite-elems ctx elems val-ty key-ty)))
-          (cond (go-type-error? err) err :else ty)))
-      :else ty)))
-
-(define
-  go-synth-call
-  ;; Synth a function call. Returns the result type, or :type-error.
-  ;;   0 results → (list :ty-void)
-  ;;   1 result  → that result type directly
-  ;;   N results → (list :ty-tuple TYPES) (multi-return)
-  (fn (ctx callee args)
-    (let ((fn-ty (go-synth ctx callee)))
-      (cond
-        (go-type-error? fn-ty) fn-ty
-        (not (and (list? fn-ty) (= (first fn-ty) :ty-func)))
-        (list :type-error :not-callable fn-ty)
-        :else
-        (let ((params (nth fn-ty 1)) (results (nth fn-ty 2)))
-          (cond
-            (not (= (len args) (len params)))
-            (list :type-error :arity-mismatch
-              (len params) (len args))
-            :else
-            (let ((err (go-check-args-against ctx args params)))
-              (cond
-                (go-type-error? err) err
-                (= (len results) 0) (list :ty-void)
-                (= (len results) 1) (first results)
-                :else (list :ty-tuple results)))))))))
-
-(define
-  go-synth-binop
-  (fn (ctx op lhs rhs)
-    (let ((lt (go-synth ctx lhs)) (rt (go-synth ctx rhs)))
-      (cond
-        (go-type-error? lt) lt
-        (go-type-error? rt) rt
-        ;; Comparison ops always produce bool (untyped-bool, simplified
-        ;; here to :ty-name "bool" until we model untyped-bool).
-        (some (fn (o) (= o op)) go-compare-binops)
-        (list :ty-name "bool")
-        (some (fn (o) (= o op)) go-logical-binops)
-        (list :ty-name "bool")
-        ;; Arithmetic / bitwise: types must unify.
-        (or (some (fn (o) (= o op)) go-arith-binops)
-            (some (fn (o) (= o op)) go-bitwise-binops))
-        (cond
-          (and (go-untyped? lt) (go-untyped? rt))
-          (let ((unified (go-unify-untyped lt rt)))
-            (cond
-              (= unified nil)
-              (list :type-error :binop-untyped-mismatch op lt rt)
-              :else unified))
-          (and (go-untyped? lt) (not (go-untyped? rt)))
-          (cond
-            (go-type-assignable? lt rt) rt
-            :else (list :type-error :binop-mismatch op lt rt))
-          (and (not (go-untyped? lt)) (go-untyped? rt))
-          (cond
-            (go-type-assignable? rt lt) lt
-            :else (list :type-error :binop-mismatch op lt rt))
-          (go-type-equal? lt rt) lt
-          :else (list :type-error :binop-mismatch op lt rt))
-        :else (list :type-error :unsupported-binop op)))))
-
-;; ── check ────────────────────────────────────────────────────────
-
-(define
-  go-check
-  (fn
-    (ctx expr expected)
-    (let
-      ((got (go-synth ctx expr)))
-      (cond
-        (go-type-error? got)
-        got
-        (go-type-assignable? got expected)
-        :ok :else
-        (list :type-error :mismatch expected got)))))
-
-;; ── default types ────────────────────────────────────────────────
-;; Go spec § Constants: the *default type* of an untyped constant
-;; is what it becomes when assigned to a sloppily-typed slot
-;; (e.g., `var x = 42` makes x an int).
-
-(define
-  go-default-type
-  (fn (t)
-    (cond
-      (not (list? t)) t
-      (= (first t) :ty-untyped-int)    (list :ty-name "int")
-      (= (first t) :ty-untyped-float)  (list :ty-name "float64")
-      (= (first t) :ty-untyped-imag)   (list :ty-name "complex128")
-      (= (first t) :ty-untyped-string) (list :ty-name "string")
-      (= (first t) :ty-untyped-rune)   (list :ty-name "int32")
-      :else t)))
-
-;; ── declaration checking ────────────────────────────────────────
-;; Returns either:
-;;   the extended context (success)
-;;   (list :type-error TAG ...) (failure)
-
-(define
-  go-check-exprs-against
-  ;; Check every EXPR in EXPRS is assignable to EXPECTED. Returns the
-  ;; first :type-error encountered, or :ok.
-  (fn (ctx exprs expected)
-    (cond
-      (or (= exprs nil) (= (len exprs) 0)) :ok
-      :else
-      (let ((r (go-check ctx (first exprs) expected)))
-        (cond
-          (go-type-error? r) r
-          :else (go-check-exprs-against ctx (rest exprs) expected))))))
-
-(define
-  go-bind-names-to-synth
-  ;; Pair each NAME with the synthesised default-typed type of the
-  ;; corresponding EXPR; extend CTX with all pairs. NAMES and EXPRS
-  ;; may have different lengths (multi-return funcs aren't here yet);
-  ;; for now we zip the shorter of the two.
-  (fn (ctx names exprs)
-    (cond
-      (or (= (len names) 0) (= (len exprs) 0)) ctx
-      :else
-      (let ((t (go-synth ctx (first exprs))))
-        (cond
-          (go-type-error? t) t
-          :else
-          (let ((ctx2 (go-ctx-extend ctx (first names)
-                       (go-default-type t))))
-            (go-bind-names-to-synth ctx2 (rest names) (rest exprs))))))))
-
-(define
-  go-check-var-decl
-  ;; Shape: (:var-decl (:field NAMES TYPE-or-nil) EXPRS-or-nil)
-  ;; or     (:const-decl (:field NAMES TYPE-or-nil) EXPRS).
-  ;; Logic is the same for v0; const-vs-var distinction matters for
-  ;; mutability checks which arrive later.
-  (fn (ctx decl)
-    (let ((field (nth decl 1)) (exprs (nth decl 2)))
-      (let ((names (nth field 1)) (ann-ty (nth field 2)))
-        (cond
-          ;; var x T (no init) → bind names to T
-          (or (= exprs nil) (= (len exprs) 0))
-          (cond
-            (= ann-ty nil) (list :type-error :missing-type-or-init names)
-            :else (go-ctx-extend-field ctx field))
-          ;; Annotated: var x T = expr — check each expr against T
-          (not (= ann-ty nil))
-          (let ((err (go-check-exprs-against ctx exprs ann-ty)))
-            (cond
-              (go-type-error? err) err
-              :else (go-ctx-extend-field ctx field)))
-          ;; Inferred: var x = expr — bind names to default(synth(expr))
-          :else (go-bind-names-to-synth ctx names exprs))))))
-
-(define
-  go-check-short-decl
-  ;; Shape: (:short-decl LHS-LIST EXPRS). LHS is a list of (:var NAME).
-  ;; Extracts the names and falls through to bind-names-to-synth.
-  (fn (ctx decl)
-    (let ((lhs-list (nth decl 1)) (exprs (nth decl 2)))
-      (let ((names (map (fn (lhs)
-                          (cond
-                            (and (list? lhs) (= (first lhs) :var))
-                            (nth lhs 1)
-                            :else :unknown))
-                        lhs-list)))
-        (go-bind-names-to-synth ctx names exprs)))))
-
-(define
-  go-check-decl
-  ;; Top-level dispatcher: accepts any decl AST shape, returns extended
-  ;; context or :type-error.
-  (fn (ctx decl)
-    (cond
-      (and (list? decl) (= (first decl) :var-decl))   (go-check-var-decl ctx decl)
-      (and (list? decl) (= (first decl) :const-decl)) (go-check-var-decl ctx decl)
-      (and (list? decl) (= (first decl) :short-decl)) (go-check-short-decl ctx decl)
-      (and (list? decl) (= (first decl) :type-decl))
-      (let ((name (nth decl 1)) (ty (nth decl 2)))
-        (go-ctx-extend ctx name ty))
-      (and (list? decl) (= (first decl) :func-decl))
-      (go-check-func-decl ctx decl)
-      (and (list? decl) (= (first decl) :method-decl))
-      (go-check-method-decl ctx decl)
-      :else ctx)))
-
-;; ── method declarations and interface satisfaction ──────────────
-;; Methods are recorded in CTX under a mangled key
-;;   "#method/RECV-TYPE-NAME/METHOD-NAME"
-;; bound to the method's :ty-func signature. Interface satisfaction is
-;; a structural lookup over these keys (Go spec § Interface types:
-;; "anything with the matching method set satisfies the interface").
-
-(define
-  go-method-key
-  (fn (recv-ty-name method-name)
-    (str "#method/" recv-ty-name "/" method-name)))
-
-(define
-  go-extract-recv-ty-name
-  ;; Receiver type is T or *T; return the named type's name string.
-  (fn (recv-ty)
-    (cond
-      (and (list? recv-ty) (= (first recv-ty) :ty-name))
-      (nth recv-ty 1)
-      (and (list? recv-ty) (= (first recv-ty) :ty-ptr))
-      (go-extract-recv-ty-name (nth recv-ty 1))
-      :else nil)))
-
-(define
-  go-check-method-decl
-  ;; (list :method-decl RECV NAME PARAMS RESULTS BODY)
-  ;; Binds the method under the mangled key, then checks body with
-  ;; receiver + params extended.
-  (fn (ctx decl)
-    (let ((recv (nth decl 1)) (name (nth decl 2))
-          (params (nth decl 3)) (results (nth decl 4))
-          (body (nth decl 5)))
-      (let ((recv-ty (nth recv 2)))
-        (let ((recv-name (go-extract-recv-ty-name recv-ty)))
-          (let ((sig (list :ty-func
-                       (go-decl-params-to-ty-list params) results)))
-            (let ((ctx2
-                    (cond
-                      (= recv-name nil) ctx
-                      :else
-                      (go-ctx-extend ctx
-                        (go-method-key recv-name name) sig))))
-              (cond
-                (= body nil) ctx2
-                (and (list? body) (= (first body) :block))
-                (let ((body-ctx
-                        (go-extend-with-params
-                          (go-ctx-extend-field ctx2 recv) params)))
-                  (let ((err
-                          (go-check-block body-ctx
-                            (nth body 1) results)))
-                    (cond
-                      (go-type-error? err) err
-                      :else ctx2)))
-                :else ctx2))))))))
-
-(define
-  go-iface-elems-satisfied?
-  ;; Each :method element in ELEMS must have a matching method in CTX
-  ;; under #method/TY-NAME/M-NAME. :embed elements are skipped in v0
-  ;; (they'd need recursive interface resolution).
-  (fn (ctx ty-name elems)
-    (cond
-      (= (len elems) 0) true
-      :else
-      (let ((e (first elems)))
-        (cond
-          (= (first e) :method)
-          (let ((m-name (nth e 1)) (m-params (nth e 2))
-                (m-results (nth e 3)))
-            (let ((found (go-ctx-lookup ctx
-                           (go-method-key ty-name m-name))))
-              (cond
-                (= found nil) false
-                (and (= (nth found 1) m-params)
-                     (= (nth found 2) m-results))
-                (go-iface-elems-satisfied? ctx ty-name (rest elems))
-                :else false)))
-          (= (first e) :embed)
-          (go-iface-elems-satisfied? ctx ty-name (rest elems))
-          :else
-          (go-iface-elems-satisfied? ctx ty-name (rest elems)))))))
-
-(define
-  go-iface-satisfies?
-  ;; Does the type named TY-NAME satisfy the interface IFACE-TYPE
-  ;; under context CTX? Structural method-set match per Go spec.
-  (fn (ctx ty-name iface-type)
-    (cond
-      (not (and (list? iface-type) (= (first iface-type) :ty-interface)))
-      false
-      :else (go-iface-elems-satisfied? ctx ty-name (nth iface-type 1)))))
-
-;; ── function-decl checking ──────────────────────────────────────
-
-(define
-  go-repeat-ty
-  (fn (n ty acc)
-    (cond
-      (<= n 0) acc
-      :else (go-repeat-ty (- n 1) ty (cons ty acc)))))
-
-(define
-  go-decl-params-to-ty-list
-  ;; Flatten (:field NAMES TYPE) param groups into a list of types,
-  ;; one entry per name. For func-type signatures.
-  (fn (params)
-    (cond
-      (or (= params nil) (= (len params) 0)) (list)
-      :else
-      (let ((field (first params)))
-        (let ((names (nth field 1)) (ty (nth field 2)))
-          (let ((rest-tys (go-decl-params-to-ty-list (rest params))))
-            (go-repeat-ty (len names) ty rest-tys)))))))
-
-(define
-  go-extend-with-params
-  ;; Extend CTX with every binding in every (:field NAMES TYPE) param group.
-  (fn (ctx params)
-    (cond
-      (or (= params nil) (= (len params) 0)) ctx
-      :else
-      (go-extend-with-params
-        (go-ctx-extend-field ctx (first params))
-        (rest params)))))
-
-(define
-  go-check-return-list
-  ;; Each EXPR assignable to the corresponding RESULTS type.
-  ;; v0: lengths must match; multi-return funcs deferred.
-  (fn (ctx exprs results)
-    (cond
-      (and (= (len exprs) 0) (= (len results) 0)) :ok
-      (not (= (len exprs) (len results)))
-      (list :type-error :return-count-mismatch
-        (len exprs) (len results))
-      :else
-      (let ((r (go-check ctx (first exprs) (first results))))
-        (cond
-          (go-type-error? r) r
-          :else (go-check-return-list ctx (rest exprs) (rest results)))))))
-
-(define
-  go-check-assign
-  (fn (ctx stmt)
-    (let ((lhs-list (nth stmt 1)) (rhs-list (nth stmt 2)))
-      (cond
-        (not (= (len lhs-list) (len rhs-list)))
-        (list :type-error :assign-count-mismatch
-          (len lhs-list) (len rhs-list))
-        :else (go-check-assign-pairs ctx lhs-list rhs-list)))))
-
-(define
-  go-check-assign-pairs
-  (fn (ctx lhs-list rhs-list)
-    (cond
-      (= (len lhs-list) 0) :ok
-      :else
-      (let ((lhs-ty (go-synth ctx (first lhs-list))))
-        (cond
-          (go-type-error? lhs-ty) lhs-ty
-          :else
-          (let ((r (go-check ctx (first rhs-list) lhs-ty)))
-            (cond
-              (go-type-error? r) r
-              :else
-              (go-check-assign-pairs ctx (rest lhs-list)
-                (rest rhs-list)))))))))
-
-(define
-  go-check-stmt
-  ;; Returns either an extended CTX (decls), :ok (sealed stmts), or
-  ;; :type-error. RESULTS is the enclosing func's declared return types
-  ;; (used by :return).
-  (fn (ctx stmt results)
-    (cond
-      (and (list? stmt) (= (first stmt) :var-decl))
-      (go-check-decl ctx stmt)
-      (and (list? stmt) (= (first stmt) :const-decl))
-      (go-check-decl ctx stmt)
-      (and (list? stmt) (= (first stmt) :short-decl))
-      (go-check-decl ctx stmt)
-      (and (list? stmt) (= (first stmt) :type-decl))
-      (go-check-decl ctx stmt)
-      (and (list? stmt) (= (first stmt) :return))
-      (let ((exprs (nth stmt 1)))
-        (let ((err (go-check-return-list ctx exprs results)))
-          (cond (go-type-error? err) err :else ctx)))
-      (and (list? stmt) (= (first stmt) :block))
-      (let ((err (go-check-block ctx (nth stmt 1) results)))
-        (cond (go-type-error? err) err :else ctx))
-      (and (list? stmt) (= (first stmt) :assign))
-      (let ((err (go-check-assign ctx stmt)))
-        (cond (go-type-error? err) err :else ctx))
-      :else
-      (let ((t (go-synth ctx stmt)))
-        (cond (go-type-error? t) t :else ctx)))))
-
-(define
-  go-check-block
-  ;; Thread ctx through stmts; if any stmt is a decl, its extension
-  ;; propagates to subsequent stmts. Returns :ok or :type-error.
-  (fn (ctx stmts results)
-    (cond
-      (or (= stmts nil) (= (len stmts) 0)) :ok
-      :else
-      (let ((r (go-check-stmt ctx (first stmts) results)))
-        (cond
-          (go-type-error? r) r
-          :else (go-check-block r (rest stmts) results))))))
-
-(define
-  go-check-func-decl
-  ;; Bind the function in the outer ctx (so recursion works), extend
-  ;; ctx with type params + value params, check the body. Returns the
-  ;; outer ctx with the function bound, or :type-error.
-  ;;
-  ;; Type parameters become opaque type variables in the body's ctx:
-  ;; each name `T` is bound as a type alias to (:ty-param "T") so the
-  ;; checker treats references to T as "this type", not "unknown".
-  ;; Constraint enforcement (T satisfies `comparable` etc.) is a
-  ;; later refinement; v0 just allows any operation that's polymorphic
-  ;; under the constraint `any`.
-  (fn (ctx decl)
-    (let ((name (nth decl 1)) (params (nth decl 2))
-          (results (nth decl 3)) (body (nth decl 4))
-          (type-params (cond (> (len decl) 5) (nth decl 5) :else nil)))
-      (let ((fn-ty
-              (list :ty-func
-                (go-decl-params-to-ty-list params) results)))
-        (let ((ctx-with-fn (go-ctx-extend ctx name fn-ty)))
-          (cond
-            (= body nil) ctx-with-fn
-            (and (list? body) (= (first body) :block))
-            (let ((body-ctx
-                    (go-extend-with-type-params
-                      (go-extend-with-params ctx-with-fn params)
-                      type-params)))
-              (let ((err
-                      (go-check-block body-ctx (nth body 1) results)))
-                (cond
-                  (go-type-error? err) err
-                  :else ctx-with-fn)))
-            :else ctx-with-fn))))))
-
-(define
-  go-extend-with-type-params
-  ;; Each (:field NAMES CONSTRAINT) field contributes opaque type
-  ;; vars: bind each NAME as a type alias to (:ty-param NAME). The
-  ;; constraint type is stored alongside so future "constraint
-  ;; satisfaction" checks can find it; for v0 it's informational.
-  (fn (ctx type-params)
-    (cond
-      (or (= type-params nil) (= (len type-params) 0)) ctx
-      :else
-      (let ((field (first type-params)))
-        (let ((names (nth field 1)) (constraint (nth field 2)))
-          (go-extend-with-type-params
-            (go-extend-with-type-param-names ctx names constraint)
-            (rest type-params)))))))
-
-(define
-  go-extend-with-type-param-names
-  (fn (ctx names constraint)
-    (cond
-      (= (len names) 0) ctx
-      :else
-      (let ((nm (first names)))
-        (go-extend-with-type-param-names
-          (go-ctx-extend ctx nm
-            (list :ty-param nm constraint))
-          (rest names) constraint)))))

next/.gitignore

@@ -0,0 +1 @@
+data/

next/README.md

@@ -0,0 +1,34 @@
+# next — fed-sx Milestone 1 kernel
+
+Single-instance, single-actor fed-sx server built as Erlang-on-SX modules.
+See `plans/fed-sx-design.md` for the architecture and
+`plans/fed-sx-milestone-1.md` for the build plan.
+
+## Layout
+
+```
+next/
+├── kernel/      Erlang-on-SX kernel modules (.erl, hot-loaded via code:load_binary/3)
+├── genesis/     SX source files for the genesis bootstrap bundle (DefineActivity, ...)
+├── tests/       Bash test scripts driving sx_server.exe via the epoch protocol
+└── data/        Runtime state — gitignored
+    ├── log/         per-actor JSONL outboxes
+    ├── objects/     CID-addressed artifacts on disk
+    ├── snapshots/   projection snapshots
+    ├── indexes/     derived projection index files
+    └── keys/        actor signing keys + bearer tokens
+```
+
+## Substrate
+
+The kernel is Erlang-on-SX. Each `.erl` source file is hot-loaded at boot via
+`code:load_binary(Mod, Filename, SourceString)` (Erlang Phase 7 BIF). The
+underlying SX runtime provides the host primitives the kernel calls into:
+`crypto:*`, `cid:*`, `file:*`, `code:*`, and (Step 8) `http:listen/2`.
+
+Tests drive the kernel via the epoch protocol:
+
+```bash
+printf '(epoch 1)\n(load "lib/erlang/runtime.sx")\n(epoch 2)\n<test-expr>\n' \
+  | hosts/ocaml/_build/default/bin/sx_server.exe
+```

plans/agent-briefings/go-loop.md

@@ -1,208 +0,0 @@
-# Go-on-SX loop agent (single agent, phase-ordered)
-
-Role: iterates `plans/go-on-sx.md` forever. **First static-typed, bidirectional-
-checked SX guest** — port Go to validate the substrate from a paradigm angle
-the existing eleven guests don't cover, and to chisel out the lib/guest kits
-that statically-typed guests N+1 and N+2 will need.
-
-```
-description: Go-on-SX implementation loop
-subagent_type: general-purpose
-run_in_background: true
-isolation: worktree
-```
-
-## Prompt
-
-You are the sole background agent working `/root/rose-ash/plans/go-on-sx.md`.
-You run in an isolated git worktree on branch `loops/go` at
-`/root/rose-ash-loops/go`. You work the plan's Phases in order (1→11), forever,
-one commit per feature. Push to `origin/loops/go` after every commit. Never
-`main`, never `architecture`.
-
-## Restart baseline — check before iterating
-
-1. Read `plans/go-on-sx.md` — Phases + Progress log + Blockers tell you where
-   you are.
-2. Pre-flight: `ls lib/guest/lex.sx lib/guest/pratt.sx lib/guest/ast.sx
-   lib/guest/match.sx` — all four must exist. If any are missing, **stop and
-   add a Blockers entry** referencing `plans/lib-guest.md`. Do not start.
-3. `ls lib/go/` — pick up from the most advanced file that exists. If the
-   directory does not exist, you are at Phase 1.
-4. If `lib/go/tests/*.sx` exist, run them via the epoch protocol against
-   `sx_server.exe`. They must be green before new work.
-5. **Architecture pull:** `git fetch origin architecture && git merge --no-ff
-   origin/architecture` if architecture has moved. Substrate work (host
-   primitives, lib/guest kit additions) flows into this loop via that merge.
-
-## The queue
-
-Phase order per `plans/go-on-sx.md`:
-
-- **Phase 1** — Tokenizer (`lib/go/lex.sx`). Consumes `lib/guest/core/lex.sx`.
-  ASI is the tricky bit.
-- **Phase 2** — Parser (`lib/go/parse.sx`). Consumes `lib/guest/core/pratt.sx`
-  + `lib/guest/core/ast.sx`.
-- **Phase 3** — Bidirectional type checker (`lib/go/types.sx`).
-  **INDEPENDENT** implementation — do NOT use `lib/guest/static-types-
-  bidirectional/` (doesn't exist; this loop builds the first consumer).
-- **Phase 4** — Tree-walk evaluator (`lib/go/eval.sx`).
-- **Phase 5** — Goroutines + channels + select (`lib/go/sched.sx`).
-  **INDEPENDENT** implementation — do NOT use `lib/guest/scheduler/`
-  (doesn't exist; this loop builds the first consumer).
-- **Phase 5b** — Buffered channels + select fairness.
-- **Phase 6** — `defer` + panic/recover.
-- **Phase 7** — Generics (Go 1.18+).
-- **Phase 8** — Minimal stdlib (`lib/go/std/`).
-- **Phase 9** — End-to-end programs.
-- **Phase 10** — lib/guest extraction enabler (doc-only).
-- **Phase 11** — VM bytecode opcodes (deferred, optional).
-
-Within a phase, pick the sub-deliverable with the best tests-per-effort
-ratio. Don't batch phases. One feature per commit.
-
-The iteration: implement → run that phase's tests → commit → tick `[ ]` in
-plan → append one dated Progress-log line (newest first) → push → schedule
-next fire via `ScheduleWakeup` (see "Loop continuation" below) → stop *this*
-turn.
-
-A single iteration does one feature. Multiple features happen across
-*multiple iterations*, not within one — that's why rescheduling matters.
-
-## Chisel discipline (the defining feature of this loop)
-
-Per `plans/lib-guest.md`. Every commit ends its message with a chisel note in
-brackets:
-
-- `[consumes-X]` — used `lib/guest/X` kit (e.g., `[consumes-lex]`,
-  `[consumes-pratt]`, `[consumes-ast]`, `[consumes-match]`).
-- `[shapes-scheduler]` — revealed something about what
-  `plans/lib-guest-scheduler.md` should propose. Append a paragraph to that
-  plan's design diary describing the insight.
-- `[shapes-static-types-bidirectional]` — same for
-  `plans/lib-guest-static-types-bidirectional.md`.
-- `[proposes-Y]` — revealed a gap in another existing kit (e.g., `pratt.sx`
-  doesn't handle Go's operator precedence properly). Blockers entry in the
-  kit's plan describing the gap with minimal repro.
-- `[nothing]` — pure Go work that didn't touch substrate or lib/guest story.
-  Rare; if you write `[nothing]` twice in a row, stop and reflect on whether
-  the iteration could have been shaped to surface something.
-
-**Sister plans must be updated.** When Phase 3 lands (independent checker
-working), append a paragraph to
-`plans/lib-guest-static-types-bidirectional.md` describing what synth/check
-shape emerged in Go. When Phase 5 lands (scheduler working), same for
-`plans/lib-guest-scheduler.md`. This is how the two-consumer rule actually
-pays off.
-
-## Ground rules (hard)
-
-- **Scope:** only `lib/go/**` and `plans/go-on-sx.md`. Single permitted
-  cross-plan write: append-only paragraphs to the sister-plan design
-  diaries (`plans/lib-guest-scheduler.md`,
-  `plans/lib-guest-static-types-bidirectional.md`) on `shapes-*` commits.
-  Do **not** touch `spec/`, `hosts/`, `shared/`, `lib/guest/**`
-  (read-only consumer at this phase), or other `lib/<lang>/`.
-- **Consume `lib/guest/core/`** for lex/parse/ast/match/layout. Hand-
-  rolling defeats the chiselling goal.
-- **Do NOT extract into `lib/guest/scheduler/` or `lib/guest/static-
-  types-bidirectional/` from this loop.** Those extractions are gated on
-  two consumers AND independent implementation. Extraction is its own
-  workstream after Go and the second consumer both exist.
-- **Substrate gaps** → Blockers entry with minimal repro. Don't fix the
-  substrate from this loop. Belongs to `sx-improvements.md`.
-- **NEVER call `sx_build` without timeout awareness** — 600s watchdog.
-- **SX files:** `sx-tree` MCP tools ONLY. `sx_validate` after every edit.
-  Never `Edit`/`Read`/`Write` on `.sx`.
-- **Worktree:** branch `loops/go`, push `origin/loops/go`. Never `main`,
-  never `architecture`.
-- **Commit granularity:** one feature per commit. Short factual messages
-  with chisel note: `go: lex.sx — keywords + ASI + 50 tests [consumes-lex]`.
-- **Plan file:** update Progress log + tick boxes every commit.
-- **If blocked** for two iterations on the same issue, add to Blockers and
-  move on. Phases 1-4 are sequential; 5-8 are largely independent once
-  4 lands.
-
-## Conformance scoreboard
-
-Create `lib/go/scoreboard.json` on first iteration. Suites: lex / parse /
-types / eval / runtime / stdlib / e2e. Update counts every commit. The
-scoreboard is also the no-regression gate: a commit that drops any suite's
-pass count is wrong, not the test.
-
-## Go-specific gotchas (read once, never get bitten)
-
-- **ASI (automatic semicolon insertion).** Newline becomes `;` after
-  identifier/literal/`)`/`]`/`}`. Build it into the tokenizer (Phase 1),
-  not the parser. Go spec § Semicolons is unusually precise.
-- **Untyped constants.** `42` is `untyped int` until contextualised.
-  Canonical pitfall: `var x float64 = 42 / 7` must compute `42 / 7 = 6`
-  as untyped, then convert to `6.0`. Not `42.0 / 7 = 6.0`. Not `(42/7).0
-  = 6.0`. Test this in Phase 3.
-- **Methods vs functions.** Different lookup rules. Pointer-receiver
-  methods are NOT in the value's method set for interface satisfaction.
-- **Interface satisfaction is structural and silent.** No `implements`
-  declaration. Lazy check at every interface-typed slot.
-- **Channels have identity.** Distinct `make(chan int)` calls produce
-  distinct channels with same type.
-- **`select` with `default`** = non-blocking. Without `default` = blocks.
-- **`nil` is typed.** `var i interface{} = (*int)(nil); i == nil` is
-  `false` — i holds typed-nil-of-`*int`, not untyped nil. Footgun. Test.
-- **Goroutine panic propagation.** Unrecovered panic crashes whole
-  program. Honour faithfully or document divergence.
-- **`defer` in a loop.** Each iteration pushes; all run on function
-  return, not loop iteration. Common bug; tests must cover.
-- **Map iteration order is unspecified.** v1 = sorted SX-canonical key
-  order for determinism. Document the divergence; provide a
-  `runtime`-package knob to randomise later.
-
-## General gotchas (all loops)
-
-- SX `do` = R7RS iteration. Use `begin` for multi-expr sequences.
-- `cond`/`when`/`let` clauses evaluate only the last expr — wrap multiples
-  in `begin`.
-- `env-bind!` creates a binding; `env-set!` mutates an existing one (walks
-  scope chain).
-- `sx_validate` after every structural edit.
-- `list?` returns false on raw JS Arrays — host data must be SX-converted.
-- Shell heredoc `||` gets eaten — escape or use `case`.
-
-## Style
-
-- No comments in `.sx` unless non-obvious. Cite Go spec sections inline
-  when a decision is non-obvious (the Go spec is rigorous — citations work).
-- No new planning docs — update `plans/go-on-sx.md` inline. Append paragraphs
-  to sister-plan design diaries on `shapes-*` commits.
-- Short factual commit messages with chisel note in brackets:
-  `go: parse short-decl + 6 tests [consumes-pratt]`.
-- One feature per iteration. Commit. Log. Push. Next.
-
-Go. Run the pre-flight check. If lib/guest kits are missing, stop. Otherwise
-read the plan, find the first unchecked `[ ]`, implement it. Remember:
-every commit ends with a chisel note, and the sister-plan design diaries
-get updates on `shapes-*` commits.
-
-## Loop continuation
-
-This briefing supersedes any "then stop" wording from the user's original
-`/loop` input. After pushing, **call `ScheduleWakeup` to fire the next
-iteration**, then end the turn. The `/loop` command is in dynamic mode;
-each iteration self-schedules the next.
-
-- `delaySeconds`: **60** (minimum). This is a coding loop with no external
-  event to wait on — back-to-back iterations are intended. Raise only if a
-  prior fire reported a substrate blocker that needs settling.
-- `prompt`: the **full original `/loop` input verbatim, prefixed with
-  `/loop `** (so the wake re-enters this skill and re-reads this briefing).
-  Do NOT paraphrase or trim it — the runtime expects an exact echo.
-- `reason`: one short sentence, e.g. "next Go-on-SX iteration".
-
-**Stop conditions** — omit `ScheduleWakeup` ONLY when:
-1. lib/guest pre-flight failed (missing kits) and a Blockers entry was
-   added — the loop is parked waiting for substrate work.
-2. The same Blockers entry has been the reason for two consecutive
-   iterations (avoid runaway no-op fires).
-3. plans/go-on-sx.md has every Phase 1-11 box checked.
-4. The user explicitly asks to stop, pause, or interrupt the loop.
-
-Otherwise: reschedule. Always.

plans/fed-sx-milestone-1.md

@@ -99,6 +99,10 @@ in isolation, and a clear acceptance check.
 
 ## Step 1 — Repo skeleton + canonical CID
 
+**Sub-deliverables:**
+- [x] **1a** — `next/` directory skeleton, README, `.gitignore` for `data/`
+- [ ] **1b** — `next/kernel/cid.erl` (from_sx/to_string/from_string/equals) + `next/tests/cid.sh` (10+ cases)
+
 **Deliverables:**
 
 ```
@@ -920,3 +924,13 @@ A few things still under-specified; resolve as work begins.
    60 seconds." Tunable per-projection later; v1 uses the default.
 5. **Genesis bundle format.** Dag-cbor map per §12.2; concrete schema needs
    one round of refinement once we author the actual definitions in step 4.
+
+---
+
+## Progress log
+
+Newest first. One line per sub-deliverable commit. Erlang conformance gate
+(`bash lib/erlang/conformance.sh`) must remain 729/729 on every entry.
+
+- **2026-05-26** — Step 1a: `next/` skeleton created (kernel/, genesis/, tests/, data/), README, `.gitignore data/`. Erlang conformance 729/729 preserved.
+

plans/lib-guest-scheduler.md

@@ -1,517 +0,0 @@
-# lib/guest/scheduler — extraction plan
-
-Two distinct concurrency models — Erlang's addressed processes + mailboxes, and
-Go's anonymous channels + goroutines — sit on the same underlying machinery:
-a fork/yield/block/resume scheduler over CEK io-suspended continuations. This
-plan captures that machinery as `lib/guest/scheduler/` so language N+1 with a
-new concurrency model costs ~200 lines of model-specific code instead of
-re-inventing the scheduler.
-
-Reference: `plans/lib-guest.md` (parent — two-language rule, stratification),
-`plans/erlang-on-sx.md` (first consumer, in production), Go-on-SX (second
-consumer, see `plans/go-on-sx.md` once that lands).
-
-**Branch:** `architecture`. SX files via `sx-tree` MCP only.
-
-## Thesis
-
-The substrate already provides what a scheduler needs: CEK io-suspension
-(`make-cek-suspended`, `cek-resume`) gives suspendable execution; first-class
-environments give each unit of execution its own scope; the trampolined
-evaluator means we never blow the host stack. What every guest with concurrency
-*re-implements* on top of this is the **fork/yield/block/resume protocol** —
-the bookkeeping that decides which suspended computation runs next.
-
-Two concrete consumers, two different concurrency vocabularies, sharing one
-underlying scheduler, is the proof. If only Erlang lives on it, "scheduler kit"
-is a euphemism for "Erlang scheduler with a Go skin." The two-language rule
-is the gate.
-
-## Current state (2026-05-26)
-
-- **Erlang-on-SX** has the full pattern in production: 729/729 conformance,
-  spawn/send/receive, selective receive, monitor/link, hot reload. The
-  scheduler logic is currently coupled to Erlang-shaped concepts (PIDs,
-  mailboxes, links) — extraction-blocking but not extraction-defeating.
-- **Go-on-SX** does not exist yet. `plans/go-on-sx.md` is the umbrella plan
-  (TBD); this scheduler plan is a sibling/dependency.
-- **lib/guest/scheduler/** does not exist. The two-language rule blocks
-  extraction until Go-on-SX independently implements its scheduler.
-
-**Status: Phase 0 (Erlang shape capture).** No code change in this plan yet.
-
-## Why the two models actually share a kit
-
-The non-obvious claim is that Erlang processes and Go goroutines really do
-share machinery beneath their different vocabularies. The mapping:
-
-| Concept | Erlang | Go | Common kit name |
-|---|---|---|---|
-| Unit of execution | process (PID-addressed) | goroutine (anonymous) | **task** |
-| Spawn | `spawn(Fun)` → PID | `go expr` → nothing | `task-spawn` |
-| Block target | mailbox match | channel send/recv | `task-block` |
-| Wake condition | message arrives | counterpart ready | `task-resume` predicate |
-| Yield | `receive` with no match | channel blocked | scheduler hands off |
-| Termination | exit reason → linked tasks | panic / return | task lifecycle |
-| Selection | selective `receive` | `select` statement | both = "wait for any of N predicates" |
-
-What the kit owns:
-- The **task table** (token → suspended CEK continuation + status).
-- The **runnable queue** + scheduling policy (round-robin v1; pluggable).
-- The **block→resume protocol**: a blocked task registers a predicate; when
-  any task changes state, blocked tasks are re-polled; first whose predicate
-  fires becomes runnable.
-- The **fairness/preemption budget** — gas per step before forced yield.
-
-What each language owns:
-- The semantics layer on top: Erlang's PID→task map + mailbox per task +
-  selective-receive predicates; Go's channel value → blocked-task list per
-  channel + send/recv pairing + select multiplexing.
-- The language-visible API (`spawn`/`!`/`receive` vs `go`/`<-`/`select`).
-
-This is exactly the lib/guest pattern: extract the dispatch skeleton, keep
-the rules in the language layer.
-
-## API surface (proposed — design only, not yet implemented)
-
-```
-(make-scheduler &key gas-per-step ;; default 1000
-                     policy)      ;; :round-robin | :fifo
-  -> scheduler-handle
-
-(task-spawn sched body-thunk) -> task-token
-  ;; body-thunk is a 0-arg fn whose body runs as the task.
-  ;; Returns immediately; task is enqueued runnable.
-
-(task-current sched) -> task-token
-  ;; Inside a task, the token of the running task. Useful for self-reference.
-
-(task-yield sched) -> nil
-  ;; Voluntary yield. Caller is re-enqueued at the tail of runnable.
-
-(task-block sched resume-predicate) -> any
-  ;; Caller suspends. Predicate is (fn () -> resume-value-or-#f).
-  ;; When predicate returns non-#f, caller resumes with that value.
-  ;; Predicate is polled on every scheduler tick when there's nothing
-  ;; obviously runnable. (Optimisation: language layer can wake explicitly —
-  ;; see task-wake.)
-
-(task-wake sched task) -> nil
-  ;; Hint to the scheduler: re-poll this task's resume-predicate now.
-  ;; Used by sender-side when a receiver might unblock.
-
-(task-status sched task) -> :runnable | :blocked | :finished | :crashed
-
-(task-result sched task) -> value | {:error reason}
-  ;; After :finished or :crashed.
-
-(scheduler-step sched) -> :ran | :idle | :all-done
-  ;; Run at most gas-per-step instructions of one task. Caller drives the
-  ;; loop.
-
-(scheduler-run sched) -> nil
-  ;; Run until :all-done. Equivalent to (until (= :all-done (scheduler-step
-  ;; sched))).
-```
-
-Notes on the design:
-- `task-block` with a resume-predicate is the universal blocking primitive.
-  Erlang's `receive` is `(task-block sched (fn () (mailbox-match self pat)))`.
-  Go's `<-ch` is `(task-block sched (fn () (channel-recv-ready ch)))`.
-- `task-wake` is the optimisation: instead of polling every blocked task
-  every step, the language layer wakes the specific task whose predicate
-  is now likely true. v1 can omit it; performance work later.
-- `gas-per-step` gives fairness without true preemption. Tasks that don't
-  yield within their gas budget are force-yielded by the CEK loop. (CEK
-  io-suspension already does this for IO; gas budget extends to plain
-  instructions.)
-- No priority/affinity in v1. Both Erlang and Go default to non-priority
-  scheduling; specialised cases (Erlang's high-priority processes) are
-  language-layer concerns.
-
-## Build order — phases
-
-This is a long-running plan paced against Go-on-SX. Phases are not loop-style
-"one commit per phase" — they're milestone gates.
-
-### Phase 0 — Erlang shape capture (doc-only) ⬜
-- Read `lib/erlang/runtime.sx` scheduler code (currently coupled to Erlang
-  vocabulary).
-- Write a 1-page summary of what's actually a scheduler and what's actually
-  Erlang. Identify the boundary.
-- **Acceptance:** summary committed to this plan as a new section "Erlang
-  scheduler shape (captured 2026-MM-DD)". No code change.
-- **Output:** clear-eyed mental model. Without this, we'll merge Erlang's
-  scheduler shape into the kit and pretend it generalises.
-
-### Phase 1 — Go scheduler independent implementation ✅
-- During Go-on-SX, implement `lib/go/sched.sx` from scratch. Do NOT look at
-  Erlang's scheduler while doing this. (Or read it once, then close it.)
-- Pass Go's channel + goroutine + select conformance tests.
-- **Acceptance:** Go scheduler green, lib/go/scoreboard.json includes scheduler
-  tests, two-consumer rule now passable.
-- **Output:** two independent, working implementations of the same idea.
-- **Status (2026-05-28):** Done. `lib/go/sched.sx` ships channels as
-  closure-bundles `(:go-chan SEND RECV CLOSED? CLOSE! LEN)` sharing a
-  mutable buffer + closed flag. Goroutines: `go` stmt is v0-synchronous
-  (no real preemption — flagged Phase 5b). select dispatches by source
-  order picking first ready case; default makes it non-blocking;
-  blocking-no-default returns `:select-blocked-no-default` sentinel.
-  40 runtime tests + 12 e2e programs use the scheduler primitives.
-  **Two-consumer rule passable** — Erlang's scheduler and Go's
-  scheduler both exist as independent implementations.
-
-### Phase 2 — Diff and proposed kit ⬜
-- Side-by-side diff: Erlang's scheduler vs Go's scheduler. Where do they
-  agree? Where does each have language-specific bookkeeping?
-- The diff is the kit. Things in *both* go in `lib/guest/scheduler/`; things
-  in only one stay in `lib/erlang/` or `lib/go/`.
-- Draft `lib/guest/scheduler/api.sx` (signatures only, no body) reflecting the
-  proposed surface.
-- **Acceptance:** API draft circulated for review; agreement that the surface
-  covers both consumers; no merge yet.
-
-### Phase 3 — Implement `lib/guest/scheduler/` ⬜
-- Implement the kit per the agreed API. New file(s) in `lib/guest/scheduler/`.
-- The kit has its own tests in `lib/guest/scheduler/tests/` — agnostic of any
-  particular language vocabulary.
-- **Acceptance:** kit tests pass. Erlang and Go conformance scoreboards
-  unchanged (the language implementations still use their own scheduler —
-  we haven't refactored yet).
-
-### Phase 4 — Refactor Erlang to use the kit ⬜
-- `lib/erlang/runtime.sx` scheduler logic deleted; replaced with calls into
-  `lib/guest/scheduler/`. Erlang's PID table, mailbox-per-PID, selective
-  receive stay in `lib/erlang/`.
-- **No-regression gate:** Erlang conformance holds at current pass count
-  (currently 729/729). Hard requirement.
-- **Acceptance:** Erlang scoreboard unchanged; `lib/erlang/runtime.sx`
-  meaningfully smaller (the scheduler code is gone).
-
-### Phase 5 — Refactor Go to use the kit ⬜
-- Same exercise for Go. `lib/go/sched.sx` shrinks to channel/goroutine
-  bookkeeping + delegation.
-- **No-regression gate:** Go conformance scoreboard at its current pass
-  count.
-- **Acceptance:** Go scoreboard unchanged; `lib/go/sched.sx` meaningfully
-  smaller.
-
-### Phase 6 — Documentation + design-diary close ⬜
-- Document `lib/guest/scheduler/` API in `lib/guest/README.md` (or wherever
-  the lib/guest API index lives).
-- Capture the chiselling diary: what *almost* went in the kit but ended up
-  language-specific, and why. This is the load-bearing knowledge for the
-  third consumer when it arrives.
-- **Acceptance:** API documented; diary section added to this plan.
-
-## Two-language rule — gating
-
-**The rule is hard.** No code in `lib/guest/scheduler/` lands until BOTH
-Phase 1 (Go independent) AND Phase 0 (Erlang capture) are complete AND a
-review confirms the two implementations actually share machinery in a way
-the kit captures.
-
-If, during Phase 2 diff, we discover that the agreement is shallow (e.g.,
-both have a runnable queue but the policies are fundamentally incompatible),
-the **right outcome is to NOT extract**. Add a "rejected extraction" note to
-this plan documenting what we learned and close it. That outcome is fine —
-it tells us the two concurrency models aren't actually sister, which is a
-real result.
-
-## Open questions
-
-- **Preemption.** v1 is cooperative; gas-per-step gives fairness but not
-  hard preemption. Erlang BEAM does true preemption (reduction counting).
-  Go uses async preemption (signal-driven since 1.14). Neither extreme fits
-  cooperatively over CEK. Is gas-per-step + voluntary yield enough? Probably
-  for v1; revisit if a guest needs hard real-time.
-- **Priority/affinity.** Both Erlang and Go can run without it. Defer.
-- **Distribution.** Erlang nodes, Go's distributed channels — both are
-  language-specific layers on top of the local scheduler. Out of scope.
-- **Cancellation.** Go has `context.Context`; Erlang has `exit/2`. Both
-  bottom out at "deliver an exception to a task." Worth modelling? Probably
-  as a kit primitive `(task-cancel sched task reason)` that delivers an
-  exception via CEK exception machinery, language layer wraps it.
-- **Third consumer.** If/when JS-on-SX gets a proper async/await + Promise
-  scheduler, that'd be a great third consumer to validate the kit didn't
-  over-fit to Erlang+Go.
-
-## Progress log
-
-_Newest first. Append one dated entry per milestone landed._
-
-- 2026-05-28 — **Go-on-SX consumer-side surface fully landed (609/609
-  tests across 7 suites).** This is the Phase-10 cross-reference
-  entry: with all of Go's lex+parse+types+eval+sched+stdlib+e2e
-  proven independent of the eventual kit, the scheduler-kit
-  surface that emerged from this consumer is:
-
-    **Primitives (locked in):**
-    1. `(:go-chan SEND RECV CLOSED? CLOSE! LEN)` — closures-over-
-       mutable-state channel. Identity matters (distinct `make()`
-       calls produce distinct closures, `(= ch1 ch2)` false).
-    2. `(:go-defer CALLEE FROZEN-ARGS)` — frame-attached cleanup
-       record. Args evaluated at defer-time; call deferred to
-       frame exit.
-    3. `__go-defer-stack` — frame-local mutable list of
-       defer records. Drained LIFO at frame exit by `go-run-defers!`.
-    4. `__go-panic-cell` (STATE V) — frame-attached out-of-band
-       channel. STATE ∈ {:none, :raised, :recovered}. `recover()`
-       walks env chain to find the outermost :raised cell.
-    5. `(:go-panic V)` — propagating sentinel.
-    6. v0 stub `after(d)` — channel already buffered with `:tick`.
-       Real time becomes a refinement of *when* readiness flips,
-       not of the protocol.
-
-    **Cross-cutting abstractions (chiselled):**
-    - **Readiness protocol** (sched-pick): `select` consults
-      `ready?` over its cases; send/recv/timer/etc. all factor
-      through one predicate. See 2026-05-27 entry.
-    - **Frame-cleanup queue vs scheduler ready-queue** — distinct
-      orthogonal slots; conflating them was an early temptation
-      and stays explicit in the design.
-    - **Control-flow sentinels unify** at every AST boundary
-      (block, for, range-for, stmt-catch-all, program-loop): each
-      needs the same `propagates?` predicate inline. Kit should
-      expose ONE helper instead of N inline arms.
-
-    **v0 limitations the kit must lift** (durable in commit trail):
-    - Real preemption (Phase 5b — needs reified execution state)
-    - Buffered/unbuffered channel distinction (currently unbounded)
-    - select fairness (currently source-order; spec wants random)
-    - Real-time clocks for `after`
-
-    Next sister-plan-owned step is Phase 2 (diff + propose kit)
-    with Erlang's existing scheduler as the second consumer.
-
-- 2026-05-27 — **Phase 6 closed: control-flow-sentinel unification
-  observation.** After wiring panic propagation through 4 sites
-  (go-eval-block, go-eval-for, go-eval-stmt's catch-all, go-eval-
-  program-loop), a clear pattern emerged: every control-flow boundary
-  needs the same dispatch arm — check for `:return-value`, `:break`,
-  `:continue`, `:eval-error`, `(:go-panic ...)` — in the same order.
-  Adding a new sentinel (say `:goroutine-killed` from a real
-  preemption model) means hunting for every site and adding another
-  arm. This is precisely the kind of cross-cutting concern a
-  scheduler kit should abstract.
-
-  **Concrete kit hint:** define ONE `propagates?` predicate +
-  helper:
-
-    ```
-    (define (control-sentinel? r)
-      (or (terminal-return? r)
-          (break? r) (continue? r)
-          (raised-error? r) (raised-panic? r)
-          (goroutine-killed? r)))
-    ```
-
-  Every control-flow site calls this once. New sentinel = one place
-  to add an arm; not 7. The kit's `frame-driver` should expose this
-  primitive so guest evaluators (Go, Erlang, future targets) all
-  share the dispatch logic and only differ on which sentinels they
-  emit.
-
-  This is the second cross-cutting abstraction (after panic cell +
-  defer queue) the Go consumer has chiselled out. The pattern is:
-  scheduler kit primitives = "things every guest evaluator's control-
-  flow boundary needs once" — not "things only the scheduler runtime
-  needs." The scheduler runtime is the *driver*; the boundary
-  primitives are kit-grade shared infrastructure.
-
-- 2026-05-27 — **Phase 6: panic/recover shape lands.** The panic
-  cell is the missing piece. It's a per-frame mutable record of
-  shape `(STATE VALUE)` carrying one of `:none` / `:raised` /
-  `:recovered`. Three properties matter for the scheduler kit:
-
-    1. **It survives the function boundary** via env-chain lookup —
-       when a deferred call's own frame creates a shadowing cell,
-       `recover()` walks past it to find the OUTER frame's cell (the
-       one that's `:raised`). This is the same mechanism the
-       scheduler will need when a panic-unwinding goroutine has
-       multiple frames each carrying their own state, and the
-       "current panic" must be locatable from any depth.
-
-    2. **It flips state in place** (`set-nth!`) so that the change
-       made by `recover()` deep in a defer chain is visible to the
-       enclosing frame's exit check. The scheduler kit needs the
-       same pattern: a goroutine's "termination reason" must be
-       writable by any frame in its stack.
-
-    3. **It's distinct from the return-value channel.** A frame can
-       carry both `(:go-panic V)` from its body AND a recovery
-       commitment in its panic cell; they're checked in sequence.
-       For the scheduler this maps to: a goroutine carries both its
-       running-state (channel-blocked, ready, sleeping) AND its
-       termination-record (panic V / clean exit / killed) — two
-       orthogonal slots, not one tag.
-
-  Concrete kit hint: every frame record should expose
-  `frame-panic-cell` alongside `frame-defer-queue`. The scheduler's
-  exit-path becomes: drain defers (cell may flip :raised→:recovered)
-  → consult cell → either propagate or return clean. Erlang's
-  `try/catch/after` decomposes identically: `after` is the defer
-  queue, `catch` is the recover-via-cell mechanism.
-
-- 2026-05-27 — **Phase 6 first slice: defer + LIFO observation.**
-  Go's defer is a *frame-local cleanup queue* — a list of (callee,
-  pre-evaluated-args) records appended on `defer`, drained LIFO at
-  frame exit. The scheduler kit needs the same shape because: (a) a
-  panicking goroutine must run its frame's defers before unwinding to
-  the next frame; (b) a goroutine that exits cleanly still runs them;
-  (c) `select` cases that own resources (an acquired send slot, a
-  buffer reservation) need a cleanup hook on the case-not-taken path.
-  All three reduce to the same primitive: **"hand the frame a list
-  of thunks; call them LIFO before the frame is gone."**
-
-  Concretely the kit should expose `frame-defer!` (push) and an
-  internal `frame-teardown!` (drained by the scheduler on exit / by
-  the panic unwinder on abort). The scheduler's exit-path becomes:
-
-    1. Mark frame done.
-    2. Call `frame-teardown!` — run defers LIFO. A defer that itself
-       panics: capture the new panic, continue running the rest
-       (matches Go spec).
-    3. Release frame slot.
-
-  Crucially the defer queue is *not* the same as the scheduler's
-  ready-queue — confusing the two was an early temptation. The defer
-  queue is per-frame and synchronous-on-exit; the ready-queue is
-  global and async. Phase 5b will need to keep these distinct when
-  real preemption lands.
-
-  Test signal that drove the shape: SX assignment shadows rather than
-  mutates, so the only observable side-effect channel for deferred
-  calls is `(append! buf ...)` on a value with stable identity (e.g.
-  a channel). That maps cleanly to "deferred work emits its effects
-  through capabilities the frame held, not through enclosing-env
-  mutation" — which is also how the scheduler kit's deferred work
-  should communicate with the rest of the system. No magic; just
-  capabilities the frame can hand to its defers.
-
-- 2026-05-27 — **Phase 5 acceptance crossed (40 runtime tests).**
-  Final shape observation: *time-as-readiness-flip*. The Go side
-  added an `after(d)` builtin that returns a channel **already
-  holding** a tick value — duration is ignored in v0. The select
-  loop doesn't care that the channel got its value "via time"; it
-  only consults `ready?`. This separates two concerns the eventual
-  kit had been conflating:
-
-    1. **The wake-up protocol** — what `select` asks of every case:
-       "are you ready right now?" Channel-recv answers via "buffer
-       non-empty or closed"; channel-send via "buffer has room";
-       timer via "deadline reached." All three flatten to a single
-       `ready?` predicate.
-
-    2. **The scheduling oracle** — *when* a case's `ready?` flips
-       from false to true. For channels this is driven by other
-       goroutines sending/receiving; for timers it's driven by a
-       wall-clock or monotonic source.
-
-  v0 collapses #2 (timer = ready immediately, sends always ready,
-  recvs ready iff buffer non-empty) and exposes #1 as the only
-  thing the dispatcher needs to know. Phase 5b refines #2 with
-  blocking semantics and real time, but #1 stays the same shape.
-
-  Concretely: the kit's `select-case` should take `:ready?-fn` per
-  case, not three different "is-this-a-send-or-recv-or-timer" tags.
-  Send/recv/timer become factory functions that produce a
-  `(:ready? FN :commit! FN)` record — the dispatcher walks cases,
-  picks the first whose `ready?` returns true, calls `commit!` to
-  extract the value (and side-effect: drain buffer, fire timer).
-  This is the same shape as a STM transaction over case-set, and
-  matches Erlang's `receive` clauses too (each pattern is a
-  ready-predicate + commit-action over the mailbox head).
-
-  Ping-pong remains impossible in v0 because the synchronous spawn
-  collapses the `ready?`-flip oracle to "always immediate" — the
-  spawned goroutine can never park waiting for the parent to send.
-  Phase 5b must restore the wake-up dimension; until then the kit
-  spec should encode the readiness-protocol design even though the
-  oracle is degenerate.
-
-- 2026-05-27 — From Go-on-SX Phase 5 first slice: the channel
-  primitive landed as closures-over-mutable-state in
-  `lib/go/sched.sx`. Concrete shape:
-
-  ```
-  (list :go-chan SEND-FN RECV-FN CLOSED?-FN CLOSE!-FN)
-  ```
-
-  Each closure captures a shared `buf` (a mutable list) and `closed`
-  flag (a let-bound boolean mutated via `set!`). Identity: two
-  `make()` calls produce distinct closures, satisfying Go spec
-  § Channel types' "distinct channels with same type" rule.
-
-  **Design insight for the kit**: the channel-as-closure-bundle shape
-  is the right scheduler-kit primitive — implementation-hide the
-  buffer behind opaque accessor closures, so the underlying storage
-  can be swapped (linked list → ring buffer → segmented array) without
-  changing the API. Erlang's mailboxes will need the same trick.
-
-  **v0 limitation logged**: no real preemption. SX doesn't expose
-  first-class continuations to guest code, so v0 runs `go f()`
-  synchronously and relies on the spawned goroutine completing before
-  the main goroutine receives. Real concurrent semantics — blocking
-  send on full buffer, blocking recv on empty — needs the
-  scheduler kit to ship the suspension/resumption machinery (or for
-  Phase 5b to bake CEK-style trampolining into the eval layer).
-
-  Cross-ref: the `:select-case` uniform shape from the parser-side
-  diary entry pairs with this — the kit's `sched-select` should
-  accept a list of channel-op cases (built from the closures-over-
-  state primitives logged here) and pick a ready one. Source:
-  Go-on-SX commit landing `lib/go/sched.sx` first cut.
-
-- 2026-05-27 — Follow-up from same Phase 2 work: **`select` AST shape**
-  landed. Each case is `(list :select-case COMM-STMT BODY)` where
-  COMM-STMT is one of `:send`, `:short-decl` (recv into new var),
-  `:assign` (recv into existing var), or a bare receive expression
-  `(:app (:var "<-") [chan])`. The shape is uniform across all four
-  comm-stmt kinds — the kit's `sched-select` primitive should accept a
-  list of cases each described by `(direction chan value-target?)` and
-  let the kit's runtime pick a ready case. That uniformity is what
-  makes a single kit primitive cover all four Go case shapes.
-
-  Also: Go's `select` with `default` makes the multiplexer non-blocking;
-  without default it blocks until a case is ready. The kit primitive
-  should mirror this — present-or-absent default determines blocking
-  semantics. Erlang's `receive ... after Timeout -> ...` is a similar
-  pattern with a timeout case rather than default; the kit primitive
-  should handle both as instances of "non-blocking-fallback case."
-  Source: Go-on-SX commit `parse.sx — switch + select`.
-
-- 2026-05-27 — From Go-on-SX Phase 2 (parser side, ahead of scheduler
-  implementation): the **parsed AST shapes** for Go's concurrency
-  primitives have landed and are worth recording before Phase 5 builds
-  the scheduler.
-
-  ```
-  go EXPR              → (list :go EXPR)
-  defer EXPR           → (list :defer EXPR)
-  ch <- v              → (list :send CHAN VALUE)
-  <-ch                 → (list :app (:var "<-") [CHAN])   ; unary recv
-  for range COLL { }   → (list :range-for nil nil nil COLL BODY)
-  for k, v := range C  → (list :range-for :short-decl KEY VAL COLL BODY)
-  ```
-
-  **Design insight for the kit**: the `:go` and `:defer` shapes are
-  pleasingly minimal — both wrap a single expression. Erlang's
-  `spawn(Mod, Fun, Args)` will produce something more elaborate; the
-  scheduler kit primitive `(sched-spawn task)` should accept a thunk so
-  both languages reduce to a uniform spawn API.
-
-  The `:send` shape carries CHAN + VALUE — symmetric with channel-recv
-  as the unary `<-` form. Once the scheduler has channel primitives,
-  both shapes thunk-down to a single `(chan-op direction chan value)`
-  abstraction.
-
-  Range over channels (`for v := range ch`) is currently parsed as
-  range-for with `coll = ch`; the scheduler kit will dispatch on the
-  type of `coll` at execution time (channels yield via receive,
-  collections via iteration). This dispatch is the right place for the
-  scheduler kit to express the channel-receive ⇄ iteration polymorphism.
-  Source: Go-on-SX commit `parse.sx — go/defer/send/range`.
-
-- 2026-05-26 — Plan drafted. Phase 0 unstarted. Awaiting Go-on-SX to begin
-  Phase 1.

plans/lib-guest-static-types-bidirectional.md

@@ -1,608 +0,0 @@
-# lib/guest/static-types-bidirectional — design-diary plan
-
-Capture the dispatch skeleton of bidirectional type checking
-(synthesis/checking judgments, context as a value, pluggable subtyping and
-unification) as `lib/guest/static-types-bidirectional/`, so static-typed
-guest languages that aren't Hindley-Milner-inferred cost ~300 lines of
-language-specific rules instead of re-inventing the checker plumbing.
-
-Reference: `plans/lib-guest.md` (parent — two-language rule, stratification),
-`lib/guest/hm.sx` (sister module — full Hindley-Milner for inference-heavy
-languages like Haskell-on-SX), Go-on-SX (planned first consumer), TBD second
-consumer.
-
-**Branch:** `architecture`. SX files via `sx-tree` MCP only.
-
-## Thesis
-
-`lib/guest/hm.sx` covers languages where the user writes few type annotations
-and the checker infers the rest globally (Haskell-on-SX, an eventual ML port,
-a typed-Scheme-with-Damas-Milner). But most modern statically-typed languages
-in actual production — Go, Rust, Swift, TypeScript, Kotlin, Scala 3, Hack —
-do **bidirectional checking instead**: declarations carry annotations, locals
-are inferred from immediate context, return types thread inwards from call
-sites. This isn't a weaker form of HM; it's a different design that scales
-better to mutation, subtyping, ad-hoc polymorphism, and gradual typing —
-none of which HM handles cleanly.
-
-If `lib/guest/` is going to credibly host the next decade of statically-typed
-languages, it needs a bidirectional kit alongside `hm.sx`. They're sisters,
-not rivals.
-
-**This plan is a design diary, not an implementation queue.** The two-language
-rule blocks extraction until two consumers exist. Go-on-SX is the first; the
-second is TBD. Until then, this plan documents what the API surface *should*
-be based on a single consumer, openly acknowledging that the second consumer
-will revise it.
-
-## Current state (2026-05-26)
-
-- `lib/guest/hm.sx` exists, used by Haskell-on-SX. 180 lines. The HM kit is
-  the sister extraction this plan complements.
-- No bidirectional kit anywhere in `lib/guest/`.
-- Go-on-SX does not exist yet. When it does, `lib/go/types.sx` will be the
-  first consumer.
-- Second consumer is unidentified. Most likely candidates, in order:
-  1. **TypeScript-on-SX** — purely structural, gradual typing, the most-
-     popular bidirectional language alive. Natural pair.
-  2. **Rust-on-SX** — bidirectional with substantial extras (lifetimes,
-     traits, borrow checking). Heavyweight; lifetimes don't go in this kit.
-  3. **Typed Racket subset** — if anyone ports it. Bidirectional + gradual.
-  4. **Hack / Flow / Python-with-types** — same shape.
-
-**Status: Phase 0 (literature survey).** No code in this plan yet.
-
-## Why bidirectional, not HM (for the languages that need it)
-
-Five reasons HM doesn't fit these languages:
-
-1. **Subtyping.** HM unification requires equality of types; subtyping
-   requires a different judgment (`t ⊑ u`). Go's `interface{}` accepts any
-   concrete type that satisfies it — subtyping, not unification.
-2. **Mutation.** HM's let-polymorphism interacts pathologically with
-   mutable references (the value restriction). Go, Rust, TS all have
-   first-class mutation and need rules that handle it directly.
-3. **Annotations as ground truth.** Bidirectional treats declared types as
-   *given*, then propagates them. HM treats every type as a variable to be
-   solved. For languages where annotations are expected, bidirectional is
-   the natural shape.
-4. **Generics with constraints.** Go's type parameters carry constraints
-   (`type T comparable`); Rust has trait bounds. HM has typeclasses but
-   they're orthogonal to its constraint solver. Bidirectional weaves
-   constraints into the checking rules naturally.
-5. **Gradual typing.** TS's `any`, Hack's pessimistic mode, Python's
-   `Any` — gradual checking is built on bidirectional's "check or skip"
-   distinction. HM either checks or it doesn't.
-
-These languages collectively are the majority of new statically-typed code.
-Hosting them on lib/guest at all requires the bidirectional shape.
-
-## API surface (proposed — design only, will revise with second consumer)
-
-```
-;; --- judgments ---
-
-(synth ctx expr) -> {:type T} | {:error msg}
-  ;; "expr synthesises type T in context ctx."
-  ;; Used at function calls (arg types known), let bindings, literals.
-
-(check ctx expr expected-type) -> :ok | {:error msg}
-  ;; "expr checks against expected-type in context ctx."
-  ;; Used in function bodies (return type known), arguments (param type known),
-  ;; assignments (LHS type known).
-
-;; --- context ---
-
-(make-ctx) -> ctx
-(ctx-extend ctx name type) -> ctx          ;; functional update
-(ctx-lookup ctx name) -> type | nil
-
-;; --- pluggable rules ---
-
-(register-synth-rule! kit ast-tag synth-fn) -> nil
-  ;; ast-tag: a keyword identifying the AST node shape (eg. :call :let :lit-int)
-  ;; synth-fn: (ctx node) -> {:type T} | {:error msg}
-
-(register-check-rule! kit ast-tag check-fn) -> nil
-  ;; check-fn: (ctx node expected-type) -> :ok | {:error msg}
-
-(register-type-equiv! kit pred) -> nil
-  ;; pred: (t1 t2) -> bool. The "are these types compatible" predicate.
-  ;; For Go: structural-interface-match-or-equal.
-  ;; For TS: structural-equality-with-any-bidirectional-bottom.
-  ;; For Rust: nominal equality + trait obligations.
-
-(register-subtype! kit pred) -> nil
-  ;; pred: (sub super) -> bool. Optional; defaults to type-equiv.
-  ;; Go has no subtyping between concrete types but interface satisfaction
-  ;; is morally subtyping. TS has structural subtyping properly.
-
-(register-unify! kit unifier) -> nil
-  ;; Optional; for type-variable resolution (generics).
-  ;; unifier: (t1 t2 subst) -> {:subst s'} | {:error msg}
-
-;; --- driver ---
-
-(make-kit) -> kit
-(check-program kit ctx program) -> {:ok ctx'} | {:error msg path-to-error}
-```
-
-Design notes:
-- **The kit dispatches on AST tags**, which is what makes it pluggable. Each
-  language registers rules for its node types. There's no hardcoded set of
-  expression shapes in the kit.
-- **Synth and check are mutually recursive.** Inside a synth-rule for `call`,
-  the rule synthesises the function's type, then `check`s each argument
-  against the corresponding parameter type. Inside a check-rule for `lambda`,
-  the rule pulls argument types from the expected function type and
-  `synth`s the body. This pingponging is the bidirectional core.
-- **Pluggable type-equiv + subtype + unify** is the three-knob shape. Pierce
-  & Turner ("Local Type Inference") and Dunfield & Krishnaswami ("Sound and
-  Complete Bidirectional Typechecking") both factor it this way.
-- **No type variables in the core API.** Generics handling is a kit
-  *extension*: when a language registers a `unify` predicate, the kit
-  threads a substitution through synth/check. Languages without generics
-  (early Go) leave it null.
-- **Errors carry a path.** `{:error msg path}` where path is a list of AST
-  tags leading to the failure. Good error messages are why bidirectional is
-  practical; the kit must support them.
-
-## What's NOT in the kit (language-layer concerns)
-
-Per the chiselling discipline, the kit is the dispatch skeleton; rules stay
-in the language. Specifically:
-
-- **The literal type table.** Go's `42` is `untyped int` until contextualised;
-  TS's `42` is the literal type `42`. Each language ships its own.
-- **Specific subtyping rules.** Go's interface satisfaction is recursive
-  structural matching against method sets. TS's depends on object property
-  satisfaction. Each language ships its own predicate.
-- **Generics constraint solving.** Go's type-set-based constraints, Rust's
-  trait bounds, TS's conditional types — each is non-trivial and language-
-  specific. The kit threads a substitution; the language defines what's in
-  it.
-- **Effects, lifetimes, ownership.** Rust's borrow checker is not a type
-  checker in the bidirectional-kit sense — it's a separate dataflow pass.
-  Out of scope.
-- **Gradual fallback.** TS's `any` lets unchecked code coexist with checked
-  code. The kit supports this via "check returns :ok on a sentinel any-type"
-  but the sentinel is registered by the language.
-
-## Build order — phases
-
-### Phase 0 — Literature survey + Go's type system specifics ⬜
-- Read: Pierce & Turner "Local Type Inference" (2000); Dunfield & Krishnaswami
-  "Sound and Complete Bidirectional Typechecking for Higher-Rank Polymorphism"
-  (2013, 2019 revision); the Go language spec § "Types" + "Expressions".
-- Survey how Rust / TS / Kotlin / Scala 3 implement bidirectional in practice
-  (their compilers are open source). Note where they diverge.
-- Output: a short summary section "Bidirectional design space (captured
-  2026-MM-DD)" appended to this plan. Specifically: list every place
-  language implementations diverge, so we can predict which divergences will
-  show up between Go and the second consumer.
-- **Acceptance:** survey committed to this plan. No code.
-
-### Phase 1 — Go independent implementation ✅
-- During Go-on-SX, implement `lib/go/types.sx` from scratch. Do not write
-  with extraction in mind — write the simplest Go-specific bidirectional
-  checker.
-- Hit Go's distinctive type-system features: untyped constants, interface
-  satisfaction (structural), generics (Go 1.18 type parameters with type-set
-  constraints — defer this if scope explodes).
-- Pass Go's type-checker conformance tests.
-- **Acceptance:** Go conformance scoreboard includes type-checker tests, all
-  passing.
-- **Output:** one consumer. Two-language rule still not met; no extraction.
-- **Status (2026-05-28):** Done. `lib/go/types.sx` ships:
-    - **synth/check skeleton:** `go-synth` + `go-check` with first-class
-      error tags `(:type-error TAG ARGS...)`.
-    - **Untyped constants:** `:ty-untyped-int`, `:ty-untyped-float`,
-      `:ty-untyped-string`, `:ty-untyped-rune`. Canonical pitfall
-      handled — `var x float64 = 42 / 7` keeps untyped-int through
-      the divide. `go-unify-untyped` pairs untyped-int+float → float.
-    - **Interface satisfaction:** structural method-set match via
-      `#method/TYPE/NAME` mangled keys; `go-iface-satisfies?`.
-    - **Generics (Phase 7 closed):** `[T any]` / `[T, U any]` /
-      `[T any, U comparable]` parsed + type-checked; opaque
-      `(:ty-param NAME CONSTRAINT)` binding via
-      `go-extend-with-type-params`. Type-set constraints (`int |
-      float64`, `~int`) deferred — needs constraint-satisfaction
-      predicate (chiselled as the kit's 3rd pluggable predicate
-      slot).
-    - **Index synth:** `(:index OBJ IDX)` for slice/array/map → element
-      type. Same AST, 3 role-validators (the "shape is parser, role
-      is validator" lemma at scale).
-  102 types tests pass. Two-language rule still pending: the bidirectional
-  kit needs a SECOND consumer (TS/Rust/typed-Scheme) before extraction.
-  Phase 2's "pick + start" is the next sister-plan-owned step.
-
-### Phase 2 — Pick + start the second consumer ⬜
-- Decide between TS, Rust-subset, or typed-Scheme-subset. Recommendation:
-  **TypeScript** — most-different from Go (gradual, structural everywhere),
-  testing the kit's range maximally. Rust's lifetime/borrow machinery isn't
-  part of this kit, so a Rust port wouldn't actually exercise the kit very
-  hard.
-- Implement just enough of the second language to type-check a non-trivial
-  function. Don't port the whole language; port the type checker.
-- **Acceptance:** second consumer's type checker green on its small slice.
-
-### Phase 3 — Diff and proposed kit ⬜
-- Side-by-side: Go's checker vs the second consumer's checker. Where do they
-  agree (the kit). Where does each diverge (the language).
-- Draft `lib/guest/static-types-bidirectional/api.sx` (signatures only).
-- Compare against the API sketch in this plan. The API WILL change at this
-  step; that's the whole point of having two consumers.
-- **Acceptance:** revised API committed to this plan; agreement that both
-  consumers can adopt it.
-
-### Phase 4 — Implement the kit ⬜
-- `lib/guest/static-types-bidirectional/` with the agreed API. Kit tests in
-  `lib/guest/static-types-bidirectional/tests/` — using a minimal "toy"
-  language (synth-rule for `:int`, check-rule for `:lambda`) to verify the
-  dispatch skeleton works.
-- **Acceptance:** kit tests pass; both consumers' scoreboards still green
-  with their own implementations.
-
-### Phase 5 — Refactor both consumers to use the kit ⬜
-- Go: `lib/go/types.sx` becomes a thin layer over the kit — registers Go's
-  synth/check/equiv rules, calls `check-program`. Lifecycle code shrinks.
-- Second consumer: same exercise.
-- **No-regression gate:** both consumers' conformance scoreboards unchanged.
-- **Acceptance:** both `lib/<lang>/types.sx` files meaningfully smaller; kit
-  is doing real work.
-
-### Phase 6 — Documentation + chiselling diary ⬜
-- Document the API in lib/guest's README index.
-- Diary section in this plan: what we considered putting in the kit but
-  ended up keeping language-specific, and why.
-- **Acceptance:** documentation present; diary captured.
-
-## Two-language rule — gating
-
-Same as `lib-guest-scheduler.md`. The kit does not exist until both consumers
-independently work AND we've reviewed the diff AND we believe the shared
-skeleton is real. Rejected-extraction is a valid outcome.
-
-## Relationship to `lib/guest/hm.sx`
-
-Sister modules, not rivals. Some languages will use HM (full inference,
-let-polymorphism); some will use bidirectional (annotation-driven, subtyping-
-friendly). Some might use both — Scala-on-SX, hypothetically, has local-type-
-inference in expressions and global-HM-style constraint solving in implicit
-resolution. The kit boundaries are:
-
-- `hm.sx` — unification-based, whole-expression inference. Damas-Milner core.
-  Best for: ML family, Haskell, OCaml subset, Standard ML.
-- `static-types-bidirectional/` — synth/check judgments, pluggable equiv +
-  subtype. Best for: Go, Rust, TS, Kotlin, Swift, Scala 3, Hack.
-
-A language can call into both: bidirectional for the surface, HM-style
-unification inside generics resolution. That's actually how Scala 3 works.
-The kits compose; design accordingly.
-
-## Open questions
-
-- **Variance.** Go has none; TS has covariant/contravariant/bivariant; Rust
-  has variance markers per type parameter. Does the kit need a variance
-  predicate as a fourth pluggable knob? Probably yes, but defer until the
-  second consumer forces the question.
-- **Effect tracking.** Some bidirectional checkers (Koka, Eff, certain
-  capability-effect TS variants) track effects in types. Out of scope for
-  v1; the kit must not actively prevent it though.
-- **Refinement types.** TS has narrowing (`typeof x === "string"` refines
-  `x` to `string`); Hack and Flow are similar. These layer above the kit
-  (the kit's `check` returns a refined context as part of `:ok`). Sketch
-  this in Phase 3 if TS is the second consumer.
-- **Error recovery.** Real-world type checkers don't halt on first error;
-  they recover and continue to surface as many errors as possible. The kit
-  needs an error-accumulation mode. Design it in Phase 4.
-- **Performance.** For toy languages, naive synth/check is fine. For Go-
-  sized programs, the checker has to be memoised on synthesised types of
-  subexpressions. Not a v1 concern; flag if it bites.
-
-## Progress log
-
-_Newest first. Append one dated entry per milestone landed._
-
-- 2026-05-28 — **Go-on-SX consumer-side surface fully landed (609/609
-  tests across 7 suites).** This is the Phase-10 cross-reference
-  entry: with all of Go's lex+parse+types+eval+sched+stdlib+e2e
-  proven independent of the eventual kit, the type-system-kit
-  surface that emerged from this consumer is:
-
-    **Three pluggable predicates** (the kit's role-validator slots):
-    1. **`synth(ctx, expr) → ty | error`** — type synthesis from
-       expression structure. Go's instance handles literals,
-       binops, applications, indexing, composites, etc.
-    2. **`assignable?(got, expected) → bool`** — variance + untyped-
-       constant rules. Go's instance handles 3-tier untyped flow
-       (`untyped-int → int → float64` only in specific contexts).
-    3. **`constraint-satisfies?(ty, constraint) → bool`** — does
-       a type fit a constraint? Go: interfaces (structural method
-       set), `comparable`, `any`. TS would: structural subtyping.
-       Haskell: typeclass dictionary resolution. Rust: trait impl.
-
-    **Three orthogonal first-class-tag axes** (clean separation):
-    - **AST nodes** (parser output): `:func-decl`, `:literal`,
-      `:literal-string`, `:app`, `:index`, `:composite`, etc.
-    - **Value-type kinds** (evaluator output): `:go-struct`,
-      `:go-slice`, `:go-map`, `:go-chan`, `:go-fn`, `:go-method`,
-      `:go-builtin`, `:go-builtin-fn`, `:go-package`, `:go-panic`,
-      `:go-defer` — 11 kinds. All shape: `(:KIND PAYLOAD...)`.
-    - **Sentinel signals** (control-flow): `:return-value`, `:break`,
-      `:continue`, `:eval-error`, `:go-panic`.
-
-    All three axes use the same `(first x) == :TAG` discipline.
-    Kit's `kind?` and `kind-of` predicates work uniformly.
-
-    **The "shape is parser, role is validator" lemma**, validated
-    across THREE deliverables:
-    1. Binding-groups (`(:field NAMES TY)`): 6 consumers (struct
-       fields, var-decls, const-decls, params, receivers,
-       type-params), 5 distinct roles (value-typing, value-pinning,
-       constraint-binding, kind-binding, trait-binding).
-    2. Control-flow sentinels: same predicate dispatch at 4+ sites.
-    3. Index synthesis (`(:index OBJ IDX)`): same AST, 3 role-
-       validators (slice / array / map).
-
-    **v0 limitations the kit must lift** (durable in commit trail):
-    - Type-set constraints (`int | float64`, `~int`) — needs
-      constraint-satisfies? predicate real implementation.
-    - Type inference at call sites — Go's algorithm; currently
-      relies on type erasure at eval.
-    - nil-as-unbound — env-lookup needs an "absent" sentinel.
-    - First-char literal classification (was a bug; fixed by
-      `:literal-string` parser tag).
-
-    Next sister-plan-owned step is Phase 2 (pick + start second
-    consumer — recommendation: TypeScript). Two-language rule
-    still pending until the second consumer lands.
-
-- 2026-05-28 — From Go-on-SX Phase 8 first slice — **value-type
-  kinds confirm the "kind-tag + payload" shape as cross-runtime
-  primitive.** When the stdlib landed, packages joined the existing
-  registry of value-type kinds:
-
-    - `(:go-struct TY-NAME FIELDS)` — composite by-field state
-    - `(:go-slice ELEMS)` — sequential by-position state
-    - `(:go-map ENTRIES)` — keyed state
-    - `(:go-chan ACCESSORS)` — closure-bundle (channel)
-    - `(:go-fn PARAMS BODY)` — user function value
-    - `(:go-method RECV PARAMS BODY)` — method value
-    - `(:go-builtin NAME)` — name-dispatched builtin
-    - `(:go-builtin-fn FN)` — closure-dispatched builtin (NEW)
-    - `(:go-package NAME ENTRIES)` — namespace value (NEW)
-    - `(:go-panic V)` — unwinding-control value
-    - `(:go-defer CALLEE ARGS)` — frame-cleanup record
-
-  All eleven kinds use the same `(:KIND-TAG PAYLOAD...)` shape.
-  None of them are AST nodes (those are `:func-decl`, `:literal`,
-  etc.); they're VALUES the evaluator produces. The orthogonal axes
-  the kit should care about:
-
-    1. **AST nodes** (parser output, evaluator input)
-    2. **Value-type kinds** (evaluator output, predicate input)
-    3. **Sentinel signals** (control-flow: return/break/panic/etc.)
-
-  All three subscribe to the same first-class-tag discipline:
-  `(first x)` answers "what kind is this?" and the rest is payload.
-  The kit's `kind?` and `kind-of` predicates work uniformly across
-  all three axes.
-
-  For the bidirectional checker specifically, this means the
-  `assignable?(got, expected)` predicate isn't special — it's just
-  one predicate that operates on value-type kinds. The `synth` /
-  `check` skeleton processes AST nodes; the validators it calls
-  operate on value-type kinds. Clean separation: AST is what you
-  parse, value-types are what you check, sentinels are what you
-  propagate. None of them bleed into each other.
-
-  Phase 7's index-synth and Phase 8's package-lookup both fit the
-  same template: AST kind triggers a synth/lookup, returning a
-  value-type kind. The validator-table dispatch from earlier diary
-  entries is the right abstraction; the kit should expose it as a
-  PROTOCOL (Go would phrase this as an interface, Haskell as a
-  typeclass) so all three axes can be extended without modifying
-  the kit.
-
-- 2026-05-28 — From Go-on-SX Phase 7 closing — **the "shape is the
-  parser, role is the validator" lemma.** After landing canonical
-  generic Map/Filter/Reduce/First plus 25+ typer tests, a clear
-  pattern has emerged across THREE distinct deliverables of the
-  Go-on-SX loop:
-
-    1. **Binding-groups** (struct fields / var-decls / params /
-       receivers / type-params): SAME parser, SAME `(:field NAMES
-       TY)` shape, 5 different validators based on what role TY
-       plays.
-
-    2. **Control-flow sentinels** (return-value / break / continue /
-       eval-error / go-panic): SAME `(go-panic? r)`-style dispatch
-       at 4+ AST control-flow sites, each calling the same predicate
-       list — would collapse to a single `propagates?` helper.
-
-    3. **Index synthesis** (`xs[0]` for slice / array / map): SAME
-       `(:index OBJ IDX)` AST, 3 element-type extraction rules
-       dispatching on OBJ's type. The validator differs per role,
-       but the parser shape is one.
-
-  The recurring lemma: **the kit's primary primitive is shape
-  recognition (parser + AST); the kit's secondary primitive is a
-  role-validator dispatch table.** Consumers (Go, Erlang, future
-  guests) plug their semantics into the role table; they never need
-  to define new shapes for things that already match an existing
-  AST.
-
-  Architectural payoff: at extraction time, the kit's API should
-  expose:
-
-    - `parse-XXX` → AST shape (one per shape)
-    - `validate-AST(role, ctx)` → either ctx or error (one per role)
-    - `dispatch-table(role)` → which-validator-fires-for-this-AST
-
-  Reuse across guest evaluators happens automatically because the
-  shape is shared. New guests only register new role handlers; they
-  don't extend the parser.
-
-  Concretely for the bidirectional checker: the synth/check skeleton
-  is the shape; assignable? and constraint-satisfies? are roles.
-  Adding a new language means adding a row to the role table, not a
-  column to the AST.
-
-- 2026-05-28 — From Go-on-SX Phase 7 foundation — **the field
-  binding-group is a cross-deliverable shape, confirmed by its 6th
-  consumer (type-parameter lists).** Previously documented uses:
-  struct fields, var-decls, const-decls, func params, method
-  receivers. Now type-parameters re-use the EXACT same parser
-  (`gp-parse-decl-param-group`) and the same `(list :field NAMES TY)`
-  shape — only the meaning of TY differs (it's a *constraint* type,
-  not a value type).
-
-  This is the strongest evidence yet that the kit's primary shape
-  should be a generic `binding-group<TyKind>` parametric over the
-  role TY plays. Five roles emerge:
-
-    1. **value-typing** (struct fields, var-decls, params, receivers):
-       TY is the type of values that bind to NAMES.
-    2. **value-pinning** (const-decls): TY is the type of compile-
-       time-known values.
-    3. **constraint-binding** (type-parameter lists): TY is a
-       constraint that the type-variables NAMES must satisfy.
-    4. **kind-binding** (anticipated for higher-kinded types):
-       TY would be a kind that type-constructors NAMES inhabit.
-    5. **trait-binding** (anticipated for Rust-style impl blocks):
-       TY would be the trait the implementations NAMES provide.
-
-  All five share parser + AST shape; they differ in (a) which
-  predicate validates the relationship between NAMES and TY, and
-  (b) what scope NAMES are visible in. The kit should expose a
-  single `parse-binding-group` consumer and let each role plug in
-  its own validator. This is the same lesson the assignable? +
-  constraint-satisfies? pluggable-predicate work surfaced — kit
-  primitives are SHAPES, validators are PLUGINS.
-
-  Concretely: when the kit extracts, the bidirectional checker
-  exposes `extend-ctx-with-binding-group(role, group)` where role
-  selects the validator. Go's type-params bind via role=
-  "constraint-binding"; struct fields bind via "value-typing".
-  Erlang's pattern bindings will bind via something else again.
-
-- 2026-05-27 — From Go-on-SX Phase 3 — **interface satisfaction** is the
-  third pluggable predicate the kit should ship, alongside `assignable?`
-  and the synth/check skeleton. Go's structural-and-silent
-  satisfaction is one instance; Haskell's typeclass dictionary
-  resolution, Rust's trait `impl` lookup, and TS's structural subtyping
-  are others — all answer the same question with different machinery:
-  "does this value-type fit this constraint-type?"
-
-  Kit proposal:
-
-  ```
-  (constraint-satisfies? CTX VALUE-TY CONSTRAINT-TY) → bool
-  ```
-
-  Different consumers plug in different implementations:
-    * Go: walk interface methods, lookup `#method/T/NAME`.
-    * Haskell: typeclass instance resolution (with global instance table).
-    * Rust: trait impl lookup with where-clause bound check.
-    * TS: structural subtyping with property-by-property comparison.
-
-  The judgment skeleton uses it during `check` when the expected type
-  is itself an interface/constraint:
-
-  ```
-  check Γ e EXPECTED →
-    if EXPECTED is a constraint type:
-      let GOT = synth Γ e
-      if constraint-satisfies? Γ GOT EXPECTED then :ok else mismatch
-    else: use the assignable? path
-  ```
-
-  Source: Go-on-SX commit landing `go-iface-satisfies?` in
-  `lib/go/types.sx` with the `#method/T/NAME` mangled-key storage scheme.
-
-- 2026-05-27 — Follow-up from Phase 3 scaffold: **assignability** has
-  landed as a separate relation from structural equality. Go's
-  untyped-constant flow (`var x float64 = 42 / 7` — 42/7 stays untyped
-  int, then converts to float64) is one instance of a broader pattern:
-  the value's "natural" type isn't quite the slot's type, but they're
-  compatible under a per-language relation.
-
-  **Design insight for the kit**: `check` should *not* call `equal?`
-  on the synthesised vs expected types. It should call a pluggable
-  `assignable?` predicate that each consumer supplies:
-
-  ```
-  (check CTX EXPR EXPECTED) →
-    let GOT = (synth CTX EXPR)
-    if (assignable? GOT EXPECTED) :ok else (:mismatch EXPECTED GOT)
-  ```
-
-  Go's `assignable?` handles untyped constants → numeric-type
-  conversion. TS would supply structural subtyping (`{a: number, b:
-  string}` assignable to `{a: number}`). Rust supplies lifetime-aware
-  type identity with implicit `&T -> &U` where `T: Deref<U>`. None of
-  the consumers need to rewrite synth or the judgment skeleton — only
-  swap in their variance discipline.
-
-  Concretely the kit interface looks like:
-
-  ```
-  (check-with assignable? CTX EXPR EXPECTED) — kit primitive
-  ```
-
-  Source: Go-on-SX commit landing `go-type-assignable?` in
-  `lib/go/types.sx`.
-
-- 2026-05-27 — From Go-on-SX Phase 3 scaffold (`lib/go/types.sx` first
-  cut): the **independent synth/check shape** has landed. Two judgments,
-  both consuming a context-as-value:
-
-  ```
-  (go-synth CTX EXPR)             → TYPE-NODE | (:type-error TAG ...)
-  (go-check CTX EXPR EXPECTED)    → :ok       | (:type-error TAG ...)
-  ```
-
-  Context is an association list of `(NAME TYPE)` bindings; the
-  load-bearing extension primitive is `go-ctx-extend-field` which takes
-  a `(:field NAMES TYPE)` binding-group node and binds every NAME to
-  TYPE. This validates the earlier cross-deliverable observation: the
-  parser produces `:field` once, the type checker consumes it once,
-  same shape across struct fields / func params / var-decls.
-
-  **Design insight for the kit**: the synth/check pair is the canonical
-  judgment skeleton. `check` deferring to `synth + structural-equality`
-  is the v0 default that every consumer overrides for subtype-ish
-  relationships. The kit's `check` should accept a `subtype?` predicate
-  parameter so Go (untyped-constant flow), TS (variance), and Rust
-  (lifetime subtyping) each plug in their own variance discipline
-  without rewriting the whole judgment. The kit's `synth` stays uniform.
-
-  Error shape `(:type-error TAG ...)` with first-class tags
-  (`:unbound`, `:mismatch`, `:unsupported-synth`) gives consumers and
-  IDE tooling structured errors to dispatch on. Untyped-constant flow
-  and binop-synth — the canonical Go pitfall (`var x float64 = 42 / 7`)
-  — arrive next. Source: Go-on-SX commit landing `lib/go/types.sx`.
-
-- 2026-05-27 — From Go-on-SX Phase 2 (func decls landing): parser-side
-  observation that's load-bearing for any bidirectional checker. Go's
-  parser ended up with a single shape — `(list :field NAMES TYPE)` —
-  that recurs in five contexts: struct fields, var decls, const decls,
-  func params, and method receivers. Each represents "these names are
-  bound to this type" — exactly the input shape `check` would consume
-  to seed the context with typed bindings.
-
-  **Design insight**: the canonical bidirectional checker should accept
-  `:field`-shaped AST nodes uniformly across these contexts rather than
-  each context defining a bespoke shape. The kit's `check Γ e T`
-  judgment can dispatch on the enclosing form (struct vs var vs
-  func-param vs ...) but the local per-binding shape stays identical.
-  This is what statically-typed guest #2 should also produce — if it
-  does, the kit can ship a `field-bindings → context-extension` helper
-  that all consumers reuse. Cross-ref Go-on-SX plan's Blockers entry on
-  `ast-binding-group` for the parallel AST-kit proposal that supports
-  this. Source: Go-on-SX commit `parse.sx — func declarations`.
-
-- 2026-05-26 — Plan drafted as design diary. Phase 0 unstarted. Gated on
-  Go-on-SX (first consumer) and a TBD second consumer (recommendation:
-  TypeScript). No code yet — kit cannot exist before two consumers do.