plans: log precision number-to-string iteration

- js-big-int-str-loop: extract decimal digits from integer-valued float
- js-find-decimal-k: find min decimal places k where round(n*10^k)/10^k == n
- js-format-decimal-digits: insert decimal point into digit string at position (len-k)
- js-number-to-string: if 6-sig-fig round-trip fails AND n in [1e-6, 1e21),
  use digit extraction for full precision (up to 17 sig figs)
- String(1.0000001)="1.0000001", String(1/3)="0.3333333333333333"
- String test262 subset: 58→62/100

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

lib/js/lexer.sx

@@ -94,7 +94,7 @@
   (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 +109,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 {:pos start :value value :type type :nl nl-before})))
       (define
         skip-line-comment!
         (fn
@@ -136,7 +132,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) "*"))
@@ -568,6 +570,7 @@
         (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/runtime.sx

@@ -1169,7 +1169,14 @@
       ((= v false) "false")
       ((= (type-of v) "string") v)
       ((= (type-of v) "number") (js-number-to-string v))
-      (else (str v)))))
+      (else
+        (if
+          (= (type-of v) "dict")
+          (if
+            (contains? (keys v) "__js_string_value__")
+            (get v "__js_string_value__")
+            "[object Object]")
+          (str v))))))
 
 (define
   js-template-concat
@@ -1187,6 +1194,79 @@
         (+ i 1)
         (str acc (js-to-string (nth parts i)))))))
 
+(define
+  js-big-int-str-loop
+  (fn
+    (n acc)
+    (if
+      (< n 1)
+      (if (= acc "") "0" acc)
+      (let
+        ((d (floor (- n (* 10 (floor (/ n 10)))))))
+        (js-big-int-str-loop
+          (floor (/ n 10))
+          (str (js-string-slice "0123456789" d (+ d 1)) acc))))))
+
+(define
+  js-find-decimal-k
+  (fn
+    (n k)
+    (if
+      (> k 17)
+      17
+      (let
+        ((big-int (round (* n (js-pow-int 10 k)))))
+        (if
+          (= (/ big-int (js-pow-int 10 k)) n)
+          k
+          (js-find-decimal-k n (+ k 1)))))))
+
+(define
+  js-format-decimal-digits
+  (fn
+    (digits k)
+    (if
+      (= k 0)
+      digits
+      (let
+        ((dlen (len digits)))
+        (if
+          (> dlen k)
+          (str
+            (js-string-slice digits 0 (- dlen k))
+            "."
+            (js-string-slice digits (- dlen k) dlen))
+          (if
+            (= dlen k)
+            (str "0." digits)
+            (str "0." (js-string-repeat "0" (- k dlen)) digits)))))))
+
+(define
+  js-expand-sci-notation
+  (fn
+    (mant exp-n)
+    (let
+      ((di (js-string-index-of mant "." 0)))
+      (let
+        ((int-part (if (< di 0) mant (js-string-slice mant 0 di)))
+          (frac-part
+            (if (< di 0) "" (js-string-slice mant (+ di 1) (len mant)))))
+        (let
+          ((all-digits (str int-part frac-part))
+            (frac-len (if (< di 0) 0 (- (- (len mant) di) 1))))
+          (if
+            (>= exp-n 0)
+            (if
+              (>= exp-n frac-len)
+              (str all-digits (js-string-repeat "0" (- exp-n frac-len)))
+              (let
+                ((dot-pos (+ (len int-part) exp-n)))
+                (str
+                  (js-string-slice all-digits 0 dot-pos)
+                  "."
+                  (js-string-slice all-digits dot-pos (len all-digits)))))
+            (str "0." (js-string-repeat "0" (- (- 0 exp-n) 1)) all-digits)))))))
+
 (define
   js-number-to-string
   (fn
@@ -1195,7 +1275,16 @@
       ((js-number-is-nan n) "NaN")
       ((= n (js-infinity-value)) "Infinity")
       ((= n (- 0 (js-infinity-value))) "-Infinity")
-      (else (js-normalize-num-str (str n))))))
+      (else
+        (let
+          ((pos-n (if (< n 0) (- 0 n) n)))
+          (let
+            ((s0 (js-normalize-num-str (str pos-n))))
+            (let
+              ((n2 (js-to-number s0)))
+              (let
+                ((precise (if (= n2 pos-n) (let ((ei (js-string-index-of s0 "e" 0))) (if (< ei 0) s0 (let ((exp-n (js-to-number (js-string-slice s0 (+ ei 1) (len s0))))) (if (and (>= exp-n -6) (<= exp-n 20)) (js-expand-sci-notation (js-string-slice s0 0 ei) exp-n) (if (>= exp-n 0) (str (js-string-slice s0 0 (+ ei 1)) "+" (str exp-n)) s0))))) (if (and (>= pos-n 1e-06) (< pos-n 1e+21)) (let ((k (js-find-decimal-k pos-n 0))) (let ((big-int (round (* pos-n (js-pow-int 10 k))))) (js-format-decimal-digits (js-big-int-str-loop big-int "") k))) (let ((ei (js-string-index-of s0 "e" 0))) (if (< ei 0) s0 (let ((exp-n (js-to-number (js-string-slice s0 (+ ei 1) (len s0))))) (if (>= exp-n 0) (str (js-string-slice s0 0 (+ ei 1)) "+" (str exp-n)) s0))))))))
+                (if (< n 0) (str "-" precise) precise)))))))))
 
 (define
   js-normalize-num-str
@@ -1296,6 +1385,10 @@
         (= (js-to-number a) b))
       ((= (type-of a) "boolean") (js-loose-eq (js-to-number a) b))
       ((= (type-of b) "boolean") (js-loose-eq a (js-to-number b)))
