Phase 2: IO detection & selective expansion in deps.sx

Extend the spec with IO scanning functions (scan-io-refs, transitive-io-refs,
compute-all-io-refs, component-pure?) that detect IO primitive references in
component ASTs. Components are classified as pure (no IO deps, safe for client
rendering) or IO-dependent (must expand server-side).

The partial evaluator (_aser) now uses per-component IO metadata instead of
the global _expand_components toggle: IO-dependent components expand server-
side, pure components serialize for client. Layout slot context still expands
all components for backwards compat.

Spec: 5 new functions + 2 platform interface additions in deps.sx
Host: io_refs field + is_pure property on Component, compute_all_io_refs()
Bootstrap: both sx_ref.py and sx-ref.js updated with IO functions
Bundle analyzer: shows pure/IO classification per page

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

shared/sx/ref/deps.sx

@@ -208,6 +208,112 @@
       classes)))
 
 
+;; --------------------------------------------------------------------------
+;; 8. IO detection — scan component ASTs for IO primitive references
+;; --------------------------------------------------------------------------
+;; Extends the dependency walker to detect references to IO primitives.
+;; IO names are provided by the host (from boundary.sx declarations).
+;; A component is "pure" if it (transitively) references no IO primitives.
+;;
+;; Platform interface additions:
+;;   (component-io-refs c)        → cached IO ref list (may be empty)
+;;   (component-set-io-refs! c r) → cache IO refs on component
+
+(define scan-io-refs-walk
+  (fn (node io-names refs)
+    (cond
+      ;; Symbol → check if name is in the IO set
+      (= (type-of node) "symbol")
+        (let ((name (symbol-name node)))
+          (when (contains? io-names name)
+            (when (not (contains? refs name))
+              (append! refs name))))
+
+      ;; List → recurse into all elements
+      (= (type-of node) "list")
+        (for-each (fn (item) (scan-io-refs-walk item io-names refs)) node)
+
+      ;; Dict → recurse into values
+      (= (type-of node) "dict")
+        (for-each (fn (key) (scan-io-refs-walk (dict-get node key) io-names refs))
+                  (keys node))
+
+      ;; Literals → no IO refs
+      :else nil)))
+
+
+(define scan-io-refs
+  (fn (node io-names)
+    (let ((refs (list)))
+      (scan-io-refs-walk node io-names refs)
+      refs)))
+
+
+;; --------------------------------------------------------------------------
+;; 9. Transitive IO refs — follow component deps and union IO refs
+;; --------------------------------------------------------------------------
+
+(define transitive-io-refs-walk
+  (fn (n seen all-refs env io-names)
+    (when (not (contains? seen n))
+      (append! seen n)
+      (let ((val (env-get env n)))
+        (cond
+          (= (type-of val) "component")
+            (do
+              ;; Scan this component's body for IO refs
+              (for-each
+                (fn (ref)
+                  (when (not (contains? all-refs ref))
+                    (append! all-refs ref)))
+                (scan-io-refs (component-body val) io-names))
+              ;; Recurse into component deps
+              (for-each
+                (fn (dep) (transitive-io-refs-walk dep seen all-refs env io-names))
+                (scan-refs (component-body val))))
+
+          (= (type-of val) "macro")
+            (do
+              (for-each
+                (fn (ref)
+                  (when (not (contains? all-refs ref))
+                    (append! all-refs ref)))
+                (scan-io-refs (macro-body val) io-names))
+              (for-each
+                (fn (dep) (transitive-io-refs-walk dep seen all-refs env io-names))
+                (scan-refs (macro-body val))))
+
+          :else nil)))))
+
+
+(define transitive-io-refs
+  (fn (name env io-names)
+    (let ((all-refs (list))
+          (seen (list))
+          (key (if (starts-with? name "~") name (str "~" name))))
+      (transitive-io-refs-walk key seen all-refs env io-names)
+      all-refs)))
+
+
+;; --------------------------------------------------------------------------
+;; 10. Compute IO refs for all components in an environment
+;; --------------------------------------------------------------------------
+
+(define compute-all-io-refs
+  (fn (env io-names)
+    (for-each
+      (fn (name)
+        (let ((val (env-get env name)))
+          (when (= (type-of val) "component")
+            (component-set-io-refs! val (transitive-io-refs name env io-names)))))
+      (env-components env))))
+
+
+(define component-pure?
+  (fn (name env io-names)
+    (empty? (transitive-io-refs name env io-names))))
+
+
 ;; --------------------------------------------------------------------------
 ;; Platform interface summary
 ;; --------------------------------------------------------------------------
@@ -223,6 +329,8 @@
 ;;   (component-deps c)       → cached deps list (may be empty)
 ;;   (component-set-deps! c d)→ cache deps on component
 ;;   (component-css-classes c)→ pre-scanned CSS class list
+;;   (component-io-refs c)       → cached IO ref list (may be empty)
+;;   (component-set-io-refs! c r)→ cache IO refs on component
 ;;   (macro-body m)           → AST body of macro
 ;;   (env-components env)     → list of component names in env
 ;;   (regex-find-all pat src) → list of capture group matches