Scalar def lands; the oracle unwraps what eval wraps; (def y y) refuses

0022 D verbatim: one mutable global per var, declared null, assigned at
eval; a redef reuses its global; a def is a top-level statement only —
in expression position, or as the entry's last form, or without init,
it is a loud out-of-slice error, because a var value and an Unbound
sentinel have no representation to compare.

Two findings from the independent critique (Check #6), fixed here:
the init now emits before the var's global registers, so the
self-referential (def y y) — which silently returned 2 where the JVM's
Unbound sentinel is truthy and returns 1 — hits the unresolved-var
error instead; and status.md's entry count and mode-divergence claim
contradicted their own paragraph (29, not 21; divergence starts at
calls to def'd fns, not at def).

The oracle records the cause when eval wraps a top-level throw in
Compiler$CompilerException — the same triage clojure.main performs —
found by def-redef-throws, the entry that exercises trap row 1 through
a def init. Mode divergence has still not started; fn is next.

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

Author: chaploud

corpus/s3.edn

@@ -45,4 +45,12 @@
  {:id "let-shadow"      :forms [(let [x 1] (let [x (+ x 1)] (* x 10)))]}
  {:id "let-sequential"  :forms [(let [x 2 y (+ x 3)] (* x y))]}
  {:id "top-level-forms" :forms [(+ 1 1) (+ 2 2)]}
+ {:id "def-ref"         :forms [(def x 5) (+ x 1)]}
+ {:id "def-uses-def"    :forms [(def x 5) (def y (+ x 3)) (+ x y)]}
+ {:id "def-redef"       :forms [(def x 1) (def x 2) x]}
+ ;; A throwing re-def: both lanes abort the entry at form 2, and row 1
+ ;; licenses the comparison. That the old root survives (0022 D, the
+ ;; sibling's recorded bug) is unobservable until try/catch exists —
+ ;; claimed nowhere until it does.
+ {:id "def-redef-throws" :forms [(def x 5) (def x (quot 1 0)) x]}
  {:id "trap-div-zero"   :forms [(quot 1 0)]}]

doc/design/0023-first-vertical-slice.md

@@ -56,6 +56,12 @@ representation for everything the slice touches.
   compare with `=`. An oracle value that `pr-str`→`read-string` cannot
   round-trip is a corpus lint error (`0022` B.4) — this falls out of the
   mechanism rather than being a separate linter.
+- **The oracle records what the program observably throws**, not what
+  `eval` wraps it in: a throw during a top-level form (a `def` init, per
+  the first `def` entries) surfaces as `Compiler$CompilerException`, and
+  the oracle unwraps to its cause — the same triage `clojure.main`
+  performs before showing a user the error. Found by the harness itself
+  the day `def` landed, not designed in advance.
 
 ### The representation (the new pins)
 

doc/status.md

@@ -20,19 +20,22 @@ _Short by design, and printed at every session start — so findings live in
    the watcher — waits for a compiler to serve, so:
 3. **S3's first vertical slice is landed** (`0022` decided the shape,
    `0023` the harness and representation): the differential oracle is in
-   the gate — `corpus/s3.edn` (21 scalar entries) runs through real
+   the gate — `corpus/s3.edn` (29 scalar entries) runs through real
    `clojure` (fresh namespace per entry) and through
    `cljwit.analyze` → `cljwit.emit` → `wasm-tools` → **wasmtime and V8,
-   in both modes** (which emit identical bytes until `def` lands — stated,
-   not hidden), with `corpus/trap_table.edn` row 1
+   in both modes** (which emit identical bytes until calls to def'd fns
+   land — stated, not hidden), with `corpus/trap_table.edn` row 1
    (`ArithmeticException` ↔ division trap) exercised. Representation
    pinned in `0023`: values are `(ref null eq)`, fixnums i31, nil = null,
    false/true = singleton structs, overflow arm `unreachable`. Still
    open, each with its benchmark named (`0022`): the dev-loop output
    format (before the nREPL unit), the boxed-i64 lane (before the
-   emitter grows past i31), the throw representation. Next unit:
-   **`loop`/`recur` entries and emission** (a block and a `br`, forces
-   nothing open), then `def` — which starts the real dev/prod divergence.
+   emitter grows past i31), the throw representation. `loop`/`recur` and
+   scalar `def` are in the corpus (29 entries); mode divergence has still
+   not started — it begins with *calls to* def'd fns (direct linking,
+   `0004`), so the next unit is **`fn`**: `0022` D's full contract —
+   multi-arity ships with it, varargs carry an explicit rest-mode — and
+   the first depth-sensitive entry brings the trap table its stack row.
 
 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

