Level 2-3: lake morphing — server content flows through reactive islands

Lake tag (lake :id "name" children...) creates server-morphable slots
within islands. During morph, the engine enters hydrated islands and
updates data-sx-lake elements by ID while preserving surrounding
reactive DOM (signals, effects, event listeners).

Specced in .sx, bootstrapped to JS and Python:
- adapter-dom.sx: render-dom-lake, reactive-attr marks data-sx-reactive-attrs
- adapter-html.sx: render-html-lake SSR output
- adapter-sx.sx: lake serialized in wire format
- engine.sx: morph-island-children (lake-by-ID matching),
  sync-attrs skips reactive attributes
- ~sx-header uses lakes for logo and copyright
- Hegelian essay updated with lake code example

Also includes: lambda nil-padding for missing args, page env ordering fix

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

shared/sx/ref/adapter-dom.sx

@@ -77,6 +77,10 @@
               (= name "<>")
                 (render-dom-fragment args env ns)
 
+              ;; lake — server-morphable slot within an island
+              (= name "lake")
+                (render-dom-lake args env ns)
+
               ;; html: prefix → force element rendering
               (starts-with? name "html:")
                 (render-dom-element (slice name 5) args env ns)
@@ -649,6 +653,50 @@
             container))))))
 
 
+;; --------------------------------------------------------------------------
+;; render-dom-lake — server-morphable slot within an island
+;; --------------------------------------------------------------------------
+;;
+;; (lake :id "name" children...)
+;;
+;; Renders as <div data-sx-lake="name">children</div>.
+;; During morph, the server can replace lake content while the surrounding
+;; reactive island DOM is preserved. This is the "water around the rocks" —
+;; server substance flowing through client territory.
+;;
+;; Supports :tag keyword to change wrapper element (default "div").
+
+(define render-dom-lake
+  (fn (args env ns)
+    (let ((lake-id nil)
+          (lake-tag "div")
+          (children (list)))
+      (reduce
+        (fn (state arg)
+          (let ((skip (get state "skip")))
+            (if skip
+              (assoc state "skip" false "i" (inc (get state "i")))
+              (if (and (= (type-of arg) "keyword")
+                       (< (inc (get state "i")) (len args)))
+                (let ((kname (keyword-name arg))
+                      (kval (trampoline (eval-expr (nth args (inc (get state "i"))) env))))
+                  (cond
+                    (= kname "id")  (set! lake-id kval)
+                    (= kname "tag") (set! lake-tag kval))
+                  (assoc state "skip" true "i" (inc (get state "i"))))
+                (do
+                  (append! children arg)
+                  (assoc state "i" (inc (get state "i"))))))))
+        (dict "i" 0 "skip" false)
+        args)
+      (let ((el (dom-create-element lake-tag nil)))
+        (dom-set-attr el "data-sx-lake" (or lake-id ""))
+        (for-each
+          (fn (c) (dom-append el (render-to-dom c env ns)))
+          children)
+        el))))
+
+
 ;; --------------------------------------------------------------------------
 ;; Reactive DOM rendering helpers
 ;; --------------------------------------------------------------------------
@@ -668,8 +716,14 @@
 
 ;; reactive-attr — bind an element attribute to a signal expression
 ;; Used when an attribute value contains (deref sig) inside an island.
+;; Marks the attribute name on the element via data-sx-reactive-attrs so
+;; the morph algorithm knows not to overwrite it with server content.
 (define reactive-attr
   (fn (el attr-name compute-fn)
+    ;; Mark this attribute as reactively managed
+    (let ((existing (or (dom-get-attr el "data-sx-reactive-attrs") ""))
+          (updated (if (empty? existing) attr-name (str existing "," attr-name))))
+      (dom-set-attr el "data-sx-reactive-attrs" updated))
     (effect (fn ()
       (let ((val (compute-fn)))
         (cond

shared/sx/ref/adapter-html.sx

@@ -81,6 +81,10 @@
               (= name "raw!")
                 (join "" (map (fn (x) (str (trampoline (eval-expr x env)))) args))
 
+              ;; Lake — server-morphable slot within an island
+              (= name "lake")
+                (render-html-lake args env)
+
               ;; HTML tag
               (contains? HTML_TAGS name)
                 (render-html-element name args env)
@@ -293,6 +297,43 @@
             "</" tag ">"))))))
 
 
