fix(el-runtime): promote http_handler typedefs to el_runtime.h (cross-module + Windows)

http_handler_fn / http_handler4_fn were defined only inside el_runtime.c, so soul
modules (routes/chat/...) that reference them via cross-module forward declarations
couldn't see the types — which broke the Windows link of every module. Moving the
public function-pointer types to the shared header is the correct home and unblocks
the build on all platforms (identical typedef, C11-safe redefinition in el_runtime.c).

With this, the soul links into a native Windows neuron.exe (mingw, static) that boots
and serves HTTP on :7770 — verified /health → 200 {"status":"alive",...} in a Win11 VM.

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

.gitea/workflows/ci-dev.yaml

@@ -22,10 +22,7 @@ jobs:
       - name: Install build dependencies
         run: |
           apt-get update -qq
-          apt-get install -y gcc libcurl4-openssl-dev apt-transport-https ca-certificates
-          echo "deb [trusted=yes] https://packages.cloud.google.com/apt cloud-sdk main" \
-            > /etc/apt/sources.list.d/google-cloud-sdk.list
-          apt-get update -qq && apt-get install -y google-cloud-cli
+          apt-get install -y gcc libcurl4-openssl-dev
 
       # Seed: use the committed linux-amd64 binary as the bootstrap
       - name: Bootstrap from committed linux binary (seed)
@@ -87,22 +84,13 @@ jobs:
           bash tests/html_sanitizer/run.sh
 
       # Native El test suites (elc --test, compile-link-run)
-      # el_runtime.c is precompiled to .o once and reused by all 8 modules.
-      - name: Precompile el_runtime.o
-        run: |
-          set -euo pipefail
-          RUNTIME="$(pwd)/el-compiler/runtime"
-          gcc -O2 -c -I "$RUNTIME" "$RUNTIME/el_runtime.c" \
-            -o /tmp/el_runtime.o
-          echo "el_runtime.o compiled"
-
       - name: Run tests - native (core)
         run: |
           set -euo pipefail
           ELC="$(pwd)/dist/platform/elc"
           RUNTIME="$(pwd)/el-compiler/runtime"
           "$ELC" --test tests/native/test_core.el > /tmp/el_native_core.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_core.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_core.c "$RUNTIME/el_runtime.c" \
             -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_core
           /tmp/el_native_core
 
@@ -112,7 +100,7 @@ jobs:
           ELC="$(pwd)/dist/platform/elc"
           RUNTIME="$(pwd)/el-compiler/runtime"
           "$ELC" --test tests/native/test_text.el > /tmp/el_native_text.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_text.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_text.c "$RUNTIME/el_runtime.c" \
             -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_text
           /tmp/el_native_text
 
@@ -122,7 +110,7 @@ jobs:
           ELC="$(pwd)/dist/platform/elc"
           RUNTIME="$(pwd)/el-compiler/runtime"
           "$ELC" --test tests/native/test_string.el > /tmp/el_native_string.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_string.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_string.c "$RUNTIME/el_runtime.c" \
             -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_string
           /tmp/el_native_string
 
@@ -132,7 +120,7 @@ jobs:
           ELC="$(pwd)/dist/platform/elc"
           RUNTIME="$(pwd)/el-compiler/runtime"
           "$ELC" --test tests/native/test_math.el > /tmp/el_native_math.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_math.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_math.c "$RUNTIME/el_runtime.c" \
             -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_math
           /tmp/el_native_math
 
@@ -142,7 +130,7 @@ jobs:
           ELC="$(pwd)/dist/platform/elc"
           RUNTIME="$(pwd)/el-compiler/runtime"
           "$ELC" --test tests/native/test_state.el > /tmp/el_native_state.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_state.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_state.c "$RUNTIME/el_runtime.c" \
             -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_state
           /tmp/el_native_state
 
@@ -152,7 +140,7 @@ jobs:
           ELC="$(pwd)/dist/platform/elc"
           RUNTIME="$(pwd)/el-compiler/runtime"
           "$ELC" --test tests/native/test_time.el > /tmp/el_native_time.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_time.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_time.c "$RUNTIME/el_runtime.c" \
             -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_time
           /tmp/el_native_time
 
@@ -162,7 +150,7 @@ jobs:
           ELC="$(pwd)/dist/platform/elc"
           RUNTIME="$(pwd)/el-compiler/runtime"
           "$ELC" --test tests/native/test_json.el > /tmp/el_native_json.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_json.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_json.c "$RUNTIME/el_runtime.c" \
             -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_json
           /tmp/el_native_json
 
@@ -172,7 +160,7 @@ jobs:
           ELC="$(pwd)/dist/platform/elc"
           RUNTIME="$(pwd)/el-compiler/runtime"
           "$ELC" --test tests/native/test_env.el > /tmp/el_native_env.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_env.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_env.c "$RUNTIME/el_runtime.c" \
             -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_env
           /tmp/el_native_env
 
@@ -182,7 +170,7 @@ jobs:
           ELC="$(pwd)/dist/platform/elc"
           RUNTIME="$(pwd)/el-compiler/runtime"
           "$ELC" --test tests/native/test_fs.el > /tmp/el_native_fs.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_fs.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_fs.c "$RUNTIME/el_runtime.c" \
             -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_fs
           /tmp/el_native_fs
 
@@ -215,6 +203,9 @@ jobs:
           GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
         run: |
           echo "${GCP_SA_KEY}" > /tmp/gcp-key.json
+          apt-get install -y -qq apt-transport-https ca-certificates curl
+          echo "deb [trusted=yes] https://packages.cloud.google.com/apt cloud-sdk main" > /etc/apt/sources.list.d/google-cloud-sdk.list
+          apt-get update -qq && apt-get install -y google-cloud-cli
           gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
           gcloud config set project neuron-785695
 
@@ -261,52 +252,4 @@ jobs:
             --source=el-compiler/runtime/el_runtime.js
 
           echo "Published El SDK version=${VERSION} to foundation-dev"
-          # Keep key alive for the ci-base rebuild step below
-          # (deleted in that step after docker push)
-
-      - name: Rebuild ci-base with fresh El SDK (dev)
-        # Patches ci-base:dev in-place: pulls the existing image (which has all
-        # system deps — Node, Go, gcloud, Docker CLI, etc.) and overlays the freshly
-        # built El SDK on top. Keeps the full ci-base rebuild fast and incremental.
-        if: github.event_name == 'push'
-        env:
-          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
-        run: |
-          set -euo pipefail
-          CI_BASE="us-central1-docker.pkg.dev/neuron-785695/neuron-ci/ci-base"
-          SHA="${GITHUB_SHA:0:8}"
-
-          echo "${GCP_SA_KEY}" > /tmp/gcp-key.json
-          gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
-          gcloud config set project neuron-785695
-          gcloud auth configure-docker us-central1-docker.pkg.dev --quiet
-
-          # Pull existing ci-base:dev (or fall back to :latest on first run)
-          BASE_TAG="dev"
-          docker pull "${CI_BASE}:dev" || { docker pull "${CI_BASE}:latest" && BASE_TAG="latest"; }
-
-          # Inline Dockerfile — only replaces the El SDK layer
-          cat > /tmp/Dockerfile.ci-base-patch << 'EOF'
-          ARG BASE
-          FROM ${BASE}
-          COPY dist/platform/elc                 /opt/el/dist/platform/elc
-          COPY dist/bin/elb                       /opt/el/dist/bin/elb
-          COPY el-compiler/runtime/el_runtime.c  /opt/el/el-compiler/runtime/el_runtime.c
-          COPY el-compiler/runtime/el_runtime.h  /opt/el/el-compiler/runtime/el_runtime.h
-          COPY el-compiler/runtime/el_runtime.js /opt/el/el-compiler/runtime/el_runtime.js
-          RUN chmod +x /opt/el/dist/platform/elc /opt/el/dist/bin/elb
-          EOF
-
-          docker build \
-            --build-arg BASE="${CI_BASE}:${BASE_TAG}" \
-            --build-arg BUILDKIT_INLINE_CACHE=1 \
-            -f /tmp/Dockerfile.ci-base-patch \
-            -t "${CI_BASE}:dev" \
-            -t "${CI_BASE}:dev-${SHA}" \
-            .
-
-          docker push "${CI_BASE}:dev"
-          docker push "${CI_BASE}:dev-${SHA}"
-
-          echo "ci-base rebuilt: ${CI_BASE}:dev (${SHA})"
           rm -f /tmp/gcp-key.json