src/cljwit/emit.clj

@@ -26,6 +26,16 @@
     (swap! local-decls conj (format "(local %s (ref null eq))" nm))
     nm))
 
+(defn- global-for!
+  "The module global backing a def'd var — one per var, declared null and
+   assigned at eval (`0022` D: declare at analysis, assign at eval)."
+  [{:keys [counter globals global-decls]} v]
+  (or (get @globals v)
+      (let [nm (str "$g" (swap! counter inc))]
+        (swap! global-decls conj (format "(global %s (mut (ref null eq)) (ref.null eq))" nm))
+        (swap! globals assoc v nm)
+        nm)))
+
 (declare emit-expr)
 
 (defn- emit-const [{:keys [type val] :as ast}]
@@ -136,9 +146,27 @@
     :local  (if-let [wl (get-in ctx [:locals (:name ast)])]
               (format "(local.get %s)" wl)
               (out-of-slice! (str "unresolved local " (:name ast)) ast))
+    :var    (if-let [g (get @(:globals ctx) (:var ast))]
+              (format "(global.get %s)" g)
+              (out-of-slice! (str "var " (:var ast) " has no global — only def'd vars are referenceable") ast))
+    :def    (out-of-slice! "def in expression position — its value is a var, which has no representation yet" ast)
     :invoke (emit-invoke ctx ast)
     (out-of-slice! (str "op " (:op ast)) ast)))
 
+(defn- emit-top-level
+  "A top-level statement: a def becomes a `global.set`; anything else is
+   an expression whose value is dropped."
+  [ctx ast]
+  (if (= :def (:op ast))
+    (if-let [init (:init ast)]
+      ;; The init is emitted before the var's global registers: a
+      ;; self-referential `(def y y)` must hit the loud unresolved-var
+      ;; error, not silently read the null the global was declared with.
+      (let [init-wat (emit-expr ctx init)]
+        (format "(global.set %s %s)" (global-for! ctx (:var ast)) init-wat))
+      (out-of-slice! "def without init — an unbound var has no edn representation" ast))
+    (format "(drop %s)" (emit-expr ctx ast))))
+
 (def ^:private runtime
   "  (type $Unit (struct))
   (global $false (ref $Unit) (struct.new $Unit))
@@ -179,13 +207,19 @@
    (`0023`)."
   [asts mode]
   {:pre [(#{:dev :prod} mode) (seq asts)]}
-  (let [ctx   {:locals {} :counter (atom 0) :local-decls (atom [])}
-        stmts (mapv #(emit-expr ctx %) (butlast asts))
-        ret   (emit-expr ctx (last asts))]
+  (let [ctx   {:locals {} :counter (atom 0) :local-decls (atom [])
+               :globals (atom {}) :global-decls (atom [])}
+        stmts (mapv #(emit-top-level ctx %) (butlast asts))
+        ;; The last form is the entry's result, so it cannot be a def —
+        ;; a def's value is the var itself, which is not a scalar.
+        ret   (if (= :def (:op (last asts)))
+                (out-of-slice! "a def cannot be an entry's last form — its value is a var" (last asts))
+                (emit-expr ctx (last asts)))]
     (str "(module\n"
          (format "  ;; mode %s — no divergence in the slice yet (0023)\n" (name mode))
          runtime
+         (str/join (map #(str "  " % "\n") @(:global-decls ctx)))
          "  (func $entry (export \"entry\") (result i64)\n"
          (str/join (map #(str "    " % "\n") @(:local-decls ctx)))
-         (str/join (map #(format "    (drop %s)\n" %) stmts))
+         (str/join (map #(str "    " % "\n") stmts))
          (format "    (i64.extend_i32_s (i31.get_s (ref.cast (ref i31) %s)))))\n" ret))))

test/cljwit/corpus_test.clj

@@ -50,7 +50,15 @@
         (refer-clojure)
         {:value (reduce (fn [_ f] (eval f)) nil forms)}
         (catch Throwable t
-          {:throw (.getName (class t)) :message (.getMessage t)})
+          ;; `eval` wraps a throw during a top-level form (a def init, say)
+          ;; in Compiler$CompilerException; what the program observably
+          ;; throws under `clojure` is the cause — clojure.main's own
+          ;; ex-triage reports the cause's class — so the oracle records it.
+          (let [t (if (and (instance? clojure.lang.Compiler$CompilerException t)
+                           (.getCause t))
+                    (.getCause t)
+                    t)]
+            {:throw (.getName (class t)) :message (.getMessage t)}))
         (finally (remove-ns ns-sym))))))
 
 (defn- assemble!