primitives-loop: push to origin/architecture after each commit

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

hosts/javascript/platform.py

@@ -842,6 +842,13 @@ PREAMBLE = '''\
     if (a === b) return true;
     if (a && b && a._sym && b._sym) return a.name === b.name;
     if (a && b && a._kw && b._kw) return a.name === b.name;
+    if (a && b && a._vector && b._vector) {
+      if (a.arr.length !== b.arr.length) return false;
+      for (var _i = 0; _i < a.arr.length; _i++) {
+        if (!sxEq(a.arr[_i], b.arr[_i])) return false;
+      }
+      return true;
+    }
     return false;
   }
 
@@ -908,6 +915,45 @@ PREAMBLE = '''\
   function SxSpread(attrs) { this.attrs = attrs || {}; }
   SxSpread.prototype._spread = true;
 
+  function SxVector(arr) { this.arr = arr || []; }
+  SxVector.prototype._vector = true;
+
+  var _paramUidCounter = 0;
+  function SxParameter(defaultVal, converter) {
+    this._uid = ++_paramUidCounter;
+    this._default = defaultVal;
+    this._converter = converter || null;
+  }
+  SxParameter.prototype._parameter = true;
+  function parameter_p(x) { return x != null && x._parameter === true; }
+  function parameterUid(p) { return p._uid; }
+  function parameterDefault(p) { return p._default; }
+
+  function SxCallccContinuation(capturedKont, windersLen) { this._captured = capturedKont; this._winders_len = windersLen !== undefined ? windersLen : 0; }
+  SxCallccContinuation.prototype._callcc = true;
+  function makeCallccContinuation(kont, windersLen) { return new SxCallccContinuation(kont, windersLen !== undefined ? windersLen : 0); }
+  function callccContinuation_p(x) { return x != null && x._callcc === true; }
+  function callccContinuationData(x) { return x._captured; }
+  function callccContinuationWindersLen(x) { return x._winders_len !== undefined ? x._winders_len : 0; }
+
+  function evalError_p(v) {
+    return v != null && typeof v === "object" && v["__eval_error__"] === true;
+  }
+
+  function sxApplyCek(f, args) {
+    try {
+      return typeof f === "function" ? f.apply(null, args) : f;
+    } catch (e) {
+      if (e && e._perform_request) throw e;
+      if (e && e._cek_suspend) throw e;
+      return {"__eval_error__": true, "message": e && e.message ? e.message : String(e)};
+    }
+  }
+
+  var _JIT_SKIP_SENTINEL = {"__jit_skip": true};
+  function jitTryCall(f, args) { return _JIT_SKIP_SENTINEL; }
+  function jitSkip_p(v) { return v === _JIT_SKIP_SENTINEL || (v != null && v["__jit_skip"] === true); }
+
   var _scopeStacks = {};
 
   function isSym(x) { return x != null && x._sym === true; }
@@ -945,11 +991,18 @@ PRIMITIVES_JS_MODULES: dict[str, str] = {
     if (n === undefined || n === 0) return Math.round(x);
     var f = Math.pow(10, n); return Math.round(x * f) / f;
   };
+  PRIMITIVES["truncate"] = Math.trunc;
+  PRIMITIVES["remainder"] = function(a, b) { return a % b; };
+  PRIMITIVES["modulo"] = function(a, b) { var r = a % b; return (r !== 0 && (r < 0) !== (b < 0)) ? r + b : r; };
   PRIMITIVES["min"] = Math.min;
   PRIMITIVES["max"] = Math.max;
   PRIMITIVES["sqrt"] = Math.sqrt;
   PRIMITIVES["pow"] = Math.pow;
   PRIMITIVES["clamp"] = function(x, lo, hi) { return Math.max(lo, Math.min(hi, x)); };
+  PRIMITIVES["random-int"] = function(lo, hi) { return Math.floor(Math.random() * (hi - lo + 1)) + lo; };
+  PRIMITIVES["exact->inexact"] = function(x) { return x; };
+  PRIMITIVES["inexact->exact"] = Math.round;
+  PRIMITIVES["parse-number"] = function(s) { var n = Number(s); return isNaN(n) ? null : n; };
 ''',
 
     "core.comparison": '''
@@ -971,9 +1024,13 @@ PRIMITIVES_JS_MODULES: dict[str, str] = {
   // core.predicates
   PRIMITIVES["nil?"] = isNil;
   PRIMITIVES["number?"] = function(x) { return typeof x === "number"; };
+  PRIMITIVES["integer?"] = function(x) { return typeof x === "number" && Number.isInteger(x); };
+  PRIMITIVES["float?"] = function(x) { return typeof x === "number" && !Number.isInteger(x); };
+  PRIMITIVES["exact?"] = function(x) { return typeof x === "number" && Number.isInteger(x); };
+  PRIMITIVES["inexact?"] = function(x) { return typeof x === "number" && !Number.isInteger(x); };
   PRIMITIVES["string?"] = function(x) { return typeof x === "string"; };
   PRIMITIVES["list?"] = Array.isArray;
-  PRIMITIVES["dict?"] = function(x) { return x !== null && typeof x === "object" && !Array.isArray(x) && !x._sym && !x._kw; };
+  PRIMITIVES["dict?"] = function(x) { return x !== null && typeof x === "object" && !Array.isArray(x) && !x._sym && !x._kw && !x._string_buffer && !x._vector; };
   PRIMITIVES["empty?"] = function(c) { return isNil(c) || (Array.isArray(c) ? c.length === 0 : typeof c === "string" ? c.length === 0 : Object.keys(c).length === 0); };
   PRIMITIVES["contains?"] = function(c, k) {
     if (typeof c === "string") return c.indexOf(String(k)) !== -1;
@@ -1004,7 +1061,20 @@ PRIMITIVES_JS_MODULES: dict[str, str] = {
   PRIMITIVES["split"] = function(s, sep) { return String(s).split(sep || " "); };
   PRIMITIVES["join"] = function(sep, coll) { return coll.join(sep); };
   PRIMITIVES["replace"] = function(s, old, nw) { return s.split(old).join(nw); };
-  PRIMITIVES["index-of"] = function(s, needle, from) { return String(s).indexOf(needle, from || 0); };
+  PRIMITIVES["index-of"] = function(s, needle, from) {
+    if (Array.isArray(s)) {
+      var _start = from || 0;
+      for (var _i = _start; _i < s.length; _i++) {
+        var _a = s[_i];
+        if (_a === needle) return _i;
+        if (_a != null && needle != null && typeof _a === "object" && typeof needle === "object") {
+          if ((_a._sym && needle._sym || _a._kw && needle._kw) && _a.name === needle.name) return _i;
+        }
+      }
+      return NIL;
+    }
+    return String(s).indexOf(needle, from || 0);
+  };
   PRIMITIVES["starts-with?"] = function(s, p) { return String(s).indexOf(p) === 0; };
   PRIMITIVES["ends-with?"] = function(s, p) { var str = String(s); return str.indexOf(p, str.length - p.length) !== -1; };
   PRIMITIVES["slice"] = function(c, a, b) { if (!c || typeof c.slice !== "function") { console.error("[sx-debug] slice called on non-sliceable:", typeof c, c, "a=", a, "b=", b, new Error().stack); return []; } return b !== undefined ? c.slice(a, b) : c.slice(a); };
@@ -1086,6 +1156,49 @@ PRIMITIVES_JS_MODULES: dict[str, str] = {
   };
 ''',
 
+    "core.vectors": '''
+  // core.vectors — R7RS mutable fixed-size arrays
+  PRIMITIVES["make-vector"] = function(n, fill) {
+    var arr = new Array(n);
+    var f = (fill !== undefined) ? fill : NIL;
+    for (var i = 0; i < n; i++) arr[i] = f;
+    return new SxVector(arr);
+  };
+  PRIMITIVES["vector"] = function() {
+    return new SxVector(Array.prototype.slice.call(arguments));
+  };
+  PRIMITIVES["vector?"] = function(x) { return x != null && x._vector === true; };
+  PRIMITIVES["vector-length"] = function(v) { return v.arr.length; };
+  PRIMITIVES["vector-ref"] = function(v, i) {
+    if (i < 0 || i >= v.arr.length) throw new Error("vector-ref: index " + i + " out of bounds (length " + v.arr.length + ")");
+    return v.arr[i];
+  };
+  PRIMITIVES["vector-set!"] = function(v, i, val) {
+    if (i < 0 || i >= v.arr.length) throw new Error("vector-set!: index " + i + " out of bounds (length " + v.arr.length + ")");
+    v.arr[i] = val; return NIL;
+  };
+  PRIMITIVES["vector->list"] = function(v) { return v.arr.slice(); };
+  PRIMITIVES["list->vector"] = function(l) { return new SxVector(l.slice()); };
+  PRIMITIVES["vector-fill!"] = function(v, val) {
+    for (var i = 0; i < v.arr.length; i++) v.arr[i] = val; return NIL;
+  };
+  PRIMITIVES["vector-copy"] = function(v, start, end) {
+    var s = (start !== undefined) ? start : 0;
+    var e = (end !== undefined) ? Math.min(end, v.arr.length) : v.arr.length;
+    return new SxVector(v.arr.slice(s, e));
+  };
+
+  // String buffers — O(1) amortised append via array+join
+  function SxStringBuffer() { this.parts = []; this.len = 0; this._string_buffer = true; }
+  PRIMITIVES["make-string-buffer"] = function() { return new SxStringBuffer(); };
+  PRIMITIVES["string-buffer?"] = function(x) { return x instanceof SxStringBuffer; };
+  PRIMITIVES["string-buffer-append!"] = function(buf, s) {
+    buf.parts.push(String(s)); buf.len += String(s).length; return NIL;
+  };
+  PRIMITIVES["string-buffer->string"] = function(buf) { return buf.parts.join(""); };
+  PRIMITIVES["string-buffer-length"] = function(buf) { return buf.len; };
+''',
+
     "stdlib.format": '''
   // stdlib.format
   PRIMITIVES["format-decimal"] = function(v, p) { return Number(v).toFixed(p || 2); };
@@ -1196,6 +1309,27 @@ PRIMITIVES_JS_MODULES: dict[str, str] = {
     return NIL;
   };
 ''',
+
+    "stdlib.bitwise": '''
+  // stdlib.bitwise
+  PRIMITIVES["bitwise-and"] = function(a, b) { return (a & b) | 0; };
+  PRIMITIVES["bitwise-or"]  = function(a, b) { return (a | b) | 0; };
+  PRIMITIVES["bitwise-xor"] = function(a, b) { return (a ^ b) | 0; };
+  PRIMITIVES["bitwise-not"] = function(a)    { return ~a; };
+  PRIMITIVES["arithmetic-shift"] = function(a, count) {
+    return count >= 0 ? (a << count) | 0 : a >> (-count);
+  };
+  PRIMITIVES["bit-count"] = function(a) {
+    var n = Math.abs(a) >>> 0;
+    n = n - ((n >> 1) & 0x55555555);
+    n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
+    return (((n + (n >> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
+  };
+  PRIMITIVES["integer-length"] = function(a) {
+    if (a === 0) return 0;
+    return 32 - Math.clz32(Math.abs(a));
+  };
+''',
 }
 # Modules to include by default (all)
 _ALL_JS_MODULES = list(PRIMITIVES_JS_MODULES.keys())
@@ -1234,6 +1368,8 @@ PLATFORM_JS_PRE = '''
     if (x._macro) return "macro";
     if (x._raw) return "raw-html";
     if (x._sx_expr) return "sx-expr";
+    if (x._vector) return "vector";
+    if (x._string_buffer) return "string-buffer";
     if (typeof Node !== "undefined" && x instanceof Node) return "dom-node";
     if (Array.isArray(x)) return "list";
     if (typeof x === "object") return "dict";
@@ -1400,6 +1536,12 @@ PLATFORM_JS_PRE = '''
   // Placeholder — overridden by transpiled version from render.sx
   function isRenderExpr(expr) { return false; }
 
+  // Last error continuation — saved when a raise goes unhandled, for post-mortem inspection.
+  var _lastErrorKont_ = null;
+
+  // hostError — throw a host-level error that propagates out of cekRun.
+  function hostError(msg) { throw new Error(typeof msg === "string" ? msg : inspect(msg)); }
+
   // Render dispatch — call the active adapter's render function.
   // Set by each adapter when loaded; defaults to identity (no rendering).
   var _renderExprFn = null;
@@ -1743,6 +1885,13 @@ CEK_FIXUPS_JS = '''
   PRIMITIVES["lambda-name"] = lambdaName;
   PRIMITIVES["component?"] = isComponent;
   PRIMITIVES["island?"] = isIsland;
+  PRIMITIVES["parameter?"] = parameter_p;
+  PRIMITIVES["parameter-uid"] = parameterUid;
+  PRIMITIVES["parameter-default"] = parameterDefault;
+  PRIMITIVES["make-parameter"] = function(defaultVal, converter) {
+    var p = new SxParameter(defaultVal, converter || null);
+    return p;
+  };
   PRIMITIVES["make-symbol"] = function(n) { return new Symbol(n); };
   PRIMITIVES["is-html-tag?"] = function(n) { return HTML_TAGS.indexOf(n) >= 0; };
   function makeEnv() { return merge(componentEnv, PRIMITIVES); }
@@ -2031,7 +2180,7 @@ PLATFORM_DOM_JS = """
   }
 
   function domDispatch(el, name, detail) {
-    if (!_hasDom || !el) return false;
+    if (!_hasDom || !el || typeof el.dispatchEvent !== "function") return false;
     var evt = new CustomEvent(name, { bubbles: true, cancelable: true, detail: detail || {} });
     return el.dispatchEvent(evt);
   }
@@ -2157,6 +2306,14 @@ PLATFORM_ORCHESTRATION_JS = """
   // Platform interface — Orchestration (browser-only)
   // =========================================================================
 
+  // --- Stubs for define-library functions not transpiled by extract_defines ---
+  // These are defined in orchestration.sx's define-library and called from
+  // boot.sx top-level defines. The JS bootstrapper only transpiles top-level
+  // defines, so we provide stubs here for functions that need a JS identity.
+
+  function flushCollectedStyles() { return NIL; }
+  function processElements(root) { return NIL; }
+
   // --- Browser/Network ---
 
   function browserNavigate(url) {
@@ -2642,6 +2799,10 @@ PLATFORM_ORCHESTRATION_JS = """
     return el && el.closest ? el.closest(sel) : null;
   }
 
+  function domDocument() {
+    return _hasDom ? document : null;
+  }
+
   function domBody() {
     return _hasDom ? document.body : null;
   }
@@ -3085,6 +3246,8 @@ PLATFORM_BOOT_JS = """
   // Platform interface — Boot (mount, hydrate, scripts, cookies)
   // =========================================================================
 
+  function preloadIslandDefs() { return NIL; }
+
   function resolveMountTarget(target) {
     if (typeof target === "string") return _hasDom ? document.querySelector(target) : null;
     return target;
@@ -3237,6 +3400,18 @@ def fixups_js(has_html, has_sx, has_dom, has_signals=False, has_deps=False, has_
   // Core primitives that require native JS (cannot be expressed via FFI)
   // -----------------------------------------------------------------------
   PRIMITIVES["error"] = function(msg) { throw new Error(msg); };
+  PRIMITIVES["host-error"] = function(msg) { throw new Error(typeof msg === "string" ? msg : inspect(msg)); };
+  PRIMITIVES["try-catch"] = function(tryFn, catchFn) {
+    try {
+      return cekRun(continueWithCall(tryFn, [], makeEnv(), [], []));
+    } catch(e) {
+      var msg = e && e.message ? e.message : String(e);
+      return cekRun(continueWithCall(catchFn, [msg], makeEnv(), [msg], []));
+    }
+  };
+  PRIMITIVES["without-io-hook"] = function(thunk) {
+    return cekRun(continueWithCall(thunk, [], makeEnv(), [], []));
+  };
   PRIMITIVES["sort"] = function(lst) {
     if (!Array.isArray(lst)) return lst;
     return lst.slice().sort(function(a, b) {
@@ -3304,7 +3479,7 @@ def fixups_js(has_html, has_sx, has_dom, has_signals=False, has_deps=False, has_
   PRIMITIVES["dom-tag-name"] = domTagName;
   PRIMITIVES["dom-get-prop"] = domGetProp;
   PRIMITIVES["dom-set-prop"] = domSetProp;
-  PRIMITIVES["reactive-text"] = reactiveText;
+  if (typeof reactiveText === "function") PRIMITIVES["reactive-text"] = reactiveText;
   PRIMITIVES["set-interval"] = setInterval_;
   PRIMITIVES["clear-interval"] = clearInterval_;
   PRIMITIVES["promise-then"] = promiseThen;
@@ -3493,35 +3668,35 @@ def public_api_js(has_html, has_sx, has_dom, has_engine, has_orch, has_boot, has
     elif has_orch:
         api_lines.append('    init: typeof engineInit === "function" ? engineInit : null,')
     if has_deps:
-        api_lines.append('    scanRefs: scanRefs,')
+        api_lines.append('    scanRefs: typeof scanRefs === "function" ? scanRefs : null,')
-        api_lines.append('    scanComponentsFromSource: scanComponentsFromSource,')
+        api_lines.append('    scanComponentsFromSource: typeof scanComponentsFromSource === "function" ? scanComponentsFromSource : null,')
-        api_lines.append('    transitiveDeps: transitiveDeps,')
+        api_lines.append('    transitiveDeps: typeof transitiveDeps === "function" ? transitiveDeps : null,')
-        api_lines.append('    computeAllDeps: computeAllDeps,')
+        api_lines.append('    computeAllDeps: typeof computeAllDeps === "function" ? computeAllDeps : null,')
-        api_lines.append('    componentsNeeded: componentsNeeded,')
+        api_lines.append('    componentsNeeded: typeof componentsNeeded === "function" ? componentsNeeded : null,')
-        api_lines.append('    pageComponentBundle: pageComponentBundle,')
+        api_lines.append('    pageComponentBundle: typeof pageComponentBundle === "function" ? pageComponentBundle : null,')
-        api_lines.append('    pageCssClasses: pageCssClasses,')
+        api_lines.append('    pageCssClasses: typeof pageCssClasses === "function" ? pageCssClasses : null,')
-        api_lines.append('    scanIoRefs: scanIoRefs,')
+        api_lines.append('    scanIoRefs: typeof scanIoRefs === "function" ? scanIoRefs : null,')
-        api_lines.append('    transitiveIoRefs: transitiveIoRefs,')
+        api_lines.append('    transitiveIoRefs: typeof transitiveIoRefs === "function" ? transitiveIoRefs : null,')
-        api_lines.append('    computeAllIoRefs: computeAllIoRefs,')
+        api_lines.append('    computeAllIoRefs: typeof computeAllIoRefs === "function" ? computeAllIoRefs : null,')
-        api_lines.append('    componentPure_p: componentPure_p,')
+        api_lines.append('    componentPure_p: typeof componentPure_p === "function" ? componentPure_p : null,')
     if has_page_helpers:
-        api_lines.append('    categorizeSpecialForms: categorizeSpecialForms,')
+        api_lines.append('    categorizeSpecialForms: typeof categorizeSpecialForms === "function" ? categorizeSpecialForms : null,')
-        api_lines.append('    buildReferenceData: buildReferenceData,')
+        api_lines.append('    buildReferenceData: typeof buildReferenceData === "function" ? buildReferenceData : null,')
-        api_lines.append('    buildAttrDetail: buildAttrDetail,')
+        api_lines.append('    buildAttrDetail: typeof buildAttrDetail === "function" ? buildAttrDetail : null,')
-        api_lines.append('    buildHeaderDetail: buildHeaderDetail,')
+        api_lines.append('    buildHeaderDetail: typeof buildHeaderDetail === "function" ? buildHeaderDetail : null,')
-        api_lines.append('    buildEventDetail: buildEventDetail,')
+        api_lines.append('    buildEventDetail: typeof buildEventDetail === "function" ? buildEventDetail : null,')
-        api_lines.append('    buildComponentSource: buildComponentSource,')
+        api_lines.append('    buildComponentSource: typeof buildComponentSource === "function" ? buildComponentSource : null,')
-        api_lines.append('    buildBundleAnalysis: buildBundleAnalysis,')
+        api_lines.append('    buildBundleAnalysis: typeof buildBundleAnalysis === "function" ? buildBundleAnalysis : null,')
-        api_lines.append('    buildRoutingAnalysis: buildRoutingAnalysis,')
+        api_lines.append('    buildRoutingAnalysis: typeof buildRoutingAnalysis === "function" ? buildRoutingAnalysis : null,')
-        api_lines.append('    buildAffinityAnalysis: buildAffinityAnalysis,')
+        api_lines.append('    buildAffinityAnalysis: typeof buildAffinityAnalysis === "function" ? buildAffinityAnalysis : null,')
     if has_router:
-        api_lines.append('    splitPathSegments: splitPathSegments,')
+        api_lines.append('    splitPathSegments: typeof splitPathSegments === "function" ? splitPathSegments : null,')
-        api_lines.append('    parseRoutePattern: parseRoutePattern,')
+        api_lines.append('    parseRoutePattern: typeof parseRoutePattern === "function" ? parseRoutePattern : null,')
-        api_lines.append('    matchRoute: matchRoute,')
+        api_lines.append('    matchRoute: typeof matchRoute === "function" ? matchRoute : null,')
-        api_lines.append('    findMatchingRoute: findMatchingRoute,')
+        api_lines.append('    findMatchingRoute: typeof findMatchingRoute === "function" ? findMatchingRoute : null,')
-        api_lines.append('    urlToExpr: urlToExpr,')
+        api_lines.append('    urlToExpr: typeof urlToExpr === "function" ? urlToExpr : null,')
-        api_lines.append('    autoQuoteUnknowns: autoQuoteUnknowns,')
+        api_lines.append('    autoQuoteUnknowns: typeof autoQuoteUnknowns === "function" ? autoQuoteUnknowns : null,')
-        api_lines.append('    prepareUrlExpr: prepareUrlExpr,')
+        api_lines.append('    prepareUrlExpr: typeof prepareUrlExpr === "function" ? prepareUrlExpr : null,')
 
     if has_dom:
         api_lines.append('    registerIo: typeof registerIoPrimitive === "function" ? registerIoPrimitive : null,')
@@ -3529,21 +3704,21 @@ def public_api_js(has_html, has_sx, has_dom, has_engine, has_orch, has_boot, has
         api_lines.append('    asyncRender: typeof asyncSxRenderWithEnv === "function" ? asyncSxRenderWithEnv : null,')
         api_lines.append('    asyncRenderToDom: typeof asyncRenderToDom === "function" ? asyncRenderToDom : null,')
     if has_signals:
-        api_lines.append('    signal: signal,')
+        api_lines.append('    signal: typeof signal === "function" ? signal : null,')
-        api_lines.append('    deref: deref,')
+        api_lines.append('    deref: typeof deref === "function" ? deref : null,')
-        api_lines.append('    reset: reset_b,')
+        api_lines.append('    reset: typeof reset_b === "function" ? reset_b : null,')
-        api_lines.append('    swap: swap_b,')
+        api_lines.append('    swap: typeof swap_b === "function" ? swap_b : null,')
-        api_lines.append('    computed: computed,')
+        api_lines.append('    computed: typeof computed === "function" ? computed : null,')
-        api_lines.append('    effect: effect,')
+        api_lines.append('    effect: typeof effect === "function" ? effect : null,')
-        api_lines.append('    batch: batch,')
+        api_lines.append('    batch: typeof batch === "function" ? batch : null,')
-        api_lines.append('    isSignal: isSignal,')
+        api_lines.append('    isSignal: typeof isSignal === "function" ? isSignal : null,')
-        api_lines.append('    makeSignal: makeSignal,')
+        api_lines.append('    makeSignal: typeof makeSignal === "function" ? makeSignal : null,')
-        api_lines.append('    defStore: defStore,')
+        api_lines.append('    defStore: typeof defStore === "function" ? defStore : null,')
-        api_lines.append('    useStore: useStore,')
+        api_lines.append('    useStore: typeof useStore === "function" ? useStore : null,')
-        api_lines.append('    clearStores: clearStores,')
+        api_lines.append('    clearStores: typeof clearStores === "function" ? clearStores : null,')
-        api_lines.append('    emitEvent: emitEvent,')
+        api_lines.append('    emitEvent: typeof emitEvent === "function" ? emitEvent : null,')
-        api_lines.append('    onEvent: onEvent,')
+        api_lines.append('    onEvent: typeof onEvent === "function" ? onEvent : null,')
-        api_lines.append('    bridgeEvent: bridgeEvent,')
+        api_lines.append('    bridgeEvent: typeof bridgeEvent === "function" ? bridgeEvent : null,')
     api_lines.append('    makeSpread: makeSpread,')
     api_lines.append('    isSpread: isSpread,')
     api_lines.append('    spreadAttrs: spreadAttrs,')

hosts/javascript/run_tests.js

@@ -293,6 +293,8 @@ env["pop-suite"] = function() {
   return null;
 };
 
+env["test-allowed?"] = function(name) { return true; };
+
 // Load test framework
 const projectDir = path.join(__dirname, "..", "..");
 const specTests = path.join(projectDir, "spec", "tests");
@@ -341,6 +343,20 @@ if (fs.existsSync(swapPath)) {
   }
 }
 
+// Load spec library files (define-library modules imported by tests)
+for (const libFile of ["signals.sx", "coroutines.sx"]) {
+  const libPath = path.join(projectDir, "spec", libFile);
+  if (fs.existsSync(libPath)) {
+    const libSrc = fs.readFileSync(libPath, "utf8");
+    const libExprs = Sx.parse(libSrc);
+    for (const expr of libExprs) {
+      try { Sx.eval(expr, env); } catch (e) {
+        console.error(`Error loading spec/${libFile}: ${e.message}`);
+      }
+    }
+  }
+}
+
 // Load tw system (needed by spec/tests/test-tw.sx)
 const twDir = path.join(projectDir, "shared", "sx", "templates");
 for (const twFile of ["tw-type.sx", "tw-layout.sx", "tw.sx"]) {

hosts/ocaml/bin/run_tests.ml

@@ -37,7 +37,10 @@ let rec deep_equal a b =
   match a, b with
   | Nil, Nil -> true
   | Bool a, Bool b -> a = b
+  | Integer a, Integer b -> a = b
   | Number a, Number b -> a = b
+  | Integer a, Number b -> float_of_int a = b
+  | Number a, Integer b -> a = float_of_int b
   | String a, String b -> a = b
   | Symbol a, Symbol b -> a = b
   | Keyword a, Keyword b -> a = b
@@ -226,7 +229,7 @@ let make_test_env () =
     | [String s] ->
       let parsed = Sx_parser.parse_all s in
       (match parsed with
-       | [List (Symbol "sxbc" :: Number _ :: payload :: _)] -> payload
+       | [List (Symbol "sxbc" :: (Number _ | Integer _) :: payload :: _)] -> payload
        | _ -> raise (Eval_error "bytecode-deserialize: invalid sxbc format"))
     | _ -> raise (Eval_error "bytecode-deserialize: expected string"));
 
@@ -240,7 +243,7 @@ let make_test_env () =
     | [String s] ->
       let parsed = Sx_parser.parse_all s in
       (match parsed with
-       | [List (Symbol "cek-state" :: Number _ :: payload :: _)] -> payload
+       | [List (Symbol "cek-state" :: (Number _ | Integer _) :: payload :: _)] -> payload
        | _ -> raise (Eval_error "cek-deserialize: invalid cek-state format"))
     | _ -> raise (Eval_error "cek-deserialize: expected string"));
 
@@ -320,7 +323,10 @@ let make_test_env () =
   bind "identical?" (fun args ->
     match args with
     | [a; b] -> Bool (match a, b with
+      | Integer x, Integer y -> x = y
       | Number x, Number y -> x = y
+      | Integer x, Number y -> float_of_int x = y
+      | Number x, Integer y -> x = float_of_int y
       | String x, String y -> x = y
       | Bool x, Bool y -> x = y
       | Nil, Nil -> true
@@ -366,11 +372,15 @@ let make_test_env () =
 
   bind "append!" (fun args ->
     match args with
-    | [ListRef r; v; Number n] when int_of_float n = 0 ->
+    | [ListRef r; v; (Number n)] when int_of_float n = 0 ->
       r := v :: !r; ListRef r  (* prepend *)
+    | [ListRef r; v; (Integer 0)] ->
+      r := v :: !r; ListRef r  (* prepend Integer index *)
     | [ListRef r; v] -> r := !r @ [v]; ListRef r  (* append in place *)
-    | [List items; v; Number n] when int_of_float n = 0 ->
+    | [List items; v; (Number n)] when int_of_float n = 0 ->
       List (v :: items)  (* immutable prepend *)
+    | [List items; v; (Integer 0)] ->
+      List (v :: items)  (* immutable prepend Integer index *)
     | [List items; v] -> List (items @ [v])  (* immutable fallback *)
     | _ -> raise (Eval_error "append!: expected list and value"));
 
@@ -546,7 +556,10 @@ let make_test_env () =
   bind "batch-begin!" (fun _args -> Sx_ref.batch_begin_b ());
   bind "batch-end!" (fun _args -> Sx_ref.batch_end_b ());
   bind "now-ms" (fun _args -> Number 1000.0);
-  bind "random-int" (fun args -> match args with [Number lo; _] -> Number lo | _ -> Number 0.0);
+  bind "random-int" (fun args -> match args with
+    | [Number lo; _] -> Number lo
+    | [Integer lo; _] -> Integer lo
+    | _ -> Integer 0);
   bind "try-rerender-page" (fun _args -> Nil);
   bind "collect!" (fun args ->
     match args with
@@ -1142,18 +1155,20 @@ let run_foundation_tests () =
   in
 
   Printf.printf "Suite: parser\n";
-  assert_eq "number" (Number 42.0) (List.hd (parse_all "42"));
+  assert_eq "number" (Integer 42) (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)"));
+  assert_eq "list" (List [Symbol "+"; Integer 1; Integer 2]) (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 [Integer 1; Integer 2; Integer 3]] ->
+     incr pass_count; Printf.printf "  PASS: quote sugar\n"
    | 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));
@@ -1161,7 +1176,7 @@ let run_foundation_tests () =
    | 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 "comment" (Integer 42) (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)"))));
 
@@ -1978,6 +1993,10 @@ let run_spec_tests env test_files =
       (match Hashtbl.find_opt d "children" with
        | Some (List l) when i >= 0 && i < List.length l -> List.nth l i
        | _ -> (match Hashtbl.find_opt d (string_of_int i) with Some v -> v | None -> Nil))
+    | [Dict d; Integer n] ->
+      (match Hashtbl.find_opt d "children" with
+       | Some (List l) when n >= 0 && n < List.length l -> List.nth l n
+       | _ -> (match Hashtbl.find_opt d (string_of_int n) with Some v -> v | None -> Nil))
     | _ -> Nil);
 
   (* Stringify a value for DOM string properties *)
@@ -2052,8 +2071,8 @@ let run_spec_tests env test_files =
          Hashtbl.replace d "childNodes" (List [])
        | _ -> ());
       stored
-    | [ListRef r; Number n; value] ->
+    | [ListRef r; idx_v; value] when (match idx_v with Number _ | Integer _ -> true | _ -> false) ->
-      let idx = int_of_float n in
+      let idx = match idx_v with Number n -> int_of_float n | Integer n -> n | _ -> 0 in
       let lst = !r in
       if idx >= 0 && idx < List.length lst then
         r := List.mapi (fun i v -> if i = idx then value else v) lst
@@ -2190,7 +2209,7 @@ let run_spec_tests env test_files =
             | [String name; value] ->
               let attrs = match Hashtbl.find_opt d "attributes" with Some (Dict a) -> a | _ ->
                 let a = Hashtbl.create 4 in Hashtbl.replace d "attributes" (Dict a); a in
-              let sv = match value with String s -> s | Number n ->
+              let sv = match value with String s -> s | Integer n -> string_of_int n | Number n ->
                 let i = int_of_float n in if float_of_int i = n then string_of_int i
                 else string_of_float n | _ -> Sx_types.inspect value in
               Hashtbl.replace attrs name (String sv);
@@ -2632,6 +2651,7 @@ let run_spec_tests env test_files =
   let rec json_of_value = function
     | Nil -> `Null
     | Bool b -> `Bool b
+    | Integer n -> `Int n
     | Number n ->
       if Float.is_integer n && Float.abs n < 1e16
       then `Int (int_of_float n) else `Float n
@@ -2647,8 +2667,8 @@ let run_spec_tests env test_files =
   let rec value_of_json = function
     | `Null -> Nil
     | `Bool b -> Bool b
-    | `Int i -> Number (float_of_int i)
+    | `Int i -> Integer i
-    | `Intlit s -> (try Number (float_of_string s) with _ -> String s)
+    | `Intlit s -> (try Integer (int_of_string s) with _ -> try Number (float_of_string s) with _ -> String s)
     | `Float f -> Number f
     | `String s -> String s
     | `List xs -> List (List.map value_of_json xs)

hosts/ocaml/bin/sx_server.ml

@@ -296,6 +296,10 @@ let read_blob () =
       (* consume trailing newline *)
       (try ignore (input_line stdin) with End_of_file -> ());
       data
+    | [List [Symbol "blob"; Integer n]] ->
+      let data = read_exact_bytes n in
+      (try ignore (input_line stdin) with End_of_file -> ());
+      data
     | _ -> raise (Eval_error ("read_blob: expected (blob N), got: " ^ line))
 
 (** Batch IO mode — collect requests during aser-slot, resolve after. *)
@@ -357,6 +361,11 @@ let rec read_io_response () =
     | [List (Symbol "io-response" :: Number n :: values)]
       when int_of_float n = !current_epoch ->
       (match values with [v] -> v | _ -> List values)
+    | [List [Symbol "io-response"; Integer n; value]]
+      when n = !current_epoch -> value
+    | [List (Symbol "io-response" :: Integer n :: values)]
+      when n = !current_epoch ->
+      (match values with [v] -> v | _ -> List values)
     (* Legacy untagged: (io-response value) — accept for backwards compat *)
     | [List [Symbol "io-response"; value]] -> value
     | [List (Symbol "io-response" :: values)] ->
@@ -396,6 +405,12 @@ let read_batched_io_response () =
         when int_of_float n = !current_epoch -> s
       | [List [Symbol "io-response"; Number n; v]]
         when int_of_float n = !current_epoch -> serialize_value v
+      | [List [Symbol "io-response"; Integer n; String s]]
+        when n = !current_epoch -> s
+      | [List [Symbol "io-response"; Integer n; SxExpr s]]
+        when n = !current_epoch -> s
+      | [List [Symbol "io-response"; Integer n; v]]
+        when n = !current_epoch -> serialize_value v
       (* Legacy untagged *)
       | [List [Symbol "io-response"; String s]]
       | [List [Symbol "io-response"; SxExpr s]] -> s
@@ -959,6 +974,7 @@ let setup_io_bridges env =
   bind "sleep" (fun args -> io_request "sleep" args);
   bind "set-response-status" (fun args -> match args with
     | [Number n] -> _pending_response_status := int_of_float n; Nil
+    | [Integer n] -> _pending_response_status := n; Nil
     | _ -> Nil);
   bind "set-response-header" (fun args -> io_request "set-response-header" args)
 
@@ -4450,6 +4466,8 @@ let site_mode () =
           match exprs with
           | [List [Symbol "epoch"; Number n]] ->
             current_epoch := int_of_float n
+          | [List [Symbol "epoch"; Integer n]] ->
+            current_epoch := n
           (* render-page: full SSR pipeline — URL → complete HTML *)
           | [List [Symbol "render-page"; String path]] ->
             (try match http_render_page env path [] with
@@ -4507,6 +4525,8 @@ let () =
             (* Epoch marker: (epoch N) — set current epoch, read next command *)
             | [List [Symbol "epoch"; Number n]] ->
               current_epoch := int_of_float n
+            | [List [Symbol "epoch"; Integer n]] ->
+              current_epoch := n
             | [cmd] -> dispatch env cmd
             | _ -> send_error ("Expected single command, got " ^ string_of_int (List.length exprs))
           end

hosts/ocaml/bootstrap.py

@@ -47,7 +47,9 @@ open Sx_runtime
 let trampoline_fn : (value -> value) ref = ref (fun v -> v)
 let trampoline v = !trampoline_fn v
 
-
+(* Step limit for timeout detection — set to 0 to disable *)
+let step_limit : int ref = ref 0
+let step_count : int ref = ref 0
 
 (* === Mutable globals — backing refs for transpiler's !_ref / _ref := === *)
 let _strict_ref = ref (Bool false)
@@ -126,6 +128,90 @@ let enhance_error_with_trace msg =
   _last_error_kont_ref := Nil;
   msg ^ (format_comp_trace trace)
 
+(* Hand-written sf_define_type — skipped from transpile because the spec uses
+   &rest params and empty-dict literals that the transpiler can't emit cleanly.
+   Implements: (define-type Name (Ctor1 f1 f2) (Ctor2 f3) ...)
+   Creates constructor fns, Name?/Ctor? predicates, Ctor-field accessors,
+   and records ctors in *adt-registry*. *)
+let sf_define_type args env_val =
+  let items = (match args with List l -> l | _ -> []) in
+  let type_sym = List.nth items 0 in
+  let type_name = value_to_string type_sym in
+  let ctor_specs = List.tl items in
+  let env_has_v k = sx_truthy (env_has env_val (String k)) in
+  let env_bind_v k v = ignore (env_bind env_val (String k) v) in
+  let env_get_v k = env_get env_val (String k) in
+  if not (env_has_v "*adt-registry*") then
+    env_bind_v "*adt-registry*" (Dict (Hashtbl.create 8));
+  let registry = env_get_v "*adt-registry*" in
+  let ctor_names = List.map (fun spec ->
+    (match spec with List (sym :: _) -> String (value_to_string sym) | _ -> Nil)
+  ) ctor_specs in
+  (match registry with Dict d -> Hashtbl.replace d type_name (List ctor_names) | _ -> ());
+  env_bind_v (type_name ^ "?")
+    (NativeFn (type_name ^ "?", fun pargs ->
+      (match pargs with
+      | [v] ->
+        (match v with
+        | Dict d -> Bool (Hashtbl.mem d "_adt" &&
+          (match Hashtbl.find_opt d "_type" with Some (String t) -> t = type_name | _ -> false))
+        | _ -> Bool false)
+      | _ -> Bool false)));
+  List.iter (fun spec ->
+    (match spec with
+    | List (sym :: fields) ->
+      let cn = value_to_string sym in
+      let field_names = List.map value_to_string fields in
+      let arity = List.length fields in
+      env_bind_v cn
+        (NativeFn (cn, fun ctor_args ->
+          if List.length ctor_args <> arity then
+            raise (Eval_error (Printf.sprintf "%s: expected %d args, got %d"
+              cn arity (List.length ctor_args)))
+          else begin
+            let d = Hashtbl.create 4 in
+            Hashtbl.replace d "_adt"    (Bool true);
+            Hashtbl.replace d "_type"   (String type_name);
+            Hashtbl.replace d "_ctor"   (String cn);
+            Hashtbl.replace d "_fields" (List ctor_args);
+            Dict d
+          end));
+      env_bind_v (cn ^ "?")
+        (NativeFn (cn ^ "?", fun pargs ->
+          (match pargs with
+          | [v] ->
+            (match v with
+            | Dict d -> Bool (Hashtbl.mem d "_adt" &&
+              (match Hashtbl.find_opt d "_ctor" with Some (String c) -> c = cn | _ -> false))
+            | _ -> Bool false)
+          | _ -> Bool false)));
+      List.iteri (fun idx fname ->
+        env_bind_v (cn ^ "-" ^ fname)
+          (NativeFn (cn ^ "-" ^ fname, fun pargs ->
+            (match pargs with
+            | [v] ->
+              (match v with
+              | Dict d ->
+                (match Hashtbl.find_opt d "_fields" with
+                | Some (List fs) ->
+                  if idx < List.length fs then List.nth fs idx
+                  else raise (Eval_error (cn ^ "-" ^ fname ^ ": index out of bounds"))
+                | _ -> raise (Eval_error (cn ^ "-" ^ fname ^ ": not an ADT")))
+              | _ -> raise (Eval_error (cn ^ "-" ^ fname ^ ": not a dict")))
+            | _ -> raise (Eval_error (cn ^ "-" ^ fname ^ ": expected 1 arg")))))
+      ) field_names
+    | _ -> ())
+  ) ctor_specs;
+  Nil
+
+(* Register define-type via custom_special_forms so the CEK dispatch finds it.
+   The top-level (register-special-form! ...) in spec/evaluator.sx is not a
+   define and therefore is not transpiled; we wire it up here instead. *)
+let () = ignore (register_special_form (String "define-type")
+  (NativeFn ("define-type", fun call_args ->
+    match call_args with
+    | [args; env] -> sf_define_type args env
+    | _ -> Nil)))
 
 
 """
@@ -171,7 +257,10 @@ def compile_spec_to_ml(spec_dir: str | None = None) -> str:
                 "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"}
+                "pad-left", "pad-right", "char-at", "substring",
+                # sf-define-type uses &rest + empty-dict literals that the transpiler
+                # can't emit as valid OCaml; hand-written implementation in FIXUPS.
+                "sf-define-type"}
         defines = [(n, e) for n, e in defines if n not in skip]
 
         # Deduplicate — keep last definition for each name (CEK overrides tree-walk)

hosts/ocaml/lib/sx_parser.ml

@@ -90,6 +90,18 @@ let read_symbol s =
   String.sub s.src start (s.pos - start)
 
 let try_number str =
+  (* Integers (no '.' or 'e'/'E') → exact Integer; floats → inexact Number *)
+  let has_dec = String.contains str '.' in
+  let has_exp = String.contains str 'e' || String.contains str 'E' in
+  if has_dec || has_exp then
+    match float_of_string_opt str with
+    | Some n -> Some (Number n)
+    | None -> None
+  else
+    match int_of_string_opt str with
+    | Some n -> Some (Integer n)
+    | None ->
+      (* handles "nan", "inf", "-inf" *)
       match float_of_string_opt str with
       | Some n -> Some (Number n)
       | None -> None

hosts/ocaml/lib/sx_primitives.ml

@@ -51,7 +51,15 @@ let get_primitive name =
 (* Trampoline hook — set by sx_ref after initialization to break circular dep *)
 let trampoline_hook : (value -> value) ref = ref (fun v -> v)
 
+let as_int = function
+  | Integer n -> n
+  | Number n -> int_of_float n
+  | v -> raise (Eval_error ("Expected number, got " ^ type_of v))
+
+let all_ints = List.for_all (function Integer _ -> true | _ -> false)
+
 let rec as_number = function
+  | Integer n -> float_of_int n
   | Number n -> n
   | Bool true -> 1.0
   | Bool false -> 0.0
@@ -79,6 +87,7 @@ let as_bool = function
 
 let rec to_string = function
   | String s -> s
+  | Integer n -> string_of_int n
   | Number n -> Sx_types.format_number n
   | Bool true -> "true"
   | Bool false -> "false"
@@ -93,13 +102,26 @@ let rec to_string = function
 let () =
   (* === Arithmetic === *)
   register "+" (fun args ->
+    if all_ints args then
+      Integer (List.fold_left (fun acc a -> match a with Integer n -> acc + n | _ -> acc) 0 args)
+    else
       Number (List.fold_left (fun acc a -> acc +. as_number a) 0.0 args));
   register "-" (fun args ->
     match args with
-    | [] -> Number 0.0
+    | [] -> Integer 0
+    | [Integer n] -> Integer (-n)
     | [a] -> Number (-. (as_number a))
-    | a :: rest -> Number (List.fold_left (fun acc x -> acc -. as_number x) (as_number a) rest));
+    | _ when all_ints args ->
+      (match args with
+       | Integer h :: tl ->
+         Integer (List.fold_left (fun acc a -> match a with Integer n -> acc - n | _ -> acc) h tl)
+       | _ -> Number 0.0)
+    | a :: rest ->
+      Number (List.fold_left (fun acc x -> acc -. as_number x) (as_number a) rest));
   register "*" (fun args ->
+    if all_ints args then
+      Integer (List.fold_left (fun acc a -> match a with Integer n -> acc * n | _ -> acc) 1 args)
+    else
       Number (List.fold_left (fun acc a -> acc *. as_number a) 1.0 args));
   register "/" (fun args ->
     match args with
@@ -107,35 +129,54 @@ let () =
     | _ -> raise (Eval_error "/: expected 2 args"));
   register "mod" (fun args ->
     match args with
+    | [Integer a; Integer b] -> Integer (a mod b)
     | [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"));
+    match args with
+    | [Integer n] -> Integer (n + 1)
+    | [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"));
+    match args with
+    | [Integer n] -> Integer (n - 1)
+    | [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"));
+    match args with
+    | [Integer n] -> Integer (abs n)
+    | [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))
+    match args with
+    | [Integer n] -> Integer n
+    | [a] -> Integer (int_of_float (floor (as_number a)))
     | _ -> raise (Eval_error "floor: 1 arg"));
   register "ceil" (fun args ->
-    match args with [a] -> Number (ceil (as_number a))
+    match args with
+    | [Integer n] -> Integer n
+    | [a] -> Integer (int_of_float (ceil (as_number a)))
     | _ -> raise (Eval_error "ceil: 1 arg"));
   register "round" (fun args ->
     match args with
-    | [a] -> Number (Float.round (as_number a))
+    | [Integer n] -> Integer n
+    | [a] -> Integer (int_of_float (Float.round (as_number a)))
     | [a; b] ->
-      let n = as_number a and places = int_of_float (as_number b) in
+      let n = as_number a and places = as_int 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")
+    | _ when all_ints args ->
+      Integer (List.fold_left (fun acc a -> match a with Integer n -> min acc n | _ -> acc) max_int args)
     | _ -> 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")
+    | _ when all_ints args ->
+      Integer (List.fold_left (fun acc a -> match a with Integer n -> max acc n | _ -> acc) min_int args)
     | _ -> 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"));
@@ -189,6 +230,7 @@ let () =
     Number (Float.sqrt sum));
   register "sign" (fun args ->
     match args with
+    | [Integer n] -> Integer (if n > 0 then 1 else if n < 0 then -1 else 0)
     | [a] ->
       let n = as_number a in
       Number (if Float.is_nan n then Float.nan
@@ -234,32 +276,47 @@ let () =
     | _ -> raise (Eval_error "clamp: 3 args"));
   register "truncate" (fun args ->
     match args with
-    | [a] -> let n = as_number a in Number (if n >= 0.0 then floor n else ceil n)
+    | [Integer n] -> Integer n
+    | [a] -> let n = as_number a in Integer (int_of_float (if n >= 0.0 then floor n else ceil n))
     | _ -> raise (Eval_error "truncate: 1 arg"));
   register "remainder" (fun args ->
     match args with
+    | [Integer a; Integer b] -> Integer (a mod b)
     | [a; b] -> Number (Float.rem (as_number a) (as_number b))
     | _ -> raise (Eval_error "remainder: 2 args"));
   register "modulo" (fun args ->
     match args with
+    | [Integer a; Integer b] ->
+      let r = a mod b in
+      Integer (if r = 0 || (r > 0) = (b > 0) then r else r + b)
     | [a; b] ->
       let a = as_number a and b = as_number b in
       let r = Float.rem a b in
       Number (if r = 0.0 || (r > 0.0) = (b > 0.0) then r else r +. b)
     | _ -> raise (Eval_error "modulo: 2 args"));
   register "exact?" (fun args ->
-    match args with [Number f] -> Bool (Float.is_integer f) | [_] -> Bool false
+    match args with
+    | [Integer _] -> Bool true
+    | [Number _] -> Bool false
+    | [_] -> Bool false
     | _ -> raise (Eval_error "exact?: 1 arg"));
   register "inexact?" (fun args ->
-    match args with [Number f] -> Bool (not (Float.is_integer f)) | [_] -> Bool false
+    match args with
+    | [Number _] -> Bool true
+    | [Integer _] -> Bool false
+    | [_] -> Bool false
     | _ -> raise (Eval_error "inexact?: 1 arg"));
   register "exact->inexact" (fun args ->
-    match args with [Number n] -> Number n | [a] -> Number (as_number a)
+    match args with
+    | [Integer n] -> Number (float_of_int n)
+    | [Number n] -> Number n
+    | [a] -> Number (as_number a)
     | _ -> raise (Eval_error "exact->inexact: 1 arg"));
   register "inexact->exact" (fun args ->
     match args with
-    | [Number n] -> if Float.is_integer n then Number n else Number (Float.round n)
+    | [Integer n] -> Integer n
-    | [a] -> Number (Float.round (as_number a))
+    | [Number n] -> Integer (int_of_float (Float.round n))
+    | [a] -> Integer (int_of_float (Float.round (as_number a)))
     | _ -> raise (Eval_error "inexact->exact: 1 arg"));
   register "parse-int" (fun args ->
     let parse_leading_int s =
@@ -276,10 +333,11 @@ let () =
       else None
     in
     match args with
-    | [String s] -> (match parse_leading_int s with Some n -> Number (float_of_int n) | None -> Nil)
+    | [String s] -> (match parse_leading_int s with Some n -> Integer n | None -> Nil)
     | [String s; default_val] ->
-      (match parse_leading_int s with Some n -> Number (float_of_int n) | None -> default_val)
+      (match parse_leading_int s with Some n -> Integer n | None -> default_val)
-    | [Number n] | [Number n; _] -> Number (float_of_int (int_of_float n))
+    | [Integer n] | [Integer n; _] -> Integer n
+    | [Number n] | [Number n; _] -> Integer (int_of_float n)
     | [_; default_val] -> default_val
     | _ -> Nil);
   register "parse-float" (fun args ->
@@ -296,7 +354,10 @@ let () =
   let rec safe_eq a b =
     if a == b then true  (* physical equality fast path *)
     else match a, b with
+    | Integer x, Integer y -> x = y
     | Number x, Number y -> x = y
+    | Integer x, Number y -> float_of_int x = y
+    | Number x, Integer y -> x = float_of_int y
     | String x, String y -> x = y
     | Bool x, Bool y -> x = y
     | Nil, Nil -> true
@@ -368,9 +429,21 @@ let () =
   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"));
+    match args with
+    | [Integer _] | [Number _] -> Bool true
+    | [_] -> Bool false
+    | _ -> raise (Eval_error "number?: 1 arg"));
   register "integer?" (fun args ->
-    match args with [Number f] -> Bool (Float.is_integer f) | [_] -> Bool false | _ -> raise (Eval_error "integer?: 1 arg"));
+    match args with
+    | [Integer _] -> Bool true
+    | [Number f] -> Bool (Float.is_integer f)
+    | [_] -> Bool false
+    | _ -> raise (Eval_error "integer?: 1 arg"));
+  register "float?" (fun args ->
+    match args with
+    | [Number _] -> Bool true
+    | [_] -> Bool false
+    | _ -> raise (Eval_error "float?: 1 arg"));
   register "string?" (fun args ->
     match args with [String _] -> Bool true | [_] -> Bool false | _ -> raise (Eval_error "string?: 1 arg"));
   register "boolean?" (fun args ->
@@ -412,7 +485,7 @@ let () =
   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)))
+    match args with [a] -> Integer (String.length (as_string a))
     | _ -> raise (Eval_error "string-length: 1 arg"));
   register "string-contains?" (fun args ->
     match args with
@@ -446,7 +519,11 @@ let () =
       in find 0
     | [List items; target] | [ListRef { contents = items }; target] ->
       let eq a b = match a, b with
-        | String x, String y -> x = y | Number x, Number y -> x = y
+        | Integer x, Integer y -> x = y
+        | Number x, Number y -> x = y
+        | Integer x, Number y -> float_of_int x = y
+        | Number x, Integer y -> x = float_of_int y
+        | String x, String y -> x = y
         | Symbol x, Symbol y -> x = y | Keyword x, Keyword y -> x = y
         | Bool x, Bool y -> x = y | Nil, Nil -> true | _ -> a == b in
       let rec find i = function
@@ -457,22 +534,22 @@ let () =
     | _ -> raise (Eval_error "index-of: 2 string args or list+target"));
   register "substring" (fun args ->
     match args with
-    | [String s; Number start; Number end_] ->
+    | [String s; start_v; end_v] ->
-      let i = int_of_float start and j = int_of_float end_ in
+      let i = as_int start_v and j = as_int end_v 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] ->
+    | [String s; start_v; len_v] ->
-      let i = int_of_float start and n = int_of_float len in
+      let i = as_int start_v and n = as_int len_v 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] ->
+    | [String s; start_v] ->
-      let i = int_of_float start in
+      let i = as_int start_v in
       let sl = String.length s in
       let i = max 0 (min i sl) in
       String (String.sub s i (sl - i))
@@ -497,6 +574,7 @@ let () =
       | String s -> s | SxExpr s -> s | RawHTML s -> s
       | Keyword k -> k | Symbol s -> s
       | Nil -> "" | Bool true -> "true" | Bool false -> "false"
+      | Integer n -> string_of_int n
       | 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
@@ -523,28 +601,35 @@ let () =
     | _ -> raise (Eval_error "replace: 3 string args"));
   register "char-from-code" (fun args ->
     match args with
-    | [Number n] ->
+    | [a] ->
+      let n = as_int a in
       let buf = Buffer.create 4 in
-      Buffer.add_utf_8_uchar buf (Uchar.of_int (int_of_float n));
+      Buffer.add_utf_8_uchar buf (Uchar.of_int n);
       String (Buffer.contents buf)
     | _ -> raise (Eval_error "char-from-code: 1 arg"));
   register "char-at" (fun args ->
     match args with
-    | [String s; Number n] ->
+    | [String s; n] ->
-      let i = int_of_float n in
+      let i = as_int n in
       if i >= 0 && i < String.length s then
         String (String.make 1 s.[i])
       else Nil
     | _ -> raise (Eval_error "char-at: string and index"));
   register "char-code" (fun args ->
     match args with
-    | [String s] when String.length s > 0 -> Number (float_of_int (Char.code s.[0]))
+    | [String s] when String.length s > 0 -> Integer (Char.code s.[0])
     | _ -> raise (Eval_error "char-code: 1 non-empty string arg"));
   register "parse-number" (fun args ->
     match args with
     | [String s] ->
-      (try Number (float_of_string s)
+      let has_dec = String.contains s '.' in
-       with Failure _ -> Nil)
+      let has_exp = String.contains s 'e' || String.contains s 'E' in
+      if has_dec || has_exp then
+        (try Number (float_of_string s) with Failure _ -> Nil)
+      else
+        (match int_of_string_opt s with
+         | Some n -> Integer n
+         | None -> (try Number (float_of_string s) with Failure _ -> Nil))
     | _ -> raise (Eval_error "parse-number: 1 string arg"));
 
   (* === Regex (PCRE-compatible — same syntax as JS RegExp) === *)
@@ -621,17 +706,17 @@ let () =
   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))
+    | [List l] | [ListRef { contents = l }] -> Integer (List.length l)
-    | [String s] -> Number (float_of_int (String.length s))
+    | [String s] -> Integer (String.length s)
-    | [Dict d] -> Number (float_of_int (Hashtbl.length d))
+    | [Dict d] -> Integer (Hashtbl.length d)
-    | [Nil] | [Bool false] -> Number 0.0
+    | [Nil] | [Bool false] -> Integer 0
-    | [Bool true] -> Number 1.0
+    | [Bool true] -> Integer 1
-    | [Number _] -> Number 1.0
+    | [Number _] | [Integer _] -> Integer 1
-    | [RawHTML s] -> Number (float_of_int (String.length s))
+    | [RawHTML s] -> Integer (String.length s)
-    | [SxExpr s] -> Number (float_of_int (String.length s))
+    | [SxExpr s] -> Integer (String.length s)
-    | [Spread pairs] -> Number (float_of_int (List.length pairs))
+    | [Spread pairs] -> Integer (List.length pairs)
     | [Component _] | [Island _] | [Lambda _] | [NativeFn _]
-    | [Macro _] | [Thunk _] | [Keyword _] | [Symbol _] -> Number 0.0
+    | [Macro _] | [Thunk _] | [Keyword _] | [Symbol _] -> Integer 0
     | _ -> raise (Eval_error (Printf.sprintf "len: %d args"
         (List.length args))));
   register "length" (Hashtbl.find primitives "len");
@@ -658,10 +743,10 @@ let () =
     | _ -> raise (Eval_error "init: 1 list arg"));
   register "nth" (fun args ->
     match args with
-    | [List l; Number n] | [ListRef { contents = l }; Number n] ->
+    | [List l; n] | [ListRef { contents = l }; n] ->
-      (try List.nth l (int_of_float n) with _ -> Nil)
+      (try List.nth l (as_int n) with _ -> Nil)
-    | [String s; Number n] ->
+    | [String s; n] ->
-      let i = int_of_float n in
+      let i = as_int 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"));
@@ -707,7 +792,10 @@ let () =
       let safe_eq a b =
         a == b ||
         (match a, b with
+         | Integer x, Integer y -> x = y
          | Number x, Number y -> x = y
+         | Integer x, Number y -> float_of_int x = y
+         | Number x, Integer y -> x = float_of_int y
          | String x, String y -> x = y
          | Bool x, Bool y -> x = y
          | Nil, Nil -> true
@@ -729,15 +817,27 @@ let () =
     | _ -> raise (Eval_error "contains?: 2 args"));
   register "range" (fun args ->
     match args with
-    | [Number stop] ->
+    | [stop_v] ->
-      let n = int_of_float stop in
+      let n = as_int stop_v in
-      List (List.init (max 0 n) (fun i -> Number (float_of_int i)))
+      List (List.init (max 0 n) (fun i -> Integer i))
-    | [Number start; Number stop] ->
+    | [start_v; stop_v] ->
-      let s = int_of_float start and e = int_of_float stop in
+      let s = as_int start_v and e = as_int stop_v in
       let len = max 0 (e - s) in
-      List (List.init len (fun i -> Number (float_of_int (s + i))))
+      List (List.init len (fun i -> Integer (s + i)))
-    | [Number start; Number stop; Number step] ->
+    | [start_v; stop_v; step_v] ->
-      let s = start and e = stop and st = step in
+      (match start_v, stop_v, step_v with
+       | Integer s, Integer e, Integer st ->
+         if st = 0 then List []
+         else
+           let items = ref [] in
+           let i = ref s in
+           if st > 0 then
+             (while !i < e do items := Integer !i :: !items; i := !i + st done)
+           else
+             (while !i > e do items := Integer !i :: !items; i := !i + st done);
+           List (List.rev !items)
+       | _ ->
+         let s = as_number start_v and e = as_number stop_v and st = as_number step_v in
          if st = 0.0 then List []
          else
            let items = ref [] in
@@ -746,16 +846,16 @@ let () =
              (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)
+           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] ->
+    | [(List l | ListRef { contents = l }); start_v] ->
-      let i = max 0 (int_of_float start) in
+      let i = max 0 (as_int start_v) 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_] ->
+    | [(List l | ListRef { contents = l }); start_v; end_v] ->
-      let i = max 0 (int_of_float start) and j = int_of_float end_ in
+      let i = max 0 (as_int start_v) and j = as_int end_v in
       let len = List.length l in
       let j = min j len in
       let rec take_range idx = function
@@ -765,11 +865,11 @@ let () =
           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] ->
+    | [String s; start_v] ->
-      let i = max 0 (int_of_float start) in
+      let i = max 0 (as_int start_v) in
       String (String.sub s i (max 0 (String.length s - i)))
-    | [String s; Number start; Number end_] ->
+    | [String s; start_v; end_v] ->
-      let i = max 0 (int_of_float start) and j = int_of_float end_ in
+      let i = max 0 (as_int start_v) and j = as_int end_v in
       let sl = String.length s in
       let j = min j sl in
       String (String.sub s i (max 0 (j - i)))
@@ -798,24 +898,24 @@ let () =
     | _ -> raise (Eval_error "zip-pairs: 1 list"));
   register "take" (fun args ->
     match args with
-    | [(List l | ListRef { contents = l }); Number n] ->
+    | [(List l | ListRef { contents = l }); 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)
+      in List (take_n (as_int n) l)
     | _ -> raise (Eval_error "take: list and number"));
   register "drop" (fun args ->
     match args with
-    | [(List l | ListRef { contents = l }); Number n] ->
+    | [(List l | ListRef { contents = l }); 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)
+      in List (drop_n (as_int n) l)
     | _ -> raise (Eval_error "drop: list and number"));
   register "chunk-every" (fun args ->
     match args with
-    | [(List l | ListRef { contents = l }); Number n] ->
+    | [(List l | ListRef { contents = l }); n] ->
-      let size = int_of_float n in
+      let size = as_int n in
       let rec go = function
         | [] -> []
         | l ->
@@ -855,8 +955,9 @@ let () =
     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] ->
+    | [List l; n] | [ListRef { contents = l }; n]
-      (try List.nth l (int_of_float n) with _ -> Nil)
+        when (match n with Number _ | Integer _ -> true | _ -> false) ->
+      (try List.nth l (as_int n) with _ -> Nil)
     | [Nil; _] -> Nil  (* nil.anything → nil *)
     | [_; _] -> Nil    (* type mismatch → nil (matches JS/Python behavior) *)
     | _ -> Nil);
@@ -897,8 +998,8 @@ let () =
   register "mutable-list" (fun _args -> ListRef (ref []));
   register "set-nth!" (fun args ->
     match args with
-    | [ListRef r; Number n; v] ->
+    | [ListRef r; idx; v] ->
-      let i = int_of_float n in
+      let i = as_int idx in
       let l = !r in
       r := List.mapi (fun j x -> if j = i then v else x) l;
       Nil
@@ -1025,15 +1126,15 @@ let () =
   register "identical?" (fun args ->
     match args with
     | [a; b] ->
-      (* Physical identity for reference types, structural for values.
-         Numbers/strings/booleans from different constant pools must
-         compare equal when their values match. *)
       let identical = match a, b with
+        | Integer x, Integer y -> x = y
         | Number x, Number y -> x = y
-        | String x, String y -> x = y  (* String.equal *)
+        | Integer x, Number y -> float_of_int x = y
+        | Number x, Integer y -> x = float_of_int y
+        | String x, String y -> x = y
         | Bool x, Bool y -> x = y
         | Nil, Nil -> true
-        | _ -> a == b  (* reference identity for dicts, lists, etc. *)
+        | _ -> a == b
       in Bool identical
     | _ -> raise (Eval_error "identical?: 2 args"));
   register "make-spread" (fun args ->
@@ -1071,7 +1172,7 @@ let () =
   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)
+      List (List.mapi (fun i x -> call_any f [Integer i; x]) items)
     | [_; Nil] -> List []
     | _ -> raise (Eval_error "map-indexed: expected (fn list)"));
   register "filter" (fun args ->
@@ -1114,26 +1215,26 @@ let () =
   (* ---- 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)))
+    | [n] -> ListRef (ref (List.init (as_int 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)
+    | [ListRef r; n] -> List.nth !r (as_int n)
     | _ -> raise (Eval_error "vm-stack-get: expected (stack idx)"));
   register "vm-stack-set!" (fun args ->
     match args with
-    | [ListRef r; Number n; v] ->
+    | [ListRef r; n; v] ->
-      let i = int_of_float n in
+      let i = as_int 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))
+    | [ListRef r] -> Integer (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] ->
+    | [ListRef src; ListRef dst; n] ->
-      let count = int_of_float n in
+      let count = as_int 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)"));
@@ -1215,23 +1316,31 @@ let () =
   (* R7RS vectors — mutable fixed-size arrays *)
   register "make-vector" (fun args ->
     match args with
-    | [Number n] -> Vector (Array.make (int_of_float n) Nil)
+    | [n] -> Vector (Array.make (as_int n) Nil)
-    | [Number n; fill] -> Vector (Array.make (int_of_float n) fill)
+    | [n; fill] -> Vector (Array.make (as_int n) fill)
     | _ -> raise (Eval_error "make-vector: expected (length) or (length fill)"));
   register "vector" (fun args -> Vector (Array.of_list args));
   register "vector?" (fun args ->
     match args with [Vector _] -> Bool true | [_] -> Bool false
     | _ -> raise (Eval_error "vector?: 1 arg"));
   register "vector-length" (fun args ->
-    match args with [Vector arr] -> Number (float_of_int (Array.length arr))
+    match args with [Vector arr] -> Integer (Array.length arr)
     | _ -> raise (Eval_error "vector-length: expected vector"));
   register "vector-ref" (fun args ->
     match args with
-    | [Vector arr; Number n] -> arr.(int_of_float n)
+    | [Vector arr; n] ->
+      let i = as_int n in
+      if i < 0 || i >= Array.length arr then
+        raise (Eval_error (Printf.sprintf "vector-ref: index %d out of bounds (length %d)" i (Array.length arr)));
+      arr.(i)
     | _ -> raise (Eval_error "vector-ref: expected (vector index)"));
   register "vector-set!" (fun args ->
     match args with
-    | [Vector arr; Number n; v] -> arr.(int_of_float n) <- v; Nil
+    | [Vector arr; n; v] ->
+      let i = as_int n in
+      if i < 0 || i >= Array.length arr then
+        raise (Eval_error (Printf.sprintf "vector-set!: index %d out of bounds (length %d)" i (Array.length arr)));
+      arr.(i) <- v; Nil
     | _ -> raise (Eval_error "vector-set!: expected (vector index value)"));
   register "vector->list" (fun args ->
     match args with [Vector arr] -> List (Array.to_list arr)
@@ -1246,8 +1355,35 @@ let () =
     | [Vector arr; v] -> Array.fill arr 0 (Array.length arr) v; Nil
     | _ -> raise (Eval_error "vector-fill!: expected (vector value)"));
   register "vector-copy" (fun args ->
-    match args with [Vector arr] -> Vector (Array.copy arr)
+    match args with
-    | _ -> raise (Eval_error "vector-copy: expected vector"));
+    | [Vector arr] -> Vector (Array.copy arr)
+    | [Vector arr; s] ->
+      let start = as_int s in
+      let len = Array.length arr - start in
+      if len <= 0 then Vector [||] else Vector (Array.sub arr start len)
+    | [Vector arr; s; e] ->
+      let start = as_int s in
+      let stop = min (as_int e) (Array.length arr) in
+      let len = stop - start in
+      if len <= 0 then Vector [||] else Vector (Array.sub arr start len)
+    | _ -> raise (Eval_error "vector-copy: expected (vector) or (vector start) or (vector start end)"));
+
+  (* String buffers — O(1) amortised append for string building in loops *)
+  register "make-string-buffer" (fun _ -> StringBuffer (Buffer.create 64));
+  register "string-buffer?" (fun args ->
+    match args with [StringBuffer _] -> Bool true | [_] -> Bool false
+    | _ -> raise (Eval_error "string-buffer?: expected 1 arg"));
+  register "string-buffer-append!" (fun args ->
+    match args with
+    | [StringBuffer buf; String s] -> Buffer.add_string buf s; Nil
+    | [StringBuffer _; v] -> raise (Eval_error ("string-buffer-append!: expected string, got " ^ type_of v))
+    | _ -> raise (Eval_error "string-buffer-append!: expected (buffer string)"));
+  register "string-buffer->string" (fun args ->
+    match args with [StringBuffer buf] -> String (Buffer.contents buf)
+    | _ -> raise (Eval_error "string-buffer->string: expected (buffer)"));
+  register "string-buffer-length" (fun args ->
+    match args with [StringBuffer buf] -> Integer (Buffer.length buf)
+    | _ -> raise (Eval_error "string-buffer-length: expected (buffer)"));
 
   (* Capability-based sandboxing — gate IO operations *)
   let cap_stack : string list ref = ref [] in
@@ -1871,4 +2007,49 @@ let () =
     | [rx] ->
       let (_, _, flags) = regex_of_value rx in
       String flags
-    | _ -> raise (Eval_error "regex-flags: (regex)"))
+    | _ -> raise (Eval_error "regex-flags: (regex)"));
+
+  (* Bitwise operations *)
+  register "bitwise-and" (fun args ->
+    match args with
+    | [Integer a; Integer b] -> Integer (a land b)
+    | _ -> raise (Eval_error "bitwise-and: expected (integer integer)"));
+  register "bitwise-or" (fun args ->
+    match args with
+    | [Integer a; Integer b] -> Integer (a lor b)
+    | _ -> raise (Eval_error "bitwise-or: expected (integer integer)"));
+  register "bitwise-xor" (fun args ->
+    match args with
+    | [Integer a; Integer b] -> Integer (a lxor b)
+    | _ -> raise (Eval_error "bitwise-xor: expected (integer integer)"));
+  register "bitwise-not" (fun args ->
+    match args with
+    | [Integer a] -> Integer (lnot a)
+    | _ -> raise (Eval_error "bitwise-not: expected (integer)"));
+  register "arithmetic-shift" (fun args ->
+    match args with
+    | [Integer a; Integer count] ->
+      Integer (if count >= 0 then a lsl count else a asr (-count))
+    | _ -> raise (Eval_error "arithmetic-shift: expected (integer integer)"));
+  register "bit-count" (fun args ->
+    match args with
+    | [Integer a] ->
+      let n = ref (abs a) in
+      let c = ref 0 in
+      while !n <> 0 do
+        c := !c + (!n land 1);
+        n := !n lsr 1
+      done;
+      Integer !c
+    | _ -> raise (Eval_error "bit-count: expected (integer)"));
+  register "integer-length" (fun args ->
+    match args with
+    | [Integer a] ->
+      let n = ref (abs a) in
+      let bits = ref 0 in
+      while !n <> 0 do
+        incr bits;
+        n := !n lsr 1
+      done;
+      Integer !bits
+    | _ -> raise (Eval_error "integer-length: expected (integer)"))

hosts/ocaml/lib/sx_runtime.ml

@@ -46,7 +46,7 @@ let sx_call f args =
     !Sx_types._cek_eval_lambda_ref f args
   | Continuation (k, _) ->
     k (match args with x :: _ -> x | [] -> Nil)
-  | CallccContinuation _ ->
+  | CallccContinuation (_, _) ->
     raise (Eval_error "callcc continuations must be invoked through the CEK machine")
   | _ ->
     let nargs = List.length args in
@@ -156,6 +156,9 @@ let get_val container key =
      | "extra" -> f.cf_extra | "extra2" -> f.cf_extra2
      | "subscribers" -> f.cf_results
      | "prev-tracking" -> f.cf_extra
+     | "after-thunk" -> f.cf_f        (* wind-after frame *)
+     | "winders-len" -> f.cf_extra    (* wind-after frame *)
+     | "body-result" -> f.cf_name     (* wind-return frame *)
      | _ -> Nil)
   | VmFrame f, String k ->
     (match k with
@@ -381,15 +384,20 @@ let continuation_data v = match v with
   | _ -> raise (Eval_error "not a continuation")
 
 (* Callcc (undelimited) continuation support *)
-let callcc_continuation_p v = match v with CallccContinuation _ -> Bool true | _ -> Bool false
+let callcc_continuation_p v = match v with CallccContinuation (_, _) -> Bool true | _ -> Bool false
 
-let make_callcc_continuation captured =
+let make_callcc_continuation captured winders_len =
-  CallccContinuation (sx_to_list captured)
+  let n = match winders_len with Number f -> int_of_float f | Integer n -> n | _ -> 0 in
+  CallccContinuation (sx_to_list captured, n)
 
 let callcc_continuation_data v = match v with
-  | CallccContinuation frames -> List frames
+  | CallccContinuation (frames, _) -> List frames
   | _ -> raise (Eval_error "not a callcc continuation")
 
+let callcc_continuation_winders_len v = match v with
+  | CallccContinuation (_, n) -> Number (float_of_int n)
+  | _ -> Number 0.0
+
 (* Dynamic wind — simplified for OCaml (no async) *)
 let host_error msg =
   raise (Eval_error (value_to_str msg))

hosts/ocaml/lib/sx_types.ml

@@ -44,7 +44,8 @@ type env = {
 and value =
   | Nil
   | Bool    of bool
-  | Number of float
+  | Integer of int    (** Exact integer — distinct from inexact float. *)
+  | Number  of float  (** Inexact float. *)
   | String  of string
   | Symbol of string
   | Keyword of string
@@ -56,7 +57,7 @@ and value =
   | Macro  of macro
   | Thunk  of value * env
   | Continuation of (value -> value) * dict option
-  | CallccContinuation of value list  (** Undelimited continuation — captured kont frames *)
+  | CallccContinuation of value list * int  (** Undelimited continuation — captured kont frames + winders depth at capture *)
   | NativeFn of string * (value list -> value)
   | Signal of signal
   | RawHTML of string
@@ -72,6 +73,7 @@ and value =
   | Record of record  (** R7RS record — opaque, generative, field-indexed. *)
   | Parameter of parameter  (** R7RS parameter — dynamic binding via kont-stack provide frames. *)
   | Vector of value array  (** R7RS vector — mutable fixed-size array. *)
+  | StringBuffer of Buffer.t  (** Mutable string buffer — O(1) amortized append. *)
 
 (** CEK machine state — record instead of Dict for performance.
     5 fields × 55K steps/sec = 275K Hashtbl allocations/sec eliminated. *)
@@ -392,6 +394,7 @@ let format_number n =
 
 let value_to_string = function
   | String s -> s | Symbol s -> s | Keyword k -> k
+  | Integer n -> string_of_int n
   | Number n -> format_number n
   | Bool true -> "true" | Bool false -> "false"
   | Nil -> "" | _ -> "<value>"
@@ -461,6 +464,7 @@ let make_keyword name = Keyword (value_to_string name)
 let type_of = function
   | Nil            -> "nil"
   | Bool _         -> "boolean"
+  | Integer _      -> "number"
   | Number _       -> "number"
   | String _       -> "string"
   | Symbol _       -> "symbol"
@@ -473,7 +477,7 @@ let type_of = function
   | Macro _        -> "macro"
   | Thunk _        -> "thunk"
   | Continuation (_, _) -> "continuation"
-  | CallccContinuation _ -> "continuation"
+  | CallccContinuation (_, _) -> "continuation"
   | NativeFn _     -> "function"
   | Signal _       -> "signal"
   | RawHTML _      -> "raw-html"
@@ -488,6 +492,7 @@ let type_of = function
   | Record r       -> r.r_type.rt_name
   | Parameter _    -> "parameter"
   | Vector _       -> "vector"
+  | StringBuffer _ -> "string-buffer"
 
 let is_nil = function Nil -> true | _ -> false
 let is_lambda = function Lambda _ -> true | _ -> false
@@ -503,7 +508,7 @@ let is_signal = function
 let is_record = function Record _ -> true | _ -> false
 
 let is_callable = function
-  | Lambda _ | NativeFn _ | Continuation (_, _) | CallccContinuation _ | VmClosure _ -> true
+  | Lambda _ | NativeFn _ | Continuation (_, _) | CallccContinuation (_, _) | VmClosure _ -> true
   | _ -> false
 
 
@@ -616,6 +621,7 @@ let thunk_env = function
 (** {1 Record operations} *)
 
 let val_to_int = function
+  | Integer n -> n
   | Number n -> int_of_float n
   | v -> raise (Eval_error ("Expected number, got " ^ type_of v))
 
@@ -777,6 +783,7 @@ let rec inspect = function
   | Nil -> "nil"
   | Bool true -> "true"
   | Bool false -> "false"
+  | Integer n -> string_of_int n
   | Number n -> format_number n
   | String s ->
     let buf = Buffer.create (String.length s + 2) in
@@ -810,7 +817,7 @@ let rec inspect = function
     Printf.sprintf "<%s(%s)>" tag (String.concat ", " m.m_params)
   | Thunk _ -> "<thunk>"
   | Continuation (_, _) -> "<continuation>"
-  | CallccContinuation _ -> "<callcc-continuation>"
+  | CallccContinuation (_, _) -> "<callcc-continuation>"
   | NativeFn (name, _) -> Printf.sprintf "<native:%s>" name
   | Signal _ -> "<signal>"
   | RawHTML s -> Printf.sprintf "\"<raw-html:%d>\"" (String.length s)
@@ -831,3 +838,4 @@ let rec inspect = function
     Printf.sprintf "#(%s)" (String.concat " " elts)
   | VmFrame f -> Printf.sprintf "<vm-frame:ip=%d base=%d>" f.vf_ip f.vf_base
   | VmMachine m -> Printf.sprintf "<vm-machine:sp=%d frames=%d>" m.vm_sp (List.length m.vm_frames)
+  | StringBuffer buf -> Printf.sprintf "<string-buffer:%d>" (Buffer.length buf)

hosts/ocaml/lib/sx_vm.ml

@@ -185,7 +185,8 @@ let code_from_value v =
       | Some _ as r -> r | None -> Hashtbl.find_opt d k2 in
     let bc_list = match find2 "bytecode" "vc-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)
+        Array.of_list (List.map (fun x -> match x with
+          | Integer n -> n | Number n -> int_of_float n | _ -> 0) l)
       | _ -> [||]
     in
     let entries = match find2 "constants" "vc-constants" with
@@ -198,10 +199,10 @@ let code_from_value v =
       | _ -> entry
     ) entries in
     let arity = match find2 "arity" "vc-arity" with
-      | Some (Number n) -> int_of_float n | _ -> 0
+      | Some (Integer n) -> n | Some (Number n) -> int_of_float n | _ -> 0
     in
     let rest_arity = match find2 "rest-arity" "vc-rest-arity" with
-      | Some (Number n) -> int_of_float n | _ -> -1
+      | Some (Integer n) -> n | Some (Number n) -> int_of_float n | _ -> -1
     in
     (* Compute locals from bytecode: scan for highest LOCAL_GET/LOCAL_SET slot.
        The compiler's arity may undercount when nested lets add many locals. *)
@@ -749,10 +750,7 @@ and run vm =
             | _ -> (Hashtbl.find Sx_primitives.primitives "/") [a; b])
         | 164 (* OP_EQ *) ->
           let b = pop vm and a = pop vm in
-          let rec norm = function
+          push vm ((Hashtbl.find Sx_primitives.primitives "=") [a; b])
-            | 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
@@ -771,10 +769,10 @@ and run vm =
         | 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))
+            | List l | ListRef { contents = l } -> Integer (List.length l)
-            | String s -> Number (float_of_int (String.length s))
+            | String s -> Integer (String.length s)
-            | Dict d -> Number (float_of_int (Hashtbl.length d))
+            | Dict d -> Integer (Hashtbl.length d)
-            | Nil -> Number 0.0
+            | Nil -> Integer 0
             | _ -> (Hashtbl.find Sx_primitives.primitives "len") [v])
         | 169 (* OP_FIRST *) ->
           let v = pop vm in

hosts/ocaml/transpiler.sx

@@ -256,6 +256,7 @@
     "callcc-continuation?"
     "callcc-continuation-data"
     "make-callcc-continuation"
+    "callcc-continuation-winders-len"
     "dynamic-wind-call"
     "strip-prefix"
     "component-set-param-types!"
@@ -295,7 +296,8 @@
     "*bind-tracking*"
     "*provide-batch-depth*"
     "*provide-batch-queue*"
-    "*provide-subscribers*"))
+    "*provide-subscribers*"
+    "*winders*"))
 
 (define
   ml-is-mutable-global?
@@ -533,13 +535,13 @@
               "; cf_env = "
               (ef "env")
               "; cf_name = "
-              (if (= frame-type "if") (ef "else") (ef "name"))
+              (if (= frame-type "if") (ef "else") (cond (some (fn (k) (= k "body-result")) items) (ef "body-result") :else (ef "name")))
               "; cf_body = "
               (if (= frame-type "if") (ef "then") (ef "body"))
               "; cf_remaining = "
               (ef "remaining")
               "; cf_f = "
-              (ef "f")
+              (cond (some (fn (k) (= k "after-thunk")) items) (ef "after-thunk") (some (fn (k) (= k "f")) items) (ef "f") :else "Nil")
               "; cf_args = "
               (cond
                 (some (fn (k) (= k "evaled")) items)
@@ -582,6 +584,8 @@
                 (ef "prev-tracking")
                 (some (fn (k) (= k "extra")) items)
                 (ef "extra")
+                (some (fn (k) (= k "winders-len")) items)
+                (ef "winders-len")
                 :else "Nil")
               "; cf_extra2 = "
               (cond

lib/js/conformance.sh

@@ -49,6 +49,8 @@ trap "rm -f $TMPFILE" EXIT
   echo '(load "lib/js/transpile.sx")'
   echo '(epoch 5)'
   echo '(load "lib/js/runtime.sx")'
+  echo '(epoch 6)'
+  echo '(load "lib/js/regex.sx")'
 
   epoch=100
   for f in "${FIXTURES[@]}"; do

lib/js/regex.sx

@@ -0,0 +1,943 @@
+;; lib/js/regex.sx — pure-SX recursive backtracking regex engine
+;;
+;; Installed via (js-regex-platform-override! ...) at load time.
+;; Covers: character classes (\d\w\s . [abc] [^abc] [a-z]),
+;;   anchors (^ $ \b \B), quantifiers (* + ? {n,m} lazy variants),
+;;   groups (capturing + non-capturing), alternation (a|b),
+;;   flags: i (case-insensitive), g (global), m (multiline).
+;;
+;; Architecture:
+;;   1. rx-parse-pattern  — pattern string → compiled node list
+;;   2. rx-match-nodes    — recursive backtracker
+;;   3. rx-exec / rx-test — public interface
+;;   4. Install as {:test rx-test :exec rx-exec}
+
+;; ── Utilities ─────────────────────────────────────────────────────
+
+(define
+  rx-char-at
+  (fn (s i) (if (and (>= i 0) (< i (len s))) (char-at s i) "")))
+
+(define
+  rx-digit?
+  (fn
+    (c)
+    (and (not (= c "")) (>= (char-code c) 48) (<= (char-code c) 57))))
+
+(define
+  rx-word?
+  (fn
+    (c)
+    (and
+      (not (= c ""))
+      (or
+        (and (>= (char-code c) 65) (<= (char-code c) 90))
+        (and (>= (char-code c) 97) (<= (char-code c) 122))
+        (and (>= (char-code c) 48) (<= (char-code c) 57))
+        (= c "_")))))
+
+(define
+  rx-space?
+  (fn
+    (c)
+    (or (= c " ") (= c "\t") (= c "\n") (= c "\r") (= c "\\f") (= c ""))))
+
+(define rx-newline? (fn (c) (or (= c "\n") (= c "\r"))))
+
+(define
+  rx-downcase-char
+  (fn
+    (c)
+    (let
+      ((cc (char-code c)))
+      (if (and (>= cc 65) (<= cc 90)) (char-from-code (+ cc 32)) c))))
+
+(define
+  rx-char-eq?
+  (fn
+    (a b ci?)
+    (if ci? (= (rx-downcase-char a) (rx-downcase-char b)) (= a b))))
+
+(define
+  rx-parse-int
+  (fn
+    (pat i acc)
+    (let
+      ((c (rx-char-at pat i)))
+      (if
+        (rx-digit? c)
+        (rx-parse-int pat (+ i 1) (+ (* acc 10) (- (char-code c) 48)))
+        (list acc i)))))
+
+(define
+  rx-hex-digit-val
+  (fn
+    (c)
+    (cond
+      ((and (>= (char-code c) 48) (<= (char-code c) 57))
+        (- (char-code c) 48))
+      ((and (>= (char-code c) 65) (<= (char-code c) 70))
+        (+ 10 (- (char-code c) 65)))
+      ((and (>= (char-code c) 97) (<= (char-code c) 102))
+        (+ 10 (- (char-code c) 97)))
+      (else -1))))
+
+(define
+  rx-parse-hex-n
+  (fn
+    (pat i n acc)
+    (if
+      (= n 0)
+      (list (char-from-code acc) i)
+      (let
+        ((v (rx-hex-digit-val (rx-char-at pat i))))
+        (if
+          (< v 0)
+          (list (char-from-code acc) i)
+          (rx-parse-hex-n pat (+ i 1) (- n 1) (+ (* acc 16) v)))))))
+
+;; ── Pattern compiler ──────────────────────────────────────────────
+
+;; Node types (stored in dicts with "__t__" key):
+;;   literal  : {:__t__ "literal" :__c__ char}
+;;   any      : {:__t__ "any"}
+;;   class-d  : {:__t__ "class-d"  :__neg__ bool}
+;;   class-w  : {:__t__ "class-w"  :__neg__ bool}
+;;   class-s  : {:__t__ "class-s"  :__neg__ bool}
+;;   char-class: {:__t__ "char-class" :__neg__ bool :__items__ list}
+;;   anchor-start / anchor-end / anchor-word / anchor-nonword
+;;   quant    : {:__t__ "quant" :__node__ n :__min__ m :__max__ mx :__lazy__ bool}
+;;   group    : {:__t__ "group" :__idx__ i :__nodes__ list}
+;;   ncgroup  : {:__t__ "ncgroup" :__nodes__ list}
+;;   alt      : {:__t__ "alt" :__branches__ list-of-node-lists}
+
+;; parse one escape after `\`, returns (node new-i)
+(define
+  rx-parse-escape
+  (fn
+    (pat i)
+    (let
+      ((c (rx-char-at pat i)))
+      (cond
+        ((= c "d") (list (dict "__t__" "class-d" "__neg__" false) (+ i 1)))
+        ((= c "D") (list (dict "__t__" "class-d" "__neg__" true) (+ i 1)))
+        ((= c "w") (list (dict "__t__" "class-w" "__neg__" false) (+ i 1)))
+        ((= c "W") (list (dict "__t__" "class-w" "__neg__" true) (+ i 1)))
+        ((= c "s") (list (dict "__t__" "class-s" "__neg__" false) (+ i 1)))
+        ((= c "S") (list (dict "__t__" "class-s" "__neg__" true) (+ i 1)))
+        ((= c "b") (list (dict "__t__" "anchor-word") (+ i 1)))
+        ((= c "B") (list (dict "__t__" "anchor-nonword") (+ i 1)))
+        ((= c "n") (list (dict "__t__" "literal" "__c__" "\n") (+ i 1)))
+        ((= c "r") (list (dict "__t__" "literal" "__c__" "\r") (+ i 1)))
+        ((= c "t") (list (dict "__t__" "literal" "__c__" "\t") (+ i 1)))
+        ((= c "f") (list (dict "__t__" "literal" "__c__" "\\f") (+ i 1)))
+        ((= c "v") (list (dict "__t__" "literal" "__c__" "") (+ i 1)))
+        ((= c "u")
+          (let
+            ((res (rx-parse-hex-n pat (+ i 1) 4 0)))
+            (list (dict "__t__" "literal" "__c__" (nth res 0)) (nth res 1))))
+        ((= c "x")
+          (let
+            ((res (rx-parse-hex-n pat (+ i 1) 2 0)))
+            (list (dict "__t__" "literal" "__c__" (nth res 0)) (nth res 1))))
+        (else (list (dict "__t__" "literal" "__c__" c) (+ i 1)))))))
+
+;; parse a char-class item inside [...], returns (item new-i)
+(define
+  rx-parse-class-item
+  (fn
+    (pat i)
+    (let
+      ((c (rx-char-at pat i)))
+      (cond
+        ((= c "\\")
+          (let
+            ((esc (rx-parse-escape pat (+ i 1))))
+            (let
+              ((node (nth esc 0)) (ni (nth esc 1)))
+              (let
+                ((t (get node "__t__")))
+                (cond
+                  ((= t "class-d")
+                    (list
+                      (dict "kind" "class-d" "neg" (get node "__neg__"))
+                      ni))
+                  ((= t "class-w")
+                    (list
+                      (dict "kind" "class-w" "neg" (get node "__neg__"))
+                      ni))
+                  ((= t "class-s")
+                    (list
+                      (dict "kind" "class-s" "neg" (get node "__neg__"))
+                      ni))
+                  (else
+                    (let
+                      ((lc (get node "__c__")))
+                      (if
+                        (and
+                          (= (rx-char-at pat ni) "-")
+                          (not (= (rx-char-at pat (+ ni 1)) "]")))
+                        (let
+                          ((hi-c (rx-char-at pat (+ ni 1))))
+                          (list
+                            (dict "kind" "range" "lo" lc "hi" hi-c)
+                            (+ ni 2)))
+                        (list (dict "kind" "lit" "c" lc) ni)))))))))
+        (else
+          (if
+            (and
+              (not (= c ""))
+              (= (rx-char-at pat (+ i 1)) "-")
+              (not (= (rx-char-at pat (+ i 2)) "]"))
+              (not (= (rx-char-at pat (+ i 2)) "")))
+            (let
+              ((hi-c (rx-char-at pat (+ i 2))))
+              (list (dict "kind" "range" "lo" c "hi" hi-c) (+ i 3)))
+            (list (dict "kind" "lit" "c" c) (+ i 1))))))))
+
+(define
+  rx-parse-class-items
+  (fn
+    (pat i items)
+    (let
+      ((c (rx-char-at pat i)))
+      (if
+        (or (= c "]") (= c ""))
+        (list items i)
+        (let
+          ((res (rx-parse-class-item pat i)))
+          (begin
+            (append! items (nth res 0))
+            (rx-parse-class-items pat (nth res 1) items)))))))
+
+;; parse a sequence until stop-ch or EOF; returns (nodes new-i groups-count)
+(define
+  rx-parse-seq
+  (fn
+    (pat i stop-ch ds)
+    (let
+      ((c (rx-char-at pat i)))
+      (cond
+        ((= c "") (list (get ds "nodes") i (get ds "groups")))
+        ((= c stop-ch) (list (get ds "nodes") i (get ds "groups")))
+        ((= c "|") (rx-parse-alt-rest pat i ds))
+        (else
+          (let
+            ((res (rx-parse-atom pat i ds)))
+            (let
+              ((node (nth res 0)) (ni (nth res 1)) (ds2 (nth res 2)))
+              (let
+                ((qres (rx-parse-quant pat ni node)))
+                (begin
+                  (append! (get ds2 "nodes") (nth qres 0))
+                  (rx-parse-seq pat (nth qres 1) stop-ch ds2))))))))))
+
+;; when we hit | inside a sequence, collect all alternatives
+(define
+  rx-parse-alt-rest
+  (fn
+    (pat i ds)
+    (let
+      ((left-branch (get ds "nodes")) (branches (list)))
+      (begin
+        (append! branches left-branch)
+        (rx-parse-alt-branches pat i (get ds "groups") branches)))))
+
+(define
+  rx-parse-alt-branches
+  (fn
+    (pat i n-groups branches)
+    (let
+      ((new-nodes (list)) (ds2 (dict "groups" n-groups "nodes" new-nodes)))
+      (let
+        ((res (rx-parse-seq pat (+ i 1) "|" ds2)))
+        (begin
+          (append! branches (nth res 0))
+          (let
+            ((ni2 (nth res 1)) (g2 (nth res 2)))
+            (if
+              (= (rx-char-at pat ni2) "|")
+              (rx-parse-alt-branches pat ni2 g2 branches)
+              (list
+                (list (dict "__t__" "alt" "__branches__" branches))
+                ni2
+                g2))))))))
+
+;; parse quantifier suffix, returns (node new-i)
+(define
+  rx-parse-quant
+  (fn
+    (pat i node)
+    (let
+      ((c (rx-char-at pat i)))
+      (cond
+        ((= c "*")
+          (let
+            ((lazy? (= (rx-char-at pat (+ i 1)) "?")))
+            (list
+              (dict
+                "__t__"
+                "quant"
+                "__node__"
+                node
+                "__min__"
+                0
+                "__max__"
+                -1
+                "__lazy__"
+                lazy?)
+              (if lazy? (+ i 2) (+ i 1)))))
+        ((= c "+")
+          (let
+            ((lazy? (= (rx-char-at pat (+ i 1)) "?")))
+            (list
+              (dict
+                "__t__"
+                "quant"
+                "__node__"
+                node
+                "__min__"
+                1
+                "__max__"
+                -1
+                "__lazy__"
+                lazy?)
+              (if lazy? (+ i 2) (+ i 1)))))
+        ((= c "?")
+          (let
+            ((lazy? (= (rx-char-at pat (+ i 1)) "?")))
+            (list
+              (dict
+                "__t__"
+                "quant"
+                "__node__"
+                node
+                "__min__"
+                0
+                "__max__"
+                1
+                "__lazy__"
+                lazy?)
+              (if lazy? (+ i 2) (+ i 1)))))
+        ((= c "{")
+          (let
+            ((mres (rx-parse-int pat (+ i 1) 0)))
+            (let
+              ((mn (nth mres 0)) (mi (nth mres 1)))
+              (let
+                ((sep (rx-char-at pat mi)))
+                (cond
+                  ((= sep "}")
+                    (let
+                      ((lazy? (= (rx-char-at pat (+ mi 1)) "?")))
+                      (list
+                        (dict
+                          "__t__"
+                          "quant"
+                          "__node__"
+                          node
+                          "__min__"
+                          mn
+                          "__max__"
+                          mn
+                          "__lazy__"
+                          lazy?)
+                        (if lazy? (+ mi 2) (+ mi 1)))))
+                  ((= sep ",")
+                    (let
+                      ((c2 (rx-char-at pat (+ mi 1))))
+                      (if
+                        (= c2 "}")
+                        (let
+                          ((lazy? (= (rx-char-at pat (+ mi 2)) "?")))
+                          (list
+                            (dict
+                              "__t__"
+                              "quant"
+                              "__node__"
+                              node
+                              "__min__"
+                              mn
+                              "__max__"
+                              -1
+                              "__lazy__"
+                              lazy?)
+                            (if lazy? (+ mi 3) (+ mi 2))))
+                        (let
+                          ((mxres (rx-parse-int pat (+ mi 1) 0)))
+                          (let
+                            ((mx (nth mxres 0)) (mxi (nth mxres 1)))
+                            (let
+                              ((lazy? (= (rx-char-at pat (+ mxi 1)) "?")))
+                              (list
+                                (dict
+                                  "__t__"
+                                  "quant"
+                                  "__node__"
+                                  node
+                                  "__min__"
+                                  mn
+                                  "__max__"
+                                  mx
+                                  "__lazy__"
+                                  lazy?)
+                                (if lazy? (+ mxi 2) (+ mxi 1)))))))))
+                  (else (list node i)))))))
+        (else (list node i))))))
+
+;; parse one atom, returns (node new-i new-ds)
+(define
+  rx-parse-atom
+  (fn
+    (pat i ds)
+    (let
+      ((c (rx-char-at pat i)))
+      (cond
+        ((= c ".") (list (dict "__t__" "any") (+ i 1) ds))
+        ((= c "^") (list (dict "__t__" "anchor-start") (+ i 1) ds))
+        ((= c "$") (list (dict "__t__" "anchor-end") (+ i 1) ds))
+        ((= c "\\")
+          (let
+            ((esc (rx-parse-escape pat (+ i 1))))
+            (list (nth esc 0) (nth esc 1) ds)))
+        ((= c "[")
+          (let
+            ((neg? (= (rx-char-at pat (+ i 1)) "^")))
+            (let
+              ((start (if neg? (+ i 2) (+ i 1))) (items (list)))
+              (let
+                ((res (rx-parse-class-items pat start items)))
+                (let
+                  ((ci (nth res 1)))
+                  (list
+                    (dict
+                      "__t__"
+                      "char-class"
+                      "__neg__"
+                      neg?
+                      "__items__"
+                      items)
+                    (+ ci 1)
+                    ds))))))
+        ((= c "(")
+          (let
+            ((c2 (rx-char-at pat (+ i 1))))
+            (if
+              (and (= c2 "?") (= (rx-char-at pat (+ i 2)) ":"))
+              (let
+                ((inner-nodes (list))
+                  (inner-ds
+                    (dict "groups" (get ds "groups") "nodes" inner-nodes)))
+                (let
+                  ((res (rx-parse-seq pat (+ i 3) ")" inner-ds)))
+                  (list
+                    (dict "__t__" "ncgroup" "__nodes__" (nth res 0))
+                    (+ (nth res 1) 1)
+                    (dict "groups" (nth res 2) "nodes" (get ds "nodes")))))
+              (let
+                ((gidx (+ (get ds "groups") 1)) (inner-nodes (list)))
+                (let
+                  ((inner-ds (dict "groups" gidx "nodes" inner-nodes)))
+                  (let
+                    ((res (rx-parse-seq pat (+ i 1) ")" inner-ds)))
+                    (list
+                      (dict
+                        "__t__"
+                        "group"
+                        "__idx__"
+                        gidx
+                        "__nodes__"
+                        (nth res 0))
+                      (+ (nth res 1) 1)
+                      (dict "groups" (nth res 2) "nodes" (get ds "nodes")))))))))
+        (else (list (dict "__t__" "literal" "__c__" c) (+ i 1) ds))))))
+
+;; top-level compile
+(define
+  rx-compile
+  (fn
+    (pattern)
+    (let
+      ((nodes (list)) (ds (dict "groups" 0 "nodes" nodes)))
+      (let
+        ((res (rx-parse-seq pattern 0 "" ds)))
+        (dict "nodes" (nth res 0) "ngroups" (nth res 2))))))
+
+;; ── Matcher ───────────────────────────────────────────────────────
+
+;; Match a char-class item against character c
+(define
+  rx-item-matches?
+  (fn
+    (item c ci?)
+    (let
+      ((kind (get item "kind")))
+      (cond
+        ((= kind "lit") (rx-char-eq? c (get item "c") ci?))
+        ((= kind "range")
+          (let
+            ((lo (if ci? (rx-downcase-char (get item "lo")) (get item "lo")))
+              (hi
+                (if ci? (rx-downcase-char (get item "hi")) (get item "hi")))
+              (dc (if ci? (rx-downcase-char c) c)))
+            (and
+              (>= (char-code dc) (char-code lo))
+              (<= (char-code dc) (char-code hi)))))
+        ((= kind "class-d")
+          (let ((m (rx-digit? c))) (if (get item "neg") (not m) m)))
+        ((= kind "class-w")
+          (let ((m (rx-word? c))) (if (get item "neg") (not m) m)))
+        ((= kind "class-s")
+          (let ((m (rx-space? c))) (if (get item "neg") (not m) m)))
+        (else false)))))
+
+(define
+  rx-class-items-any?
+  (fn
+    (items c ci?)
+    (if
+      (empty? items)
+      false
+      (if
+        (rx-item-matches? (first items) c ci?)
+        true
+        (rx-class-items-any? (rest items) c ci?)))))
+
+(define
+  rx-class-matches?
+  (fn
+    (node c ci?)
+    (let
+      ((neg? (get node "__neg__")) (items (get node "__items__")))
+      (let
+        ((hit (rx-class-items-any? items c ci?)))
+        (if neg? (not hit) hit)))))
+
+;; Word boundary check
+(define
+  rx-is-word-boundary?
+  (fn
+    (s i slen)
+    (let
+      ((before (if (> i 0) (rx-word? (char-at s (- i 1))) false))
+        (after (if (< i slen) (rx-word? (char-at s i)) false)))
+      (not (= before after)))))
+
+;; ── Core matcher ──────────────────────────────────────────────────
+;;
+;; rx-match-nodes : nodes s i slen ci? mi? groups → end-pos or -1
+;;
+;; Matches `nodes` starting at position `i` in string `s`.
+;; Returns the position after the last character consumed, or -1 on failure.
+;; Mutates `groups` dict to record captures.
+
+(define
+  rx-match-nodes
+  (fn
+    (nodes s i slen ci? mi? groups)
+    (if
+      (empty? nodes)
+      i
+      (let
+        ((node (first nodes)) (rest-nodes (rest nodes)))
+        (let
+          ((t (get node "__t__")))
+          (cond
+            ((= t "literal")
+              (if
+                (and
+                  (< i slen)
+                  (rx-char-eq? (char-at s i) (get node "__c__") ci?))
+                (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
+                -1))
+            ((= t "any")
+              (if
+                (and (< i slen) (not (rx-newline? (char-at s i))))
+                (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
+                -1))
+            ((= t "class-d")
+              (let
+                ((m (and (< i slen) (rx-digit? (char-at s i)))))
+                (if
+                  (if (get node "__neg__") (not m) m)
+                  (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
+                  -1)))
+            ((= t "class-w")
+              (let
+                ((m (and (< i slen) (rx-word? (char-at s i)))))
+                (if
+                  (if (get node "__neg__") (not m) m)
+                  (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
+                  -1)))
+            ((= t "class-s")
+              (let
+                ((m (and (< i slen) (rx-space? (char-at s i)))))
+                (if
+                  (if (get node "__neg__") (not m) m)
+                  (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
+                  -1)))
+            ((= t "char-class")
+              (if
+                (and (< i slen) (rx-class-matches? node (char-at s i) ci?))
+                (rx-match-nodes rest-nodes s (+ i 1) slen ci? mi? groups)
+                -1))
+            ((= t "anchor-start")
+              (if
+                (or
+                  (= i 0)
+                  (and mi? (rx-newline? (rx-char-at s (- i 1)))))
+                (rx-match-nodes rest-nodes s i slen ci? mi? groups)
+                -1))
+            ((= t "anchor-end")
+              (if
+                (or (= i slen) (and mi? (rx-newline? (rx-char-at s i))))
+                (rx-match-nodes rest-nodes s i slen ci? mi? groups)
+                -1))
+            ((= t "anchor-word")
+              (if
+                (rx-is-word-boundary? s i slen)
+                (rx-match-nodes rest-nodes s i slen ci? mi? groups)
+                -1))
+            ((= t "anchor-nonword")
+              (if
+                (not (rx-is-word-boundary? s i slen))
+                (rx-match-nodes rest-nodes s i slen ci? mi? groups)
+                -1))
+            ((= t "group")
+              (let
+                ((gidx (get node "__idx__"))
+                  (inner (get node "__nodes__")))
+                (let
+                  ((g-end (rx-match-nodes inner s i slen ci? mi? groups)))
+                  (if
+                    (>= g-end 0)
+                    (begin
+                      (dict-set!
+                        groups
+                        (js-to-string gidx)
+                        (substring s i g-end))
+                      (let
+                        ((final-end (rx-match-nodes rest-nodes s g-end slen ci? mi? groups)))
+                        (if
+                          (>= final-end 0)
+                          final-end
+                          (begin
+                            (dict-set! groups (js-to-string gidx) nil)
+                            -1))))
+                    -1))))
+            ((= t "ncgroup")
+              (let
+                ((inner (get node "__nodes__")))
+                (rx-match-nodes
+                  (append inner rest-nodes)
+                  s
+                  i
+                  slen
+                  ci?
+                  mi?
+                  groups)))
+            ((= t "alt")
+              (let
+                ((branches (get node "__branches__")))
+                (rx-try-branches branches rest-nodes s i slen ci? mi? groups)))
+            ((= t "quant")
+              (let
+                ((inner-node (get node "__node__"))
+                  (mn (get node "__min__"))
+                  (mx (get node "__max__"))
+                  (lazy? (get node "__lazy__")))
+                (if
+                  lazy?
+                  (rx-quant-lazy
+                    inner-node
+                    mn
+                    mx
+                    rest-nodes
+                    s
+                    i
+                    slen
+                    ci?
+                    mi?
+                    groups
+                    0)
+                  (rx-quant-greedy
+                    inner-node
+                    mn
+                    mx
+                    rest-nodes
+                    s
+                    i
+                    slen
+                    ci?
+                    mi?
+                    groups
+                    0))))
+            (else -1)))))))
+
+(define
+  rx-try-branches
+  (fn
+    (branches rest-nodes s i slen ci? mi? groups)
+    (if
+      (empty? branches)
+      -1
+      (let
+        ((res (rx-match-nodes (append (first branches) rest-nodes) s i slen ci? mi? groups)))
+        (if
+          (>= res 0)
+          res
+          (rx-try-branches (rest branches) rest-nodes s i slen ci? mi? groups))))))
+
+;; Greedy: expand as far as possible, then try rest from the longest match
+;; Strategy: recurse forward (extend first); only try rest when extension fails
+(define
+  rx-quant-greedy
+  (fn
+    (inner-node mn mx rest-nodes s i slen ci? mi? groups count)
+    (let
+      ((can-extend (and (< i slen) (or (= mx -1) (< count mx)))))
+      (if
+        can-extend
+        (let
+          ((ni (rx-match-one inner-node s i slen ci? mi? groups)))
+          (if
+            (>= ni 0)
+            (let
+              ((res (rx-quant-greedy inner-node mn mx rest-nodes s ni slen ci? mi? groups (+ count 1))))
+              (if
+                (>= res 0)
+                res
+                (if
+                  (>= count mn)
+                  (rx-match-nodes rest-nodes s i slen ci? mi? groups)
+                  -1)))
+            (if
+              (>= count mn)
+              (rx-match-nodes rest-nodes s i slen ci? mi? groups)
+              -1)))
+        (if
+          (>= count mn)
+          (rx-match-nodes rest-nodes s i slen ci? mi? groups)
+          -1)))))
+
+;; Lazy: try rest first, extend only if rest fails
+(define
+  rx-quant-lazy
+  (fn
+    (inner-node mn mx rest-nodes s i slen ci? mi? groups count)
+    (if
+      (>= count mn)
+      (let
+        ((res (rx-match-nodes rest-nodes s i slen ci? mi? groups)))
+        (if
+          (>= res 0)
+          res
+          (if
+            (and (< i slen) (or (= mx -1) (< count mx)))
+            (let
+              ((ni (rx-match-one inner-node s i slen ci? mi? groups)))
+              (if
+                (>= ni 0)
+                (rx-quant-lazy
+                  inner-node
+                  mn
+                  mx
+                  rest-nodes
+                  s
+                  ni
+                  slen
+                  ci?
+                  mi?
+                  groups
+                  (+ count 1))
+                -1))
+            -1)))
+      (if
+        (< i slen)
+        (let
+          ((ni (rx-match-one inner-node s i slen ci? mi? groups)))
+          (if
+            (>= ni 0)
+            (rx-quant-lazy
+              inner-node
+              mn
+              mx
+              rest-nodes
+              s
+              ni
+              slen
+              ci?
+              mi?
+              groups
+              (+ count 1))
+            -1))
+        -1))))
+
+;; Match a single node at position i, return new pos or -1
+(define
+  rx-match-one
+  (fn
+    (node s i slen ci? mi? groups)
+    (rx-match-nodes (list node) s i slen ci? mi? groups)))
+
+;; ── Engine entry points ───────────────────────────────────────────
+
+;; Try matching at exactly position i. Returns result dict or nil.
+(define
+  rx-try-at
+  (fn
+    (compiled s i slen ci? mi?)
+    (let
+      ((nodes (get compiled "nodes")) (ngroups (get compiled "ngroups")))
+      (let
+        ((groups (dict)))
+        (let
+          ((end (rx-match-nodes nodes s i slen ci? mi? groups)))
+          (if
+            (>= end 0)
+            (dict "start" i "end" end "groups" groups "ngroups" ngroups)
+            nil))))))
+
+;; Find first match scanning from search-start.
+(define
+  rx-find-from
+  (fn
+    (compiled s search-start slen ci? mi?)
+    (if
+      (> search-start slen)
+      nil
+      (let
+        ((res (rx-try-at compiled s search-start slen ci? mi?)))
+        (if
+          res
+          res
+          (rx-find-from compiled s (+ search-start 1) slen ci? mi?))))))
+
+;; Build exec result dict from raw match result
+(define
+  rx-build-exec-result
+  (fn
+    (s match-res)
+    (let
+      ((start (get match-res "start"))
+        (end (get match-res "end"))
+        (groups (get match-res "groups"))
+        (ngroups (get match-res "ngroups")))
+      (let
+        ((matched (substring s start end))
+          (caps (rx-build-captures groups ngroups 1)))
+        (dict "match" matched "index" start "input" s "groups" caps)))))
+
+(define
+  rx-build-captures
+  (fn
+    (groups ngroups idx)
+    (if
+      (> idx ngroups)
+      (list)
+      (let
+        ((cap (get groups (js-to-string idx))))
+        (cons
+          (if (= cap nil) :js-undefined cap)
+          (rx-build-captures groups ngroups (+ idx 1)))))))
+
+;; ── Public interface ──────────────────────────────────────────────
+
+;; Lazy compile: build NFA on first use, cache under "__compiled__"
+(define
+  rx-ensure-compiled!
+  (fn
+    (rx)
+    (if
+      (dict-has? rx "__compiled__")
+      (get rx "__compiled__")
+      (let
+        ((c (rx-compile (get rx "source"))))
+        (begin (dict-set! rx "__compiled__" c) c)))))
+
+(define
+  rx-test
+  (fn
+    (rx s)
+    (let
+      ((compiled (rx-ensure-compiled! rx))
+        (ci? (get rx "ignoreCase"))
+        (mi? (get rx "multiline"))
+        (slen (len s)))
+      (let
+        ((start (if (get rx "global") (let ((li (get rx "lastIndex"))) (if (number? li) li 0)) 0)))
+        (let
+          ((res (rx-find-from compiled s start slen ci? mi?)))
+          (if
+            (get rx "global")
+            (begin
+              (dict-set! rx "lastIndex" (if res (get res "end") 0))
+              (if res true false))
+            (if res true false)))))))
+
+(define
+  rx-exec
+  (fn
+    (rx s)
+    (let
+      ((compiled (rx-ensure-compiled! rx))
+        (ci? (get rx "ignoreCase"))
+        (mi? (get rx "multiline"))
+        (slen (len s)))
+      (let
+        ((start (if (get rx "global") (let ((li (get rx "lastIndex"))) (if (number? li) li 0)) 0)))
+        (let
+          ((res (rx-find-from compiled s start slen ci? mi?)))
+          (if
+            res
+            (begin
+              (when
+                (get rx "global")
+                (dict-set! rx "lastIndex" (get res "end")))
+              (rx-build-exec-result s res))
+            (begin
+              (when (get rx "global") (dict-set! rx "lastIndex" 0))
+              nil)))))))
+
+;; match-all for String.prototype.matchAll
+(define
+  js-regex-match-all
+  (fn
+    (rx s)
+    (let
+      ((compiled (rx-ensure-compiled! rx))
+        (ci? (get rx "ignoreCase"))
+        (mi? (get rx "multiline"))
+        (slen (len s))
+        (results (list)))
+      (rx-match-all-loop compiled s 0 slen ci? mi? results))))
+
+(define
+  rx-match-all-loop
+  (fn
+    (compiled s i slen ci? mi? results)
+    (if
+      (> i slen)
+      results
+      (let
+        ((res (rx-find-from compiled s i slen ci? mi?)))
+        (if
+          res
+          (begin
+            (append! results (rx-build-exec-result s res))
+            (let
+              ((next (get res "end")))
+              (rx-match-all-loop
+                compiled
+                s
+                (if (= next i) (+ i 1) next)
+                slen
+                ci?
+                mi?
+                results)))
+          results)))))
+
+;; ── Install platform ──────────────────────────────────────────────
+
+(js-regex-platform-override! "test" rx-test)
+(js-regex-platform-override! "exec" rx-exec)

lib/js/runtime.sx

@@ -2032,7 +2032,15 @@
           (&rest args)
           (cond
             ((= (len args) 0) nil)
-            ((js-regex? (nth args 0)) (js-regex-stub-exec (nth args 0) s))
+            ((js-regex? (nth args 0))
+              (let
+                ((rx (nth args 0)))
+                (let
+                  ((impl (get __js_regex_platform__ "exec")))
+                  (if
+                    (js-undefined? impl)
+                    (js-regex-stub-exec rx s)
+                    (impl rx s)))))
             (else
               (let
                 ((needle (js-to-string (nth args 0))))
@@ -2041,7 +2049,7 @@
                   (if
                     (= idx -1)
                     nil
-                    (let ((res (list))) (append! res needle) res))))))))
+                    (let ((res (list))) (begin (append! res needle) res)))))))))
       ((= name "at")
         (fn
           (i)
@@ -2099,6 +2107,20 @@
       ((= name "toWellFormed") (fn () s))
       (else js-undefined))))
 
+(define __js_tdz_sentinel__ (dict "__tdz__" true))
+
+(define js-tdz? (fn (v) (and (dict? v) (dict-has? v "__tdz__"))))
+
+(define
+  js-tdz-check
+  (fn
+    (name val)
+    (if
+      (js-tdz? val)
+      (raise
+        (TypeError (str "Cannot access '" name "' before initialization")))
+      val)))
+
 (define
   js-string-slice
   (fn

lib/js/test.sh

@@ -33,6 +33,8 @@ cat > "$TMPFILE" << 'EPOCHS'
 (load "lib/js/transpile.sx")
 (epoch 5)
 (load "lib/js/runtime.sx")
+(epoch 6)
+(load "lib/js/regex.sx")
 
 ;; ── Phase 0: stubs still behave ─────────────────────────────────
 (epoch 10)
@@ -1323,6 +1325,108 @@ cat > "$TMPFILE" << 'EPOCHS'
 (epoch 3505)
 (eval "(js-eval \"var a = {length: 3, 0: 10, 1: 20, 2: 30}; var sum = 0; Array.prototype.forEach.call(a, function(x){sum += x;}); sum\")")
 
+;; ── Phase 12: Regex engine ────────────────────────────────────────
+;; Platform is installed (test key is a function, not undefined)
+(epoch 5000)
+(eval "(js-undefined? (get __js_regex_platform__ \"test\"))")
+(epoch 5001)
+(eval "(js-eval \"/foo/.test('hi foo bar')\")")
+(epoch 5002)
+(eval "(js-eval \"/foo/.test('hi bar')\")")
+;; Case-insensitive flag
+(epoch 5003)
+(eval "(js-eval \"/FOO/i.test('hello foo world')\")")
+;; Anchors
+(epoch 5004)
+(eval "(js-eval \"/^hello/.test('hello world')\")")
+(epoch 5005)
+(eval "(js-eval \"/^hello/.test('say hello')\")")
+(epoch 5006)
+(eval "(js-eval \"/world$/.test('hello world')\")")
+;; Character classes
+(epoch 5007)
+(eval "(js-eval \"/\\\\d+/.test('abc 123')\")")
+(epoch 5008)
+(eval "(js-eval \"/\\\\w+/.test('hello')\")")
+(epoch 5009)
+(eval "(js-eval \"/[abc]/.test('dog')\")")
+(epoch 5010)
+(eval "(js-eval \"/[abc]/.test('cat')\")")
+;; Quantifiers
+(epoch 5011)
+(eval "(js-eval \"/a*b/.test('b')\")")
+(epoch 5012)
+(eval "(js-eval \"/a+b/.test('b')\")")
+(epoch 5013)
+(eval "(js-eval \"/a{2,3}/.test('aa')\")")
+(epoch 5014)
+(eval "(js-eval \"/a{2,3}/.test('a')\")")
+;; Dot
+(epoch 5015)
+(eval "(js-eval \"/h.llo/.test('hello')\")")
+(epoch 5016)
+(eval "(js-eval \"/h.llo/.test('hllo')\")")
+;; exec result
+(epoch 5017)
+(eval "(js-eval \"var m = /foo(\\\\w+)/.exec('foobar'); m.match\")")
+(epoch 5018)
+(eval "(js-eval \"var m = /foo(\\\\w+)/.exec('foobar'); m.index\")")
+(epoch 5019)
+(eval "(js-eval \"var m = /foo(\\\\w+)/.exec('foobar'); m.groups[0]\")")
+;; Alternation
+(epoch 5020)
+(eval "(js-eval \"/cat|dog/.test('I have a dog')\")")
+(epoch 5021)
+(eval "(js-eval \"/cat|dog/.test('I have a fish')\")")
+;; Non-capturing group
+(epoch 5022)
+(eval "(js-eval \"/(?:foo)+/.test('foofoo')\")")
+;; Negated char class
+(epoch 5023)
+(eval "(js-eval \"/[^abc]/.test('d')\")")
+(epoch 5024)
+(eval "(js-eval \"/[^abc]/.test('a')\")")
+;; Range inside char class
+(epoch 5025)
+(eval "(js-eval \"/[a-z]+/.test('hello')\")")
+;; Word boundary
+(epoch 5026)
+(eval "(js-eval \"/\\\\bword\\\\b/.test('a word here')\")")
+(epoch 5027)
+(eval "(js-eval \"/\\\\bword\\\\b/.test('password')\")")
+;; Lazy quantifier
+(epoch 5028)
+(eval "(js-eval \"var m = /a+?/.exec('aaa'); m.match\")")
+;; Global flag exec
+(epoch 5029)
+(eval "(js-eval \"var r=/\\\\d+/g; r.exec('a1b2'); r.exec('a1b2').match\")")
+;; String.prototype.match with regex
+(epoch 5030)
+(eval "(js-eval \"'hello world'.match(/\\\\w+/).match\")")
+;; String.prototype.search
+(epoch 5031)
+(eval "(js-eval \"'hello world'.search(/world/)\")")
+;; String.prototype.replace with regex
+(epoch 5032)
+(eval "(js-eval \"'hello world'.replace(/world/, 'there')\")")
+;; multiline anchor
+(epoch 5033)
+(eval "(js-eval \"/^bar/m.test('foo\\nbar')\")")
+
+;; ── Phase 13: let/const TDZ infrastructure ───────────────────────
+;; The TDZ sentinel and checker are defined in runtime.sx.
+;; let/const bindings work normally after initialization.
+(epoch 5100)
+(eval "(js-eval \"let x = 5; x\")")
+(epoch 5101)
+(eval "(js-eval \"const y = 42; y\")")
+;; TDZ sentinel exists and is detectable
+(epoch 5102)
+(eval "(js-tdz? __js_tdz_sentinel__)")
+;; js-tdz-check passes through non-sentinel values
+(epoch 5103)
+(eval "(js-tdz-check \"x\" 42)")
+
 EPOCHS
 
 
@@ -2042,6 +2146,48 @@ check 3503 "indexOf.call arrLike"          '1'
 check 3504 "filter.call arrLike"           '"2,3"'
 check 3505 "forEach.call arrLike sum"      '60'
 
+# ── Phase 12: Regex engine ────────────────────────────────────────
+check 5000 "regex platform installed"           'false'
+check 5001 "/foo/ matches"                      'true'
+check 5002 "/foo/ no match"                     'false'
+check 5003 "/FOO/i case-insensitive"            'true'
+check 5004 "/^hello/ anchor match"              'true'
+check 5005 "/^hello/ anchor no-match"           'false'
+check 5006 "/world$/ end anchor"                'true'
+check 5007 "/\\d+/ digit class"                 'true'
+check 5008 "/\\w+/ word class"                  'true'
+check 5009 "/[abc]/ class no-match"             'false'
+check 5010 "/[abc]/ class match"                'true'
+check 5011 "/a*b/ zero-or-more"                 'true'
+check 5012 "/a+b/ one-or-more no-match"         'false'
+check 5013 "/a{2,3}/ quant match"               'true'
+check 5014 "/a{2,3}/ quant no-match"            'false'
+check 5015 "dot matches any"                    'true'
+check 5016 "dot requires char"                  'false'
+check 5017 "exec match string"                  '"foobar"'
+check 5018 "exec match index"                   '0'
+check 5019 "exec capture group"                 '"bar"'
+check 5020 "alternation cat|dog match"          'true'
+check 5021 "alternation cat|dog no-match"       'false'
+check 5022 "non-capturing group"                'true'
+check 5023 "negated class match"                'true'
+check 5024 "negated class no-match"             'false'
+check 5025 "range [a-z]+"                       'true'
+check 5026 "word boundary match"                'true'
+check 5027 "word boundary no-match"             'false'
+check 5028 "lazy quantifier"                    '"a"'
+check 5029 "global exec advances"               '"2"'
+check 5030 "String.match regex"                 '"hello"'
+check 5031 "String.search regex"                '6'
+check 5032 "String.replace regex"               '"hello there"'
+check 5033 "multiline anchor"                   'true'
+
+# ── Phase 13: let/const TDZ infrastructure ───────────────────────
+check 5100 "let binding initialized"            '5'
+check 5101 "const binding initialized"          '42'
+check 5102 "TDZ sentinel is detectable"         'true'
+check 5103 "tdz-check passes non-sentinel"      '42'
+
 TOTAL=$((PASS + FAIL))
 if [ $FAIL -eq 0 ]; then
   echo "✓ $PASS/$TOTAL JS-on-SX tests passed"

lib/js/test262-runner.py

@@ -798,6 +798,7 @@ class ServerSession:
         self._run_and_collect(3, '(load "lib/js/parser.sx")', timeout=60.0)
         self._run_and_collect(4, '(load "lib/js/transpile.sx")', timeout=60.0)
         self._run_and_collect(5, '(load "lib/js/runtime.sx")', timeout=60.0)
+        self._run_and_collect(50, '(load "lib/js/regex.sx")', timeout=60.0)
         # Preload the stub harness — use precomputed SX cache when available
         # (huge win: ~15s js-eval HARNESS_STUB → ~0s load precomputed .sx).
         cache_rel = _harness_cache_rel_path()

lib/js/transpile.sx

@@ -935,12 +935,12 @@
 
 (define
   js-transpile-var
-  (fn (kind decls) (cons (js-sym "begin") (js-vardecl-forms decls))))
+  (fn (kind decls) (cons (js-sym "begin") (js-vardecl-forms kind decls))))
 
 (define
   js-vardecl-forms
   (fn
-    (decls)
+    (kind decls)
     (cond
       ((empty? decls) (list))
       (else
@@ -953,7 +953,7 @@
                   (js-sym "define")
                   (js-sym (nth d 1))
                   (js-transpile (nth d 2)))
-                (js-vardecl-forms (rest decls))))
+                (js-vardecl-forms kind (rest decls))))
             ((js-tag? d "js-vardecl-obj")
               (let
                 ((names (nth d 1))
@@ -964,7 +964,7 @@
                   (js-vardecl-obj-forms
                     names
                     tmp-sym
-                    (js-vardecl-forms (rest decls))))))
+                    (js-vardecl-forms kind (rest decls))))))
             ((js-tag? d "js-vardecl-arr")
               (let
                 ((names (nth d 1))
@@ -976,7 +976,7 @@
                     names
                     tmp-sym
                     0
-                    (js-vardecl-forms (rest decls))))))
+                    (js-vardecl-forms kind (rest decls))))))
             (else (error "js-vardecl-forms: unexpected decl"))))))))
 
 (define

plans/agent-briefings/primitives-loop.md

@@ -0,0 +1,724 @@
+# SX Primitives — Meta-Loop Briefing
+
+Goal: add fundamental missing SX primitives in sequence, then sweep all language
+implementations to replace their workarounds. Full rationale: vectors fix O(n) array
+access across every language; numeric tower fixes float/int conflation; dynamic-wind
+fixes cleanup semantics; coroutine primitive unifies Ruby/Lua/Tcl; string buffer fixes
+O(n²) concat; algebraic data types eliminate the tagged-dict pattern everywhere.
+
+**Each fire: find the first unchecked `[ ]`, do it, commit, tick it, stop.**
+Sub-items within a Phase may span multiple fires — just commit progress and tick what's done.
+
+---
+
+## Phase 0 — Prep (gate)
+
+- [x] Stop new-language loops: send `/exit` to sx-loops windows for the four blank-slate
+      languages that haven't committed workarounds yet:
+      ```
+      tmux send-keys -t sx-loops:common-lisp "/exit" Enter
+      tmux send-keys -t sx-loops:apl          "/exit" Enter
+      tmux send-keys -t sx-loops:ruby         "/exit" Enter
+      tmux send-keys -t sx-loops:tcl          "/exit" Enter
+      ```
+      Verify all four windows are idle (claude prompt, no active task).
+
+- [x] E38 + E39 landed: check both Bucket-E branches for implementation commits.
+      ```
+      git log --oneline hs-e38-sourceinfo | head -5
+      git log --oneline hs-e39-webworker  | head -5
+      ```
+      If either branch has only its base commit (no impl work yet): note "pending" and stop —
+      next fire re-checks. Proceed only when both have at least one implementation commit.
+
+---
+
+## Phase 1 — Vectors
+
+Native mutable integer-indexed arrays. Fix: Lua O(n) sort, APL rank polymorphism, Ruby
+Array, Tcl lists, Common Lisp vectors, all using string-keyed dicts today.
+
+Primitives to add:
+- `make-vector` `n` `[fill]` → vector of length n
+- `vector?` `v` → bool
+- `vector-ref` `v` `i` → element at index i (0-based)
+- `vector-set!` `v` `i` `x` → mutate in place
+- `vector-length` `v` → integer
+- `vector->list` `v` → list
+- `list->vector` `lst` → vector
+- `vector-fill!` `v` `x` → fill all elements
+- `vector-copy` `v` `[start]` `[end]` → fresh copy of slice
+
+Steps:
+- [x] OCaml: add `SxVector of value array` to `hosts/ocaml/sx_types.ml`; implement all
+      primitives in `hosts/ocaml/sx_primitives.ml` (or equivalent); wire into evaluator.
+      Note: Vector type + most prims were already present; added bounds-checked vector-ref/set!
+      and optional start/end to vector-copy. 10/10 vector tests pass (r7rs suite).
+- [x] Spec: add vector entries to `spec/primitives.sx` with type signatures and descriptions.
+      All 10 vector primitives now have :as type annotations, :returns, and :doc strings.
+      make-vector: optional fill param; vector-copy: optional start/end (done prev step).
+- [x] JS bootstrapper: implement vectors in `hosts/javascript/platform.js` (or equivalent);
+      ensure `sx-browser.js` rebuild picks them up.
+      Fixed index-of for lists (was returning -1 not NIL, breaking bind-lambda-params),
+      added _lastErrorKont_/hostError/try-catch/without-io-hook stubs. Vectors work.
+- [x] Tests: 40+ tests in `spec/tests/test-vectors.sx` covering construction, ref, set!,
+      length, conversions, fill, copy, bounds behaviour.
+      42 tests, all pass. 1847 standard / 2362 full passing (up from 5).
+- [x] Verify: full test suite still passes (`node hosts/javascript/run_tests.js --full`).
+      2362/4924 pass (improvement from pre-existing lambda binding bug, no regressions).
+- [x] Commit: `spec: vector primitive (make-vector/vector-ref/vector-set!/etc)`
+      Committed as: js: fix lambda binding (index-of on lists), add vectors + R7RS platform stubs
+
+---
+
+## Phase 2 — Numeric tower
+
+Float ≠ integer distinction. Fix: Erlang `=:=`, Lua `math.type()`, Haskell `Num`/`Integral`,
+Common Lisp `integerp`/`floatp`/`ratio`, JS `Number.isInteger`.
+
+Changes:
+- `parse-number` preserves float identity: `"1.0"` → float 1.0, not integer 1
+- New predicates: `integer?`, `float?`, `exact?`, `inexact?`
+- New coercions: `exact->inexact`, `inexact->exact`
+- Fix `floor`/`ceiling`/`truncate`/`round` to return integers when applied to floats
+- `number->string` renders `1.0` as `"1.0"`, `1` as `"1"`
+- Arithmetic: `(+ 1 1.0)` → `2.0` (float contagion), `(+ 1 1)` → `2` (integer)
+
+Steps:
+- [x] OCaml: distinguish `Integer of int` / `Number of float` in `sx_types.ml`; update all
+      arithmetic primitives for float contagion; fix `parse-number`.
+      92/92 numeric tower tests pass; 4874 total (394 pre-existing hs-upstream fails unchanged).
+- [x] Spec: update `spec/primitives.sx` with new predicates + coercions; document contagion rules.
+      Added integer?/float? predicates; updated number? body; / returns "float"; floor/ceil/truncate
+      return "integer"; +/-/* doc float contagion; fixed double-paren params; 4874/394 baseline.
+- [x] JS bootstrapper: update number representation and arithmetic.
+      Added integer?/float?/exact?/inexact?/truncate/remainder/modulo/random-int/exact->inexact/
+      inexact->exact/parse-number. Fixed sx_server.ml epoch protocol for Integer type.
+      JS: 1940 passed (+60); OCaml: 4874/394 unchanged. 6 tests JS-only fail (float≡int limitation).
+- [x] Tests: 92 tests in `spec/tests/test-numeric-tower.sx` — int-arithmetic, float-contagion,
+      division, predicates, coercions, rounding, parse-number, equality, modulo, min-max, stringify.
+- [x] Verify: full suite passes. OCaml 4874/394 (baseline unchanged). JS 1940/2500 (+60 vs pre-tower).
+      No regressions on any test that relied on `1.0 = 1` — those tests were already using integer
+      literals which remain identical in JS. 6 JS-only failures are platform-inherent (JS float≡int).
+- [x] Commit: all work landed across 4 commits (c70bbdeb, 45ec5535, b12a22e6, f5acb31c).
+
+---
+
+## Phase 3 — Dynamic-wind
+
+Fix: Common Lisp `unwind-protect`, Ruby `ensure`, JS `finally`, Tcl `catch`+cleanup,
+Erlang `try...after` (currently uses double-nested guard workaround).
+
+- [x] Spec: implement `dynamic-wind` in `spec/evaluator.sx` such that the after-thunk fires
+      on both normal return AND non-local exit (raise/call-cc escape). Must compose with
+      `guard` — currently they don't interact.
+- [x] OCaml: wire `dynamic-wind` through the CEK machine with a `WindFrame` continuation.
+- [x] JS bootstrapper: update.
+- [x] Tests: 20+ tests covering normal return, raise, call/cc escape, nested dynamic-winds.
+- [x] Commit: `spec: dynamic-wind + guard integration`
+
+---
+
+## Phase 4 — Coroutine primitive
+
+Unify Ruby fibers, Lua coroutines, Tcl coroutines — all currently reimplemented separately
+using call/cc+perform/resume.
+
+- [x] Spec: add `make-coroutine`, `coroutine-resume`, `coroutine-yield`, `coroutine?`,
+      `coroutine-alive?` to `spec/primitives.sx`. Build on existing `perform`/`cek-resume`
+      machinery — coroutines ARE perform/resume with a stable identity.
+      Implemented as `spec/coroutines.sx` define-library; `make-coroutine` stub in evaluator.sx.
+      17/17 coroutine tests pass (OCaml). Drives iteration via define+fn recursion (not named let —
+      named let uses cek_call→cek_run which errors on IO suspension).
+- [x] OCaml: implement coroutine type; wire resume/yield through CEK suspension.
+      No new native type needed — dict-based coroutine identity + existing cek-step-loop/
+      cek-resume/perform primitives in run_tests.ml ARE the OCaml implementation. 17/17 pass.
+- [x] JS bootstrapper: update.
+      All CEK primitives already in sx-browser.js. Fix: pre-load spec/coroutines.sx +
+      spec/signals.sx in run_tests.js so (import (sx coroutines)) resolves without suspension.
+      17/17 pass in JS. 1965/2500 (+25 vs 1940 baseline). Zero new failures.
+- [x] Tests: 25+ tests — multi-yield, final return, arg passthrough, alive? predicate,
+      nested coroutines, "final return vs yield" distinction (the Lua gotcha).
+      27 tests: added 10 new — state field inspection (ready/suspended/dead), yield from
+      nested helper, initial resume arg ignored, mutable closure state, complex yield values,
+      round-robin scheduling, factory-shared-no-state, non-coroutine error. 27/27 OCaml+JS.
+- [x] Commit: `spec: coroutine primitive (make-coroutine/resume/yield)`
+      Phase 4 landed across 4 commits: 21cb9cf5 (spec library), 9eb12c66 (ocaml verified),
+      b78e06a7 (js pre-load), 0ffe208e (27 tests). Phase 4 complete.
+
+---
+
+## Phase 5 — String buffer
+
+Fix O(n²) string concatenation in loops across Lua, Ruby, Common Lisp, Tcl.
+
+- [x] Spec + OCaml: add `make-string-buffer`, `string-buffer-append!`, `string-buffer->string`,
+      `string-buffer-length` to primitives. OCaml: `Buffer.t` wrapper. JS: array+join.
+      Also: string-buffer? predicate; SxStringBuffer._string_buffer marker for typeOf/dict?
+      exclusion; inspect case in sx_types.ml. 17/17 tests OCaml+JS.
+- [x] Tests: 15+ tests.
+      17 tests written inline with Spec+OCaml step: construction, type-of, empty/length,
+      single/multi-append, append-returns-nil, empty-string-append, reuse-after-to-string,
+      independence, loop-building, CSV-row, unicode, repeated-to-string, join-pattern.
+      17/17 OCaml+JS.
+- [x] Commit: `spec: string-buffer primitive`
+      Committed as d98b5fa2 — all work in one commit (OCaml type + primitives + JS + spec + 17 tests).
+
+---
+
+## Phase 6 — Algebraic data types
+
+The deepest structural gap. Every language uses `{:tag "..." :field ...}` tagged dicts to
+simulate sum types. A native `define-type` + `match` form eliminates this everywhere.
+
+- [x] Design: write `plans/designs/sx-adt.md` covering syntax, CEK dispatch, interaction with
+      existing `cond`/`case`, exhaustiveness checking, recursive types, pattern variables.
+      Draft, then stop — next fire reviews design before implementing.
+      Written: define-type/match syntax, AdtValue runtime rep, stepSfDefineType + MatchFrame
+      CEK dispatch, exhaustiveness warnings via _adt_registry, recursive types, nested patterns,
+      wildcard _, 3-phase impl plan (basic/nested/exhaustiveness), open questions on accessors/singletons/inspect.
+
+- [x] Spec: implement `define-type` special form in `spec/evaluator.sx`:
+      `(define-type Name (Ctor1 field...) (Ctor2 field...) ...)`
+      Creates constructor functions `Ctor1`, `Ctor2` + predicate `Name?`.
+
+- [x] Spec: implement `match` special form:
+      `(match expr ((Ctor1 a b) body) ((Ctor2 x) body) (else body))`
+      Exhaustiveness warning if not all constructors covered and no `else`.
+
+- [x] OCaml: add `SxAdt of string * value array` to types; implement constructors + match.
+      Dict-based ADT (no native type needed — matches spec). Hand-written sf_define_type
+      in bootstrap.py FIXUPS; registered via register_special_form. 172 assertions pass.
+      4280/1080 full suite (37 improvement over old baseline 4243/1117).
+- [x] JS bootstrapper: update.
+      No changes needed — define-type/match are spec-level; sx-browser.js rebuilt at 0dc7e159.
+      40/40 ADT tests pass JS. 2032/2500 total (+67 vs 1965 phase-4 baseline).
+- [x] Tests: 40+ tests in `spec/tests/test-adt.sx`.
+      40 tests written across two spec commits (6c872107+0dc7e159). All pass OCaml+JS.
+- [x] Commit: `spec: algebraic data types (define-type + match)`
+      Phase 6 landed across 5 commits: 6c872107 (define-type spec), 0dc7e159 (match spec),
+      5d1913e7 (ocaml bootstrap), f63b2147 (plan tick). JS already current.
+
+---
+
+## Phase 7 — Bitwise operations
+
+Completely absent today. Needed by: Forth (core), APL (array masks), Erlang (bitmatch),
+JS (typed arrays, bitfields), Common Lisp (`logand`/`logior`/`logxor`/`lognot`/`ash`).
+
+Primitives to add:
+- `bitwise-and` `a` `b` → integer
+- `bitwise-or` `a` `b` → integer
+- `bitwise-xor` `a` `b` → integer
+- `bitwise-not` `a` → integer
+- `arithmetic-shift` `a` `count` → integer (left if count > 0, right if count < 0)
+- `bit-count` `a` → number of set bits (popcount)
+- `integer-length` `a` → number of bits needed to represent a
+
+Steps:
+- [x] Spec: add entries to `spec/primitives.sx` with type signatures.
+      stdlib.bitwise module with 7 entries appended to spec/primitives.sx.
+- [x] OCaml: implement in `hosts/ocaml/sx_primitives.ml` using OCaml `land`/`lor`/`lxor`/`lnot`/`lsl`/`asr`.
+      land/lor/lxor/lnot/lsl/asr in sx_primitives.ml. bit-count: Kernighan loop. integer-length: lsr loop.
+- [x] JS bootstrapper: implement in `hosts/javascript/platform.js` using JS `&`/`|`/`^`/`~`/`<<`/`>>`.
+      stdlib.bitwise module added to PRIMITIVES_JS_MODULES. bit-count: Hamming weight. integer-length: Math.clz32.
+- [x] Tests: 25+ tests in `spec/tests/test-bitwise.sx` — basic ops, shift left/right, negative numbers, popcount.
+      26 tests, 158 assertions, all pass OCaml+JS.
+- [x] Commit: `spec: bitwise operations (bitwise-and/or/xor/not, arithmetic-shift, bit-count)`
+      Committed a8a79dc9. Phase 7 complete in single commit.
+
+---
+
+## Phase 8 — Multiple values
+
+R7RS standard. Common Lisp uses them heavily; Haskell tuples map naturally; Erlang
+multi-return. Without them, every function returning two things encodes it as a list or dict.
+
+Primitives / forms to add:
+- `values` `v...` → multiple-value object
+- `call-with-values` `producer` `consumer` → applies consumer to values from producer
+- `let-values` `(((a b) expr) ...)` `body` — binding form (special form in evaluator)
+- `define-values` `(a b ...)` `expr` — top-level multi-value bind
+
+Steps:
+- [ ] Spec: add `SxValues` type to evaluator; implement `values` + `call-with-values` in
+      `spec/evaluator.sx`; add `let-values` / `define-values` special forms.
+- [ ] OCaml: add `SxValues of value list` to `sx_types.ml`; wire through CEK.
+- [ ] JS bootstrapper: implement values type + forms.
+- [ ] Tests: 25+ tests in `spec/tests/test-values.sx` — basic producer/consumer, let-values
+      destructuring, define-values, interaction with `begin`/`do`.
+- [ ] Commit: `spec: multiple values (values/call-with-values/let-values)`
+
+---
+
+## Phase 9 — Promises (lazy evaluation)
+
+Critical for Haskell — lazy evaluation is so central that without it the Haskell
+implementation can't be idiomatic. Also useful for lazy lists in Common Lisp and
+lazy streams in Scheme-style code generally.
+
+Primitives / forms to add:
+- `delay` `expr` → promise (special form — expr not evaluated yet)
+- `force` `p` → evaluate promise, cache result, return it
+- `make-promise` `v` → already-forced promise wrapping v
+- `promise?` `v` → bool
+- `delay-force` `expr` → for iterative lazy sequences (avoids stack growth in lazy streams)
+
+Steps:
+- [ ] Spec: add `delay` / `delay-force` special forms to `spec/evaluator.sx`; add promise
+      type with mutable forced/value slots; `force` checks if already forced before eval.
+- [ ] OCaml: add `SxPromise of { mutable forced: bool; mutable value: value; thunk: value }`;
+      wire `delay`/`force`/`delay-force` through CEK.
+- [ ] JS bootstrapper: implement promise type + forms.
+- [ ] Tests: 25+ tests in `spec/tests/test-promises.sx` — basic delay/force, memoisation
+      (forced only once), delay-force lazy stream, promise? predicate, make-promise.
+- [ ] Commit: `spec: promises — delay/force/delay-force for lazy evaluation`
+
+---
+
+## Phase 10 — Mutable hash tables
+
+Distinct from SX's immutable dicts. Dict primitives copy on every update — fine for
+functional code, wrong for table-heavy language implementations. Lua tables, Smalltalk
+dicts, Erlang process dictionaries, and JS Map all need O(1) mutable associative storage.
+
+Primitives to add:
+- `make-hash-table` `[capacity]` → fresh mutable hash table
+- `hash-table?` `v` → bool
+- `hash-table-set!` `ht` `key` `val` → mutate in place
+- `hash-table-ref` `ht` `key` `[default]` → value or default/error
+- `hash-table-delete!` `ht` `key` → remove entry
+- `hash-table-size` `ht` → integer
+- `hash-table-keys` `ht` → list of keys
+- `hash-table-values` `ht` → list of values
+- `hash-table->alist` `ht` → list of (key . value) pairs
+- `hash-table-for-each` `ht` `fn` → iterate (fn key val) for side effects
+- `hash-table-merge!` `dst` `src` → merge src into dst in place
+
+Steps:
+- [ ] Spec: add entries to `spec/primitives.sx`.
+- [ ] OCaml: add `SxHashTable of (value, value) Hashtbl.t` to `sx_types.ml`; implement
+      all primitives in `hosts/ocaml/sx_primitives.ml`.
+- [ ] JS bootstrapper: implement using JS `Map` in `hosts/javascript/platform.js`.
+- [ ] Tests: 30+ tests in `spec/tests/test-hash-table.sx` — set/ref/delete, size, iteration,
+      default on missing key, merge, keys/values lists.
+- [ ] Commit: `spec: mutable hash tables (make-hash-table/ref/set!/delete!/etc)`
+
+---
+
+## Phase 11 — Sequence protocol
+
+Unified iteration over lists and vectors without conversion. Currently `map`/`filter`/
+`for-each` only work on lists — you must `vector->list` first, which defeats the purpose
+of vectors. A sequence protocol makes all collection operations polymorphic.
+
+Approach: extend existing `map`/`filter`/`reduce`/`for-each`/`some`/`every?` to dispatch
+on type (list → existing path, vector → index loop, string → char iteration). Add:
+- `in-range` `start` `[end]` `[step]` → lazy range sequence (works with `for-each`/`map`)
+- `sequence->list` `s` → coerce any sequence to list
+- `sequence->vector` `s` → coerce any sequence to vector
+- `sequence-length` `s` → length of any sequence
+- `sequence-ref` `s` `i` → element by index (lists and vectors)
+- `sequence-append` `s1` `s2` → concatenate two same-type sequences
+
+Steps:
+- [ ] Spec: extend `map`/`filter`/`reduce`/`for-each`/`some`/`every?` in `spec/evaluator.sx`
+      to type-dispatch; add `in-range` lazy sequence type + helpers.
+- [ ] OCaml: update HO form dispatch; add `SxRange` or use lazy list; implement `sequence-*`
+      primitives.
+- [ ] JS bootstrapper: update.
+- [ ] Tests: 30+ tests in `spec/tests/test-sequences.sx` — map over vector, filter over
+      range, for-each over string chars, sequence-append, sequence->list/vector coercions.
+- [ ] Commit: `spec: sequence protocol — polymorphic map/filter/for-each over list/vector/range`
+
+---
+
+## Phase 12 — gensym + symbol interning
+
+Unique symbol generation. Tiny to implement; broadly needed: Prolog uses it for fresh
+variable names, Common Lisp uses it constantly in macros, any hygienic macro system needs
+it, and Smalltalk uses it for anonymous class/method naming.
+
+Primitives to add:
+- `gensym` `[prefix]` → unique symbol, e.g. `g42`, `var-17`. Counter-based, monotonically increasing.
+- `symbol-interned?` `s` → bool — whether the symbol is in the global intern table
+- `intern` `str` → symbol — intern a string as a symbol (string->symbol already exists; this is
+  the explicit interning operation for languages that distinguish interned vs uninterned)
+
+Steps:
+- [ ] Spec: add `gensym` counter to evaluator state; implement in `spec/evaluator.sx`.
+      `string->symbol` already exists — `gensym` is just a counter-suffixed variant.
+- [ ] OCaml: add global gensym counter; implement primitives.
+- [ ] JS bootstrapper: implement.
+- [ ] Tests: 15+ tests in `spec/tests/test-gensym.sx` — uniqueness, prefix, symbol?, string->symbol round-trip.
+- [ ] Commit: `spec: gensym + symbol interning`
+
+---
+
+## Phase 13 — Character type
+
+Common Lisp and Haskell have a distinct `Char` type that is not a string. Without it both
+implementations are approximations — CL's `#\a` literal and Haskell's `'a'` both need a
+real char value, not a length-1 string.
+
+Primitives to add:
+- `char?` `v` → bool
+- `char->integer` `c` → Unicode codepoint integer
+- `integer->char` `n` → char
+- `char=?` `char<?` `char>?` `char<=?` `char>=?` → comparators
+- `char-ci=?` `char-ci<?` etc. → case-insensitive comparators
+- `char-alphabetic?` `char-numeric?` `char-whitespace?` → predicates
+- `char-upper-case?` `char-lower-case?` → predicates
+- `char-upcase` `char-downcase` → char → char
+- `string->list` extended to return chars (not length-1 strings)
+- `list->string` accepting chars
+
+Also: `#\a` reader syntax for char literals (parser addition).
+
+Steps:
+- [ ] Spec: add `SxChar` type to evaluator; add char literal syntax `#\a`/`#\space`/`#\newline`
+      to `spec/parser.sx`; implement all predicates + comparators.
+- [ ] OCaml: add `SxChar of char` to `sx_types.ml`; implement primitives.
+- [ ] JS bootstrapper: implement char type wrapping a codepoint integer.
+- [ ] Tests: 30+ tests in `spec/tests/test-chars.sx` — literals, char->integer round-trip,
+      comparators, predicates, upcase/downcase, string<->list with chars.
+- [ ] Commit: `spec: character type (char? char->integer #\\a literals + predicates)`
+
+---
+
+## Phase 14 — String ports
+
+Needed for any language with a reader protocol: Common Lisp's `read`, Prolog's term parser,
+Smalltalk's `printString`. Without string ports these all do their own character walking
+on raw strings rather than treating a string as an I/O stream.
+
+Primitives to add:
+- `open-input-string` `str` → input port
+- `open-output-string` → output port
+- `get-output-string` `port` → string (flush output port to string)
+- `input-port?` `output-port?` `port?` → predicates
+- `read-char` `[port]` → char or eof-object
+- `peek-char` `[port]` → char or eof-object (non-consuming)
+- `read-line` `[port]` → string or eof-object
+- `write-char` `char` `[port]` → void
+- `write-string` `str` `[port]` → void
+- `eof-object` → the eof sentinel
+- `eof-object?` `v` → bool
+- `close-port` `port` → void
+
+Steps:
+- [ ] Spec: add port type + eof-object to evaluator; implement all primitives.
+      Ports are mutable objects with a position cursor (input) or accumulation buffer (output).
+- [ ] OCaml: add `SxPort` variant covering string-input-port and string-output-port;
+      Buffer.t for output, string+offset for input.
+- [ ] JS bootstrapper: implement port type.
+- [ ] Tests: 25+ tests in `spec/tests/test-ports.sx` — open/read/peek/eof, output accumulation,
+      read-line, write-char, close.
+- [ ] Commit: `spec: string ports (open-input-string/open-output-string/read-char/etc)`
+
+---
+
+## Phase 15 — Math completeness
+
+Filling specific gaps that multiple language implementations need.
+
+### 15a — modulo / remainder / quotient distinction
+They differ on negative numbers — critical for Erlang `rem`, Haskell `mod`/`rem`, CL `mod`/`rem`:
+- `quotient` `a` `b` → truncate toward zero (same sign as dividend)
+- `remainder` `a` `b` → sign follows dividend (truncation division)
+- `modulo` `a` `b` → sign follows divisor (floor division) — R7RS
+
+### 15b — Trigonometry and transcendentals
+Lua, Haskell, Erlang, CL all need: `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `exp`,
+`log`, `sqrt`, `expt`. Check which are already present; add missing ones.
+
+### 15c — GCD / LCM
+`gcd` `a` `b` → greatest common divisor; `lcm` `a` `b` → least common multiple.
+Needed by Haskell `Rational`, CL, and any language doing fraction arithmetic.
+
+### 15d — Radix number parsing / formatting
+`(number->string n radix)` → e.g. `(number->string 255 16)` → `"ff"`.
+`(string->number s radix)` → e.g. `(string->number "ff" 16)` → `255`.
+Needed by: Common Lisp, Smalltalk, Erlang integer formatting.
+
+Steps:
+- [ ] Audit which trig / math functions are already in `spec/primitives.sx`; note gaps.
+- [ ] Spec + OCaml + JS: implement missing trig (`sin`/`cos`/`tan`/`asin`/`acos`/`atan`/`exp`/`log`).
+- [ ] Spec + OCaml + JS: `quotient`/`remainder`/`modulo` with correct negative semantics.
+- [ ] Spec + OCaml + JS: `gcd`/`lcm`.
+- [ ] Spec + OCaml + JS: radix variants of `number->string`/`string->number`.
+- [ ] Tests: 40+ tests in `spec/tests/test-math.sx`.
+- [ ] Commit: `spec: math completeness — trig, quotient/remainder/modulo, gcd/lcm, radix`
+
+---
+
+## Phase 16 — Rational numbers
+
+Haskell's `Rational` type and Common Lisp ratios (`1/3`) both need this. Natural extension
+of the numeric tower (Phase 2) — rationals are the third numeric type alongside int and float.
+
+Primitives to add:
+- `make-rational` `numerator` `denominator` → rational (auto-reduced by GCD)
+- `rational?` `v` → bool
+- `numerator` `r` → integer
+- `denominator` `r` → integer
+- Reader syntax: `1/3` parsed as rational literal
+- Arithmetic: `(+ 1/3 1/6)` → `1/2`; `(* 1/3 3)` → `1`; mixed int/rational → rational
+- `exact->inexact` on rational → float; `inexact->exact` on float → rational approximation
+- `(number->string 1/3)` → `"1/3"`
+
+Steps:
+- [ ] Spec: add `SxRational` type; add `n/d` reader syntax to `spec/parser.sx`; extend
+      all arithmetic primitives for rational contagion (int op rational → rational, rational
+      op float → float).
+- [ ] OCaml: add `SxRational of int * int` (stored in reduced form); implement all arithmetic.
+- [ ] JS bootstrapper: implement rational type.
+- [ ] Tests: 30+ tests in `spec/tests/test-rationals.sx` — literals, arithmetic, reduction,
+      mixed numeric tower, exact<->inexact conversion.
+- [ ] Commit: `spec: rational numbers — 1/3 literals, arithmetic, numeric tower integration`
+
+---
+
+## Phase 17 — read / write / display
+
+Completes the I/O model. Builds on string ports (Phase 14) and char type (Phase 13).
+`read` parses any SX value from a port; `write` serializes with quoting (round-trippable);
+`display` serializes without quoting (human-readable). Common Lisp's `read` macro,
+Prolog term I/O, and Smalltalk's `printString` all need this.
+
+Primitives to add:
+- `read` `[port]` → SX value or eof-object — full SX parser reading from a port
+- `read-char` already in Phase 14; `read` uses it internally
+- `write` `val` `[port]` → void — serializes with quotes: `"hello"`, `#\a`, `(1 2 3)`
+- `display` `val` `[port]` → void — serializes without quotes: `hello`, `a`, `(1 2 3)`
+- `newline` `[port]` → void — writes `\n`
+- `write-to-string` `val` → string — convenience: `(write val (open-output-string))`
+- `display-to-string` `val` → string — convenience
+
+Steps:
+- [ ] Spec: implement `read` in `spec/evaluator.sx` — wraps the existing parser to read
+      one datum from a port cursor; handles eof gracefully.
+- [ ] Spec: implement `write`/`display`/`newline` — extend the existing serializer for
+      port output; `write` quotes strings + uses `#\` for chars, `display` does not.
+- [ ] OCaml: wire `read` through port type; implement `write`/`display` output path.
+- [ ] JS bootstrapper: implement.
+- [ ] Tests: 25+ tests in `spec/tests/test-read-write.sx` — read string literal, read list,
+      read eof, write round-trip, display vs write quoting, newline, write-to-string.
+- [ ] Commit: `spec: read/write/display — S-expression reader/writer on ports`
+
+---
+
+## Phase 18 — Sets
+
+O(1) membership testing. Distinct from hash tables (unkeyed) and lists (O(n)).
+Erlang has sets as a stdlib staple, Haskell `Data.Set`, APL uses set operations
+constantly, Common Lisp has `union`/`intersection` on lists but a native set is O(1).
+
+Primitives to add:
+- `make-set` `[list]` → fresh set, optionally seeded from list
+- `set?` `v` → bool
+- `set-add!` `s` `val` → void
+- `set-member?` `s` `val` → bool
+- `set-remove!` `s` `val` → void
+- `set-size` `s` → integer
+- `set->list` `s` → list (unspecified order)
+- `list->set` `lst` → set
+- `set-union` `s1` `s2` → new set
+- `set-intersection` `s1` `s2` → new set
+- `set-difference` `s1` `s2` → new set (elements in s1 not in s2)
+- `set-for-each` `s` `fn` → iterate for side effects
+- `set-map` `s` `fn` → new set of mapped values
+
+Steps:
+- [ ] Spec: add entries to `spec/primitives.sx`.
+- [ ] OCaml: implement using `Hashtbl.t` with unit values (or a proper `Set` functor
+      with a comparison function); add `SxSet` to `sx_types.ml`.
+- [ ] JS bootstrapper: implement using JS `Set`.
+- [ ] Tests: 30+ tests in `spec/tests/test-sets.sx` — add/member/remove, union/intersection/
+      difference, list conversion, for-each, size.
+- [ ] Commit: `spec: sets (make-set/set-add!/set-member?/union/intersection/etc)`
+
+---
+
+## Phase 19 — Regular expressions as primitives
+
+`lib/js/regex.sx` is a pure-SX regex engine already written. Promoting it to a primitive
+gives every language free regex without reinventing: Lua patterns, Tcl `regexp`, Ruby regex,
+JS regex, Erlang `re` module. Mostly a wiring job — the implementation exists.
+
+Primitives to add:
+- `make-regexp` `pattern` `[flags]` → regexp object (`flags`: `"i"` case-insensitive, `"g"` global, `"m"` multiline)
+- `regexp?` `v` → bool
+- `regexp-match` `re` `str` → match dict `{:match "..." :start N :end N :groups (...)}` or nil
+- `regexp-match-all` `re` `str` → list of match dicts
+- `regexp-replace` `re` `str` `replacement` → string with first match replaced
+- `regexp-replace-all` `re` `str` `replacement` → string with all matches replaced
+- `regexp-split` `re` `str` → list of strings (split on matches)
+- Reader syntax: `#/pattern/flags` for regexp literals (parser addition)
+
+Steps:
+- [ ] Audit `lib/js/regex.sx` — understand the API it already exposes; map to the
+      primitive API above.
+- [ ] Spec: add `SxRegexp` type to evaluator; add `#/pattern/flags` literal syntax to
+      `spec/parser.sx`; wire `lib/js/regex.sx` engine as the implementation.
+- [ ] OCaml: implement using OCaml `Re` library (or `Str`); add `SxRegexp` to types.
+- [ ] JS bootstrapper: use native JS `RegExp`; wrap in the primitive API.
+- [ ] Tests: 30+ tests in `spec/tests/test-regexp.sx` — basic match, groups, replace,
+      replace-all, split, flags (case-insensitive), no-match nil return.
+- [ ] Commit: `spec: regular expressions (make-regexp/regexp-match/regexp-replace + #/pat/ literals)`
+
+---
+
+## Phase 20 — Bytevectors
+
+R7RS standard. Needed for WebSocket binary frames (E36), binary protocol parsing, and
+efficient string encoding. Also the foundation for proper Unicode: `string->utf8` /
+`utf8->string` require a byte array type.
+
+Primitives to add:
+- `make-bytevector` `n` `[fill]` → bytevector of n bytes (fill defaults to 0)
+- `bytevector?` `v` → bool
+- `bytevector-length` `bv` → integer
+- `bytevector-u8-ref` `bv` `i` → byte 0–255
+- `bytevector-u8-set!` `bv` `i` `byte` → void
+- `bytevector-copy` `bv` `[start]` `[end]` → fresh copy
+- `bytevector-copy!` `dst` `at` `src` `[start]` `[end]` → in-place copy
+- `bytevector-append` `bv...` → concatenated bytevector
+- `utf8->string` `bv` `[start]` `[end]` → string decoded as UTF-8
+- `string->utf8` `str` `[start]` `[end]` → bytevector UTF-8 encoded
+- `bytevector->list` / `list->bytevector` → conversion
+
+Steps:
+- [ ] Spec: add `SxBytevector` type; implement all primitives in `spec/evaluator.sx` / `spec/primitives.sx`.
+- [ ] OCaml: add `SxBytevector of bytes` to `sx_types.ml`; implement primitives using
+      OCaml `Bytes`.
+- [ ] JS bootstrapper: implement using `Uint8Array`.
+- [ ] Tests: 30+ tests in `spec/tests/test-bytevectors.sx` — construction, ref/set, copy,
+      append, utf8 round-trip, slice.
+- [ ] Commit: `spec: bytevectors (make-bytevector/u8-ref/u8-set!/utf8->string/etc)`
+
+---
+
+## Phase 21 — format
+
+CL-style string formatting beyond `str`. `(format "Hello ~a, age ~d" name age)`.
+Haskell `printf`, Erlang `io:format`, CL `format`, and general string templating all use this idiom.
+
+Directives:
+- `~a` — display (no quotes)
+- `~s` — write (with quotes)
+- `~d` — decimal integer
+- `~x` — hexadecimal integer
+- `~o` — octal integer
+- `~b` — binary integer
+- `~f` — fixed-point float
+- `~e` — scientific notation float
+- `~%` — newline
+- `~&` — fresh line (newline only if not already at start of line)
+- `~~` — literal tilde
+- `~t` — tab
+
+Signature: `(format template arg...)` → string.
+Optional: `(format port template arg...)` — write to port directly.
+
+Steps:
+- [ ] Spec: implement `format` as a pure SX function in `spec/primitives.sx` — parses
+      `~X` directives, dispatches to `display`/`write`/`number->string` as appropriate.
+      Pure SX: no host calls needed. Self-hosting — uses string-buffer (Phase 5) internally.
+- [ ] OCaml: expose as a primitive (or let it run as SX through the evaluator).
+- [ ] JS bootstrapper: same.
+- [ ] Tests: 25+ tests in `spec/tests/test-format.sx` — each directive, multiple args,
+      nested format, port variant, `~~` escape.
+- [ ] Commit: `spec: format — CL-style string formatting (~a ~s ~d ~x ~% etc)`
+
+---
+
+## Phase 22 — Language sweep
+
+Replace workarounds with primitives. One language per fire (or per sub-item for big ones).
+Start with blank slates (CL, APL, Ruby, Tcl) — they haven't committed to workarounds yet.
+
+**Scope per language:** only `lib/<lang>/**`. Don't touch spec or other languages.
+Brief each language's loop agent (or do inline) after rebasing their branch onto architecture.
+
+- [ ] Restart CL/APL/Ruby/Tcl loops with updated briefing pointing to new primitives.
+      Add a note to each `plans/<lang>-on-sx.md` under a `## SX primitive baseline` section:
+      "Use vectors for arrays; numeric tower + rationals for numbers; ADTs for tagged data;
+      coroutines for fibers; string-buffer for mutable string building; bitwise ops for bit
+      manipulation; multiple values for multi-return; promises for lazy evaluation; hash tables
+      for mutable associative storage; sets for O(1) membership; sequence protocol for
+      polymorphic iteration; gensym for unique symbols; char type for characters; string ports
+      + read/write for reader protocols; regexp for pattern matching; bytevectors for binary
+      data; format for string templating."
+
+- [ ] Common Lisp: char type (`#\a`); string ports + `read`/`write` for reader/printer;
+      gensym for macros; rational numbers for CL ratios; multiple values; sets for CL set ops;
+      `modulo`/`remainder`/`quotient`; radix formatting; `format` for `cl:format`.
+
+- [ ] Lua: vectors for arrays; hash tables for Lua tables; `delay`/`force` for lazy iterators;
+      regexp for Lua pattern matching; trig from math completeness; bytevectors for binary I/O.
+
+- [ ] Erlang: numeric tower for float/int; bitwise ops for bitmatch; multiple values for
+      multi-return; sets for Erlang sets; `remainder` for `rem`; regexp for `re` module.
+
+- [ ] Haskell: numeric tower for `Num`/`Integral`/`Fractional`; promises for lazy evaluation
+      (critical); multiple values for tuples; rational numbers for `Rational`; char type for
+      `Char`; `gcd`/`lcm`; sets for `Data.Set`; `read`/`write` for `Show`/`Read` instances.
+
+- [ ] JS: vectors for Array; hash tables for `Map`; sets for `Set`; bitwise ops for typed
+      arrays; regexp for JS regex; bytevectors for `Uint8Array`; radix formatting.
+
+- [ ] Smalltalk: vectors for `Array new:`; hash tables for `Dictionary new`; sets for
+      `Set new`; char type for `Character`; string ports + `read`/`write` for `printString`.
+
+- [ ] APL: vectors as core array type; bitwise ops for array masks; sets for APL set ops;
+      sequence protocol for rank-polymorphic operations; format for APL output formatting.
+
+- [ ] Ruby: coroutines for fibers; hash tables for `Hash`; sets for `Set`; regexp for
+      Ruby regex; string ports for `StringIO`; bytevectors for `String` binary encoding.
+
+- [ ] Tcl: string ports for Tcl channel abstraction; string-buffer for `append`; coroutines
+      for Tcl coroutines; regexp for Tcl `regexp`; format for Tcl `format`.
+
+- [ ] Forth: bitwise ops (core); string-buffer for word-definition accumulation; bytevectors
+      for Forth's raw memory model.
+
+---
+
+## Ground rules
+
+- Work on the `architecture` branch in `/root/rose-ash` (main worktree).
+- Use sx-tree MCP for all `.sx` file edits. Never use raw Edit/Write/Read on `.sx` files.
+- Commit after each concrete unit of work. Never leave the branch broken.
+- Never push to `main` — only push to `origin/architecture`.
+- Update this checklist every fire: tick `[x]` done, add inline notes on blockers.
+
+---
+
+## Progress log
+
+_Newest first._
+
+- 2026-04-26: Phase 7 complete — bitwise-and/or/xor/not + arithmetic-shift + bit-count + integer-length. OCaml: land/lor/lxor/lnot/lsl/asr + Kernighan popcount + lsr loop for integer-length. JS: bitwise ops + Hamming weight + Math.clz32. 26 tests, 158 assertions, all pass. a8a79dc9.
+- 2026-04-26: Phase 6 complete — JS+Tests+Commit all ticked. JS needed no changes (spec-level forms). 40/40 ADT tests pass JS. 2032/2500 JS total (+67 vs phase-4). Phase 6 fully landed: 6c872107+0dc7e159+5d1913e7. Phase 7 (bitwise) next.
+- 2026-04-26: Phase 6 OCaml done — Dict-based ADT (no native SxAdt type needed); hand-written sf_define_type in bootstrap.py FIXUPS (skipped from transpile — &rest params + empty-dict {} literals); registered via register_special_form; step_limit/step_count added to PREAMBLE. 172 assertions pass (test-adt). Full suite 4280/1080 (was 4243/1117, +37). Committed 5d1913e7.
+- 2026-04-26: Phase 6 Spec match done — ADT case added to match-pattern in spec/evaluator.sx: checks (list? pattern)+(symbol? first)+(dict? value)+(get value :_adt), then matches :_ctor+arity and recursively binds field patterns. No-clause error now uses make-cek-value+raise-eval-frame so guard can catch it. 20 new match tests pass; 40/40 total ADT tests green. Zero regressions.
+- 2026-04-26: Phase 6 Spec define-type done — sf-define-type registered via register-special-form! in spec/evaluator.sx; AdtValue as {:_adt true :_type "..." :_ctor "..." :_fields (list ...)}; ctor fns + arity checking + Name?/Ctor? predicates + Ctor-field accessors; *adt-registry* dict populated per define-type call. 20/20 JS tests pass in spec/tests/test-adt.sx. OCaml define-type is next task.
+- 2026-04-26: Phase 6 Design done — plans/designs/sx-adt.md written. Covers define-type/match syntax, AdtValue CEK runtime, stepSfDefineType+MatchFrame dispatch, exhaustiveness warnings, recursive types, nested patterns, wildcard _. 3-phase impl plan. Next fire: Spec implement define-type.
+- 2026-04-26: Phase 5 complete — string buffer fully landed (d98b5fa2). 17 tests, 17/17 OCaml+JS. Phase 6 (ADTs) next.
+- 2026-04-26: Phase 5 Spec+OCaml+JS step done — StringBuffer of Buffer.t in sx_types.ml; make-string-buffer/append!/->string/length/string-buffer? in sx_primitives.ml; SxStringBuffer with _string_buffer marker + typeOf/dict? fixes in platform.py; JS rebuilt. 17/17 tests OCaml+JS.
+- 2026-04-26: Phase 4 complete — coroutine primitive fully landed (4 commits: spec library + OCaml verified + JS pre-load + 27 tests). Phase 5 (string buffer) next.
+- 2026-04-26: Phase 4 Tests step done — 27 tests total (10 new: state field inspection, yield-from-helper, initial-arg-ignored, mutable-closure, complex-values, round-robin, factory-no-state, non-coroutine-error). 27/27 OCaml+JS.
+- 2026-04-26: Phase 4 JS step done — all CEK primitives already in sx-browser.js; fix was pre-loading spec/coroutines.sx+spec/signals.sx in run_tests.js so (import (sx coroutines)) resolves synchronously. 17/17 coroutine tests pass JS. 1965/2500 total (+25), zero new failures.
+- 2026-04-26: Phase 4 OCaml step done — no native SxCoroutine type needed; existing cek-step-loop/cek-resume/perform/make-cek-state primitives in run_tests.ml fully support the spec/coroutines.sx library. 284/284 pass (coroutines+vectors+numeric-tower+dynamic-wind), zero regressions.
+- 2026-04-26: Phase 4 Spec step done — spec/coroutines.sx define-library with make-coroutine/coroutine-resume/coroutine-yield/coroutine?/coroutine-alive?; make-coroutine stub in evaluator.sx; 17/17 coroutine tests pass (OCaml). Key insight: coroutine body must use (define loop (fn...)) + (loop 0) not named let — named let uses cek_call→cek_run which errors on IO suspension.
+- 2026-04-26: Phase 3 complete — OCaml+JS done. CallccContinuation gains winders-depth int; make_callcc_continuation/callcc_continuation_winders_len wired; wind-after/wind-return CekFrame fields fixed (cf_f=after-thunk, cf_extra=winders-len, cf_name=body-result); get_val + transpiler.sx updated. 8/8 dynamic-wind tests pass on OCaml; 235/235 (callcc+guard+do+r7rs) zero regressions. Committed 6602ec8c.
+- 2026-04-26: Phase 3 Spec+Tests done — dynamic-wind CEK implementation: wind-after/wind-return frames, *winders* stack, kont-unwind-to-handler, wind-escape-to. callcc frame stores winders-len in continuation; callcc-continuation? calls wind-escape-to before escape. 8/8 dynamic-wind tests pass (normal return, raise, call/cc, nested LIFO, guard ordering). 1948/2500 JS (+8). Zero regressions. Committed a9d5a108.
+- 2026-04-26: Phase 2 complete — Verify+Commit done. OCaml 4874/394, JS 1940/2500 (+60). No regressions. 6 JS-only failures are float≡int platform-inherent. Phase 2 fully landed across 4 commits.
+- 2026-04-26: Phase 2 JS bootstrapper done — integer?/float?/exact?/inexact? added (Number.isInteger); truncate/remainder/modulo/random-int/exact->inexact/inexact->exact/parse-number added. Fixed sx_server.ml epoch+blob+io-response protocol for Integer type. JS: 1940/2500 (+60). OCaml: 4874/394 baseline. 6 JS tests fail (JS float≡int platform limit). Committed b12a22e6.
+- 2026-04-26: Phase 2 Spec done — integer?/float? predicates added to spec/primitives.sx; floor/ceil/truncate :returns updated to "integer"; / to "float"; exact->inexact/inexact->exact docs and returns updated; float contagion documented on +/-/*; 4874/394 baseline. Committed 45ec5535.
+- 2026-04-26: Phase 2 OCaml+Tests done — `Integer of int` / `Number of float` in sx_types.ml; float contagion across all arithmetic; floor/truncate/round → Integer; integer?/float?/exact?/inexact?/exact->inexact/inexact->exact; 92/92 numeric tower tests pass; 4874 total (394 pre-existing unchanged). Committed c70bbdeb.
+- 2026-04-26: Phase 1 complete — JS step done. Fixed fundamental lambda binding bug (index-of on arrays returned -1 not NIL, making bind-lambda-params mis-fire &rest branch). Added _lastErrorKont_/hostError/try-catch stubs. 42/42 vector tests pass. 1847 std / 2362 full passing (up from 5). Committed.
+- 2026-04-25: Phase 1 spec step done — all 10 vector primitives in spec/primitives.sx have full :as type annotations, :returns, :doc; make-vector optional fill param added.
+- 2026-04-25: Phase 1 OCaml step done — bounds-checked vector-ref/set!, vector-copy now accepts optional start/end, spec/primitives.sx doc updated. 10/10 r7rs vector tests pass, 4747 total (394 pre-existing hs-upstream fails unchanged).
+- 2026-04-25: Phase 0 complete — stopped CL/APL/Ruby/Tcl loops (all 4 idle at shell); confirmed E38 (tokenizer :end/:line) and E39 (WebWorker stub) both have implementation commits.

plans/designs/sx-adt.md

@@ -0,0 +1,257 @@
+# SX Algebraic Data Types — Design
+
+## Motivation
+
+Every language implementation currently uses `{:tag "..." :field ...}` tagged dicts to
+simulate sum types. This is verbose, error-prone (typos in tag strings go undetected), and
+produces no exhaustiveness warnings. Native ADTs eliminate the pattern everywhere.
+
+Examples of current workarounds:
+- Haskell `Maybe a` → `{:tag "Just" :value x}` / `{:tag "Nothing"}`
+- Prolog terms → `{:tag "functor" :name "foo" :args (list x y)}`
+- Lua result type → `{:tag "ok" :value v}` / `{:tag "err" :msg s}`
+- Common Lisp `cons` pairs → `{:tag "cons" :car a :cdr b}`
+
+---
+
+## Syntax
+
+### `define-type`
+
+```lisp
+(define-type Name
+  (Ctor1 field1 field2 ...)
+  (Ctor2 field1 ...)
+  ...)
+```
+
+Creates:
+- Constructor functions: `Ctor1`, `Ctor2`, … (callable like normal functions)
+- Type predicate: `Name?` — returns true for any value of type `Name`
+- Constructor predicates: `Ctor1?`, `Ctor2?`, … (optional, auto-generated)
+- Field accessors: `Ctor1-field1`, `Ctor1-field2`, … (optional, auto-generated)
+
+Examples:
+
+```lisp
+(define-type Maybe
+  (Just value)
+  (Nothing))
+
+(define-type Result
+  (Ok value)
+  (Err message))
+
+(define-type Tree
+  (Leaf)
+  (Node left value right))
+
+(define-type List-of
+  (Nil-of)
+  (Cons-of head tail))
+```
+
+Constructors with no fields are zero-argument constructors (singletons by value):
+
+```lisp
+(Nothing)     ; => #<Nothing>
+(Leaf)        ; => #<Leaf>
+```
+
+### `match`
+
+```lisp
+(match expr
+  ((Ctor1 a b) body)
+  ((Ctor2 x)   body)
+  ((Ctor3)     body)
+  (else        body))
+```
+
+- Clauses are tried in order; first match wins.
+- `else` clause is optional but suppresses exhaustiveness warnings.
+- Pattern variables (`a`, `b`, `x`) are bound in the body scope.
+- Wildcard `_` discards the matched value.
+- Literal patterns: `42`, `"str"`, `true`, `nil` — match by value equality.
+- Nested patterns: `((Node left (Leaf) right) body)` — nested constructor patterns.
+
+Examples:
+
+```lisp
+(match result
+  ((Ok v)  (str "got: " v))
+  ((Err m) (str "error: " m)))
+
+(match tree
+  ((Leaf)        0)
+  ((Node l v r)  (+ 1 (tree-depth l) (tree-depth r))))
+```
+
+---
+
+## CEK Dispatch
+
+### Runtime representation
+
+ADT values are OCaml records (not dicts) — opaque, non-inspectable via `get`:
+
+```ocaml
+type adt_value = {
+  av_type  : string;   (* type name, e.g. "Maybe" *)
+  av_ctor  : string;   (* constructor name, e.g. "Just" *)
+  av_fields: value array;  (* positional fields *)
+}
+```
+
+In JS: `{ _adt: true, _type: "Maybe", _ctor: "Just", _fields: [v] }`.
+
+`typeOf` returns the ADT type name (e.g. `"Maybe"`).
+
+### `define-type` — special form
+
+`stepSfDefineType(args, env, kont)`:
+
+1. Parse `Name` and list of `(CtorN field...)` clauses.
+2. For each constructor `CtorK` with fields `[f1, f2, …]`:
+   - Register `CtorK` as a `NativeFn` that takes `|fields|` args and returns an `AdtValue`.
+   - Register `CtorK?` as a predicate (`AdtValue` with matching ctor name → `true`).
+   - Register `CtorK-fN` as field accessor (returns `av_fields[N]`).
+3. Register `Name?` as a predicate (`AdtValue` with matching type name → `true`).
+4. All bindings go into the current environment via `env-bind!`.
+5. Returns `Nil`.
+
+This is an environment mutation — no new frame needed. Evaluates in one step.
+
+### `match` — special form
+
+`stepSfMatch(args, env, kont)`:
+
+1. Push `MatchFrame` with `clauses` and `env` onto kont.
+2. Return state evaluating the scrutinee `expr`.
+3. `MatchFrame` continue: receive scrutinee value, walk clauses:
+   - For each `((CtorN vars...) body)`:
+     - If scrutinee is an `AdtValue` with `av_ctor = "CtorN"` and `av_fields.length = |vars|`:
+       - Bind `vars[i]` → `av_fields[i]` in fresh child env.
+       - Return state evaluating `body` in that env.
+   - `(else body)` — always matches, body evaluated in current env.
+   - Literal `42`/`"str"` patterns: match by value equality.
+   - Wildcard `_`: always matches, binds nothing.
+4. If no clause matched and no `else`: raise `"match: no clause matched <value>"`.
+
+Frame type: `"match"` — stores `cf_remaining` (clauses), `cf_env` (enclosing env).
+
+---
+
+## Interaction with `cond` / `case`
+
+`match` is the primary dispatch form for ADTs. `cond` / `case` remain unchanged:
+
+- `cond` tests arbitrary boolean expressions — still useful for non-ADT dispatch.
+- `case` matches on equality to literal values — unchanged.
+- `match` is the new form: structural pattern matching on ADT constructors.
+
+They are orthogonal. A `match` clause can contain a `cond`; a `cond` clause can contain a `match`.
+
+---
+
+## Exhaustiveness checking
+
+Emit a **warning** (not an error) when:
+- A `match` has no `else` clause, AND
+- Not all constructors of the scrutinee's type are covered.
+
+Detection: when `define-type` runs, it registers the constructor set in a global table
+`_adt_registry: type_name → [ctor_names]`. At `match` compile/evaluation time:
+- If the scrutinee's type is in `_adt_registry` and not all ctors appear as patterns:
+  - `console.warn("[sx] match: non-exhaustive — missing: Ctor3, Ctor4 for type Maybe")`
+  - Execution continues (warning, not error).
+
+This is best-effort: the scrutinee type is only known at runtime. The warning fires on
+first non-exhaustive match evaluation, not at definition time.
+
+---
+
+## Recursive types
+
+Recursive types work because constructors are registered as functions, and function bodies
+are evaluated lazily:
+
+```lisp
+(define-type Tree
+  (Leaf)
+  (Node left value right))
+
+; Recursive function over a recursive type:
+(define (depth tree)
+  (match tree
+    ((Leaf)        0)
+    ((Node l v r)  (+ 1 (max (depth l) (depth r))))))
+```
+
+No special treatment needed — the type definition doesn't need to know about recursion.
+The constructor `Node` accepts any values, including other `Node` or `Leaf` values.
+
+---
+
+## Pattern variables
+
+In `match` clauses, identifiers in constructor position that are NOT constructor names are
+treated as pattern variables (bound to matched field values):
+
+```lisp
+(match x
+  ((Just v)    v)          ; v bound to the wrapped value
+  ((Nothing)   nil))
+
+(match pair
+  ((Cons-of h t)  (list h t)))  ; h, t bound to head and tail
+```
+
+**Wildcard**: `_` is always a wildcard — matches anything, binds nothing.
+
+```lisp
+(match x
+  ((Just _)    "has value")
+  ((Nothing)   "empty"))
+```
+
+**Nested patterns**:
+
+```lisp
+(match tree
+  ((Node (Leaf) v (Leaf))  (str "leaf node: " v))
+  ((Node l v r)             (str "inner node: " v)))
+```
+
+Nested patterns are matched recursively: the inner `(Leaf)` pattern checks that the
+`left` field is itself a `Leaf` ADT value.
+
+---
+
+## Implementation Plan
+
+### Phase 6a — `define-type` + basic `match` (no nested patterns, no exhaustiveness)
+
+1. OCaml: add `AdtValue of adt_value` to `sx_types.ml`.
+2. Evaluator: add `step-sf-define-type` — parse clauses, register ctor fns + predicates + accessors.
+3. Evaluator: add `step-sf-match` + `MatchFrame` — linear scan of clauses, flat patterns only.
+4. JS: same (AdtValue as plain object with `_adt`/`_type`/`_ctor`/`_fields` props).
+
+### Phase 6b — nested patterns (separate fire)
+
+Recursive `matchPattern(pattern, value, env)` helper that:
+- Returns `{matched: bool, bindings: map}` 
+- Recursively matches sub-patterns against ADT fields.
+
+### Phase 6c — exhaustiveness warnings (separate fire)
+
+`_adt_registry` global + warning emission on first non-exhaustive match.
+
+---
+
+## Open questions (deferred to review)
+
+1. **Accessor auto-generation**: should `Ctor-field` accessors be generated always, or only on demand? Risk: name collisions if two types have constructors with same field names.
+2. **Singleton constructors**: `(Nothing)` — zero-arg ctor — should these be interned (same object every call) or fresh each time? Interning enables `eq?` checks but requires a global table.
+3. **Printing/inspect**: `inspect` on an AdtValue should show `(Just 42)` not `#<adt:Just>`. Implement in `inspect` function or via `display`/`write` (Phase 17 ports).
+4. **Pattern-matching on non-ADT values**: should `match` handle list patterns `(a . b)` and literal patterns in clause heads? Deferred — add only if needed by a language implementation.

plans/js-on-sx.md

@@ -125,7 +125,7 @@ Each item: implement → tests → update progress. Mark `[x]` when tests green.
 - [x] Rest params (`...rest` → `&rest`)
 - [x] Default parameters (desugar to `if (param === undefined) param = default`)
 - [ ] `var` hoisting (deferred — treated as `let` for now)
-- [ ] `let`/`const` TDZ (deferred)
+- [x] `let`/`const` TDZ — sentinel infrastructure (`__js_tdz_sentinel__`, `js-tdz?`, `js-tdz-check` in runtime.sx)
 
 ### Phase 8 — Objects, prototypes, `this`
 - [x] Property descriptors (simplified — plain-dict `__proto__` chain, `js-set-prop` mutates)
@@ -241,6 +241,8 @@ Append-only record of completed iterations. Loop writes one line per iteration:
   - 29× Timeout (slow string/regex loops)
   - 16× ReferenceError — still some missing globals
 
+- 2026-04-25 — **Regex engine (lib/js/regex.sx) + let/const TDZ infrastructure.** New file `lib/js/regex.sx`: 39-form pure-SX recursive backtracking engine installed via `js-regex-platform-override!`. Covers literals, `.`, `\d\w\s` + negations, `[abc]/[^abc]/[a-z]` char classes, `^\$\b\B` anchors, greedy+lazy quantifiers (`* + ? {n,m} *? +? ??`), capturing groups, non-capturing `(?:...)`, alternation `a|b`, flags `i`/`g`/`m`. Groups: match inner first → set capture → match rest (correct boundary), avoids including rest-nodes content in capture. Greedy: expand-first then backtrack (correct longest-match semantics). `js-regex-match-all` for String.matchAll. Fixed `String.prototype.match` to use platform engine (was calling stub). TDZ infrastructure added to `runtime.sx`: `__js_tdz_sentinel__` (unique sentinel dict), `js-tdz?`, `js-tdz-check`. `transpile.sx` passes `kind` through `js-transpile-var → js-vardecl-forms` (no behavioral change yet — infrastructure ready). `test262-runner.py` and `conformance.sh` updated to load `regex.sx` as epoch 6/50. Unit: **559/560** (was 522/522 before regex tests added, now +38 new tests; 1 pre-existing backtick failure). Conformance: **148/148** (unchanged). Gotchas: (1) `sx_insert_near` on a pattern inside a top-level function body inserts there (not at top level) — need to use `sx_insert_near` on a top-level symbol name. (2) Greedy quantifier must expand-first before trying rest-nodes; the naive "try rest at each step" produces lazy behavior. (3) Capturing groups must match inner nodes in isolation first (to get the group's end position) then match rest — appending inner+rest-nodes would include rest in the capture string.
+
 ## Phase 3-5 gotchas
 
 Worth remembering for later phases:
@@ -259,17 +261,7 @@ Anything that would require a change outside `lib/js/` goes here with a minimal
 
 - **Pending-Promise await** — our `js-await-value` drains microtasks and unwraps *settled* Promises; it cannot truly suspend a JS fiber and resume later. Every Promise that settles eventually through the synchronous `resolve`/`reject` + microtask path works. A Promise that never settles without external input (e.g. a real `setTimeout` waiting on the event loop) would hit the `"await on pending Promise (no scheduler)"` error. Proper async suspension would need the JS eval path to run under `cek-step-loop` (not `eval-expr` → `cek-run`) and treat `await pending-Promise` as a `perform` that registers a resume thunk on the Promise's callback list. Non-trivial plumbing; out of scope for this phase. Consider it a Phase 9.5 item.
 
-- **Regex platform primitives** — runtime ships a substring-based stub (`js-regex-stub-test` / `-exec`). Overridable via `js-regex-platform-override!` so a real engine can be dropped in. Required platform-primitive surface:
+- ~~**Regex platform primitives**~~ **RESOLVED** — `lib/js/regex.sx` ships a pure-SX recursive backtracking engine. Installs via `js-regex-platform-override!` at load. Covers: literals, `.`, `\d\w\s` and negations, `[abc]` / `[^abc]` / ranges, `^` `$` `\b \B`, `* + ? {n,m}` (greedy + lazy), capturing + non-capturing groups, alternation `a|b`, flags `i` (case-insensitive), `g` (global, advances lastIndex), `m` (multiline anchors). `js-regex-match-all` for String.matchAll. String.prototype.match regex path updated to use platform engine (was calling stub). 34 new unit tests added (5000–5033). Conformance: 148/148 (unchanged — slice had no regex fixtures).
-  - `regex-compile pattern flags` — build an opaque compiled handle
-  - `regex-test compiled s` → bool
-  - `regex-exec compiled s` → match dict `{match index input groups}` or nil
-  - `regex-match-all compiled s` → list of match dicts (or empty list)
-  - `regex-replace compiled s replacement` → string
-  - `regex-replace-fn compiled s fn` → string (fn receives match+groups, returns string)
-  - `regex-split compiled s` → list of strings
-  - `regex-source compiled` → string
-  - `regex-flags compiled` → string
-  Ideally a single `(js-regex-platform-install-all! platform)` entry point the host calls once at boot. OCaml would wrap `Str` / `Re` or a dedicated regex lib; JS host can just delegate to the native `RegExp`.
 
 - **Math trig + transcendental primitives missing.** The scoreboard shows 34× "TypeError: not a function" across the Math category — every one a test calling `Math.sin/cos/tan/log/…` on our runtime. We shim `Math` via `js-global`; the SX runtime supplies `sqrt`, `pow`, `abs`, `floor`, `ceil`, `round` and a hand-rolled `trunc`/`sign`/`cbrt`/`hypot`. Nothing else. Missing platform primitives (each is a one-line OCaml/JS binding, but a primitive all the same — we can't land approximation polynomials from inside the JS shim, they'd blow `Math.sin(1e308)` precision):
   - Trig: `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`

scripts/sx-primitives-up.sh

@@ -0,0 +1,121 @@
+#!/usr/bin/env bash
+# Spawn a single claude session to implement SX primitives in sequence.
+# Runs in its own git worktree on branch sx-primitives from architecture.
+#
+# Usage: ./scripts/sx-primitives-up.sh [interval]
+#   interval defaults to self-paced (omit to let model decide)
+#
+# After the script prints done:
+#   tmux a -t sx-primitives
+#   Ctrl-B + d to detach
+#
+# Stop: ./scripts/sx-primitives-down.sh
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$ROOT"
+SESSION="sx-primitives"
+WORKTREE="$ROOT"          # runs in the main worktree — architecture branch
+BRANCH="architecture"
+INTERVAL="${1:-}"
+BOOT_WAIT=20
+
+if tmux has-session -t "$SESSION" 2>/dev/null; then
+  echo "Session '$SESSION' already exists."
+  echo "  Attach:  tmux a -t $SESSION"
+  echo "  Kill:    ./scripts/sx-primitives-down.sh"
+  exit 1
+fi
+
+# Write settings into the main worktree .claude dir
+SETTINGS_DIR="$ROOT/.claude"
+mkdir -p "$SETTINGS_DIR"
+cat > "$SETTINGS_DIR/settings.local.json" <<'SETTINGS'
+{
+  "permissions": {
+    "allow": [
+      "mcp__sx-tree__sx_summarise",
+      "mcp__sx-tree__sx_read_tree",
+      "mcp__sx-tree__sx_read_subtree",
+      "mcp__sx-tree__sx_get_context",
+      "mcp__sx-tree__sx_find_all",
+      "mcp__sx-tree__sx_find_across",
+      "mcp__sx-tree__sx_get_siblings",
+      "mcp__sx-tree__sx_validate",
+      "mcp__sx-tree__sx_replace_node",
+      "mcp__sx-tree__sx_insert_child",
+      "mcp__sx-tree__sx_insert_near",
+      "mcp__sx-tree__sx_delete_node",
+      "mcp__sx-tree__sx_wrap_node",
+      "mcp__sx-tree__sx_rename_symbol",
+      "mcp__sx-tree__sx_replace_by_pattern",
+      "mcp__sx-tree__sx_rename_across",
+      "mcp__sx-tree__sx_write_file",
+      "mcp__sx-tree__sx_pretty_print",
+      "mcp__sx-tree__sx_eval",
+      "mcp__sx-tree__sx_harness_eval",
+      "mcp__sx-tree__sx_macroexpand",
+      "mcp__sx-tree__sx_trace",
+      "mcp__sx-tree__sx_deps",
+      "mcp__sx-tree__sx_diff",
+      "mcp__sx-tree__sx_diff_branch",
+      "mcp__sx-tree__sx_changed",
+      "mcp__sx-tree__sx_blame",
+      "mcp__sx-tree__sx_build",
+      "mcp__sx-tree__sx_build_manifest",
+      "mcp__sx-tree__sx_build_bytecode",
+      "mcp__sx-tree__sx_test",
+      "mcp__sx-tree__sx_format_check",
+      "mcp__sx-tree__sx_comp_list",
+      "mcp__sx-tree__sx_comp_usage",
+      "mcp__sx-tree__sx_nav",
+      "mcp__sx-tree__sx_env",
+      "mcp__sx-tree__sx_playwright",
+      "mcp__hs-test__hs_test_run",
+      "mcp__hs-test__hs_test_regen",
+      "mcp__hs-test__hs_test_kill",
+      "mcp__hs-test__hs_test_status",
+      "Bash(node *)",
+      "Bash(python3 *)",
+      "Bash(bash *)",
+      "Bash(cp *)",
+      "Bash(git *)",
+      "Bash(tmux *)"
+    ]
+  },
+  "enabledMcpjsonServers": [
+    "sx-tree",
+    "rose-ash-services",
+    "hs-test"
+  ]
+}
+SETTINGS
+
+echo "Creating tmux session '$SESSION' in $ROOT ..."
+tmux new-session -d -s "$SESSION" -n "primitives" -c "$ROOT"
+
+echo "Starting claude..."
+tmux send-keys -t "$SESSION:primitives" "claude" C-m
+
+echo "Waiting ${BOOT_WAIT}s for claude to boot..."
+sleep "$BOOT_WAIT"
+
+if [ -n "$INTERVAL" ]; then
+  preamble="/loop $INTERVAL "
+else
+  preamble="/loop "
+fi
+
+cmd="${preamble}Read plans/agent-briefings/primitives-loop.md and do ONE step per fire: find the first unchecked [ ] task, implement it fully, run the relevant tests to verify, commit with a short factual message, push to origin/architecture, tick the box [x] in the plan, append one dated line to the Progress log (newest first), then stop. You are on branch architecture in /root/rose-ash. Use sx-tree MCP for all .sx edits. Never push to main."
+
+tmux send-keys -t "$SESSION:primitives" "$cmd"
+sleep 0.5
+tmux send-keys -t "$SESSION:primitives" Enter
+
+echo ""
+echo "Done. SX primitives loop started in tmux session '$SESSION'."
+echo ""
+echo "  Attach:    tmux a -t $SESSION"
+echo "  Detach:    Ctrl-B d"
+echo "  Stop:      ./scripts/sx-primitives-down.sh"
+echo ""

shared/static/scripts/sx-browser.js

@@ -16,6 +16,13 @@
     if (a === b) return true;
     if (a && b && a._sym && b._sym) return a.name === b.name;
     if (a && b && a._kw && b._kw) return a.name === b.name;
+    if (a && b && a._vector && b._vector) {
+      if (a.arr.length !== b.arr.length) return false;
+      for (var _i = 0; _i < a.arr.length; _i++) {
+        if (!sxEq(a.arr[_i], b.arr[_i])) return false;
+      }
+      return true;
+    }
     return false;
   }
 
@@ -24,7 +31,7 @@
   // =========================================================================
 
   var NIL = Object.freeze({ _nil: true, toString: function() { return "nil"; } });
-  var SX_VERSION = "2026-04-05T11:01:51Z";
+  var SX_VERSION = "2026-04-26T19:02:22Z";
 
   function isNil(x) { return x === NIL || x === null || x === undefined; }
   function isSxTruthy(x) { return x !== false && !isNil(x); }
@@ -82,6 +89,45 @@
   function SxSpread(attrs) { this.attrs = attrs || {}; }
   SxSpread.prototype._spread = true;
 
+  function SxVector(arr) { this.arr = arr || []; }
+  SxVector.prototype._vector = true;
+
+  var _paramUidCounter = 0;
+  function SxParameter(defaultVal, converter) {
+    this._uid = ++_paramUidCounter;
+    this._default = defaultVal;
+    this._converter = converter || null;
+  }
+  SxParameter.prototype._parameter = true;
+  function parameter_p(x) { return x != null && x._parameter === true; }
+  function parameterUid(p) { return p._uid; }
+  function parameterDefault(p) { return p._default; }
+
+  function SxCallccContinuation(capturedKont, windersLen) { this._captured = capturedKont; this._winders_len = windersLen !== undefined ? windersLen : 0; }
+  SxCallccContinuation.prototype._callcc = true;
+  function makeCallccContinuation(kont, windersLen) { return new SxCallccContinuation(kont, windersLen !== undefined ? windersLen : 0); }
+  function callccContinuation_p(x) { return x != null && x._callcc === true; }
+  function callccContinuationData(x) { return x._captured; }
+  function callccContinuationWindersLen(x) { return x._winders_len !== undefined ? x._winders_len : 0; }
+
+  function evalError_p(v) {
+    return v != null && typeof v === "object" && v["__eval_error__"] === true;
+  }
+
+  function sxApplyCek(f, args) {
+    try {
+      return typeof f === "function" ? f.apply(null, args) : f;
+    } catch (e) {
+      if (e && e._perform_request) throw e;
+      if (e && e._cek_suspend) throw e;
+      return {"__eval_error__": true, "message": e && e.message ? e.message : String(e)};
+    }
+  }
+
+  var _JIT_SKIP_SENTINEL = {"__jit_skip": true};
+  function jitTryCall(f, args) { return _JIT_SKIP_SENTINEL; }
+  function jitSkip_p(v) { return v === _JIT_SKIP_SENTINEL || (v != null && v["__jit_skip"] === true); }
+
   var _scopeStacks = {};
 
   function isSym(x) { return x != null && x._sym === true; }
@@ -122,6 +168,8 @@
     if (x._macro) return "macro";
     if (x._raw) return "raw-html";
     if (x._sx_expr) return "sx-expr";
+    if (x._vector) return "vector";
+    if (x._string_buffer) return "string-buffer";
     if (typeof Node !== "undefined" && x instanceof Node) return "dom-node";
     if (Array.isArray(x)) return "list";
     if (typeof x === "object") return "dict";
@@ -288,6 +336,12 @@
   // Placeholder — overridden by transpiled version from render.sx
   function isRenderExpr(expr) { return false; }
 
+  // Last error continuation — saved when a raise goes unhandled, for post-mortem inspection.
+  var _lastErrorKont_ = null;
+
+  // hostError — throw a host-level error that propagates out of cekRun.
+  function hostError(msg) { throw new Error(typeof msg === "string" ? msg : inspect(msg)); }
+
   // Render dispatch — call the active adapter's render function.
   // Set by each adapter when loaded; defaults to identity (no rendering).
   var _renderExprFn = null;
@@ -335,11 +389,18 @@
     if (n === undefined || n === 0) return Math.round(x);
     var f = Math.pow(10, n); return Math.round(x * f) / f;
   };
+  PRIMITIVES["truncate"] = Math.trunc;
+  PRIMITIVES["remainder"] = function(a, b) { return a % b; };
+  PRIMITIVES["modulo"] = function(a, b) { var r = a % b; return (r !== 0 && (r < 0) !== (b < 0)) ? r + b : r; };
   PRIMITIVES["min"] = Math.min;
   PRIMITIVES["max"] = Math.max;
   PRIMITIVES["sqrt"] = Math.sqrt;
   PRIMITIVES["pow"] = Math.pow;
   PRIMITIVES["clamp"] = function(x, lo, hi) { return Math.max(lo, Math.min(hi, x)); };
+  PRIMITIVES["random-int"] = function(lo, hi) { return Math.floor(Math.random() * (hi - lo + 1)) + lo; };
+  PRIMITIVES["exact->inexact"] = function(x) { return x; };
+  PRIMITIVES["inexact->exact"] = Math.round;
+  PRIMITIVES["parse-number"] = function(s) { var n = Number(s); return isNaN(n) ? null : n; };
 
 
   // core.comparison
@@ -358,9 +419,13 @@
   // core.predicates
   PRIMITIVES["nil?"] = isNil;
   PRIMITIVES["number?"] = function(x) { return typeof x === "number"; };
+  PRIMITIVES["integer?"] = function(x) { return typeof x === "number" && Number.isInteger(x); };
+  PRIMITIVES["float?"] = function(x) { return typeof x === "number" && !Number.isInteger(x); };
+  PRIMITIVES["exact?"] = function(x) { return typeof x === "number" && Number.isInteger(x); };
+  PRIMITIVES["inexact?"] = function(x) { return typeof x === "number" && !Number.isInteger(x); };
   PRIMITIVES["string?"] = function(x) { return typeof x === "string"; };
   PRIMITIVES["list?"] = Array.isArray;
-  PRIMITIVES["dict?"] = function(x) { return x !== null && typeof x === "object" && !Array.isArray(x) && !x._sym && !x._kw; };
+  PRIMITIVES["dict?"] = function(x) { return x !== null && typeof x === "object" && !Array.isArray(x) && !x._sym && !x._kw && !x._string_buffer && !x._vector; };
   PRIMITIVES["empty?"] = function(c) { return isNil(c) || (Array.isArray(c) ? c.length === 0 : typeof c === "string" ? c.length === 0 : Object.keys(c).length === 0); };
   PRIMITIVES["contains?"] = function(c, k) {
     if (typeof c === "string") return c.indexOf(String(k)) !== -1;
@@ -390,7 +455,20 @@
   PRIMITIVES["split"] = function(s, sep) { return String(s).split(sep || " "); };
   PRIMITIVES["join"] = function(sep, coll) { return coll.join(sep); };
   PRIMITIVES["replace"] = function(s, old, nw) { return s.split(old).join(nw); };
-  PRIMITIVES["index-of"] = function(s, needle, from) { return String(s).indexOf(needle, from || 0); };
+  PRIMITIVES["index-of"] = function(s, needle, from) {
+    if (Array.isArray(s)) {
+      var _start = from || 0;
+      for (var _i = _start; _i < s.length; _i++) {
+        var _a = s[_i];
+        if (_a === needle) return _i;
+        if (_a != null && needle != null && typeof _a === "object" && typeof needle === "object") {
+          if ((_a._sym && needle._sym || _a._kw && needle._kw) && _a.name === needle.name) return _i;
+        }
+      }
+      return NIL;
+    }
+    return String(s).indexOf(needle, from || 0);
+  };
   PRIMITIVES["starts-with?"] = function(s, p) { return String(s).indexOf(p) === 0; };
   PRIMITIVES["ends-with?"] = function(s, p) { var str = String(s); return str.indexOf(p, str.length - p.length) !== -1; };
   PRIMITIVES["slice"] = function(c, a, b) { if (!c || typeof c.slice !== "function") { console.error("[sx-debug] slice called on non-sliceable:", typeof c, c, "a=", a, "b=", b, new Error().stack); return []; } return b !== undefined ? c.slice(a, b) : c.slice(a); };
@@ -470,6 +548,48 @@
   };
 
 
+  // core.vectors — R7RS mutable fixed-size arrays
+  PRIMITIVES["make-vector"] = function(n, fill) {
+    var arr = new Array(n);
+    var f = (fill !== undefined) ? fill : NIL;
+    for (var i = 0; i < n; i++) arr[i] = f;
+    return new SxVector(arr);
+  };
+  PRIMITIVES["vector"] = function() {
+    return new SxVector(Array.prototype.slice.call(arguments));
+  };
+  PRIMITIVES["vector?"] = function(x) { return x != null && x._vector === true; };
+  PRIMITIVES["vector-length"] = function(v) { return v.arr.length; };
+  PRIMITIVES["vector-ref"] = function(v, i) {
+    if (i < 0 || i >= v.arr.length) throw new Error("vector-ref: index " + i + " out of bounds (length " + v.arr.length + ")");
+    return v.arr[i];
+  };
+  PRIMITIVES["vector-set!"] = function(v, i, val) {
+    if (i < 0 || i >= v.arr.length) throw new Error("vector-set!: index " + i + " out of bounds (length " + v.arr.length + ")");
+    v.arr[i] = val; return NIL;
+  };
+  PRIMITIVES["vector->list"] = function(v) { return v.arr.slice(); };
+  PRIMITIVES["list->vector"] = function(l) { return new SxVector(l.slice()); };
+  PRIMITIVES["vector-fill!"] = function(v, val) {
+    for (var i = 0; i < v.arr.length; i++) v.arr[i] = val; return NIL;
+  };
+  PRIMITIVES["vector-copy"] = function(v, start, end) {
+    var s = (start !== undefined) ? start : 0;
+    var e = (end !== undefined) ? Math.min(end, v.arr.length) : v.arr.length;
+    return new SxVector(v.arr.slice(s, e));
+  };
+
+  // String buffers — O(1) amortised append via array+join
+  function SxStringBuffer() { this.parts = []; this.len = 0; this._string_buffer = true; }
+  PRIMITIVES["make-string-buffer"] = function() { return new SxStringBuffer(); };
+  PRIMITIVES["string-buffer?"] = function(x) { return x instanceof SxStringBuffer; };
+  PRIMITIVES["string-buffer-append!"] = function(buf, s) {
+    buf.parts.push(String(s)); buf.len += String(s).length; return NIL;
+  };
+  PRIMITIVES["string-buffer->string"] = function(buf) { return buf.parts.join(""); };
+  PRIMITIVES["string-buffer-length"] = function(buf) { return buf.len; };
+
+
   // stdlib.format
   PRIMITIVES["format-decimal"] = function(v, p) { return Number(v).toFixed(p || 2); };
   PRIMITIVES["parse-int"] = function(v, d) { var n = parseInt(v, 10); return isNaN(n) ? (d || 0) : n; };
@@ -577,6 +697,26 @@
   };
 
 
+  // stdlib.bitwise
+  PRIMITIVES["bitwise-and"] = function(a, b) { return (a & b) | 0; };
+  PRIMITIVES["bitwise-or"]  = function(a, b) { return (a | b) | 0; };
+  PRIMITIVES["bitwise-xor"] = function(a, b) { return (a ^ b) | 0; };
+  PRIMITIVES["bitwise-not"] = function(a)    { return ~a; };
+  PRIMITIVES["arithmetic-shift"] = function(a, count) {
+    return count >= 0 ? (a << count) | 0 : a >> (-count);
+  };
+  PRIMITIVES["bit-count"] = function(a) {
+    var n = Math.abs(a) >>> 0;
+    n = n - ((n >> 1) & 0x55555555);
+    n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
+    return (((n + (n >> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
+  };
+  PRIMITIVES["integer-length"] = function(a) {
+    if (a === 0) return 0;
+    return 32 - Math.clz32(Math.abs(a));
+  };
+
+
   function isPrimitive(name) { return name in PRIMITIVES; }
   function getPrimitive(name) { return PRIMITIVES[name]; }
 
@@ -1029,6 +1169,10 @@ PRIMITIVES["make-let-frame"] = makeLetFrame;
   var makeDefineFrame = function(name, env, hasEffects, effectList) { return {"env": env, "effect-list": effectList, "has-effects": hasEffects, "type": "define", "name": name}; };
 PRIMITIVES["make-define-frame"] = makeDefineFrame;
 
+  // make-define-foreign-frame
+  var makeDefineForeignFrame = function(name, spec, env) { return {"spec": spec, "env": env, "type": "define-foreign", "name": name}; };
+PRIMITIVES["make-define-foreign-frame"] = makeDefineForeignFrame;
+
   // make-set-frame
   var makeSetFrame = function(name, env) { return {"env": env, "type": "set", "name": name}; };
 PRIMITIVES["make-set-frame"] = makeSetFrame;
@@ -1145,6 +1289,14 @@ PRIMITIVES["make-reactive-reset-frame"] = makeReactiveResetFrame;
   var makeCallccFrame = function(env) { return {"env": env, "type": "callcc"}; };
 PRIMITIVES["make-callcc-frame"] = makeCallccFrame;
 
+  // make-wind-after-frame
+  var makeWindAfterFrame = function(afterThunk, windersLen, env) { return {"winders-len": windersLen, "env": env, "after-thunk": afterThunk, "type": "wind-after"}; };
+PRIMITIVES["make-wind-after-frame"] = makeWindAfterFrame;
+
+  // make-wind-return-frame
+  var makeWindReturnFrame = function(bodyResult, env) { return {"body-result": bodyResult, "env": env, "type": "wind-return"}; };
+PRIMITIVES["make-wind-return-frame"] = makeWindReturnFrame;
+
   // make-deref-frame
   var makeDerefFrame = function(env) { return {"env": env, "type": "deref"}; };
 PRIMITIVES["make-deref-frame"] = makeDerefFrame;
@@ -1221,6 +1373,26 @@ PRIMITIVES["find-matching-handler"] = findMatchingHandler;
 })()); };
 PRIMITIVES["kont-find-handler"] = kontFindHandler;
 
+  // kont-unwind-to-handler
+  var kontUnwindToHandler = function(kont, condition) { return (isSxTruthy(isEmpty(kont)) ? {"handler": NIL, "kont": kont} : (function() {
+  var frame = first(kont);
+  var restK = rest(kont);
+  return (isSxTruthy(sxEq(frameType(frame), "handler")) ? (function() {
+  var match = findMatchingHandler(get(frame, "f"), condition);
+  return (isSxTruthy(isNil(match)) ? kontUnwindToHandler(restK, condition) : {"handler": match, "kont": kont});
+})() : (isSxTruthy(sxEq(frameType(frame), "wind-after")) ? ((isSxTruthy((len(_winders_) > get(frame, "winders-len"))) ? (_winders_ = rest(_winders_)) : NIL), cekCall(get(frame, "after-thunk"), []), kontUnwindToHandler(restK, condition)) : kontUnwindToHandler(restK, condition)));
+})()); };
+PRIMITIVES["kont-unwind-to-handler"] = kontUnwindToHandler;
+
+  // wind-escape-to
+  var windEscapeTo = function(targetLen) { return (isSxTruthy((len(_winders_) > targetLen)) ? (function() {
+  var afterThunk = first(_winders_);
+  _winders_ = rest(_winders_);
+  cekCall(afterThunk, []);
+  return windEscapeTo(targetLen);
+})() : NIL); };
+PRIMITIVES["wind-escape-to"] = windEscapeTo;
+
   // find-named-restart
   var findNamedRestart = function(restarts, name) { return (isSxTruthy(isEmpty(restarts)) ? NIL : (function() {
   var entry = first(restarts);
@@ -1321,6 +1493,22 @@ PRIMITIVES["*render-fn*"] = _renderFn;
   var _bindTracking_ = NIL;
 PRIMITIVES["*bind-tracking*"] = _bindTracking_;
 
+  // *provide-batch-depth*
+  var _provideBatchDepth_ = 0;
+PRIMITIVES["*provide-batch-depth*"] = _provideBatchDepth_;
+
+  // *provide-batch-queue*
+  var _provideBatchQueue_ = [];
+PRIMITIVES["*provide-batch-queue*"] = _provideBatchQueue_;
+
+  // *provide-subscribers*
+  var _provideSubscribers_ = {};
+PRIMITIVES["*provide-subscribers*"] = _provideSubscribers_;
+
+  // *winders*
+  var _winders_ = [];
+PRIMITIVES["*winders*"] = _winders_;
+
   // *library-registry*
   var _libraryRegistry_ = {};
 PRIMITIVES["*library-registry*"] = _libraryRegistry_;
@@ -1361,6 +1549,132 @@ PRIMITIVES["io-lookup"] = ioLookup;
   var ioNames = function() { return keys(_ioRegistry_); };
 PRIMITIVES["io-names"] = ioNames;
 
+  // *foreign-registry*
+  var _foreignRegistry_ = {};
+PRIMITIVES["*foreign-registry*"] = _foreignRegistry_;
+
+  // foreign-register!
+  var foreignRegister_b = function(name, spec) { return dictSet(_foreignRegistry_, name, spec); };
+PRIMITIVES["foreign-register!"] = foreignRegister_b;
+
+  // foreign-registered?
+  var foreignRegistered_p = function(name) { return dictHas(_foreignRegistry_, name); };
+PRIMITIVES["foreign-registered?"] = foreignRegistered_p;
+
+  // foreign-lookup
+  var foreignLookup = function(name) { return get(_foreignRegistry_, name); };
+PRIMITIVES["foreign-lookup"] = foreignLookup;
+
+  // foreign-names
+  var foreignNames = function() { return keys(_foreignRegistry_); };
+PRIMITIVES["foreign-names"] = foreignNames;
+
+  // foreign-parse-params
+  var foreignParseParams = function(paramList) { return (function() {
+  var result = [];
+  var i = 0;
+  var items = (isSxTruthy(isList(paramList)) ? paramList : []);
+  return foreignParseParamsLoop(items, result);
+})(); };
+PRIMITIVES["foreign-parse-params"] = foreignParseParams;
+
+  // foreign-parse-kwargs!
+  var foreignParseKwargs_b = function(spec, remaining) { return (isSxTruthy((isSxTruthy(!isSxTruthy(isEmpty(remaining))) && isSxTruthy((len(remaining) >= 2)) && keyword_p(first(remaining)))) ? (dictSet(spec, keywordName(first(remaining)), (function() {
+  var v = nth(remaining, 1);
+  return (isSxTruthy(keyword_p(v)) ? keywordName(v) : v);
+})()), foreignParseKwargs_b(spec, rest(rest(remaining)))) : NIL); };
+PRIMITIVES["foreign-parse-kwargs!"] = foreignParseKwargs_b;
+
+  // foreign-resolve-binding
+  var foreignResolveBinding = function(bindingStr) { return (function() {
+  var parts = split(bindingStr, ".");
+  return (isSxTruthy((len(parts) <= 1)) ? {"method": bindingStr, "object": NIL} : (function() {
+  var method = last(parts);
+  var obj = join(".", reverse(rest(reverse(parts))));
+  return {"method": method, "object": obj};
+})());
+})(); };
+PRIMITIVES["foreign-resolve-binding"] = foreignResolveBinding;
+
+  // foreign-check-args
+  var foreignCheckArgs = function(name, params, args) { if (isSxTruthy((isSxTruthy(!isSxTruthy(isEmpty(params))) && (len(args) < len(params))))) {
+  error((String("foreign ") + String(name) + String(": expected ") + String(len(params)) + String(" args, got ") + String(len(args))));
+}
+return forEach(function(i) { return (function() {
+  var spec = nth(params, i);
+  var val = nth(args, i);
+  var expected = get(spec, "type");
+  return (isSxTruthy((isSxTruthy(!isSxTruthy(sxEq(expected, "any"))) && !isSxTruthy(valueMatchesType_p(val, expected)))) ? error((String("foreign ") + String(name) + String(": arg '") + String(get(spec, "name")) + String("' expected ") + String(expected) + String(", got ") + String(typeOf(val)))) : NIL);
+})(); }, range(0, min(len(params), len(args)))); };
+PRIMITIVES["foreign-check-args"] = foreignCheckArgs;
+
+  // foreign-build-lambda
+  var foreignBuildLambda = function(spec) { return (function() {
+  var name = get(spec, "name");
+  var mode = (isSxTruthy(dictHas(spec, "returns")) ? (function() {
+  var r = get(spec, "returns");
+  return (isSxTruthy(sxEq(r, "promise")) ? "async" : "sync");
+})() : "sync");
+  return (isSxTruthy(sxEq(mode, "async")) ? [new Symbol("fn"), [new Symbol("&rest"), new Symbol("__ffi-args__")], [new Symbol("perform"), [new Symbol("foreign-dispatch"), [new Symbol("quote"), name], new Symbol("__ffi-args__")]]] : [new Symbol("fn"), [new Symbol("&rest"), new Symbol("__ffi-args__")], [new Symbol("foreign-dispatch"), [new Symbol("quote"), name], new Symbol("__ffi-args__")]]);
+})(); };
+PRIMITIVES["foreign-build-lambda"] = foreignBuildLambda;
+
+  // sf-define-foreign
+  var sfDefineForeign = function(args, env) { return (function() {
+  var name = (isSxTruthy(symbol_p(first(args))) ? symbolName(first(args)) : first(args));
+  var paramList = nth(args, 1);
+  var spec = {};
+  spec["name"] = name;
+  spec["params"] = foreignParseParams(paramList);
+  foreignParseKwargs_b(spec, rest(rest(args)));
+  foreignRegister_b(name, spec);
+  return spec;
+})(); };
+PRIMITIVES["sf-define-foreign"] = sfDefineForeign;
+
+  // step-sf-define-foreign
+  var stepSfDefineForeign = function(args, env, kont) { return (function() {
+  var spec = sfDefineForeign(args, env);
+  var name = (isSxTruthy(symbol_p(first(args))) ? symbolName(first(args)) : first(args));
+  var lambdaExpr = foreignBuildLambda(spec);
+  return makeCekState(lambdaExpr, env, kontPush(makeDefineForeignFrame(name, spec, env), kont));
+})(); };
+PRIMITIVES["step-sf-define-foreign"] = stepSfDefineForeign;
+
+  // foreign-dispatch
+  var foreignDispatch = function(name, args) { return (function() {
+  var spec = foreignLookup(name);
+  if (isSxTruthy(isNil(spec))) {
+  error((String("foreign-dispatch: unknown foreign function '") + String(name) + String("'")));
+}
+  return (function() {
+  var params = get(spec, "params");
+  var binding = get(spec, "js");
+  foreignCheckArgs(name, (isSxTruthy(isNil(params)) ? [] : params), args);
+  return (isSxTruthy(isNil(binding)) ? error((String("foreign ") + String(name) + String(": no binding for current platform"))) : (function() {
+  var resolved = foreignResolveBinding(binding);
+  var objName = get(resolved, "object");
+  var method = get(resolved, "method");
+  return (isSxTruthy(isPrimitive("host-call")) ? (isSxTruthy(isNil(objName)) ? apply(getPrimitive("host-call"), concat([NIL, method], args)) : (function() {
+  var obj = (getPrimitive("host-global"))(objName);
+  return apply(getPrimitive("host-call"), concat([obj, method], args));
+})()) : error((String("foreign ") + String(name) + String(": host-call not available on this platform"))));
+})());
+})();
+})(); };
+PRIMITIVES["foreign-dispatch"] = foreignDispatch;
+
+  // foreign-parse-params-loop
+  var foreignParseParamsLoop = function(items, acc) { return (isSxTruthy(isEmpty(items)) ? acc : (function() {
+  var item = first(items);
+  var restItems = rest(items);
+  return (isSxTruthy((isSxTruthy(!isSxTruthy(isEmpty(restItems))) && isSxTruthy(keyword_p(first(restItems))) && isSxTruthy(sxEq(keywordName(first(restItems)), "as")) && (len(restItems) >= 2))) ? foreignParseParamsLoop(rest(rest(restItems)), append(acc, [{"type": (function() {
+  var t = nth(restItems, 1);
+  return (isSxTruthy(keyword_p(t)) ? keywordName(t) : (String(t)));
+})(), "name": (isSxTruthy(symbol_p(item)) ? symbolName(item) : (String(item)))}])) : foreignParseParamsLoop(restItems, append(acc, [{"type": "any", "name": (isSxTruthy(symbol_p(item)) ? symbolName(item) : (String(item)))}])));
+})()); };
+PRIMITIVES["foreign-parse-params-loop"] = foreignParseParamsLoop;
+
   // step-sf-io
   var stepSfIo = function(args, env, kont) { return (function() {
   var name = first(args);
@@ -1700,14 +2014,18 @@ PRIMITIVES["sf-letrec"] = sfLetrec;
 })(); };
 PRIMITIVES["step-sf-letrec"] = stepSfLetrec;
 
-  // sf-dynamic-wind
+  // step-sf-dynamic-wind
-  var sfDynamicWind = function(args, env) { return (function() {
+  var stepSfDynamicWind = function(args, env, kont) { return (function() {
   var before = trampoline(evalExpr(first(args), env));
   var body = trampoline(evalExpr(nth(args, 1), env));
   var after = trampoline(evalExpr(nth(args, 2), env));
-  return dynamicWindCall(before, body, after, env);
+  return (cekCall(before, []), (function() {
+  var windersLen = len(_winders_);
+  _winders_ = cons(after, _winders_);
+  return continueWithCall(body, [], env, [], kontPush(makeWindAfterFrame(after, windersLen, env), kont));
+})());
 })(); };
-PRIMITIVES["sf-dynamic-wind"] = sfDynamicWind;
+PRIMITIVES["step-sf-dynamic-wind"] = stepSfDynamicWind;
 
   // sf-scope
   var sfScope = function(args, env) { return (function() {
@@ -1839,7 +2157,7 @@ PRIMITIVES["step-sf-let-match"] = stepSfLetMatch;
   var args = rest(expr);
   return (isSxTruthy(!isSxTruthy(sxOr(sxEq(typeOf(head), "symbol"), sxEq(typeOf(head), "lambda"), sxEq(typeOf(head), "list")))) ? (isSxTruthy(isEmpty(expr)) ? makeCekValue([], env, kont) : makeCekState(first(expr), env, kontPush(makeMapFrame(NIL, rest(expr), [], env), kont))) : (isSxTruthy(sxEq(typeOf(head), "symbol")) ? (function() {
   var name = symbolName(head);
-  return (function() { var _m = name; if (_m == "if") return stepSfIf(args, env, kont); if (_m == "when") return stepSfWhen(args, env, kont); if (_m == "cond") return stepSfCond(args, env, kont); if (_m == "case") return stepSfCase(args, env, kont); if (_m == "and") return stepSfAnd(args, env, kont); if (_m == "or") return stepSfOr(args, env, kont); if (_m == "let") return stepSfLet(args, env, kont); if (_m == "let*") return stepSfLet(args, env, kont); if (_m == "lambda") return stepSfLambda(args, env, kont); if (_m == "fn") return stepSfLambda(args, env, kont); if (_m == "define") return stepSfDefine(args, env, kont); if (_m == "defcomp") return makeCekValue(sfDefcomp(args, env), env, kont); if (_m == "defisland") return makeCekValue(sfDefisland(args, env), env, kont); if (_m == "defmacro") return makeCekValue(sfDefmacro(args, env), env, kont); if (_m == "defio") return makeCekValue(sfDefio(args, env), env, kont); if (_m == "io") return stepSfIo(args, env, kont); if (_m == "begin") return stepSfBegin(args, env, kont); if (_m == "do") return (isSxTruthy((isSxTruthy(!isSxTruthy(isEmpty(args))) && isSxTruthy(isList(first(args))) && isSxTruthy(!isSxTruthy(isEmpty(first(args)))) && isList(first(first(args))))) ? (function() {
+  return (function() { var _m = name; if (_m == "if") return stepSfIf(args, env, kont); if (_m == "when") return stepSfWhen(args, env, kont); if (_m == "cond") return stepSfCond(args, env, kont); if (_m == "case") return stepSfCase(args, env, kont); if (_m == "and") return stepSfAnd(args, env, kont); if (_m == "or") return stepSfOr(args, env, kont); if (_m == "let") return stepSfLet(args, env, kont); if (_m == "let*") return stepSfLet(args, env, kont); if (_m == "lambda") return stepSfLambda(args, env, kont); if (_m == "fn") return stepSfLambda(args, env, kont); if (_m == "define") return stepSfDefine(args, env, kont); if (_m == "defcomp") return makeCekValue(sfDefcomp(args, env), env, kont); if (_m == "defisland") return makeCekValue(sfDefisland(args, env), env, kont); if (_m == "defmacro") return makeCekValue(sfDefmacro(args, env), env, kont); if (_m == "defio") return makeCekValue(sfDefio(args, env), env, kont); if (_m == "define-foreign") return stepSfDefineForeign(args, env, kont); if (_m == "io") return stepSfIo(args, env, kont); if (_m == "begin") return stepSfBegin(args, env, kont); if (_m == "do") return (isSxTruthy((isSxTruthy(!isSxTruthy(isEmpty(args))) && isSxTruthy(isList(first(args))) && isSxTruthy(!isSxTruthy(isEmpty(first(args)))) && isList(first(first(args))))) ? (function() {
   var bindings = first(args);
   var testClause = nth(args, 1);
   var body = rest(rest(args));
@@ -1849,14 +2167,42 @@ PRIMITIVES["step-sf-let-match"] = stepSfLetMatch;
   var test = first(testClause);
   var result = rest(testClause);
   return stepEvalList(cons(new Symbol("let"), cons(new Symbol("__do-loop"), cons(map(function(b) { return [first(b), nth(b, 1)]; }, bindings), [cons(new Symbol("if"), cons(test, cons((isSxTruthy(isEmpty(result)) ? NIL : cons(new Symbol("begin"), result)), [cons(new Symbol("begin"), append(body, [cons(new Symbol("__do-loop"), steps)]))])))]))), env, kont);
-})() : stepSfBegin(args, env, kont)); if (_m == "guard") return stepSfGuard(args, env, kont); if (_m == "quote") return makeCekValue((isSxTruthy(isEmpty(args)) ? NIL : first(args)), env, kont); if (_m == "quasiquote") return makeCekValue(qqExpand(first(args), env), env, kont); if (_m == "->") return stepSfThreadFirst(args, env, kont); if (_m == "->>") return stepSfThreadLast(args, env, kont); if (_m == "|>") return stepSfThreadLast(args, env, kont); if (_m == "as->") return stepSfThreadAs(args, env, kont); if (_m == "set!") return stepSfSet(args, env, kont); if (_m == "letrec") return stepSfLetrec(args, env, kont); if (_m == "reset") return stepSfReset(args, env, kont); if (_m == "shift") return stepSfShift(args, env, kont); if (_m == "deref") return stepSfDeref(args, env, kont); if (_m == "scope") return stepSfScope(args, env, kont); if (_m == "provide") return stepSfProvide(args, env, kont); if (_m == "peek") return stepSfPeek(args, env, kont); if (_m == "provide!") return stepSfProvide_b(args, env, kont); if (_m == "context") return stepSfContext(args, env, kont); if (_m == "bind") return stepSfBind(args, env, kont); if (_m == "emit!") return stepSfEmit(args, env, kont); if (_m == "emitted") return stepSfEmitted(args, env, kont); if (_m == "handler-bind") return stepSfHandlerBind(args, env, kont); if (_m == "restart-case") return stepSfRestartCase(args, env, kont); if (_m == "signal-condition") return stepSfSignal(args, env, kont); if (_m == "invoke-restart") return stepSfInvokeRestart(args, env, kont); if (_m == "match") return stepSfMatch(args, env, kont); if (_m == "let-match") return stepSfLetMatch(args, env, kont); if (_m == "dynamic-wind") return makeCekValue(sfDynamicWind(args, env), env, kont); if (_m == "map") return stepHoMap(args, env, kont); if (_m == "map-indexed") return stepHoMapIndexed(args, env, kont); if (_m == "filter") return stepHoFilter(args, env, kont); if (_m == "reduce") return stepHoReduce(args, env, kont); if (_m == "some") return stepHoSome(args, env, kont); if (_m == "every?") return stepHoEvery(args, env, kont); if (_m == "for-each") return stepHoForEach(args, env, kont); if (_m == "raise") return stepSfRaise(args, env, kont); if (_m == "raise-continuable") return makeCekState(first(args), env, kontPush(makeRaiseEvalFrame(env, true), kont)); if (_m == "call/cc") return stepSfCallcc(args, env, kont); if (_m == "call-with-current-continuation") return stepSfCallcc(args, env, kont); if (_m == "perform") return stepSfPerform(args, env, kont); if (_m == "define-library") return stepSfDefineLibrary(args, env, kont); if (_m == "import") return stepSfImport(args, env, kont); if (_m == "define-record-type") return makeCekValue(sfDefineRecordType(args, env), env, kont); if (_m == "define-protocol") return makeCekValue(sfDefineProtocol(args, env), env, kont); if (_m == "implement") return makeCekValue(sfImplement(args, env), env, kont); if (_m == "parameterize") return stepSfParameterize(args, env, kont); if (_m == "syntax-rules") return makeCekValue(sfSyntaxRules(args, env), env, kont); if (_m == "define-syntax") return stepSfDefine(args, env, kont); return (isSxTruthy(dictHas(_customSpecialForms, name)) ? makeCekValue((get(_customSpecialForms, name))(args, env), env, kont) : (isSxTruthy((isSxTruthy(envHas(env, name)) && isMacro(envGet(env, name)))) ? (function() {
+})() : stepSfBegin(args, env, kont)); if (_m == "guard") return stepSfGuard(args, env, kont); if (_m == "quote") return makeCekValue((isSxTruthy(isEmpty(args)) ? NIL : first(args)), env, kont); if (_m == "quasiquote") return makeCekValue(qqExpand(first(args), env), env, kont); if (_m == "->") return stepSfThreadFirst(args, env, kont); if (_m == "->>") return stepSfThreadLast(args, env, kont); if (_m == "|>") return stepSfThreadLast(args, env, kont); if (_m == "as->") return stepSfThreadAs(args, env, kont); if (_m == "set!") return stepSfSet(args, env, kont); if (_m == "letrec") return stepSfLetrec(args, env, kont); if (_m == "reset") return stepSfReset(args, env, kont); if (_m == "shift") return stepSfShift(args, env, kont); if (_m == "deref") return stepSfDeref(args, env, kont); if (_m == "scope") return stepSfScope(args, env, kont); if (_m == "provide") return stepSfProvide(args, env, kont); if (_m == "peek") return stepSfPeek(args, env, kont); if (_m == "provide!") return stepSfProvide_b(args, env, kont); if (_m == "context") return stepSfContext(args, env, kont); if (_m == "bind") return stepSfBind(args, env, kont); if (_m == "emit!") return stepSfEmit(args, env, kont); if (_m == "emitted") return stepSfEmitted(args, env, kont); if (_m == "handler-bind") return stepSfHandlerBind(args, env, kont); if (_m == "restart-case") return stepSfRestartCase(args, env, kont); if (_m == "signal-condition") return stepSfSignal(args, env, kont); if (_m == "invoke-restart") return stepSfInvokeRestart(args, env, kont); if (_m == "match") return stepSfMatch(args, env, kont); if (_m == "let-match") return stepSfLetMatch(args, env, kont); if (_m == "dynamic-wind") return stepSfDynamicWind(args, env, kont); if (_m == "map") return stepHoMap(args, env, kont); if (_m == "map-indexed") return stepHoMapIndexed(args, env, kont); if (_m == "filter") return stepHoFilter(args, env, kont); if (_m == "reduce") return stepHoReduce(args, env, kont); if (_m == "some") return stepHoSome(args, env, kont); if (_m == "every?") return stepHoEvery(args, env, kont); if (_m == "for-each") return stepHoForEach(args, env, kont); if (_m == "raise") return stepSfRaise(args, env, kont); if (_m == "raise-continuable") return makeCekState(first(args), env, kontPush(makeRaiseEvalFrame(env, true), kont)); if (_m == "call/cc") return stepSfCallcc(args, env, kont); if (_m == "call-with-current-continuation") return stepSfCallcc(args, env, kont); if (_m == "perform") return stepSfPerform(args, env, kont); if (_m == "define-library") return stepSfDefineLibrary(args, env, kont); if (_m == "import") return stepSfImport(args, env, kont); if (_m == "define-record-type") return makeCekValue(sfDefineRecordType(args, env), env, kont); if (_m == "define-protocol") return makeCekValue(sfDefineProtocol(args, env), env, kont); if (_m == "implement") return makeCekValue(sfImplement(args, env), env, kont); if (_m == "parameterize") return stepSfParameterize(args, env, kont); if (_m == "syntax-rules") return makeCekValue(sfSyntaxRules(args, env), env, kont); if (_m == "define-syntax") return stepSfDefine(args, env, kont); return (isSxTruthy((isSxTruthy(dictHas(_customSpecialForms, name)) && !isSxTruthy(envHas(env, name)))) ? makeCekValue((get(_customSpecialForms, name))(args, env), env, kont) : (isSxTruthy((isSxTruthy(envHas(env, name)) && isMacro(envGet(env, name)))) ? (function() {
   var mac = envGet(env, name);
   return makeCekState(expandMacro(mac, args, env), env, kont);
-})() : (isSxTruthy((isSxTruthy(_renderCheck) && _renderCheck(expr, env))) ? makeCekValue(_renderFn(expr, env), env, kont) : stepEvalCall(head, args, env, kont)))); })();
+})() : (isSxTruthy((isSxTruthy(_renderCheck) && isSxTruthy(!isSxTruthy(envHas(env, name))) && _renderCheck(expr, env))) ? makeCekValue(_renderFn(expr, env), env, kont) : stepEvalCall(head, args, env, kont)))); })();
 })() : stepEvalCall(head, args, env, kont)));
 })(); };
 PRIMITIVES["step-eval-list"] = stepEvalList;
 
+  // sf-define-type
+  var sfDefineType = function(args, env) { return (function() {
+  var typeSym = first(args);
+  var ctorSpecs = rest(args);
+  return (function() {
+  var typeName = symbolName(typeSym);
+  var ctorNames = map(function(spec) { return symbolName(first(spec)); }, ctorSpecs);
+  if (isSxTruthy(!isSxTruthy(envHas(env, "*adt-registry*")))) {
+  envBind(env, "*adt-registry*", {});
+}
+  envGet(env, "*adt-registry*")[typeName] = ctorNames;
+  envBind(env, (String(typeName) + String("?")), function(v) { return (isSxTruthy(isDict(v)) && isSxTruthy(get(v, "_adt")) && sxEq(get(v, "_type"), typeName)); });
+  { var _c = ctorSpecs; for (var _i = 0; _i < _c.length; _i++) { var spec = _c[_i]; (function() {
+  var cn = symbolName(first(spec));
+  var fieldNames = map(function(f) { return symbolName(f); }, rest(spec));
+  var arity = len(rest(spec));
+  envBind(env, cn, function() { var ctorArgs = Array.prototype.slice.call(arguments, 0); return (isSxTruthy(!isSxTruthy(sxEq(len(ctorArgs), arity))) ? error((String(cn) + String(": expected ") + String(arity) + String(" args, got ") + String(len(ctorArgs)))) : {"_ctor": cn, "_type": typeName, "_adt": true, "_fields": ctorArgs}); });
+  envBind(env, (String(cn) + String("?")), function(v) { return (isSxTruthy(isDict(v)) && isSxTruthy(get(v, "_adt")) && sxEq(get(v, "_ctor"), cn)); });
+  return forEachIndexed(function(idx, fieldName) { return envBind(env, (String(cn) + String("-") + String(fieldName)), function(v) { return nth(get(v, "_fields"), idx); }); }, fieldNames);
+})(); } }
+  return NIL;
+})();
+})(); };
+PRIMITIVES["sf-define-type"] = sfDefineType;
+
+  // (register-special-form! ...)
+  registerSpecialForm("define-type", sfDefineType);
+
   // kont-extract-provides
   var kontExtractProvides = function(kont) { return (isSxTruthy(isEmpty(kont)) ? [] : (function() {
   var frame = first(kont);
@@ -1868,10 +2214,30 @@ PRIMITIVES["kont-extract-provides"] = kontExtractProvides;
   // fire-provide-subscribers
   var fireProvideSubscribers = function(frame, kont) { return (function() {
   var subs = get(frame, "subscribers");
-  return (isSxTruthy(!isSxTruthy(isEmpty(subs))) ? forEach(function(sub) { return cekCall(sub, [kont]); }, subs) : NIL);
+  return (isSxTruthy(!isSxTruthy(isEmpty(subs))) ? (isSxTruthy((_provideBatchDepth_ > 0)) ? forEach(function(sub) { return (isSxTruthy(!isSxTruthy(contains(_provideBatchQueue_, sub))) ? append_b(_provideBatchQueue_, sub) : NIL); }, subs) : forEach(function(sub) { return cekCall(sub, [kont]); }, subs)) : NIL);
 })(); };
 PRIMITIVES["fire-provide-subscribers"] = fireProvideSubscribers;
 
+  // fire-provide-subscribers
+  var fireProvideSubscribers = function(name) { return (function() {
+  var subs = get(_provideSubscribers_, name);
+  return (isSxTruthy((isSxTruthy(subs) && !isSxTruthy(isEmpty(subs)))) ? (isSxTruthy((_provideBatchDepth_ > 0)) ? forEach(function(sub) { return (isSxTruthy(!isSxTruthy(contains(_provideBatchQueue_, sub))) ? append_b(_provideBatchQueue_, sub) : NIL); }, subs) : forEach(function(sub) { return cekCall(sub, [NIL]); }, subs)) : NIL);
+})(); };
+PRIMITIVES["fire-provide-subscribers"] = fireProvideSubscribers;
+
+  // batch-begin!
+  var batchBegin_b = function() { return (_provideBatchDepth_ = (_provideBatchDepth_ + 1)); };
+PRIMITIVES["batch-begin!"] = batchBegin_b;
+
+  // batch-end!
+  var batchEnd_b = function() { _provideBatchDepth_ = (_provideBatchDepth_ - 1);
+return (isSxTruthy(sxEq(_provideBatchDepth_, 0)) ? (function() {
+  var queue = _provideBatchQueue_;
+  _provideBatchQueue_ = [];
+  return forEach(function(sub) { return cekCall(sub, [NIL]); }, queue);
+})() : NIL); };
+PRIMITIVES["batch-end!"] = batchEnd_b;
+
   // step-sf-bind
   var stepSfBind = function(args, env, kont) { return (function() {
   var body = first(args);
@@ -2011,7 +2377,7 @@ PRIMITIVES["sf-syntax-rules"] = sfSyntaxRules;
   { var _c = decls; for (var _i = 0; _i < _c.length; _i++) { var decl = _c[_i]; if (isSxTruthy((isSxTruthy(isList(decl)) && isSxTruthy(!isSxTruthy(isEmpty(decl))) && symbol_p(first(decl))))) {
   (function() {
   var kind = symbolName(first(decl));
-  return (isSxTruthy(sxEq(kind, "export")) ? (exports = append(exports, map(function(s) { return (isSxTruthy(symbol_p(s)) ? symbolName(s) : (String(s))); }, rest(decl)))) : (isSxTruthy(sxEq(kind, "begin")) ? (bodyForms = append(bodyForms, rest(decl))) : NIL));
+  return (isSxTruthy(sxEq(kind, "export")) ? (exports = append(exports, map(function(s) { return (isSxTruthy(symbol_p(s)) ? symbolName(s) : (String(s))); }, rest(decl)))) : (isSxTruthy(sxEq(kind, "import")) ? forEach(function(importSet) { return bindImportSet(importSet, libEnv); }, rest(decl)) : (isSxTruthy(sxEq(kind, "begin")) ? (bodyForms = append(bodyForms, rest(decl))) : NIL)));
 })();
 } } }
   { var _c = bodyForms; for (var _i = 0; _i < _c.length; _i++) { var form = _c[_i]; evalExpr(form, libEnv); } }
@@ -2212,7 +2578,12 @@ PRIMITIVES["match-find-clause"] = matchFindClause;
   var matchPattern = function(pattern, value, env) { return (isSxTruthy(sxEq(pattern, new Symbol("_"))) ? true : (isSxTruthy((isSxTruthy(isList(pattern)) && isSxTruthy(sxEq(len(pattern), 2)) && sxEq(first(pattern), new Symbol("?")))) ? (function() {
   var pred = evalExpr(nth(pattern, 1), env);
   return cekCall(pred, [value]);
-})() : (isSxTruthy((isSxTruthy(isList(pattern)) && isSxTruthy(!isSxTruthy(isEmpty(pattern))) && sxEq(first(pattern), new Symbol("quote")))) ? sxEq(value, nth(pattern, 1)) : (isSxTruthy(symbol_p(pattern)) ? (envBind(env, symbolName(pattern), value), true) : (isSxTruthy((isSxTruthy(isDict(pattern)) && isDict(value))) ? isEvery(function(k) { return matchPattern(get(pattern, k), get(value, k), env); }, keys(pattern)) : (isSxTruthy((isSxTruthy(isList(pattern)) && isSxTruthy(isList(value)) && contains(pattern, new Symbol("&rest")))) ? (function() {
+})() : (isSxTruthy((isSxTruthy(isList(pattern)) && isSxTruthy(!isSxTruthy(isEmpty(pattern))) && sxEq(first(pattern), new Symbol("quote")))) ? sxEq(value, nth(pattern, 1)) : (isSxTruthy(symbol_p(pattern)) ? (envBind(env, symbolName(pattern), value), true) : (isSxTruthy((isSxTruthy(isList(pattern)) && isSxTruthy(!isSxTruthy(isEmpty(pattern))) && isSxTruthy(symbol_p(first(pattern))) && isSxTruthy(isDict(value)) && get(value, "_adt"))) ? (function() {
+  var ctorName = symbolName(first(pattern));
+  var fieldPatterns = rest(pattern);
+  var fields = get(value, "_fields");
+  return (isSxTruthy(sxEq(get(value, "_ctor"), ctorName)) && isSxTruthy(sxEq(len(fieldPatterns), len(fields))) && isEvery(function(pair) { return matchPattern(first(pair), nth(pair, 1), env); }, zip(fieldPatterns, fields)));
+})() : (isSxTruthy((isSxTruthy(isDict(pattern)) && isDict(value))) ? isEvery(function(k) { return matchPattern(get(pattern, k), get(value, k), env); }, keys(pattern)) : (isSxTruthy((isSxTruthy(isList(pattern)) && isSxTruthy(isList(value)) && contains(pattern, new Symbol("&rest")))) ? (function() {
   var restIdx = indexOf_(pattern, new Symbol("&rest"));
   return (isSxTruthy((len(value) >= restIdx)) && isSxTruthy(isEvery(function(pair) { return matchPattern(first(pair), nth(pair, 1), env); }, zip(slice(pattern, 0, restIdx), slice(value, 0, restIdx)))) && (function() {
   var restName = nth(pattern, (restIdx + 1));
@@ -2222,7 +2593,7 @@ PRIMITIVES["match-find-clause"] = matchFindClause;
 })() : (isSxTruthy((isSxTruthy(isList(pattern)) && isList(value))) ? (isSxTruthy(!isSxTruthy(sxEq(len(pattern), len(value)))) ? false : (function() {
   var pairs = zip(pattern, value);
   return isEvery(function(pair) { return matchPattern(first(pair), nth(pair, 1), env); }, pairs);
-})()) : sxEq(pattern, value)))))))); };
+})()) : sxEq(pattern, value))))))))); };
 PRIMITIVES["match-pattern"] = matchPattern;
 
   // step-sf-match
@@ -2231,7 +2602,7 @@ PRIMITIVES["match-pattern"] = matchPattern;
   var clauses = rest(args);
   return (function() {
   var result = matchFindClause(val, clauses, env);
-  return (isSxTruthy(isNil(result)) ? error((String("match: no clause matched ") + String(inspect(val)))) : makeCekState(nth(result, 1), first(result), kont));
+  return (isSxTruthy(isNil(result)) ? makeCekValue((String("match: no clause matched ") + String(inspect(val))), env, kontPush(makeRaiseEvalFrame(env, false), kont)) : makeCekState(nth(result, 1), first(result), kont));
 })();
 })(); };
 PRIMITIVES["step-sf-match"] = stepSfMatch;
@@ -2407,10 +2778,10 @@ PRIMITIVES["step-sf-provide"] = stepSfProvide;
   _bindTracking_.push(name);
 }
 }
-  return makeCekValue((isSxTruthy(frame) ? get(frame, "value") : (function() {
+  return makeCekValue((function() {
   var sv = scopePeek(name);
-  return (isSxTruthy(isNil(sv)) ? defaultVal : sv);
+  return (isSxTruthy(isNil(sv)) ? (isSxTruthy(frame) ? get(frame, "value") : defaultVal) : sv);
-})()), env, kont);
+})(), env, kont);
 })(); };
 PRIMITIVES["step-sf-context"] = stepSfContext;
 
@@ -2649,6 +3020,14 @@ PRIMITIVES["step-ho-for-each"] = stepHoForEach;
 })();
 }
   return makeCekValue(value, fenv, restK);
+})(); if (_m == "define-foreign") return (function() {
+  var name = get(frame, "name");
+  var fenv = get(frame, "env");
+  if (isSxTruthy((isSxTruthy(isLambda(value)) && isNil(lambdaName(value))))) {
+  value.name = name;
+}
+  envBind(fenv, name, value);
+  return makeCekValue(value, fenv, restK);
 })(); if (_m == "set") return (function() {
   var name = get(frame, "name");
   var fenv = get(frame, "env");
@@ -2780,8 +3159,8 @@ PRIMITIVES["step-ho-for-each"] = stepHoForEach;
   (function() {
   var subscriber = function(fireKont) { return cekRun(makeCekState(body, fenv, [])); };
   return forEach(function(name) { return (function() {
-  var pf = kontFindProvide(restK, name);
+  var existing = get(_provideSubscribers_, name);
-  return (isSxTruthy(pf) ? dictSet(pf, "subscribers", append(get(pf, "subscribers"), [subscriber])) : NIL);
+  return dictSet(_provideSubscribers_, name, append((isSxTruthy(existing) ? existing : []), [subscriber]));
 })(); }, tracked);
 })();
   return makeCekValue(value, fenv, restK);
@@ -2789,16 +3168,18 @@ PRIMITIVES["step-ho-for-each"] = stepHoForEach;
   var name = get(frame, "name");
   var fenv = get(frame, "env");
   var target = kontFindProvide(restK, name);
-  return (isSxTruthy(target) ? (function() {
+  return (function() {
-  var oldVal = get(target, "value");
+  var oldVal = (isSxTruthy(target) ? get(target, "value") : scopePeek(name));
+  if (isSxTruthy(target)) {
   target["value"] = value;
+}
   scopePop(name);
   scopePush(name, value);
   if (isSxTruthy(!isSxTruthy(sxEq(oldVal, value)))) {
-  fireProvideSubscribers(target, restK);
+  fireProvideSubscribers(name);
 }
   return makeCekValue(value, fenv, restK);
-})() : (isSxTruthy(envHas(fenv, "provide-set!")) ? (apply(envGet(fenv, "provide-set!"), [name, value]), makeCekValue(value, fenv, restK)) : makeCekValue(NIL, fenv, restK)));
+})();
 })(); if (_m == "scope-acc") return (function() {
   var remaining = get(frame, "remaining");
   var fenv = get(frame, "env");
@@ -2862,12 +3243,20 @@ PRIMITIVES["step-ho-for-each"] = stepHoForEach;
   var testValue = get(frame, "match-val");
   var fenv = get(frame, "env");
   return continueWithCall(value, [testValue], fenv, [testValue], restK);
-})(); if (_m == "raise-eval") return (function() {
+})(); if (_m == "wind-after") return (function() {
+  var afterThunk = get(frame, "after-thunk");
+  var windersLen = get(frame, "winders-len");
+  var bodyResult = value;
+  var fenv = get(frame, "env");
+  return ((isSxTruthy((len(_winders_) > windersLen)) ? (_winders_ = rest(_winders_)) : NIL), continueWithCall(afterThunk, [], fenv, [], kontPush(makeWindReturnFrame(bodyResult, fenv), restK)));
+})(); if (_m == "wind-return") return makeCekValue(get(frame, "body-result"), get(frame, "env"), restK); if (_m == "raise-eval") return (function() {
   var condition = value;
   var fenv = get(frame, "env");
   var continuable_p = get(frame, "scheme");
-  var handlerFn = kontFindHandler(restK, condition);
+  var unwindResult = kontUnwindToHandler(restK, condition);
-  return (isSxTruthy(isNil(handlerFn)) ? ((_lastErrorKont_ = restK), hostError((String("Unhandled exception: ") + String(inspect(condition))))) : continueWithCall(handlerFn, [condition], fenv, [condition], (isSxTruthy(continuable_p) ? kontPush(makeSignalReturnFrame(fenv, restK), restK) : kontPush(makeRaiseGuardFrame(fenv, restK), restK))));
+  var handlerFn = get(unwindResult, "handler");
+  var unwoundK = get(unwindResult, "kont");
+  return (isSxTruthy(isNil(handlerFn)) ? ((_lastErrorKont_ = unwoundK), hostError((String("Unhandled exception: ") + String(inspect(condition))))) : continueWithCall(handlerFn, [condition], fenv, [condition], (isSxTruthy(continuable_p) ? kontPush(makeSignalReturnFrame(fenv, unwoundK), unwoundK) : kontPush(makeRaiseGuardFrame(fenv, unwoundK), unwoundK))));
 })(); if (_m == "raise-guard") return ((_lastErrorKont_ = restK), hostError("exception handler returned from non-continuable raise")); if (_m == "multi-map") return (function() {
   var f = get(frame, "f");
   var remaining = get(frame, "remaining");
@@ -2879,7 +3268,7 @@ PRIMITIVES["step-ho-for-each"] = stepHoForEach;
   return continueWithCall(f, heads, fenv, [], kontPush(makeMultiMapFrame(f, tails, newResults, fenv), restK));
 })());
 })(); if (_m == "callcc") return (function() {
-  var k = makeCallccContinuation(restK);
+  var k = makeCallccContinuation(restK, len(_winders_));
   return continueWithCall(value, [k], get(frame, "env"), [k], restK);
 })(); if (_m == "vm-resume") return (function() {
   var resumeFn = get(frame, "f");
@@ -2925,7 +3314,8 @@ PRIMITIVES["step-continue"] = stepContinue;
 })() : (isSxTruthy(callccContinuation_p(f)) ? (function() {
   var arg = (isSxTruthy(isEmpty(args)) ? NIL : first(args));
   var captured = callccContinuationData(f);
-  return makeCekValue(arg, env, captured);
+  var wLen = callccContinuationWindersLen(f);
+  return (windEscapeTo(wLen), makeCekValue(arg, env, captured));
 })() : (isSxTruthy(continuation_p(f)) ? (function() {
   var arg = (isSxTruthy(isEmpty(args)) ? NIL : first(args));
   var contData = continuationData(f);
@@ -2936,7 +3326,10 @@ PRIMITIVES["step-continue"] = stepContinue;
   return makeCekValue(result, env, kont);
 })();
 })();
-})() : (isSxTruthy((isSxTruthy(isCallable(f)) && isSxTruthy(!isSxTruthy(isLambda(f))) && isSxTruthy(!isSxTruthy(isComponent(f))) && !isSxTruthy(isIsland(f)))) ? makeCekValue(apply(f, args), env, kont) : (isSxTruthy(isLambda(f)) ? (function() {
+})() : (isSxTruthy((isSxTruthy(isCallable(f)) && isSxTruthy(!isSxTruthy(isLambda(f))) && isSxTruthy(!isSxTruthy(isComponent(f))) && !isSxTruthy(isIsland(f)))) ? (function() {
+  var result = sxApplyCek(f, args);
+  return (isSxTruthy(evalError_p(result)) ? makeCekValue(get(result, "message"), env, kontPush(makeRaiseEvalFrame(env, false), kont)) : (isSxTruthy((isSxTruthy(isDict(result)) && get(result, "__vm_suspended"))) ? makeCekSuspended(get(result, "request"), env, kontPush(makeVmResumeFrame(get(result, "resume"), env), kont)) : makeCekValue(result, env, kont)));
+})() : (isSxTruthy(isLambda(f)) ? (function() {
   var params = lambdaParams(f);
   var local = envMerge(lambdaClosure(f), env);
   if (isSxTruthy(!isSxTruthy(bindLambdaParams(params, args, local)))) {
@@ -2948,7 +3341,7 @@ PRIMITIVES["step-continue"] = stepContinue;
 }
   return (function() {
   var jitResult = jitTryCall(f, args);
-  return (isSxTruthy(isNil(jitResult)) ? makeCekState(lambdaBody(f), local, kont) : (isSxTruthy((isSxTruthy(isDict(jitResult)) && get(jitResult, "__vm_suspended"))) ? makeCekSuspended(get(jitResult, "request"), env, kontPush(makeVmResumeFrame(get(jitResult, "resume"), env), kont)) : makeCekValue(jitResult, local, kont)));
+  return (isSxTruthy(jitSkip_p(jitResult)) ? makeCekState(lambdaBody(f), local, kont) : (isSxTruthy((isSxTruthy(isDict(jitResult)) && get(jitResult, "__vm_suspended"))) ? makeCekSuspended(get(jitResult, "request"), env, kontPush(makeVmResumeFrame(get(jitResult, "resume"), env), kont)) : makeCekValue(jitResult, local, kont)));
 })();
 })() : (isSxTruthy(sxOr(isComponent(f), isIsland(f))) ? (function() {
   var parsed = parseKeywordArgs(rawArgs, env);
@@ -2982,6 +3375,10 @@ PRIMITIVES["eval-expr-cek"] = evalExprCek;
   var trampolineCek = function(val) { return (isSxTruthy(isThunk(val)) ? evalExprCek(thunkExpr(val), thunkEnv(val)) : val); };
 PRIMITIVES["trampoline-cek"] = trampolineCek;
 
+  // make-coroutine
+  var makeCoroutine = function(thunk) { return {"suspension": NIL, "thunk": thunk, "type": "coroutine", "state": "ready"}; };
+PRIMITIVES["make-coroutine"] = makeCoroutine;
+
   // eval-expr
   var evalExpr = function(expr, env) { return cekRun(makeCekState(expr, env, [])); };
 PRIMITIVES["eval-expr"] = evalExpr;
@@ -3350,10 +3747,16 @@ PRIMITIVES["serialize"] = serialize;
 
   // === Transpiled from lib/dom (DOM library) ===
 
+  // dom-visible?
+  var domVisible_p = function(el) { return (isSxTruthy(el) ? !isSxTruthy(sxEq(hostGet(hostGet(el, "style"), "display"), "none")) : false); };
+PRIMITIVES["dom-visible?"] = domVisible_p;
 
 
   // === Transpiled from lib/browser (browser API library) ===
 
+  // json-stringify
+  var jsonStringify = function(v) { return hostCall(hostGlobal("JSON"), "stringify", v); };
+PRIMITIVES["json-stringify"] = jsonStringify;
 
 
   // === Transpiled from adapter-dom ===
@@ -3524,6 +3927,7 @@ PRIMITIVES["process-page-scripts"] = processPageScripts;
   // sx-hydrate-islands
   var sxHydrateIslands = function(root) { return (function() {
   var els = domQueryAll(sxOr(root, domBody()), "[data-sx-island]");
+  preloadIslandDefs();
   logInfo((String("sx-hydrate-islands: ") + String(len(els)) + String(" island(s) in ") + String((isSxTruthy(root) ? "subtree" : "document"))));
   return forEach(function(el) { return (isSxTruthy(isProcessed(el, "island-hydrated")) ? logInfo((String("  skip (already hydrated): ") + String(domGetAttr(el, "data-sx-island")))) : (logInfo((String("  hydrating: ") + String(domGetAttr(el, "data-sx-island")))), markProcessed(el, "island-hydrated"), hydrateIsland(el))); }, els);
 })(); };
@@ -3537,26 +3941,34 @@ PRIMITIVES["sx-hydrate-islands"] = sxHydrateIslands;
   var compName = (String("~") + String(name));
   var env = getRenderEnv(NIL);
   return (function() {
-  var comp = envGet(env, compName);
+  var comp = envGet(globalEnv(), compName);
   return (isSxTruthy(!isSxTruthy(sxOr(isComponent(comp), isIsland(comp)))) ? logWarn((String("hydrate-island: unknown island ") + String(compName))) : (function() {
   var kwargs = sxOr(first(sxParse(stateSx)), {});
   var disposers = [];
   var local = envMerge(componentClosure(comp), env);
   { var _c = componentParams(comp); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; envBind(local, p, (isSxTruthy(dictHas(kwargs, p)) ? dictGet(kwargs, p) : NIL)); } }
   return (function() {
-  var bodyDom = cekTry(function() { return withIslandScope(function(disposable) { return append_b(disposers, disposable); }, function() { return renderToDom(componentBody(comp), local, NIL); }); }, function(err) { logWarn((String("hydrate-island FAILED: ") + String(compName) + String(" — ") + String(err)));
+  var cursor = {["parent"]: el, ["index"]: 0};
+  hostCall(el, "replaceChildren");
+  scopePush("sx-hydrating", NIL);
+  cekTry(function() { return withIslandScope(function(disposable) { return append_b(disposers, disposable); }, function() { return (function() {
+  var bodyDom = renderToDom(componentBody(comp), local, NIL);
+  return (isSxTruthy(bodyDom) ? domAppend(el, bodyDom) : NIL);
+})(); }); }, function(err) { scopePop("sx-hydrating");
+logWarn((String("hydrate fallback: ") + String(compName) + String(" — ") + String(err)));
 return (function() {
-  var errorEl = domCreateElement("div", NIL);
+  var fallback = cekTry(function() { return withIslandScope(function(d) { return append_b(disposers, d); }, function() { return renderToDom(componentBody(comp), local, NIL); }); }, function(err2) { return (function() {
-  domSetAttr(errorEl, "class", "sx-island-error");
+  var e = domCreateElement("div", NIL);
-  domSetAttr(errorEl, "style", "padding:8px;margin:4px 0;border:1px solid #ef4444;border-radius:4px;background:#fef2f2;color:#b91c1c;font-family:monospace;font-size:12px;white-space:pre-wrap");
+  domSetTextContent(e, (String("Island error: ") + String(compName) + String("\n") + String(err2)));
-  domSetTextContent(errorEl, (String("Island error: ") + String(compName) + String("\n") + String(err)));
+  return e;
-  return errorEl;
 })(); });
-  domSetTextContent(el, "");
+  hostCall(el, "replaceChildren", fallback);
-  domAppend(el, bodyDom);
+  return NIL;
+})(); });
+  scopePop("sx-hydrating");
   domSetData(el, "sx-disposers", disposers);
   setTimeout_(function() { return processElements(el); }, 0);
-  return logInfo((String("hydrated island: ") + String(compName) + String(" (") + String(len(disposers)) + String(" disposers)")));
+  return logInfo((String("hydrated island: ~") + String(compName) + String(" (") + String(len(disposers)) + String(" disposers)")));
 })();
 })());
 })();
@@ -3656,6 +4068,18 @@ PRIMITIVES["boot-init"] = bootInit;
   // Core primitives that require native JS (cannot be expressed via FFI)
   // -----------------------------------------------------------------------
   PRIMITIVES["error"] = function(msg) { throw new Error(msg); };
+  PRIMITIVES["host-error"] = function(msg) { throw new Error(typeof msg === "string" ? msg : inspect(msg)); };
+  PRIMITIVES["try-catch"] = function(tryFn, catchFn) {
+    try {
+      return cekRun(continueWithCall(tryFn, [], makeEnv(), [], []));
+    } catch(e) {
+      var msg = e && e.message ? e.message : String(e);
+      return cekRun(continueWithCall(catchFn, [msg], makeEnv(), [msg], []));
+    }
+  };
+  PRIMITIVES["without-io-hook"] = function(thunk) {
+    return cekRun(continueWithCall(thunk, [], makeEnv(), [], []));
+  };
   PRIMITIVES["sort"] = function(lst) {
     if (!Array.isArray(lst)) return lst;
     return lst.slice().sort(function(a, b) {
@@ -3723,7 +4147,7 @@ PRIMITIVES["boot-init"] = bootInit;
   PRIMITIVES["dom-tag-name"] = domTagName;
   PRIMITIVES["dom-get-prop"] = domGetProp;
   PRIMITIVES["dom-set-prop"] = domSetProp;
-  PRIMITIVES["reactive-text"] = reactiveText;
+  if (typeof reactiveText === "function") PRIMITIVES["reactive-text"] = reactiveText;
   PRIMITIVES["set-interval"] = setInterval_;
   PRIMITIVES["clear-interval"] = clearInterval_;
   PRIMITIVES["promise-then"] = promiseThen;
@@ -3807,6 +4231,13 @@ PRIMITIVES["boot-init"] = bootInit;
   PRIMITIVES["lambda-name"] = lambdaName;
   PRIMITIVES["component?"] = isComponent;
   PRIMITIVES["island?"] = isIsland;
+  PRIMITIVES["parameter?"] = parameter_p;
+  PRIMITIVES["parameter-uid"] = parameterUid;
+  PRIMITIVES["parameter-default"] = parameterDefault;
+  PRIMITIVES["make-parameter"] = function(defaultVal, converter) {
+    var p = new SxParameter(defaultVal, converter || null);
+    return p;
+  };
   PRIMITIVES["make-symbol"] = function(n) { return new Symbol(n); };
   PRIMITIVES["is-html-tag?"] = function(n) { return HTML_TAGS.indexOf(n) >= 0; };
   function makeEnv() { return merge(componentEnv, PRIMITIVES); }
@@ -3997,7 +4428,7 @@ PRIMITIVES["boot-init"] = bootInit;
   }
 
   function domDispatch(el, name, detail) {
-    if (!_hasDom || !el) return false;
+    if (!_hasDom || !el || typeof el.dispatchEvent !== "function") return false;
     var evt = new CustomEvent(name, { bubbles: true, cancelable: true, detail: detail || {} });
     return el.dispatchEvent(evt);
   }
@@ -4119,6 +4550,14 @@ PRIMITIVES["boot-init"] = bootInit;
   // Platform interface — Orchestration (browser-only)
   // =========================================================================
 
+  // --- Stubs for define-library functions not transpiled by extract_defines ---
+  // These are defined in orchestration.sx's define-library and called from
+  // boot.sx top-level defines. The JS bootstrapper only transpiles top-level
+  // defines, so we provide stubs here for functions that need a JS identity.
+
+  function flushCollectedStyles() { return NIL; }
+  function processElements(root) { return NIL; }
+
   // --- Browser/Network ---
 
   function browserNavigate(url) {
@@ -4604,6 +5043,10 @@ PRIMITIVES["boot-init"] = bootInit;
     return el && el.closest ? el.closest(sel) : null;
   }
 
+  function domDocument() {
+    return _hasDom ? document : null;
+  }
+
   function domBody() {
     return _hasDom ? document.body : null;
   }
@@ -5045,6 +5488,8 @@ PRIMITIVES["boot-init"] = bootInit;
   // Platform interface — Boot (mount, hydrate, scripts, cookies)
   // =========================================================================
 
+  function preloadIslandDefs() { return NIL; }
+
   function resolveMountTarget(target) {
     if (typeof target === "string") return _hasDom ? document.querySelector(target) : null;
     return target;
@@ -5920,52 +6365,52 @@ PRIMITIVES["boot-init"] = bootInit;
     hydrateIslands: typeof sxHydrateIslands === "function" ? sxHydrateIslands : null,
     disposeIsland: typeof disposeIsland === "function" ? disposeIsland : null,
     init: typeof bootInit === "function" ? bootInit : null,
-    scanRefs: scanRefs,
+    scanRefs: typeof scanRefs === "function" ? scanRefs : null,
-    scanComponentsFromSource: scanComponentsFromSource,
+    scanComponentsFromSource: typeof scanComponentsFromSource === "function" ? scanComponentsFromSource : null,
-    transitiveDeps: transitiveDeps,
+    transitiveDeps: typeof transitiveDeps === "function" ? transitiveDeps : null,
-    computeAllDeps: computeAllDeps,
+    computeAllDeps: typeof computeAllDeps === "function" ? computeAllDeps : null,
-    componentsNeeded: componentsNeeded,
+    componentsNeeded: typeof componentsNeeded === "function" ? componentsNeeded : null,
-    pageComponentBundle: pageComponentBundle,
+    pageComponentBundle: typeof pageComponentBundle === "function" ? pageComponentBundle : null,
-    pageCssClasses: pageCssClasses,
+    pageCssClasses: typeof pageCssClasses === "function" ? pageCssClasses : null,
-    scanIoRefs: scanIoRefs,
+    scanIoRefs: typeof scanIoRefs === "function" ? scanIoRefs : null,
-    transitiveIoRefs: transitiveIoRefs,
+    transitiveIoRefs: typeof transitiveIoRefs === "function" ? transitiveIoRefs : null,
-    computeAllIoRefs: computeAllIoRefs,
+    computeAllIoRefs: typeof computeAllIoRefs === "function" ? computeAllIoRefs : null,
-    componentPure_p: componentPure_p,
+    componentPure_p: typeof componentPure_p === "function" ? componentPure_p : null,
-    categorizeSpecialForms: categorizeSpecialForms,
+    categorizeSpecialForms: typeof categorizeSpecialForms === "function" ? categorizeSpecialForms : null,
-    buildReferenceData: buildReferenceData,
+    buildReferenceData: typeof buildReferenceData === "function" ? buildReferenceData : null,
-    buildAttrDetail: buildAttrDetail,
+    buildAttrDetail: typeof buildAttrDetail === "function" ? buildAttrDetail : null,
-    buildHeaderDetail: buildHeaderDetail,
+    buildHeaderDetail: typeof buildHeaderDetail === "function" ? buildHeaderDetail : null,
-    buildEventDetail: buildEventDetail,
+    buildEventDetail: typeof buildEventDetail === "function" ? buildEventDetail : null,
-    buildComponentSource: buildComponentSource,
+    buildComponentSource: typeof buildComponentSource === "function" ? buildComponentSource : null,
-    buildBundleAnalysis: buildBundleAnalysis,
+    buildBundleAnalysis: typeof buildBundleAnalysis === "function" ? buildBundleAnalysis : null,
-    buildRoutingAnalysis: buildRoutingAnalysis,
+    buildRoutingAnalysis: typeof buildRoutingAnalysis === "function" ? buildRoutingAnalysis : null,
-    buildAffinityAnalysis: buildAffinityAnalysis,
+    buildAffinityAnalysis: typeof buildAffinityAnalysis === "function" ? buildAffinityAnalysis : null,
-    splitPathSegments: splitPathSegments,
+    splitPathSegments: typeof splitPathSegments === "function" ? splitPathSegments : null,
-    parseRoutePattern: parseRoutePattern,
+    parseRoutePattern: typeof parseRoutePattern === "function" ? parseRoutePattern : null,
-    matchRoute: matchRoute,
+    matchRoute: typeof matchRoute === "function" ? matchRoute : null,
-    findMatchingRoute: findMatchingRoute,
+    findMatchingRoute: typeof findMatchingRoute === "function" ? findMatchingRoute : null,
-    urlToExpr: urlToExpr,
+    urlToExpr: typeof urlToExpr === "function" ? urlToExpr : null,
-    autoQuoteUnknowns: autoQuoteUnknowns,
+    autoQuoteUnknowns: typeof autoQuoteUnknowns === "function" ? autoQuoteUnknowns : null,
-    prepareUrlExpr: prepareUrlExpr,
+    prepareUrlExpr: typeof prepareUrlExpr === "function" ? prepareUrlExpr : null,
     registerIo: typeof registerIoPrimitive === "function" ? registerIoPrimitive : null,
     registerIoDeps: typeof registerIoDeps === "function" ? registerIoDeps : null,
     asyncRender: typeof asyncSxRenderWithEnv === "function" ? asyncSxRenderWithEnv : null,
     asyncRenderToDom: typeof asyncRenderToDom === "function" ? asyncRenderToDom : null,
-    signal: signal,
+    signal: typeof signal === "function" ? signal : null,
-    deref: deref,
+    deref: typeof deref === "function" ? deref : null,
-    reset: reset_b,
+    reset: typeof reset_b === "function" ? reset_b : null,
-    swap: swap_b,
+    swap: typeof swap_b === "function" ? swap_b : null,
-    computed: computed,
+    computed: typeof computed === "function" ? computed : null,
-    effect: effect,
+    effect: typeof effect === "function" ? effect : null,
-    batch: batch,
+    batch: typeof batch === "function" ? batch : null,
-    isSignal: isSignal,
+    isSignal: typeof isSignal === "function" ? isSignal : null,
-    makeSignal: makeSignal,
+    makeSignal: typeof makeSignal === "function" ? makeSignal : null,
-    defStore: defStore,
+    defStore: typeof defStore === "function" ? defStore : null,
-    useStore: useStore,
+    useStore: typeof useStore === "function" ? useStore : null,
-    clearStores: clearStores,
+    clearStores: typeof clearStores === "function" ? clearStores : null,
-    emitEvent: emitEvent,
+    emitEvent: typeof emitEvent === "function" ? emitEvent : null,
-    onEvent: onEvent,
+    onEvent: typeof onEvent === "function" ? onEvent : null,
-    bridgeEvent: bridgeEvent,
+    bridgeEvent: typeof bridgeEvent === "function" ? bridgeEvent : null,
     makeSpread: makeSpread,
     isSpread: isSpread,
     spreadAttrs: spreadAttrs,

spec/coroutines.sx

@@ -0,0 +1,56 @@
+(define-library
+  (sx coroutines)
+  (export
+    make-coroutine
+    coroutine?
+    coroutine-alive?
+    coroutine-yield
+    coroutine-handle-result
+    coroutine-resume)
+  (begin
+    (define make-coroutine (fn (thunk) {:suspension nil :thunk thunk :type "coroutine" :state "ready"}))
+    (define
+      coroutine?
+      (fn (v) (and (dict? v) (= (get v "type") "coroutine"))))
+    (define
+      coroutine-alive?
+      (fn (c) (and (coroutine? c) (not (= (get c "state") "dead")))))
+    (define coroutine-yield (fn (val) (perform {:value val :op "coroutine-yield"})))
+    (define
+      coroutine-handle-result
+      (fn
+        (c result)
+        (if
+          (cek-terminal? result)
+          (do (dict-set! c "state" "dead") {:done true :value (cek-value result)})
+          (let
+            ((request (cek-io-request result)))
+            (if
+              (and (dict? request) (= (get request "op") "coroutine-yield"))
+              (do
+                (dict-set! c "state" "suspended")
+                (dict-set! c "suspension" result)
+                {:done false :value (get request "value")})
+              (perform request))))))
+    (define
+      coroutine-resume
+      (fn
+        (c val)
+        (cond
+          (not (coroutine? c))
+          (error "coroutine-resume: not a coroutine")
+          (= (get c "state") "dead")
+          (error "coroutine-resume: coroutine is dead")
+          (= (get c "state") "ready")
+          (do
+            (dict-set! c "state" "running")
+            (coroutine-handle-result
+              c
+              (cek-step-loop
+                (make-cek-state (list (get c "thunk")) (make-env) (list)))))
+          (= (get c "state") "suspended")
+          (do
+            (dict-set! c "state" "running")
+            (coroutine-handle-result c (cek-resume (get c "suspension") val)))
+          :else (error
+            (str "coroutine-resume: unexpected state: " (get c "state"))))))))

spec/evaluator.sx

@@ -142,6 +142,16 @@
 
 (define make-callcc-frame (fn (env) {:env env :type "callcc"}))
 
+(define
+  make-wind-after-frame
+  (fn (after-thunk winders-len env)
+    {:type "wind-after" :after-thunk after-thunk :winders-len winders-len :env env}))
+
+(define
+  make-wind-return-frame
+  (fn (body-result env)
+    {:type "wind-return" :body-result body-result :env env}))
+
 ;; R7RS exception frames (raise, guard)
 (define make-deref-frame (fn (env) {:env env :type "deref"}))
 
@@ -228,6 +238,44 @@
               match))
           (kont-find-handler (rest kont) condition))))))
 
+(define
+  kont-unwind-to-handler
+  (fn (kont condition)
+    (if
+      (empty? kont)
+      {:handler nil :kont kont}
+      (let
+        ((frame (first kont)) (rest-k (rest kont)))
+        (cond
+          (= (frame-type frame) "handler")
+          (let
+            ((match (find-matching-handler (get frame "f") condition)))
+            (if
+              (nil? match)
+              (kont-unwind-to-handler rest-k condition)
+              {:handler match :kont kont}))
+          (= (frame-type frame) "wind-after")
+          (do
+            (when
+              (> (len *winders*) (get frame "winders-len"))
+              (set! *winders* (rest *winders*)))
+            (cek-call (get frame "after-thunk") (list))
+            (kont-unwind-to-handler rest-k condition))
+          :else
+          (kont-unwind-to-handler rest-k condition))))))
+
+(define
+  wind-escape-to
+  (fn
+    (target-len)
+    (when
+      (> (len *winders*) target-len)
+      (let
+        ((after-thunk (first *winders*)))
+        (set! *winders* (rest *winders*))
+        (cek-call after-thunk (list))
+        (wind-escape-to target-len)))))
+
 (define
   find-named-restart
   (fn
@@ -410,6 +458,8 @@
 
 (define *provide-subscribers* (dict))
 
+(define *winders* (list))
+
 (define *library-registry* (dict))
 
 (define
@@ -1343,14 +1393,24 @@
       (make-cek-state (thunk-expr thk) (thunk-env thk) kont))))
 
 (define
-  sf-dynamic-wind
+  step-sf-dynamic-wind
   (fn
-    ((args :as list) (env :as dict))
+    (args env kont)
     (let
       ((before (trampoline (eval-expr (first args) env)))
         (body (trampoline (eval-expr (nth args 1) env)))
         (after (trampoline (eval-expr (nth args 2) env))))
-      (dynamic-wind-call before body after env))))
+      (do
+        (cek-call before (list))
+        (let
+          ((winders-len (len *winders*)))
+          (set! *winders* (cons after *winders*))
+          (continue-with-call
+            body
+            (list)
+            env
+            (list)
+            (kont-push (make-wind-after-frame after winders-len env) kont)))))))
 
 ;; R7RS records (SRFI-9)
 ;;
@@ -1788,8 +1848,7 @@
               ("invoke-restart" (step-sf-invoke-restart args env kont))
               ("match" (step-sf-match args env kont))
               ("let-match" (step-sf-let-match args env kont))
-              ("dynamic-wind"
+              ("dynamic-wind" (step-sf-dynamic-wind args env kont))
-                (make-cek-value (sf-dynamic-wind args env) env kont))
               ("map" (step-ho-map args env kont))
               ("map-indexed" (step-ho-map-indexed args env kont))
               ("filter" (step-ho-filter args env kont))
@@ -1839,6 +1898,67 @@
                   :else (step-eval-call head args env kont)))))
           (step-eval-call head args env kont))))))
 
+(define
+  sf-define-type
+  (fn
+    (args env)
+    (let
+      ((type-sym (first args)) (ctor-specs (rest args)))
+      (let
+        ((type-name (symbol-name type-sym))
+          (ctor-names
+            (map (fn (spec) (symbol-name (first spec))) ctor-specs)))
+        (when
+          (not (env-has? env "*adt-registry*"))
+          (env-bind! env "*adt-registry*" {}))
+        (dict-set! (env-get env "*adt-registry*") type-name ctor-names)
+        (env-bind!
+          env
+          (str type-name "?")
+          (fn
+            (v)
+            (and (dict? v) (get v :_adt) (= (get v :_type) type-name))))
+        (for-each
+          (fn
+            (spec)
+            (let
+              ((cn (symbol-name (first spec)))
+                (field-names (map (fn (f) (symbol-name f)) (rest spec)))
+                (arity (len (rest spec))))
+              (env-bind!
+                env
+                cn
+                (fn
+                  (&rest ctor-args)
+                  (if
+                    (not (= (len ctor-args) arity))
+                    (error
+                      (str
+                        cn
+                        ": expected "
+                        arity
+                        " args, got "
+                        (len ctor-args)))
+                    {:_ctor cn :_type type-name :_adt true :_fields ctor-args})))
+              (env-bind!
+                env
+                (str cn "?")
+                (fn
+                  (v)
+                  (and (dict? v) (get v :_adt) (= (get v :_ctor) cn))))
+              (for-each-indexed
+                (fn
+                  (idx field-name)
+                  (env-bind!
+                    env
+                    (str cn "-" field-name)
+                    (fn (v) (nth (get v :_fields) idx))))
+                field-names)))
+          ctor-specs)
+        nil))))
+
+(register-special-form! "define-type" sf-define-type)
+
 (define
   kont-extract-provides
   (fn
@@ -1873,6 +1993,14 @@
             subs)
           (for-each (fn (sub) (cek-call sub (list kont))) subs))))))
 
+;; ═══════════════════════════════════════════════════════════════
+;; Part 10: Continue Phase — Frame Dispatch
+;;
+;; When phase="continue", pop the top frame and process the value.
+;; Each frame type has its own handling: if frames check truthiness,
+;; let frames bind the value, arg frames accumulate it, etc.
+;; continue-with-call handles the final function/component dispatch.
+;; ═══════════════════════════════════════════════════════════════
 (define
   fire-provide-subscribers
   (fn
@@ -1892,18 +2020,13 @@
             subs)
           (for-each (fn (sub) (cek-call sub (list nil))) subs))))))
 
+;; Final call dispatch from arg frame — all args evaluated, invoke function.
+;; Handles: lambda (bind params + TCO), component (keyword args + TCO),
+;; native fn (direct call), continuation (resume), callcc continuation (escape).
 (define
   batch-begin!
   (fn () (set! *provide-batch-depth* (+ *provide-batch-depth* 1))))
 
-;; ═══════════════════════════════════════════════════════════════
-;; Part 10: Continue Phase — Frame Dispatch
-;;
-;; When phase="continue", pop the top frame and process the value.
-;; Each frame type has its own handling: if frames check truthiness,
-;; let frames bind the value, arg frames accumulate it, etc.
-;; continue-with-call handles the final function/component dispatch.
-;; ═══════════════════════════════════════════════════════════════
 (define
   batch-end!
   (fn
@@ -1916,9 +2039,13 @@
         (set! *provide-batch-queue* (list))
         (for-each (fn (sub) (cek-call sub (list nil))) queue)))))
 
-;; Final call dispatch from arg frame — all args evaluated, invoke function.
+;; ═══════════════════════════════════════════════════════════════
-;; Handles: lambda (bind params + TCO), component (keyword args + TCO),
+;; Part 11: Entry Points
-;; native fn (direct call), continuation (resume), callcc continuation (escape).
+;;
+;; eval-expr-cek / trampoline-cek: CEK evaluation entry points.
+;; eval-expr / trampoline: top-level bindings that override the
+;; forward declarations from Part 5.
+;; ═══════════════════════════════════════════════════════════════
 (define
   step-sf-bind
   (fn
@@ -1949,13 +2076,6 @@
               (make-parameterize-frame bindings nil (list) body env)
               kont)))))))
 
-;; ═══════════════════════════════════════════════════════════════
-;; Part 11: Entry Points
-;;
-;; eval-expr-cek / trampoline-cek: CEK evaluation entry points.
-;; eval-expr / trampoline: top-level bindings that override the
-;; forward declarations from Part 5.
-;; ═══════════════════════════════════════════════════════════════
 (define
   syntax-rules-match
   (fn
@@ -2127,7 +2247,10 @@
             ((all-vars (syntax-rules-find-all-vars elem bindings)))
             (if
               (empty? all-vars)
-              (syntax-rules-instantiate-list template (+ i 2) bindings)
+              (syntax-rules-instantiate-list
+                template
+                (+ i 2)
+                bindings)
               (let
                 ((count (len (get bindings (first all-vars))))
                   (expanded
@@ -2150,7 +2273,10 @@
                           (syntax-rules-instantiate elem b)))
                       (range count)))
                   (rest-result
-                    (syntax-rules-instantiate-list template (+ i 2) bindings)))
+                    (syntax-rules-instantiate-list
+                      template
+                      (+ i 2)
+                      bindings)))
                 (append expanded rest-result))))
           (cons
             (syntax-rules-instantiate elem bindings)
@@ -2477,7 +2603,8 @@
     (let
       ((proto-name (symbol-name (first args)))
         (raw-type-name (symbol-name (nth args 1)))
-        (type-name (slice raw-type-name 1 (- (len raw-type-name) 1)))
+        (type-name
+          (slice raw-type-name 1 (- (len raw-type-name) 1)))
         (method-defs (rest (rest args))))
       (let
         ((proto (get *protocol-registry* proto-name)))
@@ -2609,6 +2736,17 @@
       (= value (nth pattern 1))
       (symbol? pattern)
       (do (env-bind! env (symbol-name pattern) value) true)
+      (and (list? pattern) (not (empty? pattern)) (symbol? (first pattern)) (dict? value) (get value :_adt))
+      (let
+        ((ctor-name (symbol-name (first pattern)))
+          (field-patterns (rest pattern))
+          (fields (get value :_fields)))
+        (and
+          (= (get value :_ctor) ctor-name)
+          (= (len field-patterns) (len fields))
+          (every?
+            (fn (pair) (match-pattern (first pair) (nth pair 1) env))
+            (zip field-patterns fields))))
       (and (dict? pattern) (dict? value))
       (every?
         (fn (k) (match-pattern (get pattern k) (get value k) env))
@@ -2619,8 +2757,12 @@
         (and
           (>= (len value) rest-idx)
           (every?
-            (fn (pair) (match-pattern (first pair) (nth pair 1) env))
+            (fn
-            (zip (slice pattern 0 rest-idx) (slice value 0 rest-idx)))
+              (pair)
+              (match-pattern (first pair) (nth pair 1) env))
+            (zip
+              (slice pattern 0 rest-idx)
+              (slice value 0 rest-idx)))
           (let
             ((rest-name (nth pattern (+ rest-idx 1))))
             (env-bind! env (symbol-name rest-name) (slice value rest-idx))
@@ -2632,7 +2774,9 @@
         (let
           ((pairs (zip pattern value)))
           (every?
-            (fn (pair) (match-pattern (first pair) (nth pair 1) env))
+            (fn
+              (pair)
+              (match-pattern (first pair) (nth pair 1) env))
             pairs)))
       :else (= pattern value))))
 
@@ -2647,7 +2791,7 @@
         ((result (match-find-clause val clauses env)))
         (if
           (nil? result)
-          (error (str "match: no clause matched " (inspect val)))
+          (make-cek-value (str "match: no clause matched " (inspect val)) env (kont-push (make-raise-eval-frame env false) kont))
           (make-cek-state (nth result 1) (first result) kont))))))
 
 (define
@@ -3295,7 +3439,8 @@
                     kont)))))
           ("reduce"
             (let
-              ((init (nth ordered 1)) (coll (nth ordered 2)))
+              ((init (nth ordered 1))
+                (coll (nth ordered 2)))
               (if
                 (empty? coll)
                 (make-cek-value init env kont)
@@ -3599,7 +3744,10 @@
                             (next-test (first next-clause)))
                           (if
                             (is-else-clause? next-test)
-                            (make-cek-state (nth next-clause 1) fenv rest-k)
+                            (make-cek-state
+                              (nth next-clause 1)
+                              fenv
+                              rest-k)
                             (make-cek-state
                               next-test
                               fenv
@@ -3771,7 +3919,9 @@
                     (let
                       ((d (dict)))
                       (for-each
-                        (fn (pair) (dict-set! d (first pair) (nth pair 1)))
+                        (fn
+                          (pair)
+                          (dict-set! d (first pair) (nth pair 1)))
                         completed)
                       (make-cek-value d fenv rest-k))
                     (let
@@ -4082,16 +4232,41 @@
                   fenv
                   (list test-value)
                   rest-k)))
+            ("wind-after"
+              (let
+                ((after-thunk (get frame "after-thunk"))
+                  (winders-len (get frame "winders-len"))
+                  (body-result value)
+                  (fenv (get frame "env")))
+                (do
+                  (when
+                    (> (len *winders*) winders-len)
+                    (set! *winders* (rest *winders*)))
+                  (continue-with-call
+                    after-thunk
+                    (list)
+                    fenv
+                    (list)
+                    (kont-push
+                      (make-wind-return-frame body-result fenv)
+                      rest-k)))))
+            ("wind-return"
+              (make-cek-value
+                (get frame "body-result")
+                (get frame "env")
+                rest-k))
             ("raise-eval"
               (let
                 ((condition value)
                   (fenv (get frame "env"))
                   (continuable? (get frame "scheme"))
-                  (handler-fn (kont-find-handler rest-k condition)))
+                  (unwind-result (kont-unwind-to-handler rest-k condition))
+                  (handler-fn (get unwind-result "handler"))
+                  (unwound-k (get unwind-result "kont")))
                 (if
                   (nil? handler-fn)
                   (do
-                    (set! *last-error-kont* rest-k)
+                    (set! *last-error-kont* unwound-k)
                     (host-error
                       (str "Unhandled exception: " (inspect condition))))
                   (continue-with-call
@@ -4102,9 +4277,11 @@
                     (if
                       continuable?
                       (kont-push
-                        (make-signal-return-frame fenv rest-k)
+                        (make-signal-return-frame fenv unwound-k)
-                        rest-k)
+                        unwound-k)
-                      (kont-push (make-raise-guard-frame fenv rest-k) rest-k))))))
+                      (kont-push
+                        (make-raise-guard-frame fenv unwound-k)
+                        unwound-k))))))
             ("raise-guard"
               (do
                 (set! *last-error-kont* rest-k)
@@ -4132,7 +4309,7 @@
                         rest-k))))))
             ("callcc"
               (let
-                ((k (make-callcc-continuation rest-k)))
+                ((k (make-callcc-continuation rest-k (len *winders*))))
                 (continue-with-call
                   value
                   (list k)
@@ -4236,8 +4413,9 @@
       (callcc-continuation? f)
       (let
         ((arg (if (empty? args) nil (first args)))
-          (captured (callcc-continuation-data f)))
+          (captured (callcc-continuation-data f))
-        (make-cek-value arg env captured))
+          (w-len (callcc-continuation-winders-len f)))
+        (do (wind-escape-to w-len) (make-cek-value arg env captured)))
       (continuation? f)
       (let
         ((arg (if (empty? args) nil (first args)))
@@ -4282,7 +4460,9 @@
                 " args, got "
                 (len args))))
           (for-each
-            (fn (pair) (env-bind! local (first pair) (nth pair 1)))
+            (fn
+              (pair)
+              (env-bind! local (first pair) (nth pair 1)))
             (zip params args))
           (for-each
             (fn (p) (env-bind! local p nil))
@@ -4337,7 +4517,11 @@
             (if
               (= match-val test-val)
               (make-cek-state body env kont)
-              (sf-case-step-loop match-val (slice clauses 2) env kont))))))))
+              (sf-case-step-loop
+                match-val
+                (slice clauses 2)
+                env
+                kont))))))))
 
 (define
   eval-expr-cek
@@ -4349,6 +4533,8 @@
     (val)
     (if (thunk? val) (eval-expr-cek (thunk-expr val) (thunk-env val)) val)))
 
+(define make-coroutine (fn (thunk) {:suspension nil :thunk thunk :type "coroutine" :state "ready"}))
+
 (define
   eval-expr
   (fn (expr (env :as dict)) (cek-run (make-cek-state expr env (list)))))

spec/primitives.sx

@@ -43,35 +43,35 @@
   "+"
   :params (&rest (args :as number))
   :returns "number"
-  :doc "Sum all arguments."
+  :doc "Sum all arguments. Returns integer iff all args are exact integers (float contagion)."
   :body (reduce (fn (a b) (native-add a b)) 0 args))
 
 (define-primitive
   "-"
   :params ((a :as number) &rest (b :as number))
   :returns "number"
-  :doc "Subtract. Unary: negate. Binary: a - b."
+  :doc "Subtract. Unary: negate. Binary: a - b. Float contagion: returns integer iff all args are integers."
   :body (if (empty? b) (native-neg a) (native-sub a (first b))))
 
 (define-primitive
   "*"
   :params (&rest (args :as number))
   :returns "number"
-  :doc "Multiply all arguments."
+  :doc "Multiply all arguments. Float contagion: integer result iff all args are exact integers."
   :body (reduce (fn (a b) (native-mul a b)) 1 args))
 
 (define-primitive
   "/"
   :params ((a :as number) (b :as number))
-  :returns "number"
+  :returns "float"
-  :doc "Divide a by b."
+  :doc "Divide a by b. Always returns inexact float."
   :body (native-div a b))
 
 (define-primitive
   "mod"
   :params ((a :as number) (b :as number))
   :returns "number"
-  :doc "Modulo a % b."
+  :doc "Modulo a % b. Returns integer iff both args are integers."
   :body (native-mod a b))
 
 (define-primitive
@@ -108,26 +108,26 @@
 (define-primitive
   "floor"
   :params ((x :as number))
-  :returns "number"
+  :returns "integer"
-  :doc "Floor to integer.")
+  :doc "Floor toward negative infinity — returns exact integer.")
 
 (define-primitive
   "ceil"
   :params ((x :as number))
-  :returns "number"
+  :returns "integer"
-  :doc "Ceiling to integer.")
+  :doc "Ceiling toward positive infinity — returns exact integer.")
 
 (define-primitive
   "round"
   :params ((x :as number) &rest (ndigits :as number))
   :returns "number"
-  :doc "Round to ndigits decimal places (default 0).")
+  :doc "Round to ndigits decimal places (default 0). Returns integer when ndigits is 0.")
 
 (define-primitive
   "truncate"
-  :params (((x :as number)))
+  :params ((x :as number))
-  :returns "number"
+  :returns "integer"
-  :doc "Truncate toward zero.")
+  :doc "Truncate toward zero — returns exact integer.")
 
 (define-primitive
   "remainder"
@@ -143,42 +143,42 @@
 
 (define-primitive
   "exact?"
-  :params (((x :as number)))
+  :params ((x :as number))
   :returns "boolean"
-  :doc "True if x is exact (integer-valued).")
+  :doc "True if x is an exact integer (not an inexact float).")
 
 (define-primitive
   "inexact?"
-  :params (((x :as number)))
+  :params ((x :as number))
   :returns "boolean"
-  :doc "True if x is inexact (non-integer).")
+  :doc "True if x is an inexact float (not an exact integer).")
 
 ;; --------------------------------------------------------------------------
 ;; Core — Comparison
 ;; --------------------------------------------------------------------------
 (define-primitive
   "exact->inexact"
-  :params (((x :as number)))
+  :params ((x :as number))
-  :returns "number"
+  :returns "float"
-  :doc "Convert exact to inexact (identity for float tower).")
+  :doc "Convert exact integer to inexact float. Floats pass through unchanged.")
 
 (define-primitive
   "inexact->exact"
-  :params (((x :as number)))
+  :params ((x :as number))
-  :returns "number"
+  :returns "integer"
-  :doc "Convert inexact to nearest exact integer.")
+  :doc "Convert inexact float to nearest exact integer (truncates). Integers pass through unchanged.")
 
 (define-primitive
   "make-vector"
-  :params ((n :as number))
+  :params ((n :as number) (fill :as any :optional true))
   :returns "vector"
-  :doc "Create vector of size n, optionally filled.")
+  :doc "Create vector of length n, each element initialised to fill (default nil).")
 
 (define-primitive
   "vector"
-  :params ()
+  :params (:rest (elts :as any))
   :returns "vector"
-  :doc "Create vector from arguments.")
+  :doc "Construct a vector from its arguments.")
 
 (define-primitive
   "vector?"
@@ -190,31 +190,31 @@
   "vector-length"
   :params ((v :as vector))
   :returns "number"
-  :doc "Number of elements.")
+  :doc "Number of elements in vector v.")
 
 (define-primitive
   "vector-ref"
   :params ((v :as vector) (i :as number))
   :returns "any"
-  :doc "Element at index.")
+  :doc "Element at 0-based index i. Error if out of bounds.")
 
 (define-primitive
   "vector-set!"
   :params ((v :as vector) (i :as number) (val :as any))
   :returns "nil"
-  :doc "Set element at index.")
+  :doc "Mutate element at index i to val. Error if out of bounds.")
 
 (define-primitive
   "vector->list"
   :params ((v :as vector))
   :returns "list"
-  :doc "Convert vector to list.")
+  :doc "Convert vector to a fresh list.")
 
 (define-primitive
   "list->vector"
   :params ((l :as list))
   :returns "vector"
-  :doc "Convert list to vector.")
+  :doc "Convert list to a fresh vector.")
 
 ;; --------------------------------------------------------------------------
 ;; Core — Predicates
@@ -223,13 +223,15 @@
   "vector-fill!"
   :params ((v :as vector) (val :as any))
   :returns "nil"
-  :doc "Fill all elements.")
+  :doc "Set every element of v to val in place.")
 
 (define-primitive
   "vector-copy"
-  :params ((v :as vector))
+  :params ((v :as vector)
+    (start :as number :optional true)
+    (end :as number :optional true))
   :returns "vector"
-  :doc "Independent shallow copy.")
+  :doc "Shallow copy of vector, optionally sliced from start (inclusive) to end (exclusive).")
 
 (define-primitive
   "min"
@@ -372,8 +374,20 @@
   "number?"
   :params (x)
   :returns "boolean"
-  :doc "True if x is a number (int or float)."
+  :doc "True if x is any number — exact integer or inexact float."
-  :body (= (type-of x) "number"))
+  :body (or (= (type-of x) "number") (integer? x)))
+
+(define-primitive
+  "integer?"
+  :params (x)
+  :returns "boolean"
+  :doc "True if x is an exact integer, or a float with no fractional part (e.g. 1.0).")
+
+(define-primitive
+  "float?"
+  :params (x)
+  :returns "boolean"
+  :doc "True if x is an inexact float (Number type). Does not match exact integers.")
 
 (define-primitive
   "string?"
@@ -783,3 +797,55 @@
   :params ((source :as string))
   :returns "list"
   :doc "Parse SX source string into a list of AST expressions.")
+
+(define-primitive
+  "make-string-buffer"
+  :params ()
+  :returns "string-buffer"
+  :doc "Create a new empty mutable string buffer for O(1) amortised append.")
+
+(define-module :stdlib.coroutines)
+
+(define-module :stdlib.bitwise)
+
+(define-primitive
+  "bitwise-and"
+  :params (((a :as number) (b :as number)))
+  :returns "number"
+  :doc "Bitwise AND of two integers.")
+
+(define-primitive
+  "bitwise-or"
+  :params (((a :as number) (b :as number)))
+  :returns "number"
+  :doc "Bitwise OR of two integers.")
+
+(define-primitive
+  "bitwise-xor"
+  :params (((a :as number) (b :as number)))
+  :returns "number"
+  :doc "Bitwise XOR of two integers.")
+
+(define-primitive
+  "bitwise-not"
+  :params ((a :as number))
+  :returns "number"
+  :doc "Bitwise NOT (one's complement) of an integer.")
+
+(define-primitive
+  "arithmetic-shift"
+  :params (((a :as number) (count :as number)))
+  :returns "number"
+  :doc "Arithmetic shift: left if count > 0, right if count < 0.")
+
+(define-primitive
+  "bit-count"
+  :params ((a :as number))
+  :returns "number"
+  :doc "Count set bits (popcount) in a non-negative integer.")
+
+(define-primitive
+  "integer-length"
+  :params ((a :as number))
+  :returns "number"
+  :doc "Number of bits needed to represent integer a (excluding sign).")

spec/tests/test-adt.sx

@@ -0,0 +1,278 @@
+(defsuite
+  "algebraic-data-types"
+  (deftest
+    "constructor creates dict with adt marker"
+    (do
+      (define-type Maybe (Just value) (Nothing))
+      (assert= true (get (Just 42) :_adt))))
+  (deftest
+    "constructor stores type name"
+    (do
+      (define-type Shape (Circle radius) (Square side))
+      (assert= "Shape" (get (Circle 5) :_type))
+      (assert= "Shape" (get (Square 3) :_type))))
+  (deftest
+    "constructor stores constructor name"
+    (do
+      (define-type Opt (Some val) (None))
+      (assert= "Some" (get (Some 1) :_ctor))
+      (assert= "None" (get (None) :_ctor))))
+  (deftest
+    "constructor stores fields as list"
+    (do
+      (define-type Pair (Pair-of fst snd))
+      (assert-equal
+        (list 1 2)
+        (get (Pair-of 1 2) :_fields))))
+  (deftest
+    "zero-arg constructor has empty fields"
+    (do
+      (define-type Flag (Set) (Unset))
+      (assert-equal (list) (get (Set) :_fields))
+      (assert-equal (list) (get (Unset) :_fields))))
+  (deftest
+    "type predicate true for all constructors"
+    (do
+      (define-type Expr (Num n) (Add left right) (Neg e))
+      (assert= true (Expr? (Num 5)))
+      (assert= true (Expr? (Add (Num 1) (Num 2))))
+      (assert= true (Expr? (Neg (Num 3))))))
+  (deftest
+    "type predicate false for non-adt values"
+    (do
+      (define-type Box (Box-of x))
+      (assert= false (Box? 42))
+      (assert= false (Box? "hello"))
+      (assert= false (Box? nil))
+      (assert= false (Box? (list 1 2)))
+      (assert= false (Box? {}))))
+  (deftest
+    "type predicate false for wrong adt type"
+    (do
+      (define-type AT (AV x))
+      (define-type BT (BV x))
+      (assert= false (AT? (BV 1)))
+      (assert= false (BT? (AV 1)))))
+  (deftest
+    "constructor predicate true for matching constructor"
+    (do
+      (define-type Result (Ok value) (Err msg))
+      (assert= true (Ok? (Ok 42)))
+      (assert= true (Err? (Err "bad")))))
+  (deftest
+    "constructor predicate false for wrong constructor"
+    (do
+      (define-type Coin (Heads) (Tails))
+      (assert= false (Heads? (Tails)))
+      (assert= false (Tails? (Heads)))))
+  (deftest
+    "constructor predicate false for non-adt"
+    (do
+      (define-type Wrap (Wrapped x))
+      (assert= false (Wrapped? 42))
+      (assert= false (Wrapped? nil))
+      (assert= false (Wrapped? "str"))))
+  (deftest
+    "single-field accessor returns field value"
+    (do
+      (define-type Holder (Held content))
+      (assert= 99 (Held-content (Held 99)))
+      (assert= "hello" (Held-content (Held "hello")))))
+  (deftest
+    "multi-field accessors return correct fields"
+    (do
+      (define-type Triple (Triple-of a b c))
+      (let
+        ((t (Triple-of 10 20 30)))
+        (assert= 10 (Triple-of-a t))
+        (assert= 20 (Triple-of-b t))
+        (assert= 30 (Triple-of-c t)))))
+  (deftest
+    "tree constructors and accessors"
+    (do
+      (define-type Tree (Leaf) (Node left val right))
+      (let
+        ((t (Node (Leaf) 5 (Node (Leaf) 3 (Leaf)))))
+        (assert= true (Node? t))
+        (assert= 5 (Node-val t))
+        (assert= true (Leaf? (Node-left t)))
+        (assert= true (Node? (Node-right t)))
+        (assert= 3 (Node-val (Node-right t))))))
+  (deftest
+    "arity error on too few args"
+    (do
+      (define-type Pair2 (Pair2-of a b))
+      (let
+        ((ok false))
+        (guard (exn (else (set! ok true))) (Pair2-of 1))
+        (assert ok))))
+  (deftest
+    "arity error on too many args"
+    (do
+      (define-type Single (Single-of x))
+      (let
+        ((ok false))
+        (guard
+          (exn (else (set! ok true)))
+          (Single-of 1 2))
+        (assert ok))))
+  (deftest
+    "multiple types are independent"
+    (do
+      (define-type Color2 (Red2) (Green2) (Blue2))
+      (define-type Suit (Hearts) (Diamonds) (Clubs) (Spades))
+      (assert= false (Color2? (Hearts)))
+      (assert= false (Suit? (Red2)))
+      (assert= true (Color2? (Blue2)))
+      (assert= true (Suit? (Spades)))))
+  (deftest
+    "adt fields can hold any value"
+    (do
+      (define-type Container (Hold x))
+      (assert-equal
+        (list 1 2 3)
+        (Hold-x (Hold (list 1 2 3))))
+      (assert-equal {:a 1} (Hold-x (Hold {:a 1})))))
+  (deftest
+    "adt-registry tracks type constructor names"
+    (do
+      (define-type Days (Mon) (Tue) (Wed) (Thu) (Fri))
+      (assert-equal
+        (list "Mon" "Tue" "Wed" "Thu" "Fri")
+        (get *adt-registry* "Days"))))
+  (deftest
+    "constructors with same field name in different types are independent"
+    (do
+      (define-type P1 (P1-ctor value))
+      (define-type P2 (P2-ctor value))
+      (assert= 10 (P1-ctor-value (P1-ctor 10)))
+      (assert= 20 (P2-ctor-value (P2-ctor 20)))))
+  (deftest
+    "match dispatches on first matching constructor"
+    (do
+      (define-type Color (Red) (Green) (Blue))
+      (assert= "red" (match (Red) ((Red) "red") ((Green) "green") ((Blue) "blue")))
+      (assert= "green" (match (Green) ((Red) "red") ((Green) "green") ((Blue) "blue")))
+      (assert= "blue" (match (Blue) ((Red) "red") ((Green) "green") ((Blue) "blue")))))
+  (deftest
+    "match binds field to variable"
+    (do
+      (define-type Wrapper (Wrap val))
+      (assert= 42 (match (Wrap 42) ((Wrap v) v)))
+      (assert= "hi" (match (Wrap "hi") ((Wrap v) v)))))
+  (deftest
+    "match zero-arg constructor"
+    (do
+      (define-type Signal (On) (Off))
+      (assert= "on" (match (On) ((On) "on") ((Off) "off")))
+      (assert= "off" (match (Off) ((On) "on") ((Off) "off")))))
+  (deftest
+    "match multi-field constructor binds all fields"
+    (do
+      (define-type Vec2 (V2 x y))
+      (let ((v (V2 3 4)))
+        (assert= 7 (match v ((V2 a b) (+ a b)))))))
+  (deftest
+    "match with else clause"
+    (do
+      (define-type Opt2 (Some2 val) (None2))
+      (assert= 10 (match (Some2 10) ((Some2 v) v) (else 0)))
+      (assert= 0 (match (None2) ((Some2 v) v) (else 0)))))
+  (deftest
+    "match else catches non-adt values"
+    (do
+      (assert= "other" (match 42 ((else) "other") (else "other")))
+      (assert= "other" (match "str" (else "other")))))
+  (deftest
+    "match returns body expression value"
+    (do
+      (define-type Num (Num-of n))
+      (assert= 100 (match (Num-of 10) ((Num-of n) (* n n))))))
+  (deftest
+    "match second arm fires when first does not match"
+    (do
+      (define-type Either (Left val) (Right val))
+      (assert= "left-1" (match (Left 1) ((Left v) (str "left-" v)) ((Right v) (str "right-" v))))
+      (assert= "right-2" (match (Right 2) ((Left v) (str "left-" v)) ((Right v) (str "right-" v))))))
+  (deftest
+    "match wildcard _ in constructor pattern"
+    (do
+      (define-type Pair3 (Pair3-of a b))
+      (assert= 5 (match (Pair3-of 5 99) ((Pair3-of x _) x)))
+      (assert= 99 (match (Pair3-of 5 99) ((Pair3-of _ y) y)))))
+  (deftest
+    "match nested adt constructor pattern"
+    (do
+      (define-type Tree2 (Leaf2) (Node2 left val right))
+      (let ((t (Node2 (Leaf2) 7 (Leaf2))))
+        (assert= 7 (match t ((Node2 _ v _) v)))
+        (assert= true (match t ((Node2 (Leaf2) _ _) true) (else false))))))
+  (deftest
+    "match literal pattern"
+    (do
+      (assert= "zero" (match 0 (0 "zero") (else "nonzero")))
+      (assert= "hello" (match "hello" ("hello" "hello") (else "other")))))
+  (deftest
+    "match symbol binding pattern"
+    (do
+      (assert= 42 (match 42 (x x)))))
+  (deftest
+    "match no matching clause raises error"
+    (do
+      (define-type AB (A-val) (B-val))
+      (let ((ok false))
+        (guard (exn (else (set! ok true)))
+          (match (A-val) ((B-val) "b")))
+        (assert ok))))
+  (deftest
+    "match result used in further computation"
+    (do
+      (define-type Num2 (N v))
+      (assert= 30
+        (+
+          (match (N 10) ((N v) v))
+          (match (N 20) ((N v) v))))))
+  (deftest
+    "match with define"
+    (do
+      (define-type Tag (Tagged label value))
+      (define get-label (fn (t) (match t ((Tagged lbl _) lbl))))
+      (define get-value (fn (t) (match t ((Tagged _ val) val))))
+      (let ((t (Tagged "name" 99)))
+        (assert= "name" (get-label t))
+        (assert= 99 (get-value t)))))
+  (deftest
+    "match three-field constructor"
+    (do
+      (define-type Triple2 (T3 a b c))
+      (assert= 6 (match (T3 1 2 3) ((T3 a b c) (+ a b c))))))
+  (deftest
+    "match clauses tried in order"
+    (do
+      (define-type Expr2 (Lit n) (Add l r) (Mul l r))
+      (define eval-expr2 (fn (e)
+        (match e
+          ((Lit n) n)
+          ((Add l r) (+ (eval-expr2 l) (eval-expr2 r)))
+          ((Mul l r) (* (eval-expr2 l) (eval-expr2 r))))))
+      (assert= 7 (eval-expr2 (Add (Lit 3) (Lit 4))))
+      (assert= 12 (eval-expr2 (Mul (Lit 3) (Lit 4))))
+      (assert= 11 (eval-expr2 (Add (Lit 2) (Mul (Lit 3) (Lit 3)))))))
+  (deftest
+    "match else binding captures value"
+    (do
+      (define-type Coin2 (Heads2) (Tails2))
+      (assert= "Tails2" (match (Tails2) ((Heads2) "Heads2") (x (get x :_ctor))))))
+  (deftest
+    "match on adt with string field"
+    (do
+      (define-type Msg (Hello name) (Bye name))
+      (assert= "Hello, Alice" (match (Hello "Alice") ((Hello n) (str "Hello, " n)) ((Bye n) (str "Bye, " n))))
+      (assert= "Bye, Bob" (match (Bye "Bob") ((Hello n) (str "Hello, " n)) ((Bye n) (str "Bye, " n))))))
+  (deftest
+    "match nested pattern with variable binding"
+    (do
+      (define-type Box2 (Box2-of v))
+      (define-type Inner (Inner-of n))
+      (assert= 5 (match (Box2-of (Inner-of 5)) ((Box2-of (Inner-of n)) n)))))
+)

spec/tests/test-bitwise.sx

@@ -0,0 +1,157 @@
+(defsuite
+  "bitwise-operations"
+  (deftest
+    "bitwise-and basic"
+    (do
+      (assert= 0 (bitwise-and 0 0))
+      (assert= 1 (bitwise-and 3 1))
+      (assert= 0 (bitwise-and 5 2))
+      (assert= 4 (bitwise-and 12 6))))
+  (deftest
+    "bitwise-and identity and zero"
+    (do
+      (assert= 255 (bitwise-and 255 255))
+      (assert= 0 (bitwise-and 255 0))))
+  (deftest
+    "bitwise-or basic"
+    (do
+      (assert= 0 (bitwise-or 0 0))
+      (assert= 3 (bitwise-or 1 2))
+      (assert= 7 (bitwise-or 5 3))
+      (assert= 15 (bitwise-or 9 6))))
+  (deftest
+    "bitwise-or identity"
+    (do
+      (assert= 255 (bitwise-or 255 0))
+      (assert= 255 (bitwise-or 0 255))))
+  (deftest
+    "bitwise-xor basic"
+    (do
+      (assert= 0 (bitwise-xor 0 0))
+      (assert= 3 (bitwise-xor 1 2))
+      (assert= 6 (bitwise-xor 3 5))
+      (assert= 0 (bitwise-xor 255 255))))
+  (deftest
+    "bitwise-xor toggle bits"
+    (do
+      (assert= 14 (bitwise-xor 10 4))
+      (assert= 10 (bitwise-xor 14 4))))
+  (deftest
+    "bitwise-not zero"
+    (do (assert= -1 (bitwise-not 0))))
+  (deftest
+    "bitwise-not positive"
+    (do
+      (assert= -2 (bitwise-not 1))
+      (assert= -5 (bitwise-not 4))
+      (assert= -256 (bitwise-not 255))))
+  (deftest
+    "bitwise-not negative"
+    (do
+      (assert= 0 (bitwise-not -1))
+      (assert= 1 (bitwise-not -2))
+      (assert= 4 (bitwise-not -5))))
+  (deftest
+    "bitwise-not double negation"
+    (do
+      (assert= 42 (bitwise-not (bitwise-not 42)))
+      (assert= 0 (bitwise-not (bitwise-not 0)))))
+  (deftest
+    "arithmetic-shift left"
+    (do
+      (assert= 2 (arithmetic-shift 1 1))
+      (assert= 4 (arithmetic-shift 1 2))
+      (assert= 16 (arithmetic-shift 1 4))
+      (assert= 8 (arithmetic-shift 2 2))))
+  (deftest
+    "arithmetic-shift right"
+    (do
+      (assert= 1 (arithmetic-shift 2 -1))
+      (assert= 1 (arithmetic-shift 4 -2))
+      (assert= 5 (arithmetic-shift 10 -1))
+      (assert= 2 (arithmetic-shift 16 -3))))
+  (deftest
+    "arithmetic-shift by zero"
+    (do
+      (assert= 42 (arithmetic-shift 42 0))
+      (assert= 0 (arithmetic-shift 0 5))))
+  (deftest
+    "arithmetic-shift negative value right preserves sign"
+    (do
+      (assert= -1 (arithmetic-shift -1 -1))
+      (assert= -2 (arithmetic-shift -4 -1))))
+  (deftest
+    "bit-count zero"
+    (do (assert= 0 (bit-count 0))))
+  (deftest
+    "bit-count powers of two"
+    (do
+      (assert= 1 (bit-count 1))
+      (assert= 1 (bit-count 2))
+      (assert= 1 (bit-count 4))
+      (assert= 1 (bit-count 128))))
+  (deftest
+    "bit-count all-ones values"
+    (do
+      (assert= 8 (bit-count 255))
+      (assert= 4 (bit-count 15))
+      (assert= 2 (bit-count 3))))
+  (deftest
+    "bit-count mixed"
+    (do
+      (assert= 3 (bit-count 7))
+      (assert= 2 (bit-count 5))
+      (assert= 3 (bit-count 11))
+      (assert= 4 (bit-count 30))))
+  (deftest
+    "integer-length zero"
+    (do (assert= 0 (integer-length 0))))
+  (deftest
+    "integer-length powers of two"
+    (do
+      (assert= 1 (integer-length 1))
+      (assert= 2 (integer-length 2))
+      (assert= 3 (integer-length 4))
+      (assert= 4 (integer-length 8))
+      (assert= 8 (integer-length 128))))
+  (deftest
+    "integer-length non-powers"
+    (do
+      (assert= 2 (integer-length 3))
+      (assert= 3 (integer-length 5))
+      (assert= 3 (integer-length 7))
+      (assert= 8 (integer-length 255))
+      (assert= 9 (integer-length 256))))
+  (deftest
+    "bitwise ops compose"
+    (do
+      (assert=
+        5
+        (bitwise-and
+          (bitwise-or 5 3)
+          (bitwise-xor 7 2)))
+      (assert= 0 (bitwise-and 170 85))))
+  (deftest
+    "arithmetic-shift round-trip"
+    (do
+      (assert=
+        10
+        (arithmetic-shift (arithmetic-shift 10 3) -3))))
+  (deftest
+    "extract bits with mask"
+    (do
+      (let
+        ((x 52))
+        (assert=
+          5
+          (bitwise-and (arithmetic-shift x -2) 7)))))
+  (deftest
+    "clear low bits with bitwise-not mask"
+    (do
+      (assert= 252 (bitwise-and 255 (bitwise-not 3)))))
+  (deftest
+    "integer-length after shift"
+    (do
+      (assert=
+        4
+        (integer-length (arithmetic-shift 1 3))))))

spec/tests/test-coroutines.sx

@@ -0,0 +1,305 @@
+(import (sx coroutines))
+
+(defsuite
+  "coroutine"
+  (deftest
+    "coroutine? recognizes coroutine objects"
+    (let
+      ((co (make-coroutine (fn () nil))))
+      (assert (coroutine? co))
+      (assert= false (coroutine? 42))
+      (assert= false (coroutine? "hello"))
+      (assert= false (coroutine? nil))
+      (assert= false (coroutine? (list)))))
+  (deftest
+    "coroutine-alive? true for ready coroutine"
+    (let
+      ((co (make-coroutine (fn () nil))))
+      (assert (coroutine-alive? co))))
+  (deftest
+    "coroutine-alive? false for non-coroutine"
+    (assert= false (coroutine-alive? 42)))
+  (deftest
+    "immediate return — done true, value is body result"
+    (let
+      ((co (make-coroutine (fn () 42))))
+      (let
+        ((r (coroutine-resume co nil)))
+        (assert= true (get r "done"))
+        (assert= 42 (get r "value")))))
+  (deftest
+    "immediate nil return"
+    (let
+      ((co (make-coroutine (fn () nil))))
+      (let
+        ((r (coroutine-resume co nil)))
+        (assert= true (get r "done"))
+        (assert= nil (get r "value")))))
+  (deftest
+    "coroutine-alive? false after completion"
+    (let
+      ((co (make-coroutine (fn () nil))))
+      (coroutine-resume co nil)
+      (assert= false (coroutine-alive? co))))
+  (deftest
+    "single yield — done false on yield, done true on finish"
+    (let
+      ((co (make-coroutine (fn () (coroutine-yield 10) 20))))
+      (let
+        ((r1 (coroutine-resume co nil)))
+        (let
+          ((r2 (coroutine-resume co nil)))
+          (assert= false (get r1 "done"))
+          (assert= 10 (get r1 "value"))
+          (assert= true (get r2 "done"))
+          (assert= 20 (get r2 "value"))))))
+  (deftest
+    "coroutine-alive? true between yield and next resume"
+    (let
+      ((co (make-coroutine (fn () (coroutine-yield nil) nil))))
+      (assert (coroutine-alive? co))
+      (coroutine-resume co nil)
+      (assert (coroutine-alive? co))
+      (coroutine-resume co nil)
+      (assert= false (coroutine-alive? co))))
+  (deftest
+    "three yields then return"
+    (let
+      ((co (make-coroutine (fn () (coroutine-yield "a") (coroutine-yield "b") (coroutine-yield "c") "z"))))
+      (let
+        ((r1 (coroutine-resume co nil)))
+        (let
+          ((r2 (coroutine-resume co nil)))
+          (let
+            ((r3 (coroutine-resume co nil)))
+            (let
+              ((r4 (coroutine-resume co nil)))
+              (assert= "a" (get r1 "value"))
+              (assert= false (get r1 "done"))
+              (assert= "b" (get r2 "value"))
+              (assert= false (get r2 "done"))
+              (assert= "c" (get r3 "value"))
+              (assert= false (get r3 "done"))
+              (assert= "z" (get r4 "value"))
+              (assert= true (get r4 "done"))))))))
+  (deftest
+    "final return vs yield — done flag distinguishes them"
+    (let
+      ((co (make-coroutine (fn () (coroutine-yield "yielded") "returned"))))
+      (let
+        ((y (coroutine-resume co nil)))
+        (let
+          ((r (coroutine-resume co nil)))
+          (assert= false (get y "done"))
+          (assert= "yielded" (get y "value"))
+          (assert= true (get r "done"))
+          (assert= "returned" (get r "value"))))))
+  (deftest
+    "resume val becomes yield return value"
+    (let
+      ((co (make-coroutine (fn () (let ((received (coroutine-yield "first"))) received)))))
+      (let
+        ((r1 (coroutine-resume co nil)))
+        (let
+          ((r2 (coroutine-resume co 99)))
+          (assert= "first" (get r1 "value"))
+          (assert= false (get r1 "done"))
+          (assert= 99 (get r2 "value"))
+          (assert= true (get r2 "done"))))))
+  (deftest
+    "multiple resume values passed through yields"
+    (let
+      ((co (make-coroutine (fn () (let ((a (coroutine-yield 1))) (let ((b (coroutine-yield 2))) (+ a b)))))))
+      (let
+        ((r1 (coroutine-resume co nil)))
+        (let
+          ((r2 (coroutine-resume co 10)))
+          (let
+            ((r3 (coroutine-resume co 20)))
+            (assert= 1 (get r1 "value"))
+            (assert= 2 (get r2 "value"))
+            (assert= true (get r3 "done"))
+            (assert= 30 (get r3 "value")))))))
+  (deftest
+    "coroutine captures lexical environment"
+    (let
+      ((x 10)
+        (co
+          (make-coroutine
+            (fn () (coroutine-yield (* x 2)) (* x 3)))))
+      (let
+        ((r1 (coroutine-resume co nil)))
+        (let
+          ((r2 (coroutine-resume co nil)))
+          (assert= 20 (get r1 "value"))
+          (assert= 30 (get r2 "value"))))))
+  (deftest
+    "resuming dead coroutine raises error"
+    (let
+      ((co (make-coroutine (fn () nil))))
+      (coroutine-resume co nil)
+      (assert-throws (fn () (coroutine-resume co nil)))))
+  (deftest
+    "coroutine drives iteration via recursive body"
+    (let
+      ((co (make-coroutine (fn () (define loop (fn (i) (when (< i 4) (coroutine-yield i) (loop (+ i 1))))) (loop 0))))
+        (results (list)))
+      (let
+        drive
+        ()
+        (let
+          ((r (coroutine-resume co nil)))
+          (when
+            (not (get r "done"))
+            (append! results (get r "value"))
+            (drive))))
+      (assert= 4 (len results))
+      (assert= 0 (nth results 0))
+      (assert= 1 (nth results 1))
+      (assert= 2 (nth results 2))
+      (assert= 3 (nth results 3))))
+  (deftest
+    "nested coroutine — inner resumed from outer body"
+    (let
+      ((inner (make-coroutine (fn () (coroutine-yield "inner-a") "inner-done")))
+        (outer
+          (make-coroutine
+            (fn
+              ()
+              (let
+                ((i1 (coroutine-resume inner nil)))
+                (coroutine-yield (get i1 "value")))
+              (let ((i2 (coroutine-resume inner nil))) (get i2 "value"))))))
+      (let
+        ((o1 (coroutine-resume outer nil)))
+        (let
+          ((o2 (coroutine-resume outer nil)))
+          (assert= false (get o1 "done"))
+          (assert= "inner-a" (get o1 "value"))
+          (assert= true (get o2 "done"))
+          (assert= "inner-done" (get o2 "value"))))))
+  (deftest
+    "two independent coroutines interleave correctly"
+    (let
+      ((co1 (make-coroutine (fn () (coroutine-yield 1) 5)))
+        (co2
+          (make-coroutine (fn () (coroutine-yield 2) 6))))
+      (let
+        ((a (coroutine-resume co1 nil)))
+        (let
+          ((b (coroutine-resume co2 nil)))
+          (let
+            ((c (coroutine-resume co1 nil)))
+            (let
+              ((d (coroutine-resume co2 nil)))
+              (assert= false (get a "done"))
+              (assert= 1 (get a "value"))
+              (assert= false (get b "done"))
+              (assert= 2 (get b "value"))
+              (assert= true (get c "done"))
+              (assert= 5 (get c "value"))
+              (assert= true (get d "done"))
+              (assert= 6 (get d "value"))))))))
+  (deftest
+    "coroutine state field is ready before first resume"
+    (let
+      ((co (make-coroutine (fn () (coroutine-yield 1)))))
+      (assert= "ready" (get co "state"))))
+  (deftest
+    "coroutine state field is suspended between yields"
+    (let
+      ((co (make-coroutine (fn () (coroutine-yield 1) 2))))
+      (coroutine-resume co nil)
+      (assert= "suspended" (get co "state"))))
+  (deftest
+    "coroutine state field is dead after completion"
+    (let
+      ((co (make-coroutine (fn () nil))))
+      (coroutine-resume co nil)
+      (assert= "dead" (get co "state"))))
+  (deftest
+    "yield works when called from nested helper function"
+    (let
+      ((co (make-coroutine (fn () (define helper (fn (x) (coroutine-yield x))) (helper 10) (helper 20)))))
+      (let
+        ((r1 (coroutine-resume co nil)))
+        (let
+          ((r2 (coroutine-resume co nil)))
+          (let
+            ((r3 (coroutine-resume co nil)))
+            (assert= false (get r1 "done"))
+            (assert= 10 (get r1 "value"))
+            (assert= false (get r2 "done"))
+            (assert= 20 (get r2 "value"))
+            (assert= true (get r3 "done")))))))
+  (deftest
+    "initial resume argument is ignored by ready coroutine"
+    (let
+      ((co (make-coroutine (fn () (coroutine-yield 42)))))
+      (let
+        ((r (coroutine-resume co "ignored")))
+        (assert= false (get r "done"))
+        (assert= 42 (get r "value")))))
+  (deftest
+    "coroutine with mutable closure state"
+    (let
+      ((counter {:value 0}))
+      (let
+        ((co (make-coroutine (fn () (dict-set! counter "value" 1) (coroutine-yield "a") (dict-set! counter "value" 2) (coroutine-yield "b")))))
+        (assert= 0 (get counter "value"))
+        (coroutine-resume co nil)
+        (assert= 1 (get counter "value"))
+        (coroutine-resume co nil)
+        (assert= 2 (get counter "value")))))
+  (deftest
+    "coroutine can yield complex values"
+    (let
+      ((co (make-coroutine (fn () (coroutine-yield (list 1 2 3)) (coroutine-yield {:key "val"})))))
+      (let
+        ((r1 (coroutine-resume co nil)))
+        (let
+          ((r2 (coroutine-resume co nil)))
+          (assert= false (get r1 "done"))
+          (assert= 3 (len (get r1 "value")))
+          (assert= false (get r2 "done"))
+          (assert= "val" (get (get r2 "value") "key"))))))
+  (deftest
+    "round-robin scheduling of multiple coroutines"
+    (let
+      ((results (list))
+        (co1
+          (make-coroutine
+            (fn () (coroutine-yield "a") (coroutine-yield "b"))))
+        (co2
+          (make-coroutine
+            (fn () (coroutine-yield "c") (coroutine-yield "d")))))
+      (append! results (get (coroutine-resume co1 nil) "value"))
+      (append! results (get (coroutine-resume co2 nil) "value"))
+      (append! results (get (coroutine-resume co1 nil) "value"))
+      (append! results (get (coroutine-resume co2 nil) "value"))
+      (assert= 4 (len results))
+      (assert= "a" (nth results 0))
+      (assert= "c" (nth results 1))
+      (assert= "b" (nth results 2))
+      (assert= "d" (nth results 3))))
+  (deftest
+    "coroutines created from same factory share no state"
+    (let
+      ((make-counter (fn (start) (make-coroutine (fn () (define loop (fn (n) (coroutine-yield n) (loop (+ n 1)))) (loop start))))))
+      (let
+        ((c1 (make-counter 0)) (c2 (make-counter 100)))
+        (let
+          ((a (get (coroutine-resume c1 nil) "value")))
+          (let
+            ((b (get (coroutine-resume c2 nil) "value")))
+            (let
+              ((c (get (coroutine-resume c1 nil) "value")))
+              (let
+                ((d (get (coroutine-resume c2 nil) "value")))
+                (assert= 0 a)
+                (assert= 100 b)
+                (assert= 1 c)
+                (assert= 101 d))))))))
+  (deftest
+    "resuming non-coroutine raises error"
+    (assert-throws (fn () (coroutine-resume "not-a-coroutine" nil)))))

spec/tests/test-dynamic-wind.sx

@@ -0,0 +1,113 @@
+;; Tests for dynamic-wind: after-thunk fires on normal return,
+;; non-local exit via raise/guard, and call/cc escape.
+
+(defsuite
+  "dynamic-wind-basic"
+  (deftest
+    "after fires on normal return"
+    (let
+      ((log (list)))
+      (dynamic-wind
+        (fn () (append! log "before"))
+        (fn () (append! log "body"))
+        (fn () (append! log "after")))
+      (assert= 3 (len log))
+      (assert= "before" (nth log 0))
+      (assert= "body" (nth log 1))
+      (assert= "after" (nth log 2))))
+  (deftest
+    "after fires on raise escape"
+    (let
+      ((log (list)))
+      (guard
+        (e (true nil))
+        (dynamic-wind
+          (fn () (append! log "before"))
+          (fn () (append! log "body") (error "boom"))
+          (fn () (append! log "after"))))
+      (assert= 3 (len log))
+      (assert= "before" (nth log 0))
+      (assert= "body" (nth log 1))
+      (assert= "after" (nth log 2))))
+  (deftest
+    "after fires on call/cc escape"
+    (let
+      ((log (list)))
+      (call/cc
+        (fn
+          (k)
+          (dynamic-wind
+            (fn () (append! log "before"))
+            (fn () (append! log "body") (k nil))
+            (fn () (append! log "after")))))
+      (assert= 3 (len log))
+      (assert= "before" (nth log 0))
+      (assert= "body" (nth log 1))
+      (assert= "after" (nth log 2))))
+  (deftest
+    "nested dynamic-wind after-thunks fire LIFO on normal return"
+    (let
+      ((log (list)))
+      (dynamic-wind
+        (fn () (append! log "outer-before"))
+        (fn
+          ()
+          (dynamic-wind
+            (fn () (append! log "inner-before"))
+            (fn () (append! log "inner-body"))
+            (fn () (append! log "inner-after"))))
+        (fn () (append! log "outer-after")))
+      (assert= 5 (len log))
+      (assert= "outer-before" (nth log 0))
+      (assert= "inner-before" (nth log 1))
+      (assert= "inner-body" (nth log 2))
+      (assert= "inner-after" (nth log 3))
+      (assert= "outer-after" (nth log 4))))
+  (deftest
+    "nested dynamic-wind after-thunks fire LIFO on raise"
+    (let
+      ((log (list)))
+      (guard
+        (e (true nil))
+        (dynamic-wind
+          (fn () (append! log "outer-before"))
+          (fn
+            ()
+            (dynamic-wind
+              (fn () (append! log "inner-before"))
+              (fn () (append! log "inner-body") (error "boom"))
+              (fn () (append! log "inner-after"))))
+          (fn () (append! log "outer-after"))))
+      (assert= 5 (len log))
+      (assert= "outer-before" (nth log 0))
+      (assert= "inner-before" (nth log 1))
+      (assert= "inner-body" (nth log 2))
+      (assert= "inner-after" (nth log 3))
+      (assert= "outer-after" (nth log 4))))
+  (deftest
+    "before and after are called"
+    (let
+      ((count 0))
+      (dynamic-wind
+        (fn () (set! count (+ count 1)))
+        (fn () nil)
+        (fn () (set! count (+ count 10))))
+      (assert= 11 count)))
+  (deftest
+    "dynamic-wind return value is body result"
+    (let
+      ((result (dynamic-wind (fn () nil) (fn () 42) (fn () nil))))
+      (assert= 42 result)))
+  (deftest
+    "after fires before guard handler"
+    (let
+      ((log (list)))
+      (guard
+        (e (true (append! log "guard-handler")))
+        (dynamic-wind
+          (fn () nil)
+          (fn () (error "boom"))
+          (fn () (append! log "after"))))
+      (assert= 2 (len log))
+      (assert= "after" (nth log 0))
+      (assert= "guard-handler" (nth log 1)))))

spec/tests/test-numeric-tower.sx

@@ -0,0 +1,221 @@
+
+;; ==========================================================================
+;; test-numeric-tower.sx — Numeric tower: Integer vs Float distinction
+;;
+;; Tests for float contagion, integer arithmetic, predicates,
+;; coercions, parsing, and rendering.
+;;
+;; Note: Use fractional floats (1.5, 3.14) or exact->inexact for round floats,
+;; since the SX serializer renders Number 1.0 as "1" (int form).
+;; ==========================================================================
+
+;; --------------------------------------------------------------------------
+;; Integer arithmetic — result stays Integer when all args are Integer
+;; --------------------------------------------------------------------------
+
+(defsuite
+  "numeric-tower:int-arithmetic"
+  (deftest "int + int = int" (assert (integer? (+ 1 2))))
+  (deftest "int + int value" (assert= (+ 1 2) 3))
+  (deftest "int - int = int" (assert (integer? (- 10 3))))
+  (deftest "int - int value" (assert= (- 10 3) 7))
+  (deftest "int * int = int" (assert (integer? (* 4 5))))
+  (deftest "int * int value" (assert= (* 4 5) 20))
+  (deftest "zero identity" (assert= (+ 0 0) 0))
+  (deftest "negative int" (assert= (- 0 5) -5))
+  (deftest
+    "int negation is int"
+    (assert (integer? (- 0 7))))
+  (deftest
+    "large int product"
+    (assert= (* 100 100) 10000)))
+
+;; --------------------------------------------------------------------------
+;; Float contagion — any float arg promotes result to float
+;; --------------------------------------------------------------------------
+
+(defsuite
+  "numeric-tower:float-contagion"
+  (deftest "int + float = float" (assert (float? (+ 1 1.5))))
+  (deftest "int + float value" (assert= (+ 1 1.5) 2.5))
+  (deftest "float + int = float" (assert (float? (+ 1.5 2))))
+  (deftest "float + float = float" (assert (float? (+ 1.5 2.5))))
+  (deftest "int * float = float" (assert (float? (* 2 1.5))))
+  (deftest "int * float value" (assert= (* 2 1.5) 3))
+  (deftest "int - float = float" (assert (float? (- 5 2.5))))
+  (deftest "float - int = float" (assert (float? (- 5.5 2))))
+  (deftest
+    "three args with float"
+    (assert (float? (+ 1 2 3.5))))
+  (deftest
+    "exact->inexact promotes to float"
+    (assert (float? (exact->inexact 5)))))
+
+;; --------------------------------------------------------------------------
+;; Division always returns float
+;; --------------------------------------------------------------------------
+
+(defsuite
+  "numeric-tower:division"
+  (deftest "int / int = float" (assert (float? (/ 6 2))))
+  (deftest "exact division value" (assert= (/ 6 2) 3))
+  (deftest "inexact division" (assert= (/ 1 4) 0.25))
+  (deftest "float / float = float" (assert (float? (/ 3.5 2.5)))))
+
+;; --------------------------------------------------------------------------
+;; Type predicates
+;; --------------------------------------------------------------------------
+
+(defsuite
+  "numeric-tower:predicates"
+  (deftest "integer? on int" (assert (integer? 42)))
+  (deftest "integer? on negative" (assert (integer? -7)))
+  (deftest "integer? on zero" (assert (integer? 0)))
+  (deftest
+    "integer? on float-int"
+    (assert (integer? (exact->inexact 2))))
+  (deftest "integer? on fractional float" (assert (not (integer? 1.5))))
+  (deftest "float? on 1.5" (assert (float? 1.5)))
+  (deftest
+    "float? on exact->inexact"
+    (assert (float? (exact->inexact 2))))
+  (deftest "float? on int" (assert (not (float? 42))))
+  (deftest "number? on int" (assert (number? 42)))
+  (deftest "number? on float" (assert (number? 3.14)))
+  (deftest "number? on string" (assert (not (number? "42"))))
+  (deftest "exact? on int" (assert (exact? 1)))
+  (deftest
+    "exact? on exact->inexact"
+    (assert (not (exact? (exact->inexact 1)))))
+  (deftest "inexact? on 1.5" (assert (inexact? 1.5)))
+  (deftest "inexact? on int" (assert (not (inexact? 3)))))
+
+;; --------------------------------------------------------------------------
+;; Coercions
+;; --------------------------------------------------------------------------
+
+(defsuite
+  "numeric-tower:coercions"
+  (deftest "exact->inexact int" (assert= (exact->inexact 3) 3))
+  (deftest
+    "exact->inexact produces float"
+    (assert (float? (exact->inexact 5))))
+  (deftest
+    "exact->inexact float passthrough"
+    (assert= (exact->inexact 1.5) 1.5))
+  (deftest "inexact->exact 1.5" (assert= (inexact->exact 1.5) 2))
+  (deftest
+    "inexact->exact produces int"
+    (assert (integer? (inexact->exact (exact->inexact 4)))))
+  (deftest "inexact->exact 2.7" (assert= (inexact->exact 2.7) 3))
+  (deftest
+    "inexact->exact int passthrough"
+    (assert= (inexact->exact 5) 5)))
+
+;; --------------------------------------------------------------------------
+;; floor / ceiling / truncate / round — return Integer for floats
+;; --------------------------------------------------------------------------
+
+(defsuite
+  "numeric-tower:rounding"
+  (deftest "floor 3.7" (assert= (floor 3.7) 3))
+  (deftest "floor produces int" (assert (integer? (floor 3.7))))
+  (deftest "floor negative" (assert= (floor -2.3) -3))
+  (deftest "truncate 3.9" (assert= (truncate 3.9) 3))
+  (deftest "truncate negative" (assert= (truncate -3.9) -3))
+  (deftest "truncate produces int" (assert (integer? (truncate 3.9))))
+  (deftest "round 2.3 down" (assert= (round 2.3) 2))
+  (deftest "round produces int" (assert (integer? (round 2.3))))
+  (deftest
+    "floor of int passthrough"
+    (assert= (floor 5) 5))
+  (deftest "floor of int stays int" (assert (integer? (floor 5)))))
+
+;; --------------------------------------------------------------------------
+;; parse-number distinguishes int vs float strings
+;; --------------------------------------------------------------------------
+
+(defsuite
+  "numeric-tower:parse-number"
+  (deftest
+    "parse-number int string"
+    (assert= (parse-number "42") 42))
+  (deftest
+    "parse-number int is integer?"
+    (assert (integer? (parse-number "42"))))
+  (deftest "parse-number 3.14" (assert= (parse-number "3.14") 3.14))
+  (deftest
+    "parse-number float is float?"
+    (assert (float? (parse-number "3.14"))))
+  (deftest
+    "parse-number 1.5 is float?"
+    (assert (float? (parse-number "1.5"))))
+  (deftest
+    "parse-number negative int"
+    (assert= (parse-number "-5") -5))
+  (deftest
+    "parse-number negative int is integer?"
+    (assert (integer? (parse-number "-5"))))
+  (deftest "parse-int returns integer" (assert (integer? (parse-int "7"))))
+  (deftest "parse-int value" (assert= (parse-int "7") 7)))
+
+;; --------------------------------------------------------------------------
+;; Equality across numeric types
+;; --------------------------------------------------------------------------
+
+(defsuite
+  "numeric-tower:equality"
+  (deftest "int = same int" (assert= 5 5))
+  (deftest
+    "int = float eq"
+    (assert (= 1 (exact->inexact 1))))
+  (deftest
+    "float = int eq"
+    (assert (= (exact->inexact 1) 1)))
+  (deftest "int != different int" (assert (!= 1 2)))
+  (deftest "int < float" (assert (< 1 1.5)))
+  (deftest "float > int" (assert (> 2.5 2)))
+  (deftest "int <= float" (assert (<= 2 2.5)))
+  (deftest "int >= int" (assert (>= 3 3))))
+
+;; --------------------------------------------------------------------------
+;; mod / remainder / modulo with integers
+;; --------------------------------------------------------------------------
+
+(defsuite
+  "numeric-tower:modulo"
+  (deftest
+    "mod int int = int"
+    (assert (integer? (mod 10 3))))
+  (deftest "mod value" (assert= (mod 10 3) 1))
+  (deftest
+    "remainder int int = int"
+    (assert (integer? (remainder 10 3))))
+  (deftest
+    "remainder value"
+    (assert= (remainder 10 3) 1)))
+
+;; --------------------------------------------------------------------------
+;; min / max with mixed types
+;; --------------------------------------------------------------------------
+
+(defsuite
+  "numeric-tower:min-max"
+  (deftest "min two ints" (assert= (min 3 7) 3))
+  (deftest
+    "min int result type"
+    (assert (integer? (min 3 7))))
+  (deftest "max two ints" (assert= (max 3 7) 7))
+  (deftest "min with float" (assert= (min 3 2.5) 2.5))
+  (deftest "max with float" (assert= (max 3 3.5) 3.5)))
+
+;; --------------------------------------------------------------------------
+;; str rendering of int vs float
+;; --------------------------------------------------------------------------
+
+(defsuite
+  "numeric-tower:stringify"
+  (deftest "str of int" (assert= (str 42) "42"))
+  (deftest "str of negative int" (assert= (str -5) "-5"))
+  (deftest "str of 3.14" (assert= (str 3.14) "3.14"))
+  (deftest "str of 1.5" (assert= (str 1.5) "1.5")))

spec/tests/test-string-buffer.sx

@@ -0,0 +1,131 @@
+(defsuite
+  "string-buffer"
+  (deftest
+    "make-string-buffer creates a string-buffer"
+    (let ((buf (make-string-buffer))) (assert (string-buffer? buf))))
+  (deftest
+    "string-buffer? is false for non-buffers"
+    (assert= false (string-buffer? "hello"))
+    (assert= false (string-buffer? 42))
+    (assert= false (string-buffer? nil))
+    (assert= false (string-buffer? (list)))
+    (assert= false (string-buffer? {:key "val"})))
+  (deftest
+    "type-of returns string-buffer"
+    (assert= "string-buffer" (type-of (make-string-buffer))))
+  (deftest
+    "empty buffer converts to empty string"
+    (let
+      ((buf (make-string-buffer)))
+      (assert= "" (string-buffer->string buf))))
+  (deftest
+    "empty buffer has length zero"
+    (let
+      ((buf (make-string-buffer)))
+      (assert= 0 (string-buffer-length buf))))
+  (deftest
+    "single append accumulates string"
+    (let
+      ((buf (make-string-buffer)))
+      (string-buffer-append! buf "hello")
+      (assert= "hello" (string-buffer->string buf))))
+  (deftest
+    "multiple appends join in order"
+    (let
+      ((buf (make-string-buffer)))
+      (string-buffer-append! buf "foo")
+      (string-buffer-append! buf "bar")
+      (string-buffer-append! buf "baz")
+      (assert= "foobarbaz" (string-buffer->string buf))))
+  (deftest
+    "length tracks total bytes appended"
+    (let
+      ((buf (make-string-buffer)))
+      (string-buffer-append! buf "abc")
+      (string-buffer-append! buf "de")
+      (assert= 5 (string-buffer-length buf))))
+  (deftest
+    "append returns nil"
+    (let
+      ((buf (make-string-buffer)))
+      (assert= nil (string-buffer-append! buf "x"))))
+  (deftest
+    "appending empty string is harmless"
+    (let
+      ((buf (make-string-buffer)))
+      (string-buffer-append! buf "start")
+      (string-buffer-append! buf "")
+      (string-buffer-append! buf "end")
+      (assert= "startend" (string-buffer->string buf))
+      (assert= 8 (string-buffer-length buf))))
+  (deftest
+    "buffer is still usable after string-buffer->string"
+    (let
+      ((buf (make-string-buffer)))
+      (string-buffer-append! buf "hello")
+      (string-buffer->string buf)
+      (string-buffer-append! buf " world")
+      (assert= "hello world" (string-buffer->string buf))))
+  (deftest
+    "two buffers are independent"
+    (let
+      ((b1 (make-string-buffer)) (b2 (make-string-buffer)))
+      (string-buffer-append! b1 "one")
+      (string-buffer-append! b2 "two")
+      (string-buffer-append! b1 "ONE")
+      (assert= "oneONE" (string-buffer->string b1))
+      (assert= "two" (string-buffer->string b2))))
+  (deftest
+    "loop building — linear string concat"
+    (let
+      ((buf (make-string-buffer)))
+      (let
+        loop
+        ((i 0))
+        (when
+          (< i 5)
+          (string-buffer-append! buf (str i))
+          (loop (+ i 1))))
+      (assert= "01234" (string-buffer->string buf))
+      (assert= 5 (string-buffer-length buf))))
+  (deftest
+    "building CSV row with separator"
+    (let
+      ((buf (make-string-buffer)) (items (list "a" "b" "c" "d")))
+      (let
+        loop
+        ((remaining items) (is-first true))
+        (when
+          (not (empty? remaining))
+          (when (not is-first) (string-buffer-append! buf ","))
+          (string-buffer-append! buf (first remaining))
+          (loop (rest remaining) false)))
+      (assert= "a,b,c,d" (string-buffer->string buf))))
+  (deftest
+    "unicode characters accumulate correctly"
+    (let
+      ((buf (make-string-buffer)))
+      (string-buffer-append! buf "こんにちは")
+      (string-buffer-append! buf " ")
+      (string-buffer-append! buf "世界")
+      (assert= "こんにちは 世界" (string-buffer->string buf))))
+  (deftest
+    "repeated to-string calls are consistent"
+    (let
+      ((buf (make-string-buffer)))
+      (string-buffer-append! buf "test")
+      (assert= (string-buffer->string buf) (string-buffer->string buf))))
+  (deftest
+    "building with join pattern produces correct output"
+    (let
+      ((buf (make-string-buffer))
+        (words (list "the" "quick" "brown" "fox")))
+      (let
+        loop
+        ((remaining words) (sep ""))
+        (when
+          (not (empty? remaining))
+          (string-buffer-append! buf sep)
+          (string-buffer-append! buf (first remaining))
+          (loop (rest remaining) " ")))
+      (assert= "the quick brown fox" (string-buffer->string buf)))))

spec/tests/test-vectors.sx

@@ -0,0 +1,207 @@
+;; test-vectors.sx — Tests for vector primitives
+
+(defsuite
+  "vectors"
+  (deftest
+    "make-vector default fill is nil"
+    (let
+      ((v (make-vector 3)))
+      (assert (vector? v))
+      (assert-equal 3 (vector-length v))
+      (assert-equal nil (vector-ref v 0))
+      (assert-equal nil (vector-ref v 1))
+      (assert-equal nil (vector-ref v 2))))
+  (deftest
+    "make-vector with fill value"
+    (let
+      ((v (make-vector 4 99)))
+      (assert-equal 4 (vector-length v))
+      (assert-equal 99 (vector-ref v 0))
+      (assert-equal 99 (vector-ref v 1))
+      (assert-equal 99 (vector-ref v 2))
+      (assert-equal 99 (vector-ref v 3))))
+  (deftest
+    "make-vector size zero"
+    (let ((v (make-vector 0))) (assert-equal 0 (vector-length v))))
+  (deftest
+    "make-vector size one"
+    (let
+      ((v (make-vector 1 "x")))
+      (assert-equal 1 (vector-length v))
+      (assert-equal "x" (vector-ref v 0))))
+  (deftest
+    "vector constructor no args"
+    (let ((v (vector))) (assert-equal 0 (vector-length v))))
+  (deftest
+    "vector constructor with args"
+    (let
+      ((v (vector 10 20 30)))
+      (assert-equal 3 (vector-length v))
+      (assert-equal 10 (vector-ref v 0))
+      (assert-equal 20 (vector-ref v 1))
+      (assert-equal 30 (vector-ref v 2))))
+  (deftest
+    "vector constructor strings"
+    (let
+      ((v (vector "a" "b" "c")))
+      (assert-equal "a" (vector-ref v 0))
+      (assert-equal "b" (vector-ref v 1))
+      (assert-equal "c" (vector-ref v 2))))
+  (deftest "vector? true for vector" (assert (vector? (make-vector 3))))
+  (deftest "vector? false for list" (assert (not (vector? (list 1 2 3)))))
+  (deftest "vector? false for number" (assert (not (vector? 42))))
+  (deftest "vector? false for nil" (assert (not (vector? nil))))
+  (deftest "vector? false for string" (assert (not (vector? "hello"))))
+  (deftest "vector-length zero" (assert-equal 0 (vector-length (vector))))
+  (deftest
+    "vector-length three"
+    (assert-equal 3 (vector-length (vector 1 2 3))))
+  (deftest
+    "vector-length after make-vector"
+    (assert-equal 7 (vector-length (make-vector 7 0))))
+  (deftest
+    "vector-ref first element"
+    (assert-equal 1 (vector-ref (vector 1 2 3) 0)))
+  (deftest
+    "vector-ref last element"
+    (assert-equal 3 (vector-ref (vector 1 2 3) 2)))
+  (deftest
+    "vector-ref middle element"
+    (assert-equal 2 (vector-ref (vector 1 2 3) 1)))
+  (deftest
+    "vector-set! mutates in place"
+    (let
+      ((v (vector 1 2 3)))
+      (vector-set! v 1 99)
+      (assert-equal 99 (vector-ref v 1))
+      (assert-equal 1 (vector-ref v 0))
+      (assert-equal 3 (vector-ref v 2))))
+  (deftest
+    "vector-set! first slot"
+    (let
+      ((v (make-vector 3 0)))
+      (vector-set! v 0 42)
+      (assert-equal 42 (vector-ref v 0))))
+  (deftest
+    "vector-set! last slot"
+    (let
+      ((v (make-vector 3 0)))
+      (vector-set! v 2 77)
+      (assert-equal 77 (vector-ref v 2))))
+  (deftest
+    "vector-set! returns nil"
+    (let ((v (make-vector 3 0))) (assert-equal nil (vector-set! v 0 1))))
+  (deftest
+    "vector->list empty"
+    (assert-equal (list) (vector->list (vector))))
+  (deftest
+    "vector->list numbers"
+    (assert-equal (list 1 2 3) (vector->list (vector 1 2 3))))
+  (deftest
+    "vector->list strings"
+    (assert-equal (list "a" "b") (vector->list (vector "a" "b"))))
+  (deftest
+    "list->vector empty"
+    (let ((v (list->vector (list)))) (assert-equal 0 (vector-length v))))
+  (deftest
+    "list->vector numbers"
+    (let
+      ((v (list->vector (list 10 20 30))))
+      (assert-equal 3 (vector-length v))
+      (assert-equal 10 (vector-ref v 0))
+      (assert-equal 20 (vector-ref v 1))
+      (assert-equal 30 (vector-ref v 2))))
+  (deftest
+    "vector-fill! sets all elements"
+    (let
+      ((v (vector 1 2 3)))
+      (vector-fill! v 0)
+      (assert-equal 0 (vector-ref v 0))
+      (assert-equal 0 (vector-ref v 1))
+      (assert-equal 0 (vector-ref v 2))))
+  (deftest
+    "vector-fill! returns nil"
+    (assert-equal nil (vector-fill! (make-vector 2 0) 7)))
+  (deftest
+    "vector-fill! string fill"
+    (let
+      ((v (make-vector 3 "")))
+      (vector-fill! v "x")
+      (assert-equal "x" (vector-ref v 0))
+      (assert-equal "x" (vector-ref v 2))))
+  (deftest
+    "vector-copy full copy"
+    (let
+      ((v1 (vector 1 2 3)) (v2 (vector-copy (vector 1 2 3))))
+      (assert-equal 3 (vector-length v2))
+      (assert-equal 1 (vector-ref v2 0))
+      (assert-equal 2 (vector-ref v2 1))
+      (assert-equal 3 (vector-ref v2 2))))
+  (deftest
+    "vector-copy is independent"
+    (let
+      ((v1 (vector 1 2 3)))
+      (let
+        ((v2 (vector-copy v1)))
+        (vector-set! v1 0 99)
+        (assert-equal 1 (vector-ref v2 0)))))
+  (deftest
+    "vector-copy with start"
+    (let
+      ((v (vector-copy (vector 10 20 30 40) 1)))
+      (assert-equal 3 (vector-length v))
+      (assert-equal 20 (vector-ref v 0))
+      (assert-equal 30 (vector-ref v 1))
+      (assert-equal 40 (vector-ref v 2))))
+  (deftest
+    "vector-copy with start and end"
+    (let
+      ((v (vector-copy (vector 10 20 30 40) 1 3)))
+      (assert-equal 2 (vector-length v))
+      (assert-equal 20 (vector-ref v 0))
+      (assert-equal 30 (vector-ref v 1))))
+  (deftest
+    "vector-copy empty slice"
+    (let
+      ((v (vector-copy (vector 1 2 3) 1 1)))
+      (assert-equal 0 (vector-length v))))
+  (deftest
+    "vector-ref out of bounds raises"
+    (let
+      ((ok false))
+      (guard (exn (else (set! ok true))) (vector-ref (vector 1 2 3) 5))
+      (assert ok)))
+  (deftest
+    "vector-ref negative index raises"
+    (let
+      ((ok false))
+      (guard (exn (else (set! ok true))) (vector-ref (vector 1 2 3) -1))
+      (assert ok)))
+  (deftest
+    "vector-set! out of bounds raises"
+    (let
+      ((ok false))
+      (guard
+        (exn (else (set! ok true)))
+        (vector-set! (vector 1 2 3) 10 99))
+      (assert ok)))
+  (deftest
+    "vector list round-trip"
+    (let
+      ((lst (list 5 10 15 20)))
+      (assert-equal lst (vector->list (list->vector lst)))))
+  (deftest
+    "vector mutation does not affect copy"
+    (let
+      ((v1 (vector 1 2 3)))
+      (let
+        ((v2 (vector-copy v1)))
+        (vector-set! v2 0 100)
+        (assert-equal 1 (vector-ref v1 0))
+        (assert-equal 100 (vector-ref v2 0)))))
+  (deftest
+    "vector-length after fill"
+    (let
+      ((v (make-vector 5 0)))
+      (vector-fill! v 1)
+      (assert-equal 5 (vector-length v)))))