.gitea/workflows/ci-stage.yaml

@@ -246,51 +246,4 @@ jobs:
             --source=el-compiler/runtime/el_runtime.h
 
           echo "Published El SDK version=${VERSION} to foundation-stage"
-          # Keep key alive for the ci-base rebuild step below
-          # (deleted in that step after docker push)
-
-      - name: Rebuild ci-base with fresh El SDK (stage)
-        # Patches ci-base:stage in-place: pulls the existing image (which has all
-        # system deps — Node, Go, gcloud, Docker CLI, etc.) and overlays the freshly
-        # built El SDK on top. Keeps the full ci-base rebuild fast and incremental.
-        if: github.event_name == 'push'
-        env:
-          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
-        run: |
-          set -euo pipefail
-          CI_BASE="us-central1-docker.pkg.dev/neuron-785695/neuron-ci/ci-base"
-          SHA="${GITHUB_SHA:0:8}"
-
-          echo "${GCP_SA_KEY}" > /tmp/gcp-key.json
-          gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
-          gcloud config set project neuron-785695
-          gcloud auth configure-docker us-central1-docker.pkg.dev --quiet
-
-          # Pull existing ci-base:stage (system deps stay cached in the base layer)
-          docker pull "${CI_BASE}:stage" || docker pull "${CI_BASE}:latest"
-
-          # Inline Dockerfile — only replaces the El SDK layer
-          cat > /tmp/Dockerfile.ci-base-patch << 'EOF'
-          ARG BASE
-          FROM ${BASE}
-          COPY dist/platform/elc                 /opt/el/dist/platform/elc
-          COPY dist/bin/elb                       /opt/el/dist/bin/elb
-          COPY el-compiler/runtime/el_runtime.c  /opt/el/el-compiler/runtime/el_runtime.c
-          COPY el-compiler/runtime/el_runtime.h  /opt/el/el-compiler/runtime/el_runtime.h
-          COPY el-compiler/runtime/el_runtime.js /opt/el/el-compiler/runtime/el_runtime.js
-          RUN chmod +x /opt/el/dist/platform/elc /opt/el/dist/bin/elb
-          EOF
-
-          docker build \
-            --build-arg BASE="${CI_BASE}:stage" \
-            --build-arg BUILDKIT_INLINE_CACHE=1 \
-            -f /tmp/Dockerfile.ci-base-patch \
-            -t "${CI_BASE}:stage" \
-            -t "${CI_BASE}:stage-${SHA}" \
-            .
-
-          docker push "${CI_BASE}:stage"
-          docker push "${CI_BASE}:stage-${SHA}"
-
-          echo "ci-base rebuilt: ${CI_BASE}:stage (${SHA})"
           rm -f /tmp/gcp-key.json

elp/src/language-profile.elh

@@ -1,46 +1,46 @@
-// auto-generated by elc --emit-header — do not edit
-extern fn lang_profile(code: String, word_order: String, morph_type: String, has_case: String, has_gender: String, script_dir: String, agreement: String, null_subject: String) -> [String]
-extern fn lang_get(profile: [String], key: String) -> String
-extern fn lang_profile_en() -> [String]
-extern fn lang_profile_ja() -> [String]
-extern fn lang_profile_ar() -> [String]
-extern fn lang_profile_zh() -> [String]
-extern fn lang_profile_de() -> [String]
-extern fn lang_profile_es() -> [String]
-extern fn lang_profile_fi() -> [String]
-extern fn lang_profile_sw() -> [String]
-extern fn lang_profile_hi() -> [String]
-extern fn lang_profile_ru() -> [String]
-extern fn lang_profile_fr() -> [String]
-extern fn lang_profile_la() -> [String]
-extern fn lang_profile_he() -> [String]
-extern fn lang_profile_sa() -> [String]
-extern fn lang_profile_got() -> [String]
-extern fn lang_profile_non() -> [String]
-extern fn lang_profile_enm() -> [String]
-extern fn lang_profile_pi() -> [String]
-extern fn lang_profile_grc() -> [String]
-extern fn lang_profile_ang() -> [String]
-extern fn lang_profile_fro() -> [String]
-extern fn lang_profile_goh() -> [String]
-extern fn lang_profile_sga() -> [String]
-extern fn lang_profile_txb() -> [String]
-extern fn lang_profile_peo() -> [String]
-extern fn lang_profile_akk() -> [String]
-extern fn lang_profile_uga() -> [String]
-extern fn lang_profile_egy() -> [String]
-extern fn lang_profile_sux() -> [String]
-extern fn lang_profile_gez() -> [String]
-extern fn lang_profile_cop() -> [String]
-extern fn lang_from_code(code: String) -> [String]
-extern fn lang_default() -> [String]
-extern fn lang_is_isolating(profile: [String]) -> Bool
-extern fn lang_is_agglutinative(profile: [String]) -> Bool
-extern fn lang_is_fusional(profile: [String]) -> Bool
-extern fn lang_is_polysynthetic(profile: [String]) -> Bool
-extern fn lang_is_rtl(profile: [String]) -> Bool
-extern fn lang_has_null_subject(profile: [String]) -> Bool
-extern fn lang_has_case(profile: [String]) -> Bool
-extern fn lang_has_gender(profile: [String]) -> Bool
-extern fn lang_word_order(profile: [String]) -> String
-extern fn lang_code(profile: [String]) -> String
+// auto-generated by elc --emit-header - do not edit
+extern fn lang_profile(code: String, word_order: String, morph_type: String, has_case: String, has_gender: String, script_dir: String, agreement: String, null_subject: String) -> Any
+extern fn lang_get(profile: Any, key: String) -> String
+extern fn lang_profile_en() -> Any
+extern fn lang_profile_ja() -> Any
+extern fn lang_profile_ar() -> Any
+extern fn lang_profile_zh() -> Any
+extern fn lang_profile_de() -> Any
+extern fn lang_profile_es() -> Any
+extern fn lang_profile_fi() -> Any
+extern fn lang_profile_sw() -> Any
+extern fn lang_profile_hi() -> Any
+extern fn lang_profile_ru() -> Any
+extern fn lang_profile_fr() -> Any
+extern fn lang_profile_la() -> Any
+extern fn lang_profile_he() -> Any
+extern fn lang_profile_sa() -> Any
+extern fn lang_profile_got() -> Any
+extern fn lang_profile_non() -> Any
+extern fn lang_profile_enm() -> Any
+extern fn lang_profile_pi() -> Any
+extern fn lang_profile_grc() -> Any
+extern fn lang_profile_ang() -> Any
+extern fn lang_profile_fro() -> Any
+extern fn lang_profile_goh() -> Any
+extern fn lang_profile_sga() -> Any
+extern fn lang_profile_txb() -> Any
+extern fn lang_profile_peo() -> Any
+extern fn lang_profile_akk() -> Any
+extern fn lang_profile_uga() -> Any
+extern fn lang_profile_egy() -> Any
+extern fn lang_profile_sux() -> Any
+extern fn lang_profile_gez() -> Any
+extern fn lang_profile_cop() -> Any
+extern fn lang_from_code(code: String) -> Any
+extern fn lang_default() -> Any
+extern fn lang_is_isolating(profile: Any) -> Bool
+extern fn lang_is_agglutinative(profile: Any) -> Bool
+extern fn lang_is_fusional(profile: Any) -> Bool
+extern fn lang_is_polysynthetic(profile: Any) -> Bool
+extern fn lang_is_rtl(profile: Any) -> Bool
+extern fn lang_has_null_subject(profile: Any) -> Bool
+extern fn lang_has_case(profile: Any) -> Bool
+extern fn lang_has_gender(profile: Any) -> Bool
+extern fn lang_word_order(profile: Any) -> String
+extern fn lang_code(profile: Any) -> String