+      ((and (dict? a) (contains? (keys a) "__js_string_value__"))
+        (js-loose-eq (get a "__js_string_value__") b))
+      ((and (dict? b) (contains? (keys b) "__js_string_value__"))
+        (js-loose-eq a (get b "__js_string_value__")))
       (else false))))
 
 (define js-loose-neq (fn (a b) (not (js-loose-eq a b))))
@@ -1903,7 +1996,15 @@
               (char-code (char-at s idx))
               0))))
       ((= name "indexOf")
-        (fn (needle) (js-string-index-of s (js-to-string needle) 0)))
+        (fn
+          (&rest args)
+          (if
+            (empty? args)
+            -1
+            (js-string-index-of
+              s
+              (js-to-string (nth args 0))
+              (if (< (len args) 2) 0 (max 0 (js-num-to-int (nth args 1))))))))
       ((= name "slice")
         (fn
           (&rest args)
@@ -1927,7 +2028,16 @@
               (js-string-slice s lo (min hi (len s)))))))
       ((= name "toUpperCase") (fn () (js-upper-case s)))
       ((= name "toLowerCase") (fn () (js-lower-case s)))
-      ((= name "split") (fn (sep) (js-string-split s (js-to-string sep))))
+      ((= name "split")
+        (fn
+          (&rest args)
+          (let
+            ((sep (if (= (len args) 0) :js-undefined (nth args 0)))
+              (limit
+                (if (< (len args) 2) -1 (js-num-to-int (nth args 1)))))
+            (let
+              ((result (js-string-split s (js-to-string sep))))
+              (if (< limit 0) result (js-list-take result limit))))))
       ((= name "concat")
         (fn (&rest args) (js-string-concat-loop s args 0)))
       ((= name "includes")
@@ -2042,6 +2152,17 @@
                     (= idx -1)
                     nil
                     (let ((res (list))) (append! res needle) res))))))))
+      ((= name "matchAll")
+        (fn
+          (&rest args)
+          (if
+            (empty? args)
+            (list)
+            (let
+              ((needle (js-to-string (nth args 0))))
+              (let
+                ((loop (fn (start acc) (let ((idx (js-string-index-of s needle start))) (if (= idx -1) acc (let ((m (list))) (begin (append! m needle) (dict-set! m "index" idx) (loop (+ idx (max 1 (len needle))) (begin (append! acc m) acc)))))))))
+                (loop 0 (list)))))))
       ((= name "at")
         (fn
           (i)
@@ -2068,7 +2189,14 @@
             -1
             (let
               ((needle (js-to-string (nth args 0))))
-              (js-string-last-index-of s needle (- (len s) (len needle)))))))
+              (let
+                ((default-start (- (len s) (len needle)))
+                  (from
+                    (if (< (len args) 2) -1 (js-num-to-int (nth args 1)))))
+                (js-string-last-index-of
+                  s
+                  needle
+                  (if (< from 0) default-start (min from default-start))))))))
       ((= name "localeCompare")
         (fn
           (&rest args)
@@ -2166,6 +2294,15 @@
       ((not (= (char-at s (+ si ni)) (char-at needle ni))) false)
       (else (js-string-matches? s needle si (+ ni 1))))))
 
