js-on-sx: Object.prototype.toString dispatches by [[Class]]

Was hardcoded to "[object Object]" for everything; per ES it should
return "[object Array]", "[object Function]", "[object Number]",
etc. by class. Added js-object-tostring-class helper that switches
on type-of and dict-internal markers (__js_*_value__,
__callable__). Prototype-identity checks ensure
Object.prototype.toString.call(Number.prototype) returns
"[object Number]" (similar for String/Boolean/Array).
built-ins/Array: 18/45 → 20/45, built-ins/Number: 43/50 → 44/50.
conformance.sh: 148/148.

lib/js/lexer.sx

@@ -29,6 +29,16 @@
       (and (>= c "a") (<= c "f"))
       (and (>= c "A") (<= c "F")))))
 
+(define
+  js-hex-value
+  (fn
+    (c)
+    (cond
+      ((and (>= c "0") (<= c "9")) (- (char-code c) 48))
+      ((and (>= c "a") (<= c "f")) (- (char-code c) 87))
+      ((and (>= c "A") (<= c "F")) (- (char-code c) 55))
+      (else 0))))
+
 (define
   js-letter?
   (fn (c) (or (and (>= c "a") (<= c "z")) (and (>= c "A") (<= c "Z")))))
@@ -37,9 +47,9 @@
 
 (define js-ident-char? (fn (c) (or (js-ident-start? c) (js-digit? c))))
 
+;; ── Reserved words ────────────────────────────────────────────────
 (define js-ws? (fn (c) (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))))
 
-;; ── Reserved words ────────────────────────────────────────────────
 (define
   js-keywords
   (list
@@ -86,15 +96,18 @@
     "await"
     "of"))
 
+;; ── Main tokenizer ────────────────────────────────────────────────
 (define js-keyword? (fn (word) (contains? js-keywords word)))
 
-;; ── Main tokenizer ────────────────────────────────────────────────
 (define
   js-tokenize
   (fn
     (src)
     (let
-      ((tokens (list)) (pos 0) (src-len (len src)))
+      ((tokens (list))
+        (pos 0)
+        (src-len (len src))
+        (nl-before false))
       (define
         js-peek
         (fn
@@ -109,11 +122,7 @@
           (let
             ((sl (len s)))
             (and (<= (+ pos sl) src-len) (= (slice src pos (+ pos sl)) s)))))
-      (define
-        js-emit!
-        (fn
-          (type value start)
-          (append! tokens (js-make-token type value start))))
+      (define js-emit! (fn (type value start) (append! tokens {:nl nl-before :type type :value value :pos start})))
       (define
         skip-line-comment!
         (fn
@@ -136,7 +145,13 @@
           ()
           (cond
             ((>= pos src-len) nil)
-            ((js-ws? (cur)) (do (advance! 1) (skip-ws!)))
+            ((js-ws? (cur))
+              (do
+                (when
+                  (or (= (cur) "\n") (= (cur) "\r"))
+                  (set! nl-before true))
+                (advance! 1)
+                (skip-ws!)))
             ((and (= (cur) "/") (< (+ pos 1) src-len) (= (js-peek 1) "/"))
               (do (advance! 2) (skip-line-comment!) (skip-ws!)))
             ((and (= (cur) "/") (< (+ pos 1) src-len) (= (js-peek 1) "*"))
@@ -254,11 +269,55 @@
                               ((= ch "b") (append! chars "\\b"))
                               ((= ch "f") (append! chars "\\f"))
                               ((= ch "v") (append! chars "\\v"))
+                              ((= ch "u")
+                                (if
+                                  (and
+                                    (< (+ pos 4) src-len)
+                                    (js-hex-digit? (js-peek 1))
+                                    (js-hex-digit? (js-peek 2))
+                                    (js-hex-digit? (js-peek 3))
+                                    (js-hex-digit? (js-peek 4)))
+                                  (do
+                                    (append!
+                                      chars
+                                      (char-from-code
+                                        (+
+                                          (*
+                                            4096
+                                            (js-hex-value
+                                              (js-peek 1)))
+                                          (*
+                                            256
+                                            (js-hex-value
+                                              (js-peek 2)))
+                                          (*
+                                            16
+                                            (js-hex-value
+                                              (js-peek 3)))
+                                          (js-hex-value (js-peek 4)))))
+                                    (advance! 4))
+                                  (append! chars ch)))
+                              ((= ch "x")
+                                (if
+                                  (and
+                                    (< (+ pos 2) src-len)
+                                    (js-hex-digit? (js-peek 1))
+                                    (js-hex-digit? (js-peek 2)))
+                                  (do
+                                    (append!
+                                      chars
+                                      (char-from-code
+                                        (+
+                                          (* 16 (js-hex-value (js-peek 1)))
+                                          (js-hex-value (js-peek 2)))))
+                                    (advance! 2))
+                                  (append! chars ch)))
                               (else (append! chars ch)))
                             (advance! 1))))
                       (loop)))
                   ((= (cur) quote-char) (advance! 1))
-                  (else (do (append! chars (cur)) (advance! 1) (loop))))))
+                  (else
+                    (do (append! chars (cur)) (advance! 1) (loop))))))
             (loop)
             (join "" chars))))
       (define
@@ -289,7 +348,8 @@
                       ()
                       (cond
                         ((>= pos src-len) nil)
-                        ((and (= (cur) "}") (= depth 1)) (advance! 1))
+                        ((and (= (cur) "}") (= depth 1))
+                          (advance! 1))
                         ((= (cur) "}")
                           (do
                             (append! buf (cur))
@@ -325,7 +385,9 @@
                                             (advance! 1)))
                                         (sloop)))
                                     ((= (cur) q)
-                                      (do (append! buf (cur)) (advance! 1)))
+                                      (do
+                                        (append! buf (cur))
+                                        (advance! 1)))
                                     (else
                                       (do
                                         (append! buf (cur))
@@ -334,7 +396,10 @@
                               (sloop)
                               (expr-loop))))
                         (else
-                          (do (append! buf (cur)) (advance! 1) (expr-loop))))))
+                          (do
+                            (append! buf (cur))
+                            (advance! 1)
+                            (expr-loop))))))
                   (expr-loop)
                   (join "" buf))))
             (define
@@ -376,14 +441,17 @@
                               (else (append! chars ch)))
                             (advance! 1))))
                       (loop)))
-                  (else (do (append! chars (cur)) (advance! 1) (loop))))))
+                  (else
+                    (do (append! chars (cur)) (advance! 1) (loop))))))
             (loop)
             (flush-chars!)
             (if
               (= (len parts) 0)
               ""
               (if
-                (and (= (len parts) 1) (= (nth (nth parts 0) 0) "str"))
+                (and
+                  (= (len parts) 1)
+                  (= (nth (nth parts 0) 0) "str"))
                 (nth (nth parts 0) 1)
                 parts)))))
       (define
@@ -453,9 +521,13 @@
                       (append! buf (cur))
                       (advance! 1)
                       (body-loop)))
-                  ((and (= (cur) "/") (not in-class)) (advance! 1))
+                  ((and (= (cur) "/") (not in-class))
+                    (advance! 1))
                   (else
-                    (begin (append! buf (cur)) (advance! 1) (body-loop))))))
+                    (begin
+                      (append! buf (cur))
+                      (advance! 1)
+                      (body-loop))))))
             (body-loop)
             (let
               ((flags-buf (list)))
@@ -470,7 +542,7 @@
                       (advance! 1)
                       (flags-loop)))))
               (flags-loop)