elp/src/morphology-akk.el

@@ -56,7 +56,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn akk_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-akk.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn akk_str_ends(s: String, suf: String) -> Bool
 extern fn akk_str_len(s: String) -> Int
 extern fn akk_str_drop_last(s: String, n: Int) -> String

elp/src/morphology-ang.el

@@ -36,7 +36,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn ang_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-ang.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn ang_str_ends(s: String, suf: String) -> Bool
 extern fn ang_str_drop_last(s: String, n: Int) -> String
 extern fn ang_str_last_char(s: String) -> String

elp/src/morphology-ar.el

@@ -21,7 +21,6 @@
 
 // ── String helpers ────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn ar_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-ar.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn ar_str_ends(s: String, suf: String) -> Bool
 extern fn ar_str_len(s: String) -> Int
 extern fn ar_str_drop_last(s: String, n: Int) -> String

elp/src/morphology-cop.el

@@ -54,7 +54,6 @@
 
 // ── String helpers ──────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn cop_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-cop.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn cop_str_ends(s: String, suf: String) -> Bool
 extern fn cop_str_len(s: String) -> Int
 extern fn cop_drop(s: String, n: Int) -> String

elp/src/morphology-de.el

@@ -26,7 +26,6 @@
 //  Dat:    dem     der     dem     den
 //  Gen:    des     der     des     der
 