+(define
+  js-list-take
+  (fn
+    (lst n)
+    (if
+      (or (<= n 0) (empty? lst))
+      (list)
+      (cons (first lst) (js-list-take (rest lst) (- n 1))))))
+
 (define
   js-string-split
   (fn
@@ -2306,7 +2443,13 @@
               (js-string-method obj "toLocaleUpperCase"))
             ((= key "isWellFormed") (js-string-method obj "isWellFormed"))
             ((= key "toWellFormed") (js-string-method obj "toWellFormed"))
-            (else js-undefined)))
+            (else
+              (let
+                ((proto (get String "prototype")))
+                (if
+                  (and (dict? proto) (contains? (keys proto) key))
+                  (get proto key)
+                  js-undefined)))))
         ((= (type-of obj) "dict")
           (js-dict-get-walk obj (js-to-string key)))
         ((and (= obj Promise) (dict-has? __js_promise_statics__ (js-to-string key)))
@@ -2480,7 +2623,49 @@
         ((n (js-to-number (first args))))
         (js-math-hypot-loop (rest args) (+ acc (* n n)))))))
 
-(define Math {:random js-math-random :trunc js-math-trunc :LN10 2.30259 :SQRT1_2 0.707107 :floor js-math-floor :PI 3.14159 :sqrt js-math-sqrt :hypot js-math-hypot :LOG2E 1.4427 :round js-math-round :ceil js-math-ceil :abs js-math-abs :pow js-math-pow :max js-math-max :LOG10E 0.434294 :SQRT2 1.41421 :cbrt js-math-cbrt :min js-math-min :sign js-math-sign :E 2.71828 :LN2 0.693147})
+(begin
+  (define js-math-sin (fn (x) (sin (js-to-number x))))
+  (define js-math-cos (fn (x) (cos (js-to-number x))))
+  (define js-math-tan (fn (x) (tan (js-to-number x))))
+  (define js-math-asin (fn (x) (asin (js-to-number x))))
+  (define js-math-acos (fn (x) (acos (js-to-number x))))
+  (define js-math-atan (fn (x) (atan (js-to-number x))))
+  (define
+    js-math-atan2
+    (fn (y x) (atan2 (js-to-number y) (js-to-number x))))
+  (define js-math-sinh (fn (x) (sinh (js-to-number x))))
+  (define js-math-cosh (fn (x) (cosh (js-to-number x))))
+  (define js-math-tanh (fn (x) (tanh (js-to-number x))))
+  (define js-math-asinh (fn (x) (asinh (js-to-number x))))
+  (define js-math-acosh (fn (x) (acosh (js-to-number x))))
+  (define js-math-atanh (fn (x) (atanh (js-to-number x))))
+  (define js-math-exp (fn (x) (exp (js-to-number x))))
+  (define js-math-log (fn (x) (log (js-to-number x))))
+  (define js-math-log2 (fn (x) (log2 (js-to-number x))))
+  (define js-math-log10 (fn (x) (log10 (js-to-number x))))
+  (define js-math-expm1 (fn (x) (expm1 (js-to-number x))))
+  (define js-math-log1p (fn (x) (log1p (js-to-number x))))
+  (define
+    js-math-clz32
+    (fn
+      (&rest args)
+      (let
+        ((x (if (empty? args) 0 (js-to-number (nth args 0)))))
+        (let
+          ((n (modulo (floor x) 4294967296)))
+          (if (= n 0) 32 (- 31 (floor (log2 n))))))))
+  (define
+    js-math-imul
+    (fn
+      (a b)
+      (let
+        ((a32 (modulo (floor (js-to-number a)) 4294967296))
+          (b32 (modulo (floor (js-to-number b)) 4294967296)))
+        (let
+          ((result (modulo (* a32 b32) 4294967296)))
+          (if (>= result 2147483648) (- result 4294967296) result)))))
+  (define js-math-fround (fn (x) (js-to-number x)))
+  (define Math {:trunc js-math-trunc :expm1 js-math-expm1 :atan2 js-math-atan2 :PI 3.14159 :asinh js-math-asinh :acosh js-math-acosh :hypot js-math-hypot :LOG2E 1.4427 :atanh js-math-atanh :ceil js-math-ceil :pow js-math-pow :sin js-math-sin :max js-math-max :log2 js-math-log2 :SQRT2 1.41421 :cbrt js-math-cbrt :log1p js-math-log1p :fround js-math-fround :E 2.71828 :sinh js-math-sinh :random js-math-random :LN10 2.30259 :SQRT1_2 0.707107 :asin js-math-asin :clz32 js-math-clz32 :floor js-math-floor :exp js-math-exp :tan js-math-tan :sqrt js-math-sqrt :cosh js-math-cosh :log js-math-log :round js-math-round :abs js-math-abs :LOG10E 0.434294 :tanh js-math-tanh :acos js-math-acos :log10 js-math-log10 :min js-math-min :sign js-math-sign :LN2 0.693147 :cos js-math-cos :imul js-math-imul :atan js-math-atan}))
 
 (define
   js-number-is-finite
@@ -2986,6 +3171,35 @@
   js-string-from-char-code
   (fn (&rest args) (js-string-from-char-code-loop args 0 "")))
 