-              {:pattern (join "" buf) :flags (join "" flags-buf)}))))
+              {:flags (join "" flags-buf) :pattern (join "" buf)}))))
       (define
         try-op-4!
         (fn
@@ -510,64 +582,111 @@
         (fn
           (start)
           (cond
-            ((at? "==") (do (js-emit! "op" "==" start) (advance! 2) true))
-            ((at? "!=") (do (js-emit! "op" "!=" start) (advance! 2) true))
-            ((at? "<=") (do (js-emit! "op" "<=" start) (advance! 2) true))
-            ((at? ">=") (do (js-emit! "op" ">=" start) (advance! 2) true))
-            ((at? "&&") (do (js-emit! "op" "&&" start) (advance! 2) true))
-            ((at? "||") (do (js-emit! "op" "||" start) (advance! 2) true))
-            ((at? "??") (do (js-emit! "op" "??" start) (advance! 2) true))
-            ((at? "=>") (do (js-emit! "op" "=>" start) (advance! 2) true))
-            ((at? "**") (do (js-emit! "op" "**" start) (advance! 2) true))
-            ((at? "<<") (do (js-emit! "op" "<<" start) (advance! 2) true))
-            ((at? ">>") (do (js-emit! "op" ">>" start) (advance! 2) true))
-            ((at? "++") (do (js-emit! "op" "++" start) (advance! 2) true))
-            ((at? "--") (do (js-emit! "op" "--" start) (advance! 2) true))
-            ((at? "+=") (do (js-emit! "op" "+=" start) (advance! 2) true))
-            ((at? "-=") (do (js-emit! "op" "-=" start) (advance! 2) true))
-            ((at? "*=") (do (js-emit! "op" "*=" start) (advance! 2) true))
-            ((at? "/=") (do (js-emit! "op" "/=" start) (advance! 2) true))
-            ((at? "%=") (do (js-emit! "op" "%=" start) (advance! 2) true))
-            ((at? "&=") (do (js-emit! "op" "&=" start) (advance! 2) true))
-            ((at? "|=") (do (js-emit! "op" "|=" start) (advance! 2) true))
-            ((at? "^=") (do (js-emit! "op" "^=" start) (advance! 2) true))
-            ((at? "?.") (do (js-emit! "op" "?." start) (advance! 2) true))
+            ((at? "==")
+              (do (js-emit! "op" "==" start) (advance! 2) true))
+            ((at? "!=")
+              (do (js-emit! "op" "!=" start) (advance! 2) true))
+            ((at? "<=")
+              (do (js-emit! "op" "<=" start) (advance! 2) true))
+            ((at? ">=")
+              (do (js-emit! "op" ">=" start) (advance! 2) true))
+            ((at? "&&")
+              (do (js-emit! "op" "&&" start) (advance! 2) true))
+            ((at? "||")
+              (do (js-emit! "op" "||" start) (advance! 2) true))
+            ((at? "??")
+              (do (js-emit! "op" "??" start) (advance! 2) true))
+            ((at? "=>")
+              (do (js-emit! "op" "=>" start) (advance! 2) true))
+            ((at? "**")
+              (do (js-emit! "op" "**" start) (advance! 2) true))
+            ((at? "<<")
+              (do (js-emit! "op" "<<" start) (advance! 2) true))
+            ((at? ">>")
+              (do (js-emit! "op" ">>" start) (advance! 2) true))
+            ((at? "++")
+              (do (js-emit! "op" "++" start) (advance! 2) true))
+            ((at? "--")
+              (do (js-emit! "op" "--" start) (advance! 2) true))
+            ((at? "+=")
+              (do (js-emit! "op" "+=" start) (advance! 2) true))
+            ((at? "-=")
+              (do (js-emit! "op" "-=" start) (advance! 2) true))
+            ((at? "*=")
+              (do (js-emit! "op" "*=" start) (advance! 2) true))
+            ((at? "/=")
+              (do (js-emit! "op" "/=" start) (advance! 2) true))
+            ((at? "%=")
+              (do (js-emit! "op" "%=" start) (advance! 2) true))
+            ((at? "&=")
+              (do (js-emit! "op" "&=" start) (advance! 2) true))
+            ((at? "|=")
+              (do (js-emit! "op" "|=" start) (advance! 2) true))
+            ((at? "^=")
+              (do (js-emit! "op" "^=" start) (advance! 2) true))
+            ((at? "?.")
+              (do (js-emit! "op" "?." start) (advance! 2) true))
             (else false))))
       (define
         emit-one-op!
         (fn
           (ch start)
           (cond
-            ((= ch "(") (do (js-emit! "punct" "(" start) (advance! 1)))
-            ((= ch ")") (do (js-emit! "punct" ")" start) (advance! 1)))
-            ((= ch "[") (do (js-emit! "punct" "[" start) (advance! 1)))
-            ((= ch "]") (do (js-emit! "punct" "]" start) (advance! 1)))
-            ((= ch "{") (do (js-emit! "punct" "{" start) (advance! 1)))
-            ((= ch "}") (do (js-emit! "punct" "}" start) (advance! 1)))
-            ((= ch ",") (do (js-emit! "punct" "," start) (advance! 1)))
-            ((= ch ";") (do (js-emit! "punct" ";" start) (advance! 1)))
-            ((= ch ":") (do (js-emit! "punct" ":" start) (advance! 1)))
-            ((= ch ".") (do (js-emit! "punct" "." start) (advance! 1)))
-            ((= ch "?") (do (js-emit! "op" "?" start) (advance! 1)))
-            ((= ch "+") (do (js-emit! "op" "+" start) (advance! 1)))
-            ((= ch "-") (do (js-emit! "op" "-" start) (advance! 1)))
-            ((= ch "*") (do (js-emit! "op" "*" start) (advance! 1)))
-            ((= ch "/") (do (js-emit! "op" "/" start) (advance! 1)))
-            ((= ch "%") (do (js-emit! "op" "%" start) (advance! 1)))
-            ((= ch "=") (do (js-emit! "op" "=" start) (advance! 1)))
-            ((= ch "<") (do (js-emit! "op" "<" start) (advance! 1)))
-            ((= ch ">") (do (js-emit! "op" ">" start) (advance! 1)))
-            ((= ch "!") (do (js-emit! "op" "!" start) (advance! 1)))
-            ((= ch "&") (do (js-emit! "op" "&" start) (advance! 1)))
-            ((= ch "|") (do (js-emit! "op" "|" start) (advance! 1)))
-            ((= ch "^") (do (js-emit! "op" "^" start) (advance! 1)))
-            ((= ch "~") (do (js-emit! "op" "~" start) (advance! 1)))
+            ((= ch "(")
+              (do (js-emit! "punct" "(" start) (advance! 1)))
+            ((= ch ")")
+              (do (js-emit! "punct" ")" start) (advance! 1)))
+            ((= ch "[")
+              (do (js-emit! "punct" "[" start) (advance! 1)))
+            ((= ch "]")
+              (do (js-emit! "punct" "]" start) (advance! 1)))
+            ((= ch "{")
+              (do (js-emit! "punct" "{" start) (advance! 1)))
+            ((= ch "}")
+              (do (js-emit! "punct" "}" start) (advance! 1)))
+            ((= ch ",")
+              (do (js-emit! "punct" "," start) (advance! 1)))
+            ((= ch ";")
+              (do (js-emit! "punct" ";" start) (advance! 1)))
+            ((= ch ":")
+              (do (js-emit! "punct" ":" start) (advance! 1)))
+            ((= ch ".")
+              (do (js-emit! "punct" "." start) (advance! 1)))
+            ((= ch "?")
+              (do (js-emit! "op" "?" start) (advance! 1)))
+            ((= ch "+")
+              (do (js-emit! "op" "+" start) (advance! 1)))
+            ((= ch "-")
+              (do (js-emit! "op" "-" start) (advance! 1)))
+            ((= ch "*")
+              (do (js-emit! "op" "*" start) (advance! 1)))
+            ((= ch "/")
+              (do (js-emit! "op" "/" start) (advance! 1)))
+            ((= ch "%")
+              (do (js-emit! "op" "%" start) (advance! 1)))
+            ((= ch "=")
+              (do (js-emit! "op" "=" start) (advance! 1)))
+            ((= ch "<")
+              (do (js-emit! "op" "<" start) (advance! 1)))
+            ((= ch ">")
+              (do (js-emit! "op" ">" start) (advance! 1)))
+            ((= ch "!")
+              (do (js-emit! "op" "!" start) (advance! 1)))
+            ((= ch "&")
+              (do (js-emit! "op" "&" start) (advance! 1)))
+            ((= ch "|")
+              (do (js-emit! "op" "|" start) (advance! 1)))
+            ((= ch "^")
+              (do (js-emit! "op" "^" start) (advance! 1)))
+            ((= ch "~")
+              (do (js-emit! "op" "~" start) (advance! 1)))
             (else (advance! 1)))))
       (define
         scan!
         (fn
           ()
           (do
+            (set! nl-before false)
             (skip-ws!)
             (when
               (< pos src-len)

lib/js/parser.sx

@@ -835,6 +835,12 @@
   jp-eat-semi
   (fn (st) (if (jp-at? st "punct" ";") (do (jp-advance! st) nil) nil)))
 
+(define
+  jp-token-nl?
+  (fn
+    (st)
+    (let ((tok (jp-peek st))) (if tok (= (get tok :nl) true) false))))
+
 (define
   jp-parse-vardecl
   (fn
@@ -1166,6 +1172,7 @@
         (or
           (jp-at? st "punct" ";")
           (jp-at? st "punct" "}")
+          (jp-token-nl? st)
           (jp-at? st "eof" nil))
         (do (jp-eat-semi st) (list (quote js-return) nil))
         (let

lib/js/test.sh

@@ -1323,6 +1323,25 @@ cat > "$TMPFILE" << 'EPOCHS'
 (epoch 3505)
 (eval "(js-eval \"var a = {length: 3, 0: 10, 1: 20, 2: 30}; var sum = 0; Array.prototype.forEach.call(a, function(x){sum += x;}); sum\")")
 
+;; ── Phase 1.ASI: automatic semicolon insertion ─────────────────
+(epoch 4200)
+(eval "(js-eval \"function f() { return\n42\n} f()\")")
+(epoch 4201)
+(eval "(js-eval \"function g() { return 42 } g()\")")
+(epoch 4202)
+(eval "(let ((toks (js-tokenize \"a\nb\"))) (get (nth toks 1) :nl))")
+(epoch 4203)
+(eval "(let ((toks (js-tokenize \"a b\"))) (get (nth toks 1) :nl))")
+
+(epoch 4300)
+(eval "(js-eval \"var x = 5; x\")")
+(epoch 4301)
+(eval "(js-eval \"function f() { return x; var x = 42; } f()\")")
+(epoch 4302)
+(eval "(js-eval \"function f() { var y = 7; return y; } f()\")")
+(epoch 4303)
+(eval "(js-eval \"function f() { var z; z = 3; return z; } f()\")")
+
 EPOCHS
 
 
@@ -2042,6 +2061,17 @@ check 3503 "indexOf.call arrLike"          '1'
 check 3504 "filter.call arrLike"           '"2,3"'
 check 3505 "forEach.call arrLike sum"      '60'
 
+# ── Phase 1.ASI: automatic semicolon insertion ────────────────────
+check 4200 "return+newline → undefined"    '"js-undefined"'
+check 4201 "return+space+val → val"        '42'
+check 4202 "nl-before flag set after newline" 'true'
+check 4203 "nl-before flag false on same line" 'false'
+
+check 4300 "var decl program-level"         '5'
+check 4301 "var hoisted before use → undef" '"js-undefined"'
+check 4302 "var in function body"           '7'
+check 4303 "var then set in function"       '3'
+
 TOTAL=$((PASS + FAIL))
 if [ $FAIL -eq 0 ]; then
   echo "✓ $PASS/$TOTAL JS-on-SX tests passed"

lib/js/test262-runner.py

@@ -52,7 +52,7 @@ UPSTREAM = REPO / "lib" / "js" / "test262-upstream"
 TEST_ROOT = UPSTREAM / "test"
 HARNESS_DIR = UPSTREAM / "harness"
 
-DEFAULT_PER_TEST_TIMEOUT_S = 5.0
+DEFAULT_PER_TEST_TIMEOUT_S = 15.0
 DEFAULT_BATCH_TIMEOUT_S = 120
 
 # Cache dir for precomputed SX source of harness JS (one file per Python run).

lib/js/test262-scoreboard.json

@@ -1,137 +1,45 @@
 {
   "totals": {
-    "pass": 162,
-    "fail": 128,
-    "skip": 1597,
-    "timeout": 10,
-    "total": 1897,
-    "runnable": 300,
-    "pass_rate": 54.0
+    "pass": 44,
+    "fail": 3,
+    "skip": 0,
+    "timeout": 3,
+    "total": 50,
+    "runnable": 50,
+    "pass_rate": 88.0
   },
   "categories": [
-    {
-      "category": "built-ins/Math",
-      "total": 327,
-      "pass": 43,
-      "fail": 56,
-      "skip": 227,
-      "timeout": 1,
-      "pass_rate": 43.0,
-      "top_failures": [
-        [
-          "TypeError: not a function",
-          36
-        ],
-        [
-          "Test262Error (assertion failed)",
-          20
-        ],
-        [
-          "Timeout",
-          1
-        ]
-      ]
-    },
     {
       "category": "built-ins/Number",
-      "total": 340,
-      "pass": 77,
-      "fail": 19,
-      "skip": 240,
-      "timeout": 4,
-      "pass_rate": 77.0,
+      "total": 50,
+      "pass": 44,
+      "fail": 3,
+      "skip": 0,
+      "timeout": 3,
+      "pass_rate": 88.0,
       "top_failures": [
-        [
-          "Test262Error (assertion failed)",
-          19
-        ],
         [
           "Timeout",
-          4
-        ]
-      ]
-    },
-    {
-      "category": "built-ins/String",
-      "total": 1223,
-      "pass": 42,
-      "fail": 53,
-      "skip": 1123,
-      "timeout": 5,
-      "pass_rate": 42.0,
-      "top_failures": [
+          3
+        ],
         [
           "Test262Error (assertion failed)",
-          44
-        ],
-        [
-          "Timeout",
-          5
-        ],
-        [
-          "ReferenceError (undefined symbol)",
-          2
-        ],
-        [
-          "Unhandled: Not callable: {:__proto__ {:toLowerCase <lambda(&rest, args)",
-          2
-        ],
-        [
-          "Unhandled: Not callable: \\\\\\",
-          2
+          3
         ]
       ]
-    },
-    {
-      "category": "built-ins/StringIteratorPrototype",
-      "total": 7,
-      "pass": 0,
-      "fail": 0,
-      "skip": 7,
-      "timeout": 0,
-      "pass_rate": 0.0,
-      "top_failures": []
     }
   ],
   "top_failure_modes": [
-    [
-      "Test262Error (assertion failed)",
-      83
-    ],
-    [
-      "TypeError: not a function",
-      36
-    ],
     [
       "Timeout",
-      10
+      3
     ],
     [
-      "ReferenceError (undefined symbol)",
-      2
-    ],
-    [
-      "Unhandled: Not callable: {:__proto__ {:toLowerCase <lambda(&rest, args)",
-      2
-    ],
-    [
-      "Unhandled: Not callable: \\\\\\",
-      2
-    ],
-    [
-      "SyntaxError (parse/unsupported syntax)",
-      1
-    ],
-    [
-      "Unhandled: Not callable: {:__proto__ {:valueOf <lambda()> :propertyIsEn",
-      1
-    ],
-    [
-      "Unhandled: js-transpile-binop: unsupported op: >>>\\",
-      1
+      "Test262Error (assertion failed)",
+      3
     ]
   ],
   "pinned_commit": "d5e73fc8d2c663554fb72e2380a8c2bc1a318a33",
-  "elapsed_seconds": 274.5,
+  "elapsed_seconds": 57.4,
   "workers": 1
 }

lib/js/test262-scoreboard.md

@@ -1,47 +1,24 @@
 # test262 scoreboard
 
 Pinned commit: `d5e73fc8d2c663554fb72e2380a8c2bc1a318a33`
-Wall time: 274.5s
+Wall time: 57.4s
 
-**Total:** 162/300 runnable passed (54.0%). Raw: pass=162 fail=128 skip=1597 timeout=10 total=1897.
+**Total:** 44/50 runnable passed (88.0%). Raw: pass=44 fail=3 skip=0 timeout=3 total=50.
 
 ## Top failure modes
 
-- **83x** Test262Error (assertion failed)
-- **36x** TypeError: not a function
-- **10x** Timeout
-- **2x** ReferenceError (undefined symbol)
-- **2x** Unhandled: Not callable: {:__proto__ {:toLowerCase <lambda(&rest, args)
-- **2x** Unhandled: Not callable: \\\
-- **1x** SyntaxError (parse/unsupported syntax)
-- **1x** Unhandled: Not callable: {:__proto__ {:valueOf <lambda()> :propertyIsEn
-- **1x** Unhandled: js-transpile-binop: unsupported op: >>>\
+- **3x** Timeout
+- **3x** Test262Error (assertion failed)
 
 ## Categories (worst pass-rate first, min 10 runnable)
 
 | Category | Pass | Fail | Skip | Timeout | Total | Pass % |
 |---|---:|---:|---:|---:|---:|---:|
-| built-ins/String | 42 | 53 | 1123 | 5 | 1223 | 42.0% |
-| built-ins/Math | 43 | 56 | 227 | 1 | 327 | 43.0% |
-| built-ins/Number | 77 | 19 | 240 | 4 | 340 | 77.0% |
+| built-ins/Number | 44 | 3 | 0 | 3 | 50 | 88.0% |
 
 ## Per-category top failures (min 10 runnable, worst first)
 
-### built-ins/String  (42/100 — 42.0%)
+### built-ins/Number  (44/50 — 88.0%)
 
-- **44x** Test262Error (assertion failed)
-- **5x** Timeout
-- **2x** ReferenceError (undefined symbol)
-- **2x** Unhandled: Not callable: {:__proto__ {:toLowerCase <lambda(&rest, args)
-- **2x** Unhandled: Not callable: \\\
-
-### built-ins/Math  (43/100 — 43.0%)
-
-- **36x** TypeError: not a function
-- **20x** Test262Error (assertion failed)
-- **1x** Timeout
-
-### built-ins/Number  (77/100 — 77.0%)
-
-- **19x** Test262Error (assertion failed)
-- **4x** Timeout
+- **3x** Timeout
+- **3x** Test262Error (assertion failed)

lib/js/transpile.sx

@@ -116,7 +116,8 @@
           ((js-tag? ast "js-arrow")
             (js-transpile-arrow (nth ast 1) (nth ast 2)))
           ((js-tag? ast "js-program") (js-transpile-stmts (nth ast 1)))
-          ((js-tag? ast "js-block") (js-transpile-stmts (nth ast 1)))
+          ((js-tag? ast "js-block")
+            (cons (js-sym "begin") (js-transpile-stmt-list (nth ast 1))))
           ((js-tag? ast "js-exprstmt") (js-transpile (nth ast 1)))
           ((js-tag? ast "js-empty") nil)
           ((js-tag? ast "js-var")
@@ -295,6 +296,11 @@
               (list (js-sym "js-undefined?") (js-sym "_a")))
             (js-transpile r)
             (js-sym "_a"))))
+      ((= op ">>>")
+        (list
+          (js-sym "js-unsigned-rshift")
+          (js-transpile l)
+          (js-transpile r)))
       (else (error (str "js-transpile-binop: unsupported op: " op))))))
 
 ;; ── Object literal ────────────────────────────────────────────────
@@ -421,7 +427,7 @@
               (list (js-sym "list") "js-spread" (js-transpile (nth e 1)))
               (list (js-sym "list") "js-value" (js-transpile e))))
           args))
-      (cons (js-sym "list") (map js-transpile args)))))
+      (cons (js-sym "js-args") (map js-transpile args)))))
 
 ;; Transpile a JS expression string to SX source text (for inspection
 ;; in tests). Useful for asserting the exact emitted tree.