+;; --------------------------------------------------------------------------
+;; render-html-lake — SSR rendering of a server-morphable slot
+;; --------------------------------------------------------------------------
+;;
+;; (lake :id "name" children...) → <div data-sx-lake="name">children</div>
+;;
+;; Lakes are server territory inside islands. The morph can update lake
+;; content while preserving surrounding reactive DOM.
+
+(define render-html-lake
+  (fn (args env)
+    (let ((lake-id nil)
+          (lake-tag "div")
+          (children (list)))
+      (reduce
+        (fn (state arg)
+          (let ((skip (get state "skip")))
+            (if skip
+              (assoc state "skip" false "i" (inc (get state "i")))
+              (if (and (= (type-of arg) "keyword")
+                       (< (inc (get state "i")) (len args)))
+                (let ((kname (keyword-name arg))
+                      (kval (trampoline (eval-expr (nth args (inc (get state "i"))) env))))
+                  (cond
+                    (= kname "id")  (set! lake-id kval)
+                    (= kname "tag") (set! lake-tag kval))
+                  (assoc state "skip" true "i" (inc (get state "i"))))
+                (do
+                  (append! children arg)
+                  (assoc state "i" (inc (get state "i"))))))))
+        (dict "i" 0 "skip" false)
+        args)
+      (str "<" lake-tag " data-sx-lake=\"" (escape-attr (or lake-id "")) "\">"
+           (join "" (map (fn (c) (render-to-html c env)) children))
+           "</" lake-tag ">"))))
+
+
 ;; --------------------------------------------------------------------------
 ;; render-html-island — SSR rendering of a reactive island
 ;; --------------------------------------------------------------------------

shared/sx/ref/adapter-sx.sx

@@ -66,6 +66,10 @@
             (starts-with? name "~")
               (aser-call name args env)
 
+            ;; Lake — serialize (server-morphable slot)
+            (= name "lake")
+              (aser-call name args env)
+
             ;; HTML tag — serialize
             (contains? HTML_TAGS name)
               (aser-call name args env)

shared/sx/ref/engine.sx

@@ -338,15 +338,17 @@
           (dom-has-attr? old-node "sx-ignore"))
         nil
 
-      ;; Hydrated island → preserve reactive state across server swaps.
+      ;; Hydrated island → preserve reactive state, morph lakes.
       ;; If old and new are the same island (by name), keep the old DOM
       ;; with its live signals, effects, and event listeners intact.
+      ;; But recurse into data-sx-lake slots so the server can update
+      ;; non-reactive content within the island.
       (and (dom-has-attr? old-node "data-sx-island")
            (is-processed? old-node "island-hydrated")
            (dom-has-attr? new-node "data-sx-island")
            (= (dom-get-attr old-node "data-sx-island")
               (dom-get-attr new-node "data-sx-island")))
