Merge branch 'ocaml-vm'

The opam base image has dune in the switch but not on PATH.
RUN eval $(opam env) doesn't persist across layers. Install dune
explicitly and set PATH so dune is available in build steps.

Also fix run-tests.sh to respect QUICK env var from caller
(was being overwritten to false).

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

.claude/projects/-root-rose-ash/memory/feedback_sx_navigation.md

@@ -0,0 +1,17 @@
+---
+name: SX navigation single-source-of-truth
+description: Navigation must be defined once in nav-data.sx — no fragment URLs, no duplicated case statements, use make-page-fn for convention-based routing
+type: feedback
+---
+
+Never use fragment URLs (#anchors) in the SX docs nav system. Every navigable item must have its own Lisp URL.
+
+**Why:** Fragment URLs don't work with the SX URL routing system — fragments are client-side only and never reach the server, so nav resolution can't identify the current page.
+
+**How to apply:**
+- `nav-data.sx` is the single source of truth for all navigation labels, hrefs, summaries, and hierarchy
+- `page-functions.sx` uses `make-page-fn` (convention-based) or `slug->component` to derive component names from slugs — no hand-written case statements for simple pages
+- Overview/index pages should generate link lists from nav-data variables (e.g. `reactive-examples-nav-items`) rather than hardcoding URLs
+- To add a new simple page: add nav item to nav-data.sx, create the component file. That's it — the naming convention handles routing.
+- Pages that need server-side data fetching (reference, spec, test, bootstrapper, isomorphism) still use custom functions with explicit case clauses
+- Legacy Python nav lists in `content/pages.py` have been removed — nav-data.sx is canonical

.dockerignore

@@ -1,5 +1,5 @@
 .git
-.gitea
+.gitea/workflows
 .env
 _snapshot
 docs

.gitea/Dockerfile.test

@@ -0,0 +1,85 @@
+# syntax=docker/dockerfile:1
+#
+# CI test image — Python 3 + Node.js + OCaml 5.2 + dune.
+#
+# Build chain:
+#   1. Compile OCaml from checked-in sx_ref.ml  — produces sx_server.exe
+#   2. Bootstrap JS (sx-browser.js)             — OcamlSync transpiler → JS
+#   3. Re-bootstrap OCaml (sx_ref.ml)           — OcamlSync transpiler → OCaml
+#   4. Recompile OCaml with fresh sx_ref.ml     — final native binary
+#
+# Test suites (run at CMD):
+#   - JS standard + full tests         — Node
+#   - OCaml spec tests                 — native binary
+#   - OCaml bridge integration tests   — Python + OCaml subprocess
+#
+# Usage:
+#   docker build -f .gitea/Dockerfile.test -t sx-test .
+#   docker run --rm sx-test
+
+FROM ocaml/opam:debian-12-ocaml-5.2
+
+USER root
+RUN apt-get update && apt-get install -y --no-install-recommends \
+      python3 ca-certificates curl xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+# Node.js — direct binary (avoids the massive Debian nodejs dep tree)
+RUN NODE_VERSION=22.22.1 \
+    && ARCH=$(dpkg --print-architecture | sed 's/amd64/x64/;s/arm64/arm64/;s/armhf/armv7l/') \
+    && curl -fsSL "https://nodejs.org/dist/v${NODE_VERSION}/node-v${NODE_VERSION}-linux-${ARCH}.tar.xz" \
+       | tar -xJ --strip-components=1 -C /usr/local
+USER opam
+
+# Install dune into the opam switch
+RUN opam install dune -y
+
+# Bake the opam switch PATH into the image so dune/ocamlfind work in RUN
+ENV PATH="/home/opam/.opam/5.2/bin:${PATH}"
+
+WORKDIR /home/opam/project
+
+# Copy OCaml sources first (changes less often → better caching)
+COPY --chown=opam:opam hosts/ocaml/dune-project ./hosts/ocaml/
+COPY --chown=opam:opam hosts/ocaml/lib/         ./hosts/ocaml/lib/
+COPY --chown=opam:opam hosts/ocaml/bin/         ./hosts/ocaml/bin/
+
+# Copy spec, lib, web, shared (needed by bootstrappers + tests)
+COPY --chown=opam:opam spec/           ./spec/
+COPY --chown=opam:opam lib/            ./lib/
+COPY --chown=opam:opam web/            ./web/
+COPY --chown=opam:opam shared/sx/      ./shared/sx/
+COPY --chown=opam:opam shared/__init__.py ./shared/__init__.py
+
+# Copy JS host (bootstrapper + test runner)
+COPY --chown=opam:opam hosts/javascript/ ./hosts/javascript/
+
+# Copy OCaml host (bootstrapper + transpiler)
+COPY --chown=opam:opam hosts/ocaml/bootstrap.py   ./hosts/ocaml/bootstrap.py
+COPY --chown=opam:opam hosts/ocaml/transpiler.sx   ./hosts/ocaml/transpiler.sx
+
+# Create output directory for JS builds
+RUN mkdir -p shared/static/scripts
+
+# Step 1: Compile OCaml from checked-in sx_ref.ml
+#   → produces sx_server.exe (needed by both JS and OCaml bootstrappers)
+RUN cd hosts/ocaml && dune build
+
+# Step 2: Bootstrap JS (uses sx_server.exe via OcamlSync)
+RUN python3 hosts/javascript/cli.py \
+      --output shared/static/scripts/sx-browser.js \
+    && python3 hosts/javascript/cli.py \
+      --extensions continuations --spec-modules types \
+      --output shared/static/scripts/sx-full-test.js
+
+# Step 3: Re-bootstrap OCaml (transpile current spec → fresh sx_ref.ml)
+RUN python3 hosts/ocaml/bootstrap.py \
+      --output hosts/ocaml/lib/sx_ref.ml
+
+# Step 4: Recompile OCaml with freshly bootstrapped sx_ref.ml
+RUN cd hosts/ocaml && dune build
+
+# Default: run all tests
+COPY --chown=opam:opam .gitea/run-ci-tests.sh ./run-ci-tests.sh
+RUN chmod +x run-ci-tests.sh
+
+CMD ["./run-ci-tests.sh"]

.gitea/run-ci-tests.sh

@@ -0,0 +1,115 @@
+#!/usr/bin/env bash
+# ===========================================================================
+# run-ci-tests.sh — CI test runner for SX language suite.
+#
+# Runs JS + OCaml tests. No Python evaluator (eliminated).
+# Exit non-zero if any suite fails.
+# ===========================================================================
+set -euo pipefail
+
+FAILURES=()
+PASSES=()
+
+run_suite() {
+  local name="$1"
+  shift
+  echo ""
+  echo "============================================================"
+  echo "  $name"
+  echo "============================================================"
+  if "$@"; then
+    PASSES+=("$name")
+  else
+    FAILURES+=("$name")
+  fi
+}
+
+# -------------------------------------------------------------------
+# 1. JS standard tests
+# -------------------------------------------------------------------
+run_suite "JS standard (spec tests)" \
+  node hosts/javascript/run_tests.js
+
+# -------------------------------------------------------------------
+# 2. JS full tests (continuations + types + VM)
+# -------------------------------------------------------------------
+run_suite "JS full (spec + continuations + types + VM)" \
+  node hosts/javascript/run_tests.js --full
+
+# -------------------------------------------------------------------
+# 3. OCaml spec tests
+# -------------------------------------------------------------------
+run_suite "OCaml (spec tests)" \
+  hosts/ocaml/_build/default/bin/run_tests.exe
+
+# -------------------------------------------------------------------
+# 4. OCaml bridge integration (custom special forms, web-forms.sx)
+# -------------------------------------------------------------------
+run_suite "OCaml bridge — custom special forms + web-forms" \
+  python3 -c "
+from shared.sx.ocaml_sync import OcamlSync
+bridge = OcamlSync()
+for f in ['spec/parser.sx', 'spec/render.sx', 'web/adapter-html.sx', 'web/adapter-sx.sx', 'web/web-forms.sx', 'lib/freeze.sx']:
+    bridge.load(f)
+ok = 0; fail = 0
+def check(name, expr, expected=None):
+    global ok, fail
+    try:
+        r = bridge.eval(expr)
+        if expected is not None and r != expected:
+            print(f'  FAIL: {name}: expected {expected!r}, got {r!r}'); fail += 1
+        else:
+            print(f'  PASS: {name}'); ok += 1
+    except Exception as e:
+        print(f'  FAIL: {name}: {e}'); fail += 1
+
+for form in ['defhandler', 'defquery', 'defaction', 'defpage', 'defrelation', 'defstyle', 'deftype', 'defeffect']:
+    check(f'{form} registered', f'(has-key? *custom-special-forms* \"{form}\")', 'true')
+
+check('deftype via eval', '(deftype test-t number)', 'nil')
+check('defeffect via eval', '(defeffect test-e)', 'nil')
+check('defstyle via eval', '(defstyle my-s \"bold\")', 'bold')
+check('defhandler via eval', '(has-key? (defhandler test-h (&key x) x) \"__type\")', 'true')
+
+check('definition-form-extensions populated', '(> (len *definition-form-extensions*) 0)', 'true')
+check('RENDER_HTML_FORMS has defstyle', '(contains? RENDER_HTML_FORMS \"defstyle\")', 'true')
+
+bridge2 = OcamlSync()
+bridge2.eval('(register-special-form! \"shadow-test\" (fn (args env) 42))')
+bridge2.load('spec/evaluator.sx')
+check('custom form survives evaluator.sx load',
+      bridge2.eval('(has-key? *custom-special-forms* \"shadow-test\")'), 'true')
+bridge2.eval('(register-special-form! \"post-load\" (fn (args env) 99))')
+check('custom form callable after evaluator.sx load',
+      bridge2.eval('(post-load 1)'), '99')
+
+print(f'\nResults: {ok} passed, {fail} failed')
+import sys; sys.exit(1 if fail > 0 else 0)
+"
+
+# -------------------------------------------------------------------
+# Summary
+# -------------------------------------------------------------------
+echo ""
+echo "============================================================"
+echo "  CI TEST SUMMARY"
+echo "============================================================"
+for p in "${PASSES[@]}"; do
+  echo "  PASS: $p"
+done
+for f in "${FAILURES[@]}"; do
+  echo "  FAIL: $f"
+done
+echo "============================================================"
+
+if [ ${#FAILURES[@]} -gt 0 ]; then
+  echo ""
+  echo "  ${#FAILURES[@]} suite(s) FAILED"
+  echo ""
+  exit 1
+else
+  echo ""
+  echo "  All ${#PASSES[@]} suites passed."
+  echo ""
+  exit 0
+fi

.gitea/workflows/ci.yml

@@ -1,4 +1,4 @@
-name: Build and Deploy
+name: Test, Build, and Deploy
 
 on:
   push:
@@ -10,7 +10,7 @@ env:
   BUILD_DIR: /root/rose-ash-ci
 
 jobs:
-  build-and-deploy:
+  test-build-deploy:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -29,12 +29,11 @@ jobs:
           chmod 600 ~/.ssh/id_rsa
           ssh-keyscan -H "$DEPLOY_HOST" >> ~/.ssh/known_hosts 2>/dev/null || true
 
-      - name: Build and deploy changed apps
+      - name: Sync CI build directory
         env:
           DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }}
         run: |
           ssh "root@$DEPLOY_HOST" "
-            # --- Build in isolated CI directory (never touch dev working tree) ---
             BUILD=${{ env.BUILD_DIR }}
             ORIGIN=\$(git -C ${{ env.APP_DIR }} remote get-url origin)
             if [ ! -d \"\$BUILD/.git\" ]; then
@@ -43,6 +42,31 @@ jobs:
             cd \"\$BUILD\"
             git fetch origin
             git reset --hard origin/${{ github.ref_name }}
+          "
+
+      - name: Test SX language suite
+        env:
+          DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }}
+        run: |
+          ssh "root@$DEPLOY_HOST" "
+            cd ${{ env.BUILD_DIR }}
+
+            echo '=== Building SX test image ==='
+            docker build \
+              -f .gitea/Dockerfile.test \
+              -t sx-test:${{ github.sha }} \
+              .
+
+            echo '=== Running SX tests ==='
+            docker run --rm sx-test:${{ github.sha }}
+          "
+
+      - name: Build and deploy changed apps
+        env:
+          DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }}
+        run: |
+          ssh "root@$DEPLOY_HOST" "
+            cd ${{ env.BUILD_DIR }}
 
             # Detect changes using push event SHAs (not local checkout state)
             BEFORE='${{ github.event.before }}'

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

deploy.sh

@@ -53,16 +53,10 @@ fi
 echo "Building: ${BUILD[*]}"
 echo ""
 
-# --- Run unit tests before deploying ---
-echo "=== Running unit tests ==="
-docker build -f test/Dockerfile.unit -t rose-ash-test-unit:latest . -q
-if ! docker run --rm rose-ash-test-unit:latest; then
-  echo ""
-  echo "Unit tests FAILED — aborting deploy."
+# --- Run unit tests before deploying (skip Playwright — needs running server) ---
+if ! QUICK=true ./run-tests.sh; then
   exit 1
 fi
-echo "Unit tests passed."
-echo ""
 
 for app in "${BUILD[@]}"; do
   dir=$(_app_dir "$app")

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,71 @@
+# 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"
+      OCAMLRUNPARAM: "b"
+    ports:
+      - "8013:8000"
+    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
+      # Spec + lib + web SX files (loaded by OCaml kernel)
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
+      # 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.dev.yml

@@ -12,6 +12,8 @@ x-dev-env: &dev-env
   WORKERS: "1"
   SX_USE_REF: "1"
   SX_BOUNDARY_STRICT: "1"
+  SX_USE_OCAML: "1"
+  SX_OCAML_BIN: "/app/bin/sx_server"
 
 x-sibling-models: &sibling-models
   # Every app needs all sibling __init__.py + models/ for cross-domain SQLAlchemy imports
@@ -44,6 +46,10 @@ services:
     volumes:
       - /root/rose-ash/_config/app-config.yaml:/app/config/app-config.yaml:ro
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./blog/alembic.ini:/app/blog/alembic.ini:ro
       - ./blog/alembic:/app/blog/alembic:ro
       - ./blog/app.py:/app/app.py
@@ -83,6 +89,10 @@ services:
       - /root/rose-ash/_config/app-config.yaml:/app/config/app-config.yaml:ro
       - /root/rose-ash/_snapshot:/app/_snapshot
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./market/alembic.ini:/app/market/alembic.ini:ro
       - ./market/alembic:/app/market/alembic:ro
       - ./market/app.py:/app/app.py
@@ -121,6 +131,10 @@ services:
     volumes:
       - /root/rose-ash/_config/app-config.yaml:/app/config/app-config.yaml:ro
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./cart/alembic.ini:/app/cart/alembic.ini:ro
       - ./cart/alembic:/app/cart/alembic:ro
       - ./cart/app.py:/app/app.py
@@ -159,6 +173,10 @@ services:
     volumes:
       - /root/rose-ash/_config/app-config.yaml:/app/config/app-config.yaml:ro
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./events/alembic.ini:/app/events/alembic.ini:ro
       - ./events/alembic:/app/events/alembic:ro
       - ./events/app.py:/app/app.py
@@ -197,6 +215,10 @@ services:
     volumes:
       - /root/rose-ash/_config/app-config.yaml:/app/config/app-config.yaml:ro
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./federation/alembic.ini:/app/federation/alembic.ini:ro
       - ./federation/alembic:/app/federation/alembic:ro
       - ./federation/app.py:/app/app.py
@@ -235,6 +257,10 @@ services:
     volumes:
       - /root/rose-ash/_config/app-config.yaml:/app/config/app-config.yaml:ro
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./account/alembic.ini:/app/account/alembic.ini:ro
       - ./account/alembic:/app/account/alembic:ro
       - ./account/app.py:/app/app.py
@@ -273,6 +299,10 @@ services:
     volumes:
       - /root/rose-ash/_config/app-config.yaml:/app/config/app-config.yaml:ro
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./relations/alembic.ini:/app/relations/alembic.ini:ro
       - ./relations/alembic:/app/relations/alembic:ro
       - ./relations/app.py:/app/app.py
@@ -304,6 +334,10 @@ services:
     volumes:
       - /root/rose-ash/_config/app-config.yaml:/app/config/app-config.yaml:ro
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./likes/alembic.ini:/app/likes/alembic.ini:ro
       - ./likes/alembic:/app/likes/alembic:ro
       - ./likes/app.py:/app/app.py
@@ -335,6 +369,10 @@ services:
     volumes:
       - /root/rose-ash/_config/app-config.yaml:/app/config/app-config.yaml:ro
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./orders/alembic.ini:/app/orders/alembic.ini:ro
       - ./orders/alembic:/app/orders/alembic:ro
       - ./orders/app.py:/app/app.py
@@ -369,6 +407,10 @@ services:
     volumes:
       - /root/rose-ash/_config/app-config.yaml:/app/config/app-config.yaml:ro
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./test/app.py:/app/app.py
       - ./test/sx:/app/sx
       - ./test/bp:/app/bp
@@ -393,9 +435,14 @@ services:
       - "8012:8000"
     environment:
       <<: *dev-env
+      SX_STANDALONE: "true"
     volumes:
       - /root/rose-ash/_config/app-config.yaml:/app/config/app-config.yaml:ro
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./sx/app.py:/app/app.py
       - ./sx/sxc:/app/sxc
       - ./sx/bp:/app/bp
@@ -431,6 +478,10 @@ services:
       dockerfile: test/Dockerfile.unit
     volumes:
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./artdag/core:/app/artdag/core
       - ./artdag/l1/tests:/app/artdag/l1/tests
       - ./artdag/l1/sexp_effects:/app/artdag/l1/sexp_effects
@@ -456,6 +507,10 @@ services:
       dockerfile: test/Dockerfile.integration
     volumes:
       - ./shared:/app/shared
+      - ./hosts/ocaml/_build/default/bin/sx_server.exe:/app/bin/sx_server:ro
+      - ./spec:/app/spec:ro
+      - ./lib:/app/lib:ro
+      - ./web:/app/web:ro
       - ./artdag:/app/artdag
     profiles:
       - test

docker-compose.yml

@@ -58,6 +58,8 @@ x-app-env: &app-env
   EXTERNAL_INBOXES: "artdag|https://celery-artdag.rose-ash.com/inbox"
   SX_BOUNDARY_STRICT: "1"
   SX_USE_REF: "1"
+  SX_USE_OCAML: "1"
+  SX_OCAML_BIN: "/app/bin/sx_server"
 
 services:
   blog:

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 (
+import tempfile
+from shared.sx.parser import serialize
+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,
@@ -35,29 +35,23 @@ from shared.sx.ref.platform_js import (
 )
 
 
-_js_sx_env = None  # cached
+_bridge = None  # cached OcamlSync instance
 
 
-def load_js_sx() -> dict:
-    """Load js.sx into an evaluator environment and return it."""
-    global _js_sx_env
-    if _js_sx_env is not None:
-        return _js_sx_env
+def _get_bridge():
+    """Get or create the OCaml sync bridge with transpiler loaded."""
+    global _bridge
+    if _bridge is not None:
+        return _bridge
+    from shared.sx.ocaml_sync import OcamlSync
+    _bridge = OcamlSync()
+    _bridge.load(os.path.join(_HERE, "transpiler.sx"))
+    return _bridge
 
-    js_sx_path = os.path.join(_HERE, "js.sx")
-    with open(js_sx_path) as f:
-        source = f.read()
 
-    exprs = parse_all(source)
-
-    from shared.sx.ref.sx_ref import evaluate, make_env
-
-    env = make_env()
-    for expr in exprs:
-        evaluate(expr, env)
-
-    _js_sx_env = env
-    return env
+def load_js_sx():
+    """Load js.sx transpiler into the OCaml kernel. Returns the bridge."""
+    return _get_bridge()
 
 
 def compile_ref_to_js(
@@ -75,10 +69,14 @@ def compile_ref_to_js(
         spec_modules: List of spec modules (deps, router, signals). None = auto.
     """
     from datetime import datetime, timezone
-    from shared.sx.ref.sx_ref import evaluate
 
-    ref_dir = _HERE
-    env = load_js_sx()
+    # Source directories: core spec, standard library, web framework
+    _source_dirs = [
+        os.path.join(_PROJECT, "spec"),      # Core language spec
+        os.path.join(_PROJECT, "lib"),       # Standard library (stdlib, compiler, vm, ...)
+        os.path.join(_PROJECT, "web"),       # Web framework
+    ]
+    bridge = _get_bridge()
 
     # Resolve adapter set
     if adapters is None:
@@ -106,17 +104,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()
@@ -127,10 +119,16 @@ 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)"),
+        # stdlib.sx is loaded at runtime via eval, not transpiled —
+        # transpiling it would shadow native PRIMITIVES in module scope.
+        ("freeze.sx", "freeze (serializable state boundaries)"),
+        ("content.sx", "content (content-addressed computation)"),
         ("render.sx", "render (core)"),
+        ("web-forms.sx", "web-forms (defstyle, deftype, defeffect, defrelation)"),
     ]
     for name in ("parser", "html", "sx", "dom", "engine", "orchestration", "boot"):
         if name in adapter_set:
@@ -195,9 +193,16 @@ def compile_ref_to_js(
         parts.append(PLATFORM_CEK_JS)
 
     # Translate each spec file using js.sx
+    def _find_sx(filename):
+        for d in _source_dirs:
+            p = os.path.join(d, filename)
+            if os.path.exists(p):
+                return p
+        return None
+
     for filename, label in sx_files:
-        filepath = os.path.join(ref_dir, filename)
-        if not os.path.exists(filepath):
+        filepath = _find_sx(filename)
+        if not filepath:
             continue
         with open(filepath) as f:
             src = f.read()
@@ -206,11 +211,16 @@ def compile_ref_to_js(
         sx_defines = [[name, expr] for name, expr in defines]
 
         parts.append(f"\n  // === Transpiled from {label} ===\n")
-        env["_defines"] = sx_defines
-        result = evaluate(
-            [Symbol("js-translate-file"), Symbol("_defines")],
-            env,
-        )
+        # Serialize defines to SX, write to temp file, load into OCaml kernel
+        defines_sx = serialize(sx_defines)
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".sx", delete=False) as tmp:
+            tmp.write(f"(define _defines \'{defines_sx})\n")
+            tmp_path = tmp.name
+        try:
+            bridge.load(tmp_path)
+        finally:
+            os.unlink(tmp_path)
+        result = bridge.eval("(js-translate-file _defines)")
         parts.append(result)
 
     # Platform JS for selected adapters
@@ -222,11 +232,36 @@ def compile_ref_to_js(
     if has_cek:
         parts.append(CEK_FIXUPS_JS)
 
+    # Load stdlib.sx via eval (NOT transpiled) so defines go into the eval
+    # env, not the module scope. This prevents stdlib functions from
+    # shadowing native PRIMITIVES aliases used by transpiled evaluator code.
+    stdlib_path = _find_sx("stdlib.sx")
+    if stdlib_path:
+        with open(stdlib_path) as f:
+            stdlib_src = f.read()
+        # Escape for JS string literal
+        stdlib_escaped = stdlib_src.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
+        parts.append(f'\n  // === stdlib.sx (eval\'d at runtime, not transpiled) ===')
+        parts.append(f'  (function() {{')
+        parts.append(f'    var src = "{stdlib_escaped}";')
+        parts.append(f'    var forms = sxParse(src);')
+        parts.append(f'    var tmpEnv = merge({{}}, PRIMITIVES);')
+        parts.append(f'    for (var i = 0; i < forms.length; i++) {{')
+        parts.append(f'      trampoline(evalExpr(forms[i], tmpEnv));')
+        parts.append(f'    }}')
+        parts.append(f'    for (var k in tmpEnv) {{')
+        parts.append(f'      if (!PRIMITIVES[k]) PRIMITIVES[k] = tmpEnv[k];')
+        parts.append(f'    }}')
+        parts.append(f'  }})();\n')
+
     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

@@ -13,7 +13,14 @@ 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."""
+    """Parse .sx source, return list of (name, expr) for top-level forms.
+
+    Extracts (define name ...) forms with their name, plus selected
+    non-define top-level expressions (e.g. register-special-form! calls)
+    with a synthetic name for the comment.
+    """
+    # Top-level calls that should be transpiled (not special forms)
+    _TOPLEVEL_CALLS = {"register-special-form!"}
     exprs = parse_all(source)
     defines = []
     for expr in exprs:
@@ -21,12 +28,18 @@ def extract_defines(source: str) -> list[tuple[str, list]]:
             if expr[0].name == "define":
                 name = expr[1].name if isinstance(expr[1], Symbol) else str(expr[1])
                 defines.append((name, expr))
+            elif expr[0].name in _TOPLEVEL_CALLS:
+                # Top-level call expression (e.g. register-special-form!)
+                call_name = expr[0].name
+                defines.append((f"({call_name} ...)", expr))
     return defines
 
 ADAPTER_FILES = {
     "parser":        ("parser.sx",       "parser"),
     "html":          ("adapter-html.sx", "adapter-html"),
     "sx":            ("adapter-sx.sx",   "adapter-sx"),
+    "dom-lib":       ("lib/dom.sx",      "lib/dom (DOM library)"),
+    "browser-lib":   ("lib/browser.sx",  "lib/browser (browser API library)"),
     "dom":           ("adapter-dom.sx",  "adapter-dom"),
     "engine":        ("engine.sx",       "engine"),
     "orchestration": ("orchestration.sx","orchestration"),
@@ -35,6 +48,9 @@ ADAPTER_FILES = {
 
 # Dependencies
 ADAPTER_DEPS = {
+    "dom-lib": [],
+    "browser-lib": ["dom-lib"],
+    "dom": ["dom-lib", "browser-lib"],
     "engine": ["dom"],
     "orchestration": ["engine", "dom"],
     "boot": ["dom", "engine", "orchestration", "parser"],
@@ -46,13 +62,13 @@ 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)"),
+    "vm": ("vm.sx", "vm (bytecode virtual machine)"),
 }
+# 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", "vm"]
 
 
 EXTENSION_NAMES = {"continuations"}
@@ -61,9 +77,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;
@@ -280,9 +300,11 @@ ASYNC_IO_JS = '''
       if (hname === "map-indexed") return asyncRenderMapIndexed(expr, env, ns);
       if (hname === "for-each") return asyncRenderMap(expr, env, ns);
 
-      // define/defcomp/defmacro — eval for side effects
+      // define/defcomp/defmacro and custom special forms — eval for side effects
       if (hname === "define" || hname === "defcomp" || hname === "defmacro" ||
-          hname === "defstyle" || hname === "defhandler") {
+          hname === "defstyle" || hname === "defhandler" ||
+          hname === "deftype" || hname === "defeffect" ||
+          (typeof _customSpecialForms !== "undefined" && _customSpecialForms[hname])) {
         trampoline(evalExpr(expr, env));
         return null;
       }
@@ -978,6 +1000,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 = [];
@@ -1107,6 +1130,58 @@ PRIMITIVES_JS_MODULES: dict[str, str] = {
   PRIMITIVES["context"] = sxContext;
   PRIMITIVES["emit!"] = sxEmit;
   PRIMITIVES["emitted"] = sxEmitted;
+  // Aliases for aser adapter (avoids CEK special form conflict on server)
+  var scopeEmit = sxEmit;
+  function scopePeek(name) {
+    if (_scopeStacks[name] && _scopeStacks[name].length) {
+      return _scopeStacks[name][_scopeStacks[name].length - 1].value;
+    }
+    return NIL;
+  }
+  PRIMITIVES["scope-emit!"] = scopeEmit;
+  PRIMITIVES["scope-peek"] = scopePeek;
+  PRIMITIVES["scope-emitted"] = sxEmitted;
+  PRIMITIVES["scope-collected"] = sxCollected;
+  PRIMITIVES["scope-clear-collected!"] = sxClearCollected;
+
+  // ---- VM stack primitives ----
+  // The VM spec (vm.sx) requires these array-like operations.
+  // In JS, a plain Array serves as the stack.
+  PRIMITIVES["make-vm-stack"] = function(size) {
+    var a = new Array(size);
+    for (var i = 0; i < size; i++) a[i] = NIL;
+    return a;
+  };
+  PRIMITIVES["vm-stack-get"] = function(stack, idx) { return stack[idx]; };
+  PRIMITIVES["vm-stack-set!"] = function(stack, idx, value) { stack[idx] = value; return NIL; };
+  PRIMITIVES["vm-stack-length"] = function(stack) { return stack.length; };
+  PRIMITIVES["vm-stack-copy!"] = function(src, dst, count) {
+    for (var i = 0; i < count; i++) dst[i] = src[i];
+    return NIL;
+  };
+  PRIMITIVES["get-primitive"] = function(name) {
+    if (name in PRIMITIVES) return PRIMITIVES[name];
+    throw new Error("VM undefined: " + name);
+  };
+  PRIMITIVES["call-primitive"] = function(name, args) {
+    if (!(name in PRIMITIVES)) throw new Error("VM undefined: " + name);
+    var fn = PRIMITIVES[name];
+    return fn.apply(null, Array.isArray(args) ? args : []);
+  };
+  PRIMITIVES["primitive?"] = function(name) {
+    return name in PRIMITIVES;
+  };
+  PRIMITIVES["set-nth!"] = function(lst, idx, val) {
+    lst[idx] = val;
+    return NIL;
+  };
+
+  PRIMITIVES["env-parent"] = function(env) {
+    if (env && Object.getPrototypeOf(env) !== Object.prototype &&
+        Object.getPrototypeOf(env) !== null)
+      return Object.getPrototypeOf(env);
+    return NIL;
+  };
 ''',
 }
 # Modules to include by default (all)
@@ -1145,6 +1220,7 @@ PLATFORM_JS_PRE = '''
     if (x._spread) return "spread";
     if (x._macro) return "macro";
     if (x._raw) return "raw-html";
+    if (x._sx_expr) return "sx-expr";
     if (typeof Node !== "undefined" && x instanceof Node) return "dom-node";
     if (Array.isArray(x)) return "list";
     if (typeof x === "object") return "dict";
@@ -1156,12 +1232,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 +1306,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 +1327,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 +1342,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;
@@ -1383,6 +1466,11 @@ PLATFORM_JS_POST = '''
   var get = PRIMITIVES["get"];
   var assoc = PRIMITIVES["assoc"];
   var range = PRIMITIVES["range"];
+  var floor = PRIMITIVES["floor"];
+  var pow = PRIMITIVES["pow"];
+  var mod = PRIMITIVES["mod"];
+  var indexOf_ = PRIMITIVES["index-of"];
+  var hasKey = PRIMITIVES["has-key?"];
   function zip(a, b) { var r = []; for (var i = 0; i < Math.min(a.length, b.length); i++) r.push([a[i], b[i]]); return r; }
   function append_b(arr, x) { arr.push(x); return arr; }
   var apply = function(f, args) {
@@ -1401,12 +1489,10 @@ PLATFORM_JS_POST = '''
   var dict_fn = PRIMITIVES["dict"];
 
   // HTML rendering helpers
-  function escapeHtml(s) {
-    return String(s).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;");
-  }
-  function escapeAttr(s) { return escapeHtml(s); }
+  // escape-html and escape-attr are now library functions defined in render.sx
   function rawHtmlContent(r) { return r.html; }
   function makeRawHtml(s) { return { _raw: true, html: s }; }
+  function makeSxExpr(s) { return { _sx_expr: true, source: s }; }
   function sxExprSource(x) { return x && x.source ? x.source : String(x); }
 
   // Placeholders — overridden by transpiled spec from parser.sx / adapter-sx.sx
@@ -1414,11 +1500,102 @@ PLATFORM_JS_POST = '''
   function isSpecialForm(n) { return false; }
   function isHoForm(n) { return false; }
 
+  // -----------------------------------------------------------------------
+  // Host FFI — the irreducible web platform primitives
+  // All DOM/browser operations are built on these in web/lib/dom.sx
+  // -----------------------------------------------------------------------
+  PRIMITIVES["host-global"] = function(name) {
+    if (typeof globalThis !== "undefined" && name in globalThis) return globalThis[name];
+    if (typeof window !== "undefined" && name in window) return window[name];
+    return NIL;
+  };
+  PRIMITIVES["host-get"] = function(obj, prop) {
+    if (obj == null || obj === NIL) return NIL;
+    var v = obj[prop];
+    return v === undefined || v === null ? NIL : v;
+  };
+  PRIMITIVES["host-set!"] = function(obj, prop, val) {
+    if (obj != null && obj !== NIL) obj[prop] = val === NIL ? null : val;
+  };
+  PRIMITIVES["host-call"] = function() {
+    var obj = arguments[0], method = arguments[1];
+    var args = [];
+    for (var i = 2; i < arguments.length; i++) {
+      var a = arguments[i];
+      args.push(a === NIL ? null : a);
+    }
+    if (obj == null || obj === NIL) {
+      // Global function call
+      var fn = typeof globalThis !== "undefined" ? globalThis[method] : window[method];
+      if (typeof fn === "function") return fn.apply(null, args);
+      return NIL;
+    }
+    if (typeof obj[method] === "function") {
+      try { return obj[method].apply(obj, args); }
+      catch(e) { return NIL; }
+    }
+    return NIL;
+  };
+  PRIMITIVES["host-new"] = function() {
+    var name = arguments[0];
+    var args = Array.prototype.slice.call(arguments, 1).map(function(a) { return a === NIL ? null : a; });
+    var Ctor = typeof globalThis !== "undefined" ? globalThis[name] : window[name];
+    if (typeof Ctor !== "function") return NIL;
+    // Support 0-4 args (covers all practical cases)
+    switch (args.length) {
+      case 0: return new Ctor();
+      case 1: return new Ctor(args[0]);
+      case 2: return new Ctor(args[0], args[1]);
+      case 3: return new Ctor(args[0], args[1], args[2]);
+      default: return new Ctor(args[0], args[1], args[2], args[3]);
+    }
+  };
+  PRIMITIVES["host-callback"] = function(fn) {
+    // Wrap SX function/lambda as a native JS callback
+    if (typeof fn === "function") return fn;
+    if (fn && fn._type === "lambda") {
+      return function() {
+        var a = Array.prototype.slice.call(arguments);
+        return cekCall(fn, a);
+      };
+    }
+    return function() {};
+  };
+  PRIMITIVES["host-typeof"] = function(obj) {
+    if (obj == null || obj === NIL) return "nil";
+    if (obj instanceof Element) return "element";
+    if (obj instanceof Text) return "text";
+    if (obj instanceof DocumentFragment) return "fragment";
+    if (obj instanceof Document) return "document";
+    if (obj instanceof Event) return "event";
+    if (obj instanceof Promise) return "promise";
+    if (obj instanceof AbortController) return "abort-controller";
+    return typeof obj;
+  };
+  PRIMITIVES["host-await"] = function(promise, callback) {
+    if (promise && typeof promise.then === "function") {
+      var cb = typeof callback === "function" ? callback :
+               (callback && callback._type === "lambda") ?
+                 function(v) { return cekCall(callback, [v]); } : function() {};
+      promise.then(cb);
+    }
+  };
+  // Aliases for transpiled dom.sx / browser.sx code (transpiler mangles host-* names)
+  var hostGlobal = PRIMITIVES["host-global"];
+  var hostGet = PRIMITIVES["host-get"];
+  var hostSet = PRIMITIVES["host-set!"];
+  var hostCall = PRIMITIVES["host-call"];
+  var hostNew = PRIMITIVES["host-new"];
+  var hostCallback = PRIMITIVES["host-callback"];
+  var hostTypeof = PRIMITIVES["host-typeof"];
+  var hostAwait = PRIMITIVES["host-await"];
+
   // processBindings and evalCond — now specced in render.sx, bootstrapped above
 
   function isDefinitionForm(name) {
     return name === "define" || name === "defcomp" || name === "defmacro" ||
-           name === "defstyle" || name === "defhandler";
+           name === "defstyle" || name === "defhandler" ||
+           name === "deftype" || name === "defeffect";
   }
 
   function indexOf_(s, ch) {
@@ -1491,13 +1668,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 +1704,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;
@@ -1536,21 +1730,8 @@ CEK_FIXUPS_JS = '''
   PRIMITIVES["island?"] = isIsland;
   PRIMITIVES["make-symbol"] = function(n) { return new Symbol(n); };
   PRIMITIVES["is-html-tag?"] = function(n) { return HTML_TAGS.indexOf(n) >= 0; };
-  PRIMITIVES["make-env"] = function() { return merge(componentEnv, PRIMITIVES); };
-
-  // localStorage — defined here (before boot) so islands can use at hydration
-  PRIMITIVES["local-storage-get"] = function(key) {
-    try { var v = localStorage.getItem(key); return v === null ? NIL : v; }
-    catch (e) { return NIL; }
-  };
-  PRIMITIVES["local-storage-set"] = function(key, val) {
-    try { localStorage.setItem(key, val); } catch (e) {}
-    return NIL;
-  };
-  PRIMITIVES["local-storage-remove"] = function(key) {
-    try { localStorage.removeItem(key); } catch (e) {}
-    return NIL;
-  };
+  function makeEnv() { return merge(componentEnv, PRIMITIVES); }
+  PRIMITIVES["make-env"] = makeEnv;
 '''
 
 
@@ -1659,7 +1840,7 @@ PLATFORM_PARSER_JS = r"""
   function escapeString(s) {
     return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t");
   }
-  function sxExprSource(e) { return typeof e === "string" ? e : String(e); }
+  function sxExprSource(e) { return typeof e === "string" ? e : (e && e.source ? e.source : String(e)); }
   var charFromCode = PRIMITIVES["char-from-code"];
 """
 
@@ -1675,6 +1856,11 @@ PLATFORM_DOM_JS = """
   _renderExprFn = function(expr, env) { return renderToDom(expr, env, null); };
   _renderMode = true;  // Browser always evaluates in render context.
 
+  // Wire CEK render hooks — evaluator checks _renderCheck/_renderFn instead of
+  // the old renderActiveP()/isRenderExpr()/renderExpr() triple.
+  _renderCheck = function(expr, env) { return _renderMode && isRenderExpr(expr); };
+  _renderFn = function(expr, env) { return renderToDom(expr, env, null); };
+
   var SVG_NS = "http://www.w3.org/2000/svg";
   var MATH_NS = "http://www.w3.org/1998/Math/MathML";
 
@@ -1841,12 +2027,14 @@ PLATFORM_DOM_JS = """
     // If lambda takes 0 params, call without event arg (convenience for on-click handlers)
     var wrapped = isLambda(handler)
       ? (lambdaParams(handler).length === 0
-        ? function(e) { try { cekCall(handler, NIL); } catch(err) { console.error("[sx-ref] domListen handler error:", name, err); } finally { runPostRenderHooks(); } }
-        : function(e) { try { cekCall(handler, [e]); } catch(err) { console.error("[sx-ref] domListen handler error:", name, err); } finally { runPostRenderHooks(); } })
+        ? function(e) { try { cekCall(handler, NIL); } catch(err) { console.error("[sx-ref] domListen handler error:", name, err); } }
+        : function(e) { try { cekCall(handler, [e]); } catch(err) { console.error("[sx-ref] domListen handler error:", name, err); } })
       : handler;
     if (name === "click") logInfo("domListen: click on <" + (el.tagName||"?").toLowerCase() + "> text=" + (el.textContent||"").substring(0,20) + " isLambda=" + isLambda(handler));
-    el.addEventListener(name, wrapped);
-    return function() { el.removeEventListener(name, wrapped); };
+    var passiveEvents = { touchstart: 1, touchmove: 1, wheel: 1, scroll: 1 };
+    var opts = passiveEvents[name] ? { passive: true } : undefined;
+    el.addEventListener(name, wrapped, opts);
+    return function() { el.removeEventListener(name, wrapped, opts); };
   }
 
   function eventDetail(e) {
@@ -2160,7 +2348,10 @@ PLATFORM_ORCHESTRATION_JS = """
           }
         }
       });
-    }).catch(function() { location.reload(); });
+    }).catch(function(err) {
+      logWarn("sx:popstate fetch error " + url + " — " + (err && err.message ? err.message : err));
+      location.reload();
+    });
   }
 
   function fetchStreaming(target, url, headers) {
@@ -2298,7 +2489,9 @@ PLATFORM_ORCHESTRATION_JS = """
       return resp.text().then(function(text) {
         preloadCacheSet(cache, url, text, ct);
       });
-    }).catch(function() { /* ignore */ });
+    }).catch(function(err) {
+      logInfo("sx:preload error " + url + " — " + (err && err.message ? err.message : err));
+    });
   }
 
   // --- Request body building ---
@@ -2463,6 +2656,7 @@ PLATFORM_ORCHESTRATION_JS = """
 
   function preventDefault_(e) { if (e && e.preventDefault) e.preventDefault(); }
   function stopPropagation_(e) { if (e && e.stopPropagation) e.stopPropagation(); }
+  function eventModifierKey_p(e) { return !!(e && (e.ctrlKey || e.metaKey || e.shiftKey || e.altKey)); }
   function domFocus(el) { if (el && el.focus) el.focus(); }
   function tryCatch(tryFn, catchFn) {
     var t = _wrapSxFn(tryFn);
@@ -2566,6 +2760,7 @@ PLATFORM_ORCHESTRATION_JS = """
 
   function bindBoostLink(el, _href) {
     el.addEventListener("click", function(e) {
+      if (e.ctrlKey || e.metaKey || e.shiftKey || e.altKey) return;
       e.preventDefault();
       // Re-read href from element at click time (not closed-over value)
       var liveHref = el.getAttribute("href") || _href;
@@ -2587,6 +2782,8 @@ PLATFORM_ORCHESTRATION_JS = """
       var liveAction = form.getAttribute("action") || _action || location.href;
       executeRequest(form, { method: liveMethod, url: liveAction }).then(function() {
         try { history.pushState({ sxUrl: liveAction, scrollY: window.scrollY }, "", liveAction); } catch (err) {}
+      }).catch(function(err) {
+        logWarn("sx:boost form error " + liveMethod + " " + liveAction + " — " + (err && err.message ? err.message : err));
       });
     });
   }
@@ -2595,6 +2792,7 @@ PLATFORM_ORCHESTRATION_JS = """
 
   function bindClientRouteClick(link, _href, fallbackFn) {
     link.addEventListener("click", function(e) {
+      if (e.ctrlKey || e.metaKey || e.shiftKey || e.altKey) return;
       e.preventDefault();
       // Re-read href from element at click time (not closed-over value)
       var liveHref = link.getAttribute("href") || _href;
@@ -2745,7 +2943,7 @@ PLATFORM_ORCHESTRATION_JS = """
         } else {
           fn();
         }
-      });
+      }, { passive: true });
     });
   }
 
@@ -2755,6 +2953,7 @@ PLATFORM_ORCHESTRATION_JS = """
 
   function markProcessed(el, key) { el[PROCESSED + key] = true; }
   function isProcessed(el, key) { return !!el[PROCESSED + key]; }
+  function clearProcessed(el, key) { delete el[PROCESSED + key]; }
 
   // --- Script cloning ---
 
@@ -3008,57 +3207,37 @@ def fixups_js(has_html, has_sx, has_dom, has_signals=False, has_deps=False, has_
     return _rawCallLambda(f, args, callerEnv);
   };
 
-  // Expose render functions as primitives so SX code can call them''']
-    if has_html:
-        lines.append('  if (typeof renderToHtml === "function") PRIMITIVES["render-to-html"] = renderToHtml;')
-    if has_sx:
-        lines.append('  if (typeof renderToSx === "function") PRIMITIVES["render-to-sx"] = renderToSx;')
-        lines.append('  if (typeof aser === "function") PRIMITIVES["aser"] = aser;')
-    if has_dom:
-        lines.append('  if (typeof renderToDom === "function") PRIMITIVES["render-to-dom"] = renderToDom;')
-    if has_signals:
-        lines.append('''
-  // Expose signal functions as primitives so runtime-evaluated SX code
-  // (e.g. island bodies from .sx files) can call them
-  PRIMITIVES["signal"] = signal;
-  PRIMITIVES["signal?"] = isSignal;
-  PRIMITIVES["deref"] = deref;
-  PRIMITIVES["reset!"] = reset_b;
-  PRIMITIVES["swap!"] = swap_b;
-  PRIMITIVES["computed"] = computed;
-  PRIMITIVES["effect"] = effect;
-  PRIMITIVES["batch"] = batch;
-  // Timer primitives for island code
-  PRIMITIVES["set-interval"] = setInterval_;
-  PRIMITIVES["clear-interval"] = clearInterval_;
-  // Reactive DOM helpers for island code
-  PRIMITIVES["reactive-text"] = reactiveText;
-  PRIMITIVES["create-text-node"] = createTextNode;
-  PRIMITIVES["dom-set-text-content"] = domSetTextContent;
-  PRIMITIVES["dom-listen"] = domListen;
-  PRIMITIVES["dom-dispatch"] = domDispatch;
-  PRIMITIVES["event-detail"] = eventDetail;
-  PRIMITIVES["resource"] = resource;
-  PRIMITIVES["promise-delayed"] = promiseDelayed;
-  PRIMITIVES["promise-then"] = promiseThen;
-  PRIMITIVES["def-store"] = defStore;
-  PRIMITIVES["use-store"] = useStore;
-  PRIMITIVES["emit-event"] = emitEvent;
-  PRIMITIVES["on-event"] = onEvent;
-  PRIMITIVES["bridge-event"] = bridgeEvent;
-  // DOM primitives for island code
-  PRIMITIVES["dom-focus"] = domFocus;
-  PRIMITIVES["dom-tag-name"] = domTagName;
-  PRIMITIVES["dom-get-prop"] = domGetProp;
-  PRIMITIVES["dom-set-prop"] = domSetProp;
-  PRIMITIVES["dom-call-method"] = domCallMethod;
-  PRIMITIVES["dom-post-message"] = domPostMessage;
+  // -----------------------------------------------------------------------
+  // Core primitives that require native JS (cannot be expressed via FFI)
+  // -----------------------------------------------------------------------
+  PRIMITIVES["error"] = function(msg) { throw new Error(msg); };
+
+  // FFI library functions — defined in dom.sx/browser.sx but not transpiled.
+  // Registered here so runtime-evaluated SX code (data-init, islands) can use them.
+  PRIMITIVES["prevent-default"] = preventDefault_;
   PRIMITIVES["stop-propagation"] = stopPropagation_;
+  PRIMITIVES["event-modifier-key?"] = eventModifierKey_p;
+  PRIMITIVES["element-value"] = elementValue;
   PRIMITIVES["error-message"] = errorMessage;
   PRIMITIVES["schedule-idle"] = scheduleIdle;
-  PRIMITIVES["error"] = function(msg) { throw new Error(msg); };
-  PRIMITIVES["filter"] = filter;
-  // DOM primitives for sx-on:* handlers and data-init scripts
+  PRIMITIVES["console-log"] = function() {
+    var args = Array.prototype.slice.call(arguments);
+    console.log.apply(console, ["[sx]"].concat(args));
+    return args.length > 0 ? args[0] : NIL;
+  };
+  PRIMITIVES["set-cookie"] = function(name, value, days) {
+    var d = days || 365;
+    var expires = new Date(Date.now() + d * 864e5).toUTCString();
+    document.cookie = name + "=" + encodeURIComponent(value) + ";expires=" + expires + ";path=/;SameSite=Lax";
+    return NIL;
+  };
+  PRIMITIVES["get-cookie"] = function(name) {
+    var m = document.cookie.match(new RegExp("(?:^|;\\\\s*)" + name + "=([^;]*)"));
+    return m ? decodeURIComponent(m[1]) : NIL;
+  };
+
+  // dom.sx / browser.sx library functions — not transpiled, registered from
+  // native platform implementations so runtime-eval'd SX code can use them.
   if (typeof domBody === "function") PRIMITIVES["dom-body"] = domBody;
   if (typeof domQuery === "function") PRIMITIVES["dom-query"] = domQuery;
   if (typeof domQueryAll === "function") PRIMITIVES["dom-query-all"] = domQueryAll;
@@ -3072,8 +3251,6 @@ def fixups_js(has_html, has_sx, has_dom, has_signals=False, has_deps=False, has_
   if (typeof domHasClass === "function") PRIMITIVES["dom-has-class?"] = domHasClass;
   if (typeof domClosest === "function") PRIMITIVES["dom-closest"] = domClosest;
   if (typeof domMatches === "function") PRIMITIVES["dom-matches?"] = domMatches;
-  if (typeof preventDefault_ === "function") PRIMITIVES["prevent-default"] = preventDefault_;
-  if (typeof elementValue === "function") PRIMITIVES["element-value"] = elementValue;
   if (typeof domOuterHtml === "function") PRIMITIVES["dom-outer-html"] = domOuterHtml;
   if (typeof domInnerHtml === "function") PRIMITIVES["dom-inner-html"] = domInnerHtml;
   if (typeof domTextContent === "function") PRIMITIVES["dom-text-content"] = domTextContent;
@@ -3082,52 +3259,43 @@ def fixups_js(has_html, has_sx, has_dom, has_signals=False, has_deps=False, has_
   if (typeof domAppendToHead === "function") PRIMITIVES["dom-append-to-head"] = domAppendToHead;
   if (typeof jsonParse === "function") PRIMITIVES["json-parse"] = jsonParse;
   if (typeof nowMs === "function") PRIMITIVES["now-ms"] = nowMs;
-  PRIMITIVES["sx-parse"] = sxParse;
-  PRIMITIVES["console-log"] = function() { console.log.apply(console, ["[sx]"].concat(Array.prototype.slice.call(arguments))); return arguments.length > 0 ? arguments[0] : NIL; };''')
+  PRIMITIVES["log-info"] = logInfo;
+  PRIMITIVES["log-warn"] = logWarn;
+  PRIMITIVES["dom-listen"] = domListen;
+  PRIMITIVES["dom-dispatch"] = domDispatch;
+  PRIMITIVES["event-detail"] = eventDetail;
+  PRIMITIVES["create-text-node"] = createTextNode;
+  PRIMITIVES["dom-set-text-content"] = domSetTextContent;
+  PRIMITIVES["dom-focus"] = domFocus;
+  PRIMITIVES["dom-tag-name"] = domTagName;
+  PRIMITIVES["dom-get-prop"] = domGetProp;
+  PRIMITIVES["dom-set-prop"] = domSetProp;
+  PRIMITIVES["reactive-text"] = reactiveText;
+  PRIMITIVES["set-interval"] = setInterval_;
+  PRIMITIVES["clear-interval"] = clearInterval_;
+  PRIMITIVES["promise-then"] = promiseThen;
+  PRIMITIVES["promise-delayed"] = promiseDelayed;
+  PRIMITIVES["local-storage-get"] = function(key) {
+    try { var v = localStorage.getItem(key); return v === null ? NIL : v; }
+    catch (e) { return NIL; }
+  };
+  PRIMITIVES["local-storage-set"] = function(key, val) {
+    try { localStorage.setItem(key, val); } catch (e) {}
+    return NIL;
+  };
+  PRIMITIVES["local-storage-remove"] = function(key) {
+    try { localStorage.removeItem(key); } catch (e) {}
+    return NIL;
+  };
+  if (typeof sxParse === "function") PRIMITIVES["sx-parse"] = sxParse;''']
     if has_deps:
         lines.append('''
-  // Expose deps module functions as primitives so runtime-evaluated SX code
-  // (e.g. test-deps.sx in browser) can call them
-  // Platform functions (from PLATFORM_DEPS_JS)
+  // Platform deps functions (native JS, not transpiled — need explicit registration)
   PRIMITIVES["component-deps"] = componentDeps;
   PRIMITIVES["component-set-deps!"] = componentSetDeps;
   PRIMITIVES["component-css-classes"] = componentCssClasses;
-  PRIMITIVES["env-components"] = envComponents;
   PRIMITIVES["regex-find-all"] = regexFindAll;
-  PRIMITIVES["scan-css-classes"] = scanCssClasses;
-  // Transpiled functions (from deps.sx)
-  PRIMITIVES["scan-refs"] = scanRefs;
-  PRIMITIVES["scan-refs-walk"] = scanRefsWalk;
-  PRIMITIVES["transitive-deps"] = transitiveDeps;
-  PRIMITIVES["transitive-deps-walk"] = transitiveDepsWalk;
-  PRIMITIVES["compute-all-deps"] = computeAllDeps;
-  PRIMITIVES["scan-components-from-source"] = scanComponentsFromSource;
-  PRIMITIVES["components-needed"] = componentsNeeded;
-  PRIMITIVES["page-component-bundle"] = pageComponentBundle;
-  PRIMITIVES["page-css-classes"] = pageCssClasses;
-  PRIMITIVES["scan-io-refs-walk"] = scanIoRefsWalk;
-  PRIMITIVES["scan-io-refs"] = scanIoRefs;
-  PRIMITIVES["transitive-io-refs-walk"] = transitiveIoRefsWalk;
-  PRIMITIVES["transitive-io-refs"] = transitiveIoRefs;
-  PRIMITIVES["compute-all-io-refs"] = computeAllIoRefs;
-  PRIMITIVES["component-io-refs-cached"] = componentIoRefsCached;
-  PRIMITIVES["component-pure?"] = componentPure_p;
-  PRIMITIVES["render-target"] = renderTarget;
-  PRIMITIVES["page-render-plan"] = pageRenderPlan;''')
-    if has_page_helpers:
-        lines.append('''
-  // Expose page-helper functions as primitives
-  PRIMITIVES["categorize-special-forms"] = categorizeSpecialForms;
-  PRIMITIVES["extract-define-kwargs"] = extractDefineKwargs;
-  PRIMITIVES["build-reference-data"] = buildReferenceData;
-  PRIMITIVES["build-ref-items-with-href"] = buildRefItemsWithHref;
-  PRIMITIVES["build-attr-detail"] = buildAttrDetail;
-  PRIMITIVES["build-header-detail"] = buildHeaderDetail;
-  PRIMITIVES["build-event-detail"] = buildEventDetail;
-  PRIMITIVES["build-component-source"] = buildComponentSource;
-  PRIMITIVES["build-bundle-analysis"] = buildBundleAnalysis;
-  PRIMITIVES["build-routing-analysis"] = buildRoutingAnalysis;
-  PRIMITIVES["build-affinity-analysis"] = buildAffinityAnalysis;''')
+  PRIMITIVES["scan-css-classes"] = scanCssClasses;''')
     return "\n".join(lines)
 
 
@@ -3228,6 +3396,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,356 @@
+#!/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
+// primitive? is now in platform.py PRIMITIVES
+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;
+};
+
+// Aser test helper: parse SX source, evaluate via aser, return wire format string
+env["render-sx"] = function(source) {
+  const exprs = Sx.parse(source);
+  const parts = [];
+  for (const expr of exprs) {
+    const result = Sx.renderToSx(expr, env);
+    if (result !== null && result !== undefined && result !== Sx.NIL) {
+      parts.push(typeof result === "string" ? result : Sx.serialize(result));
+    }
+  }
+  return parts.join("");
+};
+
+// 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 libTests = path.join(projectDir, "lib", "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);
+}
+
+// Load compiler + VM from lib/ when running full tests
+if (fullBuild) {
+  const libDir = path.join(projectDir, "lib");
+  for (const libFile of ["bytecode.sx", "compiler.sx", "vm.sx"]) {
+    const libPath = path.join(libDir, libFile);
+    if (fs.existsSync(libPath)) {
+      const src = fs.readFileSync(libPath, "utf8");
+      const exprs = Sx.parse(src);
+      for (const expr of exprs) {
+        try { Sx.eval(expr, env); } catch (e) {
+          console.error(`Error loading ${libFile}: ${e.message}`);
+        }
+      }
+    }
+  }
+}
+
+// Determine which tests to run
+const args = process.argv.slice(2).filter(a => !a.startsWith("--"));
+let testFiles = [];
+
+if (args.length > 0) {
+  // Specific test files — search spec, lib, and web test dirs
+  for (const arg of args) {
+    const name = arg.endsWith(".sx") ? arg : `${arg}.sx`;
+    const specPath = path.join(specTests, name);
+    const libPath = path.join(libTests, name);
+    const webPath = path.join(webTests, name);
+    if (fs.existsSync(specPath)) testFiles.push(specPath);
+    else if (fs.existsSync(libPath)) testFiles.push(libPath);
+    else if (fs.existsSync(webPath)) testFiles.push(webPath);
+    else console.error(`Test file not found: ${name}`);
+  }
+} else {
+  // All spec tests (core language — always run)
+  for (const f of fs.readdirSync(specTests).sort()) {
+    if (f.startsWith("test-") && f.endsWith(".sx") && f !== "test-framework.sx") {
+      testFiles.push(path.join(specTests, f));
+    }
+  }
+  // Library tests (only with --full — require compiler, vm, signals, etc.)
+  if (fullBuild) {
+    for (const f of fs.readdirSync(libTests).sort()) {
+      if (f.startsWith("test-") && f.endsWith(".sx")) {
+        testFiles.push(path.join(libTests, 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

@@ -54,6 +54,8 @@
   "make-action-def" "makeActionDef"
   "make-page-def" "makePageDef"
   "make-symbol" "makeSymbol"
+  "make-env" "makeEnv"
+  "make-sx-expr" "makeSxExpr"
   "make-keyword" "makeKeyword"
   "lambda-params" "lambdaParams"
   "lambda-body" "lambdaBody"
@@ -93,6 +95,25 @@
   "dispose-computed" "disposeComputed"
   "with-island-scope" "withIslandScope"
   "register-in-scope" "registerInScope"
+  "*custom-special-forms*" "_customSpecialForms"
+  "register-special-form!" "registerSpecialForm"
+  "*render-check*" "_renderCheck"
+  "*render-fn*" "_renderFn"
+  "is-else-clause?" "isElseClause"
+  "host-global" "hostGlobal"
+  "host-get" "hostGet"
+  "host-set!" "hostSet"
+  "host-call" "hostCall"
+  "host-new" "hostNew"
+  "host-callback" "hostCallback"
+  "host-typeof" "hostTypeof"
+  "host-await" "hostAwait"
+  "dom-document" "domDocument"
+  "dom-window" "domWindow"
+  "dom-head" "domHead"
+  "!=" "notEqual_"
+  "<=" "lte_"
+  ">=" "gte_"
   "*batch-depth*" "_batchDepth"
   "*batch-queue*" "_batchQueue"
   "*store-registry*" "_storeRegistry"
@@ -107,6 +128,7 @@
   "get-primitive" "getPrimitive"
   "env-has?" "envHas"
   "env-get" "envGet"
+  "env-bind!" "envBind"
   "env-set!" "envSet"
   "env-extend" "envExtend"
   "env-merge" "envMerge"
@@ -143,6 +165,7 @@
   "aser-special" "aserSpecial"
   "eval-case-aser" "evalCaseAser"
   "sx-serialize" "sxSerialize"
+
   "sx-serialize-dict" "sxSerializeDict"
   "sx-expr-source" "sxExprSource"
   "sf-if" "sfIf"
@@ -180,7 +203,6 @@
   "ho-some" "hoSome"
   "ho-every" "hoEvery"
   "ho-for-each" "hoForEach"
-  "sf-defstyle" "sfDefstyle"
   "kf-name" "kfName"
   "special-form?" "isSpecialForm"
   "ho-form?" "isHoForm"
@@ -401,6 +423,7 @@
   "bind-preload" "bindPreload"
   "mark-processed!" "markProcessed"
   "is-processed?" "isProcessed"
+  "clear-processed!" "clearProcessed"
   "create-script-clone" "createScriptClone"
   "sx-render" "sxRender"
   "sx-process-scripts" "sxProcessScripts"
@@ -600,6 +623,9 @@
   "cond-scheme?" "condScheme_p"
   "scope-push!" "scopePush"
   "scope-pop!" "scopePop"
+  "scope-emit!" "scopeEmit"
+  "scope-emitted" "sxEmitted"
+  "scope-peek" "scopePeek"
   "provide-push!" "providePush"
   "provide-pop!" "providePop"
   "context" "sxContext"
@@ -906,8 +932,11 @@
     (let ((head (first expr))
           (args (rest expr)))
       (if (not (= (type-of head) "symbol"))
-        ;; Data list — not a function call
-        (str "[" (join ", " (map js-expr expr)) "]")
+        (if (= (type-of head) "list")
+          ;; Head is a sub-expression (call) — emit as function call: (head)(args)
+          (str "(" (js-expr head) ")(" (join ", " (map js-expr args)) ")")
+          ;; Data list — not a function call
+          (str "[" (join ", " (map js-expr expr)) "]"))
         (let ((op (symbol-name head)))
           (cond
             ;; fn/lambda
@@ -989,6 +1018,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))
@@ -1091,19 +1125,50 @@
 
 (define js-emit-let
   (fn (expr)
-    (let ((bindings (nth expr 1))
-          (body (rest (rest expr))))
-      (let ((binding-lines (js-parse-let-bindings bindings))
-            (body-strs (list)))
-        (begin
-          (for-each (fn (b) (append! body-strs (str "  " (js-statement b))))
-                    (slice body 0 (- (len body) 1)))
-          (append! body-strs (str "  return " (js-expr (last body)) ";"))
-          (str "(function() {\n"
-               (join "\n" binding-lines)
-               (if (empty? binding-lines) "" "\n")
-               (join "\n" body-strs)
-               "\n})()"))))))
+    ;; Detect named let: (let name ((x init) ...) body...)
+    (if (= (type-of (nth expr 1)) "symbol")
+      (js-emit-named-let expr)
+      (let ((bindings (nth expr 1))
+            (body (rest (rest expr))))
+        (let ((binding-lines (js-parse-let-bindings bindings))
+              (body-strs (list)))
+          (begin
+            (for-each (fn (b) (append! body-strs (str "  " (js-statement b))))
+                      (slice body 0 (- (len body) 1)))
+            (append! body-strs (str "  return " (js-expr (last body)) ";"))
+            (str "(function() {\n"
+                 (join "\n" binding-lines)
+                 (if (empty? binding-lines) "" "\n")
+                 (join "\n" body-strs)
+                 "\n})()")))))))
+
+;; Named let: (let loop-name ((param init) ...) body...)
+;; Emits a named IIFE: (function loop(p1, p2) { body })(init1, init2)
+(define js-emit-named-let
+  (fn (expr)
+    (let ((loop-name (symbol-name (nth expr 1)))
+          (bindings (nth expr 2))
+          (body (slice expr 3))
+          (params (list))
+          (inits (list)))
+      ;; Parse bindings — Scheme-style ((name val) ...)
+      (for-each
+        (fn (b)
+          (let ((pname (if (= (type-of (first b)) "symbol")
+                         (symbol-name (first b))
+                         (str (first b)))))
+            (append! params (js-mangle pname))
+            (append! inits (js-expr (nth b 1)))))
+        bindings)
+      ;; Emit body statements + return last
+      (let ((body-strs (list))
+            (mangled-name (js-mangle loop-name)))
+        (for-each (fn (b) (append! body-strs (str "  " (js-statement b))))
+                  (slice body 0 (- (len body) 1)))
+        (append! body-strs (str "  return " (js-expr (last body)) ";"))
+        (str "(function " mangled-name "(" (join ", " params) ") {\n"
+             (join "\n" body-strs)
+             "\n})(" (join ", " inits) ")")))))
 
 (define js-parse-let-bindings
   (fn (bindings)
@@ -1396,6 +1461,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/Dockerfile

@@ -0,0 +1,25 @@
+# OCaml SX kernel build image.
+#
+# Produces a statically-linked sx_server binary that can be COPY'd
+# into any service's Docker image.
+#
+# Usage:
+#   docker build -t sx-kernel -f hosts/ocaml/Dockerfile .
+#   docker build --target=export -o hosts/ocaml/_build/export -f hosts/ocaml/Dockerfile .
+
+FROM ocaml/opam:debian-12-ocaml-5.2 AS build
+
+USER opam
+WORKDIR /home/opam/sx
+
+# Copy only what's needed for the OCaml build
+COPY --chown=opam:opam hosts/ocaml/dune-project ./
+COPY --chown=opam:opam hosts/ocaml/lib/ ./lib/
+COPY --chown=opam:opam hosts/ocaml/bin/ ./bin/
+
+# Build the server binary
+RUN eval $(opam env) && dune build bin/sx_server.exe
+
+# Export stage — just the binary
+FROM scratch AS export
+COPY --from=build /home/opam/sx/_build/default/bin/sx_server.exe /sx_server

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 integration_tests)
+ (libraries sx unix))

hosts/ocaml/bin/dune_debug

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

hosts/ocaml/bin/integration_tests.ml

@@ -0,0 +1,521 @@
+(** Integration tests — exercises the full rendering pipeline.
+
+    Loads spec files + web adapters into a server-like env, then renders
+    HTML expressions. Catches "Undefined symbol" errors that only surface
+    when the full stack is loaded (not caught by spec unit tests).
+
+    Usage:
+      dune exec bin/integration_tests.exe *)
+
+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
+
+let pass_count = ref 0
+let fail_count = ref 0
+
+let assert_eq name expected actual =
+  if expected = actual then begin
+    incr pass_count;
+    Printf.printf "  PASS: %s\n%!" name
+  end else begin
+    incr fail_count;
+    Printf.printf "  FAIL: %s\n    expected: %s\n    got:      %s\n%!" name expected actual
+  end
+
+let assert_contains name needle haystack =
+  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
+  if String.length needle > 0 && find 0 then begin
+    incr pass_count;
+    Printf.printf "  PASS: %s\n%!" name
+  end else begin
+    incr fail_count;
+    Printf.printf "  FAIL: %s — expected to contain %S in %S\n%!" name needle haystack
+  end
+
+let assert_no_error name f =
+  try
+    ignore (f ());
+    incr pass_count;
+    Printf.printf "  PASS: %s\n%!" name
+  with
+  | Eval_error msg ->
+    incr fail_count;
+    Printf.printf "  FAIL: %s — %s\n%!" name msg
+  | exn ->
+    incr fail_count;
+    Printf.printf "  FAIL: %s — %s\n%!" name (Printexc.to_string exn)
+
+(* Build a server-like env with rendering support *)
+let make_integration_env () =
+  let env = make_env () in
+  let bind (n : string) fn =
+    ignore (Sx_types.env_bind env n (NativeFn (n, fn)))
+  in
+
+  Sx_render.setup_render_env env;
+
+  (* HTML tag functions — same as sx_server.ml *)
+  List.iter (fun tag ->
+    ignore (env_bind env tag
+      (NativeFn ("html:" ^ tag, fun args -> List (Symbol tag :: args))))
+  ) Sx_render.html_tags;
+
+  (* Platform primitives needed by spec/render.sx and adapters *)
+  bind "make-raw-html" (fun args ->
+    match args with [String s] -> RawHTML s | [v] -> RawHTML (value_to_string v) | _ -> Nil);
+  bind "raw-html-content" (fun args ->
+    match args with [RawHTML s] -> String s | [String s] -> String s | _ -> String "");
+  bind "escape-html" (fun args ->
+    match args with [String s] -> String (Sx_render.escape_html s) | _ -> String "");
+  bind "escape-attr" (fun args ->
+    match args with [String s] -> String (Sx_render.escape_html s) | _ -> String "");
+  bind "escape-string" (fun args ->
+    match args with [String s] -> String (Sx_render.escape_html s) | _ -> String "");
+  bind "is-html-tag?" (fun args ->
+    match args with [String s] -> Bool (Sx_render.is_html_tag s) | _ -> Bool false);
+  bind "is-void-element?" (fun args ->
+    match args with [String s] -> Bool (Sx_render.is_void s) | _ -> Bool false);
+  bind "is-boolean-attr?" (fun args ->
+    match args with [String s] -> Bool (Sx_render.is_boolean_attr s) | _ -> Bool false);
+
+  (* Mutable operations needed by adapter code *)
+  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"));
+  bind "dict-set!" (fun args ->
+    match args with
+    | [Dict d; String k; v] -> Hashtbl.replace d k v; v
+    | [Dict d; Keyword k; v] -> Hashtbl.replace d k v; v
+    | _ -> Nil);
+  bind "dict-has?" (fun args ->
+    match args with
+    | [Dict d; String k] -> Bool (Hashtbl.mem d k)
+    | [Dict d; Keyword k] -> Bool (Hashtbl.mem d k)
+    | _ -> Bool false);
+  bind "dict-get" (fun args ->
+    match args with
+    | [Dict d; String k] -> (match Hashtbl.find_opt d k with Some v -> v | None -> Nil)
+    | [Dict d; Keyword k] -> (match Hashtbl.find_opt d k with Some v -> v | None -> Nil)
+    | _ -> Nil);
+  bind "empty-dict?" (fun args ->
+    match args with
+    | [Dict d] -> Bool (Hashtbl.length d = 0)
+    | _ -> Bool true);
+  bind "mutable-list" (fun _args -> ListRef (ref []));
+
+  (* Symbol/keyword accessors needed by adapter-html.sx *)
+  bind "symbol-name" (fun args ->
+    match args with [Symbol s] -> String s | _ -> raise (Eval_error "symbol-name: expected symbol"));
+  bind "keyword-name" (fun args ->
+    match args with [Keyword k] -> String k | _ -> raise (Eval_error "keyword-name: expected keyword"));
+  bind "make-symbol" (fun args ->
+    match args with [String s] -> Symbol s | _ -> raise (Eval_error "make-symbol: expected string"));
+  bind "make-keyword" (fun args ->
+    match args with [String s] -> Keyword s | _ -> raise (Eval_error "make-keyword: expected string"));
+
+  (* Type predicates needed by adapters *)
+  bind "island?" (fun args -> match args with [Island _] -> Bool true | _ -> Bool false);
+  bind "component?" (fun args -> match args with [Component _] -> Bool true | _ -> Bool false);
+  bind "macro?" (fun args -> match args with [Macro _] -> Bool true | _ -> Bool false);
+  bind "lambda?" (fun args -> match args with [Lambda _] -> Bool true | _ -> Bool false);
+  bind "spread?" (fun args -> match args with [Spread _] -> Bool true | _ -> Bool false);
+  bind "spread-attrs" (fun args ->
+    match args with
+    | [Spread pairs] -> let d = Hashtbl.create 8 in
+      List.iter (fun (k, v) -> Hashtbl.replace d k v) pairs; Dict d
+    | _ -> Nil);
+  bind "component-name" (fun args -> match args with [Component c] -> String c.c_name | [Island i] -> String i.i_name | _ -> Nil);
+  bind "component-params" (fun args -> match args with [Component c] -> List (List.map (fun s -> String s) c.c_params) | _ -> List []);
+  bind "component-body" (fun args -> match args with [Component c] -> c.c_body | _ -> Nil);
+  bind "component-closure" (fun args -> match args with [Component c] -> Env c.c_closure | _ -> 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 "lambda-params" (fun args -> match args with [Lambda l] -> List (List.map (fun s -> String s) l.l_params) | _ -> List []);
+  bind "lambda-body" (fun args -> match args with [Lambda l] -> l.l_body | _ -> Nil);
+  bind "lambda-closure" (fun args -> match args with [Lambda l] -> Env l.l_closure | _ -> Nil);
+  bind "lambda-name" (fun args -> match args with [Lambda l] -> (match l.l_name with Some n -> String n | None -> Nil) | _ -> Nil);
+  bind "set-lambda-name!" (fun args -> match args with [Lambda l; String n] -> l.l_name <- Some n; Nil | _ -> Nil);
+
+  (* Environment operations *)
+  bind "env-extend" (fun args ->
+    match args with [Env e] -> Env (env_extend e) | _ -> Env (env_extend env));
+  bind "env-bind!" (fun args ->
+    match args with [Env e; String k; v] -> env_bind e k v | _ -> Nil);
+  bind "env-set!" (fun args ->
+    match args with [Env e; String k; v] -> env_set e k v | _ -> Nil);
+  bind "env-get" (fun args ->
+    match args with [Env e; String k] -> env_get e k | _ -> Nil);
+  bind "env-has?" (fun args ->
+    match args with [Env e; String k] -> Bool (env_has e k) | _ -> Bool false);
+  bind "env-merge" (fun args ->
+    match args with [Env a; Env b] -> Env (env_merge a b) | _ -> Nil);
+  bind "make-env" (fun _args -> Env (make_env ()));
+
+  (* Eval/trampoline — needed by adapters *)
+  bind "eval-expr" (fun args ->
+    match args with
+    | [expr; e] -> Sx_ref.eval_expr expr e
+    | _ -> Nil);
+  bind "trampoline" (fun args ->
+    match args with
+    | [Thunk (e, env)] -> Sx_ref.eval_expr e (Env env)
+    | [v] -> v | _ -> Nil);
+  bind "call-lambda" (fun args ->
+    match args with
+    | [f; List a] -> Sx_runtime.sx_call f a
+    | [f; a] -> Sx_runtime.sx_call f [a]
+    | _ -> Nil);
+  bind "expand-macro" (fun args ->
+    match args with
+    | [Macro m; List macro_args; _env] ->
+      let local = env_extend m.m_closure 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
+        | _ :: _, [] -> ()
+      in
+      bind_params m.m_params macro_args;
+      Sx_ref.eval_expr m.m_body (Env local)
+    | _ -> Nil);
+
+  (* Scope/provide — needed by adapter-html.sx and the CEK evaluator.
+     Must be registered as primitives (prim_call) not just env bindings. *)
+  let scope_stacks : (string, value list) Hashtbl.t = Hashtbl.create 8 in
+  let scope_emitted : (string, value list) Hashtbl.t = Hashtbl.create 8 in
+  let scope_push name v =
+    let stack = try Hashtbl.find scope_stacks name with Not_found -> [] in
+    Hashtbl.replace scope_stacks name (v :: stack); Nil in
+  let scope_pop name =
+    (match Hashtbl.find_opt scope_stacks name with
+     | Some (_ :: rest) -> Hashtbl.replace scope_stacks name rest
+     | _ -> ()); Nil in
+  let scope_peek name =
+    match Hashtbl.find_opt scope_stacks name with
+    | Some (v :: _) -> v | _ -> Nil in
+  let scope_emit name v =
+    let items = try Hashtbl.find scope_emitted name with Not_found -> [] in
+    Hashtbl.replace scope_emitted name (items @ [v]); Nil in
+  let emitted name =
+    match Hashtbl.find_opt scope_emitted name with Some l -> List l | None -> List [] in
+  (* Register as both env bindings AND primitives *)
+  bind "scope-push!" (fun args -> match args with [String n; v] -> scope_push n v | _ -> Nil);
+  bind "scope-pop!" (fun args -> match args with [String n] -> scope_pop n | _ -> Nil);
+  bind "scope-peek" (fun args -> match args with [String n] -> scope_peek n | _ -> Nil);
+  bind "scope-emit!" (fun args -> match args with [String n; v] -> scope_emit n v | _ -> Nil);
+  bind "emitted" (fun args -> match args with [String n] -> emitted n | _ -> List []);
+  bind "emit!" (fun args -> match args with [String n; v] -> scope_emit n v | _ -> Nil);
+  bind "scope-emitted" (fun args -> match args with [String n] -> emitted n | _ -> List []);
+  bind "collect!" (fun _args -> Nil);
+  bind "collected" (fun _args -> List []);
+  bind "clear-collected!" (fun _args -> Nil);
+  bind "scope-collected" (fun _args -> List []);
+  bind "scope-clear-collected!" (fun _args -> Nil);
+  bind "provide-push!" (fun args -> match args with [String n; v] -> scope_push n v | _ -> Nil);
+  bind "provide-pop!" (fun args -> match args with [String n] -> scope_pop n | _ -> Nil);
+  bind "context" (fun args -> match args with [String n] -> scope_peek n | [String n; _] -> scope_peek n | _ -> Nil);
+  bind "sx-context" (fun args -> match args with [String n] -> scope_peek n | [String n; _] -> scope_peek n | _ -> Nil);
+  (* Also register as primitives for prim_call *)
+  Sx_primitives.register "scope-push!" (fun args -> match args with [String n; v] -> scope_push n v | _ -> Nil);
+  Sx_primitives.register "scope-pop!" (fun args -> match args with [String n] -> scope_pop n | _ -> Nil);
+  Sx_primitives.register "scope-peek" (fun args -> match args with [String n] -> scope_peek n | _ -> Nil);
+  Sx_primitives.register "scope-emit!" (fun args -> match args with [String n; v] -> scope_emit n v | _ -> Nil);
+  Sx_primitives.register "emitted" (fun args -> match args with [String n] -> emitted n | _ -> List []);
+  Sx_primitives.register "emit!" (fun args -> match args with [String n; v] -> scope_emit n v | _ -> Nil);
+  Sx_primitives.register "scope-emitted" (fun args -> match args with [String n] -> emitted n | _ -> List []);
+  Sx_primitives.register "collect!" (fun _args -> Nil);
+  Sx_primitives.register "collected" (fun _args -> List []);
+  Sx_primitives.register "clear-collected!" (fun _args -> Nil);
+  Sx_primitives.register "scope-collected" (fun _args -> List []);
+  Sx_primitives.register "scope-clear-collected!" (fun _args -> Nil);
+  Sx_primitives.register "provide-push!" (fun args -> match args with [String n; v] -> scope_push n v | _ -> Nil);
+  Sx_primitives.register "provide-pop!" (fun args -> match args with [String n] -> scope_pop n | _ -> Nil);
+  Sx_primitives.register "context" (fun args -> match args with [String n] -> scope_peek n | [String n; _] -> scope_peek n | _ -> Nil);
+
+  (* Render-mode flags *)
+  ignore (env_bind env "*render-active*" (Bool false));
+  bind "set-render-active!" (fun args ->
+    match args with [v] -> ignore (env_set env "*render-active*" v); Nil | _ -> Nil);
+  bind "render-active?" (fun _args ->
+    try env_get env "*render-active*" with _ -> Bool false);
+  bind "definition-form?" (fun args ->
+    match args with
+    | [String s] -> Bool (List.mem s ["define"; "defcomp"; "defisland"; "defmacro";
+        "defstyle"; "defhandler"; "deftype"; "defeffect"; "defquery"; "defaction"; "defrelation"])
+    | _ -> Bool false);
+
+  (* Signal stubs for SSR — overridden when signals.sx is loaded *)
+  bind "signal" (fun args -> match args with [v] -> v | _ -> Nil);
+  bind "computed" (fun args -> match args with [f] -> Sx_runtime.sx_call f [] | _ -> Nil);
+  bind "deref" (fun args -> match args with [v] -> v | _ -> Nil);
+  bind "reset!" (fun _args -> Nil);
+  bind "swap!" (fun _args -> Nil);
+  bind "effect" (fun _args -> Nil);
+  bind "batch" (fun _args -> Nil);
+
+  (* Type predicates — needed by adapter-sx.sx *)
+  bind "callable?" (fun args ->
+    match args with [NativeFn _] | [Lambda _] | [Component _] | [Island _] -> Bool true | _ -> Bool false);
+  bind "lambda?" (fun args -> match args with [Lambda _] -> Bool true | _ -> Bool false);
+  bind "macro?" (fun args -> match args with [Macro _] -> Bool true | _ -> Bool false);
+  bind "island?" (fun args -> match args with [Island _] -> Bool true | _ -> Bool false);
+  bind "component?" (fun args ->
+    match args with [Component _] | [Island _] -> Bool true | _ -> Bool false);
+  bind "spread?" (fun args -> match args with [Spread _] -> Bool true | _ -> Bool false);
+  bind "lambda-params" (fun args ->
+    match args with [Lambda l] -> List (List.map (fun s -> String s) l.l_params) | _ -> List []);
+  bind "lambda-body" (fun args -> match args with [Lambda l] -> l.l_body | _ -> Nil);
+  bind "lambda-closure" (fun args ->
+    match args with [Lambda l] -> Env l.l_closure | _ -> Dict (Hashtbl.create 0));
+  bind "component-name" (fun args ->
+    match args with [Component c] -> String c.c_name | [Island i] -> String i.i_name | _ -> String "");
+  bind "component-closure" (fun args ->
+    match args with [Component c] -> Env c.c_closure | [Island i] -> Env i.i_closure | _ -> Dict (Hashtbl.create 0));
+  bind "component-params" (fun args ->
+    match args with
+    | [Component c] -> List (List.map (fun s -> String s) c.c_params)
+    | [Island i] -> List (List.map (fun s -> String s) i.i_params)
+    | _ -> Nil);
+  bind "component-body" (fun args ->
+    match args with [Component c] -> c.c_body | [Island i] -> i.i_body | _ -> Nil);
+  bind "component-affinity" (fun args ->
+    match args with [Component c] -> String c.c_affinity
+    | [Island _] -> Nil | _ -> Nil);
+  bind "component-has-children?" (fun args ->
+    match args with
+    | [Component c] -> Bool (List.mem "children" c.c_params)
+    | [Island i] -> Bool (List.mem "children" i.i_params)
+    | _ -> Bool false);
+
+  (* Evaluator bridge — needed by adapter-sx.sx *)
+  bind "call-lambda" (fun args ->
+    match args with
+    | [fn_val; List call_args; Env _e] ->
+      Sx_ref.cek_call fn_val (List call_args)
+    | [fn_val; List call_args] ->
+      Sx_ref.cek_call fn_val (List call_args)
+    | _ -> raise (Eval_error "call-lambda: expected (fn args env?)"));
+  bind "cek-call" (fun args ->
+    match args with
+    | [fn_val; List call_args] -> Sx_ref.cek_call fn_val (List call_args)
+    | [fn_val; Nil] -> Sx_ref.cek_call fn_val (List [])
+    | [fn_val] -> Sx_ref.cek_call fn_val (List [])
+    | _ -> Nil);
+  bind "expand-macro" (fun args ->
+    match args with
+    | [Macro m; List macro_args; Env e] ->
+      let body_env = { bindings = Hashtbl.create 16; parent = Some e } in
+      List.iteri (fun i p ->
+        let v = if i < List.length macro_args then List.nth macro_args i else Nil in
+        Hashtbl.replace body_env.bindings p v
+      ) m.m_params;
+      Sx_ref.eval_expr m.m_body (Env body_env)
+    | _ -> raise (Eval_error "expand-macro: expected (macro args env)"));
+  bind "eval-expr" (fun args ->
+    match args with
+    | [expr; e] -> Sx_ref.eval_expr expr (Env (Sx_runtime.unwrap_env e))
+    | [expr] -> Sx_ref.eval_expr expr (Env env)
+    | _ -> raise (Eval_error "eval-expr: expected (expr env?)"));
+  bind "trampoline" (fun args ->
+    match args with
+    | [v] ->
+      let rec resolve v = match v with
+        | Thunk (body, closure_env) -> resolve (Sx_ref.eval_expr body (Env closure_env))
+        | _ -> v
+      in resolve v
+    | _ -> raise (Eval_error "trampoline: expected 1 arg"));
+  bind "expand-components?" (fun _args -> Bool false);
+  bind "register-special-form!" (fun args ->
+    match args with
+    | [String name; handler] ->
+      ignore (Sx_ref.register_special_form (String name) handler); Nil
+    | _ -> raise (Eval_error "register-special-form!: expected (name handler)"));
+  ignore (env_bind env "*custom-special-forms*" Sx_ref.custom_special_forms);
+
+  (* DOM stubs *)
+  bind "create-text-node" (fun args -> match args with [String s] -> String s | _ -> Nil);
+  bind "create-fragment" (fun _args -> Nil);
+  bind "dom-create-element" (fun _args -> Nil);
+  bind "dom-append" (fun _args -> Nil);
+  bind "dom-set-attr" (fun _args -> Nil);
+  bind "dom-set-prop" (fun _args -> Nil);
+  bind "dom-get-attr" (fun _args -> Nil);
+  bind "dom-query" (fun _args -> Nil);
+  bind "dom-body" (fun _args -> Nil);
+
+  (* Misc stubs *)
+  bind "random-int" (fun args ->
+    match args with
+    | [Number lo; Number hi] -> Number (lo +. Float.round (Random.float (hi -. lo)))
+    | _ -> Number 0.0);
+  bind "expand-components?" (fun _args -> Bool false);
+  bind "freeze-scope" (fun _args -> Nil);
+  bind "freeze-signal" (fun _args -> Nil);
+  bind "thaw-from-sx" (fun _args -> Nil);
+  bind "local-storage-get" (fun _args -> Nil);
+  bind "local-storage-set" (fun _args -> Nil);
+  bind "schedule-idle" (fun _args -> Nil);
+  bind "run-post-render-hooks" (fun _args -> Nil);
+  bind "freeze-to-sx" (fun _args -> String "");
+
+  env
+
+
+let () =
+  Printexc.record_backtrace true;
+
+  (* Find project root *)
+  let rec find_root dir =
+    let candidate = Filename.concat dir "spec/render.sx" in
+    if Sys.file_exists candidate then dir
+    else let parent = Filename.dirname dir in
+    if parent = dir then Sys.getcwd () else find_root parent
+  in
+  let root = find_root (Sys.getcwd ()) in
+  let spec p = Filename.concat (Filename.concat root "spec") p in
+  let lib p = Filename.concat (Filename.concat root "lib") p in
+  let web p = Filename.concat (Filename.concat root "web") p in
+
+  let env = make_integration_env () in
+
+  (* Load spec + lib + adapters *)
+  Printf.printf "Loading spec + lib + adapters...\n%!";
+  let load path =
+    if Sys.file_exists path then begin
+      let exprs = Sx_parser.parse_file path in
+      List.iter (fun expr -> ignore (Sx_ref.eval_expr expr (Env env))) exprs;
+      Printf.printf "  loaded %s (%d defs)\n%!" (Filename.basename path) (List.length exprs)
+    end else
+      Printf.printf "  SKIP %s (not found)\n%!" path
+  in
+  load (spec "parser.sx");
+  load (spec "render.sx");
+  load (web "signals.sx");
+  load (web "adapter-html.sx");
+  load (web "adapter-sx.sx");
+  ignore lib; (* available for future library loading *)
+
+  (* Helper: render SX source string to HTML *)
+  let render_html src =
+    let exprs = Sx_parser.parse_all src in
+    let expr = match exprs with [e] -> e | _ -> Nil in
+    Sx_render.render_to_html expr env
+  in
+
+  (* Helper: call SX render-to-html via the adapter *)
+  let sx_render_html src =
+    let exprs = Sx_parser.parse_all src in
+    let expr = match exprs with [e] -> e | _ -> Nil in
+    let call = List [Symbol "render-to-html"; List [Symbol "quote"; expr]; Env env] in
+    match Sx_ref.eval_expr call (Env env) with
+    | String s | RawHTML s -> s
+    | v -> value_to_string v
+  in
+
+  (* ================================================================== *)
+  Printf.printf "\nSuite: native renderer — HTML tags\n%!";
+  assert_eq "div" "<div>hello</div>" (render_html "(div \"hello\")");
+  assert_eq "div with class" "<div class=\"card\">text</div>" (render_html "(div :class \"card\" \"text\")");
+  assert_eq "nested tags" "<div><p>inner</p></div>" (render_html "(div (p \"inner\"))");
+  assert_eq "void element" "<br />" (render_html "(br)");
+  assert_eq "h1" "<h1>Title</h1>" (render_html "(h1 \"Title\")");
+  assert_eq "span with attrs" "<span class=\"bold\">text</span>" (render_html "(span :class \"bold\" \"text\")");
+
+  (* ================================================================== *)
+  Printf.printf "\nSuite: SX adapter render-to-html — HTML tags\n%!";
+  assert_no_error "div doesn't throw" (fun () -> sx_render_html "(div \"hello\")");
+  assert_contains "div produces tag" "<div" (sx_render_html "(div \"hello\")");
+  assert_contains "div with class" "class=\"card\"" (sx_render_html "(div :class \"card\" \"text\")");
+  assert_contains "nested tags" "<p>" (sx_render_html "(div (p \"inner\"))");
+  assert_no_error "h1 doesn't throw" (fun () -> sx_render_html "(h1 \"Title\")");
+  assert_no_error "span doesn't throw" (fun () -> sx_render_html "(span :class \"bold\" \"text\")");
+  assert_no_error "table doesn't throw" (fun () -> sx_render_html "(table (tr (td \"cell\")))");
+
+  (* ================================================================== *)
+  Printf.printf "\nSuite: SX adapter — special forms in HTML context\n%!";
+  assert_contains "when true renders" "<p>" (sx_render_html "(when true (p \"yes\"))");
+  assert_eq "when false empty" "" (sx_render_html "(when false (p \"no\"))");
+  assert_contains "if true branch" "yes" (sx_render_html "(if true (span \"yes\") (span \"no\"))");
+  assert_contains "if false branch" "no" (sx_render_html "(if false (span \"yes\") (span \"no\"))");
+  assert_contains "let in render" "hello" (sx_render_html "(let ((x \"hello\")) (p x))");
+
+  (* ================================================================== *)
+  Printf.printf "\nSuite: SX adapter — letrec in HTML context\n%!";
+  assert_no_error "letrec with div body" (fun () ->
+    sx_render_html "(letrec ((x 42)) (div (str x)))");
+  assert_contains "letrec renders body" "<div>" (sx_render_html "(letrec ((x 42)) (div (str x)))");
+  assert_no_error "letrec with side effects then div" (fun () ->
+    sx_render_html "(letrec ((x 1) (y 2)) (let ((z (+ x y))) (div (str z))))");
+
+  (* ================================================================== *)
+  Printf.printf "\nSuite: SX adapter — components\n%!";
+  (try
+    assert_no_error "defcomp + render" (fun () ->
+      ignore (Sx_ref.eval_expr
+        (List.hd (Sx_parser.parse_all "(defcomp ~test-card (&key title &rest children) (div :class \"card\" (h2 title) children))"))
+        (Env env));
+      sx_render_html "(~test-card :title \"Hi\" (p \"body\"))");
+    assert_contains "component renders div" "<div" (sx_render_html "(~test-card :title \"Hi\" (p \"body\"))");
+    assert_contains "component renders title" "Hi" (sx_render_html "(~test-card :title \"Hi\" (p \"body\"))")
+  with Eval_error msg -> incr fail_count; Printf.printf "  FAIL: components — %s\n%!" msg);
+
+  (* ================================================================== *)
+  Printf.printf "\nSuite: eval-expr with HTML tag functions\n%!";
+  assert_no_error "eval (div) returns list" (fun () ->
+    Sx_ref.eval_expr (List [Symbol "div"; Keyword "class"; String "foo"; String "hi"]) (Env env));
+  assert_no_error "eval (span) returns list" (fun () ->
+    Sx_ref.eval_expr (List [Symbol "span"; String "text"]) (Env env));
+
+  (* ================================================================== *)
+  (* Regression: call-lambda re-evaluated Dict args through eval_expr,
+     which copies dicts.  Mutations inside the lambda (e.g. signal
+     reset!) operated on the copy, not the original.  This broke
+     island SSR where aser processes multi-body let forms. *)
+  Printf.printf "\nSuite: call-lambda dict identity (aser mode)\n%!";
+  let aser_eval src =
+    let exprs = Sx_parser.parse_all src in
+    let expr = match exprs with [e] -> e | _ -> Nil in
+    let call = List [Symbol "aser"; List [Symbol "quote"; expr]; Env env] in
+    match Sx_ref.eval_expr call (Env env) with
+    | String s | SxExpr s -> s
+    | v -> value_to_string v
+  in
+  assert_eq "lambda dict mutation in aser multi-body let"
+    "99"
+    (aser_eval
+      "(let ((mutate! (fn (d k v) (dict-set! d k v)))
+             (d (dict \"x\" 1)))
+         (mutate! d \"x\" 99)
+         (get d \"x\"))");
+  assert_eq "signal reset! in aser multi-body let"
+    "99"
+    (aser_eval
+      "(let ((s (signal 42)))
+         (reset! s 99)
+         (deref s))");
+  assert_eq "signal reset! then len of deref"
+    "3"
+    (aser_eval
+      "(let ((s (signal (list))))
+         (reset! s (list 1 2 3))
+         (len (deref s)))");
+
+  (* ================================================================== *)
+  Printf.printf "\n";
+  Printf.printf "============================================================\n";
+  Printf.printf "Integration: %d passed, %d failed\n" !pass_count !fail_count;
+  Printf.printf "============================================================\n";
+  if !fail_count > 0 then exit 1

hosts/ocaml/bin/run_tests.ml

@@ -0,0 +1,830 @@
+(** 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 --- *)
+
+  (* Env operations — accept both Env and Dict *)
+  let uw = Sx_runtime.unwrap_env in
+  bind "env-get" (fun args ->
+    match args with
+    | [e; String k] -> Sx_types.env_get (uw e) k
+    | [e; Keyword k] -> Sx_types.env_get (uw e) k
+    | _ -> raise (Eval_error "env-get: expected env and string"));
+
+  bind "env-has?" (fun args ->
+    match args with
+    | [e; String k] -> Bool (Sx_types.env_has (uw e) k)
+    | [e; Keyword k] -> Bool (Sx_types.env_has (uw e) k)
+    | _ -> raise (Eval_error "env-has?: expected env and string"));
+
+  bind "env-bind!" (fun args ->
+    match args with
+    | [e; String k; v] ->
+      let ue = uw e in
+      if k = "x" || k = "children" || k = "i" then
+        Printf.eprintf "[env-bind!] '%s' env-id=%d bindings-before=%d\n%!" k (Obj.obj (Obj.repr ue) : int) (Hashtbl.length ue.Sx_types.bindings);
+      Sx_types.env_bind ue k v
+    | [e; Keyword k; v] -> Sx_types.env_bind (uw e) k v
+    | _ -> raise (Eval_error "env-bind!: expected env, key, value"));
+
+  bind "env-set!" (fun args ->
+    match args with
+    | [e; String k; v] -> Sx_types.env_set (uw e) k v
+    | [e; Keyword k; v] -> Sx_types.env_set (uw e) k v
+    | _ -> raise (Eval_error "env-set!: expected env, key, value"));
+
+  bind "env-extend" (fun args ->
+    match args with
+    | [e] -> Env (Sx_types.env_extend (uw e))
+    | _ -> raise (Eval_error "env-extend: expected env"));
+
+  bind "env-merge" (fun args ->
+    match args with
+    | [a; b] -> Sx_runtime.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;
+
+  (* Stubs needed by adapter-html.sx when loaded at test time *)
+  bind "set-render-active!" (fun _args -> Nil);
+  bind "render-active?" (fun _args -> Bool true);
+  bind "trampoline" (fun args ->
+    match args with
+    | [Thunk (expr, e)] -> eval_expr expr (Env e)
+    | [v] -> v
+    | _ -> Nil);
+  bind "eval-expr" (fun args ->
+    match args with
+    | [expr; e] ->
+      let ue = Sx_runtime.unwrap_env e in
+      eval_expr expr (Env ue)
+    | [expr] -> eval_expr expr (Env env)
+    | _ -> raise (Eval_error "eval-expr: expected (expr env)"));
+  (* Scope primitives — use a local scope stacks table.
+     Must match the same pattern as sx_server.ml's _scope_stacks. *)
+  let _scope_stacks : (string, Sx_types.value list) Hashtbl.t = Hashtbl.create 8 in
+  bind "scope-push!" (fun args ->
+    match args with
+    | [String name; value] ->
+      let stack = try Hashtbl.find _scope_stacks name with Not_found -> [] in
+      Hashtbl.replace _scope_stacks name (value :: stack); Nil
+    | [String name] ->
+      let stack = try Hashtbl.find _scope_stacks name with Not_found -> [] in
+      Hashtbl.replace _scope_stacks name (Nil :: stack); Nil
+    | _ -> Nil);
+  bind "scope-pop!" (fun args ->
+    match args with
+    | [String name] ->
+      let stack = try Hashtbl.find _scope_stacks name with Not_found -> [] in
+      (match stack with _ :: rest -> Hashtbl.replace _scope_stacks name rest | [] -> ()); Nil
+    | _ -> Nil);
+  bind "scope-emit!" (fun args ->
+    match args with
+    | [String name; value] ->
+      let stack = try Hashtbl.find _scope_stacks name with Not_found -> [] in
+      (match stack with
+       | List items :: rest ->
+         Hashtbl.replace _scope_stacks name (List (items @ [value]) :: rest)
+       | _ :: rest ->
+         Hashtbl.replace _scope_stacks name (List [value] :: rest)
+       | [] ->
+         Hashtbl.replace _scope_stacks name [List [value]]);
+      Nil
+    | _ -> Nil);
+  bind "emitted" (fun args ->
+    match args with
+    | [String name] ->
+      let stack = try Hashtbl.find _scope_stacks name with Not_found -> [] in
+      (match stack with List items :: _ -> List items | _ -> List [])
+    | _ -> List []);
+  bind "scope-emitted" (fun args ->
+    match args with
+    | [String name] ->
+      let stack = try Hashtbl.find _scope_stacks name with Not_found -> [] in
+      (match stack with List items :: _ -> List items | _ -> List [])
+    | _ -> List []);
+  bind "provide-push!" (fun args ->
+    match args with
+    | [String name; value] ->
+      let stack = try Hashtbl.find _scope_stacks name with Not_found -> [] in
+      Hashtbl.replace _scope_stacks name (value :: stack); Nil
+    | _ -> Nil);
+  bind "provide-pop!" (fun args ->
+    match args with
+    | [String name] ->
+      let stack = try Hashtbl.find _scope_stacks name with Not_found -> [] in
+      (match stack with _ :: rest -> Hashtbl.replace _scope_stacks name rest | [] -> ()); Nil
+    | _ -> Nil);
+  bind "cond-scheme?" (fun args ->
+    match args with
+    | [(List clauses | ListRef { contents = clauses })] ->
+      (match clauses with
+       | (List _ | ListRef _) :: _ -> Bool true
+       | _ -> Bool false)
+    | _ -> Bool false);
+  bind "expand-macro" (fun args ->
+    match args with
+    | [Macro m; (List a | ListRef { contents = a }); _] ->
+      let local = Sx_types.env_extend m.m_closure in
+      List.iteri (fun i p ->
+        ignore (Sx_types.env_bind local p (if i < List.length a then List.nth a i else Nil))
+      ) m.m_params;
+      eval_expr m.m_body (Env local)
+    | _ -> raise (Eval_error "expand-macro: expected (macro args 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)
+    | [Island i] -> List (List.map (fun s -> String s) i.i_params)
+    | _ -> Nil);
+
+  bind "component-body" (fun args ->
+    match args with
+    | [Component c] -> c.c_body
+    | [Island i] -> i.i_body
+    | _ -> Nil);
+
+  bind "component-has-children" (fun args ->
+    match args with
+    | [Component c] -> Bool c.c_has_children
+    | [Island i] -> Bool i.i_has_children
+    | _ -> Bool false);
+
+  bind "component-affinity" (fun args ->
+    match args with
+    | [Component c] -> String c.c_affinity
+    | [Island _] -> String "client"
+    | _ -> 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; l_compiled = None } in
+  assert_true "is_lambda" (Bool (Sx_types.is_lambda (Lambda l)));
+  ignore (Sx_types.set_lambda_name (Lambda l) "my-fn");
+  assert_eq "lambda name mutated" (String "my-fn") (lambda_name (Lambda l))
+
+
+(* ====================================================================== *)
+(* 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;
+
+  (* Load modules needed by tests *)
+  let spec_dir = Filename.concat project_dir "spec" in
+  let lib_dir = Filename.concat project_dir "lib" in
+  let web_dir = Filename.concat project_dir "web" in
+  let load_module name dir =
+    let path = Filename.concat dir name in
+    if Sys.file_exists path then begin
+      Printf.printf "Loading %s...\n%!" name;
+      (try load_and_eval path
+       with e -> Printf.eprintf "Warning: %s: %s\n%!" name (Printexc.to_string e))
+    end
+  in
+  (* Render adapter for test-render-html.sx *)
+  load_module "render.sx" spec_dir;
+  load_module "adapter-html.sx" web_dir;
+  (* Library modules for lib/tests/ *)
+  load_module "bytecode.sx" lib_dir;
+  load_module "compiler.sx" lib_dir;
+  load_module "vm.sx" lib_dir;
+  load_module "signals.sx" web_dir;
+  load_module "freeze.sx" lib_dir;
+  load_module "content.sx" lib_dir;
+  load_module "types.sx" lib_dir;
+
+  (* Determine test files — scan spec/tests/ and lib/tests/ *)
+  let lib_tests_dir = Filename.concat project_dir "lib/tests" in
+  let files = if test_files = [] then begin
+    (* Spec tests (core language — always run) *)
+    let spec_entries = Sys.readdir spec_tests_dir in
+    Array.sort String.compare spec_entries;
+    let spec_files = Array.to_list spec_entries
+      |> List.filter (fun f ->
+        String.length f > 5 &&
+        String.sub f 0 5 = "test-" &&
+        Filename.check_suffix f ".sx" &&
+        f <> "test-framework.sx")
+      |> List.map (fun f -> Filename.concat spec_tests_dir f)
+    in
+    spec_files
+  end else
+    (* Specific test files — search all test dirs *)
+    List.map (fun name ->
+      let name = if Filename.check_suffix name ".sx" then name else name ^ ".sx" in
+      let spec_path = Filename.concat spec_tests_dir name in
+      let lib_path = Filename.concat lib_tests_dir name in
+      if Sys.file_exists spec_path then spec_path
+      else if Sys.file_exists lib_path then lib_path
+      else Filename.concat spec_tests_dir name  (* will fail with "not found" *)
+    ) test_files
+  in
+
+  List.iter (fun path ->
+    if Sys.file_exists path then begin
+      let name = Filename.basename path in
+      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/bootstrap.py

@@ -0,0 +1,276 @@
+#!/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 — forward ref, resolved after eval_expr is defined. *)
+let trampoline_fn : (value -> value) ref = ref (fun v -> v)
+let trampoline v = !trampoline_fn v
+
+
+
+(* === Mutable state for strict mode === *)
+(* These are defined as top-level refs because the transpiler cannot handle
+   global set! mutation (it creates local refs that shadow the global). *)
+let _strict_ref = ref (Bool false)
+let _prim_param_types_ref = ref Nil
+
+(* JIT call hook — cek_call checks this before CEK dispatch for named
+   lambdas.  Registered by sx_server.ml after compiler loads.  Tests
+   run with hook = None (pure CEK, no compilation dependency). *)
+let jit_call_hook : (value -> value list -> value option) option ref = ref None
+
+"""
+
+
+# OCaml fixups — wire up trampoline + iterative CEK run + JIT hook
+FIXUPS = """\
+
+(* Wire up trampoline to resolve thunks via the CEK machine *)
+let () = trampoline_fn := (fun v ->
+  match v with
+  | Thunk (expr, env) -> eval_expr expr (Env env)
+  | _ -> v)
+
+(* Wire up the primitives trampoline so call_any in HO forms resolves Thunks *)
+let () = Sx_primitives._sx_trampoline_fn := !trampoline_fn
+
+(* 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."""
+    import tempfile
+    from shared.sx.ocaml_sync import OcamlSync
+    from shared.sx.parser import serialize
+
+    if spec_dir is None:
+        spec_dir = os.path.join(_PROJECT, "spec")
+
+    # Load the transpiler into OCaml kernel
+    bridge = OcamlSync()
+    transpiler_path = os.path.join(_HERE, "transpiler.sx")
+    bridge.load(transpiler_path)
+
+    # Spec files to transpile (in dependency order)
+    # stdlib.sx functions are already registered as OCaml primitives —
+    # only the evaluator needs transpilation.
+    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, fixups, or already-registered primitives
+        # Skip: preamble-provided, math primitives, and stdlib functions
+        # that use loop/named-let (transpiler can't handle those yet)
+        skip = {"trampoline", "ceil", "floor", "round", "abs", "min", "max",
+                "debug-log", "debug_log", "range", "chunk-every", "zip-pairs",
+                "string-contains?", "starts-with?", "ends-with?",
+                "string-replace", "trim", "split", "index-of",
+                "pad-left", "pad-right", "char-at", "substring"}
+        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 and known names for the transpiler
+        defines_list = [[name, expr] for name, expr in defines]
+        known_names = [name for name, _ in defines]
+
+        # Serialize defines + known names to temp file, load into kernel
+        defines_sx = serialize(defines_list)
+        known_sx = serialize(known_names)
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".sx", delete=False) as tmp:
+            tmp.write(f"(define _defines \'{defines_sx})\n")
+            tmp.write(f"(define _known_defines \'{known_sx})\n")
+            tmp_path = tmp.name
+        try:
+            bridge.load(tmp_path)
+        finally:
+            os.unlink(tmp_path)
+
+        # Call ml-translate-file — emits as single let rec block
+        result = bridge.eval("(ml-translate-file _defines)")
+
+        parts.append(f"\n(* === Transpiled from {label} === *)\n")
+        parts.append(result)
+
+    bridge.stop()
+    parts.append(FIXUPS)
+    output = "\n".join(parts)
+
+    # Post-process: fix mutable globals that the transpiler can't handle.
+    # The transpiler emits local refs for set! targets within functions,
+    # but top-level globals (*strict*, *prim-param-types*) need to use
+    # the pre-declared refs from the preamble.
+    import re
+
+    # Fix *strict*: use _strict_ref instead of immutable let rec binding
+    output = re.sub(
+        r'and _strict_ =\n  \(Bool false\)',
+        'and _strict_ = !_strict_ref',
+        output,
+    )
+    # Fix set-strict!: use _strict_ref instead of local ref
+    output = re.sub(
+        r'and set_strict_b val\' =\n  let _strict_ = ref Nil in \(_strict_ := val\'; Nil\)',
+        "and set_strict_b val' =\n  _strict_ref := val'; Nil",
+        output,
+    )
+    # Fix *prim-param-types*: use _prim_param_types_ref
+    output = re.sub(
+        r'and _prim_param_types_ =\n  Nil',
+        'and _prim_param_types_ = !_prim_param_types_ref',
+        output,
+    )
+    # Fix set-prim-param-types!: use _prim_param_types_ref
+    output = re.sub(
+        r'and set_prim_param_types_b types =\n  let _prim_param_types_ = ref Nil in \(_prim_param_types_ := types; Nil\)',
+        "and set_prim_param_types_b types =\n  _prim_param_types_ref := types; Nil",
+        output,
+    )
+
+    # Fix all runtime reads of _strict_ and _prim_param_types_ to deref
+    # the mutable refs instead of using the stale let-rec bindings.
+    # This is needed because let-rec value bindings capture initial values.
+    # Use regex with word boundary to avoid replacing _strict_ref with
+    # !_strict_refref.
+    def fix_mutable_reads(text):
+        lines = text.split('\n')
+        fixed = []
+        for line in lines:
+            # Skip the definition lines
+            stripped = line.strip()
+            if stripped.startswith('and _strict_ =') or stripped.startswith('and _prim_param_types_ ='):
+                fixed.append(line)
+                continue
+            # Replace _strict_ as a standalone identifier only (not inside
+            # other names like set_strict_b). Match when preceded by space,
+            # paren, or start-of-line, and followed by space, paren, or ;.
+            line = re.sub(r'(?<=[ (])_strict_(?=[ );])', '!_strict_ref', line)
+            line = re.sub(r'(?<=[ (])_prim_param_types_(?=[ );])', '!_prim_param_types_ref', line)
+            fixed.append(line)
+        return '\n'.join(fixed)
+    output = fix_mutable_reads(output)
+
+    # Fix cek_call: the spec passes (make-env) as the env arg to
+    # continue_with_call, but the transpiler evaluates make-env at
+    # transpile time (it's a primitive), producing Dict instead of Env.
+    output = output.replace(
+        "((Dict (Hashtbl.create 0))) (a) ((List []))",
+        "(Env (Sx_types.make_env ())) (a) ((List []))",
+    )
+
+    # Inject JIT dispatch into continue_with_call's lambda branch.
+    # After params are bound, check jit_call_hook before creating CEK state.
+    lambda_body_pattern = (
+        '(prim_call "slice" [params; (len (args))])); Nil)) in '
+        '(make_cek_state ((lambda_body (f))) (local) (kont))'
+    )
+    lambda_body_jit = (
+        '(prim_call "slice" [params; (len (args))])); Nil)) in '
+        '(match !jit_call_hook, f with '
+        '| Some hook, Lambda l when l.l_name <> None -> '
+        'let args_list = match args with '
+        'List a | ListRef { contents = a } -> a | _ -> [] in '
+        '(match hook f args_list with '
+        'Some result -> make_cek_value result local kont '
+        '| None -> make_cek_state (lambda_body f) local kont) '
+        '| _ -> make_cek_state ((lambda_body (f))) (local) (kont))'
+    )
+    if lambda_body_pattern in output:
+        output = output.replace(lambda_body_pattern, lambda_body_jit, 1)
+    else:
+        import sys
+        print("WARNING: Could not find lambda body pattern for JIT injection", file=sys.stderr)
+
+    return output
+
+
+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/browser/test_page_render.js

@@ -0,0 +1,18 @@
+const path = require("path");
+const fs = require("fs");
+require(path.join(__dirname, "../_build/default/browser/sx_browser.bc.js"));
+require(path.join(__dirname, "sx-platform.js"));
+const K = globalThis.SxKernel;
+for (const n of ["signals","deps","page-helpers","router","adapter-html"])
+  K.loadSource(fs.readFileSync(path.join(__dirname,`../../../web/${n}.sx`),"utf8"));
+K.loadSource(fs.readFileSync("/tmp/comp_defs.txt","utf8"));
+
+const pageSx = fs.readFileSync("/tmp/page_sx.txt","utf8");
+const parsed = K.parse(pageSx);
+const html = K.renderToHtml(parsed[0]);
+if (typeof html === "string" && !html.startsWith("Error:")) {
+  console.log("SUCCESS! Rendered", html.length, "chars of HTML");
+  console.log("Preview:", html.substring(0, 200));
+} else {
+  console.log("Error:", html);
+}

hosts/ocaml/browser/test_signals.js

@@ -0,0 +1,25 @@
+const path = require("path");
+const fs = require("fs");
+require(path.join(__dirname, "../_build/default/browser/sx_browser.bc.js"));
+require(path.join(__dirname, "sx-platform.js"));
+const K = globalThis.SxKernel;
+for (const n of ["signals","deps","page-helpers","router","adapter-html"])
+  K.loadSource(fs.readFileSync(path.join(__dirname,`../../../web/${n}.sx`),"utf8"));
+
+// Test signal basics
+const tests = [
+  '(signal 42)',
+  '(let ((s (signal 42))) (deref s))',
+  '(let ((s (signal 42))) (reset! s 100) (deref s))',
+  '(let ((s (signal 10))) (swap! s (fn (v) (* v 2))) (deref s))',
+  '(let ((s (signal 0))) (computed (fn () (+ (deref s) 1))))',
+  '(let ((idx (signal 0))) (let ((c (computed (fn () (+ (deref idx) 10))))) (deref c)))',
+];
+
+for (const t of tests) {
+  const r = K.eval(t);
+  const s = JSON.stringify(r);
+  console.log(`${t.substring(0,60)}`);
+  console.log(`  => ${s && s.length > 100 ? s.substring(0,100) + '...' : s}`);
+  console.log();
+}

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,213 @@
+(** 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 ()
+
+(* Character classification — matches spec/parser.sx ident-start/ident-char.
+   ident-start: a-z A-Z _ ~ * + - > < = / ! ? &
+   ident-char:  ident-start plus 0-9 . : / # , *)
+let is_ident_start = function
+  | 'a'..'z' | 'A'..'Z' | '_' | '~' | '*' | '+' | '-'
+  | '>' | '<' | '=' | '/' | '!' | '?' | '&' -> true
+  | _ -> false
+
+let is_ident_char = function
+  | c when is_ident_start c -> true
+  | '0'..'9' | '.' | ':' | '#' | ',' -> true
+  | _ -> false
+
+(* Symbol reading uses ident_char; first char must be ident_start or digit/colon *)
+let is_symbol_char = is_ident_char
+
+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 ()
+  | ',' ->
+    (* Unquote / splice-unquote — matches spec: , always triggers unquote *)
+    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]
+  | _ ->
+    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,813 @@
+(** 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
+
+(** Forward refs for calling SX functions from primitives (breaks cycle). *)
+let _sx_call_fn : (value -> value list -> value) ref =
+  ref (fun _ _ -> raise (Eval_error "sx_call not initialized"))
+let _sx_trampoline_fn : (value -> value) ref =
+  ref (fun v -> v)
+
+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 ^ ": " ^ (match v with Dict d -> (match Hashtbl.find_opt d "__signal" with Some _ -> "signal{value=" ^ (match Hashtbl.find_opt d "value" with Some v' -> value_to_string v' | None -> "?") ^ "}" | None -> "dict") | _ -> "")))
+
+let as_string = function
+  | String s -> s
+  | v -> raise (Eval_error ("Expected string, got " ^ type_of v))
+
+let rec as_list = function
+  | List l -> l
+  | ListRef r -> !r
+  | Nil -> []
+  | Thunk _ as t -> as_list (!_sx_trampoline_fn t)
+  | 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 (floor (as_number a))
+    | _ -> raise (Eval_error "floor: 1 arg"));
+  register "ceil" (fun args ->
+    match args with [a] -> Number (ceil (as_number a))
+    | _ -> 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)
+    | [String s; default_val] ->
+      (match int_of_string_opt s with Some n -> Number (float_of_int n) | None -> default_val)
+    | [Number n] | [Number n; _] -> Number (float_of_int (int_of_float n))
+    | [_; default_val] -> default_val
+    | _ -> 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 ->
+    let to_str = function
+      | String s -> s | SxExpr s -> s | RawHTML s -> s
+      | Keyword k -> k | Symbol s -> s
+      | 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
+      | Thunk _ as t -> (match !_sx_trampoline_fn t with String s -> s | v -> to_string v)
+      | v -> to_string v
+    in
+    match args with
+    | [s; old_s; new_s] ->
+      let s = to_str s and old_s = to_str old_s and new_s = to_str new_s in
+      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] | [Bool false] -> Number 0.0
+    | [Bool true] -> Number 1.0
+    | [Number _] -> Number 1.0
+    | [RawHTML s] -> Number (float_of_int (String.length s))
+    | [SxExpr s] -> Number (float_of_int (String.length s))
+    | [Spread pairs] -> Number (float_of_int (List.length pairs))
+    | [Component _] | [Island _] | [Lambda _] | [NativeFn _]
+    | [Macro _] | [Thunk _] | [Keyword _] | [Symbol _] -> Number 0.0
+    | _ -> raise (Eval_error (Printf.sprintf "len: %d args"
+        (List.length args))));
+  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 "init" (fun args ->
+    match args with
+    | [List l] | [ListRef { contents = l }] ->
+      (match List.rev l with _ :: rest -> List (List.rev rest) | [] -> List [])
+    | _ -> raise (Eval_error "init: 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)
+    | [String s; Number n] ->
+      let i = int_of_float n in
+      if i >= 0 && i < String.length s then String (String.make 1 s.[i])
+      else Nil
+    | _ -> raise (Eval_error "nth: list/string 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 ->
+    match args with
+    | [List la | ListRef { contents = la }; List lb | ListRef { contents = lb }] ->
+      List (la @ lb)
+    | [List la | ListRef { contents = la }; Nil] -> List la
+    | [Nil; List lb | ListRef { contents = lb }] -> List lb
+    | [List la | ListRef { contents = la }; v] -> List (la @ [v])
+    | [v; List lb | ListRef { contents = lb }] -> List ([v] @ lb)
+    | _ ->
+      let all = List.concat_map as_list 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)
+    | [Nil; _] -> Nil  (* nil.anything → nil *)
+    | [_; _] -> Nil    (* type mismatch → nil (matches JS/Python behavior) *)
+    | _ -> Nil);
+  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 "mutable-list" (fun _args -> ListRef (ref []));
+  register "set-nth!" (fun args ->
+    match args with
+    | [ListRef r; Number n; v] ->
+      let i = int_of_float n in
+      let l = !r in
+      r := List.mapi (fun j x -> if j = i then v else x) l;
+      Nil
+    | [List _; _; _] ->
+      raise (Eval_error "set-nth!: list is immutable, use ListRef")
+    | _ -> raise (Eval_error "set-nth!: expected (list idx val)"));
+  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 "serialize" (fun args ->
+    match args with
+    | [a] -> String (inspect a)  (* used for dedup keys in compiler *)
+    | _ -> raise (Eval_error "serialize: 1 arg"));
+  register "make-symbol" (fun args ->
+    match args with
+    | [String s] -> Symbol s
+    | _ -> raise (Eval_error "make-symbol: expected string"));
+  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 | ListRef { contents = a })] -> f a
+    | [NativeFn (_, f); Nil] -> f []
+    | _ -> 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"));
+
+  (* Higher-order forms as callable primitives — used by the VM.
+     The CEK machine handles these as special forms with dedicated frames;
+     the VM needs them as plain callable values. *)
+  (* Call any SX callable — handles NativeFn, Lambda (via trampoline), VM closures *)
+  let call_any f args =
+    match f with
+    | NativeFn (_, fn) -> fn args
+    | _ -> !_sx_trampoline_fn (!_sx_call_fn f args)
+  in
+  register "map" (fun args ->
+    match args with
+    | [f; (List items | ListRef { contents = items })] ->
+      List (List.map (fun x -> call_any f [x]) items)
+    | [_; Nil] -> List []
+    | _ -> raise (Eval_error "map: expected (fn list)"));
+  register "map-indexed" (fun args ->
+    match args with
+    | [f; (List items | ListRef { contents = items })] ->
+      List (List.mapi (fun i x -> call_any f [Number (float_of_int i); x]) items)
+    | [_; Nil] -> List []
+    | _ -> raise (Eval_error "map-indexed: expected (fn list)"));
+  register "filter" (fun args ->
+    match args with
+    | [f; (List items | ListRef { contents = items })] ->
+      List (List.filter (fun x -> sx_truthy (call_any f [x])) items)
+    | [_; Nil] -> List []
+    | _ -> raise (Eval_error "filter: expected (fn list)"));
+  register "for-each" (fun args ->
+    match args with
+    | [f; (List items | ListRef { contents = items })] ->
+      List.iter (fun x -> ignore (call_any f [x])) items; Nil
+    | [_; Nil] -> Nil  (* nil collection = no-op *)
+    | _ ->
+      let types = String.concat ", " (List.map (fun v -> type_of v) args) in
+      raise (Eval_error (Printf.sprintf "for-each: expected (fn list), got (%s) %d args" types (List.length args))));
+  register "reduce" (fun args ->
+    match args with
+    | [f; init; (List items | ListRef { contents = items })] ->
+      List.fold_left (fun acc x -> call_any f [acc; x]) init items
+    | _ -> raise (Eval_error "reduce: expected (fn init list)"));
+  register "some" (fun args ->
+    match args with
+    | [f; (List items | ListRef { contents = items })] ->
+      (try List.find (fun x -> sx_truthy (call_any f [x])) items
+       with Not_found -> Bool false)
+    | [_; Nil] -> Bool false
+    | _ -> raise (Eval_error "some: expected (fn list)"));
+  register "every?" (fun args ->
+    match args with
+    | [f; (List items | ListRef { contents = items })] ->
+      Bool (List.for_all (fun x -> sx_truthy (call_any f [x])) items)
+    | [_; Nil] -> Bool true
+    | _ -> raise (Eval_error "every?: expected (fn list)"));
+
+  (* ---- VM stack primitives (vm.sx platform interface) ---- *)
+  register "make-vm-stack" (fun args ->
+    match args with
+    | [Number n] -> ListRef (ref (List.init (int_of_float n) (fun _ -> Nil)))
+    | _ -> raise (Eval_error "make-vm-stack: expected (size)"));
+  register "vm-stack-get" (fun args ->
+    match args with
+    | [ListRef r; Number n] -> List.nth !r (int_of_float n)
+    | _ -> raise (Eval_error "vm-stack-get: expected (stack idx)"));
+  register "vm-stack-set!" (fun args ->
+    match args with
+    | [ListRef r; Number n; v] ->
+      let i = int_of_float n in
+      r := List.mapi (fun j x -> if j = i then v else x) !r; Nil
+    | _ -> raise (Eval_error "vm-stack-set!: expected (stack idx val)"));
+  register "vm-stack-length" (fun args ->
+    match args with
+    | [ListRef r] -> Number (float_of_int (List.length !r))
+    | _ -> raise (Eval_error "vm-stack-length: expected (stack)"));
+  register "vm-stack-copy!" (fun args ->
+    match args with
+    | [ListRef src; ListRef dst; Number n] ->
+      let count = int_of_float n in
+      let src_items = !src in
+      dst := List.mapi (fun i x -> if i < count then List.nth src_items i else x) !dst; Nil
+    | _ -> raise (Eval_error "vm-stack-copy!: expected (src dst count)"));
+  register "primitive?" (fun args ->
+    match args with
+    | [String name] -> Bool (Hashtbl.mem primitives name)
+    | _ -> Bool false);
+
+  (* Scope stack primitives are registered by sx_server.ml / run_tests.ml
+     because they use a shared scope stacks table with collect!/collected. *)
+
+  (* ---- Predicates needed by adapter-html.sx ---- *)
+  register "lambda?" (fun args ->
+    match args with [Lambda _] -> Bool true | _ -> Bool false);
+  register "island?" (fun args ->
+    match args with [Island _] -> Bool true | _ -> Bool false);
+  register "is-else-clause?" (fun args ->
+    match args with
+    | [Keyword "else"] -> Bool true
+    | [Bool true] -> Bool true
+    | _ -> Bool false);
+  register "component?" (fun args ->
+    match args with [Component _] -> Bool true | [Island _] -> Bool true | _ -> Bool false);
+  register "lambda-closure" (fun args ->
+    match args with [Lambda l] -> Env l.l_closure | _ -> Nil);
+  register "component-closure" (fun args ->
+    match args with
+    | [Component c] -> Env c.c_closure
+    | [Island i] -> Env i.i_closure
+    | _ -> Nil);
+  register "component-has-children?" (fun args ->
+    match args with
+    | [Component c] -> Bool c.c_has_children
+    | [Island i] -> Bool i.i_has_children
+    | _ -> Bool false);
+  register "component-name" (fun args ->
+    match args with
+    | [Component c] -> String c.c_name
+    | [Island i] -> String i.i_name
+    | _ -> Nil);
+  register "component-params" (fun args ->
+    match args with
+    | [Component c] -> List (List.map (fun s -> String s) c.c_params)
+    | [Island i] -> List (List.map (fun s -> String s) i.i_params)
+    | _ -> List []);
+  register "component-body" (fun args ->
+    match args with
+    | [Component c] -> c.c_body
+    | [Island i] -> i.i_body
+    | _ -> Nil);
+  register "macro?" (fun args ->
+    match args with [Macro _] -> Bool true | _ -> Bool false);
+  register "for-each-indexed" (fun args ->
+    match args with
+    | [f; (List items | ListRef { contents = items })] ->
+      List.iteri (fun i x -> ignore (call_any f [Number (float_of_int i); x])) items; Nil
+    | _ -> raise (Eval_error "for-each-indexed: expected (fn list)"));
+  register "lambda-params" (fun args ->
+    match args with
+    | [Lambda l] -> List (List.map (fun s -> String s) l.l_params)
+    | _ -> List []);
+  register "lambda-body" (fun args ->
+    match args with [Lambda l] -> l.l_body | _ -> Nil);
+  (* expand-macro is registered later by run_tests.ml / sx_server.ml
+     because it needs eval_expr which creates a dependency cycle *);
+  register "empty-dict?" (fun args ->
+    match args with
+    | [Dict d] -> Bool (Hashtbl.length d = 0)
+    | _ -> Bool true);
+  register "make-raw-html" (fun args ->
+    match args with [String s] -> RawHTML s | _ -> Nil);
+  register "raw-html-content" (fun args ->
+    match args with [RawHTML s] -> String s | _ -> String "");
+  register "get-primitive" (fun args ->
+    match args with
+    | [String name] ->
+      (match Hashtbl.find_opt primitives name with
+       | Some fn -> NativeFn (name, fn)
+       | None -> raise (Eval_error ("VM undefined: " ^ name)))
+    | _ -> raise (Eval_error "get-primitive: expected (name)"));
+  register "call-primitive" (fun args ->
+    match args with
+    | [String name; (List a | ListRef { contents = a })] ->
+      (match Hashtbl.find_opt primitives name with
+       | Some fn -> fn a
+       | None -> raise (Eval_error ("VM undefined: " ^ name)))
+    | [String name; Nil] ->
+      (match Hashtbl.find_opt primitives name with
+       | Some fn -> fn []
+       | None -> raise (Eval_error ("VM undefined: " ^ name)))
+    | _ -> raise (Eval_error "call-primitive: expected (name args-list)"));
+  ()

hosts/ocaml/lib/sx_render.ml

@@ -0,0 +1,457 @@
+(** 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 "raw!" ->
+    (* Inject pre-rendered HTML without escaping *)
+    let v = Sx_ref.eval_expr (List.hd args) (Env env) in
+    (match v with
+     | String s | RawHTML s -> s
+     | _ -> value_to_string v)
+  | 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 c when c.c_affinity = "client" -> ""  (* skip client-only *)
+       | Component _ -> render_component v args env
+       | Island _i ->
+         (* Islands: SSR via the SX render-to-html from adapter-html.sx.
+            It handles deref/signal/computed through the CEK correctly,
+            and renders island bodies with hydration markers. *)
+         (try
+           let call_expr = List (Symbol name :: args) in
+           let quoted = List [Symbol "quote"; call_expr] in
+           let render_call = List [Symbol "render-to-html"; quoted; Env env] in
+           let result = Sx_ref.eval_expr render_call (Env env) in
+           (match result with
+            | String s | RawHTML s -> s
+            | _ -> value_to_string result)
+         with e ->
+           Printf.eprintf "[ssr-island] ~%s FAILED: %s\n%s\n%!" _i.i_name (Printexc.to_string e) (Printexc.get_backtrace ());
+           "")
+       | 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,419 @@
+(** 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
+  | VmClosure cl -> !Sx_types._vm_call_closure_ref cl 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;
+    Thunk (l.l_body, local)
+  | Continuation (k, _) ->
+    k (match args with x :: _ -> x | [] -> Nil)
+  | _ -> raise (Eval_error ("Not callable: " ^ inspect f))
+
+(* Initialize forward ref so primitives can call SX functions *)
+let () = Sx_primitives._sx_call_fn := sx_call
+(* Trampoline ref is set by sx_ref.ml after it's loaded *)
+
+(** 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
+  | CekState s, String k ->
+    (match k with
+     | "control" -> s.cs_control | "env" -> s.cs_env
+     | "kont" -> s.cs_kont | "phase" -> String s.cs_phase
+     | "value" -> s.cs_value | _ -> Nil)
+  | CekFrame f, String k ->
+    (match k with
+     | "type" -> String f.cf_type | "env" -> f.cf_env
+     | "name" -> f.cf_name | "body" -> f.cf_body
+     | "remaining" -> f.cf_remaining | "f" -> f.cf_f
+     | "args" -> f.cf_args | "evaled" -> f.cf_args
+     | "results" -> f.cf_results | "raw-args" -> f.cf_results
+     | "then" -> f.cf_body | "else" -> f.cf_name
+     | "ho-type" -> f.cf_extra | "scheme" -> f.cf_extra
+     | "indexed" -> f.cf_extra | "value" -> f.cf_extra
+     | "phase" -> f.cf_extra | "has-effects" -> f.cf_extra
+     | "match-val" -> f.cf_extra | "current-item" -> f.cf_extra
+     | "update-fn" -> f.cf_extra | "head-name" -> f.cf_extra
+     | "emitted" -> f.cf_extra2 | "effect-list" -> f.cf_extra2
+     | "first-render" -> f.cf_extra2
+     | _ -> Nil)
+  | 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)
+  | Nil, _ -> Nil  (* nil.anything → nil *)
+  | _, _ -> Nil    (* type mismatch → nil (matches JS/Python behavior) *)
+
+(** 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
+  | Dict d ->
+    (* Dict used as env — wrap it. Needed by adapter-html.sx which
+       passes dicts as env args (e.g. empty {} as caller env). *)
+    let e = Sx_types.make_env () in
+    Hashtbl.iter (fun k v -> ignore (Sx_types.env_bind e k v)) d;
+    e
+  | Nil ->
+    Sx_types.make_env ()
+  | v -> raise (Eval_error ("Expected env, got " ^ Sx_types.type_of v))
+
+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 — all delegated to primitives registered in sx_server.ml *)
+let scope_push name value = prim_call "scope-push!" [name; value]
+let scope_pop name = prim_call "scope-pop!" [name]
+let scope_peek name = prim_call "scope-peek" [name]
+let scope_emit name value = prim_call "scope-emit!" [name; value]
+let provide_push name value = prim_call "scope-push!" [name; value]
+let provide_pop name = prim_call "scope-pop!" [name]
+
+(* Custom special forms registry — mutable dict *)
+let custom_special_forms = Dict (Hashtbl.create 4)
+
+(* register-special-form! — add a handler to the custom registry *)
+let register_special_form name handler =
+  (match custom_special_forms with
+   | Dict tbl -> Hashtbl.replace tbl (value_to_str name) handler; handler
+   | _ -> raise (Eval_error "custom_special_forms not a dict"))
+
+(* Render check/fn hooks — nil by default, set by platform if needed *)
+let render_check = Nil
+let render_fn = Nil
+
+(* is-else-clause? — check if a cond/case test is an else marker *)
+let is_else_clause v =
+  match v with
+  | Keyword k -> Bool (k = "else" || k = "default")
+  | Symbol s -> Bool (s = "else" || s = "default")
+  | Bool true -> Bool true
+  | _ -> Bool false
+
+(* Signal accessors *)
+let signal_value s = match s with
+  | Signal sig' -> sig'.s_value
+  | Dict d -> (match Hashtbl.find_opt d "value" with Some v -> v | None -> Nil)
+  | _ -> 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 both bare OCaml fns and NativeFn values
+   from transpiled code (NativeFn wrapping for value-storable lambdas). *)
+let with_island_scope _register_fn body_fn =
+  match body_fn with
+  | NativeFn (_, f) -> f []
+  | _ -> Nil
+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
+
+(* debug_log — no-op in production, used by CEK evaluator for component warnings *)
+let debug_log _ _ = Nil
+

hosts/ocaml/lib/sx_scope.ml

@@ -0,0 +1,154 @@
+(** Scope stacks — dynamic scope for render-time effects.
+
+    Provides scope-push!/pop!/peek, collect!/collected/clear-collected!,
+    scope-emit!/emitted/scope-emitted, context, and cookie access.
+
+    All functions are registered as primitives so both the CEK evaluator
+    and the JIT VM can find them in the same place. *)
+
+open Sx_types
+
+(** The shared scope stacks hashtable. Each key maps to a stack of values.
+    Used by aser for spread/provide/emit patterns, CSSX collect/flush, etc. *)
+let scope_stacks : (string, value list) Hashtbl.t = Hashtbl.create 8
+
+(** Request cookies — set by the Python bridge before each render.
+    get-cookie reads from here; set-cookie is a no-op on the server. *)
+let request_cookies : (string, string) Hashtbl.t = Hashtbl.create 8
+
+(** Clear all scope stacks. Called between requests if needed. *)
+let clear_all () = Hashtbl.clear scope_stacks
+
+let () =
+  let register = Sx_primitives.register in
+
+  (* --- Cookies --- *)
+
+  register "get-cookie" (fun args ->
+    match args with
+    | [String name] ->
+      (match Hashtbl.find_opt request_cookies name with
+       | Some v -> String v
+       | None -> Nil)
+    | _ -> Nil);
+
+  register "set-cookie" (fun _args -> Nil);
+
+  (* --- Core scope stack operations --- *)
+
+  register "scope-push!" (fun args ->
+    match args with
+    | [String name; value] ->
+      let stack = try Hashtbl.find scope_stacks name with Not_found -> [] in
+      Hashtbl.replace scope_stacks name (value :: stack); Nil
+    | _ -> Nil);
+
+  register "scope-pop!" (fun args ->
+    match args with
+    | [String name] ->
+      let stack = try Hashtbl.find scope_stacks name with Not_found -> [] in
+      (match stack with _ :: rest -> Hashtbl.replace scope_stacks name rest | [] -> ()); Nil
+    | _ -> Nil);
+
+  register "scope-peek" (fun args ->
+    match args with
+    | [String name] ->
+      let stack = try Hashtbl.find scope_stacks name with Not_found -> [] in
+      (match stack with v :: _ -> v | [] -> Nil)
+    | _ -> Nil);
+
+  (* --- Context (scope lookup with optional default) --- *)
+
+  register "context" (fun args ->
+    match args with
+    | [String name] | [String name; _] ->
+      let stack = try Hashtbl.find scope_stacks name with Not_found -> [] in
+      (match stack, args with
+       | v :: _, _ -> v
+       | [], [_; default_val] -> default_val
+       | [], _ -> Nil)
+    | _ -> Nil);
+
+  (* --- Collect / collected / clear-collected! --- *)
+
+  register "collect!" (fun args ->
+    match args with
+    | [String name; value] ->
+      let stack = try Hashtbl.find scope_stacks name with Not_found -> [] in
+      (match stack with
+       | List items :: rest ->
+         if not (List.mem value items) then
+           Hashtbl.replace scope_stacks name (List (items @ [value]) :: rest)
+       | [] ->
+         Hashtbl.replace scope_stacks name [List [value]]
+       | _ :: _ -> ());
+      Nil
+    | _ -> Nil);
+
+  register "collected" (fun args ->
+    match args with
+    | [String name] ->
+      let stack = try Hashtbl.find scope_stacks name with Not_found -> [] in
+      (match stack with List items :: _ -> List items | _ -> List [])
+    | _ -> List []);
+
+  register "clear-collected!" (fun args ->
+    match args with
+    | [String name] ->
+      let stack = try Hashtbl.find scope_stacks name with Not_found -> [] in
+      (match stack with
+       | _ :: rest -> Hashtbl.replace scope_stacks name (List [] :: rest)
+       | [] -> Hashtbl.replace scope_stacks name [List []]);
+      Nil
+    | _ -> Nil);
+
+  (* --- Emit / emitted (for spread attrs in adapter-html.sx) --- *)
+
+  register "scope-emit!" (fun args ->
+    match args with
+    | [String name; value] ->
+      let stack = try Hashtbl.find scope_stacks name with Not_found -> [] in
+      (match stack with
+       | List items :: rest ->
+         Hashtbl.replace scope_stacks name (List (items @ [value]) :: rest)
+       | Nil :: rest ->
+         Hashtbl.replace scope_stacks name (List [value] :: rest)
+       | [] ->
+         Hashtbl.replace scope_stacks name [List [value]]
+       | _ :: _ -> ());
+      Nil
+    | _ -> Nil);
+
+  register "emit!" (fun args ->
+    (* Alias for scope-emit! *)
+    match Sx_primitives.get_primitive "scope-emit!" with
+    | NativeFn (_, fn) -> fn args | _ -> Nil);
+
+  register "emitted" (fun args ->
+    match args with
+    | [String name] ->
+      let stack = try Hashtbl.find scope_stacks name with Not_found -> [] in
+      (match stack with List items :: _ -> List items | _ -> List [])
+    | _ -> List []);
+
+  register "scope-emitted" (fun args ->
+    match Sx_primitives.get_primitive "emitted" with
+    | NativeFn (_, fn) -> fn args | _ -> List []);
+
+  register "scope-collected" (fun args ->
+    match Sx_primitives.get_primitive "collected" with
+    | NativeFn (_, fn) -> fn args | _ -> List []);
+
+  register "scope-clear-collected!" (fun args ->
+    match Sx_primitives.get_primitive "clear-collected!" with
+    | NativeFn (_, fn) -> fn args | _ -> Nil);
+
+  (* --- Provide aliases --- *)
+
+  register "provide-push!" (fun args ->
+    match Sx_primitives.get_primitive "scope-push!" with
+    | NativeFn (_, fn) -> fn args | _ -> Nil);
+
+  register "provide-pop!" (fun args ->
+    match Sx_primitives.get_primitive "scope-pop!" with
+    | NativeFn (_, fn) -> fn args | _ -> Nil)

hosts/ocaml/lib/sx_types.ml

@@ -0,0 +1,484 @@
+(** 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! *)
+  | CekState of cek_state  (** Optimized CEK machine state — avoids Dict allocation. *)
+  | CekFrame of cek_frame  (** Optimized CEK continuation frame. *)
+  | VmClosure of vm_closure  (** VM-compiled closure — callable within the VM without allocating a new VM. *)
+
+(** CEK machine state — record instead of Dict for performance.
+    5 fields × 55K steps/sec = 275K Hashtbl allocations/sec eliminated. *)
+and cek_state = {
+  cs_control : value;
+  cs_env     : value;
+  cs_kont    : value;
+  cs_phase   : string;
+  cs_value   : value;
+}
+
+(** CEK continuation frame — tagged record covering all 29 frame types.
+    Fields are named generically; not all are used by every frame type.
+    Eliminates ~100K Hashtbl allocations per page render. *)
+and cek_frame = {
+  cf_type      : string;        (* frame type tag: "if", "let", "call", etc. *)
+  cf_env       : value;         (* environment — every frame has this *)
+  cf_name      : value;         (* let/define/set/scope: binding name *)
+  cf_body      : value;         (* when/let: body expr *)
+  cf_remaining : value;         (* begin/cond/map/etc: remaining exprs *)
+  cf_f         : value;         (* call/map/filter/etc: function *)
+  cf_args      : value;         (* call: raw args; arg: evaled args *)
+  cf_results   : value;         (* map/filter/dict: accumulated results *)
+  cf_extra     : value;         (* extra field: scheme, indexed, value, phase, etc. *)
+  cf_extra2    : value;         (* second extra: emitted, etc. *)
+}
+
+(** 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;
+  mutable l_compiled : vm_closure option;  (** Lazy JIT cache *)
+}
+
+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" *)
+  mutable c_compiled : vm_closure option;  (** Lazy JIT cache *)
+}
+
+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 Bytecode VM types}
+
+    Defined here (not in sx_vm.ml) because [vm_code.constants] references
+    [value] and [lambda.l_compiled] references [vm_closure] — mutual
+    recursion requires all types in one [and] chain. *)
+
+(** Compiled function body — bytecode + constant pool. *)
+and vm_code = {
+  vc_arity     : int;
+  vc_locals    : int;
+  vc_bytecode  : int array;
+  vc_constants : value array;
+}
+
+(** Upvalue cell — shared mutable reference to a captured variable. *)
+and vm_upvalue_cell = {
+  mutable uv_value : value;
+}
+
+(** Closure — compiled code + captured upvalues + live env reference. *)
+and vm_closure = {
+  vm_code     : vm_code;
+  vm_upvalues : vm_upvalue_cell array;
+  vm_name     : string option;
+  vm_env_ref  : (string, value) Hashtbl.t;
+  vm_closure_env : env option;  (** Original closure env for inner functions *)
+}
+
+
+(** {1 Forward ref for calling VM closures from outside the VM} *)
+
+let _vm_call_closure_ref : (vm_closure -> value list -> value) ref =
+  ref (fun _ _ -> raise (Failure "VM call_closure not initialized"))
+
+
+(** {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; l_compiled = 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;
+    c_compiled = None;
+  }
+
+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"
+  | CekState _     -> "dict"  (* CEK state behaves as a dict for type checks *)
+  | CekFrame _     -> "dict"
+  | VmClosure _    -> "function"
+
+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
+  | Dict d -> Hashtbl.mem d "__signal"
+  | _ -> false
+
+let is_callable = function
+  | Lambda _ | NativeFn _ | Continuation (_, _) | VmClosure _ -> 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
+  | Island i -> String i.i_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)
+  | Island i -> List (List.map (fun s -> String s) i.i_params)
+  | v -> raise (Eval_error ("Expected component, got " ^ type_of v))
+
+let component_body = function
+  | Component c -> c.c_body
+  | Island i -> i.i_body
+  | v -> raise (Eval_error ("Expected component, got " ^ type_of v))
+
+let component_closure = function
+  | Component c -> Env c.c_closure
+  | Island i -> Env i.i_closure
+  | v -> raise (Eval_error ("Expected component, got " ^ type_of v))
+
+let component_has_children = function
+  | Component c -> Bool c.c_has_children
+  | Island i -> Bool i.i_has_children
+  | v -> raise (Eval_error ("Expected component, got " ^ type_of v))
+
+let component_affinity = function
+  | Component c -> String c.c_affinity
+  | Island _ -> String "client"
+  | _ -> 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 ->
+    let buf = Buffer.create (String.length s + 2) in
+    Buffer.add_char buf '"';
+    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.add_char buf '"';
+    Buffer.contents buf
+  | 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>"
+  | CekState _ -> "<cek-state>"
+  | CekFrame f -> Printf.sprintf "<frame:%s>" f.cf_type
+  | VmClosure cl -> Printf.sprintf "<vm:%s>" (match cl.vm_name with Some n -> n | None -> "anon")

hosts/ocaml/lib/sx_vm.ml

@@ -0,0 +1,584 @@
+(** SX bytecode VM — stack-based interpreter.
+
+    Executes bytecode produced by compiler.sx.
+    Designed for speed: array-based stack, direct dispatch,
+    no allocation per step (unlike the CEK machine).
+
+    This is the platform-native execution engine. The same bytecode
+    runs on all platforms (OCaml, JS, WASM).
+
+    VM types (vm_code, vm_upvalue_cell, vm_closure) are defined in
+    sx_types.ml to share the mutual recursion block with [value]. *)
+
+open Sx_types
+
+(** Call frame — one per function invocation. *)
+type frame = {
+  closure   : vm_closure;
+  mutable ip : int;
+  base      : int;  (* base index in value stack for locals *)
+  local_cells : (int, vm_upvalue_cell) Hashtbl.t;  (* slot → shared cell for captured locals *)
+}
+
+(** VM state. *)
+type vm = {
+  mutable stack  : value array;
+  mutable sp     : int;
+  mutable frames : frame list;
+  globals        : (string, value) Hashtbl.t;  (* live reference to kernel env *)
+}
+
+(** Forward reference for JIT compilation — set after definition. *)
+let jit_compile_ref : (lambda -> (string, value) Hashtbl.t -> vm_closure option) ref =
+  ref (fun _ _ -> None)
+
+(** Sentinel closure indicating JIT compilation was attempted and failed.
+    Prevents retrying compilation on every call. *)
+let jit_failed_sentinel = {
+  vm_code = { vc_arity = -1; vc_locals = 0; vc_bytecode = [||]; vc_constants = [||] };
+  vm_upvalues = [||]; vm_name = Some "__jit_failed__"; vm_env_ref = Hashtbl.create 0; vm_closure_env = None
+}
+
+let is_jit_failed cl = cl.vm_code.vc_arity = -1
+
+let create globals =
+  { stack = Array.make 4096 Nil; sp = 0; frames = []; globals }
+
+(** Stack ops — inlined for speed. *)
+let push vm v =
+  if vm.sp >= Array.length vm.stack then begin
+    let ns = Array.make (vm.sp * 2) Nil in
+    Array.blit vm.stack 0 ns 0 vm.sp;
+    vm.stack <- ns
+  end;
+  vm.stack.(vm.sp) <- v;
+  vm.sp <- vm.sp + 1
+
+let[@inline] pop vm =
+  vm.sp <- vm.sp - 1;
+  vm.stack.(vm.sp)
+
+let[@inline] peek vm = vm.stack.(vm.sp - 1)
+
+(** Read operands. *)
+let[@inline] read_u8 f =
+  let v = f.closure.vm_code.vc_bytecode.(f.ip) in
+  f.ip <- f.ip + 1; v
+
+let[@inline] read_u16 f =
+  let lo = f.closure.vm_code.vc_bytecode.(f.ip) in
+  let hi = f.closure.vm_code.vc_bytecode.(f.ip + 1) in
+  f.ip <- f.ip + 2;
+  lo lor (hi lsl 8)
+
+let[@inline] read_i16 f =
+  let v = read_u16 f in
+  if v >= 32768 then v - 65536 else v
+
+(** Wrap a VM closure as an SX value (NativeFn). *)
+let closure_to_value cl =
+  NativeFn ("vm:" ^ (match cl.vm_name with Some n -> n | None -> "anon"),
+    fun args -> raise (Eval_error ("VM_CLOSURE_CALL:" ^ String.concat "," (List.map Sx_runtime.value_to_str args))))
+  (* Placeholder — actual calls go through vm_call below *)
+
+let _vm_insn_count = ref 0
+let _vm_call_count = ref 0
+let _vm_cek_count = ref 0
+let vm_reset_counters () = _vm_insn_count := 0; _vm_call_count := 0; _vm_cek_count := 0
+let vm_report_counters () =
+  Printf.eprintf "[vm-perf] insns=%d calls=%d cek_fallbacks=%d\n%!"
+    !_vm_insn_count !_vm_call_count !_vm_cek_count
+
+(** Push a VM closure frame onto the current VM — no new VM allocation.
+    This is the fast path for intra-VM closure calls. *)
+let push_closure_frame vm cl args =
+  let frame = { closure = cl; ip = 0; base = vm.sp; local_cells = Hashtbl.create 4 } in
+  List.iter (fun a -> push vm a) args;
+  for _ = List.length args to cl.vm_code.vc_locals - 1 do push vm Nil done;
+  vm.frames <- frame :: vm.frames
+
+(** Convert compiler output (SX dict) to a vm_code object. *)
+let code_from_value v =
+  match v with
+  | Dict d ->
+    let bc_list = match Hashtbl.find_opt d "bytecode" with
+      | Some (List l | ListRef { contents = l }) ->
+        Array.of_list (List.map (fun x -> match x with Number n -> int_of_float n | _ -> 0) l)
+      | _ -> [||]
+    in
+    let entries = match Hashtbl.find_opt d "constants" with
+      | Some (List l | ListRef { contents = l }) -> Array.of_list l
+      | _ -> [||]
+    in
+    let constants = Array.map (fun entry ->
+      match entry with
+      | Dict ed when Hashtbl.mem ed "bytecode" -> entry  (* nested code — convert lazily *)
+      | _ -> entry
+    ) entries in
+    let arity = match Hashtbl.find_opt d "arity" with
+      | Some (Number n) -> int_of_float n | _ -> 0
+    in
+    { vc_arity = arity; vc_locals = arity + 16; vc_bytecode = bc_list; vc_constants = constants }
+  | _ -> { vc_arity = 0; vc_locals = 16; vc_bytecode = [||]; vc_constants = [||] }
+
+(** Execute a closure with arguments — creates a fresh VM.
+    Used for entry points: JIT Lambda calls, module execution, cross-boundary. *)
+let rec call_closure cl args globals =
+  incr _vm_call_count;
+  let vm = create globals in
+  push_closure_frame vm cl args;
+  (try run vm with e -> raise e);
+  pop vm
+
+(** Call a value as a function — dispatch by type.
+    VmClosure: pushes frame on current VM (fast intra-VM path).
+    Lambda: tries JIT then falls back to CEK.
+    NativeFn: calls directly. *)
+and vm_call vm f args =
+  match f with
+  | VmClosure cl ->
+    (* Fast path: push frame on current VM — no allocation, enables TCO *)
+    push_closure_frame vm cl args
+  | NativeFn (_name, fn) ->
+    let result = fn args in
+    push vm result
+  | Lambda l ->
+    (match l.l_compiled with
+     | Some cl when not (is_jit_failed cl) ->
+       (* Cached bytecode — run on VM, fall back to CEK on runtime error *)
+       (try push vm (call_closure cl args vm.globals)
+        with _ -> push vm (Sx_ref.cek_call f (List args)))
+     | Some _ ->
+       (* Compile failed — CEK *)
+       push vm (Sx_ref.cek_call f (List args))
+     | None ->
+       if l.l_name <> None
+       then begin
+         (* Pre-mark before compile attempt to prevent re-entrancy *)
+         l.l_compiled <- Some jit_failed_sentinel;
+         match !jit_compile_ref l vm.globals with
+         | Some cl ->
+           l.l_compiled <- Some cl;
+           (try push vm (call_closure cl args vm.globals)
+            with _ ->
+              l.l_compiled <- Some jit_failed_sentinel;
+              push vm (Sx_ref.cek_call f (List args)))
+         | None ->
+           push vm (Sx_ref.cek_call f (List args))
+       end
+       else
+         push vm (Sx_ref.cek_call f (List args)))
+  | Component _ | Island _ ->
+    (* Components use keyword-arg parsing — CEK handles this *)
+    incr _vm_cek_count;
+    let result = Sx_ref.cek_call f (List args) in
+    push vm result
+  | _ ->
+    raise (Eval_error ("VM: not callable: " ^ Sx_runtime.value_to_str f))
+
+(** Main execution loop — iterative (no OCaml stack growth).
+    VmClosure calls push frames; the loop picks them up.
+    OP_TAIL_CALL + VmClosure = true TCO: drop frame, push new, loop. *)
+and run vm =
+  while vm.frames <> [] do
+    match vm.frames with
+    | [] -> ()  (* guard handled by while condition *)
+    | frame :: rest_frames ->
+      let bc = frame.closure.vm_code.vc_bytecode in
+      let consts = frame.closure.vm_code.vc_constants in
+      if frame.ip >= Array.length bc then
+        vm.frames <- []  (* bytecode exhausted — stop *)
+      else begin
+        let saved_ip = frame.ip in
+        let op = bc.(frame.ip) in
+        frame.ip <- frame.ip + 1;
+        (try match op with
+        (* ---- Constants ---- *)
+        | 1 (* OP_CONST *) ->
+          let idx = read_u16 frame in
+          if idx >= Array.length consts then
+            raise (Eval_error (Printf.sprintf "VM: CONST index %d out of bounds (pool size %d)"
+              idx (Array.length consts)));
+          push vm consts.(idx)
+        | 2 (* OP_NIL *)   -> push vm Nil
+        | 3 (* OP_TRUE *)  -> push vm (Bool true)
+        | 4 (* OP_FALSE *) -> push vm (Bool false)
+        | 5 (* OP_POP *)   -> ignore (pop vm)
+        | 6 (* OP_DUP *)   -> push vm (peek vm)
+
+        (* ---- Variable access ---- *)
+        | 16 (* OP_LOCAL_GET *) ->
+          let slot = read_u8 frame in
+          let v = match Hashtbl.find_opt frame.local_cells slot with
+            | Some cell -> cell.uv_value
+            | None ->
+              let idx = frame.base + slot in
+              if idx >= vm.sp then
+                raise (Eval_error (Printf.sprintf
+                  "VM: LOCAL_GET slot=%d base=%d sp=%d out of bounds" slot frame.base vm.sp));
+              vm.stack.(idx)
+          in
+          push vm v
+        | 17 (* OP_LOCAL_SET *) ->
+          let slot = read_u8 frame in
+          let v = peek vm in
+          (* Write to shared cell if captured, else to stack *)
+          (match Hashtbl.find_opt frame.local_cells slot with
+           | Some cell -> cell.uv_value <- v
+           | None -> vm.stack.(frame.base + slot) <- v)
+        | 18 (* OP_UPVALUE_GET *) ->
+          let idx = read_u8 frame in
+          if idx >= Array.length frame.closure.vm_upvalues then
+            raise (Eval_error (Printf.sprintf
+              "VM: UPVALUE_GET idx=%d out of bounds (have %d)" idx
+              (Array.length frame.closure.vm_upvalues)));
+          push vm frame.closure.vm_upvalues.(idx).uv_value
+        | 19 (* OP_UPVALUE_SET *) ->
+          let idx = read_u8 frame in
+          frame.closure.vm_upvalues.(idx).uv_value <- peek vm
+        | 20 (* OP_GLOBAL_GET *) ->
+          let idx = read_u16 frame in
+          let name = match consts.(idx) with String s -> s | _ -> "" in
+          let v = try Hashtbl.find vm.globals name with Not_found ->
+            (* Walk the closure env chain for inner functions *)
+            let rec env_lookup e =
+              try Hashtbl.find e.bindings name
+              with Not_found ->
+                match e.parent with Some p -> env_lookup p | None ->
+                  try Sx_primitives.get_primitive name
+                  with _ -> raise (Eval_error ("VM undefined: " ^ name))
+            in
+            match frame.closure.vm_closure_env with
+            | Some env -> env_lookup env
+            | None ->
+              try Sx_primitives.get_primitive name
+              with _ -> raise (Eval_error ("VM undefined: " ^ name))
+          in
+          push vm v
+        | 21 (* OP_GLOBAL_SET *) ->
+          let idx = read_u16 frame in
+          let name = match consts.(idx) with String s -> s | _ -> "" in
+          (* Write to closure env if the name exists there (mutable closure vars) *)
+          let written = match frame.closure.vm_closure_env with
+            | Some env ->
+              let rec find_env e =
+                if Hashtbl.mem e.bindings name then
+                  (Hashtbl.replace e.bindings name (peek vm); true)
+                else match e.parent with Some p -> find_env p | None -> false
+              in find_env env
+            | None -> false
+          in
+          if not written then Hashtbl.replace vm.globals name (peek vm)
+
+        (* ---- Control flow ---- *)
+        | 32 (* OP_JUMP *) ->
+          let offset = read_i16 frame in
+          frame.ip <- frame.ip + offset
+        | 33 (* OP_JUMP_IF_FALSE *) ->
+          let offset = read_i16 frame in
+          let v = pop vm in
+          if not (sx_truthy v) then frame.ip <- frame.ip + offset
+        | 34 (* OP_JUMP_IF_TRUE *) ->
+          let offset = read_i16 frame in
+          let v = pop vm in
+          if sx_truthy v then frame.ip <- frame.ip + offset
+
+        (* ---- Function calls ---- *)
+        | 48 (* OP_CALL *) ->
+          let argc = read_u8 frame in
+          let args = Array.init argc (fun _ -> pop vm) in
+          let f = pop vm in
+          let args_list = List.rev (Array.to_list args) in
+          vm_call vm f args_list
+          (* Loop continues — if VmClosure, new frame runs next iteration *)
+        | 49 (* OP_TAIL_CALL *) ->
+          let argc = read_u8 frame in
+          let args = Array.init argc (fun _ -> pop vm) in
+          let f = pop vm in
+          let args_list = List.rev (Array.to_list args) in
+          (* Drop current frame, reuse stack space — true TCO for VmClosure *)
+          vm.frames <- rest_frames;
+          vm.sp <- frame.base;
+          vm_call vm f args_list
+        | 50 (* OP_RETURN *) ->
+          let result = pop vm in
+          vm.frames <- rest_frames;
+          vm.sp <- frame.base;
+          push vm result
+          (* Loop continues with caller frame *)
+        | 51 (* OP_CLOSURE *) ->
+          let idx = read_u16 frame in
+          if idx >= Array.length consts then
+            raise (Eval_error (Printf.sprintf "VM: CLOSURE idx %d >= consts %d" idx (Array.length consts)));
+          let code_val = consts.(idx) in
+          let code = code_from_value code_val in
+          (* Read upvalue descriptors from bytecode *)
+          let uv_count = match code_val with
+            | Dict d -> (match Hashtbl.find_opt d "upvalue-count" with
+                | Some (Number n) -> int_of_float n | _ -> 0)
+            | _ -> 0
+          in
+          let upvalues = Array.init uv_count (fun _ ->
+            let is_local = read_u8 frame in
+            let index = read_u8 frame in
+            if is_local = 1 then begin
+              (* Capture from enclosing frame's local slot.
+                 Create a shared cell — both parent and closure
+                 read/write through this cell. *)
+              let cell = match Hashtbl.find_opt frame.local_cells index with
+                | Some existing -> existing  (* reuse existing cell *)
+                | None ->
+                  let c = { uv_value = vm.stack.(frame.base + index) } in
+                  Hashtbl.replace frame.local_cells index c;
+                  c
+              in
+              cell
+            end else
+              (* Capture from enclosing frame's upvalue — already a shared cell *)
+              frame.closure.vm_upvalues.(index)
+          ) in
+          let cl = { vm_code = code; vm_upvalues = upvalues; vm_name = None;
+                     vm_env_ref = vm.globals; vm_closure_env = None } in
+          push vm (VmClosure cl)
+        | 52 (* OP_CALL_PRIM *) ->
+          let idx = read_u16 frame in
+          let argc = read_u8 frame in
+          let name = match consts.(idx) with String s -> s | _ -> "" in
+          let args = List.init argc (fun _ -> pop vm) |> List.rev in
+          (* Resolve thunks — the CEK evaluator does this automatically
+             via trampoline, but the VM must do it explicitly before
+             passing args to primitives. *)
+          let args = List.map (fun v ->
+            match v with
+            | Thunk _ -> !Sx_primitives._sx_trampoline_fn v
+            | _ -> v) args in
+          let result =
+            try
+              (* Check primitives FIRST (native implementations of map/filter/etc.),
+                 then globals (which may have ho_via_cek wrappers that route
+                 through the CEK — these can't call VM closures). *)
+              let fn_val = try Sx_primitives.get_primitive name with _ ->
+                try Hashtbl.find vm.globals name with Not_found ->
+                  raise (Eval_error ("VM: unknown primitive " ^ name))
+              in
+              (match fn_val with
+               | NativeFn (_, fn) -> fn args
+               | _ -> Nil)
+            with Eval_error msg ->
+              raise (Eval_error (Printf.sprintf "%s (in CALL_PRIM \"%s\" with %d args)"
+                msg name argc))
+          in
+          push vm result
+
+        (* ---- Collections ---- *)
+        | 64 (* OP_LIST *) ->
+          let count = read_u16 frame in
+          let items = List.init count (fun _ -> pop vm) |> List.rev in
+          push vm (List items)
+        | 65 (* OP_DICT *) ->
+          let count = read_u16 frame in
+          let d = Hashtbl.create count in
+          for _ = 1 to count do
+            let v = pop vm in
+            let k = pop vm in
+            let key = match k with String s -> s | Keyword s -> s | _ -> Sx_runtime.value_to_str k in
+            Hashtbl.replace d key v
+          done;
+          push vm (Dict d)
+
+        (* ---- String ops ---- *)
+        | 144 (* OP_STR_CONCAT *) ->
+          let count = read_u8 frame in
+          let parts = List.init count (fun _ -> pop vm) |> List.rev in
+          let s = String.concat "" (List.map Sx_runtime.value_to_str parts) in
+          push vm (String s)
+
+        (* ---- Define ---- *)
+        | 128 (* OP_DEFINE *) ->
+          let idx = read_u16 frame in
+          let name = match consts.(idx) with String s -> s | _ -> "" in
+          let v = peek vm in
+          Hashtbl.replace vm.globals name v
+
+        (* ---- Inline primitives (no hashtable lookup) ---- *)
+        | 160 (* OP_ADD *) ->
+          let b = pop vm and a = pop vm in
+          push vm (match a, b with
+            | Number x, Number y -> Number (x +. y)
+            | String x, String y -> String (x ^ y)
+            | _ -> Sx_primitives.(get_primitive "+" |> function NativeFn (_, f) -> f [a; b] | _ -> Nil))
+        | 161 (* OP_SUB *) ->
+          let b = pop vm and a = pop vm in
+          push vm (match a, b with Number x, Number y -> Number (x -. y) | _ -> Nil)
+        | 162 (* OP_MUL *) ->
+          let b = pop vm and a = pop vm in
+          push vm (match a, b with Number x, Number y -> Number (x *. y) | _ -> Nil)
+        | 163 (* OP_DIV *) ->
+          let b = pop vm and a = pop vm in
+          push vm (match a, b with Number x, Number y -> Number (x /. y) | _ -> Nil)
+        | 164 (* OP_EQ *) ->
+          let b = pop vm and a = pop vm in
+          (* Must normalize ListRef→List before structural compare,
+             same as the "=" primitive in sx_primitives.ml *)
+          let rec norm = function
+            | ListRef { contents = l } -> List (List.map norm l)
+            | List l -> List (List.map norm l) | v -> v in
+          push vm (Bool (norm a = norm b))
+        | 165 (* OP_LT *) ->
+          let b = pop vm and a = pop vm in
+          push vm (match a, b with Number x, Number y -> Bool (x < y) | String x, String y -> Bool (x < y) | _ -> Bool false)
+        | 166 (* OP_GT *) ->
+          let b = pop vm and a = pop vm in
+          push vm (match a, b with Number x, Number y -> Bool (x > y) | String x, String y -> Bool (x > y) | _ -> Bool false)
+        | 167 (* OP_NOT *) ->
+          let v = pop vm in
+          push vm (Bool (not (sx_truthy v)))
+        | 168 (* OP_LEN *) ->
+          let v = pop vm in
+          push vm (match v 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 | _ -> Number 0.0)
+        | 169 (* OP_FIRST *) ->
+          let v = pop vm in
+          push vm (match v with List (x :: _) | ListRef { contents = x :: _ } -> x | _ -> Nil)
+        | 170 (* OP_REST *) ->
+          let v = pop vm in
+          push vm (match v with List (_ :: xs) | ListRef { contents = _ :: xs } -> List xs | _ -> List [])
+        | 171 (* OP_NTH *) ->
+          let n = pop vm and coll = pop vm in
+          let i = match n with Number f -> int_of_float f | _ -> 0 in
+          push vm (match coll with
+            | List l | ListRef { contents = l } ->
+              (try List.nth l i with _ -> Nil)
+            | _ -> Nil)
+        | 172 (* OP_CONS *) ->
+          let coll = pop vm and x = pop vm in
+          push vm (match coll with
+            | List l -> List (x :: l)
+            | ListRef { contents = l } -> List (x :: l)
+            | Nil -> List [x]
+            | _ -> List [x])
+        | 173 (* OP_NEG *) ->
+          let v = pop vm in
+          push vm (match v with Number x -> Number (-.x) | _ -> Nil)
+        | 174 (* OP_INC *) ->
+          let v = pop vm in
+          push vm (match v with Number x -> Number (x +. 1.0) | _ -> Nil)
+        | 175 (* OP_DEC *) ->
+          let v = pop vm in
+          push vm (match v with Number x -> Number (x -. 1.0) | _ -> Nil)
+
+        | opcode ->
+          raise (Eval_error (Printf.sprintf "VM: unknown opcode %d at ip=%d"
+                               opcode (frame.ip - 1)))
+        with Invalid_argument msg ->
+          let fn_name = match frame.closure.vm_name with Some n -> n | None -> "?" in
+          raise (Eval_error (Printf.sprintf
+            "VM: %s at ip=%d op=%d in %s (base=%d sp=%d bc_len=%d consts=%d)"
+            msg saved_ip op fn_name frame.base vm.sp
+            (Array.length bc) (Array.length consts))))
+      end
+  done
+
+(** Execute a compiled module (top-level bytecode). *)
+let execute_module code globals =
+  let cl = { vm_code = code; vm_upvalues = [||]; vm_name = Some "module"; vm_env_ref = globals; vm_closure_env = None } in
+  let vm = create globals in
+  let frame = { closure = cl; ip = 0; base = 0; local_cells = Hashtbl.create 4 } in
+  for _ = 0 to code.vc_locals - 1 do push vm Nil done;
+  vm.frames <- [frame];
+  run vm;
+  pop vm
+
+
+(** {1 Lazy JIT compilation} *)
+
+(** Compile a lambda or component body to bytecode using the SX compiler.
+    Invokes [compile] from spec/compiler.sx via the CEK machine.
+    Returns a [vm_closure] ready for execution, or [None] on failure
+    (safe fallback to CEK interpretation).
+
+    The compilation cost is a single CEK evaluation of the compiler —
+    microseconds per function. The result is cached in the lambda/component
+    record so subsequent calls go straight to the VM. *)
+let jit_compile_lambda (l : lambda) globals =
+  let fn_name = match l.l_name with Some n -> n | None -> "<anon>" in
+  try
+    let compile_fn = try Hashtbl.find globals "compile"
+      with Not_found -> raise (Eval_error "JIT: compiler not loaded") in
+    (* Reconstruct the (fn (params) body) form so the compiler produces
+       a proper closure. l.l_body is the inner body; we need the full
+       function form with params so the compiled code binds them. *)
+    let param_syms = List (List.map (fun s -> Symbol s) l.l_params) in
+    let fn_expr = List [Symbol "fn"; param_syms; l.l_body] in
+    let quoted = List [Symbol "quote"; fn_expr] in
+    let result = Sx_ref.eval_expr (List [compile_fn; quoted]) (Env (make_env ())) in
+    (* If the lambda has closure-captured variables, merge them into globals
+       so the VM can find them via GLOBAL_GET. The compiler doesn't know
+       about the enclosing scope, so closure vars get compiled as globals. *)
+    let effective_globals =
+      let closure = l.l_closure in
+      if Hashtbl.length closure.bindings = 0 && closure.parent = None then
+        globals  (* no closure vars — use globals directly *)
+      else begin
+        (* Merge: closure bindings layered on top of globals.
+           Use a shallow copy so we don't pollute the real globals. *)
+        let merged = Hashtbl.copy globals in
+        let rec inject env =
+          Hashtbl.iter (fun k v -> Hashtbl.replace merged k v) env.bindings;
+          match env.parent with Some p -> inject p | None -> ()
+        in
+        inject closure;
+        let n = Hashtbl.length merged - Hashtbl.length globals in
+        if n > 0 then
+          Printf.eprintf "[jit] %s: injected %d closure bindings\n%!" fn_name n;
+        merged
+      end
+    in
+    (match result with
+    | Dict d when Hashtbl.mem d "bytecode" ->
+      let outer_code = code_from_value result in
+      let bc = outer_code.vc_bytecode in
+      if Array.length bc >= 4 && bc.(0) = 51 (* OP_CLOSURE *) then begin
+        let idx = bc.(1) lor (bc.(2) lsl 8) in
+        if idx < Array.length outer_code.vc_constants then
+          let inner_val = outer_code.vc_constants.(idx) in
+          let code = code_from_value inner_val in
+          Some { vm_code = code; vm_upvalues = [||];
+                 vm_name = l.l_name; vm_env_ref = effective_globals; vm_closure_env = Some l.l_closure }
+        else begin
+          Printf.eprintf "[jit] FAIL %s: closure index %d out of bounds (pool=%d)\n%!"
+            fn_name idx (Array.length outer_code.vc_constants);
+
+          None
+        end
+      end else begin
+        (* Not a closure — constant expression, alias, or simple computation.
+           Execute the bytecode as a module to get the value, then wrap
+           as a NativeFn if it's callable (so the CEK can dispatch to it). *)
+        (try
+          let value = execute_module outer_code globals in
+          Printf.eprintf "[jit] RESOLVED %s: %s (bc[0]=%d)\n%!"
+            fn_name (type_of value) (if Array.length bc > 0 then bc.(0) else -1);
+          (* If the resolved value is a NativeFn, we can't wrap it as a
+             vm_closure — just let the CEK handle it directly. Return None
+             so the lambda falls through to CEK, which will find the
+             resolved value in the env on next lookup. *)
+          None
+        with _ ->
+          Printf.eprintf "[jit] SKIP %s: non-closure execution failed (bc[0]=%d, len=%d)\n%!"
+            fn_name (if Array.length bc > 0 then bc.(0) else -1) (Array.length bc);
+          None)
+      end
+    | _ ->
+      Printf.eprintf "[jit] FAIL %s: compiler returned %s\n%!" fn_name (type_of result);
+      None)
+  with e ->
+    Printf.eprintf "[jit] FAIL %s: %s\n%!" fn_name (Printexc.to_string e);
+    None
+
+(* Wire up forward references *)
+let () = jit_compile_ref := jit_compile_lambda
+let () = _vm_call_closure_ref := (fun cl args -> call_closure cl args cl.vm_env_ref)

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
@@ -179,6 +179,11 @@ class PyEmitter:
             "*batch-depth*": "_batch_depth",
             "*batch-queue*": "_batch_queue",
             "*store-registry*": "_store_registry",
+            "*custom-special-forms*": "_custom_special_forms",
+            "*render-check*": "_render_check",
+            "*render-fn*": "_render_fn",
+            "register-special-form!": "register_special_form_b",
+            "is-else-clause?": "is_else_clause_p",
             "def-store": "def_store",
             "use-store": "use_store",
             "clear-stores": "clear_stores",
@@ -1313,7 +1318,7 @@ try:
         EXTENSION_NAMES, EXTENSION_FORMS,
     )
 except ImportError:
-    from shared.sx.ref.platform_py import (
+    from hosts.python.platform import (
         PREAMBLE, PLATFORM_PY, PRIMITIVES_PY_PRE, PRIMITIVES_PY_POST,
         PRIMITIVES_PY_MODULES, _ALL_PY_MODULES,
         PLATFORM_PARSER_PY,
@@ -1325,9 +1330,17 @@ except ImportError:
     )
 
 
-def _parse_special_forms_spec(ref_dir: str) -> set[str]:
+def _parse_special_forms_spec(ref_dir: str, source_dirs=None) -> set[str]:
     """Parse special-forms.sx to extract declared form names."""
-    filepath = os.path.join(ref_dir, "special-forms.sx")
+    filepath = None
+    if source_dirs:
+        for d in source_dirs:
+            p = os.path.join(d, "special-forms.sx")
+            if os.path.exists(p):
+                filepath = p
+                break
+    if not filepath:
+        filepath = os.path.join(ref_dir, "special-forms.sx")
     if not os.path.exists(filepath):
         return set()
     with open(filepath) as f:
@@ -1359,9 +1372,9 @@ def _extract_eval_dispatch_names(all_sections: list) -> set[str]:
 
 
 def _validate_special_forms(ref_dir: str, all_sections: list,
-                            has_continuations: bool) -> None:
+                            has_continuations: bool, source_dirs=None) -> None:
     """Cross-check special-forms.sx against eval.sx dispatch. Warn on mismatches."""
-    spec_names = _parse_special_forms_spec(ref_dir)
+    spec_names = _parse_special_forms_spec(ref_dir, source_dirs=source_dirs)
     if not spec_names:
         return
 
@@ -1431,7 +1444,22 @@ def compile_ref_to_py(
                     raise ValueError(f"Unknown module: {m!r}. Valid: {', '.join(PRIMITIVES_PY_MODULES)}")
                 prim_modules.append(m)
 
-    ref_dir = os.path.dirname(os.path.abspath(__file__))
+    ref_dir = os.path.join(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..")), "shared", "sx", "ref")
+    _project = os.path.abspath(os.path.join(ref_dir, "..", "..", ".."))
+    _source_dirs = [
+        os.path.join(_project, "spec"),
+        os.path.join(_project, "lib"),
+        os.path.join(_project, "web"),
+        ref_dir,
+    ]
+
+    def _find_sx(filename):
+        for d in _source_dirs:
+            p = os.path.join(d, filename)
+            if os.path.exists(p):
+                return p
+        return None
+
     emitter = PyEmitter()
 
     # Resolve adapter set
@@ -1462,16 +1490,16 @@ 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)"),
+        ("web-forms.sx", "web-forms (defstyle, deftype, defeffect, defrelation)"),
         ("render.sx", "render (core)"),
     ]
     # Parser before html/sx — provides serialize used by adapters
@@ -1494,7 +1522,7 @@ def compile_ref_to_py(
     has_async = "async" in adapter_set
     if has_async:
         async_filename = ADAPTER_FILES["async"][0]
-        async_filepath = os.path.join(ref_dir, async_filename)
+        async_filepath = _find_sx(async_filename) or os.path.join(ref_dir, async_filename)
         if os.path.exists(async_filepath):
             with open(async_filepath) as f:
                 async_src = f.read()
@@ -1513,7 +1541,7 @@ def compile_ref_to_py(
 
     all_sections = []
     for filename, label in sx_files:
-        filepath = os.path.join(ref_dir, filename)
+        filepath = _find_sx(filename) or os.path.join(ref_dir, filename)
         if not os.path.exists(filepath):
             continue
         with open(filepath) as f:
@@ -1531,7 +1559,7 @@ def compile_ref_to_py(
     has_continuations = "continuations" in ext_set
 
     # Validate special forms
-    _validate_special_forms(ref_dir, all_sections, has_continuations)
+    _validate_special_forms(ref_dir, all_sections, has_continuations, source_dirs=_source_dirs)
 
     # Build output
     has_html = "html" in adapter_set

hosts/python/platform.py

@@ -498,10 +498,23 @@ def env_get(env, name):
     return env.get(name, NIL)
 
 
-def env_set(env, name, val):
+def env_bind(env, name, val):
+    """Create/overwrite binding on THIS env only (let, define, param binding)."""
     env[name] = val
 
 
+def env_set(env, name, val):
+    """Mutate existing binding, walking scope chain (set!)."""
+    if hasattr(env, 'set'):
+        try:
+            env.set(name, val)
+        except KeyError:
+            # Not found anywhere — bind on immediate env
+            env[name] = val
+    else:
+        env[name] = val
+
+
 def env_extend(env):
     return _ensure_env(env).extend()
 
@@ -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
@@ -588,13 +612,7 @@ def inspect(x):
     return repr(x)
 
 
-def escape_html(s):
-    s = str(s)
-    return s.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
-
-
-def escape_attr(s):
-    return escape_html(s)
+# escape_html and escape_attr are now library functions defined in render.sx
 
 
 def raw_html_content(x):
@@ -818,7 +836,7 @@ def _sx_parse_int(v, default=0):
     "stdlib.text": '''
 # stdlib.text
 PRIMITIVES["pluralize"] = lambda n, s="", p="s": s if n == 1 else p
-PRIMITIVES["escape"] = escape_html
+PRIMITIVES["escape"] = lambda s: str(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
 PRIMITIVES["strip-tags"] = lambda s: _strip_tags(str(s))
 
 import re as _re
@@ -1622,15 +1640,18 @@ SPEC_MODULES = {
     "engine": ("engine.sx", "engine (fetch/swap/trigger pure logic)"),
     "signals": ("signals.sx", "signals (reactive signal runtime)"),
     "page-helpers": ("page-helpers.sx", "page-helpers (pure data transformation helpers)"),
+    "stdlib": ("stdlib.sx", "stdlib (library functions from former primitives)"),
     "types": ("types.sx", "types (gradual type system)"),
-    "frames": ("frames.sx", "frames (CEK continuation frames)"),
-    "cek": ("cek.sx", "cek (explicit CEK machine evaluator)"),
+    "freeze": ("freeze.sx", "freeze (serializable state boundaries)"),
+    "content": ("content.sx", "content (content-addressed computation)"),
 }
+# 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.
+# stdlib must come first — other modules use its functions.
+# freeze depends on signals; content depends on freeze.
 SPEC_MODULE_ORDER = [
-    "deps", "engine", "frames", "page-helpers", "router", "cek", "signals", "types",
+    "stdlib", "deps", "engine", "page-helpers", "router", "signals", "types", "freeze", "content",
 ]
 
 EXTENSION_NAMES = {"continuations"}

hosts/python/transpiler.sx

@@ -93,6 +93,11 @@
   "*batch-depth*" "_batch_depth"
   "*batch-queue*" "_batch_queue"
   "*store-registry*" "_store_registry"
+  "*custom-special-forms*" "_custom_special_forms"
+  "*render-check*" "_render_check"
+  "*render-fn*" "_render_fn"
+  "register-special-form!" "register_special_form_b"
+  "is-else-clause?" "is_else_clause_p"
   "def-store" "def_store"
   "use-store" "use_store"
   "clear-stores" "clear_stores"
@@ -107,6 +112,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 +530,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 +912,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 +1113,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)))))))))
 

lib/bytecode.sx

@@ -0,0 +1,163 @@
+;; ==========================================================================
+;; bytecode.sx — SX bytecode format definition
+;;
+;; Universal bytecode for SX evaluation. Produced by compiler.sx,
+;; executed by platform-native VMs (OCaml, JS, WASM).
+;;
+;; Design principles:
+;;   - One byte per opcode (~65 ops, fits in u8)
+;;   - Variable-length encoding (1-5 bytes per instruction)
+;;   - Lexical scope resolved at compile time (no hash lookups)
+;;   - Tail calls detected statically (no thunks/trampoline)
+;;   - Control flow via jumps (no continuation frames for if/when/etc.)
+;;   - Content-addressable (deterministic binary for CID)
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; Opcode constants
+;; --------------------------------------------------------------------------
+
+;; Stack / Constants
+(define OP_CONST          1)  ;; u16 pool_idx — push constant
+(define OP_NIL            2)  ;; push nil
+(define OP_TRUE           3)  ;; push true
+(define OP_FALSE          4)  ;; push false
+(define OP_POP            5)  ;; discard TOS
+(define OP_DUP            6)  ;; duplicate TOS
+
+;; Variable access (resolved at compile time)
+(define OP_LOCAL_GET      16)  ;; u8 slot
+(define OP_LOCAL_SET      17)  ;; u8 slot
+(define OP_UPVALUE_GET    18)  ;; u8 idx
+(define OP_UPVALUE_SET    19)  ;; u8 idx
+(define OP_GLOBAL_GET     20)  ;; u16 name_idx
+(define OP_GLOBAL_SET     21)  ;; u16 name_idx
+
+;; Control flow (replaces if/when/cond/and/or frames)
+(define OP_JUMP           32)  ;; i16 offset
+(define OP_JUMP_IF_FALSE  33)  ;; i16 offset
+(define OP_JUMP_IF_TRUE   34)  ;; i16 offset
+
+;; Function operations
+(define OP_CALL           48)  ;; u8 argc
+(define OP_TAIL_CALL      49)  ;; u8 argc — reuse frame (TCO)
+(define OP_RETURN         50)  ;; return TOS
+(define OP_CLOSURE        51)  ;; u16 code_idx — create closure
+(define OP_CALL_PRIM      52)  ;; u16 name_idx, u8 argc — direct primitive
+(define OP_APPLY          53)  ;; (apply f args-list)
+
+;; Collection construction
+(define OP_LIST           64)  ;; u16 count — build list from stack
+(define OP_DICT           65)  ;; u16 count — build dict from stack pairs
+(define OP_APPEND_BANG    66)  ;; (append! TOS-1 TOS)
+
+;; Higher-order forms (inlined loop)
+(define OP_ITER_INIT      80)  ;; init iterator on TOS list
+(define OP_ITER_NEXT      81)  ;; i16 end_offset — push next or jump
+(define OP_MAP_OPEN       82)  ;; push empty accumulator
+(define OP_MAP_APPEND     83)  ;; append TOS to accumulator
+(define OP_MAP_CLOSE      84)  ;; pop accumulator as list
+(define OP_FILTER_TEST    85)  ;; i16 skip — if falsy jump (skip append)
+
+;; HO fallback (dynamic callback)
+(define OP_HO_MAP         88)  ;; (map fn coll)
+(define OP_HO_FILTER      89)  ;; (filter fn coll)
+(define OP_HO_REDUCE      90)  ;; (reduce fn init coll)
+(define OP_HO_FOR_EACH    91)  ;; (for-each fn coll)
+(define OP_HO_SOME        92)  ;; (some fn coll)
+(define OP_HO_EVERY       93)  ;; (every? fn coll)
+
+;; Scope / dynamic binding
+(define OP_SCOPE_PUSH     96)  ;; TOS = name
+(define OP_SCOPE_POP      97)
+(define OP_PROVIDE_PUSH   98)  ;; TOS-1 = name, TOS = value
+(define OP_PROVIDE_POP    99)
+(define OP_CONTEXT        100)  ;; TOS = name → push value
+(define OP_EMIT           101)  ;; TOS-1 = name, TOS = value
+(define OP_EMITTED        102)  ;; TOS = name → push collected
+
+;; Continuations
+(define OP_RESET          112)  ;; i16 body_len — push delimiter
+(define OP_SHIFT          113)  ;; u8 k_slot, i16 body_len — capture k
+
+;; Define / component
+(define OP_DEFINE         128)  ;; u16 name_idx — bind TOS to name
+(define OP_DEFCOMP        129)  ;; u16 template_idx
+(define OP_DEFISLAND      130)  ;; u16 template_idx
+(define OP_DEFMACRO       131)  ;; u16 template_idx
+(define OP_EXPAND_MACRO   132)  ;; u8 argc — runtime macro expansion
+
+;; String / serialize (hot path)
+(define OP_STR_CONCAT     144)  ;; u8 count — concat N values as strings
+(define OP_STR_JOIN       145)  ;; (join sep list)
+(define OP_SERIALIZE      146)  ;; serialize TOS to SX string
+
+;; Inline primitives (hot path — no hashtable lookup)
+(define OP_ADD            160)  ;; TOS-1 + TOS → push
+(define OP_SUB            161)  ;; TOS-1 - TOS → push
+(define OP_MUL            162)  ;; TOS-1 * TOS → push
+(define OP_DIV            163)  ;; TOS-1 / TOS → push
+(define OP_EQ             164)  ;; TOS-1 = TOS → push bool
+(define OP_LT             165)  ;; TOS-1 < TOS → push bool
+(define OP_GT             166)  ;; TOS-1 > TOS → push bool
+(define OP_NOT            167)  ;; !TOS → push bool
+(define OP_LEN            168)  ;; len(TOS) → push number
+(define OP_FIRST          169)  ;; first(TOS) → push
+(define OP_REST           170)  ;; rest(TOS) → push list
+(define OP_NTH            171)  ;; nth(TOS-1, TOS) → push
+(define OP_CONS           172)  ;; cons(TOS-1, TOS) → push list
+(define OP_NEG            173)  ;; negate TOS → push number
+(define OP_INC            174)  ;; TOS + 1 → push
+(define OP_DEC            175)  ;; TOS - 1 → push
+
+;; Aser specialization (optional, 224-239 reserved)
+(define OP_ASER_TAG       224)  ;; u16 tag_name_idx — serialize HTML tag
+(define OP_ASER_FRAG      225)  ;; u8 child_count — serialize fragment
+
+
+;; --------------------------------------------------------------------------
+;; Bytecode module structure
+;; --------------------------------------------------------------------------
+
+;; A module contains:
+;;   magic:      "SXBC" (4 bytes)
+;;   version:    u16
+;;   pool_count: u32
+;;   pool:       constant pool entries (self-describing tagged values)
+;;   code_count: u32
+;;   codes:      code objects
+;;   entry:      u32 (index of entry-point code object)
+
+(define BYTECODE_MAGIC "SXBC")
+(define BYTECODE_VERSION 1)
+
+;; Constant pool tags
+(define CONST_NUMBER   1)
+(define CONST_STRING   2)
+(define CONST_BOOL     3)
+(define CONST_NIL      4)
+(define CONST_SYMBOL   5)
+(define CONST_KEYWORD  6)
+(define CONST_LIST     7)
+(define CONST_DICT     8)
+(define CONST_CODE     9)
+
+
+;; --------------------------------------------------------------------------
+;; Disassembler
+;; --------------------------------------------------------------------------
+
+(define opcode-name
+  (fn (op)
+    (cond
+      (= op 1) "CONST"    (= op 2) "NIL"
+      (= op 3) "TRUE"     (= op 4) "FALSE"
+      (= op 5) "POP"      (= op 6) "DUP"
+      (= op 16) "LOCAL_GET"  (= op 17) "LOCAL_SET"
+      (= op 20) "GLOBAL_GET" (= op 21) "GLOBAL_SET"
+      (= op 32) "JUMP"     (= op 33) "JUMP_IF_FALSE"
+      (= op 48) "CALL"     (= op 49) "TAIL_CALL"
+      (= op 50) "RETURN"   (= op 52) "CALL_PRIM"
+      (= op 128) "DEFINE"   (= op 144) "STR_CONCAT"
+      :else (str "OP_" op))))

lib/compiler.sx

@@ -0,0 +1,826 @@
+;; ==========================================================================
+;; compiler.sx — SX bytecode compiler
+;;
+;; Compiles SX AST to bytecode for the platform-native VM.
+;; Written in SX — runs on any platform with an SX evaluator.
+;;
+;; Architecture:
+;;   Pass 1: Scope analysis — resolve variables, detect tail positions
+;;   Pass 2: Code generation — emit bytecode
+;;
+;; The compiler produces Code objects (bytecode + constant pool).
+;; The VM executes them with a stack machine model.
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; Constant pool builder
+;; --------------------------------------------------------------------------
+
+(define make-pool
+  (fn ()
+    {:entries (if (primitive? "mutable-list") (mutable-list) (list))
+     :index   {:_count 0}}))
+
+(define pool-add
+  (fn (pool value)
+    "Add a value to the constant pool, return its index. Deduplicates."
+    (let ((key (serialize value))
+          (idx-map (get pool "index")))
+      (if (has-key? idx-map key)
+        (get idx-map key)
+        (let ((idx (get idx-map "_count")))
+          (dict-set! idx-map key idx)
+          (dict-set! idx-map "_count" (+ idx 1))
+          (append! (get pool "entries") value)
+          idx)))))
+
+
+;; --------------------------------------------------------------------------
+;; Scope analysis
+;; --------------------------------------------------------------------------
+
+(define make-scope
+  (fn (parent)
+    {:locals     (list)   ;; list of {name, slot, mutable?}
+     :upvalues   (list)   ;; list of {name, is-local, index}
+     :parent     parent
+     :is-function false   ;; true for fn/lambda scopes (create frames)
+     :next-slot  0}))
+
+(define scope-define-local
+  (fn (scope name)
+    "Add a local variable, return its slot index.
+     Idempotent: if name already has a slot, return it."
+    (let ((existing (first (filter (fn (l) (= (get l "name") name))
+                                   (get scope "locals")))))
+      (if existing
+        (get existing "slot")
+        (let ((slot (get scope "next-slot")))
+          (append! (get scope "locals")
+            {:name name :slot slot :mutable false})
+          (dict-set! scope "next-slot" (+ slot 1))
+          slot)))))
+
+(define scope-resolve
+  (fn (scope name)
+    "Resolve a variable name. Returns {:type \"local\"|\"upvalue\"|\"global\", :index N}.
+     Upvalue captures only happen at function boundaries (is-function=true).
+     Let scopes share the enclosing function's frame — their locals are
+     accessed directly without upvalue indirection."
+    (if (nil? scope)
+      {:type "global" :index name}
+      ;; Check locals in this scope
+      (let ((locals (get scope "locals"))
+            (found (some (fn (l) (= (get l "name") name)) locals)))
+        (if found
+          (let ((local (first (filter (fn (l) (= (get l "name") name)) locals))))
+            {:type "local" :index (get local "slot")})
+          ;; Check upvalues already captured at this scope
+          (let ((upvals (get scope "upvalues"))
+                (uv-found (some (fn (u) (= (get u "name") name)) upvals)))
+            (if uv-found
+              (let ((uv (first (filter (fn (u) (= (get u "name") name)) upvals))))
+                {:type "upvalue" :index (get uv "uv-index")})
+              ;; Look in parent
+              (let ((parent (get scope "parent")))
+                (if (nil? parent)
+                  {:type "global" :index name}
+                  (let ((parent-result (scope-resolve parent name)))
+                    (if (= (get parent-result "type") "global")
+                      parent-result
+                      ;; Found in parent. Capture as upvalue only at function boundaries.
+                      (if (get scope "is-function")
+                        ;; Function boundary — create upvalue capture
+                        (let ((uv-idx (len (get scope "upvalues"))))
+                          (append! (get scope "upvalues")
+                            {:name name
+                             :is-local (= (get parent-result "type") "local")
+                             :index (get parent-result "index")
+                             :uv-index uv-idx})
+                          {:type "upvalue" :index uv-idx})
+                        ;; Let scope — pass through (same frame)
+                        parent-result))))))))))))
+
+
+;; --------------------------------------------------------------------------
+;; Code emitter
+;; --------------------------------------------------------------------------
+
+(define make-emitter
+  (fn ()
+    {:bytecode (if (primitive? "mutable-list") (mutable-list) (list))
+     :pool     (make-pool)}))
+
+(define emit-byte
+  (fn (em byte)
+    (append! (get em "bytecode") byte)))
+
+(define emit-u16
+  (fn (em value)
+    (emit-byte em (mod value 256))
+    (emit-byte em (mod (floor (/ value 256)) 256))))
+
+(define emit-i16
+  (fn (em value)
+    (let ((v (if (< value 0) (+ value 65536) value)))
+      (emit-u16 em v))))
+
+(define emit-op
+  (fn (em opcode)
+    (emit-byte em opcode)))
+
+(define emit-const
+  (fn (em value)
+    (let ((idx (pool-add (get em "pool") value)))
+      (emit-op em 1)   ;; OP_CONST
+      (emit-u16 em idx))))
+
+(define current-offset
+  (fn (em)
+    (len (get em "bytecode"))))
+
+(define patch-i16
+  (fn (em offset value)
+    "Patch a previously emitted i16 at the given bytecode offset."
+    (let ((v (if (< value 0) (+ value 65536) value))
+          (bc (get em "bytecode")))
+      ;; Direct mutation of bytecode list at offset
+      (set-nth! bc offset (mod v 256))
+      (set-nth! bc (+ offset 1) (mod (floor (/ v 256)) 256)))))
+
+
+;; --------------------------------------------------------------------------
+;; Compilation — expression dispatch
+;; --------------------------------------------------------------------------
+
+(define compile-expr
+  (fn (em expr scope tail?)
+    "Compile an expression. tail? indicates tail position for TCO."
+    (cond
+      ;; Nil
+      (nil? expr)
+        (emit-op em 2)  ;; OP_NIL
+
+      ;; Number
+      (= (type-of expr) "number")
+        (emit-const em expr)
+
+      ;; String
+      (= (type-of expr) "string")
+        (emit-const em expr)
+
+      ;; Boolean
+      (= (type-of expr) "boolean")
+        (emit-op em (if expr 3 4))  ;; OP_TRUE / OP_FALSE
+
+      ;; Keyword
+      (= (type-of expr) "keyword")
+        (emit-const em (keyword-name expr))
+
+      ;; Symbol — resolve to local/upvalue/global
+      (= (type-of expr) "symbol")
+        (compile-symbol em (symbol-name expr) scope)
+
+      ;; List — dispatch on head
+      (= (type-of expr) "list")
+        (if (empty? expr)
+          (do (emit-op em 64) (emit-u16 em 0))  ;; OP_LIST 0
+          (compile-list em expr scope tail?))
+
+      ;; Dict literal
+      (= (type-of expr) "dict")
+        (compile-dict em expr scope)
+
+      ;; Fallback
+      :else
+        (emit-const em expr))))
+
+
+(define compile-symbol
+  (fn (em name scope)
+    (let ((resolved (scope-resolve scope name)))
+      (cond
+        (= (get resolved "type") "local")
+          (do (emit-op em 16)  ;; OP_LOCAL_GET
+              (emit-byte em (get resolved "index")))
+        (= (get resolved "type") "upvalue")
+          (do (emit-op em 18)  ;; OP_UPVALUE_GET
+              (emit-byte em (get resolved "index")))
+        :else
+          ;; Global or primitive
+          (let ((idx (pool-add (get em "pool") name)))
+            (emit-op em 20)  ;; OP_GLOBAL_GET
+            (emit-u16 em idx))))))
+
+
+(define compile-dict
+  (fn (em expr scope)
+    (let ((ks (keys expr))
+          (count (len ks)))
+      (for-each (fn (k)
+        (emit-const em k)
+        (compile-expr em (get expr k) scope false))
+        ks)
+      (emit-op em 65)     ;; OP_DICT
+      (emit-u16 em count))))
+
+
+;; --------------------------------------------------------------------------
+;; List compilation — special forms, calls
+;; --------------------------------------------------------------------------
+
+(define compile-list
+  (fn (em expr scope tail?)
+    (let ((head (first expr))
+          (args (rest expr)))
+      (if (not (= (type-of head) "symbol"))
+        ;; Non-symbol head — compile as call
+        (compile-call em head args scope tail?)
+        ;; Symbol head — check for special forms
+        (let ((name (symbol-name head)))
+          (cond
+            (= name "if")      (compile-if em args scope tail?)
+            (= name "when")    (compile-when em args scope tail?)
+            (= name "and")     (compile-and em args scope tail?)
+            (= name "or")      (compile-or em args scope tail?)
+            (= name "let")     (compile-let em args scope tail?)
+            (= name "let*")    (compile-let em args scope tail?)
+            (= name "begin")   (compile-begin em args scope tail?)
+            (= name "do")      (compile-begin em args scope tail?)
+            (= name "lambda")  (compile-lambda em args scope)
+            (= name "fn")      (compile-lambda em args scope)
+            (= name "define")  (compile-define em args scope)
+            (= name "set!")    (compile-set em args scope)
+            (= name "quote")   (compile-quote em args)
+            (= name "cond")    (compile-cond em args scope tail?)
+            (= name "case")    (compile-case em args scope tail?)
+            (= name "->")      (compile-thread em args scope tail?)
+            (= name "defcomp") (compile-defcomp em args scope)
+            (= name "defisland") (compile-defcomp em args scope)
+            (= name "defmacro") (compile-defmacro em args scope)
+            (= name "defstyle") (emit-op em 2)  ;; defstyle → nil (no-op at runtime)
+            (= name "defhandler") (emit-op em 2)  ;; no-op
+            (= name "defpage") (emit-op em 2)  ;; handled by page loader
+            (= name "defquery") (emit-op em 2)
+            (= name "defaction") (emit-op em 2)
+            (= name "defrelation") (emit-op em 2)
+            (= name "deftype") (emit-op em 2)
+            (= name "defeffect") (emit-op em 2)
+            (= name "defisland") (compile-defcomp em args scope)
+            (= name "quasiquote") (compile-quasiquote em (first args) scope)
+            (= name "letrec") (compile-letrec em args scope tail?)
+            ;; Default — function call
+            :else
+              (compile-call em head args scope tail?)))))))
+
+
+;; --------------------------------------------------------------------------
+;; Special form compilation
+;; --------------------------------------------------------------------------
+
+(define compile-if
+  (fn (em args scope tail?)
+    (let ((test (first args))
+          (then-expr (nth args 1))
+          (else-expr (if (> (len args) 2) (nth args 2) nil)))
+      ;; Compile test
+      (compile-expr em test scope false)
+      ;; Jump if false to else
+      (emit-op em 33)  ;; OP_JUMP_IF_FALSE
+      (let ((else-jump (current-offset em)))
+        (emit-i16 em 0)  ;; placeholder
+        ;; Compile then (in tail position if if is)
+        (compile-expr em then-expr scope tail?)
+        ;; Jump over else
+        (emit-op em 32)  ;; OP_JUMP
+        (let ((end-jump (current-offset em)))
+          (emit-i16 em 0)  ;; placeholder
+          ;; Patch else jump
+          (patch-i16 em else-jump (- (current-offset em) (+ else-jump 2)))
+          ;; Compile else
+          (if (nil? else-expr)
+            (emit-op em 2)  ;; OP_NIL
+            (compile-expr em else-expr scope tail?))
+          ;; Patch end jump
+          (patch-i16 em end-jump (- (current-offset em) (+ end-jump 2))))))))
+
+
+(define compile-when
+  (fn (em args scope tail?)
+    (let ((test (first args))
+          (body (rest args)))
+      (compile-expr em test scope false)
+      (emit-op em 33)  ;; OP_JUMP_IF_FALSE
+      (let ((skip-jump (current-offset em)))
+        (emit-i16 em 0)
+        (compile-begin em body scope tail?)
+        (emit-op em 32)  ;; OP_JUMP
+        (let ((end-jump (current-offset em)))
+          (emit-i16 em 0)
+          (patch-i16 em skip-jump (- (current-offset em) (+ skip-jump 2)))
+          (emit-op em 2)  ;; OP_NIL
+          (patch-i16 em end-jump (- (current-offset em) (+ end-jump 2))))))))
+
+
+(define compile-and
+  (fn (em args scope tail?)
+    (if (empty? args)
+      (emit-op em 3)  ;; OP_TRUE
+      (if (= (len args) 1)
+        (compile-expr em (first args) scope tail?)
+        (do
+          (compile-expr em (first args) scope false)
+          (emit-op em 6)  ;; OP_DUP
+          (emit-op em 33)  ;; OP_JUMP_IF_FALSE
+          (let ((skip (current-offset em)))
+            (emit-i16 em 0)
+            (emit-op em 5)  ;; OP_POP (discard duplicated truthy)
+            (compile-and em (rest args) scope tail?)
+            (patch-i16 em skip (- (current-offset em) (+ skip 2)))))))))
+
+
+(define compile-or
+  (fn (em args scope tail?)
+    (if (empty? args)
+      (emit-op em 4)  ;; OP_FALSE
+      (if (= (len args) 1)
+        (compile-expr em (first args) scope tail?)
+        (do
+          (compile-expr em (first args) scope false)
+          (emit-op em 6)  ;; OP_DUP
+          (emit-op em 34)  ;; OP_JUMP_IF_TRUE
+          (let ((skip (current-offset em)))
+            (emit-i16 em 0)
+            (emit-op em 5)  ;; OP_POP
+            (compile-or em (rest args) scope tail?)
+            (patch-i16 em skip (- (current-offset em) (+ skip 2)))))))))
+
+
+(define compile-begin
+  (fn (em exprs scope tail?)
+    ;; Hoist: pre-allocate local slots for all define forms in this block.
+    ;; Enables forward references between inner functions (e.g. sx-parse).
+    ;; Only inside function bodies (scope has parent), not at top level.
+    (when (and (not (empty? exprs)) (not (nil? (get scope "parent"))))
+      (for-each (fn (expr)
+        (when (and (= (type-of expr) "list")
+                   (>= (len expr) 2)
+                   (= (type-of (first expr)) "symbol")
+                   (= (symbol-name (first expr)) "define"))
+          (let ((name-expr (nth expr 1))
+                (name (if (= (type-of name-expr) "symbol")
+                        (symbol-name name-expr)
+                        name-expr)))
+            (scope-define-local scope name))))
+        exprs))
+    ;; Compile expressions
+    (if (empty? exprs)
+      (emit-op em 2)  ;; OP_NIL
+      (if (= (len exprs) 1)
+        (compile-expr em (first exprs) scope tail?)
+        (do
+          (compile-expr em (first exprs) scope false)
+          (emit-op em 5)  ;; OP_POP
+          (compile-begin em (rest exprs) scope tail?))))))
+
+
+(define compile-let
+  (fn (em args scope tail?)
+    ;; Detect named let: (let loop ((x init) ...) body)
+    (if (= (type-of (first args)) "symbol")
+      ;; Named let → desugar to letrec:
+      ;;   (letrec ((loop (fn (x ...) body))) (loop init ...))
+      (let ((loop-name (symbol-name (first args)))
+            (bindings (nth args 1))
+            (body (slice args 2))
+            (params (list))
+            (inits (list)))
+        (for-each (fn (binding)
+          (append! params (if (= (type-of (first binding)) "symbol")
+                            (first binding)
+                            (make-symbol (first binding))))
+          (append! inits (nth binding 1)))
+          bindings)
+        ;; Compile as: (letrec ((loop (fn (params...) body...))) (loop inits...))
+        (let ((lambda-expr (concat (list (make-symbol "fn") params) body))
+              (letrec-bindings (list (list (make-symbol loop-name) lambda-expr)))
+              (call-expr (cons (make-symbol loop-name) inits)))
+          (compile-letrec em (list letrec-bindings call-expr) scope tail?)))
+      ;; Normal let
+      (let ((bindings (first args))
+            (body (rest args))
+            (let-scope (make-scope scope)))
+        ;; Let scopes share the enclosing function's frame.
+        ;; Continue slot numbering from parent.
+        (dict-set! let-scope "next-slot" (get scope "next-slot"))
+        ;; Compile each binding
+        (for-each (fn (binding)
+          (let ((name (if (= (type-of (first binding)) "symbol")
+                        (symbol-name (first binding))
+                        (first binding)))
+                (value (nth binding 1))
+                (slot (scope-define-local let-scope name)))
+            (compile-expr em value let-scope false)
+            (emit-op em 17)  ;; OP_LOCAL_SET
+            (emit-byte em slot)))
+          bindings)
+        ;; Compile body in let scope
+        (compile-begin em body let-scope tail?)))))
+
+
+(define compile-letrec
+  (fn (em args scope tail?)
+    "Compile letrec: all names visible during value compilation.
+     1. Define all local slots (initialized to nil).
+     2. Compile each value and assign — names are already in scope
+        so mutually recursive functions can reference each other."
+    (let ((bindings (first args))
+          (body (rest args))
+          (let-scope (make-scope scope)))
+      (dict-set! let-scope "next-slot" (get scope "next-slot"))
+      ;; Phase 1: define all slots (push nil for each)
+      (let ((slots (map (fn (binding)
+              (let ((name (if (= (type-of (first binding)) "symbol")
+                            (symbol-name (first binding))
+                            (first binding))))
+                (let ((slot (scope-define-local let-scope name)))
+                  (emit-op em 2)    ;; OP_NIL
+                  (emit-op em 17)   ;; OP_LOCAL_SET
+                  (emit-byte em slot)
+                  slot)))
+            bindings)))
+        ;; Phase 2: compile values and assign (all names in scope)
+        (for-each (fn (pair)
+          (let ((binding (first pair))
+                (slot (nth pair 1)))
+            (compile-expr em (nth binding 1) let-scope false)
+            (emit-op em 17)   ;; OP_LOCAL_SET
+            (emit-byte em slot)))
+          (map (fn (i) (list (nth bindings i) (nth slots i)))
+               (range 0 (len bindings)))))
+      ;; Compile body
+      (compile-begin em body let-scope tail?))))
+
+(define compile-lambda
+  (fn (em args scope)
+    (let ((params (first args))
+          (body (rest args))
+          (fn-scope (make-scope scope))
+          (fn-em (make-emitter)))
+      ;; Mark as function boundary — upvalue captures happen here
+      (dict-set! fn-scope "is-function" true)
+      ;; Define params as locals in fn scope.
+      ;; Handle type annotations: (name :as type) → extract name
+      (for-each (fn (p)
+        (let ((name (cond
+                      (= (type-of p) "symbol") (symbol-name p)
+                      ;; Type-annotated param: (name :as type)
+                      (and (list? p) (not (empty? p))
+                           (= (type-of (first p)) "symbol"))
+                        (symbol-name (first p))
+                      :else p)))
+          (when (and (not (= name "&key"))
+                     (not (= name "&rest")))
+            (scope-define-local fn-scope name))))
+        params)
+      ;; Compile body
+      (compile-begin fn-em body fn-scope true)  ;; tail position
+      (emit-op fn-em 50)  ;; OP_RETURN
+      ;; Add code object to parent constant pool
+      (let ((upvals (get fn-scope "upvalues"))
+            (code {:arity (len (get fn-scope "locals"))
+                   :bytecode (get fn-em "bytecode")
+                   :constants (get (get fn-em "pool") "entries")
+                   :upvalue-count (len upvals)})
+            (code-idx (pool-add (get em "pool") code)))
+        (emit-op em 51)  ;; OP_CLOSURE
+        (emit-u16 em code-idx)
+        ;; Emit upvalue descriptors: for each captured variable,
+        ;; (is_local, index) — tells the VM where to find the value.
+        ;; is_local=1: capture from enclosing frame's local slot
+        ;; is_local=0: capture from enclosing frame's upvalue
+        (for-each (fn (uv)
+          (emit-byte em (if (get uv "is-local") 1 0))
+          (emit-byte em (get uv "index")))
+          upvals)))))
+
+
+(define compile-define
+  (fn (em args scope)
+    (let ((name-expr (first args))
+          (name (if (= (type-of name-expr) "symbol")
+                  (symbol-name name-expr)
+                  name-expr))
+          ;; Handle :effects annotation: (define name :effects [...] value)
+          ;; Skip keyword-value pairs between name and body
+          (value (let ((rest-args (rest args)))
+                   (if (and (not (empty? rest-args))
+                            (= (type-of (first rest-args)) "keyword"))
+                     ;; Skip :keyword value pairs until we hit the body
+                     (let ((skip-annotations
+                             (fn (items)
+                               (if (empty? items) nil
+                                 (if (= (type-of (first items)) "keyword")
+                                   (skip-annotations (rest (rest items)))
+                                   (first items))))))
+                       (skip-annotations rest-args))
+                     (first rest-args)))))
+      ;; Inside a function body, define creates a LOCAL binding.
+      ;; At top level (no enclosing function scope), define creates a global.
+      ;; Local binding prevents recursive calls from overwriting
+      ;; each other's defines in the flat globals hashtable.
+      (if (not (nil? (get scope "parent")))
+          ;; Local define — allocate slot, compile value, set local
+          (let ((slot (scope-define-local scope name)))
+            (compile-expr em value scope false)
+            (emit-op em 17)  ;; OP_LOCAL_SET
+            (emit-byte em slot))
+          ;; Top-level define — global
+          (let ((name-idx (pool-add (get em "pool") name)))
+            (compile-expr em value scope false)
+            (emit-op em 128)  ;; OP_DEFINE
+            (emit-u16 em name-idx))))))
+
+
+(define compile-set
+  (fn (em args scope)
+    (let ((name (if (= (type-of (first args)) "symbol")
+                  (symbol-name (first args))
+                  (first args)))
+          (value (nth args 1))
+          (resolved (scope-resolve scope name)))
+      (compile-expr em value scope false)
+      (cond
+        (= (get resolved "type") "local")
+          (do (emit-op em 17)  ;; OP_LOCAL_SET
+              (emit-byte em (get resolved "index")))
+        (= (get resolved "type") "upvalue")
+          (do (emit-op em 19)  ;; OP_UPVALUE_SET
+              (emit-byte em (get resolved "index")))
+        :else
+          (let ((idx (pool-add (get em "pool") name)))
+            (emit-op em 21)  ;; OP_GLOBAL_SET
+            (emit-u16 em idx))))))
+
+
+(define compile-quote
+  (fn (em args)
+    (if (empty? args)
+      (emit-op em 2)  ;; OP_NIL
+      (emit-const em (first args)))))
+
+
+(define compile-cond
+  (fn (em args scope tail?)
+    "Compile (cond test1 body1 test2 body2 ... :else fallback)."
+    (if (< (len args) 2)
+      (emit-op em 2)  ;; OP_NIL
+      (let ((test (first args))
+            (body (nth args 1))
+            (rest-clauses (if (> (len args) 2) (slice args 2) (list))))
+        (if (or (and (= (type-of test) "keyword") (= (keyword-name test) "else"))
+                (= test true))
+          ;; else clause — just compile the body
+          (compile-expr em body scope tail?)
+          (do
+            (compile-expr em test scope false)
+            (emit-op em 33)  ;; OP_JUMP_IF_FALSE
+            (let ((skip (current-offset em)))
+              (emit-i16 em 0)
+              (compile-expr em body scope tail?)
+              (emit-op em 32)  ;; OP_JUMP
+              (let ((end-jump (current-offset em)))
+                (emit-i16 em 0)
+                (patch-i16 em skip (- (current-offset em) (+ skip 2)))
+                (compile-cond em rest-clauses scope tail?)
+                (patch-i16 em end-jump (- (current-offset em) (+ end-jump 2)))))))))))
+
+
+(define compile-case
+  (fn (em args scope tail?)
+    "Compile (case expr val1 body1 val2 body2 ... :else fallback)."
+    ;; Desugar to nested if: evaluate expr once, then compare
+    (compile-expr em (first args) scope false)
+    (let ((clauses (rest args)))
+      (compile-case-clauses em clauses scope tail?))))
+
+(define compile-case-clauses
+  (fn (em clauses scope tail?)
+    (if (< (len clauses) 2)
+      (do (emit-op em 5) (emit-op em 2))  ;; POP match-val, push NIL
+      (let ((test (first clauses))
+            (body (nth clauses 1))
+            (rest-clauses (if (> (len clauses) 2) (slice clauses 2) (list))))
+        (if (or (and (= (type-of test) "keyword") (= (keyword-name test) "else"))
+                (= test true))
+          (do (emit-op em 5)  ;; POP match-val
+              (compile-expr em body scope tail?))
+          (do
+            (emit-op em 6)  ;; DUP match-val
+            (compile-expr em test scope false)
+            (let ((name-idx (pool-add (get em "pool") "=")))
+              (emit-op em 52) (emit-u16 em name-idx) (emit-byte em 2))  ;; CALL_PRIM "=" 2
+            (emit-op em 33)  ;; JUMP_IF_FALSE
+            (let ((skip (current-offset em)))
+              (emit-i16 em 0)
+              (emit-op em 5)  ;; POP match-val
+              (compile-expr em body scope tail?)
+              (emit-op em 32)  ;; JUMP
+              (let ((end-jump (current-offset em)))
+                (emit-i16 em 0)
+                (patch-i16 em skip (- (current-offset em) (+ skip 2)))
+                (compile-case-clauses em rest-clauses scope tail?)
+                (patch-i16 em end-jump (- (current-offset em) (+ end-jump 2)))))))))))
+
+
+(define compile-thread
+  (fn (em args scope tail?)
+    "Compile (-> val (f1 a) (f2 b)) by desugaring to nested calls."
+    (if (empty? args)
+      (emit-op em 2)
+      (if (= (len args) 1)
+        (compile-expr em (first args) scope tail?)
+        ;; Desugar: (-> x (f a)) → (f x a)
+        (let ((val-expr (first args))
+              (forms (rest args)))
+          (compile-thread-step em val-expr forms scope tail?))))))
+
+(define compile-thread-step
+  (fn (em val-expr forms scope tail?)
+    (if (empty? forms)
+      (compile-expr em val-expr scope tail?)
+      (let ((form (first forms))
+            (rest-forms (rest forms))
+            (is-tail (and tail? (empty? rest-forms))))
+        ;; Build desugared call: (f val args...)
+        (let ((call-expr
+                (if (list? form)
+                  ;; (-> x (f a b)) → (f x a b)
+                  (concat (list (first form) val-expr) (rest form))
+                  ;; (-> x f) → (f x)
+                  (list form val-expr))))
+          (if (empty? rest-forms)
+            (compile-expr em call-expr scope is-tail)
+            (do
+              (compile-expr em call-expr scope false)
+              ;; Thread result through remaining forms
+              ;; Store in temp, compile next step
+              ;; Actually, just compile sequentially — each step returns a value
+              (compile-thread-step em call-expr rest-forms scope tail?))))))))
+
+
+(define compile-defcomp
+  (fn (em args scope)
+    "Compile defcomp/defisland — delegates to runtime via GLOBAL_GET + CALL."
+    (let ((name-idx (pool-add (get em "pool") "eval-defcomp")))
+      (emit-op em 20) (emit-u16 em name-idx))  ;; GLOBAL_GET fn
+    (emit-const em (concat (list (make-symbol "defcomp")) args))
+    (emit-op em 48) (emit-byte em 1)))  ;; CALL 1
+
+(define compile-defmacro
+  (fn (em args scope)
+    "Compile defmacro — delegates to runtime via GLOBAL_GET + CALL."
+    (let ((name-idx (pool-add (get em "pool") "eval-defmacro")))
+      (emit-op em 20) (emit-u16 em name-idx))  ;; GLOBAL_GET fn
+    (emit-const em (concat (list (make-symbol "defmacro")) args))
+    (emit-op em 48) (emit-byte em 1)))
+
+
+(define compile-quasiquote
+  (fn (em expr scope)
+    "Compile quasiquote inline — walks the template at compile time,
+     emitting code that builds the structure at runtime. Unquoted
+     expressions are compiled normally (resolving locals/upvalues),
+     avoiding the qq-expand-runtime env-lookup limitation."
+    (compile-qq-expr em expr scope)))
+
+(define compile-qq-expr
+  (fn (em expr scope)
+    "Compile a quasiquote sub-expression."
+    (if (not (= (type-of expr) "list"))
+      ;; Atom — emit as constant
+      (emit-const em expr)
+      (if (empty? expr)
+        ;; Empty list
+        (do (emit-op em 64) (emit-u16 em 0))  ;; OP_LIST 0
+        (let ((head (first expr)))
+          (if (and (= (type-of head) "symbol")
+                   (= (symbol-name head) "unquote"))
+            ;; (unquote expr) — compile the expression
+            (compile-expr em (nth expr 1) scope false)
+            ;; List — compile elements, handling splice-unquote
+            (compile-qq-list em expr scope)))))))
+
+(define compile-qq-list
+  (fn (em items scope)
+    "Compile a quasiquote list. Handles splice-unquote by building
+     segments and concatenating them."
+    (let ((has-splice (some (fn (item)
+            (and (= (type-of item) "list")
+                 (>= (len item) 2)
+                 (= (type-of (first item)) "symbol")
+                 (= (symbol-name (first item)) "splice-unquote")))
+            items)))
+      (if (not has-splice)
+        ;; No splicing — compile each element, then OP_LIST
+        (do
+          (for-each (fn (item) (compile-qq-expr em item scope)) items)
+          (emit-op em 64) (emit-u16 em (len items)))  ;; OP_LIST N
+        ;; Has splicing — build segments and concat
+        ;; Strategy: accumulate non-spliced items into a pending list,
+        ;; flush as OP_LIST when hitting a splice, concat all segments.
+        (let ((segment-count 0)
+              (pending 0))
+          (for-each
+            (fn (item)
+              (if (and (= (type-of item) "list")
+                       (>= (len item) 2)
+                       (= (type-of (first item)) "symbol")
+                       (= (symbol-name (first item)) "splice-unquote"))
+                ;; Splice-unquote: flush pending, compile spliced expr
+                (do
+                  (when (> pending 0)
+                    (emit-op em 64) (emit-u16 em pending)  ;; OP_LIST for pending
+                    (set! segment-count (+ segment-count 1))
+                    (set! pending 0))
+                  ;; Compile the spliced expression
+                  (compile-expr em (nth item 1) scope false)
+                  (set! segment-count (+ segment-count 1)))
+                ;; Normal element — compile and count as pending
+                (do
+                  (compile-qq-expr em item scope)
+                  (set! pending (+ pending 1)))))
+            items)
+          ;; Flush remaining pending items
+          (when (> pending 0)
+            (emit-op em 64) (emit-u16 em pending)
+            (set! segment-count (+ segment-count 1)))
+          ;; Concat all segments
+          (when (> segment-count 1)
+            (let ((concat-idx (pool-add (get em "pool") "concat")))
+              ;; concat takes N args — call with all segments
+              (emit-op em 52) (emit-u16 em concat-idx)
+              (emit-byte em segment-count))))))))
+
+
+;; --------------------------------------------------------------------------
+;; Function call compilation
+;; --------------------------------------------------------------------------
+
+(define compile-call
+  (fn (em head args scope tail?)
+    ;; Check for known primitives
+    (let ((is-prim (and (= (type-of head) "symbol")
+                        (let ((name (symbol-name head)))
+                          (and (not (= (get (scope-resolve scope name) "type") "local"))
+                               (not (= (get (scope-resolve scope name) "type") "upvalue"))
+                               (primitive? name))))))
+      (if is-prim
+        ;; Direct primitive call via CALL_PRIM
+        (let ((name (symbol-name head))
+              (argc (len args))
+              (name-idx (pool-add (get em "pool") name)))
+          (for-each (fn (a) (compile-expr em a scope false)) args)
+          (emit-op em 52)  ;; OP_CALL_PRIM
+          (emit-u16 em name-idx)
+          (emit-byte em argc))
+        ;; General call
+        (do
+          (compile-expr em head scope false)
+          (for-each (fn (a) (compile-expr em a scope false)) args)
+          (if tail?
+            (do (emit-op em 49)  ;; OP_TAIL_CALL
+                (emit-byte em (len args)))
+            (do (emit-op em 48)  ;; OP_CALL
+                (emit-byte em (len args)))))))))
+
+
+;; --------------------------------------------------------------------------
+;; Top-level API
+;; --------------------------------------------------------------------------
+
+(define compile
+  (fn (expr)
+    "Compile a single SX expression to a bytecode module."
+    (let ((em (make-emitter))
+          (scope (make-scope nil)))
+      (compile-expr em expr scope false)
+      (emit-op em 50)  ;; OP_RETURN
+      {:bytecode (get em "bytecode")
+       :constants (get (get em "pool") "entries")})))
+
+(define compile-module
+  (fn (exprs)
+    "Compile a list of top-level expressions to a bytecode module."
+    (let ((em (make-emitter))
+          (scope (make-scope nil)))
+      (for-each (fn (expr)
+        (compile-expr em expr scope false)
+        (emit-op em 5))  ;; OP_POP between top-level exprs
+        (init exprs))
+      ;; Last expression's value is the module result
+      (compile-expr em (last exprs) scope false)
+      (emit-op em 50)  ;; OP_RETURN
+      {:bytecode (get em "bytecode")
+       :constants (get (get em "pool") "entries")})))

lib/content.sx

@@ -0,0 +1,48 @@
+;; ==========================================================================
+;; content.sx — Content-addressed computation
+;;
+;; Hash frozen SX to a content identifier. Store and retrieve by CID.
+;; The content IS the address — same SX always produces the same CID.
+;;
+;; This is a library built on top of freeze.sx. It is NOT part of the
+;; core evaluator. Load order: evaluator.sx → freeze.sx → content.sx
+;;
+;; Uses an in-memory content store. Applications can persist to
+;; localStorage or IPFS by providing their own store backend.
+;; ==========================================================================
+
+(define content-store (dict))
+
+(define content-hash :effects []
+  (fn (sx-text)
+    ;; djb2 hash → hex string. Simple, deterministic, fast.
+    ;; Real deployment would use SHA-256 / multihash.
+    (let ((hash 5381))
+      (for-each (fn (i)
+        (set! hash (mod (+ (* hash 33) (char-code-at sx-text i)) 4294967296)))
+        (range 0 (len sx-text)))
+      (to-hex hash))))
+
+(define content-put :effects [mutation]
+  (fn (sx-text)
+    (let ((cid (content-hash sx-text)))
+      (dict-set! content-store cid sx-text)
+      cid)))
+
+(define content-get :effects []
+  (fn (cid)
+    (get content-store cid)))
+
+;; Freeze a scope → store → return CID
+(define freeze-to-cid :effects [mutation]
+  (fn (scope-name)
+    (let ((sx-text (freeze-to-sx scope-name)))
+      (content-put sx-text))))
+
+;; Thaw from CID → look up → restore
+(define thaw-from-cid :effects [mutation]
+  (fn (cid)
+    (let ((sx-text (content-get cid)))
+      (when sx-text
+        (thaw-from-sx sx-text)
+        true))))

lib/freeze.sx

@@ -0,0 +1,94 @@
+;; ==========================================================================
+;; freeze.sx — Serializable state boundaries
+;;
+;; Freeze scopes collect signals registered within them. On freeze,
+;; their current values are serialized to SX. On thaw, values are
+;; restored. Multiple named scopes can coexist independently.
+;;
+;; This is a library built on top of the evaluator's scoped effects
+;; (scope-push!/scope-pop!/context) and signal system. It is NOT
+;; part of the core evaluator — it loads after evaluator.sx.
+;;
+;; Usage:
+;;   (freeze-scope "editor"
+;;     (let ((doc (signal "hello")))
+;;       (freeze-signal "doc" doc)
+;;       ...))
+;;
+;;   (cek-freeze-scope "editor")  → {:name "editor" :signals {:doc "hello"}}
+;;   (cek-thaw-scope "editor" frozen-data)  → restores signal values
+;; ==========================================================================
+
+;; Registry of freeze scopes: name → list of {name signal} entries
+(define freeze-registry (dict))
+
+;; Register a signal in the current freeze scope
+(define freeze-signal :effects [mutation]
+  (fn (name sig)
+    (let ((scope-name (context "sx-freeze-scope" nil)))
+      (when scope-name
+        (let ((entries (or (get freeze-registry scope-name) (list))))
+          (append! entries (dict "name" name "signal" sig))
+          (dict-set! freeze-registry scope-name entries))))))
+
+;; Freeze scope delimiter — collects signals registered within body
+(define freeze-scope :effects [mutation]
+  (fn (name body-fn)
+    (scope-push! "sx-freeze-scope" name)
+    ;; Initialize empty entry list for this scope
+    (dict-set! freeze-registry name (list))
+    (cek-call body-fn nil)
+    (scope-pop! "sx-freeze-scope")
+    nil))
+
+;; Freeze a named scope → SX dict of signal values
+(define cek-freeze-scope :effects []
+  (fn (name)
+    (let ((entries (or (get freeze-registry name) (list)))
+          (signals-dict (dict)))
+      (for-each (fn (entry)
+        (dict-set! signals-dict
+          (get entry "name")
+          (signal-value (get entry "signal"))))
+        entries)
+      (dict "name" name "signals" signals-dict))))
+
+;; Freeze all scopes
+(define cek-freeze-all :effects []
+  (fn ()
+    (map (fn (name) (cek-freeze-scope name))
+      (keys freeze-registry))))
+
+;; Thaw a named scope — restore signal values from frozen data
+(define cek-thaw-scope :effects [mutation]
+  (fn (name frozen)
+    (let ((entries (or (get freeze-registry name) (list)))
+          (values (get frozen "signals")))
+      (when values
+        (for-each (fn (entry)
+          (let ((sig-name (get entry "name"))
+                (sig (get entry "signal"))
+                (val (get values sig-name)))
+            (when (not (nil? val))
+              (reset! sig val))))
+          entries)))))
+
+;; Thaw all scopes from a list of frozen scope dicts
+(define cek-thaw-all :effects [mutation]
+  (fn (frozen-list)
+    (for-each (fn (frozen)
+      (cek-thaw-scope (get frozen "name") frozen))
+      frozen-list)))
+
+;; Serialize a frozen scope to SX text
+(define freeze-to-sx :effects []
+  (fn (name)
+    (sx-serialize (cek-freeze-scope name))))
+
+;; Restore from SX text
+(define thaw-from-sx :effects [mutation]
+  (fn (sx-text)
+    (let ((parsed (sx-parse sx-text)))
+      (when (not (empty? parsed))
+        (let ((frozen (first parsed)))
+          (cek-thaw-scope (get frozen "name") frozen))))))

lib/stdlib.sx

@@ -0,0 +1,275 @@
+;; ==========================================================================
+;; stdlib.sx — Standard library functions
+;;
+;; Every function here is expressed in SX using the irreducible primitive
+;; set. They are library functions — in band, auditable, portable.
+;;
+;; Depends on: evaluator.sx (special forms)
+;; Must load before: render.sx, freeze.sx, types.sx, user code
+;; ==========================================================================
+
+
+;; Logic + comparison: not, !=, <=, >= stay as primitives.
+;; Replacing them with SX lambdas changes behavior inside shift/reset
+;; because the transpiled evaluator code uses them directly.
+
+(define eq?    (fn (a b) (= a b)))
+(define eqv?   (fn (a b) (= a b)))
+(define equal? (fn (a b) (= a b)))
+
+
+;; --------------------------------------------------------------------------
+;; Type predicates
+;; --------------------------------------------------------------------------
+
+;; nil? stays as primitive — host's type-of uses it internally.
+
+(define boolean?
+  (fn (x) (= (type-of x) "boolean")))
+
+(define number?
+  (fn (x) (= (type-of x) "number")))
+
+(define string?
+  (fn (x) (= (type-of x) "string")))
+
+(define list?
+  (fn (x) (= (type-of x) "list")))
+
+(define dict?
+  (fn (x) (= (type-of x) "dict")))
+
+(define continuation?
+  (fn (x) (= (type-of x) "continuation")))
+
+(define zero?
+  (fn (n) (= n 0)))
+
+(define odd?
+  (fn (n) (= (mod n 2) 1)))
+
+(define even?
+  (fn (n) (= (mod n 2) 0)))
+
+(define empty?
+  (fn (coll) (or (nil? coll) (= (len coll) 0))))
+
+
+;; --------------------------------------------------------------------------
+;; Arithmetic
+;; --------------------------------------------------------------------------
+
+;; inc and dec stay as primitives — used inside continuation contexts.
+
+(define abs
+  (fn (x) (if (< x 0) (- x) x)))
+
+(define ceil
+  (fn (x)
+    (let ((f (floor x)))
+      (if (= x f) f (+ f 1)))))
+
+(define round
+  (fn (x ndigits)
+    (if (nil? ndigits)
+      (floor (+ x 0.5))
+      (let ((f (pow 10 ndigits)))
+        (/ (floor (+ (* x f) 0.5)) f)))))
+
+(define min
+  (fn (a b) (if (< a b) a b)))
+
+(define max
+  (fn (a b) (if (> a b) a b)))
+
+(define clamp
+  (fn (x lo hi) (max lo (min hi x))))
+
+
+;; --------------------------------------------------------------------------
+;; Collection accessors
+;; --------------------------------------------------------------------------
+
+(define first
+  (fn (coll)
+    (if (and coll (> (len coll) 0)) (get coll 0) nil)))
+
+(define last
+  (fn (coll)
+    (if (and coll (> (len coll) 0))
+      (get coll (- (len coll) 1))
+      nil)))
+
+(define rest
+  (fn (coll) (if coll (slice coll 1) (list))))
+
+(define nth
+  (fn (coll n)
+    (if (and coll (>= n 0) (< n (len coll)))
+      (get coll n)
+      nil)))
+
+(define cons
+  (fn (x coll) (concat (list x) (or coll (list)))))
+
+(define append
+  (fn (coll x)
+    (if (list? x) (concat coll x) (concat coll (list x)))))
+
+
+;; --------------------------------------------------------------------------
+;; Collection transforms
+;; --------------------------------------------------------------------------
+
+(define reverse
+  (fn (coll)
+    (reduce (fn (acc x) (cons x acc)) (list) coll)))
+
+(define flatten
+  (fn (coll)
+    (reduce
+      (fn (acc x)
+        (if (list? x) (concat acc x) (concat acc (list x))))
+      (list) coll)))
+
+(define range
+  (fn (start end step)
+    (let ((s (if (nil? step) 1 step))
+          (result (list)))
+      (let loop ((i start))
+        (when (< i end)
+          (append! result i)
+          (loop (+ i s))))
+      result)))
+
+(define chunk-every
+  (fn (coll n)
+    (let ((result (list))
+          (clen (len coll)))
+      (let loop ((i 0))
+        (when (< i clen)
+          (append! result (slice coll i (min (+ i n) clen)))
+          (loop (+ i n))))
+      result)))
+
+(define zip-pairs
+  (fn (coll)
+    (let ((result (list))
+          (clen (len coll)))
+      (let loop ((i 0))
+        (when (< i (- clen 1))
+          (append! result (list (get coll i) (get coll (+ i 1))))
+          (loop (+ i 1))))
+      result)))
+
+
+;; --------------------------------------------------------------------------
+;; Dict operations
+;; --------------------------------------------------------------------------
+
+(define vals
+  (fn (d)
+    (map (fn (k) (get d k)) (keys d))))
+
+(define has-key?
+  (fn (d key)
+    (some (fn (k) (= k key)) (keys d))))
+
+(define assoc
+  (fn (d key val)
+    (let ((result (merge d (dict))))
+      (dict-set! result key val)
+      result)))
+
+(define dissoc
+  (fn (d key)
+    (let ((result (dict)))
+      (for-each
+        (fn (k)
+          (when (!= k key)
+            (dict-set! result k (get d k))))
+        (keys d))
+      result)))
+
+(define into
+  (fn (target coll)
+    (cond
+      (list? target)
+        (if (list? coll)
+          (concat coll (list))
+          (let ((result (list)))
+            (for-each (fn (k) (append! result (list k (get coll k)))) (keys coll))
+            result))
+      (dict? target)
+        (let ((result (dict)))
+          (for-each
+            (fn (pair)
+              (when (and (list? pair) (>= (len pair) 2))
+                (dict-set! result (get pair 0) (get pair 1))))
+            coll)
+          result)
+      :else target)))
+
+
+;; --------------------------------------------------------------------------
+;; String operations
+;; --------------------------------------------------------------------------
+
+(define upcase (fn (s) (upper s)))
+(define downcase (fn (s) (lower s)))
+(define string-length (fn (s) (len s)))
+(define substring (fn (s start end) (slice s start end)))
+
+(define string-contains?
+  (fn (s needle) (!= (index-of s needle) -1)))
+
+(define starts-with?
+  (fn (s prefix) (= (index-of s prefix) 0)))
+
+(define ends-with?
+  (fn (s suffix)
+    (let ((slen (len s))
+          (plen (len suffix)))
+      (if (< slen plen) false
+        (= (slice s (- slen plen)) suffix)))))
+
+;; split, join, replace stay as primitives — the stdlib versions cause
+;; stack overflows due to PRIMITIVES entry shadowing in the transpiled output.
+
+(define contains?
+  (fn (coll key)
+    (cond
+      (string? coll) (!= (index-of coll (str key)) -1)
+      (dict? coll) (has-key? coll key)
+      (list? coll) (some (fn (x) (= x key)) coll)
+      :else false)))
+
+
+;; --------------------------------------------------------------------------
+;; Text utilities
+;; --------------------------------------------------------------------------
+
+(define pluralize
+  (fn (count singular plural)
+    (if (= count 1)
+      (or singular "")
+      (or plural "s"))))
+
+(define escape
+  (fn (s)
+    (let ((r (str s)))
+      (set! r (replace r "&" "&amp;"))
+      (set! r (replace r "<" "&lt;"))
+      (set! r (replace r ">" "&gt;"))
+      (set! r (replace r "\"" "&quot;"))
+      (set! r (replace r "'" "&#x27;"))
+      r)))
+
+(define parse-datetime
+  (fn (s) (if s (str s) nil)))
+
+(define assert
+  (fn (condition message)
+    (when (not condition)
+      (error (or message "Assertion failed")))
+    true))

lib/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))))
+

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

lib/tests/test-signals-advanced.sx

@@ -0,0 +1,348 @@
+;; ==========================================================================
+;; test-signals-advanced.sx — Stress tests for the reactive signal system
+;;
+;; Requires: test-framework.sx loaded first.
+;; Modules tested: signals.sx (signal, deref, reset!, swap!, computed,
+;;                 effect, batch)
+;;
+;; Note: Multi-expression lambda bodies are wrapped in (do ...) for
+;; compatibility with evaluators that support only single-expression bodies.
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; Signal basics extended
+;; --------------------------------------------------------------------------
+
+(defsuite "signal-basics-extended"
+  (deftest "signal with nil initial value"
+    (let ((s (signal nil)))
+      (assert-true (signal? s))
+      (assert-nil (deref s))))
+
+  (deftest "signal with list value"
+    (let ((s (signal (list 1 2 3))))
+      (assert-equal (list 1 2 3) (deref s))
+      (reset! s (list 4 5 6))
+      (assert-equal (list 4 5 6) (deref s))))
+
+  (deftest "signal with dict value"
+    (let ((s (signal {:name "alice" :score 42})))
+      (assert-equal "alice" (get (deref s) "name"))
+      (assert-equal 42      (get (deref s) "score"))))
+
+  (deftest "signal with lambda value"
+    (let ((fn-val (fn (x) (* x 2)))
+          (s (signal nil)))
+      (reset! s fn-val)
+      ;; The stored lambda should be callable
+      (assert-equal 10 ((deref s) 5))))
+
+  (deftest "multiple signals independent of each other"
+    (let ((a (signal 1))
+          (b (signal 2))
+          (c (signal 3)))
+      (reset! a 10)
+      ;; b and c must be unchanged
+      (assert-equal 10 (deref a))
+      (assert-equal 2  (deref b))
+      (assert-equal 3  (deref c))
+      (reset! b 20)
+      (assert-equal 10 (deref a))
+      (assert-equal 20 (deref b))
+      (assert-equal 3  (deref c))))
+
+  (deftest "deref returns current value not a stale snapshot"
+    (let ((s (signal "first")))
+      (let ((snap1 (deref s)))
+        (reset! s "second")
+        (let ((snap2 (deref s)))
+          ;; snap1 holds the string "first" (immutable), snap2 is "second"
+          (assert-equal "first"  snap1)
+          (assert-equal "second" snap2))))))
+
+
+;; --------------------------------------------------------------------------
+;; Computed chains
+;; --------------------------------------------------------------------------
+
+(defsuite "computed-chains"
+  (deftest "chain of three computed signals"
+    (let ((base     (signal 2))
+          (doubled  (computed (fn () (* 2  (deref base)))))
+          (tripled  (computed (fn () (* 3  (deref doubled))))))
+      ;; Initial: base=2 → doubled=4 → tripled=12
+      (assert-equal 4  (deref doubled))
+      (assert-equal 12 (deref tripled))
+      ;; Update propagates through the entire chain
+      (reset! base 5)
+      (assert-equal 10 (deref doubled))
+      (assert-equal 30 (deref tripled))))
+
+  (deftest "computed depending on multiple signals"
+    (let ((x    (signal 3))
+          (y    (signal 4))
+          (hypo (computed (fn ()
+                  ;; sqrt(x^2 + y^2) — Pythagorean hypotenuse (integer approx)
+                  (+ (* (deref x) (deref x))
+                     (* (deref y) (deref y)))))))
+      (assert-equal 25 (deref hypo))
+      (reset! x 0)
+      (assert-equal 16 (deref hypo))
+      (reset! y 0)
+      (assert-equal 0  (deref hypo))))
+
+  (deftest "computed with conditional logic"
+    (let ((flag   (signal true))
+          (a      (signal 10))
+          (b      (signal 99))
+          (result (computed (fn ()
+                    (if (deref flag) (deref a) (deref b))))))
+      (assert-equal 10 (deref result))
+      (reset! flag false)
+      (assert-equal 99 (deref result))
+      (reset! b 42)
+      (assert-equal 42 (deref result))
+      (reset! flag true)
+      (assert-equal 10 (deref result))))
+
+  (deftest "diamond dependency: A->B, A->C, B+C->D"
+    ;; A change in A must propagate via both B and C to D,
+    ;; but D must still hold a coherent (not intermediate) value.
+    (let ((A (signal 1))
+          (B (computed (fn () (* 2 (deref A)))))
+          (C (computed (fn () (* 3 (deref A)))))
+          (D (computed (fn () (+ (deref B) (deref C))))))
+      ;; A=1 → B=2, C=3 → D=5
+      (assert-equal 2 (deref B))
+      (assert-equal 3 (deref C))
+      (assert-equal 5 (deref D))
+      ;; A=4 → B=8, C=12 → D=20
+      (reset! A 4)
+      (assert-equal 8  (deref B))
+      (assert-equal 12 (deref C))
+      (assert-equal 20 (deref D))))
+
+  (deftest "computed returns nil when source signal is nil"
+    (let ((s (signal nil))
+          (c (computed (fn ()
+                (let ((v (deref s)))
+                  (when (not (nil? v)) (* v 2)))))))
+      (assert-nil (deref c))
+      (reset! s 7)
+      (assert-equal 14 (deref c))
+      (reset! s nil)
+      (assert-nil (deref c)))))
+
+
+;; --------------------------------------------------------------------------
+;; Effect patterns
+;; --------------------------------------------------------------------------
+
+(defsuite "effect-patterns"
+  (deftest "effect runs immediately on creation"
+    (let ((ran (signal false)))
+      (effect (fn () (reset! ran true)))
+      (assert-true (deref ran))))
+
+  (deftest "effect re-runs when dependency changes"
+    (let ((n      (signal 0))
+          (calls  (signal 0)))
+      (effect (fn () (do (deref n) (swap! calls inc))))
+      ;; Initial run counts as 1
+      (assert-equal 1 (deref calls))
+      (reset! n 1)
+      (assert-equal 2 (deref calls))
+      (reset! n 2)
+      (assert-equal 3 (deref calls))))
+
+  (deftest "effect with multiple dependencies"
+    (let ((a     (signal "x"))
+          (b     (signal "y"))
+          (calls (signal 0)))
+      (effect (fn () (do (deref a) (deref b) (swap! calls inc))))
+      (assert-equal 1 (deref calls))
+      ;; Changing a triggers re-run
+      (reset! a "x2")
+      (assert-equal 2 (deref calls))
+      ;; Changing b also triggers re-run
+      (reset! b "y2")
+      (assert-equal 3 (deref calls))))
+
+  (deftest "effect cleanup function called on re-run"
+    (let ((trigger  (signal 0))
+          (cleanups (signal 0)))
+      (effect (fn () (do
+        (deref trigger)
+        ;; Return a cleanup function
+        (fn () (swap! cleanups inc)))))
+      ;; First run — no previous cleanup to call
+      (assert-equal 0 (deref cleanups))
+      ;; Second run — previous cleanup fires first
+      (reset! trigger 1)
+      (assert-equal 1 (deref cleanups))
+      ;; Third run — second cleanup fires
+      (reset! trigger 2)
+      (assert-equal 2 (deref cleanups))))
+
+  (deftest "effect tracks only actually-deref'd signals"
+    ;; An effect that conditionally reads signal B should only re-run
+    ;; for B changes when B is actually read (flag=true).
+    (let ((flag   (signal true))
+          (b      (signal 0))
+          (calls  (signal 0)))
+      (effect (fn () (do
+        (deref flag)
+        (when (deref flag) (deref b))
+        (swap! calls inc))))
+      ;; Initial run reads both flag and b
+      (assert-equal 1 (deref calls))
+      ;; flip flag to false — re-run, but now b is NOT deref'd
+      (reset! flag false)
+      (assert-equal 2 (deref calls))
+      ;; Changing b should NOT trigger another run (b wasn't deref'd last time)
+      (reset! b 99)
+      (assert-equal 2 (deref calls)))))
+
+
+;; --------------------------------------------------------------------------
+;; Batch behavior
+;; --------------------------------------------------------------------------
+
+(defsuite "batch-behavior"
+  (deftest "batch coalesces multiple signal updates into one effect run"
+    (let ((a        (signal 0))
+          (b        (signal 0))
+          (run-count (signal 0)))
+      (effect (fn () (do (deref a) (deref b) (swap! run-count inc))))
+      ;; Initial run
+      (assert-equal 1 (deref run-count))
+      ;; Two writes inside a single batch → one effect run, not two
+      (batch (fn () (do
+        (reset! a 1)
+        (reset! b 2))))
+      (assert-equal 2 (deref run-count))))
+
+  (deftest "nested batch — inner batch does not flush, outer batch does"
+    (let ((s        (signal 0))
+          (run-count (signal 0)))
+      (effect (fn () (do (deref s) (swap! run-count inc))))
+      (assert-equal 1 (deref run-count))
+      (batch (fn ()
+        (batch (fn ()
+          (reset! s 1)))
+        ;; Still inside outer batch — should not have fired yet
+        (reset! s 2)))
+      ;; Outer batch ends → exactly one more run
+      (assert-equal 2 (deref run-count))
+      ;; Final value is the last write
+      (assert-equal 2 (deref s))))
+
+  (deftest "batch with computed — computed updates once not per signal write"
+    (let ((x      (signal 0))
+          (y      (signal 0))
+          (sum    (computed (fn () (+ (deref x) (deref y)))))
+          (recomps (signal 0)))
+      ;; Track recomputations by wrapping via an effect
+      (effect (fn () (do (deref sum) (swap! recomps inc))))
+      ;; Initial: effect + computed both ran once
+      (assert-equal 1 (deref recomps))
+      (batch (fn () (do
+        (reset! x 10)
+        (reset! y 20))))
+      ;; sum must reflect both changes
+      (assert-equal 30 (deref sum))
+      ;; effect re-ran at most once more (not twice)
+      (assert-equal 2 (deref recomps))))
+
+  (deftest "batch executes the thunk"
+    ;; batch runs the thunk for side effects; return value is implementation-defined
+    (let ((s (signal 0)))
+      (batch (fn () (reset! s 42)))
+      (assert-equal 42 (deref s)))))
+
+
+;; --------------------------------------------------------------------------
+;; Swap patterns
+;; --------------------------------------------------------------------------
+
+(defsuite "swap-patterns"
+  (deftest "swap! with increment function"
+    (let ((n (signal 0)))
+      (swap! n inc)
+      (assert-equal 1 (deref n))
+      (swap! n inc)
+      (assert-equal 2 (deref n))))
+
+  (deftest "swap! with list append"
+    (let ((items (signal (list))))
+      (swap! items (fn (l) (append l "a")))
+      (swap! items (fn (l) (append l "b")))
+      (swap! items (fn (l) (append l "c")))
+      (assert-equal (list "a" "b" "c") (deref items))))
+
+  (deftest "swap! with dict assoc"
+    (let ((store (signal {})))
+      (swap! store (fn (d) (assoc d "x" 1)))
+      (swap! store (fn (d) (assoc d "y" 2)))
+      (assert-equal 1 (get (deref store) "x"))
+      (assert-equal 2 (get (deref store) "y"))))
+
+  (deftest "multiple swap! in sequence build up correct value"
+    (let ((acc (signal 0)))
+      (swap! acc + 10)
+      (swap! acc + 5)
+      (swap! acc - 3)
+      (assert-equal 12 (deref acc)))))
+
+
+;; --------------------------------------------------------------------------
+;; call-lambda + trampoline — event handler pattern
+;; --------------------------------------------------------------------------
+;;
+;; Regression: dom-on wraps Lambda event handlers in JS functions that
+;; call callLambda. callLambda returns a Thunk (TCO), but the wrapper
+;; never trampolined it, so the handler body (swap!, reset!, etc.)
+;; never executed. Buttons rendered but clicks had no effect.
+;;
+;; These tests verify the pattern that dom-on uses:
+;;   (trampoline (call-lambda handler (list arg)))
+;; must resolve thunks and execute side effects.
+
+(defsuite "call-lambda-trampoline-handlers"
+  (deftest "call-lambda + trampoline executes signal mutation"
+    (let ((count (signal 0))
+          (handler (fn () (swap! count + 1))))
+      (trampoline (call-lambda handler (list)))
+      (assert-equal 1 (deref count))))
+
+  (deftest "call-lambda + trampoline with event arg"
+    (let ((last-val (signal nil))
+          (handler (fn (e) (reset! last-val e))))
+      (trampoline (call-lambda handler (list "click-event")))
+      (assert-equal "click-event" (deref last-val))))
+
+  (deftest "call-lambda + trampoline executes multi-statement body"
+    (let ((a (signal 0))
+          (b (signal 0))
+          (handler (fn ()
+            (reset! a 10)
+            (reset! b 20))))
+      (trampoline (call-lambda handler (list)))
+      (assert-equal 10 (deref a))
+      (assert-equal 20 (deref b))))
+
+  (deftest "repeated call-lambda accumulates side effects"
+    (let ((count (signal 0))
+          (handler (fn () (swap! count + 1))))
+      (trampoline (call-lambda handler (list)))
+      (trampoline (call-lambda handler (list)))
+      (trampoline (call-lambda handler (list)))
+      (assert-equal 3 (deref count))))
+
+  (deftest "call-lambda handler calling another lambda"
+    (let ((log (signal (list)))
+          (inner (fn (msg) (reset! log (append (deref log) (list msg)))))
+          (outer (fn () (inner "hello") (inner "world"))))
+      (trampoline (call-lambda outer (list)))
+      (assert-equal (list "hello" "world") (deref log)))))

lib/tests/test-types.sx

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

lib/tests/test-vm-closures.sx

@@ -0,0 +1,244 @@
+;; ==========================================================================
+;; test-vm-closures.sx — Tests for inner closure recursion patterns
+;;
+;; Requires: test-framework.sx loaded first.
+;;
+;; These tests exercise patterns where inner closures recurse deeply
+;; while sharing mutable state via upvalues. This is the sx-parse
+;; pattern: many inner functions close over a mutable cursor variable.
+;; Without proper VM closure support, each recursive call would
+;; allocate a fresh VM — blowing the stack or hanging.
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; Inner closure recursion with mutable upvalues
+;; --------------------------------------------------------------------------
+
+(defsuite "inner-closure-recursion"
+  (deftest "self-recursive inner closure with set! on captured variable"
+    ;; Pattern: closure mutates captured var on each recursive call.
+    ;; This is the core pattern in skip-ws, read-str-loop, etc.
+    (let ((counter 0))
+      (define count-up
+        (fn (n)
+          (when (> n 0)
+            (set! counter (+ counter 1))
+            (count-up (- n 1)))))
+      (count-up 100)
+      (assert-equal 100 counter)))
+
+  (deftest "deep inner closure recursion (500 iterations)"
+    ;; Stress test: 500 recursive calls through an inner closure
+    ;; mutating a shared upvalue. Would stack-overflow without TCO.
+    (let ((acc 0))
+      (define sum-up
+        (fn (n)
+          (if (<= n 0)
+            acc
+            (do (set! acc (+ acc n))
+                (sum-up (- n 1))))))
+      (assert-equal 125250 (sum-up 500))))
+
+  (deftest "inner closure reading captured variable updated by another"
+    ;; Two closures: one writes, one reads, sharing the same binding.
+    (let ((pos 0))
+      (define advance! (fn () (set! pos (+ pos 1))))
+      (define current  (fn () pos))
+      (advance!)
+      (advance!)
+      (advance!)
+      (assert-equal 3 (current))))
+
+  (deftest "recursive closure with multiple mutable upvalues"
+    ;; Like sx-parse: multiple cursor variables mutated during recursion.
+    (let ((pos 0)
+          (count 0))
+      (define scan
+        (fn (source)
+          (when (< pos (len source))
+            (set! count (+ count 1))
+            (set! pos (+ pos 1))
+            (scan source))))
+      (scan "hello world")
+      (assert-equal 11 pos)
+      (assert-equal 11 count))))
+
+
+;; --------------------------------------------------------------------------
+;; Mutual recursion between inner closures
+;; --------------------------------------------------------------------------
+
+(defsuite "mutual-inner-closures"
+  (deftest "two inner closures calling each other"
+    ;; Pattern: read-expr calls read-list, read-list calls read-expr.
+    (let ((result (list)))
+      (define process-a
+        (fn (items)
+          (when (not (empty? items))
+            (append! result (str "a:" (first items)))
+            (process-b (rest items)))))
+      (define process-b
+        (fn (items)
+          (when (not (empty? items))
+            (append! result (str "b:" (first items)))
+            (process-a (rest items)))))
+      (process-a (list 1 2 3 4))
+      (assert-equal 4 (len result))
+      (assert-equal "a:1" (nth result 0))
+      (assert-equal "b:2" (nth result 1))
+      (assert-equal "a:3" (nth result 2))
+      (assert-equal "b:4" (nth result 3))))
+
+  (deftest "mutual recursion with shared mutable state"
+    ;; Both closures read and write the same captured variable.
+    (let ((pos 0)
+          (source "aAbBcC"))
+      (define skip-lower
+        (fn ()
+          (when (and (< pos (len source))
+                     (>= (nth source pos) "a")
+                     (<= (nth source pos) "z"))
+            (set! pos (+ pos 1))
+            (skip-upper))))
+      (define skip-upper
+        (fn ()
+          (when (and (< pos (len source))
+                     (>= (nth source pos) "A")
+                     (<= (nth source pos) "Z"))
+            (set! pos (+ pos 1))
+            (skip-lower))))
+      (skip-lower)
+      (assert-equal 6 pos)))
+
+  (deftest "three-way mutual recursion"
+    (let ((n 30)
+          (result nil))
+      (define step-a
+        (fn (i)
+          (if (>= i n)
+            (set! result "done")
+            (step-b (+ i 1)))))
+      (define step-b
+        (fn (i)
+          (step-c (+ i 1))))
+      (define step-c
+        (fn (i)
+          (step-a (+ i 1))))
+      (step-a 0)
+      (assert-equal "done" result))))
+
+
+;; --------------------------------------------------------------------------
+;; Parser-like patterns (the sx-parse structure)
+;; --------------------------------------------------------------------------
+
+(defsuite "parser-pattern"
+  (deftest "mini-parser: tokenize digits from string"
+    ;; Simplified sx-parse pattern: closure over pos + source,
+    ;; multiple inner functions sharing the mutable cursor.
+    (let ((pos 0)
+          (source "12 34 56")
+          (len-src 8))
+
+      (define skip-ws
+        (fn ()
+          (when (and (< pos len-src) (= (nth source pos) " "))
+            (set! pos (+ pos 1))
+            (skip-ws))))
+
+      (define read-digits
+        (fn ()
+          (let ((start pos))
+            (define digit-loop
+              (fn ()
+                (when (and (< pos len-src)
+                           (>= (nth source pos) "0")
+                           (<= (nth source pos) "9"))
+                  (set! pos (+ pos 1))
+                  (digit-loop))))
+            (digit-loop)
+            (slice source start pos))))
+
+      (define read-all
+        (fn ()
+          (let ((tokens (list)))
+            (define parse-loop
+              (fn ()
+                (skip-ws)
+                (when (< pos len-src)
+                  (append! tokens (read-digits))
+                  (parse-loop))))
+            (parse-loop)
+            tokens)))
+
+      (let ((tokens (read-all)))
+        (assert-equal 3 (len tokens))
+        (assert-equal "12" (nth tokens 0))
+        (assert-equal "34" (nth tokens 1))
+        (assert-equal "56" (nth tokens 2)))))
+
+  (deftest "nested inner closures with upvalue chain"
+    ;; Inner function defines its own inner function,
+    ;; both closing over the outer mutable variable.
+    (let ((total 0))
+      (define outer-fn
+        (fn (items)
+          (for-each
+            (fn (item)
+              (let ((sub-total 0))
+                (define inner-loop
+                  (fn (n)
+                    (when (> n 0)
+                      (set! sub-total (+ sub-total 1))
+                      (set! total (+ total 1))
+                      (inner-loop (- n 1)))))
+                (inner-loop item)))
+            items)))
+      (outer-fn (list 3 2 1))
+      (assert-equal 6 total)))
+
+  (deftest "closure returning accumulated list via append!"
+    ;; Pattern from read-list: loop appends to mutable list, returns it.
+    (let ((items (list)))
+      (define collect
+        (fn (source pos)
+          (if (>= pos (len source))
+            items
+            (do (append! items (nth source pos))
+                (collect source (+ pos 1))))))
+      (let ((result (collect (list "a" "b" "c" "d") 0)))
+        (assert-equal 4 (len result))
+        (assert-equal "a" (first result))
+        (assert-equal "d" (last result))))))
+
+
+;; --------------------------------------------------------------------------
+;; Closures as callbacks to higher-order functions
+;; --------------------------------------------------------------------------
+
+(defsuite "closure-ho-callbacks"
+  (deftest "map with closure that mutates captured variable"
+    (let ((running-total 0))
+      (let ((results (map (fn (x)
+                            (set! running-total (+ running-total x))
+                            running-total)
+                          (list 1 2 3 4))))
+        (assert-equal (list 1 3 6 10) results)
+        (assert-equal 10 running-total))))
+
+  (deftest "reduce with closure over external state"
+    (let ((call-count 0))
+      (let ((sum (reduce (fn (acc x)
+                           (set! call-count (+ call-count 1))
+                           (+ acc x))
+                         0
+                         (list 10 20 30))))
+        (assert-equal 60 sum)
+        (assert-equal 3 call-count))))
+
+  (deftest "filter with closure reading shared state"
+    (let ((threshold 3))
+      (let ((result (filter (fn (x) (> x threshold))
+                            (list 1 2 3 4 5))))
+        (assert-equal (list 4 5) result)))))

lib/tests/test-vm.sx

@@ -0,0 +1,495 @@
+;; ==========================================================================
+;; test-vm.sx — Tests for the bytecode VM (spec/vm.sx)
+;;
+;; Requires: test-framework.sx, compiler.sx, vm.sx loaded.
+;; Tests the compile → bytecode → VM execution pipeline.
+;; ==========================================================================
+
+
+;; Helper: compile an SX expression and execute it on the VM.
+;; Returns the result value.
+(define vm-eval
+  (fn (expr)
+    (let ((code (compile expr)))
+      (vm-execute-module
+        (code-from-value code)
+        {}))))
+
+;; Helper: compile and run with a pre-populated globals dict.
+(define vm-eval-with
+  (fn (expr globals)
+    (let ((code (compile expr)))
+      (vm-execute-module (code-from-value code) globals))))
+
+
+;; --------------------------------------------------------------------------
+;; Constants and literals
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-constants"
+  (deftest "number constant"
+    (assert-equal 42 (vm-eval 42)))
+
+  (deftest "string constant"
+    (assert-equal "hello" (vm-eval "hello")))
+
+  (deftest "boolean true"
+    (assert-equal true (vm-eval true)))
+
+  (deftest "boolean false"
+    (assert-equal false (vm-eval false)))
+
+  (deftest "nil constant"
+    (assert-nil (vm-eval nil)))
+
+  (deftest "negative number"
+    (assert-equal -7 (vm-eval -7)))
+
+  (deftest "float constant"
+    (assert-equal 3.14 (vm-eval 3.14))))
+
+
+;; --------------------------------------------------------------------------
+;; Arithmetic via primitives
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-arithmetic"
+  (deftest "addition"
+    (assert-equal 5 (vm-eval '(+ 2 3))))
+
+  (deftest "subtraction"
+    (assert-equal 7 (vm-eval '(- 10 3))))
+
+  (deftest "multiplication"
+    (assert-equal 24 (vm-eval '(* 6 4))))
+
+  (deftest "division"
+    (assert-equal 5 (vm-eval '(/ 10 2))))
+
+  (deftest "nested arithmetic"
+    (assert-equal 14 (vm-eval '(+ (* 3 4) 2))))
+
+  (deftest "three-arg addition"
+    (assert-equal 15 (vm-eval '(+ 5 4 6)))))
+
+
+;; --------------------------------------------------------------------------
+;; Comparison and logic
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-comparison"
+  (deftest "equal numbers"
+    (assert-equal true (vm-eval '(= 1 1))))
+
+  (deftest "unequal numbers"
+    (assert-equal false (vm-eval '(= 1 2))))
+
+  (deftest "less than"
+    (assert-equal true (vm-eval '(< 1 2))))
+
+  (deftest "greater than"
+    (assert-equal true (vm-eval '(> 5 3))))
+
+  (deftest "not"
+    (assert-equal true (vm-eval '(not false))))
+
+  (deftest "not truthy"
+    (assert-equal false (vm-eval '(not 42)))))
+
+
+;; --------------------------------------------------------------------------
+;; Control flow — if, when, cond, and, or
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-control-flow"
+  (deftest "if true branch"
+    (assert-equal 1 (vm-eval '(if true 1 2))))
+
+  (deftest "if false branch"
+    (assert-equal 2 (vm-eval '(if false 1 2))))
+
+  (deftest "if without else returns nil"
+    (assert-nil (vm-eval '(if false 1))))
+
+  (deftest "when true evaluates body"
+    (assert-equal 42 (vm-eval '(when true 42))))
+
+  (deftest "when false returns nil"
+    (assert-nil (vm-eval '(when false 42))))
+
+  (deftest "and short-circuits on false"
+    (assert-equal false (vm-eval '(and true false 42))))
+
+  (deftest "and returns last truthy"
+    (assert-equal 3 (vm-eval '(and 1 2 3))))
+
+  (deftest "or short-circuits on true"
+    (assert-equal 1 (vm-eval '(or 1 false 2))))
+
+  (deftest "or returns false when all falsy"
+    (assert-equal false (vm-eval '(or false false false))))
+
+  (deftest "cond first match"
+    (assert-equal "one" (vm-eval '(cond (= 1 1) "one" (= 2 2) "two"))))
+
+  (deftest "cond else clause"
+    (assert-equal "none" (vm-eval '(cond (= 1 2) "one" :else "none"))))
+
+  (deftest "case match"
+    (assert-equal "two" (vm-eval '(case 2 1 "one" 2 "two" :else "other"))))
+
+  (deftest "case else"
+    (assert-equal "other" (vm-eval '(case 99 1 "one" 2 "two" :else "other")))))
+
+
+;; --------------------------------------------------------------------------
+;; Let bindings
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-let"
+  (deftest "single binding"
+    (assert-equal 10 (vm-eval '(let ((x 10)) x))))
+
+  (deftest "multiple bindings"
+    (assert-equal 30 (vm-eval '(let ((x 10) (y 20)) (+ x y)))))
+
+  (deftest "bindings are sequential"
+    (assert-equal 11 (vm-eval '(let ((x 10) (y (+ x 1))) y))))
+
+  (deftest "nested let"
+    (assert-equal 3 (vm-eval '(let ((x 1)) (let ((y 2)) (+ x y))))))
+
+  (deftest "inner let shadows outer"
+    (assert-equal 99 (vm-eval '(let ((x 1)) (let ((x 99)) x)))))
+
+  (deftest "let body returns last expression"
+    (assert-equal 3 (vm-eval '(let ((x 1)) 1 2 3)))))
+
+
+;; --------------------------------------------------------------------------
+;; Lambda and function calls
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-lambda"
+  (deftest "lambda call"
+    (assert-equal 7 (vm-eval '(let ((f (fn (x) (+ x 2)))) (f 5)))))
+
+  (deftest "lambda with multiple params"
+    (assert-equal 11 (vm-eval '(let ((add (fn (a b) (+ a b)))) (add 5 6)))))
+
+  (deftest "higher-order: pass lambda to lambda"
+    (assert-equal 10
+      (vm-eval '(let ((apply-fn (fn (f x) (f x)))
+                      (double (fn (n) (* n 2))))
+                  (apply-fn double 5)))))
+
+  (deftest "lambda returns lambda"
+    (assert-equal 15
+      (vm-eval '(let ((make-adder (fn (n) (fn (x) (+ n x)))))
+                  (let ((add10 (make-adder 10)))
+                    (add10 5))))))
+
+  (deftest "immediately invoked lambda"
+    (assert-equal 42 (vm-eval '((fn (x) (* x 2)) 21)))))
+
+
+;; --------------------------------------------------------------------------
+;; Closures and upvalues
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-closures"
+  (deftest "closure captures local"
+    (assert-equal 10
+      (vm-eval '(let ((x 10))
+                  (let ((f (fn () x)))
+                    (f))))))
+
+  (deftest "closure captures through two levels"
+    (assert-equal 30
+      (vm-eval '(let ((x 10))
+                  (let ((y 20))
+                    (let ((f (fn () (+ x y))))
+                      (f)))))))
+
+  (deftest "two closures share upvalue"
+    (assert-equal 42
+      (vm-eval '(let ((x 0))
+                  (let ((set-x (fn (v) (set! x v)))
+                        (get-x (fn () x)))
+                    (set-x 42)
+                    (get-x))))))
+
+  (deftest "closure mutation visible to sibling"
+    (assert-equal 3
+      (vm-eval '(let ((counter 0))
+                  (let ((inc! (fn () (set! counter (+ counter 1)))))
+                    (inc!)
+                    (inc!)
+                    (inc!)
+                    counter))))))
+
+
+;; --------------------------------------------------------------------------
+;; Tail call optimization
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-tco"
+  (deftest "tail-recursive loop doesn't overflow"
+    ;; Count down from 10000 — would overflow without TCO
+    (assert-equal 0
+      (vm-eval '(let ((loop (fn (n)
+                              (if (<= n 0) 0
+                                (loop (- n 1))))))
+                  (loop 10000)))))
+
+  (deftest "tail-recursive accumulator"
+    (assert-equal 5050
+      (vm-eval '(let ((sum (fn (n acc)
+                             (if (<= n 0) acc
+                               (sum (- n 1) (+ acc n))))))
+                  (sum 100 0))))))
+
+
+;; --------------------------------------------------------------------------
+;; Collections
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-collections"
+  (deftest "list construction"
+    (assert-equal (list 1 2 3) (vm-eval '(list 1 2 3))))
+
+  (deftest "empty list"
+    (assert-equal (list) (vm-eval '(list))))
+
+  (deftest "dict construction"
+    (let ((d (vm-eval '{:a 1 :b 2})))
+      (assert-equal 1 (get d "a"))
+      (assert-equal 2 (get d "b"))))
+
+  (deftest "list operations"
+    (assert-equal 1 (vm-eval '(first (list 1 2 3))))
+    (assert-equal 3 (vm-eval '(len (list 1 2 3)))))
+
+  (deftest "nested list"
+    (assert-equal (list 1 (list 2 3))
+      (vm-eval '(list 1 (list 2 3))))))
+
+
+;; --------------------------------------------------------------------------
+;; String operations
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-strings"
+  (deftest "str concat"
+    (assert-equal "hello world" (vm-eval '(str "hello" " " "world"))))
+
+  (deftest "string-length"
+    (assert-equal 5 (vm-eval '(string-length "hello"))))
+
+  (deftest "str coerces numbers"
+    (assert-equal "42" (vm-eval '(str 42)))))
+
+
+;; --------------------------------------------------------------------------
+;; Define — top-level and local
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-define"
+  (deftest "top-level define"
+    (assert-equal 42
+      (vm-eval '(do (define x 42) x))))
+
+  (deftest "define function then call"
+    (assert-equal 10
+      (vm-eval '(do
+                  (define double (fn (n) (* n 2)))
+                  (double 5)))))
+
+  (deftest "local define inside fn"
+    (assert-equal 30
+      (vm-eval '(let ((f (fn (x)
+                           (define y (* x 2))
+                           (+ x y))))
+                  (f 10)))))
+
+  (deftest "define with forward reference"
+    (assert-equal 120
+      (vm-eval '(do
+                  (define fact (fn (n)
+                    (if (<= n 1) 1 (* n (fact (- n 1))))))
+                  (fact 5))))))
+
+
+;; --------------------------------------------------------------------------
+;; Letrec — mutual recursion
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-letrec"
+  (deftest "letrec self-recursion"
+    (assert-equal 55
+      (vm-eval '(letrec ((sum-to (fn (n)
+                                   (if (<= n 0) 0
+                                     (+ n (sum-to (- n 1)))))))
+                  (sum-to 10)))))
+
+  (deftest "letrec mutual recursion"
+    (assert-equal true
+      (vm-eval '(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))))))
+                  (my-even? 10))))))
+
+
+;; --------------------------------------------------------------------------
+;; Quasiquote
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-quasiquote"
+  (deftest "simple quasiquote"
+    (assert-equal (list 1 2 3)
+      (vm-eval '(let ((x 2)) `(1 ,x 3)))))
+
+  (deftest "quasiquote with splice"
+    (assert-equal (list 1 2 3 4)
+      (vm-eval '(let ((xs (list 2 3))) `(1 ,@xs 4))))))
+
+
+;; --------------------------------------------------------------------------
+;; Thread macro
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-threading"
+  (deftest "thread-first"
+    (assert-equal 7
+      (vm-eval '(-> 5 (+ 2)))))
+
+  (deftest "thread-first chain"
+    (assert-equal 12
+      (vm-eval '(-> 10 (+ 5) (- 3))))))
+
+
+;; --------------------------------------------------------------------------
+;; Integration: compile then execute
+;; --------------------------------------------------------------------------
+
+(defsuite "vm-integration"
+  (deftest "fibonacci"
+    (assert-equal 55
+      (vm-eval '(do
+                  (define fib (fn (n)
+                    (if (<= n 1) n
+                      (+ (fib (- n 1)) (fib (- n 2))))))
+                  (fib 10)))))
+
+  (deftest "map via recursive define"
+    (assert-equal (list 2 4 6)
+      (vm-eval '(do
+                  (define my-map (fn (f lst)
+                    (if (empty? lst) (list)
+                      (cons (f (first lst)) (my-map f (rest lst))))))
+                  (my-map (fn (x) (* x 2)) (list 1 2 3))))))
+
+  (deftest "filter via recursive define"
+    (assert-equal (list 2 4)
+      (vm-eval '(do
+                  (define my-filter (fn (pred lst)
+                    (if (empty? lst) (list)
+                      (if (pred (first lst))
+                        (cons (first lst) (my-filter pred (rest lst)))
+                        (my-filter pred (rest lst))))))
+                  (my-filter (fn (x) (even? x)) (list 1 2 3 4 5))))))
+
+  (deftest "reduce via recursive define"
+    (assert-equal 15
+      (vm-eval '(do
+                  (define my-reduce (fn (f acc lst)
+                    (if (empty? lst) acc
+                      (my-reduce f (f acc (first lst)) (rest lst)))))
+                  (my-reduce (fn (acc x) (+ acc x)) 0 (list 1 2 3 4 5))))))
+
+  (deftest "nested function calls"
+    (assert-equal 42
+      (vm-eval '(do
+                  (define compose (fn (f g) (fn (x) (f (g x)))))
+                  (define inc (fn (x) (+ x 1)))
+                  (define double (fn (x) (* x 2)))
+                  (let ((inc-then-double (compose double inc)))
+                    (inc-then-double 20)))))))
+
+;; --------------------------------------------------------------------------
+;; VM recursive mutation — closure capture must preserve mutable references
+;; --------------------------------------------------------------------------
+;;
+;; Regression: recursive functions that append! to a shared mutable list
+;; lost mutations after the first call under JIT.  The stepper island's
+;; split-tag function produced 1 step instead of 16, breaking SSR.
+
+(defsuite "vm-recursive-mutation"
+  (deftest "recursive append! to shared list"
+    (assert-equal 3
+      (vm-eval '(do
+        (define walk (fn (items result)
+          (when (not (empty? items))
+            (append! result (first items))
+            (walk (rest items) result))))
+        (let ((result (list)))
+          (walk (list "a" "b" "c") result)
+          (len result))))))
+
+  (deftest "recursive tree walk with append!"
+    (assert-equal 7
+      (vm-eval '(do
+        (define walk-children (fn (items result walk-fn)
+          (when (not (empty? items))
+            (walk-fn (first items) result)
+            (walk-children (rest items) result walk-fn))))
+        (define walk (fn (expr result)
+          (cond
+            (not (list? expr))
+              (append! result "leaf")
+            (empty? expr) nil
+            :else
+              (do (append! result "open")
+                  (walk-children (rest expr) result walk)
+                  (append! result "close")))))
+        (let ((tree (first (sx-parse "(div \"a\" (span \"b\") \"c\")")))
+              (result (list)))
+          (walk tree result)
+          (len result))))))
+
+  (deftest "recursive walk matching stepper split-tag pattern"
+    (assert-equal 16
+      (vm-eval '(do
+        (define walk-each (fn (items result walk-fn)
+          (when (not (empty? items))
+            (walk-fn (first items) result)
+            (walk-each (rest items) result walk-fn))))
+        (define collect-children (fn (items cch)
+          (when (not (empty? items))
+            (let ((a (first items)))
+              (if (and (list? a) (not (empty? a))
+                       (= (type-of (first a)) "symbol")
+                       (starts-with? (symbol-name (first a)) "~"))
+                nil  ;; skip component spreads
+                (append! cch a))
+              (collect-children (rest items) cch)))))
+        (define split-tag (fn (expr result)
+          (cond
+            (not (list? expr))
+              (append! result "leaf")
+            (empty? expr) nil
+            (not (= (type-of (first expr)) "symbol"))
+              (append! result "leaf")
+            (is-html-tag? (symbol-name (first expr)))
+              (let ((cch (list)))
+                (collect-children (rest expr) cch)
+                (append! result "open")
+                (walk-each cch result split-tag)
+                (append! result "close"))
+            :else
+              (append! result "expr"))))
+        (let ((parsed (sx-parse "(div (~cssx/tw :tokens \"text-center\")\n  (h1 (~cssx/tw :tokens \"text-3xl font-bold mb-2\")\n    (span (~cssx/tw :tokens \"text-rose-500\") \"the \")\n    (span (~cssx/tw :tokens \"text-amber-500\") \"joy \")\n    (span (~cssx/tw :tokens \"text-emerald-500\") \"of \")\n    (span (~cssx/tw :tokens \"text-violet-600 text-4xl\") \"sx\")))"))
+              (result (list)))
+          (split-tag (first parsed) result)
+          (len result)))))))

lib/tests/vm-inline.sx

@@ -0,0 +1,117 @@
+;; vm-inline.sx — Tests for inline VM opcodes (OP_ADD, OP_EQ, etc.)
+;;
+;; These verify that the JIT-compiled inline opcodes produce
+;; identical results to the CALL_PRIM fallback.
+
+;; --------------------------------------------------------------------------
+;; Arithmetic
+;; --------------------------------------------------------------------------
+
+(test "inline + integers" (= (+ 3 4) 7))
+(test "inline + floats" (= (+ 1.5 2.5) 4.0))
+(test "inline + string concat" (= (+ "hello" " world") "hello world"))
+(test "inline - integers" (= (- 10 3) 7))
+(test "inline - negative" (= (- 3 10) -7))
+(test "inline * integers" (= (* 6 7) 42))
+(test "inline * float" (= (* 2.5 4.0) 10.0))
+(test "inline / integers" (= (/ 10 2) 5))
+(test "inline / float" (= (/ 7.0 2.0) 3.5))
+(test "inline inc" (= (inc 5) 6))
+(test "inline dec" (= (dec 5) 4))
+(test "inline inc float" (= (inc 2.5) 3.5))
+(test "inline dec zero" (= (dec 0) -1))
+
+;; --------------------------------------------------------------------------
+;; Comparison
+;; --------------------------------------------------------------------------
+
+(test "inline = numbers" (= 5 5))
+(test "inline = strings" (= "hello" "hello"))
+(test "inline = false" (not (= 5 6)))
+(test "inline = nil" (= nil nil))
+(test "inline = mixed false" (not (= 5 "5")))
+(test "inline < numbers" (< 3 5))
+(test "inline < false" (not (< 5 3)))
+(test "inline < equal" (not (< 5 5)))
+(test "inline < strings" (< "abc" "def"))
+(test "inline > numbers" (> 5 3))
+(test "inline > false" (not (> 3 5)))
+(test "inline > equal" (not (> 5 5)))
+(test "inline not true" (= (not true) false))
+(test "inline not false" (= (not false) true))
+(test "inline not nil" (= (not nil) true))
+(test "inline not number" (= (not 0) true))
+(test "inline not string" (= (not "") true))
+(test "inline not nonempty" (= (not "x") false))
+
+;; --------------------------------------------------------------------------
+;; Collection ops
+;; --------------------------------------------------------------------------
+
+(test "inline len list" (= (len (list 1 2 3)) 3))
+(test "inline len string" (= (len "hello") 5))
+(test "inline len empty" (= (len (list)) 0))
+(test "inline len nil" (= (len nil) 0))
+(test "inline first" (= (first (list 10 20 30)) 10))
+(test "inline first empty" (= (first (list)) nil))
+(test "inline rest" (= (rest (list 1 2 3)) (list 2 3)))
+(test "inline rest single" (= (rest (list 1)) (list)))
+(test "inline nth" (= (nth (list 10 20 30) 1) 20))
+(test "inline nth zero" (= (nth (list 10 20 30) 0) 10))
+(test "inline nth out of bounds" (= (nth (list 1 2) 5) nil))
+(test "inline cons" (= (cons 1 (list 2 3)) (list 1 2 3)))
+(test "inline cons to empty" (= (cons 1 (list)) (list 1)))
+(test "inline cons to nil" (= (cons 1 nil) (list 1)))
+
+;; --------------------------------------------------------------------------
+;; Composition — inline ops in expressions
+;; --------------------------------------------------------------------------
+
+(test "nested arithmetic" (= (+ (* 3 4) (- 10 5)) 17))
+(test "comparison in if" (if (< 3 5) "yes" "no") (= "yes"))
+(test "len in condition" (if (> (len (list 1 2 3)) 2) true false))
+(test "inc in loop" (= (let ((x 0)) (for-each (fn (_) (set! x (inc x))) (list 1 2 3)) x) 3))
+(test "first + rest roundtrip" (= (cons (first (list 1 2 3)) (rest (list 1 2 3))) (list 1 2 3)))
+(test "nested comparison" (= (and (< 1 2) (> 3 0) (= 5 5)) true))
+
+;; --------------------------------------------------------------------------
+;; Edge cases
+;; --------------------------------------------------------------------------
+
+(test "+ with nil" (= (+ 5 nil) 5))
+(test "len of dict" (= (len {:a 1 :b 2}) 2))
+(test "= with booleans" (= (= true true) true))
+(test "= with keywords" (= (= :foo :foo) true))
+(test "not with list" (= (not (list 1)) false))
+
+;; --------------------------------------------------------------------------
+;; Recursive mutation — VM closure capture must preserve mutable state
+;; --------------------------------------------------------------------------
+;;
+;; Regression: recursive functions that append! to a shared mutable list
+;; lost mutations after the first call under JIT.  The VM closure capture
+;; was copying the list value instead of sharing the mutable reference.
+
+(test "recursive append! to shared list"
+  (let ((walk (fn (items result)
+          (when (not (empty? items))
+            (append! result (first items))
+            (walk (rest items) result)))))
+    (let ((result (list)))
+      (walk (list "a" "b" "c") result)
+      (= (len result) 3))))
+
+(test "recursive tree walk with append!"
+  (let ((walk (fn (expr result)
+          (cond
+            (not (list? expr))
+              (append! result "leaf")
+            (empty? expr) nil
+            :else
+              (do (append! result "open")
+                  (for-each (fn (c) (walk c result)) (rest expr))
+                  (append! result "close"))))))
+    (let ((tree (first (sx-parse "(div \"a\" (span \"b\") \"c\")")))
+          (result (list)))
+      (walk tree result)
+      (= (len result) 7))))

lib/types.sx

@@ -4,10 +4,13 @@
 ;; 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)
+;; This is an optional spec module — NOT part of the core evaluator.
+;; It registers deftype and defeffect via register-special-form! at load time.
+;;
+;; Depends on: evaluator.sx (type-of, component accessors, env ops)
 ;;             primitives.sx, boundary.sx (return type declarations)
 ;;
-;; Platform interface (from eval.sx, already provided):
+;; Platform interface (from evaluator.sx, already provided):
 ;;   (type-of x)            → type string
 ;;   (symbol-name s)        → string
 ;;   (keyword-name k)       → string
@@ -22,6 +25,13 @@
 ;; ==========================================================================
 
 
+;; --------------------------------------------------------------------------
+;; NOTE: deftype and defeffect definition forms have moved to web/web-forms.sx
+;; (alongside defhandler, defpage, etc.) — they are domain forms, not core.
+;; The type system below uses them but does not define them.
+;; --------------------------------------------------------------------------
+
+
 ;; --------------------------------------------------------------------------
 ;; 1. Type representation
 ;; --------------------------------------------------------------------------

lib/vm.sx

@@ -0,0 +1,633 @@
+;; ==========================================================================
+;; vm.sx — SX bytecode virtual machine
+;;
+;; Stack-based interpreter for bytecode produced by compiler.sx.
+;; Written in SX — transpiled to each target (OCaml, JS, WASM).
+;;
+;; Architecture:
+;;   - Array-based value stack (no allocation per step)
+;;   - Frame list for call stack (one frame per function invocation)
+;;   - Upvalue cells for shared mutable closure variables
+;;   - Iterative dispatch loop (no host-stack growth)
+;;   - TCO via frame replacement on OP_TAIL_CALL
+;;
+;; Platform interface:
+;;   The host must provide:
+;;     - make-vm-stack, vm-stack-get, vm-stack-set!, vm-stack-grow
+;;     - cek-call (fallback for Lambda/Component)
+;;     - get-primitive (primitive lookup)
+;;   Everything else is defined here.
+;; ==========================================================================
+
+
+;; --------------------------------------------------------------------------
+;; 1. Types — VM data structures
+;; --------------------------------------------------------------------------
+
+;; Upvalue cell — shared mutable reference for captured variables.
+;; When a closure captures a local, both the parent frame and the
+;; closure read/write through this cell.
+(define make-upvalue-cell
+  (fn (value)
+    {:uv-value value}))
+
+(define uv-get (fn (cell) (get cell "uv-value")))
+(define uv-set! (fn (cell value) (dict-set! cell "uv-value" value)))
+
+;; VM code object — compiled bytecode + constant pool.
+;; Produced by compiler.sx, consumed by the VM.
+(define make-vm-code
+  (fn (arity locals bytecode constants)
+    {:vc-arity arity
+     :vc-locals locals
+     :vc-bytecode bytecode
+     :vc-constants constants}))
+
+;; VM closure — code + captured upvalues + globals reference.
+(define make-vm-closure
+  (fn (code upvalues name globals closure-env)
+    {:vm-code code
+     :vm-upvalues upvalues
+     :vm-name name
+     :vm-globals globals
+     :vm-closure-env closure-env}))
+
+;; VM frame — one per active function invocation.
+(define make-vm-frame
+  (fn (closure base)
+    {:closure closure
+     :ip 0
+     :base base
+     :local-cells {}}))
+
+;; VM state — the virtual machine.
+(define make-vm
+  (fn (globals)
+    {:stack (make-vm-stack 4096)
+     :sp 0
+     :frames (list)
+     :globals globals}))
+
+
+;; --------------------------------------------------------------------------
+;; 2. Stack operations
+;; --------------------------------------------------------------------------
+
+(define vm-push
+  (fn (vm value)
+    (let ((sp (get vm "sp"))
+          (stack (get vm "stack")))
+      ;; Grow stack if needed
+      (when (>= sp (vm-stack-length stack))
+        (let ((new-stack (make-vm-stack (* sp 2))))
+          (vm-stack-copy! stack new-stack sp)
+          (dict-set! vm "stack" new-stack)
+          (set! stack new-stack)))
+      (vm-stack-set! stack sp value)
+      (dict-set! vm "sp" (+ sp 1)))))
+
+(define vm-pop
+  (fn (vm)
+    (let ((sp (- (get vm "sp") 1)))
+      (dict-set! vm "sp" sp)
+      (vm-stack-get (get vm "stack") sp))))
+
+(define vm-peek
+  (fn (vm)
+    (vm-stack-get (get vm "stack") (- (get vm "sp") 1))))
+
+
+;; --------------------------------------------------------------------------
+;; 3. Operand reading — read from bytecode stream
+;; --------------------------------------------------------------------------
+
+(define frame-read-u8
+  (fn (frame)
+    (let ((ip (get frame "ip"))
+          (bc (get (get (get frame "closure") "vm-code") "vc-bytecode")))
+      (let ((v (nth bc ip)))
+        (dict-set! frame "ip" (+ ip 1))
+        v))))
+
+(define frame-read-u16
+  (fn (frame)
+    (let ((lo (frame-read-u8 frame))
+          (hi (frame-read-u8 frame)))
+      (+ lo (* hi 256)))))
+
+(define frame-read-i16
+  (fn (frame)
+    (let ((v (frame-read-u16 frame)))
+      (if (>= v 32768) (- v 65536) v))))
+
+
+;; --------------------------------------------------------------------------
+;; 4. Frame management
+;; --------------------------------------------------------------------------
+
+;; Push a closure frame onto the VM.
+;; Lays out args as locals, pads remaining locals with nil.
+(define vm-push-frame
+  (fn (vm closure args)
+    (let ((frame (make-vm-frame closure (get vm "sp"))))
+      (for-each (fn (a) (vm-push vm a)) args)
+      ;; Pad remaining local slots with nil
+      (let ((arity (len args))
+            (total-locals (get (get closure "vm-code") "vc-locals")))
+        (let ((pad-count (- total-locals arity)))
+          (when (> pad-count 0)
+            (let ((i 0))
+              (define pad-loop
+                (fn ()
+                  (when (< i pad-count)
+                    (vm-push vm nil)
+                    (set! i (+ i 1))
+                    (pad-loop))))
+              (pad-loop)))))
+      (dict-set! vm "frames" (cons frame (get vm "frames"))))))
+
+
+;; --------------------------------------------------------------------------
+;; 5. Code loading — convert compiler output to VM structures
+;; --------------------------------------------------------------------------
+
+(define code-from-value
+  (fn (v)
+    "Convert a compiler output dict to a vm-code object."
+    (if (not (dict? v))
+      (make-vm-code 0 16 (list) (list))
+      (let ((bc-raw (get v "bytecode"))
+            (bc (if (nil? bc-raw) (list) bc-raw))
+            (consts-raw (get v "constants"))
+            (consts (if (nil? consts-raw) (list) consts-raw))
+            (arity-raw (get v "arity"))
+            (arity (if (nil? arity-raw) 0 arity-raw)))
+        (make-vm-code arity (+ arity 16) bc consts)))))
+
+
+;; --------------------------------------------------------------------------
+;; 6. Call dispatch — route calls by value type
+;; --------------------------------------------------------------------------
+
+;; vm-call dispatches a function call within the VM.
+;; VmClosure: push frame on current VM (fast path, enables TCO).
+;; NativeFn: call directly, push result.
+;; Lambda/Component: fall back to CEK evaluator.
+(define vm-closure?
+  (fn (v)
+    (and (dict? v) (has-key? v "vm-code"))))
+
+(define vm-call
+  (fn (vm f args)
+    (cond
+      (vm-closure? f)
+        ;; Fast path: push frame on current VM
+        (vm-push-frame vm f args)
+
+      (callable? f)
+        ;; Native function or primitive
+        (vm-push vm (apply f args))
+
+      (or (= (type-of f) "lambda") (= (type-of f) "component") (= (type-of f) "island"))
+        ;; CEK fallback — the host provides cek-call
+        (vm-push vm (cek-call f args))
+
+      :else
+        (error (str "VM: not callable: " (type-of f))))))
+
+
+;; --------------------------------------------------------------------------
+;; 7. Local/upvalue access helpers
+;; --------------------------------------------------------------------------
+
+(define frame-local-get
+  (fn (vm frame slot)
+    "Read a local variable — check shared cells first, then stack."
+    (let ((cells (get frame "local-cells"))
+          (key (str slot)))
+      (if (has-key? cells key)
+        (uv-get (get cells key))
+        (vm-stack-get (get vm "stack") (+ (get frame "base") slot))))))
+
+(define frame-local-set
+  (fn (vm frame slot value)
+    "Write a local variable — to shared cell if captured, else to stack."
+    (let ((cells (get frame "local-cells"))
+          (key (str slot)))
+      (if (has-key? cells key)
+        (uv-set! (get cells key) value)
+        (vm-stack-set! (get vm "stack") (+ (get frame "base") slot) value)))))
+
+(define frame-upvalue-get
+  (fn (frame idx)
+    (uv-get (nth (get (get frame "closure") "vm-upvalues") idx))))
+
+(define frame-upvalue-set
+  (fn (frame idx value)
+    (uv-set! (nth (get (get frame "closure") "vm-upvalues") idx) value)))
+
+
+;; --------------------------------------------------------------------------
+;; 8. Global variable access with closure env chain
+;; --------------------------------------------------------------------------
+
+(define vm-global-get
+  (fn (vm frame name)
+    "Look up a global: globals table → closure env chain → primitives."
+    (let ((globals (get vm "globals")))
+      (if (has-key? globals name)
+        (get globals name)
+        ;; Walk the closure env chain for inner functions
+        (let ((closure-env (get (get frame "closure") "vm-closure-env")))
+          (if (nil? closure-env)
+            (get-primitive name)
+            (let ((found (env-walk closure-env name)))
+              (if (nil? found)
+                (get-primitive name)
+                found))))))))
+
+(define vm-global-set
+  (fn (vm frame name value)
+    "Set a global: write to closure env if name exists there, else globals."
+    (let ((closure-env (get (get frame "closure") "vm-closure-env"))
+          (written false))
+      (when (not (nil? closure-env))
+        (set! written (env-walk-set! closure-env name value)))
+      (when (not written)
+        (dict-set! (get vm "globals") name value)))))
+
+;; env-walk: walk an environment chain looking for a binding.
+;; Returns the value or nil if not found.
+(define env-walk
+  (fn (env name)
+    (if (nil? env) nil
+      (if (env-has? env name)
+        (env-get env name)
+        (let ((parent (env-parent env)))
+          (if (nil? parent) nil
+            (env-walk parent name)))))))
+
+;; env-walk-set!: walk an environment chain, set value if name found.
+;; Returns true if set, false if not found.
+(define env-walk-set!
+  (fn (env name value)
+    (if (nil? env) false
+      (if (env-has? env name)
+        (do (env-set! env name value) true)
+        (let ((parent (env-parent env)))
+          (if (nil? parent) false
+            (env-walk-set! parent name value)))))))
+
+
+;; --------------------------------------------------------------------------
+;; 9. Closure creation — OP_CLOSURE with upvalue capture
+;; --------------------------------------------------------------------------
+
+(define vm-create-closure
+  (fn (vm frame code-val)
+    "Create a closure from a code constant. Reads upvalue descriptors
+     from the bytecode stream and captures values from the enclosing frame."
+    (let ((code (code-from-value code-val))
+          (uv-count (if (dict? code-val)
+                      (let ((n (get code-val "upvalue-count")))
+                        (if (nil? n) 0 n))
+                      0)))
+      (let ((upvalues
+              (let ((result (list))
+                    (i 0))
+                (define capture-loop
+                  (fn ()
+                    (when (< i uv-count)
+                      (let ((is-local (frame-read-u8 frame))
+                            (index (frame-read-u8 frame)))
+                        (let ((cell
+                                (if (= is-local 1)
+                                  ;; Capture from enclosing frame's local slot.
+                                  ;; Create/reuse a shared cell so both parent
+                                  ;; and closure read/write through it.
+                                  (let ((cells (get frame "local-cells"))
+                                        (key (str index)))
+                                    (if (has-key? cells key)
+                                      (get cells key)
+                                      (let ((c (make-upvalue-cell
+                                                 (vm-stack-get (get vm "stack")
+                                                   (+ (get frame "base") index)))))
+                                        (dict-set! cells key c)
+                                        c)))
+                                  ;; Capture from enclosing frame's upvalue
+                                  (nth (get (get frame "closure") "vm-upvalues") index))))
+                          (append! result cell)
+                          (set! i (+ i 1))
+                          (capture-loop))))))
+                (capture-loop)
+                result)))
+        (make-vm-closure code upvalues nil
+          (get vm "globals") nil)))))
+
+
+;; --------------------------------------------------------------------------
+;; 10. Main execution loop — iterative dispatch
+;; --------------------------------------------------------------------------
+
+(define vm-run
+  (fn (vm)
+    "Execute bytecode until all frames are exhausted.
+     VmClosure calls push new frames; the loop picks them up.
+     OP_TAIL_CALL + VmClosure = true TCO: drop frame, push new, loop."
+    (define loop
+      (fn ()
+        (when (not (empty? (get vm "frames")))
+          (let ((frame (first (get vm "frames")))
+                (rest-frames (rest (get vm "frames"))))
+            (let ((bc (get (get (get frame "closure") "vm-code") "vc-bytecode"))
+                  (consts (get (get (get frame "closure") "vm-code") "vc-constants")))
+              (if (>= (get frame "ip") (len bc))
+                ;; Bytecode exhausted — stop
+                (dict-set! vm "frames" (list))
+                (do
+                  (vm-step vm frame rest-frames bc consts)
+                  (loop))))))))
+    (loop)))
+
+
+;; --------------------------------------------------------------------------
+;; 11. Single step — opcode dispatch
+;; --------------------------------------------------------------------------
+
+(define vm-step
+  (fn (vm frame rest-frames bc consts)
+    (let ((op (frame-read-u8 frame)))
+      (cond
+
+        ;; ---- Constants ----
+        (= op 1)   ;; OP_CONST
+          (let ((idx (frame-read-u16 frame)))
+            (vm-push vm (nth consts idx)))
+
+        (= op 2)   ;; OP_NIL
+          (vm-push vm nil)
+
+        (= op 3)   ;; OP_TRUE
+          (vm-push vm true)
+
+        (= op 4)   ;; OP_FALSE
+          (vm-push vm false)
+
+        (= op 5)   ;; OP_POP
+          (vm-pop vm)
+
+        (= op 6)   ;; OP_DUP
+          (vm-push vm (vm-peek vm))
+
+        ;; ---- Variable access ----
+        (= op 16)  ;; OP_LOCAL_GET
+          (let ((slot (frame-read-u8 frame)))
+            (vm-push vm (frame-local-get vm frame slot)))
+
+        (= op 17)  ;; OP_LOCAL_SET
+          (let ((slot (frame-read-u8 frame)))
+            (frame-local-set vm frame slot (vm-peek vm)))
+
+        (= op 18)  ;; OP_UPVALUE_GET
+          (let ((idx (frame-read-u8 frame)))
+            (vm-push vm (frame-upvalue-get frame idx)))
+
+        (= op 19)  ;; OP_UPVALUE_SET
+          (let ((idx (frame-read-u8 frame)))
+            (frame-upvalue-set frame idx (vm-peek vm)))
+
+        (= op 20)  ;; OP_GLOBAL_GET
+          (let ((idx (frame-read-u16 frame))
+                (name (nth consts idx)))
+            (vm-push vm (vm-global-get vm frame name)))
+
+        (= op 21)  ;; OP_GLOBAL_SET
+          (let ((idx (frame-read-u16 frame))
+                (name (nth consts idx)))
+            (vm-global-set vm frame name (vm-peek vm)))
+
+        ;; ---- Control flow ----
+        (= op 32)  ;; OP_JUMP
+          (let ((offset (frame-read-i16 frame)))
+            (dict-set! frame "ip" (+ (get frame "ip") offset)))
+
+        (= op 33)  ;; OP_JUMP_IF_FALSE
+          (let ((offset (frame-read-i16 frame))
+                (v (vm-pop vm)))
+            (when (not v)
+              (dict-set! frame "ip" (+ (get frame "ip") offset))))
+
+        (= op 34)  ;; OP_JUMP_IF_TRUE
+          (let ((offset (frame-read-i16 frame))
+                (v (vm-pop vm)))
+            (when v
+              (dict-set! frame "ip" (+ (get frame "ip") offset))))
+
+        ;; ---- Function calls ----
+        (= op 48)  ;; OP_CALL
+          (let ((argc (frame-read-u8 frame))
+                (args-rev (list))
+                (i 0))
+            (define collect-args
+              (fn ()
+                (when (< i argc)
+                  (set! args-rev (cons (vm-pop vm) args-rev))
+                  (set! i (+ i 1))
+                  (collect-args))))
+            (collect-args)
+            (let ((f (vm-pop vm)))
+              (vm-call vm f args-rev)))
+
+        (= op 49)  ;; OP_TAIL_CALL
+          (let ((argc (frame-read-u8 frame))
+                (args-rev (list))
+                (i 0))
+            (define collect-args
+              (fn ()
+                (when (< i argc)
+                  (set! args-rev (cons (vm-pop vm) args-rev))
+                  (set! i (+ i 1))
+                  (collect-args))))
+            (collect-args)
+            (let ((f (vm-pop vm)))
+              ;; Drop current frame, reuse stack space — true TCO
+              (dict-set! vm "frames" rest-frames)
+              (dict-set! vm "sp" (get frame "base"))
+              (vm-call vm f args-rev)))
+
+        (= op 50)  ;; OP_RETURN
+          (let ((result (vm-pop vm)))
+            (dict-set! vm "frames" rest-frames)
+            (dict-set! vm "sp" (get frame "base"))
+            (vm-push vm result))
+
+        (= op 51)  ;; OP_CLOSURE
+          (let ((idx (frame-read-u16 frame))
+                (code-val (nth consts idx)))
+            (let ((cl (vm-create-closure vm frame code-val)))
+              (vm-push vm cl)))
+
+        (= op 52)  ;; OP_CALL_PRIM
+          (let ((idx (frame-read-u16 frame))
+                (argc (frame-read-u8 frame))
+                (name (nth consts idx))
+                (args-rev (list))
+                (i 0))
+            (define collect-args
+              (fn ()
+                (when (< i argc)
+                  (set! args-rev (cons (vm-pop vm) args-rev))
+                  (set! i (+ i 1))
+                  (collect-args))))
+            (collect-args)
+            (vm-push vm (call-primitive name args-rev)))
+
+        ;; ---- Collections ----
+        (= op 64)  ;; OP_LIST
+          (let ((count (frame-read-u16 frame))
+                (items-rev (list))
+                (i 0))
+            (define collect-items
+              (fn ()
+                (when (< i count)
+                  (set! items-rev (cons (vm-pop vm) items-rev))
+                  (set! i (+ i 1))
+                  (collect-items))))
+            (collect-items)
+            (vm-push vm items-rev))
+
+        (= op 65)  ;; OP_DICT
+          (let ((count (frame-read-u16 frame))
+                (d {})
+                (i 0))
+            (define collect-pairs
+              (fn ()
+                (when (< i count)
+                  (let ((v (vm-pop vm))
+                        (k (vm-pop vm)))
+                    (dict-set! d k v)
+                    (set! i (+ i 1))
+                    (collect-pairs)))))
+            (collect-pairs)
+            (vm-push vm d))
+
+        ;; ---- String ops ----
+        (= op 144) ;; OP_STR_CONCAT
+          (let ((count (frame-read-u8 frame))
+                (parts-rev (list))
+                (i 0))
+            (define collect-parts
+              (fn ()
+                (when (< i count)
+                  (set! parts-rev (cons (vm-pop vm) parts-rev))
+                  (set! i (+ i 1))
+                  (collect-parts))))
+            (collect-parts)
+            (vm-push vm (apply str parts-rev)))
+
+        ;; ---- Define ----
+        (= op 128) ;; OP_DEFINE
+          (let ((idx (frame-read-u16 frame))
+                (name (nth consts idx)))
+            (dict-set! (get vm "globals") name (vm-peek vm)))
+
+        ;; ---- Inline primitives ----
+        (= op 160) ;; OP_ADD
+          (let ((b (vm-pop vm)) (a (vm-pop vm)))
+            (vm-push vm (+ a b)))
+        (= op 161) ;; OP_SUB
+          (let ((b (vm-pop vm)) (a (vm-pop vm)))
+            (vm-push vm (- a b)))
+        (= op 162) ;; OP_MUL
+          (let ((b (vm-pop vm)) (a (vm-pop vm)))
+            (vm-push vm (* a b)))
+        (= op 163) ;; OP_DIV
+          (let ((b (vm-pop vm)) (a (vm-pop vm)))
+            (vm-push vm (/ a b)))
+        (= op 164) ;; OP_EQ
+          (let ((b (vm-pop vm)) (a (vm-pop vm)))
+            (vm-push vm (= a b)))
+        (= op 165) ;; OP_LT
+          (let ((b (vm-pop vm)) (a (vm-pop vm)))
+            (vm-push vm (< a b)))
+        (= op 166) ;; OP_GT
+          (let ((b (vm-pop vm)) (a (vm-pop vm)))
+            (vm-push vm (> a b)))
+        (= op 167) ;; OP_NOT
+          (vm-push vm (not (vm-pop vm)))
+        (= op 168) ;; OP_LEN
+          (vm-push vm (len (vm-pop vm)))
+        (= op 169) ;; OP_FIRST
+          (vm-push vm (first (vm-pop vm)))
+        (= op 170) ;; OP_REST
+          (vm-push vm (rest (vm-pop vm)))
+        (= op 171) ;; OP_NTH
+          (let ((n (vm-pop vm)) (coll (vm-pop vm)))
+            (vm-push vm (nth coll n)))
+        (= op 172) ;; OP_CONS
+          (let ((coll (vm-pop vm)) (x (vm-pop vm)))
+            (vm-push vm (cons x coll)))
+        (= op 173) ;; OP_NEG
+          (vm-push vm (- 0 (vm-pop vm)))
+        (= op 174) ;; OP_INC
+          (vm-push vm (inc (vm-pop vm)))
+        (= op 175) ;; OP_DEC
+          (vm-push vm (dec (vm-pop vm)))
+
+        :else
+          (error (str "VM: unknown opcode " op))))))
+
+
+;; --------------------------------------------------------------------------
+;; 12. Entry points
+;; --------------------------------------------------------------------------
+
+;; Execute a closure with arguments — creates a fresh VM.
+(define vm-call-closure
+  (fn (closure args globals)
+    (let ((vm (make-vm globals)))
+      (vm-push-frame vm closure args)
+      (vm-run vm)
+      (vm-pop vm))))
+
+;; Execute a compiled module (top-level bytecode).
+(define vm-execute-module
+  (fn (code globals)
+    (let ((closure (make-vm-closure code (list) "module" globals nil))
+          (vm (make-vm globals)))
+      (let ((frame (make-vm-frame closure 0)))
+        ;; Pad local slots
+        (let ((i 0)
+              (total (get code "vc-locals")))
+          (define pad-loop
+            (fn ()
+              (when (< i total)
+                (vm-push vm nil)
+                (set! i (+ i 1))
+                (pad-loop))))
+          (pad-loop))
+        (dict-set! vm "frames" (list frame))
+        (vm-run vm)
+        (vm-pop vm)))))
+
+
+;; --------------------------------------------------------------------------
+;; 13. Platform interface
+;; --------------------------------------------------------------------------
+;;
+;; Each target must provide:
+;;
+;;   make-vm-stack(size)        → opaque stack (array-like)
+;;   vm-stack-get(stack, idx)   → value at index
+;;   vm-stack-set!(stack, idx, value) → mutate index
+;;   vm-stack-length(stack)     → current capacity
+;;   vm-stack-copy!(src, dst, count) → copy first count elements
+;;
+;;   cek-call(f, args)          → evaluate via CEK machine (fallback)
+;;   get-primitive(name)        → look up primitive by name (returns callable)
+;;   call-primitive(name, args) → call primitive directly with args list
+;;
+;;   env-parent(env)            → parent environment or nil
+;;   env-has?(env, name)        → boolean
+;;   env-get(env, name)         → value
+;;   env-set!(env, name, value) → mutate binding

run-tests.sh

@@ -0,0 +1,166 @@
+#!/usr/bin/env bash
+# ===========================================================================
+# run-tests.sh — Run ALL test suites. Exit non-zero if any fail.
+#
+# Usage:
+#   ./run-tests.sh           # run everything
+#   ./run-tests.sh --quick   # skip Playwright (fast CI check)
+#   ./run-tests.sh --sx-only # SX language tests only (JS + Python + OCaml)
+# ===========================================================================
+set -euo pipefail
+
+cd "$(dirname "$0")"
+
+QUICK="${QUICK:-false}"
+SX_ONLY="${SX_ONLY:-false}"
+for arg in "$@"; do
+  case "$arg" in
+    --quick)   QUICK=true ;;
+    --sx-only) SX_ONLY=true ;;
+  esac
+done
+
+FAILURES=()
+PASSES=()
+
+run_suite() {
+  local name="$1"
+  shift
+  echo ""
+  echo "============================================================"
+  echo "  $name"
+  echo "============================================================"
+  if "$@"; then
+    PASSES+=("$name")
+  else
+    FAILURES+=("$name")
+  fi
+}
+
+# -------------------------------------------------------------------
+# 1. Build SX bundles
+# -------------------------------------------------------------------
+echo "=== Building SX bundles ==="
+python3 hosts/javascript/cli.py --output shared/static/scripts/sx-browser.js
+python3 hosts/javascript/cli.py --extensions continuations --spec-modules types \
+  --output shared/static/scripts/sx-full-test.js
+
+# -------------------------------------------------------------------
+# 2. JavaScript SX tests (standard + full)
+# -------------------------------------------------------------------
+run_suite "JS standard (spec tests)" \
+  node hosts/javascript/run_tests.js
+
+run_suite "JS full (spec + continuations + types + VM)" \
+  node hosts/javascript/run_tests.js --full
+
+# -------------------------------------------------------------------
+# 3. OCaml SX tests
+# -------------------------------------------------------------------
+if [ -x hosts/ocaml/_build/default/bin/run_tests.exe ]; then
+  run_suite "OCaml (spec tests)" \
+    hosts/ocaml/_build/default/bin/run_tests.exe
+else
+  echo ""
+  echo "[SKIP] OCaml tests — binary not built (run: cd hosts/ocaml && dune build)"
+fi
+
+# -------------------------------------------------------------------
+# 4. OCaml bridge integration (custom special forms, web-forms.sx)
+# -------------------------------------------------------------------
+run_suite "OCaml bridge — custom special forms + web-forms" \
+  python3 -c "
+from shared.sx.ocaml_sync import OcamlSync
+bridge = OcamlSync()
+# Load exactly what the server does (no evaluator.sx!)
+for f in ['spec/parser.sx', 'spec/render.sx', 'web/adapter-html.sx', 'web/adapter-sx.sx', 'web/web-forms.sx', 'lib/freeze.sx']:
+    bridge.load(f)
+ok = 0; fail = 0
+def check(name, expr, expected=None):
+    global ok, fail
+    try:
+        r = bridge.eval(expr)
+        if expected is not None and r != expected:
+            print(f'  FAIL: {name}: expected {expected!r}, got {r!r}'); fail += 1
+        else:
+            print(f'  PASS: {name}'); ok += 1
+    except Exception as e:
+        print(f'  FAIL: {name}: {e}'); fail += 1
+
+# Custom special forms registered by web-forms.sx
+for form in ['defhandler', 'defquery', 'defaction', 'defpage', 'defrelation', 'defstyle', 'deftype', 'defeffect']:
+    check(f'{form} registered', f'(has-key? *custom-special-forms* \"{form}\")', 'true')
+
+# Custom forms callable via eval (not just via load)
+check('deftype via eval', '(deftype test-t number)', 'nil')
+check('defeffect via eval', '(defeffect test-e)', 'nil')
+check('defstyle via eval', '(defstyle my-s \"bold\")', 'bold')
+check('defhandler via eval', '(has-key? (defhandler test-h (&key x) x) \"__type\")', 'true')
+
+# Extension lists populated
+check('definition-form-extensions populated', '(> (len *definition-form-extensions*) 0)', 'true')
+check('RENDER_HTML_FORMS has defstyle', '(contains? RENDER_HTML_FORMS \"defstyle\")', 'true')
+
+# Env-shadowing regression: custom forms survive evaluator.sx load
+bridge2 = OcamlSync()
+bridge2.eval('(register-special-form! \"shadow-test\" (fn (args env) 42))')
+bridge2.load('spec/evaluator.sx')
+check('custom form survives evaluator.sx load',
+      bridge2.eval('(has-key? *custom-special-forms* \"shadow-test\")'), 'true')
+bridge2.eval('(register-special-form! \"post-load\" (fn (args env) 99))')
+check('custom form callable after evaluator.sx load',
+      bridge2.eval('(post-load 1)'), '99')
+
+print(f'\\nResults: {ok} passed, {fail} failed')
+import sys; sys.exit(1 if fail > 0 else 0)
+"
+
+# -------------------------------------------------------------------
+# 5. Python SX tests (post-removal regression, components, parser)
+# -------------------------------------------------------------------
+run_suite "Python — post-removal regression" \
+  python3 -m pytest shared/sx/tests/test_post_removal_bugs.py -v --tb=short
+
+run_suite "Python — component rendering" \
+  python3 -m pytest shared/sx/tests/test_components.py -v --tb=short
+
+run_suite "Python — parser" \
+  python3 -m pytest shared/sx/tests/test_parser.py -v --tb=short
+
+# -------------------------------------------------------------------
+# 5. Playwright tests (browser)
+# -------------------------------------------------------------------
+if [ "$QUICK" = false ] && [ "$SX_ONLY" = false ]; then
+  run_suite "Playwright — isomorphic SSR" \
+    npx playwright test --reporter=list
+
+  run_suite "Playwright — SX demos (98 tests)" \
+    python3 -m pytest sx/tests/test_demos.py -v --tb=short
+fi
+
+# -------------------------------------------------------------------
+# Summary
+# -------------------------------------------------------------------
+echo ""
+echo "============================================================"
+echo "  TEST SUMMARY"
+echo "============================================================"
+for p in "${PASSES[@]}"; do
+  echo "  PASS: $p"
+done
+for f in "${FAILURES[@]}"; do
+  echo "  FAIL: $f"
+done
+echo "============================================================"
+
+if [ ${#FAILURES[@]} -gt 0 ]; then
+  echo ""
+  echo "  ${#FAILURES[@]} suite(s) FAILED — deploy blocked."
+  echo ""
+  exit 1
+else
+  echo ""
+  echo "  All ${#PASSES[@]} suites passed."
+  echo ""
+  exit 0
+fi

shared/infrastructure/factory.py

@@ -344,7 +344,7 @@ def create_base_app(
             response.headers["Access-Control-Allow-Origin"] = origin
             response.headers["Access-Control-Allow-Credentials"] = "true"
             response.headers["Access-Control-Allow-Headers"] = (
-                "SX-Request, SX-Target, SX-Current-URL, SX-Components, SX-Css, "
+                "SX-Request, SX-Target, SX-Current-URL, SX-Components, SX-Components-Hash, SX-Css, "
                 "HX-Request, HX-Target, HX-Current-URL, HX-Trigger, "
                 "Content-Type, X-CSRFToken"
             )

shared/sx/__init__.py

@@ -32,7 +32,6 @@ from .parser import (
     serialize,
 )
 from .types import EvalError
-from .ref.sx_ref import evaluate, make_env
 
 from .primitives import (
     all_primitives,

shared/sx/async_eval.py

@@ -53,7 +53,9 @@ from .types import Component, Island, Keyword, Lambda, Macro, NIL, Symbol
 _expand_components: contextvars.ContextVar[bool] = contextvars.ContextVar(
     "_expand_components", default=False
 )
-from .ref.sx_ref import expand_macro as _expand_macro
+# sx_ref.py removed — stub so module loads. OCaml bridge handles macro expansion.
+def _expand_macro(*a, **kw):
+    raise RuntimeError("sx_ref.py has been removed — use SX_USE_OCAML=1")
 from .types import EvalError
 from .primitives import _PRIMITIVES
 from .primitives_io import IO_PRIMITIVES, RequestContext, execute_io
@@ -421,23 +423,39 @@ async def _asf_define(expr, env, ctx):
 
 
 async def _asf_defcomp(expr, env, ctx):
-    from .ref.sx_ref import sf_defcomp
-    return sf_defcomp(expr[1:], env)
+    # Component definitions are handled by OCaml kernel at load time.
+    # Python-side: just store a minimal Component in env for reference.
+    from .types import Component
+    name_sym = expr[1]
+    name = name_sym.name if hasattr(name_sym, 'name') else str(name_sym)
+    env[name] = Component(name=name.lstrip("~"), params=[], has_children=False,
+                          body=expr[-1], closure={})
+    return NIL
 
 
 async def _asf_defstyle(expr, env, ctx):
-    from .ref.sx_ref import sf_defstyle
-    return sf_defstyle(expr[1:], env)
+    # Style definitions handled by OCaml kernel.
+    return NIL
 
 
 async def _asf_defmacro(expr, env, ctx):
-    from .ref.sx_ref import sf_defmacro
-    return sf_defmacro(expr[1:], env)
+    # Macro definitions handled by OCaml kernel.
+    from .types import Macro
+    name_sym = expr[1]
+    name = name_sym.name if hasattr(name_sym, 'name') else str(name_sym)
+    params_form = expr[2] if len(expr) > 3 else []
+    param_names = [p.name for p in params_form if isinstance(p, Symbol) and not p.name.startswith("&")]
+    rest_param = None
+    for i, p in enumerate(params_form):
+        if isinstance(p, Symbol) and p.name == "&rest" and i + 1 < len(params_form):
+            rest_param = params_form[i + 1].name if isinstance(params_form[i + 1], Symbol) else None
+    env[name] = Macro(name=name, params=param_names, rest_param=rest_param, body=expr[-1])
+    return NIL
 
 
 async def _asf_defhandler(expr, env, ctx):
-    from .ref.sx_ref import sf_defhandler
-    return sf_defhandler(expr[1:], env)
+    # Handler definitions handled by OCaml kernel.
+    return NIL
 
 
 async def _asf_begin(expr, env, ctx):
@@ -599,9 +617,12 @@ async def _asf_reset(expr, env, ctx):
             from .types import NIL
             _ASYNC_RESET_RESUME.append(value if value is not None else NIL)
             try:
-                # Sync re-evaluation; the async caller will trampoline
-                from .ref.sx_ref import eval_expr as sync_eval, trampoline as _trampoline
-                return _trampoline(sync_eval(body, env))
+                # Continuations are handled by OCaml kernel.
+                # Python-side cont_fn should not be called in normal operation.
+                raise RuntimeError(
+                    "Python-side continuation invocation not supported — "
+                    "use OCaml bridge for shift/reset"
+                )
             finally:
                 _ASYNC_RESET_RESUME.pop()
         k = Continuation(cont_fn)

shared/sx/deps.py

@@ -14,7 +14,7 @@ from .types import Component, Island, Macro, Symbol
 
 
 def _use_ref() -> bool:
-    return os.environ.get("SX_USE_REF") == "1"
+    return False  # sx_ref.py removed — always use fallback
 
 
 # ---------------------------------------------------------------------------
@@ -152,18 +152,11 @@ def transitive_deps(name: str, env: dict[str, Any]) -> set[str]:
     Returns the set of all component names (with ~ prefix) that
     *name* can transitively render, NOT including *name* itself.
     """
-    if _use_ref():
-        from .ref.sx_ref import transitive_deps as _ref_td
-        return set(_ref_td(name, env))
     return _transitive_deps_fallback(name, env)
 
 
 def compute_all_deps(env: dict[str, Any]) -> None:
     """Compute and cache deps for all Component entries in *env*."""
-    if _use_ref():
-        from .ref.sx_ref import compute_all_deps as _ref_cad
-        _ref_cad(env)
-        return
     _compute_all_deps_fallback(env)
 
 
@@ -172,9 +165,6 @@ def scan_components_from_sx(source: str) -> set[str]:
 
     Returns names with ~ prefix, e.g. {"~card", "~shared:layout/nav-link"}.
     """
-    if _use_ref():
-        from .ref.sx_ref import scan_components_from_source as _ref_sc
-        return set(_ref_sc(source))
     return _scan_components_from_sx_fallback(source)
 
 
@@ -183,18 +173,11 @@ def components_needed(page_sx: str, env: dict[str, Any]) -> set[str]:
 
     Returns names with ~ prefix.
     """
-    if _use_ref():
-        from .ref.sx_ref import components_needed as _ref_cn
-        return set(_ref_cn(page_sx, env))
     return _components_needed_fallback(page_sx, env)
 
 
 def compute_all_io_refs(env: dict[str, Any], io_names: set[str]) -> None:
     """Compute and cache transitive IO refs for all Component entries in *env*."""
-    if _use_ref():
-        from .ref.sx_ref import compute_all_io_refs as _ref_cio
-        _ref_cio(env, list(io_names))
-        return
     _compute_all_io_refs_fallback(env, io_names)
 
 
@@ -209,9 +192,17 @@ def page_render_plan(page_sx: str, env: dict[str, Any], io_names: set[str] | Non
     """
     if io_names is None:
         io_names = get_all_io_names()
-    from .ref.sx_ref import page_render_plan as _ref_prp
-    plan = _ref_prp(page_sx, env, list(io_names))
-    return plan
+    # Use fallback implementation (sx_ref.py removed)
+    needed = _components_needed_fallback(page_sx, env)
+    server, client, io_deps = [], [], []
+    for name in needed:
+        comp = env.get(name)
+        if comp and hasattr(comp, 'io_refs') and comp.io_refs:
+            client.append(name)
+        else:
+            server.append(name)
+    return {"components": {n: ("server" if n in server else "client") for n in needed},
+            "server": server, "client": client, "io-deps": io_deps}
 
 
 def get_all_io_names() -> set[str]:

shared/sx/handlers.py

@@ -80,30 +80,76 @@ def clear_handlers(service: str | None = None) -> None:
 # Loading — parse .sx files and collect HandlerDef instances
 # ---------------------------------------------------------------------------
 
+def _parse_defhandler(expr: list) -> HandlerDef | None:
+    """Extract HandlerDef from a (defhandler name :path ... (&key ...) body) form."""
+    from .types import Keyword
+    if len(expr) < 3:
+        return None
+    name = expr[1].name if hasattr(expr[1], 'name') else str(expr[1])
+
+    # Parse keyword options and find params/body
+    path = None
+    method = "get"
+    csrf = True
+    returns = "element"
+    params_list = None
+    body = None
+
+    i = 2
+    while i < len(expr):
+        item = expr[i]
+        if isinstance(item, Keyword) and i + 1 < len(expr):
+            kn = item.name
+            val = expr[i + 1]
+            if kn == "path":
+                path = val if isinstance(val, str) else str(val)
+            elif kn == "method":
+                method = val.name if hasattr(val, 'name') else str(val)
+            elif kn == "csrf":
+                csrf = val not in (False, "false")
+            elif kn == "returns":
+                returns = val if isinstance(val, str) else str(val)
+            i += 2
+        elif isinstance(item, list) and not params_list:
+            # This is the params list (&key ...)
+            params_list = item
+            i += 1
+        else:
+            body = item
+            i += 1
+
+    param_names = []
+    if params_list:
+        for p in params_list:
+            if hasattr(p, 'name') and p.name not in ("&key", "&rest"):
+                param_names.append(p.name)
+
+    return HandlerDef(
+        name=name, params=param_names, body=body or [],
+        path=path, method=method, csrf=csrf, returns=returns,
+    )
+
+
 def load_handler_file(filepath: str, service_name: str) -> list[HandlerDef]:
     """Parse an .sx file, evaluate it, and register any HandlerDef values."""
     from .parser import parse_all
     import os
-    from .ref.sx_ref import eval_expr as _raw_eval, trampoline as _trampoline
-    _eval = lambda expr, env: _trampoline(_raw_eval(expr, env))
     from .jinja_bridge import get_component_env
 
     with open(filepath, encoding="utf-8") as f:
         source = f.read()
 
-    # Seed env with component definitions so handlers can reference components
-    env = dict(get_component_env())
+    # Parse defhandler forms from the AST to extract handler registration info
     exprs = parse_all(source)
     handlers: list[HandlerDef] = []
 
     for expr in exprs:
-        _eval(expr, env)
-
-    # Collect all HandlerDef values from the env
-    for key, val in env.items():
-        if isinstance(val, HandlerDef):
-            register_handler(service_name, val)
-            handlers.append(val)
+        if (isinstance(expr, list) and expr
+                and hasattr(expr[0], 'name') and expr[0].name == "defhandler"):
+            hd = _parse_defhandler(expr)
+            if hd:
+                register_handler(service_name, hd)
+                handlers.append(hd)
 
     return handlers
 
@@ -137,36 +183,54 @@ async def execute_handler(
 
     1. Build env from component env + handler closure
     2. Bind handler params from args (typically request.args)
-    3. Evaluate via ``async_eval_to_sx`` (I/O inline, components serialized)
+    3. Evaluate via OCaml kernel (or Python fallback)
     4. Return ``SxExpr`` wire format
     """
     from .jinja_bridge import get_component_env, _get_request_context
     from .pages import get_page_helpers
+    from .parser import serialize
+    from .types import NIL, SxExpr
     import os
-    if os.environ.get("SX_USE_REF") == "1":
-        from .ref.async_eval_ref import async_eval_to_sx
-    else:
-        from .async_eval import async_eval_to_sx
-    from .types import NIL
 
     if args is None:
         args = {}
 
-    # Build environment
-    env = dict(get_component_env())
-    env.update(get_page_helpers(service_name))
-    env.update(handler_def.closure)
+    use_ocaml = os.environ.get("SX_USE_OCAML") == "1"
 
-    # Bind handler params from request args
-    for param in handler_def.params:
-        env[param] = args.get(param, args.get(param.replace("-", "_"), NIL))
+    if use_ocaml:
+        from .ocaml_bridge import get_bridge
 
-    # Get request context for I/O primitives
-    ctx = _get_request_context()
+        # Serialize handler body with bound params as a let expression.
+        # Define constants and defcomps from the handler file are available
+        # in the kernel's global env (loaded by _ensure_components).
+        param_bindings = []
+        for param in handler_def.params:
+            val = args.get(param, args.get(param.replace("-", "_"), NIL))
+            param_bindings.append(f"({param} {serialize(val)})")
 
-    # Async eval → sx source — I/O primitives are awaited inline,
-    # but component/tag calls serialize to sx wire format (not HTML).
-    return await async_eval_to_sx(handler_def.body, env, ctx)
+        body_sx = serialize(handler_def.body)
+        if param_bindings:
+            sx_text = f"(let ({' '.join(param_bindings)}) {body_sx})"
+        else:
+            sx_text = body_sx
+
+        bridge = await get_bridge()
+        ocaml_ctx = {"_helper_service": service_name}
+        result_sx = await bridge.aser(sx_text, ctx=ocaml_ctx)
+        return SxExpr(result_sx or "")
+    else:
+        # Python fallback (async_eval)
+        from .async_eval import async_eval_to_sx
+
+        env = dict(get_component_env())
+        env.update(get_page_helpers(service_name))
+        env.update(handler_def.closure)
+
+        for param in handler_def.params:
+            env[param] = args.get(param, args.get(param.replace("-", "_"), NIL))
+
+        ctx = _get_request_context()
+        return await async_eval_to_sx(handler_def.body, env, ctx)
 
 
 # ---------------------------------------------------------------------------

shared/sx/helpers.py

@@ -364,10 +364,6 @@ async def _render_to_sx_with_env(__name: str, extra_env: dict, **kwargs: Any) ->
     """
     from .jinja_bridge import get_component_env, _get_request_context
     import os
-    if os.environ.get("SX_USE_REF") == "1":
-        from .ref.async_eval_ref import async_eval_slot_to_sx
-    else:
-        from .async_eval import async_eval_slot_to_sx
     from .types import Symbol, Keyword, NIL as _NIL
 
     # Build AST with extra_env entries as keyword args so _aser_component
@@ -381,6 +377,16 @@ async def _render_to_sx_with_env(__name: str, extra_env: dict, **kwargs: Any) ->
         ast.append(Keyword(k.replace("_", "-")))
         ast.append(v if v is not None else _NIL)
 
+    if os.environ.get("SX_USE_OCAML") == "1":
+        from .ocaml_bridge import get_bridge
+        from .parser import serialize
+        bridge = await get_bridge()
+        sx_text = serialize(ast)
+        ocaml_ctx = {"_helper_service": _get_request_context().get("_helper_service", "")} if isinstance(_get_request_context(), dict) else {}
+        return SxExpr(await bridge.aser_slot(sx_text, ctx=ocaml_ctx))
+
+    from .async_eval import async_eval_slot_to_sx
+
     env = dict(get_component_env())
     env.update(extra_env)
     ctx = _get_request_context()
@@ -399,12 +405,21 @@ async def _render_to_sx(__name: str, **kwargs: Any) -> str:
     """
     from .jinja_bridge import get_component_env, _get_request_context
     import os
-    if os.environ.get("SX_USE_REF") == "1":
-        from .ref.async_eval_ref import async_eval_to_sx
-    else:
-        from .async_eval import async_eval_to_sx
 
     ast = _build_component_ast(__name, **kwargs)
+
+    if os.environ.get("SX_USE_OCAML") == "1":
+        from .ocaml_bridge import get_bridge
+        from .parser import serialize
+        bridge = await get_bridge()
+        sx_text = serialize(ast)
+        # aser_slot (not aser) — layout wrappers contain re-parsed
+        # content from earlier aser_slot calls.  Regular aser fails on
+        # symbols like `title` that were bound during the earlier expansion.
+        return SxExpr(await bridge.aser_slot(sx_text))
+
+    from .async_eval import async_eval_to_sx
+
     env = dict(get_component_env())
     ctx = _get_request_context()
     return SxExpr(await async_eval_to_sx(ast, env, ctx))
@@ -420,15 +435,24 @@ async def render_to_html(__name: str, **kwargs: Any) -> str:
 
     Same as render_to_sx() but produces HTML output instead of SX wire
     format. Used by route renders that need HTML (full pages, fragments).
+
+    Routes through the OCaml bridge (render mode) which handles component
+    parameter binding, scope primitives, and all evaluation.
     """
-    from .jinja_bridge import get_component_env, _get_request_context
     import os
-    if os.environ.get("SX_USE_REF") == "1":
-        from .ref.async_eval_ref import async_render
-    else:
-        from .async_eval import async_render
 
     ast = _build_component_ast(__name, **kwargs)
+
+    if os.environ.get("SX_USE_OCAML") == "1":
+        from .ocaml_bridge import get_bridge
+        from .parser import serialize
+        bridge = await get_bridge()
+        sx_text = serialize(ast)
+        return await bridge.render(sx_text)
+
+    # Fallback: Python async_eval (requires working evaluator)
+    from .jinja_bridge import get_component_env, _get_request_context
+    from .async_eval import async_render
     env = dict(get_component_env())
     ctx = _get_request_context()
     return await async_render(ast, env, ctx)
@@ -496,8 +520,18 @@ def components_for_request(source: str = "",
     elif extra_names:
         needed = extra_names
 
-    loaded_raw = request.headers.get("SX-Components", "")
-    loaded = set(loaded_raw.split(",")) if loaded_raw else set()
+    # Check hash first (new): if client hash matches current, skip all defs.
+    # Fall back to legacy name list (SX-Components) for backward compat.
+    comp_hash_header = request.headers.get("SX-Components-Hash", "")
+    if comp_hash_header:
+        from .jinja_bridge import components_for_page
+        _, current_hash = components_for_page("", service=None)
+        if comp_hash_header == current_hash:
+            return ""  # client has everything
+        loaded = set()  # hash mismatch — send all needed
+    else:
+        loaded_raw = request.headers.get("SX-Components", "")
+        loaded = set(loaded_raw.split(",")) if loaded_raw else set()
 
     parts = []
     for key, val in _COMPONENT_ENV.items():
@@ -767,6 +801,162 @@ def _sx_literal(v: object) -> str:
 
 
 
+_cached_shell_static: dict[str, Any] | None = None
+_cached_shell_comp_hash: str | None = None
+
+
+def invalidate_shell_cache():
+    """Call on component hot-reload to recompute shell statics."""
+    global _cached_shell_static, _cached_shell_comp_hash
+    _cached_shell_static = None
+    _cached_shell_comp_hash = None
+
+
+def _get_shell_static() -> dict[str, Any]:
+    """Compute and cache all shell kwargs that don't change per-request.
+
+    This is the expensive part: component dep scanning, serialization,
+    CSS class scanning, rule lookup, pages registry. All stable until
+    components are hot-reloaded.
+    """
+    global _cached_shell_static, _cached_shell_comp_hash
+    from .jinja_bridge import components_for_page, css_classes_for_page, _component_env_hash
+    from .css_registry import lookup_rules, get_preamble, registry_loaded, store_css_hash
+
+    current_hash = _component_env_hash()
+    if _cached_shell_static is not None and _cached_shell_comp_hash == current_hash:
+        return _cached_shell_static
+
+    import time
+    t0 = time.monotonic()
+
+    from quart import current_app as _ca
+    from .jinja_bridge import client_components_tag, _COMPONENT_ENV, _CLIENT_LIBRARY_SOURCES
+    from .jinja_bridge import _component_env_hash
+    from .parser import serialize as _serialize
+
+    # Send ALL component definitions — the hash is stable per env so the
+    # browser caches them across all pages. Server-side expansion handles
+    # the per-page subset; the client needs the full set for client-side
+    # routing to any page.
+    parts = []
+    for key, val in _COMPONENT_ENV.items():
+        from .types import Island, Component, Macro
+        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, pretty=True)})")
+        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, pretty=True)})")
+        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, pretty=True)})")
+    all_parts = list(_CLIENT_LIBRARY_SOURCES) + parts
+    component_defs = "\n".join(all_parts)
+    component_hash = _component_env_hash()
+
+    # CSS: scan ALL components (not per-page) for the static cache
+    sx_css = ""
+    sx_css_classes = ""
+    if registry_loaded():
+        classes: set[str] = set()
+        from .types import Island as _I, Component as _C
+        for val in _COMPONENT_ENV.values():
+            if isinstance(val, (_I, _C)) and val.css_classes:
+                classes.update(val.css_classes)
+        classes.update(["bg-stone-50", "text-stone-900"])
+        rules = lookup_rules(classes)
+        sx_css = get_preamble() + rules
+        sx_css_classes = store_css_hash(classes)
+
+    pages_sx = _build_pages_sx(_ca.name)
+
+    _shell_cfg = _ca.config.get("SX_SHELL", {})
+
+    static = dict(
+        component_hash=component_hash,
+        component_defs=component_defs,
+        pages_sx=pages_sx,
+        sx_css=sx_css,
+        sx_css_classes=sx_css_classes,
+        sx_js_hash=_script_hash("sx-browser.js"),
+        body_js_hash=_script_hash("body.js"),
+        asset_url=_ca.config.get("ASSET_URL", "/static"),
+        head_scripts=_shell_cfg.get("head_scripts"),
+        inline_css=_shell_cfg.get("inline_css"),
+        inline_head_js=_shell_cfg.get("inline_head_js"),
+        init_sx=_shell_cfg.get("init_sx"),
+        body_scripts=_shell_cfg.get("body_scripts"),
+    )
+
+    t1 = time.monotonic()
+    import logging
+    logging.getLogger("sx.pages").info(
+        "[shell-static] computed in %.3fs, comp_defs=%d css=%d pages=%d",
+        t1 - t0, len(component_defs), len(sx_css), len(pages_sx))
+
+    _cached_shell_static = static
+    _cached_shell_comp_hash = current_hash
+    return static
+
+
+async def _build_shell_kwargs(ctx: dict, page_sx: str, *,
+                              meta_html: str = "",
+                              head_scripts: list[str] | None = None,
+                              inline_css: str | None = None,
+                              inline_head_js: str | None = None,
+                              init_sx: str | None = None,
+                              body_scripts: list[str] | None = None) -> dict[str, Any]:
+    """Compute all shell kwargs for sx-page-shell.
+
+    Static parts (components, CSS, pages) are cached. Only per-request
+    values (title, csrf) are computed fresh.
+    """
+    static = _get_shell_static()
+
+    asset_url = get_asset_url(ctx) or static["asset_url"]
+    title = ctx.get("base_title", "Rose Ash")
+    csrf = _get_csrf_token()
+
+    kwargs: dict[str, Any] = dict(static)
+    kwargs.update(
+        title=_html_escape(title),
+        asset_url=asset_url,
+        meta_html=meta_html,
+        csrf=_html_escape(csrf),
+    )
+
+    # Per-page CSS: scan THIS page's classes and add to cached CSS
+    from .css_registry import scan_classes_from_sx, lookup_rules, registry_loaded
+    if registry_loaded() and page_sx:
+        page_classes = scan_classes_from_sx(page_sx)
+        if page_classes:
+            extra_rules = lookup_rules(page_classes)
+            if extra_rules:
+                kwargs["sx_css"] = static["sx_css"] + extra_rules
+
+    # Cookie-based component caching
+    client_hash = _get_sx_comp_cookie()
+    if not _is_dev_mode() and client_hash and client_hash == static["component_hash"]:
+        kwargs["component_defs"] = ""
+
+    # Per-call overrides
+    if head_scripts is not None:
+        kwargs["head_scripts"] = head_scripts
+    if inline_css is not None:
+        kwargs["inline_css"] = inline_css
+    if inline_head_js is not None:
+        kwargs["inline_head_js"] = inline_head_js
+    if init_sx is not None:
+        kwargs["init_sx"] = init_sx
+    if body_scripts is not None:
+        kwargs["body_scripts"] = body_scripts
+    return kwargs
+
+
 async def sx_page(ctx: dict, page_sx: str, *,
               meta_html: str = "",
               head_scripts: list[str] | None = None,
@@ -774,109 +964,18 @@ async def sx_page(ctx: dict, page_sx: str, *,
               inline_head_js: str | None = None,
               init_sx: str | None = None,
               body_scripts: list[str] | None = None) -> str:
-    """Return a minimal HTML shell that boots the page from sx source.
-
-    The browser loads component definitions and page sx, then sx.js
-    renders everything client-side.  CSS rules are scanned from the sx
-    source and component defs, then injected as a <style> block.
-
-    The shell is rendered from the ~shared:shell/sx-page-shell SX component
-    (shared/sx/templates/shell.sx).
-    """
-    from .jinja_bridge import components_for_page, css_classes_for_page
-    from .css_registry import lookup_rules, get_preamble, registry_loaded, store_css_hash
-
-    # Per-page component bundle: this page's deps + all :data page deps
-    from quart import current_app as _ca
-    component_defs, component_hash = components_for_page(page_sx, service=_ca.name)
-
-    # Check if client already has this version cached (via cookie)
-    # In dev mode, always send full source so edits are visible immediately
-    client_hash = _get_sx_comp_cookie()
-    if not _is_dev_mode() and client_hash and client_hash == component_hash:
-        # Client has current components cached — send empty source
-        component_defs = ""
-
-    # Scan for CSS classes — only from components this page uses + page source
-    sx_css = ""
-    sx_css_classes = ""
-    sx_css_hash = ""
-    if registry_loaded():
-        classes = css_classes_for_page(page_sx, service=_ca.name)
-        # Always include body classes
-        classes.update(["bg-stone-50", "text-stone-900"])
-        rules = lookup_rules(classes)
-        sx_css = get_preamble() + rules
-        sx_css_hash = store_css_hash(classes)
-        sx_css_classes = sx_css_hash
-
-    asset_url = get_asset_url(ctx)
-    title = ctx.get("base_title", "Rose Ash")
-    csrf = _get_csrf_token()
-
-    # Dev mode: pretty-print page sx for readable View Source
-    if _is_dev_mode() and page_sx and page_sx.startswith("("):
-        from .parser import parse as _parse, serialize as _serialize
-        try:
-            page_sx = _serialize(_parse(page_sx), pretty=True)
-        except Exception as e:
-            import logging
-            logging.getLogger("sx").warning("Pretty-print page_sx failed: %s", e)
-
-    # Page registry for client-side routing
-    import logging
-    _plog = logging.getLogger("sx.pages")
-    from quart import current_app
-    pages_sx = _build_pages_sx(current_app.name)
-    _plog.debug("sx_page: pages_sx %d bytes for service %s", len(pages_sx), current_app.name)
-    if pages_sx:
-        _plog.debug("sx_page: pages_sx first 200 chars: %s", pages_sx[:200])
-
-    # Ensure page_sx is a plain str, not SxExpr — _build_component_ast
-    # parses SxExpr back into AST, which _arender then evaluates as HTML
-    # instead of passing through as raw content for the script tag.
+    """Return a minimal HTML shell that boots the page from sx source."""
+    # Ensure page_sx is a plain str
     if isinstance(page_sx, SxExpr):
         page_sx = "".join([page_sx])
 
-    # Per-app shell config: check explicit args, then app config, then defaults
-    from quart import current_app as _app
-    _shell_cfg = _app.config.get("SX_SHELL", {})
-    if head_scripts is None:
-        head_scripts = _shell_cfg.get("head_scripts")
-    if inline_css is None:
-        inline_css = _shell_cfg.get("inline_css")
-    if inline_head_js is None:
-        inline_head_js = _shell_cfg.get("inline_head_js")
-    if init_sx is None:
-        init_sx = _shell_cfg.get("init_sx")
-    if body_scripts is None:
-        body_scripts = _shell_cfg.get("body_scripts")
-
-    shell_kwargs: dict[str, Any] = dict(
-        title=_html_escape(title),
-        asset_url=asset_url,
-        meta_html=meta_html,
-        csrf=_html_escape(csrf),
-        component_hash=component_hash,
-        component_defs=component_defs,
-        pages_sx=pages_sx,
-        page_sx=page_sx,
-        sx_css=sx_css,
-        sx_css_classes=sx_css_classes,
-        sx_js_hash=_script_hash("sx-browser.js"),
-        body_js_hash=_script_hash("body.js"),
-    )
-    if head_scripts is not None:
-        shell_kwargs["head_scripts"] = head_scripts
-    if inline_css is not None:
-        shell_kwargs["inline_css"] = inline_css
-    if inline_head_js is not None:
-        shell_kwargs["inline_head_js"] = inline_head_js
-    if init_sx is not None:
-        shell_kwargs["init_sx"] = init_sx
-    if body_scripts is not None:
-        shell_kwargs["body_scripts"] = body_scripts
-    return await render_to_html("shared:shell/sx-page-shell", **shell_kwargs)
+    kwargs = await _build_shell_kwargs(
+        ctx, page_sx, meta_html=meta_html,
+        head_scripts=head_scripts, inline_css=inline_css,
+        inline_head_js=inline_head_js, init_sx=init_sx,
+        body_scripts=body_scripts)
+    kwargs["page_sx"] = page_sx
+    return await render_to_html("shared:shell/sx-page-shell", **kwargs)
 
 
 _SX_STREAMING_RESOLVE = """\

shared/sx/html.py

@@ -28,15 +28,163 @@ import contextvars
 from typing import Any
 
 from .types import Component, Island, Keyword, Lambda, Macro, NIL, Symbol
-from .ref.sx_ref import eval_expr as _raw_eval, call_component as _raw_call_component, expand_macro as _expand_macro, trampoline as _trampoline
+
 
 def _eval(expr, env):
-    """Evaluate and unwrap thunks — all html.py _eval calls are non-tail."""
-    return _trampoline(_raw_eval(expr, env))
+    """Minimal Python evaluator for sync html.py rendering.
 
-def _call_component(comp, raw_args, env):
-    """Call component and unwrap thunks — non-tail in html.py."""
-    return _trampoline(_raw_call_component(comp, raw_args, env))
+    Handles: literals, symbols, keywords, dicts, special forms (if, when,
+    cond, let, begin/do, and, or, str, not, list), lambda calls, and
+    primitive function calls. Enough for the sync sx() Jinja function.
+    """
+    from .primitives import _PRIMITIVES
+
+    # Literals
+    if isinstance(expr, (int, float, str, bool)):
+        return expr
+    if expr is None or expr is NIL:
+        return NIL
+
+    # Symbol lookup
+    if isinstance(expr, Symbol):
+        name = expr.name
+        if name in env:
+            return env[name]
+        if name in _PRIMITIVES:
+            return _PRIMITIVES[name]
+        if name == "true":
+            return True
+        if name == "false":
+            return False
+        if name == "nil":
+            return NIL
+        from .types import EvalError
+        raise EvalError(f"Undefined symbol: {name}")
+
+    # Keyword
+    if isinstance(expr, Keyword):
+        return expr.name
+
+    # Dict
+    if isinstance(expr, dict):
+        return {k: _eval(v, env) for k, v in expr.items()}
+
+    # List — dispatch
+    if not isinstance(expr, list):
+        return expr
+    if not expr:
+        return []
+
+    head = expr[0]
+    if isinstance(head, Symbol):
+        name = head.name
+
+        # Special forms
+        if name == "if":
+            cond = _eval(expr[1], env)
+            if cond and cond is not NIL:
+                return _eval(expr[2], env)
+            return _eval(expr[3], env) if len(expr) > 3 else NIL
+
+        if name == "when":
+            cond = _eval(expr[1], env)
+            if cond and cond is not NIL:
+                result = NIL
+                for body in expr[2:]:
+                    result = _eval(body, env)
+                return result
+            return NIL
+
+        if name == "let":
+            bindings = expr[1]
+            local = dict(env)
+            if isinstance(bindings, list):
+                if bindings and isinstance(bindings[0], list):
+                    for b in bindings:
+                        vname = b[0].name if isinstance(b[0], Symbol) else b[0]
+                        local[vname] = _eval(b[1], local)
+                elif len(bindings) % 2 == 0:
+                    for i in range(0, len(bindings), 2):
+                        vname = bindings[i].name if isinstance(bindings[i], Symbol) else bindings[i]
+                        local[vname] = _eval(bindings[i + 1], local)
+            result = NIL
+            for body in expr[2:]:
+                result = _eval(body, local)
+            return result
+
+        if name in ("begin", "do"):
+            result = NIL
+            for body in expr[1:]:
+                result = _eval(body, env)
+            return result
+
+        if name == "and":
+            result = True
+            for arg in expr[1:]:
+                result = _eval(arg, env)
+                if not result or result is NIL:
+                    return result
+            return result
+
+        if name == "or":
+            for arg in expr[1:]:
+                result = _eval(arg, env)
+                if result and result is not NIL:
+                    return result
+            return NIL
+
+        if name == "not":
+            val = _eval(expr[1], env)
+            return val is NIL or val is False or val is None
+
+        if name == "lambda" or name == "fn":
+            params_form = expr[1]
+            param_names = [p.name if isinstance(p, Symbol) else str(p) for p in params_form]
+            return Lambda(params=param_names, body=expr[2], closure=dict(env))
+
+        if name == "define":
+            var_name = expr[1].name if isinstance(expr[1], Symbol) else str(expr[1])
+            env[var_name] = _eval(expr[2], env)
+            return NIL
+
+        if name == "quote":
+            return expr[1]
+
+        if name == "str":
+            parts = []
+            for arg in expr[1:]:
+                val = _eval(arg, env)
+                if val is NIL or val is None:
+                    parts.append("")
+                else:
+                    parts.append(str(val))
+            return "".join(parts)
+
+        if name == "list":
+            return [_eval(arg, env) for arg in expr[1:]]
+
+        # Primitive or function call
+        fn = _eval(head, env)
+    else:
+        fn = _eval(head, env)
+
+    # Evaluate args
+    args = [_eval(a, env) for a in expr[1:]]
+
+    # Call
+    if callable(fn):
+        return fn(*args)
+    if isinstance(fn, Lambda):
+        local = dict(fn.closure)
+        local.update(env)
+        for p, v in zip(fn.params, args):
+            local[p] = v
+        return _eval(fn.body, local)
+    return NIL
+
+
+def _expand_macro(*a, **kw):
+    raise RuntimeError("Macro expansion requires OCaml bridge")
 
 # ContextVar for collecting CSS class names during render.
 # Set to a set[str] to collect; None to skip.

shared/sx/jinja_bridge.py

@@ -30,11 +30,7 @@ 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":
-    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
+from .html import render as html_render, _render_component
 
 _logger = logging.getLogger("sx.bridge")
 
@@ -335,6 +331,9 @@ def reload_if_changed() -> None:
         _COMPONENT_ENV.clear()
         _CLIENT_LIBRARY_SOURCES.clear()
         _dirs_from_cache.clear()
+        invalidate_component_hash()
+        from .helpers import invalidate_shell_cache
+        invalidate_shell_cache()
         # Reload SX libraries first (e.g. z3.sx) so reader macros resolve
         for cb in _reload_callbacks:
             cb()
@@ -348,6 +347,14 @@ 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
+                _bridge._shell_statics_injected = False
+                _bridge._helpers_injected = False
+
         # Recompute render plans for all services that have pages
         from .pages import _PAGE_REGISTRY, compute_page_render_plans
         for svc in _PAGE_REGISTRY:
@@ -389,6 +396,40 @@ def load_handler_dir(directory: str, service_name: str) -> None:
         _load(directory, service_name)
 
 
+def _parse_defcomp_params(param_form: list) -> tuple[list[str], bool]:
+    """Extract keyword param names and has_children from a defcomp param list.
+
+    Handles: (&key p1 p2 &rest children), (&key (p1 :as type) &rest children),
+    (p1 p2), () etc.
+
+    Returns (param_names, has_children).
+    """
+    if not isinstance(param_form, list):
+        return [], False
+
+    params: list[str] = []
+    has_children = False
+    in_key = False
+    i = 0
+    while i < len(param_form):
+        item = param_form[i]
+        if isinstance(item, Symbol):
+            sname = item.name
+            if sname == "&key":
+                in_key = True
+            elif sname == "&rest":
+                has_children = True
+                i += 1  # skip the rest-param name (e.g. 'children')
+            else:
+                params.append(sname)
+        elif isinstance(item, list):
+            # Typed param: (name :as type)
+            if item and isinstance(item[0], Symbol):
+                params.append(item[0].name)
+        i += 1
+    return params, has_children
+
+
 def register_components(sx_source: str, *, _defer_postprocess: bool = False) -> None:
     """Parse and evaluate s-expression component definitions into the
     shared environment.
@@ -396,17 +437,30 @@ def register_components(sx_source: str, *, _defer_postprocess: bool = False) ->
     When *_defer_postprocess* is True, skip deps/io_refs/hash computation.
     Call ``finalize_components()`` once after all files are loaded.
     """
-    from .ref.sx_ref import eval_expr as _raw_eval, trampoline as _trampoline
-    _eval = lambda expr, env: _trampoline(_raw_eval(expr, env))
     from .parser import parse_all
     from .css_registry import scan_classes_from_sx
 
     # Snapshot existing component names before eval
     existing = set(_COMPONENT_ENV.keys())
 
+    # Evaluate definitions — OCaml kernel handles everything.
+    # Python-side component registry is populated with parsed params for CSS/deps.
     exprs = parse_all(sx_source)
     for expr in exprs:
-        _eval(expr, _COMPONENT_ENV)
+        if (isinstance(expr, list) and expr and isinstance(expr[0], Symbol)
+                and expr[0].name in ("defcomp", "defisland", "defmacro",
+                                      "define", "defstyle", "deftype",
+                                      "defeffect", "defrelation", "defhandler")):
+            name_sym = expr[1] if len(expr) > 1 else None
+            name = name_sym.name if hasattr(name_sym, 'name') else str(name_sym) if name_sym else None
+            if name and expr[0].name in ("defcomp", "defisland"):
+                params, has_children = _parse_defcomp_params(expr[2] if len(expr) > 3 else [])
+                cls = Island if expr[0].name == "defisland" else Component
+                _COMPONENT_ENV[name] = cls(
+                    name=name.lstrip("~"),
+                    params=params, has_children=has_children,
+                    body=expr[-1], closure={},
+                )
 
     # Pre-scan CSS classes for newly registered components.
     all_classes: set[str] | None = None
@@ -430,6 +484,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 +539,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)
@@ -563,25 +629,23 @@ def client_components_tag(*names: str) -> str:
 
 
 def components_for_page(page_sx: str, service: str | None = None) -> tuple[str, str]:
-    """Return (component_defs_source, page_hash) for a page.
+    """Return (component_defs_source, stable_hash) for a page.
 
-    Scans *page_sx* for component references, computes the transitive
-    closure, and returns only the definitions needed for this page.
+    Sends per-page component subsets for bandwidth, but the hash is
+    computed from the FULL component env — stable across all pages.
+    Browser caches once on first page load, subsequent navigations
+    hit the cache (same hash) without re-downloading.
 
-    When *service* is given, also includes deps for all :data pages
-    in that service so the client can render them without a server
-    roundtrip on navigation.
-
-    The hash is computed from the page-specific bundle for caching.
+    Components go to the client for: hydration, client-side routing,
+    data binding, and future CID-based caching.
     """
     from .deps import components_needed
     from .parser import serialize
 
     needed = components_needed(page_sx, _COMPONENT_ENV)
 
-    # Include deps for all :data pages so the client can render them.
-    # Pages with IO deps use the async render path (Phase 5) — the IO
-    # primitives are proxied via /sx/io/<name>.
+    # Include deps for all :data pages so the client can render them
+    # during client-side navigation.
     if service:
         from .pages import get_all_pages
         for page_def in get_all_pages(service).values():
@@ -592,7 +656,6 @@ def components_for_page(page_sx: str, service: str | None = None) -> tuple[str,
     if not needed:
         return "", ""
 
-    # Also include macros — they're needed for client-side expansion
     parts = []
     for key, val in _COMPONENT_ENV.items():
         if isinstance(val, Island):
@@ -605,10 +668,6 @@ def components_for_page(page_sx: str, service: str | None = None) -> tuple[str,
                 parts.append(f"(defisland ~{val.name} {params_sx} {body_sx})")
         elif isinstance(val, Component):
             if f"~{val.name}" in needed or key in needed:
-                # Skip server-affinity components — they're expanded server-side
-                # and the client doesn't have the define values they depend on.
-                if val.render_target == "server":
-                    continue
                 param_strs = ["&key"] + list(val.params)
                 if val.has_children:
                     param_strs.extend(["&rest", "children"])
@@ -616,8 +675,7 @@ def components_for_page(page_sx: str, service: str | None = None) -> tuple[str,
                 body_sx = serialize(val.body, pretty=True)
                 parts.append(f"(defcomp ~{val.name} {params_sx} {body_sx})")
         elif isinstance(val, Macro):
-            # Include macros that are referenced in needed components' bodies
-            # For now, include all macros (they're small and often shared)
+            # Include all macros — small and often shared across pages
             param_strs = list(val.params)
             if val.rest_param:
                 param_strs.extend(["&rest", val.rest_param])
@@ -631,10 +689,39 @@ def components_for_page(page_sx: str, service: str | None = None) -> tuple[str,
     # Prepend client library sources (define forms) before component defs
     all_parts = list(_CLIENT_LIBRARY_SOURCES) + parts
     source = "\n".join(all_parts)
-    digest = hashlib.sha256(source.encode()).hexdigest()[:12]
+
+    # Hash from FULL component env — stable across all pages.
+    # Browser caches by this hash; same hash = cache hit on navigation.
+    digest = _component_env_hash()
     return source, digest
 
 
+# Cached full-env hash — invalidated when components are reloaded.
+_env_hash_cache: str | None = None
+
+
+def _component_env_hash() -> str:
+    """Compute a stable hash from all loaded component names + bodies."""
+    global _env_hash_cache
+    if _env_hash_cache is not None:
+        return _env_hash_cache
+    from .parser import serialize
+    h = hashlib.sha256()
+    for key in sorted(_COMPONENT_ENV.keys()):
+        val = _COMPONENT_ENV[key]
+        if isinstance(val, (Island, Component, Macro)):
+            h.update(key.encode())
+            h.update(serialize(val.body).encode())
+    _env_hash_cache = h.hexdigest()[:12]
+    return _env_hash_cache
+
+
+def invalidate_component_hash():
+    """Call when components are reloaded (hot-reload, file change)."""
+    global _env_hash_cache
+    _env_hash_cache = None
+
+
 def css_classes_for_page(page_sx: str, service: str | None = None) -> set[str]:
     """Return CSS classes needed for a page's component bundle + page source.
 

shared/sx/ocaml_bridge.py

@@ -0,0 +1,980 @@
+"""
+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._in_io_handler = False  # re-entrancy guard
+        self._started = False
+        self._components_loaded = False
+        self._helpers_injected = False
+        self._io_cache: dict[tuple, Any] = {}  # (name, args...) → cached result
+        self._epoch: int = 0  # request epoch — monotonically increasing
+
+    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)
+        import sys
+        self._proc = await asyncio.create_subprocess_exec(
+            bin_path,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=sys.stderr,  # kernel timing/debug to container logs
+            limit=10 * 1024 * 1024,  # 10MB readline buffer for large spec data
+        )
+
+        # Wait for (ready)
+        line = await self._readline()
+        if line != "(ready)":
+            raise OcamlBridgeError(f"Expected (ready), got: {line!r}")
+
+        self._started = True
+
+        # Verify engine identity
+        await self._send_command("(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 _restart(self) -> None:
+        """Kill and restart the OCaml subprocess to recover from pipe desync."""
+        _logger.warning("Restarting OCaml SX kernel (pipe recovery)")
+        if self._proc and self._proc.returncode is None:
+            self._proc.kill()
+            await self._proc.wait()
+        self._proc = None
+        self._started = False
+        self._components_loaded = False
+        self._helpers_injected = False
+        await self.start()
+
+    async def ping(self) -> str:
+        """Health check — returns engine name (e.g. 'ocaml-cek')."""
+        async with self._lock:
+            await self._send_command("(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:
+            await self._send_command(f'(load "{_escape(path)}")')
+            value = await self._read_until_ok(ctx=None)
+            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:
+            await self._send_command(f'(load-source "{_escape(source)}")')
+            value = await self._read_until_ok(ctx=None)
+            return int(float(value)) if value else 0
+
+    async def eval(self, source: str, ctx: dict[str, Any] | None = None) -> str:
+        """Evaluate SX expression, return serialized result.
+
+        Supports io-requests (helper calls, query, action, etc.) via the
+        coroutine bridge, just like render().
+        """
+        await self._ensure_components()
+        async with self._lock:
+            await self._send_command('(eval-blob)')
+            await self._send_blob(source)
+            return await self._read_until_ok(ctx)
+
+    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:
+            await self._send_command(f'(render "{_escape(source)}")')
+            return await self._read_until_ok(ctx)
+
+    async def aser(self, source: str, ctx: dict[str, Any] | None = None) -> str:
+        """Evaluate SX and return SX wire format, handling io-requests."""
+        await self._ensure_components()
+        async with self._lock:
+            await self._send_command('(aser-blob)')
+            await self._send_blob(source)
+            return await self._read_until_ok(ctx)
+
+    async def aser_slot(self, source: str, ctx: dict[str, Any] | None = None) -> str:
+        """Like aser() but expands ALL components server-side.
+
+        Equivalent to Python's async_eval_slot_to_sx — used for layout
+        slots where component bodies need server-side IO evaluation.
+        """
+        await self._ensure_components()
+        async with self._lock:
+            # Inject helpers inside the lock to avoid pipe desync —
+            # a separate lock acquisition could let another coroutine
+            # interleave commands between injection and aser-slot.
+            await self._inject_helpers_locked()
+            await self._send_command('(aser-slot-blob)')
+            await self._send_blob(source)
+            return await self._read_until_ok(ctx)
+
+    _shell_statics_injected: bool = False
+
+    async def _inject_shell_statics_locked(self) -> None:
+        """Inject cached shell static data into kernel. MUST hold lock."""
+        if self._shell_statics_injected:
+            return
+        from .helpers import _get_shell_static
+        try:
+            static = _get_shell_static()
+        except Exception:
+            return  # not ready yet (no app context)
+        # Only inject small, safe values as kernel variables.
+        # Large/complex blobs use placeholder tokens at render time.
+        for key in ("component_hash", "sx_css_classes", "asset_url",
+                    "sx_js_hash", "body_js_hash"):
+            val = static.get(key) or ""
+            var = f"__shell-{key.replace('_', '-')}"
+            defn = f'(define {var} "{_escape(str(val))}")'
+            try:
+                await self._send_command(f'(load-source "{_escape(defn)}")')
+                await self._read_until_ok(ctx=None)
+            except OcamlBridgeError as e:
+                _logger.warning("Shell static inject failed for %s: %s", key, e)
+        # List/nil values
+        for key in ("head_scripts", "body_scripts"):
+            val = static.get(key)
+            var = f"__shell-{key.replace('_', '-')}"
+            if val is None:
+                defn = f'(define {var} nil)'
+            elif isinstance(val, list):
+                items = " ".join(f'"{_escape(str(v))}"' for v in val)
+                defn = f'(define {var} (list {items}))'
+            else:
+                defn = f'(define {var} "{_escape(str(val))}")'
+            try:
+                await self._send_command(f'(load-source "{_escape(defn)}")')
+                await self._read_until_ok(ctx=None)
+            except OcamlBridgeError as e:
+                _logger.warning("Shell static inject failed for %s: %s", key, e)
+        self._shell_statics_injected = True
+        _logger.info("Injected shell statics into OCaml kernel")
+
+    async def _inject_request_cookies_locked(self) -> None:
+        """Send current request cookies to kernel for get-cookie primitive."""
+        try:
+            from quart import request
+            cookies = request.cookies
+        except Exception:
+            return  # no request context (CLI mode, tests)
+        if not cookies:
+            return
+        # Build SX dict: {:name1 "val1" :name2 "val2"}
+        # Cookie values may be URL-encoded (client set-cookie uses
+        # encodeURIComponent) — decode before sending to kernel.
+        from urllib.parse import unquote
+        pairs = []
+        for k, v in cookies.items():
+            pairs.append(f':{k} "{_escape(unquote(str(v)))}"')
+        if pairs:
+            cmd = f'(set-request-cookies {{{" ".join(pairs)}}})'
+            try:
+                await self._send_command(cmd)
+                await self._read_until_ok(ctx=None)
+            except OcamlBridgeError as e:
+                _logger.debug("Cookie inject failed: %s", e)
+
+    async def sx_page_full(
+        self,
+        page_source: str,
+        shell_kwargs: dict[str, Any],
+        ctx: dict[str, Any] | None = None,
+    ) -> str:
+        """Render full page HTML in one OCaml call: aser-slot + shell render.
+
+        Static data (component_defs, CSS, pages_sx) is pre-injected as
+        kernel vars on first call. Per-request command sends only small
+        values (title, csrf) + references to the kernel vars.
+        """
+        await self._ensure_components()
+        async with self._lock:
+            await self._inject_helpers_locked()
+            await self._inject_shell_statics_locked()
+            # Send request cookies so get-cookie works during SSR
+            await self._inject_request_cookies_locked()
+            # Large/complex blobs use placeholders — OCaml renders the shell
+            # with short tokens; Python splices in the real values post-render.
+            # This avoids piping large strings or strings with special chars
+            # through the SX parser.
+            PLACEHOLDER_KEYS = {"component_defs", "pages_sx", "init_sx",
+                                "sx_css", "inline_css", "inline_head_js"}
+            placeholders = {}
+            static_keys = {"component_hash", "sx_css_classes", "asset_url",
+                           "sx_js_hash", "body_js_hash",
+                           "head_scripts", "body_scripts"}
+            # page_source is SX wire format that may contain \" escapes.
+            # Send via binary blob protocol to avoid double-escaping
+            # through the SX string parser round-trip.
+            parts = ['(sx-page-full-blob']
+            for key, val in shell_kwargs.items():
+                k = key.replace("_", "-")
+                if key in PLACEHOLDER_KEYS:
+                    token = f"__SLOT_{key.upper()}__"
+                    placeholders[token] = str(val) if val else ""
+                    parts.append(f' :{k} "{token}"')
+                elif key in static_keys:
+                    parts.append(f' :{k} __shell-{k}')
+                elif val is None:
+                    parts.append(f' :{k} nil')
+                elif isinstance(val, bool):
+                    parts.append(f' :{k} {"true" if val else "false"}')
+                elif isinstance(val, list):
+                    items = " ".join(f'"{_escape(str(v))}"' for v in val)
+                    parts.append(f' :{k} ({items})')
+                else:
+                    parts.append(f' :{k} "{_escape(str(val))}"')
+            parts.append(")")
+            cmd = "".join(parts)
+            await self._send_command(cmd)
+            # Send page source as binary blob (avoids string-escape issues)
+            await self._send_blob(page_source)
+            html = await self._read_until_ok(ctx)
+            # Splice in large blobs
+            for token, blob in placeholders.items():
+                html = html.replace(token, blob)
+            return html
+
+    async def _inject_helpers_locked(self) -> None:
+        """Inject page helpers into the kernel. MUST be called with lock held."""
+        if self._helpers_injected:
+            return
+        self._helpers_injected = True
+        try:
+            from .pages import get_page_helpers
+            import inspect
+            helpers = get_page_helpers("sx")
+            if not helpers:
+                self._helpers_injected = False
+                return
+            count = 0
+            for name, fn in helpers.items():
+                if callable(fn) and not name.startswith("~"):
+                    try:
+                        sig = inspect.signature(fn)
+                        nargs = sum(1 for p in sig.parameters.values()
+                                    if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD))
+                    except (ValueError, TypeError):
+                        nargs = 2
+                    nargs = max(nargs, 1)
+                    param_names = " ".join(chr(97 + i) for i in range(nargs))
+                    arg_list = " ".join(chr(97 + i) for i in range(nargs))
+                    sx_def = f'(define {name} (fn ({param_names}) (helper "{name}" {arg_list})))'
+                    try:
+                        await self._send_command(f'(load-source "{_escape(sx_def)}")')
+                        await self._read_until_ok(ctx=None)
+                        count += 1
+                    except OcamlBridgeError:
+                        pass
+            _logger.info("Injected %d page helpers into OCaml kernel", count)
+        except Exception as e:
+            _logger.warning("Helper injection failed: %s", e)
+            self._helpers_injected = False
+
+    async def _compile_adapter_module(self) -> None:
+        """Compile adapter-sx.sx to bytecode and load as a VM module.
+
+        Previously used Python's sx_ref.py evaluator for compilation.
+        Now the OCaml kernel handles JIT compilation natively — this method
+        is a no-op. The kernel's own JIT hook compiles functions on first call.
+        """
+        _logger.info("Adapter module compilation delegated to OCaml kernel JIT")
+
+    async def _ensure_components(self) -> None:
+        """Load all .sx source files into the kernel on first use.
+
+        Errors during loading are handled gracefully — IO responses are
+        always sent back to keep the pipe clean.
+        """
+        if self._components_loaded:
+            return
+        self._components_loaded = True
+        try:
+            from .jinja_bridge import _watched_dirs, _dirs_from_cache
+            import glob
+
+            # Skip patterns — files that use constructs not available in the kernel
+            skip_names = {"boundary.sx", "forms.sx"}
+            skip_dirs = {"tests"}
+
+            # Collect files to load
+            all_files: list[str] = []
+
+            # Core spec files
+            spec_dir = os.path.join(os.path.dirname(__file__), "../../spec")
+            for spec_file in ["parser.sx", "render.sx"]:
+                path = os.path.normpath(os.path.join(spec_dir, spec_file))
+                if os.path.isfile(path):
+                    all_files.append(path)
+
+            # Library files (compiler, vm, freeze — written in the language)
+            lib_dir = os.path.join(os.path.dirname(__file__), "../../lib")
+            for lib_file in ["bytecode.sx", "compiler.sx"]:
+                path = os.path.normpath(os.path.join(lib_dir, lib_file))
+                if os.path.isfile(path):
+                    all_files.append(path)
+
+            # All directories loaded into the Python env
+            all_dirs = list(set(_watched_dirs) | _dirs_from_cache)
+
+            # Isomorphic libraries: signals, rendering, web forms
+            web_dir = os.path.join(os.path.dirname(__file__), "../../web")
+            if os.path.isdir(web_dir):
+                for web_file in ["signals.sx", "adapter-html.sx", "adapter-sx.sx",
+                                 "web-forms.sx"]:
+                    path = os.path.normpath(os.path.join(web_dir, web_file))
+                    if os.path.isfile(path):
+                        all_files.append(path)
+            # Library files loaded after adapters (depend on scope primitives)
+            for lib_file in ["freeze.sx"]:
+                path = os.path.normpath(os.path.join(lib_dir, lib_file))
+                if os.path.isfile(path):
+                    all_files.append(path)
+
+            for directory in sorted(all_dirs):
+                files = sorted(
+                    glob.glob(os.path.join(directory, "**", "*.sx"), recursive=True)
+                )
+                for filepath in files:
+                    basename = os.path.basename(filepath)
+                    # Skip known-bad files
+                    if basename in skip_names:
+                        continue
+                    # Skip test and handler directories
+                    parts = filepath.replace("\\", "/").split("/")
+                    if any(d in skip_dirs for d in parts):
+                        continue
+                    all_files.append(filepath)
+
+            # Load all files under a single lock
+            count = 0
+            skipped = 0
+            async with self._lock:
+                for filepath in all_files:
+                    try:
+                        await self._send_command(f'(load "{_escape(filepath)}")')
+                        value = await self._read_until_ok(ctx=None)
+                        # Response may be a number (count) or a value — just count files
+                        count += 1
+                    except OcamlBridgeError as e:
+                        skipped += 1
+                        _logger.warning("OCaml load skipped %s: %s",
+                                        filepath, e)
+
+                # SSR overrides: effect is a no-op on the server (prevents
+                # reactive loops during island SSR — effects are DOM side-effects)
+                try:
+                    noop_dispose = '(fn () nil)'
+                    await self._send_command(f'(load-source "(define effect (fn (f) {noop_dispose}))")')
+                    await self._read_until_ok(ctx=None)
+                except OcamlBridgeError:
+                    pass
+
+                # Register JIT hook — lambdas compile on first call
+                try:
+                    await self._send_command('(vm-compile-adapter)')
+                    await self._read_until_ok(ctx=None)
+                    _logger.info("JIT hook registered — lambdas compile on first call")
+                except OcamlBridgeError as e:
+                    _logger.warning("JIT hook registration skipped: %s", e)
+            _logger.info("Loaded %d definitions from .sx files into OCaml kernel (%d skipped)",
+                         count, skipped)
+        except Exception as e:
+            _logger.error("Failed to load .sx files into OCaml kernel: %s", e)
+            self._components_loaded = False  # retry next time
+
+    async def inject_page_helpers(self, helpers: dict) -> None:
+        """Register page helpers as IO-routing definitions in the kernel.
+
+        Each helper becomes a function that yields (io-request "helper" name ...),
+        routing the call back to Python via the coroutine bridge.
+        """
+        await self._ensure_components()
+        async with self._lock:
+            count = 0
+            for name, fn in helpers.items():
+                if callable(fn) and not name.startswith("~"):
+                    sx_def = f'(define {name} (fn (&rest args) (apply helper (concat (list "{name}") args))))'
+                    try:
+                        await self._send_command(f'(load-source "{_escape(sx_def)}")')
+                        await self._read_until_ok(ctx=None)
+                        count += 1
+                    except OcamlBridgeError:
+                        pass  # non-fatal
+            if count:
+                _logger.info("Injected %d page helpers into OCaml kernel", count)
+
+    async def reset(self) -> None:
+        """Reset the kernel environment to pristine state."""
+        async with self._lock:
+            await self._send_command("(reset)")
+            kind, value = await self._read_response()
+            if kind == "error":
+                raise OcamlBridgeError(f"reset: {value}")
+
+    # ------------------------------------------------------------------
+    # Internal protocol handling
+    # ------------------------------------------------------------------
+
+    async def _send(self, line: str) -> None:
+        """Write a line to the subprocess stdin and flush."""
+        if self._in_io_handler:
+            raise OcamlBridgeError(
+                f"Re-entrant bridge call from IO handler: {line[:80]}. "
+                f"IO handlers must not call the bridge — use Python-only code."
+            )
+        assert self._proc and self._proc.stdin
+        _logger.debug("SEND: %s", line[:120])
+        self._proc.stdin.write((line + "\n").encode())
+        await self._proc.stdin.drain()
+
+    async def _send_command(self, line: str) -> None:
+        """Send a command with a fresh epoch prefix.
+
+        Increments the epoch counter and sends (epoch N) before the
+        actual command. The OCaml kernel tags all responses with this
+        epoch so stale messages from previous requests are discarded.
+        """
+        self._epoch += 1
+        assert self._proc and self._proc.stdin
+        _logger.debug("EPOCH %d SEND: %s", self._epoch, line[:120])
+        self._proc.stdin.write(f"(epoch {self._epoch})\n".encode())
+        self._proc.stdin.write((line + "\n").encode())
+        await self._proc.stdin.drain()
+
+    async def _send_blob(self, data: str) -> None:
+        """Send a length-prefixed binary blob to the subprocess.
+
+        Protocol: sends "(blob N)\\n" followed by exactly N bytes, then "\\n".
+        The OCaml side reads the length, then reads exactly N bytes.
+        This avoids string-escape round-trip issues for SX wire format.
+        """
+        assert self._proc and self._proc.stdin
+        encoded = data.encode()
+        self._proc.stdin.write(f"(blob {len(encoded)})\n".encode())
+        self._proc.stdin.write(encoded)
+        self._proc.stdin.write(b"\n")
+        await self._proc.stdin.drain()
+
+    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
+            raise OcamlBridgeError(
+                "OCaml subprocess died unexpectedly (check container stderr)"
+            )
+        line = data.decode().rstrip("\n")
+        _logger.debug("RECV: %s", line[:120])
+        return line
+
+    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".
+        Discards stale epoch messages.
+        """
+        while True:
+            line = await self._readline()
+            if not self._is_current_epoch(line):
+                _logger.debug("Discarding stale response: %s", line[:80])
+                if line.startswith("(ok-len "):
+                    parts = line[1:-1].split()
+                    if len(parts) >= 3:
+                        n = int(parts[-1])
+                        assert self._proc and self._proc.stdout
+                        await self._proc.stdout.readexactly(n)
+                        await self._proc.stdout.readline()
+                continue
+            # Length-prefixed blob: (ok-len EPOCH N) or (ok-len N)
+            if line.startswith("(ok-len "):
+                parts = line[1:-1].split()
+                n = int(parts[-1])
+                assert self._proc and self._proc.stdout
+                data = await self._proc.stdout.readexactly(n)
+                await self._proc.stdout.readline()  # trailing newline
+                return ("ok", data.decode())
+            return _parse_response(line)
+
+    def _is_current_epoch(self, line: str) -> bool:
+        """Check if a response line belongs to the current epoch.
+
+        Lines tagged with a stale epoch are discarded. Untagged lines
+        (from a kernel that predates the epoch protocol) are accepted.
+        """
+        # Extract epoch number from known tagged formats:
+        #   (ok EPOCH ...), (error EPOCH ...), (ok-len EPOCH N),
+        #   (io-request EPOCH ...), (io-done EPOCH N)
+        import re
+        m = re.match(r'\((?:ok|error|ok-len|ok-raw|io-request|io-done)\s+(\d+)\b', line)
+        if m:
+            return int(m.group(1)) == self._epoch
+        # Untagged (legacy) — accept
+        return True
+
+    async def _read_until_ok(
+        self,
+        ctx: dict[str, Any] | None = None,
+    ) -> str:
+        """Read lines until (ok ...) or (error ...).
+
+        Handles IO requests in two modes:
+        - Legacy (blocking): single io-request → immediate io-response
+        - Batched: collect io-requests until (io-done N), process ALL
+          concurrently with asyncio.gather, send responses in order
+
+        Lines tagged with a stale epoch are silently discarded, making
+        pipe desync from previous failed requests impossible.
+        """
+        import asyncio
+        pending_batch: list[str] = []
+
+        while True:
+            line = await self._readline()
+
+            # Discard stale epoch messages
+            if not self._is_current_epoch(line):
+                _logger.debug("Discarding stale epoch message: %s", line[:80])
+                # If it's a stale ok-len, drain the blob bytes too
+                if line.startswith("(ok-len "):
+                    parts = line[1:-1].split()
+                    if len(parts) >= 3:
+                        n = int(parts[2])
+                        assert self._proc and self._proc.stdout
+                        await self._proc.stdout.readexactly(n)
+                        await self._proc.stdout.readline()
+                continue
+
+            if line.startswith("(io-request "):
+                # New format: (io-request EPOCH ...) or (io-request EPOCH ID ...)
+                # Strip epoch from the line for IO dispatch
+                after = line[len("(io-request "):].lstrip()
+                # Skip epoch number if present
+                if after and after[0].isdigit():
+                    # Could be epoch or batch ID — check for second number
+                    parts = after.split(None, 2)
+                    if len(parts) >= 2 and parts[1][0].isdigit():
+                        # (io-request EPOCH ID "name" args...) — batched with epoch
+                        pending_batch.append(line)
+                        continue
+                    elif len(parts) >= 2 and parts[1].startswith('"'):
+                        # (io-request EPOCH "name" args...) — legacy with epoch
+                        try:
+                            result = await self._handle_io_request(line, ctx)
+                            await self._send(
+                                f"(io-response {self._epoch} {_serialize_for_ocaml(result)})")
+                        except Exception as e:
+                            _logger.warning("IO request failed, sending nil: %s", e)
+                            await self._send(f"(io-response {self._epoch} nil)")
+                        continue
+                    else:
+                        # Old format: (io-request ID "name" ...) — batched, no epoch
+                        pending_batch.append(line)
+                        continue
+                # Legacy blocking mode — respond immediately
+                try:
+                    result = await self._handle_io_request(line, ctx)
+                    await self._send(
+                        f"(io-response {self._epoch} {_serialize_for_ocaml(result)})")
+                except Exception as e:
+                    _logger.warning("IO request failed, sending nil: %s", e)
+                    await self._send(f"(io-response {self._epoch} nil)")
+                continue
+
+            if line.startswith("(io-done "):
+                # Batch complete — process all pending IO concurrently
+                tasks = [self._handle_io_request(req, ctx)
+                         for req in pending_batch]
+                results = await asyncio.gather(*tasks, return_exceptions=True)
+                for result in results:
+                    if isinstance(result, BaseException):
+                        _logger.warning("Batched IO failed: %s", result)
+                        await self._send(f"(io-response {self._epoch} nil)")
+                    else:
+                        await self._send(
+                            f"(io-response {self._epoch} {_serialize_for_ocaml(result)})")
+                pending_batch = []
+                continue
+
+            # Length-prefixed blob: (ok-len EPOCH N) or (ok-len N)
+            if line.startswith("(ok-len "):
+                parts = line[1:-1].split()  # ["ok-len", epoch, n] or ["ok-len", n]
+                n = int(parts[-1])  # last number is always byte count
+                assert self._proc and self._proc.stdout
+                data = await self._proc.stdout.readexactly(n)
+                # Read trailing newline
+                await self._proc.stdout.readline()
+                return data.decode()
+
+            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.
+
+        IO handlers MUST NOT call the bridge (eval/aser/render) — doing so
+        would deadlock since the lock is already held.  The _in_io_handler
+        flag triggers an immediate error if this rule is violated.
+        """
+        self._in_io_handler = True
+        try:
+            return await self._dispatch_io(line, ctx)
+        finally:
+            self._in_io_handler = False
+
+    async def _dispatch_io(
+        self,
+        line: str,
+        ctx: dict[str, Any] | None,
+    ) -> Any:
+        """Inner dispatch for IO requests."""
+        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]
+        # Legacy: [Symbol("io-request"), name_str, ...args]
+        # Batched: [Symbol("io-request"), id_num, name_str, ...args]
+        if len(parts) < 2:
+            raise OcamlBridgeError(f"Malformed io-request: {line}")
+
+        # Skip numeric batch ID if present
+        offset = 1
+        if isinstance(parts[1], (int, float)):
+            offset = 2
+        req_name = _to_str(parts[offset])
+        args = parts[offset + 1:]
+
+        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)
+        elif req_name == "helper":
+            return await self._io_helper(args, ctx)
+        else:
+            # Fall back to registered IO handlers (set-response-status, sleep, etc.)
+            from .primitives_io import _IO_HANDLERS, RequestContext
+            io_handler = _IO_HANDLERS.get(req_name)
+            if io_handler is not None:
+                helper_args = [_to_python(a) for a in args]
+                return await io_handler(helper_args, {}, ctx or RequestContext())
+            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)
+
+    # Helpers that are pure functions — safe to cache by args.
+    _CACHEABLE_HELPERS = frozenset({
+        "highlight", "component-source", "primitives-data",
+        "special-forms-data", "reference-data", "read-spec-file",
+        "bootstrapper-data", "bundle-analyzer-data", "routing-analyzer-data",
+    })
+
+    async def _io_helper(self, args: list, ctx: dict[str, Any] | None) -> Any:
+        """Handle (io-request "helper" name arg1 arg2 ...).
+
+        Dispatches to registered page helpers — Python functions like
+        read-spec-file, bootstrapper-data, etc.  The helper service name
+        is passed via ctx["_helper_service"].
+
+        Pure helpers (highlight etc.) are cached — same input always
+        produces same output.  Eliminates blocking round-trips for
+        repeat calls across pages.
+        """
+        import asyncio
+        from .pages import get_page_helpers
+        from .primitives_io import _IO_HANDLERS, RequestContext
+
+        name = _to_str(args[0]) if args else ""
+        helper_args = [_to_python(a) for a in args[1:]]
+
+        # Cache lookup for pure helpers
+        if name in self._CACHEABLE_HELPERS:
+            cache_key = (name, *[repr(a) for a in helper_args])
+            if cache_key in self._io_cache:
+                return self._io_cache[cache_key]
+
+        # Check page helpers first (application-level)
+        service = (ctx or {}).get("_helper_service", "sx")
+        helpers = get_page_helpers(service)
+        fn = helpers.get(name)
+        if fn is not None:
+            result = fn(*helper_args)
+            if asyncio.iscoroutine(result):
+                result = await result
+            # Cache pure helper results
+            if name in self._CACHEABLE_HELPERS:
+                self._io_cache[cache_key] = result
+            return result
+
+        # Fall back to IO primitives (now, state-get, state-set!, etc.)
+        io_handler = _IO_HANDLERS.get(name)
+        if io_handler is not None:
+            return await io_handler(helper_args, {}, RequestContext())
+
+        # Fall back to regular primitives (json-encode, into, etc.)
+        from .primitives import get_primitive as _get_prim
+        prim = _get_prim(name)
+        if prim is not None:
+            return prim(*helper_args)
+
+        raise OcamlBridgeError(f"Unknown helper: {name!r}")
+
+
+# ------------------------------------------------------------------
+# 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.
+
+    Handles epoch-tagged responses: (ok EPOCH), (ok EPOCH value),
+    (error EPOCH "msg"), as well as legacy untagged responses.
+
+    Returns (kind, value) tuple.
+    """
+    line = line.strip()
+    # (ok EPOCH) — tagged no-value
+    if line == "(ok)" or (line.startswith("(ok ") and line[4:-1].isdigit()):
+        return ("ok", None)
+    if line.startswith("(ok-raw "):
+        # (ok-raw EPOCH value) or (ok-raw value)
+        inner = line[8:-1]
+        # Strip epoch if present
+        if inner and inner[0].isdigit():
+            space = inner.find(" ")
+            if space > 0:
+                inner = inner[space + 1:]
+            else:
+                return ("ok", None)
+        return ("ok", inner)
+    if line.startswith("(ok "):
+        inner = line[4:-1]  # strip (ok  and )
+        # Strip epoch number if present: (ok 42 "value") → "value"
+        if inner and inner[0].isdigit():
+            space = inner.find(" ")
+            if space > 0:
+                inner = inner[space + 1:]
+            else:
+                # (ok EPOCH) with no value
+                return ("ok", None)
+        # If the value is a quoted string, unquote it
+        if inner.startswith('"') and inner.endswith('"'):
+            inner = _unescape(inner[1:-1])
+        return ("ok", inner)
+    if line.startswith("(error "):
+        inner = line[7:-1]
+        # Strip epoch number if present: (error 42 "msg") → "msg"
+        if inner and inner[0].isdigit():
+            space = inner.find(" ")
+            if space > 0:
+                inner = inner[space + 1:]
+        if inner.startswith('"') and inner.endswith('"'):
+            inner = _unescape(inner[1:-1])
+        return ("error", inner)
+    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_python(val: Any) -> Any:
+    """Convert an SX parsed value to a plain Python value."""
+    from .types import NIL as _NIL
+    if val is None or val is _NIL:
+        return None
+    if hasattr(val, "name"):  # Symbol or Keyword
+        return val.name
+    return val
+
+
+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/ocaml_sync.py

@@ -0,0 +1,167 @@
+"""
+Synchronous OCaml bridge — persistent subprocess for build-time evaluation.
+
+Used by bootstrappers (JS cli.py, OCaml bootstrap.py) that need a sync
+evaluator to run transpiler.sx. For async runtime use, see ocaml_bridge.py.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+
+_DEFAULT_BIN = os.path.join(
+    os.path.dirname(__file__),
+    "../../hosts/ocaml/_build/default/bin/sx_server.exe",
+)
+
+
+class OcamlSyncError(Exception):
+    """Error from the OCaml SX kernel."""
+
+
+def _sx_unescape(s: str) -> str:
+    """Unescape an SX string literal (left-to-right, one pass)."""
+    out = []
+    i = 0
+    while i < len(s):
+        if s[i] == '\\' and i + 1 < len(s):
+            c = s[i + 1]
+            if c == 'n':
+                out.append('\n')
+            elif c == 'r':
+                out.append('\r')
+            elif c == 't':
+                out.append('\t')
+            elif c == '"':
+                out.append('"')
+            elif c == '\\':
+                out.append('\\')
+            else:
+                out.append(c)
+            i += 2
+        else:
+            out.append(s[i])
+            i += 1
+    return ''.join(out)
+
+
+class OcamlSync:
+    """Synchronous bridge to the OCaml sx_server subprocess."""
+
+    def __init__(self, binary: str | None = None):
+        self._binary = binary or os.environ.get("SX_OCAML_BIN") or _DEFAULT_BIN
+        self._proc: subprocess.Popen | None = None
+        self._epoch: int = 0
+
+    def _ensure(self):
+        if self._proc is not None and self._proc.poll() is None:
+            return
+        self._proc = subprocess.Popen(
+            [self._binary],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        self._epoch = 0
+        # Wait for (ready)
+        line = self._readline()
+        if line != "(ready)":
+            raise OcamlSyncError(f"Expected (ready), got: {line}")
+
+    def _send(self, command: str):
+        """Send a command with epoch prefix."""
+        assert self._proc and self._proc.stdin
+        self._epoch += 1
+        self._proc.stdin.write(f"(epoch {self._epoch})\n".encode())
+        self._proc.stdin.write((command + "\n").encode())
+        self._proc.stdin.flush()
+
+    def _readline(self) -> str:
+        assert self._proc and self._proc.stdout
+        data = self._proc.stdout.readline()
+        if not data:
+            raise OcamlSyncError("OCaml subprocess died unexpectedly")
+        return data.decode().rstrip("\n")
+
+    def _strip_epoch(self, inner: str) -> str:
+        """Strip leading epoch number from a response value: '42 value' → 'value'."""
+        if inner and inner[0].isdigit():
+            space = inner.find(" ")
+            if space > 0:
+                return inner[space + 1:]
+            return ""  # epoch only, no value
+        return inner
+
+    def _read_response(self) -> str:
+        """Read a single response. Returns the value string or raises on error.
+
+        Handles epoch-tagged responses: (ok EPOCH), (ok EPOCH value),
+        (ok-len EPOCH N), (error EPOCH "msg").
+        """
+        line = self._readline()
+        # Length-prefixed blob: (ok-len N) or (ok-len EPOCH N)
+        if line.startswith("(ok-len "):
+            parts = line[1:-1].split()  # ["ok-len", ...]
+            n = int(parts[-1])  # last number is always byte count
+            assert self._proc and self._proc.stdout
+            data = self._proc.stdout.read(n)
+            self._proc.stdout.readline()  # trailing newline
+            value = data.decode()
+            # Blob is SX-serialized — strip string quotes and unescape
+            if value.startswith('"') and value.endswith('"'):
+                value = _sx_unescape(value[1:-1])
+            return value
+        if line == "(ok)" or (line.startswith("(ok ") and line[4:-1].isdigit()):
+            return ""
+        if line.startswith("(ok-raw "):
+            inner = self._strip_epoch(line[8:-1])
+            return inner
+        if line.startswith("(ok "):
+            value = self._strip_epoch(line[4:-1])
+            if value.startswith('"') and value.endswith('"'):
+                value = _sx_unescape(value[1:-1])
+            return value
+        if line.startswith("(error "):
+            msg = self._strip_epoch(line[7:-1])
+            if msg.startswith('"') and msg.endswith('"'):
+                msg = _sx_unescape(msg[1:-1])
+            raise OcamlSyncError(msg)
+        raise OcamlSyncError(f"Unexpected response: {line}")
+
+    def eval(self, source: str) -> str:
+        """Evaluate SX source, return result as string."""
+        self._ensure()
+        escaped = source.replace("\\", "\\\\").replace('"', '\\"')
+        self._send(f'(eval "{escaped}")')
+        return self._read_response()
+
+    def load(self, path: str) -> str:
+        """Load an .sx file into the kernel."""
+        self._ensure()
+        self._send(f'(load "{path}")')
+        return self._read_response()
+
+    def load_source(self, source: str) -> str:
+        """Load SX source directly into the kernel."""
+        self._ensure()
+        escaped = source.replace("\\", "\\\\").replace('"', '\\"')
+        self._send(f'(load-source "{escaped}")')
+        return self._read_response()
+
+    def stop(self):
+        if self._proc and self._proc.poll() is None:
+            self._proc.terminate()
+            self._proc.wait(timeout=5)
+        self._proc = None
+
+
+# Singleton
+_global: OcamlSync | None = None
+
+
+def get_sync_bridge() -> OcamlSync:
+    global _global
+    if _global is None:
+        _global = OcamlSync()
+    return _global

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 html import escape 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
 # ---------------------------------------------------------------------------
@@ -124,29 +141,60 @@ def get_page_helpers(service: str) -> dict[str, Any]:
 # Loading — parse .sx files and collect PageDef instances
 # ---------------------------------------------------------------------------
 
+def _parse_defpage(expr: list) -> PageDef | None:
+    """Extract PageDef from a (defpage name :path ... :content ...) form."""
+    from .types import Keyword
+    if len(expr) < 3:
+        return None
+    name = expr[1].name if hasattr(expr[1], 'name') else str(expr[1])
+
+    kwargs: dict[str, Any] = {}
+    i = 2
+    while i < len(expr):
+        item = expr[i]
+        if isinstance(item, Keyword) and i + 1 < len(expr):
+            kwargs[item.name] = expr[i + 1]
+            i += 2
+        else:
+            i += 1
+
+    path = kwargs.get("path")
+    if not path or not isinstance(path, str):
+        return None
+
+    auth = kwargs.get("auth", "public")
+    if hasattr(auth, 'name'):
+        auth = auth.name
+
+    return PageDef(
+        name=name, path=path, auth=auth,
+        layout=kwargs.get("layout"),
+        cache=None,
+        data_expr=kwargs.get("data"),
+        content_expr=kwargs.get("content"),
+        filter_expr=kwargs.get("filter"),
+        aside_expr=kwargs.get("aside"),
+        menu_expr=kwargs.get("menu"),
+    )
+
+
 def load_page_file(filepath: str, service_name: str) -> list[PageDef]:
-    """Parse an .sx file, evaluate it, and register any PageDef values."""
+    """Parse an .sx file and register any defpage definitions."""
     from .parser import parse_all
-    from .ref.sx_ref import eval_expr as _raw_eval, trampoline as _trampoline
-    _eval = lambda expr, env: _trampoline(_raw_eval(expr, env))
-    from .jinja_bridge import get_component_env
 
     with open(filepath, encoding="utf-8") as f:
         source = f.read()
 
-    # Seed env with component definitions so pages can reference components
-    env = dict(get_component_env())
     exprs = parse_all(source)
     pages: list[PageDef] = []
 
     for expr in exprs:
-        _eval(expr, env)
-
-    # Collect all PageDef values from the env
-    for key, val in env.items():
-        if isinstance(val, PageDef):
-            register_page(service_name, val)
-            pages.append(val)
+        if (isinstance(expr, list) and expr
+                and hasattr(expr[0], 'name') and expr[0].name == "defpage"):
+            pd = _parse_defpage(expr)
+            if pd:
+                register_page(service_name, pd)
+                pages.append(pd)
 
     return pages
 
@@ -160,10 +208,95 @@ def load_page_dir(directory: str, service_name: str) -> list[PageDef]:
     return pages
 
 
+# ---------------------------------------------------------------------------
+# URL → SX expression conversion (was in sx_ref.py, pure logic)
+# ---------------------------------------------------------------------------
+
+def prepare_url_expr(url_path: str, env: dict) -> list:
+    """Convert a URL path to an SX expression, quoting unknown symbols."""
+    from .parser import parse_all
+    from .types import Symbol
+
+    if not url_path or url_path == "/":
+        return []
+    trimmed = url_path.lstrip("/")
+    sx_source = trimmed.replace(".", " ")
+    exprs = parse_all(sx_source)
+    if not exprs:
+        return []
+    expr = exprs[0]
+    if not isinstance(expr, list):
+        return expr
+    # Auto-quote unknown symbols (not in env, not keywords/components)
+    return _auto_quote(expr, env)
+
+
+def _auto_quote(expr, env: dict):
+    from .types import Symbol
+    if not isinstance(expr, list) or not expr:
+        return expr
+    head = expr[0]
+    children = []
+    for child in expr[1:]:
+        if isinstance(child, list):
+            children.append(_auto_quote(child, env))
+        elif isinstance(child, Symbol):
+            name = child.name
+            if (name in env or name.startswith(":") or
+                    name.startswith("~") or name.startswith("!")):
+                children.append(child)
+            else:
+                children.append(name)  # quote as string
+        else:
+            children.append(child)
+    return [head] + children
+
+
 # ---------------------------------------------------------------------------
 # Page execution
 # ---------------------------------------------------------------------------
 
+def _wrap_with_env(expr: Any, env: dict) -> str:
+    """Serialize an expression wrapped with let-bindings from env.
+
+    Injects page env values (URL params, data results) as let-bindings
+    so the OCaml kernel can evaluate the expression with those bindings.
+    Only injects non-component, non-callable values that pages add dynamically.
+    """
+    from .parser import serialize
+    from .ocaml_bridge import _serialize_for_ocaml
+    from .types import Symbol, Keyword, NIL
+
+    body = serialize(expr)
+    bindings = []
+    for k, v in env.items():
+        # Skip component definitions — already loaded in kernel
+        if k.startswith("~") or callable(v):
+            continue
+        # Skip env keys that are component-env infrastructure
+        if isinstance(v, (type, type(None))) and v is not None:
+            continue
+        # Serialize the value
+        if v is NIL or v is None:
+            sv = "nil"
+        elif isinstance(v, bool):
+            sv = "true" if v else "false"
+        elif isinstance(v, (int, float)):
+            sv = str(int(v)) if isinstance(v, float) and v == int(v) else str(v)
+        elif isinstance(v, str):
+            sv = _serialize_for_ocaml(v)
+        elif isinstance(v, (list, dict)):
+            sv = _serialize_for_ocaml(v)
+        else:
+            # Component, Lambda, etc — skip, already in kernel
+            continue
+        bindings.append(f"({k} {sv})")
+
+    if not bindings:
+        return body
+    return f"(let ({' '.join(bindings)}) {body})"
+
+
 async def _eval_slot(expr: Any, env: dict, ctx: Any) -> str:
     """Evaluate a page slot expression and return an sx source string.
 
@@ -171,10 +304,16 @@ async def _eval_slot(expr: Any, env: dict, ctx: Any) -> str:
     the result as SX wire format, not HTML.
     """
     import os
-    if os.environ.get("SX_USE_REF") == "1":
-        from .ref.async_eval_ref import async_eval_slot_to_sx
-    else:
-        from .async_eval import async_eval_slot_to_sx
+    if os.environ.get("SX_USE_OCAML") == "1":
+        from .ocaml_bridge import get_bridge
+        from .parser import serialize
+        bridge = await get_bridge()
+        # Wrap expression with let-bindings for env values that pages
+        # inject (URL params, data results, etc.)
+        sx_text = _wrap_with_env(expr, env)
+        service = ctx.get("_helper_service", "") if isinstance(ctx, dict) else ""
+        return await bridge.aser_slot(sx_text, ctx={"_helper_service": service})
+    from .async_eval import async_eval_slot_to_sx
     return await async_eval_slot_to_sx(expr, env, ctx)
 
 
@@ -231,12 +370,19 @@ async def execute_page(
     6. Branch: full_page_sx() vs oob_page_sx() based on is_htmx_request()
     """
     from .jinja_bridge import get_component_env, _get_request_context
-    from .async_eval import async_eval
     from .page import get_template_context
     from .helpers import full_page_sx, oob_page_sx, sx_response
     from .layouts import get_layout
     from shared.browser.app.utils.htmx import is_htmx_request
 
+    _use_ocaml = os.environ.get("SX_USE_OCAML") == "1"
+    if _use_ocaml:
+        from .ocaml_bridge import get_bridge
+        from .parser import serialize, parse_all
+        from .ocaml_bridge import _serialize_for_ocaml
+    else:
+        from .async_eval import async_eval
+
     if url_params is None:
         url_params = {}
 
@@ -258,7 +404,19 @@ async def execute_page(
     # Evaluate :data expression if present
     _multi_stream_content = None
     if page_def.data_expr is not None:
-        data_result = await async_eval(page_def.data_expr, env, ctx)
+        if _use_ocaml:
+            bridge = await get_bridge()
+            sx_text = _wrap_with_env(page_def.data_expr, env)
+            ocaml_ctx = {"_helper_service": service_name}
+            raw = await bridge.eval(sx_text, ctx=ocaml_ctx)
+            # Parse result back to Python dict/value
+            if raw:
+                parsed = parse_all(raw)
+                data_result = parsed[0] if parsed else {}
+            else:
+                data_result = {}
+        else:
+            data_result = await async_eval(page_def.data_expr, env, ctx)
         if hasattr(data_result, '__aiter__'):
             # Multi-stream: consume generator, eval :content per chunk,
             # combine into shell with resolved suspense slots.
@@ -341,7 +499,18 @@ async def execute_page(
                 k = raw[i]
                 if isinstance(k, SxKeyword) and i + 1 < len(raw):
                     raw_val = raw[i + 1]
-                    resolved = await async_eval(raw_val, env, ctx)
+                    if _use_ocaml:
+                        bridge = await get_bridge()
+                        sx_text = _wrap_with_env(raw_val, env)
+                        ocaml_ctx = {"_helper_service": service_name}
+                        raw_result = await bridge.eval(sx_text, ctx=ocaml_ctx)
+                        if raw_result:
+                            parsed = parse_all(raw_result)
+                            resolved = parsed[0] if parsed else None
+                        else:
+                            resolved = None
+                    else:
+                        resolved = await async_eval(raw_val, env, ctx)
                     layout_kwargs[k.name.replace("-", "_")] = resolved
                     i += 2
                 else:
@@ -511,8 +680,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 +697,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 +802,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 +906,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 +923,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 +1014,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/parser.py

@@ -38,10 +38,11 @@ def _resolve_sx_reader_macro(name: str):
     If a file like z3.sx defines (define z3-translate ...), then #z3 is
     automatically available as a reader macro without any Python registration.
     Looks for {name}-translate as a Lambda in the component env.
+
+    Uses the synchronous OCaml bridge (ocaml_sync) when available.
     """
     try:
         from .jinja_bridge import get_component_env
-        from .ref.sx_ref import trampoline as _trampoline, call_lambda as _call_lambda
         from .types import Lambda
     except ImportError:
         return None
@@ -49,10 +50,18 @@ def _resolve_sx_reader_macro(name: str):
     fn = env.get(f"{name}-translate")
     if fn is None or not isinstance(fn, Lambda):
         return None
-    # Return a Python callable that invokes the SX lambda
-    def _sx_handler(expr):
-        return _trampoline(_call_lambda(fn, [expr], env))
-    return _sx_handler
+    # Use sync OCaml bridge to invoke the lambda
+    try:
+        from .ocaml_sync import OcamlSync
+        _sync = OcamlSync()
+        _sync.start()
+        def _sx_handler(expr):
+            from .parser import serialize as _ser
+            result = _sync.eval(f"({name}-translate {_ser(expr)})")
+            return parse(result) if result else expr
+        return _sx_handler
+    except Exception:
+        return None
 
 
 # ---------------------------------------------------------------------------

shared/sx/primitives.py

@@ -573,3 +573,60 @@ 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 _register_scope_primitives():
+    """Register scope/provide/collect primitive stubs.
+
+    The OCaml kernel provides the real implementations. These stubs exist
+    so _PRIMITIVES contains the names for dependency analysis, and so
+    any Python-side code that checks for their existence finds them.
+    """
+    import threading
+    _scope_data = threading.local()
+
+    def _collect(channel, value):
+        if not hasattr(_scope_data, 'collected'):
+            _scope_data.collected = {}
+        _scope_data.collected.setdefault(channel, []).append(value)
+        return NIL
+
+    def _collected(channel):
+        if not hasattr(_scope_data, 'collected'):
+            return []
+        return list(_scope_data.collected.get(channel, []))
+
+    def _clear_collected(channel):
+        if hasattr(_scope_data, 'collected'):
+            _scope_data.collected.pop(channel, None)
+        return NIL
+
+    def _emit(channel, value):
+        if not hasattr(_scope_data, 'emitted'):
+            _scope_data.emitted = {}
+        _scope_data.emitted.setdefault(channel, []).append(value)
+        return NIL
+
+    def _emitted(channel):
+        if not hasattr(_scope_data, 'emitted'):
+            return []
+        return list(_scope_data.emitted.get(channel, []))
+
+    def _context(key):
+        if not hasattr(_scope_data, 'context'):
+            return NIL
+        return _scope_data.context.get(key, NIL) if isinstance(_scope_data.context, dict) else NIL
+
+    _PRIMITIVES["collect!"] = _collect
+    _PRIMITIVES["collected"] = _collected
+    _PRIMITIVES["clear-collected!"] = _clear_collected
+    _PRIMITIVES["emitted"] = _emitted
+    _PRIMITIVES["emit!"] = _emit
+    _PRIMITIVES["context"] = _context
+
+_register_scope_primitives()
+

shared/sx/primitives_io.py

@@ -642,7 +642,8 @@ from . import primitives_ctx  # noqa: E402, F401
 # Auto-derive IO_PRIMITIVES from registered handlers
 # ---------------------------------------------------------------------------
 
-IO_PRIMITIVES: frozenset[str] = frozenset(_IO_HANDLERS.keys())
+# Placeholder — rebuilt at end of file after all handlers are registered
+IO_PRIMITIVES: frozenset[str] = frozenset()
 
 
 # ---------------------------------------------------------------------------
@@ -703,9 +704,45 @@ _PRIMITIVES["relations-from"] = _bridge_relations_from
 # Validate all IO handlers against boundary.sx
 # ---------------------------------------------------------------------------
 
+@register_io_handler("helper")
+async def _io_helper(
+    args: list[Any], kwargs: dict[str, Any], ctx: RequestContext
+) -> Any:
+    """``(helper "name" args...)`` → dispatch to page helpers or IO handlers.
+
+    Universal IO dispatcher — same interface as the OCaml kernel's helper
+    IO primitive. Checks page helpers first, then IO handlers.
+    """
+    if not args:
+        raise ValueError("helper requires a name")
+    name = str(args[0])
+    helper_args = args[1:]
+
+    # Check page helpers first
+    from .pages import get_page_helpers
+    helpers = get_page_helpers("sx")
+    fn = helpers.get(name)
+    if fn is not None:
+        import asyncio
+        result = fn(*helper_args)
+        if asyncio.iscoroutine(result):
+            result = await result
+        return result
+
+    # Fall back to IO handlers
+    io_handler = _IO_HANDLERS.get(name)
+    if io_handler is not None:
+        return await io_handler(helper_args, {}, ctx)
+
+    raise ValueError(f"Unknown helper: {name!r}")
+
+
 def _validate_io_handlers() -> None:
     from .boundary import validate_io
     for name in _IO_HANDLERS:
         validate_io(name)
 
 _validate_io_handlers()
+
+# Rebuild IO_PRIMITIVES now that all handlers (including helper) are registered
+IO_PRIMITIVES = frozenset(_IO_HANDLERS.keys())

shared/sx/query_executor.py

@@ -21,10 +21,6 @@ async def execute_query(query_def: QueryDef, params: dict[str, str]) -> Any:
     """
     from .jinja_bridge import get_component_env, _get_request_context
     import os
-    if os.environ.get("SX_USE_REF") == "1":
-        from .ref.async_eval_ref import async_eval
-    else:
-        from .async_eval import async_eval
 
     env = dict(get_component_env())
     env.update(query_def.closure)
@@ -38,6 +34,23 @@ async def execute_query(query_def: QueryDef, params: dict[str, str]) -> Any:
             val = int(val)
         env[param] = val
 
+    if os.environ.get("SX_USE_OCAML") == "1":
+        from .ocaml_bridge import get_bridge
+        from .parser import serialize, parse_all
+        from .pages import _wrap_with_env
+        bridge = await get_bridge()
+        sx_text = _wrap_with_env(query_def.body, env)
+        ctx = {"_helper_service": ""}
+        raw = await bridge.eval(sx_text, ctx=ctx)
+        if raw:
+            parsed = parse_all(raw)
+            result = parsed[0] if parsed else None
+        else:
+            result = None
+        return _normalize(result)
+
+    from .async_eval import async_eval
+
     ctx = _get_request_context()
     result = await async_eval(query_def.body, env, ctx)
     return _normalize(result)
@@ -50,10 +63,6 @@ async def execute_action(action_def: ActionDef, payload: dict[str, Any]) -> Any:
     """
     from .jinja_bridge import get_component_env, _get_request_context
     import os
-    if os.environ.get("SX_USE_REF") == "1":
-        from .ref.async_eval_ref import async_eval
-    else:
-        from .async_eval import async_eval
 
     env = dict(get_component_env())
     env.update(action_def.closure)
@@ -64,6 +73,23 @@ async def execute_action(action_def: ActionDef, payload: dict[str, Any]) -> Any:
         val = payload.get(param, payload.get(snake, NIL))
         env[param] = val
 
+    if os.environ.get("SX_USE_OCAML") == "1":
+        from .ocaml_bridge import get_bridge
+        from .parser import serialize, parse_all
+        from .pages import _wrap_with_env
+        bridge = await get_bridge()
+        sx_text = _wrap_with_env(action_def.body, env)
+        ctx = {"_helper_service": ""}
+        raw = await bridge.eval(sx_text, ctx=ctx)
+        if raw:
+            parsed = parse_all(raw)
+            result = parsed[0] if parsed else None
+        else:
+            result = None
+        return _normalize(result)
+
+    from .async_eval import async_eval
+
     ctx = _get_request_context()
     result = await async_eval(action_def.body, env, ctx)
     return _normalize(result)

shared/sx/query_registry.py

@@ -78,19 +78,18 @@ def clear(service: str | None = None) -> None:
 def load_query_file(filepath: str, service_name: str) -> list[QueryDef]:
     """Parse an .sx file and register any defquery definitions."""
     from .parser import parse_all
-    from .ref.sx_ref import eval_expr as _raw_eval, trampoline as _trampoline
-    _eval = lambda expr, env: _trampoline(_raw_eval(expr, env))
     from .jinja_bridge import get_component_env
 
     with open(filepath, encoding="utf-8") as f:
         source = f.read()
 
-    env = dict(get_component_env())
-    exprs = parse_all(source)
-    queries: list[QueryDef] = []
+    # Use the jinja_bridge register_components path which handles
+    # defquery/defaction via the OCaml kernel
+    from .jinja_bridge import register_components
+    register_components(source, _defer_postprocess=True)
 
-    for expr in exprs:
-        _eval(expr, env)
+    env = get_component_env()
+    queries: list[QueryDef] = []
 
     for val in env.values():
         if isinstance(val, QueryDef):
@@ -102,20 +101,15 @@ def load_query_file(filepath: str, service_name: str) -> list[QueryDef]:
 
 def load_action_file(filepath: str, service_name: str) -> list[ActionDef]:
     """Parse an .sx file and register any defaction definitions."""
-    from .parser import parse_all
-    from .ref.sx_ref import eval_expr as _raw_eval, trampoline as _trampoline
-    _eval = lambda expr, env: _trampoline(_raw_eval(expr, env))
-    from .jinja_bridge import get_component_env
+    from .jinja_bridge import get_component_env, register_components
 
     with open(filepath, encoding="utf-8") as f:
         source = f.read()
 
-    env = dict(get_component_env())
-    exprs = parse_all(source)
-    actions: list[ActionDef] = []
+    register_components(source, _defer_postprocess=True)
 
-    for expr in exprs:
-        _eval(expr, env)
+    env = get_component_env()
+    actions: list[ActionDef] = []
 
     for val in env.values():
         if isinstance(val, ActionDef):

shared/sx/ref/async_eval_ref.py

@@ -1,22 +0,0 @@
-"""Async evaluation — thin re-export from bootstrapped sx_ref.py.
-
-The async adapter (adapter-async.sx) is now bootstrapped directly into
-sx_ref.py alongside the sync evaluator.  This file re-exports the public
-API so existing imports keep working.
-
-All async rendering, serialization, and evaluation logic lives in the spec:
-  - shared/sx/ref/adapter-async.sx  (canonical SX source)
-  - shared/sx/ref/sx_ref.py         (bootstrapped Python)
-
-Platform async primitives (I/O dispatch, context vars, RequestContext)
-are in shared/sx/ref/platform_py.py → PLATFORM_ASYNC_PY.
-"""
-
-from . import sx_ref
-
-# Re-export the public API used by handlers.py, helpers.py, pages.py, etc.
-EvalError = sx_ref.EvalError
-async_eval = sx_ref.async_eval
-async_render = sx_ref.async_render
-async_eval_to_sx = sx_ref.async_eval_to_sx
-async_eval_slot_to_sx = sx_ref.async_eval_slot_to_sx

shared/sx/ref/bootstrap_test.py

@@ -1,245 +0,0 @@
-#!/usr/bin/env python3
-"""
-Bootstrap compiler: test.sx -> pytest test module.
-
-Reads test.sx and emits a Python test file that runs each deftest
-as a pytest test case, grouped into classes by defsuite.
-
-The emitted tests use the SX evaluator to run SX test bodies,
-verifying that the Python implementation matches the spec.
-
-Usage:
-    python bootstrap_test.py --output shared/sx/tests/test_sx_spec.py
-    pytest shared/sx/tests/test_sx_spec.py -v
-"""
-from __future__ import annotations
-
-import os
-import re
-import sys
-import argparse
-
-_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, Keyword, NIL as SX_NIL
-
-
-def _slugify(name: str) -> str:
-    """Convert a test/suite name to a valid Python identifier."""
-    s = name.lower().strip()
-    s = re.sub(r'[^a-z0-9]+', '_', s)
-    s = s.strip('_')
-    return s
-
-
-def _sx_to_source(expr) -> str:
-    """Convert an SX AST node back to SX source string."""
-    if isinstance(expr, bool):
-        return "true" if expr else "false"
-    if isinstance(expr, (int, float)):
-        return str(expr)
-    if isinstance(expr, str):
-        escaped = expr.replace('\\', '\\\\').replace('"', '\\"')
-        return f'"{escaped}"'
-    if expr is None or expr is SX_NIL:
-        return "nil"
-    if isinstance(expr, Symbol):
-        return expr.name
-    if isinstance(expr, Keyword):
-        return f":{expr.name}"
-    if isinstance(expr, dict):
-        pairs = []
-        for k, v in expr.items():
-            pairs.append(f":{k} {_sx_to_source(v)}")
-        return "{" + " ".join(pairs) + "}"
-    if isinstance(expr, list):
-        if not expr:
-            return "()"
-        return "(" + " ".join(_sx_to_source(e) for e in expr) + ")"
-    return str(expr)
-
-
-def _parse_test_sx(path: str) -> tuple[list[dict], list]:
-    """Parse test.sx and return (suites, preamble_exprs).
-
-    Preamble exprs are define forms (assertion helpers) that must be
-    evaluated before tests run. Suites contain the actual test cases.
-    """
-    with open(path) as f:
-        content = f.read()
-
-    exprs = parse_all(content)
-    suites = []
-    preamble = []
-
-    for expr in exprs:
-        if not isinstance(expr, list) or not expr:
-            continue
-        head = expr[0]
-        if isinstance(head, Symbol) and head.name == "defsuite":
-            suite = _parse_suite(expr)
-            if suite:
-                suites.append(suite)
-        elif isinstance(head, Symbol) and head.name == "define":
-            preamble.append(expr)
-
-    return suites, preamble
-
-
-def _parse_suite(expr: list) -> dict | None:
-    """Parse a (defsuite "name" ...) form."""
-    if len(expr) < 2:
-        return None
-
-    name = expr[1]
-    if not isinstance(name, str):
-        return None
-
-    tests = []
-    for child in expr[2:]:
-        if not isinstance(child, list) or not child:
-            continue
-        head = child[0]
-        if isinstance(head, Symbol):
-            if head.name == "deftest":
-                test = _parse_test(child)
-                if test:
-                    tests.append(test)
-            elif head.name == "defsuite":
-                sub = _parse_suite(child)
-                if sub:
-                    tests.append(sub)
-
-    return {"type": "suite", "name": name, "tests": tests}
-
-
-def _parse_test(expr: list) -> dict | None:
-    """Parse a (deftest "name" body ...) form."""
-    if len(expr) < 3:
-        return None
-    name = expr[1]
-    if not isinstance(name, str):
-        return None
-    body = expr[2:]
-    return {"type": "test", "name": name, "body": body}
-
-
-def _emit_py(suites: list[dict], preamble: list) -> str:
-    """Emit a pytest module from parsed suites."""
-    # Serialize preamble (assertion helpers) as SX source
-    preamble_sx = "\n".join(_sx_to_source(expr) for expr in preamble)
-    preamble_escaped = preamble_sx.replace('\\', '\\\\').replace("'", "\\'")
-
-    lines = []
-    lines.append('"""Auto-generated from test.sx — SX spec self-tests.')
-    lines.append('')
-    lines.append('DO NOT EDIT. Regenerate with:')
-    lines.append('    python shared/sx/ref/bootstrap_test.py --output shared/sx/tests/test_sx_spec.py')
-    lines.append('"""')
-    lines.append('from __future__ import annotations')
-    lines.append('')
-    lines.append('import pytest')
-    lines.append('from shared.sx.parser import parse_all')
-    lines.append('from shared.sx.ref.sx_ref import eval_expr as _eval, trampoline as _trampoline')
-    lines.append('')
-    lines.append('')
-    lines.append(f"_PREAMBLE = '''{preamble_escaped}'''")
-    lines.append('')
-    lines.append('')
-    lines.append('def _make_env() -> dict:')
-    lines.append('    """Create a fresh env with assertion helpers loaded."""')
-    lines.append('    env = {}')
-    lines.append('    for expr in parse_all(_PREAMBLE):')
-    lines.append('        _trampoline(_eval(expr, env))')
-    lines.append('    return env')
-    lines.append('')
-    lines.append('')
-    lines.append('def _run(sx_source: str, env: dict | None = None) -> object:')
-    lines.append('    """Evaluate SX source and return the result."""')
-    lines.append('    if env is None:')
-    lines.append('        env = _make_env()')
-    lines.append('    exprs = parse_all(sx_source)')
-    lines.append('    result = None')
-    lines.append('    for expr in exprs:')
-    lines.append('        result = _trampoline(_eval(expr, env))')
-    lines.append('    return result')
-    lines.append('')
-
-    for suite in suites:
-        _emit_suite(suite, lines, indent=0)
-
-    return "\n".join(lines)
-
-
-def _emit_suite(suite: dict, lines: list[str], indent: int):
-    """Emit a pytest class for a suite."""
-    class_name = f"TestSpec{_slugify(suite['name']).title().replace('_', '')}"
-    pad = "    " * indent
-    lines.append(f'{pad}class {class_name}:')
-    lines.append(f'{pad}    """test.sx suite: {suite["name"]}"""')
-    lines.append('')
-
-    for item in suite["tests"]:
-        if item["type"] == "test":
-            _emit_test(item, lines, indent + 1)
-        elif item["type"] == "suite":
-            _emit_suite(item, lines, indent + 1)
-
-    lines.append('')
-
-
-def _emit_test(test: dict, lines: list[str], indent: int):
-    """Emit a pytest test method."""
-    method_name = f"test_{_slugify(test['name'])}"
-    pad = "    " * indent
-
-    # Convert body expressions to SX source
-    body_parts = []
-    for expr in test["body"]:
-        body_parts.append(_sx_to_source(expr))
-
-    # Wrap in (do ...) if multiple expressions, or use single
-    if len(body_parts) == 1:
-        sx_source = body_parts[0]
-    else:
-        sx_source = "(do " + " ".join(body_parts) + ")"
-
-    # Escape for Python string
-    sx_escaped = sx_source.replace('\\', '\\\\').replace("'", "\\'")
-
-    lines.append(f"{pad}def {method_name}(self):")
-    lines.append(f"{pad}    _run('{sx_escaped}')")
-    lines.append('')
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Bootstrap test.sx to pytest")
-    parser.add_argument("--output", "-o", help="Output file path")
-    parser.add_argument("--dry-run", action="store_true", help="Print to stdout")
-    args = parser.parse_args()
-
-    test_sx = os.path.join(_HERE, "test.sx")
-    suites, preamble = _parse_test_sx(test_sx)
-
-    print(f"Parsed {len(suites)} suites, {len(preamble)} preamble defines from test.sx", file=sys.stderr)
-    total_tests = sum(
-        sum(1 for t in s["tests"] if t["type"] == "test")
-        for s in suites
-    )
-    print(f"Total test cases: {total_tests}", file=sys.stderr)
-
-    output = _emit_py(suites, preamble)
-
-    if args.output and not args.dry_run:
-        with open(args.output, "w") as f:
-            f.write(output)
-        print(f"Wrote {args.output}", file=sys.stderr)
-    else:
-        print(output)
-
-
-if __name__ == "__main__":
-    main()

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/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/demo-signals.html

@@ -1,182 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>SX Reactive Islands Demo</title>
-  <style>
-    * { box-sizing: border-box; margin: 0; padding: 0; }
-    body { font-family: system-ui, sans-serif; max-width: 640px; margin: 40px auto; padding: 0 20px; color: #1a1a2e; background: #f8f8fc; }
-    h1 { margin-bottom: 8px; font-size: 1.5rem; }
-    .subtitle { color: #666; margin-bottom: 32px; font-size: 0.9rem; }
-    .demo { background: white; border: 1px solid #e2e2ea; border-radius: 8px; padding: 20px; margin-bottom: 20px; }
-    .demo h2 { font-size: 1.1rem; margin-bottom: 12px; color: #2d2d4e; }
-    .demo-row { display: flex; align-items: center; gap: 12px; margin-bottom: 8px; }
-    button { background: #4a3f8a; color: white; border: none; border-radius: 4px; padding: 6px 16px; cursor: pointer; font-size: 0.9rem; }
-    button:hover { background: #5b4fa0; }
-    button:active { background: #3a2f7a; }
-    .value { font-size: 1.4rem; font-weight: 600; min-width: 3ch; text-align: center; }
-    .derived { color: #666; font-size: 0.85rem; }
-    .effect-log { background: #f0f0f8; border-radius: 4px; padding: 8px 12px; font-family: monospace; font-size: 0.8rem; max-height: 120px; overflow-y: auto; white-space: pre-wrap; }
-    .batch-indicator { display: inline-block; background: #e8f5e9; color: #2e7d32; padding: 2px 8px; border-radius: 3px; font-size: 0.8rem; }
-    code { background: #f0f0f8; padding: 2px 6px; border-radius: 3px; font-size: 0.85rem; }
-    .note { color: #888; font-size: 0.8rem; margin-top: 8px; }
-  </style>
-</head>
-<body>
-  <h1>SX Reactive Islands</h1>
-  <p class="subtitle">Signals transpiled from <code>signals.sx</code> spec via <code>bootstrap_js.py</code></p>
-
-  <!-- Demo 1: Basic signal -->
-  <div class="demo" id="demo-counter">
-    <h2>1. Signal: Counter</h2>
-    <div class="demo-row">
-      <button onclick="decr()">-</button>
-      <span class="value" id="count-display">0</span>
-      <button onclick="incr()">+</button>
-    </div>
-    <div class="derived" id="doubled-display"></div>
-    <p class="note"><code>signal</code> + <code>computed</code> + <code>effect</code></p>
-  </div>
-
-  <!-- Demo 2: Batch -->
-  <div class="demo" id="demo-batch">
-    <h2>2. Batch: Two signals, one notification</h2>
-    <div class="demo-row">
-      <span>first: <strong id="first-display">0</strong></span>
-      <span>second: <strong id="second-display">0</strong></span>
-      <span class="batch-indicator" id="render-count"></span>
-    </div>
-    <div class="demo-row">
-      <button onclick="batchBoth()">Batch increment both</button>
-      <button onclick="noBatchBoth()">No-batch increment both</button>
-    </div>
-    <p class="note"><code>batch</code> coalesces writes: 2 updates, 1 re-render</p>
-  </div>
-
-  <!-- Demo 3: Effect with cleanup -->
-  <div class="demo" id="demo-effect">
-    <h2>3. Effect: Auto-tracking + Cleanup</h2>
-    <div class="demo-row">
-      <button onclick="togglePolling()">Toggle polling</button>
-      <span id="poll-status"></span>
-    </div>
-    <div class="effect-log" id="effect-log"></div>
-    <p class="note"><code>effect</code> returns cleanup fn; dispose stops tracking</p>
-  </div>
-
-  <!-- Demo 4: Computed chains -->
-  <div class="demo" id="demo-chain">
-    <h2>4. Computed chain: base &rarr; doubled &rarr; quadrupled</h2>
-    <div class="demo-row">
-      <button onclick="chainDecr()">-</button>
-      <span>base: <strong id="chain-base">1</strong></span>
-      <button onclick="chainIncr()">+</button>
-    </div>
-    <div class="derived">
-      doubled: <strong id="chain-doubled"></strong> &nbsp;
-      quadrupled: <strong id="chain-quad"></strong>
-    </div>
-    <p class="note">Three-level computed dependency graph, auto-propagation</p>
-  </div>
-
-  <script src="sx-ref.js"></script>
-  <script>
-    // Grab signal primitives from transpiled runtime
-    var S = window.Sx;
-    var signal   = S.signal;
-    var deref    = S.deref;
-    var reset    = S.reset;
-    var swap     = S.swap;
-    var computed = S.computed;
-    var effect   = S.effect;
-    var batch    = S.batch;
-
-    // ---- Demo 1: Counter ----
-    var count = signal(0);
-    var doubled = computed(function() { return deref(count) * 2; });
-
-    effect(function() {
-      document.getElementById("count-display").textContent = deref(count);
-    });
-    effect(function() {
-      document.getElementById("doubled-display").textContent = "doubled: " + deref(doubled);
-    });
-
-    function incr() { swap(count, function(n) { return n + 1; }); }
-    function decr() { swap(count, function(n) { return n - 1; }); }
-
-    // ---- Demo 2: Batch ----
-    var first = signal(0);
-    var second = signal(0);
-    var renders = signal(0);
-
-    effect(function() {
-      document.getElementById("first-display").textContent = deref(first);
-      document.getElementById("second-display").textContent = deref(second);
-      swap(renders, function(n) { return n + 1; });
-    });
-    effect(function() {
-      document.getElementById("render-count").textContent = "renders: " + deref(renders);
-    });
-
-    function batchBoth() {
-      batch(function() {
-        swap(first, function(n) { return n + 1; });
-        swap(second, function(n) { return n + 1; });
-      });
-    }
-    function noBatchBoth() {
-      swap(first, function(n) { return n + 1; });
-      swap(second, function(n) { return n + 1; });
-    }
-
-    // ---- Demo 3: Effect with cleanup ----
-    var polling = signal(false);
-    var pollDispose = null;
-    var logEl = document.getElementById("effect-log");
-
-    function log(msg) {
-      logEl.textContent += msg + "\n";
-      logEl.scrollTop = logEl.scrollHeight;
-    }
-
-    effect(function() {
-      var active = deref(polling);
-      document.getElementById("poll-status").textContent = active ? "polling..." : "stopped";
-      if (active) {
-        var n = 0;
-        var id = setInterval(function() {
-          n++;
-          log("poll #" + n);
-        }, 500);
-        log("effect: started interval");
-        // Return cleanup function
-        return function() {
-          clearInterval(id);
-          log("cleanup: cleared interval");
-        };
-      }
-    });
-
-    function togglePolling() { swap(polling, function(v) { return !v; }); }
-
-    // ---- Demo 4: Computed chain ----
-    var base = signal(1);
-    var chainDoubled = computed(function() { return deref(base) * 2; });
-    var quadrupled = computed(function() { return deref(chainDoubled) * 2; });
-
-    effect(function() {
-      document.getElementById("chain-base").textContent = deref(base);
-    });
-    effect(function() {
-      document.getElementById("chain-doubled").textContent = deref(chainDoubled);
-    });
-    effect(function() {
-      document.getElementById("chain-quad").textContent = deref(quadrupled);
-    });
-
-    function chainIncr() { swap(base, function(n) { return n + 1; }); }
-    function chainDecr() { swap(base, function(n) { return n - 1; }); }
-  </script>
-</body>
-</html>

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

@@ -1,782 +0,0 @@
-;; ==========================================================================
-;; prove.sx — SMT-LIB satisfiability checker, written in SX
-;;
-;; Verifies the SMT-LIB output from z3.sx. For the class of assertions
-;; z3.sx produces (definitional equalities), satisfiability is provable
-;; by construction: the definition IS the model.
-;;
-;; This closes the loop:
-;;   primitives.sx → z3.sx → SMT-LIB → prove.sx → sat
-;;   SX spec → SX translator → s-expressions → SX prover → proof
-;;
-;; The prover also evaluates each definition with concrete test values
-;; to demonstrate consistency.
-;;
-;; Usage:
-;;   (prove-check smtlib-string)     — verify a single check-sat block
-;;   (prove-translate expr)          — translate + verify a define-* form
-;;   (prove-file exprs)              — verify all define-* forms
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; SMT-LIB expression evaluator
-;; --------------------------------------------------------------------------
-
-;; Evaluate an SMT-LIB expression in a variable environment
-(define smt-eval
-  (fn (expr (env :as dict))
-    (cond
-      ;; Numbers
-      (number? expr) expr
-
-      ;; String literals
-      (string? expr)
-        (cond
-          (= expr "true")  true
-          (= expr "false") false
-          :else expr)
-
-      ;; Booleans
-      (= expr true) true
-      (= expr false) false
-
-      ;; Symbols — look up in env
-      (= (type-of expr) "symbol")
-        (let ((name (symbol-name expr)))
-          (cond
-            (= name "true") true
-            (= name "false") false
-            :else (get env name expr)))
-
-      ;; Lists — function application
-      (list? expr)
-        (if (empty? expr) nil
-          (let ((head (first expr))
-                (args (rest expr)))
-            (if (not (= (type-of head) "symbol"))
-              expr
-              (let ((op (symbol-name head)))
-                (cond
-                  ;; Arithmetic
-                  (= op "+")
-                    (reduce (fn (a b) (+ a b)) 0
-                      (map (fn (a) (smt-eval a env)) args))
-                  (= op "-")
-                    (if (= (len args) 1)
-                      (- 0 (smt-eval (first args) env))
-                      (- (smt-eval (nth args 0) env)
-                         (smt-eval (nth args 1) env)))
-                  (= op "*")
-                    (reduce (fn (a b) (* a b)) 1
-                      (map (fn (a) (smt-eval a env)) args))
-                  (= op "/")
-                    (let ((a (smt-eval (nth args 0) env))
-                          (b (smt-eval (nth args 1) env)))
-                      (if (= b 0) 0 (/ a b)))
-                  (= op "div")
-                    (let ((a (smt-eval (nth args 0) env))
-                          (b (smt-eval (nth args 1) env)))
-                      (if (= b 0) 0 (/ a b)))
-                  (= op "mod")
-                    (let ((a (smt-eval (nth args 0) env))
-                          (b (smt-eval (nth args 1) env)))
-                      (if (= b 0) 0 (mod a b)))
-
-                  ;; Comparison
-                  (= op "=")
-                    (= (smt-eval (nth args 0) env)
-                       (smt-eval (nth args 1) env))
-                  (= op "<")
-                    (< (smt-eval (nth args 0) env)
-                       (smt-eval (nth args 1) env))
-                  (= op ">")
-                    (> (smt-eval (nth args 0) env)
-                       (smt-eval (nth args 1) env))
-                  (= op "<=")
-                    (<= (smt-eval (nth args 0) env)
-                        (smt-eval (nth args 1) env))
-                  (= op ">=")
-                    (>= (smt-eval (nth args 0) env)
-                        (smt-eval (nth args 1) env))
-
-                  ;; Logic
-                  (= op "and")
-                    (every? (fn (a) (smt-eval a env)) args)
-                  (= op "or")
-                    (some (fn (a) (smt-eval a env)) args)
-                  (= op "not")
-                    (not (smt-eval (first args) env))
-
-                  ;; ite (if-then-else)
-                  (= op "ite")
-                    (if (smt-eval (nth args 0) env)
-                      (smt-eval (nth args 1) env)
-                      (smt-eval (nth args 2) env))
-
-                  ;; Function call — look up in env
-                  :else
-                    (let ((fn-def (get env op nil)))
-                      (if (nil? fn-def)
-                        (list op (map (fn (a) (smt-eval a env)) args))
-                        ;; fn-def is {:params [...] :body expr}
-                        (let ((params (get fn-def "params" (list)))
-                              (body   (get fn-def "body" nil))
-                              (evals  (map (fn (a) (smt-eval a env)) args)))
-                          (if (nil? body)
-                            ;; Uninterpreted — return symbolic
-                            (list op evals)
-                            ;; Evaluate body with params bound
-                            (smt-eval body
-                              (merge env
-                                (smt-bind-params params evals))))))))))))
-
-      :else expr)))
-
-
-;; Bind parameter names to values
-(define smt-bind-params
-  (fn ((params :as list) (vals :as list))
-    (smt-bind-loop params vals {})))
-
-(define smt-bind-loop
-  (fn ((params :as list) (vals :as list) (acc :as dict))
-    (if (or (empty? params) (empty? vals))
-      acc
-      (smt-bind-loop (rest params) (rest vals)
-        (assoc acc (first params) (first vals))))))
-
-
-;; --------------------------------------------------------------------------
-;; SMT-LIB statement parser
-;; --------------------------------------------------------------------------
-
-;; Extract declarations and assertions from parsed SMT-LIB
-(define smt-extract-statements
-  (fn ((exprs :as list))
-    (smt-extract-loop exprs {} (list))))
-
-(define smt-extract-loop
-  (fn ((exprs :as list) (decls :as dict) (assertions :as list))
-    (if (empty? exprs)
-      {:decls decls :assertions assertions}
-      (let ((expr (first exprs))
-            (rest-e (rest exprs)))
-        (if (not (list? expr))
-          (smt-extract-loop rest-e decls assertions)
-          (if (empty? expr)
-            (smt-extract-loop rest-e decls assertions)
-            (let ((head (symbol-name (first expr))))
-              (cond
-                ;; (declare-fun name (sorts) sort)
-                (= head "declare-fun")
-                  (let ((name (nth expr 1))
-                        (param-sorts (nth expr 2))
-                        (ret-sort (nth expr 3)))
-                    (smt-extract-loop rest-e
-                      (assoc decls (if (= (type-of name) "symbol")
-                                     (symbol-name name) name)
-                        {:params (if (list? param-sorts)
-                                   (map (fn (s) (if (= (type-of s) "symbol")
-                                                  (symbol-name s) (str s)))
-                                        param-sorts)
-                                   (list))
-                         :ret (if (= (type-of ret-sort) "symbol")
-                                (symbol-name ret-sort) (str ret-sort))})
-                      assertions))
-
-                ;; (assert ...)
-                (= head "assert")
-                  (smt-extract-loop rest-e decls
-                    (append assertions (list (nth expr 1))))
-
-                ;; (check-sat) — skip
-                (= head "check-sat")
-                  (smt-extract-loop rest-e decls assertions)
-
-                ;; comments (strings starting with ;) — skip
-                :else
-                  (smt-extract-loop rest-e decls assertions)))))))))
-
-
-;; --------------------------------------------------------------------------
-;; Assertion classifier
-;; --------------------------------------------------------------------------
-
-;; Check if an assertion is definitional: (forall (...) (= (f ...) body))
-;; or (= (f) body) for nullary
-(define smt-definitional?
-  (fn (assertion)
-    (if (not (list? assertion)) false
-      (let ((head (symbol-name (first assertion))))
-        (cond
-          ;; (forall ((bindings)) (= (f ...) body))
-          (= head "forall")
-            (let ((body (nth assertion 2)))
-              (and (list? body)
-                   (= (symbol-name (first body)) "=")))
-          ;; (= (f ...) body)
-          (= head "=")
-            true
-          :else false)))))
-
-
-;; Extract the function name, parameters, and body from a definitional assertion
-(define smt-extract-definition
-  (fn (assertion)
-    (let ((head (symbol-name (first assertion))))
-      (cond
-        ;; (forall (((x Int) (y Int))) (= (f x y) body))
-        (= head "forall")
-          (let ((bindings (first (nth assertion 1)))
-                (eq-expr (nth assertion 2))
-                (call (nth eq-expr 1))
-                (body (nth eq-expr 2)))
-            {:name (if (= (type-of (first call)) "symbol")
-                     (symbol-name (first call)) (str (first call)))
-             :params (map (fn (b)
-                       (if (list? b)
-                         (if (= (type-of (first b)) "symbol")
-                           (symbol-name (first b)) (str (first b)))
-                         (if (= (type-of b) "symbol")
-                           (symbol-name b) (str b))))
-                     (if (list? bindings) bindings (list bindings)))
-             :body body})
-
-        ;; (= (f) body)
-        (= head "=")
-          (let ((call (nth assertion 1))
-                (body (nth assertion 2)))
-            {:name (if (list? call)
-                     (if (= (type-of (first call)) "symbol")
-                       (symbol-name (first call)) (str (first call)))
-                     (str call))
-             :params (list)
-             :body body})
-
-        :else nil))))
-
-
-;; --------------------------------------------------------------------------
-;; Test value generation
-;; --------------------------------------------------------------------------
-
-(define smt-test-values
-  (list
-    (list 0)
-    (list 1)
-    (list -1)
-    (list 5)
-    (list 42)
-    (list 1 2)
-    (list -3 7)
-    (list 5 5)
-    (list 100 -50)
-    (list 3 1)
-    (list 1 1 10)
-    (list 5 1 3)
-    (list -5 1 10)
-    (list 3 3 3)
-    (list 7 2 9)))
-
-
-;; --------------------------------------------------------------------------
-;; Proof engine
-;; --------------------------------------------------------------------------
-
-;; Verify a single definitional assertion by construction + evaluation
-(define smt-verify-definition
-  (fn ((def-info :as dict) (decls :as dict))
-    (let ((name (get def-info "name"))
-          (params (get def-info "params"))
-          (body (get def-info "body"))
-          (n-params (len params)))
-
-      ;; Build the model: define f = λparams.body
-      (let ((model (assoc decls name {:params params :body body}))
-            ;; Select test values matching arity
-            (tests (filter (fn ((tv :as list)) (= (len tv) n-params)) smt-test-values))
-            ;; Run tests
-            (results (map
-              (fn ((test-vals :as list))
-                (let ((env (merge model (smt-bind-params params test-vals)))
-                      ;; Evaluate body directly
-                      (body-result (smt-eval body env))
-                      ;; Evaluate via function call
-                      (call-expr (cons (first (sx-parse name)) test-vals))
-                      (call-result (smt-eval call-expr env)))
-                  {:vals test-vals
-                   :body-result body-result
-                   :call-result call-result
-                   :equal (= body-result call-result)}))
-              tests)))
-        {:name name
-         :status (if (every? (fn ((r :as dict)) (get r "equal")) results) "sat" "FAIL")
-         :proof "by construction (definition is the model)"
-         :tests-passed (len (filter (fn ((r :as dict)) (get r "equal")) results))
-         :tests-total (len results)
-         :sample (if (empty? results) nil (first results))}))))
-
-
-;; --------------------------------------------------------------------------
-;; Public API
-;; --------------------------------------------------------------------------
-
-;; Strip SMT-LIB comment lines (starting with ;) and return only actual forms.
-;; Handles comments that contain ( characters.
-(define smt-strip-comments
-  (fn ((s :as string))
-    (let ((lines (split s "\n"))
-          (non-comment (filter
-            (fn ((line :as string)) (not (starts-with? (trim line) ";")))
-            lines)))
-      (join "\n" non-comment))))
-
-;; Verify SMT-LIB output (string) — parse, classify, prove
-(define prove-check
-  (fn ((smtlib-str :as string))
-    (let ((parsed (sx-parse (smt-strip-comments smtlib-str)))
-          (stmts (smt-extract-statements parsed))
-          (decls (get stmts "decls"))
-          (assertions (get stmts "assertions")))
-      (if (empty? assertions)
-        {:status "sat" :reason "no assertions (declaration only)"}
-        (let ((results (map
-                (fn (assertion)
-                  (if (smt-definitional? assertion)
-                    (let ((def-info (smt-extract-definition assertion)))
-                      (if (nil? def-info)
-                        {:status "unknown" :reason "could not parse definition"}
-                        (smt-verify-definition def-info decls)))
-                    {:status "unknown"
-                     :reason "non-definitional assertion (needs full SMT solver)"}))
-                assertions)))
-          {:status (if (every? (fn ((r :as dict)) (= (get r "status") "sat")) results)
-                    "sat" "unknown")
-           :assertions (len assertions)
-           :results results})))))
-
-
-;; Translate a define-* form AND verify it — the full pipeline
-(define prove-translate
-  (fn (expr)
-    (let ((smtlib (z3-translate expr))
-          (proof (prove-check smtlib))
-          (status (get proof "status"))
-          (results (get proof "results" (list))))
-      (str smtlib "\n"
-           ";; ─── prove.sx ───\n"
-           ";; status: " status "\n"
-           (if (empty? results) ""
-             (let ((r (first results)))
-               (str ";; proof:  " (get r "proof" "") "\n"
-                    ";; tested: " (str (get r "tests-passed" 0))
-                      "/" (str (get r "tests-total" 0))
-                      " ground instances\n")))))))
-
-
-;; Batch verify: translate and prove all define-* forms
-(define prove-file
-  (fn ((exprs :as list))
-    (let ((translatable
-            (filter
-              (fn (expr)
-                (and (list? expr)
-                     (>= (len expr) 2)
-                     (= (type-of (first expr)) "symbol")
-                     (let ((name (symbol-name (first expr))))
-                       (or (= name "define-primitive")
-                           (= name "define-io-primitive")
-                           (= name "define-special-form")))))
-              exprs))
-          (results (map
-            (fn (expr)
-              (let ((smtlib (z3-translate expr))
-                    (proof (prove-check smtlib))
-                    (name (nth expr 1)))
-                (assoc proof "name" name)))
-            translatable))
-          (sat-count (len (filter (fn ((r :as dict)) (= (get r "status") "sat")) results)))
-          (total (len results)))
-      {:total total
-       :sat sat-count
-       :all-sat (= sat-count total)
-       :results results})))
-
-
-;; ==========================================================================
-;; Phase 2: Property-based constraint solving
-;; ==========================================================================
-;;
-;; Properties are dicts:
-;;   {:name    "+-commutative"
-;;    :vars    ("a" "b")
-;;    :test    (fn (a b) (= (+ a b) (+ b a)))     — for bounded checking
-;;    :holds   (= (+ a b) (+ b a))                 — quoted AST for SMT-LIB
-;;    :given   (fn (lo hi) (<= lo hi))              — optional precondition
-;;    :given-expr (<= lo hi)                        — quoted AST of precondition
-;;    :domain  (-20 21)}                            — optional custom range
-
-
-;; --------------------------------------------------------------------------
-;; Domain generation
-;; --------------------------------------------------------------------------
-
-;; Default domain bounds by arity — balance coverage vs. combinatorics
-(define prove-domain-for
-  (fn ((arity :as number))
-    (cond
-      (<= arity 1) (range -50 51)       ;; 101 values
-      (= arity 2)  (range -20 21)       ;; 41^2 = 1,681 pairs
-      (= arity 3)  (range -8 9)         ;; 17^3 = 4,913 triples
-      :else        (range -5 6))))      ;; 11^n for n >= 4
-
-;; Cartesian product: all n-tuples from a domain
-(define prove-tuples
-  (fn ((domain :as list) (arity :as number))
-    (if (<= arity 0) (list (list))
-      (if (= arity 1)
-        (map (fn (x) (list x)) domain)
-        (let ((sub (prove-tuples domain (- arity 1))))
-          (prove-tuples-expand domain sub (list)))))))
-
-(define prove-tuples-expand
-  (fn ((domain :as list) (sub :as list) (acc :as list))
-    (if (empty? domain) acc
-      (prove-tuples-expand
-        (rest domain) sub
-        (append acc
-          (map (fn ((t :as list)) (cons (first domain) t)) sub))))))
-
-
-;; --------------------------------------------------------------------------
-;; Function application by arity (no apply primitive available)
-;; --------------------------------------------------------------------------
-
-(define prove-call
-  (fn ((f :as lambda) (vals :as list))
-    (let ((n (len vals)))
-      (cond
-        (= n 0) (f)
-        (= n 1) (f (nth vals 0))
-        (= n 2) (f (nth vals 0) (nth vals 1))
-        (= n 3) (f (nth vals 0) (nth vals 1) (nth vals 2))
-        (= n 4) (f (nth vals 0) (nth vals 1) (nth vals 2) (nth vals 3))
-        :else   nil))))
-
-
-;; --------------------------------------------------------------------------
-;; Bounded model checker
-;; --------------------------------------------------------------------------
-
-;; Search for a counterexample. Returns nil if property holds for all tested
-;; values, or the first counterexample found.
-(define prove-search
-  (fn ((test-fn :as lambda) given-fn (domain :as list) (vars :as list))
-    (let ((arity (len vars))
-          (tuples (prove-tuples domain arity)))
-      (prove-search-loop test-fn given-fn tuples 0 0))))
-
-(define prove-search-loop
-  (fn ((test-fn :as lambda) given-fn (tuples :as list) (tested :as number) (skipped :as number))
-    (if (empty? tuples)
-      {:status "verified" :tested tested :skipped skipped}
-      (let ((vals (first tuples))
-            (rest-t (rest tuples)))
-        ;; Check precondition (if any)
-        (if (and (not (nil? given-fn))
-                 (not (prove-call given-fn vals)))
-          ;; Precondition not met — skip this combination
-          (prove-search-loop test-fn given-fn rest-t tested (+ skipped 1))
-          ;; Evaluate the property
-          (if (prove-call test-fn vals)
-            ;; Passed — continue
-            (prove-search-loop test-fn given-fn rest-t (+ tested 1) skipped)
-            ;; Failed — counterexample found
-            {:status "falsified"
-             :tested tested
-             :skipped skipped
-             :counterexample vals}))))))
-
-
-;; --------------------------------------------------------------------------
-;; Property verification (public API)
-;; --------------------------------------------------------------------------
-
-;; Verify a single property via bounded model checking
-(define prove-property
-  (fn ((prop :as dict))
-    (let ((name     (get prop "name"))
-          (vars     (get prop "vars"))
-          (test-fn  (get prop "test"))
-          (given-fn (get prop "given" nil))
-          (custom   (get prop "domain" nil))
-          (domain   (if (nil? custom)
-                      (prove-domain-for (len vars))
-                      (range (nth custom 0) (nth custom 1)))))
-      (let ((result (prove-search test-fn given-fn domain vars)))
-        (assoc result "name" name)))))
-
-;; Batch verify a list of properties
-(define prove-properties
-  (fn ((props :as list))
-    (let ((results (map prove-property props))
-          (verified (filter (fn ((r :as dict)) (= (get r "status") "verified")) results))
-          (falsified (filter (fn ((r :as dict)) (= (get r "status") "falsified")) results)))
-      {:total     (len results)
-       :verified  (len verified)
-       :falsified (len falsified)
-       :all-verified (= (len falsified) 0)
-       :results   results})))
-
-
-;; --------------------------------------------------------------------------
-;; SMT-LIB generation for properties
-;; --------------------------------------------------------------------------
-
-;; Generate SMT-LIB for a property — asserts (not (forall ...)) so that
-;; Z3 returning "unsat" proves the property holds universally.
-(define prove-property-smtlib
-  (fn ((prop :as dict))
-    (let ((name      (get prop "name"))
-          (vars      (get prop "vars"))
-          (holds     (get prop "holds"))
-          (given-e   (get prop "given-expr" nil))
-          (bindings  (join " "
-                       (map (fn ((v :as string)) (str "(" v " Int)")) vars)))
-          (holds-smt (z3-expr holds))
-          (body      (if (nil? given-e)
-                       holds-smt
-                       (str "(=> " (z3-expr given-e) " " holds-smt ")"))))
-      (str "; Property: " name "\n"
-           "; Strategy: assert negation, check for unsat\n"
-           "(assert (not (forall ((" bindings "))\n"
-           "  " body ")))\n"
-           "(check-sat) ; expect unsat\n"))))
-
-;; Generate SMT-LIB for all properties, including necessary definitions
-(define prove-properties-smtlib
-  (fn ((props :as list) (primitives-exprs :as list))
-    (let ((defs (z3-translate-file primitives-exprs))
-          (prop-smts (map prove-property-smtlib props)))
-      (str ";; ================================================================\n"
-           ";; Auto-generated by prove.sx — property verification conditions\n"
-           ";; Feed to Z3 for unbounded proofs\n"
-           ";; ================================================================\n\n"
-           ";; --- Primitive definitions ---\n"
-           defs "\n\n"
-           ";; --- Properties ---\n"
-           (join "\n" prop-smts)))))
-
-
-;; ==========================================================================
-;; Property library: algebraic laws of SX primitives
-;; ==========================================================================
-
-(define sx-properties
-  (list
-
-    ;; ----- Arithmetic identities -----
-
-    {:name "+-commutative"
-     :vars (list "a" "b")
-     :test (fn (a b) (= (+ a b) (+ b a)))
-     :holds '(= (+ a b) (+ b a))}
-
-    {:name "+-associative"
-     :vars (list "a" "b" "c")
-     :test (fn (a b c) (= (+ (+ a b) c) (+ a (+ b c))))
-     :holds '(= (+ (+ a b) c) (+ a (+ b c)))}
-
-    {:name "+-identity"
-     :vars (list "a")
-     :test (fn (a) (= (+ a 0) a))
-     :holds '(= (+ a 0) a)}
-
-    {:name "*-commutative"
-     :vars (list "a" "b")
-     :test (fn (a b) (= (* a b) (* b a)))
-     :holds '(= (* a b) (* b a))}
-
-    {:name "*-associative"
-     :vars (list "a" "b" "c")
-     :test (fn (a b c) (= (* (* a b) c) (* a (* b c))))
-     :holds '(= (* (* a b) c) (* a (* b c)))}
-
-    {:name "*-identity"
-     :vars (list "a")
-     :test (fn (a) (= (* a 1) a))
-     :holds '(= (* a 1) a)}
-
-    {:name "*-zero"
-     :vars (list "a")
-     :test (fn (a) (= (* a 0) 0))
-     :holds '(= (* a 0) 0)}
-
-    {:name "distributive"
-     :vars (list "a" "b" "c")
-     :test (fn (a b c) (= (* a (+ b c)) (+ (* a b) (* a c))))
-     :holds '(= (* a (+ b c)) (+ (* a b) (* a c)))}
-
-    {:name "--inverse"
-     :vars (list "a")
-     :test (fn (a) (= (- a a) 0))
-     :holds '(= (- a a) 0)}
-
-    ;; ----- inc / dec -----
-
-    {:name "inc-is-plus-1"
-     :vars (list "n")
-     :test (fn (n) (= (inc n) (+ n 1)))
-     :holds '(= (inc n) (+ n 1))}
-
-    {:name "dec-is-minus-1"
-     :vars (list "n")
-     :test (fn (n) (= (dec n) (- n 1)))
-     :holds '(= (dec n) (- n 1))}
-
-    {:name "inc-dec-inverse"
-     :vars (list "n")
-     :test (fn (n) (= (dec (inc n)) n))
-     :holds '(= (dec (inc n)) n)}
-
-    {:name "dec-inc-inverse"
-     :vars (list "n")
-     :test (fn (n) (= (inc (dec n)) n))
-     :holds '(= (inc (dec n)) n)}
-
-    ;; ----- abs -----
-
-    {:name "abs-non-negative"
-     :vars (list "n")
-     :test (fn (n) (>= (abs n) 0))
-     :holds '(>= (abs n) 0)}
-
-    {:name "abs-idempotent"
-     :vars (list "n")
-     :test (fn (n) (= (abs (abs n)) (abs n)))
-     :holds '(= (abs (abs n)) (abs n))}
-
-    {:name "abs-symmetric"
-     :vars (list "n")
-     :test (fn (n) (= (abs n) (abs (- 0 n))))
-     :holds '(= (abs n) (abs (- 0 n)))}
-
-    ;; ----- Predicates -----
-
-    {:name "odd-not-even"
-     :vars (list "n")
-     :test (fn (n) (= (odd? n) (not (even? n))))
-     :holds '(= (odd? n) (not (even? n)))}
-
-    {:name "even-mod-2"
-     :vars (list "n")
-     :test (fn (n) (= (even? n) (= (mod n 2) 0)))
-     :holds '(= (even? n) (= (mod n 2) 0))}
-
-    {:name "zero-is-zero"
-     :vars (list "n")
-     :test (fn (n) (= (zero? n) (= n 0)))
-     :holds '(= (zero? n) (= n 0))}
-
-    {:name "not-involution"
-     :vars (list "n")
-     :test (fn (n) (= (not (not (zero? n))) (zero? n)))
-     :holds '(= (not (not (zero? n))) (zero? n))}
-
-    ;; ----- min / max -----
-
-    {:name "min-commutative"
-     :vars (list "a" "b")
-     :test (fn (a b) (= (min a b) (min b a)))
-     :holds '(= (min a b) (min b a))}
-
-    {:name "max-commutative"
-     :vars (list "a" "b")
-     :test (fn (a b) (= (max a b) (max b a)))
-     :holds '(= (max a b) (max b a))}
-
-    {:name "min-le-both"
-     :vars (list "a" "b")
-     :test (fn (a b) (and (<= (min a b) a) (<= (min a b) b)))
-     :holds '(and (<= (min a b) a) (<= (min a b) b))}
-
-    {:name "max-ge-both"
-     :vars (list "a" "b")
-     :test (fn (a b) (and (>= (max a b) a) (>= (max a b) b)))
-     :holds '(and (>= (max a b) a) (>= (max a b) b))}
-
-    {:name "min-max-identity"
-     :vars (list "a" "b")
-     :test (fn (a b) (= (+ (min a b) (max a b)) (+ a b)))
-     :holds '(= (+ (min a b) (max a b)) (+ a b))}
-
-    ;; ----- clamp -----
-
-    {:name "clamp-in-range"
-     :vars (list "x" "lo" "hi")
-     :test (fn (x lo hi) (and (<= lo (clamp x lo hi))
-                               (<= (clamp x lo hi) hi)))
-     :given (fn (x lo hi) (<= lo hi))
-     :holds '(and (<= lo (clamp x lo hi)) (<= (clamp x lo hi) hi))
-     :given-expr '(<= lo hi)}
-
-    {:name "clamp-identity-in-range"
-     :vars (list "x" "lo" "hi")
-     :test (fn (x lo hi) (= (clamp x lo hi) x))
-     :given (fn (x lo hi) (and (<= lo hi) (<= lo x) (<= x hi)))
-     :holds '(= (clamp x lo hi) x)
-     :given-expr '(and (<= lo hi) (<= lo x) (<= x hi))}
-
-    {:name "clamp-idempotent"
-     :vars (list "x" "lo" "hi")
-     :test (fn (x lo hi) (= (clamp (clamp x lo hi) lo hi)
-                             (clamp x lo hi)))
-     :given (fn (x lo hi) (<= lo hi))
-     :holds '(= (clamp (clamp x lo hi) lo hi) (clamp x lo hi))
-     :given-expr '(<= lo hi)}
-
-    ;; ----- Comparison -----
-
-    {:name "lt-gt-flip"
-     :vars (list "a" "b")
-     :test (fn (a b) (= (< a b) (> b a)))
-     :holds '(= (< a b) (> b a))}
-
-    {:name "le-not-gt"
-     :vars (list "a" "b")
-     :test (fn (a b) (= (<= a b) (not (> a b))))
-     :holds '(= (<= a b) (not (> a b)))}
-
-    {:name "ge-not-lt"
-     :vars (list "a" "b")
-     :test (fn (a b) (= (>= a b) (not (< a b))))
-     :holds '(= (>= a b) (not (< a b)))}
-
-    {:name "trichotomy"
-     :vars (list "a" "b")
-     :test (fn (a b) (or (< a b) (= a b) (> a b)))
-     :holds '(or (< a b) (= a b) (> a b))}
-
-    {:name "lt-transitive"
-     :vars (list "a" "b" "c")
-     :test (fn (a b c) (if (and (< a b) (< b c)) (< a c) true))
-     :given (fn (a b c) (and (< a b) (< b c)))
-     :holds '(< a c)
-     :given-expr '(and (< a b) (< b c))}
-
-    ;; ----- Inequality -----
-
-    {:name "neq-is-not-eq"
-     :vars (list "a" "b")
-     :test (fn (a b) (= (!= a b) (not (= a b))))
-     :holds '(= (!= a b) (not (= a b)))}))
-
-
-;; --------------------------------------------------------------------------
-;; Run all built-in properties
-;; --------------------------------------------------------------------------
-
-(define prove-all-properties
-  (fn ()
-    (prove-properties sx-properties)))

shared/sx/ref/reader_z3.py

@@ -1,89 +0,0 @@
-"""
-#z3 reader macro — translates SX spec declarations to SMT-LIB format.
-
-Self-hosted: loads z3.sx (the translator written in SX) and executes it
-via the SX evaluator. The Python code here is pure host infrastructure —
-all translation logic lives in z3.sx.
-
-Usage:
-    from shared.sx.ref.reader_z3 import z3_translate, register_z3_macro
-
-    # Register as reader macro (enables #z3 in parser)
-    register_z3_macro()
-
-    # Or call directly
-    smtlib = z3_translate(parse('(define-primitive "inc" :params (n) ...)'))
-"""
-from __future__ import annotations
-
-import os
-from typing import Any
-
-
-# ---------------------------------------------------------------------------
-# Load z3.sx into an evaluator environment (cached)
-# ---------------------------------------------------------------------------
-
-_z3_env: dict[str, Any] | None = None
-
-
-def _get_z3_env() -> dict[str, Any]:
-    """Load and evaluate z3.sx, returning the environment with all z3-* functions.
-
-    Platform primitives (type-of, symbol-name, keyword-name) are registered
-    in primitives.py. z3.sx uses canonical primitive names (get, assoc) so
-    no additional bindings are needed.
-    """
-    global _z3_env
-    if _z3_env is not None:
-        return _z3_env
-
-    from shared.sx.parser import parse_all
-    from shared.sx.ref.sx_ref import make_env, eval_expr as _eval, trampoline as _trampoline
-
-    env = make_env()
-    z3_path = os.path.join(os.path.dirname(__file__), "z3.sx")
-    with open(z3_path, encoding="utf-8") as f:
-        for expr in parse_all(f.read()):
-            _trampoline(_eval(expr, env))
-
-    _z3_env = env
-    return env
-
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-
-def z3_translate(expr: Any) -> str:
-    """Translate an SX define-* form to SMT-LIB.
-
-    Delegates to z3-translate defined in z3.sx.
-    """
-    from shared.sx.ref.sx_ref import trampoline as _trampoline, call_lambda as _call_lambda
-
-    env = _get_z3_env()
-    return _trampoline(_call_lambda(env["z3-translate"], [expr], env))
-
-
-def z3_translate_file(source: str) -> str:
-    """Parse an SX spec file and translate all define-* forms to SMT-LIB.
-
-    Delegates to z3-translate-file defined in z3.sx.
-    """
-    from shared.sx.parser import parse_all
-    from shared.sx.ref.sx_ref import trampoline as _trampoline, call_lambda as _call_lambda
-
-    env = _get_z3_env()
-    exprs = parse_all(source)
-    return _trampoline(_call_lambda(env["z3-translate-file"], [exprs], env))
-
-
-# ---------------------------------------------------------------------------
-# Reader macro registration
-# ---------------------------------------------------------------------------
-
-def register_z3_macro():
-    """Register #z3 as a reader macro in the SX parser."""
-    from shared.sx.parser import register_reader_macro
-    register_reader_macro("z3", z3_translate)

shared/sx/ref/run_cek_reactive_tests.py

@@ -1,249 +0,0 @@
-#!/usr/bin/env python3
-"""Run test-cek-reactive.sx — tests for deref-as-shift reactive rendering."""
-from __future__ import annotations
-import os, sys
-
-_HERE = os.path.dirname(os.path.abspath(__file__))
-_PROJECT = os.path.abspath(os.path.join(_HERE, "..", "..", ".."))
-sys.path.insert(0, _PROJECT)
-sys.setrecursionlimit(20000)
-
-from shared.sx.parser import 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,
-)
-# Use tree-walk evaluator for interpreting .sx test files.
-# The CEK override (eval_expr = cek_run) would cause the interpreted cek.sx
-# to delegate to the transpiled CEK, not the interpreted one being tested.
-# Override both the local names AND the module-level names so that transpiled
-# functions (ho_map, call_lambda, etc.) also use tree-walk internally.
-eval_expr = sx_ref._tree_walk_eval_expr
-trampoline = sx_ref._tree_walk_trampoline
-sx_ref.eval_expr = eval_expr
-sx_ref.trampoline = trampoline
-from shared.sx.types import (
-    NIL, Symbol, Keyword, Lambda, Component, Island, Continuation, Macro,
-    _ShiftSignal,
-)
-
-# Build env with primitives
-env = make_env()
-
-# Platform test functions
-_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
-
-def _test_env():
-    return env
-
-def _sx_parse(source):
-    return parse_all(source)
-
-def _sx_parse_one(source):
-    """Parse a single expression."""
-    exprs = parse_all(source)
-    return exprs[0] if exprs else NIL
-
-def _make_continuation(fn):
-    return Continuation(fn)
-
-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
-env["test-env"] = _test_env
-env["sx-parse"] = _sx_parse
-env["sx-parse-one"] = _sx_parse_one
-env["env-get"] = env_get
-env["env-has?"] = env_has
-env["env-set!"] = env_set
-env["env-extend"] = env_extend
-env["make-continuation"] = _make_continuation
-env["continuation?"] = lambda x: isinstance(x, Continuation)
-env["continuation-fn"] = lambda c: c.fn
-
-def _make_cek_continuation_with_data(captured, rest_kont):
-    c = Continuation(lambda v=NIL: v)
-    c._cek_data = {"captured": captured, "rest-kont": rest_kont}
-    return c
-
-env["make-cek-continuation"] = _make_cek_continuation_with_data
-env["continuation-data"] = lambda c: getattr(c, '_cek_data', {})
-
-# Type predicates and constructors
-env["callable?"] = lambda x: callable(x) or isinstance(x, (Lambda, Component, Island, Continuation))
-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-island"] = sx_ref.make_island
-env["make-macro"] = sx_ref.make_macro
-env["make-symbol"] = lambda n: Symbol(n)
-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-params"] = lambda c: c.params
-env["component-body"] = lambda c: c.body
-env["component-closure"] = lambda c: c.closure
-env["component-has-children?"] = lambda c: c.has_children
-env["component-affinity"] = lambda c: getattr(c, 'affinity', 'auto')
-env["component-set-param-types!"] = lambda c, t: setattr(c, 'param_types', t) or NIL
-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["env-merge"] = env_merge
-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["type-of"] = sx_ref.type_of
-env["primitive?"] = sx_ref.is_primitive
-env["get-primitive"] = sx_ref.get_primitive
-env["strip-prefix"] = lambda s, p: s[len(p):] if s.startswith(p) else s
-env["inspect"] = repr
-env["debug-log"] = lambda *args: None
-env["error"] = sx_ref.error
-env["apply"] = lambda f, args: f(*args)
-
-# Functions from eval.sx that cek.sx references
-env["trampoline"] = trampoline
-env["eval-expr"] = eval_expr
-env["eval-list"] = sx_ref.eval_list
-env["eval-call"] = sx_ref.eval_call
-env["call-lambda"] = sx_ref.call_lambda
-env["call-component"] = sx_ref.call_component
-env["parse-keyword-args"] = sx_ref.parse_keyword_args
-env["sf-lambda"] = sx_ref.sf_lambda
-env["sf-defcomp"] = sx_ref.sf_defcomp
-env["sf-defisland"] = sx_ref.sf_defisland
-env["sf-defmacro"] = sx_ref.sf_defmacro
-env["sf-defstyle"] = sx_ref.sf_defstyle
-env["sf-deftype"] = sx_ref.sf_deftype
-env["sf-defeffect"] = sx_ref.sf_defeffect
-env["sf-letrec"] = sx_ref.sf_letrec
-env["sf-named-let"] = sx_ref.sf_named_let
-env["sf-dynamic-wind"] = sx_ref.sf_dynamic_wind
-env["sf-scope"] = sx_ref.sf_scope
-env["sf-provide"] = sx_ref.sf_provide
-env["qq-expand"] = sx_ref.qq_expand
-env["expand-macro"] = sx_ref.expand_macro
-env["cond-scheme?"] = sx_ref.cond_scheme_p
-
-# Higher-order form handlers
-env["ho-map"] = sx_ref.ho_map
-env["ho-map-indexed"] = sx_ref.ho_map_indexed
-env["ho-filter"] = sx_ref.ho_filter
-env["ho-reduce"] = sx_ref.ho_reduce
-env["ho-some"] = sx_ref.ho_some
-env["ho-every"] = sx_ref.ho_every
-env["ho-for-each"] = sx_ref.ho_for_each
-env["call-fn"] = sx_ref.call_fn
-
-# Render-related (stub for testing — no active rendering)
-env["render-active?"] = lambda: False
-env["is-render-expr?"] = lambda expr: False
-env["render-expr"] = lambda expr, env: NIL
-
-# Scope primitives (needed for reactive-shift-deref island cleanup)
-env["scope-push!"] = sx_ref.PRIMITIVES.get("scope-push!", lambda *a: NIL)
-env["scope-pop!"] = sx_ref.PRIMITIVES.get("scope-pop!", lambda *a: NIL)
-env["context"] = sx_ref.PRIMITIVES.get("context", lambda *a: NIL)
-env["emit!"] = sx_ref.PRIMITIVES.get("emit!", lambda *a: NIL)
-env["emitted"] = sx_ref.PRIMITIVES.get("emitted", lambda *a: [])
-
-# Dynamic wind
-env["push-wind!"] = lambda before, after: NIL
-env["pop-wind!"] = lambda: NIL
-env["call-thunk"] = lambda f, e: f() if callable(f) else trampoline(eval_expr([f], e))
-
-# Mutation helpers
-env["dict-get"] = lambda d, k: d.get(k, NIL) if isinstance(d, dict) else NIL
-env["identical?"] = lambda a, b: a is b
-
-# defhandler, defpage, defquery, defaction stubs
-for name in ["sf-defhandler", "sf-defpage", "sf-defquery", "sf-defaction"]:
-    pyname = name.replace("-", "_")
-    fn = getattr(sx_ref, pyname, None)
-    if fn:
-        env[name] = fn
-    else:
-        env[name] = lambda args, e, _n=name: NIL
-
-# Load test framework
-with open(os.path.join(_HERE, "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:
-    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:
-    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:
-    for expr in parse_all(f.read()):
-        trampoline(eval_expr(expr, env))
-
-# Run tests
-print("=" * 60)
-print("Running test-cek-reactive.sx")
-print("=" * 60)
-
-with open(os.path.join(_HERE, "test-cek-reactive.sx")) as f:
-    for expr in parse_all(f.read()):
-        trampoline(eval_expr(expr, env))
-
-print("=" * 60)
-print(f"Results: {_pass_count} passed, {_fail_count} failed")
-print("=" * 60)
-sys.exit(1 if _fail_count > 0 else 0)

shared/sx/ref/run_cek_tests.py

@@ -1,265 +0,0 @@
-#!/usr/bin/env python3
-"""Run test-cek.sx using the bootstrapped evaluator with CEK module loaded."""
-from __future__ import annotations
-import os, 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.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,
-)
-# Use tree-walk evaluator for interpreting .sx test files.
-# The CEK override (eval_expr = cek_run) would cause the interpreted cek.sx
-# to delegate to the transpiled CEK, not the interpreted one being tested.
-# Override both the local names AND the module-level names so that transpiled
-# functions (ho_map, call_lambda, etc.) also use tree-walk internally.
-eval_expr = sx_ref._tree_walk_eval_expr
-trampoline = sx_ref._tree_walk_trampoline
-sx_ref.eval_expr = eval_expr
-sx_ref.trampoline = trampoline
-from shared.sx.types import (
-    NIL, Symbol, Keyword, Lambda, Component, Island, Continuation, Macro,
-    _ShiftSignal,
-)
-
-# Build env with primitives
-env = make_env()
-
-# Platform test functions
-_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
-
-def _test_env():
-    return env
-
-def _sx_parse(source):
-    return parse_all(source)
-
-def _sx_parse_one(source):
-    """Parse a single expression."""
-    exprs = parse_all(source)
-    return exprs[0] if exprs else NIL
-
-def _make_continuation(fn):
-    return Continuation(fn)
-
-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
-env["test-env"] = _test_env
-env["sx-parse"] = _sx_parse
-env["sx-parse-one"] = _sx_parse_one
-env["env-get"] = env_get
-env["env-has?"] = env_has
-env["env-set!"] = env_set
-env["env-extend"] = env_extend
-env["make-continuation"] = _make_continuation
-env["continuation?"] = lambda x: isinstance(x, Continuation)
-env["continuation-fn"] = lambda c: c.fn
-
-def _make_cek_continuation(captured, rest_kont):
-    """Create a Continuation that stores captured CEK frames as data."""
-    data = {"captured": captured, "rest-kont": rest_kont}
-    # The fn is a dummy — invocation happens via CEK's continue-with-call
-    return Continuation(lambda v=NIL: v)
-
-# Monkey-patch to store data
-_orig_make_cek_cont = _make_cek_continuation
-def _make_cek_continuation_with_data(captured, rest_kont):
-    c = _orig_make_cek_cont(captured, rest_kont)
-    c._cek_data = {"captured": captured, "rest-kont": rest_kont}
-    return c
-
-env["make-cek-continuation"] = _make_cek_continuation_with_data
-env["continuation-data"] = lambda c: getattr(c, '_cek_data', {})
-
-# Register platform functions from sx_ref that cek.sx and eval.sx need
-# These are normally available as transpiled Python but need to be in the
-# SX env when interpreting .sx files directly.
-
-# Type predicates and constructors
-env["callable?"] = lambda x: callable(x) or isinstance(x, (Lambda, Component, Island, Continuation))
-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-island"] = sx_ref.make_island
-env["make-macro"] = sx_ref.make_macro
-env["make-symbol"] = lambda n: Symbol(n)
-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-params"] = lambda c: c.params
-env["component-body"] = lambda c: c.body
-env["component-closure"] = lambda c: c.closure
-env["component-has-children?"] = lambda c: c.has_children
-env["component-affinity"] = lambda c: getattr(c, 'affinity', 'auto')
-env["component-set-param-types!"] = lambda c, t: setattr(c, 'param_types', t) or NIL
-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["env-merge"] = env_merge
-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["type-of"] = sx_ref.type_of
-env["primitive?"] = lambda n: n in sx_ref.PRIMITIVES
-env["get-primitive"] = lambda n: sx_ref.PRIMITIVES.get(n)
-env["strip-prefix"] = lambda s, p: s[len(p):] if s.startswith(p) else s
-env["inspect"] = repr
-env["debug-log"] = lambda *args: None
-env["error"] = sx_ref.error
-env["apply"] = lambda f, args: f(*args)
-
-# Functions from eval.sx that cek.sx references
-env["trampoline"] = trampoline
-env["eval-expr"] = eval_expr
-env["eval-list"] = sx_ref.eval_list
-env["eval-call"] = sx_ref.eval_call
-env["call-lambda"] = sx_ref.call_lambda
-env["call-component"] = sx_ref.call_component
-env["parse-keyword-args"] = sx_ref.parse_keyword_args
-env["sf-lambda"] = sx_ref.sf_lambda
-env["sf-defcomp"] = sx_ref.sf_defcomp
-env["sf-defisland"] = sx_ref.sf_defisland
-env["sf-defmacro"] = sx_ref.sf_defmacro
-env["sf-defstyle"] = sx_ref.sf_defstyle
-env["sf-deftype"] = sx_ref.sf_deftype
-env["sf-defeffect"] = sx_ref.sf_defeffect
-env["sf-letrec"] = sx_ref.sf_letrec
-env["sf-named-let"] = sx_ref.sf_named_let
-env["sf-dynamic-wind"] = sx_ref.sf_dynamic_wind
-env["sf-scope"] = sx_ref.sf_scope
-env["sf-provide"] = sx_ref.sf_provide
-env["qq-expand"] = sx_ref.qq_expand
-env["expand-macro"] = sx_ref.expand_macro
-env["cond-scheme?"] = sx_ref.cond_scheme_p
-
-# Higher-order form handlers
-env["ho-map"] = sx_ref.ho_map
-env["ho-map-indexed"] = sx_ref.ho_map_indexed
-env["ho-filter"] = sx_ref.ho_filter
-env["ho-reduce"] = sx_ref.ho_reduce
-env["ho-some"] = sx_ref.ho_some
-env["ho-every"] = sx_ref.ho_every
-env["ho-for-each"] = sx_ref.ho_for_each
-env["call-fn"] = sx_ref.call_fn
-
-# Render-related (stub for testing — no active rendering)
-env["render-active?"] = lambda: False
-env["is-render-expr?"] = lambda expr: False
-env["render-expr"] = lambda expr, env: NIL
-
-# Scope primitives
-env["scope-push!"] = sx_ref.PRIMITIVES.get("scope-push!", lambda *a: NIL)
-env["scope-pop!"] = sx_ref.PRIMITIVES.get("scope-pop!", lambda *a: NIL)
-env["context"] = sx_ref.PRIMITIVES.get("context", lambda *a: NIL)
-env["emit!"] = sx_ref.PRIMITIVES.get("emit!", lambda *a: NIL)
-env["emitted"] = sx_ref.PRIMITIVES.get("emitted", lambda *a: [])
-
-# Dynamic wind
-env["push-wind!"] = lambda before, after: NIL
-env["pop-wind!"] = lambda: NIL
-env["call-thunk"] = lambda f, e: f() if callable(f) else trampoline(eval_expr([f], e))
-
-# Mutation helpers used by parse-keyword-args etc
-env["dict-get"] = lambda d, k: d.get(k, NIL) if isinstance(d, dict) else NIL
-
-# defhandler, defpage, defquery, defaction — these are registrations
-# Use the bootstrapped versions if they exist, otherwise stub
-for name in ["sf-defhandler", "sf-defpage", "sf-defquery", "sf-defaction"]:
-    pyname = name.replace("-", "_")
-    fn = getattr(sx_ref, pyname, None)
-    if fn:
-        env[name] = fn
-    else:
-        env[name] = lambda args, e, _n=name: NIL
-
-# Load test framework
-with open(os.path.join(_HERE, "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:
-    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:
-    for expr in parse_all(f.read()):
-        trampoline(eval_expr(expr, env))
-
-# Define cek-eval helper in SX
-for expr in parse_all("""
-(define cek-eval
-  (fn (source)
-    (let ((exprs (sx-parse source)))
-      (let ((result nil))
-        (for-each (fn (e) (set! result (eval-expr-cek e (test-env)))) exprs)
-        result))))
-"""):
-    trampoline(eval_expr(expr, env))
-
-# Run tests
-print("=" * 60)
-print("Running test-cek.sx")
-print("=" * 60)
-
-with open(os.path.join(_HERE, "test-cek.sx")) as f:
-    for expr in parse_all(f.read()):
-        trampoline(eval_expr(expr, env))
-
-print("=" * 60)
-print(f"Results: {_pass_count} passed, {_fail_count} failed")
-print("=" * 60)
-sys.exit(1 if _fail_count > 0 else 0)

shared/sx/ref/run_continuation_tests.py

@@ -1,106 +0,0 @@
-#!/usr/bin/env python3
-"""Run test-continuations.sx using the bootstrapped evaluator with continuations enabled."""
-from __future__ import annotations
-import os, sys, subprocess, tempfile
-
-_HERE = os.path.dirname(os.path.abspath(__file__))
-_PROJECT = os.path.abspath(os.path.join(_HERE, "..", "..", ".."))
-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"),
-     "--extensions", "continuations"],
-    capture_output=True, text=True, cwd=_PROJECT,
-)
-if result.returncode != 0:
-    print("Bootstrap FAILED:")
-    print(result.stderr)
-    sys.exit(1)
-
-# Write to temp file and import
-tmp = tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, dir=_HERE)
-tmp.write(result.stdout)
-tmp.close()
-
-try:
-    import importlib.util
-    spec = importlib.util.spec_from_file_location("sx_ref_cont", tmp.name)
-    mod = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(mod)
-finally:
-    os.unlink(tmp.name)
-
-from shared.sx.types import NIL
-parse_all = mod.sx_parse
-
-# Use tree-walk evaluator for interpreting .sx test files.
-# CEK is now the default, but test runners need tree-walk so that
-# transpiled HO forms (ho_map, etc.) don't re-enter CEK mid-evaluation.
-eval_expr = mod._tree_walk_eval_expr
-trampoline = mod._tree_walk_trampoline
-mod.eval_expr = eval_expr
-mod.trampoline = trampoline
-env = mod.make_env()
-
-# Platform test functions
-_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
-
-# Load test framework
-with open(os.path.join(_HERE, "test-framework.sx")) as f:
-    for expr in parse_all(f.read()):
-        trampoline(eval_expr(expr, env))
-
-# Run tests
-print("=" * 60)
-print("Running test-continuations.sx")
-print("=" * 60)
-
-with open(os.path.join(_HERE, "test-continuations.sx")) as f:
-    for expr in parse_all(f.read()):
-        trampoline(eval_expr(expr, env))
-
-print("=" * 60)
-print(f"Results: {_pass_count} passed, {_fail_count} failed")
-print("=" * 60)
-sys.exit(1 if _fail_count > 0 else 0)

shared/sx/ref/run_py_sx.py

@@ -1,122 +0,0 @@
-#!/usr/bin/env python3
-"""
-Bootstrap runner: execute py.sx against spec files to produce sx_ref.py.
-
-This is the G1 bootstrapper — py.sx (SX-to-Python translator written in SX)
-is loaded into the Python evaluator, which then uses it to translate the
-spec .sx files into Python.
-
-The output should be identical to: python bootstrap_py.py
-
-Usage:
-    python run_py_sx.py > sx_ref_g1.py
-"""
-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
-from shared.sx.ref.platform_py import (
-    PREAMBLE, PLATFORM_PY, PRIMITIVES_PY_PRE, PRIMITIVES_PY_POST,
-    PLATFORM_DEPS_PY, FIXUPS_PY, CONTINUATIONS_PY,
-    _assemble_primitives_py, public_api_py,
-)
-
-
-def load_py_sx(evaluator_env: dict) -> dict:
-    """Load py.sx into an evaluator environment and return it."""
-    py_sx_path = os.path.join(_HERE, "py.sx")
-    with open(py_sx_path) as f:
-        source = f.read()
-
-    exprs = parse_all(source)
-
-    # Import the evaluator
-    from shared.sx.ref.sx_ref import evaluate, make_env
-
-    env = make_env()
-    for expr in exprs:
-        evaluate(expr, env)
-
-    return env
-
-
-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
-
-
-def main():
-    from shared.sx.ref.sx_ref import evaluate
-
-    # Load py.sx into evaluator
-    env = load_py_sx({})
-
-    # Get the py-translate-file function
-    py_translate_file = env.get("py-translate-file")
-    if py_translate_file is None:
-        print("ERROR: py-translate-file not found in py.sx environment", file=sys.stderr)
-        sys.exit(1)
-
-    # Same file list and order as bootstrap_py.py compile_ref_to_py()
-    sx_files = [
-        ("eval.sx", "eval"),
-        ("forms.sx", "forms (server definition forms)"),
-        ("render.sx", "render (core)"),
-        ("adapter-html.sx", "adapter-html"),
-        ("adapter-sx.sx", "adapter-sx"),
-        ("deps.sx", "deps (component dependency analysis)"),
-        ("signals.sx", "signals (reactive signal runtime)"),
-    ]
-
-    # Build output — static sections are identical
-    parts = []
-    parts.append(PREAMBLE)
-    parts.append(PLATFORM_PY)
-    parts.append(PRIMITIVES_PY_PRE)
-    parts.append(_assemble_primitives_py(None))
-    parts.append(PRIMITIVES_PY_POST)
-    parts.append(PLATFORM_DEPS_PY)
-
-    # Translate each spec file using py.sx
-    for filename, label in sx_files:
-        filepath = os.path.join(_HERE, filename)
-        if not os.path.exists(filepath):
-            continue
-        with open(filepath) as f:
-            src = f.read()
-        defines = extract_defines(src)
-
-        # Convert defines to SX-compatible format: list of [name, expr] pairs
-        sx_defines = [[name, expr] for name, expr in defines]
-
-        parts.append(f"\n# === Transpiled from {label} ===\n")
-        # Bind defines as data in env to avoid evaluator trying to execute AST
-        env["_defines"] = sx_defines
-        result = evaluate(
-            [Symbol("py-translate-file"), Symbol("_defines")],
-            env,
-        )
-        parts.append(result)
-
-    parts.append(FIXUPS_PY)
-    parts.append(public_api_py(True, True, True))
-
-    print("\n".join(parts))
-
-
-if __name__ == "__main__":
-    main()

shared/sx/ref/run_signal_tests.py

@@ -1,162 +0,0 @@
-#!/usr/bin/env python3
-"""Run test-signals.sx using the bootstrapped evaluator with signal primitives.
-
-Uses bootstrapped signal functions from sx_ref.py directly, patching apply
-to handle SX lambdas from the interpreter (test expressions create lambdas
-that need evaluator dispatch).
-"""
-from __future__ import annotations
-import os, 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.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, scope_push, scope_pop, sx_context
-from shared.sx.types import NIL, Island, Lambda
-# Use tree-walk evaluator for interpreting .sx test files.
-eval_expr = sx_ref._tree_walk_eval_expr
-trampoline = sx_ref._tree_walk_trampoline
-sx_ref.eval_expr = eval_expr
-sx_ref.trampoline = trampoline
-
-# Build env with primitives
-env = make_env()
-
-# --- Patch apply BEFORE anything else ---
-# Test expressions create SX Lambdas that bootstrapped code calls via apply.
-# Patch the module-level function so all bootstrapped functions see it.
-
-# apply is used by swap! and other forms to call functions with arg lists
-def _apply(f, args):
-    if isinstance(f, Lambda):
-        return trampoline(eval_expr([f] + list(args), env))
-    return f(*args)
-sx_ref.__dict__["apply"] = _apply
-
-# cons needs to handle tuples from Python *args (swap! passes &rest as tuple)
-_orig_cons = sx_ref.PRIMITIVES.get("cons")
-def _cons(x, c):
-    if isinstance(c, tuple):
-        c = list(c)
-    return [x] + (c or [])
-sx_ref.__dict__["cons"] = _cons
-sx_ref.PRIMITIVES["cons"] = _cons
-
-# Platform test functions
-_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
-
-# Signal functions are now pure SX (transpiled into sx_ref.py from signals.sx)
-# Wire both low-level dict-based signal functions and high-level API
-env["identical?"] = sx_ref.is_identical
-env["island?"] = lambda x: isinstance(x, Island)
-
-# Scope primitives (used by signals.sx for reactive tracking)
-env["scope-push!"] = scope_push
-env["scope-pop!"] = scope_pop
-env["context"] = sx_context
-
-# Low-level signal functions (now pure SX, transpiled from signals.sx)
-env["make-signal"] = sx_ref.make_signal
-env["signal?"] = sx_ref.is_signal
-env["signal-value"] = sx_ref.signal_value
-env["signal-set-value!"] = sx_ref.signal_set_value
-env["signal-subscribers"] = sx_ref.signal_subscribers
-env["signal-add-sub!"] = sx_ref.signal_add_sub
-env["signal-remove-sub!"] = sx_ref.signal_remove_sub
-env["signal-deps"] = sx_ref.signal_deps
-env["signal-set-deps!"] = sx_ref.signal_set_deps
-
-# Bootstrapped signal functions from sx_ref.py
-env["signal"] = sx_ref.signal
-env["deref"] = sx_ref.deref
-env["reset!"] = sx_ref.reset_b
-env["swap!"] = sx_ref.swap_b
-env["computed"] = sx_ref.computed
-env["effect"] = sx_ref.effect
-# batch has a bootstrapper issue with _batch_depth global variable access.
-# Wrap it to work correctly in the test context.
-def _batch(thunk):
-    sx_ref._batch_depth = getattr(sx_ref, '_batch_depth', 0) + 1
-    sx_ref.cek_call(thunk, None)
-    sx_ref._batch_depth -= 1
-    if sx_ref._batch_depth == 0:
-        queue = list(sx_ref._batch_queue)
-        sx_ref._batch_queue = []
-        seen = []
-        pending = []
-        for s in queue:
-            for sub in sx_ref.signal_subscribers(s):
-                if sub not in seen:
-                    seen.append(sub)
-                    pending.append(sub)
-        for sub in pending:
-            sub()
-    return NIL
-env["batch"] = _batch
-env["notify-subscribers"] = sx_ref.notify_subscribers
-env["flush-subscribers"] = sx_ref.flush_subscribers
-env["dispose-computed"] = sx_ref.dispose_computed
-env["with-island-scope"] = sx_ref.with_island_scope
-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:
-    for expr in parse_all(f.read()):
-        trampoline(eval_expr(expr, env))
-
-# Run tests
-print("=" * 60)
-print("Running test-signals.sx")
-print("=" * 60)
-
-with open(os.path.join(_HERE, "test-signals.sx")) as f:
-    for expr in parse_all(f.read()):
-        trampoline(eval_expr(expr, env))
-
-print("=" * 60)
-print(f"Results: {_pass_count} passed, {_fail_count} failed")
-print("=" * 60)
-sys.exit(1 if _fail_count > 0 else 0)

shared/sx/ref/run_type_tests.py

@@ -1,191 +0,0 @@
-#!/usr/bin/env python3
-"""Run test-types.sx using the bootstrapped evaluator with types module loaded."""
-from __future__ import annotations
-import os, 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.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
-from shared.sx.types import NIL, Component
-# Use tree-walk evaluator for interpreting .sx test files.
-# CEK is now the default, but the test runners need tree-walk so that
-# transpiled HO forms (ho_map, etc.) don't re-enter CEK mid-evaluation.
-eval_expr = sx_ref._tree_walk_eval_expr
-trampoline = sx_ref._tree_walk_trampoline
-sx_ref.eval_expr = eval_expr
-sx_ref.trampoline = trampoline
-
-# Build env with primitives
-env = make_env()
-
-# Platform test functions
-_suite_stack: list[str] = []
-_pass_count = 0
-_fail_count = 0
-
-def _try_call(thunk):
-    try:
-        trampoline(eval_expr([thunk], env))  # call the thunk
-        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 fixtures — provide the functions that tests expect
-
-# test-prim-types: dict of primitive return types for type inference
-def _test_prim_types():
-    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
-# Format: {name → {"positional" [["name" "type"] ...] "rest-type" type-or-nil}}
-def _test_prim_param_types():
-    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": 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},
-    }
-
-# test-env: returns a fresh env for use in tests (same as the test env)
-def _test_env():
-    return env
-
-# sx-parse: parse an SX string and return list of AST nodes
-def _sx_parse(source):
-    return parse_all(source)
-
-# dict-get: used in some legacy tests
-def _dict_get(d, k):
-    v = d.get(k) if isinstance(d, dict) else NIL
-    return v if v is not None else NIL
-
-# component-set-param-types! and component-param-types: type annotation accessors
-def _component_set_param_types(comp, types_dict):
-    comp.param_types = types_dict
-    return NIL
-
-def _component_param_types(comp):
-    return getattr(comp, 'param_types', NIL)
-
-# Platform functions used by types.sx but not SX primitives
-def _component_params(c):
-    return c.params
-
-def _component_body(c):
-    return c.body
-
-def _component_has_children(c):
-    return c.has_children
-
-def _map_dict(fn, d):
-    from shared.sx.types import Lambda as _Lambda
-    result = {}
-    for k, v in d.items():
-        if isinstance(fn, _Lambda):
-            # Call SX lambda through the evaluator
-            result[k] = trampoline(eval_expr([fn, k, v], env))
-        else:
-            result[k] = fn(k, v)
-    return result
-
-env["test-prim-types"] = _test_prim_types
-env["test-prim-param-types"] = _test_prim_param_types
-env["test-env"] = _test_env
-env["sx-parse"] = _sx_parse
-env["dict-get"] = _dict_get
-env["component-set-param-types!"] = _component_set_param_types
-env["component-param-types"] = _component_param_types
-env["component-params"] = _component_params
-env["component-body"] = _component_body
-env["component-has-children"] = _component_has_children
-env["map-dict"] = _map_dict
-env["env-get"] = env_get
-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:
-    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:
-    for expr in parse_all(f.read()):
-        trampoline(eval_expr(expr, env))
-
-# Run tests
-print("=" * 60)
-print("Running test-types.sx")
-print("=" * 60)
-
-with open(os.path.join(_HERE, "test-types.sx")) as f:
-    for expr in parse_all(f.read()):
-        trampoline(eval_expr(expr, env))
-
-print("=" * 60)
-print(f"Results: {_pass_count} passed, {_fail_count} failed")
-print("=" * 60)
-sys.exit(1 if _fail_count > 0 else 0)

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

@@ -1,358 +0,0 @@
-;; ==========================================================================
-;; z3.sx — SX spec to SMT-LIB translator, written in SX
-;;
-;; Translates define-primitive, define-io-primitive, and define-special-form
-;; declarations from the SX spec into SMT-LIB verification conditions for
-;; Z3 and other theorem provers.
-;;
-;; This is the first self-hosted bootstrapper: the SX evaluator (itself
-;; bootstrapped from eval.sx) executes this file against the spec to
-;; produce output in a different language. Same pattern as bootstrap_js.py
-;; and bootstrap_py.py, but written in SX instead of Python.
-;;
-;; Usage (from SX):
-;;   (z3-translate expr)         — translate one define-* form
-;;   (z3-translate-file exprs)   — translate a list of parsed expressions
-;;
-;; Usage (as reader macro):
-;;   #z3(define-primitive "inc" :params (n) :returns "number" :body (+ n 1))
-;;   → "; inc — ...\n(declare-fun inc (Int) Int)\n..."
-;; ==========================================================================
-
-
-;; --------------------------------------------------------------------------
-;; Type mapping: SX type names → SMT-LIB sorts
-;; --------------------------------------------------------------------------
-
-(define z3-sort
-  (fn ((sx-type :as string))
-    (case sx-type
-      "number"  "Int"
-      "boolean" "Bool"
-      "string"  "String"
-      "list"    "(List Value)"
-      "dict"    "(Array String Value)"
-      :else     "Value")))
-
-
-;; --------------------------------------------------------------------------
-;; Name translation: SX identifiers → SMT-LIB identifiers
-;; --------------------------------------------------------------------------
-
-(define z3-name
-  (fn ((name :as string))
-    (cond
-      (= name "!=") "neq"
-      (= name "+")  "+"
-      (= name "-")  "-"
-      (= name "*")  "*"
-      (= name "/")  "/"
-      (= name "=")  "="
-      (= name "<")  "<"
-      (= name ">")  ">"
-      (= name "<=") "<="
-      (= name ">=") ">="
-      :else (replace (replace (replace name "-" "_") "?" "_p") "!" "_bang"))))
-
-(define z3-sym
-  (fn (sym)
-    (let ((name (symbol-name sym)))
-      (cond
-        (ends-with? name "?")
-          (str "is_" (replace (slice name 0 (- (string-length name) 1)) "-" "_"))
-        :else
-          (replace (replace name "-" "_") "!" "_bang")))))
-
-
-;; --------------------------------------------------------------------------
-;; Expression translation: SX body expressions → SMT-LIB s-expressions
-;; --------------------------------------------------------------------------
-
-;; Operators that pass through unchanged
-(define z3-identity-ops
-  (list "+" "-" "*" "/" "=" "!=" "<" ">" "<=" ">=" "and" "or" "not" "mod"))
-
-;; Operators that get renamed
-(define z3-rename-op
-  (fn ((op :as string))
-    (case op
-      "if"  "ite"
-      "str" "str.++"
-      :else nil)))
-
-(define z3-expr
-  (fn (expr)
-    (cond
-      ;; Numbers
-      (number? expr)
-        (str expr)
-
-      ;; Strings
-      (string? expr)
-        (str "\"" expr "\"")
-
-      ;; Booleans
-      (= expr true)  "true"
-      (= expr false) "false"
-
-      ;; Nil
-      (nil? expr)
-        "nil_val"
-
-      ;; Symbols
-      (= (type-of expr) "symbol")
-        (z3-sym expr)
-
-      ;; Lists (function calls / special forms)
-      (list? expr)
-        (if (empty? expr)
-          "()"
-          (let ((head (first expr))
-                (args (rest expr)))
-            (if (not (= (type-of head) "symbol"))
-              (str expr)
-              (let ((op (symbol-name head)))
-                (cond
-                  ;; Identity ops: same syntax in both languages
-                  (some (fn (x) (= x op)) z3-identity-ops)
-                    (str "(" op " " (join " " (map z3-expr args)) ")")
-
-                  ;; Renamed ops
-                  (not (nil? (z3-rename-op op)))
-                    (str "(" (z3-rename-op op) " " (join " " (map z3-expr args)) ")")
-
-                  ;; max → ite
-                  (and (= op "max") (= (len args) 2))
-                    (let ((a (z3-expr (nth args 0)))
-                          (b (z3-expr (nth args 1))))
-                      (str "(ite (>= " a " " b ") " a " " b ")"))
-
-                  ;; min → ite
-                  (and (= op "min") (= (len args) 2))
-                    (let ((a (z3-expr (nth args 0)))
-                          (b (z3-expr (nth args 1))))
-                      (str "(ite (<= " a " " b ") " a " " b ")"))
-
-                  ;; empty? → length check
-                  (= op "empty?")
-                    (str "(= (len " (z3-expr (first args)) ") 0)")
-
-                  ;; first/rest → list ops
-                  (= op "first")
-                    (str "(head " (z3-expr (first args)) ")")
-                  (= op "rest")
-                    (str "(tail " (z3-expr (first args)) ")")
-
-                  ;; reduce with initial value
-                  (and (= op "reduce") (>= (len args) 3))
-                    (str "(reduce " (z3-expr (nth args 0)) " "
-                         (z3-expr (nth args 2)) " "
-                         (z3-expr (nth args 1)) ")")
-
-                  ;; fn (lambda)
-                  (= op "fn")
-                    (let ((params (first args))
-                          (body (nth args 1)))
-                      (str "(lambda (("
-                           (join " " (map (fn (p) (str "(" (z3-sym p) " Int)")) params))
-                           ")) " (z3-expr body) ")"))
-
-                  ;; native-* → strip prefix
-                  (starts-with? op "native-")
-                    (str "(" (slice op 7 (string-length op)) " "
-                         (join " " (map z3-expr args)) ")")
-
-                  ;; Generic function call
-                  :else
-                    (str "(" (z3-name op) " "
-                         (join " " (map z3-expr args)) ")"))))))
-
-      ;; Fallback
-      :else (str expr))))
-
-
-;; --------------------------------------------------------------------------
-;; Keyword argument extraction from define-* forms
-;; --------------------------------------------------------------------------
-
-(define z3-extract-kwargs
-  (fn ((expr :as list))
-    ;; Returns a dict of keyword args from a define-* form
-    ;; (define-primitive "name" :params (...) :returns "type" ...) → {:params ... :returns ...}
-    (let ((result {})
-          (items (rest (rest expr))))  ;; skip head and name
-      (z3-extract-kwargs-loop items result))))
-
-(define z3-extract-kwargs-loop
-  (fn ((items :as list) (result :as dict))
-    (if (or (empty? items) (< (len items) 2))
-      result
-      (if (= (type-of (first items)) "keyword")
-        (z3-extract-kwargs-loop
-          (rest (rest items))
-          (assoc result (keyword-name (first items)) (nth items 1)))
-        (z3-extract-kwargs-loop (rest items) result)))))
-
-
-;; --------------------------------------------------------------------------
-;; Parameter processing
-;; --------------------------------------------------------------------------
-
-(define z3-params-to-sorts
-  (fn ((params :as list))
-    ;; Convert SX param list to list of (name sort) pairs, skipping &rest/&key
-    (z3-params-loop params false (list))))
-
-(define z3-params-loop
-  (fn ((params :as list) (skip-next :as boolean) (acc :as list))
-    (if (empty? params)
-      acc
-      (let ((p (first params))
-            (rest-p (rest params)))
-        (cond
-          ;; &rest or &key marker — skip it and the next param
-          (and (= (type-of p) "symbol")
-               (or (= (symbol-name p) "&rest")
-                   (= (symbol-name p) "&key")))
-            (z3-params-loop rest-p true acc)
-          ;; Skipping the param after &rest/&key
-          skip-next
-            (z3-params-loop rest-p false acc)
-          ;; Normal parameter
-          (= (type-of p) "symbol")
-            (z3-params-loop rest-p false
-              (append acc (list (list (symbol-name p) "Int"))))
-          ;; Something else — skip
-          :else
-            (z3-params-loop rest-p false acc))))))
-
-(define z3-has-rest?
-  (fn ((params :as list))
-    (some (fn (p) (and (= (type-of p) "symbol") (= (symbol-name p) "&rest")))
-          params)))
-
-
-;; --------------------------------------------------------------------------
-;; define-primitive → SMT-LIB
-;; --------------------------------------------------------------------------
-
-(define z3-translate-primitive
-  (fn ((expr :as list))
-    (let ((name      (nth expr 1))
-          (kwargs    (z3-extract-kwargs expr))
-          (params    (or (get kwargs "params") (list)))
-          (returns   (or (get kwargs "returns") "any"))
-          (doc       (or (get kwargs "doc") ""))
-          (body      (get kwargs "body"))
-          (pairs     (z3-params-to-sorts params))
-          (has-rest  (z3-has-rest? params))
-          (smt-name  (z3-name name)))
-
-      (str
-        ;; Comment header
-        "; " name " — " doc "\n"
-
-        ;; Declaration
-        (if has-rest
-          (str "; (variadic — modeled as uninterpreted)\n"
-               "(declare-fun " smt-name " (Int Int) " (z3-sort returns) ")")
-          (str "(declare-fun " smt-name " ("
-               (join " " (map (fn (pair) (nth pair 1)) pairs))
-               ") " (z3-sort returns) ")"))
-        "\n"
-
-        ;; Assertion (if body exists and not variadic)
-        (if (and (not (nil? body)) (not has-rest))
-          (if (empty? pairs)
-            ;; No params — simple assertion
-            (str "(assert (= (" smt-name ") " (z3-expr body) "))\n")
-            ;; With params — forall
-            (let ((bindings (join " " (map (fn (pair) (str "(" (nth pair 0) " Int)")) pairs)))
-                  (call-args (join " " (map (fn (pair) (nth pair 0)) pairs))))
-              (str "(assert (forall ((" bindings "))\n"
-                   "  (= (" smt-name " " call-args ") " (z3-expr body) ")))\n")))
-          "")
-
-        ;; Check satisfiability
-        "(check-sat)"))))
-
-
-;; --------------------------------------------------------------------------
-;; define-io-primitive → SMT-LIB
-;; --------------------------------------------------------------------------
-
-(define z3-translate-io
-  (fn ((expr :as list))
-    (let ((name   (nth expr 1))
-          (kwargs (z3-extract-kwargs expr))
-          (doc    (or (get kwargs "doc") ""))
-          (smt-name (replace (replace name "-" "_") "?" "_p")))
-      (str "; IO primitive: " name " — " doc "\n"
-           "; (uninterpreted — IO cannot be verified statically)\n"
-           "(declare-fun " smt-name " () Value)"))))
-
-
-;; --------------------------------------------------------------------------
-;; define-special-form → SMT-LIB
-;; --------------------------------------------------------------------------
-
-(define z3-translate-special-form
-  (fn ((expr :as list))
-    (let ((name   (nth expr 1))
-          (kwargs (z3-extract-kwargs expr))
-          (doc    (or (get kwargs "doc") "")))
-      (case name
-        "if"
-          (str "; Special form: if — " doc "\n"
-               "(assert (forall ((c Bool) (t Value) (e Value))\n"
-               "  (= (sx_if c t e) (ite c t e))))\n"
-               "(check-sat)")
-        "when"
-          (str "; Special form: when — " doc "\n"
-               "(assert (forall ((c Bool) (body Value))\n"
-               "  (= (sx_when c body) (ite c body nil_val))))\n"
-               "(check-sat)")
-        :else
-          (str "; Special form: " name " — " doc "\n"
-               "; (not directly expressible in SMT-LIB)")))))
-
-
-;; --------------------------------------------------------------------------
-;; Top-level dispatch
-;; --------------------------------------------------------------------------
-
-(define z3-translate
-  (fn (expr)
-    (if (not (list? expr))
-      "; Cannot translate: not a list form"
-      (if (< (len expr) 2)
-        "; Cannot translate: too short"
-        (let ((head (first expr)))
-          (if (not (= (type-of head) "symbol"))
-            "; Cannot translate: head is not a symbol"
-            (case (symbol-name head)
-              "define-primitive"    (z3-translate-primitive expr)
-              "define-io-primitive" (z3-translate-io expr)
-              "define-special-form" (z3-translate-special-form expr)
-              :else                (z3-expr expr))))))))
-
-
-;; --------------------------------------------------------------------------
-;; Batch translation: process a list of parsed expressions
-;; --------------------------------------------------------------------------
-
-(define z3-translate-file
-  (fn ((exprs :as list))
-    ;; Filter to translatable forms and translate each
-    (let ((translatable
-            (filter
-              (fn (expr)
-                (and (list? expr)
-                     (>= (len expr) 2)
-                     (= (type-of (first expr)) "symbol")
-                     (let ((name (symbol-name (first expr))))
-                       (or (= name "define-primitive")
-                           (= name "define-io-primitive")
-                           (= name "define-special-form")))))
-              exprs)))
-      (join "\n\n" (map z3-translate translatable)))))

shared/sx/resolver.py

@@ -31,7 +31,10 @@ import asyncio
 from typing import Any
 
 from .types import Component, Keyword, Lambda, NIL, Symbol
-from .ref.sx_ref import eval_expr as _raw_eval, trampoline as _trampoline
+# sx_ref.py removed — stub so module loads. OCaml bridge handles evaluation.
+def _not_available(*a, **kw):
+    raise RuntimeError("sx_ref.py has been removed — use SX_USE_OCAML=1")
+_raw_eval = _trampoline = _not_available
 
 def _eval(expr, env):
     """Evaluate and unwrap thunks — all resolver.py _eval calls are non-tail."""

shared/sx/templates/cssx.sx

@@ -468,7 +468,7 @@
 ;;   (div (~cssx/tw "bg-red-500") (~cssx/tw "p-4") "content")
 ;; =========================================================================
 
-(defcomp ~cssx/tw (tokens)
+(defcomp ~cssx/tw (&key tokens)
   (let ((token-list (filter (fn (t) (not (= t "")))
                       (split (or tokens "") " ")))
         (results (map cssx-process-token token-list))
@@ -493,8 +493,14 @@
 ;;   (~cssx/flush)
 ;; =========================================================================
 
-(defcomp ~cssx/flush ()
-  (let ((rules (collected "cssx")))
-    (clear-collected! "cssx")
-    (when (not (empty? rules))
-      (raw! (str "<style data-cssx>" (join "" rules) "</style>")))))
+(defcomp ~cssx/flush () :affinity :client
+  (let ((rules (collected "cssx"))
+        (head-style (dom-query "#sx-css")))
+    ;; On client: append rules to <style id="sx-css"> in <head>.
+    ;; On server: head-style is nil (no DOM). Don't clear the bucket —
+    ;; the shell's <head> template reads collected("cssx") and emits them.
+    (when head-style
+      (clear-collected! "cssx")
+      (when (not (empty? rules))
+        (dom-set-prop head-style "textContent"
+          (str (dom-get-prop head-style "textContent") (join "" rules)))))))