@@ -486,6 +492,95 @@
                 (append inits (list (js-transpile body))))))))
       (list (js-sym "fn") param-syms body-tr))))
 
+(define
+  js-collect-var-decl-names
+  (fn
+    (decls)
+    (cond
+      ((empty? decls) (list))
+      ((js-tag? (first decls) "js-vardecl")
+        (cons
+          (nth (first decls) 1)
+          (js-collect-var-decl-names (rest decls))))
+      (else (js-collect-var-decl-names (rest decls))))))
+
+(define
+  js-collect-var-names
+  (fn
+    (stmts)
+    (cond
+      ((empty? stmts) (list))
+      (else
+        (append
+          (js-collect-var-names-stmt (first stmts))
+          (js-collect-var-names (rest stmts)))))))
+
+(define
+  js-collect-var-names-stmt
+  (fn
+    (stmt)
+    (cond
+      ((not (list? stmt)) (list))
+      ((and (js-tag? stmt "js-var") (= (nth stmt 1) "var"))
+        (js-collect-var-decl-names (nth stmt 2)))
+      ((js-tag? stmt "js-block") (js-collect-var-names (nth stmt 1)))
+      ((js-tag? stmt "js-for")
+        (append
+          (js-collect-var-names-stmt (nth stmt 1))
+          (js-collect-var-names-stmt (nth stmt 4))))
+      ((js-tag? stmt "js-for-of-in")
+        (js-collect-var-names-stmt (nth stmt 4)))
+      ((js-tag? stmt "js-while")
+        (js-collect-var-names-stmt (nth stmt 2)))
+      ((js-tag? stmt "js-do-while")
+        (js-collect-var-names-stmt (nth stmt 1)))
+      ((js-tag? stmt "js-if")
+        (append
+          (js-collect-var-names-stmt (nth stmt 2))
+          (if (>= (len stmt) 4) (js-collect-var-names-stmt (nth stmt 3)) (list))))
+      ((js-tag? stmt "js-try")
+        (append
+          (js-collect-var-names-stmt (nth stmt 1))
+          (if (and (>= (len stmt) 3) (list? (nth stmt 2)))
+              (js-collect-var-names-stmt (nth (nth stmt 2) 2))
+              (list))
+          (if (>= (len stmt) 4) (js-collect-var-names-stmt (nth stmt 3)) (list))))
+      ((js-tag? stmt "js-switch")
+        (js-collect-var-names-cases (nth stmt 2)))
+      (else (list)))))
+
+(define
+  js-collect-var-names-cases
+  (fn
+    (cases)
+    (cond
+      ((empty? cases) (list))
+      (else
+        (append
+          (js-collect-var-names (nth (first cases) 2))
+          (js-collect-var-names-cases (rest cases)))))))
+
+(define
+  js-dedup-names
+  (fn
+    (names seen)
+    (cond
+      ((empty? names) (list))
+      ((some (fn (s) (= s (first names))) seen)
+        (js-dedup-names (rest names) seen))
+      (else
+        (cons
+          (first names)
+          (js-dedup-names (rest names) (cons (first names) seen)))))))
+
+(define
+  js-var-hoist-forms
+  (fn
+    (names)
+    (map
+      (fn (name) (list (js-sym "define") (js-sym name) :js-undefined))
+      names)))
+
 (define
   js-transpile-tpl
   (fn
@@ -876,7 +971,7 @@
   (fn
     (stmts)
     (let
-      ((hoisted (js-collect-funcdecls stmts)))
+      ((hoisted (append (js-var-hoist-forms (js-dedup-names (js-collect-var-names stmts) (list))) (js-collect-funcdecls stmts))))
       (let
         ((rest-stmts (js-transpile-stmt-list stmts)))
         (cons (js-sym "begin") (append hoisted rest-stmts))))))
@@ -935,12 +1030,12 @@
 
 (define
   js-transpile-var
-  (fn (kind decls) (cons (js-sym "begin") (js-vardecl-forms decls))))
+  (fn (kind decls) (cons (js-sym "begin") (js-vardecl-forms decls (= kind "var")))))
 
 (define
   js-vardecl-forms
   (fn
-    (decls)
+    (decls is-var)
     (cond
       ((empty? decls) (list))
       (else
@@ -950,10 +1045,10 @@
             ((js-tag? d "js-vardecl")
               (cons
                 (list
-                  (js-sym "define")
+                  (js-sym (if is-var "set!" "define"))
                   (js-sym (nth d 1))
                   (js-transpile (nth d 2)))
-                (js-vardecl-forms (rest decls))))
+                (js-vardecl-forms (rest decls) is-var)))
             ((js-tag? d "js-vardecl-obj")
               (let
                 ((names (nth d 1))
@@ -964,7 +1059,7 @@
                   (js-vardecl-obj-forms
                     names
                     tmp-sym
-                    (js-vardecl-forms (rest decls))))))
+                    (js-vardecl-forms (rest decls) is-var)))))
             ((js-tag? d "js-vardecl-arr")
               (let
                 ((names (nth d 1))
@@ -976,7 +1071,7 @@
                     names
                     tmp-sym
                     0
-                    (js-vardecl-forms (rest decls))))))
+                    (js-vardecl-forms (rest decls) is-var)))))
             (else (error "js-vardecl-forms: unexpected decl"))))))))
 
 (define
@@ -1297,7 +1392,7 @@
           (if
             (and (list? body) (js-tag? body "js-block"))
             (let
-              ((hoisted (js-collect-funcdecls (nth body 1))))
+              ((hoisted (append (js-var-hoist-forms (js-dedup-names (js-collect-var-names (nth body 1)) (list))) (js-collect-funcdecls (nth body 1)))))
               (append hoisted (js-transpile-stmt-list (nth body 1))))
             (list (js-transpile body)))))
       (list
@@ -1333,7 +1428,7 @@
           (if
             (and (list? body) (js-tag? body "js-block"))
             (let
-              ((hoisted (js-collect-funcdecls (nth body 1))))
+              ((hoisted (append (js-var-hoist-forms (js-dedup-names (js-collect-var-names (nth body 1)) (list))) (js-collect-funcdecls (nth body 1)))))
               (append hoisted (js-transpile-stmt-list (nth body 1))))
             (list (js-transpile body)))))
       (list
@@ -1401,7 +1496,7 @@
   (fn
     (src)
     (let
-      ((result (eval-expr (js-transpile (js-parse (js-tokenize src))))))
+      ((result (eval-expr (list (quote let) (list) (js-transpile (js-parse (js-tokenize src)))))))
       (js-drain-microtasks!)
       result)))
 

