Merge branch 'stage' into feat/windows-el-runtime

Resolve el_runtime.c conflict: include both sys/resource.h (from stage)
and el_closesocket POSIX shim (from Windows port) within the #else block.

lang/el-compiler/runtime/el_runtime.c

@@ -46,6 +46,7 @@
 #include <dirent.h>
 #include <errno.h>
 #include <pthread.h>
+#include <sys/resource.h>  /* getrusage — memory guard */
 /* On POSIX, sockets close with the same close() as files; el_platform_win.h supplies the Windows
    variant. Defined here so the socket call sites are identical across platforms. */
 static inline int el_closesocket(int s) { return close(s); }
@@ -1906,6 +1907,83 @@ el_val_t http_serve_v2(el_val_t port, el_val_t handler) {
     return 0;
 }
 
+/* ── http_serve_async — non-blocking HTTP server ─────────────────────────── */
+/* Runs the accept loop in a background pthread, returns immediately so the
+ * calling EL script can continue (e.g. to run an awareness loop).
+ *
+ * El signature: http_serve_async(port, handler) -> Void               */
+
+typedef struct { int sock; } HttpServeAsyncArg;
+
+static void* _http_serve_async_loop(void* raw) {
+    HttpServeAsyncArg* a = (HttpServeAsyncArg*)raw;
+    int sock = a->sock;
+    free(a);
+    while (1) {
+        struct sockaddr_in6 cli;
+        socklen_t clen = sizeof(cli);
+        int cfd = accept(sock, (struct sockaddr*)&cli, &clen);
+        if (cfd < 0) {
+            if (errno == EINTR) continue;
+            perror("accept"); break;
+        }
+        pthread_mutex_lock(&_http_conn_mu);
+        while (_http_conn_active >= HTTP_MAX_CONNS) {
+            pthread_cond_wait(&_http_conn_cv, &_http_conn_mu);
+        }
+        _http_conn_active++;
+        pthread_mutex_unlock(&_http_conn_mu);
+        HttpWorkerArg* arg = malloc(sizeof(HttpWorkerArg));
+        if (!arg) { close(cfd); continue; }
+        arg->fd = cfd;
+        pthread_t tid;
+        if (pthread_create(&tid, NULL, http_worker, arg) != 0) {
+            close(cfd); free(arg);
+            pthread_mutex_lock(&_http_conn_mu);
+            _http_conn_active--;
+            pthread_cond_signal(&_http_conn_cv);
+            pthread_mutex_unlock(&_http_conn_mu);
+            continue;
+        }
+        pthread_detach(tid);
+    }
+    close(sock);
+    return NULL;
+}
+
+void http_serve_async(el_val_t port, el_val_t handler) {
+    const char* hname = EL_CSTR(handler);
+    if (hname && looks_like_string(handler)) {
+        http_set_handler(handler);
+    }
+    int p = (int)port;
+    if (p <= 0 || p > 65535) { fprintf(stderr, "http_serve_async: invalid port %d\n", p); return; }
+    int sock = socket(AF_INET6, SOCK_STREAM, 0);
+    if (sock < 0) { perror("socket"); return; }
+    int yes = 1; int no = 0;
+    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
+    setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &no, sizeof(no));
+    struct sockaddr_in6 addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sin6_family = AF_INET6;
+    addr.sin6_addr = in6addr_any;
+    addr.sin6_port = htons((uint16_t)p);
+    if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+        perror("bind"); close(sock); return;
+    }
+    if (listen(sock, 64) < 0) { perror("listen"); close(sock); return; }
+    fprintf(stderr, "[http] async listening on [::]:%d (dual-stack)\n", p);
+    HttpServeAsyncArg* a = malloc(sizeof(HttpServeAsyncArg));
+    if (!a) { close(sock); return; }
+    a->sock = sock;
+    pthread_t tid;
+    if (pthread_create(&tid, NULL, _http_serve_async_loop, a) != 0) {
+        perror("pthread_create"); free(a); close(sock); return;
+    }
+    pthread_detach(tid);
+    /* Returns immediately — caller can now run awareness_run() or any loop. */
+}
+
 /* Build the response envelope a 4-arg handler can return. We hand-write
  * the JSON so the discriminator key always lands first — the runtime's
  * http_parse_envelope() detects it via prefix match. headers_json must be
@@ -2284,6 +2362,43 @@ el_val_t url_decode(el_val_t sv) {
     return el_wrap_str(out);
 }
 
+/* ── html_raw ────────────────────────────────────────────────────────────────
+ * Identity passthrough for raw HTML template interpolation.
+ * El's {raw(expr)} compiles to html_raw(expr) — the value is output as-is
+ * without any escaping. The caller is responsible for safety.
+ */
+el_val_t html_raw(el_val_t s) {
+    return s;
+}
+
+/* ── html_escape ─────────────────────────────────────────────────────────────
+ * Escape < > " ' & for safe HTML text interpolation.
+ * El's {expr} in HTML templates compiles to html_escape(expr).
+ */
+el_val_t html_escape(el_val_t sv) {
+    const char* src = EL_CSTR(sv);
+    if (!src) return EL_STR("");
+    size_t len = strlen(src);
+    /* Worst case: every byte → 6 chars (&quot;) */
+    char* out = (char*)malloc(len * 6 + 1);
+    if (!out) return sv;
+    el_arena_track(out);
+    char* p = out;
+    for (size_t i = 0; i < len; i++) {
+        unsigned char c = (unsigned char)src[i];
+        switch (c) {
+            case '&':  memcpy(p, "&amp;",  5); p += 5; break;
+            case '<':  memcpy(p, "&lt;",   4); p += 4; break;
+            case '>':  memcpy(p, "&gt;",   4); p += 4; break;
+            case '"':  memcpy(p, "&quot;", 6); p += 6; break;
+            case '\'': memcpy(p, "&#39;",  5); p += 5; break;
+            default:   *p++ = (char)c;          break;
+        }
+    }
+    *p = '\0';
+    return el_wrap_str(out);
+}
+
 /* ── HTML allowlist sanitizer ────────────────────────────────────────────────
  * el_html_sanitize(input, allowlist_json)
  *
@@ -3178,23 +3293,49 @@ static void jb_puts(JsonBuf* b, const char* s) {
 
 static void jb_emit_escaped(JsonBuf* b, const char* s) {
     jb_putc(b, '"');
-    for (; *s; s++) {
-        unsigned char c = (unsigned char)*s;
+    const unsigned char* p = (const unsigned char*)s;
+    while (*p) {
+        unsigned char c = *p;
         switch (c) {
-            case '"':  jb_puts(b, "\\\""); break;
-            case '\\': jb_puts(b, "\\\\"); break;
-            case '\b': jb_puts(b, "\\b");  break;
-            case '\f': jb_puts(b, "\\f");  break;
-            case '\n': jb_puts(b, "\\n");  break;
-            case '\r': jb_puts(b, "\\r");  break;
-            case '\t': jb_puts(b, "\\t");  break;
+            case '"':  jb_puts(b, "\\\""); p++; break;
+            case '\\': jb_puts(b, "\\\\"); p++; break;
+            case '\b': jb_puts(b, "\\b");  p++; break;
+            case '\f': jb_puts(b, "\\f");  p++; break;
+            case '\n': jb_puts(b, "\\n");  p++; break;
+            case '\r': jb_puts(b, "\\r");  p++; break;
+            case '\t': jb_puts(b, "\\t");  p++; break;
             default:
                 if (c < 0x20) {
                     char tmp[8];
                     snprintf(tmp, sizeof(tmp), "\\u%04x", c);
                     jb_puts(b, tmp);
-                } else {
+                    p++;
+                } else if (c < 0x80) {
                     jb_putc(b, (char)c);
+                    p++;
+                } else {
+                    /* Multi-byte UTF-8: validate sequence, pass through if valid,
+                     * escape as \u00xx if the start byte is invalid/orphaned. */
+                    int seq_len = 0;
+                    if      ((c & 0xE0) == 0xC0) seq_len = 2;
+                    else if ((c & 0xF0) == 0xE0) seq_len = 3;
+                    else if ((c & 0xF8) == 0xF0) seq_len = 4;
+                    if (seq_len >= 2) {
+                        int valid = 1;
+                        for (int i = 1; i < seq_len; i++) {
+                            if ((p[i] & 0xC0) != 0x80) { valid = 0; break; }
+                        }
+                        if (valid) {
+                            for (int i = 0; i < seq_len; i++) jb_putc(b, (char)p[i]);
+                            p += seq_len;
+                            break;
+                        }
+                    }
+                    /* Invalid start byte or truncated sequence — escape it */
+                    char tmp[8];
+                    snprintf(tmp, sizeof(tmp), "\\u%04x", c);
+                    jb_puts(b, tmp);
+                    p++;
                 }
                 break;
         }
