Release v1.15.5 to v1.15.7 from BuddhiLW/main

.dev/accepted_divergences.yaml

@@ -680,7 +680,7 @@ accepted:
       `release-pending-sends` are implemented for real; only the executor surface
       diverges, because it presupposes a subsystem cljw deliberately lacks.
     derives_from: "ADR-0093 (per-agent worker, no shared pool) + ADR-0155 (D-442 classification) + the no-`java.util.concurrent`-executor model + provisional_marker.md permanent-no-op-forbidden."
-    pin: "test/e2e/phase16_agent.sh — agent_send_via_raises / agent_set_executor_raises / agent_set_off_executor_raises (all three raise the no-configurable-executor message)."
+    pin: "test/clj/suites/agent_test.clj, deftest agent-executor-fns-raise — agent_send_via_raises / agent_set_executor_raises / agent_set_off_executor_raises (all three raise the no-configurable-executor message)."
   - id: "AD-046"
     summary: "After `(shutdown-agents)`, a dropped `send` does NOT fire an agent's `:error-handler` — cljw silently drops the action; clj routes the swallowed `RejectedExecutionException` to the handler if one is set. The COMMON case (no handler) MATCHES clj exactly: send returns the agent, no throw, action never runs."
     example: '(do (shutdown-agents) (let [a (agent 0 :error-handler h)] (send a inc))) => cljw drops, h NOT called / clj drops, h called with a RejectedExecutionException. Without a handler both runtimes drop silently (identical).'
@@ -706,7 +706,7 @@ accepted:
       Kind differs, AD-007 covers it" claim was FACTUALLY WRONG (it assumed clj
       throws to the caller; the oracle shows it does not) and is corrected here.
     derives_from: "F-011 (clj-parity authoritative; the no-handler path matches exactly) + ADR-0093 (per-agent worker, no java.util.concurrent executor / no RejectedExecutionException type) + ADR-0155 (D-442 shutdown-agents classification) + provisional_marker.md permanent-no-op-forbidden (the silent drop is the clj-faithful terminal no-op, audited)."
-    pin: "test/e2e/phase16_agent.sh — shutdown_agents_send_returns_agent (send returns the agent, no throw), shutdown_agents_action_dropped (state unchanged), shutdown_agents_no_handler_fire (cljw does NOT fire the :error-handler on the dropped send: log stays empty)."
+    pin: "test/clj/suites/agent_test.clj, deftest shutdown-agents-is-process-global (each case in a child cljw, since shutdown-agents is process-global) — shutdown_agents_send_returns_agent (send returns the agent, no throw), shutdown_agents_action_dropped (state unchanged), shutdown_agents_no_handler_fire (cljw does NOT fire the :error-handler on the dropped send: log stays empty)."
   - id: "AD-047"
     summary: "A host java.util collection's `str`/`.toString` renders in CLOJURE content form (`[1 2]`, `{:a 1, :b 2}`, `#{1 2}`), not JVM toString form (`[1, 2]`, `{:b=2, :a=1}` with `=` pairs + JVM iteration order). The `pr`/`pr-str`/REPL form MATCHES clj exactly (`[1 2]` / `#{1 2}` / `{:a 1}`) — D-468; only the str-form (Java toString) diverges."
     example: '(str (doto (java.util.HashMap.) (.put :a 1) (.put :b 2))) => cljw "{:a 1, :b 2}" / clj "{:b=2, :a=1}"; (str (java.util.ArrayList. [1 2])) => cljw "[1 2]" / clj "[1, 2]"'