-        nil
+        (morph-island-children old-node new-node)
 
       ;; Different node type or tag → replace wholesale
       (or (not (= (dom-node-type old-node) (dom-node-type new-node)))
@@ -371,19 +373,29 @@
 
 (define sync-attrs
   (fn (old-el new-el)
-    ;; Add/update attributes from new, remove those not in new
-    (for-each
-      (fn (attr)
-        (let ((name (first attr))
-              (val  (nth attr 1)))
-          (when (not (= (dom-get-attr old-el name) val))
-            (dom-set-attr old-el name val))))
-      (dom-attr-list new-el))
-    (for-each
-      (fn (attr)
-        (when (not (dom-has-attr? new-el (first attr)))
-          (dom-remove-attr old-el (first attr))))
-      (dom-attr-list old-el))))
+    ;; Sync attributes from new to old, but skip reactively managed attrs.
+    ;; data-sx-reactive-attrs="style,class" means those attrs are owned by
+    ;; signal effects and must not be overwritten by the morph.
+    (let ((ra-str (or (dom-get-attr old-el "data-sx-reactive-attrs") ""))
+          (reactive-attrs (if (empty? ra-str) (list) (split ra-str ","))))
+      ;; Add/update attributes from new, skip reactive ones
+      (for-each
+        (fn (attr)
+          (let ((name (first attr))
+                (val  (nth attr 1)))
+            (when (and (not (= (dom-get-attr old-el name) val))
+                       (not (contains? reactive-attrs name)))
+              (dom-set-attr old-el name val))))
+        (dom-attr-list new-el))
+      ;; Remove attributes not in new, skip reactive + marker attrs
+      (for-each
+        (fn (attr)
+          (let ((aname (first attr)))
+            (when (and (not (dom-has-attr? new-el aname))
+                       (not (contains? reactive-attrs aname))
+                       (not (= aname "data-sx-reactive-attrs")))
+              (dom-remove-attr old-el aname))))
+        (dom-attr-list old-el)))))
 
 
 (define morph-children
@@ -445,6 +457,44 @@
         (range oi (len old-kids))))))
 
 
+;; --------------------------------------------------------------------------
+;; morph-island-children — deep morph into hydrated islands via lakes
+;; --------------------------------------------------------------------------
+;;
+;; Level 2-3 island morphing: the server can update non-reactive content
+;; within hydrated islands by morphing data-sx-lake slots.
+;;
+;; The island's reactive DOM (signals, effects, event listeners) is preserved.
+;; Only lake slots — explicitly marked server territory — receive new content.
+;;
+;; This is the Hegelian synthesis made concrete:
+;;   - Islands = client subjectivity (reactive state, preserved)
+;;   - Lakes = server substance (content, morphed)
+;;   - The morph = Aufhebung (cancellation/preservation/elevation of both)
+
+(define morph-island-children
+  (fn (old-island new-island)
+    ;; Find all lake slots in both old and new islands
+    (let ((old-lakes (dom-query-all old-island "[data-sx-lake]"))
+          (new-lakes (dom-query-all new-island "[data-sx-lake]")))
+      ;; Build ID→element map for new lakes
+      (let ((new-lake-map (dict)))
+        (for-each
+          (fn (lake)
+            (let ((id (dom-get-attr lake "data-sx-lake")))
+              (when id (dict-set! new-lake-map id lake))))
+          new-lakes)
+        ;; Morph each old lake from its new counterpart
+        (for-each
+          (fn (old-lake)
+            (let ((id (dom-get-attr old-lake "data-sx-lake")))
+              (let ((new-lake (dict-get new-lake-map id)))
+                (when new-lake
+                  (sync-attrs old-lake new-lake)
+                  (morph-children old-lake new-lake)))))
+          old-lakes)))))
+
+
 ;; --------------------------------------------------------------------------
 ;; Swap dispatch
 ;; --------------------------------------------------------------------------

shared/sx/ref/eval.sx

@@ -217,14 +217,18 @@
   (fn (f args caller-env)
     (let ((params (lambda-params f))
           (local  (env-merge (lambda-closure f) caller-env)))
-      (if (!= (len args) (len params))
+      ;; Too many args is an error; too few pads with nil
+      (if (> (len args) (len params))
         (error (str (or (lambda-name f) "lambda")
                     " expects " (len params) " args, got " (len args)))
         (do
-          ;; Bind params
+          ;; Bind params — provided args first, then nil for missing
           (for-each
             (fn (pair) (env-set! local (first pair) (nth pair 1)))
             (zip params args))
+          (for-each
+            (fn (p) (env-set! local p nil))
+            (slice params (len args)))
           ;; Return thunk for TCO
           (make-thunk (lambda-body f) local))))))
 