+(define
+  js-string-from-code-point-loop
+  (fn
+    (args i acc)
+    (if
+      (>= i (len args))
+      acc
+      (let
+        ((cp (floor (js-to-number (nth args i)))))
+        (if
+          (< cp 65536)
+          (js-string-from-code-point-loop
+            args
+            (+ i 1)
+            (str acc (js-code-to-char (js-num-to-int cp))))
+          (let
+            ((hi (+ 55296 (floor (/ (- cp 65536) 1024))))
+              (lo (+ 56320 (modulo (- cp 65536) 1024))))
+            (js-string-from-code-point-loop
+              args
+              (+ i 1)
+              (str
+                (str acc (js-code-to-char (js-num-to-int hi)))
+                (js-code-to-char (js-num-to-int lo))))))))))
+
+(define
+  js-string-from-code-point
+  (fn (&rest args) (js-string-from-code-point-loop args 0 "")))
+
 (define
   js-string-from-char-code-loop
   (fn
@@ -3016,8 +3230,32 @@
 
 (dict-set! String "name" "String")
 
+(dict-set! String "fromCodePoint" js-string-from-code-point)
+
+(dict-set!
+  String
+  "__callable__"
+  (fn
+    (&rest args)
+    (let
+      ((raw (if (= (len args) 0) "" (js-to-string (nth args 0)))))
+      (let
+        ((this-val (js-this)))
+        (if
+          (dict? this-val)
+          (begin
+            (dict-set! this-val "__js_string_value__" raw)
+            (dict-set! this-val "length" (len raw))
+            this-val)
+          raw)))))
+
 (define Boolean {:__callable__ (fn (&rest args) (if (= (len args) 0) false (js-to-boolean (nth args 0))))})
 
+(dict-set!
+  (get String "prototype")
+  "matchAll"
+  (js-string-proto-fn "matchAll"))
+
 (dict-set! Boolean "length" 1)
 
 (dict-set! Boolean "name" "Boolean")

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-scoreboard.json

@@ -1,84 +1,42 @@
 {
   "totals": {
-    "pass": 162,
-    "fail": 128,
-    "skip": 1597,
-    "timeout": 10,
-    "total": 1897,
-    "runnable": 300,
-    "pass_rate": 54.0
+    "pass": 62,
+    "fail": 29,
+    "skip": 1130,
+    "timeout": 9,
+    "total": 1230,
+    "runnable": 100,
+    "pass_rate": 62.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,
-      "top_failures": [
-        [
-          "Test262Error (assertion failed)",
-          19
-        ],
-        [
-          "Timeout",
-          4
-        ]
-      ]
-    },
     {
       "category": "built-ins/String",
       "total": 1223,
-      "pass": 42,
-      "fail": 53,
+      "pass": 62,
+      "fail": 29,
       "skip": 1123,
-      "timeout": 5,
-      "pass_rate": 42.0,
+      "timeout": 9,
+      "pass_rate": 62.0,
       "top_failures": [
         [
           "Test262Error (assertion failed)",
-          44
+          24
         ],
         [
           "Timeout",
-          5
-        ],
-        [
-          "ReferenceError (undefined symbol)",
-          2
-        ],
-        [
-          "Unhandled: Not callable: {:__proto__ {:toLowerCase <lambda(&rest, args)",
-          2
+          9
         ],
         [
           "Unhandled: Not callable: \\\\\\",
-          2
+          1
+        ],
+        [
+          "ReferenceError (undefined symbol)",
+          1
+        ],
+        [
+          "SyntaxError (parse/unsupported syntax)",
+          1
         ]
       ]
     },
@@ -96,34 +54,26 @@
   "top_failure_modes": [
     [
       "Test262Error (assertion failed)",
-      83
-    ],
-    [
-      "TypeError: not a function",
-      36
+      24
     ],
     [
       "Timeout",
-      10
-    ],
-    [
-      "ReferenceError (undefined symbol)",
-      2
-    ],
-    [
-      "Unhandled: Not callable: {:__proto__ {:toLowerCase <lambda(&rest, args)",
-      2
+      9
     ],
     [
       "Unhandled: Not callable: \\\\\\",
-      2
+      1
+    ],
+    [
+      "ReferenceError (undefined symbol)",
+      1
     ],
     [
       "SyntaxError (parse/unsupported syntax)",
       1
     ],
     [
-      "Unhandled: Not callable: {:__proto__ {:valueOf <lambda()> :propertyIsEn",
+      "TypeError: not a function",
       1
     ],
     [
@@ -132,6 +82,6 @@
     ]
   ],
   "pinned_commit": "d5e73fc8d2c663554fb72e2380a8c2bc1a318a33",
-  "elapsed_seconds": 274.5,
-  "workers": 1
+  "elapsed_seconds": 40.5,
+  "workers": 7
 }

lib/js/test262-scoreboard.md

@@ -1,47 +1,32 @@
 # test262 scoreboard
 
 Pinned commit: `d5e73fc8d2c663554fb72e2380a8c2bc1a318a33`
-Wall time: 274.5s
+Wall time: 40.5s
 
-**Total:** 162/300 runnable passed (54.0%). Raw: pass=162 fail=128 skip=1597 timeout=10 total=1897.
+**Total:** 62/100 runnable passed (62.0%). Raw: pass=62 fail=29 skip=1130 timeout=9 total=1230.
 
 ## 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: \\\
+- **24x** Test262Error (assertion failed)
+- **9x** Timeout
+- **1x** Unhandled: Not callable: \\\
+- **1x** ReferenceError (undefined symbol)
 - **1x** SyntaxError (parse/unsupported syntax)
-- **1x** Unhandled: Not callable: {:__proto__ {:valueOf <lambda()> :propertyIsEn
+- **1x** TypeError: not a function
 - **1x** Unhandled: js-transpile-binop: unsupported op: >>>\
 
 ## 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/String | 62 | 29 | 1123 | 9 | 1223 | 62.0% |
 
 ## Per-category top failures (min 10 runnable, worst first)
 
-### built-ins/String  (42/100 — 42.0%)
+### built-ins/String  (62/100 — 62.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
+- **24x** Test262Error (assertion failed)
+- **9x** Timeout
+- **1x** Unhandled: Not callable: \\\
+- **1x** ReferenceError (undefined symbol)
+- **1x** SyntaxError (parse/unsupported syntax)

lib/js/transpile.sx

@@ -486,6 +486,51 @@
                 (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))
+      ((and (list? (first stmts)) (js-tag? (first stmts) "js-var") (= (nth (first stmts) 1) "var"))
+        (append
+          (js-collect-var-decl-names (nth (first stmts) 2))
+          (js-collect-var-names (rest stmts))))
+      (else (js-collect-var-names (rest stmts))))))
+
+(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 +921,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))))))
@@ -1297,7 +1342,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 +1378,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

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,18 @@ 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-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 — **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.