S4 entered by its spike: the two deliverables meet, 6765 crosses the boundary

bb spike-s4 is the stage-entry check /next demands — the smallest thing
that would fail if S4's premise were wrong, run before any design note.
cljwit (the S3 emitter) compiles (defn fib ...) to a prod module,
wasm-tools wraps it as a component with zero Canonical ABI machinery —
0007's scalar path, and the clj-exn tag export rides along without
complaint — and cljwit.host (the S1 library) calls it from the JVM
through FFM: (fib 20) = 6765 through the component boundary.

The S4 survey proper (the Canonical ABI's string/list lowering as
specced today, the Kotlin sample, 0007's dated claims re-verified) is
the next unit, before a design note shapes the first real slice.

Claude-Session: https://claude.ai/code/session_01XF5Hfq4Ca2N2XYEzWQQuHt

Author: chaploud

bb.edn

@@ -55,6 +55,9 @@
   repl        {:doc  "The ClojureWit nREPL server (0029): evals compile to Wasm, run in the engine child"
                :task (run "clojure" "-M:repl")}
 
+  spike-s4    {:doc  "S4 entry: cljwit compiles fib, wasm-tools wraps it, cljwit.host calls it. Needs `nix develop`."
+               :task (run "clojure" "-M:dev" "-m" "cljwit.spike.s4-end-to-end")}
+
   test        {:doc  "Unit tests (JVM)"
                :task (if (and (fs/exists? "test") (seq (fs/glob "test" "**.clj")))
                        (run "clojure" "-X:test")

dev/cljwit/spike/s4_end_to_end.clj

@@ -0,0 +1,49 @@
+(ns cljwit.spike.s4-end-to-end
+  "The S4 entry spike: the project's two deliverables meet. `cljwit`
+   (the S3 emitter) compiles `(defn fib …)` to a prod module,
+   `wasm-tools` wraps it as a component (`0007`: scalar-only exports
+   need no Canonical ABI lowering at all), and `cljwit.host` (the S1
+   library) calls it from the JVM. Success is 6765 through the
+   component boundary — the smallest thing that would fail if S4's
+   premise were wrong. Needs `nix develop` (wasm-tools and
+   CLJWIT_WASMTIME_LIB)."
+  (:require [cljwit.analyze :as analyze]
+            [cljwit.emit :as emit]
+            [cljwit.host :as host]
+            [clojure.java.io :as io]
+            [clojure.java.process :as process]))
+
+(set! *warn-on-reflection* true)
+
+(def ^:private program
+  ['(defn fib [n] (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2)))))
+   '(fib 20)])
+
+(defn- sh! [& args]
+  (let [p    (apply process/start {:out :pipe :err :pipe} args)
+        err  (future (slurp (process/stderr p)))
+        exit @(process/exit-ref p)]
+    (when-not (zero? exit)
+      (throw (ex-info (str "failed: " (pr-str args)) {:err @err})))))
+
+(defn -main [& _]
+  (let [dir  (doto (io/file "target/spike-s4") (.mkdirs))
+        wat  (io/file dir "fib.wat")
+        core (io/file dir "fib.core.wasm")
+        emb  (io/file dir "fib.embed.wasm")
+        comp (io/file dir "fib.component.wasm")]
+    (spit wat (emit/emit-module (analyze/analyze-forms program) :prod))
+    (sh! "wasm-tools" "parse" (str wat) "-o" (str core))
+    (sh! "wasm-tools" "component" "embed" "dev/resources/s4_fib.wit" (str core) "-o" (str emb))
+    (sh! "wasm-tools" "component" "new" (str emb) "-o" (str comp))
+    (println "component:" (str comp) (str "(" (.length comp) " bytes)"))
+    (with-open [e (host/engine)
+                a (host/compile e comp)
+                i (host/instantiate a)]
+      (println "exports:  " (host/exports i))
+      (println "signature:" (host/signature i "entry"))
+      (let [v ((i "entry"))]
+        (println "(fib 20) through the component boundary =" v)
+        (when-not (= 6765 v)
+          (println "✗ expected 6765")
+          (System/exit 1))))))

dev/resources/s4_fib.wit

@@ -0,0 +1,8 @@
+// The S4 entry spike's world (doc/status.md): a cljwit-compiled module
+// exports exactly one scalar function, which is the boundary shape 0007
+// showed costs nothing.
+package cljwit:spike;
+
+world fib-world {
+  export entry: func() -> s64;
+}

doc/status.md

@@ -91,12 +91,20 @@ _Short by design, and printed at every session start — so findings live in
    classify as errors, out-of-slice stays loud. The dev assembler
    entered `tools.json` and `bb check` materializes it (guarded
    `npm ci`) — `0026`'s promise kept on its named trigger. An editor
-   connection (CIDER/Calva) remains a manual check. Next: **entering
-   S4 starts with its survey** (`/next`'s stage rule; `0007` sized the
-   stage — lift/lower over linear memory, `cabi_realloc`, resource
-   tables — and `/survey`'s Kotlin sample is the closest prior art);
-   S2's watcher waits for namespace loading, post-S3 compiler work
-   either way.
+   connection (CIDER/Calva) remains a manual check. **S4 is entered
+   the way `/next`'s stage rule demands — by running what would fail
+   if its premise were wrong**: `bb spike-s4` has the project's two
+   deliverables meet for the first time — `cljwit` compiles
+   `(defn fib …)` to a prod module, `wasm-tools` wraps it as a
+   component (`0007`'s scalar path, zero Canonical ABI machinery, the
+   tag export tolerated), and **`cljwit.host` calls it from the JVM:
+   6765 through the component boundary** (2026-07-30). Next unit: the
+   S4 survey proper — the Canonical ABI's string/list lowering as
+   specced *today*, the Kotlin sample read closely, `0007`'s dated
+   claims re-verified — before a design note shapes S4's first real
+   slice (strings are also what the corpus's message comparisons and
+   printing wait on). S2's watcher waits for namespace loading,
+   post-S3 compiler work either way.
 
 Done since the last update: `0016` `own<T>` handles, `0017` host imports
 (A–F), `0018` host-defined resources, `0012`'s `ex-data` contract shrunk to