shared/sx/ref/sx_ref.py

@@ -945,7 +945,7 @@ eval_list = lambda expr, env: (lambda head: (lambda args: (map(lambda x: trampol
 eval_call = lambda head, args, env: (lambda f: (lambda evaluated_args: (apply(f, evaluated_args) if sx_truthy((is_callable(f) if not sx_truthy(is_callable(f)) else ((not sx_truthy(is_lambda(f))) if not sx_truthy((not sx_truthy(is_lambda(f)))) else ((not sx_truthy(is_component(f))) if not sx_truthy((not sx_truthy(is_component(f)))) else (not sx_truthy(is_island(f))))))) else (call_lambda(f, evaluated_args, env) if sx_truthy(is_lambda(f)) else (call_component(f, args, env) if sx_truthy(is_component(f)) else (call_component(f, args, env) if sx_truthy(is_island(f)) else error(sx_str('Not callable: ', inspect(f))))))))(map(lambda a: trampoline(eval_expr(a, env)), args)))(trampoline(eval_expr(head, env)))
 
 # call-lambda
-call_lambda = lambda f, args, caller_env: (lambda params: (lambda local: (error(sx_str((lambda_name(f) if sx_truthy(lambda_name(f)) else 'lambda'), ' expects ', len(params), ' args, got ', len(args))) if sx_truthy((len(args) != len(params))) else _sx_begin(for_each(lambda pair: _sx_dict_set(local, first(pair), nth(pair, 1)), zip(params, args)), make_thunk(lambda_body(f), local))))(env_merge(lambda_closure(f), caller_env)))(lambda_params(f))
+call_lambda = lambda f, args, caller_env: (lambda params: (lambda local: (error(sx_str((lambda_name(f) if sx_truthy(lambda_name(f)) else 'lambda'), ' expects ', len(params), ' args, got ', len(args))) if sx_truthy((len(args) > len(params))) else _sx_begin(for_each(lambda pair: _sx_dict_set(local, first(pair), nth(pair, 1)), zip(params, args)), for_each(lambda p: _sx_dict_set(local, p, NIL), slice(params, len(args))), make_thunk(lambda_body(f), local))))(env_merge(lambda_closure(f), caller_env)))(lambda_params(f))
 
 # call-component
 call_component = lambda comp, raw_args, env: (lambda parsed: (lambda kwargs: (lambda children: (lambda local: _sx_begin(for_each(lambda p: _sx_dict_set(local, p, (dict_get(kwargs, p) if sx_truthy(dict_get(kwargs, p)) else NIL)), component_params(comp)), (_sx_dict_set(local, 'children', children) if sx_truthy(component_has_children(comp)) else NIL), make_thunk(component_body(comp), local)))(env_merge(component_closure(comp), env)))(nth(parsed, 1)))(first(parsed)))(parse_keyword_args(raw_args, env))
@@ -1198,7 +1198,7 @@ RENDER_HTML_FORMS = ['if', 'when', 'cond', 'case', 'let', 'let*', 'begin', 'do',
 is_render_html_form = lambda name: contains_p(RENDER_HTML_FORMS, name)
 
 # render-list-to-html
-render_list_to_html = lambda expr, env: ('' if sx_truthy(empty_p(expr)) else (lambda head: (join('', map(lambda x: render_value_to_html(x, env), expr)) if sx_truthy((not sx_truthy((type_of(head) == 'symbol')))) else (lambda name: (lambda args: (join('', map(lambda x: render_to_html(x, env), args)) if sx_truthy((name == '<>')) else (join('', map(lambda x: sx_str(trampoline(eval_expr(x, env))), args)) if sx_truthy((name == 'raw!')) else (render_html_element(name, args, env) if sx_truthy(contains_p(HTML_TAGS, name)) else (render_html_island(env_get(env, name), args, env) if sx_truthy((starts_with_p(name, '~') if not sx_truthy(starts_with_p(name, '~')) else (env_has(env, name) if not sx_truthy(env_has(env, name)) else is_island(env_get(env, name))))) else ((lambda val: (render_html_component(val, args, env) if sx_truthy(is_component(val)) else (render_to_html(expand_macro(val, args, env), env) if sx_truthy(is_macro(val)) else error(sx_str('Unknown component: ', name)))))(env_get(env, name)) if sx_truthy(starts_with_p(name, '~')) else (dispatch_html_form(name, expr, env) if sx_truthy(is_render_html_form(name)) else (render_to_html(expand_macro(env_get(env, name), args, env), env) if sx_truthy((env_has(env, name) if not sx_truthy(env_has(env, name)) else is_macro(env_get(env, name)))) else render_value_to_html(trampoline(eval_expr(expr, env)), env)))))))))(rest(expr)))(symbol_name(head))))(first(expr)))
+render_list_to_html = lambda expr, env: ('' if sx_truthy(empty_p(expr)) else (lambda head: (join('', map(lambda x: render_value_to_html(x, env), expr)) if sx_truthy((not sx_truthy((type_of(head) == 'symbol')))) else (lambda name: (lambda args: (join('', map(lambda x: render_to_html(x, env), args)) if sx_truthy((name == '<>')) else (join('', map(lambda x: sx_str(trampoline(eval_expr(x, env))), args)) if sx_truthy((name == 'raw!')) else (render_html_lake(args, env) if sx_truthy((name == 'lake')) else (render_html_element(name, args, env) if sx_truthy(contains_p(HTML_TAGS, name)) else (render_html_island(env_get(env, name), args, env) if sx_truthy((starts_with_p(name, '~') if not sx_truthy(starts_with_p(name, '~')) else (env_has(env, name) if not sx_truthy(env_has(env, name)) else is_island(env_get(env, name))))) else ((lambda val: (render_html_component(val, args, env) if sx_truthy(is_component(val)) else (render_to_html(expand_macro(val, args, env), env) if sx_truthy(is_macro(val)) else error(sx_str('Unknown component: ', name)))))(env_get(env, name)) if sx_truthy(starts_with_p(name, '~')) else (dispatch_html_form(name, expr, env) if sx_truthy(is_render_html_form(name)) else (render_to_html(expand_macro(env_get(env, name), args, env), env) if sx_truthy((env_has(env, name) if not sx_truthy(env_has(env, name)) else is_macro(env_get(env, name)))) else render_value_to_html(trampoline(eval_expr(expr, env)), env))))))))))(rest(expr)))(symbol_name(head))))(first(expr)))
 
 # dispatch-html-form
 dispatch_html_form = lambda name, expr, env: ((lambda cond_val: (render_to_html(nth(expr, 2), env) if sx_truthy(cond_val) else (render_to_html(nth(expr, 3), env) if sx_truthy((len(expr) > 3)) else '')))(trampoline(eval_expr(nth(expr, 1), env))) if sx_truthy((name == 'if')) else (('' if sx_truthy((not sx_truthy(trampoline(eval_expr(nth(expr, 1), env))))) else join('', map(lambda i: render_to_html(nth(expr, i), env), range(2, len(expr))))) if sx_truthy((name == 'when')) else ((lambda branch: (render_to_html(branch, env) if sx_truthy(branch) else ''))(eval_cond(rest(expr), env)) if sx_truthy((name == 'cond')) else (render_to_html(trampoline(eval_expr(expr, env)), env) if sx_truthy((name == 'case')) else ((lambda local: join('', map(lambda i: render_to_html(nth(expr, i), local), range(2, len(expr)))))(process_bindings(nth(expr, 1), env)) if sx_truthy(((name == 'let') if sx_truthy((name == 'let')) else (name == 'let*'))) else (join('', map(lambda i: render_to_html(nth(expr, i), env), range(1, len(expr)))) if sx_truthy(((name == 'begin') if sx_truthy((name == 'begin')) else (name == 'do'))) else (_sx_begin(trampoline(eval_expr(expr, env)), '') if sx_truthy(is_definition_form(name)) else ((lambda f: (lambda coll: join('', map(lambda item: (render_lambda_html(f, [item], env) if sx_truthy(is_lambda(f)) else render_to_html(apply(f, [item]), env)), coll)))(trampoline(eval_expr(nth(expr, 2), env))))(trampoline(eval_expr(nth(expr, 1), env))) if sx_truthy((name == 'map')) else ((lambda f: (lambda coll: join('', map_indexed(lambda i, item: (render_lambda_html(f, [i, item], env) if sx_truthy(is_lambda(f)) else render_to_html(apply(f, [i, item]), env)), coll)))(trampoline(eval_expr(nth(expr, 2), env))))(trampoline(eval_expr(nth(expr, 1), env))) if sx_truthy((name == 'map-indexed')) else (render_to_html(trampoline(eval_expr(expr, env)), env) if sx_truthy((name == 'filter')) else ((lambda f: (lambda coll: join('', map(lambda item: (render_lambda_html(f, [item], env) if sx_truthy(is_lambda(f)) else render_to_html(apply(f, [item]), env)), coll)))(trampoline(eval_expr(nth(expr, 2), env))))(trampoline(eval_expr(nth(expr, 1), env))) if sx_truthy((name == 'for-each')) else render_value_to_html(trampoline(eval_expr(expr, env)), env))))))))))))
@@ -1212,8 +1212,17 @@ render_html_component = lambda comp, args, env: (lambda kwargs: (lambda children
 # render-html-element
 render_html_element = lambda tag, args, env: (lambda parsed: (lambda attrs: (lambda children: (lambda is_void: sx_str('<', tag, render_attrs(attrs), (' />' if sx_truthy(is_void) else sx_str('>', join('', map(lambda c: render_to_html(c, env), children)), '</', tag, '>'))))(contains_p(VOID_ELEMENTS, tag)))(nth(parsed, 1)))(first(parsed)))(parse_element_args(args, env))
 
+# render-html-lake
+def render_html_lake(args, env):
+    _cells = {}
+    _cells['lake_id'] = NIL
+    _cells['lake_tag'] = 'div'
+    children = []
+    reduce(lambda state, arg: (lambda skip: (assoc(state, 'skip', False, 'i', (get(state, 'i') + 1)) if sx_truthy(skip) else ((lambda kname: (lambda kval: _sx_begin((_sx_cell_set(_cells, 'lake_id', kval) if sx_truthy((kname == 'id')) else (_sx_cell_set(_cells, 'lake_tag', kval) if sx_truthy((kname == 'tag')) else NIL)), assoc(state, 'skip', True, 'i', (get(state, 'i') + 1))))(trampoline(eval_expr(nth(args, (get(state, 'i') + 1)), env))))(keyword_name(arg)) if sx_truthy(((type_of(arg) == 'keyword') if not sx_truthy((type_of(arg) == 'keyword')) else ((get(state, 'i') + 1) < len(args)))) else _sx_begin(_sx_append(children, arg), assoc(state, 'i', (get(state, 'i') + 1))))))(get(state, 'skip')), {'i': 0, 'skip': False}, args)
+    return sx_str('<', _cells['lake_tag'], ' data-sx-lake="', escape_attr((_cells['lake_id'] if sx_truthy(_cells['lake_id']) else '')), '">', join('', map(lambda c: render_to_html(c, env), children)), '</', _cells['lake_tag'], '>')
+
 # render-html-island
-render_html_island = lambda island, args, env: (lambda kwargs: (lambda children: _sx_begin(reduce(lambda state, arg: (lambda skip: (assoc(state, 'skip', False, 'i', (get(state, 'i') + 1)) if sx_truthy(skip) else ((lambda val: _sx_begin(_sx_dict_set(kwargs, keyword_name(arg), val), assoc(state, 'skip', True, 'i', (get(state, 'i') + 1))))(trampoline(eval_expr(nth(args, (get(state, 'i') + 1)), env))) if sx_truthy(((type_of(arg) == 'keyword') if not sx_truthy((type_of(arg) == 'keyword')) else ((get(state, 'i') + 1) < len(args)))) else _sx_begin(_sx_append(children, arg), assoc(state, 'i', (get(state, 'i') + 1))))))(get(state, 'skip')), {'i': 0, 'skip': False}, args), (lambda local: (lambda island_name: _sx_begin(for_each(lambda p: _sx_dict_set(local, p, (dict_get(kwargs, p) if sx_truthy(dict_has(kwargs, p)) else NIL)), component_params(island)), (_sx_dict_set(local, 'children', make_raw_html(join('', map(lambda c: render_to_html(c, env), children)))) if sx_truthy(component_has_children(island)) else NIL), (lambda body_html: (lambda state_json: sx_str('<div data-sx-island="', escape_attr(island_name), '"', (sx_str(' data-sx-state="', escape_attr(state_json), '"') if sx_truthy(state_json) else ''), '>', body_html, '</div>'))(serialize_island_state(kwargs)))(render_to_html(component_body(island), local))))(component_name(island)))(env_merge(component_closure(island), env))))([]))({})
+render_html_island = lambda island, args, env: (lambda kwargs: (lambda children: _sx_begin(reduce(lambda state, arg: (lambda skip: (assoc(state, 'skip', False, 'i', (get(state, 'i') + 1)) if sx_truthy(skip) else ((lambda val: _sx_begin(_sx_dict_set(kwargs, keyword_name(arg), val), assoc(state, 'skip', True, 'i', (get(state, 'i') + 1))))(trampoline(eval_expr(nth(args, (get(state, 'i') + 1)), env))) if sx_truthy(((type_of(arg) == 'keyword') if not sx_truthy((type_of(arg) == 'keyword')) else ((get(state, 'i') + 1) < len(args)))) else _sx_begin(_sx_append(children, arg), assoc(state, 'i', (get(state, 'i') + 1))))))(get(state, 'skip')), {'i': 0, 'skip': False}, args), (lambda local: (lambda island_name: _sx_begin(for_each(lambda p: _sx_dict_set(local, p, (dict_get(kwargs, p) if sx_truthy(dict_has(kwargs, p)) else NIL)), component_params(island)), (_sx_dict_set(local, 'children', make_raw_html(join('', map(lambda c: render_to_html(c, env), children)))) if sx_truthy(component_has_children(island)) else NIL), (lambda body_html: (lambda state_json: sx_str('<span data-sx-island="', escape_attr(island_name), '"', (sx_str(' data-sx-state="', escape_attr(state_json), '"') if sx_truthy(state_json) else ''), '>', body_html, '</span>'))(serialize_island_state(kwargs)))(render_to_html(component_body(island), local))))(component_name(island)))(env_merge(component_closure(island), env))))([]))({})
 
 # serialize-island-state
 serialize_island_state = lambda kwargs: (NIL if sx_truthy(is_empty_dict(kwargs)) else json_serialize(kwargs))
@@ -1228,7 +1237,7 @@ render_to_sx = lambda expr, env: (lambda result: (result if sx_truthy((type_of(r
 aser = lambda expr, env: _sx_case(type_of(expr), [('number', lambda: expr), ('string', lambda: expr), ('boolean', lambda: expr), ('nil', lambda: NIL), ('symbol', lambda: (lambda name: (env_get(env, name) if sx_truthy(env_has(env, name)) else (get_primitive(name) if sx_truthy(is_primitive(name)) else (True if sx_truthy((name == 'true')) else (False if sx_truthy((name == 'false')) else (NIL if sx_truthy((name == 'nil')) else error(sx_str('Undefined symbol: ', name))))))))(symbol_name(expr))), ('keyword', lambda: keyword_name(expr)), ('list', lambda: ([] if sx_truthy(empty_p(expr)) else aser_list(expr, env))), (None, lambda: expr)])
 
 # aser-list
-aser_list = lambda expr, env: (lambda head: (lambda args: (map(lambda x: aser(x, env), expr) if sx_truthy((not sx_truthy((type_of(head) == 'symbol')))) else (lambda name: (aser_fragment(args, env) if sx_truthy((name == '<>')) else (aser_call(name, args, env) if sx_truthy(starts_with_p(name, '~')) else (aser_call(name, args, env) if sx_truthy(contains_p(HTML_TAGS, name)) else (aser_special(name, expr, env) if sx_truthy((is_special_form(name) if sx_truthy(is_special_form(name)) else is_ho_form(name))) else (aser(expand_macro(env_get(env, name), args, env), env) if sx_truthy((env_has(env, name) if not sx_truthy(env_has(env, name)) else is_macro(env_get(env, name)))) else (lambda f: (lambda evaled_args: (apply(f, evaled_args) if sx_truthy((is_callable(f) if not sx_truthy(is_callable(f)) else ((not sx_truthy(is_lambda(f))) if not sx_truthy((not sx_truthy(is_lambda(f)))) else ((not sx_truthy(is_component(f))) if not sx_truthy((not sx_truthy(is_component(f)))) else (not sx_truthy(is_island(f))))))) else (trampoline(call_lambda(f, evaled_args, env)) if sx_truthy(is_lambda(f)) else (aser_call(sx_str('~', component_name(f)), args, env) if sx_truthy(is_component(f)) else (aser_call(sx_str('~', component_name(f)), args, env) if sx_truthy(is_island(f)) else error(sx_str('Not callable: ', inspect(f))))))))(map(lambda a: trampoline(eval_expr(a, env)), args)))(trampoline(eval_expr(head, env)))))))))(symbol_name(head))))(rest(expr)))(first(expr))
+aser_list = lambda expr, env: (lambda head: (lambda args: (map(lambda x: aser(x, env), expr) if sx_truthy((not sx_truthy((type_of(head) == 'symbol')))) else (lambda name: (aser_fragment(args, env) if sx_truthy((name == '<>')) else (aser_call(name, args, env) if sx_truthy(starts_with_p(name, '~')) else (aser_call(name, args, env) if sx_truthy((name == 'lake')) else (aser_call(name, args, env) if sx_truthy(contains_p(HTML_TAGS, name)) else (aser_special(name, expr, env) if sx_truthy((is_special_form(name) if sx_truthy(is_special_form(name)) else is_ho_form(name))) else (aser(expand_macro(env_get(env, name), args, env), env) if sx_truthy((env_has(env, name) if not sx_truthy(env_has(env, name)) else is_macro(env_get(env, name)))) else (lambda f: (lambda evaled_args: (apply(f, evaled_args) if sx_truthy((is_callable(f) if not sx_truthy(is_callable(f)) else ((not sx_truthy(is_lambda(f))) if not sx_truthy((not sx_truthy(is_lambda(f)))) else ((not sx_truthy(is_component(f))) if not sx_truthy((not sx_truthy(is_component(f)))) else (not sx_truthy(is_island(f))))))) else (trampoline(call_lambda(f, evaled_args, env)) if sx_truthy(is_lambda(f)) else (aser_call(sx_str('~', component_name(f)), args, env) if sx_truthy(is_component(f)) else (aser_call(sx_str('~', component_name(f)), args, env) if sx_truthy(is_island(f)) else error(sx_str('Not callable: ', inspect(f))))))))(map(lambda a: trampoline(eval_expr(a, env)), args)))(trampoline(eval_expr(head, env))))))))))(symbol_name(head))))(rest(expr)))(first(expr))
 
 # aser-fragment
 aser_fragment = lambda children, env: (lambda parts: ('' if sx_truthy(empty_p(parts)) else sx_str('(<> ', join(' ', map(serialize, parts)), ')')))(filter(lambda x: (not sx_truthy(is_nil(x))), map(lambda c: aser(c, env), children)))