-import "morphology.el"
 fn de_article_def(gender: String, gram_case: String, number: String) -> String {
     if str_eq(number, "pl") {
         if str_eq(gram_case, "nom") { return "die" }

elp/src/morphology-de.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn de_article_def(gender: String, gram_case: String, number: String) -> String
 extern fn de_article_indef(gender: String, gram_case: String, number: String) -> String
 extern fn de_article(gender: String, gram_case: String, number: String, definite: String) -> String

elp/src/morphology-egy.el

@@ -52,7 +52,6 @@
 
 // ── String helpers ──────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn egy_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-egy.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn egy_str_ends(s: String, suf: String) -> Bool
 extern fn egy_str_len(s: String) -> Int
 extern fn egy_drop(s: String, n: Int) -> String

elp/src/morphology-enm.el

@@ -31,7 +31,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn enm_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-enm.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn enm_str_ends(s: String, suf: String) -> Bool
 extern fn enm_drop(s: String, n: Int) -> String
 extern fn enm_first_char(s: String) -> String

elp/src/morphology-es.el

@@ -12,7 +12,6 @@
 
 // ── String helpers (local, matching morphology.el conventions) ────────────────
 
-import "morphology.el"
 fn es_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-es.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn es_str_ends(s: String, suf: String) -> Bool
 extern fn es_str_drop_last(s: String, n: Int) -> String
 extern fn es_str_last_char(s: String) -> String

elp/src/morphology-fi.el

@@ -25,7 +25,6 @@
 // If only neutral vowels are found, default to "front" (the conservative choice
 // for borrowed words and those without clear back vowels).
 
-import "morphology.el"
 fn fi_harmony(word: String) -> String {
     let n: Int = str_len(word)
     let i: Int = n - 1

elp/src/morphology-fi.elh

@@ -1,11 +1,11 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn fi_harmony(word: String) -> String
 extern fn fi_suffix(base: String, harmony: String) -> String
 extern fn fi_noun_case(stem: String, gram_case: String, number: String, harmony: String) -> String
 extern fn fi_str_last_char(s: String) -> String
 extern fn fi_apply_case(noun: String, gram_case: String, number: String) -> String
 extern fn fi_verb_stem(dict_form: String) -> String
-extern fn fi_irregular_verb(dict_form: String) -> [String]
+extern fn fi_irregular_verb(dict_form: String) -> Any
 extern fn fi_present_ending(stem: String, person: String, number: String, harmony: String) -> String
 extern fn fi_past_stem(stem: String) -> String
 extern fn fi_past_ending(stem: String, person: String, number: String, harmony: String) -> String
@@ -14,4 +14,4 @@ extern fn fi_negative(verb: String, person: String, number: String) -> String
 extern fn fi_conjugate(verb: String, tense: String, person: String, number: String) -> String
 extern fn fi_question_suffix(harmony: String) -> String
 extern fn fi_make_question(verb_form: String, harmony: String) -> String
-extern fn fi_full_paradigm(noun: String) -> [String]
+extern fn fi_full_paradigm(noun: String) -> Any

elp/src/morphology-fr.el

@@ -19,7 +19,6 @@
 
 // ── String helpers (local, matching morphology.el conventions) ────────────────
 
-import "morphology.el"
 fn fr_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-fr.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn fr_str_ends(s: String, suf: String) -> Bool
 extern fn fr_str_drop_last(s: String, n: Int) -> String
 extern fn fr_str_last_char(s: String) -> String

elp/src/morphology-fro.el

@@ -53,7 +53,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn fro_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-fro.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn fro_str_ends(s: String, suf: String) -> Bool
 extern fn fro_drop(s: String, n: Int) -> String
 extern fn fro_slot(person: String, number: String) -> Int

elp/src/morphology-gez.el

@@ -64,7 +64,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn gez_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-gez.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn gez_str_ends(s: String, suf: String) -> Bool
 extern fn gez_str_len(s: String) -> Int
 extern fn gez_str_drop_last(s: String, n: Int) -> String

elp/src/morphology-goh.el

@@ -48,7 +48,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn goh_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-goh.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn goh_str_ends(s: String, suf: String) -> Bool
 extern fn goh_drop(s: String, n: Int) -> String
 extern fn goh_slot(person: String, number: String) -> Int

elp/src/morphology-got.el

@@ -49,7 +49,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn got_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-got.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn got_str_ends(s: String, suf: String) -> Bool
 extern fn got_str_drop_last(s: String, n: Int) -> String
 extern fn got_slot(person: String, number: String) -> Int

elp/src/morphology-grc.el

@@ -31,7 +31,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn grc_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-grc.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn grc_str_ends(s: String, suf: String) -> Bool
 extern fn grc_str_drop_last(s: String, n: Int) -> String
 extern fn grc_str_last_char(s: String) -> String

elp/src/morphology-he.el

@@ -51,7 +51,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn he_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-he.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn he_str_ends(s: String, suf: String) -> Bool
 extern fn he_str_len(s: String) -> Int
 extern fn he_str_drop_last(s: String, n: Int) -> String

elp/src/morphology-hi.el

@@ -24,7 +24,6 @@
 
 // ── String helpers ────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn hi_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-hi.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn hi_str_ends(s: String, suf: String) -> Bool
 extern fn hi_str_drop_last(s: String, n: Int) -> String
 extern fn hi_str_last_char(s: String) -> String

elp/src/morphology-ja.el

@@ -23,7 +23,6 @@
 // Note: this is a heuristic classifier for romanized input.  For production use
 // with native kana/kanji forms, the dictionary form (辞書形) must be consulted.
 
-import "morphology.el"
 fn ja_verb_group(dict_form: String) -> String {
     // Irregular verbs (exact match on dictionary form)
     if str_eq(dict_form, "する")  { return "irregular" }

elp/src/morphology-ja.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn ja_verb_group(dict_form: String) -> String
 extern fn ja_ichidan_stem(dict_form: String) -> String
 extern fn ja_godan_stem_change(dict_form: String, row: String) -> String

elp/src/morphology-la.el

@@ -25,7 +25,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn la_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-la.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn la_str_ends(s: String, suf: String) -> Bool
 extern fn la_str_drop_last(s: String, n: Int) -> String
 extern fn la_str_last_char(s: String) -> String

elp/src/morphology-non.el

@@ -27,7 +27,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn non_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-non.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn non_str_ends(s: String, suf: String) -> Bool
 extern fn non_drop(s: String, n: Int) -> String
 extern fn non_last(s: String) -> String

elp/src/morphology-peo.el

@@ -31,7 +31,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn peo_drop(s: String, n: Int) -> String {
     let len: Int = str_len(s)
     if n >= len { return "" }

elp/src/morphology-peo.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn peo_drop(s: String, n: Int) -> String
 extern fn peo_ends(s: String, suf: String) -> Bool
 extern fn peo_slot(person: String, number: String) -> Int

elp/src/morphology-pi.el

@@ -30,7 +30,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn pi_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-pi.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn pi_str_ends(s: String, suf: String) -> Bool
 extern fn pi_drop(s: String, n: Int) -> String
 extern fn pi_last_char(s: String) -> String

elp/src/morphology-ru.el

@@ -35,7 +35,6 @@
 // The heuristic returns the most probable gender.  Caller should override
 // for known exceptions (путь, рубль are masc despite -ь).
 
-import "morphology.el"
 fn ru_gender(noun: String) -> String {
     let n: Int = str_len(noun)
     if n == 0 { return "m" }

elp/src/morphology-ru.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn ru_gender(noun: String) -> String
 extern fn ru_stem_type(noun: String, gender: String) -> String
 extern fn ru_noun_case(noun: String, gender: String, gram_case: String, number: String) -> String

elp/src/morphology-sa.el

@@ -42,7 +42,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn sa_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-sa.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn sa_str_ends(s: String, suf: String) -> Bool
 extern fn sa_str_drop_last(s: String, n: Int) -> String
 extern fn sa_slot(person: String, number: String) -> Int

elp/src/morphology-sga.el

@@ -31,7 +31,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn sga_drop(s: String, n: Int) -> String {
     let len: Int = str_len(s)
     if n >= len { return "" }

elp/src/morphology-sga.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn sga_drop(s: String, n: Int) -> String
 extern fn sga_first(s: String) -> String
 extern fn sga_rest(s: String) -> String

elp/src/morphology-sux.el

@@ -53,7 +53,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn sux_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-sux.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn sux_str_ends(s: String, suf: String) -> Bool
 extern fn sux_str_drop_last(s: String, n: Int) -> String
 extern fn sux_str_last_char(s: String) -> String

elp/src/morphology-sw.el

@@ -24,7 +24,6 @@
 
 // ── String helpers ────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn sw_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-sw.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn sw_str_ends(s: String, suf: String) -> Bool
 extern fn sw_str_drop_last(s: String, n: Int) -> String
 extern fn sw_str_first_char(s: String) -> String

elp/src/morphology-txb.el

@@ -30,7 +30,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn txb_drop(s: String, n: Int) -> String {
     let len: Int = str_len(s)
     if n >= len { return "" }

elp/src/morphology-txb.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn txb_drop(s: String, n: Int) -> String
 extern fn txb_ends(s: String, suf: String) -> Bool
 extern fn txb_slot(person: String, number: String) -> Int

elp/src/morphology-uga.el

@@ -48,7 +48,6 @@
 
 // ── String helpers ─────────────────────────────────────────────────────────────
 
-import "morphology.el"
 fn uga_str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology-uga.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn uga_str_ends(s: String, suf: String) -> Bool
 extern fn uga_str_len(s: String) -> Int
 extern fn uga_str_drop_last(s: String, n: Int) -> String

elp/src/morphology.el

@@ -33,17 +33,6 @@
 
 // ── String helpers ────────────────────────────────────────────────────────────
 
-import "language-profile.el"
-import "morphology-es.el"
-import "morphology-fr.el"
-import "morphology-de.el"
-import "morphology-ru.el"
-import "morphology-fi.el"
-import "morphology-ar.el"
-import "morphology-hi.el"
-import "morphology-sw.el"
-import "morphology-la.el"
-import "morphology-ja.el"
 fn str_ends(s: String, suf: String) -> Bool {
     return str_ends_with(s, suf)
 }

elp/src/morphology.elh

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn str_ends(s: String, suf: String) -> Bool
 extern fn str_last_char(s: String) -> String
 extern fn str_last2(s: String) -> String
@@ -8,7 +8,7 @@ extern fn is_vowel(c: String) -> Bool
 extern fn morph_apply_suffix(base: String, suffix: String) -> String
 extern fn en_irregular_plural(word: String) -> String
 extern fn en_irregular_singular(word: String) -> String
-extern fn en_irregular_verb(base: String) -> [String]
+extern fn en_irregular_verb(base: String) -> Any
 extern fn en_verb_3sg(base: String) -> String
 extern fn en_should_double_final(base: String) -> Bool
 extern fn en_verb_past(base: String) -> String
@@ -16,10 +16,10 @@ extern fn en_verb_gerund(base: String) -> String
 extern fn en_pluralize_regular(singular: String) -> String
 extern fn en_verb_form(base: String, tense: String, person: String, number: String) -> String
 extern fn agree_determiner(det: String, noun: String) -> String
-extern fn morph_pluralize(noun: String, profile: [String]) -> String
+extern fn morph_pluralize(noun: String, profile: Any) -> String
 extern fn morph_map_canonical(verb: String, code: String) -> String
-extern fn morph_conjugate(verb: String, tense: String, person: String, number: String, profile: [String]) -> String
-extern fn morph_inflect(word: String, features: String, profile: [String]) -> String
+extern fn morph_conjugate(verb: String, tense: String, person: String, number: String, profile: Any) -> String
+extern fn morph_inflect(word: String, features: String, profile: Any) -> String
 extern fn pluralize(singular: String) -> String
 extern fn singularize(plural: String) -> String
 extern fn verb_form(base: String, tense: String, person: String, number: String) -> String

elp/src/vocabulary.elh

@@ -1,20 +1,20 @@
-// auto-generated by elc --emit-header — do not edit
-extern fn lex_word(entry: [String]) -> String
-extern fn lex_pos(entry: [String]) -> String
-extern fn lex_form(entry: [String], idx: Int) -> String
-extern fn lex_class(entry: [String]) -> String
-extern fn make_entry(word: String, pos: String, f0: String, f1: String, f2: String, f3: String, f4: String, cls: String) -> [String]
-extern fn make_entry2(word: String, pos: String, f0: String, f1: String, cls: String) -> [String]
-extern fn make_entry3(word: String, pos: String, f0: String, f1: String, f2: String, cls: String) -> [String]
-extern fn make_entry1(word: String, pos: String, f0: String, cls: String) -> [String]
-extern fn build_vocab() -> [[String]]
-extern fn get_vocab() -> [[String]]
-extern fn vocab_lookup(word: String, lang_code: String) -> [String]
-extern fn vocab_lookup_en(word: String) -> [String]
+// auto-generated by elc --emit-header - do not edit
+extern fn lex_word(entry: Any) -> String
+extern fn lex_pos(entry: Any) -> String
+extern fn lex_form(entry: Any, idx: Int) -> String
+extern fn lex_class(entry: Any) -> String
+extern fn make_entry(word: String, pos: String, f0: String, f1: String, f2: String, f3: String, f4: String, cls: String) -> Any
+extern fn make_entry2(word: String, pos: String, f0: String, f1: String, cls: String) -> Any
+extern fn make_entry3(word: String, pos: String, f0: String, f1: String, f2: String, cls: String) -> Any
+extern fn make_entry1(word: String, pos: String, f0: String, cls: String) -> Any
+extern fn build_vocab() -> Any
+extern fn get_vocab() -> Any
+extern fn vocab_lookup(word: String, lang_code: String) -> Any
+extern fn vocab_lookup_en(word: String) -> Any
 extern fn vocab_synonym(word: String, lang_register: String, lang_code: String) -> String
-extern fn vocab_by_pos(pos: String) -> [[String]]
-extern fn vocab_by_class(cls: String) -> [[String]]
-extern fn entry_found(entry: [String]) -> Bool
-extern fn entry_word(entry: [String]) -> String
-extern fn entry_pos(entry: [String]) -> String
-extern fn entry_form(entry: [String], n: Int) -> String
+extern fn vocab_by_pos(pos: String) -> Any
+extern fn vocab_by_class(cls: String) -> Any
+extern fn entry_found(entry: Any) -> Bool
+extern fn entry_word(entry: Any) -> String
+extern fn entry_pos(entry: Any) -> String
+extern fn entry_form(entry: Any, n: Int) -> String

lang/el-compiler/runtime/el_platform_win.h

@@ -0,0 +1,94 @@
+#ifndef EL_PLATFORM_WIN_H
+#define EL_PLATFORM_WIN_H
+/*
+ * el_platform_win.h — Windows OS-boundary shim for el_runtime.c.
+ *
+ * Branch: feat/windows-el-runtime. Included ONLY when _WIN32 is defined; the POSIX build is
+ * untouched. Goal: let el_runtime.c (a BSD-sockets / dlfcn / fork host) compile and link with
+ * mingw-w64 into a native neuron.exe, with no behavioural change to the Linux/macOS build.
+ *
+ * What it maps:
+ *   - sockets  : winsock2 (same call names: socket/bind/listen/accept/recv/send/setsockopt).
+ *                Sockets close with closesocket() (see el_closesocket), and the stack must be
+ *                started once with WSAStartup — done automatically via a load-time constructor.
+ *   - dlsym    : el_runtime.c uses dlsym(RTLD_DEFAULT, name) to resolve callback/tool symbols
+ *                exported by the main module. Windows equivalent: GetProcAddress on the process
+ *                module. Link the soul with -Wl,--export-all-symbols so the symbols are findable.
+ *   - popen    : mapped to _popen/_pclose.
+ *   - threads  : UNCHANGED. mingw-w64 ships winpthreads, so <pthread.h> + -lpthread just work.
+ */
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#include <io.h>
+#include <process.h>
+
+/* Portable headers mingw-w64 provides (verified present). */
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>   /* strcasecmp */
+#include <ctype.h>
+#include <math.h>
+#include <time.h>
+#include <sys/time.h>  /* mingw-w64 provides gettimeofday here */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <errno.h>
+#include <pthread.h>
+
+/* ── socket close ─────────────────────────────────────────────────────────── */
+/* Winsock closes sockets with closesocket(), not close() (close() is for file fds). The POSIX
+   build defines the same helper as close() so the call sites are identical across platforms. */
+static inline int el_closesocket(int s) { return closesocket((SOCKET)s); }
+
+/* ── winsock init (once, at load) ─────────────────────────────────────────── */
+static void el__win_net_init(void) {
+    static int inited = 0;
+    if (!inited) { WSADATA w; WSAStartup(MAKEWORD(2, 2), &w); inited = 1; }
+}
+__attribute__((constructor)) static void el__win_ctor(void) { el__win_net_init(); }
+
+/* ── dlsym → GetProcAddress ───────────────────────────────────────────────── */
+#ifndef RTLD_DEFAULT
+#define RTLD_DEFAULT ((void*)0)
+#endif
+static inline void* el_win_dlsym(void* handle, const char* name) {
+    (void)handle;
+    return (void*)(uintptr_t)GetProcAddress(GetModuleHandleA(NULL), name);
+}
+#define dlsym(h, n) el_win_dlsym((h), (n))
+
+/* ── popen / pclose ───────────────────────────────────────────────────────── */
+#define popen  _popen
+#define pclose _pclose
+
+/* ── misc POSIX → Win32 shims ─────────────────────────────────────────────── */
+#include <direct.h>            /* _mkdir */
+#define mkdir(path, mode) _mkdir(path)     /* POSIX mkdir(path,mode) → _mkdir(path) */
+#define timegm _mkgmtime                   /* UTC tm → time_t */
+
+/* setenv/unsetenv: not in the Windows CRT; map to _putenv_s. */
+static inline int setenv(const char* name, const char* value, int overwrite) {
+    (void)overwrite;
+    return _putenv_s(name, value ? value : "");
+}
+static inline int unsetenv(const char* name) { return _putenv_s(name, ""); }
+
+/* localtime_r/gmtime_r: Windows offers localtime_s/gmtime_s with reversed arg order. */
+static inline struct tm* localtime_r(const time_t* t, struct tm* out) {
+    return localtime_s(out, t) == 0 ? out : (struct tm*)0;
+}
+static inline struct tm* gmtime_r(const time_t* t, struct tm* out) {
+    return gmtime_s(out, t) == 0 ? out : (struct tm*)0;
+}
+
+#endif /* EL_PLATFORM_WIN_H */

lang/el-compiler/runtime/el_runtime.c

@@ -21,6 +21,10 @@
 
 #include "el_runtime.h"
 
+#ifdef _WIN32
+/* Windows OS-boundary shim (winsock/dlsym/popen). Threading stays on <pthread.h> (winpthreads). */
+#include "el_platform_win.h"
+#else
 #include <stdarg.h>
 #include <strings.h>     /* strcasecmp */
 #include <stdint.h>
@@ -42,7 +46,10 @@
 #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); }
+#endif
 #ifdef HAVE_CURL
 #include <curl/curl.h>
 #endif
@@ -1475,13 +1482,10 @@ static void http_send_response(int fd, const char* body) {
     }
 
     const char* eff_body = is_envelope ? env_body : body;
-    /* Use max(strlen, fs_read_len). fs_read_len is the real byte count for binary
-     * files (strlen stops at embedded NULs — PNG, WOFF2). strlen is correct AND larger
-     * when a handler WRAPS fs_read output in a longer text/JSON response (e.g.
-     * /api/safety-contact returns {"configured":...,"contact": <file>}); using
-     * fs_read_len alone truncated those responses to the file's length. */
-    size_t _blen_s = strlen(eff_body);
-    size_t blen = (_tl_fs_read_len > _blen_s) ? _tl_fs_read_len : _blen_s;
+    /* Use the real byte count from fs_read if available (handles binary files
+     * with embedded null bytes — PNG, WOFF2, etc.). Fall back to strlen for
+     * normal text/JSON responses where _tl_fs_read_len is 0. */
+    size_t blen = (_tl_fs_read_len > 0) ? _tl_fs_read_len : strlen(eff_body);
     _tl_fs_read_len = 0;  /* consume — one-shot per response */
     int head_only = _tl_http_head_only;
 
@@ -1555,8 +1559,7 @@ static void* http_worker(void* arg) {
             /* Copy response out BEFORE arena teardown.
              * For binary files, _tl_fs_read_len holds the real byte count —
              * use memcpy instead of strdup so null bytes are preserved. */
-            size_t _rlen_s = rs ? strlen(rs) : 0;
-            size_t rlen = (_tl_fs_read_len > _rlen_s) ? _tl_fs_read_len : _rlen_s;
+            size_t rlen = _tl_fs_read_len > 0 ? _tl_fs_read_len : (rs ? strlen(rs) : 0);
             response = malloc(rlen + 1);
             if (response && rs) { memcpy(response, rs, rlen); response[rlen] = '\0'; }
             else if (response) { response[0] = '\0'; }
@@ -1592,17 +1595,17 @@ el_val_t http_serve(el_val_t port, el_val_t handler) {
     int sock = socket(AF_INET6, SOCK_STREAM, 0);
     if (sock < 0) { perror("socket"); return 0; }
     int yes = 1; int no = 0;
-    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
-    setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &no, sizeof(no));
+    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof(yes));
+    setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&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 0;
+        perror("bind"); el_closesocket(sock); return 0;
     }
-    if (listen(sock, 64) < 0) { perror("listen"); close(sock); return 0; }
+    if (listen(sock, 64) < 0) { perror("listen"); el_closesocket(sock); return 0; }
     fprintf(stderr, "[http] listening on [::]:%d (dual-stack)\n", p);
     while (1) {
         struct sockaddr_in6 cli;
@@ -1619,11 +1622,11 @@ el_val_t http_serve(el_val_t port, el_val_t handler) {
         _http_conn_active++;
         pthread_mutex_unlock(&_http_conn_mu);
         HttpWorkerArg* arg = malloc(sizeof(HttpWorkerArg));
-        if (!arg) { close(cfd); continue; }
+        if (!arg) { el_closesocket(cfd); continue; }
         arg->fd = cfd;
         pthread_t tid;
         if (pthread_create(&tid, NULL, http_worker, arg) != 0) {
-            close(cfd); free(arg);
+            el_closesocket(cfd); free(arg);
             pthread_mutex_lock(&_http_conn_mu);
             _http_conn_active--;
             pthread_cond_signal(&_http_conn_cv);
@@ -1632,7 +1635,7 @@ el_val_t http_serve(el_val_t port, el_val_t handler) {
         }
         pthread_detach(tid);
     }
-    close(sock);
+    el_closesocket(sock);
     return 0;
 }
 
@@ -1803,8 +1806,7 @@ static void* http_worker_v2(void* arg) {
             el_val_t hmap = http_build_headers_map(hdr_block ? hdr_block : "");
             el_val_t r = h(EL_STR(dispatch_method), EL_STR(path), hmap, EL_STR(body));
             const char* rs = EL_CSTR(r);
-            size_t _rlen_s = rs ? strlen(rs) : 0;
-            size_t rlen = (_tl_fs_read_len > _rlen_s) ? _tl_fs_read_len : _rlen_s;
+            size_t rlen = _tl_fs_read_len > 0 ? _tl_fs_read_len : (rs ? strlen(rs) : 0);
             response = malloc(rlen + 1);
             if (response && rs) { memcpy(response, rs, rlen); response[rlen] = '\0'; }
             else if (response) { response[0] = '\0'; }
@@ -1843,17 +1845,17 @@ el_val_t http_serve_v2(el_val_t port, el_val_t handler) {
     int sock = socket(AF_INET6, SOCK_STREAM, 0);
     if (sock < 0) { perror("socket"); return 0; }
     int yes = 1; int no = 0;
-    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
-    setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &no, sizeof(no));
+    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof(yes));
+    setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&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 0;
+        perror("bind"); el_closesocket(sock); return 0;
     }
-    if (listen(sock, 64) < 0) { perror("listen"); close(sock); return 0; }
+    if (listen(sock, 64) < 0) { perror("listen"); el_closesocket(sock); return 0; }
     fprintf(stderr, "[http v2] listening on [::]:%d (dual-stack)\n", p);
     while (1) {
         struct sockaddr_in6 cli;
@@ -1870,11 +1872,11 @@ el_val_t http_serve_v2(el_val_t port, el_val_t handler) {
         _http_conn_active++;
         pthread_mutex_unlock(&_http_conn_mu);
         HttpWorkerArg* arg = malloc(sizeof(HttpWorkerArg));
-        if (!arg) { close(cfd); continue; }
+        if (!arg) { el_closesocket(cfd); continue; }
         arg->fd = cfd;
         pthread_t tid;
         if (pthread_create(&tid, NULL, http_worker_v2, arg) != 0) {
-            close(cfd); free(arg);
+            el_closesocket(cfd); free(arg);
             pthread_mutex_lock(&_http_conn_mu);
             _http_conn_active--;
             pthread_cond_signal(&_http_conn_cv);
@@ -1883,7 +1885,7 @@ el_val_t http_serve_v2(el_val_t port, el_val_t handler) {
         }
         pthread_detach(tid);
     }
-    close(sock);
+    el_closesocket(sock);
     return 0;
 }
 
@@ -2057,6 +2059,23 @@ el_val_t exec(el_val_t cmdv) {
 el_val_t exec_bg(el_val_t cmdv) {
     const char* cmd = EL_CSTR(cmdv);
     if (!cmd || !*cmd) return el_wrap_str(el_strdup(""));
+#ifdef _WIN32
+    /* Windows: no fork/exec. Launch a detached `cmd /c <command>` with no console window via
+       CreateProcess (DETACHED_PROCESS | CREATE_NO_WINDOW). Returns the PID as a string, "" on fail.
+       Mirrors the POSIX branch: child runs independently, caller is not blocked. */
+    char cmdline[8192];
+    snprintf(cmdline, sizeof(cmdline), "cmd.exe /c %s", cmd);
+    STARTUPINFOA si; ZeroMemory(&si, sizeof(si)); si.cb = sizeof(si);
+    PROCESS_INFORMATION pi; ZeroMemory(&pi, sizeof(pi));
+    BOOL ok = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE,
+                             DETACHED_PROCESS | CREATE_NO_WINDOW, NULL, NULL, &si, &pi);
+    if (!ok) return el_wrap_str(el_strdup(""));
+    char pidbuf[32];
+    snprintf(pidbuf, sizeof(pidbuf), "%lu", (unsigned long)pi.dwProcessId);
+    CloseHandle(pi.hProcess);
+    CloseHandle(pi.hThread);
+    return el_wrap_str(el_strdup(pidbuf));
+#else
     pid_t pid = fork();
     if (pid < 0) {
         /* fork failed */
@@ -2079,6 +2098,7 @@ el_val_t exec_bg(el_val_t cmdv) {
     char pidbuf[32];
     snprintf(pidbuf, sizeof(pidbuf), "%d", (int)pid);
     return el_wrap_str(el_strdup(pidbuf));
+#endif
 }
 
 el_val_t fs_list(el_val_t pathv) {
@@ -2247,43 +2267,6 @@ 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,49 +3161,23 @@ static void jb_puts(JsonBuf* b, const char* s) {
 
 static void jb_emit_escaped(JsonBuf* b, const char* s) {
     jb_putc(b, '"');
-    const unsigned char* p = (const unsigned char*)s;
-    while (*p) {
-        unsigned char c = *p;
+    for (; *s; s++) {
+        unsigned char c = (unsigned char)*s;
         switch (c) {
-            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;
+            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;
             default:
                 if (c < 0x20) {
                     char tmp[8];
                     snprintf(tmp, sizeof(tmp), "\\u%04x", c);
                     jb_puts(b, tmp);
-                    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++;
+                    jb_putc(b, (char)c);
                 }
                 break;
         }
@@ -4406,7 +4363,12 @@ static int _el_decompose_earth(el_caltime_t* ct, struct tm* tm_out, int* abbr_le
     localtime_r(&s, &tm);
     *tm_out = tm;
     if (abbr_buf && abbr_cap > 0) {
+        /* mingw's struct tm has no tm_zone (BSD/glibc extension); no abbrev available there. */
+#ifdef _WIN32
+        const char* z_str = "";
+#else
         const char* z_str = tm.tm_zone ? tm.tm_zone : "";
+#endif
         size_t n = strlen(z_str);
         if (n >= abbr_cap) n = abbr_cap - 1;
         memcpy(abbr_buf, z_str, n);
@@ -5743,50 +5705,6 @@ 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.
@@ -6250,9 +6168,7 @@ static void engram_grow_edges(void) {
 static char* engram_new_id(void) {
     el_val_t v = uuid_new();
     const char* s = EL_CSTR(v);
-    /* 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 : "");
+    return el_strdup(s ? s : "");
 }
 
 /* Convert a node into an ElMap of its fields.                            */
@@ -6347,17 +6263,12 @@ 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);
-    /* 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->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("{}");
     n->salience    = engram_decode_score(salience);
     n->importance  = engram_decode_score(importance);
     n->confidence  = engram_decode_score(confidence);
@@ -7300,48 +7211,13 @@ el_val_t engram_save(el_val_t path) {
         jb_putc(&b, '}');
     }
     jb_puts(&b, "]}");
-
-    /* --- Anti-clobber sparse-write floor (NTN engram clobber fix) ---------
-     * Refuse to overwrite an existing populated snapshot with a drastically
-     * smaller one. A bad boot that loaded only ~63 identity nodes must never
-     * be able to clobber a healthy 5000+ node snapshot, regardless of the
-     * upstream cause (genesis fallback, partial load, etc.). */
-    {
-        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 bytes vs existing "
-                "%lld bytes (< 1/16) — protecting snapshot %s\n",
-                b.len, (long long)_st.st_size, p);
-            free(b.buf);
-            return 0;
-        }
-    }
-
-    /* --- Atomic write: tmp + fsync + rename ------------------------------
-     * Write to a sibling temp file, fsync it durable, then rename() over the
-     * target. rename() is atomic on POSIX, so a concurrent reader (a booting
-     * soul's engram_load) never observes a truncated or 0-byte snapshot —
-     * which was the root of the genesis/clobber loop. */
-    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); /* includes NUL */
-
-    FILE* f = fopen(_tmp, "wb");
-    if (!f) { free(_tmp); free(b.buf); return 0; }
+    FILE* f = fopen(p, "wb");
+    if (!f) { free(b.buf); return 0; }
     size_t w = fwrite(b.buf, 1, b.len, f);
-    int wok = (w == b.len);
-    if (wok) { fflush(f); fsync(fileno(f)); }
     fclose(f);
+    int ok = (w == b.len);
     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;
+    return ok ? 1 : 0;
 }
 
 /* Helper: extract a string field from a JSON object substring. */

lang/el-compiler/runtime/el_runtime.h

@@ -52,6 +52,12 @@
 
 typedef int64_t el_val_t;
 
+/* HTTP request-handler function-pointer types. Public because soul modules (routes/chat/etc.)
+ * register handlers across translation units; previously defined only inside el_runtime.c, which
+ * made cross-module references (and the Windows build) fail. Home in the shared header. */
+typedef el_val_t (*http_handler_fn)(el_val_t method, el_val_t path, el_val_t body);
+typedef el_val_t (*http_handler4_fn)(el_val_t method, el_val_t path, el_val_t body, el_val_t headers);
+
 #define EL_STR(s)  ((el_val_t)(uintptr_t)(s))
 #define EL_CSTR(v) ((const char*)(uintptr_t)(v))
 #define EL_INT(v)  (v)
@@ -227,8 +233,6 @@ 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 ──────────────────────────────────────────────────────────── */
 
@@ -533,12 +537,6 @@ 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.      */

lang/el-compiler/src/codegen.el

@@ -324,10 +324,6 @@ 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, "")
@@ -417,17 +413,6 @@ 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"]
@@ -3730,7 +3715,6 @@ 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,9 +287,6 @@ 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
@@ -328,32 +325,6 @@ 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:
@@ -565,20 +536,16 @@ fn main() -> Void {
 
     let src_path: String = native_list_get(positional, 0)
 
-    // 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).
+    // When --emit-header is requested, parse the source file directly
+    // (without inlining imports) and write out a .elh file alongside the .c.
     if do_emit_header {
-        el_mem_check()
         let raw_source: String = fs_read(src_path)
         let hdr_tokens: [Any] = lex(raw_source)
-        let hdr_sigs: [Map<String, Any>] = scan_fn_sigs_el(hdr_tokens)
+        let hdr_stmts: [Map<String, Any>] = parse(hdr_tokens)
         el_release(hdr_tokens)
         let hdr_path: String = str_slice(src_path, 0, str_len(src_path) - 3) + ".elh"
-        emit_header_from_sigs(hdr_sigs, hdr_path)
-        el_release(hdr_sigs)
+        emit_header(hdr_stmts, hdr_path)
+        el_release(hdr_stmts)
     }
 
     let source: String = resolve_imports(src_path)

lang/el-compiler/src/parser.el

@@ -293,48 +293,6 @@ 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> {
@@ -362,7 +320,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})*
@@ -477,125 +435,77 @@ fn parse_html_children(tokens: [Any], pos: Int, parent_tag: String) -> Map<Strin
                 }
             } else {
                 if str_eq(k, "LBrace") {
-                    // 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.
+                    // Interpolation: {expr} or {#each ...} or {/each}
                     let k2 = tok_kind(tokens, p + 1)
-                    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)
+                    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
                             let prev_no_block: String = state_get("__no_block_expr")
                             state_set("__no_block_expr", "1")
-                            let r_cond = parse_expr(tokens, p)
+                            let r_list = parse_expr(tokens, p)
                             state_set("__no_block_expr", prev_no_block)
-                            let cond_expr = r_cond["node"]
-                            let p = r_cond["pos"]
-                            el_release(r_cond)
+                            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 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)
+                            // 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
+                                    }
                                 }
                             }
-                            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
+                            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 {
-                                // 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 })
-                                    }
-                                }
+                                let children = native_list_append(children, { "html": "Interp", "value": interp_val })
                             }
                         }
                     }
@@ -655,27 +565,6 @@ 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"]
@@ -829,123 +718,44 @@ 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)
         }
-        // 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 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" {
                     let running = false
                 } else {
-                    if k2 == "Eof" {
-                        let running = false
+                    // 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
                     } else {
-                        // 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 = new_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)
+        let p = expect(tokens, p, "RBrace")
+        return make_result({ "expr": "Map", "pairs": pairs }, p)
     }
 
     // if expression
@@ -2065,219 +1875,6 @@ 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.

lang/elb.el

@@ -77,33 +77,6 @@ fn parse_manifest_entry(src: String) -> String {
     return ""
 }
 
-// parse_manifest_c_sources - collect all `c_source "path"` lines from the
-// build block.  Returns a flat list of path strings.
-fn parse_manifest_c_sources(src: String) -> [String] {
-    let result: [String] = native_list_empty()
-    let lines: [String] = str_split(src, "\n")
-    let n: Int = native_list_len(lines)
-    let i = 0
-    while i < n {
-        let line: String = native_list_get(lines, i)
-        let t: String = str_trim(line)
-        if str_starts_with(t, "c_source ") {
-            let after: String = str_slice(t, 9, str_len(t))
-            let trimmed: String = str_trim(after)
-            if str_starts_with(trimmed, "\"") {
-                let inner: String = str_slice(trimmed, 1, str_len(trimmed))
-                let q: Int = str_index_of(inner, "\"")
-                if q >= 0 {
-                    let path: String = str_slice(inner, 0, q)
-                    let result = native_list_append(result, path)
-                }
-            }
-        }
-        let i = i + 1
-    }
-    return result
-}
-
 fn parse_manifest_name(src: String) -> String {
     let lines: [String] = str_split(src, "\n")
     let n: Int = native_list_len(lines)
@@ -301,18 +274,7 @@ fn link_binary(c_files: [String], out_bin: String, runtime_path: String, out_dir
     // Detect clang vs gcc: -fbracket-depth is clang-only; silently ignored
     // if unsupported but gcc rejects it with an error.
     let bracket_flag: String = "$(cc --version 2>&1 | grep -q clang && printf -- '-fbracket-depth=1024' || true)"
-    // On macOS, OpenSSL is not on the default linker path. Detect homebrew
-    // prefix and add it if present (no-op on Linux where libssl is in /usr/lib).
-    let ossl_lib_flag: String = "$(brew --prefix openssl 2>/dev/null | xargs -I{} printf -- '-L{}/lib' 2>/dev/null || true)"
-    let ossl_inc_flag: String = "$(brew --prefix openssl 2>/dev/null | xargs -I{} printf -- '-I{}/include' 2>/dev/null || true)"
-    // Force-include the C-level master declarations header so every translation
-    // unit sees all cross-module function signatures. Handles packages (like ELP)
-    // where modules call each other without explicit El import statements.
-    // The header is generated by elb --gen-decls or manually placed in out_dir.
-    let master_decls: String = out_dir + "/elp-c-decls.h"
-    let has_master: String = str_trim(exec_capture("test -f " + master_decls + " && echo yes || echo no"))
-    let include_flag: String = if str_eq(has_master, "yes") { "-include " + master_decls } else { "" }
-    let parts = native_list_append(parts, "cc -O2 " + bracket_flag + " " + ossl_inc_flag + " " + include_flag + " -I " + dirname_of(runtime_path) + " -I " + out_dir)
+    let parts = native_list_append(parts, "cc -O2 " + bracket_flag + " -I " + dirname_of(runtime_path) + " -I " + out_dir)
     let i = 0
     while i < n {
         let f: String = native_list_get(c_files, i)
@@ -320,7 +282,7 @@ fn link_binary(c_files: [String], out_bin: String, runtime_path: String, out_dir
         let i = i + 1
     }
     let parts = native_list_append(parts, runtime_path)
-    let parts = native_list_append(parts, ossl_lib_flag + " -lcurl -lssl -lcrypto -lpthread -lm")
+    let parts = native_list_append(parts, "-lcurl -lssl -lcrypto -lpthread -lm")
     let parts = native_list_append(parts, "-o " + out_bin)
     let cmd: String = str_join(parts, " ")
     println("  link     " + out_bin)
@@ -353,7 +315,6 @@ fn main() -> Void {
 
     let pkg_name: String = parse_manifest_name(manifest_src)
     let entry: String    = parse_manifest_entry(manifest_src)
-    let extra_c: [String] = parse_manifest_c_sources(manifest_src)
     if str_eq(entry, "") {
         println("elb: manifest.el has no 'entry' declaration")
         exit(1)
@@ -432,15 +393,6 @@ fn main() -> Void {
         exit(1)
     }
 
-    // Append any extra C sources declared in the manifest (e.g. platform stubs)
-    let ei = 0
-    let en: Int = native_list_len(extra_c)
-    while ei < en {
-        let ec: String = native_list_get(extra_c, ei)
-        let c_files = native_list_append(c_files, ec)
-        let ei = ei + 1
-    }
-
     // Link
     let out_bin: String = out_dir + "/" + pkg_name
     let linked: Bool = link_binary(c_files, out_bin, runtime_path, out_dir, dry_run)

scripts/build-soul-darwin.sh

@@ -1,21 +0,0 @@
-#!/bin/sh
-# build-soul-darwin.sh — replicate `elb` on macOS/arm64 with clang.
-# Proven 2026-06-16: produces a Mach-O arm64 soul that boots and serves :7770.
-# The official builder `elb` ships Linux-only (CI); this lets us build + test the
-# darwin soul locally (e.g. to validate the atomic engram_save fix in isolation).
-#
-# Usage: scripts/build-soul-darwin.sh <path-to-neuron/dist> [output-binary]
-set -e
-DIST="${1:?usage: build-soul-darwin.sh <neuron/dist dir> [out]}"
-OUT="${2:-./neuron}"
-RT="$(cd "$(dirname "$0")/.." && pwd)/lang/el-compiler/runtime"
-B="$(mktemp -d)"
-# elc-generated dist modules use C89-style implicit cross-module declarations that
-# Apple clang rejects as errors by default; resolve at link, so downgrade them.
-CFLAGS="-Wno-implicit-function-declaration -Wno-implicit-int -Wno-int-conversion -I$B -I$DIST -I$RT"
-cp "$RT/el_runtime.h" "$B/"
-clang -c $CFLAGS "$RT/el_runtime.c" -o "$B/el_runtime.o"
-for c in "$DIST"/*.c; do clang -c $CFLAGS "$c" -o "$B/$(basename "$c" .c).o"; done
-# NOTE: link *.o once — do not also list el_runtime.o separately (duplicate symbols).
-clang "$B"/*.o -o "$OUT" -lcurl -lm
-echo "built $OUT"