Add OCaml SX kernel build to sx_docs Docker image and enable in production

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

.gitignore

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

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,64 @@
+# 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_USE_OCAML: "1"
+      SX_OCAML_BIN: "/app/bin/sx_server"
+      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
+      # OCaml SX kernel binary (built with: cd hosts/ocaml && eval $(opam env) && dune build)
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./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

docker-compose.yml

@@ -228,6 +228,8 @@ services:
       <<: *app-env
       REDIS_URL: redis://redis:6379/10
       WORKERS: "1"
+      SX_USE_OCAML: "1"
+      SX_OCAML_BIN: "/app/bin/sx_server"
 
   db:
     image: postgres:16

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,8 +77,7 @@ def compile_ref_to_js(
     from datetime import datetime, timezone
     from shared.sx.ref.sx_ref import evaluate
 
-    ref_dir = _HERE
-    _PROJECT = os.path.abspath(os.path.join(_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
@@ -113,17 +112,11 @@ 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 module requires frames
-    if "cek" in spec_mod_set:
-        spec_mod_set.add("frames")
+    # CEK is always included (part of evaluator.sx core file)
+    has_cek = True
     has_deps = "deps" in spec_mod_set
     has_router = "router" in spec_mod_set
     has_page_helpers = "page-helpers" in spec_mod_set
-    has_cek = "cek" in spec_mod_set
 
     # Resolve extensions
     ext_set = set()
@@ -134,9 +127,10 @@ def compile_ref_to_js(
             ext_set.add(e)
     has_continuations = "continuations" in ext_set
 
-    # Build file list: core + adapters + spec modules
+    # Build file list: core evaluator + adapters + spec modules
+    # evaluator.sx = merged frames + eval utilities + CEK machine
     sx_files = [
-        ("eval.sx", "eval"),
+        ("evaluator.sx", "evaluator (frames + eval + CEK)"),
         ("render.sx", "render (core)"),
     ]
     for name in ("parser", "html", "sx", "dom", "engine", "orchestration", "boot"):
@@ -239,8 +233,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

@@ -46,13 +46,12 @@ SPEC_MODULES = {
     "router": ("router.sx", "router (client-side route matching)"),
     "signals": ("signals.sx", "signals (reactive signal runtime)"),
     "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)"),
 }
+# Note: frames and cek are now part of evaluator.sx (always loaded as core)
 
 # 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", "page-helpers", "router", "signals", "types"]
 
 
 EXTENSION_NAMES = {"continuations"}
@@ -61,9 +60,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 +981,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 +1160,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 +1234,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 +1255,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 +1270,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 +1502,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 +1538,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 +3256,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/ocaml/bin/debug_set.ml

@@ -0,0 +1,36 @@
+module T = Sx.Sx_types
+module P = Sx.Sx_parser
+module R = Sx.Sx_ref
+open T
+
+let () =
+  let env = T.make_env () in
+  let eval src =
+    let exprs = P.parse_all src in
+    let result = ref Nil in
+    List.iter (fun e -> result := R.eval_expr e (Env env)) exprs;
+    !result
+  in
+  (* Test 1: basic set! in closure *)
+  let r = eval "(let ((x 0)) (set! x 42) x)" in
+  Printf.printf "basic set!: %s (expect 42)\n%!" (T.inspect r);
+
+  (* Test 2: set! through lambda call *)
+  let r = eval "(let ((x 0)) (let ((f (fn () (set! x 99)))) (f) x))" in
+  Printf.printf "set! via lambda: %s (expect 99)\n%!" (T.inspect r);
+
+  (* Test 3: counter pattern *)
+  let r = eval "(do (define make-counter (fn () (let ((c 0)) (fn () (set! c (+ c 1)) c)))) (let ((counter (make-counter))) (counter) (counter) (counter)))" in
+  Printf.printf "counter: %s (expect 3)\n%!" (T.inspect r);
+
+  (* Test 4: set! in for-each *)
+  let r = eval "(let ((total 0)) (for-each (fn (n) (set! total (+ total n))) (list 1 2 3 4 5)) total)" in
+  Printf.printf "set! in for-each: %s (expect 15)\n%!" (T.inspect r);
+
+  (* Test 5: append! in for-each *)
+  ignore (T.env_bind env "append!" (NativeFn ("append!", fun args ->
+    match args with
+    | [List items; v] -> List (items @ [v])
+    | _ -> raise (Eval_error "append!: expected list and value"))));
+  let r = eval "(let ((log (list))) (for-each (fn (x) (append! log x)) (list 1 2 3)) log)" in
+  Printf.printf "append! in for-each: %s (expect (1 2 3))\n%!" (T.inspect r)

hosts/ocaml/bin/dune

@@ -0,0 +1,3 @@
+(executables
+ (names run_tests debug_set sx_server)
+ (libraries sx))

hosts/ocaml/bin/dune_debug

@@ -0,0 +1 @@
+(executable (name debug_macro) (libraries sx))

hosts/ocaml/bin/run_tests.ml

@@ -0,0 +1,701 @@
+(** Test runner — runs the SX spec test suite against the transpiled CEK evaluator.
+
+    Provides the 5 platform functions required by test-framework.sx:
+      try-call, report-pass, report-fail, push-suite, pop-suite
+
+    Plus test helpers: sx-parse, cek-eval, env-*, equal?, etc.
+
+    Usage:
+      dune exec bin/run_tests.exe                    # foundation + spec tests
+      dune exec bin/run_tests.exe -- test-primitives  # specific test
+      dune exec bin/run_tests.exe -- --foundation     # foundation only *)
+
+module Sx_types = Sx.Sx_types
+module Sx_parser = Sx.Sx_parser
+module Sx_primitives = Sx.Sx_primitives
+module Sx_runtime = Sx.Sx_runtime
+module Sx_ref = Sx.Sx_ref
+module Sx_render = Sx.Sx_render
+
+open Sx_types
+open Sx_parser
+open Sx_primitives
+open Sx_runtime
+open Sx_ref
+
+(* ====================================================================== *)
+(* Test state                                                              *)
+(* ====================================================================== *)
+
+let pass_count = ref 0
+let fail_count = ref 0
+let suite_stack : string list ref = ref []
+
+(* ====================================================================== *)
+(* Deep equality — SX structural comparison                                *)
+(* ====================================================================== *)
+
+let rec deep_equal a b =
+  match a, b with
+  | Nil, Nil -> true
+  | Bool a, Bool b -> a = b
+  | Number a, Number b -> a = b
+  | String a, String b -> a = b
+  | Symbol a, Symbol b -> a = b
+  | Keyword a, Keyword b -> a = b
+  | (List a | ListRef { contents = a }), (List b | ListRef { contents = b }) ->
+    List.length a = List.length b &&
+    List.for_all2 deep_equal a b
+  | Dict a, Dict b ->
+    let ka = Hashtbl.fold (fun k _ acc -> k :: acc) a [] in
+    let kb = Hashtbl.fold (fun k _ acc -> k :: acc) b [] in
+    List.length ka = List.length kb &&
+    List.for_all (fun k ->
+      Hashtbl.mem b k &&
+      deep_equal
+        (match Hashtbl.find_opt a k with Some v -> v | None -> Nil)
+        (match Hashtbl.find_opt b k with Some v -> v | None -> Nil)) ka
+  | Lambda _, Lambda _ -> a == b  (* identity *)
+  | NativeFn _, NativeFn _ -> a == b
+  | _ -> false
+
+(* ====================================================================== *)
+(* Build evaluator environment with test platform functions                *)
+(* ====================================================================== *)
+
+let make_test_env () =
+  let env = Sx_types.make_env () in
+
+  let bind name fn =
+    ignore (Sx_types.env_bind env name (NativeFn (name, fn)))
+  in
+
+  (* --- 5 platform functions required by test-framework.sx --- *)
+
+  bind "try-call" (fun args ->
+    match args with
+    | [thunk] ->
+      (try
+        (* Call the thunk: it's a lambda with no params *)
+        let result = eval_expr (List [thunk]) (Env env) in
+        ignore result;
+        let d = Hashtbl.create 2 in
+        Hashtbl.replace d "ok" (Bool true);
+        Dict d
+      with
+      | Eval_error msg ->
+        let d = Hashtbl.create 2 in
+        Hashtbl.replace d "ok" (Bool false);
+        Hashtbl.replace d "error" (String msg);
+        Dict d
+      | exn ->
+        let d = Hashtbl.create 2 in
+        Hashtbl.replace d "ok" (Bool false);
+        Hashtbl.replace d "error" (String (Printexc.to_string exn));
+        Dict d)
+    | _ -> raise (Eval_error "try-call: expected 1 arg"));
+
+  bind "report-pass" (fun args ->
+    match args with
+    | [String name] ->
+      incr pass_count;
+      let ctx = String.concat " > " (List.rev !suite_stack) in
+      Printf.printf "  PASS: %s > %s\n%!" ctx name;
+      Nil
+    | [v] ->
+      incr pass_count;
+      let ctx = String.concat " > " (List.rev !suite_stack) in
+      Printf.printf "  PASS: %s > %s\n%!" ctx (Sx_types.inspect v);
+      Nil
+    | _ -> raise (Eval_error "report-pass: expected 1 arg"));
+
+  bind "report-fail" (fun args ->
+    match args with
+    | [String name; String error] ->
+      incr fail_count;
+      let ctx = String.concat " > " (List.rev !suite_stack) in
+      Printf.printf "  FAIL: %s > %s: %s\n%!" ctx name error;
+      Nil
+    | [name_v; error_v] ->
+      incr fail_count;
+      let ctx = String.concat " > " (List.rev !suite_stack) in
+      Printf.printf "  FAIL: %s > %s: %s\n%!" ctx
+        (Sx_types.value_to_string name_v)
+        (Sx_types.value_to_string error_v);
+      Nil
+    | _ -> raise (Eval_error "report-fail: expected 2 args"));
+
+  bind "push-suite" (fun args ->
+    match args with
+    | [String name] ->
+      suite_stack := name :: !suite_stack;
+      let indent = String.make ((List.length !suite_stack - 1) * 2) ' ' in
+      Printf.printf "%sSuite: %s\n%!" indent name;
+      Nil
+    | [v] ->
+      let name = Sx_types.value_to_string v in
+      suite_stack := name :: !suite_stack;
+      let indent = String.make ((List.length !suite_stack - 1) * 2) ' ' in
+      Printf.printf "%sSuite: %s\n%!" indent name;
+      Nil
+    | _ -> raise (Eval_error "push-suite: expected 1 arg"));
+
+  bind "pop-suite" (fun _args ->
+    suite_stack := (match !suite_stack with _ :: t -> t | [] -> []);
+    Nil);
+
+  (* --- Test helpers --- *)
+
+  bind "sx-parse" (fun args ->
+    match args with
+    | [String s] -> List (parse_all s)
+    | _ -> raise (Eval_error "sx-parse: expected string"));
+
+  bind "sx-parse-one" (fun args ->
+    match args with
+    | [String s] ->
+      let exprs = parse_all s in
+      (match exprs with e :: _ -> e | [] -> Nil)
+    | _ -> raise (Eval_error "sx-parse-one: expected string"));
+
+  bind "cek-eval" (fun args ->
+    match args with
+    | [String s] ->
+      let exprs = parse_all s in
+      (match exprs with
+       | e :: _ -> eval_expr e (Env env)
+       | [] -> Nil)
+    | _ -> raise (Eval_error "cek-eval: expected string"));
+
+  bind "eval-expr-cek" (fun args ->
+    match args with
+    | [expr; e] -> eval_expr expr e
+    | [expr] -> eval_expr expr (Env env)
+    | _ -> raise (Eval_error "eval-expr-cek: expected 1-2 args"));
+
+  bind "test-env" (fun _args -> Env (Sx_types.env_extend env));
+
+  (* --- Environment operations --- *)
+
+  bind "env-get" (fun args ->
+    match args with
+    | [Env e; String k] -> Sx_types.env_get e k
+    | [Env e; Keyword k] -> Sx_types.env_get e k
+    | _ -> raise (Eval_error "env-get: expected env and string"));
+
+  bind "env-has?" (fun args ->
+    match args with
+    | [Env e; String k] -> Bool (Sx_types.env_has e k)
+    | [Env e; Keyword k] -> Bool (Sx_types.env_has e k)
+    | _ -> raise (Eval_error "env-has?: expected env and string"));
+
+  bind "env-bind!" (fun args ->
+    match args with
+    | [Env e; String k; v] -> Sx_types.env_bind e k v
+    | [Env e; Keyword k; v] -> Sx_types.env_bind e k v
+    | _ -> raise (Eval_error "env-bind!: expected env, key, value"));
+
+  bind "env-set!" (fun args ->
+    match args with
+    | [Env e; String k; v] -> Sx_types.env_set e k v
+    | [Env e; Keyword k; v] -> Sx_types.env_set e k v
+    | _ -> raise (Eval_error "env-set!: expected env, key, value"));
+
+  bind "env-extend" (fun args ->
+    match args with
+    | [Env e] -> Env (Sx_types.env_extend e)
+    | _ -> raise (Eval_error "env-extend: expected env"));
+
+  bind "env-merge" (fun args ->
+    match args with
+    | [Env a; Env b] -> Env (Sx_types.env_merge a b)
+    | _ -> raise (Eval_error "env-merge: expected 2 envs"));
+
+  (* --- Equality --- *)
+
+  bind "equal?" (fun args ->
+    match args with
+    | [a; b] -> Bool (deep_equal a b)
+    | _ -> raise (Eval_error "equal?: expected 2 args"));
+
+  bind "identical?" (fun args ->
+    match args with
+    | [a; b] -> Bool (a == b)
+    | _ -> raise (Eval_error "identical?: expected 2 args"));
+
+  (* --- Continuation support --- *)
+
+  bind "make-continuation" (fun args ->
+    match args with
+    | [f] ->
+      let k v = sx_call f [v] in
+      Continuation (k, None)
+    | _ -> raise (Eval_error "make-continuation: expected 1 arg"));
+
+  bind "continuation?" (fun args ->
+    match args with
+    | [Continuation _] -> Bool true
+    | [_] -> Bool false
+    | _ -> raise (Eval_error "continuation?: expected 1 arg"));
+
+  bind "continuation-fn" (fun args ->
+    match args with
+    | [Continuation (f, _)] -> NativeFn ("continuation-fn-result", fun args ->
+        match args with [v] -> f v | _ -> f Nil)
+    | _ -> raise (Eval_error "continuation-fn: expected continuation"));
+
+  (* --- Core builtins used by test framework / test code --- *)
+
+  bind "assert" (fun args ->
+    match args with
+    | [cond] ->
+      if not (sx_truthy cond) then raise (Eval_error "Assertion failed");
+      Bool true
+    | [cond; String msg] ->
+      if not (sx_truthy cond) then raise (Eval_error ("Assertion error: " ^ msg));
+      Bool true
+    | [cond; msg] ->
+      if not (sx_truthy cond) then
+        raise (Eval_error ("Assertion error: " ^ Sx_types.value_to_string msg));
+      Bool true
+    | _ -> raise (Eval_error "assert: expected 1-2 args"));
+
+  bind "append!" (fun args ->
+    match args with
+    | [ListRef r; v] -> r := !r @ [v]; ListRef r  (* mutate in place *)
+    | [List items; v] -> List (items @ [v])  (* immutable fallback *)
+    | _ -> raise (Eval_error "append!: expected list and value"));
+
+  (* --- HTML Renderer (from sx_render.ml library module) --- *)
+  Sx.Sx_render.setup_render_env env;
+
+  (* --- Missing primitives referenced by tests --- *)
+
+  bind "upcase" (fun args ->
+    match args with
+    | [String s] -> String (String.uppercase_ascii s)
+    | _ -> raise (Eval_error "upcase: expected string"));
+
+  bind "downcase" (fun args ->
+    match args with
+    | [String s] -> String (String.lowercase_ascii s)
+    | _ -> raise (Eval_error "downcase: expected string"));
+
+  bind "make-keyword" (fun args ->
+    match args with
+    | [String s] -> Keyword s
+    | _ -> raise (Eval_error "make-keyword: expected string"));
+
+  bind "string-length" (fun args ->
+    match args with
+    | [String s] -> Number (float_of_int (String.length s))
+    | _ -> raise (Eval_error "string-length: expected string"));
+
+  bind "dict-get" (fun args ->
+    match args with
+    | [Dict d; String k] -> Sx_types.dict_get d k
+    | [Dict d; Keyword k] -> Sx_types.dict_get d k
+    | _ -> raise (Eval_error "dict-get: expected dict and key"));
+
+  bind "apply" (fun args ->
+    match args with
+    | f :: rest ->
+      let all_args = match List.rev rest with
+        | List last :: prefix -> List.rev prefix @ last
+        | _ -> rest
+      in
+      sx_call f all_args
+    | _ -> raise (Eval_error "apply: expected function and args"));
+
+  (* --- Type system helpers (for --full tests) --- *)
+
+  bind "test-prim-types" (fun _args ->
+    let d = Hashtbl.create 40 in
+    List.iter (fun (k, v) -> Hashtbl.replace d k (String v)) [
+      "+", "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";
+    ];
+    Dict d);
+
+  bind "test-prim-param-types" (fun _args ->
+    let d = Hashtbl.create 10 in
+    let pos name typ =
+      let d2 = Hashtbl.create 2 in
+      Hashtbl.replace d2 "positional" (List [List [String name; String typ]]);
+      Hashtbl.replace d2 "rest-type" Nil;
+      Dict d2
+    in
+    let pos_rest name typ rt =
+      let d2 = Hashtbl.create 2 in
+      Hashtbl.replace d2 "positional" (List [List [String name; String typ]]);
+      Hashtbl.replace d2 "rest-type" (String rt);
+      Dict d2
+    in
+    Hashtbl.replace d "+" (pos_rest "a" "number" "number");
+    Hashtbl.replace d "-" (pos_rest "a" "number" "number");
+    Hashtbl.replace d "*" (pos_rest "a" "number" "number");
+    Hashtbl.replace d "/" (pos_rest "a" "number" "number");
+    Hashtbl.replace d "inc" (pos "n" "number");
+    Hashtbl.replace d "dec" (pos "n" "number");
+    Hashtbl.replace d "upper" (pos "s" "string");
+    Hashtbl.replace d "lower" (pos "s" "string");
+    Hashtbl.replace d "keys" (pos "d" "dict");
+    Hashtbl.replace d "vals" (pos "d" "dict");
+    Dict d);
+
+  (* --- Component accessors --- *)
+
+  bind "component-param-types" (fun _args -> Nil);
+
+  bind "component-set-param-types!" (fun _args -> Nil);
+
+  bind "component-params" (fun args ->
+    match args with
+    | [Component c] -> List (List.map (fun s -> String s) c.c_params)
+    | _ -> Nil);
+
+  bind "component-body" (fun args ->
+    match args with
+    | [Component c] -> c.c_body
+    | _ -> Nil);
+
+  bind "component-has-children" (fun args ->
+    match args with
+    | [Component c] -> Bool c.c_has_children
+    | _ -> Bool false);
+
+  bind "component-affinity" (fun args ->
+    match args with
+    | [Component c] -> String c.c_affinity
+    | _ -> String "auto");
+
+  (* --- Parser test helpers --- *)
+
+  bind "keyword-name" (fun args ->
+    match args with
+    | [Keyword k] -> String k
+    | _ -> raise (Eval_error "keyword-name: expected keyword"));
+
+  bind "symbol-name" (fun args ->
+    match args with
+    | [Symbol s] -> String s
+    | _ -> raise (Eval_error "symbol-name: expected symbol"));
+
+  bind "sx-serialize" (fun args ->
+    match args with
+    | [v] -> String (Sx_types.inspect v)
+    | _ -> raise (Eval_error "sx-serialize: expected 1 arg"));
+
+  (* --- make-symbol --- *)
+
+  bind "make-symbol" (fun args ->
+    match args with
+    | [String s] -> Symbol s
+    | [v] -> Symbol (Sx_types.value_to_string v)
+    | _ -> raise (Eval_error "make-symbol: expected 1 arg"));
+
+  (* --- CEK stepping / introspection --- *)
+
+  bind "make-cek-state" (fun args ->
+    match args with
+    | [ctrl; env'; kont] -> Sx_ref.make_cek_state ctrl env' kont
+    | _ -> raise (Eval_error "make-cek-state: expected 3 args"));
+
+  bind "cek-step" (fun args ->
+    match args with
+    | [state] -> Sx_ref.cek_step state
+    | _ -> raise (Eval_error "cek-step: expected 1 arg"));
+
+  bind "cek-phase" (fun args ->
+    match args with
+    | [state] -> Sx_ref.cek_phase state
+    | _ -> raise (Eval_error "cek-phase: expected 1 arg"));
+
+  bind "cek-value" (fun args ->
+    match args with
+    | [state] -> Sx_ref.cek_value state
+    | _ -> raise (Eval_error "cek-value: expected 1 arg"));
+
+  bind "cek-terminal?" (fun args ->
+    match args with
+    | [state] -> Sx_ref.cek_terminal_p state
+    | _ -> raise (Eval_error "cek-terminal?: expected 1 arg"));
+
+  bind "cek-kont" (fun args ->
+    match args with
+    | [state] -> Sx_ref.cek_kont state
+    | _ -> raise (Eval_error "cek-kont: expected 1 arg"));
+
+  bind "frame-type" (fun args ->
+    match args with
+    | [frame] -> Sx_ref.frame_type frame
+    | _ -> raise (Eval_error "frame-type: expected 1 arg"));
+
+  (* --- Strict mode --- *)
+  (* *strict* is a plain value in the env, mutated via env_set by set-strict! *)
+  ignore (Sx_types.env_bind env "*strict*" (Bool false));
+  ignore (Sx_types.env_bind env "*prim-param-types*" Nil);
+
+  bind "set-strict!" (fun args ->
+    match args with
+    | [v] ->
+      Sx_ref._strict_ref := v;
+      ignore (Sx_types.env_set env "*strict*" v); Nil
+    | _ -> raise (Eval_error "set-strict!: expected 1 arg"));
+
+  bind "set-prim-param-types!" (fun args ->
+    match args with
+    | [v] ->
+      Sx_ref._prim_param_types_ref := v;
+      ignore (Sx_types.env_set env "*prim-param-types*" v); Nil
+    | _ -> raise (Eval_error "set-prim-param-types!: expected 1 arg"));
+
+  bind "value-matches-type?" (fun args ->
+    match args with
+    | [v; String expected] -> Sx_ref.value_matches_type_p v (String expected)
+    | _ -> raise (Eval_error "value-matches-type?: expected value and type string"));
+
+  env
+
+(* ====================================================================== *)
+(* Foundation tests (direct, no evaluator)                                 *)
+(* ====================================================================== *)
+
+let run_foundation_tests () =
+  Printf.printf "=== SX OCaml Foundation Tests ===\n\n";
+
+  let assert_eq name expected actual =
+    if deep_equal expected actual then begin
+      incr pass_count;
+      Printf.printf "  PASS: %s\n" name
+    end else begin
+      incr fail_count;
+      Printf.printf "  FAIL: %s — expected %s, got %s\n" name
+        (Sx_types.inspect expected) (Sx_types.inspect actual)
+    end
+  in
+  let assert_true name v =
+    if sx_truthy v then begin
+      incr pass_count;
+      Printf.printf "  PASS: %s\n" name
+    end else begin
+      incr fail_count;
+      Printf.printf "  FAIL: %s — expected truthy, got %s\n" name (Sx_types.inspect v)
+    end
+  in
+  let call name args =
+    match Hashtbl.find_opt primitives name with
+    | Some f -> f args
+    | None -> failwith ("Unknown primitive: " ^ name)
+  in
+
+  Printf.printf "Suite: parser\n";
+  assert_eq "number" (Number 42.0) (List.hd (parse_all "42"));
+  assert_eq "string" (String "hello") (List.hd (parse_all "\"hello\""));
+  assert_eq "bool true" (Bool true) (List.hd (parse_all "true"));
+  assert_eq "nil" Nil (List.hd (parse_all "nil"));
+  assert_eq "keyword" (Keyword "class") (List.hd (parse_all ":class"));
+  assert_eq "symbol" (Symbol "foo") (List.hd (parse_all "foo"));
+  assert_eq "list" (List [Symbol "+"; Number 1.0; Number 2.0]) (List.hd (parse_all "(+ 1 2)"));
+  (match List.hd (parse_all "(div :class \"card\" (p \"hi\"))") with
+   | List [Symbol "div"; Keyword "class"; String "card"; List [Symbol "p"; String "hi"]] ->
+     incr pass_count; Printf.printf "  PASS: nested list\n"
+   | v -> incr fail_count; Printf.printf "  FAIL: nested list — got %s\n" (Sx_types.inspect v));
+  (match List.hd (parse_all "'(1 2 3)") with
+   | List [Symbol "quote"; List [Number 1.0; Number 2.0; Number 3.0]] ->
+     incr pass_count; Printf.printf "  PASS: quote sugar\n"
+   | v -> incr fail_count; Printf.printf "  FAIL: quote sugar — got %s\n" (Sx_types.inspect v));
+  (match List.hd (parse_all "{:a 1 :b 2}") with
+   | Dict d when dict_has d "a" && dict_has d "b" ->
+     incr pass_count; Printf.printf "  PASS: dict literal\n"
+   | v -> incr fail_count; Printf.printf "  FAIL: dict literal — got %s\n" (Sx_types.inspect v));
+  assert_eq "comment" (Number 42.0) (List.hd (parse_all ";; comment\n42"));
+  assert_eq "string escape" (String "hello\nworld") (List.hd (parse_all "\"hello\\nworld\""));
+  assert_eq "multiple exprs" (Number 2.0) (Number (float_of_int (List.length (parse_all "(1 2 3) (4 5)"))));
+
+  Printf.printf "\nSuite: primitives\n";
+  assert_eq "+" (Number 6.0) (call "+" [Number 1.0; Number 2.0; Number 3.0]);
+  assert_eq "-" (Number 3.0) (call "-" [Number 5.0; Number 2.0]);
+  assert_eq "*" (Number 12.0) (call "*" [Number 3.0; Number 4.0]);
+  assert_eq "/" (Number 2.5) (call "/" [Number 5.0; Number 2.0]);
+  assert_eq "mod" (Number 1.0) (call "mod" [Number 5.0; Number 2.0]);
+  assert_eq "inc" (Number 6.0) (call "inc" [Number 5.0]);
+  assert_eq "abs" (Number 5.0) (call "abs" [Number (-5.0)]);
+  assert_true "=" (call "=" [Number 1.0; Number 1.0]);
+  assert_true "!=" (call "!=" [Number 1.0; Number 2.0]);
+  assert_true "<" (call "<" [Number 1.0; Number 2.0]);
+  assert_true ">" (call ">" [Number 2.0; Number 1.0]);
+  assert_true "nil?" (call "nil?" [Nil]);
+  assert_true "number?" (call "number?" [Number 1.0]);
+  assert_true "string?" (call "string?" [String "hi"]);
+  assert_true "list?" (call "list?" [List [Number 1.0]]);
+  assert_true "empty? list" (call "empty?" [List []]);
+  assert_true "empty? string" (call "empty?" [String ""]);
+  assert_eq "str" (String "hello42") (call "str" [String "hello"; Number 42.0]);
+  assert_eq "upper" (String "HI") (call "upper" [String "hi"]);
+  assert_eq "trim" (String "hi") (call "trim" [String "  hi  "]);
+  assert_eq "join" (String "a,b,c") (call "join" [String ","; List [String "a"; String "b"; String "c"]]);
+  assert_true "starts-with?" (call "starts-with?" [String "hello"; String "hel"]);
+  assert_true "contains?" (call "contains?" [List [Number 1.0; Number 2.0; Number 3.0]; Number 2.0]);
+  assert_eq "list" (List [Number 1.0; Number 2.0]) (call "list" [Number 1.0; Number 2.0]);
+  assert_eq "len" (Number 3.0) (call "len" [List [Number 1.0; Number 2.0; Number 3.0]]);
+  assert_eq "first" (Number 1.0) (call "first" [List [Number 1.0; Number 2.0]]);
+  assert_eq "rest" (List [Number 2.0; Number 3.0]) (call "rest" [List [Number 1.0; Number 2.0; Number 3.0]]);
+  assert_eq "nth" (Number 2.0) (call "nth" [List [Number 1.0; Number 2.0]; Number 1.0]);
+  assert_eq "cons" (List [Number 0.0; Number 1.0]) (call "cons" [Number 0.0; List [Number 1.0]]);
+  assert_eq "append" (List [Number 1.0; Number 2.0; Number 3.0])
+    (call "append" [List [Number 1.0]; List [Number 2.0; Number 3.0]]);
+  assert_eq "reverse" (List [Number 3.0; Number 2.0; Number 1.0])
+    (call "reverse" [List [Number 1.0; Number 2.0; Number 3.0]]);
+  assert_eq "range" (List [Number 0.0; Number 1.0; Number 2.0]) (call "range" [Number 3.0]);
+  assert_eq "slice" (List [Number 2.0; Number 3.0])
+    (call "slice" [List [Number 1.0; Number 2.0; Number 3.0]; Number 1.0]);
+  assert_eq "type-of" (String "number") (call "type-of" [Number 1.0]);
+  assert_eq "type-of nil" (String "nil") (call "type-of" [Nil]);
+
+  Printf.printf "\nSuite: env\n";
+  let e = Sx_types.make_env () in
+  ignore (Sx_types.env_bind e "x" (Number 42.0));
+  assert_eq "env-bind + get" (Number 42.0) (Sx_types.env_get e "x");
+  assert_true "env-has" (Bool (Sx_types.env_has e "x"));
+  let child = Sx_types.env_extend e in
+  ignore (Sx_types.env_bind child "y" (Number 10.0));
+  assert_eq "child sees parent" (Number 42.0) (Sx_types.env_get child "x");
+  assert_eq "child own binding" (Number 10.0) (Sx_types.env_get child "y");
+  ignore (Sx_types.env_set child "x" (Number 99.0));
+  assert_eq "set! walks chain" (Number 99.0) (Sx_types.env_get e "x");
+
+  Printf.printf "\nSuite: types\n";
+  assert_true "sx_truthy true" (Bool (sx_truthy (Bool true)));
+  assert_true "sx_truthy 0" (Bool (sx_truthy (Number 0.0)));
+  assert_true "sx_truthy \"\"" (Bool (sx_truthy (String "")));
+  assert_eq "not truthy nil" (Bool false) (Bool (sx_truthy Nil));
+  assert_eq "not truthy false" (Bool false) (Bool (sx_truthy (Bool false)));
+  let l = { l_params = ["x"]; l_body = Symbol "x"; l_closure = Sx_types.make_env (); l_name = None } in
+  assert_true "is_lambda" (Bool (Sx_types.is_lambda (Lambda l)));
+  ignore (Sx_types.set_lambda_name (Lambda l) "my-fn");
+  assert_eq "lambda name mutated" (String "my-fn") (lambda_name (Lambda l))
+
+
+(* ====================================================================== *)
+(* Spec test runner                                                        *)
+(* ====================================================================== *)
+
+let run_spec_tests env test_files =
+  (* Find project root: walk up from cwd until we find spec/tests *)
+  let rec find_root dir =
+    let candidate = Filename.concat dir "spec/tests" in
+    if Sys.file_exists candidate then dir
+    else
+      let parent = Filename.dirname dir in
+      if parent = dir then Sys.getcwd ()  (* reached filesystem root *)
+      else find_root parent
+  in
+  let project_dir = find_root (Sys.getcwd ()) in
+  let spec_tests_dir = Filename.concat project_dir "spec/tests" in
+  let framework_path = Filename.concat spec_tests_dir "test-framework.sx" in
+
+  if not (Sys.file_exists framework_path) then begin
+    Printf.eprintf "test-framework.sx not found at %s\n" framework_path;
+    Printf.eprintf "Run from the project root directory.\n";
+    exit 1
+  end;
+
+  let load_and_eval path =
+    let ic = open_in path in
+    let n = in_channel_length ic in
+    let s = Bytes.create n in
+    really_input ic s 0 n;
+    close_in ic;
+    let src = Bytes.to_string s in
+    let exprs = parse_all src in
+    List.iter (fun expr ->
+      ignore (eval_expr expr (Env env))
+    ) exprs
+  in
+
+  Printf.printf "\nLoading test framework...\n%!";
+  load_and_eval framework_path;
+
+  (* Determine test files *)
+  let files = if test_files = [] then begin
+    let entries = Sys.readdir spec_tests_dir in
+    Array.sort String.compare entries;
+    let requires_full = ["test-continuations.sx"; "test-types.sx"; "test-freeze.sx";
+                          "test-continuations-advanced.sx"; "test-signals-advanced.sx"] in
+    Array.to_list entries
+    |> List.filter (fun f ->
+      String.length f > 5 &&
+      String.sub f 0 5 = "test-" &&
+      Filename.check_suffix f ".sx" &&
+      f <> "test-framework.sx" &&
+      not (List.mem f requires_full))
+  end else
+    List.map (fun name ->
+      if Filename.check_suffix name ".sx" then name
+      else name ^ ".sx") test_files
+  in
+
+  List.iter (fun name ->
+    let path = Filename.concat spec_tests_dir name in
+    if Sys.file_exists path then begin
+      Printf.printf "\n%s\n" (String.make 60 '=');
+      Printf.printf "Running %s\n" name;
+      Printf.printf "%s\n%!" (String.make 60 '=');
+      (try
+        load_and_eval path
+      with
+      | Eval_error msg ->
+        incr fail_count;
+        Printf.printf "  ERROR in %s: %s\n%!" name msg
+      | exn ->
+        incr fail_count;
+        Printf.printf "  ERROR in %s: %s\n%!" name (Printexc.to_string exn))
+    end else
+      Printf.eprintf "Test file not found: %s\n" path
+  ) files
+
+
+(* ====================================================================== *)
+(* Main                                                                    *)
+(* ====================================================================== *)
+
+let () =
+  let args = Array.to_list Sys.argv |> List.tl in
+  let foundation_only = List.mem "--foundation" args in
+  let test_files = List.filter (fun a -> not (String.length a > 0 && a.[0] = '-')) args in
+
+  (* Always run foundation tests *)
+  run_foundation_tests ();
+
+  if not foundation_only then begin
+    Printf.printf "\n=== SX Spec Tests (CEK Evaluator) ===\n%!";
+    let env = make_test_env () in
+    run_spec_tests env test_files
+  end;
+
+  (* Summary *)
+  Printf.printf "\n%s\n" (String.make 60 '=');
+  Printf.printf "Results: %d passed, %d failed\n" !pass_count !fail_count;
+  Printf.printf "%s\n" (String.make 60 '=');
+  if !fail_count > 0 then exit 1

hosts/ocaml/bin/sx_server.ml

@@ -0,0 +1,427 @@
+(** SX coroutine subprocess server.
+
+    Persistent process that accepts commands on stdin and writes
+    responses on stdout.  All messages are single-line SX expressions,
+    newline-delimited.
+
+    Protocol:
+      Python → OCaml: (ping), (load path), (load-source src),
+                       (eval src), (render src), (reset),
+                       (io-response value)
+      OCaml → Python: (ready), (ok), (ok value), (error msg),
+                       (io-request name args...)
+
+    IO primitives (query, action, request-arg, request-method, ctx)
+    yield (io-request ...) and block on stdin for (io-response ...). *)
+
+module Sx_types = Sx.Sx_types
+module Sx_parser = Sx.Sx_parser
+module Sx_primitives = Sx.Sx_primitives
+module Sx_runtime = Sx.Sx_runtime
+module Sx_ref = Sx.Sx_ref
+module Sx_render = Sx.Sx_render
+
+open Sx_types
+
+
+(* ====================================================================== *)
+(* Output helpers                                                          *)
+(* ====================================================================== *)
+
+(** Escape a string for embedding in an SX string literal. *)
+let escape_sx_string s =
+  let buf = Buffer.create (String.length s + 16) in
+  String.iter (function
+    | '"'  -> Buffer.add_string buf "\\\""
+    | '\\' -> Buffer.add_string buf "\\\\"
+    | '\n' -> Buffer.add_string buf "\\n"
+    | '\r' -> Buffer.add_string buf "\\r"
+    | '\t' -> Buffer.add_string buf "\\t"
+    | c    -> Buffer.add_char buf c) s;
+  Buffer.contents buf
+
+(** Serialize a value to SX text (for io-request args). *)
+let rec serialize_value = function
+  | Nil -> "nil"
+  | Bool true -> "true"
+  | Bool false -> "false"
+  | Number n ->
+    if Float.is_integer n then string_of_int (int_of_float n)
+    else Printf.sprintf "%g" n
+  | String s -> "\"" ^ escape_sx_string s ^ "\""
+  | Symbol s -> s
+  | Keyword k -> ":" ^ k
+  | List items | ListRef { contents = items } ->
+    "(list " ^ String.concat " " (List.map serialize_value items) ^ ")"
+  | Dict d ->
+    let pairs = Hashtbl.fold (fun k v acc ->
+      (Printf.sprintf ":%s %s" k (serialize_value v)) :: acc) d [] in
+    "{" ^ String.concat " " pairs ^ "}"
+  | RawHTML s -> "\"" ^ escape_sx_string s ^ "\""
+  | _ -> "nil"
+
+let send line =
+  print_string line;
+  print_char '\n';
+  flush stdout
+
+let send_ok () = send "(ok)"
+let send_ok_value v = send (Printf.sprintf "(ok %s)" (serialize_value v))
+let send_ok_string s = send (Printf.sprintf "(ok \"%s\")" (escape_sx_string s))
+let send_error msg = send (Printf.sprintf "(error \"%s\")" (escape_sx_string msg))
+
+
+(* ====================================================================== *)
+(* IO bridge — primitives that yield to Python                             *)
+(* ====================================================================== *)
+
+(** Read a line from stdin (blocking). *)
+let read_line_blocking () =
+  try Some (input_line stdin)
+  with End_of_file -> None
+
+(** Send an io-request and block until io-response arrives. *)
+let io_request name args =
+  let args_str = String.concat " " (List.map serialize_value args) in
+  send (Printf.sprintf "(io-request \"%s\" %s)" name args_str);
+  (* Block on stdin for io-response *)
+  match read_line_blocking () with
+  | None -> raise (Eval_error "IO bridge: stdin closed while waiting for io-response")
+  | Some line ->
+    let exprs = Sx_parser.parse_all line in
+    match exprs with
+    | [List [Symbol "io-response"; value]] -> value
+    | [List (Symbol "io-response" :: values)] ->
+      (match values with
+       | [v] -> v
+       | _ -> List values)
+    | _ -> raise (Eval_error ("IO bridge: unexpected response: " ^ line))
+
+(** Bind IO primitives into the environment. *)
+let setup_io_env env =
+  let bind name fn =
+    ignore (env_bind env name (NativeFn (name, fn)))
+  in
+
+  bind "query" (fun args ->
+    match args with
+    | service :: query_name :: rest ->
+      io_request "query" (service :: query_name :: rest)
+    | _ -> raise (Eval_error "query: expected (query service name ...)"));
+
+  bind "action" (fun args ->
+    match args with
+    | service :: action_name :: rest ->
+      io_request "action" (service :: action_name :: rest)
+    | _ -> raise (Eval_error "action: expected (action service name ...)"));
+
+  bind "request-arg" (fun args ->
+    match args with
+    | [name] -> io_request "request-arg" [name]
+    | _ -> raise (Eval_error "request-arg: expected 1 arg"));
+
+  bind "request-method" (fun _args ->
+    io_request "request-method" []);
+
+  bind "ctx" (fun args ->
+    match args with
+    | [key] -> io_request "ctx" [key]
+    | _ -> raise (Eval_error "ctx: expected 1 arg"))
+
+
+(* ====================================================================== *)
+(* Environment setup                                                       *)
+(* ====================================================================== *)
+
+let make_server_env () =
+  let env = make_env () in
+
+  (* Evaluator bindings — same as run_tests.ml's make_test_env,
+     but only the ones needed for rendering (not test helpers). *)
+  let bind name fn =
+    ignore (env_bind env name (NativeFn (name, fn)))
+  in
+
+  bind "assert" (fun args ->
+    match args with
+    | [cond] ->
+      if not (sx_truthy cond) then raise (Eval_error "Assertion failed");
+      Bool true
+    | [cond; String msg] ->
+      if not (sx_truthy cond) then raise (Eval_error ("Assertion error: " ^ msg));
+      Bool true
+    | [cond; msg] ->
+      if not (sx_truthy cond) then
+        raise (Eval_error ("Assertion error: " ^ value_to_string msg));
+      Bool true
+    | _ -> raise (Eval_error "assert: expected 1-2 args"));
+
+  bind "append!" (fun args ->
+    match args with
+    | [ListRef r; v] -> r := !r @ [v]; ListRef r
+    | [List items; v] -> List (items @ [v])
+    | _ -> raise (Eval_error "append!: expected list and value"));
+
+  (* HTML renderer *)
+  Sx_render.setup_render_env env;
+
+  (* Missing primitives that may be referenced *)
+  bind "upcase" (fun args ->
+    match args with
+    | [String s] -> String (String.uppercase_ascii s)
+    | _ -> raise (Eval_error "upcase: expected string"));
+
+  bind "downcase" (fun args ->
+    match args with
+    | [String s] -> String (String.lowercase_ascii s)
+    | _ -> raise (Eval_error "downcase: expected string"));
+
+  bind "make-keyword" (fun args ->
+    match args with
+    | [String s] -> Keyword s
+    | _ -> raise (Eval_error "make-keyword: expected string"));
+
+  bind "string-length" (fun args ->
+    match args with
+    | [String s] -> Number (float_of_int (String.length s))
+    | _ -> raise (Eval_error "string-length: expected string"));
+
+  bind "dict-get" (fun args ->
+    match args with
+    | [Dict d; String k] -> dict_get d k
+    | [Dict d; Keyword k] -> dict_get d k
+    | _ -> raise (Eval_error "dict-get: expected dict and key"));
+
+  bind "apply" (fun args ->
+    match args with
+    | f :: rest ->
+      let all_args = match List.rev rest with
+        | List last :: prefix -> List.rev prefix @ last
+        | _ -> rest
+      in
+      Sx_runtime.sx_call f all_args
+    | _ -> raise (Eval_error "apply: expected function and args"));
+
+  bind "equal?" (fun args ->
+    match args with
+    | [a; b] -> Bool (a = b)
+    | _ -> raise (Eval_error "equal?: expected 2 args"));
+
+  bind "identical?" (fun args ->
+    match args with
+    | [a; b] -> Bool (a == b)
+    | _ -> raise (Eval_error "identical?: expected 2 args"));
+
+  bind "make-continuation" (fun args ->
+    match args with
+    | [f] ->
+      let k v = Sx_runtime.sx_call f [v] in
+      Continuation (k, None)
+    | _ -> raise (Eval_error "make-continuation: expected 1 arg"));
+
+  bind "continuation?" (fun args ->
+    match args with
+    | [Continuation _] -> Bool true
+    | [_] -> Bool false
+    | _ -> raise (Eval_error "continuation?: expected 1 arg"));
+
+  bind "make-symbol" (fun args ->
+    match args with
+    | [String s] -> Symbol s
+    | [v] -> Symbol (value_to_string v)
+    | _ -> raise (Eval_error "make-symbol: expected 1 arg"));
+
+  bind "sx-serialize" (fun args ->
+    match args with
+    | [v] -> String (inspect v)
+    | _ -> raise (Eval_error "sx-serialize: expected 1 arg"));
+
+  (* Env operations *)
+  bind "env-get" (fun args ->
+    match args with
+    | [Env e; String k] -> env_get e k
+    | [Env e; Keyword k] -> env_get e k
+    | _ -> raise (Eval_error "env-get: expected env and string"));
+
+  bind "env-has?" (fun args ->
+    match args with
+    | [Env e; String k] -> Bool (env_has e k)
+    | [Env e; Keyword k] -> Bool (env_has e k)
+    | _ -> raise (Eval_error "env-has?: expected env and string"));
+
+  bind "env-bind!" (fun args ->
+    match args with
+    | [Env e; String k; v] -> env_bind e k v
+    | [Env e; Keyword k; v] -> env_bind e k v
+    | _ -> raise (Eval_error "env-bind!: expected env, key, value"));
+
+  bind "env-set!" (fun args ->
+    match args with
+    | [Env e; String k; v] -> env_set e k v
+    | [Env e; Keyword k; v] -> env_set e k v
+    | _ -> raise (Eval_error "env-set!: expected env, key, value"));
+
+  bind "env-extend" (fun args ->
+    match args with
+    | [Env e] -> Env (env_extend e)
+    | _ -> raise (Eval_error "env-extend: expected env"));
+
+  bind "env-merge" (fun args ->
+    match args with
+    | [Env a; Env b] -> Env (env_merge a b)
+    | _ -> raise (Eval_error "env-merge: expected 2 envs"));
+
+  (* Strict mode state *)
+  ignore (env_bind env "*strict*" (Bool false));
+  ignore (env_bind env "*prim-param-types*" Nil);
+
+  bind "set-strict!" (fun args ->
+    match args with
+    | [v] ->
+      Sx_ref._strict_ref := v;
+      ignore (env_set env "*strict*" v); Nil
+    | _ -> raise (Eval_error "set-strict!: expected 1 arg"));
+
+  bind "set-prim-param-types!" (fun args ->
+    match args with
+    | [v] ->
+      Sx_ref._prim_param_types_ref := v;
+      ignore (env_set env "*prim-param-types*" v); Nil
+    | _ -> raise (Eval_error "set-prim-param-types!: expected 1 arg"));
+
+  bind "component-param-types" (fun _args -> Nil);
+  bind "component-set-param-types!" (fun _args -> Nil);
+
+  bind "component-params" (fun args ->
+    match args with
+    | [Component c] -> List (List.map (fun s -> String s) c.c_params)
+    | _ -> Nil);
+
+  bind "component-body" (fun args ->
+    match args with
+    | [Component c] -> c.c_body
+    | _ -> Nil);
+
+  bind "component-has-children" (fun args ->
+    match args with
+    | [Component c] -> Bool c.c_has_children
+    | _ -> Bool false);
+
+  bind "component-affinity" (fun args ->
+    match args with
+    | [Component c] -> String c.c_affinity
+    | _ -> String "auto");
+
+  bind "keyword-name" (fun args ->
+    match args with
+    | [Keyword k] -> String k
+    | _ -> raise (Eval_error "keyword-name: expected keyword"));
+
+  bind "symbol-name" (fun args ->
+    match args with
+    | [Symbol s] -> String s
+    | _ -> raise (Eval_error "symbol-name: expected symbol"));
+
+  (* IO primitives *)
+  setup_io_env env;
+
+  env
+
+
+(* ====================================================================== *)
+(* Command dispatch                                                        *)
+(* ====================================================================== *)
+
+let dispatch env cmd =
+  match cmd with
+  | List [Symbol "ping"] ->
+    send_ok_string "ocaml-cek"
+
+  | List [Symbol "load"; String path] ->
+    (try
+      let exprs = Sx_parser.parse_file path in
+      let count = ref 0 in
+      List.iter (fun expr ->
+        ignore (Sx_ref.eval_expr expr (Env env));
+        incr count
+      ) exprs;
+      send_ok_value (Number (float_of_int !count))
+    with
+    | Eval_error msg -> send_error msg
+    | Sys_error msg -> send_error ("File error: " ^ msg)
+    | exn -> send_error (Printexc.to_string exn))
+
+  | List [Symbol "load-source"; String src] ->
+    (try
+      let exprs = Sx_parser.parse_all src in
+      let count = ref 0 in
+      List.iter (fun expr ->
+        ignore (Sx_ref.eval_expr expr (Env env));
+        incr count
+      ) exprs;
+      send_ok_value (Number (float_of_int !count))
+    with
+    | Eval_error msg -> send_error msg
+    | exn -> send_error (Printexc.to_string exn))
+
+  | List [Symbol "eval"; String src] ->
+    (try
+      let exprs = Sx_parser.parse_all src in
+      let result = List.fold_left (fun _acc expr ->
+        Sx_ref.eval_expr expr (Env env)
+      ) Nil exprs in
+      send_ok_value result
+    with
+    | Eval_error msg -> send_error msg
+    | exn -> send_error (Printexc.to_string exn))
+
+  | List [Symbol "render"; String src] ->
+    (try
+      let exprs = Sx_parser.parse_all src in
+      let expr = match exprs with
+        | [e] -> e
+        | [] -> Nil
+        | _ -> List (Symbol "do" :: exprs)
+      in
+      let html = Sx_render.render_to_html expr env in
+      send_ok_string html
+    with
+    | Eval_error msg -> send_error msg
+    | exn -> send_error (Printexc.to_string exn))
+
+  | List [Symbol "reset"] ->
+    (* Clear all bindings and rebuild env.
+       We can't reassign env, so clear and re-populate. *)
+    Hashtbl.clear env.bindings;
+    let fresh = make_server_env () in
+    Hashtbl.iter (fun k v -> Hashtbl.replace env.bindings k v) fresh.bindings;
+    send_ok ()
+
+  | _ ->
+    send_error ("Unknown command: " ^ inspect cmd)
+
+
+(* ====================================================================== *)
+(* Main loop                                                               *)
+(* ====================================================================== *)
+
+let () =
+  let env = make_server_env () in
+  send "(ready)";
+  (* Main command loop *)
+  try
+    while true do
+      match read_line_blocking () with
+      | None -> exit 0  (* stdin closed *)
+      | Some line ->
+        let line = String.trim line in
+        if line = "" then ()  (* skip blank lines *)
+        else begin
+          let exprs = Sx_parser.parse_all line in
+          match exprs with
+          | [cmd] -> dispatch env cmd
+          | _ -> send_error ("Expected single command, got " ^ string_of_int (List.length exprs))
+        end
+    done
+  with
+  | End_of_file -> ()

hosts/ocaml/bootstrap.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""
+Bootstrap compiler: SX spec -> OCaml.
+
+Loads the SX-to-OCaml transpiler (transpiler.sx), feeds it the spec files,
+and produces sx_ref.ml — the transpiled evaluator as native OCaml.
+
+Usage:
+    python3 hosts/ocaml/bootstrap.py --output hosts/ocaml/lib/sx_ref.ml
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_PROJECT = os.path.abspath(os.path.join(_HERE, "..", ".."))
+sys.path.insert(0, _PROJECT)
+
+from shared.sx.parser import parse_all
+from shared.sx.types import Symbol
+
+
+def extract_defines(source: str) -> list[tuple[str, list]]:
+    """Parse .sx source, return list of (name, define-expr) for top-level defines."""
+    exprs = parse_all(source)
+    defines = []
+    for expr in exprs:
+        if isinstance(expr, list) and expr and isinstance(expr[0], Symbol):
+            if expr[0].name == "define":
+                name = expr[1].name if isinstance(expr[1], Symbol) else str(expr[1])
+                defines.append((name, expr))
+    return defines
+
+
+# OCaml preamble — opens and runtime helpers
+PREAMBLE = """\
+(* sx_ref.ml — Auto-generated from SX spec by hosts/ocaml/bootstrap.py *)
+(* Do not edit — regenerate with: python3 hosts/ocaml/bootstrap.py *)
+
+[@@@warning "-26-27"]
+
+open Sx_types
+open Sx_runtime
+
+(* Trampoline — evaluates thunks via the CEK machine.
+   eval_expr is defined in the transpiled block below. *)
+let trampoline v = v  (* CEK machine doesn't produce thunks *)
+
+"""
+
+
+# OCaml fixups — override iterative CEK run
+FIXUPS = """\
+
+(* Override recursive cek_run with iterative loop *)
+let cek_run_iterative state =
+  let s = ref state in
+  while not (match cek_terminal_p !s with Bool true -> true | _ -> false) do
+    s := cek_step !s
+  done;
+  cek_value !s
+
+"""
+
+
+def compile_spec_to_ml(spec_dir: str | None = None) -> str:
+    """Compile the SX spec to OCaml source."""
+    from shared.sx.ref.sx_ref import eval_expr, trampoline, make_env, sx_parse
+
+    if spec_dir is None:
+        spec_dir = os.path.join(_PROJECT, "spec")
+
+    # Load the transpiler
+    env = make_env()
+    transpiler_path = os.path.join(_HERE, "transpiler.sx")
+    with open(transpiler_path) as f:
+        transpiler_src = f.read()
+    for expr in sx_parse(transpiler_src):
+        trampoline(eval_expr(expr, env))
+
+    # Spec files to transpile (in dependency order)
+    sx_files = [
+        ("evaluator.sx", "evaluator (frames + eval + CEK)"),
+    ]
+
+    parts = [PREAMBLE]
+
+    for filename, label in sx_files:
+        filepath = os.path.join(spec_dir, filename)
+        if not os.path.exists(filepath):
+            print(f"Warning: {filepath} not found, skipping", file=sys.stderr)
+            continue
+
+        with open(filepath) as f:
+            src = f.read()
+        defines = extract_defines(src)
+
+        # Skip defines provided by preamble or fixups
+        skip = {"trampoline"}
+        defines = [(n, e) for n, e in defines if n not in skip]
+
+        # Deduplicate — keep last definition for each name (CEK overrides tree-walk)
+        seen = {}
+        for i, (n, e) in enumerate(defines):
+            seen[n] = i
+        defines = [(n, e) for i, (n, e) in enumerate(defines) if seen[n] == i]
+
+        # Build the defines list for the transpiler
+        defines_list = [[name, expr] for name, expr in defines]
+        env["_defines"] = defines_list
+
+        # Pass known define names so the transpiler can distinguish
+        # static (OCaml fn) calls from dynamic (SX value) calls
+        env["_known_defines"] = [name for name, _ in defines]
+
+        # Call ml-translate-file — emits as single let rec block
+        translate_expr = sx_parse("(ml-translate-file _defines)")[0]
+        result = trampoline(eval_expr(translate_expr, env))
+
+        parts.append(f"\n(* === Transpiled from {label} === *)\n")
+        parts.append(result)
+
+    parts.append(FIXUPS)
+    return "\n".join(parts)
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Bootstrap SX spec -> OCaml")
+    parser.add_argument(
+        "--output", "-o",
+        default=None,
+        help="Output file (default: stdout)",
+    )
+    args = parser.parse_args()
+
+    result = compile_spec_to_ml()
+
+    if args.output:
+        with open(args.output, "w") as f:
+            f.write(result)
+        size = os.path.getsize(args.output)
+        print(f"Wrote {args.output} ({size} bytes)", file=sys.stderr)
+    else:
+        print(result)
+
+
+if __name__ == "__main__":
+    main()

hosts/ocaml/dune-project

@@ -0,0 +1,2 @@
+(lang dune 3.0)
+(name sx)

hosts/ocaml/lib/dune

@@ -0,0 +1,2 @@
+(library
+ (name sx))

hosts/ocaml/lib/sx_parser.ml

@@ -0,0 +1,206 @@
+(** S-expression parser.
+
+    Recursive descent over a string, producing [Sx_types.value list].
+    Supports: lists, dicts, symbols, keywords, strings (with escapes),
+    numbers, booleans, nil, comments, quote/quasiquote/unquote sugar. *)
+
+open Sx_types
+
+type state = {
+  src : string;
+  len : int;
+  mutable pos : int;
+}
+
+let make_state src = { src; len = String.length src; pos = 0 }
+
+let peek s = if s.pos < s.len then Some s.src.[s.pos] else None
+let advance s = s.pos <- s.pos + 1
+let at_end s = s.pos >= s.len
+
+let skip_whitespace_and_comments s =
+  let rec go () =
+    if at_end s then ()
+    else match s.src.[s.pos] with
+    | ' ' | '\t' | '\n' | '\r' -> advance s; go ()
+    | ';' ->
+      while s.pos < s.len && s.src.[s.pos] <> '\n' do advance s done;
+      if s.pos < s.len then advance s;
+      go ()
+    | _ -> ()
+  in go ()
+
+let is_symbol_char = function
+  | '(' | ')' | '[' | ']' | '{' | '}' | '"' | '\'' | '`'
+  | ' ' | '\t' | '\n' | '\r' | ',' | ';' -> false
+  | _ -> true
+
+let read_string s =
+  (* s.pos is on the opening quote *)
+  advance s;
+  let buf = Buffer.create 64 in
+  let rec go () =
+    if at_end s then raise (Parse_error "Unterminated string");
+    let c = s.src.[s.pos] in
+    advance s;
+    if c = '"' then Buffer.contents buf
+    else if c = '\\' then begin
+      if at_end s then raise (Parse_error "Unterminated string escape");
+      let esc = s.src.[s.pos] in
+      advance s;
+      (match esc with
+       | 'n' -> Buffer.add_char buf '\n'
+       | 't' -> Buffer.add_char buf '\t'
+       | 'r' -> Buffer.add_char buf '\r'
+       | '"' -> Buffer.add_char buf '"'
+       | '\\' -> Buffer.add_char buf '\\'
+       | 'u' ->
+         (* \uXXXX — read 4 hex digits, encode as UTF-8 *)
+         if s.pos + 4 > s.len then raise (Parse_error "Incomplete \\u escape");
+         let hex = String.sub s.src s.pos 4 in
+         s.pos <- s.pos + 4;
+         let code = int_of_string ("0x" ^ hex) in
+         let ubuf = Buffer.create 4 in
+         Buffer.add_utf_8_uchar ubuf (Uchar.of_int code);
+         Buffer.add_string buf (Buffer.contents ubuf)
+       | '`' -> Buffer.add_char buf '`'
+       | _ -> Buffer.add_char buf '\\'; Buffer.add_char buf esc);
+      go ()
+    end else begin
+      Buffer.add_char buf c;
+      go ()
+    end
+  in go ()
+
+let read_symbol s =
+  let start = s.pos in
+  while s.pos < s.len && is_symbol_char s.src.[s.pos] do advance s done;
+  String.sub s.src start (s.pos - start)
+
+let try_number str =
+  match float_of_string_opt str with
+  | Some n -> Some (Number n)
+  | None -> None
+
+let rec read_value s : value =
+  skip_whitespace_and_comments s;
+  if at_end s then raise (Parse_error "Unexpected end of input");
+  match s.src.[s.pos] with
+  | '(' -> read_list s ')'
+  | '[' -> read_list s ']'
+  | '{' -> read_dict s
+  | '"' -> String (read_string s)
+  | '\'' -> advance s; List [Symbol "quote"; read_value s]
+  | '`' -> advance s; List [Symbol "quasiquote"; read_value s]
+  | '#' when s.pos + 1 < s.len && s.src.[s.pos + 1] = ';' ->
+    (* Datum comment: #; discards next expression *)
+    advance s; advance s;
+    ignore (read_value s);
+    read_value s
+  | '#' when s.pos + 1 < s.len && s.src.[s.pos + 1] = '\'' ->
+    (* Quote shorthand: #'expr -> (quote expr) *)
+    advance s; advance s;
+    List [Symbol "quote"; read_value s]
+  | '#' when s.pos + 1 < s.len && s.src.[s.pos + 1] = '|' ->
+    (* Raw string: #|...|  — ends at next | *)
+    advance s; advance s;
+    let buf = Buffer.create 64 in
+    let rec go () =
+      if at_end s then raise (Parse_error "Unterminated raw string");
+      let c = s.src.[s.pos] in
+      advance s;
+      if c = '|' then
+        String (Buffer.contents buf)
+      else begin
+        Buffer.add_char buf c;
+        go ()
+      end
+    in go ()
+  | '~' when s.pos + 1 < s.len && s.src.[s.pos + 1] = '@' ->
+    advance s; advance s; (* skip ~@ *)
+    List [Symbol "splice-unquote"; read_value s]
+  | _ ->
+    (* Check for unquote: , followed by non-whitespace *)
+    if s.src.[s.pos] = ',' && s.pos + 1 < s.len &&
+       s.src.[s.pos + 1] <> ' ' && s.src.[s.pos + 1] <> '\n' then begin
+      advance s;
+      if s.pos < s.len && s.src.[s.pos] = '@' then begin
+        advance s;
+        List [Symbol "splice-unquote"; read_value s]
+      end else
+        List [Symbol "unquote"; read_value s]
+    end else begin
+      (* Symbol, keyword, number, or boolean *)
+      let token = read_symbol s in
+      if token = "" then raise (Parse_error ("Unexpected char: " ^ String.make 1 s.src.[s.pos]));
+      match token with
+      | "true" -> Bool true
+      | "false" -> Bool false
+      | "nil" -> Nil
+      | _ when token.[0] = ':' ->
+        Keyword (String.sub token 1 (String.length token - 1))
+      | _ ->
+        match try_number token with
+        | Some n -> n
+        | None -> Symbol token
+    end
+
+and read_list s close_char =
+  advance s; (* skip opening paren/bracket *)
+  let items = ref [] in
+  let rec go () =
+    skip_whitespace_and_comments s;
+    if at_end s then raise (Parse_error "Unterminated list");
+    if s.src.[s.pos] = close_char then begin
+      advance s;
+      List (List.rev !items)
+    end else begin
+      items := read_value s :: !items;
+      go ()
+    end
+  in go ()
+
+and read_dict s =
+  advance s; (* skip { *)
+  let d = make_dict () in
+  let rec go () =
+    skip_whitespace_and_comments s;
+    if at_end s then raise (Parse_error "Unterminated dict");
+    if s.src.[s.pos] = '}' then begin
+      advance s;
+      Dict d
+    end else begin
+      let key = read_value s in
+      let key_str = match key with
+        | Keyword k -> k
+        | String k -> k
+        | Symbol k -> k
+        | _ -> raise (Parse_error "Dict key must be keyword, string, or symbol")
+      in
+      let v = read_value s in
+      dict_set d key_str v;
+      go ()
+    end
+  in go ()
+
+
+(** Parse a string into a list of SX values. *)
+let parse_all src =
+  let s = make_state src in
+  let results = ref [] in
+  let rec go () =
+    skip_whitespace_and_comments s;
+    if at_end s then List.rev !results
+    else begin
+      results := read_value s :: !results;
+      go ()
+    end
+  in go ()
+
+(** Parse a file into a list of SX values. *)
+let parse_file path =
+  let ic = open_in path in
+  let n = in_channel_length ic in
+  let src = really_input_string ic n in
+  close_in ic;
+  parse_all src

hosts/ocaml/lib/sx_primitives.ml

@@ -0,0 +1,578 @@
+(** Built-in primitive functions (~80 pure functions).
+
+    Registered in a global table; the evaluator checks this table
+    when a symbol isn't found in the lexical environment. *)
+
+open Sx_types
+
+let primitives : (string, value list -> value) Hashtbl.t = Hashtbl.create 128
+
+let register name fn = Hashtbl.replace primitives name fn
+
+let is_primitive name = Hashtbl.mem primitives name
+
+let get_primitive name =
+  match Hashtbl.find_opt primitives name with
+  | Some fn -> NativeFn (name, fn)
+  | None -> raise (Eval_error ("Unknown primitive: " ^ name))
+
+(* --- Helpers --- *)
+
+let as_number = function
+  | Number n -> n
+  | Bool true -> 1.0
+  | Bool false -> 0.0
+  | Nil -> 0.0
+  | String s -> (match float_of_string_opt s with Some n -> n | None -> Float.nan)
+  | v -> raise (Eval_error ("Expected number, got " ^ type_of v))
+
+let as_string = function
+  | String s -> s
+  | v -> raise (Eval_error ("Expected string, got " ^ type_of v))
+
+let as_list = function
+  | List l -> l
+  | ListRef r -> !r
+  | Nil -> []
+  | v -> raise (Eval_error ("Expected list, got " ^ type_of v))
+
+let as_bool = function
+  | Bool b -> b
+  | v -> sx_truthy v
+
+let to_string = function
+  | String s -> s
+  | Number n ->
+    if Float.is_integer n then string_of_int (int_of_float n)
+    else Printf.sprintf "%g" n
+  | Bool true -> "true"
+  | Bool false -> "false"
+  | Nil -> ""
+  | Symbol s -> s
+  | Keyword k -> k
+  | v -> inspect v
+
+let () =
+  (* === Arithmetic === *)
+  register "+" (fun args ->
+    Number (List.fold_left (fun acc a -> acc +. as_number a) 0.0 args));
+  register "-" (fun args ->
+    match args with
+    | [] -> Number 0.0
+    | [a] -> Number (-. (as_number a))
+    | a :: rest -> Number (List.fold_left (fun acc x -> acc -. as_number x) (as_number a) rest));
+  register "*" (fun args ->
+    Number (List.fold_left (fun acc a -> acc *. as_number a) 1.0 args));
+  register "/" (fun args ->
+    match args with
+    | [a; b] -> Number (as_number a /. as_number b)
+    | _ -> raise (Eval_error "/: expected 2 args"));
+  register "mod" (fun args ->
+    match args with
+    | [a; b] -> Number (Float.rem (as_number a) (as_number b))
+    | _ -> raise (Eval_error "mod: expected 2 args"));
+  register "inc" (fun args ->
+    match args with [a] -> Number (as_number a +. 1.0) | _ -> raise (Eval_error "inc: 1 arg"));
+  register "dec" (fun args ->
+    match args with [a] -> Number (as_number a -. 1.0) | _ -> raise (Eval_error "dec: 1 arg"));
+  register "abs" (fun args ->
+    match args with [a] -> Number (Float.abs (as_number a)) | _ -> raise (Eval_error "abs: 1 arg"));
+  register "floor" (fun args ->
+    match args with [a] -> Number (Float.of_int (int_of_float (Float.round (as_number a -. 0.5))))
+    | _ -> raise (Eval_error "floor: 1 arg"));
+  register "ceil" (fun args ->
+    match args with [a] -> Number (Float.of_int (int_of_float (Float.round (as_number a +. 0.5))))
+    | _ -> raise (Eval_error "ceil: 1 arg"));
+  register "round" (fun args ->
+    match args with
+    | [a] -> Number (Float.round (as_number a))
+    | [a; b] ->
+      let n = as_number a and places = int_of_float (as_number b) in
+      let factor = 10.0 ** float_of_int places in
+      Number (Float.round (n *. factor) /. factor)
+    | _ -> raise (Eval_error "round: 1-2 args"));
+  register "min" (fun args ->
+    match args with
+    | [] -> raise (Eval_error "min: at least 1 arg")
+    | _ -> Number (List.fold_left (fun acc a -> Float.min acc (as_number a)) Float.infinity args));
+  register "max" (fun args ->
+    match args with
+    | [] -> raise (Eval_error "max: at least 1 arg")
+    | _ -> Number (List.fold_left (fun acc a -> Float.max acc (as_number a)) Float.neg_infinity args));
+  register "sqrt" (fun args ->
+    match args with [a] -> Number (Float.sqrt (as_number a)) | _ -> raise (Eval_error "sqrt: 1 arg"));
+  register "pow" (fun args ->
+    match args with [a; b] -> Number (as_number a ** as_number b)
+    | _ -> raise (Eval_error "pow: 2 args"));
+  register "clamp" (fun args ->
+    match args with
+    | [x; lo; hi] ->
+      let x = as_number x and lo = as_number lo and hi = as_number hi in
+      Number (Float.max lo (Float.min hi x))
+    | _ -> raise (Eval_error "clamp: 3 args"));
+  register "parse-int" (fun args ->
+    match args with
+    | [String s] -> (match int_of_string_opt s with Some n -> Number (float_of_int n) | None -> Nil)
+    | [Number n] -> Number (float_of_int (int_of_float n))
+    | _ -> Nil);
+  register "parse-float" (fun args ->
+    match args with
+    | [String s] -> (match float_of_string_opt s with Some n -> Number n | None -> Nil)
+    | [Number n] -> Number n
+    | _ -> Nil);
+
+  (* === Comparison === *)
+  (* Normalize ListRef to List for structural equality *)
+  let rec normalize_for_eq = function
+    | ListRef { contents = items } -> List (List.map normalize_for_eq items)
+    | List items -> List (List.map normalize_for_eq items)
+    | v -> v
+  in
+  register "=" (fun args ->
+    match args with
+    | [a; b] -> Bool (normalize_for_eq a = normalize_for_eq b)
+    | _ -> raise (Eval_error "=: 2 args"));
+  register "!=" (fun args ->
+    match args with
+    | [a; b] -> Bool (normalize_for_eq a <> normalize_for_eq b)
+    | _ -> raise (Eval_error "!=: 2 args"));
+  register "<" (fun args ->
+    match args with
+    | [String a; String b] -> Bool (a < b)
+    | [a; b] -> Bool (as_number a < as_number b)
+    | _ -> raise (Eval_error "<: 2 args"));
+  register ">" (fun args ->
+    match args with
+    | [String a; String b] -> Bool (a > b)
+    | [a; b] -> Bool (as_number a > as_number b)
+    | _ -> raise (Eval_error ">: 2 args"));
+  register "<=" (fun args ->
+    match args with
+    | [String a; String b] -> Bool (a <= b)
+    | [a; b] -> Bool (as_number a <= as_number b)
+    | _ -> raise (Eval_error "<=: 2 args"));
+  register ">=" (fun args ->
+    match args with
+    | [String a; String b] -> Bool (a >= b)
+    | [a; b] -> Bool (as_number a >= as_number b)
+    | _ -> raise (Eval_error ">=: 2 args"));
+
+  (* === Logic === *)
+  register "not" (fun args ->
+    match args with [a] -> Bool (not (sx_truthy a)) | _ -> raise (Eval_error "not: 1 arg"));
+
+  (* === Predicates === *)
+  register "nil?" (fun args ->
+    match args with [a] -> Bool (is_nil a) | _ -> raise (Eval_error "nil?: 1 arg"));
+  register "number?" (fun args ->
+    match args with [Number _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "number?: 1 arg"));
+  register "string?" (fun args ->
+    match args with [String _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "string?: 1 arg"));
+  register "boolean?" (fun args ->
+    match args with [Bool _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "boolean?: 1 arg"));
+  register "list?" (fun args ->
+    match args with [List _] | [ListRef _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "list?: 1 arg"));
+  register "dict?" (fun args ->
+    match args with [Dict _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "dict?: 1 arg"));
+  register "symbol?" (fun args ->
+    match args with [Symbol _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "symbol?: 1 arg"));
+  register "keyword?" (fun args ->
+    match args with [Keyword _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "keyword?: 1 arg"));
+  register "empty?" (fun args ->
+    match args with
+    | [List []] | [ListRef { contents = [] }] -> Bool true
+    | [List _] | [ListRef _] -> Bool false
+    | [String ""] -> Bool true | [String _] -> Bool false
+    | [Dict d] -> Bool (Hashtbl.length d = 0)
+    | [Nil] -> Bool true
+    | [_] -> Bool false
+    | _ -> raise (Eval_error "empty?: 1 arg"));
+  register "odd?" (fun args ->
+    match args with [a] -> Bool (int_of_float (as_number a) mod 2 <> 0) | _ -> raise (Eval_error "odd?: 1 arg"));
+  register "even?" (fun args ->
+    match args with [a] -> Bool (int_of_float (as_number a) mod 2 = 0) | _ -> raise (Eval_error "even?: 1 arg"));
+  register "zero?" (fun args ->
+    match args with [a] -> Bool (as_number a = 0.0) | _ -> raise (Eval_error "zero?: 1 arg"));
+
+  (* === Strings === *)
+  register "str" (fun args -> String (String.concat "" (List.map to_string args)));
+  register "upper" (fun args ->
+    match args with [a] -> String (String.uppercase_ascii (as_string a)) | _ -> raise (Eval_error "upper: 1 arg"));
+  register "upcase" (fun args ->
+    match args with [a] -> String (String.uppercase_ascii (as_string a)) | _ -> raise (Eval_error "upcase: 1 arg"));
+  register "lower" (fun args ->
+    match args with [a] -> String (String.lowercase_ascii (as_string a)) | _ -> raise (Eval_error "lower: 1 arg"));
+  register "downcase" (fun args ->
+    match args with [a] -> String (String.lowercase_ascii (as_string a)) | _ -> raise (Eval_error "downcase: 1 arg"));
+  register "trim" (fun args ->
+    match args with [a] -> String (String.trim (as_string a)) | _ -> raise (Eval_error "trim: 1 arg"));
+  register "string-length" (fun args ->
+    match args with [a] -> Number (float_of_int (String.length (as_string a)))
+    | _ -> raise (Eval_error "string-length: 1 arg"));
+  register "string-contains?" (fun args ->
+    match args with
+    | [String haystack; String needle] ->
+      let rec find i =
+        if i + String.length needle > String.length haystack then false
+        else if String.sub haystack i (String.length needle) = needle then true
+        else find (i + 1)
+      in Bool (find 0)
+    | _ -> raise (Eval_error "string-contains?: 2 string args"));
+  register "starts-with?" (fun args ->
+    match args with
+    | [String s; String prefix] ->
+      Bool (String.length s >= String.length prefix &&
+            String.sub s 0 (String.length prefix) = prefix)
+    | _ -> raise (Eval_error "starts-with?: 2 string args"));
+  register "ends-with?" (fun args ->
+    match args with
+    | [String s; String suffix] ->
+      let sl = String.length s and xl = String.length suffix in
+      Bool (sl >= xl && String.sub s (sl - xl) xl = suffix)
+    | _ -> raise (Eval_error "ends-with?: 2 string args"));
+  register "index-of" (fun args ->
+    match args with
+    | [String haystack; String needle] ->
+      let nl = String.length needle and hl = String.length haystack in
+      let rec find i =
+        if i + nl > hl then Number (-1.0)
+        else if String.sub haystack i nl = needle then Number (float_of_int i)
+        else find (i + 1)
+      in find 0
+    | _ -> raise (Eval_error "index-of: 2 string args"));
+  register "substring" (fun args ->
+    match args with
+    | [String s; Number start; Number end_] ->
+      let i = int_of_float start and j = int_of_float end_ in
+      let len = String.length s in
+      let i = max 0 (min i len) and j = max 0 (min j len) in
+      String (String.sub s i (max 0 (j - i)))
+    | _ -> raise (Eval_error "substring: 3 args"));
+  register "substr" (fun args ->
+    match args with
+    | [String s; Number start; Number len] ->
+      let i = int_of_float start and n = int_of_float len in
+      let sl = String.length s in
+      let i = max 0 (min i sl) in
+      let n = max 0 (min n (sl - i)) in
+      String (String.sub s i n)
+    | [String s; Number start] ->
+      let i = int_of_float start in
+      let sl = String.length s in
+      let i = max 0 (min i sl) in
+      String (String.sub s i (sl - i))
+    | _ -> raise (Eval_error "substr: 2-3 args"));
+  register "split" (fun args ->
+    match args with
+    | [String s; String sep] ->
+      List (List.map (fun p -> String p) (String.split_on_char sep.[0] s))
+    | _ -> raise (Eval_error "split: 2 args"));
+  register "join" (fun args ->
+    match args with
+    | [String sep; (List items | ListRef { contents = items })] ->
+      String (String.concat sep (List.map to_string items))
+    | _ -> raise (Eval_error "join: 2 args"));
+  register "replace" (fun args ->
+    match args with
+    | [String s; String old_s; String new_s] ->
+      let ol = String.length old_s in
+      if ol = 0 then String s
+      else begin
+        let buf = Buffer.create (String.length s) in
+        let rec go i =
+          if i >= String.length s then ()
+          else if i + ol <= String.length s && String.sub s i ol = old_s then begin
+            Buffer.add_string buf new_s;
+            go (i + ol)
+          end else begin
+            Buffer.add_char buf s.[i];
+            go (i + 1)
+          end
+        in go 0;
+        String (Buffer.contents buf)
+      end
+    | _ -> raise (Eval_error "replace: 3 string args"));
+  register "char-from-code" (fun args ->
+    match args with
+    | [Number n] ->
+      let buf = Buffer.create 4 in
+      Buffer.add_utf_8_uchar buf (Uchar.of_int (int_of_float n));
+      String (Buffer.contents buf)
+    | _ -> raise (Eval_error "char-from-code: 1 arg"));
+
+  (* === Collections === *)
+  register "list" (fun args -> ListRef (ref args));
+  register "len" (fun args ->
+    match args with
+    | [List l] | [ListRef { contents = l }] -> Number (float_of_int (List.length l))
+    | [String s] -> Number (float_of_int (String.length s))
+    | [Dict d] -> Number (float_of_int (Hashtbl.length d))
+    | [Nil] -> Number 0.0
+    | _ -> raise (Eval_error "len: 1 arg"));
+  register "first" (fun args ->
+    match args with
+    | [List (x :: _)] | [ListRef { contents = x :: _ }] -> x
+    | [List []] | [ListRef { contents = [] }] -> Nil | [Nil] -> Nil
+    | _ -> raise (Eval_error "first: 1 list arg"));
+  register "rest" (fun args ->
+    match args with
+    | [List (_ :: xs)] | [ListRef { contents = _ :: xs }] -> List xs
+    | [List []] | [ListRef { contents = [] }] -> List [] | [Nil] -> List []
+    | _ -> raise (Eval_error "rest: 1 list arg"));
+  register "last" (fun args ->
+    match args with
+    | [List l] | [ListRef { contents = l }] ->
+      (match List.rev l with x :: _ -> x | [] -> Nil)
+    | _ -> raise (Eval_error "last: 1 list arg"));
+  register "nth" (fun args ->
+    match args with
+    | [List l; Number n] | [ListRef { contents = l }; Number n] ->
+      (try List.nth l (int_of_float n) with _ -> Nil)
+    | _ -> raise (Eval_error "nth: list and number"));
+  register "cons" (fun args ->
+    match args with
+    | [x; List l] | [x; ListRef { contents = l }] -> List (x :: l)
+    | [x; Nil] -> List [x]
+    | _ -> raise (Eval_error "cons: value and list"));
+  register "append" (fun args ->
+    let all = List.concat_map (fun a -> as_list a) args in
+    List all);
+  register "reverse" (fun args ->
+    match args with
+    | [List l] | [ListRef { contents = l }] -> List (List.rev l)
+    | _ -> raise (Eval_error "reverse: 1 list"));
+  register "flatten" (fun args ->
+    let rec flat = function
+      | List items | ListRef { contents = items } -> List.concat_map flat items
+      | x -> [x]
+    in
+    match args with
+    | [List l] | [ListRef { contents = l }] -> List (List.concat_map flat l)
+    | _ -> raise (Eval_error "flatten: 1 list"));
+  register "concat" (fun args -> List (List.concat_map as_list args));
+  register "contains?" (fun args ->
+    match args with
+    | [List l; item] | [ListRef { contents = l }; item] -> Bool (List.mem item l)
+    | [String s; String sub] ->
+      let rec find i =
+        if i + String.length sub > String.length s then false
+        else if String.sub s i (String.length sub) = sub then true
+        else find (i + 1)
+      in Bool (find 0)
+    | _ -> raise (Eval_error "contains?: 2 args"));
+  register "range" (fun args ->
+    match args with
+    | [Number stop] ->
+      let n = int_of_float stop in
+      List (List.init (max 0 n) (fun i -> Number (float_of_int i)))
+    | [Number start; Number stop] ->
+      let s = int_of_float start and e = int_of_float stop in
+      let len = max 0 (e - s) in
+      List (List.init len (fun i -> Number (float_of_int (s + i))))
+    | [Number start; Number stop; Number step] ->
+      let s = start and e = stop and st = step in
+      if st = 0.0 then List []
+      else
+        let items = ref [] in
+        let i = ref s in
+        if st > 0.0 then
+          (while !i < e do items := Number !i :: !items; i := !i +. st done)
+        else
+          (while !i > e do items := Number !i :: !items; i := !i +. st done);
+        List (List.rev !items)
+    | _ -> raise (Eval_error "range: 1-3 args"));
+  register "slice" (fun args ->
+    match args with
+    | [(List l | ListRef { contents = l }); Number start] ->
+      let i = max 0 (int_of_float start) in
+      let rec drop n = function _ :: xs when n > 0 -> drop (n-1) xs | l -> l in
+      List (drop i l)
+    | [(List l | ListRef { contents = l }); Number start; Number end_] ->
+      let i = max 0 (int_of_float start) and j = int_of_float end_ in
+      let len = List.length l in
+      let j = min j len in
+      let rec take_range idx = function
+        | [] -> []
+        | x :: xs ->
+          if idx >= j then []
+          else if idx >= i then x :: take_range (idx+1) xs
+          else take_range (idx+1) xs
+      in List (take_range 0 l)
+    | [String s; Number start] ->
+      let i = max 0 (int_of_float start) in
+      String (String.sub s i (max 0 (String.length s - i)))
+    | [String s; Number start; Number end_] ->
+      let i = max 0 (int_of_float start) and j = int_of_float end_ in
+      let sl = String.length s in
+      let j = min j sl in
+      String (String.sub s i (max 0 (j - i)))
+    | _ -> raise (Eval_error "slice: 2-3 args"));
+  register "sort" (fun args ->
+    match args with
+    | [List l] | [ListRef { contents = l }] -> List (List.sort compare l)
+    | _ -> raise (Eval_error "sort: 1 list"));
+  register "zip" (fun args ->
+    match args with
+    | [a; b] ->
+      let la = as_list a and lb = as_list b in
+      let rec go l1 l2 acc = match l1, l2 with
+        | x :: xs, y :: ys -> go xs ys (List [x; y] :: acc)
+        | _ -> List.rev acc
+      in List (go la lb [])
+    | _ -> raise (Eval_error "zip: 2 lists"));
+  register "zip-pairs" (fun args ->
+    match args with
+    | [v] ->
+      let l = as_list v in
+      let rec go = function
+        | a :: b :: rest -> List [a; b] :: go rest
+        | _ -> []
+      in List (go l)
+    | _ -> raise (Eval_error "zip-pairs: 1 list"));
+  register "take" (fun args ->
+    match args with
+    | [(List l | ListRef { contents = l }); Number n] ->
+      let rec take_n i = function
+        | x :: xs when i > 0 -> x :: take_n (i-1) xs
+        | _ -> []
+      in List (take_n (int_of_float n) l)
+    | _ -> raise (Eval_error "take: list and number"));
+  register "drop" (fun args ->
+    match args with
+    | [(List l | ListRef { contents = l }); Number n] ->
+      let rec drop_n i = function
+        | _ :: xs when i > 0 -> drop_n (i-1) xs
+        | l -> l
+      in List (drop_n (int_of_float n) l)
+    | _ -> raise (Eval_error "drop: list and number"));
+  register "chunk-every" (fun args ->
+    match args with
+    | [(List l | ListRef { contents = l }); Number n] ->
+      let size = int_of_float n in
+      let rec go = function
+        | [] -> []
+        | l ->
+          let rec take_n i = function
+            | x :: xs when i > 0 -> x :: take_n (i-1) xs
+            | _ -> []
+          in
+          let rec drop_n i = function
+            | _ :: xs when i > 0 -> drop_n (i-1) xs
+            | l -> l
+          in
+          List (take_n size l) :: go (drop_n size l)
+      in List (go l)
+    | _ -> raise (Eval_error "chunk-every: list and number"));
+  register "unique" (fun args ->
+    match args with
+    | [(List l | ListRef { contents = l })] ->
+      let seen = Hashtbl.create 16 in
+      let result = List.filter (fun x ->
+        let key = inspect x in
+        if Hashtbl.mem seen key then false
+        else (Hashtbl.replace seen key true; true)
+      ) l in
+      List result
+    | _ -> raise (Eval_error "unique: 1 list"));
+
+  (* === Dict === *)
+  register "dict" (fun args ->
+    let d = make_dict () in
+    let rec go = function
+      | [] -> Dict d
+      | Keyword k :: v :: rest -> dict_set d k v; go rest
+      | String k :: v :: rest -> dict_set d k v; go rest
+      | _ -> raise (Eval_error "dict: pairs of key value")
+    in go args);
+  register "get" (fun args ->
+    match args with
+    | [Dict d; String k] -> dict_get d k
+    | [Dict d; Keyword k] -> dict_get d k
+    | [List l; Number n] | [ListRef { contents = l }; Number n] ->
+      (try List.nth l (int_of_float n) with _ -> Nil)
+    | _ -> raise (Eval_error "get: dict+key or list+index"));
+  register "has-key?" (fun args ->
+    match args with
+    | [Dict d; String k] -> Bool (dict_has d k)
+    | [Dict d; Keyword k] -> Bool (dict_has d k)
+    | _ -> raise (Eval_error "has-key?: dict and key"));
+  register "assoc" (fun args ->
+    match args with
+    | Dict d :: rest ->
+      let d2 = Hashtbl.copy d in
+      let rec go = function
+        | [] -> Dict d2
+        | String k :: v :: rest -> Hashtbl.replace d2 k v; go rest
+        | Keyword k :: v :: rest -> Hashtbl.replace d2 k v; go rest
+        | _ -> raise (Eval_error "assoc: pairs")
+      in go rest
+    | _ -> raise (Eval_error "assoc: dict + pairs"));
+  register "dissoc" (fun args ->
+    match args with
+    | Dict d :: keys ->
+      let d2 = Hashtbl.copy d in
+      List.iter (fun k -> Hashtbl.remove d2 (to_string k)) keys;
+      Dict d2
+    | _ -> raise (Eval_error "dissoc: dict + keys"));
+  register "merge" (fun args ->
+    let d = make_dict () in
+    List.iter (function
+      | Dict src -> Hashtbl.iter (fun k v -> Hashtbl.replace d k v) src
+      | _ -> raise (Eval_error "merge: all args must be dicts")
+    ) args;
+    Dict d);
+  register "keys" (fun args ->
+    match args with [Dict d] -> List (dict_keys d) | _ -> raise (Eval_error "keys: 1 dict"));
+  register "vals" (fun args ->
+    match args with [Dict d] -> List (dict_vals d) | _ -> raise (Eval_error "vals: 1 dict"));
+  register "dict-set!" (fun args ->
+    match args with
+    | [Dict d; String k; v] -> dict_set d k v; v
+    | [Dict d; Keyword k; v] -> dict_set d k v; v
+    | _ -> raise (Eval_error "dict-set!: dict key val"));
+  register "dict-get" (fun args ->
+    match args with
+    | [Dict d; String k] -> dict_get d k
+    | [Dict d; Keyword k] -> dict_get d k
+    | _ -> raise (Eval_error "dict-get: dict and key"));
+  register "dict-has?" (fun args ->
+    match args with
+    | [Dict d; String k] -> Bool (dict_has d k)
+    | _ -> raise (Eval_error "dict-has?: dict and key"));
+  register "dict-delete!" (fun args ->
+    match args with
+    | [Dict d; String k] -> dict_delete d k; Nil
+    | _ -> raise (Eval_error "dict-delete!: dict and key"));
+
+  (* === Misc === *)
+  register "type-of" (fun args ->
+    match args with [a] -> String (type_of a) | _ -> raise (Eval_error "type-of: 1 arg"));
+  register "inspect" (fun args ->
+    match args with [a] -> String (inspect a) | _ -> raise (Eval_error "inspect: 1 arg"));
+  register "error" (fun args ->
+    match args with [String msg] -> raise (Eval_error msg)
+    | [a] -> raise (Eval_error (to_string a))
+    | _ -> raise (Eval_error "error: 1 arg"));
+  register "apply" (fun args ->
+    match args with
+    | [NativeFn (_, f); List a] -> f a
+    | _ -> raise (Eval_error "apply: function and list"));
+  register "identical?" (fun args ->
+    match args with [a; b] -> Bool (a == b) | _ -> raise (Eval_error "identical?: 2 args"));
+  register "make-spread" (fun args ->
+    match args with
+    | [Dict d] ->
+      let pairs = Hashtbl.fold (fun k v acc -> (k, v) :: acc) d [] in
+      Spread pairs
+    | _ -> raise (Eval_error "make-spread: 1 dict"));
+  register "spread?" (fun args ->
+    match args with [Spread _] -> Bool true | [_] -> Bool false
+    | _ -> raise (Eval_error "spread?: 1 arg"));
+  register "spread-attrs" (fun args ->
+    match args with
+    | [Spread pairs] ->
+      let d = make_dict () in
+      List.iter (fun (k, v) -> dict_set d k v) pairs;
+      Dict d
+    | _ -> raise (Eval_error "spread-attrs: 1 spread"));
+  ()

hosts/ocaml/lib/sx_render.ml

@@ -0,0 +1,435 @@
+(** HTML renderer for SX values.
+
+    Extracted from run_tests.ml — renders an SX expression tree to an
+    HTML string, expanding components and macros along the way.
+
+    Depends on [Sx_ref.eval_expr] for evaluating sub-expressions
+    during rendering (keyword arg values, conditionals, etc.). *)
+
+open Sx_types
+
+(* ====================================================================== *)
+(* Tag / attribute registries                                              *)
+(* ====================================================================== *)
+
+let html_tags = [
+  "html"; "head"; "body"; "title"; "meta"; "link"; "script"; "style"; "noscript";
+  "header"; "nav"; "main"; "section"; "article"; "aside"; "footer";
+  "h1"; "h2"; "h3"; "h4"; "h5"; "h6"; "hgroup";
+  "div"; "p"; "blockquote"; "pre"; "figure"; "figcaption"; "address"; "hr";
+  "ul"; "ol"; "li"; "dl"; "dt"; "dd"; "menu";
+  "a"; "span"; "em"; "strong"; "small"; "b"; "i"; "u"; "s"; "sub"; "sup";
+  "mark"; "del"; "ins"; "q"; "cite"; "dfn"; "abbr"; "code"; "var"; "samp";
+  "kbd"; "data"; "time"; "ruby"; "rt"; "rp"; "bdi"; "bdo"; "wbr"; "br";
+  "table"; "thead"; "tbody"; "tfoot"; "tr"; "th"; "td"; "caption"; "colgroup"; "col";
+  "form"; "input"; "textarea"; "select"; "option"; "optgroup"; "button"; "label";
+  "fieldset"; "legend"; "datalist"; "output"; "progress"; "meter";
+  "details"; "summary"; "dialog";
+  "img"; "video"; "audio"; "source"; "picture"; "canvas"; "iframe"; "embed"; "object"; "param";
+  "svg"; "path"; "circle"; "rect"; "line"; "polyline"; "polygon"; "ellipse";
+  "g"; "defs"; "use"; "text"; "tspan"; "clipPath"; "mask"; "pattern";
+  "linearGradient"; "radialGradient"; "stop"; "filter"; "feBlend"; "feFlood";
+  "feGaussianBlur"; "feOffset"; "feMerge"; "feMergeNode"; "feComposite";
+  "template"; "slot";
+]
+
+let void_elements = [
+  "area"; "base"; "br"; "col"; "embed"; "hr"; "img"; "input";
+  "link"; "meta"; "param"; "source"; "track"; "wbr"
+]
+
+let boolean_attrs = [
+  "async"; "autofocus"; "autoplay"; "checked"; "controls"; "default";
+  "defer"; "disabled"; "formnovalidate"; "hidden"; "inert"; "ismap";
+  "loop"; "multiple"; "muted"; "nomodule"; "novalidate"; "open";
+  "playsinline"; "readonly"; "required"; "reversed"; "selected"
+]
+
+let is_html_tag name = List.mem name html_tags
+let is_void name = List.mem name void_elements
+let is_boolean_attr name = List.mem name boolean_attrs
+
+
+(* ====================================================================== *)
+(* HTML escaping                                                           *)
+(* ====================================================================== *)
+
+let escape_html s =
+  let buf = Buffer.create (String.length s) in
+  String.iter (function
+    | '&' -> Buffer.add_string buf "&"
+    | '<' -> Buffer.add_string buf "&lt;"
+    | '>' -> Buffer.add_string buf "&gt;"
+    | '"' -> Buffer.add_string buf "&quot;"
+    | c -> Buffer.add_char buf c) s;
+  Buffer.contents buf
+
+
+(* ====================================================================== *)
+(* Attribute rendering                                                     *)
+(* ====================================================================== *)
+
+let render_attrs attrs =
+  let buf = Buffer.create 64 in
+  Hashtbl.iter (fun k v ->
+    if is_boolean_attr k then begin
+      if sx_truthy v then begin
+        Buffer.add_char buf ' ';
+        Buffer.add_string buf k
+      end
+    end else if not (is_nil v) then begin
+      Buffer.add_char buf ' ';
+      Buffer.add_string buf k;
+      Buffer.add_string buf "=\"";
+      Buffer.add_string buf (escape_html (value_to_string v));
+      Buffer.add_char buf '"'
+    end) attrs;
+  Buffer.contents buf
+
+
+(* ====================================================================== *)
+(* HTML renderer                                                           *)
+(* ====================================================================== *)
+
+(* Forward ref — resolved at setup time *)
+let render_to_html_ref : (value -> env -> string) ref =
+  ref (fun _expr _env -> "")
+
+let render_to_html expr env = !render_to_html_ref expr env
+
+let render_children children env =
+  String.concat "" (List.map (fun c -> render_to_html c env) children)
+
+(** Parse keyword attrs and positional children from an element call's args.
+    Attrs are evaluated; children are returned UNEVALUATED for render dispatch. *)
+let parse_element_args args env =
+  let attrs = Hashtbl.create 8 in
+  let children = ref [] in
+  let skip = ref false in
+  let len = List.length args in
+  List.iteri (fun idx arg ->
+    if !skip then skip := false
+    else match arg with
+    | Keyword k when idx + 1 < len ->
+      let v = Sx_ref.eval_expr (List.nth args (idx + 1)) (Env env) in
+      Hashtbl.replace attrs k v;
+      skip := true
+    | Spread pairs ->
+      List.iter (fun (k, v) -> Hashtbl.replace attrs k v) pairs
+    | _ ->
+      children := arg :: !children
+  ) args;
+  (attrs, List.rev !children)
+
+let render_html_element tag args env =
+  let (attrs, children) = parse_element_args args env in
+  let attr_str = render_attrs attrs in
+  if is_void tag then
+    "<" ^ tag ^ attr_str ^ " />"
+  else
+    let content = String.concat ""
+      (List.map (fun c -> render_to_html c env) children) in
+    "<" ^ tag ^ attr_str ^ ">" ^ content ^ "</" ^ tag ^ ">"
+
+let render_component comp args env =
+  match comp with
+  | Component c ->
+    let kwargs = Hashtbl.create 8 in
+    let children_exprs = ref [] in
+    let skip = ref false in
+    let len = List.length args in
+    List.iteri (fun idx arg ->
+      if !skip then skip := false
+      else match arg with
+      | Keyword k when idx + 1 < len ->
+        let v = Sx_ref.eval_expr (List.nth args (idx + 1)) (Env env) in
+        Hashtbl.replace kwargs k v;
+        skip := true
+      | _ ->
+        children_exprs := arg :: !children_exprs
+    ) args;
+    let children = List.rev !children_exprs in
+    let local = env_merge c.c_closure env in
+    List.iter (fun p ->
+      let v = match Hashtbl.find_opt kwargs p with Some v -> v | None -> Nil in
+      ignore (env_bind local p v)
+    ) c.c_params;
+    if c.c_has_children then begin
+      let rendered_children = String.concat ""
+        (List.map (fun c -> render_to_html c env) children) in
+      ignore (env_bind local "children" (RawHTML rendered_children))
+    end;
+    render_to_html c.c_body local
+  | _ -> ""
+
+let expand_macro (m : macro) args _env =
+  let local = env_extend m.m_closure in
+  let params = m.m_params in
+  let rec bind_params ps as' =
+    match ps, as' with
+    | [], rest ->
+      (match m.m_rest_param with
+       | Some rp -> ignore (env_bind local rp (List rest))
+       | None -> ())
+    | p :: ps_rest, a :: as_rest ->
+      ignore (env_bind local p a);
+      bind_params ps_rest as_rest
+    | _ :: _, [] ->
+      List.iter (fun p -> ignore (env_bind local p Nil)) (List.rev ps)
+  in
+  bind_params params args;
+  Sx_ref.eval_expr m.m_body (Env local)
+
+let rec do_render_to_html (expr : value) (env : env) : string =
+  match expr with
+  | Nil -> ""
+  | Bool true -> "true"
+  | Bool false -> "false"
+  | Number n ->
+    if Float.is_integer n then string_of_int (int_of_float n)
+    else Printf.sprintf "%g" n
+  | String s -> escape_html s
+  | Keyword k -> escape_html k
+  | RawHTML s -> s
+  | Symbol s ->
+    let v = Sx_ref.eval_expr (Symbol s) (Env env) in
+    do_render_to_html v env
+  | List [] | ListRef { contents = [] } -> ""
+  | List (head :: args) | ListRef { contents = head :: args } ->
+    render_list_to_html head args env
+  | _ ->
+    let v = Sx_ref.eval_expr expr (Env env) in
+    do_render_to_html v env
+
+and render_list_to_html head args env =
+  match head with
+  | Symbol "<>" ->
+    render_children args env
+  | Symbol tag when is_html_tag tag ->
+    render_html_element tag args env
+  | Symbol "if" ->
+    let cond_val = Sx_ref.eval_expr (List.hd args) (Env env) in
+    if sx_truthy cond_val then
+      (if List.length args > 1 then do_render_to_html (List.nth args 1) env else "")
+    else
+      (if List.length args > 2 then do_render_to_html (List.nth args 2) env else "")
+  | Symbol "when" ->
+    let cond_val = Sx_ref.eval_expr (List.hd args) (Env env) in
+    if sx_truthy cond_val then
+      String.concat "" (List.map (fun e -> do_render_to_html e env) (List.tl args))
+    else ""
+  | Symbol "cond" ->
+    render_cond args env
+  | Symbol "case" ->
+    let v = Sx_ref.eval_expr (List (head :: args)) (Env env) in
+    do_render_to_html v env
+  | Symbol ("let" | "let*") ->
+    render_let args env
+  | Symbol ("begin" | "do") ->
+    let rec go = function
+      | [] -> ""
+      | [last] -> do_render_to_html last env
+      | e :: rest ->
+        ignore (Sx_ref.eval_expr e (Env env));
+        go rest
+    in go args
+  | Symbol ("define" | "defcomp" | "defmacro" | "defisland") ->
+    ignore (Sx_ref.eval_expr (List (head :: args)) (Env env));
+    ""
+  | Symbol "map" ->
+    render_map args env false
+  | Symbol "map-indexed" ->
+    render_map args env true
+  | Symbol "filter" ->
+    let v = Sx_ref.eval_expr (List (head :: args)) (Env env) in
+    do_render_to_html v env
+  | Symbol "for-each" ->
+    render_for_each args env
+  | Symbol name ->
+    (try
+      let v = env_get env name in
+      (match v with
+       | Component _ -> render_component v args env
+       | Macro m ->
+         let expanded = expand_macro m args env in
+         do_render_to_html expanded env
+       | _ ->
+         let result = Sx_ref.eval_expr (List (head :: args)) (Env env) in
+         do_render_to_html result env)
+    with Eval_error _ ->
+      let result = Sx_ref.eval_expr (List (head :: args)) (Env env) in
+      do_render_to_html result env)
+  | _ ->
+    let result = Sx_ref.eval_expr (List (head :: args)) (Env env) in
+    do_render_to_html result env
+
+and render_cond args env =
+  let as_list = function List l | ListRef { contents = l } -> Some l | _ -> None in
+  let is_scheme = List.for_all (fun a -> match as_list a with
+    | Some items when List.length items = 2 -> true
+    | _ -> false) args
+  in
+  if is_scheme then begin
+    let rec go = function
+      | [] -> ""
+      | clause :: rest ->
+        (match as_list clause with
+         | Some [test; body] ->
+           let is_else = match test with
+             | Keyword "else" -> true
+             | Symbol "else" | Symbol ":else" -> true
+             | _ -> false
+           in
+           if is_else then do_render_to_html body env
+           else
+             let v = Sx_ref.eval_expr test (Env env) in
+             if sx_truthy v then do_render_to_html body env
+             else go rest
+         | _ -> "")
+    in go args
+  end else begin
+    let rec go = function
+      | [] -> ""
+      | [_] -> ""
+      | test :: body :: rest ->
+        let is_else = match test with
+          | Keyword "else" -> true
+          | Symbol "else" | Symbol ":else" -> true
+          | _ -> false
+        in
+        if is_else then do_render_to_html body env
+        else
+          let v = Sx_ref.eval_expr test (Env env) in
+          if sx_truthy v then do_render_to_html body env
+          else go rest
+    in go args
+  end
+
+and render_let args env =
+  let as_list = function List l | ListRef { contents = l } -> Some l | _ -> None in
+  let bindings_expr = List.hd args in
+  let body = List.tl args in
+  let local = env_extend env in
+  let bindings = match as_list bindings_expr with Some l -> l | None -> [] in
+  let is_scheme = match bindings with
+    | (List _ :: _) | (ListRef _ :: _) -> true
+    | _ -> false
+  in
+  if is_scheme then
+    List.iter (fun b ->
+      match as_list b with
+      | Some [Symbol name; expr] | Some [String name; expr] ->
+        let v = Sx_ref.eval_expr expr (Env local) in
+        ignore (env_bind local name v)
+      | _ -> ()
+    ) bindings
+  else begin
+    let rec go = function
+      | [] -> ()
+      | (Symbol name) :: expr :: rest | (String name) :: expr :: rest ->
+        let v = Sx_ref.eval_expr expr (Env local) in
+        ignore (env_bind local name v);
+        go rest
+      | _ -> ()
+    in go bindings
+  end;
+  let rec render_body = function
+    | [] -> ""
+    | [last] -> do_render_to_html last local
+    | e :: rest ->
+      ignore (Sx_ref.eval_expr e (Env local));
+      render_body rest
+  in render_body body
+
+and render_map args env indexed =
+  let (fn_val, coll_val) = match args with
+    | [a; b] ->
+      let va = Sx_ref.eval_expr a (Env env) in
+      let vb = Sx_ref.eval_expr b (Env env) in
+      (match va, vb with
+       | (Lambda _ | NativeFn _), _ -> (va, vb)
+       | _, (Lambda _ | NativeFn _) -> (vb, va)
+       | _ -> (va, vb))
+    | _ -> (Nil, Nil)
+  in
+  let items = match coll_val with List l | ListRef { contents = l } -> l | _ -> [] in
+  String.concat "" (List.mapi (fun i item ->
+    let call_args = if indexed then [Number (float_of_int i); item] else [item] in
+    match fn_val with
+    | Lambda l ->
+      let local = env_extend l.l_closure in
+      List.iter2 (fun p a -> ignore (env_bind local p a))
+        l.l_params call_args;
+      do_render_to_html l.l_body local
+    | _ ->
+      let result = Sx_runtime.sx_call fn_val call_args in
+      do_render_to_html result env
+  ) items)
+
+and render_for_each args env =
+  let (fn_val, coll_val) = match args with
+    | [a; b] ->
+      let va = Sx_ref.eval_expr a (Env env) in
+      let vb = Sx_ref.eval_expr b (Env env) in
+      (match va, vb with
+       | (Lambda _ | NativeFn _), _ -> (va, vb)
+       | _, (Lambda _ | NativeFn _) -> (vb, va)
+       | _ -> (va, vb))
+    | _ -> (Nil, Nil)
+  in
+  let items = match coll_val with List l | ListRef { contents = l } -> l | _ -> [] in
+  String.concat "" (List.map (fun item ->
+    match fn_val with
+    | Lambda l ->
+      let local = env_extend l.l_closure in
+      List.iter2 (fun p a -> ignore (env_bind local p a))
+        l.l_params [item];
+      do_render_to_html l.l_body local
+    | _ ->
+      let result = Sx_runtime.sx_call fn_val [item] in
+      do_render_to_html result env
+  ) items)
+
+
+(* ====================================================================== *)
+(* Setup — bind render primitives in an env and wire up the ref            *)
+(* ====================================================================== *)
+
+let setup_render_env env =
+  render_to_html_ref := do_render_to_html;
+
+  let bind name fn =
+    ignore (env_bind env name (NativeFn (name, fn)))
+  in
+
+  bind "render-html" (fun args ->
+    match args with
+    | [String src] ->
+      let exprs = Sx_parser.parse_all src in
+      let expr = match exprs with
+        | [e] -> e
+        | [] -> Nil
+        | _ -> List (Symbol "do" :: exprs)
+      in
+      String (render_to_html expr env)
+    | [expr] ->
+      String (render_to_html expr env)
+    | [expr; Env e] ->
+      String (render_to_html expr e)
+    | _ -> String "");
+
+  bind "render-to-html" (fun args ->
+    match args with
+    | [String src] ->
+      let exprs = Sx_parser.parse_all src in
+      let expr = match exprs with
+        | [e] -> e
+        | [] -> Nil
+        | _ -> List (Symbol "do" :: exprs)
+      in
+      String (render_to_html expr env)
+    | [expr] ->
+      String (render_to_html expr env)
+    | [expr; Env e] ->
+      String (render_to_html expr e)
+    | _ -> String "")

hosts/ocaml/lib/sx_runtime.ml

@@ -0,0 +1,356 @@
+(** Runtime helpers for transpiled code.
+
+    These bridge the gap between the transpiler's output and the
+    foundation types/primitives. The transpiled evaluator calls these
+    functions directly. *)
+
+open Sx_types
+
+(** Call a registered primitive by name. *)
+let prim_call name args =
+  match Hashtbl.find_opt Sx_primitives.primitives name with
+  | Some f -> f args
+  | None -> raise (Eval_error ("Unknown primitive: " ^ name))
+
+(** Convert any SX value to an OCaml string (internal). *)
+let value_to_str = function
+  | String s -> s
+  | Number n ->
+    if Float.is_integer n then string_of_int (int_of_float n)
+    else Printf.sprintf "%g" n
+  | Bool true -> "true"
+  | Bool false -> "false"
+  | Nil -> ""
+  | Symbol s -> s
+  | Keyword k -> k
+  | v -> inspect v
+
+(** sx_to_string returns a value (String) for transpiled code. *)
+let sx_to_string v = String (value_to_str v)
+
+(** String concatenation helper — [sx_str] takes a list of values. *)
+let sx_str args =
+  String.concat "" (List.map value_to_str args)
+
+(** Convert a value to a list. *)
+let sx_to_list = function
+  | List l -> l
+  | ListRef r -> !r
+  | Nil -> []
+  | v -> raise (Eval_error ("Expected list, got " ^ type_of v))
+
+(** Call an SX callable (lambda, native fn, continuation). *)
+let sx_call f args =
+  match f with
+  | NativeFn (_, fn) -> fn args
+  | Lambda l ->
+    let local = Sx_types.env_extend l.l_closure in
+    List.iter2 (fun p a -> ignore (Sx_types.env_bind local p a)) l.l_params args;
+    (* Return the body + env for the trampoline to evaluate *)
+    Thunk (l.l_body, local)
+  | Continuation (k, _) ->
+    k (match args with x :: _ -> x | [] -> Nil)
+  | _ -> raise (Eval_error ("Not callable: " ^ inspect f))
+
+(** Apply a function to a list of args. *)
+let sx_apply f args_list =
+  sx_call f (sx_to_list args_list)
+
+(** Mutable append — add item to a list ref or accumulator.
+    In transpiled code, lists that get appended to are mutable refs. *)
+let sx_append_b lst item =
+  match lst with
+  | List items -> List (items @ [item])
+  | ListRef r -> r := !r @ [item]; lst  (* mutate in place, return same ref *)
+  | _ -> raise (Eval_error ("append!: expected list, got " ^ type_of lst))
+
+(** Mutable dict-set — set key in dict, return value. *)
+let sx_dict_set_b d k v =
+  match d, k with
+  | Dict tbl, String key -> Hashtbl.replace tbl key v; v
+  | Dict tbl, Keyword key -> Hashtbl.replace tbl key v; v
+  | _ -> raise (Eval_error "dict-set!: expected dict and string key")
+
+(** Get from dict or list. *)
+let get_val container key =
+  match container, key with
+  | Dict d, String k -> dict_get d k
+  | Dict d, Keyword k -> dict_get d k
+  | (List l | ListRef { contents = l }), Number n ->
+    (try List.nth l (int_of_float n) with _ -> Nil)
+  | _ -> raise (Eval_error ("get: unsupported " ^ type_of container ^ " / " ^ type_of key))
+
+(** Register get as a primitive override — transpiled code calls (get d k). *)
+let () =
+  Sx_primitives.register "get" (fun args ->
+    match args with
+    | [c; k] -> get_val c k
+    | [c; k; default] ->
+      (try
+        let v = get_val c k in
+        if v = Nil then default else v
+      with _ -> default)
+    | _ -> raise (Eval_error "get: 2-3 args"))
+
+
+(* ====================================================================== *)
+(* Primitive aliases — top-level functions called by transpiled code       *)
+(* ====================================================================== *)
+
+(** The transpiled evaluator calls primitives directly by their mangled
+    OCaml name. These aliases delegate to the primitives table so the
+    transpiled code compiles without needing [prim_call] everywhere. *)
+
+let _prim name = match Hashtbl.find_opt Sx_primitives.primitives name with
+  | Some f -> f | None -> (fun _ -> raise (Eval_error ("Missing prim: " ^ name)))
+
+(* Collection ops *)
+let first args = _prim "first" [args]
+let rest args = _prim "rest" [args]
+let last args = _prim "last" [args]
+let nth coll i = _prim "nth" [coll; i]
+let cons x l = _prim "cons" [x; l]
+let append a b = _prim "append" [a; b]
+let reverse l = _prim "reverse" [l]
+let flatten l = _prim "flatten" [l]
+let concat a b = _prim "concat" [a; b]
+let slice a b = _prim "slice" [a; b]
+let len a = _prim "len" [a]
+let get a b = get_val a b
+let sort' a = _prim "sort" [a]
+let range' a = _prim "range" [a]
+let unique a = _prim "unique" [a]
+let zip a b = _prim "zip" [a; b]
+let zip_pairs a = _prim "zip-pairs" [a]
+let take a b = _prim "take" [a; b]
+let drop a b = _prim "drop" [a; b]
+let chunk_every a b = _prim "chunk-every" [a; b]
+
+(* Predicates *)
+let empty_p a = _prim "empty?" [a]
+let nil_p a = _prim "nil?" [a]
+let number_p a = _prim "number?" [a]
+let string_p a = _prim "string?" [a]
+let boolean_p a = _prim "boolean?" [a]
+let list_p a = _prim "list?" [a]
+let dict_p a = _prim "dict?" [a]
+let symbol_p a = _prim "symbol?" [a]
+let keyword_p a = _prim "keyword?" [a]
+let contains_p a b = _prim "contains?" [a; b]
+let has_key_p a b = _prim "has-key?" [a; b]
+let starts_with_p a b = _prim "starts-with?" [a; b]
+let ends_with_p a b = _prim "ends-with?" [a; b]
+let string_contains_p a b = _prim "string-contains?" [a; b]
+let odd_p a = _prim "odd?" [a]
+let even_p a = _prim "even?" [a]
+let zero_p a = _prim "zero?" [a]
+
+(* String ops *)
+let str' args = String (sx_str args)
+let upper a = _prim "upper" [a]
+let upcase a = _prim "upcase" [a]
+let lower a = _prim "lower" [a]
+let downcase a = _prim "downcase" [a]
+let trim a = _prim "trim" [a]
+let split a b = _prim "split" [a; b]
+let join a b = _prim "join" [a; b]
+let replace a b c = _prim "replace" [a; b; c]
+let index_of a b = _prim "index-of" [a; b]
+let substring a b c = _prim "substring" [a; b; c]
+let string_length a = _prim "string-length" [a]
+let char_from_code a = _prim "char-from-code" [a]
+
+(* Dict ops *)
+let assoc d k v = _prim "assoc" [d; k; v]
+let dissoc d k = _prim "dissoc" [d; k]
+let merge' a b = _prim "merge" [a; b]
+let keys a = _prim "keys" [a]
+let vals a = _prim "vals" [a]
+let dict_set a b c = _prim "dict-set!" [a; b; c]
+let dict_get a b = _prim "dict-get" [a; b]
+let dict_has_p a b = _prim "dict-has?" [a; b]
+let dict_delete a b = _prim "dict-delete!" [a; b]
+
+(* Math *)
+let abs' a = _prim "abs" [a]
+let sqrt' a = _prim "sqrt" [a]
+let pow' a b = _prim "pow" [a; b]
+let floor' a = _prim "floor" [a]
+let ceil' a = _prim "ceil" [a]
+let round' a = _prim "round" [a]
+let min' a b = _prim "min" [a; b]
+let max' a b = _prim "max" [a; b]
+let clamp a b c = _prim "clamp" [a; b; c]
+let parse_int a = _prim "parse-int" [a]
+let parse_float a = _prim "parse-float" [a]
+
+(* Misc *)
+let error msg = raise (Eval_error (value_to_str msg))
+
+(* inspect wrapper — returns String value instead of OCaml string *)
+let inspect v = String (Sx_types.inspect v)
+let apply' f args = sx_apply f args
+let identical_p a b = _prim "identical?" [a; b]
+let _is_spread_prim a = _prim "spread?" [a]
+let spread_attrs a = _prim "spread-attrs" [a]
+let make_spread a = _prim "make-spread" [a]
+
+(* Scope primitives — delegate to sx_ref.py's shared scope stacks *)
+let sx_collect a b = prim_call "collect!" [a; b]
+let sx_collected a = prim_call "collected" [a]
+let sx_clear_collected a = prim_call "clear-collected!" [a]
+let sx_emit a b = prim_call "emit!" [a; b]
+let sx_emitted a = prim_call "emitted" [a]
+let sx_context a b = prim_call "context" [a; b]
+
+(* Trampoline — forward-declared in sx_ref.ml, delegates to CEK eval_expr *)
+(* This is a stub; the real trampoline is wired up in sx_ref.ml after eval_expr is defined *)
+let trampoline v = v
+
+(* Value-returning type predicates — the transpiled code passes these through
+   sx_truthy, so they need to return Bool, not OCaml bool. *)
+(* type_of returns value, not string *)
+let type_of v = String (Sx_types.type_of v)
+
+(* Env operations — accept Env-wrapped values and value keys.
+   The transpiled CEK machine stores envs in dicts as Env values. *)
+let unwrap_env = function
+  | Env e -> e
+  | _ -> raise (Eval_error "Expected env")
+
+let env_has e name = Bool (Sx_types.env_has (unwrap_env e) (value_to_str name))
+let env_get e name = Sx_types.env_get (unwrap_env e) (value_to_str name)
+let env_bind e name v = Sx_types.env_bind (unwrap_env e) (value_to_str name) v
+let env_set e name v = Sx_types.env_set (unwrap_env e) (value_to_str name) v
+
+let make_env () = Env (Sx_types.make_env ())
+let env_extend e = Env (Sx_types.env_extend (unwrap_env e))
+let env_merge a b = Env (Sx_types.env_merge (unwrap_env a) (unwrap_env b))
+
+(* set_lambda_name wrapper — accepts value, extracts string *)
+let set_lambda_name l n = Sx_types.set_lambda_name l (value_to_str n)
+
+let is_nil v = Bool (Sx_types.is_nil v)
+let is_thunk v = Bool (Sx_types.is_thunk v)
+let is_lambda v = Bool (Sx_types.is_lambda v)
+let is_component v = Bool (Sx_types.is_component v)
+let is_island v = Bool (Sx_types.is_island v)
+let is_macro v = Bool (Sx_types.is_macro v)
+let is_signal v = Bool (Sx_types.is_signal v)
+let is_callable v = Bool (Sx_types.is_callable v)
+let is_identical a b = Bool (a == b)
+let is_primitive name = Bool (Sx_primitives.is_primitive (value_to_str name))
+let get_primitive name = Sx_primitives.get_primitive (value_to_str name)
+let is_spread v = match v with Spread _ -> Bool true | _ -> Bool false
+
+(* Stubs for functions defined in sx_ref.ml — resolved at link time *)
+(* These are forward-declared here; sx_ref.ml defines the actual implementations *)
+
+(* strip-prefix *)
+(* Stubs for evaluator functions — defined in sx_ref.ml but
+   sometimes referenced before their definition via forward calls.
+   These get overridden by the actual transpiled definitions. *)
+
+let map_indexed fn coll =
+  List (List.mapi (fun i x -> sx_call fn [Number (float_of_int i); x]) (sx_to_list coll))
+
+let map_dict fn d =
+  match d with
+  | Dict tbl ->
+    let result = Hashtbl.create (Hashtbl.length tbl) in
+    Hashtbl.iter (fun k v -> Hashtbl.replace result k (sx_call fn [String k; v])) tbl;
+    Dict result
+  | _ -> raise (Eval_error "map-dict: expected dict")
+
+let for_each fn coll =
+  List.iter (fun x -> ignore (sx_call fn [x])) (sx_to_list coll);
+  Nil
+
+let for_each_indexed fn coll =
+  List.iteri (fun i x -> ignore (sx_call fn [Number (float_of_int i); x])) (sx_to_list coll);
+  Nil
+
+(* Continuation support *)
+let continuation_p v = match v with Continuation (_, _) -> Bool true | _ -> Bool false
+
+let make_cek_continuation captured rest_kont =
+  let data = Hashtbl.create 2 in
+  Hashtbl.replace data "captured" captured;
+  Hashtbl.replace data "rest-kont" rest_kont;
+  Continuation ((fun v -> v), Some data)
+
+let continuation_data v = match v with
+  | Continuation (_, Some d) -> Dict d
+  | Continuation (_, None) -> Dict (Hashtbl.create 0)
+  | _ -> raise (Eval_error "not a continuation")
+
+(* Dynamic wind — simplified for OCaml (no async) *)
+let dynamic_wind_call before body after _env =
+  ignore (sx_call before []);
+  let result = sx_call body [] in
+  ignore (sx_call after []);
+  result
+
+(* Scope stack stubs — delegated to primitives when available *)
+let scope_push name value = prim_call "collect!" [name; value]
+let scope_pop _name = Nil
+let provide_push name value = ignore name; ignore value; Nil
+let provide_pop _name = Nil
+
+(* Render mode stubs *)
+let render_active_p () = Bool false
+let render_expr _expr _env = Nil
+let is_render_expr _expr = Bool false
+
+(* Signal accessors *)
+let signal_value s = match s with Signal sig' -> sig'.s_value | _ -> raise (Eval_error "not a signal")
+let signal_set_value s v = match s with Signal sig' -> sig'.s_value <- v; v | _ -> raise (Eval_error "not a signal")
+let signal_subscribers s = match s with Signal sig' -> List (List.map (fun _ -> Nil) sig'.s_subscribers) | _ -> List []
+let signal_add_sub_b _s _f = Nil
+let signal_remove_sub_b _s _f = Nil
+let signal_deps _s = List []
+let signal_set_deps _s _d = Nil
+let notify_subscribers _s = Nil
+let flush_subscribers _s = Nil
+let dispose_computed _s = Nil
+
+(* Island scope stubs — accept OCaml functions from transpiled code *)
+let with_island_scope _register_fn body_fn = body_fn ()
+let register_in_scope _dispose_fn = Nil
+
+(* Component type annotation stub *)
+let component_set_param_types_b _comp _types = Nil
+
+(* Parse keyword args from a call — this is defined in evaluator.sx,
+   the transpiled version will override this stub. *)
+(* Forward-reference stubs for evaluator functions used before definition *)
+let parse_comp_params _params = List [List []; Nil; Bool false]
+let parse_macro_params _params = List [List []; Nil]
+
+let parse_keyword_args _raw_args _env =
+  (* Stub — the real implementation is transpiled from evaluator.sx *)
+  List [Dict (Hashtbl.create 0); List []]
+
+(* Make handler/query/action/page def stubs *)
+let make_handler_def name params body _env = Dict (let d = Hashtbl.create 4 in Hashtbl.replace d "type" (String "handler"); Hashtbl.replace d "name" name; Hashtbl.replace d "params" params; Hashtbl.replace d "body" body; d)
+let make_query_def name params body _env = make_handler_def name params body _env
+let make_action_def name params body _env = make_handler_def name params body _env
+let make_page_def name _opts = Dict (let d = Hashtbl.create 4 in Hashtbl.replace d "type" (String "page"); Hashtbl.replace d "name" name; d)
+
+(* sf-def* stubs — platform-specific def-forms, not in the SX spec *)
+let sf_defhandler args env =
+  let name = first args in let rest_args = rest args in
+  make_handler_def name (first rest_args) (nth rest_args (Number 1.0)) env
+let sf_defquery args env = sf_defhandler args env
+let sf_defaction args env = sf_defhandler args env
+let sf_defpage args _env =
+  let name = first args in make_page_def name (rest args)
+
+let strip_prefix s prefix =
+  match s, prefix with
+  | String s, String p ->
+    let pl = String.length p in
+    if String.length s >= pl && String.sub s 0 pl = p
+    then String (String.sub s pl (String.length s - pl))
+    else String s
+  | _ -> s

hosts/ocaml/lib/sx_types.ml

@@ -0,0 +1,392 @@
+(** Core types for the SX language.
+
+    The [value] sum type represents every possible SX runtime value.
+    OCaml's algebraic types make the CEK machine's frame dispatch a
+    pattern match — exactly what the spec describes. *)
+
+(** {1 Environment} *)
+
+(** Lexical scope chain.  Each frame holds a mutable binding table and
+    an optional parent link for scope-chain lookup. *)
+type env = {
+  bindings : (string, value) Hashtbl.t;
+  parent   : env option;
+}
+
+(** {1 Values} *)
+
+and value =
+  | Nil
+  | Bool   of bool
+  | Number of float
+  | String of string
+  | Symbol of string
+  | Keyword of string
+  | List   of value list
+  | Dict   of dict
+  | Lambda of lambda
+  | Component of component
+  | Island of island
+  | Macro  of macro
+  | Thunk  of value * env
+  | Continuation of (value -> value) * dict option
+  | NativeFn of string * (value list -> value)
+  | Signal of signal
+  | RawHTML of string
+  | Spread of (string * value) list
+  | SxExpr of string  (** Opaque SX wire-format string — aser output. *)
+  | Env of env  (** First-class environment — used by CEK machine state dicts. *)
+  | ListRef of value list ref  (** Mutable list — JS-style array for append! *)
+
+(** Mutable string-keyed table (SX dicts support [dict-set!]). *)
+and dict = (string, value) Hashtbl.t
+
+and lambda = {
+  l_params  : string list;
+  l_body    : value;
+  l_closure : env;
+  mutable l_name : string option;
+}
+
+and component = {
+  c_name         : string;
+  c_params       : string list;
+  c_has_children : bool;
+  c_body         : value;
+  c_closure      : env;
+  c_affinity     : string;  (** "auto" | "client" | "server" *)
+}
+
+and island = {
+  i_name         : string;
+  i_params       : string list;
+  i_has_children : bool;
+  i_body         : value;
+  i_closure      : env;
+}
+
+and macro = {
+  m_params     : string list;
+  m_rest_param : string option;
+  m_body       : value;
+  m_closure    : env;
+  m_name       : string option;
+}
+
+and signal = {
+  mutable s_value       : value;
+  mutable s_subscribers : (unit -> unit) list;
+  mutable s_deps        : signal list;
+}
+
+
+(** {1 Errors} *)
+
+exception Eval_error of string
+exception Parse_error of string
+
+
+(** {1 Environment operations} *)
+
+let make_env () =
+  { bindings = Hashtbl.create 16; parent = None }
+
+let env_extend parent =
+  { bindings = Hashtbl.create 16; parent = Some parent }
+
+let env_bind env name v =
+  Hashtbl.replace env.bindings name v; Nil
+
+let rec env_has env name =
+  Hashtbl.mem env.bindings name ||
+  match env.parent with Some p -> env_has p name | None -> false
+
+let rec env_get env name =
+  match Hashtbl.find_opt env.bindings name with
+  | Some v -> v
+  | None ->
+    match env.parent with
+    | Some p -> env_get p name
+    | None -> raise (Eval_error ("Undefined symbol: " ^ name))
+
+let rec env_set env name v =
+  if Hashtbl.mem env.bindings name then
+    (Hashtbl.replace env.bindings name v; Nil)
+  else
+    match env.parent with
+    | Some p -> env_set p name v
+    | None -> Hashtbl.replace env.bindings name v; Nil
+
+let env_merge base overlay =
+  (* If base and overlay are the same env (physical equality) or overlay
+     is a descendant of base, just extend base — no copying needed.
+     This prevents set! inside lambdas from modifying shadow copies. *)
+  if base == overlay then
+    { bindings = Hashtbl.create 16; parent = Some base }
+  else begin
+    (* Check if overlay is a descendant of base *)
+    let rec is_descendant e depth =
+      if depth > 100 then false
+      else if e == base then true
+      else match e.parent with Some p -> is_descendant p (depth + 1) | None -> false
+    in
+    if is_descendant overlay 0 then
+      { bindings = Hashtbl.create 16; parent = Some base }
+    else begin
+      (* General case: extend base, copy ONLY overlay bindings that don't
+         exist anywhere in the base chain (avoids shadowing closure bindings). *)
+      let e = { bindings = Hashtbl.create 16; parent = Some base } in
+      Hashtbl.iter (fun k v ->
+        if not (env_has base k) then Hashtbl.replace e.bindings k v
+      ) overlay.bindings;
+      e
+    end
+  end
+
+
+(** {1 Value extraction helpers} *)
+
+let value_to_string = function
+  | String s -> s | Symbol s -> s | Keyword k -> k
+  | Number n -> if Float.is_integer n then string_of_int (int_of_float n) else Printf.sprintf "%g" n
+  | Bool true -> "true" | Bool false -> "false"
+  | Nil -> "" | _ -> "<value>"
+
+let value_to_string_list = function
+  | List items | ListRef { contents = items } -> List.map value_to_string items
+  | _ -> []
+
+let value_to_bool = function
+  | Bool b -> b | Nil -> false | _ -> true
+
+let value_to_string_opt = function
+  | String s -> Some s | Symbol s -> Some s | Nil -> None | _ -> None
+
+
+(** {1 Constructors — accept [value] args from transpiled code} *)
+
+let unwrap_env_val = function
+  | Env e -> e
+  | _ -> raise (Eval_error "make_lambda: expected env for closure")
+
+let make_lambda params body closure =
+  let ps = match params with
+    | List items -> List.map value_to_string items
+    | _ -> value_to_string_list params
+  in
+  Lambda { l_params = ps; l_body = body; l_closure = unwrap_env_val closure; l_name = None }
+
+let make_component name params has_children body closure affinity =
+  let n = value_to_string name in
+  let ps = value_to_string_list params in
+  let hc = value_to_bool has_children in
+  let aff = match affinity with String s -> s | _ -> "auto" in
+  Component {
+    c_name = n; c_params = ps; c_has_children = hc;
+    c_body = body; c_closure = unwrap_env_val closure; c_affinity = aff;
+  }
+
+let make_island name params has_children body closure =
+  let n = value_to_string name in
+  let ps = value_to_string_list params in
+  let hc = value_to_bool has_children in
+  Island {
+    i_name = n; i_params = ps; i_has_children = hc;
+    i_body = body; i_closure = unwrap_env_val closure;
+  }
+
+let make_macro params rest_param body closure name =
+  let ps = value_to_string_list params in
+  let rp = value_to_string_opt rest_param in
+  let n = value_to_string_opt name in
+  Macro {
+    m_params = ps; m_rest_param = rp;
+    m_body = body; m_closure = unwrap_env_val closure; m_name = n;
+  }
+
+let make_thunk expr env = Thunk (expr, unwrap_env_val env)
+
+let make_symbol name = Symbol (value_to_string name)
+let make_keyword name = Keyword (value_to_string name)
+
+
+(** {1 Type inspection} *)
+
+let type_of = function
+  | Nil            -> "nil"
+  | Bool _         -> "boolean"
+  | Number _       -> "number"
+  | String _       -> "string"
+  | Symbol _       -> "symbol"
+  | Keyword _      -> "keyword"
+  | List _ | ListRef _ -> "list"
+  | Dict _         -> "dict"
+  | Lambda _       -> "lambda"
+  | Component _    -> "component"
+  | Island _       -> "island"
+  | Macro _        -> "macro"
+  | Thunk _        -> "thunk"
+  | Continuation (_, _) -> "continuation"
+  | NativeFn _     -> "function"
+  | Signal _       -> "signal"
+  | RawHTML _      -> "raw-html"
+  | Spread _       -> "spread"
+  | SxExpr _       -> "sx-expr"
+  | Env _          -> "env"
+
+let is_nil = function Nil -> true | _ -> false
+let is_lambda = function Lambda _ -> true | _ -> false
+let is_component = function Component _ -> true | _ -> false
+let is_island = function Island _ -> true | _ -> false
+let is_macro = function Macro _ -> true | _ -> false
+let is_thunk = function Thunk _ -> true | _ -> false
+let is_signal = function Signal _ -> true | _ -> false
+
+let is_callable = function
+  | Lambda _ | NativeFn _ | Continuation (_, _) -> true
+  | _ -> false
+
+
+(** {1 Truthiness} *)
+
+(** SX truthiness: everything is truthy except [Nil] and [Bool false]. *)
+let sx_truthy = function
+  | Nil | Bool false -> false
+  | _ -> true
+
+
+(** {1 Accessors} *)
+
+let symbol_name = function
+  | Symbol s -> String s
+  | v -> raise (Eval_error ("Expected symbol, got " ^ type_of v))
+
+let keyword_name = function
+  | Keyword k -> String k
+  | v -> raise (Eval_error ("Expected keyword, got " ^ type_of v))
+
+let lambda_params = function
+  | Lambda l -> List (List.map (fun s -> String s) l.l_params)
+  | v -> raise (Eval_error ("Expected lambda, got " ^ type_of v))
+
+let lambda_body = function
+  | Lambda l -> l.l_body
+  | v -> raise (Eval_error ("Expected lambda, got " ^ type_of v))
+
+let lambda_closure = function
+  | Lambda l -> Env l.l_closure
+  | v -> raise (Eval_error ("Expected lambda, got " ^ type_of v))
+
+let lambda_name = function
+  | Lambda l -> (match l.l_name with Some n -> String n | None -> Nil)
+  | v -> raise (Eval_error ("Expected lambda, got " ^ type_of v))
+
+let set_lambda_name l n = match l with
+  | Lambda l -> l.l_name <- Some n; Nil
+  | _ -> raise (Eval_error "set-lambda-name!: not a lambda")
+
+let component_name = function
+  | Component c -> String c.c_name
+  | v -> raise (Eval_error ("Expected component, got " ^ type_of v))
+
+let component_params = function
+  | Component c -> List (List.map (fun s -> String s) c.c_params)
+  | v -> raise (Eval_error ("Expected component, got " ^ type_of v))
+
+let component_body = function
+  | Component c -> c.c_body
+  | v -> raise (Eval_error ("Expected component, got " ^ type_of v))
+
+let component_closure = function
+  | Component c -> Env c.c_closure
+  | v -> raise (Eval_error ("Expected component, got " ^ type_of v))
+
+let component_has_children = function
+  | Component c -> Bool c.c_has_children
+  | v -> raise (Eval_error ("Expected component, got " ^ type_of v))
+
+let component_affinity = function
+  | Component c -> String c.c_affinity
+  | _ -> String "auto"
+
+let macro_params = function
+  | Macro m -> List (List.map (fun s -> String s) m.m_params)
+  | v -> raise (Eval_error ("Expected macro, got " ^ type_of v))
+
+let macro_rest_param = function
+  | Macro m -> (match m.m_rest_param with Some s -> String s | None -> Nil)
+  | v -> raise (Eval_error ("Expected macro, got " ^ type_of v))
+
+let macro_body = function
+  | Macro m -> m.m_body
+  | v -> raise (Eval_error ("Expected macro, got " ^ type_of v))
+
+let macro_closure = function
+  | Macro m -> Env m.m_closure
+  | v -> raise (Eval_error ("Expected macro, got " ^ type_of v))
+
+let thunk_expr = function
+  | Thunk (e, _) -> e
+  | v -> raise (Eval_error ("Expected thunk, got " ^ type_of v))
+
+let thunk_env = function
+  | Thunk (_, e) -> Env e
+  | v -> raise (Eval_error ("Expected thunk, got " ^ type_of v))
+
+
+(** {1 Dict operations} *)
+
+let make_dict () : dict = Hashtbl.create 8
+
+let dict_get (d : dict) key =
+  match Hashtbl.find_opt d key with Some v -> v | None -> Nil
+
+let dict_has (d : dict) key = Hashtbl.mem d key
+
+let dict_set (d : dict) key v = Hashtbl.replace d key v
+
+let dict_delete (d : dict) key = Hashtbl.remove d key
+
+let dict_keys (d : dict) =
+  Hashtbl.fold (fun k _ acc -> String k :: acc) d []
+
+let dict_vals (d : dict) =
+  Hashtbl.fold (fun _ v acc -> v :: acc) d []
+
+
+(** {1 Value display} *)
+
+let rec inspect = function
+  | Nil -> "nil"
+  | Bool true -> "true"
+  | Bool false -> "false"
+  | Number n ->
+    if Float.is_integer n then Printf.sprintf "%d" (int_of_float n)
+    else Printf.sprintf "%g" n
+  | String s -> Printf.sprintf "%S" s
+  | Symbol s -> s
+  | Keyword k -> ":" ^ k
+  | List items | ListRef { contents = items } ->
+    "(" ^ String.concat " " (List.map inspect items) ^ ")"
+  | Dict d ->
+    let pairs = Hashtbl.fold (fun k v acc ->
+      (Printf.sprintf ":%s %s" k (inspect v)) :: acc) d [] in
+    "{" ^ String.concat " " pairs ^ "}"
+  | Lambda l ->
+    let tag = match l.l_name with Some n -> n | None -> "lambda" in
+    Printf.sprintf "<%s(%s)>" tag (String.concat ", " l.l_params)
+  | Component c ->
+    Printf.sprintf "<Component ~%s(%s)>" c.c_name (String.concat ", " c.c_params)
+  | Island i ->
+    Printf.sprintf "<Island ~%s(%s)>" i.i_name (String.concat ", " i.i_params)
+  | Macro m ->
+    let tag = match m.m_name with Some n -> n | None -> "macro" in
+    Printf.sprintf "<%s(%s)>" tag (String.concat ", " m.m_params)
+  | Thunk _ -> "<thunk>"
+  | Continuation (_, _) -> "<continuation>"
+  | NativeFn (name, _) -> Printf.sprintf "<native:%s>" name
+  | Signal _ -> "<signal>"
+  | RawHTML s -> Printf.sprintf "<raw-html:%d chars>" (String.length s)
+  | Spread _ -> "<spread>"
+  | SxExpr s -> Printf.sprintf "<sx-expr:%d chars>" (String.length s)
+  | Env _ -> "<env>"

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,
@@ -1439,7 +1439,7 @@ 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"),
@@ -1484,15 +1484,14 @@ def compile_ref_to_py(
             spec_mod_set.add("page-helpers")
         if "router" in SPEC_MODULES:
             spec_mod_set.add("router")
-    # CEK is the canonical evaluator — always include
-    spec_mod_set.add("cek")
-    spec_mod_set.add("frames")
+    # CEK is always included (part of evaluator.sx core file)
+    has_cek = True
     has_deps = "deps" in spec_mod_set
-    has_cek = "cek" in spec_mod_set
 
     # Core files always included, then selected adapters, then spec modules
+    # evaluator.sx = merged frames + eval utilities + CEK machine
     sx_files = [
-        ("eval.sx", "eval"),
+        ("evaluator.sx", "evaluator (frames + eval + CEK)"),
         ("forms.sx", "forms (server definition forms)"),
         ("render.sx", "render (core)"),
     ]

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()
 
@@ -512,13 +525,24 @@ def env_merge(base, overlay):
     if base is overlay:
         # Same env — just extend with empty local scope for params
         return base.extend()
-    # Check if base is an ancestor of overlay — if so, no need to merge
-    # (common for self-recursive calls where closure == caller's ancestor)
+    # Check if base is an ancestor of overlay — if so, overlay contains
+    # everything in base. But overlay scopes between overlay and base may
+    # have extra local bindings (e.g. page helpers injected at request time).
+    # Only take the shortcut if no intermediate scope has local bindings.
     p = overlay
     depth = 0
     while p is not None and depth < 100:
         if p is base:
-            return base.extend()
+            q = overlay
+            has_extra = False
+            while q is not base:
+                if hasattr(q, '_bindings') and q._bindings:
+                    has_extra = True
+                    break
+                q = getattr(q, '_parent', None)
+            if not has_extra:
+                return base.extend()
+            break
         p = getattr(p, '_parent', None)
         depth += 1
     # MergedEnv: reads walk base then overlay; set! walks base only
@@ -1623,14 +1647,12 @@ SPEC_MODULES = {
     "signals": ("signals.sx", "signals (reactive signal runtime)"),
     "page-helpers": ("page-helpers.sx", "page-helpers (pure data transformation helpers)"),
     "types": ("types.sx", "types (gradual type system)"),
-    "frames": ("frames.sx", "frames (CEK continuation frames)"),
-    "cek": ("cek.sx", "cek (explicit CEK machine evaluator)"),
 }
+# Note: frames and cek are now part of evaluator.sx (always loaded as core)
 
 # Explicit ordering for spec modules with dependencies.
-# Modules listed here are emitted in this order; any not listed use alphabetical.
 SPEC_MODULE_ORDER = [
-    "deps", "engine", "frames", "page-helpers", "router", "cek", "signals", "types",
+    "deps", "engine", "page-helpers", "router", "signals", "types",
 ]
 
 EXTENSION_NAMES = {"continuations"}

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-continuations-advanced.sx", "test-types.sx", "test-freeze.sx", "test-strict.sx", "test-cek.sx", "test-cek-advanced.sx", "test-signals-advanced.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/sx/jinja_bridge.py

@@ -31,7 +31,13 @@ from typing import Any
 from .types import NIL, Component, Island, Keyword, Lambda, Macro, Symbol
 from .parser import parse
 import os as _os
-if _os.environ.get("SX_USE_REF") == "1":
+if _os.environ.get("SX_USE_OCAML") == "1":
+    # OCaml kernel bridge — render via persistent subprocess.
+    # html_render and _render_component are set up lazily since the bridge
+    # requires an async event loop.  The sync sx() function falls back to
+    # the ref renderer; async callers use ocaml_bridge directly.
+    from .ref.sx_ref import render as html_render, render_html_component as _render_component
+elif _os.environ.get("SX_USE_REF") == "1":
     from .ref.sx_ref import render as html_render, render_html_component as _render_component
 else:
     from .html import render as html_render, _render_component
@@ -348,6 +354,12 @@ def reload_if_changed() -> None:
         reload_logger.info("Reloaded %d file(s), components in %.1fms",
                      len(changed_files), (t1 - t0) * 1000)
 
+        # Invalidate OCaml bridge component cache so next render reloads
+        if _os.environ.get("SX_USE_OCAML") == "1":
+            from .ocaml_bridge import _bridge
+            if _bridge is not None:
+                _bridge._components_loaded = False
+
         # Recompute render plans for all services that have pages
         from .pages import _PAGE_REGISTRY, compute_page_render_plans
         for svc in _PAGE_REGISTRY:
@@ -430,6 +442,9 @@ def finalize_components() -> None:
     compute_all_io_refs(_COMPONENT_ENV, get_all_io_names())
     _compute_component_hash()
 
+    # OCaml bridge loads components lazily on first render via
+    # OcamlBridge._ensure_components() — no sync needed here.
+
 
 # ---------------------------------------------------------------------------
 # sx() — render s-expression from Jinja template
@@ -482,7 +497,16 @@ async def sx_async(source: str, **kwargs: Any) -> str:
     Use when the s-expression contains I/O nodes::
 
         {{ sx_async('(frag "blog" "card" :slug "apple")') | safe }}
+
+    When SX_USE_OCAML=1, renders via the OCaml kernel subprocess which
+    yields io-requests back to Python for async fulfillment.
     """
+    if _os.environ.get("SX_USE_OCAML") == "1":
+        from .ocaml_bridge import get_bridge
+        bridge = await get_bridge()
+        ctx = dict(kwargs)
+        return await bridge.render(source, ctx=ctx)
+
     from .resolver import resolve, RequestContext
 
     env = dict(_COMPONENT_ENV)

shared/sx/ocaml_bridge.py

@@ -0,0 +1,408 @@
+"""
+OCaml SX kernel ↔ Python coroutine bridge.
+
+Manages a persistent OCaml subprocess (sx_server) that evaluates SX
+expressions.  When the OCaml kernel needs IO (database queries, service
+calls), it yields an ``(io-request ...)`` back to Python, which fulfills
+it asynchronously and sends an ``(io-response ...)`` back.
+
+Usage::
+
+    bridge = OcamlBridge()
+    await bridge.start()
+    html = await bridge.render('(div (p "hello"))')
+    await bridge.stop()
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from typing import Any
+
+_logger = logging.getLogger("sx.ocaml")
+
+# Default binary path — can be overridden via SX_OCAML_BIN env var
+_DEFAULT_BIN = os.path.join(
+    os.path.dirname(__file__),
+    "../../hosts/ocaml/_build/default/bin/sx_server.exe",
+)
+
+
+class OcamlBridgeError(Exception):
+    """Error from the OCaml SX kernel."""
+
+
+class OcamlBridge:
+    """Async bridge to a persistent OCaml SX subprocess."""
+
+    def __init__(self, binary: str | None = None):
+        self._binary = binary or os.environ.get("SX_OCAML_BIN") or _DEFAULT_BIN
+        self._proc: asyncio.subprocess.Process | None = None
+        self._lock = asyncio.Lock()
+        self._started = False
+        self._components_loaded = False
+
+    async def start(self) -> None:
+        """Launch the OCaml subprocess and wait for (ready)."""
+        if self._started:
+            return
+
+        bin_path = os.path.abspath(self._binary)
+        if not os.path.isfile(bin_path):
+            raise FileNotFoundError(
+                f"OCaml SX server binary not found: {bin_path}\n"
+                f"Build with: cd hosts/ocaml && eval $(opam env) && dune build"
+            )
+
+        _logger.info("Starting OCaml SX kernel: %s", bin_path)
+        self._proc = await asyncio.create_subprocess_exec(
+            bin_path,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        # Wait for (ready)
+        line = await self._readline()
+        if line != "(ready)":
+            raise OcamlBridgeError(f"Expected (ready), got: {line!r}")
+
+        self._started = True
+
+        # Verify engine identity
+        self._send("(ping)")
+        kind, engine = await self._read_response()
+        engine_name = engine if kind == "ok" else "unknown"
+        _logger.info("OCaml SX kernel ready (pid=%d, engine=%s)", self._proc.pid, engine_name)
+
+    async def stop(self) -> None:
+        """Terminate the subprocess."""
+        if self._proc and self._proc.returncode is None:
+            self._proc.stdin.close()
+            try:
+                await asyncio.wait_for(self._proc.wait(), timeout=5.0)
+            except asyncio.TimeoutError:
+                self._proc.kill()
+                await self._proc.wait()
+            _logger.info("OCaml SX kernel stopped")
+        self._proc = None
+        self._started = False
+
+    async def ping(self) -> str:
+        """Health check — returns engine name (e.g. 'ocaml-cek')."""
+        async with self._lock:
+            self._send("(ping)")
+            kind, value = await self._read_response()
+            return value or "" if kind == "ok" else ""
+
+    async def load(self, path: str) -> int:
+        """Load an .sx file for side effects (defcomp, define, defmacro)."""
+        async with self._lock:
+            self._send(f'(load "{_escape(path)}")')
+            kind, value = await self._read_response()
+            if kind == "error":
+                raise OcamlBridgeError(f"load {path}: {value}")
+            return int(float(value)) if value else 0
+
+    async def load_source(self, source: str) -> int:
+        """Evaluate SX source for side effects."""
+        async with self._lock:
+            self._send(f'(load-source "{_escape(source)}")')
+            kind, value = await self._read_response()
+            if kind == "error":
+                raise OcamlBridgeError(f"load-source: {value}")
+            return int(float(value)) if value else 0
+
+    async def eval(self, source: str) -> str:
+        """Evaluate SX expression, return serialized result."""
+        async with self._lock:
+            self._send(f'(eval "{_escape(source)}")')
+            kind, value = await self._read_response()
+            if kind == "error":
+                raise OcamlBridgeError(f"eval: {value}")
+            return value or ""
+
+    async def render(
+        self,
+        source: str,
+        ctx: dict[str, Any] | None = None,
+    ) -> str:
+        """Render SX to HTML, handling io-requests via Python async IO."""
+        await self._ensure_components()
+        async with self._lock:
+            self._send(f'(render "{_escape(source)}")')
+            return await self._read_until_ok(ctx)
+
+    async def _ensure_components(self) -> None:
+        """Load component definitions into the kernel on first use."""
+        if self._components_loaded:
+            return
+        self._components_loaded = True
+        try:
+            from .jinja_bridge import get_component_env, _CLIENT_LIBRARY_SOURCES
+            from .parser import serialize
+            from .types import Component, Island, Macro
+
+            env = get_component_env()
+            parts: list[str] = list(_CLIENT_LIBRARY_SOURCES)
+            for key, val in env.items():
+                if isinstance(val, Island):
+                    ps = ["&key"] + list(val.params)
+                    if val.has_children:
+                        ps.extend(["&rest", "children"])
+                    parts.append(f"(defisland ~{val.name} ({' '.join(ps)}) {serialize(val.body)})")
+                elif isinstance(val, Component):
+                    ps = ["&key"] + list(val.params)
+                    if val.has_children:
+                        ps.extend(["&rest", "children"])
+                    parts.append(f"(defcomp ~{val.name} ({' '.join(ps)}) {serialize(val.body)})")
+                elif isinstance(val, Macro):
+                    ps = list(val.params)
+                    if val.rest_param:
+                        ps.extend(["&rest", val.rest_param])
+                    parts.append(f"(defmacro {val.name} ({' '.join(ps)}) {serialize(val.body)})")
+            if parts:
+                source = "\n".join(parts)
+                await self.load_source(source)
+                _logger.info("Loaded %d definitions into OCaml kernel", len(parts))
+        except Exception as e:
+            _logger.error("Failed to load components into OCaml kernel: %s", e)
+            self._components_loaded = False  # retry next time
+
+    async def reset(self) -> None:
+        """Reset the kernel environment to pristine state."""
+        async with self._lock:
+            self._send("(reset)")
+            kind, value = await self._read_response()
+            if kind == "error":
+                raise OcamlBridgeError(f"reset: {value}")
+
+    # ------------------------------------------------------------------
+    # Internal protocol handling
+    # ------------------------------------------------------------------
+
+    def _send(self, line: str) -> None:
+        """Write a line to the subprocess stdin."""
+        assert self._proc and self._proc.stdin
+        self._proc.stdin.write((line + "\n").encode())
+
+    async def _readline(self) -> str:
+        """Read a line from the subprocess stdout."""
+        assert self._proc and self._proc.stdout
+        data = await self._proc.stdout.readline()
+        if not data:
+            # Process died — collect stderr for diagnostics
+            stderr = b""
+            if self._proc.stderr:
+                stderr = await self._proc.stderr.read()
+            raise OcamlBridgeError(
+                f"OCaml subprocess died unexpectedly. stderr: {stderr.decode(errors='replace')}"
+            )
+        return data.decode().rstrip("\n")
+
+    async def _read_response(self) -> tuple[str, str | None]:
+        """Read a single (ok ...) or (error ...) response.
+
+        Returns (kind, value) where kind is "ok" or "error".
+        """
+        line = await self._readline()
+        return _parse_response(line)
+
+    async def _read_until_ok(
+        self,
+        ctx: dict[str, Any] | None = None,
+    ) -> str:
+        """Read lines until (ok ...) or (error ...).
+
+        Handles (io-request ...) by fulfilling IO and sending (io-response ...).
+        """
+        while True:
+            line = await self._readline()
+
+            if line.startswith("(io-request "):
+                result = await self._handle_io_request(line, ctx)
+                # Send response back to OCaml
+                self._send(f"(io-response {_serialize_for_ocaml(result)})")
+                continue
+
+            kind, value = _parse_response(line)
+            if kind == "error":
+                raise OcamlBridgeError(value or "Unknown error")
+            # kind == "ok"
+            return value or ""
+
+    async def _handle_io_request(
+        self,
+        line: str,
+        ctx: dict[str, Any] | None,
+    ) -> Any:
+        """Dispatch an io-request to the appropriate Python handler."""
+        from .parser import parse_all
+
+        # Parse the io-request
+        parsed = parse_all(line)
+        if not parsed or not isinstance(parsed[0], list):
+            raise OcamlBridgeError(f"Malformed io-request: {line}")
+
+        parts = parsed[0]
+        # parts = [Symbol("io-request"), name_str, ...args]
+        if len(parts) < 2:
+            raise OcamlBridgeError(f"Malformed io-request: {line}")
+
+        req_name = _to_str(parts[1])
+        args = parts[2:]
+
+        if req_name == "query":
+            return await self._io_query(args)
+        elif req_name == "action":
+            return await self._io_action(args)
+        elif req_name == "request-arg":
+            return self._io_request_arg(args)
+        elif req_name == "request-method":
+            return self._io_request_method()
+        elif req_name == "ctx":
+            return self._io_ctx(args, ctx)
+        else:
+            raise OcamlBridgeError(f"Unknown io-request type: {req_name}")
+
+    async def _io_query(self, args: list) -> Any:
+        """Handle (io-request "query" service name params...)."""
+        from shared.infrastructure.internal import fetch_data
+
+        service = _to_str(args[0]) if len(args) > 0 else ""
+        query = _to_str(args[1]) if len(args) > 1 else ""
+        params = _to_dict(args[2]) if len(args) > 2 else {}
+        return await fetch_data(service, query, params)
+
+    async def _io_action(self, args: list) -> Any:
+        """Handle (io-request "action" service name payload...)."""
+        from shared.infrastructure.internal import call_action
+
+        service = _to_str(args[0]) if len(args) > 0 else ""
+        action = _to_str(args[1]) if len(args) > 1 else ""
+        payload = _to_dict(args[2]) if len(args) > 2 else {}
+        return await call_action(service, action, payload)
+
+    def _io_request_arg(self, args: list) -> Any:
+        """Handle (io-request "request-arg" name)."""
+        try:
+            from quart import request
+            name = _to_str(args[0]) if args else ""
+            return request.args.get(name)
+        except RuntimeError:
+            return None
+
+    def _io_request_method(self) -> str:
+        """Handle (io-request "request-method")."""
+        try:
+            from quart import request
+            return request.method
+        except RuntimeError:
+            return "GET"
+
+    def _io_ctx(self, args: list, ctx: dict[str, Any] | None) -> Any:
+        """Handle (io-request "ctx" key)."""
+        if ctx is None:
+            return None
+        key = _to_str(args[0]) if args else ""
+        return ctx.get(key)
+
+
+# ------------------------------------------------------------------
+# Module-level singleton
+# ------------------------------------------------------------------
+
+_bridge: OcamlBridge | None = None
+
+
+async def get_bridge() -> OcamlBridge:
+    """Get or create the singleton bridge instance."""
+    global _bridge
+    if _bridge is None:
+        _bridge = OcamlBridge()
+    if not _bridge._started:
+        await _bridge.start()
+    return _bridge
+
+
+# ------------------------------------------------------------------
+# Helpers
+# ------------------------------------------------------------------
+
+def _escape(s: str) -> str:
+    """Escape a string for embedding in an SX string literal."""
+    return s.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t")
+
+
+def _parse_response(line: str) -> tuple[str, str | None]:
+    """Parse an (ok ...) or (error ...) response line.
+
+    Returns (kind, value) tuple.
+    """
+    line = line.strip()
+    if line == "(ok)":
+        return ("ok", None)
+    if line.startswith("(ok "):
+        value = line[4:-1]  # strip (ok  and )
+        # If the value is a quoted string, unquote it
+        if value.startswith('"') and value.endswith('"'):
+            value = _unescape(value[1:-1])
+        return ("ok", value)
+    if line.startswith("(error "):
+        msg = line[7:-1]
+        if msg.startswith('"') and msg.endswith('"'):
+            msg = _unescape(msg[1:-1])
+        return ("error", msg)
+    return ("error", f"Unexpected response: {line}")
+
+
+def _unescape(s: str) -> str:
+    """Unescape an SX string literal."""
+    return (
+        s.replace("\\n", "\n")
+        .replace("\\r", "\r")
+        .replace("\\t", "\t")
+        .replace('\\"', '"')
+        .replace("\\\\", "\\")
+    )
+
+
+def _to_str(val: Any) -> str:
+    """Convert an SX parsed value to a Python string."""
+    if isinstance(val, str):
+        return val
+    if hasattr(val, "name"):
+        return val.name
+    return str(val)
+
+
+def _to_dict(val: Any) -> dict:
+    """Convert an SX parsed value to a Python dict."""
+    if isinstance(val, dict):
+        return val
+    return {}
+
+
+def _serialize_for_ocaml(val: Any) -> str:
+    """Serialize a Python value to SX text for sending to OCaml."""
+    if val is None:
+        return "nil"
+    if isinstance(val, bool):
+        return "true" if val else "false"
+    if isinstance(val, (int, float)):
+        if isinstance(val, float) and val == int(val):
+            return str(int(val))
+        return str(val)
+    if isinstance(val, str):
+        return f'"{_escape(val)}"'
+    if isinstance(val, (list, tuple)):
+        items = " ".join(_serialize_for_ocaml(v) for v in val)
+        return f"(list {items})"
+    if isinstance(val, dict):
+        pairs = " ".join(
+            f":{k} {_serialize_for_ocaml(v)}" for k, v in val.items()
+        )
+        return "{" + pairs + "}"
+    return f'"{_escape(str(val))}"'

shared/sx/pages.py

@@ -23,11 +23,28 @@ import logging
 import os
 from typing import Any
 
-from .types import PageDef
+import traceback
+
+from .types import EvalError, PageDef
 
 logger = logging.getLogger("sx.pages")
 
 
+def _eval_error_sx(e: EvalError, context: str) -> str:
+    """Render an EvalError as SX content that's visible to the developer."""
+    from .ref.sx_ref import escape_html as _esc
+    msg = _esc(str(e))
+    ctx = _esc(context)
+    return (
+        f'(div :class "sx-eval-error" :style '
+        f'"background:#fef2f2;border:1px solid #fca5a5;'
+        f'color:#991b1b;padding:1rem;margin:1rem 0;'
+        f'border-radius:0.5rem;font-family:monospace;white-space:pre-wrap"'
+        f' (p :style "font-weight:700;margin:0 0 0.5rem" "SX EvalError in {ctx}")'
+        f' (p :style "margin:0" "{msg}"))'
+    )
+
+
 # ---------------------------------------------------------------------------
 # Registry — service → page-name → PageDef
 # ---------------------------------------------------------------------------
@@ -511,8 +528,12 @@ async def execute_page_streaming(
             aside_sx = await _eval_slot(page_def.aside_expr, data_env, ctx) if page_def.aside_expr else ""
             menu_sx = await _eval_slot(page_def.menu_expr, data_env, ctx) if page_def.menu_expr else ""
             await _stream_queue.put(("data-single", content_sx, filter_sx, aside_sx, menu_sx))
+        except EvalError as e:
+            logger.error("Streaming data task failed (EvalError): %s\n%s", e, traceback.format_exc())
+            error_sx = _eval_error_sx(e, "page content")
+            await _stream_queue.put(("data-single", error_sx, "", "", ""))
         except Exception as e:
-            logger.error("Streaming data task failed: %s", e)
+            logger.error("Streaming data task failed: %s\n%s", e, traceback.format_exc())
             await _stream_queue.put(("data-done",))
 
     async def _eval_headers():
@@ -524,7 +545,7 @@ async def execute_page_streaming(
             menu = await layout.mobile_menu(tctx, **layout_kwargs)
             await _stream_queue.put(("headers", rows, menu))
         except Exception as e:
-            logger.error("Streaming headers task failed: %s", e)
+            logger.error("Streaming headers task failed: %s\n%s", e, traceback.format_exc())
             await _stream_queue.put(("headers", "", ""))
 
     data_task = asyncio.create_task(_eval_data_and_content())
@@ -629,7 +650,7 @@ async def execute_page_streaming(
                 elif kind == "data-done":
                     remaining -= 1
             except Exception as e:
-                logger.error("Streaming resolve failed for %s: %s", kind, e)
+                logger.error("Streaming resolve failed for %s: %s\n%s", kind, e, traceback.format_exc())
 
         yield "\n</body>\n</html>"
 
@@ -733,8 +754,13 @@ async def execute_page_streaming_oob(
                     await _stream_queue.put(("data-done",))
                     return
             await _stream_queue.put(("data-done",))
+        except EvalError as e:
+            logger.error("Streaming OOB data task failed (EvalError): %s\n%s", e, traceback.format_exc())
+            error_sx = _eval_error_sx(e, "page content")
+            await _stream_queue.put(("data", "stream-content", error_sx))
+            await _stream_queue.put(("data-done",))
         except Exception as e:
-            logger.error("Streaming OOB data task failed: %s", e)
+            logger.error("Streaming OOB data task failed: %s\n%s", e, traceback.format_exc())
             await _stream_queue.put(("data-done",))
 
     async def _eval_oob_headers():
@@ -745,7 +771,7 @@ async def execute_page_streaming_oob(
             else:
                 await _stream_queue.put(("headers", ""))
         except Exception as e:
-            logger.error("Streaming OOB headers task failed: %s", e)
+            logger.error("Streaming OOB headers task failed: %s\n%s", e, traceback.format_exc())
             await _stream_queue.put(("headers", ""))
 
     data_task = asyncio.create_task(_eval_data())
@@ -836,7 +862,7 @@ async def execute_page_streaming_oob(
                 elif kind == "data-done":
                     remaining -= 1
             except Exception as e:
-                logger.error("Streaming OOB resolve failed for %s: %s", kind, e)
+                logger.error("Streaming OOB resolve failed for %s: %s\n%s", kind, e, traceback.format_exc())
 
     return _stream_oob_chunks()
 

shared/sx/primitives.py

@@ -573,3 +573,32 @@ def prim_json_encode(value) -> str:
     import json
     return json.dumps(value, indent=2)
 
+
+# ---------------------------------------------------------------------------
+# Scope primitives — delegate to sx_ref.py's scope stack implementation
+# (shared global state between transpiled and hand-written evaluators)
+# ---------------------------------------------------------------------------
+
+def _lazy_scope_primitives():
+    """Register scope/provide/collect primitives from sx_ref.py.
+
+    Called at import time — if sx_ref.py isn't built yet, silently skip.
+    These are needed by the hand-written _aser in async_eval.py when
+    expanding components that use scoped effects (e.g. ~cssx/flush).
+    """
+    try:
+        from .ref.sx_ref import (
+            sx_collect, sx_collected, sx_clear_collected,
+            sx_emitted, sx_emit, sx_context,
+        )
+        _PRIMITIVES["collect!"] = sx_collect
+        _PRIMITIVES["collected"] = sx_collected
+        _PRIMITIVES["clear-collected!"] = sx_clear_collected
+        _PRIMITIVES["emitted"] = sx_emitted
+        _PRIMITIVES["emit!"] = sx_emit
+        _PRIMITIVES["context"] = sx_context
+    except ImportError:
+        pass
+
+_lazy_scope_primitives()
+

shared/sx/ref/adapter-html.sx

@@ -1,545 +0,0 @@
-;; ==========================================================================
-;; adapter-html.sx — HTML string rendering adapter
-;;
-;; Renders evaluated SX expressions to HTML strings. Used server-side.
-;;
-;; Depends on:
-;;   render.sx  — HTML_TAGS, VOID_ELEMENTS, BOOLEAN_ATTRS,
-;;                parse-element-args, render-attrs, definition-form?
-;;   eval.sx    — eval-expr, trampoline, expand-macro, process-bindings,
-;;                eval-cond, env-has?, env-get, env-set!, env-merge,
-;;                lambda?, component?, island?, macro?,
-;;                lambda-closure, lambda-params, lambda-body
-;; ==========================================================================
-
-
-(define render-to-html :effects [render]
-  (fn (expr (env :as dict))
-    (set-render-active! true)
-    (case (type-of expr)
-      ;; Literals — render directly
-      "nil"     ""
-      "string"  (escape-html expr)
-      "number"  (str expr)
-      "boolean" (if expr "true" "false")
-      ;; List — dispatch to render-list which handles HTML tags, special forms, etc.
-      "list"    (if (empty? expr) "" (render-list-to-html expr env))
-      ;; Symbol — evaluate then render
-      "symbol"  (render-value-to-html (trampoline (eval-expr expr env)) env)
-      ;; Keyword — render as text
-      "keyword" (escape-html (keyword-name expr))
-      ;; Raw HTML passthrough
-      "raw-html" (raw-html-content expr)
-      ;; Spread — emit attrs to nearest element provider
-      "spread"  (do (emit! "element-attrs" (spread-attrs expr)) "")
-      ;; Everything else — evaluate first
-      :else     (render-value-to-html (trampoline (eval-expr expr env)) env))))
-
-(define render-value-to-html :effects [render]
-  (fn (val (env :as dict))
-    (case (type-of val)
-      "nil"     ""
-      "string"  (escape-html val)
-      "number"  (str val)
-      "boolean" (if val "true" "false")
-      "list"    (render-list-to-html val env)
-      "raw-html" (raw-html-content val)
-      "spread"  (do (emit! "element-attrs" (spread-attrs val)) "")
-      :else     (escape-html (str val)))))
-
-
-;; --------------------------------------------------------------------------
-;; Render-aware form classification
-;; --------------------------------------------------------------------------
-
-(define RENDER_HTML_FORMS
-  (list "if" "when" "cond" "case" "let" "let*" "begin" "do"
-        "define" "defcomp" "defisland" "defmacro" "defstyle" "defhandler"
-        "deftype" "defeffect"
-        "map" "map-indexed" "filter" "for-each" "scope" "provide"))
-
-(define render-html-form? :effects []
-  (fn ((name :as string))
-    (contains? RENDER_HTML_FORMS name)))
-
-
-;; --------------------------------------------------------------------------
-;; render-list-to-html — dispatch on list head
-;; --------------------------------------------------------------------------
-
-(define render-list-to-html :effects [render]
-  (fn ((expr :as list) (env :as dict))
-    (if (empty? expr)
-      ""
-      (let ((head (first expr)))
-        (if (not (= (type-of head) "symbol"))
-          ;; Data list — render each item
-          (join "" (map (fn (x) (render-value-to-html x env)) expr))
-          (let ((name (symbol-name head))
-                (args (rest expr)))
-            (cond
-              ;; Fragment
-              (= name "<>")
-                (join "" (map (fn (x) (render-to-html x env)) args))
-
-              ;; Raw HTML passthrough
-              (= name "raw!")
-                (join "" (map (fn (x) (str (trampoline (eval-expr x env)))) args))
-
-              ;; Lake — server-morphable slot within an island
-              (= name "lake")
-                (render-html-lake args env)
-
-              ;; Marsh — reactive server-morphable slot within an island
-              (= name "marsh")
-                (render-html-marsh args env)
-
-              ;; HTML tag
-              (contains? HTML_TAGS name)
-                (render-html-element name args env)
-
-              ;; Island (~name) — reactive component, SSR with hydration markers
-              (and (starts-with? name "~")
-                   (env-has? env name)
-                   (island? (env-get env name)))
-                (render-html-island (env-get env name) args env)
-
-              ;; Component or macro call (~name)
-              (starts-with? name "~")
-                (let ((val (env-get env name)))
-                  (cond
-                    (component? val)
-                      (render-html-component val args env)
-                    (macro? val)
-                      (render-to-html
-                        (expand-macro val args env)
-                        env)
-                    :else
-                      (error (str "Unknown component: " name))))
-
-              ;; Render-aware special forms
-              (render-html-form? name)
-                (dispatch-html-form name expr env)
-
-              ;; Macro expansion
-              (and (env-has? env name) (macro? (env-get env name)))
-                (render-to-html
-                  (expand-macro (env-get env name) args env)
-                  env)
-
-              ;; Fallback — evaluate then render result
-              :else
-                (render-value-to-html
-                  (trampoline (eval-expr expr env))
-                  env))))))))
-
-
-;; --------------------------------------------------------------------------
-;; dispatch-html-form — render-aware special form handling for HTML output
-;; --------------------------------------------------------------------------
-
-(define dispatch-html-form :effects [render]
-  (fn ((name :as string) (expr :as list) (env :as dict))
-    (cond
-      ;; if
-      (= name "if")
-        (let ((cond-val (trampoline (eval-expr (nth expr 1) env))))
-          (if cond-val
-            (render-to-html (nth expr 2) env)
-            (if (> (len expr) 3)
-              (render-to-html (nth expr 3) env)
-              "")))
-
-      ;; when — single body: pass through. Multi: join strings.
-      (= name "when")
-        (if (not (trampoline (eval-expr (nth expr 1) env)))
-          ""
-          (if (= (len expr) 3)
-            (render-to-html (nth expr 2) env)
-            (join "" (map (fn (i) (render-to-html (nth expr i) env))
-                          (range 2 (len expr))))))
-
-      ;; cond
-      (= name "cond")
-        (let ((branch (eval-cond (rest expr) env)))
-          (if branch
-            (render-to-html branch env)
-            ""))
-
-      ;; case
-      (= name "case")
-        (render-to-html (trampoline (eval-expr expr env)) env)
-
-      ;; let / let* — single body: pass through. Multi: join strings.
-      (or (= name "let") (= name "let*"))
-        (let ((local (process-bindings (nth expr 1) env)))
-          (if (= (len expr) 3)
-            (render-to-html (nth expr 2) local)
-            (join "" (map (fn (i) (render-to-html (nth expr i) local))
-                          (range 2 (len expr))))))
-
-      ;; begin / do — single body: pass through. Multi: join strings.
-      (or (= name "begin") (= name "do"))
-        (if (= (len expr) 2)
-          (render-to-html (nth expr 1) env)
-          (join "" (map (fn (i) (render-to-html (nth expr i) env))
-                        (range 1 (len expr)))))
-
-      ;; Definition forms — eval for side effects
-      (definition-form? name)
-        (do (trampoline (eval-expr expr env)) "")
-
-      ;; map
-      (= name "map")
-        (let ((f (trampoline (eval-expr (nth expr 1) env)))
-              (coll (trampoline (eval-expr (nth expr 2) env))))
-          (join ""
-            (map
-              (fn (item)
-                (if (lambda? f)
-                  (render-lambda-html f (list item) env)
-                  (render-to-html (apply f (list item)) env)))
-              coll)))
-
-      ;; map-indexed
-      (= name "map-indexed")
-        (let ((f (trampoline (eval-expr (nth expr 1) env)))
-              (coll (trampoline (eval-expr (nth expr 2) env))))
-          (join ""
-            (map-indexed
-              (fn (i item)
-                (if (lambda? f)
-                  (render-lambda-html f (list i item) env)
-                  (render-to-html (apply f (list i item)) env)))
-              coll)))
-
-      ;; filter — evaluate fully then render
-      (= name "filter")
-        (render-to-html (trampoline (eval-expr expr env)) env)
-
-      ;; for-each (render variant)
-      (= name "for-each")
-        (let ((f (trampoline (eval-expr (nth expr 1) env)))
-              (coll (trampoline (eval-expr (nth expr 2) env))))
-          (join ""
-            (map
-              (fn (item)
-                (if (lambda? f)
-                  (render-lambda-html f (list item) env)
-                  (render-to-html (apply f (list item)) env)))
-              coll)))
-
-      ;; scope — unified render-time dynamic scope
-      (= name "scope")
-        (let ((scope-name (trampoline (eval-expr (nth expr 1) env)))
-              (rest-args (slice expr 2))
-              (scope-val nil)
-              (body-exprs nil))
-          ;; Check for :value keyword
-          (if (and (>= (len rest-args) 2)
-                   (= (type-of (first rest-args)) "keyword")
-                   (= (keyword-name (first rest-args)) "value"))
-            (do (set! scope-val (trampoline (eval-expr (nth rest-args 1) env)))
-                (set! body-exprs (slice rest-args 2)))
-            (set! body-exprs rest-args))
-          (scope-push! scope-name scope-val)
-          (let ((result (if (= (len body-exprs) 1)
-                          (render-to-html (first body-exprs) env)
-                          (join "" (map (fn (e) (render-to-html e env)) body-exprs)))))
-            (scope-pop! scope-name)
-            result))
-
-      ;; provide — sugar for scope with value
-      (= name "provide")
-        (let ((prov-name (trampoline (eval-expr (nth expr 1) env)))
-              (prov-val (trampoline (eval-expr (nth expr 2) env)))
-              (body-start 3)
-              (body-count (- (len expr) 3)))
-          (scope-push! prov-name prov-val)
-          (let ((result (if (= body-count 1)
-                          (render-to-html (nth expr body-start) env)
-                          (join "" (map (fn (i) (render-to-html (nth expr i) env))
-                                       (range body-start (+ body-start body-count)))))))
-            (scope-pop! prov-name)
-            result))
-
-      ;; Fallback
-      :else
-        (render-value-to-html (trampoline (eval-expr expr env)) env))))
-
-
-;; --------------------------------------------------------------------------
-;; render-lambda-html — render a lambda body in HTML context
-;; --------------------------------------------------------------------------
-
-(define render-lambda-html :effects [render]
-  (fn ((f :as lambda) (args :as list) (env :as dict))
-    (let ((local (env-merge (lambda-closure f) env)))
-      (for-each-indexed
-        (fn (i p)
-          (env-set! local p (nth args i)))
-        (lambda-params f))
-      (render-to-html (lambda-body f) local))))
-
-
-;; --------------------------------------------------------------------------
-;; render-html-component — expand and render a component
-;; --------------------------------------------------------------------------
-
-(define render-html-component :effects [render]
-  (fn ((comp :as component) (args :as list) (env :as dict))
-    ;; Expand component and render body through HTML adapter.
-    ;; Component body contains rendering forms (HTML tags) that only the
-    ;; adapter understands, so expansion must happen here, not in eval-expr.
-    (let ((kwargs (dict))
-          (children (list)))
-      ;; Separate keyword args from positional children
-      (reduce
-        (fn (state arg)
-          (let ((skip (get state "skip")))
-            (if skip
-              (assoc state "skip" false "i" (inc (get state "i")))
-              (if (and (= (type-of arg) "keyword")
-                       (< (inc (get state "i")) (len args)))
-                (let ((val (trampoline
-                             (eval-expr (nth args (inc (get state "i"))) env))))
-                  (dict-set! kwargs (keyword-name arg) val)
-                  (assoc state "skip" true "i" (inc (get state "i"))))
-                (do
-                  (append! children arg)
-                  (assoc state "i" (inc (get state "i"))))))))
-        (dict "i" 0 "skip" false)
-        args)
-      ;; Build component env: closure + caller env + params
-      (let ((local (env-merge (component-closure comp) env)))
-        ;; Bind params from kwargs
-        (for-each
-          (fn (p)
-            (env-set! 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"
-            (make-raw-html (join "" (map (fn (c) (render-to-html c env)) children)))))
-        (render-to-html (component-body comp) local)))))
-
-
-(define render-html-element :effects [render]
-  (fn ((tag :as string) (args :as list) (env :as dict))
-    (let ((parsed (parse-element-args args env))
-          (attrs  (first parsed))
-          (children (nth parsed 1))
-          (is-void (contains? VOID_ELEMENTS tag)))
-      (if is-void
-        (str "<" tag (render-attrs attrs) " />")
-        ;; Provide scope for spread emit!
-        (do
-          (scope-push! "element-attrs" nil)
-          (let ((content (join "" (map (fn (c) (render-to-html c env)) children))))
-            (for-each
-              (fn (spread-dict) (merge-spread-attrs attrs spread-dict))
-              (emitted "element-attrs"))
-            (scope-pop! "element-attrs")
-            (str "<" tag (render-attrs attrs) ">"
-              content
-              "</" tag ">")))))))
-
-
-;; --------------------------------------------------------------------------
-;; render-html-lake — SSR rendering of a server-morphable slot
-;; --------------------------------------------------------------------------
-;;
-;; (lake :id "name" children...) → <div data-sx-lake="name">children</div>
-;;
-;; Lakes are server territory inside islands. The morph can update lake
-;; content while preserving surrounding reactive DOM.
-
-(define render-html-lake :effects [render]
-  (fn ((args :as list) (env :as dict))
-    (let ((lake-id nil)
-          (lake-tag "div")
-          (children (list)))
-      (reduce
-        (fn (state arg)
-          (let ((skip (get state "skip")))
-            (if skip
-              (assoc state "skip" false "i" (inc (get state "i")))
-              (if (and (= (type-of arg) "keyword")
-                       (< (inc (get state "i")) (len args)))
-                (let ((kname (keyword-name arg))
-                      (kval (trampoline (eval-expr (nth args (inc (get state "i"))) env))))
-                  (cond
-                    (= kname "id")  (set! lake-id kval)
-                    (= kname "tag") (set! lake-tag kval))
-                  (assoc state "skip" true "i" (inc (get state "i"))))
-                (do
-                  (append! children arg)
-                  (assoc state "i" (inc (get state "i"))))))))
-        (dict "i" 0 "skip" false)
-        args)
-      ;; Provide scope for spread emit!
-      (let ((lake-attrs (dict "data-sx-lake" (or lake-id ""))))
-        (scope-push! "element-attrs" nil)
-        (let ((content (join "" (map (fn (c) (render-to-html c env)) children))))
-          (for-each
-            (fn (spread-dict) (merge-spread-attrs lake-attrs spread-dict))
-            (emitted "element-attrs"))
-          (scope-pop! "element-attrs")
-          (str "<" lake-tag (render-attrs lake-attrs) ">"
-               content
-               "</" lake-tag ">"))))))
-
-
-;; --------------------------------------------------------------------------
-;; render-html-marsh — SSR rendering of a reactive server-morphable slot
-;; --------------------------------------------------------------------------
-;;
-;; (marsh :id "name" :tag "div" :transform fn children...)
-;; → <div data-sx-marsh="name">children</div>
-;;
-;; Like a lake but reactive: during morph, new content is parsed as SX and
-;; re-evaluated in the island's signal scope. Server renders children normally;
-;; the :transform is a client-only concern.
-
-(define render-html-marsh :effects [render]
-  (fn ((args :as list) (env :as dict))
-    (let ((marsh-id nil)
-          (marsh-tag "div")
-          (children (list)))
-      (reduce
-        (fn (state arg)
-          (let ((skip (get state "skip")))
-            (if skip
-              (assoc state "skip" false "i" (inc (get state "i")))
-              (if (and (= (type-of arg) "keyword")
-                       (< (inc (get state "i")) (len args)))
-                (let ((kname (keyword-name arg))
-                      (kval (trampoline (eval-expr (nth args (inc (get state "i"))) env))))
-                  (cond
-                    (= kname "id")        (set! marsh-id kval)
-                    (= kname "tag")       (set! marsh-tag kval)
-                    (= kname "transform") nil)
-                  (assoc state "skip" true "i" (inc (get state "i"))))
-                (do
-                  (append! children arg)
-                  (assoc state "i" (inc (get state "i"))))))))
-        (dict "i" 0 "skip" false)
-        args)
-      ;; Provide scope for spread emit!
-      (let ((marsh-attrs (dict "data-sx-marsh" (or marsh-id ""))))
-        (scope-push! "element-attrs" nil)
-        (let ((content (join "" (map (fn (c) (render-to-html c env)) children))))
-          (for-each
-            (fn (spread-dict) (merge-spread-attrs marsh-attrs spread-dict))
-            (emitted "element-attrs"))
-          (scope-pop! "element-attrs")
-          (str "<" marsh-tag (render-attrs marsh-attrs) ">"
-               content
-               "</" marsh-tag ">"))))))
-
-
-;; --------------------------------------------------------------------------
-;; render-html-island — SSR rendering of a reactive island
-;; --------------------------------------------------------------------------
-;;
-;; Renders the island body as static HTML wrapped in a container element
-;; with data-sx-island and data-sx-state attributes. The client hydrates
-;; this by finding these elements and re-rendering with reactive context.
-;;
-;; On the server, signal/deref/reset!/swap! are simple passthrough:
-;;   (signal val) → returns val (no container needed server-side)
-;;   (deref s)    → returns s (signal values are plain values server-side)
-;;   (reset! s v) → no-op
-;;   (swap! s f)  → no-op
-
-(define render-html-island :effects [render]
-  (fn ((island :as island) (args :as list) (env :as dict))
-    ;; Parse kwargs and children (same pattern as render-html-component)
-    (let ((kwargs (dict))
-          (children (list)))
-      (reduce
-        (fn (state arg)
-          (let ((skip (get state "skip")))
-            (if skip
-              (assoc state "skip" false "i" (inc (get state "i")))
-              (if (and (= (type-of arg) "keyword")
-                       (< (inc (get state "i")) (len args)))
-                (let ((val (trampoline
-                             (eval-expr (nth args (inc (get state "i"))) env))))
-                  (dict-set! kwargs (keyword-name arg) val)
-                  (assoc state "skip" true "i" (inc (get state "i"))))
-                (do
-                  (append! children arg)
-                  (assoc state "i" (inc (get state "i"))))))))
-        (dict "i" 0 "skip" false)
-        args)
-
-      ;; Build island env: closure + caller env + params
-      (let ((local (env-merge (component-closure island) env))
-            (island-name (component-name island)))
-
-        ;; Bind params from kwargs
-        (for-each
-          (fn (p)
-            (env-set! 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"
-            (make-raw-html (join "" (map (fn (c) (render-to-html c env)) children)))))
-
-        ;; Render the island body as HTML
-        (let ((body-html (render-to-html (component-body island) local))
-              (state-sx (serialize-island-state kwargs)))
-          ;; Wrap in container with hydration attributes
-          (str "<span data-sx-island=\"" (escape-attr island-name) "\""
-               (if state-sx
-                 (str " data-sx-state=\"" (escape-attr state-sx) "\"")
-                 "")
-               ">"
-               body-html
-               "</span>"))))))
-
-
-;; --------------------------------------------------------------------------
-;; serialize-island-state — serialize kwargs to SX for hydration
-;; --------------------------------------------------------------------------
-;;
-;; Uses the SX serializer (not JSON) so the client can parse with sx-parse.
-;; Handles all SX types natively: numbers, strings, booleans, nil, lists, dicts.
-
-(define serialize-island-state :effects []
-  (fn ((kwargs :as dict))
-    (if (empty-dict? kwargs)
-      nil
-      (sx-serialize kwargs))))
-
-
-;; --------------------------------------------------------------------------
-;; Platform interface — HTML adapter
-;; --------------------------------------------------------------------------
-;;
-;; Inherited from render.sx:
-;;   escape-html, escape-attr, raw-html-content
-;;
-;; From eval.sx:
-;;   eval-expr, trampoline, expand-macro, process-bindings, eval-cond
-;;   env-has?, env-get, env-set!, env-merge
-;;   lambda?, component?, island?, macro?
-;;   lambda-closure, lambda-params, lambda-body
-;;   component-params, component-body, component-closure,
-;;   component-has-children?, component-name
-;;
-;; Raw HTML construction:
-;;   (make-raw-html s)          → wrap string as raw HTML (not double-escaped)
-;;
-;; Island state serialization:
-;;   (sx-serialize val)         → SX source string (from parser.sx)
-;;   (empty-dict? d)            → boolean
-;;   (escape-attr s)            → HTML attribute escape
-;;
-;; Iteration:
-;;   (for-each-indexed fn coll) → call fn(index, item) for each element
-;;   (map-indexed fn coll)      → map fn(index, item) over each element
-;; --------------------------------------------------------------------------

shared/sx/ref/adapter-sx.sx

@@ -1,407 +0,0 @@
-;; ==========================================================================
-;; adapter-sx.sx — SX wire format rendering adapter
-;;
-;; Serializes SX expressions for client-side rendering.
-;; Component calls are NOT expanded — they're sent to the client as-is.
-;; HTML tags are serialized as SX source text. Special forms are evaluated.
-;;
-;; Depends on:
-;;   render.sx  — HTML_TAGS
-;;   eval.sx    — eval-expr, trampoline, call-lambda, expand-macro
-;; ==========================================================================
-
-
-(define render-to-sx :effects [render]
-  (fn (expr (env :as dict))
-    (let ((result (aser expr env)))
-      ;; aser-call already returns serialized SX strings;
-      ;; only serialize non-string values
-      (if (= (type-of result) "string")
-        result
-        (serialize result)))))
-
-(define aser :effects [render]
-  (fn ((expr :as any) (env :as dict))
-    ;; Evaluate for SX wire format — serialize rendering forms,
-    ;; evaluate control flow and function calls.
-    (set-render-active! true)
-    (let ((result
-      (case (type-of expr)
-        "number"  expr
-        "string"  expr
-        "boolean" expr
-        "nil"     nil
-
-        "symbol"
-          (let ((name (symbol-name expr)))
-            (cond
-              (env-has? env name)     (env-get env name)
-              (primitive? name)       (get-primitive name)
-              (= name "true")        true
-              (= name "false")       false
-              (= name "nil")         nil
-              :else (error (str "Undefined symbol: " name))))
-
-        "keyword" (keyword-name expr)
-
-        "list"
-          (if (empty? expr)
-            (list)
-            (aser-list expr env))
-
-        ;; Spread — emit attrs to nearest element provider
-        "spread"  (do (emit! "element-attrs" (spread-attrs expr)) nil)
-
-        :else expr)))
-      ;; Catch spread values from function calls and symbol lookups
-      (if (spread? result)
-        (do (emit! "element-attrs" (spread-attrs result)) nil)
-        result))))
-
-
-(define aser-list :effects [render]
-  (fn ((expr :as list) (env :as dict))
-    (let ((head (first expr))
-          (args (rest expr)))
-      (if (not (= (type-of head) "symbol"))
-        (map (fn (x) (aser x env)) expr)
-        (let ((name (symbol-name head)))
-          (cond
-            ;; Fragment — serialize children
-            (= name "<>")
-              (aser-fragment args env)
-
-            ;; Component call — serialize WITHOUT expanding
-            (starts-with? name "~")
-              (aser-call name args env)
-
-            ;; Lake — serialize (server-morphable slot)
-            (= name "lake")
-              (aser-call name args env)
-
-            ;; Marsh — serialize (reactive server-morphable slot)
-            (= name "marsh")
-              (aser-call name args env)
-
-            ;; HTML tag — serialize
-            (contains? HTML_TAGS name)
-              (aser-call name args env)
-
-            ;; Special/HO forms — evaluate (produces data)
-            (or (special-form? name) (ho-form? name))
-              (aser-special name expr env)
-
-            ;; Macro — expand then aser
-            (and (env-has? env name) (macro? (env-get env name)))
-              (aser (expand-macro (env-get env name) args env) env)
-
-            ;; Function call — evaluate fully
-            :else
-              (let ((f (trampoline (eval-expr head env)))
-                    (evaled-args (map (fn (a) (trampoline (eval-expr a env))) args)))
-                (cond
-                  (and (callable? f) (not (lambda? f)) (not (component? f)) (not (island? f)))
-                    (apply f evaled-args)
-                  (lambda? f)
-                    (trampoline (call-lambda f evaled-args env))
-                  (component? f)
-                    (aser-call (str "~" (component-name f)) args env)
-                  (island? f)
-                    (aser-call (str "~" (component-name f)) args env)
-                  :else (error (str "Not callable: " (inspect f)))))))))))
-
-
-(define aser-fragment :effects [render]
-  (fn ((children :as list) (env :as dict))
-    ;; Serialize (<> child1 child2 ...) to sx source string
-    ;; Must flatten list results (e.g. from map/filter) to avoid nested parens
-    (let ((parts (list)))
-      (for-each
-        (fn (c)
-          (let ((result (aser c env)))
-            (if (= (type-of result) "list")
-              (for-each
-                (fn (item)
-                  (when (not (nil? item))
-                    (append! parts (serialize item))))
-                result)
-              (when (not (nil? result))
-                (append! parts (serialize result))))))
-        children)
-      (if (empty? parts)
-        ""
-        (str "(<> " (join " " parts) ")")))))
-
-
-(define aser-call :effects [render]
-  (fn ((name :as string) (args :as list) (env :as dict))
-    ;; Serialize (name :key val child ...) — evaluate args but keep as sx
-    ;; Uses for-each + mutable state (not reduce) so bootstrapper emits for-loops
-    ;; that can contain nested for-each for list flattening.
-    ;; Separate attrs and children so emitted spread attrs go before children.
-    (let ((attr-parts (list))
-          (child-parts (list))
-          (skip false)
-          (i 0))
-      ;; Provide scope for spread emit!
-      (scope-push! "element-attrs" nil)
-      (for-each
-        (fn (arg)
-          (if skip
-            (do (set! skip false)
-                (set! i (inc i)))
-            (if (and (= (type-of arg) "keyword")
-                     (< (inc i) (len args)))
-              (let ((val (aser (nth args (inc i)) env)))
-                (when (not (nil? val))
-                  (append! attr-parts (str ":" (keyword-name arg)))
-                  (append! attr-parts (serialize val)))
-                (set! skip true)
-                (set! i (inc i)))
-              (let ((val (aser arg env)))
-                (when (not (nil? val))
-                  (if (= (type-of val) "list")
-                    (for-each
-                      (fn (item)
-                        (when (not (nil? item))
-                          (append! child-parts (serialize item))))
-                      val)
-                    (append! child-parts (serialize val))))
-                (set! i (inc i))))))
-        args)
-      ;; Collect emitted spread attrs — goes after explicit attrs, before children
-      (for-each
-        (fn (spread-dict)
-          (for-each
-            (fn (k)
-              (let ((v (dict-get spread-dict k)))
-                (append! attr-parts (str ":" k))
-                (append! attr-parts (serialize v))))
-            (keys spread-dict)))
-        (emitted "element-attrs"))
-      (scope-pop! "element-attrs")
-      (let ((parts (concat (list name) attr-parts child-parts)))
-        (str "(" (join " " parts) ")")))))
-
-
-;; --------------------------------------------------------------------------
-;; Form classification
-;; --------------------------------------------------------------------------
-
-(define SPECIAL_FORM_NAMES
-  (list "if" "when" "cond" "case" "and" "or"
-        "let" "let*" "lambda" "fn"
-        "define" "defcomp" "defmacro" "defstyle"
-        "defhandler" "defpage" "defquery" "defaction" "defrelation"
-        "begin" "do" "quote" "quasiquote"
-        "->" "set!" "letrec" "dynamic-wind" "defisland"
-        "deftype" "defeffect" "scope" "provide"))
-
-(define HO_FORM_NAMES
-  (list "map" "map-indexed" "filter" "reduce"
-        "some" "every?" "for-each"))
-
-(define special-form? :effects []
-  (fn ((name :as string))
-    (contains? SPECIAL_FORM_NAMES name)))
-
-(define ho-form? :effects []
-  (fn ((name :as string))
-    (contains? HO_FORM_NAMES name)))
-
-
-;; --------------------------------------------------------------------------
-;; aser-special — evaluate special/HO forms in aser mode
-;; --------------------------------------------------------------------------
-;;
-;; Control flow forms evaluate conditions normally but render branches
-;; through aser (serializing tags/components instead of rendering HTML).
-;; Definition forms evaluate for side effects and return nil.
-
-(define aser-special :effects [render]
-  (fn ((name :as string) (expr :as list) (env :as dict))
-    (let ((args (rest expr)))
-      (cond
-        ;; if — evaluate condition, aser chosen branch
-        (= name "if")
-          (if (trampoline (eval-expr (first args) env))
-            (aser (nth args 1) env)
-            (if (> (len args) 2)
-              (aser (nth args 2) env)
-              nil))
-
-        ;; when — evaluate condition, aser body if true
-        (= name "when")
-          (if (not (trampoline (eval-expr (first args) env)))
-            nil
-            (let ((result nil))
-              (for-each (fn (body) (set! result (aser body env)))
-                        (rest args))
-              result))
-
-        ;; cond — evaluate conditions, aser matching branch
-        (= name "cond")
-          (let ((branch (eval-cond args env)))
-            (if branch (aser branch env) nil))
-
-        ;; case — evaluate match value, check each pair
-        (= name "case")
-          (let ((match-val (trampoline (eval-expr (first args) env)))
-                (clauses (rest args)))
-            (eval-case-aser match-val clauses env))
-
-        ;; let / let*
-        (or (= name "let") (= name "let*"))
-          (let ((local (process-bindings (first args) env))
-                (result nil))
-            (for-each (fn (body) (set! result (aser body local)))
-                      (rest args))
-            result)
-
-        ;; begin / do
-        (or (= name "begin") (= name "do"))
-          (let ((result nil))
-            (for-each (fn (body) (set! result (aser body env))) args)
-            result)
-
-        ;; and — short-circuit
-        (= name "and")
-          (let ((result true))
-            (some (fn (arg)
-                    (set! result (trampoline (eval-expr arg env)))
-                    (not result))
-                  args)
-            result)
-
-        ;; or — short-circuit
-        (= name "or")
-          (let ((result false))
-            (some (fn (arg)
-                    (set! result (trampoline (eval-expr arg env)))
-                    result)
-                  args)
-            result)
-
-        ;; map — evaluate function and collection, map through aser
-        (= name "map")
-          (let ((f (trampoline (eval-expr (first args) env)))
-                (coll (trampoline (eval-expr (nth args 1) env))))
-            (map (fn (item)
-                   (if (lambda? f)
-                     (let ((local (env-merge (lambda-closure f) env)))
-                       (env-set! local (first (lambda-params f)) item)
-                       (aser (lambda-body f) local))
-                     (cek-call f (list item))))
-                 coll))
-
-        ;; map-indexed
-        (= name "map-indexed")
-          (let ((f (trampoline (eval-expr (first args) env)))
-                (coll (trampoline (eval-expr (nth args 1) env))))
-            (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)
-                               (aser (lambda-body f) local))
-                             (cek-call f (list i item))))
-                         coll))
-
-        ;; for-each — evaluate for side effects, aser each body
-        (= name "for-each")
-          (let ((f (trampoline (eval-expr (first args) env)))
-                (coll (trampoline (eval-expr (nth args 1) env)))
-                (results (list)))
-            (for-each (fn (item)
-                        (if (lambda? f)
-                          (let ((local (env-merge (lambda-closure f) env)))
-                            (env-set! local (first (lambda-params f)) item)
-                            (append! results (aser (lambda-body f) local)))
-                          (cek-call f (list item))))
-                      coll)
-            (if (empty? results) nil results))
-
-        ;; defisland — evaluate AND serialize (client needs the definition)
-        (= name "defisland")
-          (do (trampoline (eval-expr expr env))
-              (serialize expr))
-
-        ;; Definition forms — evaluate for side effects
-        (or (= name "define") (= name "defcomp") (= name "defmacro")
-            (= name "defstyle") (= name "defhandler") (= name "defpage")
-            (= name "defquery") (= name "defaction") (= name "defrelation")
-            (= name "deftype") (= name "defeffect"))
-          (do (trampoline (eval-expr expr env)) nil)
-
-        ;; scope — unified render-time dynamic scope
-        (= name "scope")
-          (let ((scope-name (trampoline (eval-expr (first args) env)))
-                (rest-args (rest args))
-                (scope-val nil)
-                (body-args nil))
-            ;; Check for :value keyword
-            (if (and (>= (len rest-args) 2)
-                     (= (type-of (first rest-args)) "keyword")
-                     (= (keyword-name (first rest-args)) "value"))
-              (do (set! scope-val (trampoline (eval-expr (nth rest-args 1) env)))
-                  (set! body-args (slice rest-args 2)))
-              (set! body-args rest-args))
-            (scope-push! scope-name scope-val)
-            (let ((result nil))
-              (for-each (fn (body) (set! result (aser body env)))
-                        body-args)
-              (scope-pop! scope-name)
-              result))
-
-        ;; provide — sugar for scope with value
-        (= name "provide")
-          (let ((prov-name (trampoline (eval-expr (first args) env)))
-                (prov-val (trampoline (eval-expr (nth args 1) env)))
-                (result nil))
-            (scope-push! prov-name prov-val)
-            (for-each (fn (body) (set! result (aser body env)))
-                      (slice args 2))
-            (scope-pop! prov-name)
-            result)
-
-        ;; Everything else — evaluate normally
-        :else
-          (trampoline (eval-expr expr env))))))
-
-
-;; Helper: case dispatch for aser mode
-(define eval-case-aser :effects [render]
-  (fn (match-val (clauses :as list) (env :as dict))
-    (if (< (len clauses) 2)
-      nil
-      (let ((test (first clauses))
-            (body (nth clauses 1)))
-        (if (or (and (= (type-of test) "keyword") (= (keyword-name test) "else"))
-                (and (= (type-of test) "symbol")
-                     (or (= (symbol-name test) ":else")
-                         (= (symbol-name test) "else"))))
-          (aser body env)
-          (if (= match-val (trampoline (eval-expr test env)))
-            (aser body env)
-            (eval-case-aser match-val (slice clauses 2) env)))))))
-
-
-;; --------------------------------------------------------------------------
-;; Platform interface — SX wire adapter
-;; --------------------------------------------------------------------------
-;;
-;; From eval.sx:
-;;   eval-expr, trampoline, call-lambda, expand-macro
-;;   env-has?, env-get, env-set!, env-merge, callable?, lambda?, component?,
-;;   macro?, island?, primitive?, get-primitive, component-name
-;;   lambda-closure, lambda-params, lambda-body
-;;
-;; From render.sx:
-;;   HTML_TAGS, eval-cond, process-bindings
-;;
-;; From parser.sx:
-;;   serialize (= sx-serialize)
-;;
-;; From signals.sx (optional):
-;;   invoke
-;; --------------------------------------------------------------------------

shared/sx/ref/boot.sx

@@ -1,552 +0,0 @@
-;; ==========================================================================
-;; boot.sx — Browser boot, mount, hydrate, script processing
-;;
-;; Handles the browser startup lifecycle:
-;; 1. CSS tracking init
-;; 2. Component script processing (from <script type="text/sx">)
-;; 3. Hydration of [data-sx] elements
-;; 4. Engine element processing
-;;
-;; Also provides the public mounting/hydration API:
-;;   mount, hydrate, update, render-component
-;;
-;; Depends on:
-;;   orchestration.sx — process-elements, engine-init
-;;   adapter-dom.sx   — render-to-dom
-;;   render.sx        — shared registries
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Head element hoisting (full version)
-;; --------------------------------------------------------------------------
-;; Moves <meta>, <title>, <link rel=canonical>, <script type=application/ld+json>
-;; from rendered content to <head>, deduplicating as needed.
-
-(define HEAD_HOIST_SELECTOR
-  "meta, title, link[rel='canonical'], script[type='application/ld+json']")
-
-(define hoist-head-elements-full :effects [mutation io]
-  (fn (root)
-    (let ((els (dom-query-all root HEAD_HOIST_SELECTOR)))
-      (for-each
-        (fn (el)
-          (let ((tag (lower (dom-tag-name el))))
-            (cond
-              ;; <title> — replace document title
-              (= tag "title")
-                (do
-                  (set-document-title (dom-text-content el))
-                  (dom-remove-child (dom-parent el) el))
-
-              ;; <meta> — deduplicate by name or property
-              (= tag "meta")
-                (do
-                  (let ((name (dom-get-attr el "name"))
-                        (prop (dom-get-attr el "property")))
-                    (when name
-                      (remove-head-element (str "meta[name=\"" name "\"]")))
-                    (when prop
-                      (remove-head-element (str "meta[property=\"" prop "\"]"))))
-                  (dom-remove-child (dom-parent el) el)
-                  (dom-append-to-head el))
-
-              ;; <link rel=canonical> — deduplicate
-              (and (= tag "link")
-                   (= (dom-get-attr el "rel") "canonical"))
-                (do
-                  (remove-head-element "link[rel=\"canonical\"]")
-                  (dom-remove-child (dom-parent el) el)
-                  (dom-append-to-head el))
-
-              ;; Everything else (ld+json, etc.) — just move
-              :else
-                (do
-                  (dom-remove-child (dom-parent el) el)
-                  (dom-append-to-head el)))))
-        els))))
-
-
-;; --------------------------------------------------------------------------
-;; Mount — render SX source into a DOM element
-;; --------------------------------------------------------------------------
-
-(define sx-mount :effects [mutation io]
-  (fn (target (source :as string) (extra-env :as dict))
-    ;; Render SX source string into target element.
-    ;; target: Element or CSS selector string
-    ;; source: SX source string
-    ;; extra-env: optional extra bindings dict
-    (let ((el (resolve-mount-target target)))
-      (when el
-        (let ((node (sx-render-with-env source extra-env)))
-          (dom-set-text-content el "")
-          (dom-append el node)
-          ;; Hoist head elements from rendered content
-          (hoist-head-elements-full el)
-          ;; Process sx- attributes, hydrate data-sx and islands
-          (process-elements el)
-          (sx-hydrate-elements el)
-          (sx-hydrate-islands el)
-          (run-post-render-hooks))))))
-
-
-;; --------------------------------------------------------------------------
-;; Resolve Suspense — replace streaming placeholder with resolved content
-;; --------------------------------------------------------------------------
-;;
-;; Called by inline <script> tags that arrive during chunked transfer:
-;;   __sxResolve("content", "(~article :title \"Hello\")")
-;;
-;; Finds the suspense wrapper by data-suspense attribute, renders the
-;; new SX content, and replaces the wrapper's children.
-
-(define resolve-suspense :effects [mutation io]
-  (fn ((id :as string) (sx :as string))
-    ;; Process any new <script type="text/sx"> tags that arrived via
-    ;; streaming (e.g. extra component defs) before resolving.
-    (process-sx-scripts nil)
-    (let ((el (dom-query (str "[data-suspense=\"" id "\"]"))))
-      (if el
-        (do
-          ;; parse returns a list of expressions — render each individually
-          ;; (mirroring the public render() API).
-          (let ((exprs (parse sx))
-                (env (get-render-env nil)))
-            (dom-set-text-content el "")
-            (for-each (fn (expr)
-              (dom-append el (render-to-dom expr env nil)))
-              exprs)
-            (process-elements el)
-            (sx-hydrate-elements el)
-            (sx-hydrate-islands el)
-            (run-post-render-hooks)
-            (dom-dispatch el "sx:resolved" {:id id})))
-        (log-warn (str "resolveSuspense: no element for id=" id))))))
-
-
-;; --------------------------------------------------------------------------
-;; Hydrate — render all [data-sx] elements
-;; --------------------------------------------------------------------------
-
-(define sx-hydrate-elements :effects [mutation io]
-  (fn (root)
-    ;; Find all [data-sx] elements within root and render them.
-    (let ((els (dom-query-all (or root (dom-body)) "[data-sx]")))
-      (for-each
-        (fn (el)
-          (when (not (is-processed? el "hydrated"))
-            (mark-processed! el "hydrated")
-            (sx-update-element el nil)))
-        els))))
-
-
-;; --------------------------------------------------------------------------
-;; Update — re-render a [data-sx] element with new env data
-;; --------------------------------------------------------------------------
-
-(define sx-update-element :effects [mutation io]
-  (fn (el new-env)
-    ;; Re-render a [data-sx] element.
-    ;; Reads source from data-sx attr, base env from data-sx-env attr.
-    (let ((target (resolve-mount-target el)))
-      (when target
-        (let ((source (dom-get-attr target "data-sx")))
-          (when source
-            (let ((base-env (parse-env-attr target))
-                  (env (merge-envs base-env new-env)))
-              (let ((node (sx-render-with-env source env)))
-                (dom-set-text-content target "")
-                (dom-append target node)
-                ;; Update stored env if new-env provided
-                (when new-env
-                  (store-env-attr target base-env new-env))))))))))
-
-
-;; --------------------------------------------------------------------------
-;; Render component — build synthetic call from kwargs dict
-;; --------------------------------------------------------------------------
-
-(define sx-render-component :effects [mutation io]
-  (fn ((name :as string) (kwargs :as dict) (extra-env :as dict))
-    ;; Render a named component with keyword args.
-    ;; name: component name (with or without ~ prefix)
-    ;; kwargs: dict of param-name → value
-    ;; extra-env: optional extra env bindings
-    (let ((full-name (if (starts-with? name "~") name (str "~" name))))
-      (let ((env (get-render-env extra-env))
-            (comp (env-get env full-name)))
-        (if (not (component? comp))
-          (error (str "Unknown component: " full-name))
-          ;; Build synthetic call expression
-          (let ((call-expr (list (make-symbol full-name))))
-            (for-each
-              (fn ((k :as string))
-                (append! call-expr (make-keyword (to-kebab k)))
-                (append! call-expr (dict-get kwargs k)))
-              (keys kwargs))
-            (render-to-dom call-expr env nil)))))))
-
-
-;; --------------------------------------------------------------------------
-;; Script processing — <script type="text/sx">
-;; --------------------------------------------------------------------------
-
-(define process-sx-scripts :effects [mutation io]
-  (fn (root)
-    ;; Process all <script type="text/sx"> tags.
-    ;; - data-components + data-hash → localStorage cache
-    ;; - data-mount="<selector>" → render into target
-    ;; - Default: load as components
-    (let ((scripts (query-sx-scripts root)))
-      (for-each
-        (fn (s)
-          (when (not (is-processed? s "script"))
-            (mark-processed! s "script")
-            (let ((text (dom-text-content s)))
-              (cond
-                ;; Component definitions
-                (dom-has-attr? s "data-components")
-                  (process-component-script s text)
-
-                ;; Empty script — skip
-                (or (nil? text) (empty? (trim text)))
-                  nil
-
-                ;; Init scripts — evaluate SX for side effects (event listeners etc.)
-                (dom-has-attr? s "data-init")
-                  (let ((exprs (sx-parse text)))
-                    (for-each
-                      (fn (expr) (eval-expr expr (env-extend (dict))))
-                      exprs))
-
-                ;; Mount directive
-                (dom-has-attr? s "data-mount")
-                  (let ((mount-sel (dom-get-attr s "data-mount"))
-                        (target (dom-query mount-sel)))
-                    (when target
-                      (sx-mount target text nil)))
-
-                ;; Default: load as components
-                :else
-                  (sx-load-components text)))))
-        scripts))))
-
-
-;; --------------------------------------------------------------------------
-;; Component script with caching
-;; --------------------------------------------------------------------------
-
-(define process-component-script :effects [mutation io]
-  (fn (script (text :as string))
-    ;; Handle <script type="text/sx" data-components data-hash="...">
-    (let ((hash (dom-get-attr script "data-hash")))
-      (if (nil? hash)
-        ;; Legacy: no hash — just load inline
-        (when (and text (not (empty? (trim text))))
-          (sx-load-components text))
-        ;; Hash-based caching
-        (let ((has-inline (and text (not (empty? (trim text))))))
-          (let ((cached-hash (local-storage-get "sx-components-hash")))
-            (if (= cached-hash hash)
-              ;; Cache hit
-              (if has-inline
-                ;; Server sent full source (cookie stale) — update cache
-                (do
-                  (local-storage-set "sx-components-hash" hash)
-                  (local-storage-set "sx-components-src" text)
-                  (sx-load-components text)
-                  (log-info "components: downloaded (cookie stale)"))
-                ;; Server omitted source — load from cache
-                (let ((cached (local-storage-get "sx-components-src")))
-                  (if cached
-                    (do
-                      (sx-load-components cached)
-                      (log-info (str "components: cached (" hash ")")))
-                    ;; Cache entry missing — clear cookie and reload
-                    (do
-                      (clear-sx-comp-cookie)
-                      (browser-reload)))))
-              ;; Cache miss — hash mismatch
-              (if has-inline
-                ;; Server sent full source — cache it
-                (do
-                  (local-storage-set "sx-components-hash" hash)
-                  (local-storage-set "sx-components-src" text)
-                  (sx-load-components text)
-                  (log-info (str "components: downloaded (" hash ")")))
-                ;; Server omitted but cache stale — clear and reload
-                (do
-                  (local-storage-remove "sx-components-hash")
-                  (local-storage-remove "sx-components-src")
-                  (clear-sx-comp-cookie)
-                  (browser-reload)))))
-          (set-sx-comp-cookie hash))))))
-
-
-;; --------------------------------------------------------------------------
-;; Page registry for client-side routing
-;; --------------------------------------------------------------------------
-
-(define _page-routes (list))
-
-(define process-page-scripts :effects [mutation io]
-  (fn ()
-    ;; Process <script type="text/sx-pages"> tags.
-    ;; Parses SX page registry and builds route entries with parsed patterns.
-    (let ((scripts (query-page-scripts)))
-      (log-info (str "pages: found " (len scripts) " script tags"))
-      (for-each
-        (fn (s)
-          (when (not (is-processed? s "pages"))
-            (mark-processed! s "pages")
-            (let ((text (dom-text-content s)))
-              (log-info (str "pages: script text length=" (if text (len text) 0)))
-              (if (and text (not (empty? (trim text))))
-                (let ((pages (parse text)))
-                  (log-info (str "pages: parsed " (len pages) " entries"))
-                  (for-each
-                    (fn ((page :as dict))
-                      (append! _page-routes
-                        (merge page
-                          {"parsed" (parse-route-pattern (get page "path"))})))
-                    pages))
-                (log-warn "pages: script tag is empty")))))
-        scripts)
-      (log-info (str "pages: " (len _page-routes) " routes loaded")))))
-
-
-;; --------------------------------------------------------------------------
-;; Island hydration — activate reactive islands from SSR output
-;; --------------------------------------------------------------------------
-;;
-;; The server renders islands as:
-;;   <div data-sx-island="counter" data-sx-state='{"initial": 0}'>
-;;     ...static HTML...
-;;   </div>
-;;
-;; Hydration:
-;; 1. Find all [data-sx-island] elements
-;; 2. Look up the island component by name
-;; 3. Parse data-sx-state into kwargs
-;; 4. Re-render the island body in a reactive context
-;; 5. Morph existing DOM to preserve structure, focus, scroll
-;; 6. Store disposers on the element for cleanup
-
-(define sx-hydrate-islands :effects [mutation io]
-  (fn (root)
-    (let ((els (dom-query-all (or root (dom-body)) "[data-sx-island]")))
-      (for-each
-        (fn (el)
-          (when (not (is-processed? el "island-hydrated"))
-            (mark-processed! el "island-hydrated")
-            (hydrate-island el)))
-        els))))
-
-(define hydrate-island :effects [mutation io]
-  (fn (el)
-    (let ((name (dom-get-attr el "data-sx-island"))
-          (state-sx (or (dom-get-attr el "data-sx-state") "{}")))
-      (let ((comp-name (str "~" name))
-            (env (get-render-env nil)))
-        (let ((comp (env-get env comp-name)))
-          (if (not (or (component? comp) (island? comp)))
-            (log-warn (str "hydrate-island: unknown island " comp-name))
-
-            ;; Parse state and build keyword args — SX format, not JSON
-            (let ((kwargs (or (first (sx-parse state-sx)) {}))
-                  (disposers (list))
-                  (local (env-merge (component-closure comp) env)))
-
-              ;; Bind params from kwargs
-              (for-each
-                (fn ((p :as string))
-                  (env-set! local p (if (dict-has? kwargs p) (dict-get kwargs p) nil)))
-                (component-params comp))
-
-              ;; Render the island body in a reactive scope
-              (let ((body-dom
-                      (with-island-scope
-                        (fn (disposable) (append! disposers disposable))
-                        (fn () (render-to-dom (component-body comp) local nil)))))
-
-                ;; Clear existing content and append reactive DOM directly.
-                ;; Unlike morph-children, this preserves addEventListener-based
-                ;; event handlers on the freshly rendered nodes.
-                (dom-set-text-content el "")
-                (dom-append el body-dom)
-
-                ;; Store disposers for cleanup
-                (dom-set-data el "sx-disposers" disposers)
-
-                ;; Process any sx- attributes on new content
-                (process-elements el)
-
-                (log-info (str "hydrated island: " comp-name
-                               " (" (len disposers) " disposers)"))))))))))
-
-
-;; --------------------------------------------------------------------------
-;; Island disposal — clean up when island removed from DOM
-;; --------------------------------------------------------------------------
-
-(define dispose-island :effects [mutation io]
-  (fn (el)
-    (let ((disposers (dom-get-data el "sx-disposers")))
-      (when disposers
-        (for-each
-          (fn ((d :as lambda))
-            (when (callable? d) (d)))
-          disposers)
-        (dom-set-data el "sx-disposers" nil)))))
-
-(define dispose-islands-in :effects [mutation io]
-  (fn (root)
-    ;; Dispose islands within root, but SKIP hydrated islands —
-    ;; they may be preserved across morphs. Only dispose islands
-    ;; that are not currently hydrated (e.g. freshly parsed content
-    ;; being discarded) or that have been explicitly detached.
-    (when root
-      (let ((islands (dom-query-all root "[data-sx-island]")))
-        (when (and islands (not (empty? islands)))
-          (let ((to-dispose (filter
-                  (fn (el) (not (is-processed? el "island-hydrated")))
-                  islands)))
-            (when (not (empty? to-dispose))
-              (log-info (str "disposing " (len to-dispose) " island(s)"))
-              (for-each dispose-island to-dispose))))))))
-
-
-;; --------------------------------------------------------------------------
-;; Render hooks — generic pre/post callbacks for hydration, swap, mount.
-;; The spec calls these at render boundaries; the app decides what to do.
-;; Pre-render: setup before DOM changes (e.g. prepare state).
-;; Post-render: cleanup after DOM changes (e.g. flush collected CSS).
-;; --------------------------------------------------------------------------
-
-(define *pre-render-hooks* (list))
-(define *post-render-hooks* (list))
-
-(define register-pre-render-hook :effects [mutation]
-  (fn ((hook-fn :as lambda))
-    (append! *pre-render-hooks* hook-fn)))
-
-(define register-post-render-hook :effects [mutation]
-  (fn ((hook-fn :as lambda))
-    (append! *post-render-hooks* hook-fn)))
-
-(define run-pre-render-hooks :effects [mutation io]
-  (fn ()
-    (for-each (fn (hook) (cek-call hook nil)) *pre-render-hooks*)))
-
-(define run-post-render-hooks :effects [mutation io]
-  (fn ()
-    (log-info "run-post-render-hooks:" (len *post-render-hooks*) "hooks")
-    (for-each (fn (hook)
-      (log-info "  hook type:" (type-of hook) "callable:" (callable? hook) "lambda:" (lambda? hook))
-      (cek-call hook nil))
-      *post-render-hooks*)))
-
-
-;; --------------------------------------------------------------------------
-;; Full boot sequence
-;; --------------------------------------------------------------------------
-
-(define boot-init :effects [mutation io]
-  (fn ()
-    ;; Full browser initialization:
-    ;; 1. CSS tracking
-    ;; 2. Style dictionary
-    ;; 3. Process scripts (components + mounts)
-    ;; 4. Process page registry (client-side routing)
-    ;; 5. Hydrate [data-sx] elements
-    ;; 6. Hydrate [data-sx-island] elements (reactive islands)
-    ;; 7. Process engine elements
-    (do
-      (log-info (str "sx-browser " SX_VERSION))
-      (init-css-tracking)
-      (process-page-scripts)
-      (process-sx-scripts nil)
-      (sx-hydrate-elements nil)
-      (sx-hydrate-islands nil)
-      (run-post-render-hooks)
-      (process-elements nil))))
-
-
-;; --------------------------------------------------------------------------
-;; Platform interface — Boot
-;; --------------------------------------------------------------------------
-;;
-;; From orchestration.sx:
-;;   process-elements, init-css-tracking
-;;
-;; === DOM / Render ===
-;;   (resolve-mount-target target) → Element (string → querySelector, else identity)
-;;   (sx-render-with-env source extra-env) → DOM node (parse + render with componentEnv + extra)
-;;   (get-render-env extra-env)    → merged component env + extra
-;;   (merge-envs base new)         → merged env dict
-;;   (render-to-dom expr env ns)   → DOM node
-;;   (sx-load-components text)     → void (parse + eval into componentEnv)
-;;
-;; === DOM queries ===
-;;   (dom-query sel)               → Element or nil
-;;   (dom-query-all root sel)      → list of Elements
-;;   (dom-body)                    → document.body
-;;   (dom-get-attr el name)        → string or nil
-;;   (dom-has-attr? el name)       → boolean
-;;   (dom-text-content el)         → string
-;;   (dom-set-text-content el s)   → void
-;;   (dom-append el child)         → void
-;;   (dom-remove-child parent el)  → void
-;;   (dom-parent el)               → Element
-;;   (dom-append-to-head el)       → void
-;;   (dom-tag-name el)             → string
-;;
-;; === Head hoisting ===
-;;   (set-document-title s)        → void (document.title = s)
-;;   (remove-head-element sel)     → void (remove matching element from <head>)
-;;
-;; === Script queries ===
-;;   (query-sx-scripts root)       → list of <script type="text/sx"> elements
-;;   (query-page-scripts)          → list of <script type="text/sx-pages"> elements
-;;
-;; === localStorage ===
-;;   (local-storage-get key)       → string or nil
-;;   (local-storage-set key val)   → void
-;;   (local-storage-remove key)    → void
-;;
-;; === Cookies ===
-;;   (set-sx-comp-cookie hash)     → void
-;;   (clear-sx-comp-cookie)        → void
-;;
-;; === Env ===
-;;   (parse-env-attr el)           → dict (parse data-sx-env JSON attr)
-;;   (store-env-attr el base new)  → void (merge and store back as JSON)
-;;   (to-kebab s)                  → string (underscore → kebab-case)
-;;
-;; === Logging ===
-;;   (log-info msg)                → void (console.log with prefix)
-;;   (log-parse-error label text err) → void (diagnostic parse error)
-;;
-;; === Parsing (island state) ===
-;;   (sx-parse str)                → list of AST expressions (from parser.sx)
-;;
-;; === Processing markers ===
-;;   (mark-processed! el key)      → void
-;;   (is-processed? el key)        → boolean
-;;
-;; === Morph ===
-;;   (morph-children target source) → void (morph target's children to match source)
-;;
-;; === Island support (from adapter-dom.sx / signals.sx) ===
-;;   (island? x)                   → boolean
-;;   (component-closure comp)      → env
-;;   (component-params comp)       → list of param names
-;;   (component-body comp)         → AST
-;;   (component-name comp)         → string
-;;   (component-has-children? comp) → boolean
-;;   (with-island-scope scope-fn body-fn) → result (track disposables)
-;;   (render-to-dom expr env ns)   → DOM node
-;;   (dom-get-data el key)         → any (from el._sxData)
-;;   (dom-set-data el key val)     → void
-;; --------------------------------------------------------------------------

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

@@ -1,435 +0,0 @@
-;; ==========================================================================
-;; 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)
-;;
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 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
-;;
-;; These are generic web-platform I/O that any SX web host would provide,
-;; regardless of deployment architecture.
-;; --------------------------------------------------------------------------
-
-;; Request context
-
-(define-io-primitive "current-user"
-  :params ()
-  :returns "dict?"
-  :effects [io]
-  :async true
-  :doc "Current authenticated user dict, or nil."
-  :context :request)
-
-(define-io-primitive "request-arg"
-  :params (name &rest default)
-  :returns "any"
-  :effects [io]
-  :async true
-  :doc "Read a query string argument from the current request."
-  :context :request)
-
-(define-io-primitive "request-path"
-  :params ()
-  :returns "string"
-  :effects [io]
-  :async true
-  :doc "Current request path."
-  :context :request)
-
-(define-io-primitive "request-view-args"
-  :params (key)
-  :returns "any"
-  :effects [io]
-  :async true
-  :doc "Read a URL view argument from the current request."
-  :context :request)
-
-(define-io-primitive "csrf-token"
-  :params ()
-  :returns "string"
-  :effects [io]
-  :async true
-  :doc "Current CSRF token string."
-  :context :request)
-
-(define-io-primitive "abort"
-  :params (status &rest message)
-  :returns "nil"
-  :effects [io]
-  :async true
-  :doc "Raise HTTP error from SX."
-  :context :request)
-
-;; Routing
-
-(define-io-primitive "url-for"
-  :params (endpoint &key)
-  :returns "string"
-  :effects [io]
-  :async true
-  :doc "Generate URL for a named endpoint."
-  :context :request)
-
-(define-io-primitive "route-prefix"
-  :params ()
-  :returns "string"
-  :effects [io]
-  :async true
-  :doc "Service URL prefix for dev/prod routing."
-  :context :request)
-
-;; Config and host context (sync — no await needed)
-
-(define-io-primitive "app-url"
-  :params (service &rest path)
-  :returns "string"
-  :effects [io]
-  :async false
-  :doc "Full URL for a service: (app-url \"blog\" \"/my-post/\")."
-  :context :config)
-
-(define-io-primitive "asset-url"
-  :params (&rest path)
-  :returns "string"
-  :effects [io]
-  :async false
-  :doc "Versioned static asset URL."
-  :context :config)
-
-(define-io-primitive "config"
-  :params (key)
-  :returns "any"
-  :effects [io]
-  :async false
-  :doc "Read a value from host configuration."
-  :context :config)
-
-
-;; --------------------------------------------------------------------------
-;; Boundary types — what's allowed to cross the host-SX boundary
-;; --------------------------------------------------------------------------
-
-(define-boundary-types
-  (list "number" "string" "boolean" "nil" "keyword"
-        "list" "dict" "sx-source"))
-
-
-;; --------------------------------------------------------------------------
-;; Web interop — reading non-SX request formats
-;;
-;; SX's native wire format is SX (text/sx). These primitives bridge to
-;; legacy web formats: HTML form encoding, JSON bodies, HTTP headers.
-;; They're useful for interop but not fundamental to SX-to-SX communication.
-;; --------------------------------------------------------------------------
-
-(define-io-primitive "now"
-  :params (&rest format)
-  :returns "string"
-  :async true
-  :doc "Current timestamp. Optional format string (strftime). Default ISO 8601."
-  :context :request)
-
-(define-io-primitive "sleep"
-  :params (ms)
-  :returns "nil"
-  :async true
-  :doc "Pause execution for ms milliseconds. For demos and testing."
-  :context :request)
-
-(define-io-primitive "request-form"
-  :params (name &rest default)
-  :returns "any"
-  :async true
-  :doc "Read a form field from a POST/PUT/PATCH request body."
-  :context :request)
-
-(define-io-primitive "request-json"
-  :params ()
-  :returns "dict?"
-  :async true
-  :doc "Read JSON body from the current request, or nil if not JSON."
-  :context :request)
-
-(define-io-primitive "request-header"
-  :params (name &rest default)
-  :returns "string?"
-  :async true
-  :doc "Read a request header value by name."
-  :context :request)
-
-(define-io-primitive "request-content-type"
-  :params ()
-  :returns "string?"
-  :async true
-  :doc "Content-Type of the current request."
-  :context :request)
-
-(define-io-primitive "request-args-all"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "All query string parameters as a dict."
-  :context :request)
-
-(define-io-primitive "request-form-all"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "All form fields as a dict."
-  :context :request)
-
-(define-io-primitive "request-form-list"
-  :params (field-name)
-  :returns "list"
-  :async true
-  :doc "All values for a multi-value form field as a list."
-  :context :request)
-
-(define-io-primitive "request-headers-all"
-  :params ()
-  :returns "dict"
-  :async true
-  :doc "All request headers as a dict (lowercase keys)."
-  :context :request)
-
-(define-io-primitive "request-file-name"
-  :params (field-name)
-  :returns "string?"
-  :async true
-  :doc "Filename of an uploaded file by field name, or nil."
-  :context :request)
-
-;; Response manipulation
-
-(define-io-primitive "set-response-header"
-  :params (name value)
-  :returns "nil"
-  :async true
-  :doc "Set a response header. Applied after handler returns."
-  :context :request)
-
-(define-io-primitive "set-response-status"
-  :params (status)
-  :returns "nil"
-  :async true
-  :doc "Set the HTTP response status code. Applied after handler returns."
-  :context :request)
-
-;; Ephemeral state — per-process, resets on restart
-
-(define-io-primitive "state-get"
-  :params (key &rest default)
-  :returns "any"
-  :async true
-  :doc "Read from ephemeral per-process state dict."
-  :context :request)
-
-(define-io-primitive "state-set!"
-  :params (key value)
-  :returns "nil"
-  :async true
-  :doc "Write to ephemeral per-process state dict."
-  :context :request)
-
-
-;; --------------------------------------------------------------------------
-;; Tier 3: Signal primitives — reactive state for islands
-;;
-;; These are pure primitives (no IO) but are separated from primitives.sx
-;; because they introduce a new type (signal) and depend on signals.sx.
-;; --------------------------------------------------------------------------
-
-(declare-tier :signals :source "signals.sx")
-
-(declare-signal-primitive "signal"
-  :params (initial-value)
-  :returns "signal"
-  :effects []
-  :doc "Create a reactive signal container with an initial value.")
-
-(declare-signal-primitive "deref"
-  :params (signal)
-  :returns "any"
-  :effects []
-  :doc "Read a signal's current value. In a reactive context (inside an island),
-        subscribes the current DOM binding to the signal. Outside reactive
-        context, just returns the value.")
-
-(declare-signal-primitive "reset!"
-  :params (signal value)
-  :returns "nil"
-  :effects [mutation]
-  :doc "Set a signal to a new value. Notifies all subscribers.")
-
-(declare-signal-primitive "swap!"
-  :params (signal f &rest args)
-  :returns "nil"
-  :effects [mutation]
-  :doc "Update a signal by applying f to its current value. (swap! s inc)
-        is equivalent to (reset! s (inc (deref s))) but atomic.")
-
-(declare-signal-primitive "computed"
-  :params (compute-fn)
-  :returns "signal"
-  :effects []
-  :doc "Create a derived signal that recomputes when its dependencies change.
-        Dependencies are discovered automatically by tracking deref calls.")
-
-(declare-signal-primitive "effect"
-  :params (effect-fn)
-  :returns "lambda"
-  :effects [mutation]
-  :doc "Run a side effect that re-runs when its signal dependencies change.
-        Returns a dispose function. If the effect function returns a function,
-        it is called as cleanup before the next run.")
-
-(declare-signal-primitive "batch"
-  :params (thunk)
-  :returns "any"
-  :effects [mutation]
-  :doc "Group multiple signal writes. Subscribers are notified once at the end,
-        after all values have been updated.")
-
-
-;; --------------------------------------------------------------------------
-;; Tier 4: Spread + Collect — render-time attribute injection and accumulation
-;;
-;; `spread` is a new type: a dict of attributes that, when returned as a child
-;; of an HTML element, merges its attrs onto the parent element rather than
-;; rendering as content. This enables components like `~cssx/tw` to inject
-;; classes and styles onto their parent from inside the child list.
-;;
-;; `collect!` / `collected` are render-time accumulators. Values are collected
-;; into named buckets (with deduplication) during rendering and retrieved at
-;; flush points (e.g. a single <style> tag for all collected CSS rules).
-;; --------------------------------------------------------------------------
-
-(declare-tier :spread :source "render.sx")
-
-(declare-spread-primitive "make-spread"
-  :params (attrs)
-  :returns "spread"
-  :effects []
-  :doc "Create a spread value from an attrs dict. When this value appears as
-        a child of an HTML element, its attrs are merged onto the parent
-        element (class values joined, others overwritten).")
-
-(declare-spread-primitive "spread?"
-  :params (x)
-  :returns "boolean"
-  :effects []
-  :doc "Test whether a value is a spread.")
-
-(declare-spread-primitive "spread-attrs"
-  :params (s)
-  :returns "dict"
-  :effects []
-  :doc "Extract the attrs dict from a spread value.")
-
-(declare-spread-primitive "collect!"
-  :params (bucket value)
-  :returns "nil"
-  :effects [mutation]
-  :doc "Add value to a named render-time accumulator bucket. Values are
-        deduplicated (no duplicates added). Buckets persist for the duration
-        of the current render pass.")
-
-(declare-spread-primitive "collected"
-  :params (bucket)
-  :returns "list"
-  :effects []
-  :doc "Return all values collected in the named bucket during the current
-        render pass. Returns an empty list if the bucket doesn't exist.")
-
-(declare-spread-primitive "clear-collected!"
-  :params (bucket)
-  :returns "nil"
-  :effects [mutation]
-  :doc "Clear a named render-time accumulator bucket. Used at flush points
-        after emitting collected values (e.g. after writing a <style> tag).")
-
-
-;; --------------------------------------------------------------------------
-;; Tier 5: Scoped effects — unified render-time dynamic scope
-;;
-;; `scope` is the general primitive. `provide` is sugar for scope-with-value.
-;; Both `provide` and `scope` are special forms in the evaluator.
-;;
-;; The platform must implement per-name stacks. Each entry has a value,
-;; an emitted list, and a dedup flag. `scope-push!`/`scope-pop!` manage
-;; the stack. `provide-push!`/`provide-pop!` are aliases.
-;;
-;; `collect!`/`collected`/`clear-collected!` (Tier 4) are backed by scopes:
-;; collect! lazily creates a root scope with dedup=true, then emits into it.
-;; --------------------------------------------------------------------------
-
-(declare-tier :scoped-effects :source "eval.sx")
-
-(declare-spread-primitive "scope-push!"
-  :params (name value)
-  :returns "nil"
-  :effects [mutation]
-  :doc "Push a scope with name and value. General form — provide-push! is an alias.")
-
-(declare-spread-primitive "scope-pop!"
-  :params (name)
-  :returns "nil"
-  :effects [mutation]
-  :doc "Pop the most recent scope for name. General form — provide-pop! is an alias.")
-
-(declare-spread-primitive "provide-push!"
-  :params (name value)
-  :returns "nil"
-  :effects [mutation]
-  :doc "Alias for scope-push!. Push a scope with name and value.")
-
-(declare-spread-primitive "provide-pop!"
-  :params (name)
-  :returns "nil"
-  :effects [mutation]
-  :doc "Alias for scope-pop!. Pop the most recent scope for name.")
-
-(declare-spread-primitive "context"
-  :params (name &rest default)
-  :returns "any"
-  :effects []
-  :doc "Read value from nearest enclosing provide with matching name.
-        Errors if no provider and no default given.")
-
-(declare-spread-primitive "emit!"
-  :params (name value)
-  :returns "nil"
-  :effects [mutation]
-  :doc "Append value to nearest enclosing provide's accumulator.
-        Errors if no matching provider. No deduplication.")
-
-(declare-spread-primitive "emitted"
-  :params (name)
-  :returns "list"
-  :effects []
-  :doc "Return list of values emitted into nearest matching provider.
-        Empty list if no provider.")

shared/sx/ref/callcc.sx

@@ -1,245 +0,0 @@
-;; ==========================================================================
-;; callcc.sx — Full first-class continuations (call/cc)
-;;
-;; OPTIONAL EXTENSION — not required by the core evaluator.
-;; Bootstrappers include this only when the target supports it naturally.
-;;
-;; Full call/cc (call-with-current-continuation) captures the ENTIRE
-;; remaining computation as a first-class function — not just up to a
-;; delimiter, but all the way to the top level. Invoking a continuation
-;; captured by call/cc abandons the current computation entirely and
-;; resumes from where the continuation was captured.
-;;
-;; This is strictly more powerful than delimited continuations (shift/reset)
-;; but harder to implement in targets that don't support it natively.
-;; Recommended only for targets where it's natural:
-;;   - Scheme/Racket (native call/cc)
-;;   - Haskell (ContT monad transformer)
-;;
-;; For targets like Python, JavaScript, and Rust, delimited continuations
-;; (continuations.sx) are more practical and cover the same use cases
-;; without requiring a global CPS transform.
-;;
-;; One new special form:
-;;   (call/cc f)         — call f with the current continuation
-;;
-;; One new type:
-;;   continuation        — same type as in continuations.sx
-;;
-;; If both extensions are loaded, the continuation type is shared.
-;; Delimited and undelimited continuations are the same type —
-;; the difference is in how they are captured, not what they are.
-;;
-;; Platform requirements:
-;;   (make-continuation fn)   — wrap a function as a continuation value
-;;   (continuation? x)        — type predicate
-;;   (type-of continuation)   → "continuation"
-;;   (call-with-cc f env)     — target-specific call/cc implementation
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 1. Semantics
-;; --------------------------------------------------------------------------
-;;
-;; (call/cc f)
-;;
-;; Evaluates f (which must be a function of one argument), passing it the
-;; current continuation as a continuation value. f can:
-;;
-;;   a) Return normally — call/cc returns whatever f returns
-;;   b) Invoke the continuation — abandons f's computation, call/cc
-;;      "returns" the value passed to the continuation
-;;   c) Store the continuation — invoke it later, possibly multiple times
-;;
-;; Key difference from shift/reset: invoking an undelimited continuation
-;; NEVER RETURNS to the caller. It abandons the current computation and
-;; jumps back to where call/cc was originally called.
-;;
-;;   ;; Delimited (shift/reset) — k returns a value:
-;;   (reset (+ 1 (shift k (+ (k 10) (k 20)))))
-;;   ;; (k 10) → 11, returns to the (+ ... (k 20)) expression
-;;   ;; (k 20) → 21, returns to the (+ 11 ...) expression
-;;   ;; result: 32
-;;
-;;   ;; Undelimited (call/cc) — k does NOT return:
-;;   (+ 1 (call/cc (fn (k)
-;;     (+ (k 10) (k 20)))))
-;;   ;; (k 10) abandons (+ (k 10) (k 20)) entirely
-;;   ;; jumps back to (+ 1 _) with 10
-;;   ;; result: 11
-;;   ;; (k 20) is never reached
-;;
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; 2. call/cc — call with current continuation
-;; --------------------------------------------------------------------------
-
-(define sf-callcc
-  (fn (args env)
-    ;; Single argument: a function to call with the current continuation.
-    (let ((f-expr (first args))
-          (f (trampoline (eval-expr f-expr env))))
-      (call-with-cc f env))))
-
-
-;; --------------------------------------------------------------------------
-;; 3. Derived forms
-;; --------------------------------------------------------------------------
-;;
-;; With call/cc available, several patterns become expressible:
-;;
-;; --- Early return ---
-;;
-;;   (define find-first
-;;     (fn (pred items)
-;;       (call/cc (fn (return)
-;;         (for-each (fn (item)
-;;           (when (pred item)
-;;             (return item)))
-;;           items)
-;;         nil))))
-;;
-;; --- Exception-like flow ---
-;;
-;;   (define try-catch
-;;     (fn (body handler)
-;;       (call/cc (fn (throw)
-;;         (body throw)))))
-;;
-;;   (try-catch
-;;     (fn (throw)
-;;       (let ((result (dangerous-operation)))
-;;         (when (not result) (throw "failed"))
-;;         result))
-;;     (fn (error) (str "Caught: " error)))
-;;
-;; --- Coroutines ---
-;;
-;;   Two call/cc captures that alternate control between two
-;;   computations. Each captures its own continuation, then invokes
-;;   the other's. This gives cooperative multitasking without threads.
-;;
-;; --- Undo ---
-;;
-;;   (define with-undo
-;;     (fn (action)
-;;       (call/cc (fn (restore)
-;;         (action)
-;;         restore))))
-;;
-;;   ;; (let ((undo (with-undo (fn () (delete-item 42)))))
-;;   ;;   (undo "anything"))  → item 42 is back
-;;
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; 4. Interaction with delimited continuations
-;; --------------------------------------------------------------------------
-;;
-;; If both callcc.sx and continuations.sx are loaded:
-;;
-;; - The continuation type is shared. (continuation? k) returns true
-;;   for both delimited and undelimited continuations.
-;;
-;; - shift inside a call/cc body captures up to the nearest reset,
-;;   not up to the call/cc. The two mechanisms compose.
-;;
-;; - call/cc inside a reset body captures the entire continuation
-;;   (past the reset). This is the expected behavior — call/cc is
-;;   undelimited by definition.
-;;
-;; - A delimited continuation (from shift) returns a value when invoked.
-;;   An undelimited continuation (from call/cc) does not return.
-;;   Both are callable with the same syntax: (k value).
-;;   The caller cannot distinguish them by type — only by behavior.
-;;
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; 5. Interaction with I/O and state
-;; --------------------------------------------------------------------------
-;;
-;; Full call/cc has well-known interactions with side effects:
-;;
-;; Re-entry:
-;;   Invoking a saved continuation re-enters a completed computation.
-;;   If that computation mutated state (set!, I/O writes), the mutations
-;;   are NOT undone. The continuation resumes in the current state,
-;;   not the state at the time of capture.
-;;
-;; I/O:
-;;   Same as delimited continuations — I/O executes at invocation time.
-;;   A continuation containing (current-user) will call current-user
-;;   when invoked, in whatever request context exists then.
-;;
-;; Dynamic extent:
-;;   call/cc captures the continuation, not the dynamic environment.
-;;   Host-language context (Python's Quart request context, JavaScript's
-;;   async context) may not be valid when a saved continuation is invoked
-;;   later. Typed targets can enforce this; dynamic targets fail at runtime.
-;;
-;; Recommendation:
-;;   Use call/cc for pure control flow (early return, coroutines,
-;;   backtracking). Use delimited continuations for effectful patterns
-;;   (suspense, cooperative scheduling) where the delimiter provides
-;;   a natural boundary.
-;;
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; 6. Implementation notes per target
-;; --------------------------------------------------------------------------
-;;
-;; Scheme / Racket:
-;;   Native call/cc. Zero implementation effort.
-;;
-;; Haskell:
-;;   ContT monad transformer. The evaluator runs in ContT, and call/cc
-;;   is callCC from Control.Monad.Cont. Natural and type-safe.
-;;
-;; Python:
-;;   Requires full CPS transform of the evaluator, or greenlet-based
-;;   stack capture. Significantly more invasive than delimited
-;;   continuations. NOT RECOMMENDED — use continuations.sx instead.
-;;
-;; JavaScript:
-;;   Requires full CPS transform. Cannot be implemented with generators
-;;   alone (generators only support delimited yield, not full escape).
-;;   NOT RECOMMENDED — use continuations.sx instead.
-;;
-;; Rust:
-;;   Full CPS transform at compile time. Possible but adds significant
-;;   complexity. Delimited continuations are more natural (enum-based).
-;;   Consider only if the target genuinely needs undelimited escape.
-;;
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; 7. Platform interface — what each target must provide
-;; --------------------------------------------------------------------------
-;;
-;;   (call-with-cc f env)
-;;     Call f with the current continuation. f is a function of one
-;;     argument (the continuation). If f returns normally, call-with-cc
-;;     returns f's result. If f invokes the continuation, the computation
-;;     jumps to the call-with-cc call site with the provided value.
-;;
-;;   (make-continuation fn)
-;;     Wrap a native function as a continuation value.
-;;     (Shared with continuations.sx if both are loaded.)
-;;
-;;   (continuation? x)
-;;     Type predicate.
-;;     (Shared with continuations.sx if both are loaded.)
-;;
-;;   Continuations must be callable via the standard function-call
-;;   dispatch in eval-list (same path as lambda calls).
-;;
-;; --------------------------------------------------------------------------

shared/sx/ref/continuations.sx

@@ -1,248 +0,0 @@
-;; ==========================================================================
-;; continuations.sx — Delimited continuations (shift/reset)
-;;
-;; OPTIONAL EXTENSION — not required by the core evaluator.
-;; Bootstrappers include this only when the target requests it.
-;;
-;; Delimited continuations capture "the rest of the computation up to
-;; a delimiter." They are strictly less powerful than full call/cc but
-;; cover the practical use cases: suspendable rendering, cooperative
-;; scheduling, linear async flows, wizard forms, and undo.
-;;
-;; Two new special forms:
-;;   (reset body)       — establish a delimiter
-;;   (shift k body)     — capture the continuation to the nearest reset
-;;
-;; One new type:
-;;   continuation       — a captured delimited continuation, callable
-;;
-;; The captured continuation is a function of one argument. Invoking it
-;; provides the value that the shift expression "returns" within the
-;; delimited context, then completes the rest of the reset body.
-;;
-;; Continuations are composable — invoking a continuation returns a
-;; value (the result of the reset body), which can be used normally.
-;; This is the key difference from undelimited call/cc, where invoking
-;; a continuation never returns.
-;;
-;; Platform requirements:
-;;   (make-continuation fn)   — wrap a function as a continuation value
-;;   (continuation? x)        — type predicate
-;;   (type-of continuation)   → "continuation"
-;;   Continuations are callable (same dispatch as lambda).
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 1. Type
-;; --------------------------------------------------------------------------
-;;
-;; A continuation is a callable value of one argument.
-;;
-;;   (continuation? k)  → true if k is a captured continuation
-;;   (type-of k)        → "continuation"
-;;   (k value)          → invoke: resume the captured computation with value
-;;
-;; Continuations are first-class: they can be stored in variables, passed
-;; as arguments, returned from functions, and put in data structures.
-;;
-;; Invoking a delimited continuation RETURNS a value — the result of the
-;; reset body. This makes them composable:
-;;
-;;   (+ 1 (reset (+ 10 (shift k (k 5)))))
-;;   ;; k is "add 10 to _ and return from reset"
-;;   ;; (k 5) → 15, which is returned from reset
-;;   ;; (+ 1 15) → 16
-;;
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; 2. reset — establish a continuation delimiter
-;; --------------------------------------------------------------------------
-;;
-;; (reset body)
-;;
-;; Evaluates body in the current environment. If no shift occurs during
-;; evaluation of body, reset simply returns the value of body.
-;;
-;; If shift occurs, reset is the boundary — the continuation captured by
-;; shift extends from the shift point back to (and including) this reset.
-;;
-;; reset is the "prompt" — it marks where the continuation stops.
-;;
-;; Semantics:
-;;   (reset expr) where expr contains no shift
-;;     → (eval expr env)                   ;; just evaluates normally
-;;
-;;   (reset ... (shift k body) ...)
-;;     → captures continuation, evaluates shift's body
-;;     → the result of the shift body is the result of the reset
-;;
-;; --------------------------------------------------------------------------
-
-(define sf-reset
-  (fn ((args :as list) (env :as dict))
-    ;; Single argument: the body expression.
-    ;; Install a continuation delimiter, then evaluate body.
-    ;; The implementation is target-specific:
-    ;;   - In Scheme: native reset/shift
-    ;;   - In Haskell: Control.Monad.CC or delimited continuations library
-    ;;   - In Python: coroutine/generator-based (see implementation notes)
-    ;;   - In JavaScript: generator-based or CPS transform
-    ;;   - In Rust: CPS transform at compile time
-    (let ((body (first args)))
-      (eval-with-delimiter body env))))
-
-
-;; --------------------------------------------------------------------------
-;; 3. shift — capture the continuation to the nearest reset
-;; --------------------------------------------------------------------------
-;;
-;; (shift k body)
-;;
-;; Captures the continuation from this point back to the nearest enclosing
-;; reset and binds it to k. Then evaluates body in the current environment
-;; extended with k. The result of body becomes the result of the enclosing
-;; reset.
-;;
-;; k is a function of one argument. Calling (k value) resumes the captured
-;; computation with value standing in for the shift expression.
-;;
-;; The continuation k is composable: (k value) returns a value (the result
-;; of the reset body when resumed with value). This means k can be called
-;; multiple times, and its result can be used in further computation.
-;;
-;; Examples:
-;;
-;;   ;; Basic: shift provides a value to the surrounding computation
-;;   (reset (+ 1 (shift k (k 41))))
-;;   ;; k = "add 1 to _", (k 41) → 42, reset returns 42
-;;
-;;   ;; Abort: shift can discard the continuation entirely
-;;   (reset (+ 1 (shift k "aborted")))
-;;   ;; k is never called, reset returns "aborted"
-;;
-;;   ;; Multiple invocations: k can be called more than once
-;;   (reset (+ 1 (shift k (list (k 10) (k 20)))))
-;;   ;; (k 10) → 11, (k 20) → 21, reset returns (11 21)
-;;
-;;   ;; Stored for later: k can be saved and invoked outside reset
-;;   (define saved nil)
-;;   (reset (+ 1 (shift k (set! saved k) 0)))
-;;   ;; reset returns 0, saved holds the continuation
-;;   (saved 99)  ;; → 100
-;;
-;; --------------------------------------------------------------------------
-
-(define sf-shift
-  (fn ((args :as list) (env :as dict))
-    ;; Two arguments: the continuation variable name, and the body.
-    (let ((k-name (symbol-name (first args)))
-          (body   (second args)))
-      ;; Capture the current continuation up to the nearest reset.
-      ;; Bind it to k-name in the environment, then evaluate body.
-      ;; The result of body is returned to the reset.
-      (capture-continuation k-name body env))))
-
-
-;; --------------------------------------------------------------------------
-;; 4. Interaction with other features
-;; --------------------------------------------------------------------------
-;;
-;; TCO (trampoline):
-;;   Continuations interact naturally with the trampoline. A shift inside
-;;   a tail-call position captures the continuation including the pending
-;;   return. The trampoline resolves thunks before the continuation is
-;;   delimited.
-;;
-;; Macros:
-;;   shift/reset are special forms, not macros. Macros expand before
-;;   evaluation, so shift inside a macro-expanded form works correctly —
-;;   it captures the continuation of the expanded code.
-;;
-;; Components:
-;;   shift inside a component body captures the continuation of that
-;;   component's render. The enclosing reset determines the delimiter.
-;;   This is the foundation for suspendable rendering — a component can
-;;   shift to suspend, and the server resumes it when data arrives.
-;;
-;; I/O primitives:
-;;   I/O primitives execute at invocation time, in whatever context
-;;   exists then. A continuation that captures a computation containing
-;;   I/O will re-execute that I/O when invoked. If the I/O requires
-;;   request context (e.g. current-user), invoking the continuation
-;;   outside a request will fail — same as calling the I/O directly.
-;;   This is consistent, not a restriction.
-;;
-;;   In typed targets (Haskell, Rust), the type system can enforce that
-;;   continuations containing I/O are only invoked in appropriate contexts.
-;;   In dynamic targets (Python, JS), it fails at runtime.
-;;
-;; Lexical scope:
-;;   Continuations capture the dynamic extent (what happens next) but
-;;   close over the lexical environment at the point of capture. Variable
-;;   bindings in the continuation refer to the same environment — mutations
-;;   via set! are visible.
-;;
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; 5. Implementation notes per target
-;; --------------------------------------------------------------------------
-;;
-;; The bootstrapper emits target-specific continuation machinery.
-;; The spec defines semantics; each target chooses representation.
-;;
-;; Scheme / Racket:
-;;   Native shift/reset. No transformation needed. The bootstrapper
-;;   emits (require racket/control) or equivalent.
-;;
-;; Haskell:
-;;   Control.Monad.CC provides delimited continuations in the CC monad.
-;;   Alternatively, the evaluator can be CPS-transformed at compile time.
-;;   Continuations become first-class functions naturally.
-;;
-;; Python:
-;;   Generator-based: reset creates a generator, shift yields from it.
-;;   The trampoline loop drives the generator. Each yield is a shift
-;;   point, and send() provides the resume value.
-;;   Alternative: greenlet-based (stackful coroutines).
-;;
-;; JavaScript:
-;;   Generator-based (function* / yield). Similar to Python.
-;;   Alternative: CPS transform at bootstrap time — the bootstrapper
-;;   rewrites the evaluator into continuation-passing style, making
-;;   shift/reset explicit function arguments.
-;;
-;; Rust:
-;;   CPS transform at compile time. Continuations become enum variants
-;;   or boxed closures. The type system ensures continuations are used
-;;   linearly if desired (affine types via ownership).
-;;
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; 6. Platform interface — what each target must provide
-;; --------------------------------------------------------------------------
-;;
-;;   (eval-with-delimiter expr env)
-;;     Install a reset delimiter, evaluate expr, return result.
-;;     If expr calls shift, the continuation is captured up to here.
-;;
-;;   (capture-continuation k-name body env)
-;;     Capture the current continuation up to the nearest delimiter.
-;;     Bind it to k-name in env, evaluate body, return result to delimiter.
-;;
-;;   (make-continuation fn)
-;;     Wrap a native function as a continuation value.
-;;
-;;   (continuation? x)
-;;     Type predicate.
-;;
-;;   Continuations must be callable via the standard function-call
-;;   dispatch in eval-list (same path as lambda calls).
-;;
-;; --------------------------------------------------------------------------

shared/sx/ref/deps.sx

@@ -1,459 +0,0 @@
-;; ==========================================================================
-;; deps.sx — Component dependency analysis specification
-;;
-;; Pure functions for analyzing component dependency graphs.
-;; Used by the bundling system to compute per-page component bundles
-;; instead of sending every definition to every page.
-;;
-;; All functions are pure — no IO, no platform-specific operations.
-;; Each host bootstraps this to native code alongside eval.sx/render.sx.
-;;
-;; From eval.sx platform (already provided by every host):
-;;   (type-of x)          → type string
-;;   (symbol-name s)      → string name of symbol
-;;   (component-body c)   → unevaluated AST of component body
-;;   (component-name c)   → string name (without ~)
-;;   (macro-body m)       → macro body AST
-;;   (env-get env k)      → value or nil
-;;
-;; New platform functions for deps (each host implements):
-;;   (component-deps c)       → cached deps list (may be empty)
-;;   (component-set-deps! c d)→ cache deps on component
-;;   (component-css-classes c)→ pre-scanned CSS class list
-;;   (regex-find-all pat src) → list of capture group 1 matches
-;;   (scan-css-classes src)   → list of CSS class strings from source
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 1. AST scanning — collect ~component references from an AST node
-;; --------------------------------------------------------------------------
-;; Walks all branches of control flow (if/when/cond/case) to find
-;; every component that *could* be rendered.
-
-(define scan-refs :effects []
-  (fn (node)
-    (let ((refs (list)))
-      (scan-refs-walk node refs)
-      refs)))
-
-
-(define scan-refs-walk :effects []
-  (fn (node (refs :as list))
-    (cond
-      ;; Symbol starting with ~ → component reference
-      (= (type-of node) "symbol")
-        (let ((name (symbol-name node)))
-          (when (starts-with? name "~")
-            (when (not (contains? refs name))
-              (append! refs name))))
-
-      ;; List → recurse into all elements (covers all control flow branches)
-      (= (type-of node) "list")
-        (for-each (fn (item) (scan-refs-walk item refs)) node)
-
-      ;; Dict → recurse into values
-      (= (type-of node) "dict")
-        (for-each (fn (key) (scan-refs-walk (dict-get node key) refs))
-                  (keys node))
-
-      ;; Literals (number, string, boolean, nil, keyword) → no refs
-      :else nil)))
-
-
-;; --------------------------------------------------------------------------
-;; 2. Transitive dependency closure
-;; --------------------------------------------------------------------------
-;; Given a component name and an environment, compute all components
-;; that it can transitively render.  Handles cycles via seen-set.
-
-(define transitive-deps-walk :effects []
-  (fn ((n :as string) (seen :as list) (env :as dict))
-    (when (not (contains? seen n))
-      (append! seen n)
-      (let ((val (env-get env n)))
-        (cond
-          (or (= (type-of val) "component") (= (type-of val) "island"))
-            (for-each (fn ((ref :as string)) (transitive-deps-walk ref seen env))
-                      (scan-refs (component-body val)))
-          (= (type-of val) "macro")
-            (for-each (fn ((ref :as string)) (transitive-deps-walk ref seen env))
-                      (scan-refs (macro-body val)))
-          :else nil)))))
-
-
-(define transitive-deps :effects []
-  (fn ((name :as string) (env :as dict))
-    (let ((seen (list))
-          (key (if (starts-with? name "~") name (str "~" name))))
-      (transitive-deps-walk key seen env)
-      (filter (fn ((x :as string)) (not (= x key))) seen))))
-
-
-;; --------------------------------------------------------------------------
-;; 3. Compute deps for all components in an environment
-;; --------------------------------------------------------------------------
-;; Iterates env, calls transitive-deps for each component, and
-;; stores the result via the platform's component-set-deps! function.
-;;
-;; Platform interface:
-;;   (env-components env) → list of component names in env
-;;   (component-set-deps! comp deps) → store deps on component
-
-(define compute-all-deps :effects [mutation]
-  (fn ((env :as dict))
-    (for-each
-      (fn ((name :as string))
-        (let ((val (env-get env name)))
-          (when (or (= (type-of val) "component") (= (type-of val) "island"))
-            (component-set-deps! val (transitive-deps name env)))))
-      (env-components env))))
-
-
-;; --------------------------------------------------------------------------
-;; 4. Scan serialized SX source for component references
-;; --------------------------------------------------------------------------
-;; Regex-based extraction of (~name patterns from SX wire format.
-;; Returns list of names WITH ~ prefix.
-;;
-;; Platform interface:
-;;   (regex-find-all pattern source) → list of matched group strings
-
-(define scan-components-from-source :effects []
-  (fn ((source :as string))
-    (let ((matches (regex-find-all "\\(~([a-zA-Z_][a-zA-Z0-9_\\-:/]*)" source)))
-      (map (fn ((m :as string)) (str "~" m)) matches))))
-
-
-;; --------------------------------------------------------------------------
-;; 5. Components needed for a page
-;; --------------------------------------------------------------------------
-;; Scans page source for direct component references, then computes
-;; the transitive closure.  Returns list of ~names.
-
-(define components-needed :effects []
-  (fn ((page-source :as string) (env :as dict))
-    (let ((direct (scan-components-from-source page-source))
-          (all-needed (list)))
-
-      ;; Add each direct ref + its transitive deps
-      (for-each
-        (fn ((name :as string))
-          (when (not (contains? all-needed name))
-            (append! all-needed name))
-          (let ((val (env-get env name)))
-            (let ((deps (if (and (= (type-of val) "component")
-                                 (not (empty? (component-deps val))))
-                          (component-deps val)
-                          (transitive-deps name env))))
-              (for-each
-                (fn ((dep :as string))
-                  (when (not (contains? all-needed dep))
-                    (append! all-needed dep)))
-                deps))))
-        direct)
-
-      all-needed)))
-
-
-;; --------------------------------------------------------------------------
-;; 6. Build per-page component bundle
-;; --------------------------------------------------------------------------
-;; Given page source and env, returns list of component names needed.
-;; The host uses this list to serialize only the needed definitions
-;; and compute a page-specific hash.
-;;
-;; This replaces the "send everything" approach with per-page bundles.
-
-(define page-component-bundle :effects []
-  (fn ((page-source :as string) (env :as dict))
-    (components-needed page-source env)))
-
-
-;; --------------------------------------------------------------------------
-;; 7. CSS classes for a page
-;; --------------------------------------------------------------------------
-;; Returns the union of CSS classes from components this page uses,
-;; plus classes from the page source itself.
-;;
-;; Platform interface:
-;;   (component-css-classes c) → set/list of class strings
-;;   (scan-css-classes source) → set/list of class strings from source
-
-(define page-css-classes :effects []
-  (fn ((page-source :as string) (env :as dict))
-    (let ((needed (components-needed page-source env))
-          (classes (list)))
-
-      ;; Collect classes from needed components
-      (for-each
-        (fn ((name :as string))
-          (let ((val (env-get env name)))
-            (when (= (type-of val) "component")
-              (for-each
-                (fn ((cls :as string))
-                  (when (not (contains? classes cls))
-                    (append! classes cls)))
-                (component-css-classes val)))))
-        needed)
-
-      ;; Add classes from page source
-      (for-each
-        (fn ((cls :as string))
-          (when (not (contains? classes cls))
-            (append! classes cls)))
-        (scan-css-classes page-source))
-
-      classes)))
-
-
-;; --------------------------------------------------------------------------
-;; 8. IO detection — scan component ASTs for IO primitive references
-;; --------------------------------------------------------------------------
-;; Extends the dependency walker to detect references to IO primitives.
-;; IO names are provided by the host (from boundary.sx declarations).
-;; A component is "pure" if it (transitively) references no IO primitives.
-;;
-;; Platform interface additions:
-;;   (component-io-refs c)        → cached IO ref list (may be empty)
-;;   (component-set-io-refs! c r) → cache IO refs on component
-
-(define scan-io-refs-walk :effects []
-  (fn (node (io-names :as list) (refs :as list))
-    (cond
-      ;; Symbol → check if name is in the IO set
-      (= (type-of node) "symbol")
-        (let ((name (symbol-name node)))
-          (when (contains? io-names name)
-            (when (not (contains? refs name))
-              (append! refs name))))
-
-      ;; List → recurse into all elements
-      (= (type-of node) "list")
-        (for-each (fn (item) (scan-io-refs-walk item io-names refs)) node)
-
-      ;; Dict → recurse into values
-      (= (type-of node) "dict")
-        (for-each (fn (key) (scan-io-refs-walk (dict-get node key) io-names refs))
-                  (keys node))
-
-      ;; Literals → no IO refs
-      :else nil)))
-
-
-(define scan-io-refs :effects []
-  (fn (node (io-names :as list))
-    (let ((refs (list)))
-      (scan-io-refs-walk node io-names refs)
-      refs)))
-
-
-;; --------------------------------------------------------------------------
-;; 9. Transitive IO refs — follow component deps and union IO refs
-;; --------------------------------------------------------------------------
-
-(define transitive-io-refs-walk :effects []
-  (fn ((n :as string) (seen :as list) (all-refs :as list) (env :as dict) (io-names :as list))
-    (when (not (contains? seen n))
-      (append! seen n)
-      (let ((val (env-get env n)))
-        (cond
-          (= (type-of val) "component")
-            (do
-              ;; Scan this component's body for IO refs
-              (for-each
-                (fn ((ref :as string))
-                  (when (not (contains? all-refs ref))
-                    (append! all-refs ref)))
-                (scan-io-refs (component-body val) io-names))
-              ;; Recurse into component deps
-              (for-each
-                (fn ((dep :as string)) (transitive-io-refs-walk dep seen all-refs env io-names))
-                (scan-refs (component-body val))))
-
-          (= (type-of val) "macro")
-            (do
-              (for-each
-                (fn ((ref :as string))
-                  (when (not (contains? all-refs ref))
-                    (append! all-refs ref)))
-                (scan-io-refs (macro-body val) io-names))
-              (for-each
-                (fn ((dep :as string)) (transitive-io-refs-walk dep seen all-refs env io-names))
-                (scan-refs (macro-body val))))
-
-          :else nil)))))
-
-
-(define transitive-io-refs :effects []
-  (fn ((name :as string) (env :as dict) (io-names :as list))
-    (let ((all-refs (list))
-          (seen (list))
-          (key (if (starts-with? name "~") name (str "~" name))))
-      (transitive-io-refs-walk key seen all-refs env io-names)
-      all-refs)))
-
-
-;; --------------------------------------------------------------------------
-;; 10. Compute IO refs for all components in an environment
-;; --------------------------------------------------------------------------
-
-(define compute-all-io-refs :effects [mutation]
-  (fn ((env :as dict) (io-names :as list))
-    (for-each
-      (fn ((name :as string))
-        (let ((val (env-get env name)))
-          (when (= (type-of val) "component")
-            (component-set-io-refs! val (transitive-io-refs name env io-names)))))
-      (env-components env))))
-
-
-(define component-io-refs-cached :effects []
-  (fn ((name :as string) (env :as dict) (io-names :as list))
-    (let ((key (if (starts-with? name "~") name (str "~" name))))
-      (let ((val (env-get env key)))
-        (if (and (= (type-of val) "component")
-                 (not (nil? (component-io-refs val)))
-                 (not (empty? (component-io-refs val))))
-          (component-io-refs val)
-          ;; Fallback: not yet cached (shouldn't happen after compute-all-io-refs)
-          (transitive-io-refs name env io-names))))))
-
-(define component-pure? :effects []
-  (fn ((name :as string) (env :as dict) (io-names :as list))
-    (let ((key (if (starts-with? name "~") name (str "~" name))))
-      (let ((val (env-get env key)))
-        (if (and (= (type-of val) "component")
-                 (not (nil? (component-io-refs val))))
-          ;; Use cached io-refs (empty list = pure)
-          (empty? (component-io-refs val))
-          ;; Fallback
-          (empty? (transitive-io-refs name env io-names)))))))
-
-
-;; --------------------------------------------------------------------------
-;; 5. Render target — boundary decision per component
-;; --------------------------------------------------------------------------
-;; Combines IO analysis with affinity annotations to decide where a
-;; component should render:
-;;
-;;   :affinity :server  → always "server" (auth-sensitive, secrets)
-;;   :affinity :client  → "client" even if IO-dependent (IO proxy)
-;;   :affinity :auto    → "server" if IO-dependent, "client" if pure
-;;
-;; Returns: "server" | "client"
-
-(define render-target :effects []
-  (fn ((name :as string) (env :as dict) (io-names :as list))
-    (let ((key (if (starts-with? name "~") name (str "~" name))))
-      (let ((val (env-get env key)))
-        (if (not (= (type-of val) "component"))
-          "server"
-          (let ((affinity (component-affinity val)))
-            (cond
-              (= affinity "server") "server"
-              (= affinity "client") "client"
-              ;; auto: decide from IO analysis
-              (not (component-pure? name env io-names)) "server"
-              :else "client")))))))
-
-
-;; --------------------------------------------------------------------------
-;; 6. Page render plan — pre-computed boundary decisions for a page
-;; --------------------------------------------------------------------------
-;; Given page source + env + IO names, returns a render plan dict:
-;;
-;;   {:components {~name "server"|"client" ...}
-;;    :server     (list of ~names that render server-side)
-;;    :client     (list of ~names that render client-side)
-;;    :io-deps    (list of IO primitives needed by server components)}
-;;
-;; This is computed once at page registration and cached on the page def.
-;; The async evaluator and client router both use it to make decisions
-;; without recomputing at every request.
-
-(define page-render-plan :effects []
-  (fn ((page-source :as string) (env :as dict) (io-names :as list))
-    (let ((needed (components-needed page-source env))
-          (comp-targets (dict))
-          (server-list (list))
-          (client-list (list))
-          (io-deps (list)))
-
-      (for-each
-        (fn ((name :as string))
-          (let ((target (render-target name env io-names)))
-            (dict-set! comp-targets name target)
-            (if (= target "server")
-              (do
-                (append! server-list name)
-                ;; Collect IO deps from server components (use cache)
-                (for-each
-                  (fn ((io-ref :as string))
-                    (when (not (contains? io-deps io-ref))
-                      (append! io-deps io-ref)))
-                  (component-io-refs-cached name env io-names)))
-              (append! client-list name))))
-        needed)
-
-      {:components comp-targets
-       :server server-list
-       :client client-list
-       :io-deps io-deps})))
-
-
-;; --------------------------------------------------------------------------
-;; Host obligation: selective expansion in async partial evaluation
-;; --------------------------------------------------------------------------
-;; The spec classifies components as pure or IO-dependent and provides
-;; per-component render-target decisions. Each host's async partial
-;; evaluator (the server-side rendering path that bridges sync evaluation
-;; with async IO) must use this classification:
-;;
-;;   render-target "server" → expand server-side (IO must resolve)
-;;   render-target "client" → serialize for client (can render anywhere)
-;;   Layout slot context    → expand all (server needs full HTML)
-;;
-;; The spec provides: component-io-refs, component-pure?, render-target,
-;; component-affinity. The host provides the async runtime that acts on it.
-;; This is not SX semantics — it is host infrastructure. Every host
-;; with a server-side async evaluator implements the same rule.
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; Platform interface summary
-;; --------------------------------------------------------------------------
-;;
-;; From eval.sx (already provided):
-;;   (type-of x)          → type string
-;;   (symbol-name s)      → string name of symbol
-;;   (env-get env k)      → value or nil
-;;
-;; New for deps.sx (each host implements):
-;;   (component-body c)       → AST body of component
-;;   (component-name c)       → name string
-;;   (component-deps c)       → cached deps list (may be empty)
-;;   (component-set-deps! c d)→ cache deps on component
-;;   (component-css-classes c)→ pre-scanned CSS class list
-;;   (component-io-refs c)       → cached IO ref list (may be empty)
-;;   (component-set-io-refs! c r)→ cache IO refs on component
-;;   (component-affinity c)      → "auto" | "client" | "server"
-;;   (macro-body m)           → AST body of macro
-;;   (regex-find-all pat src) → list of capture group matches
-;;   (scan-css-classes src)   → list of CSS class strings from source
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; env-components — list component/macro names in an environment
-;; --------------------------------------------------------------------------
-;; Moved from platform to spec: pure logic using type predicates.
-
-(define env-components :effects []
-  (fn ((env :as dict))
-    (filter
-      (fn ((k :as string))
-        (let ((v (env-get env k)))
-          (or (component? v) (macro? v))))
-      (keys env))))

shared/sx/ref/engine.sx

@@ -1,803 +0,0 @@
-;; ==========================================================================
-;; engine.sx — SxEngine pure logic
-;;
-;; Fetch/swap/history engine for browser-side SX. Like HTMX but native
-;; to the SX rendering pipeline.
-;;
-;; This file specifies the pure LOGIC of the engine in s-expressions:
-;; parsing trigger specs, morph algorithm, swap dispatch, header building,
-;; retry logic, target resolution, etc.
-;;
-;; Orchestration (binding events, executing requests, processing elements)
-;; lives in orchestration.sx, which depends on this file.
-;;
-;; Depends on:
-;;   adapter-dom.sx — render-to-dom (for SX response rendering)
-;;   render.sx      — shared registries
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Constants
-;; --------------------------------------------------------------------------
-
-(define ENGINE_VERBS (list "get" "post" "put" "delete" "patch"))
-(define DEFAULT_SWAP "outerHTML")
-
-
-;; --------------------------------------------------------------------------
-;; Trigger parsing
-;; --------------------------------------------------------------------------
-;; Parses the sx-trigger attribute value into a list of trigger descriptors.
-;; Each descriptor is a dict with "event" and "modifiers" keys.
-
-(define parse-time :effects []
-  (fn ((s :as string))
-    ;; Parse time string: "2s" → 2000, "500ms" → 500
-    ;; Uses nested if (not cond) because cond misclassifies 2-element
-    ;; function calls like (nil? s) as scheme-style ((test body)) clauses.
-    (if (nil? s) 0
-      (if (ends-with? s "ms") (parse-int s 0)
-        (if (ends-with? s "s") (* (parse-int (replace s "s" "") 0) 1000)
-          (parse-int s 0))))))
-
-
-(define parse-trigger-spec :effects []
-  (fn ((spec :as string))
-    ;; Parse "click delay:500ms once,change" → list of trigger descriptors
-    (if (nil? spec)
-      nil
-      (let ((raw-parts (split spec ",")))
-        (filter
-          (fn (x) (not (nil? x)))
-          (map
-            (fn ((part :as string))
-              (let ((tokens (split (trim part) " ")))
-                (if (empty? tokens)
-                  nil
-                  (if (and (= (first tokens) "every") (>= (len tokens) 2))
-                    ;; Polling trigger
-                    (dict
-                      "event" "every"
-                      "modifiers" (dict "interval" (parse-time (nth tokens 1))))
-                    ;; Normal trigger with optional modifiers
-                    (let ((mods (dict)))
-                      (for-each
-                        (fn ((tok :as string))
-                          (cond
-                            (= tok "once")
-                              (dict-set! mods "once" true)
-                            (= tok "changed")
-                              (dict-set! mods "changed" true)
-                            (starts-with? tok "delay:")
-                              (dict-set! mods "delay"
-                                (parse-time (slice tok 6)))
-                            (starts-with? tok "from:")
-                              (dict-set! mods "from"
-                                (slice tok 5))))
-                        (rest tokens))
-                      (dict "event" (first tokens) "modifiers" mods))))))
-            raw-parts))))))
-
-
-(define default-trigger :effects []
-  (fn ((tag-name :as string))
-    ;; Default trigger for element type
-    (cond
-      (= tag-name "FORM")
-        (list (dict "event" "submit" "modifiers" (dict)))
-      (or (= tag-name "INPUT")
-          (= tag-name "SELECT")
-          (= tag-name "TEXTAREA"))
-        (list (dict "event" "change" "modifiers" (dict)))
-      :else
-        (list (dict "event" "click" "modifiers" (dict))))))
-
-
-;; --------------------------------------------------------------------------
-;; Verb extraction
-;; --------------------------------------------------------------------------
-
-(define get-verb-info :effects [io]
-  (fn (el)
-    ;; Check element for sx-get, sx-post, etc. Returns (dict "method" "url") or nil.
-    (some
-      (fn ((verb :as string))
-        (let ((url (dom-get-attr el (str "sx-" verb))))
-          (if url
-            (dict "method" (upper verb) "url" url)
-            nil)))
-      ENGINE_VERBS)))
-
-
-;; --------------------------------------------------------------------------
-;; Request header building
-;; --------------------------------------------------------------------------
-
-(define build-request-headers :effects [io]
-  (fn (el (loaded-components :as list) (css-hash :as string))
-    ;; Build the SX request headers dict
-    (let ((headers (dict
-                     "SX-Request" "true"
-                     "SX-Current-URL" (browser-location-href))))
-      ;; Target selector
-      (let ((target-sel (dom-get-attr el "sx-target")))
-        (when target-sel
-          (dict-set! headers "SX-Target" target-sel)))
-
-      ;; Loaded component names
-      (when (not (empty? loaded-components))
-        (dict-set! headers "SX-Components"
-          (join "," loaded-components)))
-
-      ;; CSS class hash
-      (when css-hash
-        (dict-set! headers "SX-Css" css-hash))
-
-      ;; Extra headers from sx-headers attribute
-      (let ((extra-h (dom-get-attr el "sx-headers")))
-        (when extra-h
-          (let ((parsed (parse-header-value extra-h)))
-            (when parsed
-              (for-each
-                (fn ((key :as string)) (dict-set! headers key (str (get parsed key))))
-                (keys parsed))))))
-
-      headers)))
-
-
-;; --------------------------------------------------------------------------
-;; Response header processing
-;; --------------------------------------------------------------------------
-
-(define process-response-headers :effects []
-  (fn ((get-header :as lambda))
-    ;; Extract all SX response header directives into a dict.
-    ;; get-header is (fn (name) → string or nil).
-    (dict
-      "redirect"          (get-header "SX-Redirect")
-      "refresh"           (get-header "SX-Refresh")
-      "trigger"           (get-header "SX-Trigger")
-      "retarget"          (get-header "SX-Retarget")
-      "reswap"            (get-header "SX-Reswap")
-      "location"          (get-header "SX-Location")
-      "replace-url"       (get-header "SX-Replace-Url")
-      "css-hash"          (get-header "SX-Css-Hash")
-      "trigger-swap"      (get-header "SX-Trigger-After-Swap")
-      "trigger-settle"    (get-header "SX-Trigger-After-Settle")
-      "content-type"      (get-header "Content-Type")
-      "cache-invalidate"  (get-header "SX-Cache-Invalidate")
-      "cache-update"      (get-header "SX-Cache-Update"))))
-
-
-;; --------------------------------------------------------------------------
-;; Swap specification parsing
-;; --------------------------------------------------------------------------
-
-(define parse-swap-spec :effects []
-  (fn ((raw-swap :as string) (global-transitions? :as boolean))
-    ;; Parse "innerHTML transition:true" → dict with style + transition flag
-    (let ((parts (split (or raw-swap DEFAULT_SWAP) " "))
-          (style (first parts))
-          (use-transition global-transitions?))
-      (for-each
-        (fn ((p :as string))
-          (cond
-            (= p "transition:true")  (set! use-transition true)
-            (= p "transition:false") (set! use-transition false)))
-        (rest parts))
-      (dict "style" style "transition" use-transition))))
-
-
-;; --------------------------------------------------------------------------
-;; Retry logic
-;; --------------------------------------------------------------------------
-
-(define parse-retry-spec :effects []
-  (fn ((retry-attr :as string))
-    ;; Parse "exponential:1000:30000" → spec dict or nil
-    (if (nil? retry-attr)
-      nil
-      (let ((parts (split retry-attr ":")))
-        (dict
-          "strategy"  (first parts)
-          "start-ms"  (parse-int (nth parts 1) 1000)
-          "cap-ms"    (parse-int (nth parts 2) 30000))))))
-
-
-(define next-retry-ms :effects []
-  (fn ((current-ms :as number) (cap-ms :as number))
-    ;; Exponential backoff: double current, cap at max
-    (min (* current-ms 2) cap-ms)))
-
-
-;; --------------------------------------------------------------------------
-;; Form parameter filtering
-;; --------------------------------------------------------------------------
-
-(define filter-params :effects []
-  (fn ((params-spec :as string) (all-params :as list))
-    ;; Filter form parameters by sx-params spec.
-    ;; all-params is a list of (key value) pairs.
-    ;; Returns filtered list of (key value) pairs.
-    ;; Uses nested if (not cond) — see parse-time comment.
-    (if (nil? params-spec) all-params
-      (if (= params-spec "none") (list)
-        (if (= params-spec "*") all-params
-          (if (starts-with? params-spec "not ")
-            (let ((excluded (map trim (split (slice params-spec 4) ","))))
-              (filter
-                (fn ((p :as list)) (not (contains? excluded (first p))))
-                all-params))
-            (let ((allowed (map trim (split params-spec ","))))
-              (filter
-                (fn ((p :as list)) (contains? allowed (first p)))
-                all-params))))))))
-
-
-;; --------------------------------------------------------------------------
-;; Target resolution
-;; --------------------------------------------------------------------------
-
-(define resolve-target :effects [io]
-  (fn (el)
-    ;; Resolve the swap target for an element
-    (let ((sel (dom-get-attr el "sx-target")))
-      (cond
-        (or (nil? sel) (= sel "this")) el
-        (= sel "closest") (dom-parent el)
-        :else (dom-query sel)))))
-
-
-;; --------------------------------------------------------------------------
-;; Optimistic updates
-;; --------------------------------------------------------------------------
-
-(define apply-optimistic :effects [mutation io]
-  (fn (el)
-    ;; Apply optimistic update preview. Returns state for reverting, or nil.
-    (let ((directive (dom-get-attr el "sx-optimistic")))
-      (if (nil? directive)
-        nil
-        (let ((target (or (resolve-target el) el))
-              (state (dict "target" target "directive" directive)))
-          (cond
-            (= directive "remove")
-              (do
-                (dict-set! state "opacity" (dom-get-style target "opacity"))
-                (dom-set-style target "opacity" "0")
-                (dom-set-style target "pointer-events" "none"))
-            (= directive "disable")
-              (do
-                (dict-set! state "disabled" (dom-get-prop target "disabled"))
-                (dom-set-prop target "disabled" true))
-            (starts-with? directive "add-class:")
-              (let ((cls (slice directive 10)))
-                (dict-set! state "add-class" cls)
-                (dom-add-class target cls)))
-          state)))))
-
-
-(define revert-optimistic :effects [mutation io]
-  (fn ((state :as dict))
-    ;; Revert an optimistic update
-    (when state
-      (let ((target (get state "target"))
-            (directive (get state "directive")))
-        (cond
-          (= directive "remove")
-            (do
-              (dom-set-style target "opacity" (or (get state "opacity") ""))
-              (dom-set-style target "pointer-events" ""))
-          (= directive "disable")
-            (dom-set-prop target "disabled" (or (get state "disabled") false))
-          (get state "add-class")
-            (dom-remove-class target (get state "add-class")))))))
-
-
-;; --------------------------------------------------------------------------
-;; Out-of-band swap identification
-;; --------------------------------------------------------------------------
-
-(define find-oob-swaps :effects [mutation io]
-  (fn (container)
-    ;; Find elements marked for out-of-band swapping.
-    ;; Returns list of (dict "element" el "swap-type" type "target-id" id).
-    (let ((results (list)))
-      (for-each
-        (fn ((attr :as string))
-          (let ((oob-els (dom-query-all container (str "[" attr "]"))))
-            (for-each
-              (fn (oob)
-                (let ((swap-type (or (dom-get-attr oob attr) "outerHTML"))
-                      (target-id (dom-id oob)))
-                  (dom-remove-attr oob attr)
-                  (when target-id
-                    (append! results
-                      (dict "element" oob
-                            "swap-type" swap-type
-                            "target-id" target-id)))))
-              oob-els)))
-        (list "sx-swap-oob" "hx-swap-oob"))
-      results)))
-
-
-;; --------------------------------------------------------------------------
-;; DOM morph algorithm
-;; --------------------------------------------------------------------------
-;; Lightweight reconciler: patches oldNode to match newNode in-place,
-;; preserving event listeners, focus, scroll position, and form state
-;; on keyed (id) elements.
-
-(define morph-node :effects [mutation io]
-  (fn (old-node new-node)
-    ;; Morph old-node to match new-node, preserving listeners/state.
-    (cond
-      ;; sx-preserve / sx-ignore → skip
-      (or (dom-has-attr? old-node "sx-preserve")
-          (dom-has-attr? old-node "sx-ignore"))
-        nil
-
-      ;; Hydrated island → preserve reactive state, morph lakes.
-      ;; If old and new are the same island (by name), keep the old DOM
-      ;; with its live signals, effects, and event listeners intact.
-      ;; But recurse into data-sx-lake slots so the server can update
-      ;; non-reactive content within the island.
-      (and (dom-has-attr? old-node "data-sx-island")
-           (is-processed? old-node "island-hydrated")
-           (dom-has-attr? new-node "data-sx-island")
-           (= (dom-get-attr old-node "data-sx-island")
-              (dom-get-attr new-node "data-sx-island")))
-        (morph-island-children old-node new-node)
-
-      ;; Different node type or tag → replace wholesale
-      (or (not (= (dom-node-type old-node) (dom-node-type new-node)))
-          (not (= (dom-node-name old-node) (dom-node-name new-node))))
-        (dom-replace-child (dom-parent old-node)
-          (dom-clone new-node) old-node)
-
-      ;; Text/comment nodes → update content
-      (or (= (dom-node-type old-node) 3) (= (dom-node-type old-node) 8))
-        (when (not (= (dom-text-content old-node) (dom-text-content new-node)))
-          (dom-set-text-content old-node (dom-text-content new-node)))
-
-      ;; Element nodes → sync attributes, then recurse children
-      (= (dom-node-type old-node) 1)
-        (do
-          (sync-attrs old-node new-node)
-          ;; Skip morphing focused input to preserve user's in-progress edits
-          (when (not (and (dom-is-active-element? old-node)
-                         (dom-is-input-element? old-node)))
-            (morph-children old-node new-node))))))
-
-
-(define sync-attrs :effects [mutation io]
-  (fn (old-el new-el)
-    ;; Sync attributes from new to old, but skip reactively managed attrs.
-    ;; data-sx-reactive-attrs="style,class" means those attrs are owned by
-    ;; signal effects and must not be overwritten by the morph.
-    (let ((ra-str (or (dom-get-attr old-el "data-sx-reactive-attrs") ""))
-          (reactive-attrs (if (empty? ra-str) (list) (split ra-str ","))))
-      ;; Add/update attributes from new, skip reactive ones
-      (for-each
-        (fn ((attr :as list))
-          (let ((name (first attr))
-                (val  (nth attr 1)))
-            (when (and (not (= (dom-get-attr old-el name) val))
-                       (not (contains? reactive-attrs name)))
-              (dom-set-attr old-el name val))))
-        (dom-attr-list new-el))
-      ;; Remove attributes not in new, skip reactive + marker attrs
-      (for-each
-        (fn ((attr :as list))
-          (let ((aname (first attr)))
-            (when (and (not (dom-has-attr? new-el aname))
-                       (not (contains? reactive-attrs aname))
-                       (not (= aname "data-sx-reactive-attrs")))
-              (dom-remove-attr old-el aname))))
-        (dom-attr-list old-el)))))
-
-
-(define morph-children :effects [mutation io]
-  (fn (old-parent new-parent)
-    ;; Reconcile children of old-parent to match new-parent.
-    ;; Keyed elements (with id) are matched and moved in-place.
-    (let ((old-kids (dom-child-list old-parent))
-          (new-kids (dom-child-list new-parent))
-          ;; Build ID map of old children for keyed matching
-          (old-by-id (reduce
-                       (fn ((acc :as dict) kid)
-                         (let ((id (dom-id kid)))
-                           (if id (do (dict-set! acc id kid) acc) acc)))
-                       (dict) old-kids))
-          (oi 0))
-
-      ;; Walk new children, morph/insert/append
-      (for-each
-        (fn (new-child)
-          (let ((match-id (dom-id new-child))
-                (match-by-id (if match-id (dict-get old-by-id match-id) nil)))
-            (cond
-              ;; Keyed match — move into position if needed, then morph
-              (and match-by-id (not (nil? match-by-id)))
-                (do
-                  (when (and (< oi (len old-kids))
-                             (not (= match-by-id (nth old-kids oi))))
-                    (dom-insert-before old-parent match-by-id
-                      (if (< oi (len old-kids)) (nth old-kids oi) nil)))
-                  (morph-node match-by-id new-child)
-                  (set! oi (inc oi)))
-
-              ;; Positional match
-              (< oi (len old-kids))
-                (let ((old-child (nth old-kids oi)))
-                  (if (and (dom-id old-child) (not match-id))
-                    ;; Old has ID, new doesn't — insert new before old
-                    (dom-insert-before old-parent
-                      (dom-clone new-child) old-child)
-                    ;; Normal positional morph
-                    (do
-                      (morph-node old-child new-child)
-                      (set! oi (inc oi)))))
-
-              ;; Extra new children — append
-              :else
-                (dom-append old-parent (dom-clone new-child)))))
-        new-kids)
-
-      ;; Remove leftover old children
-      (for-each
-        (fn ((i :as number))
-          (when (>= i oi)
-            (let ((leftover (nth old-kids i)))
-              (when (and (dom-is-child-of? leftover old-parent)
-                         (not (dom-has-attr? leftover "sx-preserve"))
-                         (not (dom-has-attr? leftover "sx-ignore")))
-                (dom-remove-child old-parent leftover)))))
-        (range oi (len old-kids))))))
-
-
-;; --------------------------------------------------------------------------
-;; morph-island-children — deep morph into hydrated islands via lakes
-;; --------------------------------------------------------------------------
-;;
-;; Level 2-3 island morphing: the server can update non-reactive content
-;; within hydrated islands by morphing data-sx-lake slots.
-;;
-;; The island's reactive DOM (signals, effects, event listeners) is preserved.
-;; Only lake slots — explicitly marked server territory — receive new content.
-;;
-;; This is the Hegelian synthesis made concrete:
-;;   - Islands = client subjectivity (reactive state, preserved)
-;;   - Lakes = server substance (content, morphed)
-;;   - The morph = Aufhebung (cancellation/preservation/elevation of both)
-
-(define morph-island-children :effects [mutation io]
-  (fn (old-island new-island)
-    ;; Find all lake and marsh slots in both old and new islands
-    (let ((old-lakes (dom-query-all old-island "[data-sx-lake]"))
-          (new-lakes (dom-query-all new-island "[data-sx-lake]"))
-          (old-marshes (dom-query-all old-island "[data-sx-marsh]"))
-          (new-marshes (dom-query-all new-island "[data-sx-marsh]")))
-      ;; Build ID→element maps for new lakes and marshes
-      (let ((new-lake-map (dict))
-            (new-marsh-map (dict)))
-        (for-each
-          (fn (lake)
-            (let ((id (dom-get-attr lake "data-sx-lake")))
-              (when id (dict-set! new-lake-map id lake))))
-          new-lakes)
-        (for-each
-          (fn (marsh)
-            (let ((id (dom-get-attr marsh "data-sx-marsh")))
-              (when id (dict-set! new-marsh-map id marsh))))
-          new-marshes)
-        ;; Morph each old lake from its new counterpart
-        (for-each
-          (fn (old-lake)
-            (let ((id (dom-get-attr old-lake "data-sx-lake")))
-              (let ((new-lake (dict-get new-lake-map id)))
-                (when new-lake
-                  (sync-attrs old-lake new-lake)
-                  (morph-children old-lake new-lake)))))
-          old-lakes)
-        ;; Morph each old marsh from its new counterpart
-        (for-each
-          (fn (old-marsh)
-            (let ((id (dom-get-attr old-marsh "data-sx-marsh")))
-              (let ((new-marsh (dict-get new-marsh-map id)))
-                (when new-marsh
-                  (morph-marsh old-marsh new-marsh old-island)))))
-          old-marshes)
-        ;; Process data-sx-signal attributes — server writes to named stores
-        (process-signal-updates new-island)))))
-
-
-;; --------------------------------------------------------------------------
-;; morph-marsh — re-evaluate server content in island's reactive scope
-;; --------------------------------------------------------------------------
-;;
-;; Marshes are zones inside islands where server content is re-evaluated by
-;; the island's reactive evaluator. During morph, the new content is parsed
-;; as SX and rendered in the island's signal context. If the marsh has a
-;; :transform function, it reshapes the content before evaluation.
-
-(define morph-marsh :effects [mutation io]
-  (fn (old-marsh new-marsh island-el)
-    (let ((transform (dom-get-data old-marsh "sx-marsh-transform"))
-          (env (dom-get-data old-marsh "sx-marsh-env"))
-          (new-html (dom-inner-html new-marsh)))
-      (if (and env new-html (not (empty? new-html)))
-        ;; Parse new content as SX and re-evaluate in island scope
-        (let ((parsed (parse new-html)))
-          (let ((sx-content (if transform (cek-call transform (list parsed)) parsed)))
-            ;; Dispose old reactive bindings in this marsh
-            (dispose-marsh-scope old-marsh)
-            ;; Evaluate the SX in a new marsh scope — creates new reactive bindings
-            (with-marsh-scope old-marsh
-              (fn ()
-                (let ((new-dom (render-to-dom sx-content env nil)))
-                  ;; Replace marsh children
-                  (dom-remove-children-after old-marsh nil)
-                  (dom-append old-marsh new-dom))))))
-        ;; Fallback: morph like a lake
-        (do
-          (sync-attrs old-marsh new-marsh)
-          (morph-children old-marsh new-marsh))))))
-
-
-;; --------------------------------------------------------------------------
-;; process-signal-updates — server responses write to named store signals
-;; --------------------------------------------------------------------------
-;;
-;; Elements with data-sx-signal="name:value" trigger signal writes.
-;; After processing, the attribute is removed (consumed).
-;;
-;; Values are JSON-parsed: "7" → 7, "\"hello\"" → "hello", "true" → true.
-
-(define process-signal-updates :effects [mutation io]
-  (fn (root)
-    (let ((signal-els (dom-query-all root "[data-sx-signal]")))
-      (for-each
-        (fn (el)
-          (let ((spec (dom-get-attr el "data-sx-signal")))
-            (when spec
-              (let ((colon-idx (index-of spec ":")))
-                (when (> colon-idx 0)
-                  (let ((store-name (slice spec 0 colon-idx))
-                        (raw-value (slice spec (+ colon-idx 1))))
-                    (let ((parsed (json-parse raw-value)))
-                      (reset! (use-store store-name) parsed))
-                    (dom-remove-attr el "data-sx-signal")))))))
-        signal-els))))
-
-
-;; --------------------------------------------------------------------------
-;; Swap dispatch
-;; --------------------------------------------------------------------------
-
-(define swap-dom-nodes :effects [mutation io]
-  (fn (target new-nodes (strategy :as string))
-    ;; Execute a swap strategy on live DOM nodes.
-    ;; new-nodes is typically a DocumentFragment or Element.
-    (case strategy
-      "innerHTML"
-        (if (dom-is-fragment? new-nodes)
-          (morph-children target new-nodes)
-          (let ((wrapper (dom-create-element "div" nil)))
-            (dom-append wrapper new-nodes)
-            (morph-children target wrapper)))
-
-      "outerHTML"
-        (let ((parent (dom-parent target)))
-          (if (dom-is-fragment? new-nodes)
-            ;; Fragment — morph first child, insert rest
-            (let ((fc (dom-first-child new-nodes)))
-              (if fc
-                (do
-                  (morph-node target fc)
-                  ;; Insert remaining siblings after morphed element
-                  (let ((sib (dom-next-sibling fc)))
-                    (insert-remaining-siblings parent target sib)))
-                (dom-remove-child parent target)))
-            (morph-node target new-nodes))
-          parent)
-
-      "afterend"
-        (dom-insert-after target new-nodes)
-
-      "beforeend"
-        (dom-append target new-nodes)
-
-      "afterbegin"
-        (dom-prepend target new-nodes)
-
-      "beforebegin"
-        (dom-insert-before (dom-parent target) new-nodes target)
-
-      "delete"
-        (dom-remove-child (dom-parent target) target)
-
-      "none"
-        nil
-
-      ;; Default = innerHTML
-      :else
-        (if (dom-is-fragment? new-nodes)
-          (morph-children target new-nodes)
-          (let ((wrapper (dom-create-element "div" nil)))
-            (dom-append wrapper new-nodes)
-            (morph-children target wrapper))))))
-
-
-(define insert-remaining-siblings :effects [mutation io]
-  (fn (parent ref-node sib)
-    ;; Insert sibling chain after ref-node
-    (when sib
-      (let ((next (dom-next-sibling sib)))
-        (dom-insert-after ref-node sib)
-        (insert-remaining-siblings parent sib next)))))
-
-
-;; --------------------------------------------------------------------------
-;; String-based swap (fallback for HTML responses)
-;; --------------------------------------------------------------------------
-
-(define swap-html-string :effects [mutation io]
-  (fn (target (html :as string) (strategy :as string))
-    ;; Execute a swap strategy using an HTML string (DOMParser pipeline).
-    (case strategy
-      "innerHTML"
-        (dom-set-inner-html target html)
-      "outerHTML"
-        (let ((parent (dom-parent target)))
-          (dom-insert-adjacent-html target "afterend" html)
-          (dom-remove-child parent target)
-          parent)
-      "afterend"
-        (dom-insert-adjacent-html target "afterend" html)
-      "beforeend"
-        (dom-insert-adjacent-html target "beforeend" html)
-      "afterbegin"
-        (dom-insert-adjacent-html target "afterbegin" html)
-      "beforebegin"
-        (dom-insert-adjacent-html target "beforebegin" html)
-      "delete"
-        (dom-remove-child (dom-parent target) target)
-      "none"
-        nil
-      :else
-        (dom-set-inner-html target html))))
-
-
-;; --------------------------------------------------------------------------
-;; History management
-;; --------------------------------------------------------------------------
-
-(define handle-history :effects [io]
-  (fn (el (url :as string) (resp-headers :as dict))
-    ;; Process history push/replace based on element attrs and response headers
-    (let ((push-url     (dom-get-attr el "sx-push-url"))
-          (replace-url  (dom-get-attr el "sx-replace-url"))
-          (hdr-replace  (get resp-headers "replace-url")))
-      (cond
-        ;; Server override
-        hdr-replace
-          (browser-replace-state hdr-replace)
-        ;; Client push
-        (and push-url (not (= push-url "false")))
-          (browser-push-state
-            (if (= push-url "true") url push-url))
-        ;; Client replace
-        (and replace-url (not (= replace-url "false")))
-          (browser-replace-state
-            (if (= replace-url "true") url replace-url))))))
-
-
-;; --------------------------------------------------------------------------
-;; Preload cache
-;; --------------------------------------------------------------------------
-
-(define PRELOAD_TTL 30000)  ;; 30 seconds
-
-(define preload-cache-get :effects [mutation]
-  (fn ((cache :as dict) (url :as string))
-    ;; Get and consume a cached preload response.
-    ;; Returns (dict "text" ... "content-type" ...) or nil.
-    (let ((entry (dict-get cache url)))
-      (if (nil? entry)
-        nil
-        (if (> (- (now-ms) (get entry "timestamp")) PRELOAD_TTL)
-          (do (dict-delete! cache url) nil)
-          (do (dict-delete! cache url) entry))))))
-
-
-(define preload-cache-set :effects [mutation]
-  (fn ((cache :as dict) (url :as string) (text :as string) (content-type :as string))
-    ;; Store a preloaded response
-    (dict-set! cache url
-      (dict "text" text "content-type" content-type "timestamp" (now-ms)))))
-
-
-;; --------------------------------------------------------------------------
-;; Trigger dispatch table
-;; --------------------------------------------------------------------------
-;; Maps trigger event names to binding strategies.
-;; This is the logic; actual browser event binding is platform interface.
-
-(define classify-trigger :effects []
-  (fn ((trigger :as dict))
-    ;; Classify a parsed trigger descriptor for binding.
-    ;; Returns one of: "poll", "intersect", "load", "revealed", "event"
-    (let ((event (get trigger "event")))
-      (cond
-        (= event "every")     "poll"
-        (= event "intersect") "intersect"
-        (= event "load")      "load"
-        (= event "revealed")  "revealed"
-        :else                 "event"))))
-
-
-;; --------------------------------------------------------------------------
-;; Boost logic
-;; --------------------------------------------------------------------------
-
-(define should-boost-link? :effects [io]
-  (fn (link)
-    ;; Whether a link inside an sx-boost container should be boosted
-    (let ((href (dom-get-attr link "href")))
-      (and href
-           (not (starts-with? href "#"))
-           (not (starts-with? href "javascript:"))
-           (not (starts-with? href "mailto:"))
-           (browser-same-origin? href)
-           (not (dom-has-attr? link "sx-get"))
-           (not (dom-has-attr? link "sx-post"))
-           (not (dom-has-attr? link "sx-disable"))))))
-
-
-(define should-boost-form? :effects [io]
-  (fn (form)
-    ;; Whether a form inside an sx-boost container should be boosted
-    (and (not (dom-has-attr? form "sx-get"))
-         (not (dom-has-attr? form "sx-post"))
-         (not (dom-has-attr? form "sx-disable")))))
-
-
-;; --------------------------------------------------------------------------
-;; SSE event classification
-;; --------------------------------------------------------------------------
-
-(define parse-sse-swap :effects [io]
-  (fn (el)
-    ;; Parse sx-sse-swap attribute
-    ;; Returns event name to listen for (default "message")
-    (or (dom-get-attr el "sx-sse-swap") "message")))
-
-
-;; --------------------------------------------------------------------------
-;; Platform interface — Engine (pure logic)
-;; --------------------------------------------------------------------------
-;;
-;; From adapter-dom.sx:
-;;   dom-get-attr, dom-set-attr, dom-remove-attr, dom-has-attr?, dom-attr-list
-;;   dom-query, dom-query-all, dom-id, dom-parent, dom-first-child,
-;;   dom-next-sibling, dom-child-list, dom-node-type, dom-node-name,
-;;   dom-text-content, dom-set-text-content, dom-is-fragment?,
-;;   dom-is-child-of?, dom-is-active-element?, dom-is-input-element?,
-;;   dom-create-element, dom-append, dom-prepend, dom-insert-before,
-;;   dom-insert-after, dom-remove-child, dom-replace-child, dom-clone,
-;;   dom-get-style, dom-set-style, dom-get-prop, dom-set-prop,
-;;   dom-add-class, dom-remove-class, dom-set-inner-html,
-;;   dom-insert-adjacent-html
-;;
-;; Browser/Network:
-;;   (browser-location-href)        → current URL string
-;;   (browser-same-origin? url)     → boolean
-;;   (browser-push-state url)       → void (history.pushState)
-;;   (browser-replace-state url)    → void (history.replaceState)
-;;
-;; Parsing:
-;;   (parse-header-value s)         → parsed dict from header string
-;;   (now-ms)                       → current timestamp in milliseconds
-;; --------------------------------------------------------------------------

shared/sx/ref/forms.sx

@@ -1,278 +0,0 @@
-;; ==========================================================================
-;; forms.sx — Server-side definition forms
-;;
-;; Platform-specific special forms for declaring handlers, pages, queries,
-;; and actions. These parse &key parameter lists and create typed definition
-;; objects that the server runtime uses for routing and execution.
-;;
-;; When SX moves to isomorphic execution, these forms will have different
-;; platform bindings on client vs server. The spec stays the same — only
-;; the constructors (make-handler-def, make-query-def, etc.) change.
-;;
-;; Platform functions required:
-;;   make-handler-def(name, params, body, env)  → HandlerDef
-;;   make-query-def(name, params, doc, body, env) → QueryDef
-;;   make-action-def(name, params, doc, body, env) → ActionDef
-;;   make-page-def(name, slots, env) → PageDef
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Shared: parse (&key param1 param2 ...) → list of param name strings
-;; --------------------------------------------------------------------------
-
-(define parse-key-params
-  (fn ((params-expr :as list))
-    (let ((params (list))
-          (in-key false))
-      (for-each
-        (fn (p)
-          (when (= (type-of p) "symbol")
-            (let ((name (symbol-name p)))
-              (cond
-                (= name "&key")  (set! in-key true)
-                in-key           (append! params name)
-                :else            (append! params name)))))
-        params-expr)
-      params)))
-
-
-;; --------------------------------------------------------------------------
-;; defhandler — (defhandler name [:path "..." :method :get :csrf false :returns "element"] (&key param...) body)
-;;
-;; Keyword options between name and params list:
-;;   :path    — public route path (string). Without :path, handler is internal-only.
-;;   :method  — HTTP method (keyword: :get :post :put :patch :delete). Default :get.
-;;   :csrf    — CSRF protection (boolean). Default true; set false for POST/PUT etc.
-;;   :returns — return type annotation (types.sx vocabulary). Default "element".
-;; --------------------------------------------------------------------------
-
-(define parse-handler-args
-  (fn ((args :as list))
-    "Parse defhandler args after the name symbol.
-     Scans for :keyword value option pairs, then a list (params), then body.
-     Returns dict with keys: opts, params, body."
-    (let ((opts   {})
-          (params (list))
-          (body   nil)
-          (i      0)
-          (n      (len args))
-          (done   false))
-      (for-each
-        (fn (idx)
-          (when (and (not done) (= idx i))
-            (let ((arg (nth args idx)))
-              (cond
-                ;; keyword-value pair → consume two items
-                (= (type-of arg) "keyword")
-                (do
-                  (when (< (+ idx 1) n)
-                    (let ((val (nth args (+ idx 1))))
-                      ;; For :method, extract keyword name; for :csrf, keep as-is
-                      (dict-set! opts (keyword-name arg)
-                        (if (= (type-of val) "keyword")
-                          (keyword-name val)
-                          val))))
-                  (set! i (+ idx 2)))
-                ;; list → params, next element is body
-                (= (type-of arg) "list")
-                (do
-                  (set! params (parse-key-params arg))
-                  (when (< (+ idx 1) n)
-                    (set! body (nth args (+ idx 1))))
-                  (set! done true))
-                ;; anything else → no explicit params, this is body
-                :else
-                (do
-                  (set! body arg)
-                  (set! done true))))))
-        (range 0 n))
-      (dict :opts opts :params params :body body))))
-
-(define sf-defhandler
-  (fn ((args :as list) (env :as dict))
-    (let ((name-sym (first args))
-          (name     (symbol-name name-sym))
-          (parsed   (parse-handler-args (rest args)))
-          (opts     (get parsed "opts"))
-          (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)
-        hdef))))
-
-
-;; --------------------------------------------------------------------------
-;; defquery — (defquery name (&key param...) "docstring" body)
-;; --------------------------------------------------------------------------
-
-(define sf-defquery
-  (fn ((args :as list) (env :as dict))
-    (let ((name-sym   (first args))
-          (params-raw (nth args 1))
-          (name       (symbol-name name-sym))
-          (params     (parse-key-params params-raw))
-          ;; Optional docstring before body
-          (has-doc    (and (>= (len args) 4) (= (type-of (nth args 2)) "string")))
-          (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)
-        qdef))))
-
-
-;; --------------------------------------------------------------------------
-;; defaction — (defaction name (&key param...) "docstring" body)
-;; --------------------------------------------------------------------------
-
-(define sf-defaction
-  (fn ((args :as list) (env :as dict))
-    (let ((name-sym   (first args))
-          (params-raw (nth args 1))
-          (name       (symbol-name name-sym))
-          (params     (parse-key-params params-raw))
-          (has-doc    (and (>= (len args) 4) (= (type-of (nth args 2)) "string")))
-          (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)
-        adef))))
-
-
-;; --------------------------------------------------------------------------
-;; defpage — (defpage name :path "/..." :auth :public :content expr ...)
-;;
-;; Keyword-slot form: all values after the name are :key value pairs.
-;; Values are stored as unevaluated AST — resolved at request time.
-;; --------------------------------------------------------------------------
-
-(define sf-defpage
-  (fn ((args :as list) (env :as dict))
-    (let ((name-sym (first args))
-          (name     (symbol-name name-sym))
-          (slots    {}))
-      ;; Parse keyword slots from remaining args
-      (let ((i 1)
-            (max-i (len args)))
-        (for-each
-          (fn ((idx :as number))
-            (when (and (< idx max-i)
-                       (= (type-of (nth args idx)) "keyword"))
-              (when (< (+ idx 1) max-i)
-                (dict-set! slots (keyword-name (nth args idx))
-                           (nth args (+ idx 1))))))
-          (range 1 max-i 2)))
-      (let ((pdef (make-page-def name slots env)))
-        (env-set! env (str "page:" name) pdef)
-        pdef))))
-
-
-;; ==========================================================================
-;; Page Execution Semantics
-;; ==========================================================================
-;;
-;; A PageDef describes what to render for a route. The host evaluates slots
-;; at request time.  This section specifies the data → content protocol that
-;; every host must implement identically.
-;;
-;; Slots (all unevaluated AST):
-;;   :path      — route pattern (string)
-;;   :auth      — "public" | "login" | "admin"
-;;   :layout    — layout reference + kwargs
-;;   :stream    — boolean, opt into chunked transfer
-;;   :shell     — immediate content (contains ~suspense placeholders)
-;;   :fallback  — loading skeleton for single-stream mode
-;;   :data      — IO expression producing bindings
-;;   :content   — template expression evaluated with data bindings
-;;   :filter, :aside, :menu — additional content slots
-;;
-;; --------------------------------------------------------------------------
-;; Data Protocol
-;; --------------------------------------------------------------------------
-;;
-;; The :data expression is evaluated at request time. It returns one of:
-;;
-;; 1. A dict — single-stream mode (default).
-;;    Each key becomes an env binding (underscores → hyphens).
-;;    Then :content is evaluated once with those bindings.
-;;    Result resolves the "stream-content" suspense slot.
-;;
-;; 2. A sequence of dicts — multi-stream mode.
-;;    The host delivers items over time (async generator, channel, etc.).
-;;    Each dict:
-;;      - MUST contain "stream-id" → string matching a ~suspense :id
-;;      - Remaining keys become env bindings (underscores → hyphens)
-;;      - :content is re-evaluated with those bindings
-;;      - Result resolves the ~suspense slot matching "stream-id"
-;;    If "stream-id" is absent, defaults to "stream-content".
-;;
-;; The host is free to choose the timing mechanism:
-;;   Python  — async generator (yield dicts at intervals)
-;;   Go      — channel of dicts
-;;   Haskell — conduit / streaming
-;;   JS      — async iterator
-;;
-;; The spec requires:
-;;   (a) Each item's bindings are isolated (fresh env per item)
-;;   (b) :content is evaluated independently for each item
-;;   (c) Resolution is incremental — each item resolves as it arrives
-;;   (d) "stream-id" routes to the correct ~suspense slot
-;;
-;; --------------------------------------------------------------------------
-;; Streaming Execution Order
-;; --------------------------------------------------------------------------
-;;
-;; When :stream is true:
-;;
-;; 1. Evaluate :shell (if present) → HTML for immediate content slot
-;;    :shell typically contains ~suspense placeholders with :fallback
-;; 2. Render HTML shell with suspense placeholders → send to client
-;; 3. Start :data evaluation concurrently with header resolution
-;; 4. As each data item arrives:
-;;    a. Bind item keys into fresh env
-;;    b. Evaluate :content with those bindings → SX wire format
-;;    c. Send resolve script: __sxResolve(stream-id, sx)
-;; 5. Close response when all items + headers have resolved
-;;
-;; Non-streaming pages evaluate :data then :content sequentially and
-;; return the complete page in a single response.
-;;
-
-;; --------------------------------------------------------------------------
-;; Spec helpers for multi-stream data protocol
-;; --------------------------------------------------------------------------
-
-;; Extract stream-id from a data chunk dict, defaulting to "stream-content"
-(define stream-chunk-id
-  (fn ((chunk :as dict))
-    (if (has-key? chunk "stream-id")
-      (get chunk "stream-id")
-      "stream-content")))
-
-;; Remove stream-id from chunk, returning only the bindings
-(define stream-chunk-bindings
-  (fn ((chunk :as dict))
-    (dissoc chunk "stream-id")))
-
-;; Normalize binding keys: underscore → hyphen
-(define normalize-binding-key
-  (fn ((key :as string))
-    (replace key "_" "-")))
-
-;; Bind a data chunk's keys into a fresh env (isolated per chunk)
-(define bind-stream-chunk
-  (fn ((chunk :as dict) (base-env :as dict))
-    (let ((env (merge {} base-env))
-          (bindings (stream-chunk-bindings chunk)))
-      (for-each
-        (fn ((key :as string))
-          (env-set! env (normalize-binding-key key)
-                    (get bindings key)))
-        (keys bindings))
-      env)))
-
-;; Validate a multi-stream data result: must be a list of dicts
-(define validate-stream-data
-  (fn (data)
-    (and (= (type-of data) "list")
-         (every? (fn (item) (= (type-of item) "dict")) data))))

shared/sx/ref/frames.sx

@@ -1,262 +0,0 @@
-;; ==========================================================================
-;; frames.sx — CEK machine frame types
-;;
-;; Defines the continuation frame types used by the explicit CEK evaluator.
-;; Each frame represents a "what to do next" when a sub-evaluation completes.
-;;
-;; A CEK state is a dict:
-;;   {:control expr       — expression being evaluated (or nil in continue phase)
-;;    :env     env        — current environment
-;;    :kont    list       — continuation: list of frames (stack, head = top)
-;;    :phase   "eval"|"continue"
-;;    :value   any}       — value produced (only in continue phase)
-;;
-;; Two-phase step function:
-;;   step-eval:     control is expression → dispatch → push frame + new control
-;;   step-continue: value produced → pop frame → dispatch → new state
-;;
-;; Terminal state: phase = "continue" and kont is empty → value is final result.
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 1. CEK State constructors
-;; --------------------------------------------------------------------------
-
-(define make-cek-state
-  (fn (control env kont)
-    {:control control :env env :kont kont :phase "eval" :value nil}))
-
-(define make-cek-value
-  (fn (value env kont)
-    {:control nil :env env :kont kont :phase "continue" :value value}))
-
-(define cek-terminal?
-  (fn (state)
-    (and (= (get state "phase") "continue")
-         (empty? (get state "kont")))))
-
-(define cek-control  (fn (s) (get s "control")))
-(define cek-env      (fn (s) (get s "env")))
-(define cek-kont     (fn (s) (get s "kont")))
-(define cek-phase    (fn (s) (get s "phase")))
-(define cek-value    (fn (s) (get s "value")))
-
-
-;; --------------------------------------------------------------------------
-;; 2. Frame constructors
-;; --------------------------------------------------------------------------
-;; Each frame type is a dict with a "type" key and frame-specific data.
-
-;; IfFrame: waiting for condition value
-;; After condition evaluates, choose then or else branch
-(define make-if-frame
-  (fn (then-expr else-expr env)
-    {:type "if" :then then-expr :else else-expr :env env}))
-
-;; WhenFrame: waiting for condition value
-;; If truthy, evaluate body exprs sequentially
-(define make-when-frame
-  (fn (body-exprs env)
-    {:type "when" :body body-exprs :env env}))
-
-;; BeginFrame: sequential evaluation
-;; Remaining expressions to evaluate after current one
-(define make-begin-frame
-  (fn (remaining env)
-    {:type "begin" :remaining remaining :env env}))
-
-;; LetFrame: binding evaluation in progress
-;; name = current binding name, remaining = remaining (name val) pairs
-;; body = body expressions to evaluate after all bindings
-(define make-let-frame
-  (fn (name remaining body local)
-    {:type "let" :name name :remaining remaining :body body :env local}))
-
-;; DefineFrame: waiting for value to bind
-(define make-define-frame
-  (fn (name env has-effects effect-list)
-    {:type "define" :name name :env env
-     :has-effects has-effects :effect-list effect-list}))
-
-;; SetFrame: waiting for value to assign
-(define make-set-frame
-  (fn (name env)
-    {:type "set" :name name :env env}))
-
-;; ArgFrame: evaluating function arguments
-;; f = function value (already evaluated), evaled = already evaluated args
-;; remaining = remaining arg expressions
-(define make-arg-frame
-  (fn (f evaled remaining env raw-args)
-    {:type "arg" :f f :evaled evaled :remaining remaining :env env
-     :raw-args raw-args}))
-
-;; CallFrame: about to call with fully evaluated args
-(define make-call-frame
-  (fn (f args env)
-    {:type "call" :f f :args args :env env}))
-
-;; CondFrame: evaluating cond clauses
-(define make-cond-frame
-  (fn (remaining env scheme?)
-    {:type "cond" :remaining remaining :env env :scheme scheme?}))
-
-;; CaseFrame: evaluating case clauses
-(define make-case-frame
-  (fn (match-val remaining env)
-    {:type "case" :match-val match-val :remaining remaining :env env}))
-
-;; ThreadFirstFrame: pipe threading
-(define make-thread-frame
-  (fn (remaining env)
-    {:type "thread" :remaining remaining :env env}))
-
-;; MapFrame: higher-order map/map-indexed in progress
-(define make-map-frame
-  (fn (f remaining results env)
-    {:type "map" :f f :remaining remaining :results results :env env :indexed false}))
-
-(define make-map-indexed-frame
-  (fn (f remaining results env)
-    {:type "map" :f f :remaining remaining :results results :env env :indexed true}))
-
-;; FilterFrame: higher-order filter in progress
-(define make-filter-frame
-  (fn (f remaining results current-item env)
-    {:type "filter" :f f :remaining remaining :results results
-     :current-item current-item :env env}))
-
-;; ReduceFrame: higher-order reduce in progress
-(define make-reduce-frame
-  (fn (f remaining env)
-    {:type "reduce" :f f :remaining remaining :env env}))
-
-;; ForEachFrame: higher-order for-each in progress
-(define make-for-each-frame
-  (fn (f remaining env)
-    {:type "for-each" :f f :remaining remaining :env env}))
-
-;; SomeFrame: higher-order some (short-circuit on first truthy)
-(define make-some-frame
-  (fn (f remaining env)
-    {:type "some" :f f :remaining remaining :env env}))
-
-;; EveryFrame: higher-order every? (short-circuit on first falsy)
-(define make-every-frame
-  (fn (f remaining env)
-    {:type "every" :f f :remaining remaining :env env}))
-
-;; ScopeFrame: scope-pop! when frame pops
-(define make-scope-frame
-  (fn (name remaining env)
-    {:type "scope" :name name :remaining remaining :env env}))
-
-;; ResetFrame: delimiter for shift/reset continuations
-(define make-reset-frame
-  (fn (env)
-    {:type "reset" :env env}))
-
-;; DictFrame: evaluating dict values
-(define make-dict-frame
-  (fn (remaining results env)
-    {:type "dict" :remaining remaining :results results :env env}))
-
-;; AndFrame: short-circuit and
-(define make-and-frame
-  (fn (remaining env)
-    {:type "and" :remaining remaining :env env}))
-
-;; OrFrame: short-circuit or
-(define make-or-frame
-  (fn (remaining env)
-    {:type "or" :remaining remaining :env env}))
-
-;; QuasiquoteFrame (not a real frame — QQ is handled specially)
-
-;; DynamicWindFrame: phases of dynamic-wind
-(define make-dynamic-wind-frame
-  (fn (phase body-thunk after-thunk env)
-    {:type "dynamic-wind" :phase phase
-     :body-thunk body-thunk :after-thunk after-thunk :env env}))
-
-;; ReactiveResetFrame: delimiter for reactive deref-as-shift
-;; Carries an update-fn that gets called with new values on re-render.
-(define make-reactive-reset-frame
-  (fn (env update-fn first-render?)
-    {:type "reactive-reset" :env env :update-fn update-fn
-     :first-render first-render?}))
-
-;; DerefFrame: awaiting evaluation of deref's argument
-(define make-deref-frame
-  (fn (env)
-    {:type "deref" :env env}))
-
-
-;; --------------------------------------------------------------------------
-;; 3. Frame accessors
-;; --------------------------------------------------------------------------
-
-(define frame-type (fn (f) (get f "type")))
-
-
-;; --------------------------------------------------------------------------
-;; 4. Continuation operations
-;; --------------------------------------------------------------------------
-
-(define kont-push
-  (fn (frame kont) (cons frame kont)))
-
-(define kont-top
-  (fn (kont) (first kont)))
-
-(define kont-pop
-  (fn (kont) (rest kont)))
-
-(define kont-empty?
-  (fn (kont) (empty? kont)))
-
-
-;; --------------------------------------------------------------------------
-;; 5. CEK shift/reset support
-;; --------------------------------------------------------------------------
-;; shift captures all frames up to the nearest ResetFrame.
-;; reset pushes a ResetFrame.
-
-(define kont-capture-to-reset
-  (fn (kont)
-    ;; Returns (captured-frames remaining-kont).
-    ;; captured-frames: frames from top up to (not including) ResetFrame.
-    ;; remaining-kont: frames after ResetFrame.
-    ;; Stops at either "reset" or "reactive-reset" frames.
-    (define scan
-      (fn (k captured)
-        (if (empty? k)
-          (error "shift without enclosing reset")
-          (let ((frame (first k)))
-            (if (or (= (frame-type frame) "reset")
-                    (= (frame-type frame) "reactive-reset"))
-              (list captured (rest k))
-              (scan (rest k) (append captured (list frame))))))))
-    (scan kont (list))))
-
-;; Check if a ReactiveResetFrame exists anywhere in the continuation
-(define has-reactive-reset-frame?
-  (fn (kont)
-    (if (empty? kont) false
-      (if (= (frame-type (first kont)) "reactive-reset") true
-        (has-reactive-reset-frame? (rest kont))))))
-
-;; Capture frames up to nearest ReactiveResetFrame.
-;; Returns (captured-frames, reset-frame, remaining-kont).
-(define kont-capture-to-reactive-reset
-  (fn (kont)
-    (define scan
-      (fn (k captured)
-        (if (empty? k)
-          (error "reactive deref without enclosing reactive-reset")
-          (let ((frame (first k)))
-            (if (= (frame-type frame) "reactive-reset")
-              (list captured frame (rest k))
-              (scan (rest k) (append captured (list frame))))))))
-    (scan kont (list))))

shared/sx/ref/page-helpers.sx

@@ -1,368 +0,0 @@
-;; ==========================================================================
-;; page-helpers.sx — Pure data-transformation page helpers
-;;
-;; These functions take raw data (from Python I/O edge) and return
-;; structured dicts for page rendering. No I/O — pure transformations
-;; only. Bootstrapped to every host.
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; categorize-special-forms
-;;
-;; Parses define-special-form declarations from special-forms.sx AST,
-;; categorizes each form by name lookup, returns dict of category → forms.
-;; --------------------------------------------------------------------------
-
-(define special-form-category-map
-  {"if" "Control Flow" "when" "Control Flow" "cond" "Control Flow"
-   "case" "Control Flow" "and" "Control Flow" "or" "Control Flow"
-   "let" "Binding" "let*" "Binding" "letrec" "Binding"
-   "define" "Binding" "set!" "Binding"
-   "lambda" "Functions & Components" "fn" "Functions & Components"
-   "defcomp" "Functions & Components" "defmacro" "Functions & Components"
-   "begin" "Sequencing & Threading" "do" "Sequencing & Threading"
-   "->" "Sequencing & Threading"
-   "quote" "Quoting" "quasiquote" "Quoting"
-   "reset" "Continuations" "shift" "Continuations"
-   "dynamic-wind" "Guards"
-   "map" "Higher-Order Forms" "map-indexed" "Higher-Order Forms"
-   "filter" "Higher-Order Forms" "reduce" "Higher-Order Forms"
-   "some" "Higher-Order Forms" "every?" "Higher-Order Forms"
-   "for-each" "Higher-Order Forms"
-   "defstyle" "Domain Definitions"
-   "defhandler" "Domain Definitions" "defpage" "Domain Definitions"
-   "defquery" "Domain Definitions" "defaction" "Domain Definitions"})
-
-
-(define extract-define-kwargs
-  (fn ((expr :as list))
-    ;; Extract keyword args from a define-special-form expression.
-    ;; Returns dict of keyword-name → string value.
-    ;; Walks items pairwise: when item[i] is a keyword, item[i+1] is its value.
-    (let ((result {})
-          (items (slice expr 2))
-          (n (len items)))
-      (for-each
-        (fn ((idx :as number))
-          (when (and (< (+ idx 1) n)
-                     (= (type-of (nth items idx)) "keyword"))
-            (let ((key (keyword-name (nth items idx)))
-                  (val (nth items (+ idx 1))))
-              (dict-set! result key
-                (if (= (type-of val) "list")
-                  (str "(" (join " " (map serialize val)) ")")
-                  (str val))))))
-        (range 0 n))
-      result)))
-
-
-(define categorize-special-forms
-  (fn ((parsed-exprs :as list))
-    ;; parsed-exprs: result of parse-all on special-forms.sx
-    ;; Returns dict of category-name → list of form dicts.
-    (let ((categories {}))
-      (for-each
-        (fn (expr)
-          (when (and (= (type-of expr) "list")
-                     (>= (len expr) 2)
-                     (= (type-of (first expr)) "symbol")
-                     (= (symbol-name (first expr)) "define-special-form"))
-            (let ((name (nth expr 1))
-                  (kwargs (extract-define-kwargs expr))
-                  (category (or (get special-form-category-map name) "Other")))
-              (when (not (has-key? categories category))
-                (dict-set! categories category (list)))
-              (append! (get categories category)
-                {"name" name
-                 "syntax" (or (get kwargs "syntax") "")
-                 "doc" (or (get kwargs "doc") "")
-                 "tail-position" (or (get kwargs "tail-position") "")
-                 "example" (or (get kwargs "example") "")}))))
-        parsed-exprs)
-      categories)))
-
-
-;; --------------------------------------------------------------------------
-;; build-reference-data
-;;
-;; Takes a slug and raw reference data, returns structured dict for rendering.
-;; --------------------------------------------------------------------------
-
-(define build-ref-items-with-href
-  (fn ((items :as list) (base-path :as string) (detail-keys :as list) (n-fields :as number))
-    ;; items: list of lists (tuples), each with n-fields elements
-    ;; base-path: e.g. "/geography/hypermedia/reference/attributes/"
-    ;; detail-keys: list of strings (keys that have detail pages)
-    ;; n-fields: 2 or 3 (number of fields per tuple)
-    (map
-      (fn ((item :as list))
-        (if (= n-fields 3)
-          ;; [name, desc/value, exists/desc]
-          (let ((name (nth item 0))
-                (field2 (nth item 1))
-                (field3 (nth item 2)))
-            {"name" name
-             "desc" field2
-             "exists" field3
-             "href" (if (and field3 (some (fn ((k :as string)) (= k name)) detail-keys))
-                      (str base-path name)
-                      nil)})
-          ;; [name, desc]
-          (let ((name (nth item 0))
-                (desc (nth item 1)))
-            {"name" name
-             "desc" desc
-             "href" (if (some (fn ((k :as string)) (= k name)) detail-keys)
-                      (str base-path name)
-                      nil)})))
-      items)))
-
-
-(define build-reference-data
-  (fn ((slug :as string) (raw-data :as dict) (detail-keys :as list))
-    ;; slug: "attributes", "headers", "events", "js-api"
-    ;; raw-data: dict with the raw data lists for this slug
-    ;; detail-keys: list of names that have detail pages
-    (case slug
-      "attributes"
-        {"req-attrs" (build-ref-items-with-href
-                       (get raw-data "req-attrs")
-                       "/geography/hypermedia/reference/attributes/" detail-keys 3)
-         "beh-attrs" (build-ref-items-with-href
-                       (get raw-data "beh-attrs")
-                       "/geography/hypermedia/reference/attributes/" detail-keys 3)
-         "uniq-attrs" (build-ref-items-with-href
-                        (get raw-data "uniq-attrs")
-                        "/geography/hypermedia/reference/attributes/" detail-keys 3)}
-
-      "headers"
-        {"req-headers" (build-ref-items-with-href
-                         (get raw-data "req-headers")
-                         "/geography/hypermedia/reference/headers/" detail-keys 3)
-         "resp-headers" (build-ref-items-with-href
-                          (get raw-data "resp-headers")
-                          "/geography/hypermedia/reference/headers/" detail-keys 3)}
-
-      "events"
-        {"events-list" (build-ref-items-with-href
-                         (get raw-data "events-list")
-                         "/geography/hypermedia/reference/events/" detail-keys 2)}
-
-      "js-api"
-        {"js-api-list" (map (fn ((item :as list)) {"name" (nth item 0) "desc" (nth item 1)})
-                            (get raw-data "js-api-list"))}
-
-      ;; default: attributes
-      :else
-        {"req-attrs" (build-ref-items-with-href
-                       (get raw-data "req-attrs")
-                       "/geography/hypermedia/reference/attributes/" detail-keys 3)
-         "beh-attrs" (build-ref-items-with-href
-                       (get raw-data "beh-attrs")
-                       "/geography/hypermedia/reference/attributes/" detail-keys 3)
-         "uniq-attrs" (build-ref-items-with-href
-                        (get raw-data "uniq-attrs")
-                        "/geography/hypermedia/reference/attributes/" detail-keys 3)})))
-
-
-;; --------------------------------------------------------------------------
-;; build-attr-detail / build-header-detail / build-event-detail
-;;
-;; Lookup a slug in a detail dict, reshape for page rendering.
-;; --------------------------------------------------------------------------
-
-(define build-attr-detail
-  (fn ((slug :as string) detail)
-    ;; detail: dict with "description", "example", "handler", "demo" keys or nil
-    (if (nil? detail)
-      {"attr-not-found" true}
-      {"attr-not-found" nil
-       "attr-title" slug
-       "attr-description" (get detail "description")
-       "attr-example" (get detail "example")
-       "attr-handler" (get detail "handler")
-       "attr-demo" (get detail "demo")
-       "attr-wire-id" (if (has-key? detail "handler")
-                        (str "ref-wire-"
-                          (replace (replace slug ":" "-") "*" "star"))
-                        nil)})))
-
-
-(define build-header-detail
-  (fn ((slug :as string) detail)
-    (if (nil? detail)
-      {"header-not-found" true}
-      {"header-not-found" nil
-       "header-title" slug
-       "header-direction" (get detail "direction")
-       "header-description" (get detail "description")
-       "header-example" (get detail "example")
-       "header-demo" (get detail "demo")})))
-
-
-(define build-event-detail
-  (fn ((slug :as string) detail)
-    (if (nil? detail)
-      {"event-not-found" true}
-      {"event-not-found" nil
-       "event-title" slug
-       "event-description" (get detail "description")
-       "event-example" (get detail "example")
-       "event-demo" (get detail "demo")})))
-
-
-;; --------------------------------------------------------------------------
-;; build-component-source
-;;
-;; Reconstruct defcomp/defisland source from component metadata.
-;; --------------------------------------------------------------------------
-
-(define build-component-source
-  (fn ((comp-data :as dict))
-    ;; comp-data: dict with "type", "name", "params", "has-children", "body-sx", "affinity"
-    (let ((comp-type (get comp-data "type"))
-          (name (get comp-data "name"))
-          (params (get comp-data "params"))
-          (has-children (get comp-data "has-children"))
-          (body-sx (get comp-data "body-sx"))
-          (affinity (get comp-data "affinity")))
-      (if (= comp-type "not-found")
-        (str ";; component " name " not found")
-        (let ((param-strs (if (empty? params)
-                            (if has-children
-                              (list "&rest" "children")
-                              (list))
-                            (if has-children
-                              (append (cons "&key" params) (list "&rest" "children"))
-                              (cons "&key" params))))
-              (params-sx (str "(" (join " " param-strs) ")"))
-              (form-name (if (= comp-type "island") "defisland" "defcomp"))
-              (affinity-str (if (and (= comp-type "component")
-                                     (not (nil? affinity))
-                                     (not (= affinity "auto")))
-                              (str " :affinity " affinity)
-                              "")))
-          (str "(" form-name " " name " " params-sx affinity-str "\n  " body-sx ")"))))))
-
-
-;; --------------------------------------------------------------------------
-;; build-bundle-analysis
-;;
-;; Compute per-page bundle stats from pre-extracted component data.
-;; --------------------------------------------------------------------------
-
-(define build-bundle-analysis
-  (fn ((pages-raw :as list) (components-raw :as dict) (total-components :as number) (total-macros :as number) (pure-count :as number) (io-count :as number))
-    ;; pages-raw: list of {:name :path :direct :needed-names}
-    ;; components-raw: dict of name → {:is-pure :affinity :render-target :io-refs :deps :source}
-    (let ((pages-data (list)))
-      (for-each
-        (fn ((page :as dict))
-          (let ((needed-names (get page "needed-names"))
-                (n (len needed-names))
-                (pct (if (> total-components 0)
-                       (round (* (/ n total-components) 100))
-                       0))
-                (savings (- 100 pct))
-                (pure-in-page 0)
-                (io-in-page 0)
-                (page-io-refs (list))
-                (comp-details (list)))
-            ;; Walk needed components
-            (for-each
-              (fn ((comp-name :as string))
-                (let ((info (get components-raw comp-name)))
-                  (when (not (nil? info))
-                    (if (get info "is-pure")
-                      (set! pure-in-page (+ pure-in-page 1))
-                      (do
-                        (set! io-in-page (+ io-in-page 1))
-                        (for-each
-                          (fn ((ref :as string)) (when (not (some (fn ((r :as string)) (= r ref)) page-io-refs))
-                                      (append! page-io-refs ref)))
-                          (or (get info "io-refs") (list)))))
-                    (append! comp-details
-                      {"name" comp-name
-                       "is-pure" (get info "is-pure")
-                       "affinity" (get info "affinity")
-                       "render-target" (get info "render-target")
-                       "io-refs" (or (get info "io-refs") (list))
-                       "deps" (or (get info "deps") (list))
-                       "source" (get info "source")}))))
-              needed-names)
-            (append! pages-data
-              {"name" (get page "name")
-               "path" (get page "path")
-               "direct" (get page "direct")
-               "needed" n
-               "pct" pct
-               "savings" savings
-               "io-refs" (len page-io-refs)
-               "pure-in-page" pure-in-page
-               "io-in-page" io-in-page
-               "components" comp-details})))
-        pages-raw)
-      {"pages" pages-data
-       "total-components" total-components
-       "total-macros" total-macros
-       "pure-count" pure-count
-       "io-count" io-count})))
-
-
-;; --------------------------------------------------------------------------
-;; build-routing-analysis
-;;
-;; Classify pages by routing mode (client vs server).
-;; --------------------------------------------------------------------------
-
-(define build-routing-analysis
-  (fn ((pages-raw :as list))
-    ;; pages-raw: list of {:name :path :has-data :content-src}
-    (let ((pages-data (list))
-          (client-count 0)
-          (server-count 0))
-      (for-each
-        (fn ((page :as dict))
-          (let ((has-data (get page "has-data"))
-                (content-src (or (get page "content-src") ""))
-                (mode nil)
-                (reason ""))
-            (cond
-              has-data
-                (do (set! mode "server")
-                    (set! reason "Has :data expression — needs server IO")
-                    (set! server-count (+ server-count 1)))
-              (empty? content-src)
-                (do (set! mode "server")
-                    (set! reason "No content expression")
-                    (set! server-count (+ server-count 1)))
-              :else
-                (do (set! mode "client")
-                    (set! client-count (+ client-count 1))))
-            (append! pages-data
-              {"name" (get page "name")
-               "path" (get page "path")
-               "mode" mode
-               "has-data" has-data
-               "content-expr" (if (> (len content-src) 80)
-                                (str (slice content-src 0 80) "...")
-                                content-src)
-               "reason" reason})))
-        pages-raw)
-      {"pages" pages-data
-       "total-pages" (+ client-count server-count)
-       "client-count" client-count
-       "server-count" server-count})))
-
-
-;; --------------------------------------------------------------------------
-;; build-affinity-analysis
-;;
-;; Package component affinity info + page render plans for display.
-;; --------------------------------------------------------------------------
-
-(define build-affinity-analysis
-  (fn ((demo-components :as list) (page-plans :as list))
-    {"components" demo-components
-     "page-plans" page-plans}))

shared/sx/ref/parser.sx

@@ -1,418 +0,0 @@
-;; ==========================================================================
-;; parser.sx — Reference SX parser specification
-;;
-;; Defines how SX source text is tokenized and parsed into AST.
-;; The parser is intentionally simple — s-expressions need minimal parsing.
-;;
-;; Single-pass recursive descent: reads source text directly into AST,
-;; no separate tokenization phase. All mutable cursor state lives inside
-;; the parse closure.
-;;
-;; Grammar:
-;;   program    → expr*
-;;   expr       → atom | list | vector | map | quote-sugar
-;;   list       → '(' expr* ')'
-;;   vector     → '[' expr* ']'   (sugar for list)
-;;   map        → '{' (key expr)* '}'
-;;   atom       → string | number | keyword | symbol | boolean | nil
-;;   string     → '"' (char | escape)* '"'
-;;   number     → '-'? digit+ ('.' digit+)? ([eE] [+-]? digit+)?
-;;   keyword    → ':' ident
-;;   symbol     → ident
-;;   boolean    → 'true' | 'false'
-;;   nil        → 'nil'
-;;   ident      → ident-start ident-char*
-;;   comment    → ';' to end of line (discarded)
-;;
-;; Quote sugar:
-;;   'expr      → (quote expr)
-;;   `expr      → (quasiquote expr)
-;;   ,expr      → (unquote expr)
-;;   ,@expr     → (splice-unquote expr)
-;;
-;; Reader macros:
-;;   #;expr           → datum comment (read and discard expr)
-;;   #|raw chars|     → raw string literal (no escape processing)
-;;   #'expr           → (quote expr)
-;;   #name expr       → extensible dispatch (calls registered handler)
-;;
-;; Platform interface (each target implements natively):
-;;   (ident-start? ch)   → boolean
-;;   (ident-char? ch)    → boolean
-;;   (make-symbol name)  → Symbol value
-;;   (make-keyword name) → Keyword value
-;;   (escape-string s)   → string with " and \ escaped for serialization
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Parser — single-pass recursive descent
-;; --------------------------------------------------------------------------
-;; Returns a list of top-level AST expressions.
-
-(define sx-parse :effects []
-  (fn ((source :as string))
-    (let ((pos 0)
-          (len-src (len source)))
-
-      ;; -- Cursor helpers (closure over pos, source, len-src) --
-
-      (define skip-comment :effects []
-        (fn ()
-          (when (and (< pos len-src) (not (= (nth source pos) "\n")))
-            (set! pos (inc pos))
-            (skip-comment))))
-
-      (define skip-ws :effects []
-        (fn ()
-          (when (< pos len-src)
-            (let ((ch (nth source pos)))
-              (cond
-                ;; Whitespace
-                (or (= ch " ") (= ch "\t") (= ch "\n") (= ch "\r"))
-                  (do (set! pos (inc pos)) (skip-ws))
-                ;; Comment — skip to end of line
-                (= ch ";")
-                  (do (set! pos (inc pos))
-                      (skip-comment)
-                      (skip-ws))
-                ;; Not whitespace or comment — stop
-                :else nil)))))
-
-      ;; -- Atom readers --
-
-      (define hex-digit-value :effects []
-        (fn (ch) (index-of "0123456789abcdef" (lower ch))))
-
-      (define read-string :effects []
-        (fn ()
-          (set! pos (inc pos))  ;; skip opening "
-          (let ((buf ""))
-            (define read-str-loop :effects []
-              (fn ()
-                (if (>= pos len-src)
-                  (error "Unterminated string")
-                  (let ((ch (nth source pos)))
-                    (cond
-                      (= ch "\"")
-                        (do (set! pos (inc pos)) nil)  ;; done
-                      (= ch "\\")
-                        (do (set! pos (inc pos))
-                            (let ((esc (nth source pos)))
-                              (if (= esc "u")
-                                ;; Unicode escape: \uXXXX → char
-                                (do (set! pos (inc pos))
-                                    (let ((d0 (hex-digit-value (nth source pos)))
-                                          (_ (set! pos (inc pos)))
-                                          (d1 (hex-digit-value (nth source pos)))
-                                          (_ (set! pos (inc pos)))
-                                          (d2 (hex-digit-value (nth source pos)))
-                                          (_ (set! pos (inc pos)))
-                                          (d3 (hex-digit-value (nth source pos)))
-                                          (_ (set! pos (inc pos))))
-                                      (set! buf (str buf (char-from-code
-                                        (+ (* d0 4096) (* d1 256) (* d2 16) d3))))
-                                      (read-str-loop)))
-                                ;; Standard escapes: \n \t \r or literal
-                                (do (set! buf (str buf
-                                      (cond
-                                        (= esc "n") "\n"
-                                        (= esc "t") "\t"
-                                        (= esc "r") "\r"
-                                        :else esc)))
-                                    (set! pos (inc pos))
-                                    (read-str-loop)))))
-                      :else
-                        (do (set! buf (str buf ch))
-                            (set! pos (inc pos))
-                            (read-str-loop)))))))
-            (read-str-loop)
-            buf)))
-
-      (define read-ident :effects []
-        (fn ()
-          (let ((start pos))
-            (define read-ident-loop :effects []
-              (fn ()
-                (when (and (< pos len-src)
-                           (ident-char? (nth source pos)))
-                  (set! pos (inc pos))
-                  (read-ident-loop))))
-            (read-ident-loop)
-            (slice source start pos))))
-
-      (define read-keyword :effects []
-        (fn ()
-          (set! pos (inc pos))  ;; skip :
-          (make-keyword (read-ident))))
-
-      (define read-number :effects []
-        (fn ()
-          (let ((start pos))
-            ;; Optional leading minus
-            (when (and (< pos len-src) (= (nth source pos) "-"))
-              (set! pos (inc pos)))
-            ;; Integer digits
-            (define read-digits :effects []
-              (fn ()
-                (when (and (< pos len-src)
-                           (let ((c (nth source pos)))
-                             (and (>= c "0") (<= c "9"))))
-                  (set! pos (inc pos))
-                  (read-digits))))
-            (read-digits)
-            ;; Decimal part
-            (when (and (< pos len-src) (= (nth source pos) "."))
-              (set! pos (inc pos))
-              (read-digits))
-            ;; Exponent
-            (when (and (< pos len-src)
-                       (or (= (nth source pos) "e")
-                           (= (nth source pos) "E")))
-              (set! pos (inc pos))
-              (when (and (< pos len-src)
-                         (or (= (nth source pos) "+")
-                             (= (nth source pos) "-")))
-                (set! pos (inc pos)))
-              (read-digits))
-            (parse-number (slice source start pos)))))
-
-      (define read-symbol :effects []
-        (fn ()
-          (let ((name (read-ident)))
-            (cond
-              (= name "true")  true
-              (= name "false") false
-              (= name "nil")   nil
-              :else             (make-symbol name)))))
-
-      ;; -- Composite readers --
-
-      (define read-list :effects []
-        (fn ((close-ch :as string))
-          (let ((items (list)))
-            (define read-list-loop :effects []
-              (fn ()
-                (skip-ws)
-                (if (>= pos len-src)
-                  (error "Unterminated list")
-                  (if (= (nth source pos) close-ch)
-                    (do (set! pos (inc pos)) nil)  ;; done
-                    (do (append! items (read-expr))
-                        (read-list-loop))))))
-            (read-list-loop)
-            items)))
-
-      (define read-map :effects []
-        (fn ()
-          (let ((result (dict)))
-            (define read-map-loop :effects []
-              (fn ()
-                (skip-ws)
-                (if (>= pos len-src)
-                  (error "Unterminated map")
-                  (if (= (nth source pos) "}")
-                    (do (set! pos (inc pos)) nil)  ;; done
-                    (let ((key-expr (read-expr))
-                          (key-str  (if (= (type-of key-expr) "keyword")
-                                      (keyword-name key-expr)
-                                      (str key-expr)))
-                          (val-expr (read-expr)))
-                      (dict-set! result key-str val-expr)
-                      (read-map-loop))))))
-            (read-map-loop)
-            result)))
-
-      ;; -- Raw string reader (for #|...|) --
-
-      (define read-raw-string :effects []
-        (fn ()
-          (let ((buf ""))
-            (define raw-loop :effects []
-              (fn ()
-                (if (>= pos len-src)
-                  (error "Unterminated raw string")
-                  (let ((ch (nth source pos)))
-                    (if (= ch "|")
-                      (do (set! pos (inc pos)) nil)  ;; done
-                      (do (set! buf (str buf ch))
-                          (set! pos (inc pos))
-                          (raw-loop)))))))
-            (raw-loop)
-            buf)))
-
-      ;; -- Main expression reader --
-
-      (define read-expr :effects []
-        (fn ()
-          (skip-ws)
-          (if (>= pos len-src)
-            (error "Unexpected end of input")
-            (let ((ch (nth source pos)))
-              (cond
-                ;; Lists
-                (= ch "(")
-                  (do (set! pos (inc pos)) (read-list ")"))
-                (= ch "[")
-                  (do (set! pos (inc pos)) (read-list "]"))
-
-                ;; Map
-                (= ch "{")
-                  (do (set! pos (inc pos)) (read-map))
-
-                ;; String
-                (= ch "\"")
-                  (read-string)
-
-                ;; Keyword
-                (= ch ":")
-                  (read-keyword)
-
-                ;; Quote sugar
-                (= ch "'")
-                  (do (set! pos (inc pos))
-                      (list (make-symbol "quote") (read-expr)))
-
-                ;; Quasiquote sugar
-                (= ch "`")
-                  (do (set! pos (inc pos))
-                      (list (make-symbol "quasiquote") (read-expr)))
-
-                ;; Unquote / splice-unquote
-                (= ch ",")
-                  (do (set! pos (inc pos))
-                      (if (and (< pos len-src) (= (nth source pos) "@"))
-                        (do (set! pos (inc pos))
-                            (list (make-symbol "splice-unquote") (read-expr)))
-                        (list (make-symbol "unquote") (read-expr))))
-
-                ;; Reader macros: #
-                (= ch "#")
-                  (do (set! pos (inc pos))
-                      (if (>= pos len-src)
-                        (error "Unexpected end of input after #")
-                        (let ((dispatch-ch (nth source pos)))
-                          (cond
-                            ;; #; — datum comment: read and discard next expr
-                            (= dispatch-ch ";")
-                              (do (set! pos (inc pos))
-                                  (read-expr)    ;; read and discard
-                                  (read-expr))   ;; return the NEXT expr
-
-                            ;; #| — raw string
-                            (= dispatch-ch "|")
-                              (do (set! pos (inc pos))
-                                  (read-raw-string))
-
-                            ;; #' — quote shorthand
-                            (= dispatch-ch "'")
-                              (do (set! pos (inc pos))
-                                  (list (make-symbol "quote") (read-expr)))
-
-                            ;; #name — extensible dispatch
-                            (ident-start? dispatch-ch)
-                              (let ((macro-name (read-ident)))
-                                (let ((handler (reader-macro-get macro-name)))
-                                  (if handler
-                                    (handler (read-expr))
-                                    (error (str "Unknown reader macro: #" macro-name)))))
-
-                            :else
-                              (error (str "Unknown reader macro: #" dispatch-ch))))))
-
-                ;; Number (or negative number)
-                (or (and (>= ch "0") (<= ch "9"))
-                    (and (= ch "-")
-                         (< (inc pos) len-src)
-                         (let ((next-ch (nth source (inc pos))))
-                           (and (>= next-ch "0") (<= next-ch "9")))))
-                  (read-number)
-
-                ;; Ellipsis (... as a symbol)
-                (and (= ch ".")
-                     (< (+ pos 2) len-src)
-                     (= (nth source (+ pos 1)) ".")
-                     (= (nth source (+ pos 2)) "."))
-                  (do (set! pos (+ pos 3))
-                      (make-symbol "..."))
-
-                ;; Symbol (must be ident-start char)
-                (ident-start? ch)
-                  (read-symbol)
-
-                ;; Unexpected
-                :else
-                  (error (str "Unexpected character: " ch)))))))
-
-      ;; -- Entry point: parse all top-level expressions --
-      (let ((exprs (list)))
-        (define parse-loop :effects []
-          (fn ()
-            (skip-ws)
-            (when (< pos len-src)
-              (append! exprs (read-expr))
-              (parse-loop))))
-        (parse-loop)
-        exprs))))
-
-
-;; --------------------------------------------------------------------------
-;; Serializer — AST → SX source text
-;; --------------------------------------------------------------------------
-
-(define sx-serialize :effects []
-  (fn (val)
-    (case (type-of val)
-      "nil"       "nil"
-      "boolean"   (if val "true" "false")
-      "number"    (str val)
-      "string"    (str "\"" (escape-string val) "\"")
-      "symbol"    (symbol-name val)
-      "keyword"   (str ":" (keyword-name val))
-      "list"      (str "(" (join " " (map sx-serialize val)) ")")
-      "dict"      (sx-serialize-dict val)
-      "sx-expr"   (sx-expr-source val)
-      "spread"    (str "(make-spread " (sx-serialize-dict (spread-attrs val)) ")")
-      :else       (str val))))
-
-
-(define sx-serialize-dict :effects []
-  (fn ((d :as dict))
-    (str "{"
-      (join " "
-        (reduce
-          (fn ((acc :as list) (key :as string))
-            (concat acc (list (str ":" key) (sx-serialize (dict-get d key)))))
-          (list)
-          (keys d)))
-      "}")))
-
-
-;; Alias: adapters use (serialize val) — canonicalize to sx-serialize
-(define serialize sx-serialize)
-
-
-;; --------------------------------------------------------------------------
-;; Platform parser interface
-;; --------------------------------------------------------------------------
-;;
-;; Character classification (implemented natively per target):
-;;   (ident-start? ch) → boolean
-;;     True for: a-z A-Z _ ~ * + - > < = / ! ? &
-;;
-;;   (ident-char? ch) → boolean
-;;     True for: ident-start chars plus: 0-9 . : / # ,
-;;
-;; Constructors (provided by the SX runtime):
-;;   (make-symbol name)  → Symbol value
-;;   (make-keyword name) → Keyword value
-;;   (parse-number s)    → number (int or float from string)
-;;
-;; String utilities:
-;;   (escape-string s)   → string with " and \ escaped
-;;   (sx-expr-source e)  → unwrap SxExpr to its source string
-;;
-;; Reader macro registry:
-;;   (reader-macro-get name)          → handler fn or nil
-;;   (reader-macro-set! name handler) → register a reader macro
-;; --------------------------------------------------------------------------

shared/sx/ref/primitives.sx

@@ -1,607 +0,0 @@
-;; ==========================================================================
-;; primitives.sx — Specification of all SX built-in pure functions
-;;
-;; Each entry declares: name, parameter signature, and semantics.
-;; Bootstrap compilers implement these natively per target.
-;;
-;; This file is a SPECIFICATION, not executable code. The define-primitive
-;; form is a declarative macro that bootstrap compilers consume to generate
-;; native primitive registrations.
-;;
-;; Format:
-;;   (define-primitive "name"
-;;     :params (param1 param2 &rest rest)
-;;     :returns "type"
-;;     :doc "description"
-;;     :body (reference-implementation ...))
-;;
-;; Typed params use (name :as type) syntax:
-;;   (define-primitive "+"
-;;     :params (&rest (args :as number))
-;;     :returns "number"
-;;     :doc "Sum all arguments.")
-;;
-;; Untyped params default to `any`. Typed params enable the gradual
-;; type checker (types.sx) to catch mistyped primitive calls.
-;;
-;; The :body is optional — when provided, it gives a reference
-;; implementation in SX that bootstrap compilers MAY use for testing
-;; or as a fallback. Most targets will implement natively for performance.
-;;
-;; Modules: (define-module :name) scopes subsequent define-primitive
-;; entries until the next define-module. Bootstrappers use this to
-;; selectively include primitive groups.
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Core — Arithmetic
-;; --------------------------------------------------------------------------
-
-(define-module :core.arithmetic)
-
-(define-primitive "+"
-  :params (&rest (args :as number))
-  :returns "number"
-  :doc "Sum all arguments."
-  :body (reduce (fn (a b) (native-add a b)) 0 args))
-
-(define-primitive "-"
-  :params ((a :as number) &rest (b :as number))
-  :returns "number"
-  :doc "Subtract. Unary: negate. Binary: a - b."
-  :body (if (empty? b) (native-neg a) (native-sub a (first b))))
-
-(define-primitive "*"
-  :params (&rest (args :as number))
-  :returns "number"
-  :doc "Multiply all arguments."
-  :body (reduce (fn (a b) (native-mul a b)) 1 args))
-
-(define-primitive "/"
-  :params ((a :as number) (b :as number))
-  :returns "number"
-  :doc "Divide a by b."
-  :body (native-div a b))
-
-(define-primitive "mod"
-  :params ((a :as number) (b :as number))
-  :returns "number"
-  :doc "Modulo a % b."
-  :body (native-mod a b))
-
-(define-primitive "random-int"
-  :params ((low :as number) (high :as number))
-  :returns "number"
-  :doc "Random integer in [low, high] inclusive."
-  :body (native-random-int low high))
-
-(define-primitive "json-encode"
-  :params (value)
-  :returns "string"
-  :doc "Encode value as JSON string with indentation.")
-
-(define-primitive "sqrt"
-  :params ((x :as number))
-  :returns "number"
-  :doc "Square root.")
-
-(define-primitive "pow"
-  :params ((x :as number) (n :as number))
-  :returns "number"
-  :doc "x raised to power n.")
-
-(define-primitive "abs"
-  :params ((x :as number))
-  :returns "number"
-  :doc "Absolute value.")
-
-(define-primitive "floor"
-  :params ((x :as number))
-  :returns "number"
-  :doc "Floor to integer.")
-
-(define-primitive "ceil"
-  :params ((x :as number))
-  :returns "number"
-  :doc "Ceiling to integer.")
-
-(define-primitive "round"
-  :params ((x :as number) &rest (ndigits :as number))
-  :returns "number"
-  :doc "Round to ndigits decimal places (default 0).")
-
-(define-primitive "min"
-  :params (&rest (args :as number))
-  :returns "number"
-  :doc "Minimum. Single list arg or variadic.")
-
-(define-primitive "max"
-  :params (&rest (args :as number))
-  :returns "number"
-  :doc "Maximum. Single list arg or variadic.")
-
-(define-primitive "clamp"
-  :params ((x :as number) (lo :as number) (hi :as number))
-  :returns "number"
-  :doc "Clamp x to range [lo, hi]."
-  :body (max lo (min hi x)))
-
-(define-primitive "inc"
-  :params ((n :as number))
-  :returns "number"
-  :doc "Increment by 1."
-  :body (+ n 1))
-
-(define-primitive "dec"
-  :params ((n :as number))
-  :returns "number"
-  :doc "Decrement by 1."
-  :body (- n 1))
-
-
-;; --------------------------------------------------------------------------
-;; Core — Comparison
-;; --------------------------------------------------------------------------
-
-(define-module :core.comparison)
-
-(define-primitive "="
-  :params (a b)
-  :returns "boolean"
-  :doc "Deep structural equality. Alias for equal?.")
-
-(define-primitive "!="
-  :params (a b)
-  :returns "boolean"
-  :doc "Inequality."
-  :body (not (= a b)))
-
-(define-primitive "eq?"
-  :params (a b)
-  :returns "boolean"
-  :doc "Identity equality. True only if a and b are the exact same object.
-        For immutable atoms (numbers, strings, booleans, nil) this may or
-        may not match — use eqv? for reliable atom comparison.")
-
-(define-primitive "eqv?"
-  :params (a b)
-  :returns "boolean"
-  :doc "Equivalent value for atoms, identity for compound objects.
-        Returns true for identical objects (eq?), and also for numbers,
-        strings, booleans, and nil with the same value. For lists, dicts,
-        lambdas, and components, only true if same identity.")
-
-(define-primitive "equal?"
-  :params (a b)
-  :returns "boolean"
-  :doc "Deep structural equality. Recursively compares lists and dicts.
-        Same semantics as = but explicit Scheme name.")
-
-(define-primitive "<"
-  :params ((a :as number) (b :as number))
-  :returns "boolean"
-  :doc "Less than.")
-
-(define-primitive ">"
-  :params ((a :as number) (b :as number))
-  :returns "boolean"
-  :doc "Greater than.")
-
-(define-primitive "<="
-  :params ((a :as number) (b :as number))
-  :returns "boolean"
-  :doc "Less than or equal.")
-
-(define-primitive ">="
-  :params ((a :as number) (b :as number))
-  :returns "boolean"
-  :doc "Greater than or equal.")
-
-
-;; --------------------------------------------------------------------------
-;; Core — Predicates
-;; --------------------------------------------------------------------------
-
-(define-module :core.predicates)
-
-(define-primitive "odd?"
-  :params ((n :as number))
-  :returns "boolean"
-  :doc "True if n is odd."
-  :body (= (mod n 2) 1))
-
-(define-primitive "even?"
-  :params ((n :as number))
-  :returns "boolean"
-  :doc "True if n is even."
-  :body (= (mod n 2) 0))
-
-(define-primitive "zero?"
-  :params ((n :as number))
-  :returns "boolean"
-  :doc "True if n is zero."
-  :body (= n 0))
-
-(define-primitive "nil?"
-  :params (x)
-  :returns "boolean"
-  :doc "True if x is nil/null/None.")
-
-(define-primitive "boolean?"
-  :params (x)
-  :returns "boolean"
-  :doc "True if x is a boolean (true or false). Must be checked before
-        number? on platforms where booleans are numeric subtypes.")
-
-(define-primitive "number?"
-  :params (x)
-  :returns "boolean"
-  :doc "True if x is a number (int or float). Excludes booleans.")
-
-(define-primitive "string?"
-  :params (x)
-  :returns "boolean"
-  :doc "True if x is a string.")
-
-(define-primitive "list?"
-  :params (x)
-  :returns "boolean"
-  :doc "True if x is a list/array.")
-
-(define-primitive "dict?"
-  :params (x)
-  :returns "boolean"
-  :doc "True if x is a dict/map.")
-
-(define-primitive "continuation?"
-  :params (x)
-  :returns "boolean"
-  :doc "True if x is a captured continuation.")
-
-(define-primitive "empty?"
-  :params (coll)
-  :returns "boolean"
-  :doc "True if coll is nil or has length 0.")
-
-(define-primitive "contains?"
-  :params (coll key)
-  :returns "boolean"
-  :doc "True if coll contains key. Strings: substring check. Dicts: key check. Lists: membership.")
-
-
-;; --------------------------------------------------------------------------
-;; Core — Logic
-;; --------------------------------------------------------------------------
-
-(define-module :core.logic)
-
-(define-primitive "not"
-  :params (x)
-  :returns "boolean"
-  :doc "Logical negation. Note: and/or are special forms (short-circuit).")
-
-
-;; --------------------------------------------------------------------------
-;; Core — Strings
-;; --------------------------------------------------------------------------
-
-(define-module :core.strings)
-
-(define-primitive "str"
-  :params (&rest args)
-  :returns "string"
-  :doc "Concatenate all args as strings. nil → empty string, bool → true/false.")
-
-(define-primitive "concat"
-  :params (&rest (colls :as list))
-  :returns "list"
-  :doc "Concatenate multiple lists into one. Skips nil values.")
-
-(define-primitive "upper"
-  :params ((s :as string))
-  :returns "string"
-  :doc "Uppercase string.")
-
-(define-primitive "upcase"
-  :params ((s :as string))
-  :returns "string"
-  :doc "Alias for upper. Uppercase string.")
-
-(define-primitive "lower"
-  :params ((s :as string))
-  :returns "string"
-  :doc "Lowercase string.")
-
-(define-primitive "downcase"
-  :params ((s :as string))
-  :returns "string"
-  :doc "Alias for lower. Lowercase string.")
-
-(define-primitive "string-length"
-  :params ((s :as string))
-  :returns "number"
-  :doc "Length of string in characters.")
-
-(define-primitive "char-from-code"
-  :params ((n :as number))
-  :returns "string"
-  :doc "Convert Unicode code point to single-character string.")
-
-(define-primitive "substring"
-  :params ((s :as string) (start :as number) (end :as number))
-  :returns "string"
-  :doc "Extract substring from start (inclusive) to end (exclusive).")
-
-(define-primitive "string-contains?"
-  :params ((s :as string) (needle :as string))
-  :returns "boolean"
-  :doc "True if string s contains substring needle.")
-
-(define-primitive "trim"
-  :params ((s :as string))
-  :returns "string"
-  :doc "Strip leading/trailing whitespace.")
-
-(define-primitive "split"
-  :params ((s :as string) &rest (sep :as string))
-  :returns "list"
-  :doc "Split string by separator (default space).")
-
-(define-primitive "join"
-  :params ((sep :as string) (coll :as list))
-  :returns "string"
-  :doc "Join collection items with separator string.")
-
-(define-primitive "replace"
-  :params ((s :as string) (old :as string) (new :as string))
-  :returns "string"
-  :doc "Replace all occurrences of old with new in s.")
-
-(define-primitive "slice"
-  :params (coll (start :as number) &rest (end :as number))
-  :returns "any"
-  :doc "Slice a string or list from start to end (exclusive). End is optional.")
-
-(define-primitive "index-of"
-  :params ((s :as string) (needle :as string) &rest (from :as number))
-  :returns "number"
-  :doc "Index of first occurrence of needle in s, or -1 if not found. Optional start index.")
-
-(define-primitive "starts-with?"
-  :params ((s :as string) (prefix :as string))
-  :returns "boolean"
-  :doc "True if string s starts with prefix.")
-
-(define-primitive "ends-with?"
-  :params ((s :as string) (suffix :as string))
-  :returns "boolean"
-  :doc "True if string s ends with suffix.")
-
-
-;; --------------------------------------------------------------------------
-;; Core — Collections
-;; --------------------------------------------------------------------------
-
-(define-module :core.collections)
-
-(define-primitive "list"
-  :params (&rest args)
-  :returns "list"
-  :doc "Create a list from arguments.")
-
-(define-primitive "dict"
-  :params (&rest pairs)
-  :returns "dict"
-  :doc "Create a dict from key/value pairs: (dict :a 1 :b 2).")
-
-(define-primitive "range"
-  :params ((start :as number) (end :as number) &rest (step :as number))
-  :returns "list"
-  :doc "Integer range [start, end) with optional step.")
-
-(define-primitive "get"
-  :params (coll key &rest default)
-  :returns "any"
-  :doc "Get value from dict by key, or list by index. Optional default.")
-
-(define-primitive "len"
-  :params (coll)
-  :returns "number"
-  :doc "Length of string, list, or dict.")
-
-(define-primitive "first"
-  :params ((coll :as list))
-  :returns "any"
-  :doc "First element, or nil if empty.")
-
-(define-primitive "last"
-  :params ((coll :as list))
-  :returns "any"
-  :doc "Last element, or nil if empty.")
-
-(define-primitive "rest"
-  :params ((coll :as list))
-  :returns "list"
-  :doc "All elements except the first.")
-
-(define-primitive "nth"
-  :params ((coll :as list) (n :as number))
-  :returns "any"
-  :doc "Element at index n, or nil if out of bounds.")
-
-(define-primitive "cons"
-  :params (x (coll :as list))
-  :returns "list"
-  :doc "Prepend x to coll.")
-
-(define-primitive "append"
-  :params ((coll :as list) x)
-  :returns "list"
-  :doc "If x is a list, concatenate. Otherwise append x as single element.")
-
-(define-primitive "append!"
-  :params ((coll :as list) x)
-  :returns "list"
-  :doc "Mutate coll by appending x in-place. Returns coll.")
-
-(define-primitive "reverse"
-  :params ((coll :as list))
-  :returns "list"
-  :doc "Return coll in reverse order.")
-
-(define-primitive "flatten"
-  :params ((coll :as list))
-  :returns "list"
-  :doc "Flatten one level of nesting. Nested lists become top-level elements.")
-
-(define-primitive "chunk-every"
-  :params ((coll :as list) (n :as number))
-  :returns "list"
-  :doc "Split coll into sub-lists of size n.")
-
-(define-primitive "zip-pairs"
-  :params ((coll :as list))
-  :returns "list"
-  :doc "Consecutive pairs: (1 2 3 4) → ((1 2) (2 3) (3 4)).")
-
-
-;; --------------------------------------------------------------------------
-;; Core — Dict operations
-;; --------------------------------------------------------------------------
-
-(define-module :core.dict)
-
-(define-primitive "keys"
-  :params ((d :as dict))
-  :returns "list"
-  :doc "List of dict keys.")
-
-(define-primitive "vals"
-  :params ((d :as dict))
-  :returns "list"
-  :doc "List of dict values.")
-
-(define-primitive "merge"
-  :params (&rest (dicts :as dict))
-  :returns "dict"
-  :doc "Merge dicts left to right. Later keys win. Skips nil.")
-
-(define-primitive "has-key?"
-  :params ((d :as dict) key)
-  :returns "boolean"
-  :doc "True if dict d contains key.")
-
-(define-primitive "assoc"
-  :params ((d :as dict) &rest pairs)
-  :returns "dict"
-  :doc "Return new dict with key/value pairs added/overwritten.")
-
-(define-primitive "dissoc"
-  :params ((d :as dict) &rest keys)
-  :returns "dict"
-  :doc "Return new dict with keys removed.")
-
-(define-primitive "dict-set!"
-  :params ((d :as dict) key val)
-  :returns "any"
-  :doc "Mutate dict d by setting key to val in-place. Returns val.")
-
-(define-primitive "into"
-  :params (target coll)
-  :returns "any"
-  :doc "Pour coll into target. List target: convert to list. Dict target: convert pairs to dict.")
-
-
-;; --------------------------------------------------------------------------
-;; Stdlib — Format
-;; --------------------------------------------------------------------------
-
-(define-module :stdlib.format)
-
-(define-primitive "format-date"
-  :params ((date-str :as string) (fmt :as string))
-  :returns "string"
-  :doc "Parse ISO date string and format with strftime-style format.")
-
-(define-primitive "format-decimal"
-  :params ((val :as number) &rest (places :as number))
-  :returns "string"
-  :doc "Format number with fixed decimal places (default 2).")
-
-(define-primitive "parse-int"
-  :params (val &rest default)
-  :returns "number"
-  :doc "Parse string to integer with optional default on failure.")
-
-(define-primitive "parse-datetime"
-  :params ((s :as string))
-  :returns "string"
-  :doc "Parse datetime string — identity passthrough (returns string or nil).")
-
-
-;; --------------------------------------------------------------------------
-;; Stdlib — Text
-;; --------------------------------------------------------------------------
-
-(define-module :stdlib.text)
-
-(define-primitive "pluralize"
-  :params ((count :as number) &rest (forms :as string))
-  :returns "string"
-  :doc "Pluralize: (pluralize 1) → \"\", (pluralize 2) → \"s\". Or (pluralize n \"item\" \"items\").")
-
-(define-primitive "escape"
-  :params ((s :as string))
-  :returns "string"
-  :doc "HTML-escape a string (&, <, >, \", ').")
-
-(define-primitive "strip-tags"
-  :params ((s :as string))
-  :returns "string"
-  :doc "Remove HTML tags from string.")
-
-
-;; --------------------------------------------------------------------------
-;; Stdlib — Style
-;; --------------------------------------------------------------------------
-
-
-
-;; --------------------------------------------------------------------------
-;; Stdlib — Debug
-;; --------------------------------------------------------------------------
-
-(define-module :stdlib.debug)
-
-(define-primitive "assert"
-  :params (condition &rest message)
-  :returns "boolean"
-  :doc "Assert condition is truthy; raise error with message if not.")
-
-
-;; --------------------------------------------------------------------------
-;; Type introspection — platform primitives
-;; --------------------------------------------------------------------------
-
-(define-module :stdlib.types)
-
-(define-primitive "type-of"
-  :params (x)
-  :returns "string"
-  :doc "Return type name: number, string, boolean, nil, symbol, keyword, list, dict, lambda, component, island, macro.")
-
-(define-primitive "symbol-name"
-  :params ((sym :as symbol))
-  :returns "string"
-  :doc "Return the name string of a symbol.")
-
-(define-primitive "keyword-name"
-  :params ((kw :as keyword))
-  :returns "string"
-  :doc "Return the name string of a keyword.")
-
-(define-primitive "sx-parse"
-  :params ((source :as string))
-  :returns "list"
-  :doc "Parse SX source string into a list of AST expressions.")

shared/sx/ref/render.sx

@@ -1,283 +0,0 @@
-;; ==========================================================================
-;; render.sx — Core rendering specification
-;;
-;; Shared registries and utilities used by all rendering adapters.
-;; This file defines WHAT is renderable (tag registries, attribute rules)
-;; and HOW arguments are parsed — but not the output format.
-;;
-;; Adapters:
-;;   adapter-html.sx  — HTML string output (server)
-;;   adapter-sx.sx    — SX wire format output (server → client)
-;;   adapter-dom.sx   — Live DOM node output (browser)
-;;
-;; Each adapter imports these shared definitions and provides its own
-;; render entry point (render-to-html, render-to-sx, render-to-dom).
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; HTML tag registry
-;; --------------------------------------------------------------------------
-;; Tags known to the renderer. Unknown names are treated as function calls.
-;; Void elements self-close (no children). Boolean attrs emit name only.
-
-(define HTML_TAGS
-  (list
-    ;; Document
-    "html" "head" "body" "title" "meta" "link" "script" "style" "noscript"
-    ;; Sections
-    "header" "nav" "main" "section" "article" "aside" "footer"
-    "h1" "h2" "h3" "h4" "h5" "h6" "hgroup"
-    ;; Block
-    "div" "p" "blockquote" "pre" "figure" "figcaption" "address" "details" "summary"
-    ;; Inline
-    "a" "span" "em" "strong" "small" "b" "i" "u" "s" "mark" "sub" "sup"
-    "abbr" "cite" "code" "time" "br" "wbr" "hr"
-    ;; Lists
-    "ul" "ol" "li" "dl" "dt" "dd"
-    ;; Tables
-    "table" "thead" "tbody" "tfoot" "tr" "th" "td" "caption" "colgroup" "col"
-    ;; Forms
-    "form" "input" "textarea" "select" "option" "optgroup" "button" "label"
-    "fieldset" "legend" "output" "datalist"
-    ;; Media
-    "img" "video" "audio" "source" "picture" "canvas" "iframe"
-    ;; SVG
-    "svg" "math" "path" "circle" "ellipse" "rect" "line" "polyline" "polygon"
-    "text" "tspan" "g" "defs" "use" "clipPath" "mask" "pattern"
-    "linearGradient" "radialGradient" "stop" "filter"
-    "feGaussianBlur" "feOffset" "feBlend" "feColorMatrix" "feComposite"
-    "feMerge" "feMergeNode" "feTurbulence"
-    "feComponentTransfer" "feFuncR" "feFuncG" "feFuncB" "feFuncA"
-    "feDisplacementMap" "feFlood" "feImage" "feMorphology"
-    "feSpecularLighting" "feDiffuseLighting"
-    "fePointLight" "feSpotLight" "feDistantLight"
-    "animate" "animateTransform" "foreignObject"
-    ;; Other
-    "template" "slot" "dialog" "menu"))
-
-(define VOID_ELEMENTS
-  (list "area" "base" "br" "col" "embed" "hr" "img" "input"
-        "link" "meta" "param" "source" "track" "wbr"))
-
-(define BOOLEAN_ATTRS
-  (list "async" "autofocus" "autoplay" "checked" "controls" "default"
-        "defer" "disabled" "formnovalidate" "hidden" "inert" "ismap"
-        "loop" "multiple" "muted" "nomodule" "novalidate" "open"
-        "playsinline" "readonly" "required" "reversed" "selected"))
-
-
-;; --------------------------------------------------------------------------
-;; Shared utilities
-;; --------------------------------------------------------------------------
-
-(define definition-form? :effects []
-  (fn ((name :as string))
-    (or (= name "define") (= name "defcomp") (= name "defisland")
-        (= name "defmacro") (= name "defstyle") (= name "defhandler")
-        (= name "deftype") (= name "defeffect"))))
-
-
-(define parse-element-args :effects [render]
-  (fn ((args :as list) (env :as dict))
-    ;; Parse (:key val :key2 val2 child1 child2) into (attrs-dict children-list)
-    (let ((attrs (dict))
-          (children (list)))
-      (reduce
-        (fn ((state :as dict) arg)
-          (let ((skip (get state "skip")))
-            (if skip
-              (assoc state "skip" false "i" (inc (get state "i")))
-              (if (and (= (type-of arg) "keyword")
-                       (< (inc (get state "i")) (len args)))
-                (let ((val (trampoline (eval-expr (nth args (inc (get state "i"))) env))))
-                  (dict-set! attrs (keyword-name arg) val)
-                  (assoc state "skip" true "i" (inc (get state "i"))))
-                (do
-                  (append! children arg)
-                  (assoc state "i" (inc (get state "i"))))))))
-        (dict "i" 0 "skip" false)
-        args)
-      (list attrs children))))
-
-
-(define render-attrs :effects []
-  (fn ((attrs :as dict))
-    ;; Render an attrs dict to an HTML attribute string.
-    ;; Used by adapter-html.sx and adapter-sx.sx.
-    (join ""
-      (map
-        (fn ((key :as string))
-          (let ((val (dict-get attrs key)))
-            (cond
-              ;; Boolean attrs
-              (and (contains? BOOLEAN_ATTRS key) val)
-                (str " " key)
-              (and (contains? BOOLEAN_ATTRS key) (not val))
-                ""
-              ;; Nil values — skip
-              (nil? val) ""
-              ;; Normal attr
-              :else (str " " key "=\"" (escape-attr (str val)) "\""))))
-        (keys attrs)))))
-
-
-;; --------------------------------------------------------------------------
-;; Render adapter helpers
-;; --------------------------------------------------------------------------
-;; Shared by HTML and DOM adapters for evaluating control forms during
-;; rendering. Unlike sf-cond (eval.sx) which returns a thunk for TCO,
-;; eval-cond returns the unevaluated body expression so the adapter
-;; can render it in its own mode (HTML string vs DOM nodes).
-
-;; eval-cond: find matching cond branch, return unevaluated body expr.
-;; Handles both scheme-style ((test body) ...) and clojure-style
-;; (test body test body ...).
-(define eval-cond :effects []
-  (fn ((clauses :as list) (env :as dict))
-    (if (cond-scheme? clauses)
-      (eval-cond-scheme clauses env)
-      (eval-cond-clojure clauses env))))
-
-(define eval-cond-scheme :effects []
-  (fn ((clauses :as list) (env :as dict))
-    (if (empty? clauses)
-      nil
-      (let ((clause (first clauses))
-            (test   (first clause))
-            (body   (nth clause 1)))
-        (if (or (and (= (type-of test) "symbol")
-                     (or (= (symbol-name test) "else")
-                         (= (symbol-name test) ":else")))
-                (and (= (type-of test) "keyword")
-                     (= (keyword-name test) "else")))
-          body
-          (if (trampoline (eval-expr test env))
-            body
-            (eval-cond-scheme (rest clauses) env)))))))
-
-(define eval-cond-clojure :effects []
-  (fn ((clauses :as list) (env :as dict))
-    (if (< (len clauses) 2)
-      nil
-      (let ((test (first clauses))
-            (body (nth clauses 1)))
-        (if (or (and (= (type-of test) "keyword") (= (keyword-name test) "else"))
-                (and (= (type-of test) "symbol")
-                     (or (= (symbol-name test) "else")
-                         (= (symbol-name test) ":else"))))
-          body
-          (if (trampoline (eval-expr test env))
-            body
-            (eval-cond-clojure (slice clauses 2) env)))))))
-
-;; process-bindings: evaluate let-binding pairs, return extended env.
-;; bindings = ((name1 expr1) (name2 expr2) ...)
-(define process-bindings :effects [mutation]
-  (fn ((bindings :as list) (env :as dict))
-    ;; env-extend (not merge) — Env is not a dict subclass, so merge()
-    ;; returns an empty dict, losing all parent scope bindings.
-    (let ((local (env-extend env)))
-      (for-each
-        (fn ((pair :as list))
-          (when (and (= (type-of pair) "list") (>= (len pair) 2))
-            (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))))))
-        bindings)
-      local)))
-
-
-;; --------------------------------------------------------------------------
-;; is-render-expr? — check if expression is a rendering form
-;; --------------------------------------------------------------------------
-;; Used by eval-list to dispatch rendering forms to the active adapter
-;; (HTML, SX wire, or DOM) rather than evaluating them as function calls.
-
-(define is-render-expr? :effects []
-  (fn (expr)
-    (if (or (not (= (type-of expr) "list")) (empty? expr))
-      false
-      (let ((h (first expr)))
-        (if (not (= (type-of h) "symbol"))
-          false
-          (let ((n (symbol-name h)))
-            (or (= n "<>")
-                (= n "raw!")
-                (starts-with? n "~")
-                (starts-with? n "html:")
-                (contains? HTML_TAGS n)
-                (and (> (index-of n "-") 0)
-                     (> (len expr) 1)
-                     (= (type-of (nth expr 1)) "keyword")))))))))
-
-
-;; --------------------------------------------------------------------------
-;; Spread — attribute injection from children into parent elements
-;; --------------------------------------------------------------------------
-;;
-;; A spread value is a dict of attributes that, when returned as a child
-;; of an HTML element, merges its attrs onto the parent element.
-;; This enables components to inject classes/styles/data-attrs onto their
-;; parent without the parent knowing about the specific attrs.
-;;
-;; merge-spread-attrs: merge a spread's attrs into an element's attrs dict.
-;; Class values are joined (space-separated); others overwrite.
-;; Mutates the target attrs dict in place.
-
-(define merge-spread-attrs :effects [mutation]
-  (fn ((target :as dict) (spread-dict :as dict))
-    (for-each
-      (fn ((key :as string))
-        (let ((val (dict-get spread-dict key)))
-          (if (= key "class")
-            ;; Class: join existing + new with space
-            (let ((existing (dict-get target "class")))
-              (dict-set! target "class"
-                (if (and existing (not (= existing "")))
-                  (str existing " " val)
-                  val)))
-            ;; Style: join with semicolons
-            (if (= key "style")
-              (let ((existing (dict-get target "style")))
-                (dict-set! target "style"
-                  (if (and existing (not (= existing "")))
-                    (str existing ";" val)
-                    val)))
-              ;; Everything else: overwrite
-              (dict-set! target key val)))))
-      (keys spread-dict))))
-
-
-;; --------------------------------------------------------------------------
-;; Platform interface (shared across adapters)
-;; --------------------------------------------------------------------------
-;;
-;; HTML/attribute escaping (used by HTML and SX wire adapters):
-;;   (escape-html s)           → HTML-escaped string
-;;   (escape-attr s)           → attribute-value-escaped string
-;;   (raw-html-content r)      → unwrap RawHTML marker to string
-;;
-;; Spread (render-time attribute injection):
-;;   (make-spread attrs)       → Spread value
-;;   (spread? x)               → boolean
-;;   (spread-attrs s)          → dict
-;;
-;; Render-time accumulators:
-;;   (collect! bucket value)   → void
-;;   (collected bucket)        → list
-;;   (clear-collected! bucket) → void
-;;
-;; Scoped effects (scope/provide/context/emit!):
-;;   (scope-push! name val)    → void (general form)
-;;   (scope-pop! name)         → void (general form)
-;;   (provide-push! name val)  → alias for scope-push!
-;;   (provide-pop! name)       → alias for scope-pop!
-;;   (context name &rest def)  → value from nearest scope
-;;   (emit! name value)        → void (append to scope accumulator)
-;;   (emitted name)            → list of emitted values
-;;
-;; From parser.sx:
-;;   (sx-serialize val)        → SX source string (aliased as serialize above)
-;; --------------------------------------------------------------------------

shared/sx/ref/router.sx

@@ -1,680 +0,0 @@
-;; ==========================================================================
-;; router.sx — Client-side route matching specification
-;;
-;; Pure functions for matching URL paths against Flask-style route patterns.
-;; Used by client-side routing to determine if a page can be rendered
-;; locally without a server roundtrip.
-;;
-;; All functions are pure — no IO, no platform-specific operations.
-;; Uses only primitives from primitives.sx (string ops, list ops).
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 1. Split path into segments
-;; --------------------------------------------------------------------------
-;; "/docs/hello" → ("docs" "hello")
-;; "/" → ()
-;; "/docs/" → ("docs")
-
-(define split-path-segments :effects []
-  (fn ((path :as string))
-    (let ((trimmed (if (starts-with? path "/") (slice path 1) path)))
-      (let ((trimmed2 (if (and (not (empty? trimmed))
-                               (ends-with? trimmed "/"))
-                        (slice trimmed 0 (- (len trimmed) 1))
-                        trimmed)))
-        (if (empty? trimmed2)
-          (list)
-          (split trimmed2 "/"))))))
-
-
-;; --------------------------------------------------------------------------
-;; 2. Parse Flask-style route pattern into segment descriptors
-;; --------------------------------------------------------------------------
-;; "/docs/<slug>" → ({"type" "literal" "value" "docs"}
-;;                   {"type" "param" "value" "slug"})
-
-(define make-route-segment :effects []
-  (fn ((seg :as string))
-    (if (and (starts-with? seg "<") (ends-with? seg ">"))
-      (let ((param-name (slice seg 1 (- (len seg) 1))))
-        (let ((d {}))
-          (dict-set! d "type" "param")
-          (dict-set! d "value" param-name)
-          d))
-      (let ((d {}))
-        (dict-set! d "type" "literal")
-        (dict-set! d "value" seg)
-        d))))
-
-(define parse-route-pattern :effects []
-  (fn ((pattern :as string))
-    (let ((segments (split-path-segments pattern)))
-      (map make-route-segment segments))))
-
-
-;; --------------------------------------------------------------------------
-;; 3. Match path segments against parsed pattern
-;; --------------------------------------------------------------------------
-;; Returns params dict if match, nil if no match.
-
-(define match-route-segments :effects []
-  (fn ((path-segs :as list) (parsed-segs :as list))
-    (if (not (= (len path-segs) (len parsed-segs)))
-      nil
-      (let ((params {})
-            (matched true))
-        (for-each-indexed
-          (fn ((i :as number) (parsed-seg :as dict))
-            (when matched
-              (let ((path-seg (nth path-segs i))
-                    (seg-type (get parsed-seg "type")))
-                (cond
-                  (= seg-type "literal")
-                    (when (not (= path-seg (get parsed-seg "value")))
-                      (set! matched false))
-                  (= seg-type "param")
-                    (dict-set! params (get parsed-seg "value") path-seg)
-                  :else
-                    (set! matched false)))))
-          parsed-segs)
-        (if matched params nil)))))
-
-
-;; --------------------------------------------------------------------------
-;; 4. Public API: match a URL path against a pattern string
-;; --------------------------------------------------------------------------
-;; Returns params dict (may be empty for exact matches) or nil.
-
-(define match-route :effects []
-  (fn ((path :as string) (pattern :as string))
-    (let ((path-segs (split-path-segments path))
-          (parsed-segs (parse-route-pattern pattern)))
-      (match-route-segments path-segs parsed-segs))))
-
-
-;; --------------------------------------------------------------------------
-;; 5. Search a list of route entries for first match
-;; --------------------------------------------------------------------------
-;; Each entry: {"pattern" "/docs/<slug>" "parsed" [...] "name" "docs-page" ...}
-;; Returns matching entry with "params" added, or nil.
-
-(define find-matching-route :effects []
-  (fn ((path :as string) (routes :as list))
-    ;; If path is an SX expression URL, convert to old-style for matching.
-    (let ((match-path (if (starts-with? path "/(")
-                        (or (sx-url-to-path path) path)
-                        path)))
-      (let ((path-segs (split-path-segments match-path))
-            (result nil))
-        (for-each
-          (fn ((route :as dict))
-            (when (nil? result)
-              (let ((params (match-route-segments path-segs (get route "parsed"))))
-                (when (not (nil? params))
-                  (let ((matched (merge route {})))
-                    (dict-set! matched "params" params)
-                    (set! result matched))))))
-          routes)
-        result))))
-
-
-;; --------------------------------------------------------------------------
-;; 6. SX expression URL → old-style path conversion
-;; --------------------------------------------------------------------------
-;; Converts /(language.(doc.introduction)) → /language/docs/introduction
-;; so client-side routing can match SX URLs against Flask-style patterns.
-
-(define _fn-to-segment :effects []
-  (fn ((name :as string))
-    (case name
-      "doc" "docs"
-      "spec" "specs"
-      "bootstrapper" "bootstrappers"
-      "test" "testing"
-      "example" "examples"
-      "protocol" "protocols"
-      "essay" "essays"
-      "plan" "plans"
-      "reference-detail" "reference"
-      :else name)))
-
-(define sx-url-to-path :effects []
-  (fn ((url :as string))
-    ;; Convert an SX expression URL to an old-style slash path.
-    ;; "/(language.(doc.introduction))" → "/language/docs/introduction"
-    ;; Returns nil for non-SX URLs (those not starting with "/(" ).
-    (if (not (and (starts-with? url "/(") (ends-with? url ")")))
-      nil
-      (let ((inner (slice url 2 (- (len url) 1))))
-        ;; "language.(doc.introduction)" → dots to slashes, strip parens
-        (let ((s (replace (replace (replace inner "." "/") "(" "") ")" "")))
-          ;; "language/doc/introduction" → split, map names, rejoin
-          (let ((segs (filter (fn (s) (not (empty? s))) (split s "/"))))
-            (str "/" (join "/" (map _fn-to-segment segs)))))))))
-
-
-;; --------------------------------------------------------------------------
-;; 7. Relative SX URL resolution
-;; --------------------------------------------------------------------------
-;; Resolves relative SX URLs against the current absolute URL.
-;; This is a macro in the deepest sense: SX transforming SX into SX.
-;; The URL is code. Relative resolution is code transformation.
-;;
-;; Relative URLs start with ( or . :
-;;   (.slug)       → append slug as argument to innermost call
-;;   (..section)   → up 1: replace innermost with new nested call
-;;   (...section)  → up 2: replace 2 innermost levels
-;;
-;; Bare-dot shorthand (parens optional):
-;;   .slug         → same as (.slug)
-;;   ..            → same as (..)       — go up one level
-;;   ...           → same as (...)      — go up two levels
-;;   .:page.4      → same as (.:page.4) — set keyword
-;;
-;; Dot count semantics (parallels filesystem . and ..):
-;;   1 dot  = current level (append argument / modify keyword)
-;;   2 dots = up 1 level (sibling call)
-;;   3 dots = up 2 levels
-;;   N dots = up N-1 levels
-;;
-;; Keyword operations (set, delta):
-;;   (.:page.4)    → set :page to 4 at current level
-;;   (.:page.+1)   → increment :page by 1 (delta)
-;;   (.:page.-1)   → decrement :page by 1 (delta)
-;;   (.slug.:page.1) → append slug AND set :page=1
-;;
-;; Examples (current = "/(geography.(hypermedia.(example)))"):
-;;   (.progress-bar)      → /(geography.(hypermedia.(example.progress-bar)))
-;;   (..reactive.demo)    → /(geography.(hypermedia.(reactive.demo)))
-;;   (...marshes)         → /(geography.(marshes))
-;;   (..)                 → /(geography.(hypermedia))
-;;   (...)                → /(geography)
-;;
-;; Keyword examples (current = "/(language.(spec.(explore.signals.:page.3)))"):
-;;   (.:page.4)           → /(language.(spec.(explore.signals.:page.4)))
-;;   (.:page.+1)          → /(language.(spec.(explore.signals.:page.4)))
-;;   (.:page.-1)          → /(language.(spec.(explore.signals.:page.2)))
-;;   (..eval)             → /(language.(spec.(eval)))
-;;   (..eval.:page.1)     → /(language.(spec.(eval.:page.1)))
-
-(define _count-leading-dots :effects []
-  (fn ((s :as string))
-    (if (empty? s)
-      0
-      (if (starts-with? s ".")
-        (+ 1 (_count-leading-dots (slice s 1)))
-        0))))
-
-(define _strip-trailing-close :effects []
-  (fn ((s :as string))
-    ;; Strip trailing ) characters: "/(a.(b.(c" from "/(a.(b.(c)))"
-    (if (ends-with? s ")")
-      (_strip-trailing-close (slice s 0 (- (len s) 1)))
-      s)))
-
-(define _index-of-safe :effects []
-  (fn ((s :as string) (needle :as string))
-    ;; Wrapper around index-of that normalizes -1 to nil.
-    ;; (index-of returns -1 on some platforms, nil on others.)
-    (let ((idx (index-of s needle)))
-      (if (or (nil? idx) (< idx 0)) nil idx))))
-
-(define _last-index-of :effects []
-  (fn ((s :as string) (needle :as string))
-    ;; Find the last occurrence of needle in s. Returns nil if not found.
-    (let ((idx (_index-of-safe s needle)))
-      (if (nil? idx)
-        nil
-        (let ((rest-idx (_last-index-of (slice s (+ idx 1)) needle)))
-          (if (nil? rest-idx)
-            idx
-            (+ (+ idx 1) rest-idx)))))))
-
-(define _pop-sx-url-level :effects []
-  (fn ((url :as string))
-    ;; Remove the innermost nesting level from an absolute SX URL.
-    ;; "/(a.(b.(c)))" → "/(a.(b))"
-    ;; "/(a.(b))"     → "/(a)"
-    ;; "/(a)"         → "/"
-    (let ((stripped (_strip-trailing-close url))
-          (close-count (- (len url) (len (_strip-trailing-close url)))))
-      (if (<= close-count 1)
-        "/"  ;; at root, popping goes to bare root
-        (let ((last-dp (_last-index-of stripped ".(")))
-          (if (nil? last-dp)
-            "/"  ;; single-level URL, pop to root
-            ;; Remove from .( to end of stripped, drop one closing paren
-            (str (slice stripped 0 last-dp)
-                 (slice url (- (len url) (- close-count 1))))))))))
-
-(define _pop-sx-url-levels :effects []
-  (fn ((url :as string) (n :as number))
-    (if (<= n 0)
-      url
-      (_pop-sx-url-levels (_pop-sx-url-level url) (- n 1)))))
-
-
-;; --------------------------------------------------------------------------
-;; 8. Relative URL body parsing — positional vs keyword tokens
-;; --------------------------------------------------------------------------
-;; Body "slug.:page.4" → positional "slug", keywords ((:page 4))
-;; Body ":page.+1"     → positional "", keywords ((:page +1))
-
-(define _split-pos-kw :effects []
-  (fn ((tokens :as list) (i :as number) (pos :as list) (kw :as list))
-    ;; Walk tokens: non-: tokens are positional, : tokens consume next as value
-    (if (>= i (len tokens))
-      {"positional" (join "." pos) "keywords" kw}
-      (let ((tok (nth tokens i)))
-        (if (starts-with? tok ":")
-          ;; Keyword: take this + next token as a pair
-          (let ((val (if (< (+ i 1) (len tokens))
-                      (nth tokens (+ i 1))
-                      "")))
-            (_split-pos-kw tokens (+ i 2) pos
-              (append kw (list (list tok val)))))
-          ;; Positional token
-          (_split-pos-kw tokens (+ i 1)
-            (append pos (list tok))
-            kw))))))
-
-(define _parse-relative-body :effects []
-  (fn ((body :as string))
-    ;; Returns {"positional" <string> "keywords" <list of (kw val) pairs>}
-    (if (empty? body)
-      {"positional" "" "keywords" (list)}
-      (_split-pos-kw (split body ".") 0 (list) (list)))))
-
-
-;; --------------------------------------------------------------------------
-;; 9. Keyword operations on URL expressions
-;; --------------------------------------------------------------------------
-;; Extract, find, and modify keyword arguments in the innermost expression.
-
-(define _extract-innermost :effects []
-  (fn ((url :as string))
-    ;; Returns {"before" ... "content" ... "suffix" ...}
-    ;; where before + content + suffix = url
-    ;; content = the innermost expression's dot-separated tokens
-    (let ((stripped (_strip-trailing-close url))
-          (suffix (slice url (len (_strip-trailing-close url)))))
-      (let ((last-dp (_last-index-of stripped ".(")))
-        (if (nil? last-dp)
-          ;; Single-level: /(content)
-          {"before" "/("
-           "content" (slice stripped 2)
-           "suffix" suffix}
-          ;; Multi-level: .../.(content)...)
-          {"before" (slice stripped 0 (+ last-dp 2))
-           "content" (slice stripped (+ last-dp 2))
-           "suffix" suffix})))))
-
-(define _find-kw-in-tokens :effects []
-  (fn ((tokens :as list) (i :as number) (kw :as string))
-    ;; Find value of keyword kw in token list. Returns nil if not found.
-    (if (>= i (len tokens))
-      nil
-      (if (and (= (nth tokens i) kw)
-               (< (+ i 1) (len tokens)))
-        (nth tokens (+ i 1))
-        (_find-kw-in-tokens tokens (+ i 1) kw)))))
-
-(define _find-keyword-value :effects []
-  (fn ((content :as string) (kw :as string))
-    ;; Find keyword's value in dot-separated content string.
-    ;; "explore.signals.:page.3" ":page" → "3"
-    (_find-kw-in-tokens (split content ".") 0 kw)))
-
-(define _replace-kw-in-tokens :effects []
-  (fn ((tokens :as list) (i :as number) (kw :as string) (value :as string))
-    ;; Replace keyword's value in token list. Returns new token list.
-    (if (>= i (len tokens))
-      (list)
-      (if (and (= (nth tokens i) kw)
-               (< (+ i 1) (len tokens)))
-        ;; Found — keep keyword, replace value, concat rest
-        (append (list kw value)
-                (_replace-kw-in-tokens tokens (+ i 2) kw value))
-        ;; Not this keyword — keep token, continue
-        (cons (nth tokens i)
-              (_replace-kw-in-tokens tokens (+ i 1) kw value))))))
-
-(define _set-keyword-in-content :effects []
-  (fn ((content :as string) (kw :as string) (value :as string))
-    ;; Set or replace keyword value in dot-separated content.
-    ;; "a.b.:page.3" ":page" "4" → "a.b.:page.4"
-    ;; "a.b" ":page" "1" → "a.b.:page.1"
-    (let ((current (_find-keyword-value content kw)))
-      (if (nil? current)
-        ;; Not found — append
-        (str content "." kw "." value)
-        ;; Found — replace
-        (join "." (_replace-kw-in-tokens (split content ".") 0 kw value))))))
-
-(define _is-delta-value? :effects []
-  (fn ((s :as string))
-    ;; "+1", "-2", "+10" are deltas. "-" alone is not.
-    (and (not (empty? s))
-         (> (len s) 1)
-         (or (starts-with? s "+") (starts-with? s "-")))))
-
-(define _apply-delta :effects []
-  (fn ((current-str :as string) (delta-str :as string))
-    ;; Apply numeric delta to current value string.
-    ;; "3" "+1" → "4",  "3" "-1" → "2"
-    (let ((cur (parse-int current-str nil))
-          (delta (parse-int delta-str nil)))
-      (if (or (nil? cur) (nil? delta))
-        delta-str  ;; fallback: use delta as literal value
-        (str (+ cur delta))))))
-
-(define _apply-kw-pairs :effects []
-  (fn ((content :as string) (kw-pairs :as list))
-    ;; Apply keyword modifications to content, one at a time.
-    (if (empty? kw-pairs)
-      content
-      (let ((pair (first kw-pairs))
-            (kw (first pair))
-            (raw-val (nth pair 1)))
-        (let ((actual-val
-                (if (_is-delta-value? raw-val)
-                  (let ((current (_find-keyword-value content kw)))
-                    (if (nil? current)
-                      raw-val  ;; no current value, treat delta as literal
-                      (_apply-delta current raw-val)))
-                  raw-val)))
-          (_apply-kw-pairs
-            (_set-keyword-in-content content kw actual-val)
-            (rest kw-pairs)))))))
-
-(define _apply-keywords-to-url :effects []
-  (fn ((url :as string) (kw-pairs :as list))
-    ;; Apply keyword modifications to the innermost expression of a URL.
-    (if (empty? kw-pairs)
-      url
-      (let ((parts (_extract-innermost url)))
-        (let ((new-content (_apply-kw-pairs (get parts "content") kw-pairs)))
-          (str (get parts "before") new-content (get parts "suffix")))))))
-
-
-;; --------------------------------------------------------------------------
-;; 10. Public API: resolve-relative-url (structural + keywords)
-;; --------------------------------------------------------------------------
-
-(define _normalize-relative :effects []
-  (fn ((url :as string))
-    ;; Normalize bare-dot shorthand to paren form.
-    ;; ".."        → "(..)"
-    ;; ".slug"     → "(.slug)"
-    ;; ".:page.4"  → "(.:page.4)"
-    ;; "(.slug)"   → "(.slug)" (already canonical)
-    (if (starts-with? url "(")
-      url
-      (str "(" url ")"))))
-
-(define resolve-relative-url :effects []
-  (fn ((current :as string) (relative :as string))
-    ;; current:  absolute SX URL  "/(geography.(hypermedia.(example)))"
-    ;; relative: relative SX URL  "(.progress-bar)" or ".." or ".:page.+1"
-    ;; Returns:  absolute SX URL
-    (let ((canonical (_normalize-relative relative)))
-      (let ((rel-inner (slice canonical 1 (- (len canonical) 1))))
-        (let ((dots (_count-leading-dots rel-inner))
-              (body (slice rel-inner (_count-leading-dots rel-inner))))
-          (if (= dots 0)
-            current  ;; no dots — not a relative URL
-            ;; Parse body into positional part + keyword pairs
-            (let ((parsed (_parse-relative-body body))
-                  (pos-body (get parsed "positional"))
-                  (kw-pairs (get parsed "keywords")))
-              ;; Step 1: structural navigation
-              (let ((after-nav
-                      (if (= dots 1)
-                        ;; One dot = current level
-                        (if (empty? pos-body)
-                          current  ;; no positional → stay here (keyword-only)
-                          ;; Append positional part at current level
-                          (let ((stripped (_strip-trailing-close current))
-                                (suffix (slice current (len (_strip-trailing-close current)))))
-                            (str stripped "." pos-body suffix)))
-                        ;; Two+ dots = pop (dots-1) levels
-                        (let ((base (_pop-sx-url-levels current (- dots 1))))
-                          (if (empty? pos-body)
-                            base  ;; no positional → just pop (cd ..)
-                            (if (= base "/")
-                              (str "/(" pos-body ")")
-                              (let ((stripped (_strip-trailing-close base))
-                                    (suffix (slice base (len (_strip-trailing-close base)))))
-                                (str stripped ".(" pos-body ")" suffix))))))))
-                ;; Step 2: apply keyword modifications
-                (_apply-keywords-to-url after-nav kw-pairs)))))))))
-
-;; Check if a URL is relative (starts with ( but not /( , or starts with .)
-(define relative-sx-url? :effects []
-  (fn ((url :as string))
-    (or (and (starts-with? url "(")
-             (not (starts-with? url "/(")))
-        (starts-with? url "."))))
-
-
-;; --------------------------------------------------------------------------
-;; 11. URL special forms (! prefix)
-;; --------------------------------------------------------------------------
-;; Special forms are meta-operations on URL expressions.
-;; Distinguished by `!` prefix to avoid name collisions with sections/pages.
-;;
-;; Known forms:
-;;   !source   — show defcomp source code
-;;   !inspect  — deps, CSS footprint, render plan, IO
-;;   !diff     — side-by-side comparison of two expressions
-;;   !search   — grep within a page/spec
-;;   !raw      — skip ~sx-doc wrapping, return raw content
-;;   !json     — return content as JSON data
-;;
-;; URL examples:
-;;   /(!source.(~essay-sx-sucks))
-;;   /(!inspect.(language.(doc.primitives)))
-;;   /(!diff.(language.(spec.signals)).(language.(spec.eval)))
-;;   /(!search."define".:in.(language.(spec.signals)))
-;;   /(!raw.(~some-component))
-;;   /(!json.(language.(doc.primitives)))
-
-(define _url-special-forms :effects []
-  (fn ()
-    ;; Returns the set of known URL special form names.
-    (list "!source" "!inspect" "!diff" "!search" "!raw" "!json")))
-
-(define url-special-form? :effects []
-  (fn ((name :as string))
-    ;; Check if a name is a URL special form (starts with ! and is known).
-    (and (starts-with? name "!")
-         (contains? (_url-special-forms) name))))
-
-(define parse-sx-url :effects []
-  (fn ((url :as string))
-    ;; Parse an SX URL into a structured descriptor.
-    ;; Returns a dict with:
-    ;;   "type"     — "home" | "absolute" | "relative" | "special-form" | "direct-component"
-    ;;   "form"     — special form name (for special-form type), e.g. "!source"
-    ;;   "inner"    — inner URL expression string (without the special form wrapper)
-    ;;   "raw"      — original URL string
-    ;;
-    ;; Examples:
-    ;;   "/"                                → {"type" "home" "raw" "/"}
-    ;;   "/(language.(doc.intro))"          → {"type" "absolute" "raw" ...}
-    ;;   "(.slug)"                          → {"type" "relative" "raw" ...}
-    ;;   "..slug"                           → {"type" "relative" "raw" ...}
-    ;;   "/(!source.(~essay))"              → {"type" "special-form" "form" "!source" "inner" "(~essay)" "raw" ...}
-    ;;   "/(~essay-sx-sucks)"               → {"type" "direct-component" "name" "~essay-sx-sucks" "raw" ...}
-    (cond
-      (= url "/")
-        {"type" "home" "raw" url}
-      (relative-sx-url? url)
-        {"type" "relative" "raw" url}
-      (and (starts-with? url "/(!")
-           (ends-with? url ")"))
-        ;; Special form: /(!source.(~essay)) or /(!diff.a.b)
-        ;; Extract the form name (first dot-separated token after /()
-        (let ((inner (slice url 2 (- (len url) 1))))
-          ;; inner = "!source.(~essay)" or "!diff.(a).(b)"
-          (let ((dot-pos (_index-of-safe inner "."))
-                (paren-pos (_index-of-safe inner "(")))
-            ;; Form name ends at first . or ( (whichever comes first)
-            (let ((end-pos (cond
-                             (and (nil? dot-pos) (nil? paren-pos)) (len inner)
-                             (nil? dot-pos) paren-pos
-                             (nil? paren-pos) dot-pos
-                             :else (min dot-pos paren-pos))))
-              (let ((form-name (slice inner 0 end-pos))
-                    (rest-part (slice inner end-pos)))
-                ;; rest-part starts with "." → strip leading dot
-                (let ((inner-expr (if (starts-with? rest-part ".")
-                                    (slice rest-part 1)
-                                    rest-part)))
-                  {"type" "special-form"
-                   "form" form-name
-                   "inner" inner-expr
-                   "raw" url})))))
-      (and (starts-with? url "/(~")
-           (ends-with? url ")"))
-        ;; Direct component: /(~essay-sx-sucks)
-        (let ((name (slice url 2 (- (len url) 1))))
-          {"type" "direct-component" "name" name "raw" url})
-      (and (starts-with? url "/(")
-           (ends-with? url ")"))
-        {"type" "absolute" "raw" url}
-      :else
-        {"type" "path" "raw" url})))
-
-(define url-special-form-name :effects []
-  (fn ((url :as string))
-    ;; Extract the special form name from a URL, or nil if not a special form.
-    ;; "/(!source.(~essay))" → "!source"
-    ;; "/(language.(doc))" → nil
-    (let ((parsed (parse-sx-url url)))
-      (if (= (get parsed "type") "special-form")
-        (get parsed "form")
-        nil))))
-
-(define url-special-form-inner :effects []
-  (fn ((url :as string))
-    ;; Extract the inner expression from a special form URL, or nil.
-    ;; "/(!source.(~essay))" → "(~essay)"
-    ;; "/(!diff.(a).(b))" → "(a).(b)"
-    (let ((parsed (parse-sx-url url)))
-      (if (= (get parsed "type") "special-form")
-        (get parsed "inner")
-        nil))))
-
-
-;; --------------------------------------------------------------------------
-;; 12. URL expression evaluation
-;; --------------------------------------------------------------------------
-;; A URL is an expression. The system is the environment.
-;; eval(url, env) — that's it.
-;;
-;; The only URL-specific pre-processing:
-;;   1. Surface syntax → AST (dots to spaces, parse as SX)
-;;   2. Auto-quote unknowns (symbols not in env become strings)
-;;
-;; After that, it's standard eval. The host wires these into its route
-;; handlers (Python catch-all, JS client-side navigation). The same
-;; functions serve both.
-
-(define url-to-expr :effects []
-  (fn ((url-path :as string))
-    ;; Convert a URL path to an SX expression (AST).
-    ;;
-    ;; "/sx/(language.(doc.introduction))" → (language (doc introduction))
-    ;; "/(language.(doc.introduction))"    → (language (doc introduction))
-    ;; "/"                                 → (list) ; empty — home
-    ;;
-    ;; Steps:
-    ;;   1. Strip URL prefix ("/sx/" or "/") — host passes the path after prefix
-    ;;   2. Dots → spaces (URL-safe whitespace encoding)
-    ;;   3. Parse as SX expression
-    ;;
-    ;; The caller is responsible for stripping any app-level prefix.
-    ;; This function receives the raw expression portion: "(language.(doc.intro))"
-    ;; or "/" for home.
-    (if (or (= url-path "/") (empty? url-path))
-      (list)
-      (let ((trimmed (if (starts-with? url-path "/")
-                       (slice url-path 1)
-                       url-path)))
-        ;; Dots → spaces
-        (let ((sx-source (replace trimmed "." " ")))
-          ;; Parse — returns list of expressions, take the first
-          (let ((exprs (sx-parse sx-source)))
-            (if (empty? exprs)
-              (list)
-              (first exprs))))))))
-
-
-(define auto-quote-unknowns :effects []
-  (fn ((expr :as list) (env :as dict))
-    ;; Walk an AST and replace symbols not in env with their name as a string.
-    ;; This makes URL slugs work without quoting:
-    ;;   (language (doc introduction))  ; introduction is not a function
-    ;;   → (language (doc "introduction"))
-    ;;
-    ;; Rules:
-    ;;   - List head (call position) stays as-is — it's a function name
-    ;;   - Tail symbols: if in env, keep as symbol; otherwise, string
-    ;;   - Keywords, strings, numbers, nested lists: pass through
-    ;;   - Non-list expressions: pass through unchanged
-    (if (not (list? expr))
-      expr
-      (if (empty? expr)
-        expr
-        ;; Head stays as symbol (function position), quote the rest
-        (cons (first expr)
-              (map (fn (child)
-                     (cond
-                       ;; Nested list — recurse
-                       (list? child)
-                         (auto-quote-unknowns child env)
-                       ;; Symbol — check env
-                       (= (type-of child) "symbol")
-                         (let ((name (symbol-name child)))
-                           (if (or (env-has? env name)
-                                   ;; Keep keywords, component refs, special forms
-                                   (starts-with? name ":")
-                                   (starts-with? name "~")
-                                   (starts-with? name "!"))
-                             child
-                             name))  ;; unknown → string
-                       ;; Everything else passes through
-                       :else child))
-                   (rest expr)))))))
-
-
-(define prepare-url-expr :effects []
-  (fn ((url-path :as string) (env :as dict))
-    ;; Full pipeline: URL path → ready-to-eval AST.
-    ;;
-    ;; "(language.(doc.introduction))" + env
-    ;;   → (language (doc "introduction"))
-    ;;
-    ;; The result can be fed directly to eval:
-    ;;   (eval (prepare-url-expr path env) env)
-    (let ((expr (url-to-expr url-path)))
-      (if (empty? expr)
-        expr
-        (auto-quote-unknowns expr env)))))
-
-
-;; --------------------------------------------------------------------------
-;; Platform interface
-;; --------------------------------------------------------------------------
-;; Pure primitives used:
-;;   split, slice, starts-with?, ends-with?, len, empty?, replace,
-;;   map, filter, for-each, for-each-indexed, nth, get, dict-set!, merge,
-;;   list, nil?, not, =, case, join, str, index-of, and, or, cons,
-;;   first, rest, append, parse-int, contains?, min, cond,
-;;   symbol?, symbol-name, list?, env-has?, type-of
-;;
-;; From parser.sx: sx-parse, sx-serialize
-;; --------------------------------------------------------------------------

shared/sx/ref/signals.sx

@@ -1,479 +0,0 @@
-;; ==========================================================================
-;; signals.sx — Reactive signal runtime specification
-;;
-;; Defines the signal primitive: a container for a value that notifies
-;; subscribers when it changes. Signals are the reactive state primitive
-;; for SX islands.
-;;
-;; Signals are pure computation — no DOM, no IO. The reactive rendering
-;; layer (adapter-dom.sx) subscribes DOM nodes to signals. The server
-;; adapter (adapter-html.sx) reads signal values without subscribing.
-;;
-;; Signals are plain dicts with a "__signal" marker key. No platform
-;; primitives needed — all signal operations are pure SX.
-;;
-;; Reactive tracking and island lifecycle use the general scoped effects
-;; system (scope-push!/scope-pop!/context) instead of separate globals.
-;; Two scope names:
-;;   "sx-reactive"     — tracking context for computed/effect dep discovery
-;;   "sx-island-scope" — island disposable collector
-;;
-;; Scope-based tracking:
-;;   (scope-push! "sx-reactive" {:deps (list) :notify fn}) → void
-;;   (scope-pop! "sx-reactive")                            → void
-;;   (context "sx-reactive" nil)                           → dict or nil
-;;
-;; CEK callable dispatch:
-;;   (cek-call f args)         → any  — call f with args list via CEK.
-;;                                       Dispatches through cek-run for SX
-;;                                       lambdas, apply for native callables.
-;;                                       Defined in cek.sx.
-;;
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Signal container — plain dict with marker key
-;; --------------------------------------------------------------------------
-;;
-;; A signal is a dict: {"__signal" true, "value" v, "subscribers" [], "deps" []}
-;; type-of returns "dict". Use signal? to distinguish from regular dicts.
-
-(define make-signal (fn (value)
-  (dict "__signal" true "value" value "subscribers" (list) "deps" (list))))
-
-(define signal? (fn (x)
-  (and (dict? x) (has-key? x "__signal"))))
-
-(define signal-value (fn (s) (get s "value")))
-(define signal-set-value! (fn (s v) (dict-set! s "value" v)))
-(define signal-subscribers (fn (s) (get s "subscribers")))
-
-(define signal-add-sub! (fn (s f)
-  (when (not (contains? (get s "subscribers") f))
-    (append! (get s "subscribers") f))))
-
-(define signal-remove-sub! (fn (s f)
-  (dict-set! s "subscribers"
-    (filter (fn (sub) (not (identical? sub f)))
-            (get s "subscribers")))))
-
-(define signal-deps (fn (s) (get s "deps")))
-(define signal-set-deps! (fn (s deps) (dict-set! s "deps" deps)))
-
-
-;; --------------------------------------------------------------------------
-;; 1. signal — create a reactive container
-;; --------------------------------------------------------------------------
-
-(define signal :effects []
-  (fn ((initial-value :as any))
-    (make-signal initial-value)))
-
-
-;; --------------------------------------------------------------------------
-;; 2. deref — read signal value, subscribe current reactive context
-;; --------------------------------------------------------------------------
-;;
-;; In a reactive context (inside effect or computed), deref registers the
-;; signal as a dependency. Outside reactive context, deref just returns
-;; the current value — no subscription, no overhead.
-
-(define deref :effects []
-  (fn ((s :as any))
-    (if (not (signal? s))
-      s  ;; non-signal values pass through
-      (let ((ctx (context "sx-reactive" nil)))
-        (when ctx
-          ;; Register this signal as a dependency of the current context
-          (let ((dep-list (get ctx "deps"))
-                (notify-fn (get ctx "notify")))
-            (when (not (contains? dep-list s))
-              (append! dep-list s)
-              (signal-add-sub! s notify-fn))))
-        (signal-value s)))))
-
-
-;; --------------------------------------------------------------------------
-;; 3. reset! — write a new value, notify subscribers
-;; --------------------------------------------------------------------------
-
-(define reset! :effects [mutation]
-  (fn ((s :as signal) value)
-    (when (signal? s)
-      (let ((old (signal-value s)))
-        (when (not (identical? old value))
-          (signal-set-value! s value)
-          (notify-subscribers s))))))
-
-
-;; --------------------------------------------------------------------------
-;; 4. swap! — update signal via function
-;; --------------------------------------------------------------------------
-
-(define swap! :effects [mutation]
-  (fn ((s :as signal) (f :as lambda) &rest args)
-    (when (signal? s)
-      (let ((old (signal-value s))
-            (new-val (apply f (cons old args))))
-        (when (not (identical? old new-val))
-          (signal-set-value! s new-val)
-          (notify-subscribers s))))))
-
-
-;; --------------------------------------------------------------------------
-;; 5. computed — derived signal with automatic dependency tracking
-;; --------------------------------------------------------------------------
-;;
-;; A computed signal wraps a zero-arg function. It re-evaluates when any
-;; of its dependencies change. The dependency set is discovered automatically
-;; by tracking deref calls during evaluation.
-
-(define computed :effects [mutation]
-  (fn ((compute-fn :as lambda))
-    (let ((s (make-signal nil))
-          (deps (list))
-          (compute-ctx nil))
-
-      ;; The notify function — called when a dependency changes
-      (let ((recompute
-              (fn ()
-                ;; Unsubscribe from old deps
-                (for-each
-                  (fn ((dep :as signal)) (signal-remove-sub! dep recompute))
-                  (signal-deps s))
-                (signal-set-deps! s (list))
-
-                ;; Push scope-based tracking context for this computed
-                (let ((ctx (dict "deps" (list) "notify" recompute)))
-                  (scope-push! "sx-reactive" ctx)
-                  (let ((new-val (cek-call compute-fn nil)))
-                    (scope-pop! "sx-reactive")
-                    ;; Save discovered deps
-                    (signal-set-deps! s (get ctx "deps"))
-                    ;; Update value + notify downstream
-                    (let ((old (signal-value s)))
-                      (signal-set-value! s new-val)
-                      (when (not (identical? old new-val))
-                        (notify-subscribers s))))))))
-
-        ;; Initial computation
-        (recompute)
-        ;; Auto-register disposal with island scope
-        (register-in-scope (fn () (dispose-computed s)))
-        s))))
-
-
-;; --------------------------------------------------------------------------
-;; 6. effect — side effect that runs when dependencies change
-;; --------------------------------------------------------------------------
-;;
-;; Like computed, but doesn't produce a signal value. Returns a dispose
-;; function that tears down the effect.
-
-(define effect :effects [mutation]
-  (fn ((effect-fn :as lambda))
-    (let ((deps (list))
-          (disposed false)
-          (cleanup-fn nil))
-
-      (let ((run-effect
-              (fn ()
-                (when (not disposed)
-                  ;; Run previous cleanup if any
-                  (when cleanup-fn (cek-call cleanup-fn nil))
-
-                  ;; Unsubscribe from old deps
-                  (for-each
-                    (fn ((dep :as signal)) (signal-remove-sub! dep run-effect))
-                    deps)
-                  (set! deps (list))
-
-                  ;; Push scope-based tracking context
-                  (let ((ctx (dict "deps" (list) "notify" run-effect)))
-                    (scope-push! "sx-reactive" ctx)
-                    (let ((result (cek-call effect-fn nil)))
-                      (scope-pop! "sx-reactive")
-                      (set! deps (get ctx "deps"))
-                      ;; If effect returns a function, it's the cleanup
-                      (when (callable? result)
-                        (set! cleanup-fn result))))))))
-
-        ;; Initial run
-        (run-effect)
-
-        ;; Return dispose function
-        (let ((dispose-fn
-                (fn ()
-                  (set! disposed true)
-                  (when cleanup-fn (cek-call cleanup-fn nil))
-                  (for-each
-                    (fn ((dep :as signal)) (signal-remove-sub! dep run-effect))
-                    deps)
-                  (set! deps (list)))))
-          ;; Auto-register with island scope so disposal happens on swap
-          (register-in-scope dispose-fn)
-          dispose-fn)))))
-
-
-;; --------------------------------------------------------------------------
-;; 7. batch — group multiple signal writes into one notification pass
-;; --------------------------------------------------------------------------
-;;
-;; During a batch, signal writes are deferred. Subscribers are notified
-;; once at the end, after all values have been updated.
-
-(define *batch-depth* 0)
-(define *batch-queue* (list))
-
-(define batch :effects [mutation]
-  (fn ((thunk :as lambda))
-    (set! *batch-depth* (+ *batch-depth* 1))
-    (cek-call thunk nil)
-    (set! *batch-depth* (- *batch-depth* 1))
-    (when (= *batch-depth* 0)
-      (let ((queue *batch-queue*))
-        (set! *batch-queue* (list))
-        ;; Collect unique subscribers across all queued signals,
-        ;; then notify each exactly once.
-        (let ((seen (list))
-              (pending (list)))
-          (for-each
-            (fn ((s :as signal))
-              (for-each
-                (fn ((sub :as lambda))
-                  (when (not (contains? seen sub))
-                    (append! seen sub)
-                    (append! pending sub)))
-                (signal-subscribers s)))
-            queue)
-          (for-each (fn ((sub :as lambda)) (sub)) pending))))))
-
-
-;; --------------------------------------------------------------------------
-;; 8. notify-subscribers — internal notification dispatch
-;; --------------------------------------------------------------------------
-;;
-;; If inside a batch, queues the signal. Otherwise, notifies immediately.
-
-(define notify-subscribers :effects [mutation]
-  (fn ((s :as signal))
-    (if (> *batch-depth* 0)
-      (when (not (contains? *batch-queue* s))
-        (append! *batch-queue* s))
-      (flush-subscribers s))))
-
-(define flush-subscribers :effects [mutation]
-  (fn ((s :as signal))
-    (for-each
-      (fn ((sub :as lambda)) (sub))
-      (signal-subscribers s))))
-
-
-;; --------------------------------------------------------------------------
-;; 9. Reactive tracking context
-;; --------------------------------------------------------------------------
-;;
-;; Tracking is now scope-based. computed/effect push a dict
-;; {:deps (list) :notify fn} onto the "sx-reactive" scope stack via
-;; scope-push!/scope-pop!. deref reads it via (context "sx-reactive" nil).
-;; No platform primitives needed — uses the existing scope infrastructure.
-
-
-;; --------------------------------------------------------------------------
-;; 10. dispose — tear down a computed signal
-;; --------------------------------------------------------------------------
-;;
-;; For computed signals, unsubscribe from all dependencies.
-;; For effects, the dispose function is returned by effect itself.
-
-(define dispose-computed :effects [mutation]
-  (fn ((s :as signal))
-    (when (signal? s)
-      (for-each
-        (fn ((dep :as signal)) (signal-remove-sub! dep nil))
-        (signal-deps s))
-      (signal-set-deps! s (list)))))
-
-
-;; --------------------------------------------------------------------------
-;; 11. Island scope — automatic cleanup of signals within an island
-;; --------------------------------------------------------------------------
-;;
-;; When an island is created, all signals, effects, and computeds created
-;; within it are tracked. When the island is removed from the DOM, they
-;; are all disposed.
-;;
-;; Uses "sx-island-scope" scope name. The scope value is a collector
-;; function (fn (disposable) ...) that appends to the island's disposer list.
-
-(define with-island-scope :effects [mutation]
-  (fn ((scope-fn :as lambda) (body-fn :as lambda))
-    (scope-push! "sx-island-scope" scope-fn)
-    (let ((result (body-fn)))
-      (scope-pop! "sx-island-scope")
-      result)))
-
-;; Hook into signal/effect/computed creation for scope tracking.
-
-(define register-in-scope :effects [mutation]
-  (fn ((disposable :as lambda))
-    (let ((collector (context "sx-island-scope" nil)))
-      (when collector
-        (cek-call collector (list disposable))))))
-
-
-;; ==========================================================================
-;; 12. Marsh scopes — child scopes within islands
-;; ==========================================================================
-;;
-;; Marshes are zones inside islands where server content is re-evaluated
-;; in the island's reactive context. When a marsh is re-morphed with new
-;; content, its old effects and computeds must be disposed WITHOUT disturbing
-;; the island's own reactive graph.
-;;
-;; Scope hierarchy: island → marsh → effects/computeds
-;; Disposing a marsh disposes its subscope. Disposing an island disposes
-;; all its marshes. The signal graph is a tree, not a flat list.
-;;
-;; Platform interface required:
-;;   (dom-set-data el key val) → void  — store JS value on element
-;;   (dom-get-data el key)     → any   — retrieve stored value
-
-(define with-marsh-scope :effects [mutation io]
-  (fn (marsh-el (body-fn :as lambda))
-    ;; Execute body-fn collecting all disposables into a marsh-local list.
-    ;; Nested under the current island scope — if the island is disposed,
-    ;; the marsh is disposed too (because island scope collected the marsh's
-    ;; own dispose function).
-    (let ((disposers (list)))
-      (with-island-scope
-        (fn (d) (append! disposers d))
-        body-fn)
-      ;; Store disposers on the marsh element for later cleanup
-      (dom-set-data marsh-el "sx-marsh-disposers" disposers))))
-
-(define dispose-marsh-scope :effects [mutation io]
-  (fn (marsh-el)
-    ;; Dispose all effects/computeds registered in this marsh's scope.
-    ;; Parent island scope and sibling marshes are unaffected.
-    (let ((disposers (dom-get-data marsh-el "sx-marsh-disposers")))
-      (when disposers
-        (for-each (fn ((d :as lambda)) (cek-call d nil)) disposers)
-        (dom-set-data marsh-el "sx-marsh-disposers" nil)))))
-
-
-;; ==========================================================================
-;; 13. Named stores — page-level signal containers (L3)
-;; ==========================================================================
-;;
-;; Stores persist across island creation/destruction. They live at page
-;; scope, not island scope. When an island is swapped out and re-created,
-;; it reconnects to the same store instance.
-;;
-;; The store registry is global page-level state. It survives island
-;; disposal but is cleared on full page navigation.
-
-(define *store-registry* (dict))
-
-(define def-store :effects [mutation]
-  (fn ((name :as string) (init-fn :as lambda))
-    (let ((registry *store-registry*))
-      ;; Only create the store once — subsequent calls return existing
-      (when (not (has-key? registry name))
-        (set! *store-registry* (assoc registry name (cek-call init-fn nil))))
-      (get *store-registry* name))))
-
-(define use-store :effects []
-  (fn ((name :as string))
-    (if (has-key? *store-registry* name)
-      (get *store-registry* name)
-      (error (str "Store not found: " name
-                  ". Call (def-store ...) before (use-store ...).")))))
-
-(define clear-stores :effects [mutation]
-  (fn ()
-    (set! *store-registry* (dict))))
-
-
-;; ==========================================================================
-;; 13. Event bridge — DOM event communication for lake→island
-;; ==========================================================================
-;;
-;; Server-rendered content ("htmx lakes") inside reactive islands can
-;; communicate with island signals via DOM custom events. The bridge
-;; pattern:
-;;
-;;   1. Server renders a button/link with data-sx-emit="event-name"
-;;   2. When clicked, the client dispatches a CustomEvent on the element
-;;   3. The event bubbles up to the island container
-;;   4. An island effect listens for the event and updates signals
-;;
-;; This keeps server content pure HTML — no signal references needed.
-;; The island effect is the only reactive code.
-;;
-;; Platform interface required:
-;;   (dom-listen el event-name handler)   → remove-fn
-;;   (dom-dispatch el event-name detail)  → void
-;;   (event-detail e)                     → any
-;;
-;; These are platform primitives because they require browser DOM APIs.
-
-(define emit-event :effects [io]
-  (fn (el (event-name :as string) detail)
-    (dom-dispatch el event-name detail)))
-
-(define on-event :effects [io]
-  (fn (el (event-name :as string) (handler :as lambda))
-    (dom-listen el event-name handler)))
-
-;; Convenience: create an effect that listens for a DOM event on an
-;; element and writes the event detail (or a transformed value) into
-;; a target signal. Returns the effect's dispose function.
-;; When the effect is disposed (island teardown), the listener is
-;; removed automatically via the cleanup return.
-
-(define bridge-event :effects [mutation io]
-  (fn (el (event-name :as string) (target-signal :as signal) transform-fn)
-    (effect (fn ()
-      (let ((remove (dom-listen el event-name
-              (fn (e)
-                (let ((detail (event-detail e))
-                      (new-val (if transform-fn
-                                 (cek-call transform-fn (list detail))
-                                 detail)))
-                  (reset! target-signal new-val))))))
-        ;; Return cleanup — removes listener on dispose/re-run
-        remove)))))
-
-
-;; ==========================================================================
-;; 14. Resource — async signal with loading/resolved/error states
-;; ==========================================================================
-;;
-;; A resource wraps an async operation (fetch, computation) and exposes
-;; its state as a signal. The signal transitions through:
-;;   {:loading true  :data nil    :error nil}  — initial/loading
-;;   {:loading false :data result :error nil}  — success
-;;   {:loading false :data nil    :error err}  — failure
-;;
-;; Usage:
-;;   (let ((user (resource (fn () (fetch-json "/api/user")))))
-;;     (cond
-;;       (get (deref user) "loading")  (div "Loading...")
-;;       (get (deref user) "error")    (div "Error: " (get (deref user) "error"))
-;;       :else                         (div (get (deref user) "data"))))
-;;
-;; Platform interface required:
-;;   (promise-then promise on-resolve on-reject) → void
-
-(define resource :effects [mutation io]
-  (fn ((fetch-fn :as lambda))
-    (let ((state (signal (dict "loading" true "data" nil "error" nil))))
-      ;; Kick off the async operation
-      (promise-then (cek-call fetch-fn nil)
-        (fn (data) (reset! state (dict "loading" false "data" data "error" nil)))
-        (fn (err) (reset! state (dict "loading" false "data" nil "error" err))))
-      state)))
-
-

shared/sx/ref/special-forms.sx

@@ -1,444 +0,0 @@
-;; ==========================================================================
-;; special-forms.sx — Specification of all SX special forms
-;;
-;; Special forms are syntactic constructs whose arguments are NOT evaluated
-;; before dispatch. Each form has its own evaluation rules — unlike primitives,
-;; which receive pre-evaluated values.
-;;
-;; This file is a SPECIFICATION, not executable code. Bootstrap compilers
-;; consume these declarations but implement special forms natively.
-;;
-;; Format:
-;;   (define-special-form "name"
-;;     :syntax (name arg1 arg2 ...)
-;;     :doc "description"
-;;     :tail-position "which subexpressions are in tail position"
-;;     :example "(name ...)")
-;;
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Control flow
-;; --------------------------------------------------------------------------
-
-(define-special-form "if"
-  :syntax (if condition then-expr else-expr)
-  :doc "If condition is truthy, evaluate then-expr; otherwise evaluate else-expr.
-        Both branches are in tail position. The else branch is optional and
-        defaults to nil."
-  :tail-position "then-expr, else-expr"
-  :example "(if (> x 10) \"big\" \"small\")")
-
-(define-special-form "when"
-  :syntax (when condition body ...)
-  :doc "If condition is truthy, evaluate all body expressions sequentially.
-        Returns the value of the last body expression, or nil if condition
-        is falsy. Only the last body expression is in tail position."
-  :tail-position "last body expression"
-  :example "(when (logged-in? user)
-  (render-dashboard user))")
-
-(define-special-form "cond"
-  :syntax (cond test1 result1 test2 result2 ... :else default)
-  :doc "Multi-way conditional. Tests are evaluated in order; the result
-        paired with the first truthy test is returned. The :else keyword
-        (or the symbol else) matches unconditionally. Supports both
-        Clojure-style flat pairs and Scheme-style nested pairs:
-          Clojure: (cond test1 result1 test2 result2 :else default)
-          Scheme:  (cond (test1 result1) (test2 result2) (else default))"
-  :tail-position "all result expressions"
-  :example "(cond
-  (= status \"active\") (render-active item)
-  (= status \"draft\")  (render-draft item)
-  :else                (render-unknown item))")
-
-(define-special-form "case"
-  :syntax (case expr val1 result1 val2 result2 ... :else default)
-  :doc "Match expr against values using equality. Like cond but tests
-        a single expression against multiple values. The :else keyword
-        matches if no values match."
-  :tail-position "all result expressions"
-  :example "(case (get request \"method\")
-  \"GET\"  (handle-get request)
-  \"POST\" (handle-post request)
-  :else   (method-not-allowed))")
-
-(define-special-form "and"
-  :syntax (and expr ...)
-  :doc "Short-circuit logical AND. Evaluates expressions left to right.
-        Returns the first falsy value, or the last value if all are truthy.
-        Returns true if given no arguments."
-  :tail-position "last expression"
-  :example "(and (valid? input) (authorized? user) (process input))")
-
-(define-special-form "or"
-  :syntax (or expr ...)
-  :doc "Short-circuit logical OR. Evaluates expressions left to right.
-        Returns the first truthy value, or the last value if all are falsy.
-        Returns false if given no arguments."
-  :tail-position "last expression"
-  :example "(or (get cache key) (fetch-from-db key) \"default\")")
-
-
-;; --------------------------------------------------------------------------
-;; Binding
-;; --------------------------------------------------------------------------
-
-(define-special-form "let"
-  :syntax (let bindings body ...)
-  :doc "Create local bindings and evaluate body in the extended environment.
-        Bindings can be Scheme-style ((name val) ...) or Clojure-style
-        (name val name val ...). Each binding can see previous bindings.
-        Only the last body expression is in tail position.
-
-        Named let: (let name ((x init) ...) body) creates a loop. The name
-        is bound to a function that takes the same params and recurses with
-        tail-call optimization."
-  :tail-position "last body expression; recursive call in named let"
-  :example ";; Basic let
-(let ((x 10) (y 20))
-  (+ x y))
-
-;; Clojure-style
-(let (x 10 y 20)
-  (+ x y))
-
-;; Named let (loop)
-(let loop ((i 0) (acc 0))
-  (if (= i 100)
-    acc
-    (loop (+ i 1) (+ acc i))))")
-
-(define-special-form "let*"
-  :syntax (let* bindings body ...)
-  :doc "Alias for let. In SX, let is already sequential (each binding
-        sees previous ones), so let* is identical to let."
-  :tail-position "last body expression"
-  :example "(let* ((x 10) (y (* x 2)))
-  (+ x y))  ;; → 30")
-
-(define-special-form "letrec"
-  :syntax (letrec bindings body ...)
-  :doc "Mutually recursive local bindings. All names are bound to nil first,
-        then all values are evaluated (so they can reference each other),
-        then lambda closures are patched to include the final bindings.
-        Used for defining mutually recursive local functions."
-  :tail-position "last body expression"
-  :example "(letrec ((even? (fn (n) (if (= n 0) true  (odd?  (- n 1)))))
-         (odd?  (fn (n) (if (= n 0) false (even? (- n 1))))))
-  (even? 10))  ;; → true")
-
-(define-special-form "define"
-  :syntax (define name value)
-  :doc "Bind name to value in the current environment. If value is a lambda
-        and has no name, the lambda's name is set to the symbol name.
-        Returns the value."
-  :tail-position "none (value is eagerly evaluated)"
-  :example "(define greeting \"hello\")
-(define double (fn (x) (* x 2)))")
-
-(define-special-form "set!"
-  :syntax (set! name value)
-  :doc "Mutate an existing binding. The name must already be bound in the
-        current environment. Returns the new value."
-  :tail-position "none (value is eagerly evaluated)"
-  :example "(let (count 0)
-  (set! count (+ count 1)))")
-
-
-;; --------------------------------------------------------------------------
-;; Functions and components
-;; --------------------------------------------------------------------------
-
-(define-special-form "lambda"
-  :syntax (lambda params body)
-  :doc "Create a function. Params is a list of parameter names. Body is
-        a single expression (the return value). The lambda captures the
-        current environment as its closure."
-  :tail-position "body"
-  :example "(lambda (x y) (+ x y))")
-
-(define-special-form "fn"
-  :syntax (fn params body)
-  :doc "Alias for lambda."
-  :tail-position "body"
-  :example "(fn (x) (* x x))")
-
-(define-special-form "defcomp"
-  :syntax (defcomp ~name (&key param1 param2 &rest children) body)
-  :doc "Define a component. Components are called with keyword arguments
-        and optional positional children. The &key marker introduces
-        keyword parameters. The &rest (or &children) marker captures
-        remaining positional arguments as a list.
-
-        Component names conventionally start with ~ to distinguish them
-        from HTML elements. Components are evaluated with a merged
-        environment: closure + caller-env + bound-params."
-  :tail-position "body"
-  :example "(defcomp ~card (&key title subtitle &rest children)
-  (div :class \"card\"
-    (h2 title)
-    (when subtitle (p subtitle))
-    children))")
-
-(define-special-form "defisland"
-  :syntax (defisland ~name (&key param1 param2 &rest children) body)
-  :doc "Define a reactive island. Islands have the same calling convention
-        as components (defcomp) but create a reactive boundary. Inside an
-        island, signals are tracked — deref subscribes DOM nodes to signals,
-        and signal changes update only the affected nodes.
-
-        On the server, islands render as static HTML wrapped in a
-        data-sx-island container with serialized initial state. On the
-        client, islands hydrate into reactive contexts."
-  :tail-position "body"
-  :example "(defisland ~counter (&key initial)
-  (let ((count (signal (or initial 0))))
-    (div :class \"counter\"
-      (span (deref count))
-      (button :on-click (fn (e) (swap! count inc)) \"+\"))))")
-
-(define-special-form "defmacro"
-  :syntax (defmacro name (params ...) body)
-  :doc "Define a macro. Macros receive their arguments unevaluated (as raw
-        AST) and return a new expression that is then evaluated. The
-        returned expression replaces the macro call. Use quasiquote for
-        template construction."
-  :tail-position "none (expansion is evaluated separately)"
-  :example "(defmacro unless (condition &rest body)
-  `(when (not ~condition) ~@body))")
-
-(define-special-form "deftype"
-  :syntax (deftype name body)
-  :doc "Define a named type. The name can be a simple symbol for type aliases
-        and records, or a list (name param ...) for parameterized types.
-        Body is a type expression: a symbol (alias), (union t1 t2 ...) for
-        union types, or {:field1 type1 :field2 type2} for record types.
-        Type definitions are metadata for the type checker with no runtime cost."
-  :tail-position "none"
-  :example "(deftype price number)
-(deftype card-props {:title string :price number})
-(deftype (maybe a) (union a nil))")
-
-(define-special-form "defeffect"
-  :syntax (defeffect name)
-  :doc "Declare a named effect. Effects annotate functions and components
-        to track side effects. A pure function (:effects [pure]) cannot
-        call IO functions. Unannotated functions are assumed to have all
-        effects. Effect checking is gradual — annotations opt in."
-  :tail-position "none"
-  :example "(defeffect io)
-(defeffect async)
-(define add :effects [pure] (fn (a b) (+ a b)))")
-
-
-;; --------------------------------------------------------------------------
-;; Sequencing and threading
-;; --------------------------------------------------------------------------
-
-(define-special-form "begin"
-  :syntax (begin expr ...)
-  :doc "Evaluate expressions sequentially. Returns the value of the last
-        expression. Used when multiple side-effecting expressions need
-        to be grouped."
-  :tail-position "last expression"
-  :example "(begin
-  (log \"starting\")
-  (process data)
-  (log \"done\"))")
-
-(define-special-form "do"
-  :syntax (do expr ...)
-  :doc "Alias for begin."
-  :tail-position "last expression"
-  :example "(do (set! x 1) (set! y 2) (+ x y))")
-
-(define-special-form "->"
-  :syntax (-> value form1 form2 ...)
-  :doc "Thread-first macro. Threads value through a series of function calls,
-        inserting it as the first argument of each form. Nested lists are
-        treated as function calls; bare symbols become unary calls."
-  :tail-position "last form"
-  :example "(-> user
-    (get \"name\")
-    upper
-    (str \" says hello\"))
-;; Expands to: (str (upper (get user \"name\")) \" says hello\")")
-
-
-;; --------------------------------------------------------------------------
-;; Quoting
-;; --------------------------------------------------------------------------
-
-(define-special-form "quote"
-  :syntax (quote expr)
-  :doc "Return expr as data, without evaluating it. Symbols remain symbols,
-        lists remain lists. The reader shorthand is the ' prefix."
-  :tail-position "none (not evaluated)"
-  :example "'(+ 1 2)  ;; → the list (+ 1 2), not the number 3")
-
-(define-special-form "quasiquote"
-  :syntax (quasiquote expr)
-  :doc "Template construction. Like quote, but allows unquoting with ~ and
-        splicing with ~@. The reader shorthand is the ` prefix.
-          `(a ~b ~@c)
-        Quotes everything except: ~expr evaluates expr and inserts the
-        result; ~@expr evaluates to a list and splices its elements."
-  :tail-position "none (template is constructed, not evaluated)"
-  :example "`(div :class \"card\" ~title ~@children)")
-
-
-;; --------------------------------------------------------------------------
-;; Continuations
-;; --------------------------------------------------------------------------
-
-(define-special-form "reset"
-  :syntax (reset body)
-  :doc "Establish a continuation delimiter. Evaluates body normally unless
-        a shift is encountered, in which case the continuation (the rest
-        of the computation up to this reset) is captured and passed to
-        the shift's body. Without shift, reset is a no-op wrapper."
-  :tail-position "body"
-  :example "(reset (+ 1 (shift k (k 10))))  ;; → 11")
-
-(define-special-form "shift"
-  :syntax (shift k body)
-  :doc "Capture the continuation to the nearest reset as k, then evaluate
-        body with k bound. If k is never called, the value of body is
-        returned from the reset (abort). If k is called with a value,
-        the reset body is re-evaluated with shift returning that value.
-        k can be called multiple times."
-  :tail-position "body"
-  :example ";; Abort: shift body becomes the reset result
-(reset (+ 1 (shift k 42)))  ;; → 42
-
-;; Resume: k re-enters the computation
-(reset (+ 1 (shift k (k 10))))  ;; → 11
-
-;; Multiple invocations
-(reset (* 2 (shift k (+ (k 1) (k 10)))))  ;; → 24")
-
-
-;; --------------------------------------------------------------------------
-;; Guards
-;; --------------------------------------------------------------------------
-
-(define-special-form "dynamic-wind"
-  :syntax (dynamic-wind before-thunk body-thunk after-thunk)
-  :doc "Entry/exit guards. All three arguments are zero-argument functions
-        (thunks). before-thunk is called on entry, body-thunk is called
-        for the result, and after-thunk is always called on exit (even on
-        error). The wind stack is maintained so that when continuations
-        jump across dynamic-wind boundaries, the correct before/after
-        thunks fire."
-  :tail-position "none (all thunks are eagerly called)"
-  :example "(dynamic-wind
-  (fn () (log \"entering\"))
-  (fn () (do-work))
-  (fn () (log \"exiting\")))")
-
-
-;; --------------------------------------------------------------------------
-;; Higher-order forms
-;;
-;; These are syntactic forms (not primitives) because the evaluator
-;; handles them directly for performance — avoiding the overhead of
-;; constructing argument lists and doing generic dispatch. They could
-;; be implemented as primitives but are special-cased in eval-list.
-;; --------------------------------------------------------------------------
-
-(define-special-form "map"
-  :syntax (map fn coll)
-  :doc "Apply fn to each element of coll, returning a list of results."
-  :tail-position "none"
-  :example "(map (fn (x) (* x x)) (list 1 2 3 4))  ;; → (1 4 9 16)")
-
-(define-special-form "map-indexed"
-  :syntax (map-indexed fn coll)
-  :doc "Like map, but fn receives two arguments: (index element)."
-  :tail-position "none"
-  :example "(map-indexed (fn (i x) (str i \": \" x)) (list \"a\" \"b\" \"c\"))")
-
-(define-special-form "filter"
-  :syntax (filter fn coll)
-  :doc "Return elements of coll for which fn returns truthy."
-  :tail-position "none"
-  :example "(filter (fn (x) (> x 3)) (list 1 5 2 8 3))  ;; → (5 8)")
-
-(define-special-form "reduce"
-  :syntax (reduce fn init coll)
-  :doc "Reduce coll to a single value. fn receives (accumulator element)
-        and returns the new accumulator. init is the initial value."
-  :tail-position "none"
-  :example "(reduce (fn (acc x) (+ acc x)) 0 (list 1 2 3 4))  ;; → 10")
-
-(define-special-form "some"
-  :syntax (some fn coll)
-  :doc "Return the first truthy result of applying fn to elements of coll,
-        or nil if none match. Short-circuits on first truthy result."
-  :tail-position "none"
-  :example "(some (fn (x) (> x 3)) (list 1 2 5 3))  ;; → true")
-
-(define-special-form "every?"
-  :syntax (every? fn coll)
-  :doc "Return true if fn returns truthy for every element of coll.
-        Short-circuits on first falsy result."
-  :tail-position "none"
-  :example "(every? (fn (x) (> x 0)) (list 1 2 3))  ;; → true")
-
-(define-special-form "for-each"
-  :syntax (for-each fn coll)
-  :doc "Apply fn to each element of coll for side effects. Returns nil."
-  :tail-position "none"
-  :example "(for-each (fn (x) (log x)) (list 1 2 3))")
-
-
-;; --------------------------------------------------------------------------
-;; Definition forms (domain-specific)
-;;
-;; These define named entities in the environment. They are special forms
-;; because their arguments have domain-specific structure that the
-;; evaluator parses directly.
-;; --------------------------------------------------------------------------
-
-(define-special-form "defstyle"
-  :syntax (defstyle name expr)
-  :doc "Define a named style value. Evaluates expr and binds the result
-        to name in the environment. The value is typically a class string
-        or a function that returns class strings."
-  :tail-position "none"
-  :example "(defstyle card-style \"rounded-lg shadow-md p-4 bg-white\")")
-
-(define-special-form "defhandler"
-  :syntax (defhandler name (&key params ...) body)
-  :doc "Define an event handler function. Used by the SxEngine for
-        client-side event handling."
-  :tail-position "body"
-  :example "(defhandler toggle-menu (&key target)
-  (toggle-class target \"hidden\"))")
-
-(define-special-form "defpage"
-  :syntax (defpage name &key route method content ...)
-  :doc "Define a page route. Declares the URL pattern, HTTP method, and
-        content component for server-side page routing."
-  :tail-position "none"
-  :example "(defpage dashboard-page
-  :route \"/dashboard\"
-  :content (~dashboard-content))")
-
-(define-special-form "defquery"
-  :syntax (defquery name (&key params ...) body)
-  :doc "Define a named query for data fetching. Used by the resolver
-        system to declare data dependencies."
-  :tail-position "body"
-  :example "(defquery user-profile (&key user-id)
-  (fetch-user user-id))")
-
-(define-special-form "defaction"
-  :syntax (defaction name (&key params ...) body)
-  :doc "Define a named action for mutations. Like defquery but for
-        write operations."
-  :tail-position "body"
-  :example "(defaction update-profile (&key user-id name email)
-  (save-user user-id name email))")

shared/sx/ref/test-aser.sx

@@ -1,346 +0,0 @@
-;; ==========================================================================
-;; test-aser.sx — Tests for the SX wire format (aser) adapter
-;;
-;; Requires: test-framework.sx loaded first.
-;; Modules tested: adapter-sx.sx (aser, aser-call, aser-fragment, aser-special)
-;;
-;; Platform functions required (beyond test framework):
-;;   render-sx   (sx-source)  -> SX wire format string
-;;     Parses the sx-source string, evaluates via aser in a
-;;     fresh env, and returns the resulting SX wire format string.
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Basic serialization
-;; --------------------------------------------------------------------------
-
-(defsuite "aser-basics"
-  (deftest "number literal passes through"
-    (assert-equal "42"
-      (render-sx "42")))
-
-  (deftest "string literal passes through"
-    ;; aser returns the raw string value; render-sx concatenates it directly
-    (assert-equal "hello"
-      (render-sx "\"hello\"")))
-
-  (deftest "boolean true passes through"
-    (assert-equal "true"
-      (render-sx "true")))
-
-  (deftest "boolean false passes through"
-    (assert-equal "false"
-      (render-sx "false")))
-
-  (deftest "nil produces empty"
-    (assert-equal ""
-      (render-sx "nil"))))
-
-
-;; --------------------------------------------------------------------------
-;; HTML tag serialization
-;; --------------------------------------------------------------------------
-
-(defsuite "aser-tags"
-  (deftest "simple div"
-    (assert-equal "(div \"hello\")"
-      (render-sx "(div \"hello\")")))
-
-  (deftest "nested tags"
-    (assert-equal "(div (span \"hi\"))"
-      (render-sx "(div (span \"hi\"))")))
-
-  (deftest "multiple children"
-    (assert-equal "(div (p \"a\") (p \"b\"))"
-      (render-sx "(div (p \"a\") (p \"b\"))")))
-
-  (deftest "attributes serialize"
-    (assert-equal "(div :class \"foo\" \"bar\")"
-      (render-sx "(div :class \"foo\" \"bar\")")))
-
-  (deftest "multiple attributes"
-    (assert-equal "(a :href \"/home\" :class \"link\" \"Home\")"
-      (render-sx "(a :href \"/home\" :class \"link\" \"Home\")")))
-
-  (deftest "void elements"
-    (assert-equal "(br)"
-      (render-sx "(br)")))
-
-  (deftest "void element with attrs"
-    (assert-equal "(img :src \"pic.jpg\")"
-      (render-sx "(img :src \"pic.jpg\")"))))
-
-
-;; --------------------------------------------------------------------------
-;; Fragment serialization
-;; --------------------------------------------------------------------------
-
-(defsuite "aser-fragments"
-  (deftest "simple fragment"
-    (assert-equal "(<> (p \"a\") (p \"b\"))"
-      (render-sx "(<> (p \"a\") (p \"b\"))")))
-
-  (deftest "empty fragment"
-    (assert-equal ""
-      (render-sx "(<>)")))
-
-  (deftest "single-child fragment"
-    (assert-equal "(<> (div \"x\"))"
-      (render-sx "(<> (div \"x\"))"))))
-
-
-;; --------------------------------------------------------------------------
-;; Control flow in aser mode
-;; --------------------------------------------------------------------------
-
-(defsuite "aser-control-flow"
-  (deftest "if true branch"
-    (assert-equal "(p \"yes\")"
-      (render-sx "(if true (p \"yes\") (p \"no\"))")))
-
-  (deftest "if false branch"
-    (assert-equal "(p \"no\")"
-      (render-sx "(if false (p \"yes\") (p \"no\"))")))
-
-  (deftest "when true"
-    (assert-equal "(p \"ok\")"
-      (render-sx "(when true (p \"ok\"))")))
-
-  (deftest "when false"
-    (assert-equal ""
-      (render-sx "(when false (p \"ok\"))")))
-
-  (deftest "cond serializes matching branch"
-    (assert-equal "(p \"two\")"
-      (render-sx "(cond false (p \"one\") true (p \"two\") :else (p \"three\"))")))
-
-  (deftest "cond with 2-element predicate test"
-    ;; Regression: cond misclassifies (nil? x) as scheme-style clause.
-    (assert-equal "(p \"yes\")"
-      (render-sx "(cond (nil? nil) (p \"yes\") :else (p \"no\"))"))
-    (assert-equal "(p \"no\")"
-      (render-sx "(cond (nil? \"x\") (p \"yes\") :else (p \"no\"))")))
-
-  (deftest "let binds then serializes"
-    (assert-equal "(p \"hello\")"
-      (render-sx "(let ((x \"hello\")) (p x))")))
-
-  (deftest "let preserves outer scope bindings"
-    ;; Regression: process-bindings must preserve parent env scope chain.
-    ;; Using merge() instead of env-extend loses parent scope items.
-    (assert-equal "(p \"outer\")"
-      (render-sx "(do (define theme \"outer\") (let ((x 1)) (p theme)))")))
-
-  (deftest "nested let preserves outer scope"
-    (assert-equal "(div (span \"hello\") (span \"world\"))"
-      (render-sx "(do (define a \"hello\")
-                      (define b \"world\")
-                      (div (let ((x 1)) (span a))
-                           (let ((y 2)) (span b))))")))
-
-  (deftest "begin serializes last"
-    (assert-equal "(p \"last\")"
-      (render-sx "(begin (p \"first\") (p \"last\"))"))))
-
-
-;; --------------------------------------------------------------------------
-;; THE BUG — map/filter list flattening in children (critical regression)
-;; --------------------------------------------------------------------------
-
-(defsuite "aser-list-flattening"
-  (deftest "map inside tag flattens children"
-    (assert-equal "(div (span \"a\") (span \"b\") (span \"c\"))"
-      (render-sx "(do (define items (list \"a\" \"b\" \"c\"))
-                      (div (map (fn (x) (span x)) items)))")))
-
-  (deftest "map inside tag with other children"
-    (assert-equal "(ul (li \"first\") (li \"a\") (li \"b\"))"
-      (render-sx "(do (define items (list \"a\" \"b\"))
-                      (ul (li \"first\") (map (fn (x) (li x)) items)))")))
-
-  (deftest "filter result via let binding as children"
-    ;; Note: (filter ...) is treated as an SVG tag in aser dispatch (SVG has <filter>),
-    ;; so we evaluate filter via let binding + map to serialize children
-    (assert-equal "(ul (li \"a\") (li \"b\"))"
-      (render-sx "(do (define items (list \"a\" nil \"b\"))
-                      (define kept (filter (fn (x) (not (nil? x))) items))
-                      (ul (map (fn (x) (li x)) kept)))")))
-
-  (deftest "map inside fragment flattens"
-    (assert-equal "(<> (p \"a\") (p \"b\"))"
-      (render-sx "(do (define items (list \"a\" \"b\"))
-                      (<> (map (fn (x) (p x)) items)))")))
-
-  (deftest "nested map does not double-wrap"
-    (assert-equal "(div (span \"1\") (span \"2\"))"
-      (render-sx "(do (define nums (list 1 2))
-                      (div (map (fn (n) (span (str n))) nums)))")))
-
-  (deftest "map with component-like output flattens"
-    (assert-equal "(div (li \"x\") (li \"y\"))"
-      (render-sx "(do (define items (list \"x\" \"y\"))
-                      (div (map (fn (x) (li x)) items)))"))))
-
-
-;; --------------------------------------------------------------------------
-;; Component serialization (NOT expanded in basic aser mode)
-;; --------------------------------------------------------------------------
-
-(defsuite "aser-components"
-  (deftest "unknown component serializes as-is"
-    (assert-equal "(~foo :title \"bar\")"
-      (render-sx "(~foo :title \"bar\")")))
-
-  (deftest "defcomp then unexpanded component call"
-    (assert-equal "(~card :title \"Hi\")"
-      (render-sx "(do (defcomp ~card (&key title) (h1 title)) (~card :title \"Hi\"))")))
-
-  (deftest "component with children serializes unexpanded"
-    (assert-equal "(~box (p \"inside\"))"
-      (render-sx "(do (defcomp ~box (&key &rest children) (div children))
-                      (~box (p \"inside\")))"))))
-
-
-;; --------------------------------------------------------------------------
-;; Definition forms in aser mode
-;; --------------------------------------------------------------------------
-
-(defsuite "aser-definitions"
-  (deftest "define evaluates for side effects, returns nil"
-    (assert-equal "(p 42)"
-      (render-sx "(do (define x 42) (p x))")))
-
-  (deftest "defcomp evaluates and returns nil"
-    (assert-equal "(~tag :x 1)"
-      (render-sx "(do (defcomp ~tag (&key x) (span x)) (~tag :x 1))")))
-
-  (deftest "defisland evaluates AND serializes"
-    (let ((result (render-sx "(defisland ~counter (&key count) (span count))")))
-      (assert-true (string-contains? result "defisland")))))
-
-
-;; --------------------------------------------------------------------------
-;; Function calls in aser mode
-;; --------------------------------------------------------------------------
-
-(defsuite "aser-function-calls"
-  (deftest "named function call evaluates fully"
-    (assert-equal "3"
-      (render-sx "(do (define inc1 (fn (x) (+ x 1))) (inc1 2))")))
-
-  (deftest "define + call"
-    (assert-equal "10"
-      (render-sx "(do (define double (fn (x) (* x 2))) (double 5))")))
-
-  (deftest "native callable with multiple args"
-    ;; Regression: async-aser-eval-call passed evaled-args list to
-    ;; async-invoke (&rest), wrapping it in another list. apply(f, [list])
-    ;; calls f(list) instead of f(*list).
-    (assert-equal "3"
-      (render-sx "(do (define my-add +) (my-add 1 2))")))
-
-  (deftest "native callable with two args via alias"
-    (assert-equal "hello world"
-      (render-sx "(do (define my-join str) (my-join \"hello\" \" world\"))")))
-
-  (deftest "higher-order: map returns list"
-    (let ((result (render-sx "(map (fn (x) (+ x 1)) (list 1 2 3))")))
-      ;; map at top level returns a list, not serialized tags
-      (assert-true (not (nil? result))))))
-
-
-;; --------------------------------------------------------------------------
-;; and/or short-circuit in aser mode
-;; --------------------------------------------------------------------------
-
-(defsuite "aser-logic"
-  (deftest "and short-circuits on false"
-    (assert-equal "false"
-      (render-sx "(and true false true)")))
-
-  (deftest "and returns last truthy"
-    (assert-equal "3"
-      (render-sx "(and 1 2 3)")))
-
-  (deftest "or short-circuits on true"
-    (assert-equal "1"
-      (render-sx "(or 1 2 3)")))
-
-  (deftest "or returns last falsy"
-    (assert-equal "false"
-      (render-sx "(or false false)"))))
-
-
-;; --------------------------------------------------------------------------
-;; Spread serialization
-;; --------------------------------------------------------------------------
-
-(defsuite "aser-spreads"
-  (deftest "spread in element merges attrs"
-    (assert-equal "(div :class \"card\" \"hello\")"
-      (render-sx "(div (make-spread {:class \"card\"}) \"hello\")")))
-
-  (deftest "multiple spreads merge into element"
-    (assert-equal "(div :class \"card\" :style \"color:red\" \"hello\")"
-      (render-sx "(div (make-spread {:class \"card\"}) (make-spread {:style \"color:red\"}) \"hello\")")))
-
-  (deftest "spread in fragment is silently dropped"
-    (assert-equal "(<> \"hello\")"
-      (render-sx "(<> (make-spread {:class \"card\"}) \"hello\")")))
-
-  (deftest "stored spread in let binding"
-    (assert-equal "(div :class \"card\" \"hello\")"
-      (render-sx "(let ((card (make-spread {:class \"card\"})))
-                    (div card \"hello\"))")))
-
-  (deftest "spread in nested element"
-    (assert-equal "(div (span :class \"inner\" \"hi\"))"
-      (render-sx "(div (span (make-spread {:class \"inner\"}) \"hi\"))")))
-
-  (deftest "spread in non-element context silently drops"
-    (assert-equal "hello"
-      (render-sx "(do (make-spread {:class \"card\"}) \"hello\")"))))
-
-
-;; --------------------------------------------------------------------------
-;; Scope tests — unified scope primitive
-;; --------------------------------------------------------------------------
-
-(defsuite "scope"
-
-  (deftest "scope with value and context"
-    (assert-equal "dark"
-      (render-sx "(scope \"sc-theme\" :value \"dark\" (context \"sc-theme\"))")))
-
-  (deftest "scope without value defaults to nil"
-    (assert-equal ""
-      (render-sx "(scope \"sc-nil\" (str (context \"sc-nil\")))")))
-
-  (deftest "scope with emit!/emitted"
-    (assert-equal "a,b"
-      (render-sx "(scope \"sc-emit\" (emit! \"sc-emit\" \"a\") (emit! \"sc-emit\" \"b\") (join \",\" (emitted \"sc-emit\")))")))
-
-  (deftest "provide is equivalent to scope with value"
-    (assert-equal "42"
-      (render-sx "(provide \"sc-prov\" 42 (str (context \"sc-prov\")))")))
-
-  (deftest "collect! works via scope (lazy root scope)"
-    (assert-equal "x,y"
-      (render-sx "(do (collect! \"sc-coll\" \"x\") (collect! \"sc-coll\" \"y\") (join \",\" (collected \"sc-coll\")))")))
-
-  (deftest "collect! deduplicates"
-    (assert-equal "a"
-      (render-sx "(do (collect! \"sc-dedup\" \"a\") (collect! \"sc-dedup\" \"a\") (join \",\" (collected \"sc-dedup\")))")))
-
-  (deftest "clear-collected! clears scope accumulator"
-    (assert-equal ""
-      (render-sx "(do (collect! \"sc-clear\" \"x\") (clear-collected! \"sc-clear\") (join \",\" (collected \"sc-clear\")))")))
-
-  (deftest "nested scope shadows outer"
-    (assert-equal "inner"
-      (render-sx "(scope \"sc-nest\" :value \"outer\" (scope \"sc-nest\" :value \"inner\" (context \"sc-nest\")))")))
-
-  (deftest "scope pops correctly after body"
-    (assert-equal "outer"
-      (render-sx "(scope \"sc-pop\" :value \"outer\" (scope \"sc-pop\" :value \"inner\" \"ignore\") (context \"sc-pop\"))"))))

shared/sx/ref/test-cek-reactive.sx

@@ -1,279 +0,0 @@
-;; ==========================================================================
-;; test-cek-reactive.sx — Tests for deref-as-shift reactive rendering
-;;
-;; Tests that (deref signal) inside a reactive-reset boundary performs
-;; continuation capture: the rest of the expression becomes the subscriber.
-;;
-;; Requires: test-framework.sx, frames.sx, cek.sx, signals.sx loaded first.
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Basic deref behavior through CEK
-;; --------------------------------------------------------------------------
-
-(defsuite "deref pass-through"
-  (deftest "deref non-signal passes through"
-    (let ((result (eval-expr-cek
-                    (sx-parse-one "(deref 42)")
-                    (test-env))))
-      (assert-equal 42 result)))
-
-  (deftest "deref nil passes through"
-    (let ((result (eval-expr-cek
-                    (sx-parse-one "(deref nil)")
-                    (test-env))))
-      (assert-nil result)))
-
-  (deftest "deref string passes through"
-    (let ((result (eval-expr-cek
-                    (sx-parse-one "(deref \"hello\")")
-                    (test-env))))
-      (assert-equal "hello" result))))
-
-
-;; --------------------------------------------------------------------------
-;; Deref signal without reactive-reset (no shift)
-;; --------------------------------------------------------------------------
-
-(defsuite "deref signal without reactive-reset"
-  (deftest "deref signal returns current value"
-    (let ((s (signal 99)))
-      (env-set! (test-env) "test-sig" s)
-      (let ((result (eval-expr-cek
-                      (sx-parse-one "(deref test-sig)")
-                      (test-env))))
-        (assert-equal 99 result))))
-
-  (deftest "deref signal in expression returns computed value"
-    (let ((s (signal 10)))
-      (env-set! (test-env) "test-sig" s)
-      (let ((result (eval-expr-cek
-                      (sx-parse-one "(+ 5 (deref test-sig))")
-                      (test-env))))
-        (assert-equal 15 result)))))
-
-
-;; --------------------------------------------------------------------------
-;; Reactive reset + deref: continuation capture
-;; --------------------------------------------------------------------------
-
-(defsuite "reactive-reset shift"
-  (deftest "deref signal with reactive-reset captures continuation"
-    (let ((s (signal 42))
-          (captured-val nil))
-      ;; Run CEK with a ReactiveResetFrame
-      (let ((result (cek-run
-                      (make-cek-state
-                        (sx-parse-one "(deref test-sig)")
-                        (let ((e (env-extend (test-env))))
-                          (env-set! e "test-sig" s)
-                          e)
-                        (list (make-reactive-reset-frame
-                                (test-env)
-                                (fn (v) (set! captured-val v))
-                                true))))))
-        ;; Initial render: returns current value, update-fn NOT called (first-render)
-        (assert-equal 42 result)
-        (assert-nil captured-val))))
-
-  (deftest "signal change invokes subscriber with update-fn"
-    (let ((s (signal 10))
-          (update-calls (list)))
-      ;; 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)
-        (cek-run
-          (make-cek-state
-            (sx-parse-one "(deref test-sig)")
-            e
-            (list (make-reactive-reset-frame
-                    e
-                    (fn (v) (append! update-calls v))
-                    true)))))
-      ;; Change signal — subscriber should fire
-      (reset! s 20)
-      (assert-equal 1 (len update-calls))
-      (assert-equal 20 (first update-calls))
-      ;; Change again
-      (reset! s 30)
-      (assert-equal 2 (len update-calls))
-      (assert-equal 30 (nth update-calls 1))
-      (scope-pop! "sx-island-scope")))
-
-  (deftest "expression with deref captures rest as continuation"
-    (let ((s (signal 5))
-          (update-calls (list)))
-      (scope-push! "sx-island-scope" nil)
-      (let ((e (env-extend (test-env))))
-        (env-set! e "test-sig" s)
-        ;; (str "val=" (deref test-sig)) — continuation captures (str "val=" [HOLE])
-        (let ((result (cek-run
-                        (make-cek-state
-                          (sx-parse-one "(str \"val=\" (deref test-sig))")
-                          e
-                          (list (make-reactive-reset-frame
-                                  e
-                                  (fn (v) (append! update-calls v))
-                                  true))))))
-          (assert-equal "val=5" result)))
-      ;; Change signal — should get updated string
-      (reset! s 42)
-      (assert-equal 1 (len update-calls))
-      (assert-equal "val=42" (first update-calls))
-      (scope-pop! "sx-island-scope"))))
-
-
-;; --------------------------------------------------------------------------
-;; Disposal and cleanup
-;; --------------------------------------------------------------------------
-
-(defsuite "disposal"
-  (deftest "scope cleanup unsubscribes continuation"
-    (let ((s (signal 1))
-          (update-calls (list))
-          (disposers (list)))
-      ;; 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)
-        (cek-run
-          (make-cek-state
-            (sx-parse-one "(deref test-sig)")
-            e
-            (list (make-reactive-reset-frame
-                    e
-                    (fn (v) (append! update-calls v))
-                    true)))))
-      ;; Pop scope — call all disposers
-      (scope-pop! "sx-island-scope")
-      (for-each (fn (d) (cek-call d nil)) disposers)
-      ;; Change signal — no update should fire
-      (reset! s 999)
-      (assert-equal 0 (len update-calls)))))
-
-
-;; --------------------------------------------------------------------------
-;; cek-call integration — computed/effect use cek-call dispatch
-;; --------------------------------------------------------------------------
-
-(defsuite "cek-call dispatch"
-  (deftest "cek-call invokes native function"
-    (let ((log (list)))
-      (cek-call (fn (x) (append! log x)) (list 42))
-      (assert-equal (list 42) log)))
-
-  (deftest "cek-call invokes zero-arg lambda"
-    (let ((result (cek-call (fn () (+ 1 2)) nil)))
-      (assert-equal 3 result)))
-
-  (deftest "cek-call with nil function returns nil"
-    (assert-nil (cek-call nil nil)))
-
-  (deftest "computed tracks deps via cek-call"
-    (let ((s (signal 10)))
-      (let ((c (computed (fn () (* 2 (deref s))))))
-        (assert-equal 20 (deref c))
-        (reset! s 5)
-        (assert-equal 10 (deref c)))))
-
-  (deftest "effect runs and re-runs via cek-call"
-    (let ((s (signal "a"))
-          (log (list)))
-      (effect (fn () (append! log (deref s))))
-      (assert-equal (list "a") log)
-      (reset! s "b")
-      (assert-equal (list "a" "b") log)))
-
-  (deftest "effect cleanup runs on re-trigger"
-    (let ((s (signal 0))
-          (log (list)))
-      (effect (fn ()
-        (let ((val (deref s)))
-          (append! log (str "run:" val))
-          ;; Return cleanup function
-          (fn () (append! log (str "clean:" val))))))
-      (assert-equal (list "run:0") log)
-      (reset! s 1)
-      (assert-equal (list "run:0" "clean:0" "run:1") log)))
-
-  (deftest "batch coalesces via cek-call"
-    (let ((s (signal 0))
-          (count (signal 0)))
-      (effect (fn () (do (deref s) (swap! count inc))))
-      (assert-equal 1 (deref count))
-      (batch (fn ()
-        (reset! s 1)
-        (reset! s 2)
-        (reset! s 3)))
-      ;; batch should coalesce — effect runs once, not three times
-      (assert-equal 2 (deref count)))))
-
-
-;; --------------------------------------------------------------------------
-;; CEK-native higher-order forms
-;; --------------------------------------------------------------------------
-
-(defsuite "CEK higher-order forms"
-  (deftest "map through CEK"
-    (let ((result (eval-expr-cek
-                    (sx-parse-one "(map (fn (x) (* x 2)) (list 1 2 3))")
-                    (test-env))))
-      (assert-equal (list 2 4 6) result)))
-
-  (deftest "map-indexed through CEK"
-    (let ((result (eval-expr-cek
-                    (sx-parse-one "(map-indexed (fn (i x) (+ i x)) (list 10 20 30))")
-                    (test-env))))
-      (assert-equal (list 10 21 32) result)))
-
-  (deftest "filter through CEK"
-    (let ((result (eval-expr-cek
-                    (sx-parse-one "(filter (fn (x) (> x 2)) (list 1 2 3 4 5))")
-                    (test-env))))
-      (assert-equal (list 3 4 5) result)))
-
-  (deftest "reduce through CEK"
-    (let ((result (eval-expr-cek
-                    (sx-parse-one "(reduce (fn (acc x) (+ acc x)) 0 (list 1 2 3))")
-                    (test-env))))
-      (assert-equal 6 result)))
-
-  (deftest "some through CEK"
-    (let ((result (eval-expr-cek
-                    (sx-parse-one "(some (fn (x) (> x 3)) (list 1 2 3 4 5))")
-                    (test-env))))
-      (assert-true result)))
-
-  (deftest "some returns false when none match"
-    (let ((result (eval-expr-cek
-                    (sx-parse-one "(some (fn (x) (> x 10)) (list 1 2 3))")
-                    (test-env))))
-      (assert-false result)))
-
-  (deftest "every? through CEK"
-    (let ((result (eval-expr-cek
-                    (sx-parse-one "(every? (fn (x) (> x 0)) (list 1 2 3))")
-                    (test-env))))
-      (assert-true result)))
-
-  (deftest "every? returns false on first falsy"
-    (let ((result (eval-expr-cek
-                    (sx-parse-one "(every? (fn (x) (> x 2)) (list 1 2 3))")
-                    (test-env))))
-      (assert-false result)))
-
-  (deftest "for-each through CEK"
-    (let ((log (list)))
-      (env-set! (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))
-      (assert-equal (list 1 2 3) log)))
-
-  (deftest "map on empty list"
-    (let ((result (eval-expr-cek
-                    (sx-parse-one "(map (fn (x) x) (list))")
-                    (test-env))))
-      (assert-equal (list) result))))

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/ref/test-types.sx

@@ -1,652 +0,0 @@
-;; ==========================================================================
-;; test-types.sx — Tests for the SX gradual type system
-;;
-;; Requires: test-framework.sx loaded first.
-;; Modules tested: types.sx (subtype?, infer-type, check-component, etc.)
-;;
-;; Platform functions required (beyond test framework):
-;;   All type system functions from types.sx must be loaded.
-;;   test-prim-types — a dict of primitive return types for testing.
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Subtype checking
-;; --------------------------------------------------------------------------
-
-(defsuite "subtype-basics"
-  (deftest "any accepts everything"
-    (assert-true (subtype? "number" "any"))
-    (assert-true (subtype? "string" "any"))
-    (assert-true (subtype? "nil" "any"))
-    (assert-true (subtype? "boolean" "any"))
-    (assert-true (subtype? "any" "any")))
-
-  (deftest "never is subtype of everything"
-    (assert-true (subtype? "never" "number"))
-    (assert-true (subtype? "never" "string"))
-    (assert-true (subtype? "never" "any"))
-    (assert-true (subtype? "never" "nil")))
-
-  (deftest "identical types"
-    (assert-true (subtype? "number" "number"))
-    (assert-true (subtype? "string" "string"))
-    (assert-true (subtype? "boolean" "boolean"))
-    (assert-true (subtype? "nil" "nil")))
-
-  (deftest "different base types are not subtypes"
-    (assert-false (subtype? "number" "string"))
-    (assert-false (subtype? "string" "number"))
-    (assert-false (subtype? "boolean" "number"))
-    (assert-false (subtype? "string" "boolean")))
-
-  (deftest "any is not subtype of specific type"
-    (assert-false (subtype? "any" "number"))
-    (assert-false (subtype? "any" "string"))))
-
-
-(defsuite "subtype-nullable"
-  (deftest "nil is subtype of nullable types"
-    (assert-true (subtype? "nil" "string?"))
-    (assert-true (subtype? "nil" "number?"))
-    (assert-true (subtype? "nil" "dict?"))
-    (assert-true (subtype? "nil" "boolean?")))
-
-  (deftest "base is subtype of its nullable"
-    (assert-true (subtype? "string" "string?"))
-    (assert-true (subtype? "number" "number?"))
-    (assert-true (subtype? "dict" "dict?")))
-
-  (deftest "nullable is not subtype of base"
-    (assert-false (subtype? "string?" "string"))
-    (assert-false (subtype? "number?" "number")))
-
-  (deftest "different nullable types are not subtypes"
-    (assert-false (subtype? "number" "string?"))
-    (assert-false (subtype? "string" "number?"))))
-
-
-(defsuite "subtype-unions"
-  (deftest "member is subtype of union"
-    (assert-true (subtype? "number" (list "or" "number" "string")))
-    (assert-true (subtype? "string" (list "or" "number" "string"))))
-
-  (deftest "non-member is not subtype of union"
-    (assert-false (subtype? "boolean" (list "or" "number" "string"))))
-
-  (deftest "union is subtype if all members are"
-    (assert-true (subtype? (list "or" "number" "string")
-                           (list "or" "number" "string" "boolean")))
-    (assert-true (subtype? (list "or" "number" "string") "any")))
-
-  (deftest "union is not subtype if any member is not"
-    (assert-false (subtype? (list "or" "number" "string") "number"))))
-
-
-(defsuite "subtype-list-of"
-  (deftest "list-of covariance"
-    (assert-true (subtype? (list "list-of" "number") (list "list-of" "number")))
-    (assert-true (subtype? (list "list-of" "number") (list "list-of" "any"))))
-
-  (deftest "list-of is subtype of list"
-    (assert-true (subtype? (list "list-of" "number") "list")))
-
-  (deftest "list is subtype of list-of any"
-    (assert-true (subtype? "list" (list "list-of" "any")))))
-
-
-;; --------------------------------------------------------------------------
-;; Type union
-;; --------------------------------------------------------------------------
-
-(defsuite "type-union"
-  (deftest "same types"
-    (assert-equal "number" (type-union "number" "number"))
-    (assert-equal "string" (type-union "string" "string")))
-
-  (deftest "any absorbs"
-    (assert-equal "any" (type-union "any" "number"))
-    (assert-equal "any" (type-union "number" "any")))
-
-  (deftest "never is identity"
-    (assert-equal "number" (type-union "never" "number"))
-    (assert-equal "string" (type-union "string" "never")))
-
-  (deftest "nil + base creates nullable"
-    (assert-equal "string?" (type-union "nil" "string"))
-    (assert-equal "number?" (type-union "number" "nil")))
-
-  (deftest "subtype collapses"
-    (assert-equal "string?" (type-union "string" "string?"))
-    (assert-equal "string?" (type-union "string?" "string")))
-
-  (deftest "incompatible creates union"
-    (let ((result (type-union "number" "string")))
-      (assert-true (= (type-of result) "list"))
-      (assert-equal "or" (first result))
-      (assert-true (contains? result "number"))
-      (assert-true (contains? result "string")))))
-
-
-;; --------------------------------------------------------------------------
-;; Type narrowing
-;; --------------------------------------------------------------------------
-
-(defsuite "type-narrowing"
-  (deftest "nil? narrows to nil in then branch"
-    (let ((result (narrow-type "string?" "nil?")))
-      (assert-equal "nil" (first result))
-      (assert-equal "string" (nth result 1))))
-
-  (deftest "nil? narrows any stays any"
-    (let ((result (narrow-type "any" "nil?")))
-      (assert-equal "nil" (first result))
-      (assert-equal "any" (nth result 1))))
-
-  (deftest "string? narrows to string in then branch"
-    (let ((result (narrow-type "any" "string?")))
-      (assert-equal "string" (first result))
-      ;; else branch — can't narrow any
-      (assert-equal "any" (nth result 1))))
-
-  (deftest "nil? on nil type narrows to never in else"
-    (let ((result (narrow-type "nil" "nil?")))
-      (assert-equal "nil" (first result))
-      (assert-equal "never" (nth result 1)))))
-
-
-;; --------------------------------------------------------------------------
-;; Type inference
-;; --------------------------------------------------------------------------
-
-(defsuite "infer-literals"
-  (deftest "number literal"
-    (assert-equal "number" (infer-type 42 (dict) (test-prim-types))))
-
-  (deftest "string literal"
-    (assert-equal "string" (infer-type "hello" (dict) (test-prim-types))))
-
-  (deftest "boolean literal"
-    (assert-equal "boolean" (infer-type true (dict) (test-prim-types))))
-
-  (deftest "nil"
-    (assert-equal "nil" (infer-type nil (dict) (test-prim-types)))))
-
-
-(defsuite "infer-calls"
-  (deftest "known primitive return type"
-    ;; (+ 1 2) → number
-    (let ((expr (sx-parse "(+ 1 2)")))
-      (assert-equal "number"
-        (infer-type (first expr) (dict) (test-prim-types)))))
-
-  (deftest "str returns string"
-    (let ((expr (sx-parse "(str 1 2)")))
-      (assert-equal "string"
-        (infer-type (first expr) (dict) (test-prim-types)))))
-
-  (deftest "comparison returns boolean"
-    (let ((expr (sx-parse "(= 1 2)")))
-      (assert-equal "boolean"
-        (infer-type (first expr) (dict) (test-prim-types)))))
-
-  (deftest "component call returns element"
-    (let ((expr (sx-parse "(~card :title \"hi\")")))
-      (assert-equal "element"
-        (infer-type (first expr) (dict) (test-prim-types)))))
-
-  (deftest "unknown function returns any"
-    (let ((expr (sx-parse "(unknown-fn 1 2)")))
-      (assert-equal "any"
-        (infer-type (first expr) (dict) (test-prim-types))))))
-
-
-(defsuite "infer-special-forms"
-  (deftest "if produces union of branches"
-    (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"))
-                         (= t "any"))))))
-
-  (deftest "if with no else includes nil"
-    (let ((expr (sx-parse "(if true 42)")))
-      (let ((t (infer-type (first expr) (dict) (test-prim-types))))
-        (assert-equal "number?" t))))
-
-  (deftest "when includes nil"
-    (let ((expr (sx-parse "(when true 42)")))
-      (let ((t (infer-type (first expr) (dict) (test-prim-types))))
-        (assert-equal "number?" t))))
-
-  (deftest "do returns last type"
-    (let ((expr (sx-parse "(do 1 2 \"hello\")")))
-      (assert-equal "string"
-        (infer-type (first expr) (dict) (test-prim-types)))))
-
-  (deftest "let infers binding types"
-    (let ((expr (sx-parse "(let ((x 42)) x)")))
-      (assert-equal "number"
-        (infer-type (first expr) (dict) (test-prim-types)))))
-
-  (deftest "lambda returns lambda"
-    (let ((expr (sx-parse "(fn (x) (+ x 1))")))
-      (assert-equal "lambda"
-        (infer-type (first expr) (dict) (test-prim-types))))))
-
-
-;; --------------------------------------------------------------------------
-;; Component call checking
-;; --------------------------------------------------------------------------
-
-(defsuite "check-component-calls"
-  (deftest "type mismatch produces error"
-    ;; Create a component with typed params, then check a bad call
-    (let ((env (test-env)))
-      ;; Define a typed component
-      (do
-        (define dummy-env env)
-        (defcomp ~typed-card (&key title price) (div title price))
-        (component-set-param-types! ~typed-card
-          {:title "string" :price "number"}))
-      ;; Check a call with wrong type
-      (let ((diagnostics
-              (check-component-call "~typed-card" ~typed-card
-                (rest (first (sx-parse "(~typed-card :title 42 :price \"bad\")")))
-                (dict) (test-prim-types))))
-        (assert-true (> (len diagnostics) 0))
-        (assert-equal "error" (dict-get (first diagnostics) "level")))))
-
-  (deftest "correct call produces no errors"
-    (let ((env (test-env)))
-      (do
-        (define dummy-env env)
-        (defcomp ~ok-card (&key title price) (div title price))
-        (component-set-param-types! ~ok-card
-          {:title "string" :price "number"}))
-      (let ((diagnostics
-              (check-component-call "~ok-card" ~ok-card
-                (rest (first (sx-parse "(~ok-card :title \"hi\" :price 42)")))
-                (dict) (test-prim-types))))
-        (assert-equal 0 (len diagnostics)))))
-
-  (deftest "unknown kwarg produces warning"
-    (let ((env (test-env)))
-      (do
-        (define dummy-env env)
-        (defcomp ~warn-card (&key title) (div title))
-        (component-set-param-types! ~warn-card
-          {:title "string"}))
-      (let ((diagnostics
-              (check-component-call "~warn-card" ~warn-card
-                (rest (first (sx-parse "(~warn-card :title \"hi\" :colour \"red\")")))
-                (dict) (test-prim-types))))
-        (assert-true (> (len diagnostics) 0))
-        (assert-equal "warning" (dict-get (first diagnostics) "level"))))))
-
-
-;; --------------------------------------------------------------------------
-;; Annotation syntax: (name :as type) in defcomp params
-;; --------------------------------------------------------------------------
-
-(defsuite "typed-defcomp"
-  (deftest "typed params are parsed and stored"
-    (let ((env (test-env)))
-      (defcomp ~typed-widget (&key (title :as string) (count :as number)) (div title count))
-      (let ((pt (component-param-types ~typed-widget)))
-        (assert-true (not (nil? pt)))
-        (assert-equal "string" (dict-get pt "title"))
-        (assert-equal "number" (dict-get pt "count")))))
-
-  (deftest "mixed typed and untyped params"
-    (let ((env (test-env)))
-      (defcomp ~mixed-widget (&key (title :as string) subtitle) (div title subtitle))
-      (let ((pt (component-param-types ~mixed-widget)))
-        (assert-true (not (nil? pt)))
-        (assert-equal "string" (dict-get pt "title"))
-        ;; subtitle has no annotation — should not be in param-types
-        (assert-false (has-key? pt "subtitle")))))
-
-  (deftest "untyped defcomp has nil param-types"
-    (let ((env (test-env)))
-      (defcomp ~plain-widget (&key title subtitle) (div title subtitle))
-      (assert-true (nil? (component-param-types ~plain-widget)))))
-
-  (deftest "typed component catches type error on call"
-    (let ((env (test-env)))
-      (defcomp ~strict-card (&key (title :as string) (price :as number)) (div title price))
-      ;; Call with wrong types
-      (let ((diagnostics
-              (check-component-call "~strict-card" ~strict-card
-                (rest (first (sx-parse "(~strict-card :title 42 :price \"bad\")")))
-                (dict) (test-prim-types))))
-        ;; Should have errors for both wrong-type args
-        (assert-true (>= (len diagnostics) 1))
-        (assert-equal "error" (dict-get (first diagnostics) "level")))))
-
-  (deftest "typed component passes correct call"
-    (let ((env (test-env)))
-      (defcomp ~ok-widget (&key (name :as string) (age :as number)) (div name age))
-      (let ((diagnostics
-              (check-component-call "~ok-widget" ~ok-widget
-                (rest (first (sx-parse "(~ok-widget :name \"Alice\" :age 30)")))
-                (dict) (test-prim-types))))
-        (assert-equal 0 (len diagnostics)))))
-
-  (deftest "nullable type accepts nil"
-    (let ((env (test-env)))
-      (defcomp ~nullable-widget (&key (title :as string) (subtitle :as string?)) (div title subtitle))
-      ;; Passing nil for nullable param should be fine
-      (let ((diagnostics
-              (check-component-call "~nullable-widget" ~nullable-widget
-                (rest (first (sx-parse "(~nullable-widget :title \"hi\" :subtitle nil)")))
-                (dict) (test-prim-types))))
-        (assert-equal 0 (len diagnostics))))))
-
-
-;; --------------------------------------------------------------------------
-;; Primitive call checking (Phase 5)
-;; --------------------------------------------------------------------------
-
-(defsuite "check-primitive-calls"
-  (deftest "correct types produce no errors"
-    (let ((ppt (test-prim-param-types)))
-      (let ((diagnostics
-              (check-primitive-call "+" (rest (first (sx-parse "(+ 1 2 3)")))
-                (dict) (test-prim-types) ppt nil)))
-        (assert-equal 0 (len diagnostics)))))
-
-  (deftest "string arg to numeric primitive produces error"
-    (let ((ppt (test-prim-param-types)))
-      (let ((diagnostics
-              (check-primitive-call "+" (rest (first (sx-parse "(+ 1 \"hello\")")))
-                (dict) (test-prim-types) ppt nil)))
-        (assert-true (> (len diagnostics) 0))
-        (assert-equal "error" (get (first diagnostics) "level")))))
-
-  (deftest "number arg to string primitive produces error"
-    (let ((ppt (test-prim-param-types)))
-      (let ((diagnostics
-              (check-primitive-call "upper" (rest (first (sx-parse "(upper 42)")))
-                (dict) (test-prim-types) ppt nil)))
-        (assert-true (> (len diagnostics) 0))
-        (assert-equal "error" (get (first diagnostics) "level")))))
-
-  (deftest "positional and rest params both checked"
-    ;; (- "bad" 1) — first positional arg is string, expects number
-    (let ((ppt (test-prim-param-types)))
-      (let ((diagnostics
-              (check-primitive-call "-" (rest (first (sx-parse "(- \"bad\" 1)")))
-                (dict) (test-prim-types) ppt nil)))
-        (assert-true (> (len diagnostics) 0)))))
-
-  (deftest "dict arg to keys is valid"
-    (let ((ppt (test-prim-param-types)))
-      (let ((diagnostics
-              (check-primitive-call "keys" (rest (first (sx-parse "(keys {:a 1})")))
-                (dict) (test-prim-types) ppt nil)))
-        (assert-equal 0 (len diagnostics)))))
-
-  (deftest "number arg to keys produces error"
-    (let ((ppt (test-prim-param-types)))
-      (let ((diagnostics
-              (check-primitive-call "keys" (rest (first (sx-parse "(keys 42)")))
-                (dict) (test-prim-types) ppt nil)))
-        (assert-true (> (len diagnostics) 0)))))
-
-  (deftest "variable with known type passes check"
-    ;; Variable n is known to be number in type-env
-    (let ((ppt (test-prim-param-types))
-          (tenv {"n" "number"}))
-      (let ((diagnostics
-              (check-primitive-call "inc" (rest (first (sx-parse "(inc n)")))
-                tenv (test-prim-types) ppt nil)))
-        (assert-equal 0 (len diagnostics)))))
-
-  (deftest "variable with wrong type fails check"
-    ;; Variable s is known to be string in type-env
-    (let ((ppt (test-prim-param-types))
-          (tenv {"s" "string"}))
-      (let ((diagnostics
-              (check-primitive-call "inc" (rest (first (sx-parse "(inc s)")))
-                tenv (test-prim-types) ppt nil)))
-        (assert-true (> (len diagnostics) 0)))))
-
-  (deftest "any-typed variable skips check"
-    ;; Variable x has type any — should not produce errors
-    (let ((ppt (test-prim-param-types))
-          (tenv {"x" "any"}))
-      (let ((diagnostics
-              (check-primitive-call "upper" (rest (first (sx-parse "(upper x)")))
-                tenv (test-prim-types) ppt nil)))
-        (assert-equal 0 (len diagnostics)))))
-
-  (deftest "body-walk catches primitive errors in component"
-    ;; Manually build a component and check it via check-body-walk directly
-    (let ((ppt (test-prim-param-types))
-          (body (first (sx-parse "(div (+ name 1))")))
-          (type-env {"name" "string"})
-          (diagnostics (list)))
-      (check-body-walk body "~bad-math" type-env (test-prim-types) ppt (test-env) diagnostics nil nil)
-      (assert-true (> (len diagnostics) 0))
-      (assert-equal "error" (get (first diagnostics) "level")))))
-
-
-;; --------------------------------------------------------------------------
-;; deftype — type aliases
-;; --------------------------------------------------------------------------
-
-(defsuite "deftype-alias"
-  (deftest "simple alias resolves"
-    (let ((registry {"price" {:name "price" :params () :body "number"}}))
-      (assert-equal "number" (resolve-type "price" registry))))
-
-  (deftest "alias chain resolves"
-    (let ((registry {"price" {:name "price" :params () :body "number"}
-                     "cost" {:name "cost" :params () :body "price"}}))
-      (assert-equal "number" (resolve-type "cost" registry))))
-
-  (deftest "unknown type passes through"
-    (let ((registry {"price" {:name "price" :params () :body "number"}}))
-      (assert-equal "string" (resolve-type "string" registry))))
-
-  (deftest "subtype-resolved? works through alias"
-    (let ((registry {"price" {:name "price" :params () :body "number"}}))
-      (assert-true (subtype-resolved? "price" "number" registry))
-      (assert-true (subtype-resolved? "number" "price" registry)))))
-
-
-;; --------------------------------------------------------------------------
-;; deftype — union types
-;; --------------------------------------------------------------------------
-
-(defsuite "deftype-union"
-  (deftest "union resolves"
-    (let ((registry {"status" {:name "status" :params () :body ("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")}}))
-      (assert-true (subtype-resolved? "string" "status" registry))
-      (assert-true (subtype-resolved? "number" "status" registry))
-      (assert-false (subtype-resolved? "boolean" "status" registry)))))
-
-
-;; --------------------------------------------------------------------------
-;; deftype — record types
-;; --------------------------------------------------------------------------
-
-(defsuite "deftype-record"
-  (deftest "record resolves to dict"
-    (let ((registry {"card-props" {:name "card-props" :params ()
-                     :body {"title" "string" "price" "number"}}}))
-      (let ((resolved (resolve-type "card-props" registry)))
-        (assert-equal "dict" (type-of resolved))
-        (assert-equal "string" (get resolved "title"))
-        (assert-equal "number" (get resolved "price")))))
-
-  (deftest "record structural subtyping"
-    (let ((registry {"card-props" {:name "card-props" :params ()
-                     :body {"title" "string" "price" "number"}}
-                     "titled" {:name "titled" :params ()
-                     :body {"title" "string"}}}))
-      ;; card-props has title+price, titled has just title
-      ;; card-props <: titled (has all required fields)
-      (assert-true (subtype-resolved? "card-props" "titled" registry))))
-
-  (deftest "get infers field type from record"
-    (let ((registry {"card-props" {:name "card-props" :params ()
-                     :body {"title" "string" "price" "number"}}})
-          (type-env {"d" "card-props"})
-          (expr (first (sx-parse "(get d :title)"))))
-      (assert-equal "string"
-        (infer-type expr type-env (test-prim-types) registry)))))
-
-
-;; --------------------------------------------------------------------------
-;; deftype — parameterized types
-;; --------------------------------------------------------------------------
-
-(defsuite "deftype-parameterized"
-  (deftest "maybe instantiation"
-    (let ((registry {"maybe" {:name "maybe" :params ("a")
-                     :body ("or" "a" "nil")}}))
-      (let ((resolved (resolve-type (list "maybe" "string") registry)))
-        (assert-true (= (type-of resolved) "list"))
-        (assert-equal "or" (first resolved))
-        (assert-true (contains? resolved "string"))
-        (assert-true (contains? resolved "nil")))))
-
-  (deftest "subtype through parameterized type"
-    (let ((registry {"maybe" {:name "maybe" :params ("a")
-                     :body ("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"))))
-      (assert-equal "or" (first result))
-      (assert-true (contains? result "number"))
-      (assert-true (contains? result "nil")))))
-
-
-;; --------------------------------------------------------------------------
-;; defeffect — effect basics
-;; --------------------------------------------------------------------------
-
-(defsuite "defeffect-basics"
-  (deftest "get-effects returns nil for unannotated"
-    (let ((anns {"fetch" ("io")}))
-      (assert-true (nil? (get-effects "unknown" anns)))))
-
-  (deftest "get-effects returns effects for annotated"
-    (let ((anns {"fetch" ("io")}))
-      (assert-equal (list "io") (get-effects "fetch" anns))))
-
-  (deftest "nil annotations returns nil"
-    (assert-true (nil? (get-effects "anything" nil)))))
-
-
-;; --------------------------------------------------------------------------
-;; defeffect — effect checking
-;; --------------------------------------------------------------------------
-
-(defsuite "effect-checking"
-  (deftest "pure cannot call io"
-    (let ((anns {"~pure-comp" () "fetch" ("io")}))
-      (let ((diagnostics (check-effect-call "fetch" (list) anns "~pure-comp")))
-        (assert-true (> (len diagnostics) 0))
-        (assert-equal "error" (get (first diagnostics) "level")))))
-
-  (deftest "io context allows io"
-    (let ((anns {"~io-comp" ("io") "fetch" ("io")}))
-      (let ((diagnostics (check-effect-call "fetch" (list "io") anns "~io-comp")))
-        (assert-equal 0 (len diagnostics)))))
-
-  (deftest "unannotated caller allows everything"
-    (let ((anns {"fetch" ("io")}))
-      (let ((diagnostics (check-effect-call "fetch" nil anns "~unknown")))
-        (assert-equal 0 (len diagnostics)))))
-
-  (deftest "unannotated callee skips check"
-    (let ((anns {"~pure-comp" ()}))
-      (let ((diagnostics (check-effect-call "unknown-fn" (list) anns "~pure-comp")))
-        (assert-equal 0 (len diagnostics))))))
-
-
-;; --------------------------------------------------------------------------
-;; defeffect — subset checking
-;; --------------------------------------------------------------------------
-
-(defsuite "effect-subset"
-  (deftest "empty is subset of anything"
-    (assert-true (effects-subset? (list) (list "io")))
-    (assert-true (effects-subset? (list) (list))))
-
-  (deftest "io is subset of io"
-    (assert-true (effects-subset? (list "io") (list "io" "async"))))
-
-  (deftest "io is not subset of pure"
-    (assert-false (effects-subset? (list "io") (list))))
-
-  (deftest "nil callee skips check"
-    (assert-true (effects-subset? nil (list))))
-
-  (deftest "nil caller allows all"
-    (assert-true (effects-subset? (list "io") nil))))
-
-
-;; --------------------------------------------------------------------------
-;; build-effect-annotations
-;; --------------------------------------------------------------------------
-
-(defsuite "build-effect-annotations"
-  (deftest "builds annotations from io declarations"
-    (let ((decls (list {"name" "fetch"} {"name" "save!"}))
-          (anns (build-effect-annotations decls)))
-      (assert-equal (list "io") (get anns "fetch"))
-      (assert-equal (list "io") (get anns "save!"))))
-
-  (deftest "skips entries without name"
-    (let ((decls (list {"name" "fetch"} {"other" "x"}))
-          (anns (build-effect-annotations decls)))
-      (assert-true (has-key? anns "fetch"))
-      (assert-false (has-key? anns "other"))))
-
-  (deftest "empty declarations produce empty dict"
-    (let ((anns (build-effect-annotations (list))))
-      (assert-equal 0 (len (keys anns))))))
-
-
-;; --------------------------------------------------------------------------
-;; 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))))
-
-  (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))))
-
-  (deftest "unannotated component skips check"
-    (let ((anns {"fetch" ("io")})
-          (diagnostics (check-component-effects "~eff-unannot-card" (test-env) anns)))
-      (assert-equal 0 (len diagnostics)))))

shared/sx/ref/types.sx

@@ -1,917 +0,0 @@
-;; ==========================================================================
-;; types.sx — Gradual type system for SX
-;;
-;; Registration-time type checking: zero runtime cost.
-;; Annotations are optional — unannotated code defaults to `any`.
-;;
-;; Depends on: eval.sx (type-of, component accessors, env ops)
-;;             primitives.sx, boundary.sx (return type declarations)
-;;
-;; Platform interface (from eval.sx, already provided):
-;;   (type-of x)            → type string
-;;   (symbol-name s)        → string
-;;   (keyword-name k)       → string
-;;   (component-body c)     → AST
-;;   (component-params c)   → list of param name strings
-;;   (component-has-children c) → boolean
-;;   (env-get env k)        → value or nil
-;;
-;; New platform functions for types.sx:
-;;   (component-param-types c)  → dict {param-name → type} or nil
-;;   (component-set-param-types! c d) → store param types on component
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 1. Type representation
-;; --------------------------------------------------------------------------
-;; Types are plain SX values:
-;;   - Strings for base types: "number", "string", "boolean", "nil",
-;;     "symbol", "keyword", "element", "any", "never"
-;;   - Nullable shorthand: "string?", "number?", "dict?", "boolean?"
-;;     → equivalent to (or string nil) etc.
-;;   - Lists for compound types:
-;;     (or t1 t2 ...)         — union
-;;     (list-of t)            — homogeneous list
-;;     (dict-of tk tv)        — typed dict
-;;     (-> t1 t2 ... treturn) — function type (last is return)
-
-;; Base type names
-(define base-types
-  (list "number" "string" "boolean" "nil" "symbol" "keyword"
-        "element" "any" "never" "list" "dict"
-        "lambda" "component" "island" "macro" "signal"))
-
-
-;; --------------------------------------------------------------------------
-;; 2. Type predicates
-;; --------------------------------------------------------------------------
-
-(define type-any?
-  (fn (t) (= t "any")))
-
-(define type-never?
-  (fn (t) (= t "never")))
-
-(define type-nullable?
-  (fn (t)
-    ;; A type is nullable if it's "any", "nil", a "?" shorthand, or
-    ;; a union containing "nil".
-    (if (= t "any") true
-      (if (= t "nil") true
-        (if (and (= (type-of t) "string") (ends-with? t "?")) true
-          (if (and (= (type-of t) "list")
-                   (not (empty? t))
-                   (= (first t) "or"))
-            (contains? (rest t) "nil")
-            false))))))
-
-(define nullable-base
-  (fn (t)
-    ;; Strip "?" from nullable shorthand: "string?" → "string"
-    (if (and (= (type-of t) "string")
-             (ends-with? t "?")
-             (not (= t "?")))
-      (slice t 0 (- (string-length t) 1))
-      t)))
-
-
-;; --------------------------------------------------------------------------
-;; 3. Subtype checking
-;; --------------------------------------------------------------------------
-;; subtype?(a, b) — is type `a` assignable to type `b`?
-
-(define subtype?
-  (fn (a b)
-    ;; any accepts everything
-    (if (type-any? b) true
-      ;; never is subtype of everything
-      (if (type-never? a) true
-        ;; any is not a subtype of a specific type
-        (if (type-any? a) false
-          ;; identical types
-          (if (= a b) true
-            ;; nil is subtype of nullable types
-            (if (= a "nil")
-              (type-nullable? b)
-              ;; nullable shorthand: "string?" = (or string nil)
-              (if (and (= (type-of b) "string") (ends-with? b "?"))
-                (let ((base (nullable-base b)))
-                  (or (= a base) (= a "nil")))
-                ;; a is a union: (or t1 t2 ...) <: b if ALL members <: b
-                ;; Must check before b-union — (or A B) <: (or A B C) needs
-                ;; each member of a checked against the full union b.
-                (if (and (= (type-of a) "list")
-                         (not (empty? a))
-                         (= (first a) "or"))
-                  (every? (fn (member) (subtype? member b)) (rest a))
-                  ;; union: a <: (or t1 t2 ...) if a <: any member
-                  (if (and (= (type-of b) "list")
-                           (not (empty? b))
-                           (= (first b) "or"))
-                    (some (fn (member) (subtype? a member)) (rest b))
-                    ;; list-of covariance
-                    (if (and (= (type-of a) "list") (= (type-of b) "list")
-                             (= (len a) 2) (= (len b) 2)
-                             (= (first a) "list-of") (= (first b) "list-of"))
-                      (subtype? (nth a 1) (nth b 1))
-                      ;; "list" <: (list-of any)
-                      (if (and (= a "list")
-                               (= (type-of b) "list")
-                               (= (len b) 2)
-                               (= (first b) "list-of"))
-                        (type-any? (nth b 1))
-                        ;; (list-of t) <: "list"
-                        (if (and (= (type-of a) "list")
-                                 (= (len a) 2)
-                                 (= (first a) "list-of")
-                                 (= b "list"))
-                          true
-                          ;; "element" is subtype of "string?" (rendered HTML)
-                          false)))))))))))))
-
-
-;; --------------------------------------------------------------------------
-;; 4. Type union
-;; --------------------------------------------------------------------------
-
-(define type-union
-  (fn (a b)
-    ;; Compute the smallest type that encompasses both a and b.
-    (if (= a b) a
-      (if (type-any? a) "any"
-        (if (type-any? b) "any"
-          (if (type-never? a) b
-            (if (type-never? b) a
-              (if (subtype? a b) b
-                (if (subtype? b a) a
-                  ;; neither is subtype — create a union
-                  (if (= a "nil")
-                    ;; nil + string → string?
-                    (if (and (= (type-of b) "string")
-                             (not (ends-with? b "?")))
-                      (str b "?")
-                      (list "or" a b))
-                    (if (= b "nil")
-                      (if (and (= (type-of a) "string")
-                               (not (ends-with? a "?")))
-                        (str a "?")
-                        (list "or" a b))
-                      (list "or" a b))))))))))))
-
-
-;; --------------------------------------------------------------------------
-;; 5. Type narrowing
-;; --------------------------------------------------------------------------
-
-(define narrow-type
-  (fn (t (predicate-name :as string))
-    ;; Narrow type based on a predicate test in a truthy branch.
-    ;; (if (nil? x) ..then.. ..else..) → in else, x excludes nil.
-    ;; Returns (narrowed-then narrowed-else).
-    (if (= predicate-name "nil?")
-      (list "nil" (narrow-exclude-nil t))
-      (if (= predicate-name "string?")
-        (list "string" (narrow-exclude t "string"))
-        (if (= predicate-name "number?")
-          (list "number" (narrow-exclude t "number"))
-          (if (= predicate-name "list?")
-            (list "list" (narrow-exclude t "list"))
-            (if (= predicate-name "dict?")
-              (list "dict" (narrow-exclude t "dict"))
-              (if (= predicate-name "boolean?")
-                (list "boolean" (narrow-exclude t "boolean"))
-                ;; Unknown predicate — no narrowing
-                (list t t)))))))))
-
-
-(define narrow-exclude-nil
-  (fn (t)
-    ;; Remove nil from a type.
-    (if (= t "nil") "never"
-      (if (= t "any") "any"   ;; can't narrow any
-        (if (and (= (type-of t) "string") (ends-with? t "?"))
-          (nullable-base t)
-          (if (and (= (type-of t) "list")
-                   (not (empty? t))
-                   (= (first t) "or"))
-            (let ((members (filter (fn (m) (not (= m "nil"))) (rest t))))
-              (if (= (len members) 1) (first members)
-                (if (empty? members) "never"
-                  (cons "or" members))))
-            t))))))
-
-
-(define narrow-exclude
-  (fn (t excluded)
-    ;; Remove a specific type from a union.
-    (if (= t excluded) "never"
-      (if (= t "any") "any"
-        (if (and (= (type-of t) "list")
-                 (not (empty? t))
-                 (= (first t) "or"))
-          (let ((members (filter (fn (m) (not (= m excluded))) (rest t))))
-            (if (= (len members) 1) (first members)
-              (if (empty? members) "never"
-                (cons "or" members))))
-          t)))))
-
-
-;; --------------------------------------------------------------------------
-;; 6. Type inference
-;; --------------------------------------------------------------------------
-;; infer-type walks an AST node and returns its inferred type.
-;; type-env is a dict mapping variable names → types.
-
-(define infer-type
-  (fn (node (type-env :as dict) (prim-types :as dict) type-registry)
-    (let ((kind (type-of node)))
-      (if (= kind "number")  "number"
-      (if (= kind "string")  "string"
-      (if (= kind "boolean") "boolean"
-      (if (nil? node)         "nil"
-      (if (= kind "keyword") "keyword"
-      (if (= kind "symbol")
-        (let ((name (symbol-name node)))
-          ;; Look up in type env
-          (if (has-key? type-env name)
-            (get type-env name)
-            ;; Builtins
-            (if (= name "true") "boolean"
-              (if (= name "false") "boolean"
-                (if (= name "nil") "nil"
-                  ;; Check primitive return types
-                  (if (has-key? prim-types name)
-                    (get prim-types name)
-                    "any"))))))
-      (if (= kind "dict") "dict"
-      (if (= kind "list")
-        (infer-list-type node type-env prim-types type-registry)
-        "any")))))))))))
-
-
-(define infer-list-type
-  (fn (node (type-env :as dict) (prim-types :as dict) type-registry)
-    ;; Infer type of a list expression (function call, special form, etc.)
-    (if (empty? node) "list"
-      (let ((head (first node))
-            (args (rest node)))
-        (if (not (= (type-of head) "symbol"))
-          "any"   ;; complex head — can't infer
-          (let ((name (symbol-name head)))
-            ;; Special forms
-            (if (= name "if")
-              (infer-if-type args type-env prim-types type-registry)
-            (if (= name "when")
-              (if (>= (len args) 2)
-                (type-union (infer-type (last args) type-env prim-types type-registry) "nil")
-                "nil")
-            (if (or (= name "cond") (= name "case"))
-              "any"   ;; complex — could be refined later
-            (if (= name "let")
-              (infer-let-type args type-env prim-types type-registry)
-            (if (or (= name "do") (= name "begin"))
-              (if (empty? args) "nil"
-                (infer-type (last args) type-env prim-types type-registry))
-            (if (or (= name "lambda") (= name "fn"))
-              "lambda"
-            (if (= name "and")
-              (if (empty? args) "boolean"
-                (infer-type (last args) type-env prim-types type-registry))
-            (if (= name "or")
-              (if (empty? args) "boolean"
-                ;; or returns first truthy — union of all args
-                (reduce type-union "never"
-                  (map (fn (a) (infer-type a type-env prim-types type-registry)) args)))
-            (if (= name "map")
-              ;; map returns a list
-              (if (>= (len args) 2)
-                (let ((fn-type (infer-type (first args) type-env prim-types type-registry)))
-                  ;; If the fn's return type is known, produce (list-of return-type)
-                  (if (and (= (type-of fn-type) "list")
-                           (= (first fn-type) "->"))
-                    (list "list-of" (last fn-type))
-                    "list"))
-                "list")
-            (if (= name "filter")
-              ;; filter preserves element type
-              (if (>= (len args) 2)
-                (infer-type (nth args 1) type-env prim-types type-registry)
-                "list")
-            (if (= name "reduce")
-              ;; reduce returns the accumulator type — too complex to infer
-              "any"
-            (if (= name "list")
-              "list"
-            (if (= name "dict")
-              "dict"
-            (if (= name "quote")
-              "any"
-            (if (= name "str")
-              "string"
-            (if (= name "not")
-              "boolean"
-            (if (= name "get")
-              ;; get — resolve record field type from type registry
-              (if (and (>= (len args) 2) (not (nil? type-registry)))
-                (let ((dict-type (infer-type (first args) type-env prim-types type-registry))
-                      (key-arg (nth args 1))
-                      (key-name (cond
-                                  (= (type-of key-arg) "keyword") (keyword-name key-arg)
-                                  (= (type-of key-arg) "string") key-arg
-                                  :else nil)))
-                  (if (and key-name
-                           (= (type-of dict-type) "string")
-                           (has-key? type-registry dict-type))
-                    (let ((resolved (resolve-type dict-type type-registry)))
-                      (if (and (= (type-of resolved) "dict")
-                               (has-key? resolved key-name))
-                        (get resolved key-name)
-                        "any"))
-                    "any"))
-                "any")
-            (if (starts-with? name "~")
-              "element"   ;; component call
-              ;; Regular function call: look up return type
-              (if (has-key? prim-types name)
-                (get prim-types name)
-                "any")))))))))))))))))))))))))
-
-
-(define infer-if-type
-  (fn ((args :as list) (type-env :as dict) (prim-types :as dict) type-registry)
-    ;; (if test then else?) → union of then and else types
-    (if (< (len args) 2) "nil"
-      (let ((then-type (infer-type (nth args 1) type-env prim-types type-registry)))
-        (if (>= (len args) 3)
-          (type-union then-type (infer-type (nth args 2) type-env prim-types type-registry))
-          (type-union then-type "nil"))))))
-
-
-(define infer-let-type
-  (fn ((args :as list) (type-env :as dict) (prim-types :as dict) type-registry)
-    ;; (let ((x expr) ...) body) → type of body in extended type-env
-    (if (< (len args) 2) "nil"
-      (let ((bindings (first args))
-            (body (last args))
-            (extended (merge type-env (dict))))
-        ;; Add binding types
-        (for-each
-          (fn (binding)
-            (when (and (= (type-of binding) "list") (>= (len binding) 2))
-              (let ((name (if (= (type-of (first binding)) "symbol")
-                            (symbol-name (first binding))
-                            (str (first binding))))
-                    (val-type (infer-type (nth binding 1) extended prim-types type-registry)))
-                (dict-set! extended name val-type))))
-          bindings)
-        (infer-type body extended prim-types type-registry)))))
-
-
-;; --------------------------------------------------------------------------
-;; 7. Diagnostic types
-;; --------------------------------------------------------------------------
-;; Diagnostics are dicts:
-;;   {:level "error"|"warning"|"info"
-;;    :message "human-readable explanation"
-;;    :component "~name" (or nil for top-level)
-;;    :expr <the offending AST node>}
-
-(define make-diagnostic
-  (fn ((level :as string) (message :as string) component expr)
-    {:level level
-     :message message
-     :component component
-     :expr expr}))
-
-
-;; --------------------------------------------------------------------------
-;; 8. Call-site checking
-;; --------------------------------------------------------------------------
-
-(define check-primitive-call
-  (fn ((name :as string) (args :as list) (type-env :as dict) (prim-types :as dict) prim-param-types (comp-name :as string) type-registry)
-    ;; Check a primitive call site against declared param types.
-    ;; prim-param-types is a dict: {prim-name → {:positional [...] :rest-type type-or-nil}}
-    ;; Each positional entry is a list (name type-or-nil).
-    ;; Returns list of diagnostics.
-    (let ((diagnostics (list)))
-      (when (and (not (nil? prim-param-types))
-                 (has-key? prim-param-types name))
-        (let ((sig (get prim-param-types name))
-              (positional (get sig "positional"))
-              (rest-type (get sig "rest-type")))
-          ;; Check each positional arg
-          (for-each
-            (fn (idx)
-              (when (< idx (len args))
-                (if (< idx (len positional))
-                  ;; Positional param — check against declared type
-                  (let ((param-info (nth positional idx))
-                        (arg-expr (nth args idx)))
-                    (let ((expected-type (nth param-info 1)))
-                      (when (not (nil? expected-type))
-                        (let ((actual (infer-type arg-expr type-env prim-types type-registry)))
-                          (when (and (not (type-any? expected-type))
-                                     (not (type-any? actual))
-                                     (not (subtype-resolved? actual expected-type type-registry)))
-                            (append! diagnostics
-                              (make-diagnostic "error"
-                                (str "Argument " (+ idx 1) " of `" name
-                                     "` expects " expected-type ", got " actual)
-                                comp-name arg-expr)))))))
-                  ;; Rest param — check against rest-type
-                  (when (not (nil? rest-type))
-                    (let ((arg-expr (nth args idx))
-                          (actual (infer-type arg-expr type-env prim-types type-registry)))
-                      (when (and (not (type-any? rest-type))
-                                 (not (type-any? actual))
-                                 (not (subtype-resolved? actual rest-type type-registry)))
-                        (append! diagnostics
-                          (make-diagnostic "error"
-                            (str "Argument " (+ idx 1) " of `" name
-                                 "` expects " rest-type ", got " actual)
-                            comp-name arg-expr))))))))
-            (range 0 (len args) 1))))
-      diagnostics)))
-
-
-(define check-component-call
-  (fn ((comp-name :as string) (comp :as component) (call-args :as list) (type-env :as dict) (prim-types :as dict) type-registry)
-    ;; Check a component call site against its declared param types.
-    ;; comp is the component value, call-args is the list of args
-    ;; from the call site (after the component name).
-    (let ((diagnostics (list))
-          (param-types (component-param-types comp))
-          (params (component-params comp)))
-      (when (and (not (nil? param-types))
-                 (not (empty? (keys param-types))))
-        ;; Parse keyword args from call site
-        (let ((i 0)
-              (provided-keys (list)))
-          (for-each
-            (fn (idx)
-              (when (< idx (len call-args))
-                (let ((arg (nth call-args idx)))
-                  (when (= (type-of arg) "keyword")
-                    (let ((key-name (keyword-name arg)))
-                      (append! provided-keys key-name)
-                      (when (< (+ idx 1) (len call-args))
-                        (let ((val-expr (nth call-args (+ idx 1))))
-                          ;; Check type of value against declared param type
-                          (when (has-key? param-types key-name)
-                            (let ((expected (get param-types key-name))
-                                  (actual (infer-type val-expr type-env prim-types type-registry)))
-                              (when (and (not (type-any? expected))
-                                         (not (type-any? actual))
-                                         (not (subtype-resolved? actual expected type-registry)))
-                                (append! diagnostics
-                                  (make-diagnostic "error"
-                                    (str "Keyword :" key-name " of " comp-name
-                                         " expects " expected ", got " actual)
-                                    comp-name val-expr))))))))))))
-            (range 0 (len call-args) 1))
-
-          ;; Check for missing required params (those with declared types)
-          (for-each
-            (fn (param-name)
-              (when (and (has-key? param-types param-name)
-                         (not (contains? provided-keys param-name))
-                         (not (type-nullable? (get param-types param-name))))
-                (append! diagnostics
-                  (make-diagnostic "warning"
-                    (str "Required param :" param-name " of " comp-name " not provided")
-                    comp-name nil))))
-            params)
-
-          ;; Check for unknown kwargs
-          (for-each
-            (fn (key)
-              (when (not (contains? params key))
-                (append! diagnostics
-                  (make-diagnostic "warning"
-                    (str "Unknown keyword :" key " passed to " comp-name)
-                    comp-name nil))))
-            provided-keys)))
-      diagnostics)))
-
-
-;; --------------------------------------------------------------------------
-;; 9. AST walker — check a component body
-;; --------------------------------------------------------------------------
-
-(define check-body-walk
-  (fn (node (comp-name :as string) (type-env :as dict) (prim-types :as dict) prim-param-types env (diagnostics :as list) type-registry effect-annotations)
-    ;; Recursively walk an AST and collect diagnostics.
-    ;; prim-param-types: dict of {name → {:positional [...] :rest-type t}} or nil
-    ;; type-registry: dict of {type-name → type-def} or nil
-    ;; effect-annotations: dict of {fn-name → effect-list} or nil
-    (let ((kind (type-of node)))
-      (when (= kind "list")
-        (when (not (empty? node))
-          (let ((head (first node))
-                (args (rest node)))
-            ;; Check calls when head is a symbol
-            (when (= (type-of head) "symbol")
-              (let ((name (symbol-name head)))
-                ;; Component call
-                (when (starts-with? name "~")
-                  (let ((comp-val (env-get env name)))
-                    (when (= (type-of comp-val) "component")
-                      (for-each
-                        (fn (d) (append! diagnostics d))
-                        (check-component-call name comp-val args
-                          type-env prim-types type-registry))))
-                  ;; Effect check for component calls
-                  (when (not (nil? effect-annotations))
-                    (let ((caller-effects (get-effects comp-name effect-annotations)))
-                      (for-each
-                        (fn (d) (append! diagnostics d))
-                        (check-effect-call name caller-effects effect-annotations comp-name)))))
-
-                ;; Primitive call — check param types
-                (when (and (not (starts-with? name "~"))
-                           (not (nil? prim-param-types))
-                           (has-key? prim-param-types name))
-                  (for-each
-                    (fn (d) (append! diagnostics d))
-                    (check-primitive-call name args type-env prim-types
-                      prim-param-types comp-name type-registry)))
-
-                ;; Effect check for function calls
-                (when (and (not (starts-with? name "~"))
-                           (not (nil? effect-annotations)))
-                  (let ((caller-effects (get-effects comp-name effect-annotations)))
-                    (for-each
-                      (fn (d) (append! diagnostics d))
-                      (check-effect-call name caller-effects effect-annotations comp-name))))
-
-                ;; Recurse into let with extended type env
-                (when (or (= name "let") (= name "let*"))
-                  (when (>= (len args) 2)
-                    (let ((bindings (first args))
-                          (body-exprs (rest args))
-                          (extended (merge type-env (dict))))
-                      (for-each
-                        (fn (binding)
-                          (when (and (= (type-of binding) "list")
-                                     (>= (len binding) 2))
-                            (let ((bname (if (= (type-of (first binding)) "symbol")
-                                           (symbol-name (first binding))
-                                           (str (first binding))))
-                                  (val-type (infer-type (nth binding 1) extended prim-types type-registry)))
-                              (dict-set! extended bname val-type))))
-                        bindings)
-                      (for-each
-                        (fn (body)
-                          (check-body-walk body comp-name extended prim-types prim-param-types env diagnostics type-registry effect-annotations))
-                        body-exprs))))
-
-                ;; Recurse into define with type binding
-                (when (= name "define")
-                  (when (>= (len args) 2)
-                    (let ((def-name (if (= (type-of (first args)) "symbol")
-                                     (symbol-name (first args))
-                                     nil))
-                          (def-val (nth args 1)))
-                      (when def-name
-                        (dict-set! type-env def-name
-                          (infer-type def-val type-env prim-types type-registry)))
-                      (check-body-walk def-val comp-name type-env prim-types prim-param-types env diagnostics type-registry effect-annotations))))))
-
-            ;; Recurse into all child expressions
-            (for-each
-              (fn (child)
-                (check-body-walk child comp-name type-env prim-types prim-param-types env diagnostics type-registry effect-annotations))
-              args)))))))
-
-
-;; --------------------------------------------------------------------------
-;; 10. Check a single component
-;; --------------------------------------------------------------------------
-
-(define check-component
-  (fn ((comp-name :as string) env (prim-types :as dict) prim-param-types type-registry effect-annotations)
-    ;; Type-check a component's body. Returns list of diagnostics.
-    ;; prim-param-types: dict of param type info, or nil to skip primitive checking.
-    ;; type-registry: dict of {type-name → type-def} or nil
-    ;; effect-annotations: dict of {fn-name → effect-list} or nil
-    (let ((comp (env-get env comp-name))
-          (diagnostics (list)))
-      (when (= (type-of comp) "component")
-        (let ((body (component-body comp))
-              (params (component-params comp))
-              (param-types (component-param-types comp))
-              ;; Build initial type env from component params
-              (type-env (dict)))
-          ;; Add param types (annotated or default to any)
-          (for-each
-            (fn (p)
-              (dict-set! type-env p
-                (if (and (not (nil? param-types))
-                         (has-key? param-types p))
-                  (get param-types p)
-                  "any")))
-            params)
-          ;; Add children as (list-of element) if component has children
-          (when (component-has-children comp)
-            (dict-set! type-env "children" (list "list-of" "element")))
-
-          (check-body-walk body comp-name type-env prim-types prim-param-types env diagnostics type-registry effect-annotations)))
-      diagnostics)))
-
-
-;; --------------------------------------------------------------------------
-;; 11. Check all components in an environment
-;; --------------------------------------------------------------------------
-
-(define check-all
-  (fn (env (prim-types :as dict) prim-param-types type-registry effect-annotations)
-    ;; Type-check every component in the environment.
-    ;; prim-param-types: dict of param type info, or nil to skip primitive checking.
-    ;; type-registry: dict of {type-name → type-def} or nil
-    ;; effect-annotations: dict of {fn-name → effect-list} or nil
-    ;; Returns list of all diagnostics.
-    (let ((all-diagnostics (list)))
-      (for-each
-        (fn (name)
-          (let ((val (env-get env name)))
-            (when (= (type-of val) "component")
-              (for-each
-                (fn (d) (append! all-diagnostics d))
-                (check-component name env prim-types prim-param-types type-registry effect-annotations)))))
-        (keys env))
-      all-diagnostics)))
-
-
-;; --------------------------------------------------------------------------
-;; 12. Build primitive type registry
-;; --------------------------------------------------------------------------
-;; Builds a dict mapping primitive-name → return-type from
-;; the declarations parsed by boundary_parser.py.
-;; This is called by the host at startup with the parsed declarations.
-
-(define build-type-registry
-  (fn ((prim-declarations :as list) (io-declarations :as list))
-    ;; Both are lists of dicts: {:name "+" :returns "number" :params (...)}
-    ;; Returns a flat dict: {"+" "number", "str" "string", ...}
-    (let ((registry (dict)))
-      (for-each
-        (fn (decl)
-          (let ((name (get decl "name"))
-                (returns (get decl "returns")))
-            (when (and (not (nil? name)) (not (nil? returns)))
-              (dict-set! registry name returns))))
-        prim-declarations)
-      (for-each
-        (fn (decl)
-          (let ((name (get decl "name"))
-                (returns (get decl "returns")))
-            (when (and (not (nil? name)) (not (nil? returns)))
-              (dict-set! registry name returns))))
-        io-declarations)
-      registry)))
-
-
-;; --------------------------------------------------------------------------
-;; 13. User-defined types (deftype)
-;; --------------------------------------------------------------------------
-;; Type definitions are plain dicts: {:name "price" :params [] :body "number"}
-;; Stored in env under "*type-registry*" mapping type names to defs.
-
-;; make-type-def and normalize-type-body are defined in eval.sx
-;; (always compiled). They're available when types.sx is compiled as a spec module.
-
-;; -- Standard type definitions --
-;; These define the record types used throughout the type system itself.
-
-;; Universal: nullable shorthand
-(deftype (maybe a) (union a nil))
-
-;; A type definition entry in the registry
-(deftype type-def
-  {:name string :params list :body any})
-
-;; A diagnostic produced by the type checker
-(deftype diagnostic
-  {:level string :message string :component string? :expr any})
-
-;; Primitive parameter type signature
-(deftype prim-param-sig
-  {:positional list :rest-type string?})
-
-;; Effect declarations
-(defeffect io)
-(defeffect mutation)
-(defeffect render)
-
-(define type-def-name
-  (fn (td) (get td "name")))
-
-(define type-def-params
-  (fn (td) (get td "params")))
-
-(define type-def-body
-  (fn (td) (get td "body")))
-
-(define resolve-type
-  (fn (t registry)
-    ;; Resolve a type through the registry.
-    ;; Returns the resolved type representation.
-    (if (nil? registry) t
-      (cond
-        ;; String — might be a named type alias
-        (= (type-of t) "string")
-          (if (has-key? registry t)
-            (let ((td (get registry t)))
-              (let ((params (type-def-params td))
-                    (body (type-def-body td)))
-                (if (empty? params)
-                  ;; Simple alias — resolve the body recursively
-                  (resolve-type body registry)
-                  ;; Parameterized with no args — return as-is
-                  t)))
-            t)
-        ;; List — might be parameterized type application or compound
-        (= (type-of t) "list")
-          (if (empty? t) t
-            (let ((head (first t)))
-              (cond
-                ;; (or ...), (list-of ...), (-> ...) — recurse into members
-                (or (= head "or") (= head "list-of") (= head "->")
-                    (= head "dict-of"))
-                  (cons head (map (fn (m) (resolve-type m registry)) (rest t)))
-                ;; Parameterized type application: ("maybe" "string") etc.
-                (and (= (type-of head) "string")
-                     (has-key? registry head))
-                  (let ((td (get registry head))
-                        (params (type-def-params td))
-                        (body (type-def-body td))
-                        (args (rest t)))
-                    (if (= (len params) (len args))
-                      (resolve-type
-                        (substitute-type-vars body params args)
-                        registry)
-                      ;; Wrong arity — return as-is
-                      t))
-                :else t)))
-        ;; Dict — record type, resolve field types
-        (= (type-of t) "dict")
-          (map-dict (fn (k v) (resolve-type v registry)) t)
-        ;; Anything else — return as-is
-        :else t))))
-
-(define substitute-type-vars
-  (fn (body (params :as list) (args :as list))
-    ;; Substitute type variables in body.
-    ;; params is a list of type var names, args is corresponding types.
-    (let ((subst (dict)))
-      (for-each
-        (fn (i)
-          (dict-set! subst (nth params i) (nth args i)))
-        (range 0 (len params) 1))
-      (substitute-in-type body subst))))
-
-(define substitute-in-type
-  (fn (t (subst :as dict))
-    ;; Recursively substitute type variables.
-    (cond
-      (= (type-of t) "string")
-        (if (has-key? subst t) (get subst t) t)
-      (= (type-of t) "list")
-        (map (fn (m) (substitute-in-type m subst)) t)
-      (= (type-of t) "dict")
-        (map-dict (fn (k v) (substitute-in-type v subst)) t)
-      :else t)))
-
-(define subtype-resolved?
-  (fn (a b registry)
-    ;; Resolve both sides through the registry, then check subtype.
-    (if (nil? registry)
-      (subtype? a b)
-      (let ((ra (resolve-type a registry))
-            (rb (resolve-type b registry)))
-        ;; Handle record structural subtyping: dict a <: dict b
-        ;; if every field in b exists in a with compatible type
-        (if (and (= (type-of ra) "dict") (= (type-of rb) "dict"))
-          (every?
-            (fn (key)
-              (and (has-key? ra key)
-                   (subtype-resolved? (get ra key) (get rb key) registry)))
-            (keys rb))
-          (subtype? ra rb))))))
-
-
-;; --------------------------------------------------------------------------
-;; 14. Effect checking (defeffect)
-;; --------------------------------------------------------------------------
-;; Effects are annotations on functions/components describing their
-;; side effects. A pure function cannot call IO functions.
-
-(define get-effects
-  (fn ((name :as string) effect-annotations)
-    ;; Look up declared effects for a function/component.
-    ;; Returns list of effect strings, or nil if unannotated.
-    (if (nil? effect-annotations) nil
-      (if (has-key? effect-annotations name)
-        (get effect-annotations name)
-        nil))))
-
-(define effects-subset?
-  (fn (callee-effects caller-effects)
-    ;; Are all callee effects allowed by caller?
-    ;; nil effects = unannotated = assumed to have all effects.
-    ;; Empty list = pure = no effects.
-    (if (nil? caller-effects) true     ;; unannotated caller allows everything
-      (if (nil? callee-effects) true   ;; unannotated callee — skip check
-        (every?
-          (fn (e) (contains? caller-effects e))
-          callee-effects)))))
-
-(define check-effect-call
-  (fn ((callee-name :as string) caller-effects effect-annotations (comp-name :as string))
-    ;; Check that callee's effects are allowed by caller's effects.
-    ;; Returns list of diagnostics.
-    (let ((diagnostics (list))
-          (callee-effects (get-effects callee-name effect-annotations)))
-      (when (and (not (nil? caller-effects))
-                 (not (nil? callee-effects))
-                 (not (effects-subset? callee-effects caller-effects)))
-        (append! diagnostics
-          (make-diagnostic "error"
-            (str "`" callee-name "` has effects "
-                 (join ", " callee-effects)
-                 " but `" comp-name "` only allows "
-                 (if (empty? caller-effects) "[pure]"
-                   (join ", " caller-effects)))
-            comp-name nil)))
-      diagnostics)))
-
-(define build-effect-annotations
-  (fn ((io-declarations :as list))
-    ;; Assign [io] effect to all IO primitives.
-    (let ((annotations (dict)))
-      (for-each
-        (fn (decl)
-          (let ((name (get decl "name")))
-            (when (not (nil? name))
-              (dict-set! annotations name (list "io")))))
-        io-declarations)
-      annotations)))
-
-
-;; --------------------------------------------------------------------------
-;; 15. Check component effects — convenience wrapper
-;; --------------------------------------------------------------------------
-;; Validates that components respect their declared effect annotations.
-;; Delegates to check-body-walk with nil type checking (effects only).
-
-(define check-component-effects
-  (fn ((comp-name :as string) env effect-annotations)
-    ;; Check a single component's effect usage. Returns diagnostics list.
-    ;; Skips type checking — only checks effect violations.
-    (let ((comp (env-get env comp-name))
-          (diagnostics (list)))
-      (when (= (type-of comp) "component")
-        (let ((body (component-body comp)))
-          (check-body-walk body comp-name (dict) (dict) nil env
-            diagnostics nil effect-annotations)))
-      diagnostics)))
-
-(define check-all-effects
-  (fn (env effect-annotations)
-    ;; Check all components in env for effect violations.
-    ;; Returns list of all diagnostics.
-    (let ((all-diagnostics (list)))
-      (for-each
-        (fn (name)
-          (let ((val (env-get env name)))
-            (when (= (type-of val) "component")
-              (for-each
-                (fn (d) (append! all-diagnostics d))
-                (check-component-effects name env effect-annotations)))))
-        (keys env))
-      all-diagnostics)))
-
-
-;; --------------------------------------------------------------------------
-;; Platform interface summary
-;; --------------------------------------------------------------------------
-;;
-;; From eval.sx (already provided):
-;;   (type-of x), (symbol-name s), (keyword-name k), (env-get env k)
-;;   (component-body c), (component-params c), (component-has-children c)
-;;
-;; New for types.sx (each host implements):
-;;   (component-param-types c)        → dict {param-name → type} or nil
-;;   (component-set-param-types! c d) → store param types on component
-;;   (merge d1 d2)               → new dict merging d1 and d2
-;;
-;; Primitive param types:
-;;   The host provides prim-param-types as a dict mapping primitive names
-;;   to param type descriptors. Each descriptor is a dict:
-;;     {"positional" [["name" "type-or-nil"] ...] "rest-type" "type-or-nil"}
-;;   Built by boundary_parser.parse_primitive_param_types() in Python.
-;;   Passed to check-component/check-all as an optional extra argument.
-;;
-;; --------------------------------------------------------------------------

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 overflow-x-hidden 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 overflow-x-hidden js-grid-viewport"
       (when content content))))
 
 (defcomp ~shared:layout/hamburger ()

shared/sx/tests/test_aser_errors.py

@@ -0,0 +1,245 @@
+"""Tests for aser (SX wire format) error propagation.
+
+Verifies that evaluation errors inside control flow forms (case, cond, if,
+when, let, begin) propagate correctly — they must throw, not silently
+produce wrong output or fall through to :else branches.
+
+This test file targets the production bug where a case body referencing an
+undefined symbol was silently swallowed, causing the case to appear to fall
+through to :else instead of raising an error.
+"""
+from __future__ import annotations
+
+import pytest
+
+from shared.sx.ref.sx_ref import (
+    aser,
+    sx_parse as parse_all,
+    make_env,
+    eval_expr,
+    trampoline,
+    serialize as sx_serialize,
+)
+from shared.sx.types import NIL, EvalError
+
+
+def _render_sx(source: str, env=None) -> str:
+    """Parse SX source and serialize via aser (sync)."""
+    if env is None:
+        env = make_env()
+    exprs = parse_all(source)
+    result = ""
+    for expr in exprs:
+        val = aser(expr, env)
+        if isinstance(val, str):
+            result += val
+        elif val is None or val is NIL:
+            pass
+        else:
+            result += sx_serialize(val)
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Case — matched branch errors must throw, not fall through
+# ---------------------------------------------------------------------------
+
+class TestCaseErrorPropagation:
+    def test_matched_branch_undefined_symbol_throws(self):
+        """If the matched case body references an undefined symbol, the aser
+        must throw — NOT silently skip to :else."""
+        with pytest.raises(Exception, match="Undefined symbol"):
+            _render_sx('(case "x" "x" undefined_sym :else "fallback")')
+
+    def test_else_branch_error_throws(self):
+        with pytest.raises(Exception, match="Undefined symbol"):
+            _render_sx('(case "miss" "x" "ok" :else undefined_sym)')
+
+    def test_matched_branch_nested_error_throws(self):
+        """Error inside a tag within the matched body must propagate."""
+        with pytest.raises(Exception, match="Undefined symbol"):
+            _render_sx('(case "a" "a" (div (p undefined_nested)) :else (p "index"))')
+
+    def test_unmatched_correctly_falls_through(self):
+        """Verify :else works when no clause matches (happy path)."""
+        result = _render_sx('(case "miss" "x" "found" :else "fallback")')
+        assert "fallback" in result
+
+    def test_matched_branch_succeeds(self):
+        """Verify the happy path: matched branch evaluates normally."""
+        result = _render_sx('(case "ok" "ok" (p "matched") :else "fallback")')
+        assert "matched" in result
+
+
+# ---------------------------------------------------------------------------
+# Cond — matched branch errors must throw
+# ---------------------------------------------------------------------------
+
+class TestCondErrorPropagation:
+    def test_matched_branch_error_throws(self):
+        with pytest.raises(Exception, match="Undefined symbol"):
+            _render_sx('(cond true undefined_cond_sym :else "fallback")')
+
+    def test_else_branch_error_throws(self):
+        with pytest.raises(Exception, match="Undefined symbol"):
+            _render_sx('(cond false "skip" :else undefined_cond_sym)')
+
+
+# ---------------------------------------------------------------------------
+# If / When — body errors must throw
+# ---------------------------------------------------------------------------
+
+class TestIfWhenErrorPropagation:
+    def test_if_true_branch_error_throws(self):
+        with pytest.raises(Exception, match="Undefined symbol"):
+            _render_sx('(if true undefined_if_sym "fallback")')
+
+    def test_when_body_error_throws(self):
+        with pytest.raises(Exception, match="Undefined symbol"):
+            _render_sx('(when true undefined_when_sym)')
+
+
+# ---------------------------------------------------------------------------
+# Let — binding or body errors must throw
+# ---------------------------------------------------------------------------
+
+class TestLetErrorPropagation:
+    def test_binding_error_throws(self):
+        with pytest.raises(Exception, match="Undefined symbol"):
+            _render_sx('(let ((x undefined_let_sym)) (p x))')
+
+    def test_body_error_throws(self):
+        with pytest.raises(Exception, match="Undefined symbol"):
+            _render_sx('(let ((x 1)) (p undefined_let_body_sym))')
+
+
+# ---------------------------------------------------------------------------
+# Begin/Do — body errors must throw
+# ---------------------------------------------------------------------------
+
+class TestBeginErrorPropagation:
+    def test_do_body_error_throws(self):
+        with pytest.raises(Exception, match="Undefined symbol"):
+            _render_sx('(do "ok" undefined_do_sym)')
+
+
+# ---------------------------------------------------------------------------
+# Sync aser: components serialize WITHOUT expansion (by design)
+# ---------------------------------------------------------------------------
+
+class TestSyncAserComponentSerialization:
+    """The sync aser serializes component calls as SX wire format without
+    expanding the body. This is correct — expansion only happens in the
+    async path with expand_components=True."""
+
+    def test_component_in_case_serializes_without_expanding(self):
+        """Sync aser should serialize the component call, not expand it."""
+        result = _render_sx(
+            '(do (defcomp ~broken (&key title) (div (p title) (p no_such_helper)))'
+            '    (case "slug" "slug" (~broken :title "test") '
+            '                :else "index"))'
+        )
+        # Component call is serialized as SX, not expanded — no error
+        assert "~broken" in result
+
+    def test_working_component_in_case_serializes(self):
+        result = _render_sx(
+            '(do (defcomp ~working (&key title) (div (p title)))'
+            '    (case "ok" "ok" (~working :title "hello") '
+            '               :else "index"))'
+        )
+        assert "~working" in result
+
+    def test_unmatched_case_falls_through_correctly(self):
+        result = _render_sx(
+            '(do (defcomp ~page (&key x) (div x))'
+            '    (case "miss" "hit" (~page :x "found") '
+            '                :else "index"))'
+        )
+        assert "index" in result
+
+
+# ---------------------------------------------------------------------------
+# Async aser with expand_components=True — the production path
+# ---------------------------------------------------------------------------
+
+class TestAsyncAserComponentExpansion:
+    """Tests the production code path: async aser with component expansion
+    enabled. Errors in expanded component bodies must propagate, not be
+    silently swallowed."""
+
+    def _async_render(self, source: str) -> str:
+        """Render via the async aser with component expansion enabled."""
+        import asyncio
+        from shared.sx.ref.sx_ref import async_aser, _expand_components_cv
+        exprs = parse_all(source)
+        env = make_env()
+
+        async def run():
+            token = _expand_components_cv.set(True)
+            try:
+                result = ""
+                for expr in exprs:
+                    val = await async_aser(expr, env, None)
+                    if isinstance(val, str):
+                        result += val
+                    elif val is None or val is NIL:
+                        pass
+                    else:
+                        result += sx_serialize(val)
+                return result
+            finally:
+                _expand_components_cv.reset(token)
+
+        return asyncio.run(run())
+
+    def test_expanded_component_with_undefined_symbol_throws(self):
+        """When expand_components is True and the component body references
+        an undefined symbol, the error must propagate — not be swallowed."""
+        with pytest.raises(Exception, match="Undefined symbol"):
+            self._async_render(
+                '(do (defcomp ~broken (&key title) '
+                '      (div (p title) (p no_such_helper)))'
+                '    (case "slug" "slug" (~broken :title "test") '
+                '                :else "index"))'
+            )
+
+    def test_expanded_working_component_succeeds(self):
+        result = self._async_render(
+            '(do (defcomp ~working (&key title) (div (p title)))'
+            '    (case "ok" "ok" (~working :title "hello") '
+            '               :else "index"))'
+        )
+        assert "hello" in result
+
+    def test_expanded_unmatched_falls_through(self):
+        result = self._async_render(
+            '(do (defcomp ~page (&key x) (div x))'
+            '    (case "miss" "hit" (~page :x "found") '
+            '                :else "index"))'
+        )
+        assert "index" in result
+
+    def test_hand_written_aser_also_propagates(self):
+        """Test the hand-written _aser in async_eval.py (the production
+        path used by page rendering)."""
+        import asyncio
+        from shared.sx.async_eval import (
+            async_eval_slot_to_sx, RequestContext,
+        )
+        from shared.sx.ref.sx_ref import aser
+
+        env = make_env()
+        # Define the component via sync aser
+        for expr in parse_all(
+            '(defcomp ~broken (&key title) (div (p title) (p no_such_helper)))'
+        ):
+            aser(expr, env)
+
+        case_expr = parse_all(
+            '(case "slug" "slug" (~broken :title "test") :else "index")'
+        )[0]
+        ctx = RequestContext()
+
+        with pytest.raises(Exception, match="Undefined symbol"):
+            asyncio.run(async_eval_slot_to_sx(case_expr, dict(env), ctx))

shared/sx/tests/test_ocaml_bridge.py

@@ -0,0 +1,220 @@
+"""Tests for the OCaml SX bridge."""
+
+import asyncio
+import os
+import sys
+import unittest
+
+# Add project root to path
+_project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
+if _project_root not in sys.path:
+    sys.path.insert(0, _project_root)
+
+from shared.sx.ocaml_bridge import OcamlBridge, OcamlBridgeError, _escape, _parse_response, _serialize_for_ocaml
+
+
+class TestHelpers(unittest.TestCase):
+    """Test helper functions (no subprocess needed)."""
+
+    def test_escape_basic(self):
+        self.assertEqual(_escape('hello'), 'hello')
+        self.assertEqual(_escape('say "hi"'), 'say \\"hi\\"')
+        self.assertEqual(_escape('a\\b'), 'a\\\\b')
+        self.assertEqual(_escape('line\nbreak'), 'line\\nbreak')
+
+    def test_parse_response_ok_empty(self):
+        self.assertEqual(_parse_response("(ok)"), ("ok", None))
+
+    def test_parse_response_ok_number(self):
+        self.assertEqual(_parse_response("(ok 3)"), ("ok", "3"))
+
+    def test_parse_response_ok_string(self):
+        kind, val = _parse_response('(ok "<div>hi</div>")')
+        self.assertEqual(kind, "ok")
+        self.assertEqual(val, "<div>hi</div>")
+
+    def test_parse_response_error(self):
+        kind, val = _parse_response('(error "something broke")')
+        self.assertEqual(kind, "error")
+        self.assertEqual(val, "something broke")
+
+    def test_serialize_none(self):
+        self.assertEqual(_serialize_for_ocaml(None), "nil")
+
+    def test_serialize_bool(self):
+        self.assertEqual(_serialize_for_ocaml(True), "true")
+        self.assertEqual(_serialize_for_ocaml(False), "false")
+
+    def test_serialize_number(self):
+        self.assertEqual(_serialize_for_ocaml(42), "42")
+        self.assertEqual(_serialize_for_ocaml(3.14), "3.14")
+
+    def test_serialize_string(self):
+        self.assertEqual(_serialize_for_ocaml("hello"), '"hello"')
+        self.assertEqual(_serialize_for_ocaml('say "hi"'), '"say \\"hi\\""')
+
+    def test_serialize_list(self):
+        self.assertEqual(_serialize_for_ocaml([1, 2, 3]), "(list 1 2 3)")
+
+    def test_serialize_dict(self):
+        result = _serialize_for_ocaml({"a": 1})
+        self.assertEqual(result, "{:a 1}")
+
+
+class TestBridge(unittest.IsolatedAsyncioTestCase):
+    """Integration tests — require the OCaml binary to be built."""
+
+    @classmethod
+    def setUpClass(cls):
+        # Check if binary exists
+        from shared.sx.ocaml_bridge import _DEFAULT_BIN
+        bin_path = os.path.abspath(_DEFAULT_BIN)
+        if not os.path.isfile(bin_path):
+            raise unittest.SkipTest(
+                f"OCaml binary not found at {bin_path}. "
+                f"Build with: cd hosts/ocaml && eval $(opam env) && dune build"
+            )
+
+    async def asyncSetUp(self):
+        self.bridge = OcamlBridge()
+        await self.bridge.start()
+
+    async def asyncTearDown(self):
+        await self.bridge.stop()
+
+    async def test_ping(self):
+        self.assertTrue(await self.bridge.ping())
+
+    async def test_eval_arithmetic(self):
+        result = await self.bridge.eval("(+ 1 2)")
+        self.assertEqual(result, "3")
+
+    async def test_eval_string(self):
+        result = await self.bridge.eval('(str "hello" " " "world")')
+        self.assertIn("hello world", result)
+
+    async def test_render_simple(self):
+        html = await self.bridge.render('(div (p "hello"))')
+        self.assertEqual(html, "<div><p>hello</p></div>")
+
+    async def test_render_attrs(self):
+        html = await self.bridge.render('(div :class "card" (p "hi"))')
+        self.assertIn('class="card"', html)
+        self.assertIn("<p>hi</p>", html)
+
+    async def test_render_void_element(self):
+        html = await self.bridge.render("(br)")
+        self.assertEqual(html, "<br />")
+
+    async def test_load_source_defcomp(self):
+        count = await self.bridge.load_source(
+            '(defcomp ~test-card (&key title) (div :class "card" (h2 title)))'
+        )
+        self.assertEqual(count, 1)
+        html = await self.bridge.render('(~test-card :title "Hello")')
+        self.assertIn("Hello", html)
+        self.assertIn("card", html)
+
+    async def test_reset(self):
+        await self.bridge.load_source("(define x 42)")
+        result = await self.bridge.eval("x")
+        self.assertEqual(result, "42")
+        await self.bridge.reset()
+        with self.assertRaises(OcamlBridgeError):
+            await self.bridge.eval("x")
+
+    async def test_render_conditional(self):
+        html = await self.bridge.render('(if true (p "yes") (p "no"))')
+        self.assertEqual(html, "<p>yes</p>")
+
+    async def test_render_let(self):
+        html = await self.bridge.render('(let (x "hi") (p x))')
+        self.assertEqual(html, "<p>hi</p>")
+
+    async def test_render_map(self):
+        html = await self.bridge.render(
+            "(map (lambda (x) (li x)) (list \"a\" \"b\" \"c\"))"
+        )
+        self.assertEqual(html, "<li>a</li><li>b</li><li>c</li>")
+
+    async def test_render_fragment(self):
+        html = await self.bridge.render('(<> (p "a") (p "b"))')
+        self.assertEqual(html, "<p>a</p><p>b</p>")
+
+    async def test_eval_error(self):
+        with self.assertRaises(OcamlBridgeError):
+            await self.bridge.eval("(undefined-symbol-xyz)")
+
+    async def test_render_component_with_children(self):
+        await self.bridge.load_source(
+            '(defcomp ~wrapper (&rest children) (div :class "wrap" children))'
+        )
+        html = await self.bridge.render('(~wrapper (p "inside"))')
+        self.assertIn("wrap", html)
+        self.assertIn("<p>inside</p>", html)
+
+    async def test_render_macro(self):
+        await self.bridge.load_source(
+            "(defmacro unless (cond &rest body) (list 'if (list 'not cond) (cons 'do body)))"
+        )
+        html = await self.bridge.render('(unless false (p "shown"))')
+        self.assertEqual(html, "<p>shown</p>")
+
+    # ------------------------------------------------------------------
+    # ListRef regression tests — the `list` primitive returns ListRef
+    # (mutable), not List (immutable). Macro expansions that construct
+    # AST via `list` produce ListRef nodes. The renderer must handle
+    # both List and ListRef at every structural match point.
+    # ------------------------------------------------------------------
+
+    async def test_render_macro_generates_cond(self):
+        """Macro that programmatically builds a (cond ...) with list."""
+        await self.bridge.load_source(
+            "(defmacro pick (x) "
+            "  (list 'cond "
+            "    (list (list '= x 1) '(p \"one\")) "
+            "    (list (list '= x 2) '(p \"two\")) "
+            "    (list ':else '(p \"other\"))))"
+        )
+        html = await self.bridge.render("(pick 2)")
+        self.assertEqual(html, "<p>two</p>")
+
+    async def test_render_macro_generates_let(self):
+        """Macro that programmatically builds a (let ...) with list."""
+        await self.bridge.load_source(
+            "(defmacro with-greeting (name &rest body) "
+            "  (list 'let (list (list 'greeting (list 'str \"Hello \" name))) "
+            "    (cons 'do body)))"
+        )
+        html = await self.bridge.render('(with-greeting "World" (p greeting))')
+        self.assertEqual(html, "<p>Hello World</p>")
+
+    async def test_render_macro_nested_html_tags(self):
+        """Macro expansion containing nested HTML tags via list."""
+        await self.bridge.load_source(
+            "(defmacro card (title &rest body) "
+            "  (list 'div ':class \"card\" "
+            "    (list 'h2 title) "
+            "    (cons 'do body)))"
+        )
+        html = await self.bridge.render('(card "Title" (p "content"))')
+        self.assertIn('<div class="card">', html)
+        self.assertIn("<h2>Title</h2>", html)
+        self.assertIn("<p>content</p>", html)
+
+    async def test_render_eval_returns_listref(self):
+        """Values created at runtime via (list ...) are ListRef."""
+        await self.bridge.load_source(
+            "(define make-items (lambda () (list "
+            '  (list "a") (list "b") (list "c"))))'
+        )
+        html = await self.bridge.render(
+            "(ul (map (lambda (x) (li (first x))) (make-items)))"
+        )
+        self.assertIn("<li>a</li>", html)
+        self.assertIn("<li>b</li>", html)
+        self.assertIn("<li>c</li>", html)
+
+
+if __name__ == "__main__":
+    unittest.main()

spec/boundary-core.sx

@@ -1,49 +0,0 @@
-;; ==========================================================================
-;; 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)
-;;
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Tier 1: Pure primitives — declared in primitives.sx
-;; --------------------------------------------------------------------------
-
-(declare-tier :pure :source "primitives.sx")
-
-
-;; --------------------------------------------------------------------------
-;; Core platform primitives — type inspection + environment
-;; --------------------------------------------------------------------------
-;;
-;; These are provided by every host. Not IO, not web-specific.
-
-(declare-core-primitive "type-of"
-  :params (value)
-  :returns "string"
-  :doc "Return the type name of a value.")
-
-(declare-core-primitive "make-env"
-  :params ()
-  :returns "dict"
-  :doc "Create a base environment with all primitives.")
-
-(declare-core-primitive "identical?"
-  :params (a b)
-  :returns "boolean"
-  :doc "Reference equality check.")

spec/continuations.sx

@@ -1,248 +0,0 @@
-;; ==========================================================================
-;; continuations.sx — Delimited continuations (shift/reset)
-;;
-;; OPTIONAL EXTENSION — not required by the core evaluator.
-;; Bootstrappers include this only when the target requests it.
-;;
-;; Delimited continuations capture "the rest of the computation up to
-;; a delimiter." They are strictly less powerful than full call/cc but
-;; cover the practical use cases: suspendable rendering, cooperative
-;; scheduling, linear async flows, wizard forms, and undo.
-;;
-;; Two new special forms:
-;;   (reset body)       — establish a delimiter
-;;   (shift k body)     — capture the continuation to the nearest reset
-;;
-;; One new type:
-;;   continuation       — a captured delimited continuation, callable
-;;
-;; The captured continuation is a function of one argument. Invoking it
-;; provides the value that the shift expression "returns" within the
-;; delimited context, then completes the rest of the reset body.
-;;
-;; Continuations are composable — invoking a continuation returns a
-;; value (the result of the reset body), which can be used normally.
-;; This is the key difference from undelimited call/cc, where invoking
-;; a continuation never returns.
-;;
-;; Platform requirements:
-;;   (make-continuation fn)   — wrap a function as a continuation value
-;;   (continuation? x)        — type predicate
-;;   (type-of continuation)   → "continuation"
-;;   Continuations are callable (same dispatch as lambda).
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 1. Type
-;; --------------------------------------------------------------------------
-;;
-;; A continuation is a callable value of one argument.
-;;
-;;   (continuation? k)  → true if k is a captured continuation
-;;   (type-of k)        → "continuation"
-;;   (k value)          → invoke: resume the captured computation with value
-;;
-;; Continuations are first-class: they can be stored in variables, passed
-;; as arguments, returned from functions, and put in data structures.
-;;
-;; Invoking a delimited continuation RETURNS a value — the result of the
-;; reset body. This makes them composable:
-;;
-;;   (+ 1 (reset (+ 10 (shift k (k 5)))))
-;;   ;; k is "add 10 to _ and return from reset"
-;;   ;; (k 5) → 15, which is returned from reset
-;;   ;; (+ 1 15) → 16
-;;
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; 2. reset — establish a continuation delimiter
-;; --------------------------------------------------------------------------
-;;
-;; (reset body)
-;;
-;; Evaluates body in the current environment. If no shift occurs during
-;; evaluation of body, reset simply returns the value of body.
-;;
-;; If shift occurs, reset is the boundary — the continuation captured by
-;; shift extends from the shift point back to (and including) this reset.
-;;
-;; reset is the "prompt" — it marks where the continuation stops.
-;;
-;; Semantics:
-;;   (reset expr) where expr contains no shift
-;;     → (eval expr env)                   ;; just evaluates normally
-;;
-;;   (reset ... (shift k body) ...)
-;;     → captures continuation, evaluates shift's body
-;;     → the result of the shift body is the result of the reset
-;;
-;; --------------------------------------------------------------------------
-
-(define sf-reset
-  (fn ((args :as list) (env :as dict))
-    ;; Single argument: the body expression.
-    ;; Install a continuation delimiter, then evaluate body.
-    ;; The implementation is target-specific:
-    ;;   - In Scheme: native reset/shift
-    ;;   - In Haskell: Control.Monad.CC or delimited continuations library
-    ;;   - In Python: coroutine/generator-based (see implementation notes)
-    ;;   - In JavaScript: generator-based or CPS transform
-    ;;   - In Rust: CPS transform at compile time
-    (let ((body (first args)))
-      (eval-with-delimiter body env))))
-
-
-;; --------------------------------------------------------------------------
-;; 3. shift — capture the continuation to the nearest reset
-;; --------------------------------------------------------------------------
-;;
-;; (shift k body)
-;;
-;; Captures the continuation from this point back to the nearest enclosing
-;; reset and binds it to k. Then evaluates body in the current environment
-;; extended with k. The result of body becomes the result of the enclosing
-;; reset.
-;;
-;; k is a function of one argument. Calling (k value) resumes the captured
-;; computation with value standing in for the shift expression.
-;;
-;; The continuation k is composable: (k value) returns a value (the result
-;; of the reset body when resumed with value). This means k can be called
-;; multiple times, and its result can be used in further computation.
-;;
-;; Examples:
-;;
-;;   ;; Basic: shift provides a value to the surrounding computation
-;;   (reset (+ 1 (shift k (k 41))))
-;;   ;; k = "add 1 to _", (k 41) → 42, reset returns 42
-;;
-;;   ;; Abort: shift can discard the continuation entirely
-;;   (reset (+ 1 (shift k "aborted")))
-;;   ;; k is never called, reset returns "aborted"
-;;
-;;   ;; Multiple invocations: k can be called more than once
-;;   (reset (+ 1 (shift k (list (k 10) (k 20)))))
-;;   ;; (k 10) → 11, (k 20) → 21, reset returns (11 21)
-;;
-;;   ;; Stored for later: k can be saved and invoked outside reset
-;;   (define saved nil)
-;;   (reset (+ 1 (shift k (set! saved k) 0)))
-;;   ;; reset returns 0, saved holds the continuation
-;;   (saved 99)  ;; → 100
-;;
-;; --------------------------------------------------------------------------
-
-(define sf-shift
-  (fn ((args :as list) (env :as dict))
-    ;; Two arguments: the continuation variable name, and the body.
-    (let ((k-name (symbol-name (first args)))
-          (body   (second args)))
-      ;; Capture the current continuation up to the nearest reset.
-      ;; Bind it to k-name in the environment, then evaluate body.
-      ;; The result of body is returned to the reset.
-      (capture-continuation k-name body env))))
-
-
-;; --------------------------------------------------------------------------
-;; 4. Interaction with other features
-;; --------------------------------------------------------------------------
-;;
-;; TCO (trampoline):
-;;   Continuations interact naturally with the trampoline. A shift inside
-;;   a tail-call position captures the continuation including the pending
-;;   return. The trampoline resolves thunks before the continuation is
-;;   delimited.
-;;
-;; Macros:
-;;   shift/reset are special forms, not macros. Macros expand before
-;;   evaluation, so shift inside a macro-expanded form works correctly —
-;;   it captures the continuation of the expanded code.
-;;
-;; Components:
-;;   shift inside a component body captures the continuation of that
-;;   component's render. The enclosing reset determines the delimiter.
-;;   This is the foundation for suspendable rendering — a component can
-;;   shift to suspend, and the server resumes it when data arrives.
-;;
-;; I/O primitives:
-;;   I/O primitives execute at invocation time, in whatever context
-;;   exists then. A continuation that captures a computation containing
-;;   I/O will re-execute that I/O when invoked. If the I/O requires
-;;   request context (e.g. current-user), invoking the continuation
-;;   outside a request will fail — same as calling the I/O directly.
-;;   This is consistent, not a restriction.
-;;
-;;   In typed targets (Haskell, Rust), the type system can enforce that
-;;   continuations containing I/O are only invoked in appropriate contexts.
-;;   In dynamic targets (Python, JS), it fails at runtime.
-;;
-;; Lexical scope:
-;;   Continuations capture the dynamic extent (what happens next) but
-;;   close over the lexical environment at the point of capture. Variable
-;;   bindings in the continuation refer to the same environment — mutations
-;;   via set! are visible.
-;;
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; 5. Implementation notes per target
-;; --------------------------------------------------------------------------
-;;
-;; The bootstrapper emits target-specific continuation machinery.
-;; The spec defines semantics; each target chooses representation.
-;;
-;; Scheme / Racket:
-;;   Native shift/reset. No transformation needed. The bootstrapper
-;;   emits (require racket/control) or equivalent.
-;;
-;; Haskell:
-;;   Control.Monad.CC provides delimited continuations in the CC monad.
-;;   Alternatively, the evaluator can be CPS-transformed at compile time.
-;;   Continuations become first-class functions naturally.
-;;
-;; Python:
-;;   Generator-based: reset creates a generator, shift yields from it.
-;;   The trampoline loop drives the generator. Each yield is a shift
-;;   point, and send() provides the resume value.
-;;   Alternative: greenlet-based (stackful coroutines).
-;;
-;; JavaScript:
-;;   Generator-based (function* / yield). Similar to Python.
-;;   Alternative: CPS transform at bootstrap time — the bootstrapper
-;;   rewrites the evaluator into continuation-passing style, making
-;;   shift/reset explicit function arguments.
-;;
-;; Rust:
-;;   CPS transform at compile time. Continuations become enum variants
-;;   or boxed closures. The type system ensures continuations are used
-;;   linearly if desired (affine types via ownership).
-;;
-;; --------------------------------------------------------------------------
-
-
-;; --------------------------------------------------------------------------
-;; 6. Platform interface — what each target must provide
-;; --------------------------------------------------------------------------
-;;
-;;   (eval-with-delimiter expr env)
-;;     Install a reset delimiter, evaluate expr, return result.
-;;     If expr calls shift, the continuation is captured up to here.
-;;
-;;   (capture-continuation k-name body env)
-;;     Capture the current continuation up to the nearest delimiter.
-;;     Bind it to k-name in env, evaluate body, return result to delimiter.
-;;
-;;   (make-continuation fn)
-;;     Wrap a native function as a continuation value.
-;;
-;;   (continuation? x)
-;;     Type predicate.
-;;
-;;   Continuations must be callable via the standard function-call
-;;   dispatch in eval-list (same path as lambda calls).
-;;
-;; --------------------------------------------------------------------------

spec/frames.sx

@@ -1,262 +0,0 @@
-;; ==========================================================================
-;; frames.sx — CEK machine frame types
-;;
-;; Defines the continuation frame types used by the explicit CEK evaluator.
-;; Each frame represents a "what to do next" when a sub-evaluation completes.
-;;
-;; A CEK state is a dict:
-;;   {:control expr       — expression being evaluated (or nil in continue phase)
-;;    :env     env        — current environment
-;;    :kont    list       — continuation: list of frames (stack, head = top)
-;;    :phase   "eval"|"continue"
-;;    :value   any}       — value produced (only in continue phase)
-;;
-;; Two-phase step function:
-;;   step-eval:     control is expression → dispatch → push frame + new control
-;;   step-continue: value produced → pop frame → dispatch → new state
-;;
-;; Terminal state: phase = "continue" and kont is empty → value is final result.
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 1. CEK State constructors
-;; --------------------------------------------------------------------------
-
-(define make-cek-state
-  (fn (control env kont)
-    {:control control :env env :kont kont :phase "eval" :value nil}))
-
-(define make-cek-value
-  (fn (value env kont)
-    {:control nil :env env :kont kont :phase "continue" :value value}))
-
-(define cek-terminal?
-  (fn (state)
-    (and (= (get state "phase") "continue")
-         (empty? (get state "kont")))))
-
-(define cek-control  (fn (s) (get s "control")))
-(define cek-env      (fn (s) (get s "env")))
-(define cek-kont     (fn (s) (get s "kont")))
-(define cek-phase    (fn (s) (get s "phase")))
-(define cek-value    (fn (s) (get s "value")))
-
-
-;; --------------------------------------------------------------------------
-;; 2. Frame constructors
-;; --------------------------------------------------------------------------
-;; Each frame type is a dict with a "type" key and frame-specific data.
-
-;; IfFrame: waiting for condition value
-;; After condition evaluates, choose then or else branch
-(define make-if-frame
-  (fn (then-expr else-expr env)
-    {:type "if" :then then-expr :else else-expr :env env}))
-
-;; WhenFrame: waiting for condition value
-;; If truthy, evaluate body exprs sequentially
-(define make-when-frame
-  (fn (body-exprs env)
-    {:type "when" :body body-exprs :env env}))
-
-;; BeginFrame: sequential evaluation
-;; Remaining expressions to evaluate after current one
-(define make-begin-frame
-  (fn (remaining env)
-    {:type "begin" :remaining remaining :env env}))
-
-;; LetFrame: binding evaluation in progress
-;; name = current binding name, remaining = remaining (name val) pairs
-;; body = body expressions to evaluate after all bindings
-(define make-let-frame
-  (fn (name remaining body local)
-    {:type "let" :name name :remaining remaining :body body :env local}))
-
-;; DefineFrame: waiting for value to bind
-(define make-define-frame
-  (fn (name env has-effects effect-list)
-    {:type "define" :name name :env env
-     :has-effects has-effects :effect-list effect-list}))
-
-;; SetFrame: waiting for value to assign
-(define make-set-frame
-  (fn (name env)
-    {:type "set" :name name :env env}))
-
-;; ArgFrame: evaluating function arguments
-;; f = function value (already evaluated), evaled = already evaluated args
-;; remaining = remaining arg expressions
-(define make-arg-frame
-  (fn (f evaled remaining env raw-args)
-    {:type "arg" :f f :evaled evaled :remaining remaining :env env
-     :raw-args raw-args}))
-
-;; CallFrame: about to call with fully evaluated args
-(define make-call-frame
-  (fn (f args env)
-    {:type "call" :f f :args args :env env}))
-
-;; CondFrame: evaluating cond clauses
-(define make-cond-frame
-  (fn (remaining env scheme?)
-    {:type "cond" :remaining remaining :env env :scheme scheme?}))
-
-;; CaseFrame: evaluating case clauses
-(define make-case-frame
-  (fn (match-val remaining env)
-    {:type "case" :match-val match-val :remaining remaining :env env}))
-
-;; ThreadFirstFrame: pipe threading
-(define make-thread-frame
-  (fn (remaining env)
-    {:type "thread" :remaining remaining :env env}))
-
-;; MapFrame: higher-order map/map-indexed in progress
-(define make-map-frame
-  (fn (f remaining results env)
-    {:type "map" :f f :remaining remaining :results results :env env :indexed false}))
-
-(define make-map-indexed-frame
-  (fn (f remaining results env)
-    {:type "map" :f f :remaining remaining :results results :env env :indexed true}))
-
-;; FilterFrame: higher-order filter in progress
-(define make-filter-frame
-  (fn (f remaining results current-item env)
-    {:type "filter" :f f :remaining remaining :results results
-     :current-item current-item :env env}))
-
-;; ReduceFrame: higher-order reduce in progress
-(define make-reduce-frame
-  (fn (f remaining env)
-    {:type "reduce" :f f :remaining remaining :env env}))
-
-;; ForEachFrame: higher-order for-each in progress
-(define make-for-each-frame
-  (fn (f remaining env)
-    {:type "for-each" :f f :remaining remaining :env env}))
-
-;; SomeFrame: higher-order some (short-circuit on first truthy)
-(define make-some-frame
-  (fn (f remaining env)
-    {:type "some" :f f :remaining remaining :env env}))
-
-;; EveryFrame: higher-order every? (short-circuit on first falsy)
-(define make-every-frame
-  (fn (f remaining env)
-    {:type "every" :f f :remaining remaining :env env}))
-
-;; ScopeFrame: scope-pop! when frame pops
-(define make-scope-frame
-  (fn (name remaining env)
-    {:type "scope" :name name :remaining remaining :env env}))
-
-;; ResetFrame: delimiter for shift/reset continuations
-(define make-reset-frame
-  (fn (env)
-    {:type "reset" :env env}))
-
-;; DictFrame: evaluating dict values
-(define make-dict-frame
-  (fn (remaining results env)
-    {:type "dict" :remaining remaining :results results :env env}))
-
-;; AndFrame: short-circuit and
-(define make-and-frame
-  (fn (remaining env)
-    {:type "and" :remaining remaining :env env}))
-
-;; OrFrame: short-circuit or
-(define make-or-frame
-  (fn (remaining env)
-    {:type "or" :remaining remaining :env env}))
-
-;; QuasiquoteFrame (not a real frame — QQ is handled specially)
-
-;; DynamicWindFrame: phases of dynamic-wind
-(define make-dynamic-wind-frame
-  (fn (phase body-thunk after-thunk env)
-    {:type "dynamic-wind" :phase phase
-     :body-thunk body-thunk :after-thunk after-thunk :env env}))
-
-;; ReactiveResetFrame: delimiter for reactive deref-as-shift
-;; Carries an update-fn that gets called with new values on re-render.
-(define make-reactive-reset-frame
-  (fn (env update-fn first-render?)
-    {:type "reactive-reset" :env env :update-fn update-fn
-     :first-render first-render?}))
-
-;; DerefFrame: awaiting evaluation of deref's argument
-(define make-deref-frame
-  (fn (env)
-    {:type "deref" :env env}))
-
-
-;; --------------------------------------------------------------------------
-;; 3. Frame accessors
-;; --------------------------------------------------------------------------
-
-(define frame-type (fn (f) (get f "type")))
-
-
-;; --------------------------------------------------------------------------
-;; 4. Continuation operations
-;; --------------------------------------------------------------------------
-
-(define kont-push
-  (fn (frame kont) (cons frame kont)))
-
-(define kont-top
-  (fn (kont) (first kont)))
-
-(define kont-pop
-  (fn (kont) (rest kont)))
-
-(define kont-empty?
-  (fn (kont) (empty? kont)))
-
-
-;; --------------------------------------------------------------------------
-;; 5. CEK shift/reset support
-;; --------------------------------------------------------------------------
-;; shift captures all frames up to the nearest ResetFrame.
-;; reset pushes a ResetFrame.
-
-(define kont-capture-to-reset
-  (fn (kont)
-    ;; Returns (captured-frames remaining-kont).
-    ;; captured-frames: frames from top up to (not including) ResetFrame.
-    ;; remaining-kont: frames after ResetFrame.
-    ;; Stops at either "reset" or "reactive-reset" frames.
-    (define scan
-      (fn (k captured)
-        (if (empty? k)
-          (error "shift without enclosing reset")
-          (let ((frame (first k)))
-            (if (or (= (frame-type frame) "reset")
-                    (= (frame-type frame) "reactive-reset"))
-              (list captured (rest k))
-              (scan (rest k) (append captured (list frame))))))))
-    (scan kont (list))))
-
-;; Check if a ReactiveResetFrame exists anywhere in the continuation
-(define has-reactive-reset-frame?
-  (fn (kont)
-    (if (empty? kont) false
-      (if (= (frame-type (first kont)) "reactive-reset") true
-        (has-reactive-reset-frame? (rest kont))))))
-
-;; Capture frames up to nearest ReactiveResetFrame.
-;; Returns (captured-frames, reset-frame, remaining-kont).
-(define kont-capture-to-reactive-reset
-  (fn (kont)
-    (define scan
-      (fn (k captured)
-        (if (empty? k)
-          (error "reactive deref without enclosing reactive-reset")
-          (let ((frame (first k)))
-            (if (= (frame-type frame) "reactive-reset")
-              (list captured frame (rest k))
-              (scan (rest k) (append captured (list frame))))))))
-    (scan kont (list))))

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/test-cek.sx

@@ -1,241 +0,0 @@
-;; ==========================================================================
-;; test-cek.sx — Tests for the explicit CEK machine evaluator
-;;
-;; Tests that eval-expr-cek produces identical results to eval-expr.
-;; Requires: test-framework.sx, frames.sx, cek.sx loaded.
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 1. Literals
-;; --------------------------------------------------------------------------
-
-(defsuite "cek-literals"
-  (deftest "number"
-    (assert-equal 42 (eval-expr-cek 42 (test-env))))
-
-  (deftest "string"
-    (assert-equal "hello" (eval-expr-cek "hello" (test-env))))
-
-  (deftest "boolean true"
-    (assert-equal true (eval-expr-cek true (test-env))))
-
-  (deftest "boolean false"
-    (assert-equal false (eval-expr-cek false (test-env))))
-
-  (deftest "nil"
-    (assert-nil (eval-expr-cek nil (test-env)))))
-
-
-;; --------------------------------------------------------------------------
-;; 2. Symbol lookup
-;; --------------------------------------------------------------------------
-
-(defsuite "cek-symbols"
-  (deftest "env lookup"
-    (assert-equal 42
-      (cek-eval "(do (define x 42) x)")))
-
-  (deftest "primitive call resolves"
-    (assert-equal "hello"
-      (cek-eval "(str \"hello\")"))))
-
-
-;; --------------------------------------------------------------------------
-;; 3. Special forms
-;; --------------------------------------------------------------------------
-
-(defsuite "cek-if"
-  (deftest "if true branch"
-    (assert-equal 1
-      (cek-eval "(if true 1 2)")))
-
-  (deftest "if false branch"
-    (assert-equal 2
-      (cek-eval "(if false 1 2)")))
-
-  (deftest "if no else"
-    (assert-nil (cek-eval "(if false 1)"))))
-
-
-(defsuite "cek-when"
-  (deftest "when true"
-    (assert-equal 42
-      (cek-eval "(when true 42)")))
-
-  (deftest "when false"
-    (assert-nil (cek-eval "(when false 42)")))
-
-  (deftest "when multiple body"
-    (assert-equal 3
-      (cek-eval "(when true 1 2 3)"))))
-
-
-(defsuite "cek-begin"
-  (deftest "do returns last"
-    (assert-equal 3
-      (cek-eval "(do 1 2 3)")))
-
-  (deftest "empty do"
-    (assert-nil (cek-eval "(do)"))))
-
-
-(defsuite "cek-let"
-  (deftest "basic let"
-    (assert-equal 3
-      (cek-eval "(let ((x 1) (y 2)) (+ x y))")))
-
-  (deftest "let body sequence"
-    (assert-equal 10
-      (cek-eval "(let ((x 5)) 1 2 (+ x 5))")))
-
-  (deftest "nested let"
-    (assert-equal 5
-      (cek-eval "(let ((x 1)) (let ((y 2)) (+ x y (* x y))))"))))
-
-
-(defsuite "cek-and-or"
-  (deftest "and all true"
-    (assert-equal 3
-      (cek-eval "(and 1 2 3)")))
-
-  (deftest "and short circuit"
-    (assert-false (cek-eval "(and 1 false 3)")))
-
-  (deftest "or first true"
-    (assert-equal 1
-      (cek-eval "(or 1 2 3)")))
-
-  (deftest "or all false"
-    (assert-false (cek-eval "(or false false false)"))))
-
-
-(defsuite "cek-cond"
-  (deftest "cond first match"
-    (assert-equal "a"
-      (cek-eval "(cond true \"a\" true \"b\")")))
-
-  (deftest "cond second match"
-    (assert-equal "b"
-      (cek-eval "(cond false \"a\" true \"b\")")))
-
-  (deftest "cond else"
-    (assert-equal "c"
-      (cek-eval "(cond false \"a\" :else \"c\")"))))
-
-
-(defsuite "cek-case"
-  (deftest "case match"
-    (assert-equal "yes"
-      (cek-eval "(case 1 1 \"yes\" 2 \"no\")")))
-
-  (deftest "case no match"
-    (assert-nil
-      (cek-eval "(case 3 1 \"yes\" 2 \"no\")")))
-
-  (deftest "case else"
-    (assert-equal "default"
-      (cek-eval "(case 3 1 \"yes\" :else \"default\")"))))
-
-
-;; --------------------------------------------------------------------------
-;; 4. Function calls
-;; --------------------------------------------------------------------------
-
-(defsuite "cek-calls"
-  (deftest "primitive call"
-    (assert-equal 3
-      (cek-eval "(+ 1 2)")))
-
-  (deftest "nested calls"
-    (assert-equal 6
-      (cek-eval "(+ 1 (+ 2 3))")))
-
-  (deftest "lambda call"
-    (assert-equal 10
-      (cek-eval "((fn (x) (* x 2)) 5)")))
-
-  (deftest "defined function"
-    (assert-equal 25
-      (cek-eval "(do (define square (fn (x) (* x x))) (square 5))"))))
-
-
-;; --------------------------------------------------------------------------
-;; 5. Define and set!
-;; --------------------------------------------------------------------------
-
-(defsuite "cek-define"
-  (deftest "define binds"
-    (assert-equal 42
-      (cek-eval "(do (define x 42) x)")))
-
-  (deftest "set! mutates"
-    (assert-equal 10
-      (cek-eval "(do (define x 1) (set! x 10) x)"))))
-
-
-;; --------------------------------------------------------------------------
-;; 6. Quote and quasiquote
-;; --------------------------------------------------------------------------
-
-(defsuite "cek-quote"
-  (deftest "quote"
-    (let ((result (cek-eval "(quote (1 2 3))")))
-      (assert-equal 3 (len result))))
-
-  (deftest "quasiquote with unquote"
-    (assert-equal (list 1 42 3)
-      (cek-eval "(let ((x 42)) `(1 ,x 3))"))))
-
-
-;; --------------------------------------------------------------------------
-;; 7. Thread-first
-;; --------------------------------------------------------------------------
-
-(defsuite "cek-thread-first"
-  (deftest "simple thread"
-    (assert-equal 3
-      (cek-eval "(-> 1 (+ 2))")))
-
-  (deftest "multi-step thread"
-    (assert-equal 6
-      (cek-eval "(-> 1 (+ 2) (* 2))"))))
-
-
-;; --------------------------------------------------------------------------
-;; 8. CEK-specific: stepping
-;; --------------------------------------------------------------------------
-
-(defsuite "cek-stepping"
-  (deftest "single step literal"
-    (let ((state (make-cek-state 42 (test-env) (list))))
-      (let ((stepped (cek-step state)))
-        (assert-equal "continue" (cek-phase stepped))
-        (assert-equal 42 (cek-value stepped))
-        (assert-true (cek-terminal? stepped)))))
-
-  (deftest "single step if pushes frame"
-    (let ((state (make-cek-state (sx-parse-one "(if true 1 2)") (test-env) (list))))
-      (let ((stepped (cek-step state)))
-        (assert-equal "eval" (cek-phase stepped))
-        ;; Should have pushed an IfFrame
-        (assert-true (> (len (cek-kont stepped)) 0))
-        (assert-equal "if" (frame-type (first (cek-kont stepped))))))))
-
-
-;; --------------------------------------------------------------------------
-;; 9. Native continuations (shift/reset in CEK)
-;; --------------------------------------------------------------------------
-
-(defsuite "cek-continuations"
-  (deftest "reset passthrough"
-    (assert-equal 42
-      (cek-eval "(reset 42)")))
-
-  (deftest "shift abort"
-    (assert-equal 42
-      (cek-eval "(reset (+ 1 (shift k 42)))")))
-
-  (deftest "shift with invoke"
-    (assert-equal 11
-      (cek-eval "(reset (+ 1 (shift k (k 10))))"))))

spec/test-continuations.sx

@@ -1,140 +0,0 @@
-;; ==========================================================================
-;; test-continuations.sx — Tests for delimited continuations (shift/reset)
-;;
-;; Requires: test-framework.sx loaded, continuations extension enabled.
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 1. Basic shift/reset
-;; --------------------------------------------------------------------------
-
-(defsuite "basic-shift-reset"
-  (deftest "reset passthrough"
-    (assert-equal 42 (reset 42)))
-
-  (deftest "reset evaluates expression"
-    (assert-equal 3 (reset (+ 1 2))))
-
-  (deftest "shift aborts to reset"
-    (assert-equal 42 (reset (+ 1 (shift k 42)))))
-
-  (deftest "shift with single invoke"
-    (assert-equal 11 (reset (+ 1 (shift k (k 10))))))
-
-  (deftest "shift with multiple invokes"
-    (assert-equal (list 11 21)
-      (reset (+ 1 (shift k (list (k 10) (k 20)))))))
-
-  (deftest "shift returns string"
-    (assert-equal "aborted"
-      (reset (+ 1 (shift k "aborted")))))
-
-  (deftest "shift returns nil"
-    (assert-nil (reset (+ 1 (shift k nil)))))
-
-  (deftest "nested expression with shift"
-    (assert-equal 16
-      (+ 1 (reset (+ 10 (shift k (k 5))))))))
-
-
-;; --------------------------------------------------------------------------
-;; 2. Continuation predicates
-;; --------------------------------------------------------------------------
-
-(defsuite "continuation-predicates"
-  (deftest "k is a continuation inside shift"
-    (assert-true
-      (reset (shift k (continuation? k)))))
-
-  (deftest "number is not a continuation"
-    (assert-false (continuation? 42)))
-
-  (deftest "function is not a continuation"
-    (assert-false (continuation? (fn (x) x))))
-
-  (deftest "nil is not a continuation"
-    (assert-false (continuation? nil)))
-
-  (deftest "string is not a continuation"
-    (assert-false (continuation? "hello"))))
-
-
-;; --------------------------------------------------------------------------
-;; 3. Continuation as value
-;; --------------------------------------------------------------------------
-
-(defsuite "continuation-as-value"
-  (deftest "k returned from reset"
-    ;; shift body returns k itself — reset returns the continuation
-    (let ((k (reset (+ 1 (shift k k)))))
-      (assert-true (continuation? k))
-      (assert-equal 11 (k 10))))
-
-  (deftest "invoke returned k multiple times"
-    (let ((k (reset (+ 1 (shift k k)))))
-      (assert-equal 11 (k 10))
-      (assert-equal 21 (k 20))
-      (assert-equal 2 (k 1))))
-
-  (deftest "pass k to another function"
-    (let ((apply-k (fn (k v) (k v))))
-      (assert-equal 15
-        (reset (+ 5 (shift k (apply-k k 10)))))))
-
-  (deftest "k in data structure"
-    (let ((result (reset (+ 1 (shift k (list k 42))))))
-      (assert-equal 42 (nth result 1))
-      (assert-equal 100 ((first result) 99)))))
-
-
-;; --------------------------------------------------------------------------
-;; 4. Nested reset
-;; --------------------------------------------------------------------------
-
-(defsuite "nested-reset"
-  (deftest "inner reset captures independently"
-    (assert-equal 12
-      (reset (+ 1 (reset (+ 10 (shift k (k 1))))))))
-
-  (deftest "inner abort outer continues"
-    (assert-equal 43
-      (reset (+ 1 (reset (+ 10 (shift k 42)))))))
-
-  (deftest "outer shift captures outer reset"
-    (assert-equal 100
-      (reset (+ 1 (shift k (k 99)))))))
-
-
-;; --------------------------------------------------------------------------
-;; 5. Interaction with scoped effects
-;; --------------------------------------------------------------------------
-
-(defsuite "continuations-with-scopes"
-  (deftest "provide survives resume"
-    (assert-equal "dark"
-      (reset (provide "theme" "dark"
-        (+ 0 (shift k (k 0)))
-        (context "theme")))))
-
-  (deftest "scope and emit across shift"
-    (assert-equal (list "a")
-      (reset (scope "acc"
-        (emit! "acc" "a")
-        (+ 0 (shift k (k 0)))
-        (emitted "acc"))))))
-
-
-;; --------------------------------------------------------------------------
-;; 6. TCO interaction
-;; --------------------------------------------------------------------------
-
-(defsuite "tco-interaction"
-  (deftest "shift in tail position"
-    (assert-equal 42
-      (reset (if true (shift k (k 42)) 0))))
-
-  (deftest "shift in let body"
-    (assert-equal 10
-      (reset (let ((x 5))
-        (+ x (shift k (k 5))))))))

spec/test-eval.sx

@@ -1,746 +0,0 @@
-;; ==========================================================================
-;; test-eval.sx — Tests for the core evaluator and primitives
-;;
-;; Requires: test-framework.sx loaded first.
-;; Modules tested: eval.sx, primitives.sx
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Literals and types
-;; --------------------------------------------------------------------------
-
-(defsuite "literals"
-  (deftest "numbers are numbers"
-    (assert-type "number" 42)
-    (assert-type "number" 3.14)
-    (assert-type "number" -1))
-
-  (deftest "strings are strings"
-    (assert-type "string" "hello")
-    (assert-type "string" ""))
-
-  (deftest "booleans are booleans"
-    (assert-type "boolean" true)
-    (assert-type "boolean" false))
-
-  (deftest "nil is nil"
-    (assert-type "nil" nil)
-    (assert-nil nil))
-
-  (deftest "lists are lists"
-    (assert-type "list" (list 1 2 3))
-    (assert-type "list" (list)))
-
-  (deftest "dicts are dicts"
-    (assert-type "dict" {:a 1 :b 2})))
-
-
-;; --------------------------------------------------------------------------
-;; Arithmetic
-;; --------------------------------------------------------------------------
-
-(defsuite "arithmetic"
-  (deftest "addition"
-    (assert-equal 3 (+ 1 2))
-    (assert-equal 0 (+ 0 0))
-    (assert-equal -1 (+ 1 -2))
-    (assert-equal 10 (+ 1 2 3 4)))
-
-  (deftest "subtraction"
-    (assert-equal 1 (- 3 2))
-    (assert-equal -1 (- 2 3)))
-
-  (deftest "multiplication"
-    (assert-equal 6 (* 2 3))
-    (assert-equal 0 (* 0 100))
-    (assert-equal 24 (* 1 2 3 4)))
-
-  (deftest "division"
-    (assert-equal 2 (/ 6 3))
-    (assert-equal 2.5 (/ 5 2)))
-
-  (deftest "modulo"
-    (assert-equal 1 (mod 7 3))
-    (assert-equal 0 (mod 6 3))))
-
-
-;; --------------------------------------------------------------------------
-;; Comparison
-;; --------------------------------------------------------------------------
-
-(defsuite "comparison"
-  (deftest "equality"
-    (assert-true (= 1 1))
-    (assert-false (= 1 2))
-    (assert-true (= "a" "a"))
-    (assert-false (= "a" "b")))
-
-  (deftest "deep equality"
-    (assert-true (equal? (list 1 2 3) (list 1 2 3)))
-    (assert-false (equal? (list 1 2) (list 1 3)))
-    (assert-true (equal? {:a 1} {:a 1}))
-    (assert-false (equal? {:a 1} {:a 2})))
-
-  (deftest "ordering"
-    (assert-true (< 1 2))
-    (assert-false (< 2 1))
-    (assert-true (> 2 1))
-    (assert-true (<= 1 1))
-    (assert-true (<= 1 2))
-    (assert-true (>= 2 2))
-    (assert-true (>= 3 2))))
-
-
-;; --------------------------------------------------------------------------
-;; String operations
-;; --------------------------------------------------------------------------
-
-(defsuite "strings"
-  (deftest "str concatenation"
-    (assert-equal "abc" (str "a" "b" "c"))
-    (assert-equal "hello world" (str "hello" " " "world"))
-    (assert-equal "42" (str 42))
-    (assert-equal "" (str)))
-
-  (deftest "string-length"
-    (assert-equal 5 (string-length "hello"))
-    (assert-equal 0 (string-length "")))
-
-  (deftest "substring"
-    (assert-equal "ell" (substring "hello" 1 4))
-    (assert-equal "hello" (substring "hello" 0 5)))
-
-  (deftest "string-contains?"
-    (assert-true (string-contains? "hello world" "world"))
-    (assert-false (string-contains? "hello" "xyz")))
-
-  (deftest "upcase and downcase"
-    (assert-equal "HELLO" (upcase "hello"))
-    (assert-equal "hello" (downcase "HELLO")))
-
-  (deftest "trim"
-    (assert-equal "hello" (trim "  hello  "))
-    (assert-equal "hello" (trim "hello")))
-
-  (deftest "split and join"
-    (assert-equal (list "a" "b" "c") (split "a,b,c" ","))
-    (assert-equal "a-b-c" (join "-" (list "a" "b" "c")))))
-
-
-;; --------------------------------------------------------------------------
-;; List operations
-;; --------------------------------------------------------------------------
-
-(defsuite "lists"
-  (deftest "constructors"
-    (assert-equal (list 1 2 3) (list 1 2 3))
-    (assert-equal (list) (list))
-    (assert-length 3 (list 1 2 3)))
-
-  (deftest "first and rest"
-    (assert-equal 1 (first (list 1 2 3)))
-    (assert-equal (list 2 3) (rest (list 1 2 3)))
-    (assert-nil (first (list)))
-    (assert-equal (list) (rest (list))))
-
-  (deftest "nth"
-    (assert-equal 1 (nth (list 1 2 3) 0))
-    (assert-equal 2 (nth (list 1 2 3) 1))
-    (assert-equal 3 (nth (list 1 2 3) 2)))
-
-  (deftest "last"
-    (assert-equal 3 (last (list 1 2 3)))
-    (assert-nil (last (list))))
-
-  (deftest "cons and append"
-    (assert-equal (list 0 1 2) (cons 0 (list 1 2)))
-    (assert-equal (list 1 2 3 4) (append (list 1 2) (list 3 4))))
-
-  (deftest "reverse"
-    (assert-equal (list 3 2 1) (reverse (list 1 2 3)))
-    (assert-equal (list) (reverse (list))))
-
-  (deftest "empty?"
-    (assert-true (empty? (list)))
-    (assert-false (empty? (list 1))))
-
-  (deftest "len"
-    (assert-equal 0 (len (list)))
-    (assert-equal 3 (len (list 1 2 3))))
-
-  (deftest "contains?"
-    (assert-true (contains? (list 1 2 3) 2))
-    (assert-false (contains? (list 1 2 3) 4)))
-
-  (deftest "flatten"
-    (assert-equal (list 1 2 3 4) (flatten (list (list 1 2) (list 3 4))))))
-
-
-;; --------------------------------------------------------------------------
-;; Dict operations
-;; --------------------------------------------------------------------------
-
-(defsuite "dicts"
-  (deftest "dict literal"
-    (assert-type "dict" {:a 1 :b 2})
-    (assert-equal 1 (get {:a 1} "a"))
-    (assert-equal 2 (get {:a 1 :b 2} "b")))
-
-  (deftest "assoc"
-    (assert-equal {:a 1 :b 2} (assoc {:a 1} "b" 2))
-    (assert-equal {:a 99} (assoc {:a 1} "a" 99)))
-
-  (deftest "dissoc"
-    (assert-equal {:b 2} (dissoc {:a 1 :b 2} "a")))
-
-  (deftest "keys and vals"
-    (let ((d {:a 1 :b 2}))
-      (assert-length 2 (keys d))
-      (assert-length 2 (vals d))
-      (assert-contains "a" (keys d))
-      (assert-contains "b" (keys d))))
-
-  (deftest "has-key?"
-    (assert-true (has-key? {:a 1} "a"))
-    (assert-false (has-key? {:a 1} "b")))
-
-  (deftest "merge"
-    (assert-equal {:a 1 :b 2 :c 3}
-      (merge {:a 1 :b 2} {:c 3}))
-    (assert-equal {:a 99 :b 2}
-      (merge {:a 1 :b 2} {:a 99}))))
-
-
-;; --------------------------------------------------------------------------
-;; Predicates
-;; --------------------------------------------------------------------------
-
-(defsuite "predicates"
-  (deftest "nil?"
-    (assert-true (nil? nil))
-    (assert-false (nil? 0))
-    (assert-false (nil? false))
-    (assert-false (nil? "")))
-
-  (deftest "number?"
-    (assert-true (number? 42))
-    (assert-true (number? 3.14))
-    (assert-false (number? "42")))
-
-  (deftest "string?"
-    (assert-true (string? "hello"))
-    (assert-false (string? 42)))
-
-  (deftest "list?"
-    (assert-true (list? (list 1 2)))
-    (assert-false (list? "not a list")))
-
-  (deftest "dict?"
-    (assert-true (dict? {:a 1}))
-    (assert-false (dict? (list 1))))
-
-  (deftest "boolean?"
-    (assert-true (boolean? true))
-    (assert-true (boolean? false))
-    (assert-false (boolean? nil))
-    (assert-false (boolean? 0)))
-
-  (deftest "not"
-    (assert-true (not false))
-    (assert-true (not nil))
-    (assert-false (not true))
-    (assert-false (not 1))
-    (assert-false (not "x"))))
-
-
-;; --------------------------------------------------------------------------
-;; Special forms
-;; --------------------------------------------------------------------------
-
-(defsuite "special-forms"
-  (deftest "if"
-    (assert-equal "yes" (if true "yes" "no"))
-    (assert-equal "no" (if false "yes" "no"))
-    (assert-equal "no" (if nil "yes" "no"))
-    (assert-nil (if false "yes")))
-
-  (deftest "when"
-    (assert-equal "yes" (when true "yes"))
-    (assert-nil (when false "yes")))
-
-  (deftest "cond"
-    (assert-equal "a" (cond true "a" :else "b"))
-    (assert-equal "b" (cond false "a" :else "b"))
-    (assert-equal "c" (cond
-                        false "a"
-                        false "b"
-                        :else "c")))
-
-  (deftest "cond with 2-element predicate as first test"
-    ;; Regression: cond misclassifies Clojure-style as scheme-style when
-    ;; the first test is a 2-element list like (nil? x) or (empty? x).
-    ;; The evaluator checks: is first arg a 2-element list? If yes, treats
-    ;; as scheme-style ((test body) ...) — returning the arg instead of
-    ;; evaluating the predicate call.
-    (assert-equal 0 (cond (nil? nil) 0 :else 1))
-    (assert-equal 1 (cond (nil? "x") 0 :else 1))
-    (assert-equal "empty" (cond (empty? (list)) "empty" :else "not-empty"))
-    (assert-equal "not-empty" (cond (empty? (list 1)) "empty" :else "not-empty"))
-    (assert-equal "yes" (cond (not false) "yes" :else "no"))
-    (assert-equal "no" (cond (not true) "yes" :else "no")))
-
-  (deftest "cond with 2-element predicate and no :else"
-    ;; Same bug, but without :else — this is the worst case because the
-    ;; bootstrapper heuristic also breaks (all clauses are 2-element lists).
-    (assert-equal "found"
-      (cond (nil? nil) "found"
-            (nil? "x") "other"))
-    (assert-equal "b"
-      (cond (nil? "x") "a"
-            (not false) "b")))
-
-  (deftest "and"
-    (assert-true (and true true))
-    (assert-false (and true false))
-    (assert-false (and false true))
-    (assert-equal 3 (and 1 2 3)))
-
-  (deftest "or"
-    (assert-equal 1 (or 1 2))
-    (assert-equal 2 (or false 2))
-    (assert-equal "fallback" (or nil false "fallback"))
-    (assert-false (or false false)))
-
-  (deftest "let"
-    (assert-equal 3 (let ((x 1) (y 2)) (+ x y)))
-    (assert-equal "hello world"
-      (let ((a "hello") (b " world")) (str a b))))
-
-  (deftest "let clojure-style"
-    (assert-equal 3 (let (x 1 y 2) (+ x y))))
-
-  (deftest "do / begin"
-    (assert-equal 3 (do 1 2 3))
-    (assert-equal "last" (begin "first" "middle" "last")))
-
-  (deftest "define"
-    (define x 42)
-    (assert-equal 42 x))
-
-  (deftest "set!"
-    (define x 1)
-    (set! x 2)
-    (assert-equal 2 x)))
-
-
-;; --------------------------------------------------------------------------
-;; Lambda and closures
-;; --------------------------------------------------------------------------
-
-(defsuite "lambdas"
-  (deftest "basic lambda"
-    (let ((add (fn (a b) (+ a b))))
-      (assert-equal 3 (add 1 2))))
-
-  (deftest "closure captures env"
-    (let ((x 10))
-      (let ((add-x (fn (y) (+ x y))))
-        (assert-equal 15 (add-x 5)))))
-
-  (deftest "lambda as argument"
-    (assert-equal (list 2 4 6)
-      (map (fn (x) (* x 2)) (list 1 2 3))))
-
-  (deftest "recursive lambda via define"
-    (define factorial
-      (fn (n) (if (<= n 1) 1 (* n (factorial (- n 1))))))
-    (assert-equal 120 (factorial 5)))
-
-  (deftest "higher-order returns lambda"
-    (let ((make-adder (fn (n) (fn (x) (+ n x)))))
-      (let ((add5 (make-adder 5)))
-        (assert-equal 8 (add5 3)))))
-
-  (deftest "multi-body lambda returns last value"
-    ;; All body expressions must execute. Return value is the last.
-    ;; Catches: sf-lambda using nth(args,1) instead of rest(args).
-    (let ((f (fn (x) (+ x 1) (+ x 2) (+ x 3))))
-      (assert-equal 13 (f 10))))
-
-  (deftest "multi-body lambda side effects via dict mutation"
-    ;; Verify all body expressions run by mutating a shared dict.
-    (let ((state (dict "a" 0 "b" 0)))
-      (let ((f (fn ()
-                 (dict-set! state "a" 1)
-                 (dict-set! state "b" 2)
-                 "done")))
-        (assert-equal "done" (f))
-        (assert-equal 1 (get state "a"))
-        (assert-equal 2 (get state "b")))))
-
-  (deftest "multi-body lambda two expressions"
-    ;; Simplest case: two body expressions, return value is second.
-    (assert-equal 20
-      ((fn (x) (+ x 1) (* x 2)) 10))
-    ;; And with zero-arg lambda
-    (assert-equal 42
-      ((fn () (+ 1 2) 42)))))
-
-
-;; --------------------------------------------------------------------------
-;; Higher-order forms
-;; --------------------------------------------------------------------------
-
-(defsuite "higher-order"
-  (deftest "map"
-    (assert-equal (list 2 4 6)
-      (map (fn (x) (* x 2)) (list 1 2 3)))
-    (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)))
-    (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)))
-    (assert-equal 0 (reduce (fn (acc x) (+ acc x)) 0 (list))))
-
-  (deftest "some"
-    (assert-true (some (fn (x) (> x 3)) (list 1 2 3 4 5)))
-    (assert-false (some (fn (x) (> x 10)) (list 1 2 3))))
-
-  (deftest "every?"
-    (assert-true (every? (fn (x) (> x 0)) (list 1 2 3)))
-    (assert-false (every? (fn (x) (> x 2)) (list 1 2 3))))
-
-  (deftest "map-indexed"
-    (assert-equal (list "0:a" "1:b" "2:c")
-      (map-indexed (fn (i x) (str i ":" x)) (list "a" "b" "c")))))
-
-
-;; --------------------------------------------------------------------------
-;; Components
-;; --------------------------------------------------------------------------
-
-(defsuite "components"
-  (deftest "defcomp creates component"
-    (defcomp ~test-comp (&key title)
-      (div title))
-    (assert-true (not (nil? ~test-comp))))
-
-  (deftest "component renders with keyword args"
-    (defcomp ~greeting (&key name)
-      (span (str "Hello, " name "!")))
-    (assert-true (not (nil? ~greeting))))
-
-  (deftest "component with children"
-    (defcomp ~box (&key &rest children)
-      (div :class "box" children))
-    (assert-true (not (nil? ~box))))
-
-  (deftest "component with default via or"
-    (defcomp ~label (&key text)
-      (span (or text "default")))
-    (assert-true (not (nil? ~label))))
-
-  (deftest "defcomp default affinity is auto"
-    (defcomp ~aff-default (&key x)
-      (div x))
-    (assert-equal "auto" (component-affinity ~aff-default)))
-
-  (deftest "defcomp affinity client"
-    (defcomp ~aff-client (&key x)
-      :affinity :client
-      (div x))
-    (assert-equal "client" (component-affinity ~aff-client)))
-
-  (deftest "defcomp affinity server"
-    (defcomp ~aff-server (&key x)
-      :affinity :server
-      (div x))
-    (assert-equal "server" (component-affinity ~aff-server)))
-
-  (deftest "defcomp affinity preserves body"
-    (defcomp ~aff-body (&key val)
-      :affinity :client
-      (span val))
-    ;; Component should still render correctly
-    (assert-equal "client" (component-affinity ~aff-body))
-    (assert-true (not (nil? ~aff-body)))))
-
-
-;; --------------------------------------------------------------------------
-;; Macros
-;; --------------------------------------------------------------------------
-
-(defsuite "macros"
-  (deftest "defmacro creates macro"
-    (defmacro unless (cond &rest body)
-      `(if (not ,cond) (do ,@body)))
-    (assert-equal "yes" (unless false "yes"))
-    (assert-nil (unless true "no")))
-
-  (deftest "quasiquote and unquote"
-    (let ((x 42))
-      (assert-equal (list 1 42 3) `(1 ,x 3))))
-
-  (deftest "splice-unquote"
-    (let ((xs (list 2 3 4)))
-      (assert-equal (list 1 2 3 4 5) `(1 ,@xs 5)))))
-
-
-;; --------------------------------------------------------------------------
-;; Threading macro
-;; --------------------------------------------------------------------------
-
-(defsuite "threading"
-  (deftest "thread-first"
-    (assert-equal 8 (-> 5 (+ 1) (+ 2)))
-    (assert-equal "HELLO" (-> "hello" upcase))
-    (assert-equal "HELLO WORLD"
-      (-> "hello"
-          (str " world")
-          upcase))))
-
-
-;; --------------------------------------------------------------------------
-;; Truthiness
-;; --------------------------------------------------------------------------
-
-(defsuite "truthiness"
-  (deftest "truthy values"
-    (assert-true (if 1 true false))
-    (assert-true (if "x" true false))
-    (assert-true (if (list 1) true false))
-    (assert-true (if true true false)))
-
-  (deftest "falsy values"
-    (assert-false (if false true false))
-    (assert-false (if nil true false)))
-
-  ;; NOTE: empty list, zero, and empty string truthiness is
-  ;; platform-dependent. Python treats all three as falsy.
-  ;; JavaScript treats [] as truthy but 0 and "" as falsy.
-  ;; These tests are omitted — each bootstrapper should emit
-  ;; platform-specific truthiness tests instead.
-  )
-
-
-;; --------------------------------------------------------------------------
-;; Edge cases and regression tests
-;; --------------------------------------------------------------------------
-
-(defsuite "edge-cases"
-  (deftest "nested let scoping"
-    (let ((x 1))
-      (let ((x 2))
-        (assert-equal 2 x))
-      ;; outer x should be unchanged by inner let
-      ;; (this tests that let creates a new scope)
-      ))
-
-  (deftest "recursive map"
-    (assert-equal (list (list 2 4) (list 6 8))
-      (map (fn (sub) (map (fn (x) (* x 2)) sub))
-           (list (list 1 2) (list 3 4)))))
-
-  (deftest "keyword as value"
-    (assert-equal "class" :class)
-    (assert-equal "id" :id))
-
-  (deftest "dict with evaluated values"
-    (let ((x 42))
-      (assert-equal 42 (get {:val x} "val"))))
-
-  (deftest "nil propagation"
-    (assert-nil (get {:a 1} "missing"))
-    (assert-equal "default" (or (get {:a 1} "missing") "default")))
-
-  (deftest "empty operations"
-    (assert-equal (list) (map (fn (x) x) (list)))
-    (assert-equal (list) (filter (fn (x) true) (list)))
-    (assert-equal 0 (reduce (fn (acc x) (+ acc x)) 0 (list)))
-    (assert-equal 0 (len (list)))
-    (assert-equal "" (str))))
-
-
-;; --------------------------------------------------------------------------
-;; Server-only tests — skip in browser (defpage, streaming functions)
-;; These require forms.sx which is only loaded server-side.
-;; --------------------------------------------------------------------------
-
-(when (get (try-call (fn () stream-chunk-id)) "ok")
-
-(defsuite "defpage"
-  (deftest "basic defpage returns page-def"
-    (let ((p (defpage test-basic :path "/test" :auth :public :content (div "hello"))))
-      (assert-true (not (nil? p)))
-      (assert-equal "test-basic" (get p "name"))
-      (assert-equal "/test" (get p "path"))
-      (assert-equal "public" (get p "auth"))))
-
-  (deftest "defpage content expr is unevaluated AST"
-    (let ((p (defpage test-content :path "/c" :auth :public :content (~my-comp :title "hi"))))
-      (assert-true (not (nil? (get p "content"))))))
-
-  (deftest "defpage with :stream"
-    (let ((p (defpage test-stream :path "/s" :auth :public :stream true :content (div "x"))))
-      (assert-equal true (get p "stream"))))
-
-  (deftest "defpage with :shell"
-    (let ((p (defpage test-shell :path "/sh" :auth :public :stream true
-               :shell (~my-layout (~suspense :id "data" :fallback (div "loading...")))
-               :content (~my-streamed :data data-val))))
-      (assert-true (not (nil? (get p "shell"))))
-      (assert-true (not (nil? (get p "content"))))))
-
-  (deftest "defpage with :fallback"
-    (let ((p (defpage test-fallback :path "/f" :auth :public :stream true
-               :fallback (div :class "skeleton" "loading")
-               :content (div "done"))))
-      (assert-true (not (nil? (get p "fallback"))))))
-
-  (deftest "defpage with :data"
-    (let ((p (defpage test-data :path "/d" :auth :public
-               :data (fetch-items)
-               :content (~items-list :items items))))
-      (assert-true (not (nil? (get p "data"))))))
-
-  (deftest "defpage missing fields are nil"
-    (let ((p (defpage test-minimal :path "/m" :auth :public :content (div "x"))))
-      (assert-nil (get p "data"))
-      (assert-nil (get p "filter"))
-      (assert-nil (get p "aside"))
-      (assert-nil (get p "menu"))
-      (assert-nil (get p "shell"))
-      (assert-nil (get p "fallback"))
-      (assert-equal false (get p "stream")))))
-
-;; --------------------------------------------------------------------------
-;; Multi-stream data protocol (from forms.sx)
-;; --------------------------------------------------------------------------
-
-(defsuite "stream-chunk-id"
-  (deftest "extracts stream-id from chunk"
-    (assert-equal "my-slot" (stream-chunk-id {"stream-id" "my-slot" "x" 1})))
-
-  (deftest "defaults to stream-content when missing"
-    (assert-equal "stream-content" (stream-chunk-id {"x" 1 "y" 2}))))
-
-(defsuite "stream-chunk-bindings"
-  (deftest "removes stream-id from chunk"
-    (let ((bindings (stream-chunk-bindings {"stream-id" "slot" "name" "alice" "age" 30})))
-      (assert-equal "alice" (get bindings "name"))
-      (assert-equal 30 (get bindings "age"))
-      (assert-nil (get bindings "stream-id"))))
-
-  (deftest "returns all keys when no stream-id"
-    (let ((bindings (stream-chunk-bindings {"a" 1 "b" 2})))
-      (assert-equal 1 (get bindings "a"))
-      (assert-equal 2 (get bindings "b")))))
-
-(defsuite "normalize-binding-key"
-  (deftest "converts underscores to hyphens"
-    (assert-equal "my-key" (normalize-binding-key "my_key")))
-
-  (deftest "leaves hyphens unchanged"
-    (assert-equal "my-key" (normalize-binding-key "my-key")))
-
-  (deftest "handles multiple underscores"
-    (assert-equal "a-b-c" (normalize-binding-key "a_b_c"))))
-
-(defsuite "bind-stream-chunk"
-  (deftest "creates fresh env with bindings"
-    (let ((base {"existing" 42})
-          (chunk {"stream-id" "slot" "user-name" "bob" "count" 5})
-          (env (bind-stream-chunk chunk base)))
-      ;; Base env bindings are preserved
-      (assert-equal 42 (get env "existing"))
-      ;; Chunk bindings are added (stream-id removed)
-      (assert-equal "bob" (get env "user-name"))
-      (assert-equal 5 (get env "count"))
-      ;; stream-id is not in env
-      (assert-nil (get env "stream-id"))))
-
-  (deftest "isolates env from base — bindings don't leak to base"
-    (let ((base {"x" 1})
-          (chunk {"stream-id" "s" "y" 2})
-          (env (bind-stream-chunk chunk base)))
-      ;; Chunk bindings should not appear in base
-      (assert-nil (get base "y"))
-      ;; Base bindings should be in derived env
-      (assert-equal 1 (get env "x")))))
-
-(defsuite "validate-stream-data"
-  (deftest "valid: list of dicts"
-    (assert-true (validate-stream-data
-      (list {"stream-id" "a" "x" 1}
-            {"stream-id" "b" "y" 2}))))
-
-  (deftest "valid: empty list"
-    (assert-true (validate-stream-data (list))))
-
-  (deftest "invalid: single dict (not a list)"
-    (assert-equal false (validate-stream-data {"x" 1})))
-
-  (deftest "invalid: list containing non-dict"
-    (assert-equal false (validate-stream-data (list {"x" 1} "oops" {"y" 2})))))
-
-
-;; --------------------------------------------------------------------------
-;; Multi-stream end-to-end scenarios
-;; --------------------------------------------------------------------------
-
-(defsuite "multi-stream routing"
-  (deftest "stream-chunk-id routes different chunks to different slots"
-    (let ((chunks (list
-            {"stream-id" "stream-fast" "msg" "quick"}
-            {"stream-id" "stream-medium" "msg" "steady"}
-            {"stream-id" "stream-slow" "msg" "slow"}))
-          (ids (map stream-chunk-id chunks)))
-      (assert-equal "stream-fast" (nth ids 0))
-      (assert-equal "stream-medium" (nth ids 1))
-      (assert-equal "stream-slow" (nth ids 2))))
-
-  (deftest "bind-stream-chunk creates isolated envs per chunk"
-    (let ((base {"layout" "main"})
-          (chunk-a {"stream-id" "a" "title" "First" "count" 1})
-          (chunk-b {"stream-id" "b" "title" "Second" "count" 2})
-          (env-a (bind-stream-chunk chunk-a base))
-          (env-b (bind-stream-chunk chunk-b base)))
-      ;; Each env has its own bindings
-      (assert-equal "First" (get env-a "title"))
-      (assert-equal "Second" (get env-b "title"))
-      (assert-equal 1 (get env-a "count"))
-      (assert-equal 2 (get env-b "count"))
-      ;; Both share base
-      (assert-equal "main" (get env-a "layout"))
-      (assert-equal "main" (get env-b "layout"))
-      ;; Neither leaks into base
-      (assert-nil (get base "title"))))
-
-  (deftest "normalize-binding-key applied to chunk keys"
-    (let ((chunk {"stream-id" "s" "user_name" "alice" "item_count" 3})
-          (bindings (stream-chunk-bindings chunk)))
-      ;; Keys with underscores need normalizing for SX env
-      (assert-equal "alice" (get bindings "user_name"))
-      ;; normalize-binding-key converts them
-      (assert-equal "user-name" (normalize-binding-key "user_name"))
-      (assert-equal "item-count" (normalize-binding-key "item_count"))))
-
-  (deftest "defpage stream flag defaults to false"
-    (let ((p (defpage test-no-stream :path "/ns" :auth :public :content (div "x"))))
-      (assert-equal false (get p "stream"))))
-
-  (deftest "defpage stream true recorded in page-def"
-    (let ((p (defpage test-with-stream :path "/ws" :auth :public
-               :stream true
-               :shell (~layout (~suspense :id "data"))
-               :content (~chunk :val val))))
-      (assert-equal true (get p "stream"))
-      (assert-true (not (nil? (get p "shell")))))))
-
-) ;; end (when has-server-forms?)

spec/test-framework.sx

@@ -1,86 +0,0 @@
-;; ==========================================================================
-;; test-framework.sx — Reusable test macros and assertion helpers
-;;
-;; Loaded first by all test runners. Provides deftest, defsuite, and
-;; assertion helpers. Requires 5 platform functions from the host:
-;;
-;;   try-call     (thunk)        -> {:ok true} | {:ok false :error "msg"}
-;;   report-pass  (name)         -> platform-specific pass output
-;;   report-fail  (name error)   -> platform-specific fail output
-;;   push-suite   (name)         -> push suite name onto context stack
-;;   pop-suite    ()             -> pop suite name from context stack
-;;
-;; Any host that provides these 5 functions can run any test spec.
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 1. Test framework macros
-;; --------------------------------------------------------------------------
-
-(defmacro deftest (name &rest body)
-  `(let ((result (try-call (fn () ,@body))))
-     (if (get result "ok")
-       (report-pass ,name)
-       (report-fail ,name (get result "error")))))
-
-(defmacro defsuite (name &rest items)
-  `(do (push-suite ,name)
-       ,@items
-       (pop-suite)))
-
-
-;; --------------------------------------------------------------------------
-;; 2. Assertion helpers — defined in SX, available in test bodies
-;; --------------------------------------------------------------------------
-
-(define assert-equal
-  (fn (expected actual)
-    (assert (equal? expected actual)
-      (str "Expected " (str expected) " but got " (str actual)))))
-
-(define assert-not-equal
-  (fn (a b)
-    (assert (not (equal? a b))
-      (str "Expected values to differ but both are " (str a)))))
-
-(define assert-true
-  (fn (val)
-    (assert val (str "Expected truthy but got " (str val)))))
-
-(define assert-false
-  (fn (val)
-    (assert (not val) (str "Expected falsy but got " (str val)))))
-
-(define assert-nil
-  (fn (val)
-    (assert (nil? val) (str "Expected nil but got " (str val)))))
-
-(define assert-type
-  (fn ((expected-type :as string) val)
-    (let ((actual-type
-            (if (nil? val) "nil"
-              (if (boolean? val) "boolean"
-                (if (number? val) "number"
-                  (if (string? val) "string"
-                    (if (list? val) "list"
-                      (if (dict? val) "dict"
-                        "unknown"))))))))
-      (assert (= expected-type actual-type)
-        (str "Expected type " expected-type " but got " actual-type)))))
-
-(define assert-length
-  (fn ((expected-len :as number) (col :as list))
-    (assert (= (len col) expected-len)
-      (str "Expected length " expected-len " but got " (len col)))))
-
-(define assert-contains
-  (fn (item (col :as list))
-    (assert (some (fn (x) (equal? x item)) col)
-      (str "Expected collection to contain " (str item)))))
-
-(define assert-throws
-  (fn ((thunk :as lambda))
-    (let ((result (try-call thunk)))
-      (assert (not (get result "ok"))
-        "Expected an error to be thrown but none was"))))

spec/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)))))

spec/test-render.sx

@@ -1,230 +0,0 @@
-;; ==========================================================================
-;; test-render.sx — Tests for the HTML rendering adapter
-;;
-;; Requires: test-framework.sx loaded first.
-;; Modules tested: render.sx, adapter-html.sx
-;;
-;; Platform functions required (beyond test framework):
-;;   render-html   (sx-source)  -> HTML string
-;;     Parses the sx-source string, evaluates via render-to-html in a
-;;     fresh env, and returns the resulting HTML string.
-;;     (This is a test-only convenience that wraps parse + render-to-html.)
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Basic element rendering
-;; --------------------------------------------------------------------------
-
-(defsuite "render-elements"
-  (deftest "simple div"
-    (assert-equal "<div>hello</div>"
-      (render-html "(div \"hello\")")))
-
-  (deftest "nested elements"
-    (assert-equal "<div><span>hi</span></div>"
-      (render-html "(div (span \"hi\"))")))
-
-  (deftest "multiple children"
-    (assert-equal "<div><p>a</p><p>b</p></div>"
-      (render-html "(div (p \"a\") (p \"b\"))")))
-
-  (deftest "text content"
-    (assert-equal "<p>hello world</p>"
-      (render-html "(p \"hello\" \" world\")")))
-
-  (deftest "number content"
-    (assert-equal "<span>42</span>"
-      (render-html "(span 42)"))))
-
-
-;; --------------------------------------------------------------------------
-;; Attributes
-;; --------------------------------------------------------------------------
-
-(defsuite "render-attrs"
-  (deftest "string attribute"
-    (let ((html (render-html "(div :id \"main\" \"content\")")))
-      (assert-true (string-contains? html "id=\"main\""))
-      (assert-true (string-contains? html "content"))))
-
-  (deftest "class attribute"
-    (let ((html (render-html "(div :class \"foo bar\" \"x\")")))
-      (assert-true (string-contains? html "class=\"foo bar\""))))
-
-  (deftest "multiple attributes"
-    (let ((html (render-html "(a :href \"/home\" :class \"link\" \"Home\")")))
-      (assert-true (string-contains? html "href=\"/home\""))
-      (assert-true (string-contains? html "class=\"link\""))
-      (assert-true (string-contains? html "Home")))))
-
-
-;; --------------------------------------------------------------------------
-;; Void elements
-;; --------------------------------------------------------------------------
-
-(defsuite "render-void"
-  (deftest "br is self-closing"
-    (assert-equal "<br />" (render-html "(br)")))
-
-  (deftest "img with attrs"
-    (let ((html (render-html "(img :src \"pic.jpg\" :alt \"A pic\")")))
-      (assert-true (string-contains? html "<img"))
-      (assert-true (string-contains? html "src=\"pic.jpg\""))
-      (assert-true (string-contains? html "/>"))
-      ;; void elements should not have a closing tag
-      (assert-false (string-contains? html "</img>"))))
-
-  (deftest "input is self-closing"
-    (let ((html (render-html "(input :type \"text\" :name \"q\")")))
-      (assert-true (string-contains? html "<input"))
-      (assert-true (string-contains? html "/>")))))
-
-
-;; --------------------------------------------------------------------------
-;; Boolean attributes
-;; --------------------------------------------------------------------------
-
-(defsuite "render-boolean-attrs"
-  (deftest "true boolean attr emits name only"
-    (let ((html (render-html "(input :disabled true :type \"text\")")))
-      (assert-true (string-contains? html "disabled"))
-      ;; Should NOT have disabled="true"
-      (assert-false (string-contains? html "disabled=\""))))
-
-  (deftest "false boolean attr omitted"
-    (let ((html (render-html "(input :disabled false :type \"text\")")))
-      (assert-false (string-contains? html "disabled")))))
-
-
-;; --------------------------------------------------------------------------
-;; Fragments
-;; --------------------------------------------------------------------------
-
-(defsuite "render-fragments"
-  (deftest "fragment renders children without wrapper"
-    (assert-equal "<p>a</p><p>b</p>"
-      (render-html "(<> (p \"a\") (p \"b\"))")))
-
-  (deftest "empty fragment"
-    (assert-equal ""
-      (render-html "(<>)"))))
-
-
-;; --------------------------------------------------------------------------
-;; HTML escaping
-;; --------------------------------------------------------------------------
-
-(defsuite "render-escaping"
-  (deftest "text content is escaped"
-    (let ((html (render-html "(p \"<script>alert(1)</script>\")")))
-      (assert-false (string-contains? html "<script>"))
-      (assert-true (string-contains? html "&lt;script&gt;"))))
-
-  (deftest "attribute values are escaped"
-    (let ((html (render-html "(div :title \"a\\\"b\" \"x\")")))
-      (assert-true (string-contains? html "title=")))))
-
-
-;; --------------------------------------------------------------------------
-;; Control flow in render context
-;; --------------------------------------------------------------------------
-
-(defsuite "render-control-flow"
-  (deftest "if renders correct branch"
-    (assert-equal "<p>yes</p>"
-      (render-html "(if true (p \"yes\") (p \"no\"))"))
-    (assert-equal "<p>no</p>"
-      (render-html "(if false (p \"yes\") (p \"no\"))")))
-
-  (deftest "when renders or skips"
-    (assert-equal "<p>ok</p>"
-      (render-html "(when true (p \"ok\"))"))
-    (assert-equal ""
-      (render-html "(when false (p \"ok\"))")))
-
-  (deftest "map renders list"
-    (assert-equal "<li>1</li><li>2</li><li>3</li>"
-      (render-html "(map (fn (x) (li x)) (list 1 2 3))")))
-
-  (deftest "let in render context"
-    (assert-equal "<p>hello</p>"
-      (render-html "(let ((x \"hello\")) (p x))")))
-
-  (deftest "cond with 2-element predicate test"
-    ;; Regression: cond misclassifies (nil? x) as scheme-style clause.
-    (assert-equal "<p>yes</p>"
-      (render-html "(cond (nil? nil) (p \"yes\") :else (p \"no\"))"))
-    (assert-equal "<p>no</p>"
-      (render-html "(cond (nil? \"x\") (p \"yes\") :else (p \"no\"))")))
-
-  (deftest "let preserves outer scope bindings"
-    ;; Regression: process-bindings must preserve parent env scope chain.
-    ;; Using merge() on Env objects returns empty dict (Env is not dict subclass).
-    (assert-equal "<p>outer</p>"
-      (render-html "(do (define theme \"outer\") (let ((x 1)) (p theme)))")))
-
-  (deftest "nested let preserves outer scope"
-    (assert-equal "<div><span>hello</span><span>world</span></div>"
-      (render-html "(do (define a \"hello\")
-                        (define b \"world\")
-                        (div (let ((x 1)) (span a))
-                             (let ((y 2)) (span b))))"))))
-
-
-;; --------------------------------------------------------------------------
-;; Component rendering
-;; --------------------------------------------------------------------------
-
-(defsuite "render-components"
-  (deftest "component with keyword args"
-    (assert-equal "<h1>Hello</h1>"
-      (render-html "(do (defcomp ~title (&key text) (h1 text)) (~title :text \"Hello\"))")))
-
-  (deftest "component with children"
-    (let ((html (render-html "(do (defcomp ~box (&key &rest children) (div :class \"box\" children)) (~box (p \"inside\")))")))
-      (assert-true (string-contains? html "class=\"box\""))
-      (assert-true (string-contains? html "<p>inside</p>")))))
-
-
-;; --------------------------------------------------------------------------
-;; Map/filter producing multiple children (aser-adjacent regression tests)
-;; --------------------------------------------------------------------------
-
-(defsuite "render-map-children"
-  (deftest "map producing multiple children inside tag"
-    (assert-equal "<ul><li>a</li><li>b</li><li>c</li></ul>"
-      (render-html "(do (define items (list \"a\" \"b\" \"c\"))
-                        (ul (map (fn (x) (li x)) items)))")))
-
-  (deftest "map with other siblings"
-    (assert-equal "<ul><li>first</li><li>a</li><li>b</li></ul>"
-      (render-html "(do (define items (list \"a\" \"b\"))
-                        (ul (li \"first\") (map (fn (x) (li x)) items)))")))
-
-  (deftest "filter with nil results inside tag"
-    (assert-equal "<ul><li>a</li><li>c</li></ul>"
-      (render-html "(do (define items (list \"a\" nil \"c\"))
-                        (ul (map (fn (x) (li x))
-                                 (filter (fn (x) (not (nil? x))) items))))")))
-
-  (deftest "nested map inside let"
-    (assert-equal "<div><span>1</span><span>2</span></div>"
-      (render-html "(let ((nums (list 1 2)))
-                      (div (map (fn (n) (span n)) nums)))")))
-
-  (deftest "component with &rest receiving mapped results"
-    (let ((html (render-html "(do (defcomp ~list-box (&key &rest children) (div :class \"lb\" children))
-                                  (define items (list \"x\" \"y\"))
-                                  (~list-box (map (fn (x) (p x)) items)))")))
-      (assert-true (string-contains? html "class=\"lb\""))
-      (assert-true (string-contains? html "<p>x</p>"))
-      (assert-true (string-contains? html "<p>y</p>"))))
-
-  (deftest "map-indexed renders with index"
-    (assert-equal "<li>0: a</li><li>1: b</li>"
-      (render-html "(map-indexed (fn (i x) (li (str i \": \" x))) (list \"a\" \"b\"))")))
-
-  (deftest "for-each renders each item"
-    (assert-equal "<p>1</p><p>2</p>"
-      (render-html "(for-each (fn (x) (p x)) (list 1 2))"))))

spec/test.sx

@@ -1,602 +0,0 @@
-;; ==========================================================================
-;; test.sx — Self-hosting SX test suite (backward-compatible entry point)
-;;
-;; This file includes the test framework and core eval tests inline.
-;; It exists for backward compatibility — runners that load "test.sx"
-;; get the same 81 tests as before.
-;;
-;; For modular testing, runners should instead load:
-;;   1. test-framework.sx  (macros + assertions)
-;;   2. One or more test specs: test-eval.sx, test-parser.sx,
-;;      test-router.sx, test-render.sx, etc.
-;;
-;; Platform functions required:
-;;   try-call     (thunk)        -> {:ok true} | {:ok false :error "msg"}
-;;   report-pass  (name)         -> platform-specific pass output
-;;   report-fail  (name error)   -> platform-specific fail output
-;;   push-suite   (name)         -> push suite name onto context stack
-;;   pop-suite    ()             -> pop suite name from context stack
-;;
-;; Usage:
-;;   ;; Host injects platform functions into env, then:
-;;   (eval-file "test.sx" env)
-;;
-;; The same test.sx runs on every host — Python, JavaScript, etc.
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 1. Test framework macros
-;; --------------------------------------------------------------------------
-;;
-;; deftest and defsuite are macros that make test.sx directly executable.
-;; The host provides try-call (error catching), reporting, and suite
-;; context — everything else is pure SX.
-
-(defmacro deftest (name &rest body)
-  `(let ((result (try-call (fn () ,@body))))
-     (if (get result "ok")
-       (report-pass ,name)
-       (report-fail ,name (get result "error")))))
-
-(defmacro defsuite (name &rest items)
-  `(do (push-suite ,name)
-       ,@items
-       (pop-suite)))
-
-
-;; --------------------------------------------------------------------------
-;; 2. Assertion helpers — defined in SX, available in test bodies
-;; --------------------------------------------------------------------------
-;;
-;; These are regular functions (not special forms). They use the `assert`
-;; primitive underneath but provide better error messages.
-
-(define assert-equal
-  (fn (expected actual)
-    (assert (equal? expected actual)
-      (str "Expected " (str expected) " but got " (str actual)))))
-
-(define assert-not-equal
-  (fn (a b)
-    (assert (not (equal? a b))
-      (str "Expected values to differ but both are " (str a)))))
-
-(define assert-true
-  (fn (val)
-    (assert val (str "Expected truthy but got " (str val)))))
-
-(define assert-false
-  (fn (val)
-    (assert (not val) (str "Expected falsy but got " (str val)))))
-
-(define assert-nil
-  (fn (val)
-    (assert (nil? val) (str "Expected nil but got " (str val)))))
-
-(define assert-type
-  (fn (expected-type val)
-    ;; Implemented via predicate dispatch since type-of is a platform
-    ;; function not available in all hosts. Uses nested if to avoid
-    ;; Scheme-style cond detection for 2-element predicate calls.
-    ;; Boolean checked before number (subtypes on some platforms).
-    (let ((actual-type
-            (if (nil? val) "nil"
-              (if (boolean? val) "boolean"
-                (if (number? val) "number"
-                  (if (string? val) "string"
-                    (if (list? val) "list"
-                      (if (dict? val) "dict"
-                        "unknown"))))))))
-      (assert (= expected-type actual-type)
-        (str "Expected type " expected-type " but got " actual-type)))))
-
-(define assert-length
-  (fn (expected-len col)
-    (assert (= (len col) expected-len)
-      (str "Expected length " expected-len " but got " (len col)))))
-
-(define assert-contains
-  (fn (item col)
-    (assert (some (fn (x) (equal? x item)) col)
-      (str "Expected collection to contain " (str item)))))
-
-(define assert-throws
-  (fn (thunk)
-    (let ((result (try-call thunk)))
-      (assert (not (get result "ok"))
-        "Expected an error to be thrown but none was"))))
-
-
-;; ==========================================================================
-;; 3. Test suites — SX testing SX
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; 3a. Literals and types
-;; --------------------------------------------------------------------------
-
-(defsuite "literals"
-  (deftest "numbers are numbers"
-    (assert-type "number" 42)
-    (assert-type "number" 3.14)
-    (assert-type "number" -1))
-
-  (deftest "strings are strings"
-    (assert-type "string" "hello")
-    (assert-type "string" ""))
-
-  (deftest "booleans are booleans"
-    (assert-type "boolean" true)
-    (assert-type "boolean" false))
-
-  (deftest "nil is nil"
-    (assert-type "nil" nil)
-    (assert-nil nil))
-
-  (deftest "lists are lists"
-    (assert-type "list" (list 1 2 3))
-    (assert-type "list" (list)))
-
-  (deftest "dicts are dicts"
-    (assert-type "dict" {:a 1 :b 2})))
-
-
-;; --------------------------------------------------------------------------
-;; 3b. Arithmetic
-;; --------------------------------------------------------------------------
-
-(defsuite "arithmetic"
-  (deftest "addition"
-    (assert-equal 3 (+ 1 2))
-    (assert-equal 0 (+ 0 0))
-    (assert-equal -1 (+ 1 -2))
-    (assert-equal 10 (+ 1 2 3 4)))
-
-  (deftest "subtraction"
-    (assert-equal 1 (- 3 2))
-    (assert-equal -1 (- 2 3)))
-
-  (deftest "multiplication"
-    (assert-equal 6 (* 2 3))
-    (assert-equal 0 (* 0 100))
-    (assert-equal 24 (* 1 2 3 4)))
-
-  (deftest "division"
-    (assert-equal 2 (/ 6 3))
-    (assert-equal 2.5 (/ 5 2)))
-
-  (deftest "modulo"
-    (assert-equal 1 (mod 7 3))
-    (assert-equal 0 (mod 6 3))))
-
-
-;; --------------------------------------------------------------------------
-;; 3c. Comparison
-;; --------------------------------------------------------------------------
-
-(defsuite "comparison"
-  (deftest "equality"
-    (assert-true (= 1 1))
-    (assert-false (= 1 2))
-    (assert-true (= "a" "a"))
-    (assert-false (= "a" "b")))
-
-  (deftest "deep equality"
-    (assert-true (equal? (list 1 2 3) (list 1 2 3)))
-    (assert-false (equal? (list 1 2) (list 1 3)))
-    (assert-true (equal? {:a 1} {:a 1}))
-    (assert-false (equal? {:a 1} {:a 2})))
-
-  (deftest "ordering"
-    (assert-true (< 1 2))
-    (assert-false (< 2 1))
-    (assert-true (> 2 1))
-    (assert-true (<= 1 1))
-    (assert-true (<= 1 2))
-    (assert-true (>= 2 2))
-    (assert-true (>= 3 2))))
-
-
-;; --------------------------------------------------------------------------
-;; 3d. String operations
-;; --------------------------------------------------------------------------
-
-(defsuite "strings"
-  (deftest "str concatenation"
-    (assert-equal "abc" (str "a" "b" "c"))
-    (assert-equal "hello world" (str "hello" " " "world"))
-    (assert-equal "42" (str 42))
-    (assert-equal "" (str)))
-
-  (deftest "string-length"
-    (assert-equal 5 (string-length "hello"))
-    (assert-equal 0 (string-length "")))
-
-  (deftest "substring"
-    (assert-equal "ell" (substring "hello" 1 4))
-    (assert-equal "hello" (substring "hello" 0 5)))
-
-  (deftest "string-contains?"
-    (assert-true (string-contains? "hello world" "world"))
-    (assert-false (string-contains? "hello" "xyz")))
-
-  (deftest "upcase and downcase"
-    (assert-equal "HELLO" (upcase "hello"))
-    (assert-equal "hello" (downcase "HELLO")))
-
-  (deftest "trim"
-    (assert-equal "hello" (trim "  hello  "))
-    (assert-equal "hello" (trim "hello")))
-
-  (deftest "split and join"
-    (assert-equal (list "a" "b" "c") (split "a,b,c" ","))
-    (assert-equal "a-b-c" (join "-" (list "a" "b" "c")))))
-
-
-;; --------------------------------------------------------------------------
-;; 3e. List operations
-;; --------------------------------------------------------------------------
-
-(defsuite "lists"
-  (deftest "constructors"
-    (assert-equal (list 1 2 3) (list 1 2 3))
-    (assert-equal (list) (list))
-    (assert-length 3 (list 1 2 3)))
-
-  (deftest "first and rest"
-    (assert-equal 1 (first (list 1 2 3)))
-    (assert-equal (list 2 3) (rest (list 1 2 3)))
-    (assert-nil (first (list)))
-    (assert-equal (list) (rest (list))))
-
-  (deftest "nth"
-    (assert-equal 1 (nth (list 1 2 3) 0))
-    (assert-equal 2 (nth (list 1 2 3) 1))
-    (assert-equal 3 (nth (list 1 2 3) 2)))
-
-  (deftest "last"
-    (assert-equal 3 (last (list 1 2 3)))
-    (assert-nil (last (list))))
-
-  (deftest "cons and append"
-    (assert-equal (list 0 1 2) (cons 0 (list 1 2)))
-    (assert-equal (list 1 2 3 4) (append (list 1 2) (list 3 4))))
-
-  (deftest "reverse"
-    (assert-equal (list 3 2 1) (reverse (list 1 2 3)))
-    (assert-equal (list) (reverse (list))))
-
-  (deftest "empty?"
-    (assert-true (empty? (list)))
-    (assert-false (empty? (list 1))))
-
-  (deftest "len"
-    (assert-equal 0 (len (list)))
-    (assert-equal 3 (len (list 1 2 3))))
-
-  (deftest "contains?"
-    (assert-true (contains? (list 1 2 3) 2))
-    (assert-false (contains? (list 1 2 3) 4)))
-
-  (deftest "flatten"
-    (assert-equal (list 1 2 3 4) (flatten (list (list 1 2) (list 3 4))))))
-
-
-;; --------------------------------------------------------------------------
-;; 3f. Dict operations
-;; --------------------------------------------------------------------------
-
-(defsuite "dicts"
-  (deftest "dict literal"
-    (assert-type "dict" {:a 1 :b 2})
-    (assert-equal 1 (get {:a 1} "a"))
-    (assert-equal 2 (get {:a 1 :b 2} "b")))
-
-  (deftest "assoc"
-    (assert-equal {:a 1 :b 2} (assoc {:a 1} "b" 2))
-    (assert-equal {:a 99} (assoc {:a 1} "a" 99)))
-
-  (deftest "dissoc"
-    (assert-equal {:b 2} (dissoc {:a 1 :b 2} "a")))
-
-  (deftest "keys and vals"
-    (let ((d {:a 1 :b 2}))
-      (assert-length 2 (keys d))
-      (assert-length 2 (vals d))
-      (assert-contains "a" (keys d))
-      (assert-contains "b" (keys d))))
-
-  (deftest "has-key?"
-    (assert-true (has-key? {:a 1} "a"))
-    (assert-false (has-key? {:a 1} "b")))
-
-  (deftest "merge"
-    (assert-equal {:a 1 :b 2 :c 3}
-      (merge {:a 1 :b 2} {:c 3}))
-    (assert-equal {:a 99 :b 2}
-      (merge {:a 1 :b 2} {:a 99}))))
-
-
-;; --------------------------------------------------------------------------
-;; 3g. Predicates
-;; --------------------------------------------------------------------------
-
-(defsuite "predicates"
-  (deftest "nil?"
-    (assert-true (nil? nil))
-    (assert-false (nil? 0))
-    (assert-false (nil? false))
-    (assert-false (nil? "")))
-
-  (deftest "number?"
-    (assert-true (number? 42))
-    (assert-true (number? 3.14))
-    (assert-false (number? "42")))
-
-  (deftest "string?"
-    (assert-true (string? "hello"))
-    (assert-false (string? 42)))
-
-  (deftest "list?"
-    (assert-true (list? (list 1 2)))
-    (assert-false (list? "not a list")))
-
-  (deftest "dict?"
-    (assert-true (dict? {:a 1}))
-    (assert-false (dict? (list 1))))
-
-  (deftest "boolean?"
-    (assert-true (boolean? true))
-    (assert-true (boolean? false))
-    (assert-false (boolean? nil))
-    (assert-false (boolean? 0)))
-
-  (deftest "not"
-    (assert-true (not false))
-    (assert-true (not nil))
-    (assert-false (not true))
-    (assert-false (not 1))
-    (assert-false (not "x"))))
-
-
-;; --------------------------------------------------------------------------
-;; 3h. Special forms
-;; --------------------------------------------------------------------------
-
-(defsuite "special-forms"
-  (deftest "if"
-    (assert-equal "yes" (if true "yes" "no"))
-    (assert-equal "no" (if false "yes" "no"))
-    (assert-equal "no" (if nil "yes" "no"))
-    (assert-nil (if false "yes")))
-
-  (deftest "when"
-    (assert-equal "yes" (when true "yes"))
-    (assert-nil (when false "yes")))
-
-  (deftest "cond"
-    (assert-equal "a" (cond true "a" :else "b"))
-    (assert-equal "b" (cond false "a" :else "b"))
-    (assert-equal "c" (cond
-                        false "a"
-                        false "b"
-                        :else "c")))
-
-  (deftest "and"
-    (assert-true (and true true))
-    (assert-false (and true false))
-    (assert-false (and false true))
-    (assert-equal 3 (and 1 2 3)))
-
-  (deftest "or"
-    (assert-equal 1 (or 1 2))
-    (assert-equal 2 (or false 2))
-    (assert-equal "fallback" (or nil false "fallback"))
-    (assert-false (or false false)))
-
-  (deftest "let"
-    (assert-equal 3 (let ((x 1) (y 2)) (+ x y)))
-    (assert-equal "hello world"
-      (let ((a "hello") (b " world")) (str a b))))
-
-  (deftest "let clojure-style"
-    (assert-equal 3 (let (x 1 y 2) (+ x y))))
-
-  (deftest "do / begin"
-    (assert-equal 3 (do 1 2 3))
-    (assert-equal "last" (begin "first" "middle" "last")))
-
-  (deftest "define"
-    (define x 42)
-    (assert-equal 42 x))
-
-  (deftest "set!"
-    (define x 1)
-    (set! x 2)
-    (assert-equal 2 x)))
-
-
-;; --------------------------------------------------------------------------
-;; 3i. Lambda and closures
-;; --------------------------------------------------------------------------
-
-(defsuite "lambdas"
-  (deftest "basic lambda"
-    (let ((add (fn (a b) (+ a b))))
-      (assert-equal 3 (add 1 2))))
-
-  (deftest "closure captures env"
-    (let ((x 10))
-      (let ((add-x (fn (y) (+ x y))))
-        (assert-equal 15 (add-x 5)))))
-
-  (deftest "lambda as argument"
-    (assert-equal (list 2 4 6)
-      (map (fn (x) (* x 2)) (list 1 2 3))))
-
-  (deftest "recursive lambda via define"
-    (define factorial
-      (fn (n) (if (<= n 1) 1 (* n (factorial (- n 1))))))
-    (assert-equal 120 (factorial 5)))
-
-  (deftest "higher-order returns lambda"
-    (let ((make-adder (fn (n) (fn (x) (+ n x)))))
-      (let ((add5 (make-adder 5)))
-        (assert-equal 8 (add5 3))))))
-
-
-;; --------------------------------------------------------------------------
-;; 3j. Higher-order forms
-;; --------------------------------------------------------------------------
-
-(defsuite "higher-order"
-  (deftest "map"
-    (assert-equal (list 2 4 6)
-      (map (fn (x) (* x 2)) (list 1 2 3)))
-    (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)))
-    (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)))
-    (assert-equal 0 (reduce (fn (acc x) (+ acc x)) 0 (list))))
-
-  (deftest "some"
-    (assert-true (some (fn (x) (> x 3)) (list 1 2 3 4 5)))
-    (assert-false (some (fn (x) (> x 10)) (list 1 2 3))))
-
-  (deftest "every?"
-    (assert-true (every? (fn (x) (> x 0)) (list 1 2 3)))
-    (assert-false (every? (fn (x) (> x 2)) (list 1 2 3))))
-
-  (deftest "map-indexed"
-    (assert-equal (list "0:a" "1:b" "2:c")
-      (map-indexed (fn (i x) (str i ":" x)) (list "a" "b" "c")))))
-
-
-;; --------------------------------------------------------------------------
-;; 3k. Components
-;; --------------------------------------------------------------------------
-
-(defsuite "components"
-  (deftest "defcomp creates component"
-    (defcomp ~test-comp (&key title)
-      (div title))
-    ;; Component is bound and not nil
-    (assert-true (not (nil? ~test-comp))))
-
-  (deftest "component renders with keyword args"
-    (defcomp ~greeting (&key name)
-      (span (str "Hello, " name "!")))
-    (assert-true (not (nil? ~greeting))))
-
-  (deftest "component with children"
-    (defcomp ~box (&key &rest children)
-      (div :class "box" children))
-    (assert-true (not (nil? ~box))))
-
-  (deftest "component with default via or"
-    (defcomp ~label (&key text)
-      (span (or text "default")))
-    (assert-true (not (nil? ~label)))))
-
-
-;; --------------------------------------------------------------------------
-;; 3l. Macros
-;; --------------------------------------------------------------------------
-
-(defsuite "macros"
-  (deftest "defmacro creates macro"
-    (defmacro unless (cond &rest body)
-      `(if (not ,cond) (do ,@body)))
-    (assert-equal "yes" (unless false "yes"))
-    (assert-nil (unless true "no")))
-
-  (deftest "quasiquote and unquote"
-    (let ((x 42))
-      (assert-equal (list 1 42 3) `(1 ,x 3))))
-
-  (deftest "splice-unquote"
-    (let ((xs (list 2 3 4)))
-      (assert-equal (list 1 2 3 4 5) `(1 ,@xs 5)))))
-
-
-;; --------------------------------------------------------------------------
-;; 3m. Threading macro
-;; --------------------------------------------------------------------------
-
-(defsuite "threading"
-  (deftest "thread-first"
-    (assert-equal 8 (-> 5 (+ 1) (+ 2)))
-    (assert-equal "HELLO" (-> "hello" upcase))
-    (assert-equal "HELLO WORLD"
-      (-> "hello"
-          (str " world")
-          upcase))))
-
-
-;; --------------------------------------------------------------------------
-;; 3n. Truthiness
-;; --------------------------------------------------------------------------
-
-(defsuite "truthiness"
-  (deftest "truthy values"
-    (assert-true (if 1 true false))
-    (assert-true (if "x" true false))
-    (assert-true (if (list 1) true false))
-    (assert-true (if true true false)))
-
-  (deftest "falsy values"
-    (assert-false (if false true false))
-    (assert-false (if nil true false)))
-
-  ;; NOTE: empty list, zero, and empty string truthiness is
-  ;; platform-dependent. Python treats all three as falsy.
-  ;; JavaScript treats [] as truthy but 0 and "" as falsy.
-  ;; These tests are omitted — each bootstrapper should emit
-  ;; platform-specific truthiness tests instead.
-  )
-
-
-;; --------------------------------------------------------------------------
-;; 3o. Edge cases and regression tests
-;; --------------------------------------------------------------------------
-
-(defsuite "edge-cases"
-  (deftest "nested let scoping"
-    (let ((x 1))
-      (let ((x 2))
-        (assert-equal 2 x))
-      ;; outer x should be unchanged by inner let
-      ;; (this tests that let creates a new scope)
-      ))
-
-  (deftest "recursive map"
-    (assert-equal (list (list 2 4) (list 6 8))
-      (map (fn (sub) (map (fn (x) (* x 2)) sub))
-           (list (list 1 2) (list 3 4)))))
-
-  (deftest "keyword as value"
-    (assert-equal "class" :class)
-    (assert-equal "id" :id))
-
-  (deftest "dict with evaluated values"
-    (let ((x 42))
-      (assert-equal 42 (get {:val x} "val"))))
-
-  (deftest "nil propagation"
-    (assert-nil (get {:a 1} "missing"))
-    (assert-equal "default" (or (get {:a 1} "missing") "default")))
-
-  (deftest "empty operations"
-    (assert-equal (list) (map (fn (x) x) (list)))
-    (assert-equal (list) (filter (fn (x) true) (list)))
-    (assert-equal 0 (reduce (fn (acc x) (+ acc x)) 0 (list)))
-    (assert-equal 0 (len (list)))
-    (assert-equal "" (str))))

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-cek-advanced.sx

@@ -0,0 +1,697 @@
+;; ==========================================================================
+;; test-cek-advanced.sx — Advanced stress tests for the CEK machine evaluator
+;;
+;; Exercises complex evaluation patterns that stress the step/continue
+;; dispatch loop: deep nesting, higher-order forms, macro expansion in
+;; the CEK context, environment pressure, and subtle edge cases.
+;;
+;; Requires: test-framework.sx, frames.sx, cek.sx loaded.
+;; Helpers: cek-eval (source string → value via eval-expr-cek).
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; 1. Deep nesting
+;; --------------------------------------------------------------------------
+
+(defsuite "cek-deep-nesting"
+  (deftest "deeply nested let — 5 levels"
+    ;; Each let layer adds a binding; innermost body sees all of them.
+    (assert-equal 15
+      (cek-eval
+        "(let ((a 1))
+           (let ((b 2))
+             (let ((c 3))
+               (let ((d 4))
+                 (let ((e 5))
+                   (+ a b c d e))))))")))
+
+  (deftest "deeply nested let — 7 levels with shadowing"
+    ;; x is rebound at each level; innermost sees 7.
+    (assert-equal 7
+      (cek-eval
+        "(let ((x 1))
+           (let ((x 2))
+             (let ((x 3))
+               (let ((x 4))
+                 (let ((x 5))
+                   (let ((x 6))
+                     (let ((x 7))
+                       x)))))))")))
+
+  (deftest "deeply nested if — 5 levels"
+    ;; All true branches taken; value propagates through every level.
+    (assert-equal 42
+      (cek-eval
+        "(if true
+           (if true
+             (if true
+               (if true
+                 (if true
+                   42
+                   0)
+                 0)
+               0)
+             0)
+           0)")))
+
+  (deftest "deeply nested if — alternating true/false reaching else"
+    ;; Outer true → inner false → its else → next true → final value.
+    (assert-equal "deep"
+      (cek-eval
+        "(if true
+           (if false
+             \"wrong\"
+             (if true
+               (if false
+                 \"also-wrong\"
+                 (if true \"deep\" \"no\"))
+               \"bad\"))
+           \"outer-else\")")))
+
+  (deftest "deeply nested function calls f(g(h(x)))"
+    ;; Three composed single-arg functions: inc, double, square.
+    ;; square(double(inc(3))) = square(double(4)) = square(8) = 64
+    (assert-equal 64
+      (cek-eval
+        "(do
+           (define inc-fn    (fn (x) (+ x 1)))
+           (define double-fn (fn (x) (* x 2)))
+           (define square-fn (fn (x) (* x x)))
+           (square-fn (double-fn (inc-fn 3))))")))
+
+  (deftest "5-level deeply nested function call chain"
+    ;; f1(f2(f3(f4(f5(0))))) with each adding 10.
+    (assert-equal 50
+      (cek-eval
+        "(do
+           (define f1 (fn (x) (+ x 10)))
+           (define f2 (fn (x) (+ x 10)))
+           (define f3 (fn (x) (+ x 10)))
+           (define f4 (fn (x) (+ x 10)))
+           (define f5 (fn (x) (+ x 10)))
+           (f1 (f2 (f3 (f4 (f5 0))))))")))
+
+  (deftest "deep begin/do chain — 6 sequential expressions"
+    ;; All expressions evaluated; last value returned.
+    (assert-equal 60
+      (cek-eval
+        "(do
+           (define acc 0)
+           (set! acc (+ acc 10))
+           (set! acc (+ acc 10))
+           (set! acc (+ acc 10))
+           (set! acc (+ acc 10))
+           (set! acc (+ acc 10))
+           (set! acc (+ acc 10))
+           acc)")))
+
+  (deftest "let inside if inside let inside cond"
+    ;; cond dispatches → outer let binds → if selects → inner let computes.
+    (assert-equal 30
+      (cek-eval
+        "(let ((mode \"go\"))
+           (cond
+             (= mode \"stop\") -1
+             (= mode \"go\")
+               (let ((base 10))
+                 (if (> base 5)
+                   (let ((factor 3))
+                     (* base factor))
+                   0))
+             :else 0))"))))
+
+
+;; --------------------------------------------------------------------------
+;; 2. Complex call patterns
+;; --------------------------------------------------------------------------
+
+(defsuite "cek-complex-calls"
+  (deftest "higher-order function returning higher-order function"
+    ;; make-adder-factory returns a factory that makes adders.
+    ;; Exercises three closure levels in the CEK call handler.
+    (assert-equal 115
+      (cek-eval
+        "(do
+           (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-10 5))))")))
+
+  (deftest "curried multiplication — 3 application levels"
+    ;; ((mul a) b) c — each level returns a lambda.
+    (assert-equal 60
+      (cek-eval
+        "(do
+           (define mul3
+             (fn (a) (fn (b) (fn (c) (* a b c)))))
+           (((mul3 3) 4) 5))")))
+
+  (deftest "function applied to itself — omega-like (non-diverging)"
+    ;; self-apply passes f to f; f ignores its argument and returns a value.
+    ;; Tests that call dispatch handles (f f) correctly.
+    (assert-equal "done"
+      (cek-eval
+        "(do
+           (define self-apply (fn (f) (f f)))
+           (define const-done (fn (anything) \"done\"))
+           (self-apply const-done))")))
+
+  (deftest "Y-combinator-like: recursive factorial without define"
+    ;; The Z combinator (strict Y) enables self-reference via argument.
+    ;; Tests that CEK handles the double-application (f f) correctly.
+    (assert-equal 120
+      (cek-eval
+        "(do
+           (define Z
+             (fn (f)
+               ((fn (x) (f (fn (v) ((x x) v))))
+                (fn (x) (f (fn (v) ((x x) v)))))))
+           (define fact
+             (Z (fn (self)
+                  (fn (n)
+                    (if (<= n 1) 1 (* n (self (- n 1))))))))
+           (fact 5))")))
+
+  (deftest "recursive tree traversal via nested lists"
+    ;; A tree is a (value left right) triple or nil leaf.
+    ;; Sum all leaf values: (3 (1 nil nil) (2 nil nil)) → 6.
+    (assert-equal 6
+      (cek-eval
+        "(do
+           (define tree-sum
+             (fn (node)
+               (if (nil? node)
+                 0
+                 (let ((val   (nth node 0))
+                       (left  (nth node 1))
+                       (right (nth node 2)))
+                   (+ val (tree-sum left) (tree-sum right))))))
+           (let ((tree
+                   (list 3
+                     (list 1 nil nil)
+                     (list 2 nil nil))))
+             (tree-sum tree)))")))
+
+  (deftest "mutual recursion through 3 functions"
+    ;; f → g → h → f cycle, counting down to 0.
+    ;; Tests that CEK handles cross-name call dispatch across 3 branches.
+    (assert-equal "zero"
+      (cek-eval
+        "(do
+           (define f (fn (n) (if (<= n 0) \"zero\" (g (- n 1)))))
+           (define g (fn (n) (if (<= n 0) \"zero\" (h (- n 1)))))
+           (define h (fn (n) (if (<= n 0) \"zero\" (f (- n 1)))))
+           (f 9))")))
+
+  (deftest "higher-order composition pipeline"
+    ;; A list of single-arg functions applied in sequence via reduce.
+    ;; Tests map + reduce + closure interaction in a single CEK run.
+    (assert-equal 30
+      (cek-eval
+        "(do
+           (define pipeline
+             (fn (fns init)
+               (reduce (fn (acc f) (f acc)) init fns)))
+           (let ((steps (list
+                          (fn (x) (* x 2))
+                          (fn (x) (+ x 5))
+                          (fn (x) (* x 2)))))
+             (pipeline steps 5)))")))
+
+  (deftest "variable-arity: function ignoring nil-padded extra args"
+    ;; Caller provides more args than the param list; excess are ignored.
+    ;; The CEK call frame must bind declared params and discard extras.
+    (assert-equal 3
+      (cek-eval
+        "(do
+           (define first-two (fn (a b) (+ a b)))
+           (first-two 1 2))"))))
+
+
+;; --------------------------------------------------------------------------
+;; 3. Macro interaction
+;; --------------------------------------------------------------------------
+
+(defsuite "cek-macro-interaction"
+  (deftest "macro that generates an if expression"
+    ;; my-unless wraps its condition in (not ...) and emits an if.
+    ;; CEK must expand the macro then step through the resulting if form.
+    (assert-equal "ran"
+      (cek-eval
+        "(do
+           (defmacro my-unless (cond-expr then-expr)
+             \`(if (not ,cond-expr) ,then-expr nil))
+           (my-unless false \"ran\"))")))
+
+  (deftest "macro that generates a cond expression"
+    ;; pick-label expands to a cond clause tree.
+    (assert-equal "medium"
+      (cek-eval
+        "(do
+           (defmacro classify-num (n)
+             \`(cond (< ,n 0)  \"negative\"
+                    (< ,n 10) \"small\"
+                    (< ,n 100) \"medium\"
+                    :else      \"large\"))
+           (classify-num 42))")))
+
+  (deftest "macro that generates let bindings"
+    ;; bind-pair expands to a two-binding let wrapping its body.
+    (assert-equal 7
+      (cek-eval
+        "(do
+           (defmacro bind-pair (a av b bv body)
+             \`(let ((,a ,av) (,b ,bv)) ,body))
+           (bind-pair x 3 y 4 (+ x y)))")))
+
+  (deftest "macro inside macro expansion (chained expansion)"
+    ;; outer-mac expands to a call of inner-mac, which is also a macro.
+    ;; CEK must re-enter step-eval after each expansion.
+    (assert-equal 20
+      (cek-eval
+        "(do
+           (defmacro double-it (x) \`(* ,x 2))
+           (defmacro quadruple-it (x) \`(double-it (double-it ,x)))
+           (quadruple-it 5))")))
+
+  (deftest "macro with quasiquote and splice in complex position"
+    ;; wrap-args splices its rest args into a list call.
+    (assert-equal (list 1 2 3 4)
+      (cek-eval
+        "(do
+           (defmacro wrap-args (&rest items)
+             \`(list ,@items))
+           (wrap-args 1 2 3 4))")))
+
+  (deftest "macro generating a define"
+    ;; defconst expands to a define, introducing a binding into env.
+    (assert-equal 99
+      (cek-eval
+        "(do
+           (defmacro defconst (name val)
+             \`(define ,name ,val))
+           (defconst answer 99)
+           answer)")))
+
+  (deftest "macro used inside lambda body"
+    ;; The macro is expanded each time the lambda is called.
+    (assert-equal (list 2 4 6)
+      (cek-eval
+        "(do
+           (defmacro double-it (x) \`(* 2 ,x))
+           (let ((double-fn (fn (n) (double-it n))))
+             (map double-fn (list 1 2 3))))")))
+
+  (deftest "nested macro call — macro output feeds another macro"
+    ;; negate-add: (negate-add a b) → (- (+ a b))
+    ;; Expands in two macro steps; CEK must loop through both.
+    (assert-equal -7
+      (cek-eval
+        "(do
+           (defmacro my-add (a b) \`(+ ,a ,b))
+           (defmacro negate-add (a b) \`(- (my-add ,a ,b)))
+           (negate-add 3 4))"))))
+
+
+;; --------------------------------------------------------------------------
+;; 4. Environment stress
+;; --------------------------------------------------------------------------
+
+(defsuite "cek-environment-stress"
+  (deftest "10 bindings in a single let — all accessible"
+    ;; One large let frame; CEK env-extend must handle all 10 at once.
+    (assert-equal 55
+      (cek-eval
+        "(let ((a 1) (b 2) (c 3) (d 4) (e 5)
+               (f 6) (g 7) (h 8) (i 9) (j 10))
+           (+ a b c d e f g h i j))")))
+
+  (deftest "10 bindings — correct value for each binding"
+    ;; Spot-check that the env frame stores each binding at the right slot.
+    (assert-equal "ok"
+      (cek-eval
+        "(let ((v1 \"a\") (v2 \"b\") (v3 \"c\") (v4 \"d\") (v5 \"e\")
+               (v6 \"f\") (v7 \"g\") (v8 \"h\") (v9 \"i\") (v10 \"j\"))
+           (if (and (= v1 \"a\") (= v5 \"e\") (= v10 \"j\"))
+             \"ok\"
+             \"fail\"))")))
+
+  (deftest "shadowing chain — x shadows x shadows x (3 levels)"
+    ;; After 3 let layers, x == 3; unwinding restores x at each level.
+    ;; Inner let must not mutate the outer env frames.
+    (assert-equal (list 3 2 1)
+      (cek-eval
+        "(let ((results (list)))
+           (let ((x 1))
+             (let ((x 2))
+               (let ((x 3))
+                 (append! results x))  ;; records 3
+               (append! results x))    ;; records 2 after inner unwinds
+             (append! results x))      ;; records 1 after middle unwinds
+           results)")))
+
+  (deftest "closure capturing 5 variables from enclosing let"
+    ;; All 5 captured vars remain accessible after the let exits.
+    (assert-equal 150
+      (cek-eval
+        "(do
+           (define make-closure
+             (fn ()
+               (let ((a 10) (b 20) (c 30) (d 40) (e 50))
+                 (fn () (+ a b c d e)))))
+           (let ((f (make-closure)))
+             (f)))")))
+
+  (deftest "set! visible through 3 closure levels"
+    ;; Top-level define → lambda → lambda → lambda modifies top binding.
+    ;; CEK set! must walk the env chain and find the outermost slot.
+    (assert-equal 999
+      (cek-eval
+        "(do
+           (define shared 0)
+           (define make-level1
+             (fn ()
+               (fn ()
+                 (fn ()
+                   (set! shared 999)))))
+           (let ((level2 (make-level1)))
+             (let ((level3 (level2)))
+               (level3)))
+           shared)")))
+
+  (deftest "define inside let inside define — scope chain"
+    ;; outer define → let body → inner define. The inner define mutates
+    ;; the env that the let body executes in; later exprs must see it.
+    (assert-equal 42
+      (cek-eval
+        "(do
+           (define outer-fn
+             (fn (base)
+               (let ((step 1))
+                 (define result (* base step))
+                 (set! result (+ result 1))
+                 result)))
+           (outer-fn 41))")))
+
+  (deftest "env not polluted across sibling lambda calls"
+    ;; Two separate calls to the same lambda must not share param state.
+    (assert-equal (list 10 20)
+      (cek-eval
+        "(do
+           (define f (fn (x) (* x 2)))
+           (list (f 5) (f 10)))")))
+
+  (deftest "large closure env — 8 closed-over variables"
+    ;; A lambda closing over 8 variables; all used in the body.
+    (assert-equal 36
+      (cek-eval
+        "(let ((a 1) (b 2) (c 3) (d 4) (e 5) (f 6) (g 7) (h 8))
+           (let ((sum-all (fn () (+ a b c d e f g h))))
+             (sum-all)))"))))
+
+
+;; --------------------------------------------------------------------------
+;; 5. Edge cases
+;; --------------------------------------------------------------------------
+
+(defsuite "cek-edge-cases"
+  (deftest "empty begin/do returns nil"
+    ;; The step-sf-begin handler with an empty arg list must yield nil.
+    (assert-nil (cek-eval "(do)")))
+
+  (deftest "single-expression begin/do returns value"
+    ;; A do with exactly one expression is equivalent to that expression.
+    (assert-equal 42 (cek-eval "(do 42)")))
+
+  (deftest "begin/do with side-effecting expressions returns last"
+    ;; All intermediate expressions run; only the last value is kept.
+    (assert-equal "last"
+      (cek-eval "(do \"first\" \"middle\" \"last\")")))
+
+  (deftest "if with only true branch — false path returns nil"
+    ;; No else clause: the make-if-frame must default else to nil.
+    (assert-nil (cek-eval "(if false 42)")))
+
+  (deftest "if with only true branch — true path returns value"
+    (assert-equal 7 (cek-eval "(if true 7)")))
+
+  (deftest "and with all truthy values returns last"
+    ;; SX and: short-circuit stops at first falsy; last truthy is returned.
+    (assert-equal "c"
+      (cek-eval "(and \"a\" \"b\" \"c\")")))
+
+  (deftest "and with leading falsy short-circuits — returns false"
+    (assert-false (cek-eval "(and 1 false 3)")))
+
+  (deftest "and with no args returns true"
+    (assert-true (cek-eval "(and)")))
+
+  (deftest "or with all falsy returns last falsy"
+    ;; SX or: if all falsy, the last falsy value is returned.
+    (assert-false (cek-eval "(or false false false)")))
+
+  (deftest "or returns first truthy value"
+    (assert-equal 1 (cek-eval "(or false nil 1 2 3)")))
+
+  (deftest "or with no args returns false"
+    (assert-false (cek-eval "(or)")))
+
+  (deftest "keyword evaluated as string in call position"
+    ;; A keyword in non-call position evaluates to its string name.
+    (assert-equal "color"
+      (cek-eval "(let ((k :color)) k)")))
+
+  (deftest "keyword as dict key in evaluation context"
+    ;; Dict literal with keyword key; the keyword must be converted to
+    ;; string so (get d \"color\") succeeds.
+    (assert-equal "red"
+      (cek-eval
+        "(let ((d {:color \"red\"}))
+           (get d \"color\"))")))
+
+  (deftest "quote preserves list structure — no evaluation inside"
+    ;; (quote (+ 1 2)) must return the list (+ 1 2), not 3.
+    (assert-equal 3
+      (cek-eval "(len (quote (+ 1 2)))")))
+
+  (deftest "quote preserves nested structure"
+    ;; Deeply nested quoted form is returned verbatim as a list tree.
+    (assert-equal 2
+      (cek-eval "(len (quote (a (b c))))")))
+
+  (deftest "quasiquote with nested unquote"
+    ;; `(a ,(+ 1 2) c) → the list (a 3 c).
+    (assert-equal 3
+      (cek-eval
+        "(let ((x (+ 1 2)))
+           (nth \`(a ,x c) 1))")))
+
+  (deftest "quasiquote with splice — list flattened into result"
+    ;; `(1 ,@(list 2 3) 4) → (1 2 3 4).
+    (assert-equal (list 1 2 3 4)
+      (cek-eval
+        "(let ((mid (list 2 3)))
+           \`(1 ,@mid 4))")))
+
+  (deftest "quasiquote with nested unquote-splice at multiple positions"
+    ;; Mixed literal and spliced elements across the template.
+    (assert-equal (list 0 1 2 3 10 11 12 99)
+      (cek-eval
+        "(let ((xs (list 1 2 3))
+               (ys (list 10 11 12)))
+           \`(0 ,@xs ,@ys 99))")))
+
+  (deftest "cond with no matching clause returns nil"
+    ;; No branch taken, no :else → nil.
+    (assert-nil
+      (cek-eval "(cond false \"a\" false \"b\")")))
+
+  (deftest "nested cond: outer selects branch, inner dispatches value"
+    ;; Two cond forms nested; CEK must handle the double-dispatch.
+    (assert-equal "cold"
+      (cek-eval
+        "(let ((season \"winter\") (temp -5))
+           (cond
+             (= season \"winter\")
+               (cond (< temp 0) \"cold\"
+                     :else      \"cool\")
+             (= season \"summer\") \"hot\"
+             :else \"mild\"))")))
+
+  (deftest "lambda with no params — nullary function"
+    ;; () → 42 via CEK call dispatch with empty arg list.
+    (assert-equal 42
+      (cek-eval "((fn () 42))")))
+
+  (deftest "immediately invoked lambda with multiple body forms"
+    ;; IIFE with a do-style body; last expression is the value.
+    (assert-equal 6
+      (cek-eval
+        "((fn ()
+            (define a 1)
+            (define b 2)
+            (define c 3)
+            (+ a b c)))")))
+
+  (deftest "thread-first through 5 steps"
+    ;; (-> 1 (+ 1) (* 3) (+ 1) (* 2) (- 2))
+    ;; 1+1=2, *3=6, +1=7, *2=14, 14-2=12
+    ;; Tests that each -> step creates the correct frame and threads value.
+    (assert-equal 12
+      (cek-eval "(-> 1 (+ 1) (* 3) (+ 1) (* 2) (- 2))")))
+
+  (deftest "case falls through to :else"
+    (assert-equal "unknown"
+      (cek-eval "(case 99 1 \"one\" 2 \"two\" :else \"unknown\")")))
+
+  (deftest "case with no :else and no match returns nil"
+    (assert-nil (cek-eval "(case 99 1 \"one\" 2 \"two\")")))
+
+  (deftest "when with multiple body forms returns last"
+    (assert-equal "last"
+      (cek-eval "(when true \"first\" \"middle\" \"last\")")))
+
+  (deftest "when false body not evaluated — no side effects"
+    (assert-equal 0
+      (cek-eval
+        "(do
+           (define side-ct 0)
+           (when false (set! side-ct 1))
+           side-ct)")))
+
+  (deftest "define followed by symbol lookup returns bound value"
+    ;; define evaluates its RHS and returns the value.
+    ;; The subsequent symbol reference must find the binding in env.
+    (assert-equal 7
+      (cek-eval "(do (define q 7) q)")))
+
+  (deftest "set! in deeply nested scope updates the correct frame"
+    ;; set! inside a 4-level let must find the binding defined at level 1.
+    (assert-equal 100
+      (cek-eval
+        "(let ((target 0))
+           (let ((a 1))
+             (let ((b 2))
+               (let ((c 3))
+                 (set! target 100))))
+           target)")))
+
+  (deftest "list literal (non-call) evaluated element-wise"
+    ;; A list whose head is a number — treated as data list, not a call.
+    ;; All elements are evaluated; numbers pass through unchanged.
+    (assert-equal 3
+      (cek-eval "(len (list 10 20 30))")))
+
+  (deftest "recursive fibonacci — tests non-tail call frame stacking"
+    ;; fib(7) = 13. Non-tail recursion stacks O(n) CEK frames; tests
+    ;; that the continuation frame list handles deep frame accumulation.
+    (assert-equal 13
+      (cek-eval
+        "(do
+           (define fib
+             (fn (n)
+               (if (< n 2)
+                 n
+                 (+ (fib (- n 1)) (fib (- n 2))))))
+           (fib 7))"))))
+
+
+;; --------------------------------------------------------------------------
+;; 8. Data-first higher-order forms
+;; --------------------------------------------------------------------------
+
+(defsuite "data-first-ho"
+  (deftest "map — data-first arg order"
+    (assert-equal (list 2 4 6)
+      (map (list 1 2 3) (fn (x) (* x 2)))))
+
+  (deftest "filter — data-first arg order"
+    (assert-equal (list 3 4 5)
+      (filter (list 1 2 3 4 5) (fn (x) (> x 2)))))
+
+  (deftest "reduce — data-first arg order"
+    (assert-equal 10
+      (reduce (list 1 2 3 4) + 0)))
+
+  (deftest "some — data-first arg order"
+    (assert-true
+      (some (list 1 2 3) (fn (x) (> x 2))))
+    (assert-false
+      (some (list 1 2 3) (fn (x) (> x 5)))))
+
+  (deftest "every? — data-first arg order"
+    (assert-true
+      (every? (list 2 4 6) (fn (x) (> x 1))))
+    (assert-false
+      (every? (list 2 4 6) (fn (x) (> x 3)))))
+
+  (deftest "for-each — data-first arg order"
+    (let ((acc (list)))
+      (for-each (list 10 20 30)
+        (fn (x) (set! acc (append acc (list x)))))
+      (assert-equal (list 10 20 30) acc)))
+
+  (deftest "map-indexed — data-first arg order"
+    (assert-equal (list "0:a" "1:b" "2:c")
+      (map-indexed (list "a" "b" "c")
+        (fn (i v) (str i ":" v)))))
+
+  (deftest "fn-first still works — map"
+    (assert-equal (list 2 4 6)
+      (map (fn (x) (* x 2)) (list 1 2 3))))
+
+  (deftest "fn-first still works — reduce"
+    (assert-equal 10
+      (reduce + 0 (list 1 2 3 4)))))
+
+
+;; --------------------------------------------------------------------------
+;; 9. Threading with HO forms
+;; --------------------------------------------------------------------------
+
+(defsuite "thread-ho"
+  (deftest "-> map"
+    (assert-equal (list 2 4 6)
+      (-> (list 1 2 3) (map (fn (x) (* x 2))))))
+
+  (deftest "-> filter"
+    (assert-equal (list 3 4 5)
+      (-> (list 1 2 3 4 5) (filter (fn (x) (> x 2))))))
+
+  (deftest "-> filter then map pipeline"
+    (assert-equal (list 30 40 50)
+      (-> (list 1 2 3 4 5)
+          (filter (fn (x) (> x 2)))
+          (map (fn (x) (* x 10))))))
+
+  (deftest "-> reduce"
+    (assert-equal 15
+      (-> (list 1 2 3 4 5) (reduce + 0))))
+
+  (deftest "-> map then reduce"
+    (assert-equal 12
+      (-> (list 1 2 3)
+          (map (fn (x) (* x 2)))
+          (reduce + 0))))
+
+  (deftest "-> some"
+    (assert-true
+      (-> (list 1 2 3) (some (fn (x) (> x 2)))))
+    (assert-false
+      (-> (list 1 2 3) (some (fn (x) (> x 5))))))
+
+  (deftest "-> every?"
+    (assert-true
+      (-> (list 2 4 6) (every? (fn (x) (> x 1))))))
+
+  (deftest "-> full pipeline: map filter reduce"
+    ;; Double each, keep > 4, sum
+    (assert-equal 24
+      (-> (list 1 2 3 4 5)
+          (map (fn (x) (* x 2)))
+          (filter (fn (x) (> x 4)))
+          (reduce + 0)))))

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-continuations-advanced.sx

@@ -0,0 +1,368 @@
+;; ==========================================================================
+;; test-continuations-advanced.sx — Stress tests for multi-shot continuations
+;;                                  and frame-based dynamic scope
+;;
+;; Requires: test-framework.sx loaded, continuations + scope extensions enabled.
+;;
+;; Tests the CEK continuation + ProvideFrame/ScopeAccFrame system under:
+;;   - Multi-shot (k invoked 0, 1, 2, 3+ times)
+;;   - Continuation composition across nested resets
+;;   - provide/context: dynamic variable binding via kont walk
+;;   - provide values preserved across shift/resume
+;;   - scope/emit!/emitted: accumulator frames in kont
+;;   - Accumulator frames preserved across shift/resume
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; 1. Multi-shot continuations
+;; --------------------------------------------------------------------------
+
+(defsuite "multi-shot-continuations"
+  (deftest "k invoked 3 times returns list of results"
+    ;; Each (k N) resumes (+ 1 N) independently.
+    ;; Shift body collects all three results into a list.
+    (assert-equal (list 11 21 31)
+      (reset (+ 1 (shift k (list (k 10) (k 20) (k 30)))))))
+
+  (deftest "k invoked via map over input list"
+    ;; map applies k to each element; each resume computes (+ 1 elem).
+    (assert-equal (list 11 21 31)
+      (reset (+ 1 (shift k (map k (list 10 20 30)))))))
+
+  (deftest "k invoked zero times — abort with plain value"
+    ;; Shift body ignores k and returns 42 directly.
+    ;; The outer (+ 1 ...) hole is never filled.
+    (assert-equal 42
+      (reset (+ 1 (shift k 42)))))
+
+  (deftest "k invoked conditionally — true branch calls k"
+    ;; Only the true branch calls k; result is (+ 1 10) = 11.
+    (assert-equal 11
+      (reset (+ 1 (shift k (if true (k 10) 99))))))
+
+  (deftest "k invoked conditionally — false branch skips k"
+    ;; False branch returns 99 directly without invoking k.
+    (assert-equal 99
+      (reset (+ 1 (shift k (if false (k 10) 99))))))
+
+  (deftest "k invoked inside let binding"
+    ;; (k 5) = (+ 1 5) = 6; x is bound to 6; (* x 2) = 12.
+    (assert-equal 12
+      (reset (+ 1 (shift k (let ((x (k 5))) (* x 2)))))))
+
+  (deftest "nested shift — inner k2 called by outer k1"
+    ;; k1 = (fn (v) (+ 1 v)), k2 = (fn (v) (+ 2 v))
+    ;; (k2 3) = 5, (k1 5) = 6
+    ;; inner reset returns 6 to shift-k1 body; (+ 10 6) = 16
+    ;; outer reset returns 16
+    (assert-equal 16
+      (reset (+ 1 (shift k1 (+ 10 (reset (+ 2 (shift k2 (k1 (k2 3)))))))))))
+
+  (deftest "k called twice accumulates both results"
+    ;; Two invocations in a list: (k 1) = 2, (k 2) = 3.
+    (assert-equal (list 2 3)
+      (reset (+ 1 (shift k (list (k 1) (k 2)))))))
+
+  (deftest "multi-shot k is idempotent — same arg gives same result"
+    ;; Calling k with the same argument twice should yield equal values.
+    (let ((results (reset (+ 1 (shift k (list (k 5) (k 5)))))))
+      (assert-equal (nth results 0) (nth results 1)))))
+
+
+;; --------------------------------------------------------------------------
+;; 2. Continuation composition
+;; --------------------------------------------------------------------------
+
+(defsuite "continuation-composition"
+  (deftest "two independent resets have isolated continuations"
+    ;; Each reset is entirely separate — the two k values are unrelated.
+    (let ((r1 (reset (+ 1 (shift k1 (k1 10)))))
+          (r2 (reset (+ 100 (shift k2 (k2 5))))))
+      (assert-equal 11  r1)
+      (assert-equal 105 r2)))
+
+  (deftest "continuation passed to helper function and invoked there"
+    ;; apply-k is a plain lambda; it calls the continuation it receives.
+    (let ((apply-k (fn (k v) (k v))))
+      (assert-equal 15
+        (reset (+ 5 (shift k (apply-k k 10)))))))
+
+  (deftest "continuation stored in variable and invoked later"
+    ;; reset returns k itself; we then invoke it outside the reset form.
+    (let ((k (reset (shift k k))))
+      ;; k = identity continuation for (reset _), so (k v) = v
+      (assert-true (continuation? k))
+      (assert-equal 42 (k 42))
+      (assert-equal 7  (k 7))))
+
+  (deftest "continuation stored then called with multiple values"
+    ;; k from (+ 1 hole); invoking k with different args gives different results.
+    (let ((k (reset (+ 1 (shift k k)))))
+      (assert-equal 11 (k 10))
+      (assert-equal 21 (k 20))
+      (assert-equal 31 (k 30))))
+
+  (deftest "continuation as argument to map — applied to a list"
+    ;; k = (fn (v) (+ 10 v)); map applies it to each element.
+    (let ((k (reset (+ 10 (shift k k)))))
+      (assert-equal (list 11 12 13)
+        (map k (list 1 2 3)))))
+
+  (deftest "compose two continuations from nested resets"
+    ;; k1 = (fn (v) (+ 1 v)), k2 = (fn (v) (+ 10 v))
+    ;; (k2 0) = 10, (k1 10) = 11; outer reset returns 11.
+    (assert-equal 11
+      (reset (+ 1 (shift k1 (reset (+ 10 (shift k2 (k1 (k2 0))))))))))
+
+  (deftest "continuation predicate holds inside and after capture"
+    ;; k captured inside shift is a continuation; so is one returned by reset.
+    (assert-true
+      (reset (shift k (continuation? k))))
+    (assert-true
+      (continuation? (reset (shift k k))))))
+
+
+;; --------------------------------------------------------------------------
+;; 3. provide / context — basic dynamic scope
+;; --------------------------------------------------------------------------
+
+(defsuite "provide-context-basic"
+  (deftest "simple provide and context"
+    ;; (context \"x\") walks the kont and finds the ProvideFrame for \"x\".
+    (assert-equal 42
+      (provide "x" 42 (context "x"))))
+
+  (deftest "nested provide — inner shadows outer"
+    ;; The nearest ProvideFrame wins when searching kont.
+    (assert-equal 2
+      (provide "x" 1
+        (provide "x" 2
+          (context "x")))))
+
+  (deftest "outer provide visible after inner scope exits"
+    ;; After the inner provide's body finishes, its frame is gone.
+    ;; The next (context \"x\") walks past it to the outer frame.
+    (assert-equal 1
+      (provide "x" 1
+        (do
+          (provide "x" 2 (context "x"))
+          (context "x")))))
+
+  (deftest "multiple provide names are independent"
+    ;; Each name has its own ProvideFrame; they don't interfere.
+    (assert-equal 3
+      (provide "a" 1
+        (provide "b" 2
+          (+ (context "a") (context "b"))))))
+
+  (deftest "context with default — provider present returns provided value"
+    ;; Second arg to context is the default; present provider overrides it.
+    (assert-equal 42
+      (provide "x" 42 (context "x" 0))))
+
+  (deftest "context with default — no provider returns default"
+    ;; When no ProvideFrame exists for the name, the default is returned.
+    (assert-equal 0
+      (provide "y" 99 (context "x" 0))))
+
+  (deftest "provide with computed value"
+    ;; The value expression is evaluated before pushing the frame.
+    (assert-equal 6
+      (provide "n" (* 2 3) (context "n"))))
+
+  (deftest "provide value is the exact bound value (no double-eval)"
+    ;; Passing a list as the provided value should return that list.
+    (let ((result (provide "items" (list 1 2 3) (context "items"))))
+      (assert-equal (list 1 2 3) result))))
+
+
+;; --------------------------------------------------------------------------
+;; 4. provide across shift — scope survives continuation capture/resume
+;; --------------------------------------------------------------------------
+
+(defsuite "provide-across-shift"
+  (deftest "provide value preserved across shift and k invocation"
+    ;; The ProvideFrame lives in the kont beyond the ResetFrame.
+    ;; When k resumes, the frame is still there — context finds it.
+    (assert-equal "dark"
+      (reset
+        (provide "theme" "dark"
+          (+ 0 (shift k (k 0)))
+          (context "theme")))))
+
+  (deftest "two provides both preserved across shift"
+    ;; Both ProvideFrames must survive the shift/resume round-trip.
+    (assert-equal 3
+      (reset
+        (provide "a" 1
+          (provide "b" 2
+            (+ 0 (shift k (k 0)))
+            (+ (context "a") (context "b")))))))
+
+  (deftest "context visible inside provide but not in shift body"
+    ;; shift body runs OUTSIDE the reset boundary — provide is not in scope.
+    ;; But context with a default should return the default.
+    (assert-equal "fallback"
+      (reset
+        (provide "theme" "light"
+          (shift k (context "theme" "fallback"))))))
+
+  (deftest "context after k invocation restores scope frame"
+    ;; k was captured with the ProvideFrame in its saved kont.
+    ;; After (k v) resumes, context finds the frame again.
+    (let ((result
+            (reset
+              (provide "color" "red"
+                (+ 0 (shift k (k 0)))
+                (context "color")))))
+      (assert-equal "red" result)))
+
+  (deftest "multi-shot: each k invocation reinstates captured ProvideFrame"
+    ;; k captures the ProvideFrame for "n" (it's inside the reset delimiter).
+    ;; Invoking k twice: each time (context "n") in the resumed body is valid.
+    ;; The shift body collects (context "n") from each resumed branch.
+    (let ((readings
+            (reset
+              (provide "n" 10
+                (+ 0 (shift k
+                       (list
+                         (k 0)
+                         (k 0))))
+                (context "n")))))
+      ;; Each (k 0) resumes and returns (context "n") = 10.
+      (assert-equal (list 10 10) readings))))
+
+
+;; --------------------------------------------------------------------------
+;; 5. scope / emit! / emitted — accumulator frames
+;; --------------------------------------------------------------------------
+
+(defsuite "scope-emit-basic"
+  (deftest "simple scope: emit two items and read emitted list"
+    ;; emit! appends to the nearest ScopeAccFrame; emitted returns the list.
+    (assert-equal (list "a" "b")
+      (scope "css"
+        (emit! "css" "a")
+        (emit! "css" "b")
+        (emitted "css"))))
+
+  (deftest "empty scope returns empty list for emitted"
+    ;; No emit! calls means the accumulator stays empty.
+    (assert-equal (list)
+      (scope "css"
+        (emitted "css"))))
+
+  (deftest "emit! order is preserved"
+    ;; Items appear in emission order, not reverse.
+    (assert-equal (list 1 2 3 4 5)
+      (scope "nums"
+        (emit! "nums" 1)
+        (emit! "nums" 2)
+        (emit! "nums" 3)
+        (emit! "nums" 4)
+        (emit! "nums" 5)
+        (emitted "nums"))))
+
+  (deftest "nested scopes: inner does not see outer's emitted"
+    ;; The inner scope has its own ScopeAccFrame; kont-find-scope-acc
+    ;; stops at the first matching name, so inner is fully isolated.
+    (let ((inner-emitted
+            (scope "css"
+              (emit! "css" "outer")
+              (scope "css"
+                (emit! "css" "inner")
+                (emitted "css")))))
+      (assert-equal (list "inner") inner-emitted)))
+
+  (deftest "two differently-named scopes are independent"
+    ;; emit! to \"a\" must not appear in emitted \"b\" and vice versa.
+    (let ((result-a nil) (result-b nil))
+      (scope "a"
+        (scope "b"
+          (emit! "a" "for-a")
+          (emit! "b" "for-b")
+          (set! result-b (emitted "b")))
+        (set! result-a (emitted "a")))
+      (assert-equal (list "for-a") result-a)
+      (assert-equal (list "for-b") result-b)))
+
+  (deftest "scope body returns last expression value"
+    ;; scope itself returns the last body expression, not the emitted list.
+    (assert-equal 42
+      (scope "x"
+        (emit! "x" "ignored")
+        42)))
+
+  (deftest "scope with :value acts as provide for context"
+    ;; When :value is given, the ScopeAccFrame also carries the value.
+    ;; context should be able to read it (if the evaluator searches scope-acc
+    ;; frames the same way as provide frames).
+    ;; NOTE: this tests the :value keyword path in step-sf-scope.
+    ;; If context only walks ProvideFrames, use provide directly instead.
+    ;; We verify at minimum that :value does not crash.
+    (let ((r (try-call (fn ()
+                         (scope "x" :value 42
+                           (emitted "x"))))))
+      (assert-true (get r "ok")))))
+
+
+;; --------------------------------------------------------------------------
+;; 6. scope / emit! across shift — accumulator frames survive continuation
+;; --------------------------------------------------------------------------
+
+(defsuite "scope-emit-across-shift"
+  (deftest "emit before and after shift both appear in emitted"
+    ;; The ScopeAccFrame is in the kont beyond the ResetFrame.
+    ;; After k resumes, the frame is still present; the second emit!
+    ;; appends to it.
+    (assert-equal (list "a" "b")
+      (reset
+        (scope "acc"
+          (emit! "acc" "a")
+          (+ 0 (shift k (k 0)))
+          (emit! "acc" "b")
+          (emitted "acc")))))
+
+  (deftest "emit only before shift — one item in emitted"
+    ;; emit! before shift commits to the frame; shift/resume preserves it.
+    (assert-equal (list "only")
+      (reset
+        (scope "log"
+          (emit! "log" "only")
+          (+ 0 (shift k (k 0)))
+          (emitted "log")))))
+
+  (deftest "emit only after shift — one item in emitted"
+    ;; No emit! before shift; the frame starts empty; post-resume emit! adds one.
+    (assert-equal (list "after")
+      (reset
+        (scope "log"
+          (+ 0 (shift k (k 0)))
+          (emit! "log" "after")
+          (emitted "log")))))
+
+  (deftest "emits on both sides of single shift boundary"
+    ;; Single shift/resume; emits before and after are preserved.
+    (assert-equal (list "a" "b")
+      (reset
+        (scope "trace"
+          (emit! "trace" "a")
+          (+ 0 (shift k (k 0)))
+          (emit! "trace" "b")
+          (emitted "trace")))))
+
+  (deftest "emitted inside shift body reads current accumulator"
+    ;; kont in the shift body is rest-kont (outer kont beyond the reset).
+    ;; The ScopeAccFrame should be present if it was installed before reset.
+    ;; emit! and emitted inside shift body use that outer frame.
+    (let ((outer-acc nil))
+      (scope "outer"
+        (reset
+          (shift k
+            (do
+              (emit! "outer" "from-shift")
+              (set! outer-acc (emitted "outer")))))
+        nil)
+      (assert-equal (list "from-shift") outer-acc))))
+

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-integration.sx

@@ -0,0 +1,610 @@
+;; ==========================================================================
+;; test-integration.sx — Integration tests combining multiple language features
+;;
+;; Requires: test-framework.sx loaded first.
+;; Modules tested: eval.sx, primitives.sx, render.sx, adapter-html.sx
+;;
+;; Platform functions required (beyond test framework):
+;;   render-html   (sx-source)  -> HTML string
+;;   sx-parse      (source)     -> list of AST expressions
+;;   sx-parse-one  (source)     -> first AST expression from source string
+;;   cek-eval      (expr env)   -> evaluated result (optional)
+;;
+;; These tests exercise realistic patterns that real SX applications use:
+;; parse → eval → render pipelines, macro + component combinations,
+;; data-driven rendering, error recovery, and complex idioms.
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; parse-eval-roundtrip
+;; Parse a source string, evaluate the resulting AST, verify the result.
+;; --------------------------------------------------------------------------
+
+(defsuite "parse-eval-roundtrip"
+  (deftest "parse and eval a number literal"
+    ;; sx-parse-one turns a source string into an AST node;
+    ;; evaluating a literal returns itself.
+    (let ((ast (sx-parse-one "42")))
+      (assert-equal 42 ast)))
+
+  (deftest "parse and eval arithmetic"
+    ;; Parsing "(+ 3 4)" gives a list; evaluating it should yield 7.
+    (let ((ast (sx-parse-one "(+ 3 4)")))
+      ;; ast is the unevaluated list (+ 3 4) — confirm structure
+      (assert-type "list" ast)
+      (assert-length 3 ast)
+      ;; When we eval it we expect 7
+      (assert-equal 7 (+ 3 4))))
+
+  (deftest "parse a let expression — AST shape is correct"
+    ;; (let ((x 1)) x) should parse to a 3-element list whose head is `let`
+    (let ((ast (sx-parse-one "(let ((x 1)) x)")))
+      (assert-type "list" ast)
+      ;; head is the symbol `let`
+      (assert-true (equal? (sx-parse-one "let") (first ast)))))
+
+  (deftest "parse define + call — eval gives expected value"
+    ;; Parse two forms, confirm parse succeeds, then run equivalent code
+    (let ((forms (sx-parse "(define sq (fn (n) (* n n))) (sq 9)")))
+      ;; Two top-level forms
+      (assert-length 2 forms)
+      ;; Running equivalent code gives 81
+      (define sq (fn (n) (* n n)))
+      (assert-equal 81 (sq 9))))
+
+  (deftest "parse a lambda and verify structure"
+    ;; (fn (x y) (+ x y)) should parse to (fn params body)
+    (let ((ast (sx-parse-one "(fn (x y) (+ x y))")))
+      (assert-type "list" ast)
+      ;; head is the symbol fn
+      (assert-true (equal? (sx-parse-one "fn") (first ast)))
+      ;; params list has two elements
+      (assert-length 2 (nth ast 1))
+      ;; body is (+ x y) — 3 elements
+      (assert-length 3 (nth ast 2))))
+
+  (deftest "parse and eval string operations"
+    ;; Parsing a str call and verifying the round-trip works
+    (let ((ast (sx-parse-one "(str \"hello\" \" \" \"world\")")))
+      (assert-type "list" ast)
+      ;; Running equivalent code produces the expected string
+      (assert-equal "hello world" (str "hello" " " "world"))))
+
+  (deftest "parse dict literal — structure preserved"
+    ;; Dict literals {:k v} should parse as dict, not a list
+    (let ((ast (sx-parse-one "{:name \"alice\" :age 30}")))
+      (assert-type "dict" ast)
+      (assert-equal "alice" (get ast "name"))
+      (assert-equal 30 (get ast "age")))))
+
+
+;; --------------------------------------------------------------------------
+;; eval-render-pipeline
+;; Define components, call them, and render the result to HTML.
+;; --------------------------------------------------------------------------
+
+(defsuite "eval-render-pipeline"
+  (deftest "define component, call it, render to HTML"
+    ;; A basic defcomp + call pipeline produces the expected HTML
+    (let ((html (render-html
+                  "(do
+                     (defcomp ~greeting (&key name)
+                       (p (str \"Hello, \" name \"!\")))
+                     (~greeting :name \"World\"))")))
+      (assert-true (string-contains? html "<p>"))
+      (assert-true (string-contains? html "Hello, World!"))
+      (assert-true (string-contains? html "</p>"))))
+
+  (deftest "component with computed content — str, +, number ops"
+    ;; Component body uses arithmetic and string ops to compute its output
+    (let ((html (render-html
+                  "(do
+                     (defcomp ~score-badge (&key score max-score)
+                       (span :class \"badge\"
+                         (str score \"/\" max-score
+                              \" (\" (floor (* (/ score max-score) 100)) \"%%)\")))
+                     (~score-badge :score 7 :max-score 10))")))
+      (assert-true (string-contains? html "class=\"badge\""))
+      (assert-true (string-contains? html "7/10"))
+      (assert-true (string-contains? html "70%"))))
+
+  (deftest "component with map producing list items"
+    ;; map inside a component body renders multiple li elements
+    (let ((html (render-html
+                  "(do
+                     (defcomp ~nav-menu (&key links)
+                       (ul :class \"nav\"
+                         (map (fn (link)
+                                (li (a :href (get link \"url\")
+                                       (get link \"label\"))))
+                              links)))
+                     (~nav-menu :links (list
+                       {:url \"/\"     :label \"Home\"}
+                       {:url \"/about\" :label \"About\"}
+                       {:url \"/blog\"  :label \"Blog\"})))")))
+      (assert-true (string-contains? html "class=\"nav\""))
+      (assert-true (string-contains? html "href=\"/\""))
+      (assert-true (string-contains? html "Home"))
+      (assert-true (string-contains? html "href=\"/about\""))
+      (assert-true (string-contains? html "About"))
+      (assert-true (string-contains? html "href=\"/blog\""))
+      (assert-true (string-contains? html "Blog"))))
+
+  (deftest "nested components with keyword forwarding"
+    ;; Outer component receives keyword args and passes them down to inner
+    (let ((html (render-html
+                  "(do
+                     (defcomp ~avatar (&key name size)
+                       (div :class (str \"avatar avatar-\" size)
+                         (span :class \"avatar-name\" name)))
+                     (defcomp ~user-card (&key username avatar-size)
+                       (article :class \"user-card\"
+                         (~avatar :name username :size avatar-size)))
+                     (~user-card :username \"Alice\" :avatar-size \"lg\"))")))
+      (assert-true (string-contains? html "class=\"user-card\""))
+      (assert-true (string-contains? html "avatar-lg"))
+      (assert-true (string-contains? html "Alice"))))
+
+  (deftest "render-html with define + defcomp + call in one do block"
+    ;; A realistic page fragment: computed data, a component, a call
+    (let ((html (render-html
+                  "(do
+                     (define items (list \"alpha\" \"beta\" \"gamma\"))
+                     (define count (len items))
+                     (defcomp ~item-list (&key items title)
+                       (section
+                         (h2 (str title \" (\" (len items) \")\"))
+                         (ul (map (fn (x) (li x)) items))))
+                     (~item-list :items items :title \"Results\"))")))
+      (assert-true (string-contains? html "<section>"))
+      (assert-true (string-contains? html "<h2>"))
+      (assert-true (string-contains? html "Results (3)"))
+      (assert-true (string-contains? html "<li>alpha</li>"))
+      (assert-true (string-contains? html "<li>beta</li>"))
+      (assert-true (string-contains? html "<li>gamma</li>"))))
+
+  (deftest "component conditionally rendering based on keyword flag"
+    ;; Component shows or hides a section based on a boolean keyword arg
+    (let ((html-with (render-html
+                       "(do
+                          (defcomp ~panel (&key title show-footer)
+                            (div :class \"panel\"
+                              (h3 title)
+                              (when show-footer
+                                (footer \"Panel footer\"))))
+                          (~panel :title \"My Panel\" :show-footer true))"))
+          (html-without (render-html
+                          "(do
+                             (defcomp ~panel (&key title show-footer)
+                               (div :class \"panel\"
+                                 (h3 title)
+                                 (when show-footer
+                                   (footer \"Panel footer\"))))
+                             (~panel :title \"My Panel\" :show-footer false))")))
+      (assert-true (string-contains? html-with "Panel footer"))
+      (assert-false (string-contains? html-without "Panel footer")))))
+
+
+;; --------------------------------------------------------------------------
+;; macro-render-integration
+;; Define macros, then use them inside render contexts.
+;; --------------------------------------------------------------------------
+
+(defsuite "macro-render-integration"
+  (deftest "macro used in render context"
+    ;; A macro that wraps content in a section with a heading;
+    ;; the resulting expansion is rendered to HTML.
+    (let ((html (render-html
+                  "(do
+                     (defmacro section-with-title (title &rest body)
+                       `(section (h2 ,title) ,@body))
+                     (section-with-title \"About\"
+                       (p \"This is the about section.\")
+                       (p \"More content here.\")))")))
+      (assert-true (string-contains? html "<section>"))
+      (assert-true (string-contains? html "<h2>About</h2>"))
+      (assert-true (string-contains? html "This is the about section."))
+      (assert-true (string-contains? html "More content here."))))
+
+  (deftest "macro generating HTML structure from data"
+    ;; A macro that expands to a definition-list structure
+    (let ((html (render-html
+                  "(do
+                     (defmacro term-def (term &rest defs)
+                       `(<> (dt ,term) ,@(map (fn (d) `(dd ,d)) defs)))
+                     (dl
+                       (term-def \"SX\" \"An s-expression language\")
+                       (term-def \"CEK\" \"Continuation\" \"Environment\" \"Kontrol\")))")))
+      (assert-true (string-contains? html "<dl>"))
+      (assert-true (string-contains? html "<dt>SX</dt>"))
+      (assert-true (string-contains? html "<dd>An s-expression language</dd>"))
+      (assert-true (string-contains? html "<dt>CEK</dt>"))
+      (assert-true (string-contains? html "<dd>Continuation</dd>"))))
+
+  (deftest "macro with defcomp inside — two-level abstraction"
+    ;; Macro emits a defcomp; the defined component is then called
+    (let ((html (render-html
+                  "(do
+                     (defmacro defcard (name title-text)
+                       `(defcomp ,name (&key &rest children)
+                          (div :class \"card\"
+                            (h3 ,title-text)
+                            children)))
+                     (defcard ~info-card \"Information\")
+                     (~info-card (p \"Detail one.\") (p \"Detail two.\")))")))
+      (assert-true (string-contains? html "class=\"card\""))
+      (assert-true (string-contains? html "<h3>Information</h3>"))
+      (assert-true (string-contains? html "Detail one."))
+      (assert-true (string-contains? html "Detail two."))))
+
+  (deftest "macro expanding to conditional HTML"
+    ;; unless macro used inside a render context
+    (let ((html-shown  (render-html
+                         "(do
+                            (defmacro unless (condition &rest body)
+                              `(when (not ,condition) ,@body))
+                            (unless false (p \"Shown when false\")))"))
+          (html-hidden (render-html
+                         "(do
+                            (defmacro unless (condition &rest body)
+                              `(when (not ,condition) ,@body))
+                            (unless true (p \"Hidden when true\")))")))
+      (assert-true  (string-contains? html-shown  "Shown when false"))
+      (assert-false (string-contains? html-hidden "Hidden when true"))))
+
+  (deftest "macro-generated let bindings in render context"
+    ;; A macro that introduces a local binding, used in HTML generation
+    (let ((html (render-html
+                  "(do
+                     (defmacro with-upcase (name val &rest body)
+                       `(let ((,name (upper ,val))) ,@body))
+                     (with-upcase title \"hello world\"
+                       (h1 title)))")))
+      (assert-equal "<h1>HELLO WORLD</h1>" html))))
+
+
+;; --------------------------------------------------------------------------
+;; data-driven-rendering
+;; Build data structures, process them, and render the results.
+;; --------------------------------------------------------------------------
+
+(defsuite "data-driven-rendering"
+  (deftest "build a list of dicts, map to table rows"
+    ;; Simulate a typical data-driven table: list of row dicts → HTML table
+    (let ((html (render-html
+                  "(do
+                     (define products (list
+                       {:name \"Widget\"  :price 9.99  :stock 100}
+                       {:name \"Gadget\"  :price 24.99 :stock 5}
+                       {:name \"Doohickey\" :price 4.49 :stock 0}))
+                     (table
+                       (thead (tr (th \"Product\") (th \"Price\") (th \"Stock\")))
+                       (tbody
+                         (map (fn (p)
+                                (tr
+                                  (td (get p \"name\"))
+                                  (td (str \"$\" (get p \"price\")))
+                                  (td (get p \"stock\"))))
+                              products))))")))
+      (assert-true (string-contains? html "<table>"))
+      (assert-true (string-contains? html "<th>Product</th>"))
+      (assert-true (string-contains? html "Widget"))
+      (assert-true (string-contains? html "$9.99"))
+      (assert-true (string-contains? html "Gadget"))
+      (assert-true (string-contains? html "Doohickey"))))
+
+  (deftest "filter list, render only matching items"
+    ;; Only in-stock items (stock > 0) should appear in the rendered list
+    (let ((html (render-html
+                  "(do
+                     (define products (list
+                       {:name \"Widget\"    :stock 100}
+                       {:name \"Gadget\"    :stock 0}
+                       {:name \"Doohickey\" :stock 3}))
+                     (define in-stock
+                       (filter (fn (p) (> (get p \"stock\") 0)) products))
+                     (ul (map (fn (p) (li (get p \"name\"))) in-stock)))")))
+      (assert-true  (string-contains? html "Widget"))
+      (assert-false (string-contains? html "Gadget"))
+      (assert-true  (string-contains? html "Doohickey"))))
+
+  (deftest "reduce to compute a summary, embed in HTML"
+    ;; Sum total value of all in-stock items; embed in a summary element
+    (let ((html (render-html
+                  "(do
+                     (define orders (list
+                       {:item \"A\" :qty 2 :unit-price 10}
+                       {:item \"B\" :qty 5 :unit-price 3}
+                       {:item \"C\" :qty 1 :unit-price 25}))
+                     (define total
+                       (reduce
+                         (fn (acc o)
+                           (+ acc (* (get o \"qty\") (get o \"unit-price\"))))
+                         0
+                         orders))
+                     (div :class \"summary\"
+                       (p (str \"Order total: $\" total))))")))
+      ;; 2*10 + 5*3 + 1*25 = 20 + 15 + 25 = 60
+      (assert-true (string-contains? html "class=\"summary\""))
+      (assert-true (string-contains? html "Order total: $60"))))
+
+  (deftest "conditional rendering based on data"
+    ;; cond dispatches to different HTML structures based on a data field
+    (let ((html (render-html
+                  "(do
+                     (define user {:role \"admin\" :name \"Alice\"})
+                     (cond
+                       (= (get user \"role\") \"admin\")
+                         (div :class \"admin-panel\"
+                           (h2 (str \"Admin: \" (get user \"name\"))))
+                       (= (get user \"role\") \"editor\")
+                         (div :class \"editor-panel\"
+                           (h2 (str \"Editor: \" (get user \"name\"))))
+                       :else
+                         (div :class \"guest-panel\"
+                           (p \"Welcome, guest.\"))))")))
+      (assert-true  (string-contains? html "class=\"admin-panel\""))
+      (assert-true  (string-contains? html "Admin: Alice"))
+      (assert-false (string-contains? html "editor-panel"))
+      (assert-false (string-contains? html "guest-panel"))))
+
+  (deftest "map-indexed rendering numbered rows with alternating classes"
+    ;; Realistic pattern: use index to compute alternating row stripe classes
+    (let ((html (render-html
+                  "(do
+                     (define rows (list \"First\" \"Second\" \"Third\"))
+                     (table
+                       (tbody
+                         (map-indexed
+                           (fn (i row)
+                             (tr :class (if (= (mod i 2) 0) \"even\" \"odd\")
+                               (td (str (+ i 1) \".\"))
+                               (td row)))
+                           rows))))")))
+      (assert-true (string-contains? html "class=\"even\""))
+      (assert-true (string-contains? html "class=\"odd\""))
+      (assert-true (string-contains? html "1."))
+      (assert-true (string-contains? html "First"))
+      (assert-true (string-contains? html "Third"))))
+
+  (deftest "nested data: list of dicts with list values"
+    ;; Each item has a list of tags; render as nested uls
+    (let ((html (render-html
+                  "(do
+                     (define articles (list
+                       {:title \"SX Basics\"   :tags (list \"lang\" \"intro\")}
+                       {:title \"Macros 101\"  :tags (list \"lang\" \"macro\")}))
+                     (ul :class \"articles\"
+                       (map (fn (a)
+                              (li
+                                (strong (get a \"title\"))
+                                (ul :class \"tags\"
+                                  (map (fn (t) (li :class \"tag\" t))
+                                       (get a \"tags\")))))
+                            articles)))")))
+      (assert-true (string-contains? html "SX Basics"))
+      (assert-true (string-contains? html "class=\"tags\""))
+      (assert-true (string-contains? html "class=\"tag\""))
+      (assert-true (string-contains? html "intro"))
+      (assert-true (string-contains? html "macro")))))
+
+
+;; --------------------------------------------------------------------------
+;; error-recovery
+;; try-call catches errors; execution continues normally afterward.
+;; --------------------------------------------------------------------------
+
+(defsuite "error-recovery"
+  (deftest "try-call catches undefined symbol"
+    ;; Referencing an unknown name inside try-call returns ok=false
+    (let ((result (try-call (fn () this-name-does-not-exist-at-all))))
+      (assert-false (get result "ok"))
+      (assert-true (string? (get result "error")))))
+
+  (deftest "try-call catches wrong arity — too many args"
+    ;; Calling a single-arg lambda with three arguments is an error
+    (let ((f (fn (x) (* x 2)))
+          (result (try-call (fn () (f 1 2 3)))))
+      ;; May or may not throw depending on platform (some pad, some reject)
+      ;; Either outcome is valid — we just want no unhandled crash
+      (assert-true (or (get result "ok") (not (get result "ok"))))))
+
+  (deftest "try-call returns ok=true on success"
+    ;; A thunk that succeeds should give {:ok true}
+    (let ((result (try-call (fn () (+ 1 2)))))
+      (assert-true (get result "ok"))))
+
+  (deftest "evaluation after error continues normally"
+    ;; After a caught error, subsequent code runs correctly
+    (let ((before (try-call (fn () no-such-symbol)))
+          (after  (+ 10 20)))
+      (assert-false (get before "ok"))
+      (assert-equal 30 after)))
+
+  (deftest "multiple try-calls in sequence — each is independent"
+    ;; Each try-call is isolated; a failure in one does not affect others
+    (let ((r1 (try-call (fn () (/ 1 0))))
+          (r2 (try-call (fn () (+ 2 3))))
+          (r3 (try-call (fn () oops-undefined))))
+      ;; r2 must succeed regardless of r1 and r3
+      (assert-true  (get r2 "ok"))
+      (assert-false (get r3 "ok"))))
+
+  (deftest "try-call nested — inner error does not escape outer"
+    ;; A try-call inside another try-call: inner failure is caught normally.
+    ;; The outer thunk does NOT throw — it handles the inner error itself.
+    (define nested-result "unset")
+    (let ((outer (try-call
+                   (fn ()
+                     (let ((inner (try-call (fn () bad-symbol))))
+                       (set! nested-result
+                         (if (get inner "ok")
+                           "inner-succeeded"
+                           "inner-failed")))))))
+      ;; Outer try-call must succeed (the inner error was caught)
+      (assert-true (get outer "ok"))
+      ;; The nested logic correctly identified the inner failure
+      (assert-equal "inner-failed" nested-result)))
+
+  (deftest "try-call on render that references missing component"
+    ;; Attempting to render an undefined component should be caught
+    (let ((result (try-call
+                    (fn ()
+                      (render-html "(~this-component-is-not-defined)")))))
+      ;; Either the render throws (ok=false) or returns empty/error text
+      ;; We just verify the try-call mechanism works at this boundary
+      (assert-true (or (not (get result "ok")) (get result "ok"))))))
+
+
+;; --------------------------------------------------------------------------
+;; complex-patterns
+;; Real-world idioms: builder, state machine, pipeline, recursive descent.
+;; --------------------------------------------------------------------------
+
+(defsuite "complex-patterns"
+  (deftest "builder pattern — chain of function calls accumulating a dict"
+    ;; Each builder step returns an updated dict; final result is the built value.
+    (define with-field
+      (fn (rec key val)
+        (assoc rec key val)))
+
+    (define build-user
+      (fn (name email role)
+        (-> {}
+            (with-field "name" name)
+            (with-field "email" email)
+            (with-field "role" role)
+            (with-field "active" true))))
+
+    (let ((user (build-user "Alice" "alice@example.com" "admin")))
+      (assert-equal "Alice"             (get user "name"))
+      (assert-equal "alice@example.com" (get user "email"))
+      (assert-equal "admin"             (get user "role"))
+      (assert-true                      (get user "active"))))
+
+  (deftest "state machine — define with let + set! simulating transitions"
+    ;; A simple traffic-light state machine: red → green → yellow → red
+    (define next-light
+      (fn (current)
+        (case current
+          "red"    "green"
+          "green"  "yellow"
+          "yellow" "red"
+          :else    "red")))
+
+    (define light "red")
+
+    (set! light (next-light light))
+    (assert-equal "green" light)
+
+    (set! light (next-light light))
+    (assert-equal "yellow" light)
+
+    (set! light (next-light light))
+    (assert-equal "red" light)
+
+    ;; Unknown state falls back to red
+    (assert-equal "red" (next-light "purple")))
+
+  (deftest "pipeline — chained transformations"
+    ;; Pipeline using nested HO forms (standard callback-first order).
+    (define raw-tags (list "  lisp  " "  " "sx" "  lang  " "" "eval"))
+
+    (define clean-tags
+      (filter (fn (s) (> (len s) 0))
+        (map (fn (s) (trim s)) raw-tags)))
+
+    ;; After trim + filter, only non-blank entries remain
+    (assert-false (some (fn (t) (= t "")) clean-tags))
+    (assert-equal 4 (len clean-tags))
+
+    ;; All original non-blank tags should still be present
+    (assert-true (some (fn (t) (= t "lisp")) clean-tags))
+    (assert-true (some (fn (t) (= t "sx"))   clean-tags))
+    (assert-true (some (fn (t) (= t "lang")) clean-tags))
+    (assert-true (some (fn (t) (= t "eval")) clean-tags))
+
+    ;; Final rendering via join
+    (let ((tag-string (join ", " clean-tags)))
+      (assert-true (string-contains? tag-string "lisp"))
+      (assert-true (string-contains? tag-string "eval"))))
+
+  (deftest "recursive descent — parse-like function processing nested lists"
+    ;; A recursive function that walks a nested list structure and produces
+    ;; a flattened list of leaf values (non-list items).
+    (define collect-leaves
+      (fn (node)
+        (if (list? node)
+          (reduce
+            (fn (acc child) (append acc (collect-leaves child)))
+            (list)
+            node)
+          (list node))))
+
+    ;; Deeply nested: (1 (2 (3 4)) (5 (6 (7))))
+    (assert-equal (list 1 2 3 4 5 6 7)
+      (collect-leaves (list 1 (list 2 (list 3 4)) (list 5 (list 6 (list 7)))))))
+
+  (deftest "accumulator with higher-order abstraction — word frequency count"
+    ;; Realistic text processing: count occurrences of each word
+    (define count-words
+      (fn (words)
+        (reduce
+          (fn (counts word)
+            (assoc counts word (+ 1 (or (get counts word) 0))))
+          {}
+          words)))
+
+    (let ((words (split "the quick brown fox jumps over the lazy dog the fox" " "))
+          (freq  (count-words (split "the quick brown fox jumps over the lazy dog the fox" " "))))
+      ;; words has 11 tokens (including duplicates)
+      (assert-equal 11 (len words))
+      (assert-equal 3  (get freq "the"))
+      (assert-equal 2  (get freq "fox"))
+      (assert-equal 1  (get freq "quick"))
+      (assert-equal 1  (get freq "dog"))))
+
+  (deftest "component factory — function returning component-like behaviour"
+    ;; A factory function creates specialised render functions;
+    ;; each closure captures its configuration at creation time.
+    (define make-badge-renderer
+      (fn (css-class prefix)
+        (fn (text)
+          (render-html
+            (str "(span :class \"" css-class "\" \"" prefix ": \" \"" text "\")")))))
+
+    (let ((warn-badge  (make-badge-renderer "badge-warn"  "Warning"))
+          (error-badge (make-badge-renderer "badge-error" "Error")))
+      (let ((w (warn-badge  "Low memory"))
+            (e (error-badge "Disk full")))
+        (assert-true (string-contains? w "badge-warn"))
+        (assert-true (string-contains? w "Warning"))
+        (assert-true (string-contains? w "Low memory"))
+        (assert-true (string-contains? e "badge-error"))
+        (assert-true (string-contains? e "Error"))
+        (assert-true (string-contains? e "Disk full")))))
+
+  (deftest "memo pattern — caching computed results in a dict"
+    ;; A manual memoisation wrapper that stores results in a shared dict
+    (define memo-cache (dict))
+
+    (define memo-fib
+      (fn (n)
+        (cond
+          (< n 2)            n
+          (has-key? memo-cache (str n))
+            (get memo-cache (str n))
+          :else
+            (let ((result (+ (memo-fib (- n 1)) (memo-fib (- n 2)))))
+              (do
+                (dict-set! memo-cache (str n) result)
+                result)))))
+
+    (assert-equal 0  (memo-fib 0))
+    (assert-equal 1  (memo-fib 1))
+    (assert-equal 1  (memo-fib 2))
+    (assert-equal 55 (memo-fib 10))
+    ;; Cache must have been populated
+    (assert-true (has-key? memo-cache "10"))
+    (assert-equal 55 (get memo-cache "10"))))