@@ -892,7 +892,7 @@ accepted:
       has shipped the sequential shape for a decade. The seam is two functions
       (`foldvec`, `Cat`'s `coll-fold`), so a later parallelisation is local.
     derives_from: "ADR-0093 (no ForkJoinPool / java.util.concurrent executor surface) + ADR-0059 (no-JVM) + the ClojureScript precedent (clojure/core/reducers.cljs ships the same sequential fold)."
-    pin: "test/e2e/phase16_clojure_core_reducers.sh — `fold-value-on-a-large-vector` (a 10,000-element vector, well past any plausible cutoff n) and `fold-with-a-distinct-combiner` (the 4-arity arm, where a combiner that is not the reducef must still be honoured). Both assert the VALUE, so a later parallelisation cannot change it. Plus test/diff/clj_corpus/reducers.txt, whose fold rows are golden pairs against real clj."
+    pin: "test/clj/suites/core_libs_phase16_test.clj, deftest reducers-ns — `fold-value-on-a-large-vector` (a 10,000-element vector, well past any plausible cutoff n) and `fold-with-a-distinct-combiner` (the 4-arity arm, where a combiner that is not the reducef must still be honoured). Both assert the VALUE, so a later parallelisation cannot change it. Plus test/diff/clj_corpus/reducers.txt, whose fold rows are golden pairs against real clj."
   - id: "AD-059"
     area: "clojure.set"
     summary: |-
@@ -1081,28 +1081,6 @@ accepted:
     example: '(let [l (lazy-seq 1)] (try (seq l) (catch Exception _ nil)) (count l)) => cljw throws again / clj 0.'
     derives_from: "ADR-0143 (failed realization is never cached) + ADR-0197 (one publication state, immutable inner links and retained retry captures)."
     pin: "test/clj/suites/lazy_seqable_test.clj — non-seqable-bodies-raise-on-every-touch and realization-state-follows-ad067; test/golden/cases/lazy_seqable_bodies.expected — scalar retries, closed thunk retry, inner realized."
-  - id: "AD-068"
-    area: "hierarchy"
-    summary: |-
-      `derive` accepts a CLASS as the parent, where clj raises
-      `ClassCastException`. clj's 2-arity asserts `(namespace parent)`, and a
-      `Class` is not `Named`, so `(derive ::tag String)` throws there.
-      ADR-0109 makes a host class a first-class hierarchy participant in cljw:
-      `isa?` already answers on class parents, `defmulti` dispatches on them,
-      and `(derive ::x Object)` is the way a keyword tag joins that graph.
-      The edge is REAL rather than implied by `Object` being the universal
-      supertype — `(isa? ::x Object)` is false until the derive installs it —
-      so refusing a class parent would make an ADR-0109 hierarchy expressible
-      only through `make-hierarchy`, which the global `defmulti` path does not
-      read. Every OTHER bad shape is rejected exactly as clj rejects it: a
-      non-named parent, an un-namespaced parent in the 2-arity, and a tag that
-      is neither a class nor a namespaced symbol/keyword.
-      The 3-arity is deliberately more permissive than the 2-arity on
-      namespacing, in both runtimes: a hierarchy value you pass in is your own,
-      while the global one is shared across every namespace.
-    example: '(derive :user/tag String) => cljw installs the edge / clj throws ClassCastException. The reverse, (derive ::x Object) then (isa? ::x Object), is true in cljw and unreachable in clj.'
-    derives_from: "ADR-0109 (one host-class-VALUE resolver; a class is a hierarchy participant)."
-    pin: "test/e2e/phase14_opaque_host_class.sh — the derive_object case; clojure.core-test.derive carries the one residual upstream failure this row explains."
   - id: AD-069
     area: numerics
     summary: '`(int x)` / `(byte x)` / `(short x)` yield a Long: cljw has no Integer / Byte / Short types, so `(instance? Integer (int 0))` is false where clj is true. The narrowing RANGE is still enforced the way clj enforces it, so `(int 2147483648)` raises in both; only the RESULT TYPE differs.'

.dev/bench/string_seq.clj

@@ -0,0 +1,64 @@
+;; String-seq workloads ([CLJW-STRING-SEQ], A13 `.string_seq`).
+;;
+;; Two questions, same method as traversal.clj / scaling.clj:
+;;  - FIXED-OPS probes (2000 ops after warmup) against strings of growing size:
+;;    flat time across sizes = O(1) per op; growing with size = O(n) per op.
+;;  - WHOLE-WALK probes: total time 4x per 4x size = linear, 16x = quadratic.
+;;
+;; Run:  cljw .dev/bench/string_seq.clj      clj -M .dev/bench/string_seq.clj
+
+(def SIZES [2000 8000 32000])
+(def OPS 2000)
+
+(defn- ms [f]
+  (let [t0 (System/nanoTime)] (f) (/ (- (System/nanoTime) t0) 1e6)))
+
+(defn- best-of [k f] (apply min (repeatedly k #(ms f))))
+
+(defn- verdict [times]
+  (let [ratios (vec (map (fn [a b] (if (zero? a) 0.0 (/ b a))) (butlast times) (rest times)))
+        worst  (if (seq ratios) (apply max ratios) 0.0)]
+    [ratios worst]))
+
+(defn- report [label times kind]
+  (let [[ratios worst] (verdict times)
+        v (case kind
+            :per-op (cond (< worst 2.0) "O(1) per op" (< worst 6.0) "O(n) per op" :else "WORSE")
+            :walk   (cond (< worst 6.0) "LINEAR" (< worst 11.0) "superlinear" :else "QUADRATIC  <-- BAD"))]
+    (println (format "%-34s t=%-28s ratio=%-14s %s" label
+                     (vec (map #(format "%.2f" %) times))
+                     (vec (map #(format "%.1f" %) ratios)) v))))
+
+(defn- S [n] (apply str (repeat n "x")))
+(defn- U [n] (apply str (repeat n "\u00e9")))   ; 2-byte codepoints
+
+(defn- per-op [label build run]
+  (report label
+          (vec (for [n SIZES]
+                 (let [c (build n)]
+                   (dotimes [_ 300] (run c))
+                   (best-of 5 #(dotimes [_ OPS] (run c))))))
+          :per-op))
+
+(defn- walk [label build run]
+  (report label
+          (vec (for [n SIZES]
+                 (let [c (build n)] (run c) (best-of 3 #(run c)))))
+          :walk))
+
+(println "=== string seq: fixed" OPS "ops per size, sizes" SIZES "===")
+(per-op "(seq s) truthiness"        S (fn [s] (seq s)))
+(per-op "(first (seq s))"           S (fn [s] (first (seq s))))
+(per-op "(rest (seq s))"            S (fn [s] (rest (seq s))))
+(per-op "(count ss) same seq"       (comp seq S) (fn [ss] (count ss)))
+(per-op "(count ss) same seq, utf8" (comp seq U) (fn [ss] (count ss)))
+(per-op "(count (rest ss))"         (comp seq S) (fn [ss] (count (rest ss))))
+
+(println "\n=== whole walks ===")
+(walk "loop next"                   S #(loop [s (seq %) n 0] (if s (recur (next s) (inc n)) n)))
+(walk "loop next, count-guarded"    S #(loop [s (seq %) n 0] (if (> (count s) 1) (recur (next s) (inc n)) n)))
+(walk "count-guarded, utf8"         U #(loop [s (seq %) n 0] (if (> (count s) 1) (recur (next s) (inc n)) n)))
+(walk "reduce over (seq s)"         S #(reduce (fn [a _] (inc a)) 0 (seq %)))
+(walk "into [] (seq s)"             S #(into [] (seq %)))
+(walk "apply str (seq s)"           S #(apply str (seq %)))
+(walk "frequencies"                 S #(frequencies %))

.dev/debt.yaml

@@ -1405,7 +1405,7 @@ active:
       instant.zig (the existing neutral parser read-instant-date already reuses).
     last_reviewed: "2026-06-10"
   - id: "D-404"
-    status: "MARSHALLING TABLE DISCHARGED 2026-08-04: the fixture blocker (\"the full marshalling-table verification is BLOCKED on a typed component FIXTURE\") is gone — `test/e2e/fixtures/wasm/echo.component.wasm` (16 lifted functions) loads now that zwasm #157 landed, and `phase16_wasm_component_multiexport.sh` asserts 20 rows of the ADR-0135 table in BOTH directions. The RESOURCE phase is also done (ADR-0159 amendment 1: the one-shot `own` lift, the bare-integer parameter hole, and the missing owner check). Remaining: the :cljw/wasm-deps deps.edn coordinate arm. STATUS NOTE 2026-07-02 (audit): the 2026-06-14 BLOCKED-on-REQ-7 freeze below is STALE — the barrier records the blocker resolved 2026-06-21 and Impl A-E landed. True remainder = the :cljw/wasm-deps deps.edn coordinate arm only. ORIGINAL: PARTIAL (W1 first slice landed 2026-06-14): require-a-component WORKS — cljw.wasm/require-component (src/lang/clj/cljw/wasm.clj, wasm-gated bundled ns) interns one Var per component export into an :as namespace via clojure.core/intern + load-component + component-exports + component-call; export-name cleanup (#[constructor]/#[method] markers, pkg:iface/ prefix, resource type prefix stripped). (greeter/greet \"world\") -> \"Hello, world!\"; resource counter ctor/increment/get -> 6. e2e phase16_wasm_require_component.sh (-Dwasm). REMAINING W1 (:refer form DONE 2026-06-14): full WIT<->EDN marshalling table (record/variant/enum/option/result/flags/tuple — today only string/int/float/bool/char + resource handle via component-call); doc/arglists from WIT. W2: deps.edn {:wasm/component …} coords. === PARTIAL (2026-06-13): one-shot CM-API adoption WORKS, instance-caching BLOCKED on zwasm REQ-7. The zwasm-watch fired — all 6 cw CM-API requests landed (zwasm pin 5795c3d0). The experiment (push-suppressed, git stash@{0} 'wasm-component-experiment'; relative-path build.zig.zon) adopted comp.open/Opened + resolveFuncSig/WitType + REQ-2 labels: `(wasm/component-invoke …)` does greet (string→string), typed_payload (record/list/result roundtrip), resource constructor — hand-rolled TypeCtx/Opened deleted, full ADR-0135 value mapping. NEXT (instance caching → require-a-component) is BLOCKED: storing comp.open's Opened in a host heap box breaks resolveFuncSig (Opened not relocatable) → zwasm REQ-7 relayed (private/20260613_handover_from_zwasm/cw_finding_REQ7_opened_heap_stability.md; openBoxed→*Opened or relocatable Opened). Resume: watch that channel for a REQ-7 response → pop stash, re-land instance-caching (code written, in this session's history + note). Full state: private/notes/p14-wasm-component-experiment.md (§ instance caching + Extended challenge). Was: zwasm-WATCH → UNBLOCKING → open. NOTE 2026-06-14: the full marshalling-table verification is BLOCKED on a typed component FIXTURE — only greet (string) + resource_counter exist; record/variant/result need a new .wasm exercising those WIT types (or descope). doc/arglists need WIT introspection on the handle. Until a fixture lands, W1 self-selects to Track S."
+    status: "MARSHALLING TABLE DISCHARGED 2026-08-04: the fixture blocker (\"the full marshalling-table verification is BLOCKED on a typed component FIXTURE\") is gone — `test/e2e/fixtures/wasm/echo.component.wasm` (16 lifted functions) loads now that zwasm #157 landed, and `test/clj/suites/wasm_component_multiexport_test.clj` asserts 20 rows of the ADR-0135 table in BOTH directions. The RESOURCE phase is also done (ADR-0159 amendment 1: the one-shot `own` lift, the bare-integer parameter hole, and the missing owner check). Remaining: the :cljw/wasm-deps deps.edn coordinate arm. STATUS NOTE 2026-07-02 (audit): the 2026-06-14 BLOCKED-on-REQ-7 freeze below is STALE — the barrier records the blocker resolved 2026-06-21 and Impl A-E landed. True remainder = the :cljw/wasm-deps deps.edn coordinate arm only. ORIGINAL: PARTIAL (W1 first slice landed 2026-06-14): require-a-component WORKS — cljw.wasm/require-component (src/lang/clj/cljw/wasm.clj, wasm-gated bundled ns) interns one Var per component export into an :as namespace via clojure.core/intern + load-component + component-exports + component-call; export-name cleanup (#[constructor]/#[method] markers, pkg:iface/ prefix, resource type prefix stripped). (greeter/greet \"world\") -> \"Hello, world!\"; resource counter ctor/increment/get -> 6. e2e phase16_wasm_require_component.sh (-Dwasm). REMAINING W1 (:refer form DONE 2026-06-14): full WIT<->EDN marshalling table (record/variant/enum/option/result/flags/tuple — today only string/int/float/bool/char + resource handle via component-call); doc/arglists from WIT. W2: deps.edn {:wasm/component …} coords. === PARTIAL (2026-06-13): one-shot CM-API adoption WORKS, instance-caching BLOCKED on zwasm REQ-7. The zwasm-watch fired — all 6 cw CM-API requests landed (zwasm pin 5795c3d0). The experiment (push-suppressed, git stash@{0} 'wasm-component-experiment'; relative-path build.zig.zon) adopted comp.open/Opened + resolveFuncSig/WitType + REQ-2 labels: `(wasm/component-invoke …)` does greet (string→string), typed_payload (record/list/result roundtrip), resource constructor — hand-rolled TypeCtx/Opened deleted, full ADR-0135 value mapping. NEXT (instance caching → require-a-component) is BLOCKED: storing comp.open's Opened in a host heap box breaks resolveFuncSig (Opened not relocatable) → zwasm REQ-7 relayed (private/20260613_handover_from_zwasm/cw_finding_REQ7_opened_heap_stability.md; openBoxed→*Opened or relocatable Opened). Resume: watch that channel for a REQ-7 response → pop stash, re-land instance-caching (code written, in this session's history + note). Full state: private/notes/p14-wasm-component-experiment.md (§ instance caching + Extended challenge). Was: zwasm-WATCH → UNBLOCKING → open. NOTE 2026-06-14: the full marshalling-table verification is BLOCKED on a typed component FIXTURE — only greet (string) + resource_counter exist; record/variant/result need a new .wasm exercising those WIT types (or descope). doc/arglists need WIT introspection on the handle. Until a fixture lands, W1 self-selects to Track S."
     category: "wasm"
     barrier: |-
       **BLOCKER DISSOLVED (2026-06-21).** zwasm's Component-Model embedding API is now
@@ -7348,7 +7348,7 @@ discharged:
     last_reviewed: "2026-08-04"
     refs: |-
       test/e2e/fixtures/wasm/README_echo.md (provenance + rebuild recipe +
-      root-cause note); test/e2e/phase16_wasm_component_multiexport.sh;
+      root-cause note); test/clj/suites/wasm_component_multiexport_test.clj;
       zwasm D-527; D-404 (the fixture blocker this discharges half of);
       ADR-0135 (the mapping table the fixture exists to falsify).
   - id: "D-569"