Separate core spec from web framework

Three-layer architecture:
  spec/  — Core language (19 files): evaluator, parser, primitives,
           CEK machine, types, continuations. Host-independent.
  web/   — Web framework (20 files): signals, adapters, engine,
           orchestration, boot, router, CSSX. Built on core spec.
  sx/    — Application (sx-docs website). Built on web framework.

Split boundary.sx into boundary-core.sx (type-of, make-env, identical?)
and boundary-web.sx (IO primitives, signals, spreads, page helpers).

Bootstrappers search spec/ → web/ → shared/sx/ref/ for .sx files.
Original files remain in shared/sx/ref/ as fallback during transition.
All 63 tests pass.

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

spec/render.sx

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