Chez parity: STM stub + portable line-seq (janet.* audit, jolt-0obq)

Audit of the janet.*/jolt.interop/STM corpus cases vs Chez equivalents: the Janet
FFI-bridge cases (janet/string, janet/type, janet.math/sqrt, janet.string/ascii-
upper) test functionality already covered by PORTABLE corpus cases (str 29, type 9,
sqrt 3, upper-case 9), so they're safe to delete in Phase 5. Two needed a Chez
equivalent so they pass instead of being lost:

- clojure.lang.LockingTransaction/isRunning -> false (no STM on jolt).
- line-seq: the corpus case used janet/spit setup but was the SOLE line-seq
  coverage (0 other cases). Ported janet/spit->spit, and added a native Chez
  line-seq (drain a jhost io/reader + split on newline; no trailing empty line)
  that delegates a Janet map-reader to the overlay version.

zero-Janet 2694->2696, prelude floor 2648; self-host + Janet gate + JVM cert green.

jolt-cf1q.7 jolt-0obq

host/chez/host-static.ss

@@ -154,6 +154,11 @@
 (register-host-methods! "thread"
   (list (cons "getContextClassLoader" (lambda (self) (make-jhost "classloader" '())))))
 
+;; clojure.lang.LockingTransaction: jolt has no STM (no refs/dosync), so a
+;; transaction is never running. isRunning -> false (jolt-0obq).
+(register-class-statics! "LockingTransaction" (list (cons "isRunning" (lambda () #f))))
+(register-class-statics! "clojure.lang.LockingTransaction" (list (cons "isRunning" (lambda () #f))))
+
 (define (now-millis)
   (let ((t (current-time 'time-utc)))
     (+ (* 1000 (time-second t)) (quotient (time-nanosecond t) 1000000))))

host/chez/io.ss

@@ -128,6 +128,20 @@
   (jolt-invoke (var-deref "clojure.core" "read-string")
                (if (reader-jhost? reader) (drain-reader reader) (jolt-str-render-one reader))))
 
+;; line-seq (jolt-0obq): the overlay line-seq reads via a Janet map-reader's
+;; :read-line-fn, but a Chez io/reader is a jhost StringReader. Drain it (or take a
+;; string) and split on newline; a trailing newline does NOT yield a final empty
+;; line (like readLine -> nil at EOF). Re-asserted in post-prelude.ss.
+(define (chez-lines s)
+  (let loop ((cs (string->list s)) (cur '()) (acc '()))
+    (cond ((null? cs) (reverse (if (null? cur) acc (cons (list->string (reverse cur)) acc))))
+          ((char=? (car cs) #\newline) (loop (cdr cs) '() (cons (list->string (reverse cur)) acc)))
+          (else (loop (cdr cs) (cons (car cs) cur) acc)))))
+(define (chez-line-seq rdr)
+  (list->cseq (chez-lines (cond ((string? rdr) rdr)
+                                ((reader-jhost? rdr) (drain-reader rdr))
+                                (else (jolt-str-render-one rdr))))))
+
 (define (jolt-slurp src . opts)
   (cond
     ((jfile? src) (read-file-string (jfile-path src)))

host/chez/post-prelude.ss

@@ -71,3 +71,9 @@
   (case-lambda
     ((reader) (chez-edn-read reader))
     ((opts reader) (chez-edn-read reader))))
+;; line-seq: a jhost reader (io/reader result) -> drain+split; a map-reader (the
+;; overlay's :read-line-fn model, e.g. with-in-str) -> the overlay version.
+(let ((overlay-line-seq (var-deref "clojure.core" "line-seq")))
+  (def-var! "clojure.core" "line-seq"
+    (lambda (rdr)
+      (if (reader-jhost? rdr) (chez-line-seq rdr) (jolt-invoke overlay-line-seq rdr)))))

test/chez/run-corpus-prelude.janet

@@ -323,7 +323,7 @@
 # runtime-require alias registration) -> 2590; arrays + reader-features/
 # macroexpand/reader-conditional/re-matcher -> 2629; delay/force/realized? -> 2641.
 # Strided runs scale down.
-(def base-floor (scan-number (or (os/getenv "JOLT_CHEZ_PRELUDE_FLOOR") "2641")))
+(def base-floor (scan-number (or (os/getenv "JOLT_CHEZ_PRELUDE_FLOOR") "2648")))
 (def floor (if (os/getenv "JOLT_CORPUS_LIMIT") 0 base-floor))
 (when (or (> (length diverged) 0) (< pass floor))
   (printf "REGRESSION: pass %d < floor %d or %d new divergence(s)" pass floor (length diverged)))

test/chez/run-corpus-zero-janet.janet

@@ -219,7 +219,7 @@
 # 2685; deftype (P. args) constructor via host-new var fallback -> 2688;
 # date/time (Date/Timestamp/SimpleDateFormat/TimeZone) + clojure.edn/read over a
 # reader -> 2692.
-(def base-floor (scan-number (or (os/getenv "JOLT_CHEZ_ZJ_FLOOR") "2694")))
+(def base-floor (scan-number (or (os/getenv "JOLT_CHEZ_ZJ_FLOOR") "2696")))
 (def floor (if (os/getenv "JOLT_CORPUS_LIMIT") 0 base-floor))
 (when (or (> (length diverged) 0) (< pass floor))
   (printf "REGRESSION: pass %d < floor %d or %d new divergence(s)" pass floor (length diverged)))