@@ -5722,6 +5863,50 @@ el_val_t getpid_now(void) {
     return (el_val_t)getpid();
 }
 
+/* el_mem_check — self-terminating memory guard for long-running compiler runs.
+ *
+ * Call this periodically (e.g. after each function compiled) to detect runaway
+ * memory growth before the OS OOM-killer fires. Reads the limit from the env
+ * var ELC_MAX_MEM_MB (default 512 MB). If resident set size exceeds the limit,
+ * prints a diagnostic to stderr and exits with code 1 so the caller (elb or a
+ * CI script) can handle the failure gracefully instead of having the whole
+ * machine go down.
+ *
+ * Platform notes:
+ *   macOS  — ru_maxrss is in bytes.
+ *   Linux  — ru_maxrss is in kilobytes.
+ * We normalise to MB before comparing.
+ *
+ * Returns 0 always (the only non-return path is the exit() branch).
+ */
+el_val_t el_mem_check(void) {
+    /* Read limit from env; default 512 MB. */
+    long limit_mb = 512;
+    const char *env_val = getenv("ELC_MAX_MEM_MB");
+    if (env_val && *env_val) {
+        long v = atol(env_val);
+        if (v > 0) limit_mb = v;
+    }
+
+    struct rusage ru;
+    if (getrusage(RUSAGE_SELF, &ru) != 0) return 0; /* can't read — skip check */
+
+    long rss_mb;
+#if defined(__APPLE__) || defined(__MACH__)
+    /* macOS: ru_maxrss is bytes */
+    rss_mb = (long)(ru.ru_maxrss / (1024L * 1024L));
+#else
+    /* Linux: ru_maxrss is kilobytes */
+    rss_mb = (long)(ru.ru_maxrss / 1024L);
+#endif
+
+    if (rss_mb >= limit_mb) {
+        fprintf(stderr, "elc: memory limit exceeded (%ldMB), aborting\n", limit_mb);
+        exit(1);
+    }
+    return 0;
+}
+
 /* ── args() — command-line argument access ──────────────────────────────────
  * Compiled El programs call args() to get a list of CLI arguments.
  * Call el_runtime_init_args(argc, argv) at the start of C main() to populate.
@@ -5894,6 +6079,14 @@ void el_cgi_init(el_val_t name, el_val_t dharma_id, el_val_t principal,
 #define ENGRAM_LAYER_DOMAIN          2u
 #define ENGRAM_LAYER_IMPRINT         3u
 #define ENGRAM_LAYER_SUIT            4u
+#define ENGRAM_LAYER_ACCUMULATION    5u
+/* New user-facing nodes (memories, knowledge, conversations) are created in the
+ * accumulation layer — the top of the consciousness stack, the engram the user
+ * sees; every layer below shapes behavior but is hidden from the user (Layered
+ * Consciousness architecture, app 64/064,262). ENGRAM_LAYER_DEFAULT stays
+ * core-identity ON PURPOSE: it is the fallback home for LEGACY nodes loaded from
+ * snapshots without a layer_id, so existing data (the originator corpus) is
+ * never migrated out of its established layer. New != legacy. */
 #define ENGRAM_LAYER_DEFAULT         ENGRAM_LAYER_CORE_IDENTITY
 
 /* Pass 3 override floor. Layer 0 nodes that received any background
@@ -6071,6 +6264,20 @@ static void engram_init_layers(EngramStore* g) {
         .transparent = 0,
         .injectable = 1
     };
+    /* Layer 5 — accumulation. The TOP of the consciousness stack: the default
+     * home for all new user-facing nodes. This is the engram the user sees;
+     * every layer below shapes behavior but is hidden from the user. Not
+     * injectable — it is the persistent user accumulation, not a swappable
+     * overlay. transparent=0: its content is surfaced to introspection (it is
+     * the user's own knowledge/memory), unlike the lower behavioral layers. */
+    g->layers[g->layer_count++] = (EngramLayer){
+        .layer_id = ENGRAM_LAYER_ACCUMULATION,
+        .name = el_strdup_persist("accumulation"),
+        .activation_priority = 50,
+        .suppressible = 1,
+        .transparent = 0,
+        .injectable = 0
+    };
 }
 
 static EngramStore* engram_get(void) {
@@ -6185,7 +6392,9 @@ static void engram_grow_edges(void) {
 static char* engram_new_id(void) {
     el_val_t v = uuid_new();
     const char* s = EL_CSTR(v);
-    return el_strdup(s ? s : "");
+    /* Persistent: node ids live in the global store; an arena (el_strdup) id is
+     * freed at el_request_end(), corrupting the node after the creating request. */
+    return el_strdup_persist(s ? s : "");
 }
 
 /* Convert a node into an ElMap of its fields.                            */
@@ -6262,7 +6471,7 @@ el_val_t engram_node(el_val_t content, el_val_t node_type, el_val_t salience) {
     n->last_activated = now;
     n->created_at = now;
     n->updated_at = now;
-    n->layer_id   = ENGRAM_LAYER_DEFAULT;
+    n->layer_id   = ENGRAM_LAYER_ACCUMULATION; /* new user-facing node → top layer */
     g->node_count++;
     return el_wrap_str(el_strdup(n->id));
 }
@@ -6280,12 +6489,17 @@ el_val_t engram_node_full(el_val_t content, el_val_t node_type, el_val_t label,
     const char* lb = EL_CSTR(label);
     const char* ti = EL_CSTR(tier);
     const char* tg = EL_CSTR(tags);
-    n->content   = el_strdup(c ? c : "");
-    n->node_type = el_strdup(nt && *nt ? nt : "Memory");
-    n->label     = el_strdup(lb && *lb ? lb : (c ? engram_first_n_chars(c, 60) : ""));
-    n->tier      = el_strdup(ti && *ti ? ti : "Working");
-    n->tags      = el_strdup(tg ? tg : "");
-    n->metadata  = el_strdup("{}");
+    /* Persistent (el_strdup_persist, NOT el_strdup): these strings are owned by the
+     * persistent global node store. el_strdup tracks into the per-request arena, which
+     * el_request_end() frees when the creating HTTP request completes — leaving the
+     * stored node with dangling pointers (corrupted ids, "saved but never listed").
+     * This is the root cause of the hallucinated/lost-saves class of bugs. */
+    n->content   = el_strdup_persist(c ? c : "");
+    n->node_type = el_strdup_persist(nt && *nt ? nt : "Memory");
+    n->label     = el_strdup_persist(lb && *lb ? lb : (c ? engram_first_n_chars(c, 60) : ""));
+    n->tier      = el_strdup_persist(ti && *ti ? ti : "Working");
+    n->tags      = el_strdup_persist(tg ? tg : "");
+    n->metadata  = el_strdup_persist("{}");
     n->salience    = engram_decode_score(salience);
     n->importance  = engram_decode_score(importance);
     n->confidence  = engram_decode_score(confidence);
@@ -6298,7 +6512,7 @@ el_val_t engram_node_full(el_val_t content, el_val_t node_type, el_val_t label,
     n->last_activated = now;
     n->created_at = now;
     n->updated_at = now;
-    n->layer_id   = ENGRAM_LAYER_DEFAULT;
+    n->layer_id   = ENGRAM_LAYER_ACCUMULATION; /* new user-facing node → top layer */
     g->node_count++;
     return el_wrap_str(el_strdup(n->id));
 }
@@ -7228,13 +7442,28 @@ el_val_t engram_save(el_val_t path) {
         jb_putc(&b, '}');
     }
     jb_puts(&b, "]}");
-    FILE* f = fopen(p, "wb");
-    if (!f) { free(b.buf); return 0; }
+    {
+        struct stat _st;
+        if (stat(p, &_st) == 0 && _st.st_size > 200000 &&
+            (uint64_t)b.len < (uint64_t)_st.st_size / 16) {
+            fprintf(stderr, "[engram_save] REFUSED sparse write: new %zu vs existing %lld (<1/16) protecting %s\n",
+                b.len, (long long)_st.st_size, p);
+            free(b.buf); return 0;
+        }
+    }
+    size_t _plen = strlen(p);
+    char* _tmp = (char*)malloc(_plen + 5);
+    if (!_tmp) { free(b.buf); return 0; }
+    memcpy(_tmp, p, _plen); memcpy(_tmp + _plen, ".tmp", 5);
+    FILE* f = fopen(_tmp, "wb");
+    if (!f) { free(_tmp); free(b.buf); return 0; }
     size_t w = fwrite(b.buf, 1, b.len, f);
-    fclose(f);
-    int ok = (w == b.len);
-    free(b.buf);
-    return ok ? 1 : 0;
+    int wok = (w == b.len);
+    if (wok) { fflush(f); fsync(fileno(f)); }
+    fclose(f); free(b.buf);
+    if (!wok) { unlink(_tmp); free(_tmp); return 0; }
+    if (rename(_tmp, p) != 0) { unlink(_tmp); free(_tmp); return 0; }
+    free(_tmp); return 1;
 }
 
 /* Helper: extract a string field from a JSON object substring. */
@@ -7855,6 +8084,257 @@ el_val_t engram_query_range(el_val_t start_ms_v, el_val_t end_ms_v) {
     return el_wrap_str(b.buf);
 }
 
+/* engram_load_merge — like engram_load but WITHOUT resetting the store.
+ * Reads a JSON snapshot from `path` and adds any nodes/edges not already
+ * present in the in-memory graph. Dedup is by node id (for nodes) and by
+ * (from_id, to_id, relation) tuple (for edges).
+ *
+ * Returns (as an EL int) the count of new nodes added. Embeddings are
+ * intentionally skipped on merged nodes to avoid Ollama delays at runtime;
+ * auto_link_semantic will handle them when nodes are next activated.
+ *
+ * Does not merge layers — the in-process layer registry is authoritative. */
+el_val_t engram_load_merge(el_val_t path) {
+    const char* p = EL_CSTR(path);
+    if (!p || !*p) return 0;
+    FILE* f = fopen(p, "rb");
+    if (!f) return 0;
+    fseek(f, 0, SEEK_END);
+    long sz = ftell(f);
+    rewind(f);
+    if (sz <= 0) { fclose(f); return 0; }
+    char* data = malloc((size_t)sz + 1);
+    if (!data) { fclose(f); return 0; }
+    size_t got = fread(data, 1, (size_t)sz, f);
+    fclose(f);
+    data[got] = '\0';
+
+    EngramStore* g = engram_get();
+    int64_t added_nodes = 0;
+
+    /* Walk nodes array — skip any node whose id already exists */
+    const char* nodes_p = json_find_key(data, "nodes");
+    if (nodes_p) {
+        nodes_p = eg_skip_ws(nodes_p);
+        if (*nodes_p == '[') {
+            nodes_p++;
+            nodes_p = eg_skip_ws(nodes_p);
+            while (*nodes_p && *nodes_p != ']') {
+                if (*nodes_p != '{') { nodes_p++; continue; }
+                const char* end = json_skip_value(nodes_p);
+                size_t n = (size_t)(end - nodes_p);
+                char* obj = malloc(n + 1);
+                memcpy(obj, nodes_p, n); obj[n] = '\0';
+                char* nid = eg_get_str_field(obj, "id");
+                int already = (nid && *nid && engram_find_node(nid) != NULL);
+                free(nid);
+                if (!already) {
+                    engram_grow_nodes();
+                    EngramNode* nn = &g->nodes[g->node_count];
+                    memset(nn, 0, sizeof(*nn));
+                    nn->id        = eg_get_str_field(obj, "id");
+                    nn->content   = eg_get_str_field(obj, "content");
+                    nn->node_type = eg_get_str_field(obj, "node_type");
+                    nn->label     = eg_get_str_field(obj, "label");
+                    nn->tier      = eg_get_str_field(obj, "tier");
+                    nn->tags      = eg_get_str_field(obj, "tags");
+                    nn->metadata  = eg_get_str_field(obj, "metadata");
+                    if (!nn->metadata || !*nn->metadata) { free(nn->metadata); nn->metadata = strdup("{}"); }
+                    nn->salience              = eg_get_num_field(obj, "salience");
+                    nn->importance            = eg_get_num_field(obj, "importance");
+                    nn->confidence            = eg_get_num_field(obj, "confidence");
+                    nn->temporal_decay_rate   = eg_get_num_field(obj, "temporal_decay_rate");
+                    nn->activation_count      = eg_get_int_field(obj, "activation_count");
+                    nn->last_activated        = eg_get_int_field(obj, "last_activated");
+                    nn->created_at            = eg_get_int_field(obj, "created_at");
+                    nn->updated_at            = eg_get_int_field(obj, "updated_at");
+                    nn->background_activation = eg_get_num_field(obj, "background_activation");
+                    nn->working_memory_weight = eg_get_num_field(obj, "working_memory_weight");
+                    if (!isfinite(nn->working_memory_weight) || nn->working_memory_weight < 0.0 || nn->working_memory_weight > 1.0)
+                        nn->working_memory_weight = 0.0; /* clamp corrupt snapshot values */
+                    nn->suppression_count     = (int32_t)eg_get_int_field(obj, "suppression_count");
+                    if (json_find_key(obj, "layer_id")) {
+                        nn->layer_id = (uint32_t)eg_get_int_field(obj, "layer_id");
+                    } else {
+                        nn->layer_id = ENGRAM_LAYER_DEFAULT;
+                    }
+                    g->node_count++;
+                    added_nodes++;
+                }
+                free(obj);
+                nodes_p = end;
+                nodes_p = eg_skip_ws(nodes_p);
+                if (*nodes_p == ',') { nodes_p++; nodes_p = eg_skip_ws(nodes_p); }
+            }
+        }
+    }
+
+    /* Walk edges array — skip if (from_id, to_id, relation) already present */
+    const char* edges_p = json_find_key(data, "edges");
+    if (edges_p) {
+        edges_p = eg_skip_ws(edges_p);
+        if (*edges_p == '[') {
+            edges_p++;
+            edges_p = eg_skip_ws(edges_p);
+            while (*edges_p && *edges_p != ']') {
+                if (*edges_p != '{') { edges_p++; continue; }
+                const char* end = json_skip_value(edges_p);
+                size_t n = (size_t)(end - edges_p);
+                char* obj = malloc(n + 1);
+                memcpy(obj, edges_p, n); obj[n] = '\0';
+                char* efrom = eg_get_str_field(obj, "from_id");
+                char* eto   = eg_get_str_field(obj, "to_id");
+                char* erel  = eg_get_str_field(obj, "relation");
+                /* Check for duplicate by scanning existing edges */
+                int dup = 0;
+                if (efrom && eto && erel) {
+                    for (int64_t ei = 0; ei < g->edge_count; ei++) {
+                        EngramEdge* ex = &g->edges[ei];
+                        if (ex->from_id && ex->to_id && ex->relation &&
+                            strcmp(ex->from_id, efrom) == 0 &&
+                            strcmp(ex->to_id,   eto)   == 0 &&
+                            strcmp(ex->relation, erel)  == 0) {
+                            dup = 1; break;
+                        }
+                    }
+                }
+                if (!dup) {
+                    engram_grow_edges();
+                    EngramEdge* ee = &g->edges[g->edge_count];
+                    memset(ee, 0, sizeof(*ee));
+                    ee->id       = eg_get_str_field(obj, "id");
+                    ee->from_id  = efrom ? efrom : strdup("");
+                    ee->to_id    = eto   ? eto   : strdup("");
+                    ee->relation = erel  ? erel  : strdup("");
+                    ee->metadata = eg_get_str_field(obj, "metadata");
+                    if (!ee->metadata || !*ee->metadata) { free(ee->metadata); ee->metadata = strdup("{}"); }
+                    ee->weight     = eg_get_num_field(obj, "weight");
+                    ee->confidence = eg_get_num_field(obj, "confidence");
+                    ee->created_at = eg_get_int_field(obj, "created_at");
+                    ee->updated_at = eg_get_int_field(obj, "updated_at");
+                    ee->last_fired = eg_get_int_field(obj, "last_fired");
+                    ee->inhibitory = (int)eg_get_int_field(obj, "inhibitory");
+                    if (json_find_key(obj, "layer_id")) {
+                        ee->layer_id = (uint32_t)eg_get_int_field(obj, "layer_id");
+                    } else {
+                        ee->layer_id = ENGRAM_LAYER_DEFAULT;
+                    }
+                    g->edge_count++;
+                    /* NOTE: efrom/eto/erel ownership transferred to ee above */
+                    efrom = NULL; eto = NULL; erel = NULL;
+                } else {
+                    free(efrom); free(eto); free(erel);
+                }
+                free(obj);
+                edges_p = end;
+                edges_p = eg_skip_ws(edges_p);
+                if (*edges_p == ',') { edges_p++; edges_p = eg_skip_ws(edges_p); }
+            }
+        }
+    }
+
+    free(data);
+    return (el_val_t)added_nodes;
+}
+
+el_val_t engram_wm_count(void) {
+    EngramStore* g = engram_get();
+    int64_t count = 0;
+    for (int64_t i = 0; i < g->node_count; i++) {
+        if (g->nodes[i].working_memory_weight > 0.0) count++;
+    }
+    return (el_val_t)count;
+}
+
+/* Average working_memory_weight across all promoted nodes (wm > 0).
+ * Returns the float bit-pattern via el_from_float so EL can use it with
+ * float_to_str / float_gt. Returns 0.0 when no nodes are promoted.
+ * Useful in heartbeat ISEs to distinguish "many weak activations" (sparse
+ * graph, low avg) from "few strong activations" (dense subgraph, high avg).
+ * Added 2026-06-04 self-review for graph health observability. */
+el_val_t engram_wm_avg_weight(void) {
+    EngramStore* g = engram_get();
+    double sum = 0.0;
+    int64_t count = 0;
+    for (int64_t i = 0; i < g->node_count; i++) {
+        double w = g->nodes[i].working_memory_weight;
+        /* Defensive guard: skip any corrupt/out-of-range values so a single
+         * bad snapshot node doesn't produce a garbage average (e.g. 1.77e+234). */
+        if (w > 0.0 && w <= 1.0 && isfinite(w)) { sum += w; count++; }
+    }
+    double avg = (count > 0) ? (sum / (double)count) : 0.0;
+    return el_from_float(avg);
+}
+
+/* engram_wm_top_json — return top N working-memory nodes (by wm weight) as a
+ * compact JSON array for ISE heartbeat reporting.
+ *
+ * Each element: {"label":"...","node_type":"...","tier":"...","wm":0.42}
+ *
+ * Purpose: the heartbeat ISE reports wm_active (count) and wm_avg_weight but
+ * gives zero visibility into WM *composition* — which types/tiers are active.
+ * After long uptime every WM slot is in steady-state decay+re-promotion so
+ * wm_promotion ISEs never fire (they only fire on 0→>0.1 transitions).
+ * This function fills the observability gap by snapshotting the current top-N
+ * WM nodes on every heartbeat. Inserted 2026-06-05 self-review. */
+el_val_t engram_wm_top_json(el_val_t n_v) {
+    int64_t top_n = (int64_t)n_v;
+    if (top_n <= 0) top_n = 10;
+    if (top_n > 50) top_n = 50;
+    EngramStore* g = engram_get();
+
+    /* Collect indices of promoted nodes, excluding monitoring noise.
+     * InternalStateEvent nodes are system-observation artifacts — they reflect
+     * what the daemon is doing, not what it knows. Including them in wm_top
+     * buries real knowledge (Memory, Knowledge, Belief nodes) under a wall of
+     * heartbeat/curiosity ISEs, making the heartbeat ISE useless for diagnosing
+     * WM composition. Filter them out here so wm_top always shows substantive
+     * content. (2026-06-07 self-review) */
+    int64_t* idx = malloc((size_t)(g->node_count + 1) * sizeof(int64_t));
+    if (!idx) return el_wrap_str(el_strdup("[]"));
+    int64_t mc = 0;
+    for (int64_t i = 0; i < g->node_count; i++) {
+        if (g->nodes[i].working_memory_weight > 0.0) {
+            const char* nt = g->nodes[i].node_type;
+            if (nt && strcmp(nt, "InternalStateEvent") == 0) continue;
+            idx[mc++] = i;
+        }
+    }
+
+    /* Insertion-sort descending by wm weight (mc is typically small). */
+    for (int64_t i = 1; i < mc; i++) {
+        int64_t key = idx[i];
+        double  kw  = g->nodes[key].working_memory_weight;
+        int64_t j = i;
+        while (j > 0 && g->nodes[idx[j-1]].working_memory_weight < kw) {
+            idx[j] = idx[j-1]; j--;
+        }
+        idx[j] = key;
+    }
+
+    int64_t emit = mc < top_n ? mc : top_n;
+    JsonBuf b; jb_init(&b);
+    jb_putc(&b, '[');
+    for (int64_t k = 0; k < emit; k++) {
+        EngramNode* n = &g->nodes[idx[k]];
+        if (k > 0) jb_putc(&b, ',');
+        jb_putc(&b, '{');
+        jb_puts(&b, "\"label\":");
+        jb_emit_escaped(&b, n->label     ? n->label     : "");
+        jb_puts(&b, ",\"node_type\":");
+        jb_emit_escaped(&b, n->node_type ? n->node_type : "");
+        jb_puts(&b, ",\"tier\":");
+        jb_emit_escaped(&b, n->tier      ? n->tier      : "");
+        char tmp[48];
+        snprintf(tmp, sizeof(tmp), ",\"wm\":%.3f", n->working_memory_weight);
+        jb_puts(&b, tmp);
+        jb_putc(&b, '}');
+    }
+    free(idx);
+    jb_putc(&b, ']');
+    return el_wrap_str(b.buf);
+}
+
 #ifdef HAVE_CURL
 /* ── DHARMA network ─────────────────────────────────────────────────────────
  * Real implementation. Peers are addressed by `dharma_id` — either bare
@@ -8495,7 +8975,7 @@ static el_val_t llm_provider_request(const char* url, const char* key,
     }
 }
 
-static el_val_t llm_chain_call(const char* system_str, const char* user_str) {
+static el_val_t llm_chain_call(const char* model_pref, const char* system_str, const char* user_str) {
     char url_key[64], key_key[64], fmt_key[64], model_key[64];
     for (int i = 0; i < LLM_MAX_PROVIDERS; i++) {
         snprintf(url_key,   sizeof(url_key),   "NEURON_LLM_%d_URL",    i);
@@ -8508,6 +8988,7 @@ static el_val_t llm_chain_call(const char* system_str, const char* user_str) {
         const char* fmt_s = getenv(fmt_key);
         int fmt = (fmt_s && strcmp(fmt_s, "anthropic") == 0) ? 1 : 0;
         const char* model = getenv(model_key);
+        if (!model || !*model) model = model_pref; /* fall back to the caller-requested model */
         fprintf(stderr, "[llm] trying provider %d (%s)\n", i, url);
         el_val_t result = llm_provider_request(url, key, fmt, model, system_str, user_str);
         const char* t = EL_CSTR(result);
@@ -8518,7 +8999,7 @@ static el_val_t llm_chain_call(const char* system_str, const char* user_str) {
     const char* api_key = getenv("ANTHROPIC_API_KEY");
     if (!api_key || !*api_key) return http_error_json("no LLM providers configured");
     fprintf(stderr, "[llm] using legacy ANTHROPIC_API_KEY fallback\n");
-    return llm_provider_request(LLM_API_URL, api_key, 1, NULL, system_str, user_str);
+    return llm_provider_request(LLM_API_URL, api_key, 1, model_pref, system_str, user_str);
 }
 
 /* Legacy llm_request — kept for backward compat with agentic loop internals */
@@ -8582,14 +9063,16 @@ static el_val_t llm_extract_text(el_val_t resp_val) {
 }
 
 el_val_t llm_call(el_val_t model, el_val_t prompt) {
+    const char* m = EL_CSTR(model);
     const char* u = EL_CSTR(prompt); if (!u) u = "";
-    return llm_chain_call(NULL, u);
+    return llm_chain_call(m, NULL, u);
 }
 
 el_val_t llm_call_system(el_val_t model, el_val_t system_prompt, el_val_t user_prompt) {
+    const char* m = EL_CSTR(model);
     const char* s = EL_CSTR(system_prompt); if (!s) s = "";
     const char* u = EL_CSTR(user_prompt);   if (!u) u = "";
-    return llm_chain_call(s, u);
+    return llm_chain_call(m, s, u);
 }
 
 /* ── Tool registry for llm_call_agentic ─────────────────────────────────── */

lang/el-compiler/runtime/el_runtime.h

@@ -182,6 +182,7 @@ el_val_t  http_set_handler(el_val_t name);
  * existing handlers (e.g. products/web/server.el): it dispatches with
  * (method, path, body), hardcodes 200 OK, and auto-detects content type. */
 el_val_t  http_serve_v2(el_val_t port, el_val_t handler);
+void      http_serve_async(el_val_t port, el_val_t handler);
 el_val_t  http_set_handler_v2(el_val_t name);
 
 /* Build an HTTP response envelope. `headers_json` should be a JSON object
@@ -233,6 +234,8 @@ el_val_t  url_decode(el_val_t s);   /* '+' → space, %XX → byte  */
  *     {"p":[],"a":["href","title"],"strong":[],...}
  * where each value is the array of attribute names allowed for that tag. */
 el_val_t  el_html_sanitize(el_val_t input_html, el_val_t allowlist_json);
+el_val_t  html_raw(el_val_t s);
+el_val_t  html_escape(el_val_t s);
 
 /* ── Filesystem ──────────────────────────────────────────────────────────── */
 
@@ -537,6 +540,12 @@ el_val_t  parse_int(el_val_t s, el_val_t default_val);
 el_val_t  exit_program(el_val_t code);
 el_val_t  getpid_now(void);
 
+/* Self-terminating memory guard. Reads ELC_MAX_MEM_MB (default 512) and
+ * exits with code 1 if resident memory exceeds the limit. Call periodically
+ * during long compilation loops (e.g. after each function is compiled).
+ * Returns 0 when memory is within bounds.                                   */
+el_val_t  el_mem_check(void);
+
 /* ── CGI identity ─────────────────────────────────────────────────────────────
  * Called at the start of main() in CGI programs (those with a `cgi {}` block).
  * Records the program's DHARMA identity before any other code executes.      */
@@ -636,6 +645,12 @@ el_val_t  engram_list_layers_json(void);
  * no nodes promoted to working memory. */
 el_val_t  engram_compile_layered_json(el_val_t intent, el_val_t depth);
 
+/* ── Working memory ──────────────────────────────────────────────────────────*/
+el_val_t  engram_wm_count(void);
+el_val_t  engram_wm_avg_weight(void);
+el_val_t  engram_wm_top_json(el_val_t n);
+el_val_t  engram_load_merge(el_val_t path);
+
 /* ── LLM (Anthropic API client) ─────────────────────────────────────────────
  * All functions call https://api.anthropic.com/v1/messages with the API key
  * from env ANTHROPIC_API_KEY. Default model when empty: claude-sonnet-4-5. */

lang/el-compiler/src/codegen.el

@@ -324,6 +324,10 @@ fn cg_html_parts(children: [Map<String, Any>], acc_var: String) -> String {
             let each_c: String = cg_html_each(child, acc_var)
             let parts = native_list_append(parts, each_c)
         }
+        if str_eq(html_kind, "HtmlIf") {
+            let if_c: String = cg_html_if(child, acc_var)
+            let parts = native_list_append(parts, if_c)
+        }
         let i = i + 1
     }
     str_join(parts, "")
@@ -413,6 +417,17 @@ fn cg_html_each(node: Map<String, Any>, acc_var: String) -> String {
     "{ el_val_t " + list_var + " = (" + list_c + "); el_val_t " + len_var + " = el_list_len(" + list_var + "); for (el_val_t " + idx_var + " = 0; " + idx_var + " < " + len_var + "; " + idx_var + "++) { el_val_t " + item_name + " = el_list_get(" + list_var + ", " + idx_var + "); " + inner_c + "} } "
 }
 
+// Generate code for {#if cond} ... {/if} (with optional {#else}).
+fn cg_html_if(node: Map<String, Any>, acc_var: String) -> String {
+    let cond_expr = node["cond"]
+    let then_children: [Map<String, Any>] = node["then"]
+    let else_children: [Map<String, Any>] = node["else"]
+    let cond_c: String = cg_expr(cond_expr)
+    let then_c: String = cg_html_parts(then_children, acc_var)
+    let else_c: String = cg_html_parts(else_children, acc_var)
+    "if (" + cond_c + ") { " + then_c + " } else { " + else_c + " } "
+}
+
 // Top-level HTML template codegen — returns a C statement-expression string.
 fn cg_html_template(expr: Map<String, Any>) -> String {
     let root = expr["root"]
@@ -3715,6 +3730,7 @@ fn codegen_streaming(tokens: [Any], sigs: [Map<String, Any>], source: String) ->
                             cg_fn(stmt)
                             el_release(stmt)
                             el_arena_pop(fn_arena_mark)
+                            el_mem_check()
                         }
                     } else {
                         if is_top_level_decl(stmt) {

lang/el-compiler/src/compiler.el

@@ -287,6 +287,9 @@ fn type_node_to_el(t: Map<String, Any>) -> String {
 
 // emit_header — write a .elh file from parsed statements.
 // Scans for FnDef nodes and emits 'extern fn' declarations.
+// NOTE: This function requires the full AST. Prefer emit_header_from_sigs
+// for the --emit-header path — it works from a token-level scan without
+// building expression ASTs, avoiding OOM on large files.
 fn emit_header(stmts: [Map<String, Any>], hdr_path: String) -> Void {
     let n: Int = native_list_len(stmts)
     let i = 0
@@ -325,6 +328,32 @@ fn emit_header(stmts: [Map<String, Any>], hdr_path: String) -> Void {
     let ok: Bool = fs_write(hdr_path, content)
 }
 
+// emit_header_from_sigs — write a .elh file from pre-scanned El signatures.
+// Uses the output of scan_fn_sigs_el() — no full AST required.
+// Peak memory is O(tokens) rather than O(whole-program AST), which prevents
+// OOM on large files with HTML template bodies or deep BinOp chains.
+fn emit_header_from_sigs(sigs: [Map<String, Any>], hdr_path: String) -> Void {
+    let n: Int = native_list_len(sigs)
+    let i: Int = 0
+    let parts: [String] = native_list_empty()
+    let parts = native_list_append(parts, "// auto-generated by elc --emit-header — do not edit\n")
+    while i < n {
+        let sig = native_list_get(sigs, i)
+        let kind: String = sig["kind"]
+        if str_eq(kind, "fn") {
+            let name: String = sig["name"]
+            let params_el: String = sig["params_el"]
+            let ret_el: String = sig["ret_el"]
+            if str_eq(ret_el, "") { let ret_el = "Any" }
+            let line: String = "extern fn " + name + "(" + params_el + ") -> " + ret_el
+            let parts = native_list_append(parts, line + "\n")
+        }
+        let i = i + 1
+    }
+    let content: String = str_join(parts, "")
+    let ok: Bool = fs_write(hdr_path, content)
+}
+
 // ── Import resolution ────────────────────────────────────────────────────────
 //
 // elc supports two forms of import:
@@ -536,16 +565,20 @@ fn main() -> Void {
 
     let src_path: String = native_list_get(positional, 0)
 
-    // When --emit-header is requested, parse the source file directly
-    // (without inlining imports) and write out a .elh file alongside the .c.
+    // When --emit-header is requested, lex the source file and do a
+    // token-level signature scan (no full AST) to write a .elh file.
+    // This avoids OOM on large files with HTML template bodies or deep
+    // BinOp chains (e.g. checkout.el) — parse() builds O(whole-program AST)
+    // while scan_fn_sigs_el keeps peak memory at O(tokens).
     if do_emit_header {
+        el_mem_check()
         let raw_source: String = fs_read(src_path)
         let hdr_tokens: [Any] = lex(raw_source)
-        let hdr_stmts: [Map<String, Any>] = parse(hdr_tokens)
+        let hdr_sigs: [Map<String, Any>] = scan_fn_sigs_el(hdr_tokens)
         el_release(hdr_tokens)
         let hdr_path: String = str_slice(src_path, 0, str_len(src_path) - 3) + ".elh"
-        emit_header(hdr_stmts, hdr_path)
-        el_release(hdr_stmts)
+        emit_header_from_sigs(hdr_sigs, hdr_path)
+        el_release(hdr_sigs)
     }
 
     let source: String = resolve_imports(src_path)

lang/el-compiler/src/parser.el

@@ -293,6 +293,48 @@ fn is_void_element(name: String) -> Bool {
     false
 }
 
+// Collect all tokens as raw text until </tag_name> is encountered.
+// Used for <style> and <script> elements to avoid parsing CSS/JS as El.
+// Returns { "text": "...", "pos": p_after_closing_tag }
+fn parse_raw_text_content(tokens: [Any], pos: Int, tag_name: String) -> Map<String, Any> {
+    let parts: [String] = native_list_empty()
+    let p = pos
+    let running = true
+    while running {
+        let k = tok_kind(tokens, p)
+        if str_eq(k, "Eof") {
+            let running = false
+        } else {
+            if str_eq(k, "Lt") {
+                let k2 = tok_kind(tokens, p + 1)
+                if str_eq(k2, "Slash") {
+                    // Check if this is </tag_name>
+                    let close_name = tok_value(tokens, p + 2)
+                    if str_eq(close_name, tag_name) {
+                        // consume </tag_name>
+                        let p = p + 3
+                        let p = expect(tokens, p, "Gt")
+                        let running = false
+                    } else {
+                        let v = tok_value(tokens, p)
+                        let parts = native_list_append(parts, v)
+                        let p = p + 1
+                    }
+                } else {
+                    let v = tok_value(tokens, p)
+                    let parts = native_list_append(parts, v)
+                    let p = p + 1
+                }
+            } else {
+                let v = tok_value(tokens, p)
+                let parts = native_list_append(parts, v)
+                let p = p + 1
+            }
+        }
+    }
+    { "text": str_join(parts, ""), "pos": p }
+}
+
 // Collect tokens as text content until we hit Lt, LBrace, Eof, or a
 // closing-tag marker (Lt Slash). Returns { "text": "...", "pos": p }
 fn parse_html_text_tokens(tokens: [Any], pos: Int) -> Map<String, Any> {
@@ -320,7 +362,7 @@ fn parse_html_text_tokens(tokens: [Any], pos: Int) -> Map<String, Any> {
             }
         }
     }
-    { "text": str_join(parts, " "), "pos": p }
+    { "text": str_join(parts, ""), "pos": p }
 }
 
 // Parse an attribute list: (attrname | attrname="val" | attrname={expr})*
@@ -435,77 +477,125 @@ fn parse_html_children(tokens: [Any], pos: Int, parent_tag: String) -> Map<Strin
                 }
             } else {
                 if str_eq(k, "LBrace") {
-                    // Interpolation: {expr} or {#each ...} or {/each}
+                    // Interpolation: {expr}, {#each ...}, {#if ...}, {#else}, {/each}, {/if}
+                    // Note: '#' (ASCII 35) is skipped by the lexer, so {#each} lexes as
+                    // LBrace Ident:"each" ... and {#if} lexes as LBrace If ... and
+                    // {#else} lexes as LBrace Else RBrace.
                     let k2 = tok_kind(tokens, p + 1)
-                    if str_eq(k2, "Hash") {
-                        // {#each list as item}
-                        let k3_v = tok_value(tokens, p + 2)
-                        if str_eq(k3_v, "each") {
-                            let p = p + 3
-                            // parse list expr up to "as" keyword
+                    if str_eq(k2, "Slash") {
+                        // {/each} or {/if} — end of block, stop
+                        // skip { /
+                        let p = p + 2
+                        // skip the close-tag name token (each, if, etc.)
+                        let p = p + 1
+                        // skip }
+                        let p = expect(tokens, p, "RBrace")
+                        let running = false
+                    } else {
+                        if str_eq(k2, "If") {
+                            // {#if condition} ... {/if}
+                            // Skip { if (2 tokens; '#' was silently skipped by lexer)
+                            let p = p + 2
+                            // Parse condition expression (no block expr)
                             let prev_no_block: String = state_get("__no_block_expr")
                             state_set("__no_block_expr", "1")
-                            let r_list = parse_expr(tokens, p)
+                            let r_cond = parse_expr(tokens, p)
                             state_set("__no_block_expr", prev_no_block)
-                            let list_expr = r_list["node"]
-                            let p = r_list["pos"]
-                            // r_list result map fully consumed — release to free peak heap.
-                            el_release(r_list)
-                            // expect "as"
-                            let p = expect(tokens, p, "As")
-                            // item variable name
-                            let item_name = tok_value(tokens, p)
-                            let p = p + 1
+                            let cond_expr = r_cond["node"]
+                            let p = r_cond["pos"]
+                            el_release(r_cond)
                             // consume closing }
                             let p = expect(tokens, p, "RBrace")
-                            // parse body until {/each}
-                            let r_body = parse_html_each_body(tokens, p)
-                            let body_children = r_body["children"]
-                            let p = r_body["pos"]
-                            // r_body result map fully consumed — release to free peak heap.
-                            el_release(r_body)
-                            let each_node: Map<String, Any> = { "html": "Each", "list": list_expr, "item": item_name, "body": body_children }
-                            let children = native_list_append(children, each_node)
-                        } else {
-                            let p = p + 1
-                        }
-                    } else {
-                        if str_eq(k2, "Slash") {
-                            // {/each} — end of each block, stop
-                            // skip {/each}
-                            let p = p + 2
-                            // skip "each"
-                            let p = p + 1
-                            // skip }
-                            let p = expect(tokens, p, "RBrace")
-                            let running = false
-                        } else {
-                            // regular {expr}
-                            let r = parse_expr(tokens, p + 1)
-                            let interp_val = r["node"]
-                            let p = r["pos"]
-                            // r result map fully consumed — release to free peak heap.
-                            el_release(r)
-                            let p = expect(tokens, p, "RBrace")
-                            // Check if the expr is a call to raw()
-                            let is_raw_call = false
-                            let interp_kind: String = interp_val["expr"]
-                            if str_eq(interp_kind, "Call") {
-                                let fn_node = interp_val["func"]
-                                let fn_kind: String = fn_node["expr"]
-                                if str_eq(fn_kind, "Ident") {
-                                    let fn_name_v: String = fn_node["name"]
-                                    if str_eq(fn_name_v, "raw") {
-                                        let is_raw_call = true
-                                    }
+                            // parse then-children until {#else} or {/if}
+                            let r_then = parse_html_children(tokens, p, "__if_then__")
+                            let then_children = r_then["children"]
+                            let p = r_then["pos"]
+                            el_release(r_then)
+                            // check for {#else} — lexed as LBrace Else RBrace
+                            let else_children: [Map<String, Any>] = native_list_empty()
+                            let ck = tok_kind(tokens, p)
+                            if str_eq(ck, "LBrace") {
+                                let ck2 = tok_kind(tokens, p + 1)
+                                if str_eq(ck2, "Else") {
+                                    // consume { else }
+                                    let p = p + 2
+                                    let p = expect(tokens, p, "RBrace")
+                                    // parse else-children until {/if}
+                                    let r_else = parse_html_children(tokens, p, "__if_else__")
+                                    let else_children = r_else["children"]
+                                    let p = r_else["pos"]
+                                    el_release(r_else)
                                 }
                             }
-                            if is_raw_call {
-                                let raw_args = interp_val["args"]
-                                let raw_inner = native_list_get(raw_args, 0)
-                                let children = native_list_append(children, { "html": "Raw", "value": raw_inner })
+                            let if_node: Map<String, Any> = { "html": "HtmlIf", "cond": cond_expr, "then": then_children, "else": else_children }
+                            let children = native_list_append(children, if_node)
+                        } else {
+                            if str_eq(k2, "Else") {
+                                // {#else} sentinel — lexed as LBrace Else RBrace
+                                // Do NOT consume — leave position for caller ({#if} handler checks for it)
+                                let running = false
                             } else {
-                                let children = native_list_append(children, { "html": "Interp", "value": interp_val })
+                                // Check for {#each list as item} — lexed as LBrace Ident:"each" ...
+                                let k2_v = tok_value(tokens, p + 1)
+                                if str_eq(k2_v, "each") {
+                                    let p = p + 2
+                                    // parse list expr up to "as" keyword
+                                    let prev_no_block: String = state_get("__no_block_expr")
+                                    state_set("__no_block_expr", "1")
+                                    let r_list = parse_expr(tokens, p)
+                                    state_set("__no_block_expr", prev_no_block)
+                                    let list_expr = r_list["node"]
+                                    let p = r_list["pos"]
+                                    // r_list result map fully consumed — release to free peak heap.
+                                    el_release(r_list)
+                                    // expect "as"
+                                    let p = expect(tokens, p, "As")
+                                    // item variable name
+                                    let item_name = tok_value(tokens, p)
+                                    let p = p + 1
+                                    // consume closing }
+                                    let p = expect(tokens, p, "RBrace")
+                                    // parse body until {/each}
+                                    let r_body = parse_html_each_body(tokens, p)
+                                    let body_children = r_body["children"]
+                                    let p = r_body["pos"]
+                                    // r_body result map fully consumed — release to free peak heap.
+                                    el_release(r_body)
+                                    let each_node: Map<String, Any> = { "html": "Each", "list": list_expr, "item": item_name, "body": body_children }
+                                    let children = native_list_append(children, each_node)
+                                } else {
+                                    // regular {expr} — disable map-literal parsing so {fn(a,b)}
+                                    // does not trigger the LBrace→map path inside parse_primary
+                                    let prev_no_block: String = state_get("__no_block_expr")
+                                    state_set("__no_block_expr", "1")
+                                    let r = parse_expr(tokens, p + 1)
+                                    state_set("__no_block_expr", prev_no_block)
+                                    let interp_val = r["node"]
+                                    let p = r["pos"]
+                                    // r result map fully consumed — release to free peak heap.
+                                    el_release(r)
+                                    let p = expect(tokens, p, "RBrace")
+                                    // Check if the expr is a call to raw()
+                                    let is_raw_call = false
+                                    let interp_kind: String = interp_val["expr"]
+                                    if str_eq(interp_kind, "Call") {
+                                        let fn_node = interp_val["func"]
+                                        let fn_kind: String = fn_node["expr"]
+                                        if str_eq(fn_kind, "Ident") {
+                                            let fn_name_v: String = fn_node["name"]
+                                            if str_eq(fn_name_v, "raw") {
+                                                let is_raw_call = true
+                                            }
+                                        }
+                                    }
+                                    if is_raw_call {
+                                        let raw_args = interp_val["args"]
+                                        let raw_inner = native_list_get(raw_args, 0)
+                                        let children = native_list_append(children, { "html": "Raw", "value": raw_inner })
+                                    } else {
+                                        let children = native_list_append(children, { "html": "Interp", "value": interp_val })
+                                    }
+                                }
                             }
                         }
                     }
@@ -565,6 +655,27 @@ fn parse_html_element(tokens: [Any], pos: Int) -> Map<String, Any> {
     if is_void_element(tag_name) {
         return make_result({ "html": "Element", "tag": tag_name, "attrs": attrs, "children": native_list_empty(), "self_closing": true }, p)
     }
+    // raw-text mode for style/script — collect content as plain text without parsing CSS/JS as El
+    if str_eq(tag_name, "style") {
+        let r_raw = parse_raw_text_content(tokens, p, "style")
+        let raw_text: String = r_raw["text"]
+        let p = r_raw["pos"]
+        el_release(r_raw)
+        let raw_child: Map<String, Any> = { "html": "Text", "text": raw_text }
+        let raw_children: [Map<String, Any>] = native_list_empty()
+        let raw_children = native_list_append(raw_children, raw_child)
+        return make_result({ "html": "Element", "tag": tag_name, "attrs": attrs, "children": raw_children, "self_closing": false }, p)
+    }
+    if str_eq(tag_name, "script") {
+        let r_raw = parse_raw_text_content(tokens, p, "script")
+        let raw_text: String = r_raw["text"]
+        let p = r_raw["pos"]
+        el_release(r_raw)
+        let raw_child: Map<String, Any> = { "html": "Text", "text": raw_text }
+        let raw_children: [Map<String, Any>] = native_list_empty()
+        let raw_children = native_list_append(raw_children, raw_child)
+        return make_result({ "html": "Element", "tag": tag_name, "attrs": attrs, "children": raw_children, "self_closing": false }, p)
+    }
     // parse children
     let r_children = parse_html_children(tokens, p, tag_name)
     let children = r_children["children"]
@@ -718,44 +829,123 @@ fn parse_primary(tokens: [Any], pos: Int) -> Map<String, Any> {
             // as the start of the block they're expecting.
             return make_result({ "expr": "Nil" }, pos)
         }
-        let p = pos + 1
-        let pairs: [Map<String, Any>] = native_list_empty()
-        let running = true
-        while running {
-            let k2 = tok_kind(tokens, p)
-            if k2 == "RBrace" {
-                let running = false
-            } else {
-                if k2 == "Eof" {
+        // Distinguish map literal from interpolation chain.
+        // A map literal requires { key: value } — the second token inside { must be Colon.
+        // An empty {} is a map literal.  Everything else is an interpolation chain.
+        let first_k: String = tok_kind(tokens, pos + 1)
+        let second_k: String = tok_kind(tokens, pos + 2)
+        if str_eq(first_k, "RBrace") {
+            // Empty map literal {}
+            return make_result({ "expr": "Map", "pairs": native_list_empty() }, pos + 2)
+        }
+        if str_eq(second_k, "Colon") {
+            // MAP LITERAL: { key: value, ... }
+            let p = pos + 1
+            let pairs: [Map<String, Any>] = native_list_empty()
+            let running = true
+            while running {
+                let k2 = tok_kind(tokens, p)
+                if k2 == "RBrace" {
                     let running = false
                 } else {
-                    // key: Str token
-                    let key = tok_value(tokens, p)
-                    let new_p: Int = p + 1
-                    let new_p = expect(tokens, new_p, "Colon")
-                    let r = parse_expr(tokens, new_p)
-                    let val_node = r["node"]
-                    let new_p = r["pos"]
-                    // r result map fully consumed — release to free peak heap.
-                    el_release(r)
-                    let pair = { "key": key, "value": val_node }
-                    let pairs = native_list_append(pairs, pair)
-                    let k3 = tok_kind(tokens, new_p)
-                    if k3 == "Comma" {
-                        let new_p = new_p + 1
-                    }
-                    // Non-progress guard: malformed map content can leave
-                    // parse_expr returning the same pos. Force advance.
-                    if new_p <= p {
-                        let p = p + 1
+                    if k2 == "Eof" {
+                        let running = false
                     } else {
-                        let p = new_p
+                        // key: Str or Ident token
+                        let key = tok_value(tokens, p)
+                        let new_p: Int = p + 1
+                        let new_p = expect(tokens, new_p, "Colon")
+                        let r = parse_expr(tokens, new_p)
+                        let val_node = r["node"]
+                        let new_p = r["pos"]
+                        // r result map fully consumed — release to free peak heap.
+                        el_release(r)
+                        let pair = { "key": key, "value": val_node }
+                        let pairs = native_list_append(pairs, pair)
+                        let k3 = tok_kind(tokens, new_p)
+                        if k3 == "Comma" {
+                            let new_p = new_p + 1
+                        }
+                        // Non-progress guard: malformed map content can leave
+                        // parse_expr returning the same pos. Force advance.
+                        if new_p <= p {
+                            let p = p + 1
+                        } else {
+                            let p = new_p
+                        }
                     }
                 }
             }
+            let p = expect(tokens, p, "RBrace")
+            return make_result({ "expr": "Map", "pairs": pairs }, p)
         }
-        let p = expect(tokens, p, "RBrace")
-        return make_result({ "expr": "Map", "pairs": pairs }, p)
+        // INTERPOLATION CHAIN: {expr}, {expr}{expr}, {expr}<html>, etc.
+        // Build a BinOp(Plus, ...) concatenation chain.
+        let p = pos
+        let chain_node: Map<String, Any> = { "expr": "Nil" }
+        let chain_started = false
+        let chain_running = true
+        while chain_running {
+            let ck: String = tok_kind(tokens, p)
+            if str_eq(ck, "LBrace") {
+                let prev_no_block: String = state_get("__no_block_expr")
+                state_set("__no_block_expr", "1")
+                let r = parse_expr(tokens, p + 1)
+                state_set("__no_block_expr", prev_no_block)
+                let part = r["node"]
+                let p = r["pos"]
+                // r result map fully consumed — release to free peak heap.
+                el_release(r)
+                let p = expect(tokens, p, "RBrace")
+                if !chain_started {
+                    let chain_node = part
+                    let chain_started = true
+                } else {
+                    let chain_node: Map<String, Any> = { "expr": "BinOp", "op": "Plus", "left": chain_node, "right": part }
+                }
+            } else {
+                if str_eq(ck, "Lt") {
+                    let ck2: String = tok_kind(tokens, p + 1)
+                    if str_eq(ck2, "Not") {
+                        let r = parse_html_template(tokens, p)
+                        let part = r["node"]
+                        let p = r["pos"]
+                        // r result map fully consumed — release to free peak heap.
+                        el_release(r)
+                        if !chain_started {
+                            let chain_node = part
+                            let chain_started = true
+                        } else {
+                            let chain_node: Map<String, Any> = { "expr": "BinOp", "op": "Plus", "left": chain_node, "right": part }
+                        }
+                    } else {
+                        if str_eq(ck2, "Ident") {
+                            let tag_candidate: String = tok_value(tokens, p + 1)
+                            if is_html_tag_name(tag_candidate) {
+                                let r = parse_html_template(tokens, p)
+                                let part = r["node"]
+                                let p = r["pos"]
+                                // r result map fully consumed — release to free peak heap.
+                                el_release(r)
+                                if !chain_started {
+                                    let chain_node = part
+                                    let chain_started = true
+                                } else {
+                                    let chain_node: Map<String, Any> = { "expr": "BinOp", "op": "Plus", "left": chain_node, "right": part }
+                                }
+                            } else {
+                                let chain_running = false
+                            }
+                        } else {
+                            let chain_running = false
+                        }
+                    }
+                } else {
+                    let chain_running = false
+                }
+            }
+        }
+        return make_result(chain_node, p)
     }
 
     // if expression
@@ -1875,6 +2065,219 @@ fn skip_expr_to_stmt_boundary(tokens: [Any], pos: Int) -> Int {
     p
 }
 
+// scan_type_el — read a type annotation starting at pos and return its El
+// source representation as a string, plus the new position.
+// Returns { "el": String, "pos": Int }.
+// Handles: Ident, [Type], Map<K,V>, Type?, Type<T,...> (same shapes as skip_type).
+fn scan_type_el(tokens: [Any], pos: Int) -> Map<String, Any> {
+    let k: String = tok_kind(tokens, pos)
+    // Array type: [Type]
+    if str_eq(k, "LBracket") {
+        let p: Int = pos + 1
+        let inner = scan_type_el(tokens, p)
+        let inner_str: String = inner["el"]
+        let p = inner["pos"]
+        el_release(inner)
+        let p = expect(tokens, p, "RBracket")
+        return { "el": "[" + inner_str + "]", "pos": p }
+    }
+    // Named type (possibly generic or optional)
+    if str_eq(k, "Ident") {
+        let name: String = tok_value(tokens, pos)
+        let p: Int = pos + 1
+        let k2: String = tok_kind(tokens, p)
+        if str_eq(k2, "Lt") {
+            // Generic params: collect until matching >
+            let p = p + 1
+            let depth: Int = 1
+            let parts: [String] = native_list_empty()
+            let parts = native_list_append(parts, name + "<")
+            let running: Bool = true
+            while running {
+                let kk: String = tok_kind(tokens, p)
+                if str_eq(kk, "Eof") {
+                    let running = false
+                } else {
+                    if str_eq(kk, "Lt") {
+                        let depth = depth + 1
+                        let parts = native_list_append(parts, "<")
+                        let p = p + 1
+                    } else {
+                        if str_eq(kk, "Gt") {
+                            let depth = depth - 1
+                            let p = p + 1
+                            if depth <= 0 {
+                                let parts = native_list_append(parts, ">")
+                                let running = false
+                            } else {
+                                let parts = native_list_append(parts, ">")
+                            }
+                        } else {
+                            if str_eq(kk, "Comma") {
+                                let parts = native_list_append(parts, ", ")
+                                let p = p + 1
+                            } else {
+                                let parts = native_list_append(parts, tok_value(tokens, p))
+                                let p = p + 1
+                            }
+                        }
+                    }
+                }
+            }
+            let k3: String = tok_kind(tokens, p)
+            if str_eq(k3, "QuestionMark") { let p = p + 1 }
+            let result: String = str_join(parts, "")
+            el_release(parts)
+            return { "el": result, "pos": p }
+        }
+        // Optional marker
+        if str_eq(k2, "QuestionMark") {
+            return { "el": name + "?", "pos": p + 1 }
+        }
+        return { "el": name, "pos": p }
+    }
+    // Fallback: unknown token, treat as Any
+    { "el": "Any", "pos": pos + 1 }
+}
+
+// scan_params_el — scan a parameter list `(name: Type, ...)` starting at
+// position `pos` (which should point at LParen) and return the El parameter
+// declaration string (e.g. "a: String, b: Int") along with the new position.
+// Returns { "el": String, "pos": Int }.
+// Used by scan_fn_sigs_el for --emit-header without building full AST.
+fn scan_params_el(tokens: [Any], pos: Int) -> Map<String, Any> {
+    let p: Int = expect(tokens, pos, "LParen")
+    let parts: [String] = native_list_empty()
+    let going: Bool = true
+    while going {
+        let kk: String = tok_kind(tokens, p)
+        if str_eq(kk, "RParen") {
+            let going = false
+        } else {
+            if str_eq(kk, "Eof") {
+                let going = false
+            } else {
+                let pname: String = tok_value(tokens, p)
+                let p = p + 1
+                let p = expect(tokens, p, "Colon")
+                let tr = scan_type_el(tokens, p)
+                let ptype: String = tr["el"]
+                let p = tr["pos"]
+                el_release(tr)
+                let parts = native_list_append(parts, pname + ": " + ptype)
+                let k2: String = tok_kind(tokens, p)
+                if str_eq(k2, "Comma") {
+                    let p = p + 1
+                }
+            }
+        }
+    }
+    let p = expect(tokens, p, "RParen")
+    let el_str: String = str_join(parts, ", ")
+    el_release(parts)
+    { "el": el_str, "pos": p }
+}
+
+// scan_fn_sigs_el — lightweight token-level pre-scan for --emit-header.
+//
+// Like scan_fn_sigs but captures El-style type strings instead of C types.
+// Only records fn/extern_fn entries (header generation ignores lets/blocks).
+//
+// Descriptor shape:
+//   { "kind": "fn"|"extern_fn", "name": String,
+//     "params_el": String,   <- El param list, e.g. "a: String, b: Int"
+//     "ret_el": String }     <- El return type, e.g. "String" or "Void"
+//
+// Peak memory: O(tokens) with no expression AST allocation.
+fn scan_fn_sigs_el(tokens: [Any]) -> [Map<String, Any>] {
+    let total: Int = native_list_len(tokens) / 2
+    let sigs: [Map<String, Any>] = native_list_empty()
+    let pos: Int = 0
+    let going: Bool = true
+    while going {
+        if pos >= total {
+            let going = false
+        } else {
+            let k: String = tok_kind(tokens, pos)
+            if str_eq(k, "Eof") {
+                let going = false
+            } else {
+                // --- fn definition ---
+                if str_eq(k, "Fn") {
+                    let p: Int = pos + 1
+                    let name: String = tok_value(tokens, p)
+                    let p = p + 1
+                    let pr = scan_params_el(tokens, p)
+                    let params_el: String = pr["el"]
+                    let p = pr["pos"]
+                    el_release(pr)
+                    // read return type
+                    let ret_el: String = "Any"
+                    let k2: String = tok_kind(tokens, p)
+                    if str_eq(k2, "Arrow") {
+                        let p = p + 1
+                        let tr = scan_type_el(tokens, p)
+                        let ret_el = tr["el"]
+                        let p = tr["pos"]
+                        el_release(tr)
+                    }
+                    // skip body
+                    let k3: String = tok_kind(tokens, p)
+                    if str_eq(k3, "LBrace") {
+                        let p = skip_to_rbrace(tokens, p)
+                    }
+                    if !str_eq(name, "main") {
+                        let sigs = native_list_append(sigs, {
+                            "kind": "fn",
+                            "name": name,
+                            "params_el": params_el,
+                            "ret_el": ret_el
+                        })
+                    }
+                    let pos = p
+                } else {
+                // --- extern fn ---
+                if str_eq(k, "Extern") {
+                    let p: Int = pos + 1
+                    let k2: String = tok_kind(tokens, p)
+                    if str_eq(k2, "Fn") {
+                        let p = p + 1
+                        let name: String = tok_value(tokens, p)
+                        let p = p + 1
+                        let pr = scan_params_el(tokens, p)
+                        let params_el: String = pr["el"]
+                        let p = pr["pos"]
+                        el_release(pr)
+                        let ret_el: String = "Any"
+                        let k3: String = tok_kind(tokens, p)
+                        if str_eq(k3, "Arrow") {
+                            let p = p + 1
+                            let tr = scan_type_el(tokens, p)
+                            let ret_el = tr["el"]
+                            let p = tr["pos"]
+                            el_release(tr)
+                        }
+                        let sigs = native_list_append(sigs, {
+                            "kind": "extern_fn",
+                            "name": name,
+                            "params_el": params_el,
+                            "ret_el": ret_el
+                        })
+                        let pos = p
+                    } else {
+                        let pos = pos + 1
+                    }
+                } else {
+                    // Let, Cgi, Service, Import, Type, Enum, From — skip to boundary.
+                    let p: Int = pos + 1
+                    let p = skip_expr_to_stmt_boundary(tokens, p)
+                    let pos = p
+                }}}
+            }
+        }
+    sigs
+}
+
 // scan_params_c — scan a parameter list `(name: Type, ...)` starting at
 // position `pos` (which should point at LParen) and return the C parameter
 // declaration string along with the new position.