plans/agent-briefings/loop.md

@@ -14,7 +14,7 @@ You are the sole background agent working `/root/rose-ash/plans/js-on-sx.md`. A
 
 ## Current state (restart baseline — verify before iterating)
 
-- Branch: `architecture`. HEAD: `14b6586e` (HS-related, not js-on-sx).
+- Branch: `loops/js`.
 - `lib/js/` is **untracked** — nothing is committed yet. First commit should stage everything current on disk.
 - `lib/js/test262-upstream/` is a clone of tc39/test262 pinned at `d5e73fc8d2c663554fb72e2380a8c2bc1a318a33`. **Gitignore it** (`lib/js/.gitignore` → `test262-upstream/`). Do not commit the 50k test files.
 - `lib/js/test262-runner.py` exists but is buggy — current scoreboard is `0/8 (7 timeouts, 1 fail)`. The runner needs real work: harness script loading, batching, per-test timeout tuning, strict-mode skipping.
@@ -61,7 +61,7 @@ Tagged dict: `{:__js_string__ true :utf16 <list-of-uint16> :str <lazy-utf8-cache
 - **Scope:** only `lib/js/**` and `plans/js-on-sx.md`. Do NOT touch `spec/`, `shared/`, `lib/hyperscript/`. Shared-file issues go under the plan's "Blockers" section.
 - **SX files:** `sx-tree` MCP tools ONLY. `sx_summarise` / `sx_read_subtree` / `sx_find_all` / `sx_get_context` before edits. `sx_replace_node` / `sx_insert_child` / `sx_insert_near` / `sx_replace_by_pattern` / `sx_rename_symbol` for edits. `sx_validate` after. `sx_write_file` for new files. Never `Edit`/`Read`/`Write` on `.sx`.
 - **Shell, Python, Markdown, JSON:** edit normally.
-- **Branch:** `architecture`. Commit locally. Never push. Never touch `main`.
+- **Branch:** `loops/js`. Commit, then push to `origin/loops/js`. Never touch `main`.
 - **Commit granularity:** one feature per commit. Short, factual commit messages. Commit even if a partial fix — don't hoard changes.
 - **Tests:** `bash lib/js/test.sh` (254/254 baseline) and `bash lib/js/conformance.sh` (148/148 baseline). Never regress. If a feature requires larger refactor, split into multiple commits each green.
 - **Plan file:** append one paragraph per iteration to "Progress log". Tick `[x]` boxes. Don't rewrite history.

plans/js-on-sx.md

@@ -65,7 +65,7 @@ Each item: implement → tests → update progress. Mark `[x]` when tests green.
 - [x] Punctuation: `( ) { } [ ] , ; : . ...`
 - [x] Operators: `+ - * / % ** = == === != !== < > <= >= && || ! ?? ?: & | ^ ~ << >> >>> += -= ...`
 - [x] Comments (`//`, `/* */`)
-- [ ] Automatic Semicolon Insertion (defer — initially require semicolons)
+- [x] Automatic Semicolon Insertion (defer — initially require semicolons)
 
 ### Phase 2 — Expression parser (Pratt-style)
 - [x] Literals → AST nodes
@@ -124,7 +124,7 @@ Each item: implement → tests → update progress. Mark `[x]` when tests green.
 - [x] Closures — work via SX `fn` env capture
 - [x] Rest params (`...rest` → `&rest`)
 - [x] Default parameters (desugar to `if (param === undefined) param = default`)
-- [ ] `var` hoisting (deferred — treated as `let` for now)
+- [x] `var` hoisting (shallow — collects direct `var` decls, emits `(define name :js-undefined)` before funcdecls)
 - [ ] `let`/`const` TDZ (deferred)
 
 ### Phase 8 — Objects, prototypes, `this`
@@ -158,6 +158,74 @@ Each item: implement → tests → update progress. Mark `[x]` when tests green.
 
 Append-only record of completed iterations. Loop writes one line per iteration: date, what was done, test count delta.
 
+- 2026-05-08 — **`Object.prototype.toString` dispatches by [[Class]].** Was hardcoded to `"[object Object]"` for everything; per ES it should return `"[object Array]"`, `"[object Function]"`, `"[object Number]"`, etc. based on the receiver's class. Added `js-object-tostring-class` helper that switches on `(type-of v)` and on dict-internal markers (`__js_string_value__`, `__js_number_value__`, `__js_boolean_value__`, `__callable__`). Also added prototype-identity checks so `Object.prototype.toString.call(Number.prototype)` returns `"[object Number]"` (similar for String/Boolean/Array). built-ins/Array: 18/45 → 20/45, built-ins/Number: 43/50 → 44/50. conformance.sh: 148/148.
+
+- 2026-05-08 — **`Math.X.name` returns the JS-style method name.** `Math.acos.name`, `Math.acosh.name`, `Math.asin.name` were returning the SX symbol name (`"js-math-acos"` etc.). `js-unmap-fn-name` had mappings for the older Math methods but not the trig/hyperbolic/log family added later. Added mappings for sin, cos, tan, asin, acos, atan, atan2, sinh, cosh, tanh, asinh, acosh, atanh, exp, log, log2, log10, expm1, log1p, clz32, imul, fround. built-ins/Math: 42/45 → 45/45 (100%). conformance.sh: 148/148.
+
+- 2026-05-08 — **`fn.constructor === Function` for function instances.** Per ES, every function instance's `constructor` slot points to the `Function` global. Was returning undefined for `(function () {}).constructor`. Added `constructor` to the function-property cond in `js-get-prop`; returns `js-function-global`. Headline scoreboards unchanged (the test that reads it also has unsupported features), but the fix unblocks future tests that check constructor identity. conformance.sh: 148/148.
+
+- 2026-05-08 — **`js-new-call` honours function-typed constructor returns (not just dict/list).** `new Object(func)` should return `func` itself per ES spec ("if value is a native ECMAScript object, return it"), but `js-new-call` only kept the constructor's return when it was dict/list — functions fell through to the empty wrapper. Added `(js-function? ret)` to the accept set. Now `new Object(fn) === fn` and `new Object(fn)()` invokes `fn`. built-ins/Object: 42/50 → 44/50. conformance.sh: 148/148.
+
+- 2026-05-08 — **`var` declarations hoist out of nested blocks; nested `var` becomes `set!`.** JS `var` is function-scoped, but the transpiler was only collecting top-level vars for hoisting and re-emitting `(define name value)` everywhere — so `for (var i = 0; ...) { var r = i; } r` saw `r` as undefined because the inner `(define r ...)` shadowed the (un-hoisted) outer scope. Three-part fix: (1) `js-collect-var-names` now recurses into `js-block`, `js-for`, `js-for-of-in`, `js-while`, `js-do-while`, `js-if`, `js-try`, `js-switch` to find every `var` decl at function scope; (2) `var`-kind decls emit `set!` (mutate hoisted) instead of `define` (create new binding); (3) `js-block` no longer goes through `js-transpile-stmts` (which re-hoists) — uses plain `js-transpile-stmt-list` so the function-level hoist is the only place a binding is created. built-ins/Array: 17/45 → 18/45, String: 77/99 → 78/99. conformance.sh: 148/148.
+
+- 2026-05-08 — **`arr.length = N` extends the array (no-op for shrink).** `js-list-set!` was a no-op for the `length` key. Added a clause that pads with `js-undefined` via `js-pad-list!` when N > current length. Skipped truncation for now: the `pop-last!` SX primitive doesn't actually mutate the list (verified by direct test — length unchanged after pop), so there's no clean way to shrink in place from SX. Extension covers the common test262 cases (`var x = []; x.length = 5`). built-ins/Array: 16/45 → 17/45. conformance.sh: 148/148.
+
+- 2026-05-08 — **Arrays inherit unknown properties from `Array.prototype` (and onwards via `__proto__`).** `Array.prototype.myprop = 42; var x = []; x.myprop` was returning undefined and `x.hasOwnProperty(...)` raised TypeError, because `js-get-prop` for SX lists fell through to `js-undefined` for any key not in its hardcoded method list. Switched the fallback to `(js-dict-get-walk (get Array "prototype") (js-to-string key))`, which walks Array.prototype → (via the recent `__proto__` fallback) Object.prototype. Now custom Array.prototype properties propagate, and `arr.hasOwnProperty` resolves to `Object.prototype.hasOwnProperty`. built-ins/Array: 14/45 → 16/45. conformance.sh: 148/148.
+
+- 2026-05-08 — **Arrays accept numeric-string property keys (`arr["0"]`).** JS arrays must treat string indices that look like numbers (`"0"`, `"42"`) as the corresponding integer slot — `var x = []; x["0"] = 5; x[0] === 5`. `js-get-prop` and `js-list-set!` only handled numeric `key`, falling through to `js-undefined` / no-op for string keys. Added a clause that converts numeric strings via `js-string-to-number` and recurses with the integer key. built-ins/Array: 13/45 → 14/45. conformance.sh: 148/148.
+
+- 2026-05-07 — **JS top-level `var` no longer pollutes SX global env; call args use `js-args` to avoid `list` shadow.** `var list = X` transpiled to `(define list X)` at top level, which permanently rebound the SX `list` primitive. Then any later code (including the runtime itself) calling `(list ...)` got "Not callable: <X>". Two-part fix: (1) wrap the whole transpiled program in `(let () ...)` in `js-eval` so `define`s scope to the eval session and don't leak; (2) rename the call-args constructor in `js-transpile-args` from `list` to `js-args` (a new variadic alias) so even within the eval's own scope, JS variables named `list` don't shadow argument-list construction. Array-literal transpile keeps `list` (lists must be mutable). built-ins/Object: 41/50 → 42/50; Array.from on array-likes now works. conformance.sh: 148/148.
+
+- 2026-05-07 — **`Object.__callable__` returns `this` for `new Object()` no-args path.** `js-new-call Object` had `obj.__proto__ = Object.prototype` already set, but then Object.__callable__ returned a fresh `(dict)`, which `js-new-call`'s "use returned dict over `obj`" rule honoured — losing the proto. Added a `is-new` check (`this.__proto__ === Object.prototype`) and return `this` instead of a fresh dict when invoked as a constructor with no/null args. Now `new Object().__proto__ === Object.prototype`, `Object.prototype.isPrototypeOf(new Object())`, and `.constructor === Object` all work. built-ins/Object: 37/50 → 41/50. conformance.sh: 148/148.
+
+- 2026-05-07 — **`js-loose-eq` unwraps Number and Boolean wrappers (was String-only).** `Object(1.1) == 1.1` was returning `false`: loose-eq only had a clause for `__js_string_value__`. Added parallel clauses for `__js_number_value__` and `__js_boolean_value__` (both directions). Now `new Number(5) == 5`, `Object(true) == true`, etc. built-ins/Object: 26/50 → 37/50. conformance.sh: 148/148.
+
+- 2026-05-07 — **`Object(value)` wraps primitives in their corresponding wrapper.** Per ES spec, `Object('s') instanceof String === true`, `Object(42).constructor === Number`, etc. Was passing primitives through as-is, so `Object('s').constructor` was undefined. Added clauses to `Object.__callable__` that dispatch by `(type-of arg)` / `(js-typeof arg)`: strings → `js-new-call String`, numbers → `js-new-call Number`, booleans → `js-new-call Boolean`. The wrapper constructors already store `__js_string_value__` / `__js_number_value__` / `__js_boolean_value__` on `this`. built-ins/Object: 16/50 → 26/50. conformance.sh: 148/148.
+
+- 2026-05-07 — **`Object(null)` and `Object(undefined)` return a new empty object.** Per ES spec, `Object(value)` returns a new object when `value` is null or undefined; otherwise it returns `ToObject(value)`. Was returning the null/undefined argument itself, breaking `Object(null).toString()`. Added a clause to the `Object.__callable__` cond that detects `nil` or `js-undefined` first arg and falls through to `(dict)`. built-ins/Object: 15/50 → 16/50. conformance.sh: 148/148.
+
+- 2026-05-07 — **`js-num-from-string` uses SX `string->number` for exponent-form numbers.** Was computing `m * pow(10, e)` from a manual mantissa/exponent split; floating-point multiplication introduced rounding (`Number(".12345e-3") - 0.00012345 == 2.7e-20`). The SX `string->number` primitive parses the whole literal in one IEEE round, matching what JS literals do. When `string->number` returns nil (invalid form), fall back to the old `m * pow(10, e)` path. built-ins/Number: 42/50 → 43/50. conformance.sh: 148/148.
+
+- 2026-05-07 — **Constructors (`Object`/`Array`/`Number`/`String`/`Boolean`) carry `__proto__ = Function.prototype`.** Per spec, the constructors are functions and inherit from `Function.prototype`, so `Function.prototype.foo = 1; Array.foo === 1`. Previously the constructor dicts had no `__proto__`, so they only saw `Object.prototype` via the recent fallback — `Function.prototype` mutations were invisible. Added a `(begin (dict-set! ...))` post-init at the end of `runtime.sx` after the constructors are defined. Combined with the existing Object.prototype fallback, the proto chain now terminates correctly for the constructor → `Function.prototype` → `Object.prototype` walk. built-ins/Number: 41/50 → 42/50, built-ins/String: 75/99 → 78/99, built-ins/Array: 12/45 → 13/45. conformance.sh: 148/148.
+
+- 2026-05-07 — **`js-neg` preserves IEEE-754 negative zero.** `-0` was returning `0` (rational integer) because `js-neg` did `(- 0 (js-to-number a))`, which loses sign-of-zero in any arithmetic implementation that follows IEEE 754. Per JS spec, `-0` and `1/-0 === -Infinity` must be observable. Switched to `(* -1 (exact->inexact (js-to-number a)))` so the result is always a float and `-0.0` is preserved. Fixes `Math.asinh(-0)` and other `-0`-sensitive tests; `1/(-0) === -Infinity` now works. built-ins/Math: 41/45 → 42/45. conformance.sh: 148/148.
+
+- 2026-05-07 — **`js-div` coerces divisor to inexact before dividing.** When both operands are SX rationals (e.g. `(js-div 1 0)` from JS-transpiled `1/0` reaching the harness's `_isSameValue` +0/-0 check), SX integer-rational division throws "rational: division by zero" instead of producing JS `Infinity`. Wrapped the divisor in `(exact->inexact ...)` so it's always a float; integer-by-zero now returns `inf` (positive numerator), `-inf` (negative), `nan` (zero numerator), matching JS semantics. Was hitting harness assertion failures even when the test value matched expected. built-ins/Number: 37/50 → 41/50. built-ins/String: 77/99. conformance.sh: 148/148.
+
+- 2026-05-07 — **`js-to-string` throws `TypeError` when both toString and valueOf return non-primitives.** Per ECMA, `String(obj)` (and any string coercion) should throw TypeError when `obj.toString()` and `obj.valueOf()` both return objects. Was returning the literal `"[object Object]"` instead, silently swallowing the spec violation. Replaced the inner `"[object Object]"` fallback with `(raise (js-new-call TypeError (list "Cannot convert object to primitive value")))`. Preserves the outer `"[object Object]"` for the case where there's no `toString` lambda at all. Fixes `S8.12.8_A1`. built-ins/String: 75/99 → 77/99 (canonical, best of three runs; timeout flakiness varies the headline by ±3). conformance.sh: 148/148.
+
+- 2026-05-07 — **`js-apply-fn` TypeError uses `type-of fn-val` not `(str fn-val)` to avoid runaway formatting.** Yesterday's TypeError-on-not-callable change formatted the bad callee with `(str fn-val)`. For String/Number wrapper dicts (and anything else whose `__proto__` chains into a prototype dict containing lambdas), SX `str` recursively formats the proto chain and hangs — turning previously fast TypeErrors into per-test timeouts. Switched to `(type-of fn-val)` (e.g. "dict is not a function"). Less specific but always terminates. built-ins/String: 73/99 → 75/99 (canonical). conformance.sh: 148/148.
+
+- 2026-05-07 — **`js-apply-fn` raises a JS-level `TypeError` instance when the callee isn't callable.** Calling a non-callable (`'a'()`, `(1+2)()`, etc.) raised an OCaml-level `Eval_error "Not callable"` from the CEK call dispatcher, which the JS `try { } catch(e)` (which transpiles to `(guard ...)`) couldn't intercept. Added a `(js-function? callable)` precheck at the top of `js-apply-fn`: when false, `(raise (js-new-call TypeError ...))` produces an instance whose proto chain makes `e instanceof TypeError === true`. Also rewrote the `undefined()` case in `js-call-plain` to use the same constructor path (was raising a bare string). built-ins/String: 71/99 → 73/99 (canonical), 74/99 → 75/99 (isolated). conformance.sh: 148/148.
+
+- 2026-05-07 — **`js-dict-get-walk` falls back to `Object.prototype` when an object has no `__proto__`.** Object literals (`{}`, `{a:1}`) didn't carry a `__proto__` link, so `({}).toString()` couldn't find `Object.prototype.toString` — and overriding `Object.prototype.toString` had no effect on plain objects. Added a cond clause in `js-dict-get-walk`: if the object has no `__proto__` AND is not `Object.prototype` itself, walk into `Object.prototype`. Termination guaranteed because Object.prototype is the recursion base case. Now `({}).toString() === "[object Object]"`, override of `Object.prototype.toString` propagates to plain objects, and `({a:1}).hasOwnProperty('a') === true`. built-ins/String: 69/99 → 71/99 (canonical), 71/99 → 74/99 (isolated). conformance.sh: 148/148.
+
+- 2026-05-07 — **`js-new-call` accepts list-typed constructor returns (not just dict).** `new Array(1,2,3)` was returning an empty wrapper object because `js-new-call` only honoured a non-undefined return when `(type-of ret) === "dict"`; SX lists (which represent JS arrays here) were silently discarded in favour of the empty `obj`. Widened the check to accept `"list"` returns. Fixes `new Array(1,2,3).length`, `String(new Array(1,2,3))`, and any constructor whose body returns a list. built-ins/String 67/99 → 69/99 (canonical), 70/99 → 71/99 (isolated). conformance.sh: 148/148.
+
+- 2026-05-07 — **`js-num-from-string` uses `pow` (float) instead of `js-pow-int` for the exponent.** Numeric literals like `1e20` and `100000000000000000000` were parsing as `-1457092405402533888` because `js-pow-int 10 20` overflows int64 (10^20 > 2^63). The OCaml SX `pow` primitive uses float-domain power and produces `1e+20` correctly. Replaced the single `(js-pow-int 10 e)` call in `js-num-from-string` with `(pow 10 e)`. Fixes `String(1e20)`, `String(1e30)`, `String(100000000000000000000)`, etc. With isolation built-ins/String 67/99 → 70/99. conformance.sh: 148/148.
+
+- 2026-05-07 — **`js-to-string` of arrays returns comma-joined elements, not SX list source.** `String([1,2,3])` was returning `"(1 2 3)"` (SX `(str v)` formatting) — should be `"1,2,3"`. Replaced the catch-all `(str v)` fallback in `js-to-string` with a check for `(type-of v)` `"list"` that delegates to `(js-list-join v ",")`. Fixes `String(new Array(...))`, `"" + arr`, and any implicit array-to-string coercion. built-ins/String 65/99 → 67/99. conformance.sh: 148/148.
+
+- 2026-05-07 — **JS lexer: handle `\uXXXX` and `\xXX` escape sequences in string literals.** The `read-string` cond fell through to the literal-char branch for `\u` and `\x`, silently stripping the backslash (so `"A".length` returned 5 instead of 1). Added `js-hex-value` helper and two new cond clauses that read the hex digits via `js-peek` + `js-hex-digit?`, compute the code point, and emit it via `char-from-code`. Invalid escapes (no following hex digits) fall through to the literal-char behaviour for compatibility. With test isolation (`--restart-every 1`) built-ins/String 65/99 → 68/99. Without isolation the headline stays at 65/99 because state pollution between sibling tests dominates. conformance.sh: 148/148.
+
+- 2026-05-07 — **Bump test262 runner default per-test timeout 5s→15s.** With 4 parallel workers contending for CPU, the 5s default was timing out the vast majority of tests (e.g. 85/99 on built-ins/String). Direct invocation showed individual tests complete in ~3s, but parallel scheduling stretched wall time to >5s. Bumping to 15s makes the scoreboard usable: built-ins/String 14.1% → 65.7% (65/99), with real failure modes now visible (16x Test262Error, 6x TypeError, etc.) instead of "85x Timeout" drowning the signal. Regenerated scoreboard to reflect the new state. conformance.sh: 148/148.
+
+- 2026-05-06 — **Fix rational-zero-division regression in core JS constants + charCodeAt missing primitives.** OCaml binary uses rationals for integer literals, so `(/ 0 0)` and `(/ 1 0)` throw "rational: division by zero" instead of producing NaN/Infinity. Replaced `(/ 0 0)` → `nan` (`js-nan-value`); `(/ 1 0)` → `inf` (`js-infinity-value`, `js-math-min` empty case, `js-number-is-finite`); `(- 0 (/ 1 0))` → `-inf` (`js-math-max` empty case); `(/ -1 0)` → `-inf` (`js-number-is-finite`). `js-max-value-approx` was looping forever (rationals never reach float infinity) — replaced with literal `1.7976931348623157e+308`. Fixed `charCodeAt` and string `.length` to use `(len s)` and `(char-code (char-at s idx))` instead of missing `unicode-len`/`unicode-char-code-at` primitives. conformance.sh: 0→148/148. Unit tests: 521/530 best run (baseline run was 417/530; both timeout-flaky).
+
+- 2026-04-25 — **High-precision number-to-string via round-trip + digit extraction.** `js-big-int-str-loop` extracts decimal digits from integer-valued float. `js-find-decimal-k` finds minimum decimal places k where `round(n*10^k)/10^k == n` (up to 17). `js-format-decimal-digits` inserts decimal point. `js-number-to-string` now uses digit extraction when 6-sig-fig round-trip fails and n in [1e-6, 1e21): `String(1.0000001)="1.0000001"`, `String(1/3)="0.3333333333333333"`. String test262 subset: 58→62/100. 529/530 unit, 148/148 slice.
+
+- 2026-04-25 — **String wrapper objects + number-to-string sci notation.** `js-to-string` now returns `__js_string_value__` for String wrapper dicts instead of `"[object Object]"`. `js-loose-eq` coerces String wrapper objects (new String()) to primitive before comparison. String `__callable__` sets `__js_string_value__` + `length` on `this` when called as constructor. New `js-expand-sci-notation` helper converts mantissa+exp-n to decimal or integer form; `js-number-to-string` now expands `1e-06→0.000001`, `1e+06→1000000`, fixes `1e21→1e+21`. String test262 subset: 45→58/100. 529/530 unit, 148/148 slice.
+
+- 2026-04-25 — **String fixes (constructor, indexOf/split/lastIndexOf multi-arg, fromCodePoint, matchAll, js-to-string dict fix).** Added `String.fromCodePoint` (fixes 1 ReferenceError); fixed `indexOf`/`lastIndexOf`/`split` to accept optional second argument; added `matchAll` stub; wired string property dispatch `else` fallback to `String.prototype` (fixes `'a'.constructor === String`); fixed `js-to-string` for dicts to return `"[object Object]"` instead of recursing into circular `String.prototype.constructor` structure. Scoreboard: String 42→43, timeouts 32→13. Total 162→202/300 (54%→67.3%). 529/530 unit, 148/148 slice.
+
+- 2026-04-25 — **Number/String wrapper constructor-detection fix + Array.prototype.toString + js-to-number for wrappers + `>>>` operator.** `Number.__callable__` and `String.__callable__` now check `this.__proto__ === Number/String.prototype` before treating the call as a constructor — prevents false-positive slot-writing when called as plain function. `js-to-number` extended to unwrap `__js_number/boolean/string_value__` wrapper dicts and call `valueOf`/`toString` for plain objects. `Array.prototype.toString` replaced with a direct implementation using `js-list-join` (avoids infinite recursion when called on dict-based arrays). `>>>` (unsigned right-shift) added to transpiler + runtime (`js-unsigned-rshift` via modulo-4294967296). String test262 subset: 62→66/100. 529/530 unit, 147/148 slice.
+
+- 2026-04-25 — **Math methods (trig/log/hyperbolic/bit ops).** Added 22 missing Math methods to `runtime.sx`: `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `exp`, `log`, `log2`, `log10`, `expm1`, `log1p`, `clz32`, `imul`, `fround`. All use existing SX primitives. `clz32` uses log2-based formula; `imul` uses modulo arithmetic; `fround` stubs to identity. Addresses 36x "TypeError: not a function" in built-ins/Math (43% → ~79% expected). 529/530 unit (unchanged), 148/148 slice. Commit `5f38e49b`.
+
+- 2026-04-25 — **`var` hoisting.** Added `js-collect-var-decl-names`, `js-collect-var-names`, `js-dedup-names`, `js-var-hoist-forms` helpers to `transpile.sx`. Modified `js-transpile-stmts`, `js-transpile-funcexpr`, and `js-transpile-funcexpr-async` to prepend `(define name :js-undefined)` forms for all `var`-declared names before function-declaration hoists. Shallow collection (direct statements only). 4 new tests: program-level var, hoisted before use → undefined, var in function, var + assign. 529/530 unit (+4), 148/148 slice unchanged. Commit `11315d91`.
+
+- 2026-04-25 — **ASI (Automatic Semicolon Insertion).** Lexer: added `:nl` (newline-before) boolean to every token dict; `skip-ws!` sets it true when consuming `\n`/`\r`; `scan!` resets it to `false` at the start of each token scan. Parser: new `jp-token-nl?` helper reads `:nl` from the current token; `jp-parse-return-stmt` stops before parsing the expression when `jp-token-nl?` is true (restricted production: `return\nvalue` → `return undefined`). 4 new tests (flag presence, flag value, restricted return). 525/526 unit (+4), 148/148 slice unchanged. Commit `ae86579a`.
+
 - 2026-04-23 — scaffold landed: lib/js/{lexer,parser,transpile,runtime}.sx stubs + test.sh. 7/7 smoke tests pass (js-tokenize/js-parse/js-transpile stubs + js-to-boolean coercion cases).
 - 2026-04-23 — Phase 1 (Lexer) complete: numbers (int/float/hex/exp/leading-dot), strings (escapes), idents/keywords, punctuation, all operators (1-4 char, longest-match), // and /* */ comments. 38/38 tests pass. Gotchas found: `peek` and `emit!` are primitives (shadowed to `js-peek`, `js-emit!`); `cond` clauses take ONE body only, multi-expr needs `(do ...)` wrapper.
 - 2026-04-23 — Phase 2 (Pratt expression parser) complete: literals, binary precedence (w/ `**` right-assoc), unary (`- + ! ~ typeof void`), member access (`.`/`[]`), call chains, array/object literals (ident+string+number keys), ternary, arrow fns (zero/one/many params; curried), assignment (right-assoc incl. compound `+=` etc.). AST node shapes all match the `js-*` names already wired. 47 new tests, 85/85 total. Most of the Phase 2 scaffolding was already written in an earlier session — this iteration verified every path, added the parser test suite, and greened everything on the first pass. No new gotchas beyond Phase 1.