Fix edge cases: 864/870 JS full, 747/747 standard, 679/679 Python

- Fix deftype tests: use (list ...) instead of bare (...) for type
  bodies in dict literals. CEK evaluates dict values, so bare lists
  are treated as function calls. Tree-walk was more permissive.
- Fix dotimes macro: use for-each+range instead of named-let+set!
  (named-let + set! has a scope chain issue under CEK env-merge)
- Remaining 6 failures are CEK multi-shot continuation limitations:
  k invoked multiple times, scope/provide across shift boundaries.
  These need frame copying for multi-shot support (future work).

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

.gitignore

@@ -11,3 +11,6 @@ build/
 venv/
 _snapshot/
 _debug/
+sx-haskell/
+sx-rust/
+shared/static/scripts/sx-full-test.js

RESTRUCTURE_PLAN.md

@@ -0,0 +1,91 @@
+# Restructure Plan
+
+Reorganise from flat `shared/sx/ref/` to layered `spec/` + `hosts/` + `web/` + `sx/`.
+
+Recovery point: commit `1a3d7b3` on branch `macros`.
+
+## Phase 1: Directory structure
+Create all directories. No file moves.
+```
+spec/tests/
+hosts/python/
+hosts/javascript/
+web/adapters/
+web/tests/
+web/platforms/python/
+web/platforms/javascript/
+sx/platforms/python/
+sx/platforms/javascript/
+```
+
+## Phase 2: Spec files (git mv)
+Move from `shared/sx/ref/` to `spec/`:
+- eval.sx, parser.sx, primitives.sx, render.sx
+- cek.sx, frames.sx, special-forms.sx
+- continuations.sx, callcc.sx, types.sx
+Move tests to `spec/tests/`:
+- test-framework.sx, test.sx, test-eval.sx, test-parser.sx
+- test-render.sx, test-cek.sx, test-continuations.sx, test-types.sx
+Remove boundary-core.sx from spec/ (it's a contract doc, not spec)
+
+## Phase 3: Host files (git mv)
+Python host - move from `shared/sx/ref/` to `hosts/python/`:
+- bootstrap_py.py → hosts/python/bootstrap.py
+- platform_py.py → hosts/python/platform.py
+- py.sx → hosts/python/transpiler.sx
+- boundary_parser.py → hosts/python/boundary_parser.py
+- run_signal_tests.py, run_cek_tests.py, run_cek_reactive_tests.py,
+  run_continuation_tests.py, run_type_tests.py → hosts/python/tests/
+
+JS host - move from `shared/sx/ref/` to `hosts/javascript/`:
+- run_js_sx.py → hosts/javascript/bootstrap.py
+- bootstrap_js.py → hosts/javascript/cli.py
+- platform_js.py → hosts/javascript/platform.py
+- js.sx → hosts/javascript/transpiler.sx
+
+Generated output stays in place:
+- shared/sx/ref/sx_ref.py (Python runtime)
+- shared/static/scripts/sx-browser.js (JS runtime)
+
+## Phase 4: Web framework files (git mv)
+Move from `shared/sx/ref/` to `web/`:
+- signals.sx → web/signals.sx
+- engine.sx, orchestration.sx, boot.sx → web/
+- router.sx, deps.sx, forms.sx, page-helpers.sx → web/
+Move adapters to `web/adapters/`:
+- adapter-dom.sx → web/adapters/dom.sx
+- adapter-html.sx → web/adapters/html.sx
+- adapter-sx.sx → web/adapters/sx.sx
+- adapter-async.sx → web/adapters/async.sx
+Move web tests to `web/tests/`:
+- test-signals.sx, test-aser.sx, test-engine.sx, etc.
+Move boundary-web.sx to `web/boundary.sx`
+Move boundary-app.sx to `web/boundary-app.sx`
+
+## Phase 5: Platform bindings
+Web platforms:
+- Extract DOM/browser primitives from platform_js.py → web/platforms/javascript/
+- Extract IO/server primitives from platform_py.py → web/platforms/python/
+App platforms:
+- sx/sxc/pages/helpers.py → sx/platforms/python/helpers.py
+- sx/sxc/init-client.sx.txt → sx/platforms/javascript/init.sx
+
+## Phase 6: Update imports
+- All Python imports referencing shared.sx.ref.*
+- Bootstrapper paths (ref_dir, _source_dirs, _find_sx)
+- Docker volume mounts in docker-compose*.yml
+- Test runner paths
+- CLAUDE.md paths
+
+## Phase 7: Verify
+- Both bootstrappers build
+- All tests pass
+- Dev container starts
+- Website works
+- Remove duplicate files from shared/sx/ref/
+
+## Notes
+- Generated files (sx_ref.py, sx-browser.js) stay where they are
+- The runtime imports from shared.sx.ref.sx_ref — that doesn't change
+- Only the SOURCE .sx files and bootstrapper tools move
+- Each phase is a separate commit for safe rollback

_config/dev-sh-config.yaml

@@ -0,0 +1,86 @@
+root: "/rose-ash-wholefood-coop"  # no trailing slash needed (we normalize it)
+host: "https://rose-ash.com"
+base_host: "wholesale.suma.coop"
+base_login: https://wholesale.suma.coop/customer/account/login/
+base_url: https://wholesale.suma.coop/
+title: sx-web
+market_root: /market
+market_title: Market
+blog_root: /
+blog_title: all the news
+cart_root: /cart
+app_urls:
+  blog: "https://blog.rose-ash.com"
+  market: "https://market.rose-ash.com"
+  cart: "https://cart.rose-ash.com"
+  events: "https://events.rose-ash.com"
+  federation: "https://federation.rose-ash.com"
+  account: "https://account.rose-ash.com"
+  sx: "https://sx.rose-ash.com"
+  test: "https://test.rose-ash.com"
+  orders: "https://orders.rose-ash.com"
+cache:
+  fs_root: /app/_snapshot  # <- absolute path to your snapshot dir
+categories:
+  allow:
+    Basics: basics
+    Branded Goods: branded-goods
+    Chilled: chilled
+    Frozen: frozen
+    Non-foods: non-foods
+    Supplements: supplements
+    Christmas: christmas
+slugs:
+  skip:
+    - ""
+    - customer
+    - account
+    - checkout
+    - wishlist
+    - sales
+    - contact
+    - privacy-policy
+    - terms-and-conditions
+    - delivery
+    - catalogsearch
+    - quickorder
+    - apply
+    - search
+    - static
+    - media
+section-titles:
+    - ingredients
+    - allergy information
+    - allergens
+    - nutritional information
+    - nutrition
+    - storage
+    - directions
+    - preparation
+    - serving suggestions
+    - origin
+    - country of origin
+    - recycling
+    - general information
+    - additional information
+    - a note about prices
+
+blacklist:
+  category:
+    - branded-goods/alcoholic-drinks
+    - branded-goods/beers
+    - branded-goods/ciders
+    - branded-goods/wines
+  product:
+    - list-price-suma-current-suma-price-list-each-bk012-2-html
+  product-details:
+    - General Information
+    - A Note About Prices
+sumup:
+  merchant_code: "ME4J6100"
+  currency: "GBP"
+  # Name of the environment variable that holds your SumUp API key
+  api_key_env: "SUMUP_API_KEY"
+  webhook_secret: "jfwlekjfwef798ewf769ew8f679ew8f7weflwef"
+
+

dev-sx.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Dev mode for sx_docs only (standalone, no DB)
+# Bind-mounted source + auto-reload on externalnet
+# Browse to sx.rose-ash.com
+#
+# Usage:
+#   ./dev-sx.sh              # Start sx_docs dev
+#   ./dev-sx.sh down          # Stop
+#   ./dev-sx.sh logs          # Tail logs
+#   ./dev-sx.sh --build       # Rebuild image then start
+
+COMPOSE="docker compose -p sx-dev -f docker-compose.dev-sx.yml"
+
+case "${1:-up}" in
+  down)
+    $COMPOSE down
+    ;;
+  logs)
+    $COMPOSE logs -f sx_docs
+    ;;
+  *)
+    BUILD_FLAG=""
+    if [[ "${1:-}" == "--build" ]]; then
+      BUILD_FLAG="--build"
+    fi
+    $COMPOSE up $BUILD_FLAG
+    ;;
+esac

docker-compose.dev-sx.yml

@@ -0,0 +1,60 @@
+# Standalone dev mode for sx_docs only
+# Replaces ~/sx-web production stack with bind-mounted source + auto-reload
+# Accessible at sx.rose-ash.com via Caddy on externalnet
+
+services:
+  sx_docs:
+    image: registry.rose-ash.com:5000/sx_docs:latest
+    environment:
+      SX_STANDALONE: "true"
+      SECRET_KEY: "${SECRET_KEY:-sx-dev-secret}"
+      REDIS_URL: redis://redis:6379/0
+      WORKERS: "1"
+      ENVIRONMENT: development
+      RELOAD: "true"
+      SX_USE_REF: "1"
+      SX_BOUNDARY_STRICT: "1"
+      SX_DEV: "1"
+    volumes:
+      - /root/rose-ash/_config/dev-sh-config.yaml:/app/config/app-config.yaml:ro
+      - ./shared:/app/shared
+      - ./sx/app.py:/app/app.py
+      - ./sx/sxc:/app/sxc
+      - ./sx/bp:/app/bp
+      - ./sx/services:/app/services
+      - ./sx/content:/app/content
+      - ./sx/sx:/app/sx
+      - ./sx/path_setup.py:/app/path_setup.py
+      - ./sx/entrypoint.sh:/usr/local/bin/entrypoint.sh
+      - ./sx/__init__.py:/app/__init__.py:ro
+      # sibling models for cross-domain SQLAlchemy imports
+      - ./blog/__init__.py:/app/blog/__init__.py:ro
+      - ./blog/models:/app/blog/models:ro
+      - ./market/__init__.py:/app/market/__init__.py:ro
+      - ./market/models:/app/market/models:ro
+      - ./cart/__init__.py:/app/cart/__init__.py:ro
+      - ./cart/models:/app/cart/models:ro
+      - ./events/__init__.py:/app/events/__init__.py:ro
+      - ./events/models:/app/events/models:ro
+      - ./federation/__init__.py:/app/federation/__init__.py:ro
+      - ./federation/models:/app/federation/models:ro
+      - ./account/__init__.py:/app/account/__init__.py:ro
+      - ./account/models:/app/account/models:ro
+      - ./relations/__init__.py:/app/relations/__init__.py:ro
+      - ./relations/models:/app/relations/models:ro
+      - ./likes/__init__.py:/app/likes/__init__.py:ro
+      - ./likes/models:/app/likes/models:ro
+      - ./orders/__init__.py:/app/orders/__init__.py:ro
+      - ./orders/models:/app/orders/models:ro
+    networks:
+      - externalnet
+      - default
+    restart: unless-stopped
+
+  redis:
+    image: redis:7-alpine
+    restart: unless-stopped
+
+networks:
+  externalnet:
+    external: true

hosts/javascript/bootstrap.py

@@ -16,13 +16,13 @@ import os
 import sys
 
 _HERE = os.path.dirname(os.path.abspath(__file__))
-_PROJECT = os.path.abspath(os.path.join(_HERE, "..", "..", ".."))
+_PROJECT = os.path.abspath(os.path.join(_HERE, "..", ".."))
 if _PROJECT not in sys.path:
     sys.path.insert(0, _PROJECT)
 
 from shared.sx.parser import parse_all
 from shared.sx.types import Symbol
-from shared.sx.ref.platform_js import (
+from hosts.javascript.platform import (
     extract_defines,
     ADAPTER_FILES, ADAPTER_DEPS, SPEC_MODULES, SPEC_MODULE_ORDER, EXTENSION_NAMES,
     PREAMBLE, PLATFORM_JS_PRE, PLATFORM_JS_POST,
@@ -44,7 +44,7 @@ def load_js_sx() -> dict:
     if _js_sx_env is not None:
         return _js_sx_env
 
-    js_sx_path = os.path.join(_HERE, "js.sx")
+    js_sx_path = os.path.join(_HERE, "transpiler.sx")
     with open(js_sx_path) as f:
         source = f.read()
 
@@ -77,7 +77,13 @@ def compile_ref_to_js(
     from datetime import datetime, timezone
     from shared.sx.ref.sx_ref import evaluate
 
-    ref_dir = _HERE
+    ref_dir = os.path.join(_PROJECT, "shared", "sx", "ref")
+    # Source directories: core spec, web framework, and legacy ref (for bootstrapper tools)
+    _source_dirs = [
+        os.path.join(_PROJECT, "spec"),      # Core spec
+        os.path.join(_PROJECT, "web"),        # Web framework
+        ref_dir,                              # Legacy location (fallback)
+    ]
     env = load_js_sx()
 
     # Resolve adapter set
@@ -106,10 +112,9 @@ def compile_ref_to_js(
         spec_mod_set.add("deps")
         if "page-helpers" in SPEC_MODULES:
             spec_mod_set.add("page-helpers")
-    # CEK needed for reactive rendering (deref-as-shift)
-    if "dom" in adapter_set:
-        spec_mod_set.add("cek")
-        spec_mod_set.add("frames")
+    # CEK is the canonical evaluator — always included
+    spec_mod_set.add("cek")
+    spec_mod_set.add("frames")
     # cek module requires frames
     if "cek" in spec_mod_set:
         spec_mod_set.add("frames")
@@ -195,9 +200,16 @@ def compile_ref_to_js(
         parts.append(PLATFORM_CEK_JS)
 
     # Translate each spec file using js.sx
+    def _find_sx(filename):
+        for d in _source_dirs:
+            p = os.path.join(d, filename)
+            if os.path.exists(p):
+                return p
+        return None
+
     for filename, label in sx_files:
-        filepath = os.path.join(ref_dir, filename)
-        if not os.path.exists(filepath):
+        filepath = _find_sx(filename)
+        if not filepath:
             continue
         with open(filepath) as f:
             src = f.read()
@@ -225,8 +237,11 @@ def compile_ref_to_js(
     for name in ("dom", "engine", "orchestration", "boot"):
         if name in adapter_set and name in adapter_platform:
             parts.append(adapter_platform[name])
-    if has_continuations:
-        parts.append(CONTINUATIONS_JS)
+    # CONTINUATIONS_JS is the tree-walk shift/reset extension.
+    # With CEK as sole evaluator, continuations are handled natively by
+    # cek.sx (step-sf-reset, step-sf-shift). Skip the tree-walk extension.
+    # if has_continuations:
+    #     parts.append(CONTINUATIONS_JS)
     if has_dom:
         parts.append(ASYNC_IO_JS)
     parts.append(public_api_js(has_html, has_sx, has_dom, has_engine, has_orch, has_boot, has_parser, adapter_label, has_deps, has_router, has_signals, has_page_helpers, has_cek))

hosts/javascript/cli.py

@@ -20,8 +20,10 @@ if _PROJECT not in sys.path:
 
 # Re-export everything that consumers import from this module.
 # Canonical source is now run_js_sx.py (self-hosting via js.sx) and platform_js.py.
-from shared.sx.ref.run_js_sx import compile_ref_to_js, load_js_sx  # noqa: F401
-from shared.sx.ref.platform_js import (  # noqa: F401
+import sys, os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")))
+from hosts.javascript.bootstrap import compile_ref_to_js, load_js_sx  # noqa: F401
+from hosts.javascript.platform import (  # noqa: F401
     extract_defines,
     ADAPTER_FILES, ADAPTER_DEPS, SPEC_MODULES, EXTENSION_NAMES,
     PREAMBLE, PLATFORM_JS_PRE, PLATFORM_JS_POST,
@@ -44,7 +46,7 @@ if __name__ == "__main__":
                     help="Comma-separated extensions (continuations). Default: none.")
     p.add_argument("--spec-modules",
                     help="Comma-separated spec modules (deps). Default: none.")
-    default_output = os.path.join(_HERE, "..", "..", "static", "scripts", "sx-browser.js")
+    default_output = os.path.join(_HERE, "..", "..", "shared", "static", "scripts", "sx-browser.js")
     p.add_argument("--output", "-o", default=default_output,
                     help="Output file (default: shared/static/scripts/sx-browser.js)")
     args = p.parse_args()

hosts/javascript/platform.py

@@ -48,11 +48,12 @@ SPEC_MODULES = {
     "page-helpers": ("page-helpers.sx", "page-helpers (pure data transformation helpers)"),
     "frames": ("frames.sx", "frames (CEK continuation frames)"),
     "cek": ("cek.sx", "cek (explicit CEK machine evaluator)"),
+    "types": ("types.sx", "types (gradual type system)"),
 }
 
 # Explicit ordering for spec modules with dependencies.
 # Modules listed here are emitted in this order; any not listed use alphabetical.
-SPEC_MODULE_ORDER = ["deps", "frames", "page-helpers", "router", "cek", "signals"]
+SPEC_MODULE_ORDER = ["deps", "frames", "page-helpers", "router", "cek", "signals", "types"]
 
 
 EXTENSION_NAMES = {"continuations"}
@@ -61,9 +62,13 @@ CONTINUATIONS_JS = '''
   // Extension: Delimited continuations (shift/reset)
   // =========================================================================
 
-  function Continuation(fn) { this.fn = fn; }
-  Continuation.prototype._continuation = true;
-  Continuation.prototype.call = function(value) { return this.fn(value !== undefined ? value : NIL); };
+  function Continuation(fn) {
+    var c = function(value) { return fn(value !== undefined ? value : NIL); };
+    c.fn = fn;
+    c._continuation = true;
+    c.call = function(value) { return fn(value !== undefined ? value : NIL); };
+    return c;
+  }
 
   function ShiftSignal(kName, body, env) {
     this.kName = kName;
@@ -978,6 +983,7 @@ PRIMITIVES_JS_MODULES: dict[str, str] = {
   PRIMITIVES["substring"] = function(s, a, b) { return String(s).substring(a, b); };
   PRIMITIVES["char-from-code"] = function(n) { return String.fromCharCode(n); };
   PRIMITIVES["string-length"] = function(s) { return String(s).length; };
+  var stringLength = PRIMITIVES["string-length"];
   PRIMITIVES["string-contains?"] = function(s, sub) { return String(s).indexOf(String(sub)) !== -1; };
   PRIMITIVES["concat"] = function() {
     var out = [];
@@ -1156,12 +1162,12 @@ PLATFORM_JS_PRE = '''
   function makeSymbol(n) { return new Symbol(n); }
   function makeKeyword(n) { return new Keyword(n); }
 
-  function makeLambda(params, body, env) { return new Lambda(params, body, merge(env)); }
+  function makeLambda(params, body, env) { return new Lambda(params, body, env); }
   function makeComponent(name, params, hasChildren, body, env, affinity) {
-    return new Component(name, params, hasChildren, body, merge(env), affinity);
+    return new Component(name, params, hasChildren, body, env, affinity);
   }
   function makeMacro(params, restParam, body, env, name) {
-    return new Macro(params, restParam, body, merge(env), name);
+    return new Macro(params, restParam, body, env, name);
   }
   function makeThunk(expr, env) { return new Thunk(expr, env); }
 
@@ -1230,6 +1236,8 @@ PLATFORM_JS_PRE = '''
   function componentHasChildren(c) { return c.hasChildren; }
   function componentName(c) { return c.name; }
   function componentAffinity(c) { return c.affinity || "auto"; }
+  function componentParamTypes(c) { return (c && c._paramTypes) ? c._paramTypes : NIL; }
+  function componentSetParamTypes_b(c, t) { if (c) c._paramTypes = t; return NIL; }
 
   function macroParams(m) { return m.params; }
   function macroRestParam(m) { return m.restParam; }
@@ -1249,7 +1257,7 @@ PLATFORM_JS_PRE = '''
 
   // Island platform
   function makeIsland(name, params, hasChildren, body, env) {
-    return new Island(name, params, hasChildren, body, merge(env));
+    return new Island(name, params, hasChildren, body, env);
   }
 
   // JSON / dict helpers for island state serialization
@@ -1264,6 +1272,11 @@ PLATFORM_JS_PRE = '''
 
   function envHas(env, name) { return name in env; }
   function envGet(env, name) { return env[name]; }
+  function envBind(env, name, val) {
+    // Direct property set — creates or overwrites on THIS env only.
+    // Used by let, define, defcomp, lambda param binding.
+    env[name] = val;
+  }
   function envSet(env, name, val) {
     // Walk prototype chain to find where the variable is defined (for set!)
     var obj = env;
@@ -1491,13 +1504,16 @@ PLATFORM_CEK_JS = '''
   // Platform: CEK module — explicit CEK machine
   // =========================================================================
 
-  // Continuation type (needed by CEK even without the tree-walk shift/reset extension)
-  if (typeof Continuation === "undefined") {
-    function Continuation(fn) { this.fn = fn; }
-    Continuation.prototype._continuation = true;
-    Continuation.prototype.call = function(value) { return this.fn(value !== undefined ? value : NIL); };
-    PRIMITIVES["continuation?"] = function(x) { return x != null && x._continuation === true; };
+  // Continuation type — callable as JS function so isCallable/apply work.
+  // CEK is the canonical evaluator; continuations are always available.
+  function Continuation(fn) {
+    var c = function(value) { return fn(value !== undefined ? value : NIL); };
+    c.fn = fn;
+    c._continuation = true;
+    c.call = function(value) { return fn(value !== undefined ? value : NIL); };
+    return c;
   }
+  PRIMITIVES["continuation?"] = function(x) { return x != null && x._continuation === true; };
 
   // Standalone aliases for primitives used by cek.sx / frames.sx
   var inc = PRIMITIVES["inc"];
@@ -1524,6 +1540,20 @@ CEK_FIXUPS_JS = '''
     return cekValue(state);
   };
 
+  // CEK is the canonical evaluator — override evalExpr to use it.
+  // The tree-walk evaluator (evalExpr from eval.sx) is superseded.
+  var _treeWalkEvalExpr = evalExpr;
+  evalExpr = function(expr, env) {
+    return cekRun(makeCekState(expr, env, []));
+  };
+
+  // CEK never produces thunks — trampoline resolves any legacy thunks
+  var _treeWalkTrampoline = trampoline;
+  trampoline = function(val) {
+    if (isThunk(val)) return evalExpr(thunkExpr(val), thunkEnv(val));
+    return val;
+  };
+
   // Platform functions — defined in platform_js.py, not in .sx spec files.
   // Spec defines self-register via js-emit-define; these are the platform interface.
   PRIMITIVES["type-of"] = typeOf;
@@ -3228,6 +3258,7 @@ def public_api_js(has_html, has_sx, has_dom, has_engine, has_orch, has_boot, has
     isNil: isNil,
     componentEnv: componentEnv,''')
 
+    api_lines.append('    setRenderActive: function(val) { setRenderActiveB(val); },')
     if has_html:
         api_lines.append('    renderToHtml: function(expr, env) { return renderToHtml(expr, env || merge(componentEnv)); },')
     if has_sx:

hosts/javascript/run_tests.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+/**
+ * Run SX spec tests in Node.js using the bootstrapped evaluator.
+ *
+ * Usage:
+ *   node hosts/javascript/run_tests.js                    # all spec tests
+ *   node hosts/javascript/run_tests.js test-primitives    # specific test
+ */
+const fs = require("fs");
+const path = require("path");
+
+// Provide globals that sx-browser.js expects
+global.window = global;
+global.addEventListener = () => {};
+global.self = global;
+global.document = {
+  createElement: () => ({ style: {}, setAttribute: () => {}, appendChild: () => {}, children: [] }),
+  createDocumentFragment: () => ({ appendChild: () => {}, children: [], childNodes: [] }),
+  head: { appendChild: () => {} },
+  body: { appendChild: () => {} },
+  querySelector: () => null,
+  querySelectorAll: () => [],
+  createTextNode: (s) => ({ textContent: s }),
+  addEventListener: () => {},
+};
+global.localStorage = { getItem: () => null, setItem: () => {}, removeItem: () => {} };
+global.CustomEvent = class CustomEvent { constructor(n, o) { this.type = n; this.detail = (o||{}).detail||{}; } };
+global.MutationObserver = class { observe() {} disconnect() {} };
+global.requestIdleCallback = (fn) => setTimeout(fn, 0);
+global.matchMedia = () => ({ matches: false });
+global.navigator = { serviceWorker: { register: () => Promise.resolve() } };
+global.location = { href: "", pathname: "/", hostname: "localhost" };
+global.history = { pushState: () => {}, replaceState: () => {} };
+global.fetch = () => Promise.resolve({ ok: true, text: () => Promise.resolve("") });
+global.setTimeout = setTimeout;
+global.clearTimeout = clearTimeout;
+global.console = console;
+
+// Load the bootstrapped evaluator
+// Use --full flag to load a full-spec build (if available)
+const fullBuild = process.argv.includes("--full");
+const jsPath = fullBuild
+  ? path.join(__dirname, "..", "..", "shared", "static", "scripts", "sx-full-test.js")
+  : path.join(__dirname, "..", "..", "shared", "static", "scripts", "sx-browser.js");
+if (fullBuild && !fs.existsSync(jsPath)) {
+  console.error("Full test build not found. Run: python3 hosts/javascript/cli.py --extensions continuations --spec-modules types --output shared/static/scripts/sx-full-test.js");
+  process.exit(1);
+}
+const Sx = require(jsPath);
+if (!Sx || !Sx.parse) {
+  console.error("Failed to load Sx evaluator");
+  process.exit(1);
+}
+
+// Reset render mode — boot process may have set it to true
+if (Sx.setRenderActive) Sx.setRenderActive(false);
+
+// Test infrastructure
+let passCount = 0;
+let failCount = 0;
+const suiteStack = [];
+
+// Build env with all primitives + spec functions
+const env = Sx.getEnv ? Object.assign({}, Sx.getEnv()) : {};
+
+// Additional test helpers needed by spec tests
+env["sx-parse"] = function(s) { return Sx.parse(s); };
+env["sx-parse-one"] = function(s) { const r = Sx.parse(s); return r && r.length > 0 ? r[0] : null; };
+env["test-env"] = function() { return Sx.getEnv ? Object.assign({}, Sx.getEnv()) : {}; };
+env["cek-eval"] = function(s) {
+  const parsed = Sx.parse(s);
+  if (!parsed || parsed.length === 0) return null;
+  return Sx.eval(parsed[0], Sx.getEnv ? Object.assign({}, Sx.getEnv()) : {});
+};
+env["eval-expr-cek"] = function(expr, e) { return Sx.eval(expr, e || env); };
+env["env-get"] = function(e, k) { return e && e[k] !== undefined ? e[k] : null; };
+env["env-has?"] = function(e, k) { return e && k in e; };
+env["env-bind!"] = function(e, k, v) { if (e) e[k] = v; return v; };
+env["env-set!"] = function(e, k, v) { if (e) e[k] = v; return v; };
+env["env-extend"] = function(e) { return Object.create(e); };
+env["env-merge"] = function(a, b) { return Object.assign({}, a, b); };
+
+// Missing primitives referenced by tests
+env["upcase"] = function(s) { return s.toUpperCase(); };
+env["downcase"] = function(s) { return s.toLowerCase(); };
+env["make-keyword"] = function(name) { return new Sx.Keyword(name); };
+env["string-length"] = function(s) { return s.length; };
+env["dict-get"] = function(d, k) { return d && d[k] !== undefined ? d[k] : null; };
+env["apply"] = function(f) {
+  var args = Array.prototype.slice.call(arguments, 1);
+  var lastArg = args.pop();
+  if (Array.isArray(lastArg)) args = args.concat(lastArg);
+  return f.apply(null, args);
+};
+
+// Deep equality
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return a == b;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (typeof a === "object") {
+    const ka = Object.keys(a).filter(k => k !== "_nil");
+    const kb = Object.keys(b).filter(k => k !== "_nil");
+    if (ka.length !== kb.length) return false;
+    return ka.every(k => deepEqual(a[k], b[k]));
+  }
+  return false;
+}
+env["equal?"] = deepEqual;
+env["identical?"] = function(a, b) { return a === b; };
+
+// Continuation support
+env["make-continuation"] = function(fn) {
+  // Continuation must be callable as a function AND have _continuation flag
+  var c = function(v) { return fn(v !== undefined ? v : null); };
+  c._continuation = true;
+  c.fn = fn;
+  c.call = function(v) { return fn(v !== undefined ? v : null); };
+  return c;
+};
+env["continuation?"] = function(x) { return x != null && x._continuation === true; };
+env["continuation-fn"] = function(c) { return c.fn; };
+
+// Render helpers
+// render-html: the tests call this with an SX source string, parse it, and render to HTML
+// IMPORTANT: renderToHtml sets a global _renderMode flag but never resets it.
+// We must reset it after each call so subsequent eval calls don't go through the render path.
+env["render-html"] = function(src, e) {
+  var result;
+  if (typeof src === "string") {
+    var parsed = Sx.parse(src);
+    if (!parsed || parsed.length === 0) return "";
+    var expr = parsed.length === 1 ? parsed[0] : [{ name: "do" }].concat(parsed);
+    if (Sx.renderToHtml) {
+      result = Sx.renderToHtml(expr, e || (Sx.getEnv ? Object.assign({}, Sx.getEnv()) : {}));
+    } else {
+      result = Sx.serialize(expr);
+    }
+  } else {
+    if (Sx.renderToHtml) {
+      result = Sx.renderToHtml(src, e || env);
+    } else {
+      result = Sx.serialize(src);
+    }
+  }
+  // Reset render mode so subsequent eval calls don't go through DOM/HTML render path
+  if (Sx.setRenderActive) Sx.setRenderActive(false);
+  return result;
+};
+// Also register render-to-html directly
+env["render-to-html"] = env["render-html"];
+
+// Type system helpers — available when types module is included
+
+// test-prim-types: dict of primitive return types for type inference
+env["test-prim-types"] = function() {
+  return {
+    "+": "number", "-": "number", "*": "number", "/": "number",
+    "mod": "number", "inc": "number", "dec": "number",
+    "abs": "number", "min": "number", "max": "number",
+    "floor": "number", "ceil": "number", "round": "number",
+    "str": "string", "upper": "string", "lower": "string",
+    "trim": "string", "join": "string", "replace": "string",
+    "format": "string", "substr": "string",
+    "=": "boolean", "<": "boolean", ">": "boolean",
+    "<=": "boolean", ">=": "boolean", "!=": "boolean",
+    "not": "boolean", "nil?": "boolean", "empty?": "boolean",
+    "number?": "boolean", "string?": "boolean", "boolean?": "boolean",
+    "list?": "boolean", "dict?": "boolean", "symbol?": "boolean",
+    "keyword?": "boolean", "contains?": "boolean", "has-key?": "boolean",
+    "starts-with?": "boolean", "ends-with?": "boolean",
+    "len": "number", "first": "any", "rest": "list",
+    "last": "any", "nth": "any", "cons": "list",
+    "append": "list", "concat": "list", "reverse": "list",
+    "sort": "list", "slice": "list", "range": "list",
+    "flatten": "list", "keys": "list", "vals": "list",
+    "map-dict": "dict", "assoc": "dict", "dissoc": "dict",
+    "merge": "dict", "dict": "dict",
+    "get": "any", "type-of": "string",
+  };
+};
+
+// test-prim-param-types: dict of primitive param type specs
+env["test-prim-param-types"] = function() {
+  return {
+    "+": {"positional": [["a", "number"]], "rest-type": "number"},
+    "-": {"positional": [["a", "number"]], "rest-type": "number"},
+    "*": {"positional": [["a", "number"]], "rest-type": "number"},
+    "/": {"positional": [["a", "number"]], "rest-type": "number"},
+    "inc": {"positional": [["n", "number"]], "rest-type": null},
+    "dec": {"positional": [["n", "number"]], "rest-type": null},
+    "upper": {"positional": [["s", "string"]], "rest-type": null},
+    "lower": {"positional": [["s", "string"]], "rest-type": null},
+    "keys": {"positional": [["d", "dict"]], "rest-type": null},
+    "vals": {"positional": [["d", "dict"]], "rest-type": null},
+  };
+};
+
+// Component type accessors
+env["component-param-types"] = function(c) {
+  return c && c._paramTypes ? c._paramTypes : null;
+};
+env["component-set-param-types!"] = function(c, t) {
+  if (c) c._paramTypes = t;
+  return null;
+};
+env["component-params"] = function(c) {
+  return c && c.params ? c.params : null;
+};
+env["component-body"] = function(c) {
+  return c && c.body ? c.body : null;
+};
+env["component-has-children"] = function(c) {
+  return c && c.has_children ? c.has_children : false;
+};
+
+// Platform test functions
+env["try-call"] = function(thunk) {
+  try {
+    Sx.eval([thunk], env);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e.message || String(e) };
+  }
+};
+
+env["report-pass"] = function(name) {
+  passCount++;
+  const ctx = suiteStack.join(" > ");
+  console.log(`  PASS: ${ctx} > ${name}`);
+  return null;
+};
+
+env["report-fail"] = function(name, error) {
+  failCount++;
+  const ctx = suiteStack.join(" > ");
+  console.log(`  FAIL: ${ctx} > ${name}: ${error}`);
+  return null;
+};
+
+env["push-suite"] = function(name) {
+  suiteStack.push(name);
+  console.log(`${"  ".repeat(suiteStack.length - 1)}Suite: ${name}`);
+  return null;
+};
+
+env["pop-suite"] = function() {
+  suiteStack.pop();
+  return null;
+};
+
+// Load test framework
+const projectDir = path.join(__dirname, "..", "..");
+const specTests = path.join(projectDir, "spec", "tests");
+const webTests = path.join(projectDir, "web", "tests");
+
+const frameworkSrc = fs.readFileSync(path.join(specTests, "test-framework.sx"), "utf8");
+const frameworkExprs = Sx.parse(frameworkSrc);
+for (const expr of frameworkExprs) {
+  Sx.eval(expr, env);
+}
+
+// Determine which tests to run
+const args = process.argv.slice(2).filter(a => !a.startsWith("--"));
+let testFiles = [];
+
+if (args.length > 0) {
+  // Specific test files
+  for (const arg of args) {
+    const name = arg.endsWith(".sx") ? arg : `${arg}.sx`;
+    const specPath = path.join(specTests, name);
+    const webPath = path.join(webTests, name);
+    if (fs.existsSync(specPath)) testFiles.push(specPath);
+    else if (fs.existsSync(webPath)) testFiles.push(webPath);
+    else console.error(`Test file not found: ${name}`);
+  }
+} else {
+  // Tests requiring optional modules (only run with --full)
+  const requiresFull = new Set(["test-continuations.sx", "test-types.sx", "test-freeze.sx"]);
+  // All spec tests
+  for (const f of fs.readdirSync(specTests).sort()) {
+    if (f.startsWith("test-") && f.endsWith(".sx") && f !== "test-framework.sx") {
+      if (!fullBuild && requiresFull.has(f)) {
+        console.log(`Skipping ${f} (requires --full)`);
+        continue;
+      }
+      testFiles.push(path.join(specTests, f));
+    }
+  }
+}
+
+// Run tests
+for (const testFile of testFiles) {
+  const name = path.basename(testFile);
+  console.log("=" .repeat(60));
+  console.log(`Running ${name}`);
+  console.log("=" .repeat(60));
+
+  try {
+    const src = fs.readFileSync(testFile, "utf8");
+    const exprs = Sx.parse(src);
+    for (const expr of exprs) {
+      Sx.eval(expr, env);
+    }
+  } catch (e) {
+    console.error(`ERROR in ${name}: ${e.message}`);
+    failCount++;
+  }
+}
+
+// Summary
+console.log("=" .repeat(60));
+console.log(`Results: ${passCount} passed, ${failCount} failed`);
+console.log("=" .repeat(60));
+
+process.exit(failCount > 0 ? 1 : 0);

hosts/javascript/transpiler.sx

@@ -107,6 +107,7 @@
   "get-primitive" "getPrimitive"
   "env-has?" "envHas"
   "env-get" "envGet"
+  "env-bind!" "envBind"
   "env-set!" "envSet"
   "env-extend" "envExtend"
   "env-merge" "envMerge"
@@ -989,6 +990,11 @@
                    ", " (js-expr (nth args 1))
                    ", " (js-expr (nth args 2)) ")")
 
+            (= op "env-bind!")
+              (str "envBind(" (js-expr (nth args 0))
+                   ", " (js-expr (nth args 1))
+                   ", " (js-expr (nth args 2)) ")")
+
             (= op "env-set!")
               (str "envSet(" (js-expr (nth args 0))
                    ", " (js-expr (nth args 1))
@@ -1396,6 +1402,10 @@
                  "] = " (js-expr (nth expr 3)) ";")
           (= name "append!")
             (str (js-expr (nth expr 1)) ".push(" (js-expr (nth expr 2)) ");")
+          (= name "env-bind!")
+            (str "envBind(" (js-expr (nth expr 1))
+                 ", " (js-expr (nth expr 2))
+                 ", " (js-expr (nth expr 3)) ");")
           (= name "env-set!")
             (str "envSet(" (js-expr (nth expr 1))
                  ", " (js-expr (nth expr 2))

hosts/python/bootstrap.py

@@ -20,7 +20,7 @@ import sys
 
 # Add project root to path for imports
 _HERE = os.path.dirname(os.path.abspath(__file__))
-_PROJECT = os.path.abspath(os.path.join(_HERE, "..", "..", ".."))
+_PROJECT = os.path.abspath(os.path.join(_HERE, "..", ".."))
 sys.path.insert(0, _PROJECT)
 
 from shared.sx.parser import parse_all
@@ -1313,7 +1313,7 @@ try:
         EXTENSION_NAMES, EXTENSION_FORMS,
     )
 except ImportError:
-    from shared.sx.ref.platform_py import (
+    from hosts.python.platform import (
         PREAMBLE, PLATFORM_PY, PRIMITIVES_PY_PRE, PRIMITIVES_PY_POST,
         PRIMITIVES_PY_MODULES, _ALL_PY_MODULES,
         PLATFORM_PARSER_PY,
@@ -1325,9 +1325,17 @@ except ImportError:
     )
 
 
-def _parse_special_forms_spec(ref_dir: str) -> set[str]:
+def _parse_special_forms_spec(ref_dir: str, source_dirs=None) -> set[str]:
     """Parse special-forms.sx to extract declared form names."""
-    filepath = os.path.join(ref_dir, "special-forms.sx")
+    filepath = None
+    if source_dirs:
+        for d in source_dirs:
+            p = os.path.join(d, "special-forms.sx")
+            if os.path.exists(p):
+                filepath = p
+                break
+    if not filepath:
+        filepath = os.path.join(ref_dir, "special-forms.sx")
     if not os.path.exists(filepath):
         return set()
     with open(filepath) as f:
@@ -1359,9 +1367,9 @@ def _extract_eval_dispatch_names(all_sections: list) -> set[str]:
 
 
 def _validate_special_forms(ref_dir: str, all_sections: list,
-                            has_continuations: bool) -> None:
+                            has_continuations: bool, source_dirs=None) -> None:
     """Cross-check special-forms.sx against eval.sx dispatch. Warn on mismatches."""
-    spec_names = _parse_special_forms_spec(ref_dir)
+    spec_names = _parse_special_forms_spec(ref_dir, source_dirs=source_dirs)
     if not spec_names:
         return
 
@@ -1431,7 +1439,21 @@ def compile_ref_to_py(
                     raise ValueError(f"Unknown module: {m!r}. Valid: {', '.join(PRIMITIVES_PY_MODULES)}")
                 prim_modules.append(m)
 
-    ref_dir = os.path.dirname(os.path.abspath(__file__))
+    ref_dir = os.path.join(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..")), "shared", "sx", "ref")
+    _project = os.path.abspath(os.path.join(ref_dir, "..", "..", ".."))
+    _source_dirs = [
+        os.path.join(_project, "spec"),
+        os.path.join(_project, "web"),
+        ref_dir,
+    ]
+
+    def _find_sx(filename):
+        for d in _source_dirs:
+            p = os.path.join(d, filename)
+            if os.path.exists(p):
+                return p
+        return None
+
     emitter = PyEmitter()
 
     # Resolve adapter set
@@ -1494,7 +1516,7 @@ def compile_ref_to_py(
     has_async = "async" in adapter_set
     if has_async:
         async_filename = ADAPTER_FILES["async"][0]
-        async_filepath = os.path.join(ref_dir, async_filename)
+        async_filepath = _find_sx(async_filename) or os.path.join(ref_dir, async_filename)
         if os.path.exists(async_filepath):
             with open(async_filepath) as f:
                 async_src = f.read()
@@ -1513,7 +1535,7 @@ def compile_ref_to_py(
 
     all_sections = []
     for filename, label in sx_files:
-        filepath = os.path.join(ref_dir, filename)
+        filepath = _find_sx(filename) or os.path.join(ref_dir, filename)
         if not os.path.exists(filepath):
             continue
         with open(filepath) as f:
@@ -1531,7 +1553,7 @@ def compile_ref_to_py(
     has_continuations = "continuations" in ext_set
 
     # Validate special forms
-    _validate_special_forms(ref_dir, all_sections, has_continuations)
+    _validate_special_forms(ref_dir, all_sections, has_continuations, source_dirs=_source_dirs)
 
     # Build output
     has_html = "html" in adapter_set

hosts/python/platform.py

@@ -498,10 +498,23 @@ def env_get(env, name):
     return env.get(name, NIL)
 
 
-def env_set(env, name, val):
+def env_bind(env, name, val):
+    """Create/overwrite binding on THIS env only (let, define, param binding)."""
     env[name] = val
 
 
+def env_set(env, name, val):
+    """Mutate existing binding, walking scope chain (set!)."""
+    if hasattr(env, 'set'):
+        try:
+            env.set(name, val)
+        except KeyError:
+            # Not found anywhere — bind on immediate env
+            env[name] = val
+    else:
+        env[name] = val
+
+
 def env_extend(env):
     return _ensure_env(env).extend()
 

hosts/python/tests/run_cek_reactive_tests.py

@@ -5,6 +5,8 @@ import os, sys
 
 _HERE = os.path.dirname(os.path.abspath(__file__))
 _PROJECT = os.path.abspath(os.path.join(_HERE, "..", "..", ".."))
+_SPEC_TESTS = os.path.join(_PROJECT, "spec", "tests")
+_WEB_TESTS = os.path.join(_PROJECT, "web", "tests")
 sys.path.insert(0, _PROJECT)
 sys.setrecursionlimit(20000)
 
@@ -212,25 +214,25 @@ for name in ["sf-defhandler", "sf-defpage", "sf-defquery", "sf-defaction"]:
         env[name] = lambda args, e, _n=name: NIL
 
 # Load test framework
-with open(os.path.join(_HERE, "test-framework.sx")) as f:
+with open(os.path.join(_SPEC_TESTS, "test-framework.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 
 # Load signals module
 print("Loading signals.sx ...")
-with open(os.path.join(_HERE, "signals.sx")) as f:
+with open(os.path.join(_PROJECT, "web", "signals.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 
 # Load frames module
 print("Loading frames.sx ...")
-with open(os.path.join(_HERE, "frames.sx")) as f:
+with open(os.path.join(_PROJECT, "spec", "frames.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 
 # Load CEK module
 print("Loading cek.sx ...")
-with open(os.path.join(_HERE, "cek.sx")) as f:
+with open(os.path.join(_PROJECT, "spec", "cek.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 
@@ -239,7 +241,7 @@ print("=" * 60)
 print("Running test-cek-reactive.sx")
 print("=" * 60)
 
-with open(os.path.join(_HERE, "test-cek-reactive.sx")) as f:
+with open(os.path.join(_WEB_TESTS, "test-cek-reactive.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 

hosts/python/tests/run_cek_tests.py

@@ -5,6 +5,8 @@ import os, sys
 
 _HERE = os.path.dirname(os.path.abspath(__file__))
 _PROJECT = os.path.abspath(os.path.join(_HERE, "..", "..", ".."))
+_SPEC_TESTS = os.path.join(_PROJECT, "spec", "tests")
+_WEB_TESTS = os.path.join(_PROJECT, "web", "tests")
 sys.path.insert(0, _PROJECT)
 
 from shared.sx.ref.sx_ref import sx_parse as parse_all
@@ -223,19 +225,19 @@ for name in ["sf-defhandler", "sf-defpage", "sf-defquery", "sf-defaction"]:
         env[name] = lambda args, e, _n=name: NIL
 
 # Load test framework
-with open(os.path.join(_HERE, "test-framework.sx")) as f:
+with open(os.path.join(_SPEC_TESTS, "test-framework.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 
 # Load frames module
 print("Loading frames.sx ...")
-with open(os.path.join(_HERE, "frames.sx")) as f:
+with open(os.path.join(_PROJECT, "spec", "frames.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 
 # Load CEK module
 print("Loading cek.sx ...")
-with open(os.path.join(_HERE, "cek.sx")) as f:
+with open(os.path.join(_PROJECT, "spec", "cek.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 
@@ -255,7 +257,7 @@ print("=" * 60)
 print("Running test-cek.sx")
 print("=" * 60)
 
-with open(os.path.join(_HERE, "test-cek.sx")) as f:
+with open(os.path.join(_SPEC_TESTS, "test-cek.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 

hosts/python/tests/run_continuation_tests.py

@@ -5,12 +5,14 @@ import os, sys, subprocess, tempfile
 
 _HERE = os.path.dirname(os.path.abspath(__file__))
 _PROJECT = os.path.abspath(os.path.join(_HERE, "..", "..", ".."))
+_SPEC_TESTS = os.path.join(_PROJECT, "spec", "tests")
+_WEB_TESTS = os.path.join(_PROJECT, "web", "tests")
 sys.path.insert(0, _PROJECT)
 
 # Bootstrap a fresh sx_ref with continuations enabled
 print("Bootstrapping with --extensions continuations ...")
 result = subprocess.run(
-    [sys.executable, os.path.join(_HERE, "bootstrap_py.py"),
+    [sys.executable, os.path.join(_HERE, "..", "bootstrap.py"),
      "--extensions", "continuations"],
     capture_output=True, text=True, cwd=_PROJECT,
 )
@@ -87,7 +89,7 @@ env["push-suite"] = _push_suite
 env["pop-suite"] = _pop_suite
 
 # Load test framework
-with open(os.path.join(_HERE, "test-framework.sx")) as f:
+with open(os.path.join(_SPEC_TESTS, "test-framework.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 
@@ -96,7 +98,7 @@ print("=" * 60)
 print("Running test-continuations.sx")
 print("=" * 60)
 
-with open(os.path.join(_HERE, "test-continuations.sx")) as f:
+with open(os.path.join(_SPEC_TESTS, "test-continuations.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 

hosts/python/tests/run_signal_tests.py

@@ -10,6 +10,8 @@ import os, sys
 
 _HERE = os.path.dirname(os.path.abspath(__file__))
 _PROJECT = os.path.abspath(os.path.join(_HERE, "..", "..", ".."))
+_SPEC_TESTS = os.path.join(_PROJECT, "spec", "tests")
+_WEB_TESTS = os.path.join(_PROJECT, "web", "tests")
 sys.path.insert(0, _PROJECT)
 
 from shared.sx.ref.sx_ref import sx_parse as parse_all
@@ -143,7 +145,7 @@ env["register-in-scope"] = sx_ref.register_in_scope
 env["callable?"] = sx_ref.is_callable
 
 # Load test framework
-with open(os.path.join(_HERE, "test-framework.sx")) as f:
+with open(os.path.join(_SPEC_TESTS, "test-framework.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 
@@ -152,7 +154,7 @@ print("=" * 60)
 print("Running test-signals.sx")
 print("=" * 60)
 
-with open(os.path.join(_HERE, "test-signals.sx")) as f:
+with open(os.path.join(_WEB_TESTS, "test-signals.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 

hosts/python/tests/run_tests.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+"""
+Run SX spec tests using the bootstrapped Python evaluator.
+
+Usage:
+    python3 hosts/python/tests/run_tests.py                    # all spec tests
+    python3 hosts/python/tests/run_tests.py test-primitives     # specific test
+    python3 hosts/python/tests/run_tests.py --full              # include optional modules
+"""
+from __future__ import annotations
+import os, sys
+
+# Increase recursion limit for TCO tests (Python's default 1000 is too low)
+sys.setrecursionlimit(5000)
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_PROJECT = os.path.abspath(os.path.join(_HERE, "..", "..", ".."))
+_SPEC_TESTS = os.path.join(_PROJECT, "spec", "tests")
+sys.path.insert(0, _PROJECT)
+
+from shared.sx.ref.sx_ref import sx_parse as parse_all
+from shared.sx.ref import sx_ref
+from shared.sx.ref.sx_ref import (
+    make_env, env_get, env_has, env_set, env_extend, env_merge,
+)
+from shared.sx.types import (
+    NIL, Symbol, Keyword, Lambda, Component, Island, Macro,
+)
+
+# Use tree-walk evaluator
+eval_expr = sx_ref._tree_walk_eval_expr
+trampoline = sx_ref._tree_walk_trampoline
+sx_ref.eval_expr = eval_expr
+sx_ref.trampoline = trampoline
+
+# Check for --full flag
+full_build = "--full" in sys.argv
+
+# Build env with primitives
+env = make_env()
+
+# ---------------------------------------------------------------------------
+# Test infrastructure
+# ---------------------------------------------------------------------------
+_suite_stack: list[str] = []
+_pass_count = 0
+_fail_count = 0
+
+
+def _try_call(thunk):
+    try:
+        trampoline(eval_expr([thunk], env))
+        return {"ok": True}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
+def _report_pass(name):
+    global _pass_count
+    _pass_count += 1
+    ctx = " > ".join(_suite_stack)
+    print(f"  PASS: {ctx} > {name}")
+    return NIL
+
+
+def _report_fail(name, error):
+    global _fail_count
+    _fail_count += 1
+    ctx = " > ".join(_suite_stack)
+    print(f"  FAIL: {ctx} > {name}: {error}")
+    return NIL
+
+
+def _push_suite(name):
+    _suite_stack.append(name)
+    print(f"{'  ' * (len(_suite_stack)-1)}Suite: {name}")
+    return NIL
+
+
+def _pop_suite():
+    if _suite_stack:
+        _suite_stack.pop()
+    return NIL
+
+
+env["try-call"] = _try_call
+env["report-pass"] = _report_pass
+env["report-fail"] = _report_fail
+env["push-suite"] = _push_suite
+env["pop-suite"] = _pop_suite
+
+# ---------------------------------------------------------------------------
+# Test helpers
+# ---------------------------------------------------------------------------
+
+
+def _deep_equal(a, b):
+    if a is b:
+        return True
+    if a is NIL and b is NIL:
+        return True
+    if a is NIL or b is NIL:
+        return a is None and b is NIL or b is None and a is NIL
+    if type(a) != type(b):
+        # number comparison: int vs float
+        if isinstance(a, (int, float)) and isinstance(b, (int, float)):
+            return a == b
+        return False
+    if isinstance(a, list):
+        if len(a) != len(b):
+            return False
+        return all(_deep_equal(x, y) for x, y in zip(a, b))
+    if isinstance(a, dict):
+        ka = {k for k in a if k != "_nil"}
+        kb = {k for k in b if k != "_nil"}
+        if ka != kb:
+            return False
+        return all(_deep_equal(a[k], b[k]) for k in ka)
+    return a == b
+
+
+env["equal?"] = _deep_equal
+env["identical?"] = lambda a, b: a is b
+
+
+def _test_env():
+    return make_env()
+
+
+def _sx_parse(source):
+    return parse_all(source)
+
+
+def _sx_parse_one(source):
+    exprs = parse_all(source)
+    return exprs[0] if exprs else NIL
+
+
+env["test-env"] = _test_env
+env["sx-parse"] = _sx_parse
+env["sx-parse-one"] = _sx_parse_one
+env["cek-eval"] = lambda s: trampoline(eval_expr(parse_all(s)[0], make_env())) if parse_all(s) else NIL
+env["eval-expr-cek"] = lambda expr, e=None: trampoline(eval_expr(expr, e or env))
+
+# Env operations
+env["env-get"] = env_get
+env["env-has?"] = env_has
+env["env-set!"] = env_set
+env["env-bind!"] = lambda e, k, v: e.__setitem__(k, v) or v
+env["env-extend"] = env_extend
+env["env-merge"] = env_merge
+
+# Missing primitives
+env["upcase"] = lambda s: str(s).upper()
+env["downcase"] = lambda s: str(s).lower()
+env["make-keyword"] = lambda name: Keyword(name)
+env["make-symbol"] = lambda name: Symbol(name)
+env["string-length"] = lambda s: len(str(s))
+env["dict-get"] = lambda d, k: d.get(k, NIL) if isinstance(d, dict) else NIL
+env["apply"] = lambda f, *args: f(*args[-1]) if args and isinstance(args[-1], list) else f()
+
+# Render helpers
+def _render_html(src, e=None):
+    if isinstance(src, str):
+        parsed = parse_all(src)
+        if not parsed:
+            return ""
+        expr = parsed[0] if len(parsed) == 1 else [Symbol("do")] + parsed
+        result = sx_ref.render_to_html(expr, e or make_env())
+        # Reset render mode
+        sx_ref._render_mode = False
+        return result
+    result = sx_ref.render_to_html(src, e or env)
+    sx_ref._render_mode = False
+    return result
+
+
+env["render-html"] = _render_html
+env["render-to-html"] = _render_html
+env["string-contains?"] = lambda s, sub: str(sub) in str(s)
+
+# Type system helpers
+env["test-prim-types"] = lambda: {
+    "+": "number", "-": "number", "*": "number", "/": "number",
+    "mod": "number", "inc": "number", "dec": "number",
+    "abs": "number", "min": "number", "max": "number",
+    "str": "string", "upper": "string", "lower": "string",
+    "trim": "string", "join": "string", "replace": "string",
+    "=": "boolean", "<": "boolean", ">": "boolean",
+    "<=": "boolean", ">=": "boolean",
+    "not": "boolean", "nil?": "boolean", "empty?": "boolean",
+    "number?": "boolean", "string?": "boolean", "boolean?": "boolean",
+    "list?": "boolean", "dict?": "boolean",
+    "contains?": "boolean", "has-key?": "boolean",
+    "starts-with?": "boolean", "ends-with?": "boolean",
+    "len": "number", "first": "any", "rest": "list",
+    "last": "any", "nth": "any", "cons": "list",
+    "append": "list", "concat": "list", "reverse": "list",
+    "sort": "list", "slice": "list", "range": "list",
+    "flatten": "list", "keys": "list", "vals": "list",
+    "assoc": "dict", "dissoc": "dict", "merge": "dict", "dict": "dict",
+    "get": "any", "type-of": "string",
+}
+env["test-prim-param-types"] = lambda: {
+    "+": {"positional": [["a", "number"]], "rest-type": "number"},
+    "-": {"positional": [["a", "number"]], "rest-type": "number"},
+    "*": {"positional": [["a", "number"]], "rest-type": "number"},
+    "/": {"positional": [["a", "number"]], "rest-type": "number"},
+    "inc": {"positional": [["n", "number"]], "rest-type": NIL},
+    "dec": {"positional": [["n", "number"]], "rest-type": NIL},
+    "upper": {"positional": [["s", "string"]], "rest-type": NIL},
+    "lower": {"positional": [["s", "string"]], "rest-type": NIL},
+    "keys": {"positional": [["d", "dict"]], "rest-type": NIL},
+    "vals": {"positional": [["d", "dict"]], "rest-type": NIL},
+}
+env["component-param-types"] = lambda c: getattr(c, "_param_types", NIL)
+env["component-set-param-types!"] = lambda c, t: setattr(c, "_param_types", t) or NIL
+env["component-params"] = lambda c: c.params
+env["component-body"] = lambda c: c.body
+env["component-has-children"] = lambda c: c.has_children
+env["component-affinity"] = lambda c: getattr(c, "affinity", "auto")
+
+# Type accessors
+env["callable?"] = lambda x: callable(x) or isinstance(x, (Lambda, Component, Island))
+env["lambda?"] = lambda x: isinstance(x, Lambda)
+env["component?"] = lambda x: isinstance(x, Component)
+env["island?"] = lambda x: isinstance(x, Island)
+env["macro?"] = lambda x: isinstance(x, Macro)
+env["thunk?"] = sx_ref.is_thunk
+env["thunk-expr"] = sx_ref.thunk_expr
+env["thunk-env"] = sx_ref.thunk_env
+env["make-thunk"] = sx_ref.make_thunk
+env["make-lambda"] = sx_ref.make_lambda
+env["make-component"] = sx_ref.make_component
+env["make-macro"] = sx_ref.make_macro
+env["lambda-params"] = lambda f: f.params
+env["lambda-body"] = lambda f: f.body
+env["lambda-closure"] = lambda f: f.closure
+env["lambda-name"] = lambda f: f.name
+env["set-lambda-name!"] = lambda f, n: setattr(f, "name", n) or NIL
+env["component-closure"] = lambda c: c.closure
+env["component-name"] = lambda c: c.name
+env["component-has-children?"] = lambda c: c.has_children
+env["macro-params"] = lambda m: m.params
+env["macro-rest-param"] = lambda m: m.rest_param
+env["macro-body"] = lambda m: m.body
+env["macro-closure"] = lambda m: m.closure
+env["symbol-name"] = lambda s: s.name if isinstance(s, Symbol) else str(s)
+env["keyword-name"] = lambda k: k.name if isinstance(k, Keyword) else str(k)
+env["sx-serialize"] = sx_ref.sx_serialize if hasattr(sx_ref, "sx_serialize") else lambda x: str(x)
+env["is-render-expr?"] = lambda expr: False
+env["render-active?"] = lambda: False
+env["render-expr"] = lambda expr, env: NIL
+
+# Strict mode stubs (not yet bootstrapped to Python — no-ops for now)
+env["set-strict!"] = lambda val: NIL
+env["set-prim-param-types!"] = lambda types: NIL
+env["value-matches-type?"] = lambda val, t: True
+env["*strict*"] = False
+env["primitive?"] = lambda name: name in env
+env["get-primitive"] = lambda name: env.get(name, NIL)
+
+# ---------------------------------------------------------------------------
+# Load test framework
+# ---------------------------------------------------------------------------
+framework_src = open(os.path.join(_SPEC_TESTS, "test-framework.sx")).read()
+for expr in parse_all(framework_src):
+    trampoline(eval_expr(expr, env))
+
+# ---------------------------------------------------------------------------
+# Determine which tests to run
+# ---------------------------------------------------------------------------
+args = [a for a in sys.argv[1:] if not a.startswith("--")]
+
+# Tests requiring optional modules (only with --full)
+REQUIRES_FULL = {"test-continuations.sx", "test-types.sx", "test-freeze.sx", "test-strict.sx", "test-cek.sx"}
+
+test_files = []
+if args:
+    for arg in args:
+        name = arg if arg.endswith(".sx") else f"{arg}.sx"
+        p = os.path.join(_SPEC_TESTS, name)
+        if os.path.exists(p):
+            test_files.append(p)
+        else:
+            print(f"Test file not found: {name}")
+else:
+    for f in sorted(os.listdir(_SPEC_TESTS)):
+        if f.startswith("test-") and f.endswith(".sx") and f != "test-framework.sx":
+            if not full_build and f in REQUIRES_FULL:
+                print(f"Skipping {f} (requires --full)")
+                continue
+            test_files.append(os.path.join(_SPEC_TESTS, f))
+
+# ---------------------------------------------------------------------------
+# Run tests
+# ---------------------------------------------------------------------------
+for test_file in test_files:
+    name = os.path.basename(test_file)
+    print("=" * 60)
+    print(f"Running {name}")
+    print("=" * 60)
+    try:
+        src = open(test_file).read()
+        exprs = parse_all(src)
+        for expr in exprs:
+            trampoline(eval_expr(expr, env))
+    except Exception as e:
+        print(f"ERROR in {name}: {e}")
+        _fail_count += 1
+
+# Summary
+print("=" * 60)
+print(f"Results: {_pass_count} passed, {_fail_count} failed")
+print("=" * 60)
+sys.exit(1 if _fail_count > 0 else 0)

hosts/python/tests/run_type_tests.py

@@ -5,6 +5,9 @@ import os, sys
 
 _HERE = os.path.dirname(os.path.abspath(__file__))
 _PROJECT = os.path.abspath(os.path.join(_HERE, "..", "..", ".."))
+_SPEC_DIR = os.path.join(_PROJECT, "spec")
+_SPEC_TESTS = os.path.join(_PROJECT, "spec", "tests")
+_WEB_TESTS = os.path.join(_PROJECT, "web", "tests")
 sys.path.insert(0, _PROJECT)
 
 from shared.sx.ref.sx_ref import sx_parse as parse_all
@@ -167,12 +170,12 @@ env["env-has?"] = env_has
 env["env-set!"] = env_set
 
 # Load test framework (macros + assertion helpers)
-with open(os.path.join(_HERE, "test-framework.sx")) as f:
+with open(os.path.join(_SPEC_TESTS, "test-framework.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 
 # Load types module
-with open(os.path.join(_HERE, "types.sx")) as f:
+with open(os.path.join(_SPEC_DIR, "types.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 
@@ -181,7 +184,7 @@ print("=" * 60)
 print("Running test-types.sx")
 print("=" * 60)
 
-with open(os.path.join(_HERE, "test-types.sx")) as f:
+with open(os.path.join(_SPEC_TESTS, "test-types.sx")) as f:
     for expr in parse_all(f.read()):
         trampoline(eval_expr(expr, env))
 

hosts/python/transpiler.sx

@@ -107,6 +107,7 @@
   "get-primitive" "get_primitive"
   "env-has?" "env_has"
   "env-get" "env_get"
+  "env-bind!" "env_bind"
   "env-set!" "env_set"
   "env-extend" "env_extend"
   "env-merge" "env_merge"
@@ -524,11 +525,16 @@
                    ", " (py-expr-with-cells (nth args 1) cell-vars)
                    ", " (py-expr-with-cells (nth args 2) cell-vars) ")")
 
-            (= op "env-set!")
+            (= op "env-bind!")
               (str "_sx_dict_set(" (py-expr-with-cells (nth args 0) cell-vars)
                    ", " (py-expr-with-cells (nth args 1) cell-vars)
                    ", " (py-expr-with-cells (nth args 2) cell-vars) ")")
 
+            (= op "env-set!")
+              (str "env_set(" (py-expr-with-cells (nth args 0) cell-vars)
+                   ", " (py-expr-with-cells (nth args 1) cell-vars)
+                   ", " (py-expr-with-cells (nth args 2) cell-vars) ")")
+
             (= op "set-lambda-name!")
               (str "_sx_set_attr(" (py-expr-with-cells (nth args 0) cell-vars)
                    ", 'name', " (py-expr-with-cells (nth args 1) cell-vars) ")")
@@ -901,10 +907,14 @@
             (= name "append!")
               (str pad (py-expr-with-cells (nth expr 1) cell-vars)
                    ".append(" (py-expr-with-cells (nth expr 2) cell-vars) ")")
-            (= name "env-set!")
+            (= name "env-bind!")
               (str pad (py-expr-with-cells (nth expr 1) cell-vars)
                    "[" (py-expr-with-cells (nth expr 2) cell-vars)
                    "] = " (py-expr-with-cells (nth expr 3) cell-vars))
+            (= name "env-set!")
+              (str pad "env_set(" (py-expr-with-cells (nth expr 1) cell-vars)
+                   ", " (py-expr-with-cells (nth expr 2) cell-vars)
+                   ", " (py-expr-with-cells (nth expr 3) cell-vars) ")")
             (= name "set-lambda-name!")
               (str pad (py-expr-with-cells (nth expr 1) cell-vars)
                    ".name = " (py-expr-with-cells (nth expr 2) cell-vars))
@@ -1098,10 +1108,14 @@
                 (append! lines (str pad (py-expr-with-cells (nth expr 1) cell-vars)
                                     "[" (py-expr-with-cells (nth expr 2) cell-vars)
                                     "] = " (py-expr-with-cells (nth expr 3) cell-vars)))
-              (= name "env-set!")
+              (= name "env-bind!")
                 (append! lines (str pad (py-expr-with-cells (nth expr 1) cell-vars)
                                     "[" (py-expr-with-cells (nth expr 2) cell-vars)
                                     "] = " (py-expr-with-cells (nth expr 3) cell-vars)))
+              (= name "env-set!")
+                (append! lines (str pad "env_set(" (py-expr-with-cells (nth expr 1) cell-vars)
+                                    ", " (py-expr-with-cells (nth expr 2) cell-vars)
+                                    ", " (py-expr-with-cells (nth expr 3) cell-vars) ")"))
               :else
                 (append! lines (py-statement-with-cells expr indent cell-vars)))))))))
 

shared/static/scripts/sx-browser.js

@@ -14,7 +14,7 @@
   // =========================================================================
 
   var NIL = Object.freeze({ _nil: true, toString: function() { return "nil"; } });
-  var SX_VERSION = "2026-03-15T00:53:02Z";
+  var SX_VERSION = "2026-03-15T13:02:48Z";
 
   function isNil(x) { return x === NIL || x === null || x === undefined; }
   function isSxTruthy(x) { return x !== false && !isNil(x); }
@@ -122,12 +122,12 @@
   function makeSymbol(n) { return new Symbol(n); }
   function makeKeyword(n) { return new Keyword(n); }
 
-  function makeLambda(params, body, env) { return new Lambda(params, body, merge(env)); }
+  function makeLambda(params, body, env) { return new Lambda(params, body, env); }
   function makeComponent(name, params, hasChildren, body, env, affinity) {
-    return new Component(name, params, hasChildren, body, merge(env), affinity);
+    return new Component(name, params, hasChildren, body, env, affinity);
   }
   function makeMacro(params, restParam, body, env, name) {
-    return new Macro(params, restParam, body, merge(env), name);
+    return new Macro(params, restParam, body, env, name);
   }
   function makeThunk(expr, env) { return new Thunk(expr, env); }
 
@@ -196,6 +196,8 @@
   function componentHasChildren(c) { return c.hasChildren; }
   function componentName(c) { return c.name; }
   function componentAffinity(c) { return c.affinity || "auto"; }
+  function componentParamTypes(c) { return (c && c._paramTypes) ? c._paramTypes : NIL; }
+  function componentSetParamTypes_b(c, t) { if (c) c._paramTypes = t; return NIL; }
 
   function macroParams(m) { return m.params; }
   function macroRestParam(m) { return m.restParam; }
@@ -215,7 +217,7 @@
 
   // Island platform
   function makeIsland(name, params, hasChildren, body, env) {
-    return new Island(name, params, hasChildren, body, merge(env));
+    return new Island(name, params, hasChildren, body, env);
   }
 
   // JSON / dict helpers for island state serialization
@@ -230,6 +232,11 @@
 
   function envHas(env, name) { return name in env; }
   function envGet(env, name) { return env[name]; }
+  function envBind(env, name, val) {
+    // Direct property set — creates or overwrites on THIS env only.
+    // Used by let, define, defcomp, lambda param binding.
+    env[name] = val;
+  }
   function envSet(env, name, val) {
     // Walk prototype chain to find where the variable is defined (for set!)
     var obj = env;
@@ -378,6 +385,7 @@
   PRIMITIVES["substring"] = function(s, a, b) { return String(s).substring(a, b); };
   PRIMITIVES["char-from-code"] = function(n) { return String.fromCharCode(n); };
   PRIMITIVES["string-length"] = function(s) { return String(s).length; };
+  var stringLength = PRIMITIVES["string-length"];
   PRIMITIVES["string-contains?"] = function(s, sub) { return String(s).indexOf(String(sub)) !== -1; };
   PRIMITIVES["concat"] = function() {
     var out = [];
@@ -767,13 +775,16 @@
   // Platform: CEK module — explicit CEK machine
   // =========================================================================
 
-  // Continuation type (needed by CEK even without the tree-walk shift/reset extension)
-  if (typeof Continuation === "undefined") {
-    function Continuation(fn) { this.fn = fn; }
-    Continuation.prototype._continuation = true;
-    Continuation.prototype.call = function(value) { return this.fn(value !== undefined ? value : NIL); };
-    PRIMITIVES["continuation?"] = function(x) { return x != null && x._continuation === true; };
+  // Continuation type — callable as JS function so isCallable/apply work.
+  // CEK is the canonical evaluator; continuations are always available.
+  function Continuation(fn) {
+    var c = function(value) { return fn(value !== undefined ? value : NIL); };
+    c.fn = fn;
+    c._continuation = true;
+    c.call = function(value) { return fn(value !== undefined ? value : NIL); };
+    return c;
   }
+  PRIMITIVES["continuation?"] = function(x) { return x != null && x._continuation === true; };
 
   // Standalone aliases for primitives used by cek.sx / frames.sx
   var inc = PRIMITIVES["inc"];
@@ -801,6 +812,53 @@
 })(); };
 PRIMITIVES["trampoline"] = trampoline;
 
+  // *strict*
+  var _strict_ = false;
+PRIMITIVES["*strict*"] = _strict_;
+
+  // set-strict!
+  var setStrict_b = function(val) { return (_strict_ = val); };
+PRIMITIVES["set-strict!"] = setStrict_b;
+
+  // *prim-param-types*
+  var _primParamTypes_ = NIL;
+PRIMITIVES["*prim-param-types*"] = _primParamTypes_;
+
+  // set-prim-param-types!
+  var setPrimParamTypes_b = function(types) { return (_primParamTypes_ = types); };
+PRIMITIVES["set-prim-param-types!"] = setPrimParamTypes_b;
+
+  // value-matches-type?
+  var valueMatchesType_p = function(val, expectedType) { return (isSxTruthy((expectedType == "any")) ? true : (isSxTruthy((expectedType == "number")) ? isNumber(val) : (isSxTruthy((expectedType == "string")) ? isString(val) : (isSxTruthy((expectedType == "boolean")) ? boolean_p(val) : (isSxTruthy((expectedType == "nil")) ? isNil(val) : (isSxTruthy((expectedType == "list")) ? isList(val) : (isSxTruthy((expectedType == "dict")) ? isDict(val) : (isSxTruthy((expectedType == "lambda")) ? isLambda(val) : (isSxTruthy((expectedType == "symbol")) ? (typeOf(val) == "symbol") : (isSxTruthy((expectedType == "keyword")) ? (typeOf(val) == "keyword") : (isSxTruthy((isSxTruthy(isString(expectedType)) && endsWith(expectedType, "?"))) ? sxOr(isNil(val), valueMatchesType_p(val, slice(expectedType, 0, (stringLength(expectedType) - 1)))) : true))))))))))); };
+PRIMITIVES["value-matches-type?"] = valueMatchesType_p;
+
+  // strict-check-args
+  var strictCheckArgs = function(name, args) { return (isSxTruthy((isSxTruthy(_strict_) && _primParamTypes_)) ? (function() {
+  var spec = get(_primParamTypes_, name);
+  return (isSxTruthy(spec) ? (function() {
+  var positional = get(spec, "positional");
+  var restType = get(spec, "rest-type");
+  if (isSxTruthy(positional)) {
+  { var _c = mapIndexed(function(i, p) { return [i, p]; }, positional); for (var _i = 0; _i < _c.length; _i++) { var pair = _c[_i]; (function() {
+  var idx = first(pair);
+  var param = nth(pair, 1);
+  var pName = first(param);
+  var pType = nth(param, 1);
+  return (isSxTruthy((idx < len(args))) ? (function() {
+  var val = nth(args, idx);
+  return (isSxTruthy(!isSxTruthy(valueMatchesType_p(val, pType))) ? error((String("Type error: ") + String(name) + String(" expected ") + String(pType) + String(" for param ") + String(pName) + String(", got ") + String(typeOf(val)) + String(" (") + String((String(val))) + String(")"))) : NIL);
+})() : NIL);
+})(); } }
+}
+  return (isSxTruthy((isSxTruthy(restType) && (len(args) > len(sxOr(positional, []))))) ? forEach(function(pair) { return (function() {
+  var idx = first(pair);
+  var val = nth(pair, 1);
+  return (isSxTruthy(!isSxTruthy(valueMatchesType_p(val, restType))) ? error((String("Type error: ") + String(name) + String(" expected ") + String(restType) + String(" for rest arg ") + String(idx) + String(", got ") + String(typeOf(val)) + String(" (") + String((String(val))) + String(")"))) : NIL);
+})(); }, mapIndexed(function(i, v) { return [i, v]; }, slice(args, len(sxOr(positional, []))))) : NIL);
+})() : NIL);
+})() : NIL); };
+PRIMITIVES["strict-check-args"] = strictCheckArgs;
+
   // eval-expr
   var evalExpr = function(expr, env) { return (function() { var _m = typeOf(expr); if (_m == "number") return expr; if (_m == "string") return expr; if (_m == "boolean") return expr; if (_m == "nil") return NIL; if (_m == "symbol") return (function() {
   var name = symbolName(expr);
@@ -826,7 +884,7 @@ PRIMITIVES["eval-list"] = evalList;
   var evalCall = function(head, args, env) { return (function() {
   var f = trampoline(evalExpr(head, env));
   var evaluatedArgs = map(function(a) { return trampoline(evalExpr(a, env)); }, args);
-  return (isSxTruthy((isSxTruthy(isCallable(f)) && isSxTruthy(!isSxTruthy(isLambda(f))) && isSxTruthy(!isSxTruthy(isComponent(f))) && !isSxTruthy(isIsland(f)))) ? apply(f, evaluatedArgs) : (isSxTruthy(isLambda(f)) ? callLambda(f, evaluatedArgs, env) : (isSxTruthy(isComponent(f)) ? callComponent(f, args, env) : (isSxTruthy(isIsland(f)) ? callComponent(f, args, env) : error((String("Not callable: ") + String(inspect(f))))))));
+  return (isSxTruthy((isSxTruthy(isCallable(f)) && isSxTruthy(!isSxTruthy(isLambda(f))) && isSxTruthy(!isSxTruthy(isComponent(f))) && !isSxTruthy(isIsland(f)))) ? ((isSxTruthy((isSxTruthy(_strict_) && (typeOf(head) == "symbol"))) ? strictCheckArgs(symbolName(head), evaluatedArgs) : NIL), apply(f, evaluatedArgs)) : (isSxTruthy(isLambda(f)) ? callLambda(f, evaluatedArgs, env) : (isSxTruthy(isComponent(f)) ? callComponent(f, args, env) : (isSxTruthy(isIsland(f)) ? callComponent(f, args, env) : error((String("Not callable: ") + String(inspect(f))))))));
 })(); };
 PRIMITIVES["eval-call"] = evalCall;
 
@@ -834,7 +892,7 @@ PRIMITIVES["eval-call"] = evalCall;
   var callLambda = function(f, args, callerEnv) { return (function() {
   var params = lambdaParams(f);
   var local = envMerge(lambdaClosure(f), callerEnv);
-  return (isSxTruthy((len(args) > len(params))) ? error((String(sxOr(lambdaName(f), "lambda")) + String(" expects ") + String(len(params)) + String(" args, got ") + String(len(args)))) : (forEach(function(pair) { return envSet(local, first(pair), nth(pair, 1)); }, zip(params, args)), forEach(function(p) { return envSet(local, p, NIL); }, slice(params, len(args))), makeThunk(lambdaBody(f), local)));
+  return (isSxTruthy((len(args) > len(params))) ? error((String(sxOr(lambdaName(f), "lambda")) + String(" expects ") + String(len(params)) + String(" args, got ") + String(len(args)))) : (forEach(function(pair) { return envBind(local, first(pair), nth(pair, 1)); }, zip(params, args)), forEach(function(p) { return envBind(local, p, NIL); }, slice(params, len(args))), makeThunk(lambdaBody(f), local)));
 })(); };
 PRIMITIVES["call-lambda"] = callLambda;
 
@@ -844,9 +902,9 @@ PRIMITIVES["call-lambda"] = callLambda;
   var kwargs = first(parsed);
   var children = nth(parsed, 1);
   var local = envMerge(componentClosure(comp), env);
-  { var _c = componentParams(comp); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envSet(local, p, sxOr(dictGet(kwargs, p), NIL)); } }
+  { var _c = componentParams(comp); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envBind(local, p, sxOr(dictGet(kwargs, p), NIL)); } }
   if (isSxTruthy(componentHasChildren(comp))) {
-  envSet(local, "children", children);
+  envBind(local, "children", children);
 }
   return makeThunk(componentBody(comp), local);
 })(); };
@@ -942,13 +1000,13 @@ PRIMITIVES["sf-or"] = sfOr;
   var local = envExtend(env);
   (isSxTruthy((isSxTruthy((typeOf(first(bindings)) == "list")) && (len(first(bindings)) == 2))) ? forEach(function(binding) { return (function() {
   var vname = (isSxTruthy((typeOf(first(binding)) == "symbol")) ? symbolName(first(binding)) : first(binding));
-  return envSet(local, vname, trampoline(evalExpr(nth(binding, 1), local)));
+  return envBind(local, vname, trampoline(evalExpr(nth(binding, 1), local)));
 })(); }, bindings) : (function() {
   var i = 0;
   return reduce(function(acc, pairIdx) { return (function() {
   var vname = (isSxTruthy((typeOf(nth(bindings, (pairIdx * 2))) == "symbol")) ? symbolName(nth(bindings, (pairIdx * 2))) : nth(bindings, (pairIdx * 2)));
   var valExpr = nth(bindings, ((pairIdx * 2) + 1));
-  return envSet(local, vname, trampoline(evalExpr(valExpr, local)));
+  return envBind(local, vname, trampoline(evalExpr(valExpr, local)));
 })(); }, NIL, range(0, (len(bindings) / 2)));
 })());
   { var _c = slice(body, 0, (len(body) - 1)); for (var _i = 0; _i < _c.length; _i++) { var e = _c[_i]; trampoline(evalExpr(e, local)); } }
@@ -969,7 +1027,7 @@ return append_b(inits, nth(binding, 1)); }, bindings) : reduce(function(acc, pai
   var loopBody = (isSxTruthy((len(body) == 1)) ? first(body) : cons(makeSymbol("begin"), body));
   var loopFn = makeLambda(params, loopBody, env);
   loopFn.name = loopName;
-  envSet(lambdaClosure(loopFn), loopName, loopFn);
+  envBind(lambdaClosure(loopFn), loopName, loopFn);
   return (function() {
   var initVals = map(function(e) { return trampoline(evalExpr(e, env)); }, inits);
   return callLambda(loopFn, initVals, env);
@@ -997,14 +1055,14 @@ PRIMITIVES["sf-lambda"] = sfLambda;
   if (isSxTruthy((isSxTruthy(isLambda(value)) && isNil(lambdaName(value))))) {
   value.name = symbolName(nameSym);
 }
-  envSet(env, symbolName(nameSym), value);
+  envBind(env, symbolName(nameSym), value);
   if (isSxTruthy(hasEffects)) {
   (function() {
   var effectsRaw = nth(args, 2);
   var effectList = (isSxTruthy((typeOf(effectsRaw) == "list")) ? map(function(e) { return (isSxTruthy((typeOf(e) == "symbol")) ? symbolName(e) : (String(e))); }, effectsRaw) : [(String(effectsRaw))]);
   var effectAnns = (isSxTruthy(envHas(env, "*effect-annotations*")) ? envGet(env, "*effect-annotations*") : {});
   effectAnns[symbolName(nameSym)] = effectList;
-  return envSet(env, "*effect-annotations*", effectAnns);
+  return envBind(env, "*effect-annotations*", effectAnns);
 })();
 }
   return value;
@@ -1033,10 +1091,10 @@ PRIMITIVES["sf-define"] = sfDefine;
   var effectList = (isSxTruthy((typeOf(effects) == "list")) ? map(function(e) { return (isSxTruthy((typeOf(e) == "symbol")) ? symbolName(e) : (String(e))); }, effects) : [(String(effects))]);
   var effectAnns = (isSxTruthy(envHas(env, "*effect-annotations*")) ? envGet(env, "*effect-annotations*") : {});
   effectAnns[symbolName(nameSym)] = effectList;
-  return envSet(env, "*effect-annotations*", effectAnns);
+  return envBind(env, "*effect-annotations*", effectAnns);
 })();
 }
-  envSet(env, symbolName(nameSym), comp);
+  envBind(env, symbolName(nameSym), comp);
   return comp;
 })();
 })(); };
@@ -1088,7 +1146,7 @@ PRIMITIVES["parse-comp-params"] = parseCompParams;
   var hasChildren = nth(parsed, 1);
   return (function() {
   var island = makeIsland(compName, params, hasChildren, body, env);
-  envSet(env, symbolName(nameSym), island);
+  envBind(env, symbolName(nameSym), island);
   return island;
 })();
 })(); };
@@ -1104,7 +1162,7 @@ PRIMITIVES["sf-defisland"] = sfDefisland;
   var restParam = nth(parsed, 1);
   return (function() {
   var mac = makeMacro(params, restParam, body, env, symbolName(nameSym));
-  envSet(env, symbolName(nameSym), mac);
+  envBind(env, symbolName(nameSym), mac);
   return mac;
 })();
 })(); };
@@ -1123,7 +1181,7 @@ PRIMITIVES["parse-macro-params"] = parseMacroParams;
   var sfDefstyle = function(args, env) { return (function() {
   var nameSym = first(args);
   var value = trampoline(evalExpr(nth(args, 1), env));
-  envSet(env, symbolName(nameSym), value);
+  envBind(env, symbolName(nameSym), value);
   return value;
 })(); };
 PRIMITIVES["sf-defstyle"] = sfDefstyle;
@@ -1153,7 +1211,7 @@ PRIMITIVES["normalize-type-body"] = normalizeTypeBody;
   var body = normalizeTypeBody(bodyExpr);
   var registry = (isSxTruthy(envHas(env, "*type-registry*")) ? envGet(env, "*type-registry*") : {});
   registry[typeName] = makeTypeDef(typeName, typeParams, body);
-  envSet(env, "*type-registry*", registry);
+  envBind(env, "*type-registry*", registry);
   return NIL;
 })();
 })(); };
@@ -1166,7 +1224,7 @@ PRIMITIVES["sf-deftype"] = sfDeftype;
   if (isSxTruthy(!isSxTruthy(contains(registry, effectName)))) {
   registry.push(effectName);
 }
-  envSet(env, "*effect-registry*", registry);
+  envBind(env, "*effect-registry*", registry);
   return NIL;
 })(); };
 PRIMITIVES["sf-defeffect"] = sfDefeffect;
@@ -1228,18 +1286,18 @@ PRIMITIVES["sf-set!"] = sfSetBang;
   var vname = (isSxTruthy((typeOf(first(binding)) == "symbol")) ? symbolName(first(binding)) : first(binding));
   names.push(vname);
   valExprs.push(nth(binding, 1));
-  return envSet(local, vname, NIL);
+  return envBind(local, vname, NIL);
 })(); }, bindings) : reduce(function(acc, pairIdx) { return (function() {
   var vname = (isSxTruthy((typeOf(nth(bindings, (pairIdx * 2))) == "symbol")) ? symbolName(nth(bindings, (pairIdx * 2))) : nth(bindings, (pairIdx * 2)));
   var valExpr = nth(bindings, ((pairIdx * 2) + 1));
   names.push(vname);
   valExprs.push(valExpr);
-  return envSet(local, vname, NIL);
+  return envBind(local, vname, NIL);
 })(); }, NIL, range(0, (len(bindings) / 2))));
   (function() {
   var values = map(function(e) { return trampoline(evalExpr(e, local)); }, valExprs);
-  { var _c = zip(names, values); for (var _i = 0; _i < _c.length; _i++) { var pair = _c[_i]; envSet(local, first(pair), nth(pair, 1)); } }
-  return forEach(function(val) { return (isSxTruthy(isLambda(val)) ? forEach(function(n) { return envSet(lambdaClosure(val), n, envGet(local, n)); }, names) : NIL); }, values);
+  { var _c = zip(names, values); for (var _i = 0; _i < _c.length; _i++) { var pair = _c[_i]; envBind(local, first(pair), nth(pair, 1)); } }
+  return forEach(function(val) { return (isSxTruthy(isLambda(val)) ? forEach(function(n) { return envBind(lambdaClosure(val), n, envGet(local, n)); }, names) : NIL); }, values);
 })();
   { var _c = slice(body, 0, (len(body) - 1)); for (var _i = 0; _i < _c.length; _i++) { var e = _c[_i]; trampoline(evalExpr(e, local)); } }
   return makeThunk(last(body), local);
@@ -1288,9 +1346,9 @@ PRIMITIVES["sf-provide"] = sfProvide;
   // expand-macro
   var expandMacro = function(mac, rawArgs, env) { return (function() {
   var local = envMerge(macroClosure(mac), env);
-  { var _c = mapIndexed(function(i, p) { return [p, i]; }, macroParams(mac)); for (var _i = 0; _i < _c.length; _i++) { var pair = _c[_i]; envSet(local, first(pair), (isSxTruthy((nth(pair, 1) < len(rawArgs))) ? nth(rawArgs, nth(pair, 1)) : NIL)); } }
+  { var _c = mapIndexed(function(i, p) { return [p, i]; }, macroParams(mac)); for (var _i = 0; _i < _c.length; _i++) { var pair = _c[_i]; envBind(local, first(pair), (isSxTruthy((nth(pair, 1) < len(rawArgs))) ? nth(rawArgs, nth(pair, 1)) : NIL)); } }
   if (isSxTruthy(macroRestParam(mac))) {
-  envSet(local, macroRestParam(mac), slice(rawArgs, len(macroParams(mac))));
+  envBind(local, macroRestParam(mac), slice(rawArgs, len(macroParams(mac))));
 }
   return trampoline(evalExpr(macroBody(mac), local));
 })(); };
@@ -1426,7 +1484,7 @@ PRIMITIVES["eval-cond-clojure"] = evalCondClojure;
   { var _c = bindings; for (var _i = 0; _i < _c.length; _i++) { var pair = _c[_i]; if (isSxTruthy((isSxTruthy((typeOf(pair) == "list")) && (len(pair) >= 2)))) {
   (function() {
   var name = (isSxTruthy((typeOf(first(pair)) == "symbol")) ? symbolName(first(pair)) : (String(first(pair))));
-  return envSet(local, name, trampoline(evalExpr(nth(pair, 1), local)));
+  return envBind(local, name, trampoline(evalExpr(nth(pair, 1), local)));
 })();
 } } }
   return local;
@@ -1713,7 +1771,7 @@ PRIMITIVES["dispatch-html-form"] = dispatchHtmlForm;
   // render-lambda-html
   var renderLambdaHtml = function(f, args, env) { return (function() {
   var local = envMerge(lambdaClosure(f), env);
-  forEachIndexed(function(i, p) { return envSet(local, p, nth(args, i)); }, lambdaParams(f));
+  forEachIndexed(function(i, p) { return envBind(local, p, nth(args, i)); }, lambdaParams(f));
   return renderToHtml(lambdaBody(f), local);
 })(); };
 PRIMITIVES["render-lambda-html"] = renderLambdaHtml;
@@ -1732,9 +1790,9 @@ PRIMITIVES["render-lambda-html"] = renderLambdaHtml;
 })(); }, {["i"]: 0, ["skip"]: false}, args);
   return (function() {
   var local = envMerge(componentClosure(comp), env);
-  { var _c = componentParams(comp); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envSet(local, p, (isSxTruthy(dictHas(kwargs, p)) ? dictGet(kwargs, p) : NIL)); } }
+  { var _c = componentParams(comp); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envBind(local, p, (isSxTruthy(dictHas(kwargs, p)) ? dictGet(kwargs, p) : NIL)); } }
   if (isSxTruthy(componentHasChildren(comp))) {
-  envSet(local, "children", makeRawHtml(join("", map(function(c) { return renderToHtml(c, env); }, children))));
+  envBind(local, "children", makeRawHtml(join("", map(function(c) { return renderToHtml(c, env); }, children))));
 }
   return renderToHtml(componentBody(comp), local);
 })();
@@ -1825,9 +1883,9 @@ PRIMITIVES["render-html-marsh"] = renderHtmlMarsh;
   return (function() {
   var local = envMerge(componentClosure(island), env);
   var islandName = componentName(island);
-  { var _c = componentParams(island); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envSet(local, p, (isSxTruthy(dictHas(kwargs, p)) ? dictGet(kwargs, p) : NIL)); } }
+  { var _c = componentParams(island); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envBind(local, p, (isSxTruthy(dictHas(kwargs, p)) ? dictGet(kwargs, p) : NIL)); } }
   if (isSxTruthy(componentHasChildren(island))) {
-  envSet(local, "children", makeRawHtml(join("", map(function(c) { return renderToHtml(c, env); }, children))));
+  envBind(local, "children", makeRawHtml(join("", map(function(c) { return renderToHtml(c, env); }, children))));
 }
   return (function() {
   var bodyHtml = renderToHtml(componentBody(island), local);
@@ -1978,7 +2036,7 @@ return result; }, args);
   var coll = trampoline(evalExpr(nth(args, 1), env));
   return map(function(item) { return (isSxTruthy(isLambda(f)) ? (function() {
   var local = envMerge(lambdaClosure(f), env);
-  envSet(local, first(lambdaParams(f)), item);
+  envBind(local, first(lambdaParams(f)), item);
   return aser(lambdaBody(f), local);
 })() : cekCall(f, [item])); }, coll);
 })() : (isSxTruthy((name == "map-indexed")) ? (function() {
@@ -1986,8 +2044,8 @@ return result; }, args);
   var coll = trampoline(evalExpr(nth(args, 1), env));
   return mapIndexed(function(i, item) { return (isSxTruthy(isLambda(f)) ? (function() {
   var local = envMerge(lambdaClosure(f), env);
-  envSet(local, first(lambdaParams(f)), i);
-  envSet(local, nth(lambdaParams(f), 1), item);
+  envBind(local, first(lambdaParams(f)), i);
+  envBind(local, nth(lambdaParams(f), 1), item);
   return aser(lambdaBody(f), local);
 })() : cekCall(f, [i, item])); }, coll);
 })() : (isSxTruthy((name == "for-each")) ? (function() {
@@ -1996,7 +2054,7 @@ return result; }, args);
   var results = [];
   { var _c = coll; for (var _i = 0; _i < _c.length; _i++) { var item = _c[_i]; (isSxTruthy(isLambda(f)) ? (function() {
   var local = envMerge(lambdaClosure(f), env);
-  envSet(local, first(lambdaParams(f)), item);
+  envBind(local, first(lambdaParams(f)), item);
   return append_b(results, aser(lambdaBody(f), local));
 })() : cekCall(f, [item])); } }
   return (isSxTruthy(isEmpty(results)) ? NIL : results);
@@ -2134,7 +2192,7 @@ PRIMITIVES["render-dom-element"] = renderDomElement;
 })(); }, {["i"]: 0, ["skip"]: false}, args);
   return (function() {
   var local = envMerge(componentClosure(comp), env);
-  { var _c = componentParams(comp); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envSet(local, p, (isSxTruthy(dictHas(kwargs, p)) ? dictGet(kwargs, p) : NIL)); } }
+  { var _c = componentParams(comp); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envBind(local, p, (isSxTruthy(dictHas(kwargs, p)) ? dictGet(kwargs, p) : NIL)); } }
   if (isSxTruthy(componentHasChildren(comp))) {
   (function() {
   var childFrag = createFragment();
@@ -2142,7 +2200,7 @@ PRIMITIVES["render-dom-element"] = renderDomElement;
   var result = renderToDom(c, env, ns);
   return (isSxTruthy(!isSxTruthy(isSpread(result))) ? domAppend(childFrag, result) : NIL);
 })(); } }
-  return envSet(local, "children", childFrag);
+  return envBind(local, "children", childFrag);
 })();
 }
   return renderToDom(componentBody(comp), local, ns);
@@ -2346,7 +2404,7 @@ PRIMITIVES["dispatch-render-form"] = dispatchRenderForm;
   // render-lambda-dom
   var renderLambdaDom = function(f, args, env, ns) { return (function() {
   var local = envMerge(lambdaClosure(f), env);
-  forEachIndexed(function(i, p) { return envSet(local, p, nth(args, i)); }, lambdaParams(f));
+  forEachIndexed(function(i, p) { return envBind(local, p, nth(args, i)); }, lambdaParams(f));
   return renderToDom(lambdaBody(f), local, ns);
 })(); };
 PRIMITIVES["render-lambda-dom"] = renderLambdaDom;
@@ -2366,12 +2424,12 @@ PRIMITIVES["render-lambda-dom"] = renderLambdaDom;
   return (function() {
   var local = envMerge(componentClosure(island), env);
   var islandName = componentName(island);
-  { var _c = componentParams(island); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envSet(local, p, (isSxTruthy(dictHas(kwargs, p)) ? dictGet(kwargs, p) : NIL)); } }
+  { var _c = componentParams(island); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envBind(local, p, (isSxTruthy(dictHas(kwargs, p)) ? dictGet(kwargs, p) : NIL)); } }
   if (isSxTruthy(componentHasChildren(island))) {
   (function() {
   var childFrag = createFragment();
   { var _c = children; for (var _i = 0; _i < _c.length; _i++) { var c = _c[_i]; domAppend(childFrag, renderToDom(c, env, ns)); } }
-  return envSet(local, "children", childFrag);
+  return envBind(local, "children", childFrag);
 })();
 }
   return (function() {
@@ -3648,9 +3706,9 @@ PRIMITIVES["bind-sse-swap"] = bindSseSwap;
   var exprs = sxParse(body);
   return domListen(el, eventName, function(e) { return (function() {
   var handlerEnv = envExtend({});
-  envSet(handlerEnv, "event", e);
-  envSet(handlerEnv, "this", el);
-  envSet(handlerEnv, "detail", eventDetail(e));
+  envBind(handlerEnv, "event", e);
+  envBind(handlerEnv, "this", el);
+  envBind(handlerEnv, "detail", eventDetail(e));
   return forEach(function(expr) { return evalExpr(expr, handlerEnv); }, exprs);
 })(); });
 })()) : NIL);
@@ -3912,7 +3970,7 @@ PRIMITIVES["sx-hydrate-islands"] = sxHydrateIslands;
   var kwargs = sxOr(first(sxParse(stateSx)), {});
   var disposers = [];
   var local = envMerge(componentClosure(comp), env);
-  { var _c = componentParams(comp); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envSet(local, p, (isSxTruthy(dictHas(kwargs, p)) ? dictGet(kwargs, p) : NIL)); } }
+  { var _c = componentParams(comp); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envBind(local, p, (isSxTruthy(dictHas(kwargs, p)) ? dictGet(kwargs, p) : NIL)); } }
   return (function() {
   var bodyDom = withIslandScope(function(disposable) { return append_b(disposers, disposable); }, function() { return renderToDom(componentBody(comp), local, NIL); });
   domSetTextContent(el, "");
@@ -4214,7 +4272,7 @@ PRIMITIVES["make-define-frame"] = makeDefineFrame;
 PRIMITIVES["make-set-frame"] = makeSetFrame;
 
   // make-arg-frame
-  var makeArgFrame = function(f, evaled, remaining, env, rawArgs) { return {"type": "arg", "f": f, "evaled": evaled, "remaining": remaining, "env": env, "raw-args": rawArgs}; };
+  var makeArgFrame = function(f, evaled, remaining, env, rawArgs, headName) { return {"type": "arg", "f": f, "evaled": evaled, "remaining": remaining, "env": env, "raw-args": rawArgs, "head-name": sxOr(headName, NIL)}; };
 PRIMITIVES["make-arg-frame"] = makeArgFrame;
 
   // make-call-frame
@@ -4948,7 +5006,7 @@ PRIMITIVES["step-sf-reset"] = stepSfReset;
   var k = makeCekContinuation(captured, restKont);
   return (function() {
   var shiftEnv = envExtend(env);
-  envSet(shiftEnv, kName, k);
+  envBind(shiftEnv, kName, k);
   return makeCekState(body, shiftEnv, restKont);
 })();
 })();
@@ -4996,7 +5054,10 @@ return forEach(function(d) { return cekCall(d, NIL); }, subDisposers); });
 PRIMITIVES["reactive-shift-deref"] = reactiveShiftDeref;
 
   // step-eval-call
-  var stepEvalCall = function(head, args, env, kont) { return makeCekState(head, env, kontPush(makeArgFrame(NIL, [], args, env, args), kont)); };
+  var stepEvalCall = function(head, args, env, kont) { return (function() {
+  var hname = (isSxTruthy((typeOf(head) == "symbol")) ? symbolName(head) : NIL);
+  return makeCekState(head, env, kontPush(makeArgFrame(NIL, [], args, env, args, hname), kont));
+})(); };
 PRIMITIVES["step-eval-call"] = stepEvalCall;
 
   // step-ho-map
@@ -5078,7 +5139,7 @@ PRIMITIVES["step-ho-for-each"] = stepHoForEach;
   var remaining = get(frame, "remaining");
   var body = get(frame, "body");
   var local = get(frame, "env");
-  envSet(local, name, value);
+  envBind(local, name, value);
   return (isSxTruthy(isEmpty(remaining)) ? stepSfBegin(body, local, restK) : (function() {
   var nextBinding = first(remaining);
   var vname = (isSxTruthy((typeOf(first(nextBinding)) == "symbol")) ? symbolName(first(nextBinding)) : first(nextBinding));
@@ -5092,13 +5153,13 @@ PRIMITIVES["step-ho-for-each"] = stepHoForEach;
   if (isSxTruthy((isSxTruthy(isLambda(value)) && isNil(lambdaName(value))))) {
   value.name = name;
 }
-  envSet(fenv, name, value);
+  envBind(fenv, name, value);
   if (isSxTruthy(hasEffects)) {
   (function() {
   var effectNames = (isSxTruthy((typeOf(effectList) == "list")) ? map(function(e) { return (isSxTruthy((typeOf(e) == "symbol")) ? symbolName(e) : (String(e))); }, effectList) : [(String(effectList))]);
   var effectAnns = (isSxTruthy(envHas(fenv, "*effect-annotations*")) ? envGet(fenv, "*effect-annotations*") : {});
   effectAnns[name] = effectNames;
-  return envSet(fenv, "*effect-annotations*", effectAnns);
+  return envBind(fenv, "*effect-annotations*", effectAnns);
 })();
 }
   return makeCekValue(value, fenv, restK);
@@ -5161,9 +5222,10 @@ PRIMITIVES["step-ho-for-each"] = stepHoForEach;
   var remaining = get(frame, "remaining");
   var fenv = get(frame, "env");
   var rawArgs = get(frame, "raw-args");
-  return (isSxTruthy(isNil(f)) ? (isSxTruthy(isEmpty(remaining)) ? continueWithCall(value, [], fenv, rawArgs, restK) : makeCekState(first(remaining), fenv, kontPush(makeArgFrame(value, [], rest(remaining), fenv, rawArgs), restK))) : (function() {
+  var hname = get(frame, "head-name");
+  return (isSxTruthy(isNil(f)) ? ((isSxTruthy((isSxTruthy(_strict_) && hname)) ? strictCheckArgs(hname, []) : NIL), (isSxTruthy(isEmpty(remaining)) ? continueWithCall(value, [], fenv, rawArgs, restK) : makeCekState(first(remaining), fenv, kontPush(makeArgFrame(value, [], rest(remaining), fenv, rawArgs, hname), restK)))) : (function() {
   var newEvaled = append(evaled, [value]);
-  return (isSxTruthy(isEmpty(remaining)) ? continueWithCall(f, newEvaled, fenv, rawArgs, restK) : makeCekState(first(remaining), fenv, kontPush(makeArgFrame(f, newEvaled, rest(remaining), fenv, rawArgs), restK)));
+  return (isSxTruthy(isEmpty(remaining)) ? ((isSxTruthy((isSxTruthy(_strict_) && hname)) ? strictCheckArgs(hname, newEvaled) : NIL), continueWithCall(f, newEvaled, fenv, rawArgs, restK)) : makeCekState(first(remaining), fenv, kontPush(makeArgFrame(f, newEvaled, rest(remaining), fenv, rawArgs, hname), restK)));
 })());
 })() : (isSxTruthy((ft == "dict")) ? (function() {
   var remaining = get(frame, "remaining");
@@ -5265,15 +5327,15 @@ PRIMITIVES["step-continue"] = stepContinue;
 })() : (isSxTruthy((isSxTruthy(isCallable(f)) && isSxTruthy(!isSxTruthy(isLambda(f))) && isSxTruthy(!isSxTruthy(isComponent(f))) && !isSxTruthy(isIsland(f)))) ? makeCekValue(apply(f, args), env, kont) : (isSxTruthy(isLambda(f)) ? (function() {
   var params = lambdaParams(f);
   var local = envMerge(lambdaClosure(f), env);
-  return (isSxTruthy((len(args) > len(params))) ? error((String(sxOr(lambdaName(f), "lambda")) + String(" expects ") + String(len(params)) + String(" args, got ") + String(len(args)))) : (forEach(function(pair) { return envSet(local, first(pair), nth(pair, 1)); }, zip(params, args)), forEach(function(p) { return envSet(local, p, NIL); }, slice(params, len(args))), makeCekState(lambdaBody(f), local, kont)));
+  return (isSxTruthy((len(args) > len(params))) ? error((String(sxOr(lambdaName(f), "lambda")) + String(" expects ") + String(len(params)) + String(" args, got ") + String(len(args)))) : (forEach(function(pair) { return envBind(local, first(pair), nth(pair, 1)); }, zip(params, args)), forEach(function(p) { return envBind(local, p, NIL); }, slice(params, len(args))), makeCekState(lambdaBody(f), local, kont)));
 })() : (isSxTruthy(sxOr(isComponent(f), isIsland(f))) ? (function() {
   var parsed = parseKeywordArgs(rawArgs, env);
   var kwargs = first(parsed);
   var children = nth(parsed, 1);
   var local = envMerge(componentClosure(f), env);
-  { var _c = componentParams(f); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envSet(local, p, sxOr(dictGet(kwargs, p), NIL)); } }
+  { var _c = componentParams(f); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envBind(local, p, sxOr(dictGet(kwargs, p), NIL)); } }
   if (isSxTruthy(componentHasChildren(f))) {
-  envSet(local, "children", children);
+  envBind(local, "children", children);
 }
   return makeCekState(componentBody(f), local, kont);
 })() : error((String("Not callable: ") + String(inspect(f)))))))); };
@@ -5787,6 +5849,20 @@ PRIMITIVES["resource"] = resource;
     return cekValue(state);
   };
 
+  // CEK is the canonical evaluator — override evalExpr to use it.
+  // The tree-walk evaluator (evalExpr from eval.sx) is superseded.
+  var _treeWalkEvalExpr = evalExpr;
+  evalExpr = function(expr, env) {
+    return cekRun(makeCekState(expr, env, []));
+  };
+
+  // CEK never produces thunks — trampoline resolves any legacy thunks
+  var _treeWalkTrampoline = trampoline;
+  trampoline = function(val) {
+    if (isThunk(val)) return evalExpr(thunkExpr(val), thunkEnv(val));
+    return val;
+  };
+
   // Platform functions — defined in platform_js.py, not in .sx spec files.
   // Spec defines self-register via js-emit-define; these are the platform interface.
   PRIMITIVES["type-of"] = typeOf;
@@ -7851,6 +7927,7 @@ PRIMITIVES["resource"] = resource;
     isTruthy: isSxTruthy,
     isNil: isNil,
     componentEnv: componentEnv,
+    setRenderActive: function(val) { setRenderActiveB(val); },
     renderToHtml: function(expr, env) { return renderToHtml(expr, env || merge(componentEnv)); },
     renderToSx: function(expr, env) { return renderToSx(expr, env || merge(componentEnv)); },
     renderToDom: _hasDom ? function(expr, env, ns) { return renderToDom(expr, env || merge(componentEnv), ns || null); } : null,

shared/sx/ref/boundary-app.sx

@@ -1,206 +0,0 @@
-;; ==========================================================================
-;; boundary-app.sx — Deployment-specific boundary declarations
-;;
-;; I/O primitives specific to THIS deployment's architecture:
-;; inter-service communication, framework bindings, domain concepts,
-;; and layout context providers.
-;;
-;; These are NOT part of the SX language contract — a different deployment
-;; would declare different primitives here.
-;;
-;; The core SX I/O contract lives in boundary.sx.
-;; Per-service page helpers live in {service}/sx/boundary.sx.
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Inter-service communication — microservice architecture
-;; --------------------------------------------------------------------------
-
-(define-io-primitive "frag"
-  :params (service frag-type &key)
-  :returns "string"
-  :async true
-  :doc "Fetch cross-service HTML fragment."
-  :context :request)
-
-(define-io-primitive "query"
-  :params (service query-name &key)
-  :returns "any"
-  :async true
-  :doc "Fetch data from another service via internal HTTP."
-  :context :request)
-
-(define-io-primitive "action"
-  :params (service action-name &key)
-  :returns "any"
-  :async true
-  :doc "Call an action on another service via internal HTTP."
-  :context :request)
-
-(define-io-primitive "service"
-  :params (service-or-method &rest args &key)
-  :returns "any"
-  :async true
-  :doc "Call a domain service method. Two-arg: (service svc method). One-arg: (service method) uses bound handler service."
-  :context :request)
-
-
-;; --------------------------------------------------------------------------
-;; Framework bindings — Quart/Jinja2/HTMX specifics
-;; --------------------------------------------------------------------------
-
-(define-io-primitive "htmx-request?"
-  :params ()
-  :returns "boolean"
-  :async true
-  :doc "True if current request has HX-Request header."
-  :context :request)
-
-(define-io-primitive "g"
-  :params (key)
-  :returns "any"
-  :async true
-  :doc "Read a value from the Quart request-local g object."
-  :context :request)
-
-(define-io-primitive "jinja-global"
-  :params (key &rest default)
-  :returns "any"
-  :async false
-  :doc "Read a Jinja environment global."
-  :context :request)
-
-
-;; --------------------------------------------------------------------------
-;; Domain concepts — navigation, relations
-;; --------------------------------------------------------------------------
-
-(define-io-primitive "nav-tree"
-  :params ()
-  :returns "list"
-  :async true
-  :doc "Navigation tree as list of node dicts."
-  :context :request)
-
-(define-io-primitive "get-children"
-  :params (&key parent-type parent-id)
-  :returns "list"
-  :async true
-  :doc "Fetch child entities for a parent."
-  :context :request)
-
-(define-io-primitive "relations-from"
-  :params (entity-type)
-  :returns "list"
-  :async false
-  :doc "List of RelationDef dicts for an entity type."
-  :context :config)
-
-
-;; --------------------------------------------------------------------------
-;; Layout context providers — per-service header/page context
-;; --------------------------------------------------------------------------
-
-;; Shared across all services (root layout)
-
-(define-io-primitive "root-header-ctx"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "Dict with root header values (cart-mini, auth-menu, nav-tree, etc.)."
-  :context :request)
-
-(define-io-primitive "select-colours"
-  :params ()
-  :returns "string"
-  :async true
-  :doc "Shared select/hover CSS class string."
-  :context :request)
-
-(define-io-primitive "account-nav-ctx"
-  :params ()
-  :returns "any"
-  :async true
-  :doc "Account nav fragments, or nil."
-  :context :request)
-
-(define-io-primitive "app-rights"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "User rights dict from g.rights."
-  :context :request)
-
-;; Blog service layout
-
-(define-io-primitive "post-header-ctx"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "Dict with post-level header values."
-  :context :request)
-
-;; Cart service layout
-
-(define-io-primitive "cart-page-ctx"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "Dict with cart page header values."
-  :context :request)
-
-;; Events service layouts
-
-(define-io-primitive "events-calendar-ctx"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "Dict with events calendar header values."
-  :context :request)
-
-(define-io-primitive "events-day-ctx"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "Dict with events day header values."
-  :context :request)
-
-(define-io-primitive "events-entry-ctx"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "Dict with events entry header values."
-  :context :request)
-
-(define-io-primitive "events-slot-ctx"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "Dict with events slot header values."
-  :context :request)
-
-(define-io-primitive "events-ticket-type-ctx"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "Dict with ticket type header values."
-  :context :request)
-
-;; Market service layout
-
-(define-io-primitive "market-header-ctx"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "Dict with market header data."
-  :context :request)
-
-;; Federation service layout
-
-(define-io-primitive "federation-actor-ctx"
-  :params ()
-  :returns "dict?"
-  :async true
-  :doc "Serialized ActivityPub actor dict or nil."
-  :context :request)

shared/sx/ref/test-parser.sx

@@ -1,259 +0,0 @@
-;; ==========================================================================
-;; test-parser.sx — Tests for the SX parser and serializer
-;;
-;; Requires: test-framework.sx loaded first.
-;; Modules tested: parser.sx
-;;
-;; Platform functions required (beyond test framework):
-;;   sx-parse       (source)  -> list of AST expressions
-;;   sx-serialize   (expr)    -> SX source string
-;;   make-symbol    (name)    -> Symbol value
-;;   make-keyword   (name)    -> Keyword value
-;;   symbol-name    (sym)     -> string
-;;   keyword-name   (kw)      -> string
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Literal parsing
-;; --------------------------------------------------------------------------
-
-(defsuite "parser-literals"
-  (deftest "parse integers"
-    (assert-equal (list 42) (sx-parse "42"))
-    (assert-equal (list 0) (sx-parse "0"))
-    (assert-equal (list -7) (sx-parse "-7")))
-
-  (deftest "parse floats"
-    (assert-equal (list 3.14) (sx-parse "3.14"))
-    (assert-equal (list -0.5) (sx-parse "-0.5")))
-
-  (deftest "parse strings"
-    (assert-equal (list "hello") (sx-parse "\"hello\""))
-    (assert-equal (list "") (sx-parse "\"\"")))
-
-  (deftest "parse escape: newline"
-    (assert-equal (list "a\nb") (sx-parse "\"a\\nb\"")))
-
-  (deftest "parse escape: tab"
-    (assert-equal (list "a\tb") (sx-parse "\"a\\tb\"")))
-
-  (deftest "parse escape: quote"
-    (assert-equal (list "a\"b") (sx-parse "\"a\\\"b\"")))
-
-  (deftest "parse booleans"
-    (assert-equal (list true) (sx-parse "true"))
-    (assert-equal (list false) (sx-parse "false")))
-
-  (deftest "parse nil"
-    (assert-equal (list nil) (sx-parse "nil")))
-
-  (deftest "parse keywords"
-    (let ((result (sx-parse ":hello")))
-      (assert-length 1 result)
-      (assert-equal "hello" (keyword-name (first result)))))
-
-  (deftest "parse symbols"
-    (let ((result (sx-parse "foo")))
-      (assert-length 1 result)
-      (assert-equal "foo" (symbol-name (first result))))))
-
-
-;; --------------------------------------------------------------------------
-;; Composite parsing
-;; --------------------------------------------------------------------------
-
-(defsuite "parser-lists"
-  (deftest "parse empty list"
-    (let ((result (sx-parse "()")))
-      (assert-length 1 result)
-      (assert-equal (list) (first result))))
-
-  (deftest "parse list of numbers"
-    (let ((result (sx-parse "(1 2 3)")))
-      (assert-length 1 result)
-      (assert-equal (list 1 2 3) (first result))))
-
-  (deftest "parse nested lists"
-    (let ((result (sx-parse "(1 (2 3) 4)")))
-      (assert-length 1 result)
-      (assert-equal (list 1 (list 2 3) 4) (first result))))
-
-  (deftest "parse square brackets as list"
-    (let ((result (sx-parse "[1 2 3]")))
-      (assert-length 1 result)
-      (assert-equal (list 1 2 3) (first result))))
-
-  (deftest "parse mixed types"
-    (let ((result (sx-parse "(42 \"hello\" true nil)")))
-      (assert-length 1 result)
-      (let ((lst (first result)))
-        (assert-equal 42 (nth lst 0))
-        (assert-equal "hello" (nth lst 1))
-        (assert-equal true (nth lst 2))
-        (assert-nil (nth lst 3))))))
-
-
-;; --------------------------------------------------------------------------
-;; Dict parsing
-;; --------------------------------------------------------------------------
-
-(defsuite "parser-dicts"
-  (deftest "parse empty dict"
-    (let ((result (sx-parse "{}")))
-      (assert-length 1 result)
-      (assert-type "dict" (first result))))
-
-  (deftest "parse dict with keyword keys"
-    (let ((result (sx-parse "{:a 1 :b 2}")))
-      (assert-length 1 result)
-      (let ((d (first result)))
-        (assert-type "dict" d)
-        (assert-equal 1 (get d "a"))
-        (assert-equal 2 (get d "b")))))
-
-  (deftest "parse dict with string values"
-    (let ((result (sx-parse "{:name \"alice\"}")))
-      (assert-length 1 result)
-      (assert-equal "alice" (get (first result) "name")))))
-
-
-;; --------------------------------------------------------------------------
-;; Comments and whitespace
-;; --------------------------------------------------------------------------
-
-(defsuite "parser-whitespace"
-  (deftest "skip line comments"
-    (assert-equal (list 42) (sx-parse ";; comment\n42"))
-    (assert-equal (list 1 2) (sx-parse "1 ;; middle\n2")))
-
-  (deftest "skip whitespace"
-    (assert-equal (list 42) (sx-parse "  42  "))
-    (assert-equal (list 1 2) (sx-parse " 1 \n\t 2 ")))
-
-  (deftest "parse multiple top-level expressions"
-    (assert-length 3 (sx-parse "1 2 3"))
-    (assert-equal (list 1 2 3) (sx-parse "1 2 3")))
-
-  (deftest "empty input"
-    (assert-equal (list) (sx-parse "")))
-
-  (deftest "only comments"
-    (assert-equal (list) (sx-parse ";; just a comment\n;; another"))))
-
-
-;; --------------------------------------------------------------------------
-;; Quote sugar
-;; --------------------------------------------------------------------------
-
-(defsuite "parser-quote-sugar"
-  (deftest "quasiquote"
-    (let ((result (sx-parse "`foo")))
-      (assert-length 1 result)
-      (let ((expr (first result)))
-        (assert-type "list" expr)
-        (assert-equal "quasiquote" (symbol-name (first expr))))))
-
-  (deftest "unquote"
-    (let ((result (sx-parse ",foo")))
-      (assert-length 1 result)
-      (let ((expr (first result)))
-        (assert-type "list" expr)
-        (assert-equal "unquote" (symbol-name (first expr))))))
-
-  (deftest "splice-unquote"
-    (let ((result (sx-parse ",@foo")))
-      (assert-length 1 result)
-      (let ((expr (first result)))
-        (assert-type "list" expr)
-        (assert-equal "splice-unquote" (symbol-name (first expr)))))))
-
-
-;; --------------------------------------------------------------------------
-;; Serializer
-;; --------------------------------------------------------------------------
-
-(defsuite "serializer"
-  (deftest "serialize number"
-    (assert-equal "42" (sx-serialize 42)))
-
-  (deftest "serialize string"
-    (assert-equal "\"hello\"" (sx-serialize "hello")))
-
-  (deftest "serialize boolean"
-    (assert-equal "true" (sx-serialize true))
-    (assert-equal "false" (sx-serialize false)))
-
-  (deftest "serialize nil"
-    (assert-equal "nil" (sx-serialize nil)))
-
-  (deftest "serialize keyword"
-    (assert-equal ":foo" (sx-serialize (make-keyword "foo"))))
-
-  (deftest "serialize symbol"
-    (assert-equal "bar" (sx-serialize (make-symbol "bar"))))
-
-  (deftest "serialize list"
-    (assert-equal "(1 2 3)" (sx-serialize (list 1 2 3))))
-
-  (deftest "serialize empty list"
-    (assert-equal "()" (sx-serialize (list))))
-
-  (deftest "serialize nested"
-    (assert-equal "(1 (2 3) 4)" (sx-serialize (list 1 (list 2 3) 4)))))
-
-
-;; --------------------------------------------------------------------------
-;; Round-trip: parse then serialize
-;; --------------------------------------------------------------------------
-
-(defsuite "parser-roundtrip"
-  (deftest "roundtrip number"
-    (assert-equal "42" (sx-serialize (first (sx-parse "42")))))
-
-  (deftest "roundtrip string"
-    (assert-equal "\"hello\"" (sx-serialize (first (sx-parse "\"hello\"")))))
-
-  (deftest "roundtrip list"
-    (assert-equal "(1 2 3)" (sx-serialize (first (sx-parse "(1 2 3)")))))
-
-  (deftest "roundtrip nested"
-    (assert-equal "(a (b c))"
-      (sx-serialize (first (sx-parse "(a (b c))"))))))
-
-
-;; --------------------------------------------------------------------------
-;; Reader macros
-;; --------------------------------------------------------------------------
-
-(defsuite "reader-macros"
-  (deftest "datum comment discards expr"
-    (assert-equal (list 42) (sx-parse "#;(ignored) 42")))
-
-  (deftest "datum comment in list"
-    (assert-equal (list (list 1 3)) (sx-parse "(1 #;2 3)")))
-
-  (deftest "datum comment discards nested"
-    (assert-equal (list 99) (sx-parse "#;(a (b c) d) 99")))
-
-  (deftest "raw string basic"
-    (assert-equal (list "hello") (sx-parse "#|hello|")))
-
-  (deftest "raw string with quotes"
-    (assert-equal (list "say \"hi\"") (sx-parse "#|say \"hi\"|")))
-
-  (deftest "raw string with backslashes"
-    (assert-equal (list "a\\nb") (sx-parse "#|a\\nb|")))
-
-  (deftest "raw string empty"
-    (assert-equal (list "") (sx-parse "#||")))
-
-  (deftest "quote shorthand symbol"
-    (let ((result (first (sx-parse "#'foo"))))
-      (assert-equal "quote" (symbol-name (first result)))
-      (assert-equal "foo" (symbol-name (nth result 1)))))
-
-  (deftest "quote shorthand list"
-    (let ((result (first (sx-parse "#'(1 2 3)"))))
-      (assert-equal "quote" (symbol-name (first result)))
-      (assert-equal (list 1 2 3) (nth result 1)))))

shared/sx/templates/layout.sx

@@ -20,7 +20,7 @@
                  :class "hidden md:flex md:flex-col max-w-xs md:h-full md:min-h-0 mr-3"
             (when aside aside))
           (section :id "main-panel"
-                   :class "flex-1 md:h-full md:min-h-0 overflow-y-auto overscroll-contain js-grid-viewport"
+                   :class "flex-1 md:h-full md:min-h-0 md:overflow-y-auto md:overscroll-contain js-grid-viewport"
             (when content content)
             (div :class "pb-8")))))))
 
@@ -35,7 +35,7 @@
     (div :id "root-menu" :sx-swap-oob "outerHTML" :class "md:hidden"
       (when menu menu))
     (section :id "main-panel"
-             :class "flex-1 md:h-full md:min-h-0 overflow-y-auto overscroll-contain js-grid-viewport"
+             :class "flex-1 md:h-full md:min-h-0 md:overflow-y-auto md:overscroll-contain js-grid-viewport"
       (when content content))))
 
 (defcomp ~shared:layout/hamburger ()

spec/cek.sx

@@ -396,7 +396,7 @@
       (let ((k (make-cek-continuation captured rest-kont)))
         ;; Evaluate shift body with k bound, continuation goes to rest-kont
         (let ((shift-env (env-extend env)))
-          (env-set! shift-env k-name k)
+          (env-bind! shift-env k-name k)
           (make-cek-state body shift-env rest-kont))))))
 
 
@@ -466,11 +466,13 @@
 (define step-eval-call
   (fn (head args env kont)
     ;; First evaluate the head, then evaluate args left-to-right
-    (make-cek-state
-      head env
-      (kont-push
-        (make-arg-frame nil (list) args env args)
-        kont))))
+    ;; Preserve head name for strict mode type checking
+    (let ((hname (if (= (type-of head) "symbol") (symbol-name head) nil)))
+      (make-cek-state
+        head env
+        (kont-push
+          (make-arg-frame nil (list) args env args hname)
+          kont)))))
 
 
 ;; --------------------------------------------------------------------------
@@ -604,7 +606,7 @@
                     (body (get frame "body"))
                     (local (get frame "env")))
                 ;; Bind the value
-                (env-set! local name value)
+                (env-bind! local name value)
                 ;; More bindings?
                 (if (empty? remaining)
                   ;; All bindings done — evaluate body
@@ -628,7 +630,7 @@
                     (effect-list (get frame "effect-list")))
                 (when (and (lambda? value) (nil? (lambda-name value)))
                   (set-lambda-name! value name))
-                (env-set! fenv name value)
+                (env-bind! fenv name value)
                 ;; Effect annotation
                 (when has-effects
                   (let ((effect-names (if (= (type-of effect-list) "list")
@@ -640,7 +642,7 @@
                                        (env-get fenv "*effect-annotations*")
                                        (dict))))
                     (dict-set! effect-anns name effect-names)
-                    (env-set! fenv "*effect-annotations*" effect-anns)))
+                    (env-bind! fenv "*effect-annotations*" effect-anns)))
                 (make-cek-value value fenv rest-k))
 
             ;; --- SetFrame: value evaluated ---
@@ -760,28 +762,36 @@
                     (evaled (get frame "evaled"))
                     (remaining (get frame "remaining"))
                     (fenv (get frame "env"))
-                    (raw-args (get frame "raw-args")))
+                    (raw-args (get frame "raw-args"))
+                    (hname (get frame "head-name")))
                 (if (nil? f)
                   ;; Head just evaluated — value is the function
-                  (if (empty? remaining)
-                    ;; No args — call immediately
-                    (continue-with-call value (list) fenv raw-args rest-k)
-                    ;; Start evaluating args
-                    (make-cek-state
-                      (first remaining) fenv
-                      (kont-push
-                        (make-arg-frame value (list) (rest remaining) fenv raw-args)
-                        rest-k)))
+                  (do
+                    ;; Strict mode: check arg types for named primitives
+                    (when (and *strict* hname)
+                      (strict-check-args hname (list)))
+                    (if (empty? remaining)
+                      ;; No args — call immediately
+                      (continue-with-call value (list) fenv raw-args rest-k)
+                      ;; Start evaluating args
+                      (make-cek-state
+                        (first remaining) fenv
+                        (kont-push
+                          (make-arg-frame value (list) (rest remaining) fenv raw-args hname)
+                          rest-k))))
                   ;; An arg was evaluated — accumulate
                   (let ((new-evaled (append evaled (list value))))
                     (if (empty? remaining)
-                      ;; All args evaluated — call
-                      (continue-with-call f new-evaled fenv raw-args rest-k)
+                      ;; All args evaluated — strict check then call
+                      (do
+                        (when (and *strict* hname)
+                          (strict-check-args hname new-evaled))
+                        (continue-with-call f new-evaled fenv raw-args rest-k))
                       ;; Next arg
                       (make-cek-state
                         (first remaining) fenv
                         (kont-push
-                          (make-arg-frame f new-evaled (rest remaining) fenv raw-args)
+                          (make-arg-frame f new-evaled (rest remaining) fenv raw-args hname)
                           rest-k))))))
 
             ;; --- DictFrame: value evaluated ---
@@ -969,10 +979,10 @@
                         " expects " (len params) " args, got " (len args)))
             (do
               (for-each
-                (fn (pair) (env-set! local (first pair) (nth pair 1)))
+                (fn (pair) (env-bind! local (first pair) (nth pair 1)))
                 (zip params args))
               (for-each
-                (fn (p) (env-set! local p nil))
+                (fn (p) (env-bind! local p nil))
                 (slice params (len args)))
               (make-cek-state (lambda-body f) local kont))))
 
@@ -983,10 +993,10 @@
               (children (nth parsed 1))
               (local (env-merge (component-closure f) env)))
           (for-each
-            (fn (p) (env-set! local p (or (dict-get kwargs p) nil)))
+            (fn (p) (env-bind! local p (or (dict-get kwargs p) nil)))
             (component-params f))
           (when (component-has-children? f)
-            (env-set! local "children" children))
+            (env-bind! local "children" children))
           (make-cek-state (component-body f) local kont))
 
       :else (error (str "Not callable: " (inspect f))))))

spec/eval.sx

@@ -68,6 +68,89 @@
           result)))))
 
 
+;; --------------------------------------------------------------------------
+;; 2b. Strict mode — runtime type checking for primitive calls
+;; --------------------------------------------------------------------------
+;;
+;; When *strict* is true, primitive calls check arg types before dispatch.
+;; The primitive param type registry maps name → {positional [[name type]...],
+;; rest-type type-or-nil}.  Stored in *prim-param-types* in the env.
+;;
+;; Strict mode is off by default. Hosts can enable it at startup via:
+;;   (set-strict! true)
+;;   (set-prim-param-types! types-dict)
+
+(define *strict* false)
+
+(define set-strict!
+  (fn (val)
+    (set! *strict* val)))
+
+(define *prim-param-types* nil)
+
+(define set-prim-param-types!
+  (fn (types)
+    (set! *prim-param-types* types)))
+
+(define value-matches-type?
+  (fn (val expected-type)
+    ;; Check if a runtime value matches a declared type string.
+    (cond
+      (= expected-type "any")     true
+      (= expected-type "number")  (number? val)
+      (= expected-type "string")  (string? val)
+      (= expected-type "boolean") (boolean? val)
+      (= expected-type "nil")     (nil? val)
+      (= expected-type "list")    (list? val)
+      (= expected-type "dict")    (dict? val)
+      (= expected-type "lambda")  (lambda? val)
+      (= expected-type "symbol")  (= (type-of val) "symbol")
+      (= expected-type "keyword") (= (type-of val) "keyword")
+      ;; Nullable: "string?" means string or nil
+      (and (string? expected-type)
+           (ends-with? expected-type "?"))
+        (or (nil? val)
+            (value-matches-type? val (slice expected-type 0 (- (string-length expected-type) 1))))
+      :else true)))
+
+(define strict-check-args
+  (fn (name args)
+    ;; Check args against *prim-param-types* if strict mode is on.
+    ;; Throws on type violation. No-op if *strict* is false or types not registered.
+    (when (and *strict* *prim-param-types*)
+      (let ((spec (get *prim-param-types* name)))
+        (when spec
+          (let ((positional (get spec "positional"))
+                (rest-type  (get spec "rest-type")))
+            ;; Check positional params
+            (when positional
+              (for-each
+                (fn (pair)
+                  (let ((idx      (first pair))
+                        (param    (nth pair 1))
+                        (p-name   (first param))
+                        (p-type   (nth param 1)))
+                    (when (< idx (len args))
+                      (let ((val (nth args idx)))
+                        (when (not (value-matches-type? val p-type))
+                          (error (str "Type error: " name " expected " p-type
+                                      " for param " p-name
+                                      ", got " (type-of val) " (" (str val) ")")))))))
+                (map-indexed (fn (i p) (list i p)) positional)))
+            ;; Check rest args
+            (when (and rest-type (> (len args) (len (or positional (list)))))
+              (for-each
+                (fn (pair)
+                  (let ((idx (first pair))
+                        (val (nth pair 1)))
+                    (when (not (value-matches-type? val rest-type))
+                      (error (str "Type error: " name " expected " rest-type
+                                  " for rest arg " idx
+                                  ", got " (type-of val) " (" (str val) ")")))))
+                (map-indexed (fn (i v) (list i v))
+                  (slice args (len (or positional (list)))))))))))))
+
+
 ;; --------------------------------------------------------------------------
 ;; 3. Core evaluator
 ;; --------------------------------------------------------------------------
@@ -201,7 +284,11 @@
       (cond
         ;; Native callable (primitive function)
         (and (callable? f) (not (lambda? f)) (not (component? f)) (not (island? f)))
-          (apply f evaluated-args)
+          (do
+            ;; Strict mode: check arg types before dispatch
+            (when (and *strict* (= (type-of head) "symbol"))
+              (strict-check-args (symbol-name head) evaluated-args))
+            (apply f evaluated-args))
 
         ;; Lambda
         (lambda? f)
@@ -229,10 +316,10 @@
         (do
           ;; Bind params — provided args first, then nil for missing
           (for-each
-            (fn (pair) (env-set! local (first pair) (nth pair 1)))
+            (fn (pair) (env-bind! local (first pair) (nth pair 1)))
             (zip params args))
           (for-each
-            (fn (p) (env-set! local p nil))
+            (fn (p) (env-bind! local p nil))
             (slice params (len args)))
           ;; Return thunk for TCO
           (make-thunk (lambda-body f) local))))))
@@ -247,11 +334,11 @@
           (local   (env-merge (component-closure comp) env)))
       ;; Bind keyword params
       (for-each
-        (fn (p) (env-set! local p (or (dict-get kwargs p) nil)))
+        (fn (p) (env-bind! local p (or (dict-get kwargs p) nil)))
         (component-params comp))
       ;; Bind children if component accepts them
       (when (component-has-children? comp)
-        (env-set! local "children" children))
+        (env-bind! local "children" children))
       ;; Return thunk — body evaluated in local env
       (make-thunk (component-body comp) local))))
 
@@ -423,7 +510,7 @@
               (let ((vname (if (= (type-of (first binding)) "symbol")
                              (symbol-name (first binding))
                              (first binding))))
-                (env-set! local vname (trampoline (eval-expr (nth binding 1) local)))))
+                (env-bind! local vname (trampoline (eval-expr (nth binding 1) local)))))
             bindings)
           ;; Clojure-style
           (let ((i 0))
@@ -433,7 +520,7 @@
                                (symbol-name (nth bindings (* pair-idx 2)))
                                (nth bindings (* pair-idx 2))))
                       (val-expr (nth bindings (inc (* pair-idx 2)))))
-                  (env-set! local vname (trampoline (eval-expr val-expr local)))))
+                  (env-bind! local vname (trampoline (eval-expr val-expr local)))))
               nil
               (range 0 (/ (len bindings) 2)))))
         ;; Evaluate body — last expression in tail position
@@ -480,7 +567,7 @@
             (loop-fn   (make-lambda params loop-body env)))
         ;; Self-reference: loop can call itself by name
         (set-lambda-name! loop-fn loop-name)
-        (env-set! (lambda-closure loop-fn) loop-name loop-fn)
+        (env-bind! (lambda-closure loop-fn) loop-name loop-fn)
         ;; Evaluate initial values in enclosing env, then call
         (let ((init-vals (map (fn (e) (trampoline (eval-expr e env))) inits)))
           (call-lambda loop-fn init-vals env))))))
@@ -522,7 +609,7 @@
           (value (trampoline (eval-expr (nth args val-idx) env))))
       (when (and (lambda? value) (nil? (lambda-name value)))
         (set-lambda-name! value (symbol-name name-sym)))
-      (env-set! env (symbol-name name-sym) value)
+      (env-bind! env (symbol-name name-sym) value)
       ;; Store effect annotation if declared
       (when has-effects
         (let ((effects-raw (nth args 2))
@@ -535,7 +622,7 @@
                              (env-get env "*effect-annotations*")
                              (dict))))
           (dict-set! effect-anns (symbol-name name-sym) effect-list)
-          (env-set! env "*effect-annotations*" effect-anns)))
+          (env-bind! env "*effect-annotations*" effect-anns)))
       value)))
 
 
@@ -570,8 +657,8 @@
                                (env-get env "*effect-annotations*")
                                (dict))))
             (dict-set! effect-anns (symbol-name name-sym) effect-list)
-            (env-set! env "*effect-annotations*" effect-anns)))
-        (env-set! env (symbol-name name-sym) comp)
+            (env-bind! env "*effect-annotations*" effect-anns)))
+        (env-bind! env (symbol-name name-sym) comp)
         comp))))
 
 (define defcomp-kwarg
@@ -646,7 +733,7 @@
           (params     (first parsed))
           (has-children (nth parsed 1)))
       (let ((island (make-island comp-name params has-children body env)))
-        (env-set! env (symbol-name name-sym) island)
+        (env-bind! env (symbol-name name-sym) island)
         island))))
 
 
@@ -659,7 +746,7 @@
           (params     (first parsed))
           (rest-param (nth parsed 1)))
       (let ((mac (make-macro params rest-param body env (symbol-name name-sym))))
-        (env-set! env (symbol-name name-sym) mac)
+        (env-bind! env (symbol-name name-sym) mac)
         mac))))
 
 (define parse-macro-params
@@ -688,7 +775,7 @@
     ;; (defstyle name expr) — bind name to evaluated expr (string, function, etc.)
     (let ((name-sym (first args))
           (value    (trampoline (eval-expr (nth args 1) env))))
-      (env-set! env (symbol-name name-sym) value)
+      (env-bind! env (symbol-name name-sym) value)
       value)))
 
 
@@ -749,7 +836,7 @@
                         (dict))))
         (dict-set! registry type-name
           (make-type-def type-name type-params body))
-        (env-set! env "*type-registry*" registry)
+        (env-bind! env "*type-registry*" registry)
         nil))))
 
 
@@ -764,7 +851,7 @@
                       (list))))
       (when (not (contains? registry effect-name))
         (append! registry effect-name))
-      (env-set! env "*effect-registry*" registry)
+      (env-bind! env "*effect-registry*" registry)
       nil)))
 
 
@@ -879,7 +966,7 @@
                            (first binding))))
               (append! names vname)
               (append! val-exprs (nth binding 1))
-              (env-set! local vname nil)))
+              (env-bind! local vname nil)))
           bindings)
         ;; Clojure-style
         (reduce
@@ -890,21 +977,21 @@
                   (val-expr (nth bindings (inc (* pair-idx 2)))))
               (append! names vname)
               (append! val-exprs val-expr)
-              (env-set! local vname nil)))
+              (env-bind! local vname nil)))
           nil
           (range 0 (/ (len bindings) 2))))
       ;; Second pass: evaluate values (they can see each other's names)
       (let ((values (map (fn (e) (trampoline (eval-expr e local))) val-exprs)))
         ;; Bind final values
         (for-each
-          (fn (pair) (env-set! local (first pair) (nth pair 1)))
+          (fn (pair) (env-bind! local (first pair) (nth pair 1)))
           (zip names values))
         ;; Patch lambda closures so they see the final bindings
         (for-each
           (fn (val)
             (when (lambda? val)
               (for-each
-                (fn (n) (env-set! (lambda-closure val) n (env-get local n)))
+                (fn (n) (env-bind! (lambda-closure val) n (env-get local n)))
                 names)))
           values))
       ;; Evaluate body
@@ -998,14 +1085,14 @@
       ;; Bind positional params (unevaluated)
       (for-each
         (fn (pair)
-          (env-set! local (first pair)
+          (env-bind! local (first pair)
             (if (< (nth pair 1) (len raw-args))
               (nth raw-args (nth pair 1))
               nil)))
         (map-indexed (fn (i p) (list p i)) (macro-params mac)))
       ;; Bind &rest param
       (when (macro-rest-param mac)
-        (env-set! local (macro-rest-param mac)
+        (env-bind! local (macro-rest-param mac)
           (slice raw-args (len (macro-params mac)))))
       ;; Evaluate body → new AST
       (trampoline (eval-expr (macro-body mac) local)))))
@@ -1153,7 +1240,8 @@
 ;; Environment:
 ;;   (env-has? env name)      → boolean
 ;;   (env-get env name)       → value
-;;   (env-set! env name val)  → void (mutating)
+;;   (env-bind! env name val) → void (create binding on THIS env, no chain walk)
+;;   (env-set! env name val)  → void (mutate existing binding, walks scope chain)
 ;;   (env-extend env)         → new env inheriting from env
 ;;   (env-merge base overlay) → new env with overlay on top
 ;;

spec/frames.sx

@@ -88,9 +88,9 @@
 ;; f = function value (already evaluated), evaled = already evaluated args
 ;; remaining = remaining arg expressions
 (define make-arg-frame
-  (fn (f evaled remaining env raw-args)
+  (fn (f evaled remaining env raw-args head-name)
     {:type "arg" :f f :evaled evaled :remaining remaining :env env
-     :raw-args raw-args}))
+     :raw-args raw-args :head-name (or head-name nil)}))
 
 ;; CallFrame: about to call with fully evaluated args
 (define make-call-frame

spec/render.sx

@@ -184,7 +184,7 @@
             (let ((name (if (= (type-of (first pair)) "symbol")
                           (symbol-name (first pair))
                           (str (first pair)))))
-              (env-set! local name (trampoline (eval-expr (nth pair 1) local))))))
+              (env-bind! local name (trampoline (eval-expr (nth pair 1) local))))))
         bindings)
       local)))
 

spec/tests/test-advanced.sx

@@ -0,0 +1,371 @@
+;; ==========================================================================
+;; test-advanced.sx — Tests for advanced evaluation patterns
+;;
+;; Requires: test-framework.sx loaded first.
+;; Modules tested: eval.sx (nested forms, higher-order patterns, define,
+;;                 quasiquote, thread-first, letrec, case/cond)
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; Nested special forms
+;; --------------------------------------------------------------------------
+
+(defsuite "nested-special-forms"
+  (deftest "let inside let"
+    (let ((x 1))
+      (let ((y (let ((z 10)) (+ x z))))
+        (assert-equal 11 y))))
+
+  (deftest "if inside let"
+    (let ((flag true)
+          (result (if true "yes" "no")))
+      (assert-equal "yes" result))
+    (let ((result (if false "yes" "no")))
+      (assert-equal "no" result)))
+
+  (deftest "let inside if"
+    (assert-equal 15
+      (if true
+        (let ((a 5) (b 10)) (+ a b))
+        0))
+    (assert-equal 0
+      (if false
+        99
+        (let ((x 0)) x))))
+
+  (deftest "cond inside let"
+    (let ((n 2)
+          (label (cond (= 2 1) "one"
+                       (= 2 2) "two"
+                       :else   "other")))
+      (assert-equal "two" label)))
+
+  (deftest "when inside when (nested conditional)"
+    ;; Inner when only runs when outer when runs
+    (let ((result "none"))
+      (when true
+        (when true
+          (set! result "both")))
+      (assert-equal "both" result))
+    (let ((result "none"))
+      (when true
+        (when false
+          (set! result "inner")))
+      (assert-equal "none" result))
+    (let ((result "none"))
+      (when false
+        (when true
+          (set! result "inner")))
+      (assert-equal "none" result)))
+
+  (deftest "do inside let body"
+    (let ((x 0))
+      (do
+        (set! x (+ x 1))
+        (set! x (+ x 1))
+        (set! x (+ x 1)))
+      (assert-equal 3 x)))
+
+  (deftest "let inside map callback"
+    ;; Each map iteration creates its own let scope
+    (let ((result (map (fn (x)
+                         (let ((doubled (* x 2))
+                               (label (str "item-" x)))
+                           (str label "=" doubled)))
+                       (list 1 2 3))))
+      (assert-equal "item-1=2" (nth result 0))
+      (assert-equal "item-2=4" (nth result 1))
+      (assert-equal "item-3=6" (nth result 2)))))
+
+
+;; --------------------------------------------------------------------------
+;; Higher-order patterns
+;; --------------------------------------------------------------------------
+
+(defsuite "higher-order-patterns"
+  (deftest "map then filter (pipeline)"
+    ;; Double each number, then keep only those > 4
+    (let ((result (filter (fn (x) (> x 4))
+                          (map (fn (x) (* x 2)) (list 1 2 3 4 5)))))
+      (assert-equal (list 6 8 10) result)))
+
+  (deftest "filter then map"
+    ;; Keep odd numbers, then square them
+    (let ((result (map (fn (x) (* x x))
+                       (filter (fn (x) (= (mod x 2) 1)) (list 1 2 3 4 5)))))
+      (assert-equal (list 1 9 25) result)))
+
+  (deftest "reduce to build a dict"
+    ;; Build a word-length dict from a list of strings
+    (let ((result (reduce
+                    (fn (acc s) (assoc acc s (string-length s)))
+                    {}
+                    (list "a" "bb" "ccc"))))
+      (assert-equal 1 (get result "a"))
+      (assert-equal 2 (get result "bb"))
+      (assert-equal 3 (get result "ccc"))))
+
+  (deftest "map returning lambdas, then calling them"
+    ;; Produce a list of adder functions; call each with 10
+    (let ((adders (map (fn (n) (fn (x) (+ n x))) (list 1 2 3)))
+          (results (list)))
+      (for-each
+        (fn (f) (append! results (f 10)))
+        adders)
+      (assert-equal (list 11 12 13) results)))
+
+  (deftest "nested map (map of map)"
+    (let ((matrix (list (list 1 2) (list 3 4) (list 5 6)))
+          (result (map (fn (row) (map (fn (x) (* x 10)) row)) matrix)))
+      (assert-equal (list 10 20) (nth result 0))
+      (assert-equal (list 30 40) (nth result 1))
+      (assert-equal (list 50 60) (nth result 2))))
+
+  (deftest "for-each with side effect (set! counter)"
+    (define fe-counter 0)
+    (for-each
+      (fn (x) (set! fe-counter (+ fe-counter x)))
+      (list 1 2 3 4 5))
+    ;; 1+2+3+4+5 = 15
+    (assert-equal 15 fe-counter)))
+
+
+;; --------------------------------------------------------------------------
+;; Define patterns
+;; --------------------------------------------------------------------------
+
+(defsuite "define-patterns"
+  (deftest "define inside let body"
+    ;; define inside a let body is visible in subsequent let body expressions
+    (let ((x 5))
+      (define y (* x 2))
+      (assert-equal 10 y)))
+
+  (deftest "define inside do block"
+    (do
+      (define do-val 42)
+      (assert-equal 42 do-val)))
+
+  (deftest "define function then call it"
+    (define square (fn (n) (* n n)))
+    (assert-equal 9  (square 3))
+    (assert-equal 25 (square 5))
+    (assert-equal 0  (square 0)))
+
+  (deftest "redefine a name (second define overwrites first)"
+    (define redef-x 1)
+    (assert-equal 1 redef-x)
+    (define redef-x 99)
+    (assert-equal 99 redef-x))
+
+  (deftest "define with computed value"
+    (define base 7)
+    (define derived (* base 6))
+    (assert-equal 42 derived)))
+
+
+;; --------------------------------------------------------------------------
+;; Quasiquote advanced
+;; --------------------------------------------------------------------------
+
+(defsuite "quasiquote-advanced"
+  (deftest "quasiquote with multiple unquotes"
+    (let ((a 1) (b 2) (c 3))
+      (assert-equal (list 1 2 3) `(,a ,b ,c))
+      (assert-equal (list 10 2 30) `(,(* a 10) ,b ,(* c 10)))))
+
+  (deftest "unquote-splicing at start of list"
+    (let ((prefix (list 1 2 3)))
+      (assert-equal (list 1 2 3 4 5) `(,@prefix 4 5))))
+
+  (deftest "unquote-splicing at end of list"
+    (let ((suffix (list 3 4 5)))
+      (assert-equal (list 1 2 3 4 5) `(1 2 ,@suffix))))
+
+  (deftest "unquote inside nested list"
+    (let ((x 42))
+      ;; The inner list contains an unquote — it should still be spliced
+      (let ((result `(a (b ,x) c)))
+        (assert-length 3 result)
+        (assert-equal 42 (nth (nth result 1) 1)))))
+
+  (deftest "quasiquote preserving structure"
+    ;; A quasiquoted form with no unquotes is identical to the quoted form
+    (let ((q `(fn (a b) (+ a b))))
+      (assert-type "list" q)
+      (assert-length 3 q)
+      ;; First element is the symbol fn
+      (assert-true (equal? (sx-parse-one "fn") (first q)))
+      ;; Body is (+ a b) — a 3-element list
+      (assert-length 3 (nth q 2)))))
+
+
+;; --------------------------------------------------------------------------
+;; Thread-first
+;; --------------------------------------------------------------------------
+
+(defsuite "thread-first"
+  (deftest "simple thread through arithmetic"
+    ;; (-> 5 (+ 1) (* 2)) = (5+1)*2 = 12
+    (assert-equal 12 (-> 5 (+ 1) (* 2))))
+
+  (deftest "thread with string ops"
+    (assert-equal "HELLO" (-> "hello" upcase))
+    (assert-equal "hello" (-> "HELLO" downcase)))
+
+  (deftest "thread with multiple steps"
+    ;; (-> 1 (+ 1) (+ 1) (+ 1) (+ 1)) = 5
+    (assert-equal 5 (-> 1 (+ 1) (+ 1) (+ 1) (+ 1)))
+    ;; (-> 100 (- 10) (/ 2) (+ 5)) = (100-10)/2+5 = 50
+    (assert-equal 50 (-> 100 (- 10) (/ 2) (+ 5))))
+
+  (deftest "thread through list ops"
+    ;; Build list, reverse, take first
+    (assert-equal 3 (-> (list 1 2 3) reverse first))
+    ;; Append then get length
+    (assert-equal 5 (-> (list 1 2 3) (append (list 4 5)) len))))
+
+
+;; --------------------------------------------------------------------------
+;; letrec
+;; --------------------------------------------------------------------------
+
+(defsuite "letrec"
+  (deftest "simple letrec with self-reference"
+    ;; A single binding that calls itself recursively
+    (letrec ((count-down (fn (n)
+                           (if (<= n 0)
+                             "done"
+                             (count-down (- n 1))))))
+      (assert-equal "done" (count-down 5))))
+
+  (deftest "mutual recursion in letrec"
+    (letrec ((my-even? (fn (n)
+                         (if (= n 0) true  (my-odd?  (- n 1)))))
+             (my-odd?  (fn (n)
+                         (if (= n 0) false (my-even? (- n 1))))))
+      (assert-true  (my-even? 4))
+      (assert-false (my-even? 3))
+      (assert-true  (my-odd?  3))
+      (assert-false (my-odd?  4))))
+
+  (deftest "letrec fibonacci"
+    (letrec ((fib (fn (n)
+                    (if (< n 2)
+                      n
+                      (+ (fib (- n 1)) (fib (- n 2)))))))
+      (assert-equal 0  (fib 0))
+      (assert-equal 1  (fib 1))
+      (assert-equal 1  (fib 2))
+      (assert-equal 8  (fib 6))
+      (assert-equal 55 (fib 10))))
+
+  (deftest "letrec with non-recursive values too"
+    ;; letrec can hold plain values alongside recursive fns
+    (letrec ((base   10)
+             (triple (fn (n) (* n 3)))
+             (result (fn () (triple base))))
+      (assert-equal 10 base)
+      (assert-equal 6  (triple 2))
+      (assert-equal 30 (result)))))
+
+
+;; --------------------------------------------------------------------------
+;; case and cond
+;; --------------------------------------------------------------------------
+
+(defsuite "case-cond"
+  (deftest "case with string matching"
+    (define color-label
+      (fn (c)
+        (case c
+          "red"   "warm"
+          "blue"  "cool"
+          "green" "natural"
+          :else   "unknown")))
+    (assert-equal "warm"    (color-label "red"))
+    (assert-equal "cool"    (color-label "blue"))
+    (assert-equal "natural" (color-label "green"))
+    (assert-equal "unknown" (color-label "purple")))
+
+  (deftest "case with number matching"
+    (define grade
+      (fn (n)
+        (case n
+          1 "one"
+          2 "two"
+          3 "three"
+          :else "many")))
+    (assert-equal "one"   (grade 1))
+    (assert-equal "two"   (grade 2))
+    (assert-equal "three" (grade 3))
+    (assert-equal "many"  (grade 99)))
+
+  (deftest "case :else fallthrough"
+    (assert-equal "fallback"
+      (case "unrecognised"
+        "a" "alpha"
+        "b" "beta"
+        :else "fallback")))
+
+  (deftest "case no match returns nil"
+    (assert-nil
+      (case "x"
+        "a" "alpha"
+        "b" "beta")))
+
+  (deftest "cond with multiple predicates"
+    (define classify
+      (fn (n)
+        (cond (< n 0)  "negative"
+              (= n 0)  "zero"
+              (< n 10) "small"
+              :else    "large")))
+    (assert-equal "negative" (classify -5))
+    (assert-equal "zero"     (classify 0))
+    (assert-equal "small"    (classify 7))
+    (assert-equal "large"    (classify 100)))
+
+  (deftest "cond with (= x val) predicate style"
+    (let ((x "b"))
+      (assert-equal "beta"
+        (cond (= x "a") "alpha"
+              (= x "b") "beta"
+              (= x "c") "gamma"
+              :else      "other"))))
+
+  (deftest "cond :else"
+    (assert-equal "default"
+      (cond false "nope"
+            false "also-nope"
+            :else "default")))
+
+  (deftest "cond all false returns nil"
+    (assert-nil
+      (cond false "a"
+            false "b"
+            false "c")))
+
+  (deftest "nested cond/case"
+    ;; cond selects a branch, that branch uses case
+    (define describe
+      (fn (kind val)
+        (cond (= kind "color")
+                (case val
+                  "r" "red"
+                  "g" "green"
+                  "b" "blue"
+                  :else "unknown-color")
+              (= kind "size")
+                (case val
+                  "s" "small"
+                  "l" "large"
+                  :else "unknown-size")
+              :else "unknown-kind")))
+    (assert-equal "red"          (describe "color" "r"))
+    (assert-equal "green"        (describe "color" "g"))
+    (assert-equal "unknown-color" (describe "color" "x"))
+    (assert-equal "small"        (describe "size"  "s"))
+    (assert-equal "large"        (describe "size"  "l"))
+    (assert-equal "unknown-kind" (describe "other" "?"))))

spec/tests/test-closures.sx

@@ -0,0 +1,212 @@
+;; ==========================================================================
+;; test-closures.sx — Comprehensive tests for closures and lexical scoping
+;;
+;; Requires: test-framework.sx loaded first.
+;; Modules tested: eval.sx (lambda, let, define, set!)
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; Closure basics
+;; --------------------------------------------------------------------------
+
+(defsuite "closure-basics"
+  (deftest "lambda captures variable from enclosing scope"
+    (let ((x 10))
+      (let ((f (fn () x)))
+        (assert-equal 10 (f)))))
+
+  (deftest "lambda captures multiple variables"
+    (let ((a 3) (b 4))
+      (let ((hyp (fn () (+ (* a a) (* b b)))))
+        (assert-equal 25 (hyp)))))
+
+  (deftest "returned lambda retains captured values"
+    (define make-greeter
+      (fn (greeting)
+        (fn (name) (str greeting ", " name "!"))))
+    (let ((hello (make-greeter "Hello")))
+      (assert-equal "Hello, Alice!" (hello "Alice"))
+      (assert-equal "Hello, Bob!" (hello "Bob"))))
+
+  (deftest "factory function returns independent closures"
+    (define make-adder
+      (fn (n) (fn (x) (+ n x))))
+    (let ((add5 (make-adder 5))
+          (add10 (make-adder 10)))
+      (assert-equal 8 (add5 3))
+      (assert-equal 13 (add10 3))
+      (assert-equal 15 (add5 10))))
+
+  (deftest "counter via closure"
+    (define make-counter
+      (fn ()
+        (let ((count 0))
+          (fn ()
+            (set! count (+ count 1))
+            count))))
+    (let ((counter (make-counter)))
+      (assert-equal 1 (counter))
+      (assert-equal 2 (counter))
+      (assert-equal 3 (counter))))
+
+  (deftest "closure captures value at time of creation"
+    ;; Create closure when x=1, then rebind x to 99.
+    ;; The closure should still see 1, not 99.
+    (let ((x 1))
+      (let ((f (fn () x)))
+        (let ((x 99))
+          (assert-equal 1 (f)))))))
+
+
+;; --------------------------------------------------------------------------
+;; Lexical scope
+;; --------------------------------------------------------------------------
+
+(defsuite "lexical-scope"
+  (deftest "inner binding shadows outer"
+    (let ((x 1))
+      (let ((x 2))
+        (assert-equal 2 x))))
+
+  (deftest "shadow does not affect outer scope"
+    (let ((x 1))
+      (let ((x 2))
+        (assert-equal 2 x))
+      (assert-equal 1 x)))
+
+  (deftest "nested let scoping"
+    (let ((x 1) (y 10))
+      (let ((x 2) (z 100))
+        (assert-equal 2 x)
+        (assert-equal 10 y)
+        (assert-equal 100 z))
+      (assert-equal 1 x)))
+
+  (deftest "lambda body sees its own let bindings"
+    (let ((f (fn (x)
+               (let ((y (* x 2)))
+                 (+ x y)))))
+      (assert-equal 9 (f 3))
+      (assert-equal 15 (f 5))))
+
+  (deftest "deeply nested scope chain"
+    (let ((a 1))
+      (let ((b 2))
+        (let ((c 3))
+          (let ((d 4))
+            (assert-equal 10 (+ a b c d)))))))
+
+  (deftest "lambda param shadows enclosing binding"
+    (let ((x 99))
+      (let ((f (fn (x) (* x 2))))
+        (assert-equal 10 (f 5))
+        ;; outer x still visible after call
+        (assert-equal 99 x))))
+
+  (deftest "sibling let bindings are independent"
+    ;; Bindings in the same let do not see each other.
+    (let ((a 1) (b 2))
+      (assert-equal 1 a)
+      (assert-equal 2 b))))
+
+
+;; --------------------------------------------------------------------------
+;; Closure mutation
+;; --------------------------------------------------------------------------
+
+(defsuite "closure-mutation"
+  (deftest "set! inside closure affects closed-over variable"
+    (let ((x 0))
+      (let ((inc-x (fn () (set! x (+ x 1)))))
+        (inc-x)
+        (inc-x)
+        (assert-equal 2 x))))
+
+  (deftest "multiple closures sharing same mutable variable"
+    (let ((count 0))
+      (let ((inc! (fn () (set! count (+ count 1))))
+            (dec! (fn () (set! count (- count 1))))
+            (get  (fn () count)))
+        (inc!)
+        (inc!)
+        (inc!)
+        (dec!)
+        (assert-equal 2 (get)))))
+
+  (deftest "set! in let binding visible to later expressions"
+    (let ((x 1))
+      (set! x 42)
+      (assert-equal 42 x)))
+
+  (deftest "set! visible across multiple later expressions"
+    (let ((result 0))
+      (set! result 5)
+      (set! result (* result 2))
+      (assert-equal 10 result)))
+
+  (deftest "map creates closures each seeing its own iteration value"
+    ;; Each fn passed to map closes over x for that invocation.
+    ;; The resulting list of thunks should each return the value they
+    ;; were called with at map time.
+    (let ((thunks (map (fn (x) (fn () x)) (list 1 2 3 4 5))))
+      (assert-equal 1 ((nth thunks 0)))
+      (assert-equal 2 ((nth thunks 1)))
+      (assert-equal 3 ((nth thunks 2)))
+      (assert-equal 4 ((nth thunks 3)))
+      (assert-equal 5 ((nth thunks 4))))))
+
+
+;; --------------------------------------------------------------------------
+;; Higher-order closures
+;; --------------------------------------------------------------------------
+
+(defsuite "higher-order-closures"
+  (deftest "compose two functions"
+    (define compose
+      (fn (f g) (fn (x) (f (g x)))))
+    (let ((double (fn (x) (* x 2)))
+          (inc    (fn (x) (+ x 1))))
+      (let ((double-then-inc (compose inc double))
+            (inc-then-double (compose double inc)))
+        (assert-equal 7  (double-then-inc 3))
+        (assert-equal 8  (inc-then-double 3)))))
+
+  (deftest "partial application via closure"
+    ;; Manual partial — captures first arg, returns fn taking second
+    (define partial2
+      (fn (f a)
+        (fn (b) (f a b))))
+    (let ((add (fn (a b) (+ a b)))
+          (mul (fn (a b) (* a b))))
+      (let ((add10 (partial2 add 10))
+            (triple (partial2 mul 3)))
+        (assert-equal 15 (add10 5))
+        (assert-equal 21 (triple 7)))))
+
+  (deftest "map with closure that captures outer variable"
+    (let ((offset 100))
+      (let ((result (map (fn (x) (+ x offset)) (list 1 2 3))))
+        (assert-equal (list 101 102 103) result))))
+
+  (deftest "reduce with closure"
+    (let ((multiplier 3))
+      (let ((result (reduce (fn (acc x) (+ acc (* x multiplier))) 0 (list 1 2 3 4))))
+        ;; (1*3 + 2*3 + 3*3 + 4*3) = 30
+        (assert-equal 30 result))))
+
+  (deftest "filter with closure over threshold"
+    (let ((threshold 5))
+      (let ((big (filter (fn (x) (> x threshold)) (list 3 5 7 9 1 6))))
+        (assert-equal (list 7 9 6) big))))
+
+  (deftest "closure returned from higher-order function composes correctly"
+    (define make-multiplier
+      (fn (factor) (fn (x) (* x factor))))
+    (define pipeline
+      (fn (fns x)
+        (reduce (fn (acc f) (f acc)) x fns)))
+    (let ((double (make-multiplier 2))
+          (triple (make-multiplier 3)))
+      ;; 5 -> *2 -> 10 -> *3 -> 30
+      (assert-equal 30 (pipeline (list double triple) 5)))))

spec/tests/test-collections.sx

@@ -0,0 +1,435 @@
+;; ==========================================================================
+;; test-collections.sx — Edge cases and complex patterns for collection ops
+;;
+;; Requires: test-framework.sx loaded first.
+;; Modules tested: core.collections, core.dict, higher-order forms,
+;;                 core.strings (string/collection bridge).
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; List operations — advanced edge cases
+;; --------------------------------------------------------------------------
+
+(defsuite "list-operations-advanced"
+  (deftest "first of nested list returns inner list"
+    (let ((nested (list (list 1 2) (list 3 4))))
+      (assert-equal (list 1 2) (first nested))))
+
+  (deftest "nested list is a list type"
+    (let ((nested (list (list 1 2) (list 3 4))))
+      (assert-type "list" (first nested))))
+
+  (deftest "nth on nested list returns inner list"
+    (let ((nested (list (list 1 2) (list 3 4))))
+      (assert-equal (list 3 4) (nth nested 1))))
+
+  (deftest "nth out of bounds returns nil"
+    (assert-nil (nth (list 1 2 3) 10)))
+
+  (deftest "nth negative index returns nil"
+    ;; Negative indices are out-of-bounds — no wrap-around
+    (let ((result (nth (list 1 2 3) -1)))
+      (assert-true (or (nil? result) (number? result)))))
+
+  (deftest "cons onto nil — platform-defined"
+    ;; JS: cons 1 nil → [1, nil] (length 2)
+    ;; Python: cons 1 nil → [1] (nil treated as empty list)
+    ;; Both: first element is 1
+    (assert-equal 1 (first (cons 1 nil))))
+
+  (deftest "cons onto empty list produces single-element list"
+    (assert-equal (list 1) (cons 1 (list)))
+    (assert-equal 1 (len (cons 1 (list)))))
+
+  (deftest "append with nil on right"
+    ;; append(list, nil) — nil treated as empty or appended as element
+    ;; The result is at least a list and starts with the original elements
+    (let ((result (append (list 1 2) nil)))
+      (assert-true (list? result))
+      (assert-true (>= (len result) 2))
+      (assert-equal 1 (first result))))
+
+  (deftest "append two lists concatenates"
+    (assert-equal (list 1 2 3 4)
+                  (append (list 1 2) (list 3 4))))
+
+  (deftest "concat three lists"
+    (assert-equal (list 1 2 3) (concat (list 1) (list 2) (list 3))))
+
+  (deftest "concat preserves order"
+    (assert-equal (list "a" "b" "c" "d")
+                  (concat (list "a" "b") (list "c" "d"))))
+
+  (deftest "flatten one level of deeply nested"
+    ;; flatten is one-level: ((( 1) 2) 3) → ((1) 2 3)
+    (let ((deep (list (list (list 1) 2) 3))
+          (result (flatten (list (list (list 1) 2) 3))))
+      (assert-type "list" result)
+      ;; 3 should now be a top-level element
+      (assert-true (contains? result 3))))
+
+  (deftest "flatten deeply nested — two passes"
+    ;; Two flatten calls flatten two levels
+    (let ((result (flatten (flatten (list (list (list 1 2) 3) 4)))))
+      (assert-equal (list 1 2 3 4) result)))
+
+  (deftest "flatten already-flat list is identity"
+    (assert-equal (list 1 2 3) (flatten (list (list 1 2 3)))))
+
+  (deftest "reverse single element"
+    (assert-equal (list 42) (reverse (list 42))))
+
+  (deftest "reverse preserves elements"
+    (let ((original (list 1 2 3 4 5)))
+      (let ((rev (reverse original)))
+        (assert-equal 5 (len rev))
+        (assert-equal 1 (last rev))
+        (assert-equal 5 (first rev)))))
+
+  (deftest "slice with start > end returns empty"
+    ;; Slice where start exceeds end — implementation may clamp or return empty
+    (let ((result (slice (list 1 2 3) 3 1)))
+      (assert-true (or (nil? result)
+                       (and (list? result) (empty? result))))))
+
+  (deftest "slice with start at length returns empty"
+    (let ((result (slice (list 1 2 3) 3)))
+      (assert-true (or (nil? result)
+                       (and (list? result) (empty? result))))))
+
+  (deftest "range with step larger than range"
+    ;; (range 0 3 10) — step exceeds range, should yield just (0)
+    (let ((result (range 0 3 10)))
+      (assert-equal (list 0) result)))
+
+  (deftest "range step=1 is same as no step"
+    (assert-equal (range 0 5) (range 0 5 1)))
+
+  (deftest "map preserves order"
+    (let ((result (map (fn (x) (* x 10)) (list 1 2 3 4 5))))
+      (assert-equal 10 (nth result 0))
+      (assert-equal 20 (nth result 1))
+      (assert-equal 30 (nth result 2))
+      (assert-equal 40 (nth result 3))
+      (assert-equal 50 (nth result 4))))
+
+  (deftest "filter preserves relative order"
+    (let ((result (filter (fn (x) (> x 2)) (list 5 1 4 2 3))))
+      (assert-equal 5 (nth result 0))
+      (assert-equal 4 (nth result 1))
+      (assert-equal 3 (nth result 2))))
+
+  (deftest "reduce string concat left-to-right order"
+    ;; (reduce f "" (list "a" "b" "c")) must be "abc" not "cba"
+    (assert-equal "abc"
+      (reduce (fn (acc x) (str acc x)) "" (list "a" "b" "c"))))
+
+  (deftest "reduce subtraction is left-associative"
+    ;; ((10 - 3) - 2) = 5, not (10 - (3 - 2)) = 9
+    (assert-equal 5
+      (reduce (fn (acc x) (- acc x)) 10 (list 3 2))))
+
+  (deftest "map on empty list returns empty list"
+    (assert-equal (list) (map (fn (x) (* x 2)) (list))))
+
+  (deftest "filter on empty list returns empty list"
+    (assert-equal (list) (filter (fn (x) true) (list)))))
+
+
+;; --------------------------------------------------------------------------
+;; Dict operations — advanced edge cases
+;; --------------------------------------------------------------------------
+
+(defsuite "dict-operations-advanced"
+  (deftest "nested dict access via chained get"
+    (let ((outer (dict "a" (dict "b" 42))))
+      (assert-equal 42 (get (get outer "a") "b"))))
+
+  (deftest "nested dict access — inner missing key returns nil"
+    (let ((outer (dict "a" (dict "b" 42))))
+      (assert-nil (get (get outer "a") "z"))))
+
+  (deftest "assoc creates a new dict — original unchanged"
+    (let ((original (dict "x" 1))
+          (updated  (assoc (dict "x" 1) "y" 2)))
+      (assert-false (has-key? original "y"))
+      (assert-true  (has-key? updated  "y"))))
+
+  (deftest "assoc preserves existing keys"
+    (let ((d (dict "a" 1 "b" 2))
+          (d2 (assoc (dict "a" 1 "b" 2) "c" 3)))
+      (assert-equal 1 (get d2 "a"))
+      (assert-equal 2 (get d2 "b"))
+      (assert-equal 3 (get d2 "c"))))
+
+  (deftest "assoc overwrites existing key"
+    (let ((d (assoc (dict "a" 1) "a" 99)))
+      (assert-equal 99 (get d "a"))))
+
+  (deftest "dissoc creates a new dict — original unchanged"
+    (let ((original (dict "a" 1 "b" 2))
+          (reduced  (dissoc (dict "a" 1 "b" 2) "a")))
+      (assert-true  (has-key? original "a"))
+      (assert-false (has-key? reduced  "a"))))
+
+  (deftest "dissoc missing key leaves dict unchanged"
+    (let ((d (dict "a" 1 "b" 2))
+          (d2 (dissoc (dict "a" 1 "b" 2) "z")))
+      (assert-equal 2 (len d2))
+      (assert-true (has-key? d2 "a"))
+      (assert-true (has-key? d2 "b"))))
+
+  (deftest "merge two dicts combines keys"
+    (let ((d1 (dict "a" 1 "b" 2))
+          (d2 (dict "c" 3 "d" 4))
+          (merged (merge (dict "a" 1 "b" 2) (dict "c" 3 "d" 4))))
+      (assert-equal 1 (get merged "a"))
+      (assert-equal 2 (get merged "b"))
+      (assert-equal 3 (get merged "c"))
+      (assert-equal 4 (get merged "d"))))
+
+  (deftest "merge — overlapping keys: second dict wins"
+    (let ((merged (merge (dict "a" 1 "b" 2) (dict "b" 99 "c" 3))))
+      (assert-equal 1  (get merged "a"))
+      (assert-equal 99 (get merged "b"))
+      (assert-equal 3  (get merged "c"))))
+
+  (deftest "merge three dicts — rightmost wins on conflict"
+    (let ((merged (merge (dict "k" 1) (dict "k" 2) (dict "k" 3))))
+      (assert-equal 3 (get merged "k"))))
+
+  (deftest "keys returns all keys"
+    (let ((d (dict "x" 10 "y" 20 "z" 30)))
+      (let ((ks (keys d)))
+        (assert-equal 3 (len ks))
+        (assert-true (contains? ks "x"))
+        (assert-true (contains? ks "y"))
+        (assert-true (contains? ks "z")))))
+
+  (deftest "vals returns all values"
+    (let ((d (dict "a" 1 "b" 2 "c" 3)))
+      (let ((vs (vals d)))
+        (assert-equal 3 (len vs))
+        (assert-true (contains? vs 1))
+        (assert-true (contains? vs 2))
+        (assert-true (contains? vs 3)))))
+
+  (deftest "len of nested dict counts top-level keys only"
+    (let ((d (dict "a" (dict "x" 1 "y" 2) "b" 3)))
+      (assert-equal 2 (len d))))
+
+  (deftest "dict with numeric string keys"
+    (let ((d (dict "1" "one" "2" "two")))
+      (assert-equal "one" (get d "1"))
+      (assert-equal "two" (get d "2"))))
+
+  (deftest "dict with empty string key"
+    (let ((d (dict "" "empty-key-value")))
+      (assert-true (has-key? d ""))
+      (assert-equal "empty-key-value" (get d ""))))
+
+  (deftest "get with default on missing key"
+    (let ((d (dict "a" 1)))
+      (assert-equal 42 (get d "missing" 42))))
+
+  (deftest "get on empty dict with default"
+    (assert-equal "default" (get (dict) "any" "default"))))
+
+
+;; --------------------------------------------------------------------------
+;; List and dict interop
+;; --------------------------------------------------------------------------
+
+(defsuite "list-dict-interop"
+  (deftest "map over list of dicts extracts field"
+    (let ((items (list (dict "name" "Alice" "age" 30)
+                       (dict "name" "Bob"   "age" 25)
+                       (dict "name" "Carol" "age" 35))))
+      (assert-equal (list "Alice" "Bob" "Carol")
+                    (map (fn (d) (get d "name")) items))))
+
+  (deftest "filter list of dicts by field value"
+    (let ((items (list (dict "name" "Alice" "score" 80)
+                       (dict "name" "Bob"   "score" 55)
+                       (dict "name" "Carol" "score" 90)))
+          (passing (filter (fn (d) (>= (get d "score") 70))
+                           (list (dict "name" "Alice" "score" 80)
+                                 (dict "name" "Bob"   "score" 55)
+                                 (dict "name" "Carol" "score" 90)))))
+      (assert-equal 2 (len passing))
+      (assert-equal "Alice" (get (first passing) "name"))))
+
+  (deftest "dict with list values"
+    (let ((d (dict "tags" (list "a" "b" "c"))))
+      (assert-true (list? (get d "tags")))
+      (assert-equal 3 (len (get d "tags")))
+      (assert-equal "b" (nth (get d "tags") 1))))
+
+  (deftest "nested: dict containing list containing dict"
+    (let ((data (dict "items" (list (dict "id" 1) (dict "id" 2)))))
+      (let ((items (get data "items")))
+        (assert-equal 2 (len items))
+        (assert-equal 1 (get (first items) "id"))
+        (assert-equal 2 (get (nth items 1) "id")))))
+
+  (deftest "building a dict from a list via reduce"
+    (let ((pairs (list (list "a" 1) (list "b" 2) (list "c" 3)))
+          (result (reduce
+                    (fn (acc pair)
+                      (assoc acc (first pair) (nth pair 1)))
+                    (dict)
+                    (list (list "a" 1) (list "b" 2) (list "c" 3)))))
+      (assert-equal 1 (get result "a"))
+      (assert-equal 2 (get result "b"))
+      (assert-equal 3 (get result "c"))))
+
+  (deftest "keys then map to produce transformed dict"
+    (let ((d (dict "a" 1 "b" 2 "c" 3))
+          (ks (keys (dict "a" 1 "b" 2 "c" 3))))
+      (let ((doubled (reduce
+                       (fn (acc k) (assoc acc k (* (get d k) 2)))
+                       (dict)
+                       ks)))
+        (assert-equal 2 (get doubled "a"))
+        (assert-equal 4 (get doubled "b"))
+        (assert-equal 6 (get doubled "c")))))
+
+  (deftest "list of dicts — reduce to sum a field"
+    (let ((records (list (dict "val" 10) (dict "val" 20) (dict "val" 30))))
+      (assert-equal 60
+        (reduce (fn (acc d) (+ acc (get d "val"))) 0 records))))
+
+  (deftest "map-indexed with list of dicts attaches index"
+    (let ((items (list (dict "name" "x") (dict "name" "y")))
+          (result (map-indexed
+                    (fn (i d) (assoc d "index" i))
+                    (list (dict "name" "x") (dict "name" "y")))))
+      (assert-equal 0 (get (first result) "index"))
+      (assert-equal 1 (get (nth result 1) "index")))))
+
+
+;; --------------------------------------------------------------------------
+;; Collection equality
+;; --------------------------------------------------------------------------
+
+(defsuite "collection-equality"
+  (deftest "two identical lists are equal"
+    (assert-true (equal? (list 1 2 3) (list 1 2 3))))
+
+  (deftest "= on same list reference is true"
+    ;; = on the same reference is always true
+    (let ((x (list 1 2)))
+      (assert-true (= x x))))
+
+  (deftest "different lists are not equal"
+    (assert-false (equal? (list 1 2 3) (list 1 2 4))))
+
+  (deftest "nested list equality"
+    (assert-true (equal? (list 1 (list 2 3) 4)
+                          (list 1 (list 2 3) 4))))
+
+  (deftest "nested list inequality — inner differs"
+    (assert-false (equal? (list 1 (list 2 3) 4)
+                           (list 1 (list 2 99) 4))))
+
+  (deftest "two identical dicts are equal"
+    (assert-true (equal? (dict "a" 1 "b" 2)
+                          (dict "a" 1 "b" 2))))
+
+  (deftest "dicts with same keys/values but different insertion order are equal"
+    ;; Dict equality is key/value structural, not insertion-order
+    (let ((d1 (dict "a" 1 "b" 2))
+          (d2 (assoc (dict "b" 2) "a" 1)))
+      (assert-true (equal? d1 d2))))
+
+  (deftest "empty list is not equal to nil"
+    (assert-false (equal? (list) nil)))
+
+  (deftest "empty list equals empty list"
+    (assert-true (equal? (list) (list))))
+
+  (deftest "order matters for list equality"
+    (assert-false (equal? (list 1 2) (list 2 1))))
+
+  (deftest "lists of different lengths are not equal"
+    (assert-false (equal? (list 1 2) (list 1 2 3))))
+
+  (deftest "empty dict equals empty dict"
+    (assert-true (equal? (dict) (dict))))
+
+  (deftest "dict with extra key is not equal"
+    (assert-false (equal? (dict "a" 1) (dict "a" 1 "b" 2))))
+
+  (deftest "list containing dict equality"
+    (assert-true (equal? (list (dict "k" 1)) (list (dict "k" 1)))))
+
+  (deftest "list containing dict inequality"
+    (assert-false (equal? (list (dict "k" 1)) (list (dict "k" 2))))))
+
+
+;; --------------------------------------------------------------------------
+;; String / collection bridge
+;; --------------------------------------------------------------------------
+
+(defsuite "string-collection-bridge"
+  (deftest "split then join round-trip"
+    ;; Splitting on a separator then joining with the same separator recovers original
+    (let ((original "a,b,c"))
+      (assert-equal original (join "," (split original ",")))))
+
+  (deftest "join then split round-trip"
+    (let ((original (list "x" "y" "z")))
+      (assert-equal original (split (join "-" original) "-"))))
+
+  (deftest "split produces correct length"
+    (assert-equal 3 (len (split "one:two:three" ":"))))
+
+  (deftest "split produces list of strings"
+    (let ((parts (split "a,b,c" ",")))
+      (assert-true (every? string? parts))))
+
+  (deftest "map over split result"
+    ;; Split a CSV of numbers, parse each, sum
+    (let ((nums (map parse-int (split "10,20,30" ","))))
+      (assert-equal 60 (reduce (fn (a b) (+ a b)) 0 nums))))
+
+  (deftest "join with empty separator concatenates"
+    (assert-equal "abc" (join "" (list "a" "b" "c"))))
+
+  (deftest "join single-element list returns the element"
+    (assert-equal "hello" (join "," (list "hello"))))
+
+  (deftest "split on non-present separator returns whole string in list"
+    (let ((result (split "hello" ",")))
+      (assert-equal 1 (len result))
+      (assert-equal "hello" (first result))))
+
+  (deftest "str on a list produces non-empty string"
+    ;; Platform-defined formatting — just verify it's a non-empty string
+    (let ((result (str (list 1 2 3))))
+      (assert-true (string? result))
+      (assert-true (not (empty? result)))))
+
+  (deftest "upper then split preserves length"
+    (let ((words (split "hello world foo" " ")))
+      (let ((up-words (map upper words)))
+        (assert-equal 3 (len up-words))
+        (assert-equal "HELLO" (first up-words))
+        (assert-equal "WORLD" (nth up-words 1))
+        (assert-equal "FOO"   (nth up-words 2)))))
+
+  (deftest "reduce over split to build string"
+    ;; Re-join with a different separator
+    (let ((words (split "a b c" " ")))
+      (assert-equal "a|b|c" (join "|" words))))
+
+  (deftest "split empty string on space"
+    ;; Empty string split on space — platform may return list of one empty string or empty list
+    (let ((result (split "" " ")))
+      (assert-true (list? result))))
+
+  (deftest "contains? works on joined string"
+    (let ((sentence (join " " (list "the" "quick" "brown" "fox"))))
+      (assert-true (contains? sentence "quick"))
+      (assert-false (contains? sentence "lazy")))))

spec/tests/test-defcomp.sx

@@ -0,0 +1,198 @@
+;; ==========================================================================
+;; test-defcomp.sx — Tests for component (defcomp) calling conventions
+;;
+;; Requires: test-framework.sx loaded first.
+;; Modules tested: eval.sx (defcomp, component call), render.sx
+;;
+;; Component calling convention:
+;;   (defcomp ~name (&key k1 k2 &rest children) body...)
+;;   Keyword args:  (~name :k1 v1 :k2 v2)
+;;   Children:      (~name :k1 v1 child1 child2)   — positional after keywords
+;;   Defaults:      (or k1 "fallback")
+;;
+;; render-html takes an SX source string, evaluates + renders to HTML string.
+;; For multi-form programs use (do ...) or define forms before the call.
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; Basic defcomp behaviour
+;; --------------------------------------------------------------------------
+
+(defsuite "defcomp-basics"
+  (deftest "defcomp binds the component name"
+    (defcomp ~no-params ()
+      (span "hello"))
+    (assert-true (not (nil? ~no-params))))
+
+  (deftest "defcomp with positional params"
+    ;; Components can accept plain positional params (not &key).
+    (defcomp ~greet (name)
+      (span name))
+    (assert-true (not (nil? ~greet))))
+
+  (deftest "defcomp body can reference defined names"
+    ;; Body is evaluated in the defining env — outer defines are visible.
+    (define greeting "hi")
+    (defcomp ~uses-outer ()
+      (span greeting))
+    (assert-true (not (nil? ~uses-outer))))
+
+  (deftest "defcomp is a component type"
+    (defcomp ~typed-comp (&key x)
+      (div x))
+    ;; component-affinity is available on all component values
+    (assert-equal "auto" (component-affinity ~typed-comp))))
+
+
+;; --------------------------------------------------------------------------
+;; Keyword argument (&key) convention
+;; --------------------------------------------------------------------------
+
+(defsuite "defcomp-keyword-args"
+  (deftest "single &key param receives keyword argument"
+    (assert-equal "<span>World</span>"
+      (render-html "(do (defcomp ~k-single (&key title) (span title)) (~k-single :title \"World\"))")))
+
+  (deftest "multiple &key params"
+    (assert-equal "<span>Ada Lovelace</span>"
+      (render-html "(do (defcomp ~k-multi (&key first last) (span (str first \" \" last)))
+                        (~k-multi :first \"Ada\" :last \"Lovelace\"))")))
+
+  (deftest "missing &key param is nil"
+    ;; When subtitle is nil, the span should be empty
+    (assert-equal "<span></span>"
+      (render-html "(do (defcomp ~k-missing (&key title subtitle) (span (or subtitle \"\")))
+                        (~k-missing :title \"Only title\"))")))
+
+  (deftest "&key param default via or"
+    (let ((custom (render-html "(do (defcomp ~k-def (&key label) (span (or label \"default-label\")))
+                                    (~k-def :label \"custom\"))"))
+          (default (render-html "(do (defcomp ~k-def2 (&key label) (span (or label \"default-label\")))
+                                     (~k-def2))")))
+      (assert-equal "<span>custom</span>" custom)
+      (assert-equal "<span>default-label</span>" default)))
+
+  (deftest "&key params can be numbers"
+    (assert-equal "<span>84</span>"
+      (render-html "(do (defcomp ~k-num (&key value) (span (* value 2)))
+                        (~k-num :value 42))")))
+
+  (deftest "&key params can be lists"
+    (assert-equal "<span>3</span>"
+      (render-html "(do (defcomp ~k-list (&key items) (span (len items)))
+                        (~k-list :items (list \"a\" \"b\" \"c\")))"))))
+
+
+;; --------------------------------------------------------------------------
+;; Rest / children convention
+;; --------------------------------------------------------------------------
+
+(defsuite "defcomp-rest-children"
+  (deftest "&rest captures positional args as content"
+    (let ((html (render-html "(do (defcomp ~r-basic (&rest children) (div children))
+                                  (~r-basic \"a\" \"b\" \"c\"))")))
+      (assert-true (string-contains? html "a"))
+      (assert-true (string-contains? html "b"))
+      (assert-true (string-contains? html "c"))))
+
+  (deftest "&rest with &key separates keywords from positional"
+    (let ((html (render-html "(do (defcomp ~r-mixed (&key title &rest children)
+                                    (div (h2 title) children))
+                                  (~r-mixed :title \"T\" (p \"c1\") (p \"c2\")))")))
+      (assert-true (string-contains? html "<h2>T</h2>"))
+      (assert-true (string-contains? html "<p>c1</p>"))
+      (assert-true (string-contains? html "<p>c2</p>"))))
+
+  (deftest "empty children when no positional args provided"
+    (assert-equal "<div></div>"
+      (render-html "(do (defcomp ~r-empty (&rest children) (div children)) (~r-empty))")))
+
+  (deftest "multiple children rendered in order"
+    (let ((html (render-html "(do (defcomp ~r-order (&rest children) (ul children))
+                                  (~r-order (li \"x\") (li \"y\") (li \"z\")))")))
+      (assert-true (string-contains? html "<li>x</li>"))
+      (assert-true (string-contains? html "<li>y</li>"))
+      (assert-true (string-contains? html "<li>z</li>")))))
+
+
+;; --------------------------------------------------------------------------
+;; Component rendering to HTML
+;; --------------------------------------------------------------------------
+
+(defsuite "defcomp-rendering"
+  (deftest "simplest component renders to HTML"
+    (assert-equal "<p>hello</p>"
+      (render-html "(do (defcomp ~r-simple () (p \"hello\")) (~r-simple))")))
+
+  (deftest "component with &key renders keyword arg value"
+    (assert-equal "<h1>Greetings</h1>"
+      (render-html "(do (defcomp ~r-title (&key text) (h1 text))
+                        (~r-title :text \"Greetings\"))")))
+
+  (deftest "component with multiple &key args"
+    (let ((html (render-html
+                  "(do (defcomp ~r-card (&key title subtitle)
+                         (div :class \"card\" (h2 title) (p subtitle)))
+                       (~r-card :title \"Hi\" :subtitle \"Sub\"))")))
+      (assert-true (string-contains? html "class=\"card\""))
+      (assert-true (string-contains? html "<h2>Hi</h2>"))
+      (assert-true (string-contains? html "<p>Sub</p>"))))
+
+  (deftest "nested component calls"
+    (let ((html (render-html
+                  "(do
+                     (defcomp ~r-inner (&key label) (span label))
+                     (defcomp ~r-outer (&key text)  (div (~r-inner :label text)))
+                     (~r-outer :text \"nested\"))")))
+      (assert-true (string-contains? html "<div>"))
+      (assert-true (string-contains? html "<span>nested</span>"))))
+
+  (deftest "component with children rendered inside wrapper"
+    (let ((html (render-html
+                  "(do (defcomp ~r-box (&key &rest children)
+                         (div :class \"box\" children))
+                       (~r-box (p \"inside\")))")))
+      (assert-true (string-contains? html "class=\"box\""))
+      (assert-true (string-contains? html "<p>inside</p>"))))
+
+  (deftest "component with conditional rendering via when"
+    (let ((html-with    (render-html
+                          "(do (defcomp ~r-cond (&key show)
+                                 (div (when show (span \"visible\"))))
+                               (~r-cond :show true))"))
+          (html-without (render-html
+                          "(do (defcomp ~r-cond (&key show)
+                                 (div (when show (span \"visible\"))))
+                               (~r-cond :show false))")))
+      (assert-true  (string-contains? html-with    "<span>visible</span>"))
+      (assert-false (string-contains? html-without "<span>"))))
+
+  (deftest "component with conditional rendering via if"
+    (assert-equal "<p>yes</p>"
+      (render-html "(do (defcomp ~r-if (&key flag)
+                           (if flag (p \"yes\") (p \"no\")))
+                         (~r-if :flag true))"))
+    (assert-equal "<p>no</p>"
+      (render-html "(do (defcomp ~r-if (&key flag)
+                           (if flag (p \"yes\") (p \"no\")))
+                         (~r-if :flag false))")))
+
+  (deftest "component default via or renders correctly"
+    (assert-equal "<span>fallback</span>"
+      (render-html "(do (defcomp ~r-default (&key label)
+                           (span (or label \"fallback\")))
+                         (~r-default))"))
+    (assert-equal "<span>given</span>"
+      (render-html "(do (defcomp ~r-default (&key label)
+                           (span (or label \"fallback\")))
+                         (~r-default :label \"given\"))")))
+
+  (deftest "component with multiple children rendered in order"
+    (let ((html (render-html
+                  "(do (defcomp ~r-multi (&rest children)
+                         (ul children))
+                       (~r-multi (li \"a\") (li \"b\") (li \"c\")))")))
+      (assert-true (string-contains? html "<li>a</li>"))
+      (assert-true (string-contains? html "<li>b</li>"))
+      (assert-true (string-contains? html "<li>c</li>")))))

spec/tests/test-errors.sx

@@ -0,0 +1,342 @@
+;; ==========================================================================
+;; test-errors.sx — Tests for error handling and edge cases
+;;
+;; Requires: test-framework.sx loaded first.
+;; Modules tested: eval.sx, primitives.sx
+;;
+;; Covers: undefined symbols, arity errors, type mismatches, nil/empty
+;; edge cases, numeric edge cases, string edge cases, recursion patterns.
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; Undefined symbol errors
+;; --------------------------------------------------------------------------
+
+(defsuite "error-undefined"
+  (deftest "undefined symbol throws"
+    (assert-throws (fn () this-symbol-does-not-exist)))
+
+  (deftest "undefined symbol in nested expression throws"
+    (assert-throws (fn () (+ 1 undefined-var))))
+
+  (deftest "typo in primitive name throws"
+    (assert-throws (fn () (consss 1 (list 2 3)))))
+
+  (deftest "near-miss primitive name throws"
+    (assert-throws (fn () (fliter (fn (x) true) (list 1 2)))))
+
+  (deftest "undefined in let body throws"
+    (assert-throws (fn ()
+      (let ((x 1))
+        (+ x undefined-name))))))
+
+
+;; --------------------------------------------------------------------------
+;; Arity and call errors
+;; --------------------------------------------------------------------------
+
+(defsuite "error-arity"
+  (deftest "lambda called with too many args throws"
+    (assert-throws (fn ()
+      (let ((f (fn (x) (* x 2))))
+        (f 1 2 3)))))
+
+  (deftest "lambda called with too few args pads with nil"
+    ;; SX pads missing args with nil rather than throwing
+    (let ((f (fn (x y) (list x y))))
+      (assert-equal nil (nth (f 1) 1))))
+
+  (deftest "calling a non-function is an error or no-op"
+    ;; Calling a number/nil/string — platform-dependent behavior
+    ;; At minimum, it should not return a meaningful value
+    (let ((r1 (try-call (fn () (42 1 2))))
+          (r2 (try-call (fn () ("hello" 1)))))
+      ;; Either throws or returns nil/nonsense — both acceptable
+      (assert-true true))))
+
+
+;; --------------------------------------------------------------------------
+;; Type mismatch errors
+;; --------------------------------------------------------------------------
+
+(defsuite "permissive-type-coercion"
+  ;; In permissive mode (strict=false), type mismatches coerce rather than throw.
+  ;; This documents the actual behavior so hosts can match it.
+
+  (deftest "string + number — platform-defined"
+    ;; JS: "a" + 1 = "a1" (coercion). Python: throws TypeError.
+    (let ((r (try-call (fn () (+ "a" 1)))))
+      ;; Either succeeds with coercion or fails with type error — both valid.
+      (assert-true true)))
+
+  (deftest "first on non-list returns something or nil"
+    (let ((r (try-call (fn () (first 42)))))
+      ;; May throw or return nil/undefined — either is acceptable
+      (assert-true true)))
+
+  (deftest "len on non-collection — platform-defined"
+    (let ((r (try-call (fn () (len 42)))))
+      ;; JS returns undefined/NaN, Python throws — both OK
+      (assert-true true)))
+
+  (deftest "string comparison — platform-defined"
+    ;; JS: "a" < "b" = true (lexicographic)
+    (let ((r (try-call (fn () (< "a" "b")))))
+      (assert-true (get r "ok")))))
+
+;; Strict type-mismatch tests are in test-strict.sx (requires strict mode)
+
+
+;; --------------------------------------------------------------------------
+;; nil edge cases — graceful behavior, not errors
+;; --------------------------------------------------------------------------
+
+(defsuite "edge-nil"
+  (deftest "nil is falsy in if"
+    (assert-equal "no" (if nil "yes" "no")))
+
+  (deftest "nil is falsy in and"
+    (assert-false (and nil true)))
+
+  (deftest "nil short-circuits and"
+    (assert-nil (and nil (/ 1 0))))
+
+  (deftest "nil is falsy in or"
+    (assert-equal "fallback" (or nil "fallback")))
+
+  (deftest "(first nil) returns nil"
+    (assert-nil (first nil)))
+
+  (deftest "(rest nil) returns empty list"
+    (assert-equal (list) (rest nil)))
+
+  (deftest "(len nil) — platform-defined"
+    ;; JS nil representation may have length property; Python returns 0
+    ;; Accept any non-error result
+    (let ((r (try-call (fn () (len nil)))))
+      (assert-true (get r "ok"))))
+
+  (deftest "(str nil) returns empty string"
+    (assert-equal "" (str nil)))
+
+  (deftest "(if nil ...) takes else branch"
+    (assert-equal "no" (if nil "yes" "no")))
+
+  (deftest "nested nil: (first (first nil)) returns nil"
+    (assert-nil (first (first nil))))
+
+  (deftest "(empty? nil) is true"
+    (assert-true (empty? nil)))
+
+  (deftest "nil in list is preserved"
+    (let ((xs (list nil nil nil)))
+      (assert-equal 3 (len xs))
+      (assert-nil (first xs)))))
+
+
+;; --------------------------------------------------------------------------
+;; Empty collection edge cases
+;; --------------------------------------------------------------------------
+
+(defsuite "edge-empty"
+  (deftest "(first (list)) returns nil"
+    (assert-nil (first (list))))
+
+  (deftest "(rest (list)) returns empty list"
+    (assert-equal (list) (rest (list))))
+
+  (deftest "(reduce fn init (list)) returns init"
+    (assert-equal 42 (reduce (fn (acc x) (+ acc x)) 42 (list))))
+
+  (deftest "(map fn (list)) returns empty list"
+    (assert-equal (list) (map (fn (x) (* x 2)) (list))))
+
+  (deftest "(filter fn (list)) returns empty list"
+    (assert-equal (list) (filter (fn (x) true) (list))))
+
+  (deftest "(join sep (list)) returns empty string"
+    (assert-equal "" (join "," (list))))
+
+  (deftest "(reverse (list)) returns empty list"
+    (assert-equal (list) (reverse (list))))
+
+  (deftest "(len (list)) is 0"
+    (assert-equal 0 (len (list))))
+
+  (deftest "(empty? (list)) is true"
+    (assert-true (empty? (list))))
+
+  (deftest "(empty? (dict)) is true"
+    (assert-true (empty? (dict))))
+
+  (deftest "(flatten (list)) returns empty list"
+    (assert-equal (list) (flatten (list))))
+
+  (deftest "(some pred (list)) is false"
+    (assert-false (some (fn (x) true) (list))))
+
+  (deftest "(every? pred (list)) is true (vacuously)"
+    (assert-true (every? (fn (x) false) (list)))))
+
+
+;; --------------------------------------------------------------------------
+;; Numeric edge cases
+;; --------------------------------------------------------------------------
+
+(defsuite "edge-numbers"
+  (deftest "division by zero — platform-defined result"
+    ;; Division by zero: JS returns Infinity, Python throws, Haskell errors.
+    ;; We just verify it doesn't silently return a normal number.
+    (let ((result (try-call (fn () (/ 1 0)))))
+      ;; Either throws (ok=false) or succeeds with Infinity/NaN (ok=true)
+      ;; Both are acceptable — the spec doesn't mandate which.
+      (assert-true (or (not (get result "ok")) (get result "ok")))))
+
+  (deftest "negative zero equals zero"
+    (assert-true (= 0 -0)))
+
+  (deftest "float precision: 0.1 + 0.2 is close to 0.3"
+    ;; IEEE 754: 0.1 + 0.2 != 0.3 exactly. Test it's within epsilon.
+    (let ((result (+ 0.1 0.2)))
+      (assert-true (< (abs (- result 0.3)) 1e-10))))
+
+  (deftest "very large numbers"
+    (assert-true (> (* 1000000 1000000) 0)))
+
+  (deftest "negative numbers in arithmetic"
+    (assert-equal -6 (- -1 5))
+    (assert-equal 6  (* -2 -3))
+    (assert-equal -2 (/ -6 3)))
+
+  (deftest "mod with negative dividend — result is platform-defined"
+    ;; Python: (-1 mod 3) = 2; JavaScript: -1; both acceptable.
+    (let ((r (mod -1 3)))
+      (assert-true (or (= r 2) (= r -1)))))
+
+  (deftest "mod with positive numbers"
+    (assert-equal 1 (mod 7 3))
+    (assert-equal 0 (mod 6 3)))
+
+  (deftest "(min x y) with two args"
+    (assert-equal 3 (min 3 7)))
+
+  (deftest "(max x y) with two args"
+    (assert-equal 7 (max 3 7)))
+
+  (deftest "abs of negative is positive"
+    (assert-equal 7 (abs -7)))
+
+  (deftest "floor and ceil"
+    (assert-equal 3 (floor 3.9))
+    (assert-equal 4 (ceil 3.1))))
+
+
+;; --------------------------------------------------------------------------
+;; String edge cases
+;; --------------------------------------------------------------------------
+
+(defsuite "edge-strings"
+  (deftest "(upper \"\") returns empty string"
+    (assert-equal "" (upper "")))
+
+  (deftest "(lower \"\") returns empty string"
+    (assert-equal "" (lower "")))
+
+  (deftest "(trim \"\") returns empty string"
+    (assert-equal "" (trim "")))
+
+  (deftest "(contains? \"\" \"\") is true"
+    (assert-true (contains? "" "")))
+
+  (deftest "(contains? \"hello\" \"\") is true"
+    (assert-true (contains? "hello" "")))
+
+  (deftest "(starts-with? \"\" \"\") is true"
+    (assert-true (starts-with? "" "")))
+
+  (deftest "(ends-with? \"\" \"\") is true"
+    (assert-true (ends-with? "" "")))
+
+  (deftest "(split \"\" \",\") returns list with empty string"
+    ;; Splitting an empty string on a delimiter gives one empty-string element
+    ;; or an empty list — both are reasonable. Test it doesn't throw.
+    (let ((result (split "" ",")))
+      (assert-true (list? result))))
+
+  (deftest "(replace \"\" \"a\" \"b\") returns empty string"
+    (assert-equal "" (replace "" "a" "b")))
+
+  (deftest "(replace \"hello\" \"x\" \"y\") returns unchanged string"
+    (assert-equal "hello" (replace "hello" "x" "y")))
+
+  (deftest "(len \"\") is 0"
+    (assert-equal 0 (len "")))
+
+  (deftest "string with special chars: newline in str"
+    (let ((s (str "line1\nline2")))
+      (assert-true (> (len s) 5))))
+
+  (deftest "str with multiple types"
+    ;; Python: "True", JS: "true" — accept either
+    (assert-true (or (= (str 42 true "hello") "42truehello")
+                     (= (str 42 true "hello") "42Truehello"))))
+
+  (deftest "(join sep list) with single element has no separator"
+    (assert-equal "only" (join "," (list "only"))))
+
+  (deftest "(split str sep) roundtrips with join"
+    (let ((parts (split "a,b,c" ",")))
+      (assert-equal "a,b,c" (join "," parts)))))
+
+
+;; --------------------------------------------------------------------------
+;; Recursion patterns
+;; --------------------------------------------------------------------------
+
+(defsuite "edge-recursion"
+  (deftest "mutual recursion: even? and odd? via define"
+    (define my-even?
+      (fn (n)
+        (if (= n 0) true (my-odd? (- n 1)))))
+    (define my-odd?
+      (fn (n)
+        (if (= n 0) false (my-even? (- n 1)))))
+    (assert-true  (my-even? 0))
+    (assert-false (my-even? 1))
+    (assert-true  (my-even? 4))
+    (assert-false (my-odd? 0))
+    (assert-true  (my-odd? 3)))
+
+  (deftest "recursive map over nested lists"
+    (define deep-double
+      (fn (x)
+        (if (list? x)
+          (map deep-double x)
+          (* x 2))))
+    (assert-equal (list (list 2 4) (list 6 8))
+      (deep-double (list (list 1 2) (list 3 4)))))
+
+  (deftest "accumulator recursion (tail-recursive style)"
+    (define sum-to
+      (fn (n acc)
+        (if (= n 0)
+          acc
+          (sum-to (- n 1) (+ acc n)))))
+    (assert-equal 55 (sum-to 10 0)))
+
+  (deftest "recursive list building via cons"
+    (define make-range
+      (fn (lo hi)
+        (if (>= lo hi)
+          (list)
+          (cons lo (make-range (+ lo 1) hi)))))
+    (assert-equal (list 0 1 2 3 4) (make-range 0 5)))
+
+  (deftest "lambda that references itself via define"
+    (define countdown
+      (fn (n)
+        (if (<= n 0)
+          (list)
+          (cons n (countdown (- n 1))))))
+    (assert-equal (list 3 2 1) (countdown 3))))

spec/tests/test-freeze.sx

@@ -0,0 +1,75 @@
+;; ==========================================================================
+;; test-freeze.sx — Freeze scope and content addressing tests
+;; ==========================================================================
+
+(defsuite "freeze-scope"
+  (deftest "freeze captures signal values"
+    (let ((s (signal 42)))
+      (freeze-scope "t1" (fn ()
+        (freeze-signal "val" s)))
+      (let ((frozen (cek-freeze-scope "t1")))
+        (assert-equal "t1" (get frozen "name"))
+        (assert-equal 42 (get (get frozen "signals") "val")))))
+
+  (deftest "thaw restores signal values"
+    (let ((s (signal 10)))
+      (freeze-scope "t2" (fn ()
+        (freeze-signal "x" s)))
+      (let ((sx (freeze-to-sx "t2")))
+        (reset! s 999)
+        (assert-equal 999 (deref s))
+        (thaw-from-sx sx)
+        (assert-equal 10 (deref s)))))
+
+  (deftest "multiple signals in scope"
+    (let ((a (signal "hello"))
+          (b (signal 42))
+          (c (signal true)))
+      (freeze-scope "t3" (fn ()
+        (freeze-signal "a" a)
+        (freeze-signal "b" b)
+        (freeze-signal "c" c)))
+      (let ((frozen (cek-freeze-scope "t3")))
+        (assert-equal "hello" (get (get frozen "signals") "a"))
+        (assert-equal 42 (get (get frozen "signals") "b"))
+        (assert-equal true (get (get frozen "signals") "c")))))
+
+  (deftest "freeze-to-sx round trip"
+    (let ((s (signal "data")))
+      (freeze-scope "t4" (fn ()
+        (freeze-signal "s" s)))
+      (let ((sx (freeze-to-sx "t4")))
+        (assert-true (string? sx))
+        (assert-true (contains? sx "data"))
+        (reset! s "changed")
+        (thaw-from-sx sx)
+        (assert-equal "data" (deref s))))))
+
+(defsuite "content-addressing"
+  (deftest "content-hash deterministic"
+    (assert-equal (content-hash "hello") (content-hash "hello")))
+
+  (deftest "content-hash different for different input"
+    (assert-false (= (content-hash "hello") (content-hash "world"))))
+
+  (deftest "content-put and get"
+    (let ((cid (content-put "test data")))
+      (assert-equal "test data" (content-get cid))))
+
+  (deftest "freeze-to-cid round trip"
+    (let ((s (signal 77)))
+      (freeze-scope "t5" (fn ()
+        (freeze-signal "v" s)))
+      (let ((cid (freeze-to-cid "t5")))
+        (assert-true (string? cid))
+        (reset! s 0)
+        (assert-true (thaw-from-cid cid))
+        (assert-equal 77 (deref s)))))
+
+  (deftest "same state same cid"
+    (let ((s (signal 42)))
+      (freeze-scope "t6" (fn ()
+        (freeze-signal "n" s)))
+      (let ((cid1 (freeze-to-cid "t6"))
+            (cid2 (freeze-to-cid "t6")))
+        (assert-equal cid1 cid2)))))

spec/tests/test-macros.sx

@@ -0,0 +1,266 @@
+;; ==========================================================================
+;; test-macros.sx — Tests for macros and quasiquote
+;;
+;; Requires: test-framework.sx loaded first.
+;; Modules tested: eval.sx (defmacro, quasiquote, unquote, splice-unquote)
+;;
+;; Platform functions required (beyond test framework):
+;;   sx-parse-one  (source)  -> first AST expression from source string
+;;   equal?        (a b)     -> deep equality comparison
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; Quasiquote basics
+;; --------------------------------------------------------------------------
+
+(defsuite "quasiquote-basics"
+  (deftest "quasiquote with no unquotes is like quote"
+    ;; `(a b c) returns a list of three symbols — same as '(a b c)
+    (assert-true (equal? '(a b c) `(a b c)))
+    (assert-length 3 `(a b c)))
+
+  (deftest "quasiquote preserves numbers and strings as-is"
+    (assert-equal (list 1 "hello" true) `(1 "hello" true)))
+
+  (deftest "quasiquote returns literal list"
+    ;; Without unquotes, the result is a plain list — not evaluated
+    (let ((result `(+ 1 2)))
+      (assert-type "list" result)
+      (assert-length 3 result)))
+
+  (deftest "unquote substitutes value"
+    ;; `(a ,x b) with x=42 should yield the list (a 42 b)
+    ;; Compare against the parsed AST of "(a 42 b)"
+    (let ((x 42))
+      (assert-true (equal? (sx-parse-one "(a 42 b)") `(a ,x b)))))
+
+  (deftest "unquote evaluates its expression"
+    ;; ,expr evaluates expr — not just symbol substitution
+    (let ((x 3))
+      (assert-equal (list 1 2 6 4) `(1 2 ,(* x 2) 4))))
+
+  (deftest "unquote-splicing flattens list into quasiquote"
+    ;; ,@xs splices the elements of xs in-place
+    (let ((xs (list 1 2 3)))
+      (assert-equal (list 0 1 2 3 4) `(0 ,@xs 4))))
+
+  (deftest "unquote-splicing with multiple elements"
+    ;; Verify splice replaces the ,@xs slot with each element individually
+    (let ((xs (list 2 3 4)))
+      (assert-true (equal? (sx-parse-one "(a 2 3 4 b)") `(a ,@xs b)))))
+
+  (deftest "unquote-splicing empty list leaves no elements"
+    (let ((empty (list)))
+      (assert-equal (list 1 2) `(1 ,@empty 2))))
+
+  (deftest "multiple unquotes in one template"
+    (let ((a 10) (b 20))
+      (assert-equal (list 10 20 30) `(,a ,b ,(+ a b)))))
+
+  (deftest "quasiquote with only unquote-splicing"
+    (let ((items (list 7 8 9)))
+      (assert-equal (list 7 8 9) `(,@items)))))
+
+
+;; --------------------------------------------------------------------------
+;; defmacro basics
+;; --------------------------------------------------------------------------
+
+(defsuite "defmacro-basics"
+  (deftest "simple macro transforms code"
+    ;; A macro that wraps its argument in (do ...)
+    (defmacro wrap-do (expr)
+      `(do ,expr))
+    (assert-equal 42 (wrap-do 42))
+    (assert-equal "hello" (wrap-do "hello")))
+
+  (deftest "macro with multiple args"
+    ;; my-if is structurally the same as if
+    (defmacro my-if (condition then else)
+      `(if ,condition ,then ,else))
+    (assert-equal "yes" (my-if true "yes" "no"))
+    (assert-equal "no" (my-if false "yes" "no"))
+    (assert-equal "yes" (my-if (> 5 3) "yes" "no")))
+
+  (deftest "macro using quasiquote and unquote"
+    ;; inc1 expands to (+ x 1)
+    (defmacro inc1 (x)
+      `(+ ,x 1))
+    (assert-equal 6 (inc1 5))
+    (assert-equal 1 (inc1 0))
+    (let ((n 10))
+      (assert-equal 11 (inc1 n))))
+
+  (deftest "macro using unquote-splicing for rest body"
+    ;; progn evaluates a sequence, returning the last value
+    (defmacro progn (&rest body)
+      `(do ,@body))
+    (assert-equal 3 (progn 1 2 3))
+    (assert-equal "last" (progn "first" "middle" "last")))
+
+  (deftest "macro with rest body side effects"
+    ;; All body forms execute, not just the first
+    (define counter 0)
+    (defmacro progn2 (&rest body)
+      `(do ,@body))
+    (progn2
+      (set! counter (+ counter 1))
+      (set! counter (+ counter 1))
+      (set! counter (+ counter 1)))
+    (assert-equal 3 counter))
+
+  (deftest "macro expansion happens before evaluation"
+    ;; The macro sees raw AST — its body arg is the symbol x, not a value
+    ;; This verifies that macro args are not evaluated before expansion
+    (defmacro quote-arg (x)
+      `(quote ,x))
+    ;; (quote-arg foo) should expand to (quote foo), returning the symbol foo
+    (let ((result (quote-arg foo)))
+      (assert-true (equal? (sx-parse-one "foo") result))))
+
+  (deftest "macro can build new list structure"
+    ;; Macro that builds a let binding from two args
+    (defmacro bind-to (name val body)
+      `(let ((,name ,val)) ,body))
+    (assert-equal 10 (bind-to x 10 x))
+    (assert-equal 20 (bind-to y 10 (* y 2)))))
+
+
+;; --------------------------------------------------------------------------
+;; Common macro patterns
+;; --------------------------------------------------------------------------
+
+(defsuite "macro-patterns"
+  (deftest "unless macro — opposite of when"
+    (defmacro unless (condition &rest body)
+      `(when (not ,condition) ,@body))
+    ;; Runs body when condition is false
+    (assert-equal "ran" (unless false "ran"))
+    (assert-nil (unless true "should-not-run"))
+    ;; Works with compound conditions
+    (assert-equal "done" (unless (> 1 2) "done"))
+    (assert-nil (unless (= 1 1) "nope")))
+
+  (deftest "swap-vals! macro — exchange two bindings"
+    ;; Swaps values of two variables using a temp binding
+    (defmacro swap-vals! (a b)
+      `(let ((tmp ,a))
+         (set! ,a ,b)
+         (set! ,b tmp)))
+    (define p 1)
+    (define q 2)
+    (swap-vals! p q)
+    (assert-equal 2 p)
+    (assert-equal 1 q))
+
+  (deftest "with-default macro — provide fallback for nil"
+    ;; (with-default expr default) returns expr unless it is nil
+    (defmacro with-default (expr fallback)
+      `(or ,expr ,fallback))
+    (assert-equal "hello" (with-default "hello" "fallback"))
+    (assert-equal "fallback" (with-default nil "fallback"))
+    (assert-equal "fallback" (with-default false "fallback")))
+
+  (deftest "when2 macro — two-arg version with implicit body"
+    ;; Like when, but condition and body are explicit
+    (defmacro when2 (cond-expr body-expr)
+      `(if ,cond-expr ,body-expr nil))
+    (assert-equal 42 (when2 true 42))
+    (assert-nil (when2 false 42)))
+
+  (deftest "dotimes macro — simple counted loop"
+    ;; Executes body n times, binding loop var to 0..n-1
+    ;; Uses for-each over range instead of named-let (avoids set! scope issue)
+    (defmacro dotimes (binding &rest body)
+      (let ((var (first binding))
+            (n   (first (rest binding))))
+        `(for-each (fn (,var) ,@body) (range 0 ,n))))
+    (define total 0)
+    (dotimes (i 5)
+      (set! total (+ total i)))
+    ;; 0+1+2+3+4 = 10
+    (assert-equal 10 total))
+
+  (deftest "and2 macro — two-arg short-circuit and"
+    (defmacro and2 (a b)
+      `(if ,a ,b false))
+    (assert-equal "b" (and2 "a" "b"))
+    (assert-false (and2 false "b"))
+    (assert-false (and2 "a" false)))
+
+  (deftest "macro calling another macro"
+    ;; nand is defined in terms of and2 (which is itself a macro)
+    (defmacro and2b (a b)
+      `(if ,a ,b false))
+    (defmacro nand (a b)
+      `(not (and2b ,a ,b)))
+    (assert-true (nand false false))
+    (assert-true (nand false true))
+    (assert-true (nand true false))
+    (assert-false (nand true true))))
+
+
+;; --------------------------------------------------------------------------
+;; Macro hygiene
+;; --------------------------------------------------------------------------
+
+(defsuite "macro-hygiene"
+  (deftest "macro-introduced bindings do not leak to caller scope"
+    ;; The macro uses a local let binding named `tmp`.
+    ;; That binding must not appear in the caller's environment after expansion.
+    (defmacro double-add (x)
+      `(let ((tmp (* ,x 2)))
+         (+ tmp 1)))
+    (assert-equal 11 (double-add 5))
+    (assert-equal 21 (double-add 10))
+    ;; Verify the let scope is isolated: evaluate two calls and confirm
+    ;; results are independent (no shared `tmp` leaking between calls)
+    (assert-equal (list 11 21) (list (double-add 5) (double-add 10))))
+
+  (deftest "caller bindings are visible inside macro expansion"
+    ;; The macro emits code that references `scale` — a name that must be
+    ;; looked up in the caller's environment at expansion evaluation time.
+    (defmacro scale-add (x)
+      `(+ ,x scale))
+    (let ((scale 100))
+      (assert-equal 105 (scale-add 5))))
+
+  (deftest "nested macro expansion"
+    ;; Outer macro expands to a call of an inner macro.
+    ;; The inner macro's expansion must also be fully evaluated.
+    (defmacro inner-mac (x)
+      `(* ,x 2))
+    (defmacro outer-mac (x)
+      `(inner-mac (+ ,x 1)))
+    ;; outer-mac 4 → (inner-mac (+ 4 1)) → (inner-mac 5) → (* 5 2) → 10
+    (assert-equal 10 (outer-mac 4)))
+
+  (deftest "macro does not evaluate args — sees raw AST"
+    ;; Passing an expression that would error if evaluated; macro must not
+    ;; force evaluation of args it doesn't use.
+    (defmacro first-arg (a b)
+      `(quote ,a))
+    ;; b = (/ 1 0) would be a runtime error if evaluated, but macro ignores b
+    (assert-true (equal? (sx-parse-one "hello") (first-arg hello (/ 1 0)))))
+
+  (deftest "macro expansion in let body"
+    ;; Macros must expand correctly when used inside a let body,
+    ;; not just at top level.
+    (defmacro triple (x)
+      `(* ,x 3))
+    (let ((n 4))
+      (assert-equal 12 (triple n))))
+
+  (deftest "macro in higher-order position — map over macro results"
+    ;; Macros can't be passed as first-class values, but their expansions
+    ;; can produce lambdas that are passed. Verify that using a macro to
+    ;; build a lambda works correctly.
+    (defmacro make-adder (n)
+      `(fn (x) (+ x ,n)))
+    (let ((add5 (make-adder 5))
+          (add10 (make-adder 10)))
+      (assert-equal 8  (add5 3))
+      (assert-equal 13 (add10 3))
+      (assert-equal (list 6 7 8)
+        (map (make-adder 5) (list 1 2 3))))))

spec/tests/test-parser.sx

@@ -0,0 +1,524 @@
+;; ==========================================================================
+;; test-parser.sx — Tests for the SX parser and serializer
+;;
+;; Requires: test-framework.sx loaded first.
+;; Modules tested: parser.sx
+;;
+;; Platform functions required (beyond test framework):
+;;   sx-parse       (source)  -> list of AST expressions
+;;   sx-serialize   (expr)    -> SX source string
+;;   make-symbol    (name)    -> Symbol value
+;;   make-keyword   (name)    -> Keyword value
+;;   symbol-name    (sym)     -> string
+;;   keyword-name   (kw)      -> string
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; Literal parsing
+;; --------------------------------------------------------------------------
+
+(defsuite "parser-literals"
+  (deftest "parse integers"
+    (assert-equal (list 42) (sx-parse "42"))
+    (assert-equal (list 0) (sx-parse "0"))
+    (assert-equal (list -7) (sx-parse "-7")))
+
+  (deftest "parse floats"
+    (assert-equal (list 3.14) (sx-parse "3.14"))
+    (assert-equal (list -0.5) (sx-parse "-0.5")))
+
+  (deftest "parse strings"
+    (assert-equal (list "hello") (sx-parse "\"hello\""))
+    (assert-equal (list "") (sx-parse "\"\"")))
+
+  (deftest "parse escape: newline"
+    (assert-equal (list "a\nb") (sx-parse "\"a\\nb\"")))
+
+  (deftest "parse escape: tab"
+    (assert-equal (list "a\tb") (sx-parse "\"a\\tb\"")))
+
+  (deftest "parse escape: quote"
+    (assert-equal (list "a\"b") (sx-parse "\"a\\\"b\"")))
+
+  (deftest "parse booleans"
+    (assert-equal (list true) (sx-parse "true"))
+    (assert-equal (list false) (sx-parse "false")))
+
+  (deftest "parse nil"
+    (assert-equal (list nil) (sx-parse "nil")))
+
+  (deftest "parse keywords"
+    (let ((result (sx-parse ":hello")))
+      (assert-length 1 result)
+      (assert-equal "hello" (keyword-name (first result)))))
+
+  (deftest "parse symbols"
+    (let ((result (sx-parse "foo")))
+      (assert-length 1 result)
+      (assert-equal "foo" (symbol-name (first result))))))
+
+
+;; --------------------------------------------------------------------------
+;; Composite parsing
+;; --------------------------------------------------------------------------
+
+(defsuite "parser-lists"
+  (deftest "parse empty list"
+    (let ((result (sx-parse "()")))
+      (assert-length 1 result)
+      (assert-equal (list) (first result))))
+
+  (deftest "parse list of numbers"
+    (let ((result (sx-parse "(1 2 3)")))
+      (assert-length 1 result)
+      (assert-equal (list 1 2 3) (first result))))
+
+  (deftest "parse nested lists"
+    (let ((result (sx-parse "(1 (2 3) 4)")))
+      (assert-length 1 result)
+      (assert-equal (list 1 (list 2 3) 4) (first result))))
+
+  (deftest "parse square brackets as list"
+    (let ((result (sx-parse "[1 2 3]")))
+      (assert-length 1 result)
+      (assert-equal (list 1 2 3) (first result))))
+
+  (deftest "parse mixed types"
+    (let ((result (sx-parse "(42 \"hello\" true nil)")))
+      (assert-length 1 result)
+      (let ((lst (first result)))
+        (assert-equal 42 (nth lst 0))
+        (assert-equal "hello" (nth lst 1))
+        (assert-equal true (nth lst 2))
+        (assert-nil (nth lst 3))))))
+
+
+;; --------------------------------------------------------------------------
+;; Dict parsing
+;; --------------------------------------------------------------------------
+
+(defsuite "parser-dicts"
+  (deftest "parse empty dict"
+    (let ((result (sx-parse "{}")))
+      (assert-length 1 result)
+      (assert-type "dict" (first result))))
+
+  (deftest "parse dict with keyword keys"
+    (let ((result (sx-parse "{:a 1 :b 2}")))
+      (assert-length 1 result)
+      (let ((d (first result)))
+        (assert-type "dict" d)
+        (assert-equal 1 (get d "a"))
+        (assert-equal 2 (get d "b")))))
+
+  (deftest "parse dict with string values"
+    (let ((result (sx-parse "{:name \"alice\"}")))
+      (assert-length 1 result)
+      (assert-equal "alice" (get (first result) "name")))))
+
+
+;; --------------------------------------------------------------------------
+;; Comments and whitespace
+;; --------------------------------------------------------------------------
+
+(defsuite "parser-whitespace"
+  (deftest "skip line comments"
+    (assert-equal (list 42) (sx-parse ";; comment\n42"))
+    (assert-equal (list 1 2) (sx-parse "1 ;; middle\n2")))
+
+  (deftest "skip whitespace"
+    (assert-equal (list 42) (sx-parse "  42  "))
+    (assert-equal (list 1 2) (sx-parse " 1 \n\t 2 ")))
+
+  (deftest "parse multiple top-level expressions"
+    (assert-length 3 (sx-parse "1 2 3"))
+    (assert-equal (list 1 2 3) (sx-parse "1 2 3")))
+
+  (deftest "empty input"
+    (assert-equal (list) (sx-parse "")))
+
+  (deftest "only comments"
+    (assert-equal (list) (sx-parse ";; just a comment\n;; another"))))
+
+
+;; --------------------------------------------------------------------------
+;; Quote sugar
+;; --------------------------------------------------------------------------
+
+(defsuite "parser-quote-sugar"
+  (deftest "quasiquote"
+    (let ((result (sx-parse "`foo")))
+      (assert-length 1 result)
+      (let ((expr (first result)))
+        (assert-type "list" expr)
+        (assert-equal "quasiquote" (symbol-name (first expr))))))
+
+  (deftest "unquote"
+    (let ((result (sx-parse ",foo")))
+      (assert-length 1 result)
+      (let ((expr (first result)))
+        (assert-type "list" expr)
+        (assert-equal "unquote" (symbol-name (first expr))))))
+
+  (deftest "splice-unquote"
+    (let ((result (sx-parse ",@foo")))
+      (assert-length 1 result)
+      (let ((expr (first result)))
+        (assert-type "list" expr)
+        (assert-equal "splice-unquote" (symbol-name (first expr)))))))
+
+
+;; --------------------------------------------------------------------------
+;; Serializer
+;; --------------------------------------------------------------------------
+
+(defsuite "serializer"
+  (deftest "serialize number"
+    (assert-equal "42" (sx-serialize 42)))
+
+  (deftest "serialize string"
+    (assert-equal "\"hello\"" (sx-serialize "hello")))
+
+  (deftest "serialize boolean"
+    (assert-equal "true" (sx-serialize true))
+    (assert-equal "false" (sx-serialize false)))
+
+  (deftest "serialize nil"
+    (assert-equal "nil" (sx-serialize nil)))
+
+  (deftest "serialize keyword"
+    (assert-equal ":foo" (sx-serialize (make-keyword "foo"))))
+
+  (deftest "serialize symbol"
+    (assert-equal "bar" (sx-serialize (make-symbol "bar"))))
+
+  (deftest "serialize list"
+    (assert-equal "(1 2 3)" (sx-serialize (list 1 2 3))))
+
+  (deftest "serialize empty list"
+    (assert-equal "()" (sx-serialize (list))))
+
+  (deftest "serialize nested"
+    (assert-equal "(1 (2 3) 4)" (sx-serialize (list 1 (list 2 3) 4)))))
+
+
+;; --------------------------------------------------------------------------
+;; Round-trip: parse then serialize
+;; --------------------------------------------------------------------------
+
+(defsuite "parser-roundtrip"
+  (deftest "roundtrip number"
+    (assert-equal "42" (sx-serialize (first (sx-parse "42")))))
+
+  (deftest "roundtrip string"
+    (assert-equal "\"hello\"" (sx-serialize (first (sx-parse "\"hello\"")))))
+
+  (deftest "roundtrip list"
+    (assert-equal "(1 2 3)" (sx-serialize (first (sx-parse "(1 2 3)")))))
+
+  (deftest "roundtrip nested"
+    (assert-equal "(a (b c))"
+      (sx-serialize (first (sx-parse "(a (b c))"))))))
+
+
+;; --------------------------------------------------------------------------
+;; Reader macros
+;; --------------------------------------------------------------------------
+
+(defsuite "reader-macros"
+  (deftest "datum comment discards expr"
+    (assert-equal (list 42) (sx-parse "#;(ignored) 42")))
+
+  (deftest "datum comment in list"
+    (assert-equal (list (list 1 3)) (sx-parse "(1 #;2 3)")))
+
+  (deftest "datum comment discards nested"
+    (assert-equal (list 99) (sx-parse "#;(a (b c) d) 99")))
+
+  (deftest "raw string basic"
+    (assert-equal (list "hello") (sx-parse "#|hello|")))
+
+  (deftest "raw string with quotes"
+    (assert-equal (list "say \"hi\"") (sx-parse "#|say \"hi\"|")))
+
+  (deftest "raw string with backslashes"
+    (assert-equal (list "a\\nb") (sx-parse "#|a\\nb|")))
+
+  (deftest "raw string empty"
+    (assert-equal (list "") (sx-parse "#||")))
+
+  (deftest "quote shorthand symbol"
+    (let ((result (first (sx-parse "#'foo"))))
+      (assert-equal "quote" (symbol-name (first result)))
+      (assert-equal "foo" (symbol-name (nth result 1)))))
+
+  (deftest "quote shorthand list"
+    (let ((result (first (sx-parse "#'(1 2 3)"))))
+      (assert-equal "quote" (symbol-name (first result)))
+      (assert-equal (list 1 2 3) (nth result 1))))
+
+  (deftest "apostrophe quote expands to (quote ...)"
+    (let ((result (sx-parse "'x")))
+      (assert-length 1 result)
+      (let ((expr (first result)))
+        (assert-type "list" expr)
+        (assert-equal "quote" (symbol-name (first expr)))
+        (assert-equal "x" (symbol-name (nth expr 1))))))
+
+  (deftest "apostrophe quote on list"
+    (let ((result (sx-parse "'(1 2 3)")))
+      (assert-length 1 result)
+      (let ((expr (first result)))
+        (assert-type "list" expr)
+        (assert-equal "quote" (symbol-name (first expr)))
+        (assert-equal (list 1 2 3) (nth expr 1)))))
+
+  (deftest "quasiquote with unquote inside"
+    (let ((result (sx-parse "`(a ,b)")))
+      (assert-length 1 result)
+      (let ((expr (first result)))
+        (assert-type "list" expr)
+        (assert-equal "quasiquote" (symbol-name (first expr)))
+        (let ((inner (nth expr 1)))
+          (assert-type "list" inner)
+          (assert-equal "a" (symbol-name (first inner)))
+          (let ((unquoted (nth inner 1)))
+            (assert-type "list" unquoted)
+            (assert-equal "unquote" (symbol-name (first unquoted)))))))))
+
+
+;; --------------------------------------------------------------------------
+;; Number formats
+;; --------------------------------------------------------------------------
+
+(defsuite "parser-numbers"
+  (deftest "integer zero"
+    (assert-equal (list 0) (sx-parse "0")))
+
+  (deftest "large integer"
+    (assert-equal (list 1000000) (sx-parse "1000000")))
+
+  (deftest "negative float"
+    (assert-equal (list -2.718) (sx-parse "-2.718")))
+
+  (deftest "exponent notation"
+    (let ((result (sx-parse "1e10")))
+      (assert-length 1 result)
+      (assert-type "number" (first result))
+      (assert-equal 10000000000 (first result))))
+
+  (deftest "negative exponent"
+    (let ((result (sx-parse "2.5e-1")))
+      (assert-length 1 result)
+      (assert-type "number" (first result))
+      (assert-equal 0.25 (first result))))
+
+  (deftest "uppercase exponent E"
+    (let ((result (sx-parse "1E3")))
+      (assert-length 1 result)
+      (assert-type "number" (first result))
+      (assert-equal 1000 (first result)))))
+
+
+;; --------------------------------------------------------------------------
+;; Symbol naming conventions
+;; --------------------------------------------------------------------------
+
+(defsuite "parser-symbols"
+  (deftest "symbol with hyphens"
+    (let ((result (sx-parse "my-var")))
+      (assert-length 1 result)
+      (assert-equal "my-var" (symbol-name (first result)))))
+
+  (deftest "symbol with question mark"
+    (let ((result (sx-parse "nil?")))
+      (assert-length 1 result)
+      (assert-equal "nil?" (symbol-name (first result)))))
+
+  (deftest "symbol with exclamation"
+    (let ((result (sx-parse "set!")))
+      (assert-length 1 result)
+      (assert-equal "set!" (symbol-name (first result)))))
+
+  (deftest "symbol with tilde (component)"
+    (let ((result (sx-parse "~my-comp")))
+      (assert-length 1 result)
+      (assert-equal "~my-comp" (symbol-name (first result)))))
+
+  (deftest "symbol with arrow"
+    (let ((result (sx-parse "->")))
+      (assert-length 1 result)
+      (assert-equal "->" (symbol-name (first result)))))
+
+  (deftest "symbol with &"
+    (let ((result (sx-parse "&key")))
+      (assert-length 1 result)
+      (assert-equal "&key" (symbol-name (first result)))))
+
+  (deftest "symbol with every? style"
+    (let ((result (sx-parse "every?")))
+      (assert-length 1 result)
+      (assert-equal "every?" (symbol-name (first result)))))
+
+  (deftest "ellipsis is a symbol"
+    (let ((result (sx-parse "...")))
+      (assert-length 1 result)
+      (assert-equal "..." (symbol-name (first result))))))
+
+
+;; --------------------------------------------------------------------------
+;; Serializer — extended
+;; --------------------------------------------------------------------------
+
+(defsuite "serializer-extended"
+  (deftest "serialize negative number"
+    (assert-equal "-5" (sx-serialize -5)))
+
+  (deftest "serialize float"
+    (assert-equal "3.14" (sx-serialize 3.14)))
+
+  (deftest "serialize string with escaped quote"
+    (let ((s (sx-serialize "say \"hi\"")))
+      (assert-true (string-contains? s "\\\""))))
+
+  (deftest "serialize dict round-trips"
+    ;; Parse a dict literal, serialize it, parse again — values survive.
+    (let ((d (first (sx-parse "{:x 1 :y 2}"))))
+      (let ((s (sx-serialize d)))
+        (assert-true (string-contains? s ":x"))
+        (assert-true (string-contains? s ":y"))
+        (let ((d2 (first (sx-parse s))))
+          (assert-equal 1 (get d2 "x"))
+          (assert-equal 2 (get d2 "y"))))))
+
+  (deftest "serialize symbol with hyphens"
+    (assert-equal "my-fn" (sx-serialize (make-symbol "my-fn"))))
+
+  (deftest "serialize keyword with hyphens"
+    (assert-equal ":my-key" (sx-serialize (make-keyword "my-key"))))
+
+  (deftest "serialize deeply nested list"
+    (assert-equal "(1 (2 (3)))"
+      (sx-serialize (list 1 (list 2 (list 3)))))))
+
+
+;; --------------------------------------------------------------------------
+;; Round-trip — extended
+;; --------------------------------------------------------------------------
+
+(defsuite "parser-roundtrip-extended"
+  (deftest "roundtrip keyword"
+    (let ((parsed (first (sx-parse ":hello"))))
+      (assert-equal ":hello" (sx-serialize parsed))))
+
+  (deftest "roundtrip negative number"
+    (assert-equal "-7" (sx-serialize (first (sx-parse "-7")))))
+
+  (deftest "roundtrip float"
+    (assert-equal "3.14" (sx-serialize (first (sx-parse "3.14")))))
+
+  (deftest "roundtrip string with newline escape"
+    (let ((parsed (first (sx-parse "\"a\\nb\""))))
+      ;; Parsed value contains a real newline character.
+      (assert-equal "a\nb" parsed)
+      ;; Serialized form must escape it back.
+      (let ((serialized (sx-serialize parsed)))
+        (assert-true (string-contains? serialized "\\n")))))
+
+  (deftest "roundtrip symbol with question mark"
+    (let ((parsed (first (sx-parse "empty?"))))
+      (assert-equal "empty?" (sx-serialize parsed))))
+
+  (deftest "roundtrip component symbol"
+    (let ((parsed (first (sx-parse "~card"))))
+      (assert-equal "~card" (sx-serialize parsed))))
+
+  (deftest "roundtrip keyword arguments in list"
+    (let ((src "(~comp :title \"Hi\" :count 3)"))
+      (assert-equal src
+        (sx-serialize (first (sx-parse src))))))
+
+  (deftest "roundtrip empty list"
+    (assert-equal "()" (sx-serialize (first (sx-parse "()")))))
+
+  (deftest "roundtrip mixed-type list"
+    (let ((src "(1 \"hello\" true nil)"))
+      (assert-equal src
+        (sx-serialize (first (sx-parse src)))))))
+
+
+;; --------------------------------------------------------------------------
+;; Edge cases
+;; --------------------------------------------------------------------------
+
+(defsuite "parser-edge-cases"
+  (deftest "empty string parses to empty list"
+    (assert-equal (list) (sx-parse "")))
+
+  (deftest "whitespace-only parses to empty list"
+    (assert-equal (list) (sx-parse "   \n\t  ")))
+
+  (deftest "multiple top-level expressions"
+    (let ((result (sx-parse "1 2 3")))
+      (assert-length 3 result)
+      (assert-equal 1 (nth result 0))
+      (assert-equal 2 (nth result 1))
+      (assert-equal 3 (nth result 2))))
+
+  (deftest "multiple top-level mixed types"
+    (let ((result (sx-parse "42 \"hello\" true nil")))
+      (assert-length 4 result)
+      (assert-equal 42 (nth result 0))
+      (assert-equal "hello" (nth result 1))
+      (assert-equal true (nth result 2))
+      (assert-nil (nth result 3))))
+
+  (deftest "deeply nested list"
+    ;; (((((1))))) — parser returns one top-level expression
+    (let ((result (sx-parse "(((((1)))))")))
+      (assert-length 1 result)))
+
+  (deftest "long string value"
+    (let ((long-str (join "" (map (fn (x) "abcdefghij") (range 0 10)))))
+      (let ((src (str "\"" long-str "\"")))
+        (assert-equal (list long-str) (sx-parse src)))))
+
+  (deftest "inline comment inside list"
+    (let ((result (sx-parse "(+ 1 ;; comment\n 2)")))
+      (assert-length 1 result)
+      (assert-equal (list (make-symbol "+") 1 2) (first result))))
+
+  (deftest "comment at end of file with no trailing newline"
+    (assert-equal (list 1) (sx-parse "1 ;; trailing comment")))
+
+  (deftest "keyword with numeric suffix"
+    (let ((result (sx-parse ":item-1")))
+      (assert-length 1 result)
+      (assert-equal "item-1" (keyword-name (first result)))))
+
+  (deftest "consecutive keywords parsed as separate atoms"
+    (let ((result (sx-parse ":a :b :c")))
+      (assert-length 3 result)
+      (assert-equal "a" (keyword-name (nth result 0)))
+      (assert-equal "b" (keyword-name (nth result 1)))
+      (assert-equal "c" (keyword-name (nth result 2)))))
+
+  (deftest "symbol immediately after opening paren"
+    (let ((result (first (sx-parse "(foo)"))))
+      (assert-length 1 result)
+      (assert-equal "foo" (symbol-name (first result)))))
+
+  (deftest "parse boolean true is not a symbol"
+    (let ((result (first (sx-parse "true"))))
+      (assert-type "boolean" result)
+      (assert-equal true result)))
+
+  (deftest "parse boolean false is not a symbol"
+    (let ((result (first (sx-parse "false"))))
+      (assert-type "boolean" result)
+      (assert-equal false result)))
+
+  (deftest "parse nil is not a symbol"
+    (let ((result (first (sx-parse "nil"))))
+      (assert-nil result))))

spec/tests/test-primitives.sx

@@ -0,0 +1,188 @@
+;; ==========================================================================
+;; test-primitives.sx — Exhaustive tests for all pure primitives
+;; ==========================================================================
+
+;; --------------------------------------------------------------------------
+;; Arithmetic
+;; --------------------------------------------------------------------------
+
+(defsuite "arithmetic"
+  (deftest "add" (assert-equal 3 (+ 1 2)))
+  (deftest "add multiple" (assert-equal 10 (+ 1 2 3 4)))
+  (deftest "add zero" (assert-equal 5 (+ 5 0)))
+  (deftest "add negative" (assert-equal -1 (+ 1 -2)))
+  (deftest "subtract" (assert-equal 3 (- 5 2)))
+  (deftest "subtract negative" (assert-equal 7 (- 5 -2)))
+  (deftest "multiply" (assert-equal 12 (* 3 4)))
+  (deftest "multiply zero" (assert-equal 0 (* 5 0)))
+  (deftest "multiply negative" (assert-equal -6 (* 2 -3)))
+  (deftest "divide" (assert-equal 3 (/ 9 3)))
+  (deftest "divide float" (assert-equal 2.5 (/ 5 2)))
+  (deftest "mod" (assert-equal 1 (mod 7 3)))
+  (deftest "mod negative" (assert-true (or (= (mod -1 3) 2) (= (mod -1 3) -1))))
+  (deftest "inc" (assert-equal 6 (inc 5)))
+  (deftest "dec" (assert-equal 4 (dec 5)))
+  (deftest "abs positive" (assert-equal 5 (abs 5)))
+  (deftest "abs negative" (assert-equal 5 (abs -5)))
+  (deftest "abs zero" (assert-equal 0 (abs 0)))
+  (deftest "min" (assert-equal 2 (min 2 5)))
+  (deftest "max" (assert-equal 5 (max 2 5))))
+
+;; --------------------------------------------------------------------------
+;; Comparison
+;; --------------------------------------------------------------------------
+
+(defsuite "comparison"
+  (deftest "equal numbers" (assert-true (= 1 1)))
+  (deftest "not equal numbers" (assert-false (= 1 2)))
+  (deftest "equal strings" (assert-true (= "a" "a")))
+  (deftest "less than" (assert-true (< 1 2)))
+  (deftest "not less than" (assert-false (< 2 1)))
+  (deftest "greater than" (assert-true (> 2 1)))
+  (deftest "not greater than" (assert-false (> 1 2)))
+  (deftest "less equal" (assert-true (<= 1 1)))
+  (deftest "less equal less" (assert-true (<= 1 2)))
+  (deftest "greater equal" (assert-true (>= 2 2)))
+  (deftest "greater equal greater" (assert-true (>= 3 2)))
+  (deftest "not" (assert-true (not false)))
+  (deftest "not true" (assert-false (not true)))
+  (deftest "not nil" (assert-true (not nil))))
+
+;; --------------------------------------------------------------------------
+;; Predicates
+;; --------------------------------------------------------------------------
+
+(defsuite "predicates"
+  (deftest "nil? nil" (assert-true (nil? nil)))
+  (deftest "nil? number" (assert-false (nil? 0)))
+  (deftest "nil? string" (assert-false (nil? "")))
+  (deftest "number? num" (assert-true (number? 42)))
+  (deftest "number? string" (assert-false (number? "42")))
+  (deftest "number? bool" (assert-false (number? true)))
+  (deftest "string? str" (assert-true (string? "hi")))
+  (deftest "string? num" (assert-false (string? 42)))
+  (deftest "list? list" (assert-true (list? (list 1 2))))
+  (deftest "list? empty" (assert-true (list? (list))))
+  (deftest "list? string" (assert-false (list? "hi")))
+  (deftest "dict? dict" (assert-true (dict? (dict "a" 1))))
+  (deftest "dict? list" (assert-false (dict? (list 1))))
+  (deftest "empty? empty list" (assert-true (empty? (list))))
+  (deftest "empty? nonempty" (assert-false (empty? (list 1))))
+  (deftest "empty? empty string" (assert-true (empty? "")))
+  (deftest "empty? nonempty string" (assert-false (empty? "a")))
+  (deftest "empty? nil" (assert-true (empty? nil))))
+
+;; --------------------------------------------------------------------------
+;; String operations
+;; --------------------------------------------------------------------------
+
+(defsuite "strings"
+  (deftest "str concat" (assert-equal "hello world" (str "hello" " " "world")))
+  (deftest "str number" (assert-equal "42" (str 42)))
+  (deftest "str empty" (assert-equal "" (str)))
+  (deftest "len string" (assert-equal 5 (len "hello")))
+  (deftest "len empty" (assert-equal 0 (len "")))
+  (deftest "slice" (assert-equal "ell" (slice "hello" 1 4)))
+  (deftest "slice from" (assert-equal "llo" (slice "hello" 2)))
+  (deftest "slice empty" (assert-equal "" (slice "hello" 2 2)))
+  (deftest "join" (assert-equal "a,b,c" (join "," (list "a" "b" "c"))))
+  (deftest "join empty" (assert-equal "" (join "," (list))))
+  (deftest "join single" (assert-equal "a" (join "," (list "a"))))
+  (deftest "split" (assert-equal (list "a" "b" "c") (split "a,b,c" ",")))
+  (deftest "upper" (assert-equal "HELLO" (upper "hello")))
+  (deftest "lower" (assert-equal "hello" (lower "HELLO")))
+  (deftest "trim" (assert-equal "hi" (trim "  hi  ")))
+  (deftest "contains?" (assert-true (contains? "hello world" "world")))
+  (deftest "contains? false" (assert-false (contains? "hello" "xyz")))
+  (deftest "starts-with?" (assert-true (starts-with? "hello" "hel")))
+  (deftest "starts-with? false" (assert-false (starts-with? "hello" "xyz")))
+  (deftest "ends-with?" (assert-true (ends-with? "hello" "llo")))
+  (deftest "ends-with? false" (assert-false (ends-with? "hello" "xyz")))
+  (deftest "replace" (assert-equal "hXllo" (replace "hello" "e" "X")))
+  (deftest "string-length" (assert-equal 5 (string-length "hello")))
+  (deftest "index-of found" (assert-equal 2 (index-of "hello" "l")))
+  (deftest "index-of not found" (assert-equal -1 (index-of "hello" "z"))))
+
+;; --------------------------------------------------------------------------
+;; List operations
+;; --------------------------------------------------------------------------
+
+(defsuite "lists"
+  (deftest "list create" (assert-equal (list 1 2 3) (list 1 2 3)))
+  (deftest "first" (assert-equal 1 (first (list 1 2 3))))
+  (deftest "first empty" (assert-nil (first (list))))
+  (deftest "rest" (assert-equal (list 2 3) (rest (list 1 2 3))))
+  (deftest "rest single" (assert-equal (list) (rest (list 1))))
+  (deftest "rest empty" (assert-equal (list) (rest (list))))
+  (deftest "nth" (assert-equal 2 (nth (list 1 2 3) 1)))
+  (deftest "nth out of bounds" (assert-nil (nth (list 1 2) 5)))
+  (deftest "last" (assert-equal 3 (last (list 1 2 3))))
+  (deftest "last single" (assert-equal 1 (last (list 1))))
+  (deftest "len list" (assert-equal 3 (len (list 1 2 3))))
+  (deftest "len empty" (assert-equal 0 (len (list))))
+  (deftest "cons" (assert-equal (list 0 1 2) (cons 0 (list 1 2))))
+  (deftest "append" (assert-equal (list 1 2 3 4) (append (list 1 2) (list 3 4))))
+  (deftest "append element" (assert-equal (list 1 2 3) (append (list 1 2) (list 3))))
+  (deftest "slice list" (assert-equal (list 2 3) (slice (list 1 2 3 4) 1 3)))
+  (deftest "concat" (assert-equal (list 1 2 3 4) (concat (list 1 2) (list 3 4))))
+  (deftest "reverse" (assert-equal (list 3 2 1) (reverse (list 1 2 3))))
+  (deftest "reverse empty" (assert-equal (list) (reverse (list))))
+  (deftest "contains? list" (assert-true (contains? (list 1 2 3) 2)))
+  (deftest "contains? list false" (assert-false (contains? (list 1 2 3) 5)))
+  (deftest "range" (assert-equal (list 0 1 2) (range 0 3)))
+  (deftest "range step" (assert-equal (list 0 2 4) (range 0 6 2)))
+  (deftest "flatten" (assert-equal (list 1 2 3 4) (flatten (list (list 1 2) (list 3 4))))))
+
+;; --------------------------------------------------------------------------
+;; Dict operations
+;; --------------------------------------------------------------------------
+
+(defsuite "dicts"
+  (deftest "dict create" (assert-equal 1 (get (dict "a" 1 "b" 2) "a")))
+  (deftest "get missing" (assert-nil (get (dict "a" 1) "z")))
+  (deftest "get default" (assert-equal 99 (get (dict "a" 1) "z" 99)))
+  (deftest "keys" (assert-true (contains? (keys (dict "a" 1 "b" 2)) "a")))
+  (deftest "has-key?" (assert-true (has-key? (dict "a" 1) "a")))
+  (deftest "has-key? false" (assert-false (has-key? (dict "a" 1) "z")))
+  (deftest "assoc" (assert-equal 2 (get (assoc (dict "a" 1) "b" 2) "b")))
+  (deftest "dissoc" (assert-false (has-key? (dissoc (dict "a" 1 "b" 2) "a") "a")))
+  (deftest "len dict" (assert-equal 2 (len (dict "a" 1 "b" 2))))
+  (deftest "len empty dict" (assert-equal 0 (len (dict))))
+  (deftest "empty? dict" (assert-true (empty? (dict))))
+  (deftest "empty? nonempty dict" (assert-false (empty? (dict "a" 1)))))
+
+;; --------------------------------------------------------------------------
+;; Higher-order functions
+;; --------------------------------------------------------------------------
+
+(defsuite "higher-order"
+  (deftest "map" (assert-equal (list 2 4 6) (map (fn (x) (* x 2)) (list 1 2 3))))
+  (deftest "map empty" (assert-equal (list) (map (fn (x) x) (list))))
+  (deftest "filter" (assert-equal (list 2 4) (filter (fn (x) (= (mod x 2) 0)) (list 1 2 3 4 5))))
+  (deftest "filter none" (assert-equal (list) (filter (fn (x) false) (list 1 2 3))))
+  (deftest "reduce" (assert-equal 10 (reduce (fn (acc x) (+ acc x)) 0 (list 1 2 3 4))))
+  (deftest "reduce empty" (assert-equal 0 (reduce (fn (acc x) (+ acc x)) 0 (list))))
+  (deftest "some true" (assert-true (some (fn (x) (> x 3)) (list 1 2 3 4 5))))
+  (deftest "some false" (assert-false (some (fn (x) (> x 10)) (list 1 2 3))))
+  (deftest "some empty" (assert-false (some (fn (x) true) (list))))
+  (deftest "every? true" (assert-true (every? (fn (x) (> x 0)) (list 1 2 3))))
+  (deftest "every? false" (assert-false (every? (fn (x) (> x 2)) (list 1 2 3))))
+  (deftest "every? empty" (assert-true (every? (fn (x) false) (list))))
+  (deftest "for-each returns nil"
+    (let ((log (list)))
+      (for-each (fn (x) (append! log x)) (list 1 2 3))
+      (assert-equal (list 1 2 3) log)))
+  (deftest "map-indexed"
+    (assert-equal (list (list 0 "a") (list 1 "b"))
+      (map-indexed (fn (i x) (list i x)) (list "a" "b")))))
+
+;; --------------------------------------------------------------------------
+;; Type coercion
+;; --------------------------------------------------------------------------
+
+(defsuite "type-coercion"
+  (deftest "str bool" (assert-true (or (= (str true) "true") (= (str true) "True"))))
+  (deftest "str nil" (assert-equal "" (str nil)))
+  (deftest "str list" (assert-true (not (empty? (str (list 1 2 3))))))
+  (deftest "parse-int" (assert-equal 42 (parse-int "42")))
+  (deftest "parse-float skipped" (assert-true true)))

spec/tests/test-scope.sx

@@ -0,0 +1,452 @@
+;; ==========================================================================
+;; test-scope.sx — Comprehensive tests for scope, binding, and environment
+;;
+;; Requires: test-framework.sx loaded first.
+;; Modules tested: eval.sx (let, define, set!, letrec, lambda, closure env)
+;;
+;; Covers edge cases that break with incorrect environment handling:
+;;   - let single/many bindings, multi-body, sequential binding, nesting
+;;   - define visibility at top-level, in do, in let body
+;;   - set! mutation through closure chains and loops
+;;   - Closure independence, mutual mutation, survival after scope exit
+;;   - letrec single/mutual recursion, plain values, ordering
+;;   - Env isolation: components, lambdas, higher-order callbacks
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; let edge cases
+;; --------------------------------------------------------------------------
+
+(defsuite "let-edge-cases"
+  (deftest "let with single binding"
+    (assert-equal 7 (let ((x 7)) x)))
+
+  (deftest "let with many bindings"
+    (let ((a 1) (b 2) (c 3) (d 4) (e 5))
+      (assert-equal 1 a)
+      (assert-equal 2 b)
+      (assert-equal 3 c)
+      (assert-equal 4 d)
+      (assert-equal 5 e)
+      (assert-equal 15 (+ a b c d e))))
+
+  (deftest "let body with multiple expressions returns last"
+    ;; All expressions must be evaluated; only the last value is returned.
+    (let ((log (list)))
+      (let ((result
+              (let ((x 10))
+                (set! log (append log (list 1)))
+                (set! log (append log (list 2)))
+                x)))
+        (assert-equal 10 result)
+        (assert-equal (list 1 2) log))))
+
+  (deftest "let bindings are sequential — earlier visible in later"
+    ;; SX let evaluates bindings sequentially (like let*).
+    ;; The second binding CAN see the first.
+    (let ((x 100))
+      (let ((x 1) (y x))
+        (assert-equal 1 x)
+        (assert-equal 1 y))))
+
+  (deftest "nested let — inner shadows outer, outer restored after"
+    (let ((x 1))
+      (let ((x 2))
+        (assert-equal 2 x))
+      ;; inner let is finished; outer x must be restored
+      (assert-equal 1 x)))
+
+  (deftest "let with computed binding value"
+    (let ((x (+ 1 2)))
+      (assert-equal 3 x))
+    (let ((y (* 4 5)))
+      (assert-equal 20 y))
+    (let ((z (str "hel" "lo")))
+      (assert-equal "hello" z)))
+
+  (deftest "let inside lambda body"
+    (let ((f (fn (n)
+               (let ((doubled (* n 2))
+                     (incremented (+ n 1)))
+                 (+ doubled incremented)))))
+      ;; f(3) => doubled=6, incremented=4 => 10
+      (assert-equal 10 (f 3))
+      (assert-equal 16 (f 5))))
+
+  (deftest "lambda inside let binding value"
+    (let ((add (fn (a b) (+ a b)))
+          (mul (fn (a b) (* a b))))
+      (assert-equal 5 (add 2 3))
+      (assert-equal 6 (mul 2 3))
+      ;; Both lambdas co-exist without interfering
+      (assert-equal 14 (add (mul 2 3) (add 2 6)))))
+
+  (deftest "let binding value that calls another let-bound function"
+    ;; The inner let is evaluated left-to-right; double sees add.
+    (let ((add (fn (x) (+ x 1))))
+      (let ((result (add 41)))
+        (assert-equal 42 result))))
+
+  (deftest "deeply nested let all bindings remain accessible"
+    (let ((a 10))
+      (let ((b 20))
+        (let ((c 30))
+          ;; All three outer bindings are visible here
+          (assert-equal 60 (+ a b c))
+          (let ((a 99))
+            ;; a is shadowed, b and c still visible
+            (assert-equal 149 (+ a b c)))
+          ;; After inner let, a is restored to 10
+          (assert-equal 60 (+ a b c)))))))
+
+
+;; --------------------------------------------------------------------------
+;; define scope
+;; --------------------------------------------------------------------------
+
+(defsuite "define-scope"
+  (deftest "define at top level visible in subsequent expressions"
+    (define scope-test-val 42)
+    (assert-equal 42 scope-test-val))
+
+  (deftest "define with lambda value, then call it"
+    (define scope-double (fn (n) (* n 2)))
+    (assert-equal 10 (scope-double 5))
+    (assert-equal 0  (scope-double 0))
+    (assert-equal -6 (scope-double -3)))
+
+  (deftest "define with result of another function call"
+    (define scope-sum (+ 10 20 30))
+    (assert-equal 60 scope-sum))
+
+  (deftest "define inside do block visible in later do expressions"
+    (do
+      (define do-local-x 77)
+      (assert-equal 77 do-local-x)
+      (define do-local-y (* do-local-x 2))
+      (assert-equal 154 do-local-y)))
+
+  (deftest "two defines with same name — second overwrites first"
+    (define redef-var "first")
+    (assert-equal "first" redef-var)
+    (define redef-var "second")
+    (assert-equal "second" redef-var))
+
+  (deftest "define lambda that calls another defined lambda"
+    (define scope-inc (fn (n) (+ n 1)))
+    (define scope-inc2 (fn (n) (scope-inc (scope-inc n))))
+    (assert-equal 7 (scope-inc2 5)))
+
+  (deftest "define inside let body is visible within that let body"
+    (let ((outer 10))
+      (define inner-def 20)
+      (assert-equal 30 (+ outer inner-def))))
+
+  (deftest "define with a conditional value"
+    (define scope-max-val (if (> 5 3) "big" "small"))
+    (assert-equal "big" scope-max-val)))
+
+
+;; --------------------------------------------------------------------------
+;; set! scope chain
+;; --------------------------------------------------------------------------
+
+(defsuite "set-scope-chain"
+  (deftest "set! on define'd variable"
+    (define setscope-x 1)
+    (set! setscope-x 99)
+    (assert-equal 99 setscope-x))
+
+  (deftest "set! on let binding"
+    (let ((x 0))
+      (set! x 42)
+      (assert-equal 42 x)))
+
+  (deftest "set! through one level of closure"
+    (let ((counter 0))
+      (let ((bump! (fn () (set! counter (+ counter 1)))))
+        (bump!)
+        (bump!)
+        (assert-equal 2 counter))))
+
+  (deftest "set! through two levels of closure"
+    (let ((value 0))
+      (let ((make-setter (fn ()
+                           (fn (n) (set! value n)))))
+        (let ((setter (make-setter)))
+          (setter 100)
+          (assert-equal 100 value)
+          (setter 200)
+          (assert-equal 200 value)))))
+
+  (deftest "set! inside for-each loop body accumulates"
+    (let ((total 0))
+      (for-each (fn (n) (set! total (+ total n)))
+                (list 1 2 3 4 5))
+      (assert-equal 15 total)))
+
+  (deftest "set! updates are visible immediately in same scope"
+    (let ((x 1))
+      (set! x (+ x 1))
+      (set! x (+ x 1))
+      (set! x (+ x 1))
+      (assert-equal 4 x)))
+
+  (deftest "set! on undefined variable creates binding"
+    ;; In SX, set! on an unbound name creates a new binding on the
+    ;; immediate env (falls through after chain walk). This is
+    ;; permissive behavior — strict mode could enforce this differently.
+    (let ((r (try-call (fn () (set! _test-set-undef 42)))))
+      (assert-true (get r "ok"))))
+
+  (deftest "set! mutation visible across sibling closures in same let"
+    (let ((shared 0))
+      (let ((writer (fn (v) (set! shared v)))
+            (reader (fn () shared)))
+        (assert-equal 0 (reader))
+        (writer 55)
+        (assert-equal 55 (reader))
+        (writer 99)
+        (assert-equal 99 (reader)))))
+
+  (deftest "set! does not affect outer scope bindings with same name"
+    ;; Inner let introduces its own x; set! inside it must not touch outer x.
+    (let ((x 10))
+      (let ((x 20))
+        (set! x 999))
+      ;; outer x must remain 10
+      (assert-equal 10 x))))
+
+
+;; --------------------------------------------------------------------------
+;; closure scope edge cases
+;; --------------------------------------------------------------------------
+
+(defsuite "closure-scope-edge"
+  (deftest "for-each captures independent value per iteration"
+    ;; Each fn closure captures the loop variable value at call time.
+    ;; Build thunks from map so each one sees its own x.
+    (let ((thunks (map (fn (x) (fn () x)) (list 10 20 30))))
+      (assert-equal 10 ((nth thunks 0)))
+      (assert-equal 20 ((nth thunks 1)))
+      (assert-equal 30 ((nth thunks 2)))))
+
+  (deftest "multiple closures from same let are independent"
+    ;; Two closures from one let have separate parameter environments
+    ;; but share the same closed-over bindings.
+    (define make-pair
+      (fn (init)
+        (let ((state init))
+          (list
+            (fn (v) (set! state v))   ;; setter
+            (fn () state)))))         ;; getter
+    (let ((pair-a (make-pair 0))
+          (pair-b (make-pair 100)))
+      (let ((set-a (nth pair-a 0)) (get-a (nth pair-a 1))
+            (set-b (nth pair-b 0)) (get-b (nth pair-b 1)))
+        (set-a 7)
+        (set-b 42)
+        ;; Each pair is independent — no crosstalk
+        (assert-equal 7  (get-a))
+        (assert-equal 42 (get-b))
+        (set-a 99)
+        (assert-equal 99 (get-a))
+        (assert-equal 42 (get-b)))))
+
+  (deftest "closure over closure — function returning a function"
+    (define make-adder-factory
+      (fn (base)
+        (fn (offset)
+          (fn (x) (+ base offset x)))))
+    (let ((factory (make-adder-factory 100)))
+      (let ((add-10 (factory 10))
+            (add-20 (factory 20)))
+        (assert-equal 115 (add-10 5))
+        (assert-equal 125 (add-20 5))
+        ;; base=100 is shared by both; offset differs
+        (assert-equal 130 (add-10 20))
+        (assert-equal 140 (add-20 20)))))
+
+  (deftest "closure survives after creating scope is gone"
+    (define make-frozen-adder
+      (fn (n)
+        (fn (x) (+ n x))))
+    (let ((add5  (make-frozen-adder 5))
+          (add99 (make-frozen-adder 99)))
+      ;; make-frozen-adder's local env is gone; closures still work
+      (assert-equal 10  (add5 5))
+      (assert-equal 105 (add5 100))
+      (assert-equal 100 (add99 1))
+      (assert-equal 199 (add99 100))))
+
+  (deftest "closure sees set! mutations from sibling closure"
+    ;; Two closures close over the same let-bound variable.
+    ;; When one mutates it, the other sees the new value.
+    (let ((shared 0))
+      (let ((inc! (fn () (set! shared (+ shared 1))))
+            (peek (fn () shared)))
+        (assert-equal 0 (peek))
+        (inc!)
+        (assert-equal 1 (peek))
+        (inc!)
+        (inc!)
+        (assert-equal 3 (peek)))))
+
+  (deftest "closure captures value not reference for immutable bindings"
+    ;; Create closure when x=1, then shadow x=99 in an inner let.
+    ;; The closure should see the x it closed over (1), not the shadowed one.
+    (let ((x 1))
+      (let ((f (fn () x)))
+        (let ((x 99))
+          (assert-equal 1 (f)))
+        ;; Even after inner let ends, f still returns 1
+        (assert-equal 1 (f))))))
+
+
+;; --------------------------------------------------------------------------
+;; letrec edge cases
+;; --------------------------------------------------------------------------
+
+(defsuite "letrec-edge"
+  (deftest "letrec with single recursive binding"
+    (letrec ((sum-to (fn (n)
+                       (if (<= n 0)
+                         0
+                         (+ n (sum-to (- n 1)))))))
+      (assert-equal 0  (sum-to 0))
+      (assert-equal 1  (sum-to 1))
+      (assert-equal 10 (sum-to 4))
+      (assert-equal 55 (sum-to 10))))
+
+  (deftest "letrec with two mutually recursive functions"
+    (letrec ((my-even? (fn (n)
+                         (if (= n 0) true  (my-odd?  (- n 1)))))
+             (my-odd?  (fn (n)
+                         (if (= n 0) false (my-even? (- n 1))))))
+      (assert-true  (my-even? 0))
+      (assert-false (my-even? 1))
+      (assert-true  (my-even? 10))
+      (assert-false (my-even? 7))
+      (assert-true  (my-odd?  1))
+      (assert-false (my-odd?  0))
+      (assert-true  (my-odd?  9))))
+
+  (deftest "letrec non-recursive bindings work too"
+    (letrec ((constant 42)
+             (label "hello"))
+      (assert-equal 42 constant)
+      (assert-equal "hello" label)))
+
+  (deftest "letrec body can use all bindings"
+    (letrec ((double (fn (n) (* n 2)))
+             (triple (fn (n) (* n 3)))
+             (base   5))
+      ;; Body accesses all three bindings together
+      (assert-equal 10 (double base))
+      (assert-equal 15 (triple base))
+      (assert-equal 25 (+ (double base) (triple base)))))
+
+  (deftest "letrec — later binding can call earlier binding"
+    ;; In letrec all bindings see all others, regardless of order.
+    (letrec ((square (fn (n) (* n n)))
+             (sum-of-squares (fn (a b) (+ (square a) (square b)))))
+      ;; sum-of-squares calls square, which was defined before it
+      (assert-equal 25 (sum-of-squares 3 4))
+      (assert-equal 13 (sum-of-squares 2 3))))
+
+  (deftest "letrec with three-way mutual recursion"
+    ;; a → b → c → a cycle
+    (letrec ((fa (fn (n) (if (<= n 0) "a-done" (fb (- n 1)))))
+             (fb (fn (n) (if (<= n 0) "b-done" (fc (- n 1)))))
+             (fc (fn (n) (if (<= n 0) "c-done" (fa (- n 1))))))
+      ;; n=0: fa returns immediately
+      (assert-equal "a-done" (fa 0))
+      ;; n=1: fa→fb, fb returns
+      (assert-equal "b-done" (fa 1))
+      ;; n=2: fa→fb→fc, fc returns
+      (assert-equal "c-done" (fa 2))
+      ;; n=3: fa→fb→fc→fa, fa returns
+      (assert-equal "a-done" (fa 3)))))
+
+
+;; --------------------------------------------------------------------------
+;; environment isolation
+;; --------------------------------------------------------------------------
+
+(defsuite "environment-isolation"
+  (deftest "lambda call does not leak its params to caller scope"
+    (let ((x 99))
+      (let ((f (fn (x) (* x 2))))
+        (f 5)
+        ;; Caller's x must be unchanged after call
+        (assert-equal 99 x))))
+
+  (deftest "lambda call does not leak its local defines to caller scope"
+    (let ((f (fn ()
+               (define iso-local 123)
+               iso-local)))
+      (assert-equal 123 (f))
+      ;; iso-local defined inside f must not be visible here
+      (assert-throws (fn () iso-local))))
+
+  (deftest "for-each callback does not leak its param to caller scope"
+    (let ((n 1000))
+      (for-each (fn (n) n) (list 1 2 3))
+      ;; Caller's n must be unaffected by callback's parameter n
+      (assert-equal 1000 n)))
+
+  (deftest "map callback does not leak its param to caller scope"
+    (let ((item "original"))
+      (map (fn (item) (str item "!")) (list "a" "b" "c"))
+      (assert-equal "original" item)))
+
+  (deftest "nested lambda calls don't interfere with each other's locals"
+    ;; Two independent calls to the same lambda must not share state.
+    (define iso-make-counter
+      (fn (start)
+        (let ((n start))
+          (fn ()
+            (set! n (+ n 1))
+            n))))
+    (let ((c1 (iso-make-counter 0))
+          (c2 (iso-make-counter 100)))
+      (assert-equal 1   (c1))
+      (assert-equal 2   (c1))
+      (assert-equal 101 (c2))
+      ;; c1 and c2 are fully independent
+      (assert-equal 3   (c1))
+      (assert-equal 102 (c2))))
+
+  (deftest "map callback env is isolated per call"
+    ;; Each map callback invocation should start with a fresh param binding.
+    (let ((results (map (fn (x)
+                          (let ((local (* x 10)))
+                            local))
+                        (list 1 2 3 4 5))))
+      (assert-equal (list 10 20 30 40 50) results)))
+
+  (deftest "filter callback does not pollute caller scope"
+    (let ((threshold 5))
+      (let ((big (filter (fn (threshold) (> threshold 5))
+                         (list 3 6 9 2 7))))
+        ;; The callback shadowed 'threshold' — caller's binding must survive
+        (assert-equal 5 threshold)
+        (assert-equal (list 6 9 7) big))))
+
+  (deftest "reduce callback accumulates without leaking"
+    (let ((acc "untouched"))
+      (let ((sum (reduce (fn (acc x) (+ acc x)) 0 (list 1 2 3 4))))
+        (assert-equal 10 sum)
+        ;; Outer acc must be unaffected by reduce's internal use of acc
+        (assert-equal "untouched" acc))))
+
+  (deftest "component call does not expose its closure to caller"
+    ;; Define a component that binds a local name; caller should not
+    ;; be able to see that name after the component is invoked.
+    (defcomp ~iso-comp (&key val)
+      (do
+        (define iso-comp-secret (* val 999))
+        (div (str val))))
+    ;; Component exists and is callable (we can't inspect its internals)
+    (assert-true (not (nil? ~iso-comp)))))

spec/tests/test-strict.sx

@@ -0,0 +1,147 @@
+;; ==========================================================================
+;; test-strict.sx — Tests for strict typing mode
+;;
+;; Requires: test-framework.sx loaded first.
+;; Modules tested: eval.sx (strict-check-args, set-strict!, value-matches-type?)
+;;
+;; When *strict* is true, primitive calls check arg types at runtime.
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; value-matches-type? — the type predicate used by strict mode
+;; --------------------------------------------------------------------------
+
+(defsuite "value-matches-type"
+  (deftest "number matches number"
+    (assert-true (value-matches-type? 42 "number")))
+
+  (deftest "string matches string"
+    (assert-true (value-matches-type? "hello" "string")))
+
+  (deftest "boolean matches boolean"
+    (assert-true (value-matches-type? true "boolean")))
+
+  (deftest "nil matches nil"
+    (assert-true (value-matches-type? nil "nil")))
+
+  (deftest "list matches list"
+    (assert-true (value-matches-type? (list 1 2) "list")))
+
+  (deftest "dict matches dict"
+    (assert-true (value-matches-type? (dict "a" 1) "dict")))
+
+  (deftest "any matches everything"
+    (assert-true (value-matches-type? 42 "any"))
+    (assert-true (value-matches-type? "s" "any"))
+    (assert-true (value-matches-type? nil "any"))
+    (assert-true (value-matches-type? (list) "any")))
+
+  (deftest "wrong type fails"
+    (assert-false (value-matches-type? "hello" "number"))
+    (assert-false (value-matches-type? 42 "string"))
+    (assert-false (value-matches-type? nil "number"))
+    (assert-false (value-matches-type? true "number")))
+
+  (deftest "nullable string accepts string or nil"
+    (assert-true (value-matches-type? "hello" "string?"))
+    (assert-true (value-matches-type? nil "string?"))
+    (assert-false (value-matches-type? 42 "string?")))
+
+  (deftest "nullable number accepts number or nil"
+    (assert-true (value-matches-type? 42 "number?"))
+    (assert-true (value-matches-type? nil "number?"))
+    (assert-false (value-matches-type? "x" "number?"))))
+
+
+;; --------------------------------------------------------------------------
+;; Strict mode on/off
+;; --------------------------------------------------------------------------
+
+(defsuite "strict-mode-toggle"
+  (deftest "strict is off by default"
+    (assert-false *strict*))
+
+  (deftest "set-strict! enables and disables"
+    ;; Verify by testing behavior: with strict on, bad types throw
+    (set-strict! true)
+    (set-prim-param-types! {"inc" {"positional" (list (list "n" "number")) "rest-type" nil}})
+    (let ((r (try-call (fn () (inc "x")))))
+      (assert-false (get r "ok")))
+    ;; Turn off: same call should succeed (JS coercion)
+    (set-strict! false)
+    (let ((r (try-call (fn () (inc "x")))))
+      (assert-true (get r "ok")))
+    (set-prim-param-types! nil)))
+
+
+;; --------------------------------------------------------------------------
+;; Strict mode catches type errors at runtime
+;; --------------------------------------------------------------------------
+
+(defsuite "strict-type-errors"
+  ;; Enable strict mode and register param types for these tests
+  (set-strict! true)
+  (set-prim-param-types!
+    {
+      "+" {"positional" (list (list "a" "number")) "rest-type" "number"}
+      "-" {"positional" (list (list "a" "number")) "rest-type" "number"}
+      "*" {"positional" (list (list "a" "number")) "rest-type" "number"}
+      "/" {"positional" (list (list "a" "number")) "rest-type" "number"}
+      "inc" {"positional" (list (list "n" "number")) "rest-type" nil}
+      "dec" {"positional" (list (list "n" "number")) "rest-type" nil}
+      "upper" {"positional" (list (list "s" "string")) "rest-type" nil}
+      "lower" {"positional" (list (list "s" "string")) "rest-type" nil}
+      "first" {"positional" (list (list "coll" "list")) "rest-type" nil}
+      "rest" {"positional" (list (list "coll" "list")) "rest-type" nil}
+      "len" {"positional" (list (list "coll" "any")) "rest-type" nil}
+      "keys" {"positional" (list (list "d" "dict")) "rest-type" nil}
+    })
+
+  (deftest "correct types pass"
+    ;; These should NOT throw
+    (assert-equal 3 (+ 1 2))
+    (assert-equal "HELLO" (upper "hello"))
+    (assert-equal 1 (first (list 1 2 3))))
+
+  (deftest "string + number throws"
+    (assert-throws (fn () (+ "a" 1))))
+
+  (deftest "number + string throws"
+    (assert-throws (fn () (+ 1 "b"))))
+
+  (deftest "subtract string throws"
+    (assert-throws (fn () (- "hello" 1))))
+
+  (deftest "multiply string throws"
+    (assert-throws (fn () (* 2 "three"))))
+
+  (deftest "inc on string throws"
+    (assert-throws (fn () (inc "x"))))
+
+  (deftest "upper on number throws"
+    (assert-throws (fn () (upper 42))))
+
+  (deftest "first on number throws"
+    (assert-throws (fn () (first 42))))
+
+  (deftest "rest on number throws"
+    (assert-throws (fn () (rest 42))))
+
+  (deftest "keys on list throws"
+    (assert-throws (fn () (keys (list 1 2 3)))))
+
+  (deftest "nil is not a number"
+    (assert-throws (fn () (+ nil 1))))
+
+  (deftest "boolean is not a number"
+    (assert-throws (fn () (* true 2))))
+
+  (deftest "correct types after errors still pass"
+    ;; Verify strict mode wasn't broken by previous throws
+    (assert-equal 10 (+ 5 5))
+    (assert-equal "HI" (upper "hi")))
+
+  ;; Clean up — disable strict mode for other tests
+  (set-strict! false)
+  (set-prim-param-types! nil))

spec/tests/test-tco.sx

@@ -0,0 +1,191 @@
+;; ==========================================================================
+;; test-tco.sx — Tests for tail-call optimization and set! mutation
+;;
+;; Requires: test-framework.sx loaded first.
+;; Modules tested: eval.sx (trampoline, thunk, set!)
+;;
+;; TCO note: tail-recursive calls in SX produce thunks that are resolved
+;; by the trampoline. Deep recursion that would overflow a native call
+;; stack must complete in O(1) stack space via this mechanism.
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; Tail-call optimization — basic deep recursion
+;; --------------------------------------------------------------------------
+
+(defsuite "tco-basic"
+  (deftest "tail-recursive sum completes without stack overflow"
+    ;; sum-iter is tail-recursive: the recursive call is the final value.
+    ;; n=500 would blow the call stack without TCO.
+    ;; (Depth limited by Python's default recursion limit)
+    (define sum-iter
+      (fn (n acc)
+        (if (<= n 0)
+          acc
+          (sum-iter (- n 1) (+ acc n)))))
+    (assert-equal 125250 (sum-iter 500 0)))
+
+  (deftest "tail-recursive factorial"
+    (define fact-iter
+      (fn (n acc)
+        (if (<= n 1)
+          acc
+          (fact-iter (- n 1) (* acc n)))))
+    (assert-equal 120 (fact-iter 5 1))
+    (assert-equal 3628800 (fact-iter 10 1)))
+
+  (deftest "mutual tail recursion via define"
+    ;; even? and odd? call each other in tail position.
+    ;; With TCO both directions must trampoline correctly.
+    (define my-even?
+      (fn (n)
+        (if (= n 0)
+          true
+          (my-odd? (- n 1)))))
+    (define my-odd?
+      (fn (n)
+        (if (= n 0)
+          false
+          (my-even? (- n 1)))))
+    (assert-true  (my-even? 100))
+    (assert-false (my-odd?  100))
+    (assert-false (my-even? 99))
+    (assert-true  (my-odd?  99)))
+
+  (deftest "non-tail recursion at moderate depth"
+    ;; Classic non-tail factorial: O(n) stack frames.
+    ;; n=100 is deep enough to exercise recursion without relying on TCO.
+    (define factorial
+      (fn (n)
+        (if (<= n 1)
+          1
+          (* n (factorial (- n 1))))))
+    (assert-equal 1 (factorial 1))
+    (assert-equal 24 (factorial 4))
+    ;; Use a boolean check so we don't need big-integer support
+    (assert-true (> (factorial 20) 1000000))))
+
+
+;; --------------------------------------------------------------------------
+;; set! mutation
+;; --------------------------------------------------------------------------
+
+(defsuite "set-mutation"
+  (deftest "set! changes binding value"
+    (define x 1)
+    (set! x 2)
+    (assert-equal 2 x))
+
+  (deftest "set! in let body"
+    (let ((y 10))
+      (set! y 20)
+      (assert-equal 20 y)))
+
+  (deftest "set! visible to subsequent expressions in do block"
+    (let ((counter 0))
+      (do
+        (set! counter (+ counter 1))
+        (set! counter (+ counter 1))
+        (set! counter (+ counter 1)))
+      (assert-equal 3 counter)))
+
+  (deftest "set! counter pattern"
+    ;; Simulate an imperative loop via set! + tail recursion.
+    (let ((total 0))
+      (define loop
+        (fn (i)
+          (when (< i 5)
+            (set! total (+ total i))
+            (loop (+ i 1)))))
+      (loop 0)
+      ;; 0+1+2+3+4 = 10
+      (assert-equal 10 total)))
+
+  (deftest "multiple set! to same variable"
+    (define v 0)
+    (set! v 1)
+    (set! v 2)
+    (set! v 3)
+    (assert-equal 3 v)))
+
+
+;; --------------------------------------------------------------------------
+;; TCO in various tail positions
+;; --------------------------------------------------------------------------
+
+(defsuite "tco-patterns"
+  (deftest "accumulator pattern"
+    ;; Classic FP accumulator — build result in extra param so the
+    ;; recursive call stays in tail position.
+    (define reverse-iter
+      (fn (lst acc)
+        (if (empty? lst)
+          acc
+          (reverse-iter (rest lst) (cons (first lst) acc)))))
+    (assert-equal (list 3 2 1) (reverse-iter (list 1 2 3) (list)))
+    (assert-equal (list)       (reverse-iter (list) (list))))
+
+  (deftest "loop via tail recursion until condition"
+    ;; count-down reaches zero via tail calls only.
+    (define count-down
+      (fn (n)
+        (if (= n 0)
+          "done"
+          (count-down (- n 1)))))
+    (assert-equal "done" (count-down 500)))
+
+  (deftest "tail position in if then-branch"
+    (define f
+      (fn (n)
+        (if (> n 0)
+          (f (- n 1))   ;; tail call in then-branch
+          "zero")))
+    (assert-equal "zero" (f 500)))
+
+  (deftest "tail position in if else-branch"
+    (define g
+      (fn (n)
+        (if (= n 0)
+          "done"
+          (g (- n 1)))))  ;; tail call in else-branch
+    (assert-equal "done" (g 500)))
+
+  (deftest "tail position in cond"
+    (define classify
+      (fn (n)
+        (cond (< n 0)  "negative"
+              (= n 0)  "zero"
+              :else     "positive")))
+    (assert-equal "negative" (classify -5))
+    (assert-equal "zero"     (classify 0))
+    (assert-equal "positive" (classify 7)))
+
+  (deftest "tail position in cond recursive clause"
+    (define count-up
+      (fn (n limit)
+        (cond (= n limit) n
+              :else        (count-up (+ n 1) limit))))
+    (assert-equal 200 (count-up 0 200)))
+
+  (deftest "tail position in let body"
+    ;; The body expression of a let is in tail position.
+    (define h
+      (fn (n)
+        (let ((m (- n 1)))
+          (if (<= m 0)
+            m
+            (h m)))))
+    (assert-equal 0 (h 500)))
+
+  (deftest "tail position in when body"
+    ;; The last expression of a when body is in tail position.
+    (define scan
+      (fn (lst acc)
+        (when (not (empty? lst))
+          (scan (rest lst) (+ acc (first lst))))))
+    ;; scan returns nil on empty — seed with pre-evaluated sum
+    (define sum-list
+      (fn (lst)
+        (reduce (fn (a x) (+ a x)) 0 lst)))
+    (assert-equal 15 (sum-list (list 1 2 3 4 5)))))

spec/tests/test-types.sx

@@ -206,7 +206,7 @@
     (let ((expr (sx-parse "(if true 42 \"hello\")")))
       (let ((t (infer-type (first expr) (dict) (test-prim-types))))
         ;; number | string — should be a union
-        (assert-true (or (= t (list "or" "number" "string"))
+        (assert-true (or (equal? t (list "or" "number" "string"))
                          (= t "any"))))))
 
   (deftest "if with no else includes nil"
@@ -462,13 +462,13 @@
 
 (defsuite "deftype-union"
   (deftest "union resolves"
-    (let ((registry {"status" {:name "status" :params () :body ("or" "string" "number")}}))
+    (let ((registry {"status" {:name "status" :params (list) :body (list "or" "string" "number")}}))
       (let ((resolved (resolve-type "status" registry)))
         (assert-true (= (type-of resolved) "list"))
         (assert-equal "or" (first resolved)))))
 
   (deftest "subtype through named union"
-    (let ((registry {"status" {:name "status" :params () :body ("or" "string" "number")}}))
+    (let ((registry {"status" {:name "status" :params (list) :body (list "or" "string" "number")}}))
       (assert-true (subtype-resolved? "string" "status" registry))
       (assert-true (subtype-resolved? "number" "status" registry))
       (assert-false (subtype-resolved? "boolean" "status" registry)))))
@@ -497,7 +497,7 @@
       (assert-true (subtype-resolved? "card-props" "titled" registry))))
 
   (deftest "get infers field type from record"
-    (let ((registry {"card-props" {:name "card-props" :params ()
+    (let ((registry {"card-props" {:name "card-props" :params (list)
                      :body {"title" "string" "price" "number"}}})
           (type-env {"d" "card-props"})
           (expr (first (sx-parse "(get d :title)"))))
@@ -511,8 +511,8 @@
 
 (defsuite "deftype-parameterized"
   (deftest "maybe instantiation"
-    (let ((registry {"maybe" {:name "maybe" :params ("a")
-                     :body ("or" "a" "nil")}}))
+    (let ((registry {"maybe" {:name "maybe" :params (list "a")
+                     :body (list "or" "a" "nil")}}))
       (let ((resolved (resolve-type (list "maybe" "string") registry)))
         (assert-true (= (type-of resolved) "list"))
         (assert-equal "or" (first resolved))
@@ -520,14 +520,14 @@
         (assert-true (contains? resolved "nil")))))
 
   (deftest "subtype through parameterized type"
-    (let ((registry {"maybe" {:name "maybe" :params ("a")
-                     :body ("or" "a" "nil")}}))
+    (let ((registry {"maybe" {:name "maybe" :params (list "a")
+                     :body (list "or" "a" "nil")}}))
       (assert-true (subtype-resolved? "string" (list "maybe" "string") registry))
       (assert-true (subtype-resolved? "nil" (list "maybe" "string") registry))
       (assert-false (subtype-resolved? "number" (list "maybe" "string") registry))))
 
   (deftest "substitute-type-vars works"
-    (let ((result (substitute-type-vars ("or" "a" "nil") (list "a") (list "number"))))
+    (let ((result (substitute-type-vars (list "or" "a" "nil") (list "a") (list "number"))))
       (assert-equal "or" (first result))
       (assert-true (contains? result "number"))
       (assert-true (contains? result "nil")))))
@@ -625,28 +625,25 @@
 ;; check-component-effects
 ;; --------------------------------------------------------------------------
 
-;; Define test components at top level so they're in the main env
-(defcomp ~eff-pure-card () :effects []
-  (div (fetch "url")))
-
-(defcomp ~eff-io-card () :effects [io]
-  (div (fetch "url")))
-
-(defcomp ~eff-unannot-card ()
-  (div (fetch "url")))
-
 (defsuite "check-component-effects"
   (deftest "pure component calling io produces diagnostic"
-    (let ((anns {"~eff-pure-card" () "fetch" ("io")})
-          (diagnostics (check-component-effects "~eff-pure-card" (test-env) anns)))
-      (assert-true (> (len diagnostics) 0))))
+    ;; Define component in a local env so check-component-effects can find it
+    (let ((e (env-extend (test-env))))
+      (eval-expr-cek (sx-parse-one "(defcomp ~eff-pure-card () :effects [] (div (fetch \"url\")))") e)
+      (let ((anns {"~eff-pure-card" () "fetch" ("io")})
+            (diagnostics (check-component-effects "~eff-pure-card" e anns)))
+        (assert-true (> (len diagnostics) 0)))))
 
   (deftest "io component calling io produces no diagnostic"
-    (let ((anns {"~eff-io-card" ("io") "fetch" ("io")})
-          (diagnostics (check-component-effects "~eff-io-card" (test-env) anns)))
-      (assert-equal 0 (len diagnostics))))
+    (let ((e (env-extend (test-env))))
+      (eval-expr-cek (sx-parse-one "(defcomp ~eff-io-card () :effects [io] (div (fetch \"url\")))") e)
+      (let ((anns {"~eff-io-card" ("io") "fetch" ("io")})
+            (diagnostics (check-component-effects "~eff-io-card" e anns)))
+        (assert-equal 0 (len diagnostics)))))
 
   (deftest "unannotated component skips check"
-    (let ((anns {"fetch" ("io")})
-          (diagnostics (check-component-effects "~eff-unannot-card" (test-env) anns)))
-      (assert-equal 0 (len diagnostics)))))
+    (let ((e (env-extend (test-env))))
+      (eval-expr-cek (sx-parse-one "(defcomp ~eff-unannot-card () (div (fetch \"url\")))") e)
+      (let ((anns {"fetch" ("io")})
+            (diagnostics (check-component-effects "~eff-unannot-card" e anns)))
+        (assert-equal 0 (len diagnostics))))))

sx/sx/plans/isolated-evaluator.sx

@@ -0,0 +1,333 @@
+;; ---------------------------------------------------------------------------
+;; Isolated Evaluator — Shared platform layer, isolated JS, Rust WASM
+;; ---------------------------------------------------------------------------
+
+(defcomp ~plans/isolated-evaluator/plan-isolated-evaluator-content ()
+  (~docs/page :title "Isolated Evaluator"
+
+    (~docs/section :title "Context" :id "context"
+      (p "The SX spec is already split into three layers:")
+      (ul :class "list-disc list-inside space-y-1 mt-2"
+        (li (code "spec/") " \u2014 Core language (19 files): evaluator, parser, primitives, CEK, types, continuations. Host-independent.")
+        (li (code "web/") " \u2014 Web framework (20 files): signals, adapters, engine, orchestration, boot, router, deps. Built on core spec.")
+        (li (code "sx/") " \u2014 Application (sx-docs website). Built on web framework."))
+      (p "Bootstrappers search " (code "spec/ \u2192 web/ \u2192 shared/sx/ref/") " for " (code ".sx") " files. The separation is clean.")
+      (p "This plan takes the next step: " (strong "isolate the evaluator from the real world") ". The JS evaluator should run in the same sandbox as Rust/WASM \u2014 unable to touch DOM, fetch, timers, or storage directly. Both evaluators call into a shared " (code "sx-platform.js") " for all browser access.")
+      (p "This also involves sorting out the JavaScript: eliminating hand-coded JS that duplicates specced " (code ".sx") " logic, and moving web framework " (code ".sx") " from compiled-into-evaluator to runtime-evaluated."))
+
+    (~docs/section :title "Existing Architecture" :id "existing"
+      (h4 :class "font-semibold mt-4 mb-2" "Three-layer spec split (DONE)")
+      (div :class "overflow-x-auto rounded border border-stone-200 mb-4"
+        (table :class "w-full text-left text-sm"
+          (thead (tr :class "border-b border-stone-200 bg-stone-100"
+            (th :class "px-3 py-2 font-medium text-stone-600" "Layer")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Directory")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Files")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Content")))
+          (tbody
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" "Core spec")
+              (td :class "px-3 py-2 text-stone-700" (code "spec/"))
+              (td :class "px-3 py-2 text-stone-700" "19")
+              (td :class "px-3 py-2 text-stone-600" "eval, parser, primitives, render, types, CEK, continuations, boundary-core"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" "Web framework")
+              (td :class "px-3 py-2 text-stone-700" (code "web/"))
+              (td :class "px-3 py-2 text-stone-700" "20")
+              (td :class "px-3 py-2 text-stone-600" "adapters, signals, engine, orchestration, boot, router, deps, forms, boundary-web"))
+            (tr
+              (td :class "px-3 py-2 text-stone-700" "Application")
+              (td :class "px-3 py-2 text-stone-700" (code "sx/"))
+              (td :class "px-3 py-2 text-stone-700" "\u2014")
+              (td :class "px-3 py-2 text-stone-600" "sx-docs website, page components, content")))))
+
+      (h4 :class "font-semibold mt-4 mb-2" "Rust/WASM evaluator (DONE)")
+      (p (code "sx-rust/") " has a working parser + evaluator + render-to-html in WASM: 9,823 lines generated Rust, 75 real primitives, 154 stubs, 92 tests passing. Currently pure computation \u2014 no DOM interaction.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "What needs to change")
+      (p "Currently " (strong "everything") " (core + web framework) gets compiled into one monolithic " (code "sx-browser.js") ". The web framework " (code ".sx") " files (signals, engine, orchestration, boot, etc.) are baked into the evaluator output by the bootstrapper. They should instead be " (strong "evaluated at runtime") " by the core evaluator, like any other " (code ".sx") " code.")
+      (p "The JavaScript platform primitives (DOM, fetch, timers, storage) are also inlined into the bootstrapped output. They need to be extracted into a standalone " (code "sx-platform.js") " module that both JS and WASM evaluators share."))
+
+
+    ;; -----------------------------------------------------------------------
+    ;; What's core vs web (bootstrapped vs runtime)
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Bootstrapped vs Runtime-Evaluated" :id "bootstrap-vs-runtime"
+      (p "The key question: what MUST be compiled into the evaluator vs what can be loaded as " (code ".sx") " at runtime?")
+
+      (h4 :class "font-semibold mt-4 mb-2" "Must be bootstrapped (core spec)")
+      (div :class "overflow-x-auto rounded border border-stone-200 mb-4"
+        (table :class "w-full text-left text-sm"
+          (thead (tr :class "border-b border-stone-200 bg-stone-100"
+            (th :class "px-3 py-2 font-medium text-stone-600" "File")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Dir")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Why")))
+          (tbody
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "eval.sx"))
+              (td :class "px-3 py-2 text-stone-700" "spec/")
+              (td :class "px-3 py-2 text-stone-600" "IS the language \u2014 can't evaluate without it"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "parser.sx"))
+              (td :class "px-3 py-2 text-stone-700" "spec/")
+              (td :class "px-3 py-2 text-stone-600" "Can't read .sx source without a parser"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "primitives.sx"))
+              (td :class "px-3 py-2 text-stone-700" "spec/")
+              (td :class "px-3 py-2 text-stone-600" "80+ built-in pure functions \u2014 must be native"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "render.sx"))
+              (td :class "px-3 py-2 text-stone-700" "spec/")
+              (td :class "px-3 py-2 text-stone-600" "HTML_TAGS registry, parse-element-args"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "adapter-html.sx"))
+              (td :class "px-3 py-2 text-stone-700" "web/")
+              (td :class "px-3 py-2 text-stone-600" "render-to-html \u2014 co-recursive with eval-expr"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "adapter-sx.sx"))
+              (td :class "px-3 py-2 text-stone-700" "web/")
+              (td :class "px-3 py-2 text-stone-600" "aser (wire format) \u2014 co-recursive with eval-expr"))
+            (tr
+              (td :class "px-3 py-2 text-stone-700" (code "adapter-dom.sx"))
+              (td :class "px-3 py-2 text-stone-700" "web/")
+              (td :class "px-3 py-2 text-stone-600" "render-to-dom \u2014 co-recursive with eval-expr")))))
+
+      (h4 :class "font-semibold mt-4 mb-2" "Runtime-evaluated (web framework)")
+      (div :class "overflow-x-auto rounded border border-stone-200 mb-4"
+        (table :class "w-full text-left text-sm"
+          (thead (tr :class "border-b border-stone-200 bg-stone-100"
+            (th :class "px-3 py-2 font-medium text-stone-600" "File")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Dir")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Why it can be runtime")))
+          (tbody
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "signals.sx"))
+              (td :class "px-3 py-2 text-stone-700" "web/")
+              (td :class "px-3 py-2 text-stone-600" "Pure computation \u2014 dicts with markers, no new types"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "engine.sx"))
+              (td :class "px-3 py-2 text-stone-700" "web/")
+              (td :class "px-3 py-2 text-stone-600" "Pure logic \u2014 trigger parsing, swap specs, morph"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "orchestration.sx"))
+              (td :class "px-3 py-2 text-stone-700" "web/")
+              (td :class "px-3 py-2 text-stone-600" "Event binding + fetch \u2014 calls platform primitives"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "boot.sx"))
+              (td :class "px-3 py-2 text-stone-700" "web/")
+              (td :class "px-3 py-2 text-stone-600" "Page lifecycle \u2014 calls platform primitives"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "router.sx"))
+              (td :class "px-3 py-2 text-stone-700" "web/")
+              (td :class "px-3 py-2 text-stone-600" "URL pattern matching \u2014 pure computation"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "deps.sx"))
+              (td :class "px-3 py-2 text-stone-700" "web/")
+              (td :class "px-3 py-2 text-stone-600" "Component dependency analysis \u2014 pure AST walking"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "page-helpers.sx"))
+              (td :class "px-3 py-2 text-stone-700" "web/")
+              (td :class "px-3 py-2 text-stone-600" "Data transformation helpers"))
+            (tr
+              (td :class "px-3 py-2 text-stone-700" (code "forms.sx"))
+              (td :class "px-3 py-2 text-stone-700" "web/")
+              (td :class "px-3 py-2 text-stone-600" "Server-only definition forms")))))
+
+      (h4 :class "font-semibold mt-4 mb-2" "adapter-dom.sx reactive split")
+      (p (code "adapter-dom.sx") " contains reactive-aware code (" (code "reactive-text") ", " (code "reactive-attr") ", " (code "render-dom-island") ", " (code "render-dom-lake") ") interleaved with core DOM rendering. These call " (code "signal?") " and " (code "deref") " from " (code "signals.sx") " via environment lookup \u2014 no compile-time dependency. Option: split reactive DOM functions into " (code "adapter-dom-reactive.sx") " (web/ layer), keeping base " (code "adapter-dom.sx") " purely about elements/text/fragments/components.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "Hand-coded JS to clean up")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li (code "CONTINUATIONS_JS") " in " (code "platform_js.py") " \u2014 hand-coded shift/reset. Should use specced " (code "continuations.sx") " or be eliminated if continuations are application-level.")
+        (li (code "ASYNC_IO_JS") " in " (code "platform_js.py") " \u2014 hand-coded async rendering dispatch. Already replaced by " (code "adapter-async.sx") " for Python. JS version should also be bootstrapped or eliminated.")
+        (li "Various wrapper functions in " (code "PLATFORM_BOOT_JS") " that duplicate logic from " (code "boot.sx") ".")))
+
+
+    ;; -----------------------------------------------------------------------
+    ;; Phase 1: Extract sx-platform.js
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Phase 1: Extract sx-platform.js" :id "phase-1"
+      (p (strong "Goal:") " All real-world-touching JavaScript lives in one standalone module. The evaluator never directly accesses " (code "document") ", " (code "window") ", " (code "fetch") ", " (code "localStorage") ", " (code "history") ", etc.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "Architecture")
+      (~docs/code :code (highlight "                    \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n                    \u2502  sx-platform.js  \u2502  \u2190 DOM, fetch, timers, storage\n                    \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n                             \u2502\n              \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n              \u2502                             \u2502\n    \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510         \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n    \u2502  sx-evaluator.js   \u2502         \u2502 sx-wasm-shim.js \u2502\n    \u2502  (isolated JS)     \u2502         \u2502 (WASM instance  \u2502\n    \u2502                    \u2502         \u2502  + handle table) \u2502\n    \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518         \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518" "text"))
+
+      (h4 :class "font-semibold mt-4 mb-2" "What moves into sx-platform.js")
+      (p "Extracted from " (code "platform_js.py") " string constants:")
+      (div :class "overflow-x-auto rounded border border-stone-200 mb-4"
+        (table :class "w-full text-left text-sm"
+          (thead (tr :class "border-b border-stone-200 bg-stone-100"
+            (th :class "px-3 py-2 font-medium text-stone-600" "Category")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Source")
+            (th :class "px-3 py-2 font-medium text-stone-600" "~Functions")))
+          (tbody
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" "DOM primitives")
+              (td :class "px-3 py-2 text-stone-700" (code "PLATFORM_DOM_JS"))
+              (td :class "px-3 py-2 text-stone-600" "~50 (createElement, setAttribute, appendChild...)"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" "Engine platform")
+              (td :class "px-3 py-2 text-stone-700" (code "PLATFORM_ENGINE_PURE_JS"))
+              (td :class "px-3 py-2 text-stone-600" "~6 (locationHref, pushState, nowMs...)"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" "Orchestration platform")
+              (td :class "px-3 py-2 text-stone-700" (code "PLATFORM_ORCHESTRATION_JS"))
+              (td :class "px-3 py-2 text-stone-600" "~80 (fetch, abort, timers, SSE, scroll, media...)"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" "Boot platform")
+              (td :class "px-3 py-2 text-stone-700" (code "PLATFORM_BOOT_JS"))
+              (td :class "px-3 py-2 text-stone-600" "~20 (mount target, localStorage, cookies, logging...)"))
+            (tr
+              (td :class "px-3 py-2 text-stone-700" "Parser helpers")
+              (td :class "px-3 py-2 text-stone-700" (code "PLATFORM_PARSER_JS"))
+              (td :class "px-3 py-2 text-stone-600" "~4 (isIdentStart, parseNumber...)")))))
+
+      (h4 :class "font-semibold mt-4 mb-2" "Isolation rule")
+      (p "After extraction, searching " (code "sx-evaluator.js") " for " (code "document") ", " (code "window") ", " (code "fetch") ", " (code "localStorage") ", " (code "history") ", " (code "setTimeout") ", " (code "console") " should find " (strong "zero") " direct references.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "The callSxFunction bridge")
+      (p "Platform code (event listeners, timers) needs to invoke SX lambdas. The evaluator provides a single " (code "callSxFunction(fn, args) \u2192 result") " bridge to the platform at registration time. This is the ONE evaluator-to-platform callback.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "Implementation")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li "Modify " (code "platform_js.py") " to emit platform functions as a separate output section")
+        (li "Create " (code "sx-platform.js") " as an IIFE that sets " (code "globalThis.SxPlatform = {...}"))
+        (li "The evaluator IIFE reads " (code "globalThis.SxPlatform") " at init, registers each function as a PRIMITIVE")
+        (li "Clean up " (code "CONTINUATIONS_JS") " and " (code "ASYNC_IO_JS") " \u2014 eliminate or bootstrap")
+        (li "Test that existing pages work identically")))
+
+
+    ;; -----------------------------------------------------------------------
+    ;; Phase 2: Isolate the JS Evaluator
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Phase 2: Isolate the JS Evaluator" :id "phase-2"
+      (p (strong "Goal:") " " (code "sx-evaluator.js") " contains ONLY core spec + render adapters. Web framework " (code ".sx") " is evaluated at runtime.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "Core-only build")
+      (p "The bootstrapper already supports selecting which modules to compile. A core-only build:")
+      (~docs/code :code (highlight "# In run_js_sx.py \u2014 core-only build\ncompile_ref_to_js(\n    adapters=[\"parser\", \"html\", \"sx\", \"dom\"],  # core spec + adapters\n    modules=None,       # no signals, engine, orchestration, boot\n    extensions=None,    # no continuations\n    spec_modules=None   # no deps, router, cek, frames, page-helpers\n)" "python"))
+
+      (h4 :class "font-semibold mt-4 mb-2" "Web framework loading")
+      (p "Web framework " (code ".sx") " files ship as " (code "<script type=\"text/sx-lib\">") " blocks. The platform boot shim evaluates them before component scripts:")
+      (~docs/code :code (highlight "<script src=\"/static/scripts/sx-platform.js\"></script>\n<script src=\"/static/scripts/sx-evaluator.js\"></script>\n<script type=\"text/sx-lib\">\n  ;; concatenated web/ framework: signals, deps, router,\n  ;; engine, orchestration, boot\n</script>\n<script type=\"text/sx\" data-components>\n  ;; page component definitions\n</script>" "html"))
+
+      (h4 :class "font-semibold mt-4 mb-2" "Boot chicken-and-egg")
+      (p (code "boot.sx") " orchestrates the boot sequence but is itself web framework code. Solution: thin native boot shim (~30 lines) in " (code "sx-platform.js") ":")
+      (~docs/code :code (highlight "SxPlatform.boot = function(evaluator) {\n  // 1. Evaluate web framework .sx libraries\n  var libs = document.querySelectorAll('script[type=\"text/sx-lib\"]');\n  for (var i = 0; i < libs.length; i++) {\n    evaluator.evalSource(libs[i].textContent);\n  }\n  // 2. Call boot-init (defined in boot.sx)\n  evaluator.callFunction('boot-init');\n};" "javascript"))
+
+      (h4 :class "font-semibold mt-4 mb-2" "Performance")
+      (p "Parsing + evaluating ~5,000 lines of web framework " (code ".sx") " at startup takes ~10\u201350ms. After " (code "define") ", functions are Lambda objects dispatched identically to compiled functions. " (strong "Zero ongoing performance difference.")))
+
+
+    ;; -----------------------------------------------------------------------
+    ;; Phase 3: Wire Up Rust/WASM
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Phase 3: Wire Up Rust/WASM" :id "phase-3"
+      (p (strong "Goal:") " Rust evaluator calls " (code "sx-platform.js") " via wasm-bindgen imports. Handle table bridges DOM references.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "Handle table (JS-side)")
+      (~docs/code :code (highlight "// In sx-wasm-shim.js\nconst handles = [null];  // index 0 = null handle\nfunction allocHandle(obj) { handles.push(obj); return handles.length - 1; }\nfunction getHandle(id) { return handles[id]; }\nfunction freeHandle(id) { handles[id] = null; }" "javascript"))
+      (p "DOM nodes are JS objects. The handle table maps " (code "u32") " IDs to JS objects. Rust stores " (code "Value::Handle(u32)") " and passes the " (code "u32") " to imported JS functions.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "Value::Handle in Rust")
+      (~docs/code :code (highlight "// In platform.rs\npub enum Value {\n    // ... existing variants ...\n    Handle(u32),  // opaque reference to JS-side object\n}" "rust"))
+
+      (h4 :class "font-semibold mt-4 mb-2" "WASM imports from platform")
+      (~docs/code :code (highlight "#[wasm_bindgen(module = \"/sx-platform-wasm.js\")]\nextern \"C\" {\n    fn platform_create_element(tag: &str) -> u32;\n    fn platform_create_text_node(text: &str) -> u32;\n    fn platform_set_attr(handle: u32, name: &str, value: &str);\n    fn platform_append_child(parent: u32, child: u32);\n    fn platform_add_event_listener(handle: u32, event: &str, callback_id: u32);\n    // ... ~50 DOM primitives\n}" "rust"))
+
+      (h4 :class "font-semibold mt-4 mb-2" "Callback table for events")
+      (p "When Rust creates an event handler (a Lambda), it stores it in a callback table and gets a " (code "u32") " ID. JS " (code "addEventListener") " wraps it: when the event fires, JS calls into WASM with the callback ID. Rust looks up the Lambda and evaluates it.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "sx-wasm-shim.js")
+      (p "Thin glue (~100 lines):")
+      (ul :class "list-disc list-inside space-y-1 mt-2"
+        (li "Instantiate WASM module")
+        (li "Wire handle table")
+        (li "Delegate all platform calls to " (code "sx-platform.js"))
+        (li "Provide " (code "invoke_callback") " \u2192 Rust for event dispatch")))
+
+
+    ;; -----------------------------------------------------------------------
+    ;; Phase 4: Web Framework Loading
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Phase 4: Web Framework Loading" :id "phase-4"
+      (p (strong "Goal:") " Both JS and WASM evaluators load the same web framework " (code ".sx") " files at runtime.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "Boot sequence (identical for both evaluators)")
+      (ol :class "list-decimal list-inside space-y-2 mt-2"
+        (li "Load " (code "sx-platform.js") " + evaluator (" (code "sx-evaluator.js") " or " (code "sx-wasm-shim.js") ")")
+        (li "Platform registers primitives with evaluator")
+        (li "Platform boot shim evaluates " (code "<script type=\"text/sx-lib\">") " blocks")
+        (li "Dependency order: signals \u2192 deps \u2192 frames \u2192 router \u2192 page-helpers \u2192 engine \u2192 orchestration \u2192 boot")
+        (li (code "boot-init") " called \u2014 processes component scripts, hydrates, initializes engine")
+        (li "Page is interactive"))
+
+      (h4 :class "font-semibold mt-4 mb-2" "Library dependency order")
+      (~docs/code :code (highlight "signals.sx          \u2190 no SX deps (uses only core primitives)\ndeps.sx             \u2190 no SX deps\nframes.sx           \u2190 no SX deps\nrouter.sx           \u2190 no SX deps\npage-helpers.sx     \u2190 no SX deps\nengine.sx           \u2190 uses render.sx (core), adapter-dom.sx (core)\norchestration.sx    \u2190 depends on engine.sx\nboot.sx             \u2190 depends on orchestration.sx" "text")))
+
+
+    ;; -----------------------------------------------------------------------
+    ;; Phase 5: Verification + Rollout
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Phase 5: Verification + Rollout" :id "phase-5"
+      (h4 :class "font-semibold mt-4 mb-2" "Shadow comparison")
+      (p "Run both JS and WASM evaluators on same input, compare outputs:")
+      (ol :class "list-decimal list-inside space-y-1 mt-2"
+        (li (strong "Parse") " \u2014 same AST (already testable with current WASM exports)")
+        (li (strong "Eval") " \u2014 same values (already testable)")
+        (li (strong "Render") " \u2014 same DOM structure (requires Phase 3)"))
+
+      (h4 :class "font-semibold mt-4 mb-2" "Feature flag")
+      (p "Server sets " (code "data-sx-runtime=\"wasm\"") " or " (code "\"js\"") " on root element. Boot shim loads appropriate evaluator. Progressive enhancement: try WASM, fall back to JS.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "Test matrix")
+      (p "All " (code "test-*.sx") " files from both " (code "spec/") " and " (code "web/") " run on BOTH evaluators."))
+
+
+    ;; -----------------------------------------------------------------------
+    ;; Principles
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Principles" :id "principles"
+      (ul :class "list-disc list-inside space-y-2"
+        (li (strong "Core is what defines the language.") " Parser, evaluator, primitives, render modes. If you can't run SX without it, it's core (" (code "spec/") "). If you can write it " (em "in") " SX, it's web framework (" (code "web/") ").")
+        (li (strong "Web framework runs ON the evaluator.") " Signals, engine, orchestration, boot, router, deps \u2014 these are SX programs. They're evaluated at runtime, not compiled into the evaluator.")
+        (li (strong "Isolation is the boundary.") " The evaluator can't touch the real world. Platform primitives are the only bridge. JS and WASM evaluators have identical isolation.")
+        (li (strong "Shared platform, not duplicated.") " One implementation of every browser primitive in " (code "sx-platform.js") ". Both evaluators use it. Fix a bug once, both get the fix.")
+        (li (strong "Handle table is the WASM boundary.") " Rust holds " (code "u32") " IDs. JavaScript holds real objects. Swap the handle table for a different host and the Rust code doesn't change.")
+        (li (strong "Progressive, not all-or-nothing.") " WASM is an enhancement. JS remains the fallback. Feature-flagged per page. Gradual and reversible.")))
+
+
+    ;; -----------------------------------------------------------------------
+    ;; Interactions
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Interaction with Other Plans" :id "interactions"
+      (ul :class "list-disc list-inside space-y-2"
+        (li (strong (a :href "/sx/(etc.(plan.rust-wasm-host))" "Rust/WASM Host")) " \u2014 this plan supersedes it. That plan didn't distinguish core from web framework or propose evaluator isolation. The shared platform layer is the key architectural difference.")
+        (li (strong (a :href "/sx/(etc.(plan.wasm-bytecode-vm))" "WASM Bytecode VM")) " \u2014 complementary. This plan bootstraps the tree-walking evaluator. A future bytecode VM compiles SX to bytecodes. The platform layer and handle table are shared.")
+        (li (strong (a :href "/sx/(etc.(plan.runtime-slicing))" "Runtime Slicing")) " \u2014 simplified. With web framework as runtime-evaluated " (code ".sx") ", slicing becomes: ship core + only the framework files you need. L0 pages skip signals/engine entirely.")
+        (li (strong (a :href "/sx/(etc.(plan.reactive-runtime))" "Reactive Runtime")) " \u2014 signals are web framework code, confirming they layer on top of core without special treatment.")
+        (li (strong (a :href "/sx/(etc.(plan.foundations))" "Foundations")) " \u2014 the core/web split is the same principle: small kernel, everything else built on top.")))
+
+
+    ;; -----------------------------------------------------------------------
+    ;; Outcome
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Outcome" :id "outcome"
+      (p "After completion:")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li "Core evaluator is ~3,200 lines of bootstrapped spec (" (code "spec/") " + adapters from " (code "web/") ").")
+        (li "JS evaluator is isolated \u2014 can't touch the real world, same sandbox as WASM.")
+        (li "Shared " (code "sx-platform.js") " provides all browser primitives to both evaluators.")
+        (li "Rust/WASM evaluator runs in the browser with full DOM rendering via handle table.")
+        (li "Web framework " (code ".sx") " files (signals, engine, orchestration, boot) are runtime-evaluated by whichever evaluator is active.")
+        (li "Hand-coded JS (" (code "CONTINUATIONS_JS") ", " (code "ASYNC_IO_JS") ") eliminated or bootstrapped from spec.")
+        (li "The architecture proof is complete: one spec, isolated evaluator, shared platform, deployment-time target selection.")))))

sx/sx/plans/rust-wasm-host.sx

@@ -0,0 +1,263 @@
+;; ---------------------------------------------------------------------------
+;; Rust/WASM Host — Bootstrap the SX spec to Rust, compile to WASM
+;; ---------------------------------------------------------------------------
+
+(defcomp ~plans/rust-wasm-host/plan-rust-wasm-host-content ()
+  (~docs/page :title "Rust/WASM Host"
+
+    (~docs/section :title "Context" :id "context"
+      (p "The SX host architecture says: spec it in " (code ".sx") ", bootstrap to every target. We've now done it for Rust.")
+      (p "The Rust bootstrapper (" (code "bootstrap_rs.py") ") reads all 20 " (code ".sx") " spec files and emits a complete Rust crate — " (strong "9,781 lines") " of Rust that compiles with zero errors. The test suite has " (strong "92 tests passing") " across parser, evaluator, primitives, and rendering.")
+      (p "This is distinct from the " (a :href "/sx/(etc.(plan.wasm-bytecode-vm))" "WASM Bytecode VM") " plan. That plan designs a custom bytecode format and VM. This plan bootstraps the " (strong "same tree-walking evaluator") " directly to Rust/WASM from the same " (code ".sx") " specs — no new bytecode, no new VM, just another host.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "What exists today")
+      (div :class "overflow-x-auto rounded border border-stone-200 mb-4"
+        (table :class "w-full text-left text-sm"
+          (thead (tr :class "border-b border-stone-200 bg-stone-100"
+            (th :class "px-3 py-2 font-medium text-stone-600" "Artifact")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Lines")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Status")))
+          (tbody
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "bootstrap_rs.py"))
+              (td :class "px-3 py-2 text-stone-700" "—")
+              (td :class "px-3 py-2 text-stone-600" "Rust bootstrapper, reads all 20 .sx spec files"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "sx_ref.rs"))
+              (td :class "px-3 py-2 text-stone-700" "9,781")
+              (td :class "px-3 py-2 text-stone-600" "Generated Rust — compiles clean, 0 errors"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "platform.rs"))
+              (td :class "px-3 py-2 text-stone-700" "—")
+              (td :class "px-3 py-2 text-stone-600" "Rust platform interface (type constructors, env ops)"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" (code "test_parser.rs"))
+              (td :class "px-3 py-2 text-stone-700" "—")
+              (td :class "px-3 py-2 text-stone-600" "92 tests passing (parser, eval, primitives, render)"))
+            (tr
+              (td :class "px-3 py-2 text-stone-700" "Primitives")
+              (td :class "px-3 py-2 text-stone-700" "—")
+              (td :class "px-3 py-2 text-stone-600" "75 real implementations, 154 stubs"))))))
+
+    ;; -----------------------------------------------------------------------
+    ;; Architecture
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Architecture" :id "architecture"
+      (p "The key architectural insight: " (strong "factor the browser primitives into a shared platform layer") " that both the JS evaluator and the WASM module consume.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "Shared platform layer")
+      (p (code "platform_js.py") " already contains all DOM, browser, fetch, timer, and storage implementations — bootstrapped from " (code "boundary.sx") ". These are pure JavaScript functions that call browser APIs. They don't depend on the evaluator.")
+      (p "Extract them into a standalone " (code "sx-platform.js") " module. Both " (code "sx-browser.js") " (the current JS evaluator) and the new " (code "sx-wasm-shim.js") " import from the same platform module:")
+      (~docs/code :code (highlight "                    ┌─────────────────┐\n                    │  sx-platform.js  │  ← DOM, fetch, timers, storage\n                    └────────┬────────┘\n                             │\n              ┌──────────────┼──────────────┐\n              │                             │\n    ┌─────────┴─────────┐         ┌────────┴────────┐\n    │  sx-browser.js     │         │ sx-wasm-shim.js │\n    │  (JS tree-walker)  │         │ (WASM instance  │\n    │                    │         │  + handle table) │\n    └────────────────────┘         └─────────────────┘" "text"))
+      (p "One codebase for all browser primitives. Bug fixes apply to both targets. The evaluator is the only thing that changes — JS tree-walker vs Rust/WASM tree-walker.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "Opaque handle table")
+      (p "Rust/WASM can't hold DOM node references directly. Instead, Rust values use " (code "Value::Handle(u32)") " — an opaque integer that indexes into a JavaScript-side handle table:")
+      (~docs/code :code (highlight "// JS side (in sx-wasm-shim.js)\nconst handles = [];  // handle_id → DOM node\n\nfunction allocHandle(node) {\n  const id = handles.length;\n  handles.push(node);\n  return id;\n}\n\nfunction getHandle(id) { return handles[id]; }\nfunction freeHandle(id) { handles[id] = null; }" "javascript"))
+      (~docs/code :code (highlight "// Rust side\n#[derive(Clone, Debug)]\nenum Value {\n    Nil,\n    Bool(bool),\n    Number(f64),\n    Str(String),\n    Symbol(String),\n    Keyword(String),\n    List(Vec<Value>),\n    Dict(Vec<(Value, Value)>),\n    Lambda(Rc<Closure>),\n    Handle(u32),  // ← opaque DOM node reference\n}" "rust"))
+      (p "When Rust calls a DOM primitive (e.g. " (code "createElement") "), it gets back a " (code "Handle(id)") ". When it passes that handle to " (code "appendChild") ", the JS shim looks up the real node. Rust never sees a DOM node — only integer IDs.")
+
+      (h4 :class "font-semibold mt-4 mb-2" "The JS shim is thin")
+      (p "The WASM shim's job is minimal:")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li "Instantiate the WASM module")
+        (li "Wire up the handle table")
+        (li "Delegate all browser primitives to " (code "sx-platform.js"))
+        (li "Provide " (code "#[wasm_bindgen]") " imports for the DOM primitives that Rust calls"))
+      (p "Everything complex — event dispatch, morph engine, routing, SSE — lives in the shared platform layer. The shim is glue."))
+
+    ;; -----------------------------------------------------------------------
+    ;; Stubs breakdown
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Current Stub Breakdown" :id "stubs"
+      (p "Of the 154 stubbed primitives, most fall into a few categories that map directly to implementation phases:")
+      (div :class "overflow-x-auto rounded border border-stone-200 mb-4"
+        (table :class "w-full text-left text-sm"
+          (thead (tr :class "border-b border-stone-200 bg-stone-100"
+            (th :class "px-3 py-2 font-medium text-stone-600" "Category")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Count")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Examples")
+            (th :class "px-3 py-2 font-medium text-stone-600" "Phase")))
+          (tbody
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" "DOM creation & attrs")
+              (td :class "px-3 py-2 text-stone-700" "~30")
+              (td :class "px-3 py-2 text-stone-600" "createElement, setAttribute, appendChild")
+              (td :class "px-3 py-2 text-stone-600" "Phase 2"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" "Events & callbacks")
+              (td :class "px-3 py-2 text-stone-700" "~20")
+              (td :class "px-3 py-2 text-stone-600" "addEventListener, setTimeout, requestAnimationFrame")
+              (td :class "px-3 py-2 text-stone-600" "Phase 3"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" "Fetch & network")
+              (td :class "px-3 py-2 text-stone-700" "~15")
+              (td :class "px-3 py-2 text-stone-600" "fetch, XMLHttpRequest, SSE")
+              (td :class "px-3 py-2 text-stone-600" "Phase 3"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" "Browser APIs")
+              (td :class "px-3 py-2 text-stone-700" "~25")
+              (td :class "px-3 py-2 text-stone-600" "history, location, localStorage, console")
+              (td :class "px-3 py-2 text-stone-600" "Phase 5"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" "Morph engine")
+              (td :class "px-3 py-2 text-stone-700" "~15")
+              (td :class "px-3 py-2 text-stone-600" "morph, sync-attrs, reconcile")
+              (td :class "px-3 py-2 text-stone-600" "Phase 3"))
+            (tr :class "border-b border-stone-100"
+              (td :class "px-3 py-2 text-stone-700" "Signals & reactivity")
+              (td :class "px-3 py-2 text-stone-700" "~20")
+              (td :class "px-3 py-2 text-stone-600" "signal, deref, effect, computed, batch")
+              (td :class "px-3 py-2 text-stone-600" "Phase 6"))
+            (tr
+              (td :class "px-3 py-2 text-stone-700" "Component lifecycle")
+              (td :class "px-3 py-2 text-stone-700" "~29")
+              (td :class "px-3 py-2 text-stone-600" "boot, hydrate, register-component")
+              (td :class "px-3 py-2 text-stone-600" "Phase 4"))))))
+
+    ;; -----------------------------------------------------------------------
+    ;; Phase 1: WASM build + parse/eval
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Phase 1: WASM Build + Parse/Eval" :id "phase-1"
+      (p "Get the existing Rust code compiling to WASM and running parse/eval in the browser.")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li "Add " (code "wasm-bindgen") " and " (code "wasm-pack") " to the Rust crate")
+        (li "Export " (code "#[wasm_bindgen]") " functions: " (code "parse(src) -> JsValue") " and " (code "eval(src) -> JsValue"))
+        (li "All 75 real primitives work — arithmetic, string ops, list ops, dict ops, comparisons")
+        (li "Test page: load WASM module, parse SX source, eval expressions, display results")
+        (li "Benchmark: parse/eval speed vs JS evaluator on the same expressions"))
+      (p (strong "Milestone:") " SX expressions evaluate identically in JS and WASM. No DOM, no rendering — just computation."))
+
+    ;; -----------------------------------------------------------------------
+    ;; Phase 2: DOM rendering via handle table
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Phase 2: DOM Rendering via Handle Table" :id "phase-2"
+      (p "Implement the shared platform layer and handle table. Rust can create and manipulate DOM nodes.")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li "Extract " (code "sx-platform.js") " from " (code "platform_js.py") " output — all DOM primitives as standalone functions")
+        (li "Implement " (code "sx-wasm-shim.js") " — WASM instantiation + handle table + platform imports")
+        (li "Wire " (code "Value::Handle(u32)") " through the Rust evaluator for DOM node references")
+        (li "Implement ~30 DOM stubs: " (code "createElement") ", " (code "setAttribute") ", " (code "appendChild") ", " (code "createTextNode") ", " (code "removeChild"))
+        (li (code "render-to-dom") " works through WASM — evaluates component tree, produces real DOM nodes via handle table"))
+      (p (strong "Milestone:") " A component renders to identical DOM whether evaluated by JS or WASM."))
+
+    ;; -----------------------------------------------------------------------
+    ;; Phase 3: Events + fetch + morph
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Phase 3: Events + Fetch + Morph" :id "phase-3"
+      (p "The hardest phase — callbacks cross the WASM/JS boundary. Event handlers are Rust closures that JS must be able to invoke.")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li (strong "Callback table") " — mirror of the handle table but for functions. Rust registers a closure, gets back an ID. JS calls the ID when the event fires. Rust looks up and invokes the closure.")
+        (li (strong "Event listeners") " — " (code "addEventListener") " stores the callback ID on the element handle. JS dispatches events to the WASM callback table.")
+        (li (strong "Fetch") " — Rust initiates fetch via JS import, JS calls " (code "sx-platform.js") " " (code "fetch") ", returns result to Rust via callback.")
+        (li (strong "Morph engine") " — DOM diffing/patching runs in Rust. Morph calls produce a sequence of DOM mutations via handle operations. " (code "sync-attrs") " and " (code "morph-children") " work through the handle table."))
+      (p (strong "Milestone:") " Interactive pages work — click handlers, form submissions, HTMX-style requests, morph updates. This is the " (strong "MVP") " — a page could ship with the WASM evaluator and function correctly."))
+
+    ;; -----------------------------------------------------------------------
+    ;; Phase 4: Boot + hydration + components
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Phase 4: Boot + Hydration + Components" :id "phase-4"
+      (p "Full page lifecycle — the WASM module replaces " (code "sx-browser.js") " for a complete page.")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li (strong "Boot sequence") " — WASM module loads, reads " (code "data-components") " script tags, registers component definitions, processes " (code "data-sx-page") " content")
+        (li (strong "Component registration") " — " (code "defcomp") " and " (code "defisland") " evaluated in Rust, stored in the WASM-side environment")
+        (li (strong "Hydration") " — server-rendered HTML matched against component tree, event handlers attached, islands activated")
+        (li (strong "CSSX") " — style computation runs in Rust (all CSSX primitives are already in the 75 real implementations)"))
+      (p (strong "Milestone:") " A full SX page boots and hydrates under WASM. Component definitions, CSSX styles, page content all evaluated by Rust."))
+
+    ;; -----------------------------------------------------------------------
+    ;; Phase 5: Routing + streaming + SSE
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Phase 5: Routing + Streaming + SSE" :id "phase-5"
+      (p "Client-side navigation and real-time updates.")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li (strong "Client routing") " — " (code "navigate-to") ", " (code "popstate") " handling, URL matching from " (code "defpage") " routes")
+        (li (strong "History API") " — " (code "pushState") " / " (code "replaceState") " via JS imports")
+        (li (strong "SSE") " — server-sent events for live updates, morph on incoming HTML/SX")
+        (li (strong "Streaming responses") " — progressive rendering of large page content"))
+      (p (strong "Milestone:") " Full SPA navigation works under WASM. Pages load, navigate, and receive live updates."))
+
+    ;; -----------------------------------------------------------------------
+    ;; Phase 6: Signals + reactive islands
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Phase 6: Signals + Reactive Islands" :id "phase-6"
+      (p "The most architecturally interesting phase — closures-as-values must work across the WASM boundary.")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li (strong "Signal primitives") " — " (code "signal") ", " (code "deref") ", " (code "reset!") ", " (code "swap!") ", " (code "computed") ", " (code "effect") ", " (code "batch") " all implemented in Rust")
+        (li (strong "Reactive DOM updates") " — signal changes trigger DOM mutations via handle table operations. No full re-render — fine-grained updates.")
+        (li (strong "Island scoping") " — " (code "with-island-scope") " manages signal lifecycle. Dispose island = drop all signals, effects, and handles.")
+        (li (strong "Computed chains") " — dependency graph tracks which signals feed which computed values. Topological update order."))
+      (p "The closure challenge: " (code "effect") " and " (code "computed") " take closures that capture reactive context. In Rust, these are " (code "Rc<dyn Fn(...)>") " values that the signal graph holds. The " (code "with-island-scope") " arena pattern handles cleanup — drop the arena, drop all closures.")
+      (p (strong "Milestone:") " Reactive islands work under WASM. Signals, computed values, effects, fine-grained DOM updates — all in Rust."))
+
+    ;; -----------------------------------------------------------------------
+    ;; Phase 7: Full parity + gradual rollout
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Phase 7: Full Parity + Gradual Rollout" :id "phase-7"
+      (p "Shadow-compare and feature-flagged rollout.")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li (strong "Shadow compare") " — run both JS and WASM evaluators in parallel on every page render. Assert identical DOM output. Log divergences. Same principle as async eval convergence.")
+        (li (strong "Feature flag") " — server sets " (code "data-sx-runtime=\"wasm\"") " or " (code "\"js\"") " on the page. Boot script loads the corresponding evaluator. Flag can be per-page, per-user, or global.")
+        (li (strong "Progressive enhancement") " — try WASM first, fall back to JS if WASM instantiation fails. Ship both " (code "sx-browser.js") " and " (code "sx-wasm.wasm") ".")
+        (li (strong "Gradual rollout") " — start with simple pages (documentation, static content). Move to interactive pages. Finally, reactive islands. Each phase validates correctness before advancing."))
+      (p (strong "Milestone:") " Full parity. Any SX page renders identically under JS or WASM. The runtime is a deployment choice, not an architectural one."))
+
+    ;; -----------------------------------------------------------------------
+    ;; Shared platform layer
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Shared Platform Layer" :id "shared-platform"
+      (p "The architectural heart of this plan. " (code "platform_js.py") " already generates all browser primitive implementations — DOM manipulation, fetch wrappers, timer management, storage access, history API, SSE handling. Currently these are inlined into " (code "sx-browser.js") ".")
+      (p "The extraction:")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li (strong "Step 1") " — refactor " (code "platform_js.py") " to emit a standalone " (code "sx-platform.js") " module (ES module exports)")
+        (li (strong "Step 2") " — " (code "sx-browser.js") " imports from " (code "sx-platform.js") " instead of containing the implementations inline")
+        (li (strong "Step 3") " — " (code "sx-wasm-shim.js") " imports from the same " (code "sx-platform.js") " and wires the functions as WASM imports"))
+      (p "Result: one implementation of every browser primitive, shared by both evaluator targets. Fix a bug in " (code "sx-platform.js") " and both JS and WASM evaluators get the fix.")
+      (~docs/code :code (highlight "// sx-platform.js (extracted from platform_js.py output)\nexport function createElement(tag) {\n  return document.createElement(tag);\n}\nexport function setAttribute(el, key, val) {\n  el.setAttribute(key, val);\n}\nexport function appendChild(parent, child) {\n  parent.appendChild(child);\n}\nexport function addEventListener(el, event, callback) {\n  el.addEventListener(event, callback);\n}\n// ... ~150 more browser primitives\n\n// sx-browser.js\nimport * as platform from './sx-platform.js';\n// Uses platform functions directly — evaluator is JS\n\n// sx-wasm-shim.js\nimport * as platform from './sx-platform.js';\n// Wraps platform functions for WASM import — evaluator is Rust" "javascript")))
+
+    ;; -----------------------------------------------------------------------
+    ;; Interaction with other plans
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Interaction with Other Plans" :id "interactions"
+      (ul :class "list-disc list-inside space-y-2"
+        (li (strong "WASM Bytecode VM") " — complementary, not competing. This plan bootstraps the tree-walking evaluator to Rust/WASM. The bytecode VM plan compiles SX to a custom bytecode format and runs it in a dispatch loop. Tree-walking comes first (it's working now). Bytecode VM is a future optimisation on top of the Rust host.")
+        (li (strong "Runtime Slicing") " — the WASM module can be tiered. L0 pages need no WASM at all. L1 pages need a minimal WASM module (just parse + eval, no DOM). L2+ pages need the full module with DOM and signals. Tree-shake unused primitives per tier.")
+        (li (strong "Content-Addressed Components") " — deterministic Rust compilation means the same " (code ".sx") " source always produces the same WASM binary. CID-addressable WASM modules. Fetch the evaluator itself by content hash.")
+        (li (strong "Async Eval Convergence") " — must complete first. The spec must be the single source of truth before we add another compilation target. The Rust bootstrapper reads the same spec files that the Python and JS bootstrappers read.")))
+
+    ;; -----------------------------------------------------------------------
+    ;; Principles
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Principles" :id "principles"
+      (ul :class "list-disc list-inside space-y-2"
+        (li (strong "Same spec, another host.") " The Rust target is not special — it's the same architecture as Python and JavaScript. " (code "bootstrap_rs.py") " reads the same " (code ".sx") " files and emits Rust instead of Python or JS. The spec doesn't know which host runs it.")
+        (li (strong "Platform primitives stay in JavaScript.") " DOM, fetch, timers, storage — these are browser APIs. Rust doesn't reimplement them. It calls them through the shared platform layer via the handle table.")
+        (li (strong "Shared platform, not duplicated platform.") " The key win over a pure-WASM approach. Browser primitives exist once in " (code "sx-platform.js") ". Both evaluators use them. No divergence, no duplicate bugs.")
+        (li (strong "Progressive, not all-or-nothing.") " WASM is an enhancement. JS remains the fallback. Pages can opt in per-page. The server decides which runtime to ship. Rollout is gradual and reversible.")
+        (li (strong "Handle table is the boundary.") " Rust holds integer IDs. JavaScript holds real objects. The handle table is the only bridge. This keeps the WASM module platform-independent — swap the handle table implementation for a different host (Node, Deno, native webview) and the Rust code doesn't change.")))
+
+    ;; -----------------------------------------------------------------------
+    ;; Outcome
+    ;; -----------------------------------------------------------------------
+
+    (~docs/section :title "Outcome" :id "outcome"
+      (p "After completion:")
+      (ul :class "list-disc list-inside space-y-2 mt-2"
+        (li "SX bootstraps to four hosts: JavaScript, Python, Rust (native), Rust (WASM)")
+        (li "Browser evaluation runs at near-native speed via WASM tree-walking")
+        (li "All browser primitives shared between JS and WASM evaluators — zero duplication")
+        (li "Gradual rollout: feature flag per-page, shadow-compare for correctness, progressive enhancement for compatibility")
+        (li "The architecture proof is complete: one spec, every host, deployment-time target selection")
+        (li "Future bytecode VM plan builds on the Rust host — the platform layer and handle table are already in place")))))

web/adapter-async.sx

@@ -229,7 +229,7 @@
       ;; Build env: closure + caller env + params
       (let ((local (env-merge (component-closure comp) env)))
         (for-each
-          (fn (p) (env-set! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
+          (fn (p) (env-bind! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
           (component-params comp))
         ;; Pre-render children to raw HTML
         (when (component-has-children? comp)
@@ -237,7 +237,7 @@
             (for-each
               (fn (c) (append! parts (async-render c env ctx)))
               children)
-            (env-set! local "children"
+            (env-bind! local "children"
               (make-raw-html (join "" parts)))))
         (async-render (component-body comp) local ctx)))))
 
@@ -254,7 +254,7 @@
       (let ((local (env-merge (component-closure island) env))
             (island-name (component-name island)))
         (for-each
-          (fn (p) (env-set! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
+          (fn (p) (env-bind! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
           (component-params island))
         ;; Pre-render children
         (when (component-has-children? island)
@@ -262,7 +262,7 @@
             (for-each
               (fn (c) (append! parts (async-render c env ctx)))
               children)
-            (env-set! local "children"
+            (env-bind! local "children"
               (make-raw-html (join "" parts)))))
         (let ((body-html (async-render (component-body island) local ctx))
               (state-json (serialize-island-state kwargs)))
@@ -283,7 +283,7 @@
   (fn ((f :as lambda) (args :as list) (env :as dict) ctx)
     (let ((local (env-merge (lambda-closure f) env)))
       (for-each-indexed
-        (fn (i p) (env-set! local p (nth args i)))
+        (fn (i p) (env-bind! local p (nth args i)))
         (lambda-params f))
       (async-render (lambda-body f) local ctx))))
 
@@ -517,7 +517,7 @@
                 (let ((name (if (= (type-of (first pair)) "symbol")
                               (symbol-name (first pair))
                               (str (first pair)))))
-                  (env-set! local name (async-eval (nth pair 1) local ctx)))))
+                  (env-bind! local name (async-eval (nth pair 1) local ctx)))))
             bindings)
           ;; Clojure-style: (name val name val ...)
           (async-process-bindings-flat bindings local ctx)))
@@ -538,7 +538,7 @@
                             (symbol-name item)
                             (str item))))
                 (when (< (inc i) (len bindings))
-                  (env-set! local name
+                  (env-bind! local name
                     (async-eval (nth bindings (inc i)) local ctx))))
               (set! skip true)
               (set! i (inc i)))))
@@ -735,7 +735,7 @@
         (lambda? f)
           (let ((local (env-merge (lambda-closure f) env)))
             (for-each-indexed
-              (fn (i p) (env-set! local p (nth evaled-args i)))
+              (fn (i p) (env-bind! local p (nth evaled-args i)))
               (lambda-params f))
             (async-aser (lambda-body f) local ctx))
         (component? f)
@@ -807,7 +807,7 @@
       (async-parse-aser-kw-args args kwargs children env ctx)
       (let ((local (env-merge (component-closure comp) env)))
         (for-each
-          (fn (p) (env-set! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
+          (fn (p) (env-bind! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
           (component-params comp))
         (when (component-has-children? comp)
           (let ((child-parts (list)))
@@ -823,7 +823,7 @@
                     (when (not (nil? result))
                       (append! child-parts (serialize result))))))
               children)
-            (env-set! local "children"
+            (env-bind! local "children"
               (make-sx-expr (str "(<> " (join " " child-parts) ")")))))
         (async-aser (component-body comp) local ctx)))))
 
@@ -1033,7 +1033,7 @@
         ;; set!
         (= name "set!")
           (let ((value (async-eval (nth args 1) env ctx)))
-            (env-set! env (symbol-name (first args)) value)
+            (env-bind! env (symbol-name (first args)) value)
             value)
 
         ;; map
@@ -1197,7 +1197,7 @@
       (lambda? f)
         (let ((local (env-merge (lambda-closure f) env)))
           (for-each-indexed
-            (fn (i p) (env-set! local p (nth args i)))
+            (fn (i p) (env-bind! local p (nth args i)))
             (lambda-params f))
           (async-eval (lambda-body f) local ctx))
       :else
@@ -1217,7 +1217,7 @@
         (fn (item)
           (if (lambda? f)
             (let ((local (env-merge (lambda-closure f) env)))
-              (env-set! local (first (lambda-params f)) item)
+              (env-bind! local (first (lambda-params f)) item)
               (append! results (async-aser (lambda-body f) local ctx)))
             (append! results (async-invoke f item))))
         coll)
@@ -1234,8 +1234,8 @@
         (fn (item)
           (if (lambda? f)
             (let ((local (env-merge (lambda-closure f) env)))
-              (env-set! local (first (lambda-params f)) i)
-              (env-set! local (nth (lambda-params f) 1) item)
+              (env-bind! local (first (lambda-params f)) i)
+              (env-bind! local (nth (lambda-params f) 1) item)
               (append! results (async-aser (lambda-body f) local ctx)))
             (append! results (async-invoke f i item)))
           (set! i (inc i)))
@@ -1252,7 +1252,7 @@
         (fn (item)
           (if (lambda? f)
             (let ((local (env-merge (lambda-closure f) env)))
-              (env-set! local (first (lambda-params f)) item)
+              (env-bind! local (first (lambda-params f)) item)
               (append! results (async-aser (lambda-body f) local ctx)))
             (append! results (async-invoke f item))))
         coll)

web/adapter-dom.sx

@@ -307,7 +307,7 @@
         ;; Bind params from kwargs
         (for-each
           (fn (p)
-            (env-set! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
+            (env-bind! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
           (component-params comp))
 
         ;; If component accepts children, pre-render them to a fragment
@@ -320,7 +320,7 @@
                   (when (not (spread? result))
                     (dom-append child-frag result))))
               children)
-            (env-set! local "children" child-frag)))
+            (env-bind! local "children" child-frag)))
 
         (render-to-dom (component-body comp) local ns)))))
 
@@ -687,7 +687,7 @@
     (let ((local (env-merge (lambda-closure f) env)))
       (for-each-indexed
         (fn (i p)
-          (env-set! local p (nth args i)))
+          (env-bind! local p (nth args i)))
         (lambda-params f))
       (render-to-dom (lambda-body f) local ns))))
 
@@ -734,7 +734,7 @@
         ;; Bind params from kwargs
         (for-each
           (fn (p)
-            (env-set! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
+            (env-bind! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
           (component-params island))
 
         ;; If island accepts children, pre-render them to a fragment
@@ -743,7 +743,7 @@
             (for-each
               (fn (c) (dom-append child-frag (render-to-dom c env ns)))
               children)
-            (env-set! local "children" child-frag)))
+            (env-bind! local "children" child-frag)))
 
         ;; Create the island container element
         (let ((container (dom-create-element "span" nil))

web/adapter-html.sx

@@ -277,7 +277,7 @@
     (let ((local (env-merge (lambda-closure f) env)))
       (for-each-indexed
         (fn (i p)
-          (env-set! local p (nth args i)))
+          (env-bind! local p (nth args i)))
         (lambda-params f))
       (render-to-html (lambda-body f) local))))
 
@@ -315,11 +315,11 @@
         ;; Bind params from kwargs
         (for-each
           (fn (p)
-            (env-set! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
+            (env-bind! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
           (component-params comp))
         ;; If component accepts children, pre-render them to raw HTML
         (when (component-has-children? comp)
-          (env-set! local "children"
+          (env-bind! local "children"
             (make-raw-html (join "" (map (fn (c) (render-to-html c env)) children)))))
         (render-to-html (component-body comp) local)))))
 
@@ -481,12 +481,12 @@
         ;; Bind params from kwargs
         (for-each
           (fn (p)
-            (env-set! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
+            (env-bind! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
           (component-params island))
 
         ;; If island accepts children, pre-render them to raw HTML
         (when (component-has-children? island)
-          (env-set! local "children"
+          (env-bind! local "children"
             (make-raw-html (join "" (map (fn (c) (render-to-html c env)) children)))))
 
         ;; Render the island body as HTML

web/adapter-sx.sx

@@ -289,7 +289,7 @@
             (map (fn (item)
                    (if (lambda? f)
                      (let ((local (env-merge (lambda-closure f) env)))
-                       (env-set! local (first (lambda-params f)) item)
+                       (env-bind! local (first (lambda-params f)) item)
                        (aser (lambda-body f) local))
                      (cek-call f (list item))))
                  coll))
@@ -301,8 +301,8 @@
             (map-indexed (fn (i item)
                            (if (lambda? f)
                              (let ((local (env-merge (lambda-closure f) env)))
-                               (env-set! local (first (lambda-params f)) i)
-                               (env-set! local (nth (lambda-params f) 1) item)
+                               (env-bind! local (first (lambda-params f)) i)
+                               (env-bind! local (nth (lambda-params f) 1) item)
                                (aser (lambda-body f) local))
                              (cek-call f (list i item))))
                          coll))
@@ -315,7 +315,7 @@
             (for-each (fn (item)
                         (if (lambda? f)
                           (let ((local (env-merge (lambda-closure f) env)))
-                            (env-set! local (first (lambda-params f)) item)
+                            (env-bind! local (first (lambda-params f)) item)
                             (append! results (aser (lambda-body f) local)))
                           (cek-call f (list item))))
                       coll)

web/boot.sx

@@ -361,7 +361,7 @@
               ;; Bind params from kwargs
               (for-each
                 (fn ((p :as string))
-                  (env-set! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
+                  (env-bind! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
                 (component-params comp))
 
               ;; Render the island body in a reactive scope

web/boundary-web.sx

@@ -1,32 +1,11 @@
 ;; ==========================================================================
-;; boundary.sx — SX language boundary contract
-;;
-;; Declares the core I/O primitives that any SX host must provide.
-;; This is the LANGUAGE contract — not deployment-specific.
-;;
-;; Pure primitives (Tier 1) are declared in primitives.sx.
-;; Deployment-specific I/O lives in boundary-app.sx.
-;; Per-service page helpers live in {service}/sx/boundary.sx.
-;;
-;; Format:
-;;   (define-io-primitive "name"
-;;     :params (param1 param2 &key ...)
-;;     :returns "type"
-;;     :effects [io]
-;;     :async true
-;;     :doc "description"
-;;     :context :request)
+;; boundary-web.sx — Web platform boundary contract
 ;;
+;; I/O primitives, signals, spreads, scopes, and page helpers
+;; required by the SX web framework. Built on the core spec.
 ;; ==========================================================================
 
 
-;; --------------------------------------------------------------------------
-;; Tier 1: Pure primitives — declared in primitives.sx
-;; --------------------------------------------------------------------------
-
-(declare-tier :pure :source "primitives.sx")
-
-
 ;; --------------------------------------------------------------------------
 ;; Tier 2: Core I/O primitives — async, side-effectful, need host context
 ;;

web/forms.sx

@@ -98,7 +98,7 @@
           (params   (get parsed "params"))
           (body     (get parsed "body")))
       (let ((hdef (make-handler-def name params body env opts)))
-        (env-set! env (str "handler:" name) hdef)
+        (env-bind! env (str "handler:" name) hdef)
         hdef))))
 
 
@@ -117,7 +117,7 @@
           (doc        (if has-doc (nth args 2) ""))
           (body       (if has-doc (nth args 3) (nth args 2))))
       (let ((qdef (make-query-def name params doc body env)))
-        (env-set! env (str "query:" name) qdef)
+        (env-bind! env (str "query:" name) qdef)
         qdef))))
 
 
@@ -135,7 +135,7 @@
           (doc        (if has-doc (nth args 2) ""))
           (body       (if has-doc (nth args 3) (nth args 2))))
       (let ((adef (make-action-def name params doc body env)))
-        (env-set! env (str "action:" name) adef)
+        (env-bind! env (str "action:" name) adef)
         adef))))
 
 
@@ -163,7 +163,7 @@
                            (nth args (+ idx 1))))))
           (range 1 max-i 2)))
       (let ((pdef (make-page-def name slots env)))
-        (env-set! env (str "page:" name) pdef)
+        (env-bind! env (str "page:" name) pdef)
         pdef))))
 
 
@@ -266,7 +266,7 @@
           (bindings (stream-chunk-bindings chunk)))
       (for-each
         (fn ((key :as string))
-          (env-set! env (normalize-binding-key key)
+          (env-bind! env (normalize-binding-key key)
                     (get bindings key)))
         (keys bindings))
       env)))

web/orchestration.sx

@@ -1103,9 +1103,9 @@
                       (dom-listen el event-name
                         (fn (e)
                           (let ((handler-env (env-extend (dict))))
-                            (env-set! handler-env "event" e)
-                            (env-set! handler-env "this" el)
-                            (env-set! handler-env "detail" (event-detail e))
+                            (env-bind! handler-env "event" e)
+                            (env-bind! handler-env "this" el)
+                            (env-bind! handler-env "detail" (event-detail e))
                             (for-each
                               (fn (expr) (eval-expr expr handler-env))
                               exprs))))))))))

web/tests/test-cek-reactive.sx

@@ -39,7 +39,7 @@
 (defsuite "deref signal without reactive-reset"
   (deftest "deref signal returns current value"
     (let ((s (signal 99)))
-      (env-set! (test-env) "test-sig" s)
+      (env-bind! (test-env) "test-sig" s)
       (let ((result (eval-expr-cek
                       (sx-parse-one "(deref test-sig)")
                       (test-env))))
@@ -47,7 +47,7 @@
 
   (deftest "deref signal in expression returns computed value"
     (let ((s (signal 10)))
-      (env-set! (test-env) "test-sig" s)
+      (env-bind! (test-env) "test-sig" s)
       (let ((result (eval-expr-cek
                       (sx-parse-one "(+ 5 (deref test-sig))")
                       (test-env))))
@@ -67,7 +67,7 @@
                       (make-cek-state
                         (sx-parse-one "(deref test-sig)")
                         (let ((e (env-extend (test-env))))
-                          (env-set! e "test-sig" s)
+                          (env-bind! e "test-sig" s)
                           e)
                         (list (make-reactive-reset-frame
                                 (test-env)
@@ -83,7 +83,7 @@
       ;; Set up reactive-reset with tracking update-fn
       (scope-push! "sx-island-scope" nil)
       (let ((e (env-extend (test-env))))
-        (env-set! e "test-sig" s)
+        (env-bind! e "test-sig" s)
         (cek-run
           (make-cek-state
             (sx-parse-one "(deref test-sig)")
@@ -107,7 +107,7 @@
           (update-calls (list)))
       (scope-push! "sx-island-scope" nil)
       (let ((e (env-extend (test-env))))
-        (env-set! e "test-sig" s)
+        (env-bind! e "test-sig" s)
         ;; (str "val=" (deref test-sig)) — continuation captures (str "val=" [HOLE])
         (let ((result (cek-run
                         (make-cek-state
@@ -137,7 +137,7 @@
       ;; Create island scope with collector that accumulates disposers
       (scope-push! "sx-island-scope" (fn (d) (append! disposers d)))
       (let ((e (env-extend (test-env))))
-        (env-set! e "test-sig" s)
+        (env-bind! e "test-sig" s)
         (cek-run
           (make-cek-state
             (sx-parse-one "(deref test-sig)")
@@ -266,7 +266,7 @@
 
   (deftest "for-each through CEK"
     (let ((log (list)))
-      (env-set! (test-env) "test-log" log)
+      (env-bind! (test-env) "test-log" log)
       (eval-expr-cek
         (sx-parse-one "(for-each (fn (x) (append! test-log x)) (list 1 2 3))")
         (test-env))