forth: JIT cooperation hooks (vm-eligible flag + call-count + forth-hot-words)

lib/forth/ans-tests/README.md

@@ -0,0 +1,14 @@
+ANS Forth conformance tests — vendored from
+https://github.com/gerryjackson/forth2012-test-suite (master, commit-locked
+on first fetch: 2026-04-24).
+
+Files in this directory are pristine copies of upstream — do not edit them.
+They are consumed by the conformance runner in `lib/forth/conformance.sh`.
+
+- `tester.fr` — John Hayes' test harness (`T{ ... -> ... }T`). (C) 1995
+  Johns Hopkins APL, distributable under its notice.
+- `core.fr` — Core word set tests (Hayes, ~1000 lines).
+- `coreexttest.fth` — Core Extension tests (Gerry Jackson).
+
+Only `core.fr` is expected to run green end-to-end for Phase 3; the others
+stay parked until later phases.

lib/forth/ans-tests/coreexttest.fth

@@ -0,0 +1,775 @@
+\ To test the ANS Forth Core Extension word set
+
+\ This program was written by Gerry Jackson in 2006, with contributions from
+\ others where indicated, and is in the public domain - it can be distributed
+\ and/or modified in any way but please retain this notice.
+
+\ This program is distributed in the hope that it will be useful,
+\ but WITHOUT ANY WARRANTY; without even the implied warranty of
+\ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+\ The tests are not claimed to be comprehensive or correct 
+
+\ ------------------------------------------------------------------------------
+\ Version 0.15 1 August 2025 Added two tests to VALUE
+\         0.14 21 July 2022 Updated first line of BUFFER: test as recommended
+\              in issue 32
+\         0.13 28 October 2015
+\              Replace <FALSE> and <TRUE> with FALSE and TRUE to avoid
+\              dependence on Core tests
+\              Moved SAVE-INPUT and RESTORE-INPUT tests in a file to filetest.fth
+\              Use of 2VARIABLE (from optional wordset) replaced with CREATE.
+\              Minor lower to upper case conversions.
+\              Calls to COMPARE replaced by S= (in utilities.fth) to avoid use
+\              of a word from an optional word set.
+\              UNUSED tests revised as UNUSED UNUSED = may return FALSE when an
+\              implementation has the data stack sharing unused dataspace.
+\              Double number input dependency removed from the HOLDS tests.
+\              Minor case sensitivities removed in definition names.
+\         0.11 25 April 2015
+\              Added tests for PARSE-NAME HOLDS BUFFER:
+\              S\" tests added
+\              DEFER IS ACTION-OF DEFER! DEFER@ tests added
+\              Empty CASE statement test added
+\              [COMPILE] tests removed because it is obsolescent in Forth 2012
+\         0.10 1 August 2014
+\             Added tests contributed by James Bowman for:
+\                <> U> 0<> 0> NIP TUCK ROLL PICK 2>R 2R@ 2R>
+\                HEX WITHIN UNUSED AGAIN MARKER
+\             Added tests for:
+\                .R U.R ERASE PAD REFILL SOURCE-ID 
+\             Removed ABORT from NeverExecuted to enable Win32
+\             to continue after failure of RESTORE-INPUT.
+\             Removed max-intx which is no longer used.
+\         0.7 6 June 2012 Extra CASE test added
+\         0.6 1 April 2012 Tests placed in the public domain.
+\             SAVE-INPUT & RESTORE-INPUT tests, position
+\             of T{ moved so that tests work with ttester.fs
+\             CONVERT test deleted - obsolete word removed from Forth 200X
+\             IMMEDIATE VALUEs tested
+\             RECURSE with :NONAME tested
+\             PARSE and .( tested
+\             Parsing behaviour of C" added
+\         0.5 14 September 2011 Removed the double [ELSE] from the
+\             initial SAVE-INPUT & RESTORE-INPUT test
+\         0.4 30 November 2009  max-int replaced with max-intx to
+\             avoid redefinition warnings.
+\         0.3  6 March 2009 { and } replaced with T{ and }T
+\                           CONVERT test now independent of cell size
+\         0.2  20 April 2007 ANS Forth words changed to upper case
+\                            Tests qd3 to qd6 by Reinhold Straub
+\         0.1  Oct 2006 First version released
+\ -----------------------------------------------------------------------------
+\ The tests are based on John Hayes test program for the core word set
+
+\ Words tested in this file are:
+\     .( .R 0<> 0> 2>R 2R> 2R@ :NONAME <> ?DO AGAIN C" CASE COMPILE, ENDCASE
+\     ENDOF ERASE FALSE HEX MARKER NIP OF PAD PARSE PICK REFILL
+\     RESTORE-INPUT ROLL SAVE-INPUT SOURCE-ID TO TRUE TUCK U.R U> UNUSED
+\     VALUE WITHIN [COMPILE]
+
+\ Words not tested or partially tested:
+\     \ because it has been extensively used already and is, hence, unnecessary
+\     REFILL and SOURCE-ID from the user input device which are not possible
+\     when testing from a file such as this one
+\     UNUSED (partially tested) as the value returned is system dependent
+\     Obsolescent words #TIB CONVERT EXPECT QUERY SPAN TIB as they have been
+\     removed from the Forth 2012 standard
+
+\ Results from words that output to the user output device have to visually
+\ checked for correctness. These are .R U.R .(
+
+\ -----------------------------------------------------------------------------
+\ Assumptions & dependencies:
+\     - tester.fr (or ttester.fs), errorreport.fth and utilities.fth have been
+\       included prior to this file
+\     - the Core word set available
+\ -----------------------------------------------------------------------------
+TESTING Core Extension words
+
+DECIMAL
+
+TESTING TRUE FALSE
+
+T{ TRUE  -> 0 INVERT }T
+T{ FALSE -> 0 }T
+
+\ -----------------------------------------------------------------------------
+TESTING <> U>   (contributed by James Bowman)
+
+T{ 0 0 <> -> FALSE }T
+T{ 1 1 <> -> FALSE }T
+T{ -1 -1 <> -> FALSE }T
+T{ 1 0 <> -> TRUE }T
+T{ -1 0 <> -> TRUE }T
+T{ 0 1 <> -> TRUE }T
+T{ 0 -1 <> -> TRUE }T
+
+T{ 0 1 U> -> FALSE }T
+T{ 1 2 U> -> FALSE }T
+T{ 0 MID-UINT U> -> FALSE }T
+T{ 0 MAX-UINT U> -> FALSE }T
+T{ MID-UINT MAX-UINT U> -> FALSE }T
+T{ 0 0 U> -> FALSE }T
+T{ 1 1 U> -> FALSE }T
+T{ 1 0 U> -> TRUE }T
+T{ 2 1 U> -> TRUE }T
+T{ MID-UINT 0 U> -> TRUE }T
+T{ MAX-UINT 0 U> -> TRUE }T
+T{ MAX-UINT MID-UINT U> -> TRUE }T
+
+\ -----------------------------------------------------------------------------
+TESTING 0<> 0>   (contributed by James Bowman)
+
+T{ 0 0<> -> FALSE }T
+T{ 1 0<> -> TRUE }T
+T{ 2 0<> -> TRUE }T
+T{ -1 0<> -> TRUE }T
+T{ MAX-UINT 0<> -> TRUE }T
+T{ MIN-INT 0<> -> TRUE }T
+T{ MAX-INT 0<> -> TRUE }T
+
+T{ 0 0> -> FALSE }T
+T{ -1 0> -> FALSE }T
+T{ MIN-INT 0> -> FALSE }T
+T{ 1 0> -> TRUE }T
+T{ MAX-INT 0> -> TRUE }T
+
+\ -----------------------------------------------------------------------------
+TESTING NIP TUCK ROLL PICK   (contributed by James Bowman)
+
+T{ 1 2 NIP -> 2 }T
+T{ 1 2 3 NIP -> 1 3 }T
+
+T{ 1 2 TUCK -> 2 1 2 }T
+T{ 1 2 3 TUCK -> 1 3 2 3 }T
+
+T{ : RO5 100 200 300 400 500 ; -> }T
+T{ RO5 3 ROLL -> 100 300 400 500 200 }T
+T{ RO5 2 ROLL -> RO5 ROT }T
+T{ RO5 1 ROLL -> RO5 SWAP }T
+T{ RO5 0 ROLL -> RO5 }T
+
+T{ RO5 2 PICK -> 100 200 300 400 500 300 }T
+T{ RO5 1 PICK -> RO5 OVER }T
+T{ RO5 0 PICK -> RO5 DUP }T
+
+\ -----------------------------------------------------------------------------
+TESTING 2>R 2R@ 2R>   (contributed by James Bowman)
+
+T{ : RR0 2>R 100 R> R> ; -> }T
+T{ 300 400 RR0 -> 100 400 300 }T
+T{ 200 300 400 RR0 -> 200 100 400 300 }T
+
+T{ : RR1 2>R 100 2R@ R> R> ; -> }T
+T{ 300 400 RR1 -> 100 300 400 400 300 }T
+T{ 200 300 400 RR1 -> 200 100 300 400 400 300 }T
+
+T{ : RR2 2>R 100 2R> ; -> }T
+T{ 300 400 RR2 -> 100 300 400 }T
+T{ 200 300 400 RR2 -> 200 100 300 400 }T
+
+\ -----------------------------------------------------------------------------
+TESTING HEX   (contributed by James Bowman)
+
+T{ BASE @ HEX BASE @ DECIMAL BASE @ - SWAP BASE ! -> 6 }T
+
+\ -----------------------------------------------------------------------------
+TESTING WITHIN   (contributed by James Bowman)
+
+T{ 0 0 0 WITHIN -> FALSE }T
+T{ 0 0 MID-UINT WITHIN -> TRUE }T
+T{ 0 0 MID-UINT+1 WITHIN -> TRUE }T
+T{ 0 0 MAX-UINT WITHIN -> TRUE }T
+T{ 0 MID-UINT 0 WITHIN -> FALSE }T
+T{ 0 MID-UINT MID-UINT WITHIN -> FALSE }T
+T{ 0 MID-UINT MID-UINT+1 WITHIN -> FALSE }T
+T{ 0 MID-UINT MAX-UINT WITHIN -> FALSE }T
+T{ 0 MID-UINT+1 0 WITHIN -> FALSE }T
+T{ 0 MID-UINT+1 MID-UINT WITHIN -> TRUE }T
+T{ 0 MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
+T{ 0 MID-UINT+1 MAX-UINT WITHIN -> FALSE }T
+T{ 0 MAX-UINT 0 WITHIN -> FALSE }T
+T{ 0 MAX-UINT MID-UINT WITHIN -> TRUE }T
+T{ 0 MAX-UINT MID-UINT+1 WITHIN -> TRUE }T
+T{ 0 MAX-UINT MAX-UINT WITHIN -> FALSE }T
+T{ MID-UINT 0 0 WITHIN -> FALSE }T
+T{ MID-UINT 0 MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT 0 MID-UINT+1 WITHIN -> TRUE }T
+T{ MID-UINT 0 MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT MID-UINT 0 WITHIN -> TRUE }T
+T{ MID-UINT MID-UINT MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT MID-UINT MID-UINT+1 WITHIN -> TRUE }T
+T{ MID-UINT MID-UINT MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT MID-UINT+1 0 WITHIN -> FALSE }T
+T{ MID-UINT MID-UINT+1 MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT MID-UINT+1 MAX-UINT WITHIN -> FALSE }T
+T{ MID-UINT MAX-UINT 0 WITHIN -> FALSE }T
+T{ MID-UINT MAX-UINT MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT MAX-UINT MID-UINT+1 WITHIN -> TRUE }T
+T{ MID-UINT MAX-UINT MAX-UINT WITHIN -> FALSE }T
+T{ MID-UINT+1 0 0 WITHIN -> FALSE }T
+T{ MID-UINT+1 0 MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT+1 0 MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT+1 0 MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT 0 WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT+1 MID-UINT MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT+1 MID-UINT MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT+1 0 WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT+1 MID-UINT WITHIN -> TRUE }T
+T{ MID-UINT+1 MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT+1 MID-UINT+1 MAX-UINT WITHIN -> TRUE }T
+T{ MID-UINT+1 MAX-UINT 0 WITHIN -> FALSE }T
+T{ MID-UINT+1 MAX-UINT MID-UINT WITHIN -> FALSE }T
+T{ MID-UINT+1 MAX-UINT MID-UINT+1 WITHIN -> FALSE }T
+T{ MID-UINT+1 MAX-UINT MAX-UINT WITHIN -> FALSE }T
+T{ MAX-UINT 0 0 WITHIN -> FALSE }T
+T{ MAX-UINT 0 MID-UINT WITHIN -> FALSE }T
+T{ MAX-UINT 0 MID-UINT+1 WITHIN -> FALSE }T
+T{ MAX-UINT 0 MAX-UINT WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT 0 WITHIN -> TRUE }T
+T{ MAX-UINT MID-UINT MID-UINT WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT MID-UINT+1 WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT MAX-UINT WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT+1 0 WITHIN -> TRUE }T
+T{ MAX-UINT MID-UINT+1 MID-UINT WITHIN -> TRUE }T
+T{ MAX-UINT MID-UINT+1 MID-UINT+1 WITHIN -> FALSE }T
+T{ MAX-UINT MID-UINT+1 MAX-UINT WITHIN -> FALSE }T
+T{ MAX-UINT MAX-UINT 0 WITHIN -> TRUE }T
+T{ MAX-UINT MAX-UINT MID-UINT WITHIN -> TRUE }T
+T{ MAX-UINT MAX-UINT MID-UINT+1 WITHIN -> TRUE }T
+T{ MAX-UINT MAX-UINT MAX-UINT WITHIN -> FALSE }T
+
+T{ MIN-INT MIN-INT MIN-INT WITHIN -> FALSE }T
+T{ MIN-INT MIN-INT 0 WITHIN -> TRUE }T
+T{ MIN-INT MIN-INT 1 WITHIN -> TRUE }T
+T{ MIN-INT MIN-INT MAX-INT WITHIN -> TRUE }T
+T{ MIN-INT 0 MIN-INT WITHIN -> FALSE }T
+T{ MIN-INT 0 0 WITHIN -> FALSE }T
+T{ MIN-INT 0 1 WITHIN -> FALSE }T
+T{ MIN-INT 0 MAX-INT WITHIN -> FALSE }T
+T{ MIN-INT 1 MIN-INT WITHIN -> FALSE }T
+T{ MIN-INT 1 0 WITHIN -> TRUE }T
+T{ MIN-INT 1 1 WITHIN -> FALSE }T
+T{ MIN-INT 1 MAX-INT WITHIN -> FALSE }T
+T{ MIN-INT MAX-INT MIN-INT WITHIN -> FALSE }T
+T{ MIN-INT MAX-INT 0 WITHIN -> TRUE }T
+T{ MIN-INT MAX-INT 1 WITHIN -> TRUE }T
+T{ MIN-INT MAX-INT MAX-INT WITHIN -> FALSE }T
+T{ 0 MIN-INT MIN-INT WITHIN -> FALSE }T
+T{ 0 MIN-INT 0 WITHIN -> FALSE }T
+T{ 0 MIN-INT 1 WITHIN -> TRUE }T
+T{ 0 MIN-INT MAX-INT WITHIN -> TRUE }T
+T{ 0 0 MIN-INT WITHIN -> TRUE }T
+T{ 0 0 0 WITHIN -> FALSE }T
+T{ 0 0 1 WITHIN -> TRUE }T
+T{ 0 0 MAX-INT WITHIN -> TRUE }T
+T{ 0 1 MIN-INT WITHIN -> FALSE }T
+T{ 0 1 0 WITHIN -> FALSE }T
+T{ 0 1 1 WITHIN -> FALSE }T
+T{ 0 1 MAX-INT WITHIN -> FALSE }T
+T{ 0 MAX-INT MIN-INT WITHIN -> FALSE }T
+T{ 0 MAX-INT 0 WITHIN -> FALSE }T
+T{ 0 MAX-INT 1 WITHIN -> TRUE }T
+T{ 0 MAX-INT MAX-INT WITHIN -> FALSE }T
+T{ 1 MIN-INT MIN-INT WITHIN -> FALSE }T
+T{ 1 MIN-INT 0 WITHIN -> FALSE }T
+T{ 1 MIN-INT 1 WITHIN -> FALSE }T
+T{ 1 MIN-INT MAX-INT WITHIN -> TRUE }T
+T{ 1 0 MIN-INT WITHIN -> TRUE }T
+T{ 1 0 0 WITHIN -> FALSE }T
+T{ 1 0 1 WITHIN -> FALSE }T
+T{ 1 0 MAX-INT WITHIN -> TRUE }T
+T{ 1 1 MIN-INT WITHIN -> TRUE }T
+T{ 1 1 0 WITHIN -> TRUE }T
+T{ 1 1 1 WITHIN -> FALSE }T
+T{ 1 1 MAX-INT WITHIN -> TRUE }T
+T{ 1 MAX-INT MIN-INT WITHIN -> FALSE }T
+T{ 1 MAX-INT 0 WITHIN -> FALSE }T
+T{ 1 MAX-INT 1 WITHIN -> FALSE }T
+T{ 1 MAX-INT MAX-INT WITHIN -> FALSE }T
+T{ MAX-INT MIN-INT MIN-INT WITHIN -> FALSE }T
+T{ MAX-INT MIN-INT 0 WITHIN -> FALSE }T
+T{ MAX-INT MIN-INT 1 WITHIN -> FALSE }T
+T{ MAX-INT MIN-INT MAX-INT WITHIN -> FALSE }T
+T{ MAX-INT 0 MIN-INT WITHIN -> TRUE }T
+T{ MAX-INT 0 0 WITHIN -> FALSE }T
+T{ MAX-INT 0 1 WITHIN -> FALSE }T
+T{ MAX-INT 0 MAX-INT WITHIN -> FALSE }T
+T{ MAX-INT 1 MIN-INT WITHIN -> TRUE }T
+T{ MAX-INT 1 0 WITHIN -> TRUE }T
+T{ MAX-INT 1 1 WITHIN -> FALSE }T
+T{ MAX-INT 1 MAX-INT WITHIN -> FALSE }T
+T{ MAX-INT MAX-INT MIN-INT WITHIN -> TRUE }T
+T{ MAX-INT MAX-INT 0 WITHIN -> TRUE }T
+T{ MAX-INT MAX-INT 1 WITHIN -> TRUE }T
+T{ MAX-INT MAX-INT MAX-INT WITHIN -> FALSE }T
+
+\ -----------------------------------------------------------------------------
+TESTING UNUSED  (contributed by James Bowman & Peter Knaggs)
+
+VARIABLE UNUSED0
+T{ UNUSED DROP -> }T                  
+T{ ALIGN UNUSED UNUSED0 ! 0 , UNUSED CELL+ UNUSED0 @ = -> TRUE }T
+T{ UNUSED UNUSED0 ! 0 C, UNUSED CHAR+ UNUSED0 @ =
+         -> TRUE }T  \ aligned -> unaligned
+T{ UNUSED UNUSED0 ! 0 C, UNUSED CHAR+ UNUSED0 @ = -> TRUE }T  \ unaligned -> ?
+
+\ -----------------------------------------------------------------------------
+TESTING AGAIN   (contributed by James Bowman)
+
+T{ : AG0 701 BEGIN DUP 7 MOD 0= IF EXIT THEN 1+ AGAIN ; -> }T
+T{ AG0 -> 707 }T
+
+\ -----------------------------------------------------------------------------
+TESTING MARKER   (contributed by James Bowman)
+
+T{ : MA? BL WORD FIND NIP 0<> ; -> }T
+T{ MARKER MA0 -> }T
+T{ : MA1 111 ; -> }T
+T{ MARKER MA2 -> }T
+T{ : MA1 222 ; -> }T
+T{ MA? MA0 MA? MA1 MA? MA2 -> TRUE TRUE TRUE }T
+T{ MA1 MA2 MA1 -> 222 111 }T
+T{ MA? MA0 MA? MA1 MA? MA2 -> TRUE TRUE FALSE }T
+T{ MA0 -> }T
+T{ MA? MA0 MA? MA1 MA? MA2 -> FALSE FALSE FALSE }T
+
+\ -----------------------------------------------------------------------------
+TESTING ?DO
+
+: QD ?DO I LOOP ;
+T{ 789 789 QD -> }T
+T{ -9876 -9876 QD -> }T
+T{ 5 0 QD -> 0 1 2 3 4 }T
+
+: QD1 ?DO I 10 +LOOP ;
+T{ 50 1 QD1 -> 1 11 21 31 41 }T
+T{ 50 0 QD1 -> 0 10 20 30 40 }T
+
+: QD2 ?DO I 3 > IF LEAVE ELSE I THEN LOOP ;
+T{ 5 -1 QD2 -> -1 0 1 2 3 }T
+
+: QD3 ?DO I 1 +LOOP ;
+T{ 4  4 QD3 -> }T
+T{ 4  1 QD3 -> 1 2 3 }T
+T{ 2 -1 QD3 -> -1 0 1 }T
+
+: QD4 ?DO I -1 +LOOP ;
+T{  4 4 QD4 -> }T
+T{  1 4 QD4 -> 4 3 2 1 }T
+T{ -1 2 QD4 -> 2 1 0 -1 }T
+
+: QD5 ?DO I -10 +LOOP ;
+T{   1 50 QD5 -> 50 40 30 20 10 }T
+T{   0 50 QD5 -> 50 40 30 20 10 0 }T
+T{ -25 10 QD5 -> 10 0 -10 -20 }T
+
+VARIABLE ITERS
+VARIABLE INCRMNT
+
+: QD6 ( limit start increment -- )
+   INCRMNT !
+   0 ITERS !
+   ?DO
+      1 ITERS +!
+      I
+      ITERS @  6 = IF LEAVE THEN
+      INCRMNT @
+   +LOOP ITERS @
+;
+
+T{  4  4 -1 QD6 -> 0 }T
+T{  1  4 -1 QD6 -> 4 3 2 1 4 }T
+T{  4  1 -1 QD6 -> 1 0 -1 -2 -3 -4 6 }T
+T{  4  1  0 QD6 -> 1 1 1 1 1 1 6 }T
+T{  0  0  0 QD6 -> 0 }T
+T{  1  4  0 QD6 -> 4 4 4 4 4 4 6 }T
+T{  1  4  1 QD6 -> 4 5 6 7 8 9 6 }T
+T{  4  1  1 QD6 -> 1 2 3 3 }T
+T{  4  4  1 QD6 -> 0 }T
+T{  2 -1 -1 QD6 -> -1 -2 -3 -4 -5 -6 6 }T
+T{ -1  2 -1 QD6 -> 2 1 0 -1 4 }T
+T{  2 -1  0 QD6 -> -1 -1 -1 -1 -1 -1 6 }T
+T{ -1  2  0 QD6 -> 2 2 2 2 2 2 6 }T
+T{ -1  2  1 QD6 -> 2 3 4 5 6 7 6 }T
+T{  2 -1  1 QD6 -> -1 0 1 3 }T
+
+\ -----------------------------------------------------------------------------
+TESTING BUFFER:
+
+T{ 2 CELLS BUFFER: BUF:TEST -> }T
+T{ BUF:TEST DUP ALIGNED = -> TRUE }T
+T{ 111 BUF:TEST ! 222 BUF:TEST CELL+ ! -> }T
+T{ BUF:TEST @ BUF:TEST CELL+ @ -> 111 222 }T
+
+\ -----------------------------------------------------------------------------
+TESTING VALUE TO
+
+T{ 111 VALUE VAL1 -999 VALUE VAL2 -> }T
+T{ VAL1 -> 111 }T
+T{ VAL2 -> -999 }T
+T{ 222 TO VAL1 -> }T
+T{ VAL1 -> 222 }T
+T{ : VD1 VAL1 ; -> }T
+T{ VD1 -> 222 }T
+T{ : VD2 TO VAL2 ; -> }T
+T{ VAL2 -> -999 }T
+T{ -333 VD2 -> }T
+T{ VAL2 -> -333 }T
+T{ VAL1 -> 222 }T
+T{ 444 TO VAL1 -> }T
+T{ VD1 -> 444 }T
+T{ 123 VALUE VAL3 IMMEDIATE VAL3 -> 123 }T
+T{ : VD3 VAL3 LITERAL ; VD3 -> 123 }T
+
+\ -----------------------------------------------------------------------------
+TESTING CASE OF ENDOF ENDCASE
+
+: CS1 CASE 1 OF 111 ENDOF
+           2 OF 222 ENDOF
+           3 OF 333 ENDOF
+           >R 999 R>
+      ENDCASE
+;
+
+T{ 1 CS1 -> 111 }T
+T{ 2 CS1 -> 222 }T
+T{ 3 CS1 -> 333 }T
+T{ 4 CS1 -> 999 }T
+
+\ Nested CASE's
+
+: CS2 >R CASE -1 OF CASE R@ 1 OF 100 ENDOF
+                            2 OF 200 ENDOF
+                           >R -300 R>
+                    ENDCASE
+                 ENDOF
+              -2 OF CASE R@ 1 OF -99  ENDOF
+                            >R -199 R>
+                    ENDCASE
+                 ENDOF
+                 >R 299 R>
+         ENDCASE R> DROP
+;
+
+T{ -1 1 CS2 ->  100 }T
+T{ -1 2 CS2 ->  200 }T
+T{ -1 3 CS2 -> -300 }T
+T{ -2 1 CS2 -> -99  }T
+T{ -2 2 CS2 -> -199 }T
+T{  0 2 CS2 ->  299 }T
+
+\ Boolean short circuiting using CASE
+
+: CS3  ( N1 -- N2 )
+   CASE 1- FALSE OF 11 ENDOF
+        1- FALSE OF 22 ENDOF
+        1- FALSE OF 33 ENDOF
+        44 SWAP
+   ENDCASE
+;
+
+T{ 1 CS3 -> 11 }T
+T{ 2 CS3 -> 22 }T
+T{ 3 CS3 -> 33 }T
+T{ 9 CS3 -> 44 }T
+
+\ Empty CASE statements with/without default
+
+T{ : CS4 CASE ENDCASE ; 1 CS4 -> }T
+T{ : CS5 CASE 2 SWAP ENDCASE ; 1 CS5 -> 2 }T
+T{ : CS6 CASE 1 OF ENDOF 2 ENDCASE ; 1 CS6 -> }T
+T{ : CS7 CASE 3 OF ENDOF 2 ENDCASE ; 1 CS7 -> 1 }T
+
+\ -----------------------------------------------------------------------------
+TESTING :NONAME RECURSE
+
+VARIABLE NN1
+VARIABLE NN2
+:NONAME 1234 ; NN1 !
+:NONAME 9876 ; NN2 !
+T{ NN1 @ EXECUTE -> 1234 }T
+T{ NN2 @ EXECUTE -> 9876 }T
+
+T{ :NONAME ( n -- 0,1,..n ) DUP IF DUP >R 1- RECURSE R> THEN ;
+   CONSTANT RN1 -> }T
+T{ 0 RN1 EXECUTE -> 0 }T
+T{ 4 RN1 EXECUTE -> 0 1 2 3 4 }T
+
+:NONAME  ( n -- n1 )    \ Multiple RECURSEs in one definition
+   1- DUP
+   CASE 0 OF EXIT ENDOF
+        1 OF 11 SWAP RECURSE ENDOF
+        2 OF 22 SWAP RECURSE ENDOF
+        3 OF 33 SWAP RECURSE ENDOF
+        DROP ABS RECURSE EXIT
+   ENDCASE
+; CONSTANT RN2
+
+T{  1 RN2 EXECUTE -> 0 }T
+T{  2 RN2 EXECUTE -> 11 0 }T
+T{  4 RN2 EXECUTE -> 33 22 11 0 }T
+T{ 25 RN2 EXECUTE -> 33 22 11 0 }T
+
+\ -----------------------------------------------------------------------------
+TESTING C"
+
+T{ : CQ1 C" 123" ; -> }T
+T{ CQ1 COUNT EVALUATE -> 123 }T
+T{ : CQ2 C" " ; -> }T
+T{ CQ2 COUNT EVALUATE -> }T
+T{ : CQ3 C" 2345"COUNT EVALUATE ; CQ3 -> 2345 }T
+
+\ -----------------------------------------------------------------------------
+TESTING COMPILE,
+
+:NONAME DUP + ; CONSTANT DUP+
+T{ : Q DUP+ COMPILE, ; -> }T
+T{ : AS1 [ Q ] ; -> }T
+T{ 123 AS1 -> 246 }T
+
+\ -----------------------------------------------------------------------------
+\ Cannot automatically test SAVE-INPUT and RESTORE-INPUT from a console source
+
+TESTING SAVE-INPUT and RESTORE-INPUT with a string source
+
+VARIABLE SI_INC 0 SI_INC !
+
+: SI1
+   SI_INC @ >IN +!
+   15 SI_INC !
+;
+
+: S$ S" SAVE-INPUT SI1 RESTORE-INPUT 12345" ;
+
+T{ S$ EVALUATE SI_INC @ -> 0 2345 15 }T
+
+\ -----------------------------------------------------------------------------
+TESTING .(
+
+CR CR .( Output from .() 
+T{ CR .( You should see -9876: ) -9876 . -> }T
+T{ CR .( and again: ).( -9876)CR -> }T
+
+CR CR .( On the next 2 lines you should see First then Second messages:)
+T{ : DOTP  CR ." Second message via ." [CHAR] " EMIT    \ Check .( is immediate
+     [ CR ] .( First message via .( ) ; DOTP -> }T
+CR CR
+T{ : IMM? BL WORD FIND NIP ; IMM? .( -> 1 }T
+
+\ -----------------------------------------------------------------------------
+TESTING .R and U.R - has to handle different cell sizes
+
+\ Create some large integers just below/above MAX and Min INTs
+MAX-INT 73 79 */ CONSTANT LI1
+MIN-INT 71 73 */ CONSTANT LI2
+
+LI1 0 <# #S #> NIP CONSTANT LENLI1
+
+: (.R&U.R)  ( u1 u2 -- )  \ u1 <= string length, u2 is required indentation
+   TUCK + >R
+   LI1 OVER SPACES  . CR R@    LI1 SWAP  .R CR
+   LI2 OVER SPACES  . CR R@ 1+ LI2 SWAP  .R CR
+   LI1 OVER SPACES U. CR R@    LI1 SWAP U.R CR
+   LI2 SWAP SPACES U. CR R>    LI2 SWAP U.R CR
+;
+
+: .R&U.R  ( -- )
+   CR ." You should see lines duplicated:" CR
+   ." indented by 0 spaces" CR 0      0 (.R&U.R) CR
+   ." indented by 0 spaces" CR LENLI1 0 (.R&U.R) CR \ Just fits required width
+   ." indented by 5 spaces" CR LENLI1 5 (.R&U.R) CR
+;
+
+CR CR .( Output from .R and U.R)
+T{ .R&U.R -> }T
+
+\ -----------------------------------------------------------------------------
+TESTING PAD ERASE
+\ Must handle different size characters i.e. 1 CHARS >= 1 
+
+84 CONSTANT CHARS/PAD      \ Minimum size of PAD in chars
+CHARS/PAD CHARS CONSTANT AUS/PAD
+: CHECKPAD  ( caddr u ch -- f )  \ f = TRUE if u chars = ch
+   SWAP 0
+   ?DO
+      OVER I CHARS + C@ OVER <>
+      IF 2DROP UNLOOP FALSE EXIT THEN
+   LOOP  
+   2DROP TRUE
+;
+
+T{ PAD DROP -> }T
+T{ 0 INVERT PAD C! -> }T
+T{ PAD C@ CONSTANT MAXCHAR -> }T
+T{ PAD CHARS/PAD 2DUP MAXCHAR FILL MAXCHAR CHECKPAD -> TRUE }T
+T{ PAD CHARS/PAD 2DUP CHARS ERASE 0 CHECKPAD -> TRUE }T
+T{ PAD CHARS/PAD 2DUP MAXCHAR FILL PAD 0 ERASE MAXCHAR CHECKPAD -> TRUE }T
+T{ PAD 43 CHARS + 9 CHARS ERASE -> }T
+T{ PAD 43 MAXCHAR CHECKPAD -> TRUE }T
+T{ PAD 43 CHARS + 9 0 CHECKPAD -> TRUE }T
+T{ PAD 52 CHARS + CHARS/PAD 52 - MAXCHAR CHECKPAD -> TRUE }T
+
+\ Check that use of WORD and pictured numeric output do not corrupt PAD
+\ Minimum size of buffers for these are 33 chars and (2*n)+2 chars respectively
+\ where n is number of bits per cell
+
+PAD CHARS/PAD ERASE
+2 BASE !
+MAX-UINT MAX-UINT <# #S CHAR 1 DUP HOLD HOLD #> 2DROP
+DECIMAL
+BL WORD 12345678123456781234567812345678 DROP
+T{ PAD CHARS/PAD 0 CHECKPAD -> TRUE }T
+
+\ -----------------------------------------------------------------------------
+TESTING PARSE
+
+T{ CHAR | PARSE 1234| DUP ROT ROT EVALUATE -> 4 1234 }T
+T{ CHAR ^ PARSE  23 45 ^ DUP ROT ROT EVALUATE -> 7 23 45 }T
+: PA1 [CHAR] $ PARSE DUP >R PAD SWAP CHARS MOVE PAD R> ;
+T{ PA1 3456
+   DUP ROT ROT EVALUATE -> 4 3456 }T
+T{ CHAR A PARSE A SWAP DROP -> 0 }T
+T{ CHAR Z PARSE
+   SWAP DROP -> 0 }T
+T{ CHAR " PARSE 4567 "DUP ROT ROT EVALUATE -> 5 4567 }T
+ 
+\ -----------------------------------------------------------------------------
+TESTING PARSE-NAME  (Forth 2012)
+\ Adapted from the PARSE-NAME RfD tests
+
+T{ PARSE-NAME abcd  STR1  S= -> TRUE }T        \ No leading spaces
+T{ PARSE-NAME      abcde STR2 S= -> TRUE }T    \ Leading spaces
+
+\ Test empty parse area, new lines are necessary
+T{ PARSE-NAME
+  NIP -> 0 }T
+\ Empty parse area with spaces after PARSE-NAME
+T{ PARSE-NAME         
+  NIP -> 0 }T
+
+T{ : PARSE-NAME-TEST ( "name1" "name2" -- n )
+    PARSE-NAME PARSE-NAME S= ; -> }T
+T{ PARSE-NAME-TEST abcd abcd  -> TRUE }T
+T{ PARSE-NAME-TEST abcd   abcd  -> TRUE }T  \ Leading spaces
+T{ PARSE-NAME-TEST abcde abcdf -> FALSE }T
+T{ PARSE-NAME-TEST abcdf abcde -> FALSE }T
+T{ PARSE-NAME-TEST abcde abcde
+   -> TRUE }T         \ Parse to end of line
+T{ PARSE-NAME-TEST abcde           abcde         
+   -> TRUE }T         \ Leading and trailing spaces
+
+\ -----------------------------------------------------------------------------
+TESTING DEFER DEFER@ DEFER! IS ACTION-OF (Forth 2012)
+\ Adapted from the Forth 200X RfD tests
+
+T{ DEFER DEFER1 -> }T
+T{ : MY-DEFER DEFER ; -> }T
+T{ : IS-DEFER1 IS DEFER1 ; -> }T
+T{ : ACTION-DEFER1 ACTION-OF DEFER1 ; -> }T
+T{ : DEF! DEFER! ; -> }T
+T{ : DEF@ DEFER@ ; -> }T
+
+T{ ' * ' DEFER1 DEFER! -> }T
+T{ 2 3 DEFER1 -> 6 }T
+T{ ' DEFER1 DEFER@ -> ' * }T
+T{ ' DEFER1 DEF@ -> ' * }T
+T{ ACTION-OF DEFER1 -> ' * }T
+T{ ACTION-DEFER1 -> ' * }T
+T{ ' + IS DEFER1 -> }T
+T{ 1 2 DEFER1 -> 3 }T
+T{ ' DEFER1 DEFER@ -> ' + }T
+T{ ' DEFER1 DEF@ -> ' + }T
+T{ ACTION-OF DEFER1 -> ' + }T
+T{ ACTION-DEFER1 -> ' + }T
+T{ ' - IS-DEFER1 -> }T
+T{ 1 2 DEFER1 -> -1 }T
+T{ ' DEFER1 DEFER@ -> ' - }T
+T{ ' DEFER1 DEF@ -> ' - }T
+T{ ACTION-OF DEFER1 -> ' - }T
+T{ ACTION-DEFER1 -> ' - }T
+
+T{ MY-DEFER DEFER2 -> }T
+T{ ' DUP IS DEFER2 -> }T
+T{ 1 DEFER2 -> 1 1 }T
+
+\ -----------------------------------------------------------------------------
+TESTING HOLDS  (Forth 2012)
+
+: HTEST S" Testing HOLDS" ;
+: HTEST2 S" works" ;
+: HTEST3 S" Testing HOLDS works 123" ;
+T{ 0 0 <#  HTEST HOLDS #> HTEST S= -> TRUE }T
+T{ 123 0 <# #S BL HOLD HTEST2 HOLDS BL HOLD HTEST HOLDS #>
+   HTEST3 S= -> TRUE }T
+T{ : HLD HOLDS ; -> }T
+T{ 0 0 <#  HTEST HLD #> HTEST S= -> TRUE }T
+
+\ -----------------------------------------------------------------------------
+TESTING REFILL SOURCE-ID
+\ REFILL and SOURCE-ID from the user input device can't be tested from a file,
+\ can only be tested from a string via EVALUATE
+
+T{ : RF1  S" REFILL" EVALUATE ; RF1 -> FALSE }T
+T{ : SID1  S" SOURCE-ID" EVALUATE ; SID1 -> -1 }T
+
+\ ------------------------------------------------------------------------------
+TESTING S\"  (Forth 2012 compilation mode)
+\ Extended the Forth 200X RfD tests
+\ Note this tests the Core Ext definition of S\" which has unedfined
+\ interpretation semantics. S\" in interpretation mode is tested in the tests on
+\ the File-Access word set
+
+T{ : SSQ1 S\" abc" S" abc" S= ; -> }T  \ No escapes
+T{ SSQ1 -> TRUE }T
+T{ : SSQ2 S\" " ; SSQ2 SWAP DROP -> 0 }T    \ Empty string
+
+T{ : SSQ3 S\" \a\b\e\f\l\m\q\r\t\v\x0F0\x1Fa\xaBx\z\"\\" ; -> }T
+T{ SSQ3 SWAP DROP          ->  20 }T    \ String length
+T{ SSQ3 DROP            C@ ->   7 }T    \ \a   BEL  Bell
+T{ SSQ3 DROP  1 CHARS + C@ ->   8 }T    \ \b   BS   Backspace
+T{ SSQ3 DROP  2 CHARS + C@ ->  27 }T    \ \e   ESC  Escape
+T{ SSQ3 DROP  3 CHARS + C@ ->  12 }T    \ \f   FF   Form feed
+T{ SSQ3 DROP  4 CHARS + C@ ->  10 }T    \ \l   LF   Line feed
+T{ SSQ3 DROP  5 CHARS + C@ ->  13 }T    \ \m        CR of CR/LF pair
+T{ SSQ3 DROP  6 CHARS + C@ ->  10 }T    \           LF of CR/LF pair
+T{ SSQ3 DROP  7 CHARS + C@ ->  34 }T    \ \q   "    Double Quote
+T{ SSQ3 DROP  8 CHARS + C@ ->  13 }T    \ \r   CR   Carriage Return
+T{ SSQ3 DROP  9 CHARS + C@ ->   9 }T    \ \t   TAB  Horizontal Tab
+T{ SSQ3 DROP 10 CHARS + C@ ->  11 }T    \ \v   VT   Vertical Tab
+T{ SSQ3 DROP 11 CHARS + C@ ->  15 }T    \ \x0F      Given Char
+T{ SSQ3 DROP 12 CHARS + C@ ->  48 }T    \ 0    0    Digit follow on
+T{ SSQ3 DROP 13 CHARS + C@ ->  31 }T    \ \x1F      Given Char
+T{ SSQ3 DROP 14 CHARS + C@ ->  97 }T    \ a    a    Hex follow on
+T{ SSQ3 DROP 15 CHARS + C@ -> 171 }T    \ \xaB      Insensitive Given Char
+T{ SSQ3 DROP 16 CHARS + C@ -> 120 }T    \ x    x    Non hex follow on
+T{ SSQ3 DROP 17 CHARS + C@ ->   0 }T    \ \z   NUL  No Character
+T{ SSQ3 DROP 18 CHARS + C@ ->  34 }T    \ \"   "    Double Quote
+T{ SSQ3 DROP 19 CHARS + C@ ->  92 }T    \ \\   \    Back Slash
+
+\ The above does not test \n as this is a system dependent value.
+\ Check it displays a new line
+CR .( The next test should display:)
+CR .( One line...)
+CR .( another line)
+T{ : SSQ4 S\" \nOne line...\nanotherLine\n" TYPE ; SSQ4 -> }T
+
+\ Test bare escapable characters appear as themselves
+T{ : SSQ5 S\" abeflmnqrtvxz" S" abeflmnqrtvxz" S= ; SSQ5 -> TRUE }T
+
+T{ : SSQ6 S\" a\""2DROP 1111 ; SSQ6 -> 1111 }T \ Parsing behaviour
+
+T{ : SSQ7  S\" 111 : SSQ8 S\\\" 222\" EVALUATE ; SSQ8 333" EVALUATE ; -> }T
+T{ SSQ7 -> 111 222 333 }T
+T{ : SSQ9  S\" 11 : SSQ10 S\\\" \\x32\\x32\" EVALUATE ; SSQ10 33" EVALUATE ; -> }T
+T{ SSQ9 -> 11 22 33 }T
+
+\ -----------------------------------------------------------------------------
+CORE-EXT-ERRORS SET-ERROR-COUNT
+
+CR .( End of Core Extension word tests) CR
+
+

lib/forth/ans-tests/tester.fr

@@ -0,0 +1,66 @@
+\ From: John Hayes S1I
+\ Subject: tester.fr
+\ Date: Mon, 27 Nov 95 13:10:09 PST  
+
+\ (C) 1995 JOHNS HOPKINS UNIVERSITY / APPLIED PHYSICS LABORATORY
+\ MAY BE DISTRIBUTED FREELY AS LONG AS THIS COPYRIGHT NOTICE REMAINS.
+\ VERSION 1.2
+
+\ 24/11/2015 Replaced Core Ext word <> with = 0=
+\ 31/3/2015 Variable #ERRORS added and incremented for each error reported.
+\ 22/1/09 The words { and } have been changed to T{ and }T respectively to
+\ agree with the Forth 200X file ttester.fs. This avoids clashes with
+\ locals using { ... } and the FSL use of } 
+
+HEX
+
+\ SET THE FOLLOWING FLAG TO TRUE FOR MORE VERBOSE OUTPUT; THIS MAY
+\ ALLOW YOU TO TELL WHICH TEST CAUSED YOUR SYSTEM TO HANG.
+VARIABLE VERBOSE
+   FALSE VERBOSE !
+\   TRUE VERBOSE !
+
+: EMPTY-STACK   \ ( ... -- ) EMPTY STACK: HANDLES UNDERFLOWED STACK TOO.
+   DEPTH ?DUP IF DUP 0< IF NEGATE 0 DO 0 LOOP ELSE 0 DO DROP LOOP THEN THEN ;
+
+VARIABLE #ERRORS 0 #ERRORS !
+
+: ERROR      \ ( C-ADDR U -- ) DISPLAY AN ERROR MESSAGE FOLLOWED BY
+      \ THE LINE THAT HAD THE ERROR.
+   CR TYPE SOURCE TYPE       \ DISPLAY LINE CORRESPONDING TO ERROR
+   EMPTY-STACK               \ THROW AWAY EVERY THING ELSE
+   #ERRORS @ 1 + #ERRORS !
+\   QUIT  \ *** Uncomment this line to QUIT on an error
+;
+
+VARIABLE ACTUAL-DEPTH         \ STACK RECORD
+CREATE ACTUAL-RESULTS 20 CELLS ALLOT
+
+: T{      \ ( -- ) SYNTACTIC SUGAR.
+   ;
+
+: ->      \ ( ... -- ) RECORD DEPTH AND CONTENT OF STACK.
+   DEPTH DUP ACTUAL-DEPTH !      \ RECORD DEPTH
+   ?DUP IF            \ IF THERE IS SOMETHING ON STACK
+      0 DO ACTUAL-RESULTS I CELLS + ! LOOP \ SAVE THEM
+   THEN ;
+
+: }T      \ ( ... -- ) COMPARE STACK (EXPECTED) CONTENTS WITH SAVED
+      \ (ACTUAL) CONTENTS.
+   DEPTH ACTUAL-DEPTH @ = IF      \ IF DEPTHS MATCH
+      DEPTH ?DUP IF         \ IF THERE IS SOMETHING ON THE STACK
+         0  DO            \ FOR EACH STACK ITEM
+           ACTUAL-RESULTS I CELLS + @   \ COMPARE ACTUAL WITH EXPECTED
+           = 0= IF S" INCORRECT RESULT: " ERROR LEAVE THEN
+         LOOP
+      THEN
+   ELSE               \ DEPTH MISMATCH
+      S" WRONG NUMBER OF RESULTS: " ERROR
+   THEN ;
+
+: TESTING   \ ( -- ) TALKING COMMENT.
+  SOURCE VERBOSE @
+   IF DUP >R TYPE CR R> >IN !
+   ELSE >IN ! DROP [CHAR] * EMIT
+   THEN ;
+

lib/forth/conformance.sh

@@ -0,0 +1,170 @@
+#!/usr/bin/env bash
+# Run the Hayes/Gerry-Jackson Core conformance suite against our Forth
+# interpreter and emit scoreboard.json + scoreboard.md.
+#
+# Method:
+#   1. Preprocess lib/forth/ans-tests/core.fr — strip \ comments, ( ... )
+#      comments, and TESTING … metadata lines.
+#   2. Split into chunks ending at each `}T` so an error in one test
+#      chunk doesn't abort the run.
+#   3. Emit an SX file that exposes those chunks as a list.
+#   4. Run our Forth + hayes-runner under sx_server; record pass/fail/error.
+
+set -e
+FORTH_DIR="$(cd "$(dirname "$0")" && pwd)"
+ROOT="$(cd "$FORTH_DIR/../.." && pwd)"
+SX_SERVER="${SX_SERVER:-/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe}"
+SOURCE="$FORTH_DIR/ans-tests/core.fr"
+OUT_JSON="$FORTH_DIR/scoreboard.json"
+OUT_MD="$FORTH_DIR/scoreboard.md"
+TMP="$(mktemp -d)"
+PREPROC="$TMP/preproc.forth"
+CHUNKS_SX="$TMP/chunks.sx"
+
+cd "$ROOT"
+
+# 1. preprocess
+awk '
+{
+  line = $0
+  # protect POSTPONE \ so the comment-strip below leaves the literal \ alone
+  gsub(/POSTPONE[ \t]+\\/, "POSTPONE @@BS@@", line)
+  # strip leading/embedded \ line comments (must be \ followed by space or EOL)
+  gsub(/(^|[ \t])\\([ \t].*|$)/, " ", line)
+  # strip ( ... ) block comments that sit on one line
+  gsub(/\([^)]*\)/, " ", line)
+  # strip TESTING … metadata lines (rest of line, incl. bare TESTING)
+  sub(/TESTING([ \t].*)?$/, " ", line)
+  # restore the protected backslash
+  gsub(/@@BS@@/, "\\", line)
+  print line
+}' "$SOURCE" > "$PREPROC"
+
+# 2 + 3: split into chunks at each `}T` and emit as a SX file
+#
+# Cap chunks via MAX_CHUNKS env (default 638 = full Hayes Core). Lower
+# it temporarily if later tests regress into an infinite loop while you
+# are iterating on primitives.
+MAX_CHUNKS="${MAX_CHUNKS:-638}"
+
+MAX_CHUNKS="$MAX_CHUNKS" python3 - "$PREPROC" "$CHUNKS_SX" <<'PY'
+import os, re, sys
+preproc_path, out_path = sys.argv[1], sys.argv[2]
+max_chunks = int(os.environ.get("MAX_CHUNKS", "590"))
+text = open(preproc_path).read()
+# keep the `}T` attached to the preceding chunk
+parts = re.split(r'(\}T)', text)
+chunks = []
+buf = ""
+for p in parts:
+    buf += p
+    if p == "}T":
+        s = buf.strip()
+        if s:
+            chunks.append(s)
+        buf = ""
+if buf.strip():
+    chunks.append(buf.strip())
+chunks = chunks[:max_chunks]
+
+def esc(s):
+    s = s.replace('\\', '\\\\').replace('"', '\\"')
+    s = s.replace('\r', ' ').replace('\n', ' ')
+    s = re.sub(r'\s+', ' ', s).strip()
+    return s
+
+with open(out_path, "w") as f:
+    f.write("(define hayes-chunks (list\n")
+    for c in chunks:
+        f.write('  "' + esc(c) + '"\n')
+    f.write("))\n\n")
+    f.write("(define\n")
+    f.write("  hayes-run-all\n")
+    f.write("  (fn\n")
+    f.write("    ()\n")
+    f.write("    (hayes-reset!)\n")
+    f.write("    (let ((s (hayes-boot)))\n")
+    f.write("      (for-each (fn (c) (hayes-run-chunk s c)) hayes-chunks))\n")
+    f.write("    (hayes-summary)))\n")
+PY
+
+# 4. run it
+OUT=$(printf '(epoch 1)\n(load "lib/forth/runtime.sx")\n(epoch 2)\n(load "lib/forth/reader.sx")\n(epoch 3)\n(load "lib/forth/interpreter.sx")\n(epoch 4)\n(load "lib/forth/compiler.sx")\n(epoch 5)\n(load "lib/forth/hayes-runner.sx")\n(epoch 6)\n(load "%s")\n(epoch 7)\n(eval "(hayes-run-all)")\n' "$CHUNKS_SX" \
+  | timeout 180 "$SX_SERVER" 2>&1)
+STATUS=$?
+
+SUMMARY=$(printf '%s\n' "$OUT" | awk '/^\{:pass / {print; exit}')
+PASS=$(printf '%s' "$SUMMARY" | sed -n 's/.*:pass \([0-9-]*\).*/\1/p')
+FAIL=$(printf '%s' "$SUMMARY" | sed -n 's/.*:fail \([0-9-]*\).*/\1/p')
+ERR=$(printf '%s' "$SUMMARY" | sed -n 's/.*:error \([0-9-]*\).*/\1/p')
+TOTAL=$(printf '%s' "$SUMMARY" | sed -n 's/.*:total \([0-9-]*\).*/\1/p')
+CHUNK_COUNT=$(grep -c '^  "' "$CHUNKS_SX" || echo 0)
+TOTAL_AVAILABLE=$(grep -c '}T' "$PREPROC" || echo 0)
+
+NOW="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+if [ -z "$PASS" ]; then
+  PASS=0; FAIL=0; ERR=0; TOTAL=0
+  NOTE="runner halted before completing (timeout or SX error)"
+else
+  NOTE="completed"
+fi
+
+PCT=0
+if [ "$TOTAL" -gt 0 ]; then
+  PCT=$((PASS * 100 / TOTAL))
+fi
+
+cat > "$OUT_JSON" <<JSON
+{
+  "source": "gerryjackson/forth2012-test-suite src/core.fr",
+  "generated_at": "$NOW",
+  "chunks_available": $TOTAL_AVAILABLE,
+  "chunks_fed": $CHUNK_COUNT,
+  "total": $TOTAL,
+  "pass": $PASS,
+  "fail": $FAIL,
+  "error": $ERR,
+  "percent": $PCT,
+  "note": "$NOTE"
+}
+JSON
+
+cat > "$OUT_MD" <<MD
+# Forth Hayes Core scoreboard
+
+| metric            | value |
+| ----------------- | ----: |
+| chunks available  | $TOTAL_AVAILABLE |
+| chunks fed        | $CHUNK_COUNT |
+| total             | $TOTAL |
+| pass              | $PASS |
+| fail              | $FAIL |
+| error             | $ERR |
+| percent           | ${PCT}% |
+
+- **Source**: \`gerryjackson/forth2012-test-suite\` \`src/core.fr\`
+- **Generated**: $NOW
+- **Note**: $NOTE
+
+A "chunk" is any preprocessed segment ending at a \`}T\` (every Hayes test
+is one chunk, plus the small declaration blocks between tests).
+The runner catches raised errors at chunk boundaries so one bad chunk
+does not abort the rest. \`error\` covers chunks that raised; \`fail\`
+covers tests whose \`->\` / \`}T\` comparison mismatched.
+
+### Chunk cap
+
+\`conformance.sh\` processes the first \`\$MAX_CHUNKS\` chunks (default
+**638**, i.e. the whole Hayes Core file). Lower the cap temporarily
+while iterating on primitives if a regression re-opens an infinite
+loop in later tests.
+MD
+
+echo "$SUMMARY"
+echo "Scoreboard: $OUT_JSON"
+echo "           $OUT_MD"
+
+if [ "$STATUS" -ne 0 ] && [ "$TOTAL" -eq 0 ]; then
+  exit 1
+fi

lib/forth/hayes-runner.sx

@@ -0,0 +1,158 @@
+;; Hayes conformance test runner.
+;; Installs T{ -> }T as Forth primitives that snapshot and compare dstack,
+;; plus stub TESTING / HEX / DECIMAL so the Hayes Core file can stream
+;; through the interpreter without halting on unsupported metadata words.
+
+(define hayes-pass 0)
+(define hayes-fail 0)
+(define hayes-error 0)
+(define hayes-start-depth 0)
+(define hayes-actual (list))
+(define hayes-actual-set false)
+(define hayes-failures (list))
+(define hayes-first-error "")
+(define hayes-error-hist (dict))
+
+(define
+  hayes-reset!
+  (fn
+    ()
+    (set! hayes-pass 0)
+    (set! hayes-fail 0)
+    (set! hayes-error 0)
+    (set! hayes-start-depth 0)
+    (set! hayes-actual (list))
+    (set! hayes-actual-set false)
+    (set! hayes-failures (list))
+    (set! hayes-first-error "")
+    (set! hayes-error-hist (dict))))
+
+(define
+  hayes-slice
+  (fn
+    (state base)
+    (let
+      ((n (- (forth-depth state) base)))
+      (if (<= n 0) (list) (take (get state "dstack") n)))))
+
+(define
+  hayes-truncate!
+  (fn
+    (state base)
+    (let
+      ((n (- (forth-depth state) base)))
+      (when (> n 0) (dict-set! state "dstack" (drop (get state "dstack") n))))))
+
+(define
+  hayes-install!
+  (fn
+    (state)
+    (forth-def-prim!
+      state
+      "T{"
+      (fn
+        (s)
+        (set! hayes-start-depth (forth-depth s))
+        (set! hayes-actual-set false)
+        (set! hayes-actual (list))))
+    (forth-def-prim!
+      state
+      "->"
+      (fn
+        (s)
+        (set! hayes-actual (hayes-slice s hayes-start-depth))
+        (set! hayes-actual-set true)
+        (hayes-truncate! s hayes-start-depth)))
+    (forth-def-prim!
+      state
+      "}T"
+      (fn
+        (s)
+        (let
+          ((expected (hayes-slice s hayes-start-depth)))
+          (hayes-truncate! s hayes-start-depth)
+          (if
+            (and hayes-actual-set (= expected hayes-actual))
+            (set! hayes-pass (+ hayes-pass 1))
+            (begin
+              (set! hayes-fail (+ hayes-fail 1))
+              (set!
+                hayes-failures
+                (concat
+                  hayes-failures
+                  (list
+                    (dict
+                      "kind"
+                      "fail"
+                      "expected"
+                      (str expected)
+                      "actual"
+                      (str hayes-actual))))))))))
+    (forth-def-prim! state "TESTING" (fn (s) nil))
+    ;; HEX/DECIMAL are real primitives now (runtime.sx) — no stub needed.
+    state))
+
+(define
+  hayes-boot
+  (fn () (let ((s (forth-boot))) (hayes-install! s) (hayes-reset!) s)))
+
+;; Run a single preprocessed chunk (string of Forth source) on the shared
+;; state. Catch any raised error and move on — the chunk boundary is a
+;; safe resume point.
+(define
+  hayes-bump-error-key!
+  (fn
+    (err)
+    (let
+      ((msg (str err)))
+      (let
+        ((space-idx (index-of msg " ")))
+        (let
+          ((key
+            (if
+              (> space-idx 0)
+              (substr msg 0 space-idx)
+              msg)))
+          (dict-set!
+            hayes-error-hist
+            key
+            (+ 1 (or (get hayes-error-hist key) 0))))))))
+
+(define
+  hayes-run-chunk
+  (fn
+    (state src)
+    (guard
+      (err
+        ((= 1 1)
+          (begin
+            (set! hayes-error (+ hayes-error 1))
+            (when
+              (= (len hayes-first-error) 0)
+              (set! hayes-first-error (str err)))
+            (hayes-bump-error-key! err)
+            (dict-set! state "dstack" (list))
+            (dict-set! state "rstack" (list))
+            (dict-set! state "compiling" false)
+            (dict-set! state "current-def" nil)
+            (dict-set! state "cstack" (list))
+            (dict-set! state "input" (list)))))
+      (forth-interpret state src))))
+
+(define
+  hayes-summary
+  (fn
+    ()
+    (dict
+      "pass"
+      hayes-pass
+      "fail"
+      hayes-fail
+      "error"
+      hayes-error
+      "total"
+      (+ (+ hayes-pass hayes-fail) hayes-error)
+      "first-error"
+      hayes-first-error
+      "error-hist"
+      hayes-error-hist)))

lib/forth/interpreter.sx

@@ -5,7 +5,39 @@
 
 (define
   forth-execute-word
-  (fn (state word) (let ((body (get word "body"))) (body state))))
+  (fn
+    (state word)
+    (dict-set! word "call-count" (+ 1 (or (get word "call-count") 0)))
+    (let ((body (get word "body"))) (body state))))
+
+(define
+  forth-hot-words
+  (fn
+    (state threshold)
+    (forth-hot-walk
+      (keys (get state "dict"))
+      (get state "dict")
+      threshold
+      (list))))
+
+(define
+  forth-hot-walk
+  (fn
+    (names dict threshold acc)
+    (if
+      (= (len names) 0)
+      acc
+      (let
+        ((n (first names)))
+        (let
+          ((w (get dict n)))
+          (let
+            ((c (or (get w "call-count") 0)))
+            (forth-hot-walk
+              (rest names)
+              dict
+              threshold
+              (if (>= c threshold) (cons (list n c) acc) acc))))))))
 
 (define
   forth-interpret-token
@@ -17,7 +49,7 @@
         (not (nil? w))
         (forth-execute-word state w)
         (let
-          ((n (forth-parse-number tok (get state "base"))))
+          ((n (forth-parse-number tok (get (get state "vars") "base"))))
           (if
             (not (nil? n))
             (forth-push state n)

lib/forth/runtime.sx

@@ -18,10 +18,122 @@
       (dict-set! s "output" "")
       (dict-set! s "compiling" false)
       (dict-set! s "current-def" nil)
-      (dict-set! s "base" 10)
       (dict-set! s "vars" (dict))
+      (dict-set! (get s "vars") "base" 10)
+      (dict-set! s "cstack" (list))
+      (dict-set! s "mem" (dict))
+      (dict-set! s "here" 0)
+      (dict-set! s "hold" (list))
+      (dict-set! s "files" (dict))
+      (dict-set! s "by-path" (dict))
+      (dict-set! s "next-fileid" 1)
       s)))
 
+(define
+  forth-mem-write!
+  (fn (state addr u) (dict-set! (get state "mem") (str addr) u)))
+
+(define
+  forth-mem-read
+  (fn
+    (state addr)
+    (or (get (get state "mem") (str addr)) 0)))
+
+(define
+  forth-alloc-bytes!
+  (fn
+    (state n)
+    (let
+      ((addr (get state "here")))
+      (dict-set! state "here" (+ addr n))
+      addr)))
+
+(define
+  forth-mem-write-string!
+  (fn
+    (state addr s)
+    (let
+      ((n (len s)))
+      (forth-mem-write-string-loop! state addr s 0 n))))
+
+(define
+  forth-mem-write-string-loop!
+  (fn
+    (state addr s i n)
+    (when
+      (< i n)
+      (begin
+        (forth-mem-write! state (+ addr i) (char-code (substr s i 1)))
+        (forth-mem-write-string-loop! state addr s (+ i 1) n)))))
+
+(define
+  forth-mem-read-string
+  (fn
+    (state addr n)
+    (forth-mem-read-string-loop state addr 0 n "")))
+
+(define
+  forth-mem-read-string-loop
+  (fn
+    (state addr i n acc)
+    (if
+      (>= i n)
+      acc
+      (forth-mem-read-string-loop
+        state
+        addr
+        (+ i 1)
+        n
+        (str acc (char-from-code (forth-mem-read state (+ addr i))))))))
+
+(define
+  forth-fill-loop
+  (fn
+    (state addr u char i)
+    (when
+      (< i u)
+      (begin
+        (forth-mem-write! state (+ addr i) char)
+        (forth-fill-loop state addr u char (+ i 1))))))
+
+(define
+  forth-cmove-loop
+  (fn
+    (state src dst u i)
+    (when
+      (< i u)
+      (begin
+        (forth-mem-write! state (+ dst i) (forth-mem-read state (+ src i)))
+        (forth-cmove-loop state src dst u (+ i 1))))))
+
+(define
+  forth-cmove-loop-desc
+  (fn
+    (state src dst u i)
+    (when
+      (>= i 0)
+      (begin
+        (forth-mem-write! state (+ dst i) (forth-mem-read state (+ src i)))
+        (forth-cmove-loop-desc state src dst u (- i 1))))))
+
+(define
+  forth-cpush
+  (fn (state v) (dict-set! state "cstack" (cons v (get state "cstack")))))
+
+(define
+  forth-cpop
+  (fn
+    (state)
+    (let
+      ((cs (get state "cstack")))
+      (if
+        (= (len cs) 0)
+        (forth-error state "control stack underflow")
+        (let
+          ((top (first cs)))
+          (dict-set! state "cstack" (rest cs))
+          top)))))
+
 (define
   forth-error
   (fn (state msg) (dict-set! state "error" msg) (raise msg)))
@@ -81,6 +193,12 @@
   forth-emit-str
   (fn (state s) (dict-set! state "output" (str (get state "output") s))))
 
+;; The body is always a plain SX lambda — primitives and colon-def
+;; bodies alike — which means the SX VM's JIT-on-first-call can lift
+;; the body directly into bytecode. We tag every word `:vm-eligible?
+;; true` so downstream JIT cooperation (a tracing layer, a hot-call
+;; counter) can pick out the JIT-friendly entries by metadata rather
+;; than by inspecting the body shape.
 (define
   forth-make-word
   (fn
@@ -90,6 +208,8 @@
       (dict-set! w "kind" kind)
       (dict-set! w "body" body)
       (dict-set! w "immediate?" immediate?)
+      (dict-set! w "vm-eligible?" true)
+      (dict-set! w "call-count" 0)
       w)))
 
 (define
@@ -99,7 +219,8 @@
     (dict-set!
       (get state "dict")
       (downcase name)
-      (forth-make-word "primitive" body false))))
+      (forth-make-word "primitive" body false))
+    (dict-set! state "last-defined" name)))
 
 (define
   forth-def-prim-imm!
@@ -108,7 +229,8 @@
     (dict-set!
       (get state "dict")
       (downcase name)
-      (forth-make-word "primitive" body true))))
+      (forth-make-word "primitive" body true))
+    (dict-set! state "last-defined" name)))
 
 (define
   forth-lookup
@@ -166,6 +288,220 @@
 
 (define forth-bits-width 32)
 
+;; Truncate a number to the Forth 32-bit signed range (two's-complement).
+;; Used by arithmetic primitives so wrap-around matches ANS semantics and
+;; loop idioms that rely on MSB becoming 0 after enough shifts terminate.
+(define
+  forth-clip
+  (fn
+    (n)
+    (forth-from-unsigned
+      (forth-to-unsigned n forth-bits-width)
+      forth-bits-width)))
+
+;; Double-cell helpers. Single = 32-bit signed, double = 64-bit signed
+;; represented on the data stack as (lo, hi) where hi is on top.
+;; Reassembly converts the low cell as unsigned and the high cell as
+;; signed (signed) or as unsigned (unsigned), then combines.
+(define forth-2pow32 (pow 2 32))
+(define forth-2pow64 (pow 2 64))
+
+(define
+  forth-double-from-cells-u
+  (fn
+    (lo hi)
+    (+ (forth-to-unsigned lo 32) (* (forth-to-unsigned hi 32) forth-2pow32))))
+
+(define
+  forth-double-from-cells-s
+  (fn (lo hi) (+ (forth-to-unsigned lo 32) (* hi forth-2pow32))))
+
+(define
+  forth-double-push-u
+  (fn
+    (state d)
+    (let
+      ((lo (mod d forth-2pow32)) (hi (floor (/ d forth-2pow32))))
+      (forth-push state (forth-from-unsigned lo 32))
+      (forth-push state (forth-from-unsigned hi 32)))))
+
+(define
+  forth-num-to-string-loop
+  (fn
+    (u base acc)
+    (if
+      (= u 0)
+      acc
+      (let
+        ((dig (mod u base)) (rest (floor (/ u base))))
+        (let
+          ((ch
+            (if
+              (< dig 10)
+              (char-from-code (+ 48 dig))
+              (char-from-code (+ 55 dig)))))
+          (forth-num-to-string-loop rest base (str ch acc)))))))
+
+(define
+  forth-num-to-string
+  (fn
+    (u base)
+    (if (= u 0) "0" (forth-num-to-string-loop u base ""))))
+
+(define
+  forth-spaces-str
+  (fn
+    (n)
+    (if (<= n 0) "" (str " " (forth-spaces-str (- n 1))))))
+
+(define
+  forth-join-hold
+  (fn
+    (parts)
+    (forth-join-hold-loop parts "")))
+
+(define
+  forth-join-hold-loop
+  (fn
+    (parts acc)
+    (if
+      (= (len parts) 0)
+      acc
+      (forth-join-hold-loop (rest parts) (str acc (first parts))))))
+
+(define
+  forth-pic-step
+  (fn
+    (state)
+    (let
+      ((hi (forth-pop state)) (lo (forth-pop state)))
+      (let
+        ((d (forth-double-from-cells-u lo hi))
+          (b (get (get state "vars") "base")))
+        (let
+          ((dig (mod d b)) (rest (floor (/ d b))))
+          (let
+            ((ch
+              (if
+                (< dig 10)
+                (char-from-code (+ 48 dig))
+                (char-from-code (+ 55 dig)))))
+            (dict-set! state "hold" (cons ch (get state "hold")))
+            (forth-double-push-u state rest)))))))
+
+(define
+  forth-compare-bytes-loop
+  (fn
+    (state a1 u1 a2 u2 i)
+    (cond
+      ((and (= i u1) (= i u2)) 0)
+      ((= i u1) -1)
+      ((= i u2) 1)
+      (else
+        (let
+          ((b1 (forth-mem-read state (+ a1 i)))
+            (b2 (forth-mem-read state (+ a2 i))))
+          (cond
+            ((< b1 b2) -1)
+            ((> b1 b2) 1)
+            (else (forth-compare-bytes-loop state a1 u1 a2 u2 (+ i 1)))))))))
+
+(define
+  forth-match-at
+  (fn
+    (state a1 start a2 u2 j)
+    (cond
+      ((= j u2) true)
+      ((not
+        (=
+          (forth-mem-read state (+ a1 (+ start j)))
+          (forth-mem-read state (+ a2 j))))
+        false)
+      (else (forth-match-at state a1 start a2 u2 (+ j 1))))))
+
+(define
+  forth-search-bytes
+  (fn
+    (state a1 u1 a2 u2 i)
+    (cond
+      ((= u2 0) 0)
+      ((> (+ i u2) u1) -1)
+      ((forth-match-at state a1 i a2 u2 0) i)
+      (else (forth-search-bytes state a1 u1 a2 u2 (+ i 1))))))
+
+(define
+  forth-digit-of-byte
+  (fn
+    (c base)
+    (let
+      ((v
+        (cond
+          ((and (>= c 48) (<= c 57)) (- c 48))
+          ((and (>= c 65) (<= c 90)) (- c 55))
+          ((and (>= c 97) (<= c 122)) (- c 87))
+          (else -1))))
+      (if (or (< v 0) (>= v base)) -1 v))))
+
+(define
+  forth-numparse-loop
+  (fn
+    (state addr u acc base)
+    (if
+      (= u 0)
+      (list acc addr u)
+      (let
+        ((c (forth-mem-read state addr)))
+        (let
+          ((dig (forth-digit-of-byte c base)))
+          (if
+            (< dig 0)
+            (list acc addr u)
+            (forth-numparse-loop
+              state
+              (+ addr 1)
+              (- u 1)
+              (+ (* acc base) dig)
+              base)))))))
+
+(define
+  forth-pic-S-loop
+  (fn
+    (state)
+    (forth-pic-step state)
+    (let
+      ((hi (forth-pop state)) (lo (forth-pop state)))
+      (if
+        (and (= lo 0) (= hi 0))
+        (begin (forth-push state 0) (forth-push state 0))
+        (begin
+          (forth-push state lo)
+          (forth-push state hi)
+          (forth-pic-S-loop state))))))
+
+(define
+  forth-double-push-s
+  (fn
+    (state d)
+    (if
+      (>= d 0)
+      (forth-double-push-u state d)
+      (let
+        ((q (- 0 d)))
+        (let
+          ((qlo (mod q forth-2pow32)) (qhi (floor (/ q forth-2pow32))))
+          (if
+            (= qlo 0)
+            (begin
+              (forth-push state 0)
+              (forth-push state (forth-from-unsigned (- forth-2pow32 qhi) 32)))
+            (begin
+              (forth-push
+                state
+                (forth-from-unsigned (- forth-2pow32 qlo) 32))
+              (forth-push
+                state
+                (forth-from-unsigned (- (- forth-2pow32 qhi) 1) 32)))))))))
+
 (define
   forth-to-unsigned
   (fn (n w) (let ((m (pow 2 w))) (mod (+ (mod n m) m) m))))
@@ -285,6 +621,19 @@
         (s)
         (let ((a (forth-peek s))) (when (not (= a 0)) (forth-push s a)))))
     (forth-def-prim! state "DEPTH" (fn (s) (forth-push s (forth-depth s))))
+    (forth-def-prim! state "SP@" (fn (s) (forth-push s (forth-depth s))))
+    (forth-def-prim!
+      state
+      "SP!"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)))
+          (let
+            ((cur (forth-depth s)))
+            (when
+              (> cur n)
+              (dict-set! s "dstack" (drop (get s "dstack") (- cur n))))))))
     (forth-def-prim!
       state
       "PICK"
@@ -354,11 +703,17 @@
           (forth-push s d)
           (forth-push s a)
           (forth-push s b))))
-    (forth-def-prim! state "+" (forth-binop (fn (a b) (+ a b))))
+    (forth-def-prim! state "+" (forth-binop (fn (a b) (forth-clip (+ a b)))))
-    (forth-def-prim! state "-" (forth-binop (fn (a b) (- a b))))
+    (forth-def-prim! state "-" (forth-binop (fn (a b) (forth-clip (- a b)))))
-    (forth-def-prim! state "*" (forth-binop (fn (a b) (* a b))))
+    (forth-def-prim! state "*" (forth-binop (fn (a b) (forth-clip (* a b)))))
-    (forth-def-prim! state "/" (forth-binop forth-div))
+    (forth-def-prim!
-    (forth-def-prim! state "MOD" (forth-binop forth-mod))
+      state
+      "/"
+      (forth-binop (fn (a b) (forth-clip (forth-div a b)))))
+    (forth-def-prim!
+      state
+      "MOD"
+      (forth-binop (fn (a b) (forth-clip (forth-mod a b)))))
     (forth-def-prim!
       state
       "/MOD"
@@ -368,8 +723,8 @@
           ((b (forth-pop s)) (a (forth-pop s)))
           (forth-push s (forth-mod a b))
           (forth-push s (forth-div a b)))))
-    (forth-def-prim! state "NEGATE" (forth-unop (fn (a) (- 0 a))))
+    (forth-def-prim! state "NEGATE" (forth-unop (fn (a) (forth-clip (- 0 a)))))
-    (forth-def-prim! state "ABS" (forth-unop abs))
+    (forth-def-prim! state "ABS" (forth-unop (fn (a) (forth-clip (abs a)))))
     (forth-def-prim!
       state
       "MIN"
@@ -378,12 +733,15 @@
       state
       "MAX"
       (forth-binop (fn (a b) (if (> a b) a b))))
-    (forth-def-prim! state "1+" (forth-unop (fn (a) (+ a 1))))
+    (forth-def-prim! state "1+" (forth-unop (fn (a) (forth-clip (+ a 1)))))
-    (forth-def-prim! state "1-" (forth-unop (fn (a) (- a 1))))
+    (forth-def-prim! state "1-" (forth-unop (fn (a) (forth-clip (- a 1)))))
-    (forth-def-prim! state "2+" (forth-unop (fn (a) (+ a 2))))
+    (forth-def-prim! state "2+" (forth-unop (fn (a) (forth-clip (+ a 2)))))
-    (forth-def-prim! state "2-" (forth-unop (fn (a) (- a 2))))
+    (forth-def-prim! state "2-" (forth-unop (fn (a) (forth-clip (- a 2)))))
-    (forth-def-prim! state "2*" (forth-unop (fn (a) (* a 2))))
+    (forth-def-prim! state "2*" (forth-unop (fn (a) (forth-clip (* a 2)))))
-    (forth-def-prim! state "2/" (forth-unop (fn (a) (floor (/ a 2)))))
+    (forth-def-prim!
+      state
+      "2/"
+      (forth-unop (fn (a) (forth-clip (floor (/ a 2))))))
     (forth-def-prim! state "=" (forth-cmp (fn (a b) (= a b))))
     (forth-def-prim! state "<>" (forth-cmp (fn (a b) (not (= a b)))))
     (forth-def-prim! state "<" (forth-cmp (fn (a b) (< a b))))
@@ -398,6 +756,30 @@
     (forth-def-prim! state "OR" (forth-binop forth-bit-or))
     (forth-def-prim! state "XOR" (forth-binop forth-bit-xor))
     (forth-def-prim! state "INVERT" (forth-unop forth-bit-invert))
+    (forth-def-prim!
+      state
+      "LSHIFT"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (x (forth-pop s)))
+          (let
+            ((ux (forth-to-unsigned x forth-bits-width)))
+            (let
+              ((res (mod (* ux (pow 2 u)) (pow 2 forth-bits-width))))
+              (forth-push s (forth-from-unsigned res forth-bits-width)))))))
+    (forth-def-prim!
+      state
+      "RSHIFT"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (x (forth-pop s)))
+          (let
+            ((ux (forth-to-unsigned x forth-bits-width)))
+            (let
+              ((res (floor (/ ux (pow 2 u)))))
+              (forth-push s (forth-from-unsigned res forth-bits-width)))))))
     (forth-def-prim!
       state
       "."
@@ -416,7 +798,7 @@
     (forth-def-prim!
       state
       "EMIT"
-      (fn (s) (forth-emit-str s (code-char (forth-pop s)))))
+      (fn (s) (forth-emit-str s (char-from-code (forth-pop s)))))
     (forth-def-prim! state "CR" (fn (s) (forth-emit-str s "\n")))
     (forth-def-prim! state "SPACE" (fn (s) (forth-emit-str s " ")))
     (forth-def-prim!
@@ -430,4 +812,459 @@
             (> n 0)
             (for-each (fn (_) (forth-emit-str s " ")) (range 0 n))))))
     (forth-def-prim! state "BL" (fn (s) (forth-push s 32)))
+    (forth-def-prim!
+      state
+      "DECIMAL"
+      (fn (s) (dict-set! (get s "vars") "base" 10)))
+    (forth-def-prim!
+      state
+      "HEX"
+      (fn (s) (dict-set! (get s "vars") "base" 16)))
+    (forth-def-prim!
+      state
+      "OCTAL"
+      (fn (s) (dict-set! (get s "vars") "base" 8)))
+    (forth-def-prim! state "BASE" (fn (s) (forth-push s "base")))
+    (forth-def-prim! state "I" (fn (s) (forth-push s (forth-rpeek s))))
+    (forth-def-prim!
+      state
+      "J"
+      (fn (s) (forth-push s (nth (get s "rstack") 2))))
+    (forth-def-prim! state ">R" (fn (s) (forth-rpush s (forth-pop s))))
+    (forth-def-prim! state "R>" (fn (s) (forth-push s (forth-rpop s))))
+    (forth-def-prim! state "R@" (fn (s) (forth-push s (forth-rpeek s))))
+    (forth-def-prim!
+      state
+      "2>R"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-rpush s a)
+          (forth-rpush s b))))
+    (forth-def-prim!
+      state
+      "2R>"
+      (fn
+        (s)
+        (let
+          ((b (forth-rpop s)) (a (forth-rpop s)))
+          (forth-push s a)
+          (forth-push s b))))
+    (forth-def-prim!
+      state
+      "2R@"
+      (fn
+        (s)
+        (let
+          ((rs (get s "rstack")))
+          (when
+            (< (len rs) 2)
+            (forth-error s "return stack underflow"))
+          (forth-push s (nth rs 1))
+          (forth-push s (nth rs 0)))))
+    (forth-def-prim!
+      state
+      "C@"
+      (fn
+        (s)
+        (let ((addr (forth-pop s))) (forth-push s (forth-mem-read s addr)))))
+    (forth-def-prim!
+      state
+      "C!"
+      (fn
+        (s)
+        (let
+          ((addr (forth-pop s)) (v (forth-pop s)))
+          (forth-mem-write! s addr v))))
+    (forth-def-prim! state "CHAR+" (fn (s) (forth-push s (+ (forth-pop s) 1))))
+    (forth-def-prim! state "CHARS" (fn (s) nil))
+    (forth-def-prim!
+      state
+      "TYPE"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (addr (forth-pop s)))
+          (forth-emit-str s (forth-mem-read-string s addr u)))))
+    (forth-def-prim!
+      state
+      "COUNT"
+      (fn
+        (s)
+        (let
+          ((addr (forth-pop s)))
+          (let
+            ((u (forth-mem-read s addr)))
+            (forth-push s (+ addr 1))
+            (forth-push s u)))))
+    (forth-def-prim!
+      state
+      "FILL"
+      (fn
+        (s)
+        (let
+          ((char (forth-pop s)) (u (forth-pop s)) (addr (forth-pop s)))
+          (forth-fill-loop s addr u char 0))))
+    (forth-def-prim!
+      state
+      "BLANK"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (addr (forth-pop s)))
+          (forth-fill-loop s addr u 32 0))))
+    (forth-def-prim!
+      state
+      "CMOVE"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (dst (forth-pop s)) (src (forth-pop s)))
+          (forth-cmove-loop s src dst u 0))))
+    (forth-def-prim!
+      state
+      "CMOVE>"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (dst (forth-pop s)) (src (forth-pop s)))
+          (forth-cmove-loop-desc s src dst u (- u 1)))))
+    (forth-def-prim!
+      state
+      "MOVE"
+      (fn
+        (s)
+        (let
+          ((u (forth-pop s)) (dst (forth-pop s)) (src (forth-pop s)))
+          (if
+            (or (<= dst src) (>= dst (+ src u)))
+            (forth-cmove-loop s src dst u 0)
+            (forth-cmove-loop-desc s src dst u (- u 1))))))
+    (forth-def-prim!
+      state
+      "S>D"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)))
+          (forth-push s n)
+          (forth-push s (if (< n 0) -1 0)))))
+    (forth-def-prim! state "D>S" (fn (s) (forth-pop s)))
+    (forth-def-prim!
+      state
+      "M*"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-double-push-s s (* a b)))))
+    (forth-def-prim!
+      state
+      "UM*"
+      (fn
+        (s)
+        (let
+          ((b (forth-pop s)) (a (forth-pop s)))
+          (forth-double-push-u
+            s
+            (* (forth-to-unsigned a 32) (forth-to-unsigned b 32))))))
+    (forth-def-prim!
+      state
+      "UM/MOD"
+      (fn
+        (s)
+        (let
+          ((u1 (forth-pop s)) (hi (forth-pop s)) (lo (forth-pop s)))
+          (let
+            ((d (forth-double-from-cells-u lo hi))
+              (divisor (forth-to-unsigned u1 32)))
+            (when (= divisor 0) (forth-error s "division by zero"))
+            (let
+              ((q (floor (/ d divisor))) (r (mod d divisor)))
+              (forth-push s (forth-from-unsigned r 32))
+              (forth-push s (forth-from-unsigned q 32)))))))
+    (forth-def-prim!
+      state
+      "FM/MOD"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)) (hi (forth-pop s)) (lo (forth-pop s)))
+          (let
+            ((d (forth-double-from-cells-s lo hi)))
+            (when (= n 0) (forth-error s "division by zero"))
+            (let
+              ((q (floor (/ d n))))
+              (let
+                ((r (- d (* q n))))
+                (forth-push s (forth-clip r))
+                (forth-push s (forth-clip q))))))))
+    (forth-def-prim!
+      state
+      "SM/REM"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)) (hi (forth-pop s)) (lo (forth-pop s)))
+          (let
+            ((d (forth-double-from-cells-s lo hi)))
+            (when (= n 0) (forth-error s "division by zero"))
+            (let
+              ((q (forth-trunc (/ d n))))
+              (let
+                ((r (- d (* q n))))
+                (forth-push s (forth-clip r))
+                (forth-push s (forth-clip q))))))))
+    (forth-def-prim!
+      state
+      "*/"
+      (fn
+        (s)
+        (let
+          ((n3 (forth-pop s)) (n2 (forth-pop s)) (n1 (forth-pop s)))
+          (when (= n3 0) (forth-error s "division by zero"))
+          (forth-push s (forth-clip (forth-trunc (/ (* n1 n2) n3)))))))
+    (forth-def-prim!
+      state
+      "*/MOD"
+      (fn
+        (s)
+        (let
+          ((n3 (forth-pop s)) (n2 (forth-pop s)) (n1 (forth-pop s)))
+          (when (= n3 0) (forth-error s "division by zero"))
+          (let
+            ((d (* n1 n2)))
+            (let
+              ((q (forth-trunc (/ d n3))))
+              (let
+                ((r (- d (* q n3))))
+                (forth-push s (forth-clip r))
+                (forth-push s (forth-clip q))))))))
+    (forth-def-prim!
+      state
+      "D+"
+      (fn
+        (s)
+        (let
+          ((hi2 (forth-pop s))
+            (lo2 (forth-pop s))
+            (hi1 (forth-pop s))
+            (lo1 (forth-pop s)))
+          (forth-double-push-s
+            s
+            (+
+              (forth-double-from-cells-s lo1 hi1)
+              (forth-double-from-cells-s lo2 hi2))))))
+    (forth-def-prim!
+      state
+      "D-"
+      (fn
+        (s)
+        (let
+          ((hi2 (forth-pop s))
+            (lo2 (forth-pop s))
+            (hi1 (forth-pop s))
+            (lo1 (forth-pop s)))
+          (forth-double-push-s
+            s
+            (-
+              (forth-double-from-cells-s lo1 hi1)
+              (forth-double-from-cells-s lo2 hi2))))))
+    (forth-def-prim!
+      state
+      "DNEGATE"
+      (fn
+        (s)
+        (let
+          ((hi (forth-pop s)) (lo (forth-pop s)))
+          (forth-double-push-s
+            s
+            (- 0 (forth-double-from-cells-s lo hi))))))
+    (forth-def-prim!
+      state
+      "DABS"
+      (fn
+        (s)
+        (let
+          ((hi (forth-pop s)) (lo (forth-pop s)))
+          (forth-double-push-s s (abs (forth-double-from-cells-s lo hi))))))
+    (forth-def-prim!
+      state
+      "D="
+      (fn
+        (s)
+        (let
+          ((hi2 (forth-pop s))
+            (lo2 (forth-pop s))
+            (hi1 (forth-pop s))
+            (lo1 (forth-pop s)))
+          (forth-push s (if (and (= lo1 lo2) (= hi1 hi2)) -1 0)))))
+    (forth-def-prim!
+      state
+      "D<"
+      (fn
+        (s)
+        (let
+          ((hi2 (forth-pop s))
+            (lo2 (forth-pop s))
+            (hi1 (forth-pop s))
+            (lo1 (forth-pop s)))
+          (forth-push
+            s
+            (if
+              (<
+                (forth-double-from-cells-s lo1 hi1)
+                (forth-double-from-cells-s lo2 hi2))
+              -1
+              0)))))
+    (forth-def-prim!
+      state
+      "D0="
+      (fn
+        (s)
+        (let
+          ((hi (forth-pop s)) (lo (forth-pop s)))
+          (forth-push s (if (and (= lo 0) (= hi 0)) -1 0)))))
+    (forth-def-prim!
+      state
+      "D0<"
+      (fn
+        (s)
+        (let
+          ((hi (forth-pop s)) (lo (forth-pop s)))
+          (forth-push s (if (< hi 0) -1 0)))))
+    (forth-def-prim!
+      state
+      "DMAX"
+      (fn
+        (s)
+        (let
+          ((hi2 (forth-pop s))
+            (lo2 (forth-pop s))
+            (hi1 (forth-pop s))
+            (lo1 (forth-pop s)))
+          (let
+            ((d1 (forth-double-from-cells-s lo1 hi1))
+              (d2 (forth-double-from-cells-s lo2 hi2)))
+            (forth-double-push-s s (if (> d1 d2) d1 d2))))))
+    (forth-def-prim!
+      state
+      "DMIN"
+      (fn
+        (s)
+        (let
+          ((hi2 (forth-pop s))
+            (lo2 (forth-pop s))
+            (hi1 (forth-pop s))
+            (lo1 (forth-pop s)))
+          (let
+            ((d1 (forth-double-from-cells-s lo1 hi1))
+              (d2 (forth-double-from-cells-s lo2 hi2)))
+            (forth-double-push-s s (if (< d1 d2) d1 d2))))))
+    (forth-def-prim! state "<#" (fn (s) (dict-set! s "hold" (list))))
+    (forth-def-prim!
+      state
+      "HOLD"
+      (fn
+        (s)
+        (let
+          ((c (forth-pop s)))
+          (dict-set!
+            s
+            "hold"
+            (cons (char-from-code c) (get s "hold"))))))
+    (forth-def-prim!
+      state
+      "SIGN"
+      (fn
+        (s)
+        (let
+          ((n (forth-pop s)))
+          (when
+            (< n 0)
+            (dict-set! s "hold" (cons "-" (get s "hold")))))))
+    (forth-def-prim!
+      state
+      "#"
+      (fn
+        (s)
+        (let
+          ((hi (forth-pop s)) (lo (forth-pop s)))
+          (let
+            ((d (forth-double-from-cells-u lo hi))
+              (b (get (get s "vars") "base")))
+            (let
+              ((dig (mod d b)) (rest (floor (/ d b))))
+              (let
+                ((ch
+                  (if
+                    (< dig 10)
+                    (char-from-code (+ 48 dig))
+                    (char-from-code (+ 55 dig)))))
+                (dict-set! s "hold" (cons ch (get s "hold")))
+                (forth-double-push-u s rest)))))))
+    (forth-def-prim!
+      state
+      "#S"
+      (fn
+        (s)
+        (forth-pic-S-loop s)))
+    (forth-def-prim!
+      state
+      "#>"
+      (fn
+        (s)
+        (forth-pop s)
+        (forth-pop s)
+        (let
+          ((str-out (forth-join-hold (get s "hold"))))
+          (let
+            ((addr (forth-alloc-bytes! s (len str-out))))
+            (forth-mem-write-string! s addr str-out)
+            (forth-push s addr)
+            (forth-push s (len str-out))))))
+    (forth-def-prim!
+      state
+      "U."
+      (fn
+        (s)
+        (let
+          ((u (forth-to-unsigned (forth-pop s) 32))
+            (b (get (get s "vars") "base")))
+          (forth-emit-str s (str (forth-num-to-string u b) " ")))))
+    (forth-def-prim!
+      state
+      "U.R"
+      (fn
+        (s)
+        (let
+          ((width (forth-pop s))
+            (u (forth-to-unsigned (forth-pop s) 32))
+            (b (get (get s "vars") "base")))
+          (let
+            ((digits (forth-num-to-string u b)))
+            (forth-emit-str
+              s
+              (forth-spaces-str (- width (len digits))))
+            (forth-emit-str s digits)))))
+    (forth-def-prim!
+      state
+      ".R"
+      (fn
+        (s)
+        (let
+          ((width (forth-pop s))
+            (n (forth-pop s))
+            (b (get (get s "vars") "base")))
+          (let
+            ((sign-prefix (if (< n 0) "-" ""))
+              (abs-digits
+                (forth-num-to-string (forth-to-unsigned (abs n) 32) b)))
+            (let
+              ((digits (str sign-prefix abs-digits)))
+              (forth-emit-str
+                s
+                (forth-spaces-str (- width (len digits))))
+              (forth-emit-str s digits))))))
     state))

lib/forth/scoreboard.json

@@ -0,0 +1,12 @@
+{
+  "source": "gerryjackson/forth2012-test-suite src/core.fr",
+  "generated_at": "2026-04-25T04:57:22Z",
+  "chunks_available": 638,
+  "chunks_fed": 638,
+  "total": 638,
+  "pass": 618,
+  "fail": 14,
+  "error": 6,
+  "percent": 96,
+  "note": "completed"
+}

lib/forth/scoreboard.md

@@ -0,0 +1,28 @@
+# Forth Hayes Core scoreboard
+
+| metric            | value |
+| ----------------- | ----: |
+| chunks available  | 638 |
+| chunks fed        | 638 |
+| total             | 638 |
+| pass              | 618 |
+| fail              | 14 |
+| error             | 6 |
+| percent           | 96% |
+
+- **Source**: `gerryjackson/forth2012-test-suite` `src/core.fr`
+- **Generated**: 2026-04-25T04:57:22Z
+- **Note**: completed
+
+A "chunk" is any preprocessed segment ending at a `}T` (every Hayes test
+is one chunk, plus the small declaration blocks between tests).
+The runner catches raised errors at chunk boundaries so one bad chunk
+does not abort the rest. `error` covers chunks that raised; `fail`
+covers tests whose `->` / `}T` comparison mismatched.
+
+### Chunk cap
+
+`conformance.sh` processes the first `$MAX_CHUNKS` chunks (default
+**638**, i.e. the whole Hayes Core file). Lower the cap temporarily
+while iterating on primitives if a regression re-opens an infinite
+loop in later tests.

lib/forth/tests/test-phase3.sx

@@ -0,0 +1,239 @@
+;; Phase 3 — control flow (IF/ELSE/THEN, BEGIN/UNTIL/WHILE/REPEAT/AGAIN,
+;; DO/LOOP, return stack). Grows as each control construct lands.
+
+(define forth-p3-passed 0)
+(define forth-p3-failed 0)
+(define forth-p3-failures (list))
+
+(define
+  forth-p3-assert
+  (fn
+    (label expected actual)
+    (if
+      (= expected actual)
+      (set! forth-p3-passed (+ forth-p3-passed 1))
+      (begin
+        (set! forth-p3-failed (+ forth-p3-failed 1))
+        (set!
+          forth-p3-failures
+          (concat
+            forth-p3-failures
+            (list
+              (str label ": expected " (str expected) " got " (str actual)))))))))
+
+(define
+  forth-p3-check-stack
+  (fn
+    (label src expected)
+    (let ((r (forth-run src))) (forth-p3-assert label expected (nth r 2)))))
+
+(define
+  forth-p3-if-tests
+  (fn
+    ()
+    (forth-p3-check-stack
+      "IF taken (-1)"
+      ": Q -1 IF 10 THEN ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "IF not taken (0)"
+      ": Q 0 IF 10 THEN ; Q"
+      (list))
+    (forth-p3-check-stack
+      "IF with non-zero truthy"
+      ": Q 42 IF 10 THEN ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "IF ELSE — true branch"
+      ": Q -1 IF 10 ELSE 20 THEN ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "IF ELSE — false branch"
+      ": Q 0 IF 10 ELSE 20 THEN ; Q"
+      (list 20))
+    (forth-p3-check-stack
+      "IF consumes flag"
+      ": Q IF 1 ELSE 2 THEN ; 0 Q"
+      (list 2))
+    (forth-p3-check-stack
+      "absolute value via IF"
+      ": ABS2 DUP 0 < IF NEGATE THEN ; -7 ABS2"
+      (list 7))
+    (forth-p3-check-stack
+      "abs leaves positive alone"
+      ": ABS2 DUP 0 < IF NEGATE THEN ; 7 ABS2"
+      (list 7))
+    (forth-p3-check-stack
+      "sign: negative"
+      ": SIGN DUP 0 < IF DROP -1 ELSE DROP 1 THEN ; -3 SIGN"
+      (list -1))
+    (forth-p3-check-stack
+      "sign: positive"
+      ": SIGN DUP 0 < IF DROP -1 ELSE DROP 1 THEN ; 3 SIGN"
+      (list 1))
+    (forth-p3-check-stack
+      "nested IF (both true)"
+      ": Q 1 IF 1 IF 10 ELSE 20 THEN ELSE 30 THEN ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "nested IF (inner false)"
+      ": Q 1 IF 0 IF 10 ELSE 20 THEN ELSE 30 THEN ; Q"
+      (list 20))
+    (forth-p3-check-stack
+      "nested IF (outer false)"
+      ": Q 0 IF 0 IF 10 ELSE 20 THEN ELSE 30 THEN ; Q"
+      (list 30))
+    (forth-p3-check-stack
+      "IF before other ops"
+      ": Q 1 IF 5 ELSE 6 THEN 2 * ; Q"
+      (list 10))
+    (forth-p3-check-stack
+      "IF in chained def"
+      ": POS? 0 > ;
+       : DOUBLE-IF-POS DUP POS? IF 2 * THEN ;
+       3 DOUBLE-IF-POS"
+      (list 6))
+    (forth-p3-check-stack
+      "empty then branch"
+      ": Q 1 IF THEN 99 ; Q"
+      (list 99))
+    (forth-p3-check-stack
+      "empty else branch"
+      ": Q 0 IF 99 ELSE THEN ; Q"
+      (list))
+    (forth-p3-check-stack
+      "sequential IF blocks"
+      ": Q -1 IF 1 THEN -1 IF 2 THEN ; Q"
+      (list 1 2))))
+
+(define
+  forth-p3-loop-tests
+  (fn
+    ()
+    (forth-p3-check-stack
+      "BEGIN UNTIL (countdown to zero)"
+      ": CD BEGIN 1- DUP 0 = UNTIL ; 3 CD"
+      (list 0))
+    (forth-p3-check-stack
+      "BEGIN UNTIL — single pass (UNTIL true immediately)"
+      ": Q BEGIN -1 UNTIL 42 ; Q"
+      (list 42))
+    (forth-p3-check-stack
+      "BEGIN UNTIL — accumulate sum 1+2+3"
+      ": SUM3 0 3 BEGIN TUCK + SWAP 1- DUP 0 = UNTIL DROP ; SUM3"
+      (list 6))
+    (forth-p3-check-stack
+      "BEGIN WHILE REPEAT — triangular sum 5"
+      ": TRI 0 5 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ; TRI"
+      (list 15))
+    (forth-p3-check-stack
+      "BEGIN WHILE REPEAT — zero iterations"
+      ": TRI 0 0 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ; TRI"
+      (list 0))
+    (forth-p3-check-stack
+      "BEGIN WHILE REPEAT — one iteration"
+      ": TRI 0 1 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ; TRI"
+      (list 1))
+    (forth-p3-check-stack
+      "nested BEGIN UNTIL"
+      ": INNER BEGIN 1- DUP 0 = UNTIL DROP ;
+       : OUTER BEGIN 3 INNER 1- DUP 0 = UNTIL ;
+       2 OUTER"
+      (list 0))
+    (forth-p3-check-stack
+      "BEGIN UNTIL after colon prefix"
+      ": TEN 10 ;
+       : CD TEN BEGIN 1- DUP 0 = UNTIL ;
+       CD"
+      (list 0))
+    (forth-p3-check-stack
+      "WHILE inside IF branch"
+      ": Q 1 IF 0 3 BEGIN DUP 0 > WHILE TUCK + SWAP 1- REPEAT DROP ELSE 99 THEN ; Q"
+      (list 6))))
+
+(define
+  forth-p3-do-tests
+  (fn
+    ()
+    (forth-p3-check-stack
+      "DO LOOP — simple sum 0..4"
+      ": SUM 0 5 0 DO I + LOOP ; SUM"
+      (list 10))
+    (forth-p3-check-stack
+      "DO LOOP — 10..14 sum using I"
+      ": SUM 0 15 10 DO I + LOOP ; SUM"
+      (list 60))
+    (forth-p3-check-stack
+      "DO LOOP — limit = start runs one pass"
+      ": SUM 0 5 5 DO I + LOOP ; SUM"
+      (list 5))
+    (forth-p3-check-stack
+      "DO LOOP — count iterations"
+      ": COUNT 0 4 0 DO 1+ LOOP ; COUNT"
+      (list 4))
+    (forth-p3-check-stack
+      "DO LOOP — nested, I inner / J outer"
+      ": MATRIX 0 3 0 DO 3 0 DO I J + + LOOP LOOP ; MATRIX"
+      (list 18))
+    (forth-p3-check-stack
+      "DO LOOP — I used in arithmetic"
+      ": DBL 0 5 1 DO I 2 * + LOOP ; DBL"
+      (list 20))
+    (forth-p3-check-stack
+      "+LOOP — count by 2"
+      ": Q 0 10 0 DO I + 2 +LOOP ; Q"
+      (list 20))
+    (forth-p3-check-stack
+      "+LOOP — count by 3"
+      ": Q 0 10 0 DO I + 3 +LOOP ; Q"
+      (list 18))
+    (forth-p3-check-stack
+      "+LOOP — negative step"
+      ": Q 0 0 10 DO I + -1 +LOOP ; Q"
+      (list 55))
+    (forth-p3-check-stack
+      "LEAVE — early exit at I=3"
+      ": Q 0 10 0 DO I 3 = IF LEAVE THEN I + LOOP ; Q"
+      (list 3))
+    (forth-p3-check-stack
+      "LEAVE — in nested loop exits only inner"
+      ": Q 0 3 0 DO 5 0 DO I 2 = IF LEAVE THEN I + LOOP LOOP ; Q"
+      (list 3))
+    (forth-p3-check-stack
+      "DO LOOP preserves outer stack"
+      ": Q 99 5 0 DO I + LOOP ; Q"
+      (list 109))
+    (forth-p3-check-stack
+      ">R R>"
+      ": Q 7 >R 11 R> ; Q"
+      (list 11 7))
+    (forth-p3-check-stack
+      ">R R@ R>"
+      ": Q 7 >R R@ R> ; Q"
+      (list 7 7))
+    (forth-p3-check-stack
+      "2>R 2R>"
+      ": Q 1 2 2>R 99 2R> ; Q"
+      (list 99 1 2))
+    (forth-p3-check-stack
+      "2>R 2R@ 2R>"
+      ": Q 3 4 2>R 2R@ 2R> ; Q"
+      (list 3 4 3 4))))
+
+(define
+  forth-p3-run-all
+  (fn
+    ()
+    (set! forth-p3-passed 0)
+    (set! forth-p3-failed 0)
+    (set! forth-p3-failures (list))
+    (forth-p3-if-tests)
+    (forth-p3-loop-tests)
+    (forth-p3-do-tests)
+    (dict
+      "passed"
+      forth-p3-passed
+      "failed"
+      forth-p3-failed
+      "failures"
+      forth-p3-failures)))

lib/forth/tests/test-phase4.sx

@@ -0,0 +1,268 @@
+;; Phase 4 — strings + more Core.
+;; Uses the byte-memory model on state ("mem" dict + "here" cursor).
+
+(define forth-p4-passed 0)
+(define forth-p4-failed 0)
+(define forth-p4-failures (list))
+
+(define
+  forth-p4-assert
+  (fn
+    (label expected actual)
+    (if
+      (= expected actual)
+      (set! forth-p4-passed (+ forth-p4-passed 1))
+      (begin
+        (set! forth-p4-failed (+ forth-p4-failed 1))
+        (set!
+          forth-p4-failures
+          (concat
+            forth-p4-failures
+            (list
+              (str label ": expected " (str expected) " got " (str actual)))))))))
+
+(define
+  forth-p4-check-output
+  (fn
+    (label src expected)
+    (let ((r (forth-run src))) (forth-p4-assert label expected (nth r 1)))))
+
+(define
+  forth-p4-check-stack-size
+  (fn
+    (label src expected-n)
+    (let
+      ((r (forth-run src)))
+      (forth-p4-assert label expected-n (len (nth r 2))))))
+
+(define
+  forth-p4-check-top
+  (fn
+    (label src expected)
+    (let
+      ((r (forth-run src)))
+      (let
+        ((stk (nth r 2)))
+        (forth-p4-assert label expected (nth stk (- (len stk) 1)))))))
+
+(define
+  forth-p4-check-typed
+  (fn
+    (label src expected)
+    (forth-p4-check-output label (str src " TYPE") expected)))
+
+(define
+  forth-p4-string-tests
+  (fn
+    ()
+    (forth-p4-check-typed
+      "S\" + TYPE — hello"
+      "S\" HELLO\""
+      "HELLO")
+    (forth-p4-check-typed
+      "S\" + TYPE — two words"
+      "S\" HELLO WORLD\""
+      "HELLO WORLD")
+    (forth-p4-check-typed
+      "S\" + TYPE — empty"
+      "S\" \""
+      "")
+    (forth-p4-check-typed
+      "S\" + TYPE — single char"
+      "S\" X\""
+      "X")
+    (forth-p4-check-stack-size
+      "S\" pushes (addr len)"
+      "S\" HI\""
+      2)
+    (forth-p4-check-top
+      "S\" length is correct"
+      "S\" HELLO\""
+      5)
+    (forth-p4-check-output
+      ".\" prints at interpret time"
+      ".\" HELLO\""
+      "HELLO")
+    (forth-p4-check-output
+      ".\" in colon def"
+      ": GREET .\" HI \" ; GREET GREET"
+      "HI HI ")))
+
+(define
+  forth-p4-count-tests
+  (fn
+    ()
+    (forth-p4-check-typed
+      "C\" + COUNT + TYPE"
+      "C\" ABC\" COUNT"
+      "ABC")
+    (forth-p4-check-typed
+      "C\" then COUNT leaves right len"
+      "C\" HI THERE\" COUNT"
+      "HI THERE")))
+
+(define
+  forth-p4-fill-tests
+  (fn
+    ()
+    (forth-p4-check-typed
+      "FILL overwrites prefix bytes"
+      "S\" ABCDE\" 2DUP DROP 3 65 FILL"
+      "AAADE")
+    (forth-p4-check-typed
+      "BLANK sets spaces"
+      "S\" XYZAB\" 2DUP DROP 3 BLANK"
+      "   AB")))
+
+(define
+  forth-p4-cmove-tests
+  (fn
+    ()
+    (forth-p4-check-output
+      "CMOVE copies HELLO forward"
+      ": MKH 72 0 C! 69 1 C! 76 2 C! 76 3 C! 79 4 C! ;
+       : T MKH 0 10 5 CMOVE 10 5 TYPE ; T"
+      "HELLO")
+    (forth-p4-check-output
+      "CMOVE> copies overlapping backward"
+      ": MKA 65 0 C! 66 1 C! 67 2 C! ;
+       : T MKA 0 1 2 CMOVE> 0 3 TYPE ; T"
+      "AAB")
+    (forth-p4-check-output
+      "MOVE picks direction for overlap"
+      ": MKA 65 0 C! 66 1 C! 67 2 C! ;
+       : T MKA 0 1 2 MOVE 0 3 TYPE ; T"
+      "AAB")))
+
+(define
+  forth-p4-charplus-tests
+  (fn
+    ()
+    (forth-p4-check-top
+      "CHAR+ increments"
+      "5 CHAR+"
+      6)))
+
+(define
+  forth-p4-char-tests
+  (fn
+    ()
+    (forth-p4-check-top "CHAR A -> 65" "CHAR A" 65)
+    (forth-p4-check-top "CHAR x -> 120" "CHAR x" 120)
+    (forth-p4-check-top "CHAR takes only first char" "CHAR HELLO" 72)
+    (forth-p4-check-top
+      "[CHAR] compiles literal"
+      ": AA [CHAR] A ; AA"
+      65)
+    (forth-p4-check-top
+      "[CHAR] reads past IMMEDIATE"
+      ": ZZ [CHAR] Z ; ZZ"
+      90)
+    (forth-p4-check-stack-size
+      "[CHAR] doesn't leak at compile time"
+      ": FOO [CHAR] A ; "
+      0)))
+
+(define
+  forth-p4-key-accept-tests
+  (fn
+    ()
+    (let
+      ((r (forth-run "1000 2 ACCEPT")))
+      (let ((stk (nth r 2))) (forth-p4-assert "ACCEPT empty buf -> 0" (list 0) stk)))))
+
+(define
+  forth-p4-shift-tests
+  (fn
+    ()
+    (forth-p4-check-top "1 0 LSHIFT" "1 0 LSHIFT" 1)
+    (forth-p4-check-top "1 1 LSHIFT" "1 1 LSHIFT" 2)
+    (forth-p4-check-top "1 2 LSHIFT" "1 2 LSHIFT" 4)
+    (forth-p4-check-top "1 15 LSHIFT" "1 15 LSHIFT" 32768)
+    (forth-p4-check-top "1 31 LSHIFT" "1 31 LSHIFT" -2147483648)
+    (forth-p4-check-top "1 0 RSHIFT" "1 0 RSHIFT" 1)
+    (forth-p4-check-top "1 1 RSHIFT" "1 1 RSHIFT" 0)
+    (forth-p4-check-top "2 1 RSHIFT" "2 1 RSHIFT" 1)
+    (forth-p4-check-top "4 2 RSHIFT" "4 2 RSHIFT" 1)
+    (forth-p4-check-top "-1 1 RSHIFT (logical, not arithmetic)" "-1 1 RSHIFT" 2147483647)
+    (forth-p4-check-top "MSB via 1S 1 RSHIFT INVERT" "0 INVERT 1 RSHIFT INVERT" -2147483648)))
+
+(define
+  forth-p4-sp-tests
+  (fn
+    ()
+    (forth-p4-check-top "SP@ returns depth (0)" "SP@" 0)
+    (forth-p4-check-top
+      "SP@ after pushes"
+      "1 2 3 SP@ SWAP DROP SWAP DROP SWAP DROP"
+      3)
+    (forth-p4-check-stack-size
+      "SP! truncates"
+      "1 2 3 4 5 2 SP!"
+      2)
+    (forth-p4-check-top
+      "SP! leaves base items intact"
+      "1 2 3 4 5 2 SP!"
+      2)))
+
+(define
+  forth-p4-base-tests
+  (fn
+    ()
+    (forth-p4-check-top
+      "BASE default is 10"
+      "BASE @"
+      10)
+    (forth-p4-check-top
+      "HEX switches base to 16"
+      "HEX BASE @"
+      16)
+    (forth-p4-check-top
+      "DECIMAL resets to 10"
+      "HEX DECIMAL BASE @"
+      10)
+    (forth-p4-check-top
+      "HEX parses 10 as 16"
+      "HEX 10"
+      16)
+    (forth-p4-check-top
+      "HEX parses FF as 255"
+      "HEX FF"
+      255)
+    (forth-p4-check-top
+      "DECIMAL parses 10 as 10"
+      "HEX DECIMAL 10"
+      10)
+    (forth-p4-check-top
+      "OCTAL parses 17 as 15"
+      "OCTAL 17"
+      15)
+    (forth-p4-check-top
+      "BASE @ ; 16 BASE ! ; BASE @"
+      "BASE @ 16 BASE ! BASE @ SWAP DROP"
+      16)))
+
+(define
+  forth-p4-run-all
+  (fn
+    ()
+    (set! forth-p4-passed 0)
+    (set! forth-p4-failed 0)
+    (set! forth-p4-failures (list))
+    (forth-p4-string-tests)
+    (forth-p4-count-tests)
+    (forth-p4-fill-tests)
+    (forth-p4-cmove-tests)
+    (forth-p4-charplus-tests)
+    (forth-p4-char-tests)
+    (forth-p4-key-accept-tests)
+    (forth-p4-base-tests)
+    (forth-p4-shift-tests)
+    (forth-p4-sp-tests)
+    (dict
+      "passed"
+      forth-p4-passed
+      "failed"
+      forth-p4-failed
+      "failures"
+      forth-p4-failures)))

lib/forth/tests/test-phase5.sx

@@ -0,0 +1,333 @@
+;; Phase 5 — Core Extension + memory primitives.
+
+(define forth-p5-passed 0)
+(define forth-p5-failed 0)
+(define forth-p5-failures (list))
+
+(define
+  forth-p5-assert
+  (fn
+    (label expected actual)
+    (if
+      (= expected actual)
+      (set! forth-p5-passed (+ forth-p5-passed 1))
+      (begin
+        (set! forth-p5-failed (+ forth-p5-failed 1))
+        (set!
+          forth-p5-failures
+          (concat
+            forth-p5-failures
+            (list
+              (str label ": expected " (str expected) " got " (str actual)))))))))
+
+(define
+  forth-p5-check-stack
+  (fn
+    (label src expected)
+    (let ((r (forth-run src))) (forth-p5-assert label expected (nth r 2)))))
+
+(define
+  forth-p5-check-top
+  (fn
+    (label src expected)
+    (let
+      ((r (forth-run src)))
+      (let
+        ((stk (nth r 2)))
+        (forth-p5-assert label expected (nth stk (- (len stk) 1)))))))
+
+(define
+  forth-p5-create-tests
+  (fn
+    ()
+    (forth-p5-check-top
+      "CREATE pushes HERE-at-creation"
+      "HERE CREATE FOO FOO ="
+      -1)
+    (forth-p5-check-top
+      "CREATE + ALLOT advances HERE"
+      "HERE 5 ALLOT HERE SWAP -"
+      5)
+    (forth-p5-check-top
+      "CREATE + , stores cell"
+      "CREATE FOO 42 , FOO @"
+      42)
+    (forth-p5-check-stack
+      "CREATE multiple ,"
+      "CREATE TBL 1 , 2 , 3 , TBL @ TBL CELL+ @ TBL CELL+ CELL+ @"
+      (list 1 2 3))
+    (forth-p5-check-top
+      "C, stores byte"
+      "CREATE B 65 C, 66 C, B C@"
+      65)))
+
+(define
+  forth-p5-unsigned-tests
+  (fn
+    ()
+    (forth-p5-check-top "1 2 U<" "1 2 U<" -1)
+    (forth-p5-check-top "2 1 U<" "2 1 U<" 0)
+    (forth-p5-check-top "0 1 U<" "0 1 U<" -1)
+    (forth-p5-check-top "-1 1 U< (since -1 unsigned is huge)" "-1 1 U<" 0)
+    (forth-p5-check-top "1 -1 U<" "1 -1 U<" -1)
+    (forth-p5-check-top "1 2 U>" "1 2 U>" 0)
+    (forth-p5-check-top "-1 1 U>" "-1 1 U>" -1)))
+
+(define
+  forth-p5-2bang-tests
+  (fn
+    ()
+    (forth-p5-check-stack
+      "2! / 2@"
+      "CREATE X 0 , 0 , 11 22 X 2! X 2@"
+      (list 11 22))))
+
+(define
+  forth-p5-mixed-tests
+  (fn
+    ()
+    (forth-p5-check-stack "S>D positive" "5 S>D" (list 5 0))
+    (forth-p5-check-stack "S>D negative" "-5 S>D" (list -5 -1))
+    (forth-p5-check-stack "S>D zero" "0 S>D" (list 0 0))
+    (forth-p5-check-top "D>S keeps low" "5 0 D>S" 5)
+    (forth-p5-check-stack "M* small positive" "3 4 M*" (list 12 0))
+    (forth-p5-check-stack "M* negative" "-3 4 M*" (list -12 -1))
+    (forth-p5-check-stack
+      "M* negative * negative"
+      "-3 -4 M*"
+      (list 12 0))
+    (forth-p5-check-stack "UM* small" "3 4 UM*" (list 12 0))
+    (forth-p5-check-stack
+      "UM/MOD: 100 0 / 5"
+      "100 0 5 UM/MOD"
+      (list 0 20))
+    (forth-p5-check-stack
+      "FM/MOD: -7 / 2 floored"
+      "-7 -1 2 FM/MOD"
+      (list 1 -4))
+    (forth-p5-check-stack
+      "SM/REM: -7 / 2 truncated"
+      "-7 -1 2 SM/REM"
+      (list -1 -3))
+    (forth-p5-check-top "*/ truncated" "7 11 13 */" 5)
+    (forth-p5-check-stack "*/MOD" "7 11 13 */MOD" (list 12 5))))
+
+(define
+  forth-p5-double-tests
+  (fn
+    ()
+    (forth-p5-check-stack "D+ small" "5 0 7 0 D+" (list 12 0))
+    (forth-p5-check-stack "D+ negative" "-5 -1 -3 -1 D+" (list -8 -1))
+    (forth-p5-check-stack "D- small" "10 0 3 0 D-" (list 7 0))
+    (forth-p5-check-stack "DNEGATE positive" "5 0 DNEGATE" (list -5 -1))
+    (forth-p5-check-stack "DNEGATE negative" "-5 -1 DNEGATE" (list 5 0))
+    (forth-p5-check-stack "DABS negative" "-7 -1 DABS" (list 7 0))
+    (forth-p5-check-stack "DABS positive" "7 0 DABS" (list 7 0))
+    (forth-p5-check-top "D= equal" "5 0 5 0 D=" -1)
+    (forth-p5-check-top "D= unequal lo" "5 0 7 0 D=" 0)
+    (forth-p5-check-top "D= unequal hi" "5 0 5 1 D=" 0)
+    (forth-p5-check-top "D< lt" "5 0 7 0 D<" -1)
+    (forth-p5-check-top "D< gt" "7 0 5 0 D<" 0)
+    (forth-p5-check-top "D0= zero" "0 0 D0=" -1)
+    (forth-p5-check-top "D0= nonzero" "5 0 D0=" 0)
+    (forth-p5-check-top "D0< neg" "-5 -1 D0<" -1)
+    (forth-p5-check-top "D0< pos" "5 0 D0<" 0)
+    (forth-p5-check-stack "DMAX" "5 0 7 0 DMAX" (list 7 0))
+    (forth-p5-check-stack "DMIN" "5 0 7 0 DMIN" (list 5 0))))
+
+(define
+  forth-p5-format-tests
+  (fn
+    ()
+    (forth-p4-check-output-passthrough
+      "U. prints with trailing space"
+      "123 U."
+      "123 ")
+    (forth-p4-check-output-passthrough
+      "<# #S #> TYPE — decimal"
+      "123 0 <# #S #> TYPE"
+      "123")
+    (forth-p4-check-output-passthrough
+      "<# #S #> TYPE — hex"
+      "255 HEX 0 <# #S #> TYPE"
+      "FF")
+    (forth-p4-check-output-passthrough
+      "<# # # #> partial"
+      "1234 0 <# # # #> TYPE"
+      "34")
+    (forth-p4-check-output-passthrough
+      "SIGN holds minus"
+      "<# -1 SIGN -1 SIGN 0 0 #> TYPE"
+      "--")
+    (forth-p4-check-output-passthrough
+      ".R right-justifies"
+      "42 5 .R"
+      "   42")
+    (forth-p4-check-output-passthrough
+      ".R negative"
+      "-42 5 .R"
+      "  -42")
+    (forth-p4-check-output-passthrough
+      "U.R"
+      "42 5 U.R"
+      "   42")
+    (forth-p4-check-output-passthrough
+      "HOLD char"
+      "<# 0 0 65 HOLD #> TYPE"
+      "A")))
+
+(define
+  forth-p5-dict-tests
+  (fn
+    ()
+    (forth-p5-check-top
+      "EXECUTE via tick"
+      ": INC 1+ ; 9 ' INC EXECUTE"
+      10)
+    (forth-p5-check-top
+      "['] inside def"
+      ": DUB 2* ; : APPLY ['] DUB EXECUTE ; 5 APPLY"
+      10)
+    (forth-p5-check-top
+      ">BODY of CREATE word"
+      "CREATE C 99 , ' C >BODY @"
+      99)
+    (forth-p5-check-stack
+      "WORD parses next token to counted-string"
+      ": A 5 ; BL WORD A COUNT TYPE"
+      (list))
+    (forth-p5-check-top
+      "FIND on known word -> non-zero"
+      ": A 5 ; BL WORD A FIND SWAP DROP"
+      -1)))
+
+(define
+  forth-p5-state-tests
+  (fn
+    ()
+    (forth-p5-check-top
+      "STATE @ in interpret mode"
+      "STATE @"
+      0)
+    (forth-p5-check-top
+      "STATE @ via IMMEDIATE inside compile"
+      ": GT8 STATE @ ; IMMEDIATE : T GT8 LITERAL ; T"
+      -1)
+    (forth-p5-check-top
+      "[ ] LITERAL captures"
+      ": SEVEN [ 7 ] LITERAL ; SEVEN"
+      7)
+    (forth-p5-check-top
+      "EVALUATE in interpret mode"
+      "S\" 5 7 +\" EVALUATE"
+      12)
+    (forth-p5-check-top
+      "EVALUATE inside def"
+      ": A 100 ; : B S\" A\" EVALUATE ; B"
+      100)))
+
+(define
+  forth-p5-misc-tests
+  (fn
+    ()
+    (forth-p5-check-top "WITHIN inclusive lower" "3 2 10 WITHIN" -1)
+    (forth-p5-check-top "WITHIN exclusive upper" "10 2 10 WITHIN" 0)
+    (forth-p5-check-top "WITHIN below range" "1 2 10 WITHIN" 0)
+    (forth-p5-check-top "WITHIN at lower" "2 2 10 WITHIN" -1)
+    (forth-p5-check-top
+      "EXIT leaves colon-def early"
+      ": F 5 EXIT 99 ; F"
+      5)
+    (forth-p5-check-stack
+      "EXIT in IF branch"
+      ": F 5 0 IF DROP 99 EXIT THEN ; F"
+      (list 5))
+    (forth-p5-check-top
+      "UNLOOP + EXIT in DO"
+      ": SUM 0 10 0 DO I 5 = IF I UNLOOP EXIT THEN LOOP ; SUM"
+      5)))
+
+(define
+  forth-p5-fa-tests
+  (fn
+    ()
+    (forth-p5-check-top
+      "R/O R/W W/O constants"
+      "R/O R/W W/O + +"
+      3)
+    (forth-p5-check-top
+      "CREATE-FILE returns ior=0"
+      "CREATE PAD 50 ALLOT PAD S\" /tmp/test.fxf\" ROT SWAP CMOVE S\" /tmp/test.fxf\" R/W CREATE-FILE SWAP DROP"
+      0)
+    (forth-p5-check-top
+      "WRITE-FILE then CLOSE"
+      "S\" /tmp/t2.fxf\" R/W CREATE-FILE DROP >R S\" HI\" R@ WRITE-FILE R> CLOSE-FILE +"
+      0)
+    (forth-p5-check-top
+      "OPEN-FILE on unknown path returns ior!=0"
+      "S\" /tmp/nope.fxf\" R/O OPEN-FILE SWAP DROP 0 ="
+      0)))
+
+(define
+  forth-p5-string-tests
+  (fn
+    ()
+    (forth-p5-check-top "COMPARE equal" "S\" ABC\" S\" ABC\" COMPARE" 0)
+    (forth-p5-check-top "COMPARE less" "S\" ABC\" S\" ABD\" COMPARE" -1)
+    (forth-p5-check-top "COMPARE greater" "S\" ABD\" S\" ABC\" COMPARE" 1)
+    (forth-p5-check-top
+      "COMPARE prefix less"
+      "S\" AB\" S\" ABC\" COMPARE"
+      -1)
+    (forth-p5-check-top
+      "COMPARE prefix greater"
+      "S\" ABC\" S\" AB\" COMPARE"
+      1)
+    (forth-p5-check-top
+      "SEARCH found flag"
+      "S\" HELLO WORLD\" S\" WORLD\" SEARCH"
+      -1)
+    (forth-p5-check-top
+      "SEARCH not found flag"
+      "S\" HELLO\" S\" XYZ\" SEARCH"
+      0)
+    (forth-p5-check-top
+      "SEARCH empty needle flag"
+      "S\" HELLO\" S\" \" SEARCH"
+      -1)
+    (forth-p5-check-top
+      "SLITERAL via [ S\" ... \" ]"
+      ": A [ S\" HI\" ] SLITERAL ; A SWAP DROP"
+      2)))
+
+(define
+  forth-p4-check-output-passthrough
+  (fn
+    (label src expected)
+    (let ((r (forth-run src))) (forth-p5-assert label expected (nth r 1)))))
+
+(define
+  forth-p5-run-all
+  (fn
+    ()
+    (set! forth-p5-passed 0)
+    (set! forth-p5-failed 0)
+    (set! forth-p5-failures (list))
+    (forth-p5-create-tests)
+    (forth-p5-unsigned-tests)
+    (forth-p5-2bang-tests)
+    (forth-p5-mixed-tests)
+    (forth-p5-double-tests)
+    (forth-p5-format-tests)
+    (forth-p5-dict-tests)
+    (forth-p5-state-tests)
+    (forth-p5-misc-tests)
+    (forth-p5-fa-tests)
+    (forth-p5-string-tests)
+    (dict
+      "passed"
+      forth-p5-passed
+      "failed"
+      forth-p5-failed
+      "failures"
+      forth-p5-failures)))

lib/js/lexer.sx

@@ -29,16 +29,6 @@
       (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")))))
@@ -47,9 +37,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
@@ -96,18 +86,15 @@
     "await"
     "of"))
 
-;; ── Main tokenizer ────────────────────────────────────────────────
 (define js-keyword? (fn (word) (contains? js-keywords word)))
 
+;; ── Main tokenizer ────────────────────────────────────────────────
 (define
   js-tokenize
   (fn
     (src)
     (let
-      ((tokens (list))
+      ((tokens (list)) (pos 0) (src-len (len src)))
-        (pos 0)
-        (src-len (len src))
-        (nl-before false))
       (define
         js-peek
         (fn
@@ -122,7 +109,11 @@
           (let
             ((sl (len s)))
             (and (<= (+ pos sl) src-len) (= (slice src pos (+ pos sl)) s)))))
-      (define js-emit! (fn (type value start) (append! tokens {:nl nl-before :type type :value value :pos start})))
+      (define
+        js-emit!
+        (fn
+          (type value start)
+          (append! tokens (js-make-token type value start))))
       (define
         skip-line-comment!
         (fn
@@ -145,13 +136,7 @@
           ()
           (cond
             ((>= pos src-len) nil)
-            ((js-ws? (cur))
+            ((js-ws? (cur)) (do (advance! 1) (skip-ws!)))
-              (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) "*"))
@@ -269,55 +254,11 @@
                               ((= 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
+                  (else (do (append! chars (cur)) (advance! 1) (loop))))))
-                    (do (append! chars (cur)) (advance! 1) (loop))))))
             (loop)
             (join "" chars))))
       (define
@@ -348,8 +289,7 @@
                       ()
                       (cond
                         ((>= pos src-len) nil)
-                        ((and (= (cur) "}") (= depth 1))
+                        ((and (= (cur) "}") (= depth 1)) (advance! 1))
-                          (advance! 1))
                         ((= (cur) "}")
                           (do
                             (append! buf (cur))
@@ -385,9 +325,7 @@
                                             (advance! 1)))
                                         (sloop)))
                                     ((= (cur) q)
-                                      (do
+                                      (do (append! buf (cur)) (advance! 1)))
-                                        (append! buf (cur))
-                                        (advance! 1)))
                                     (else
                                       (do
                                         (append! buf (cur))
@@ -396,10 +334,7 @@
                               (sloop)
                               (expr-loop))))
                         (else
-                          (do
+                          (do (append! buf (cur)) (advance! 1) (expr-loop))))))
-                            (append! buf (cur))
-                            (advance! 1)
-                            (expr-loop))))))
                   (expr-loop)
                   (join "" buf))))
             (define
@@ -441,17 +376,14 @@
                               (else (append! chars ch)))
                             (advance! 1))))
                       (loop)))
-                  (else
+                  (else (do (append! chars (cur)) (advance! 1) (loop))))))
-                    (do (append! chars (cur)) (advance! 1) (loop))))))
             (loop)
             (flush-chars!)
             (if
               (= (len parts) 0)
               ""
               (if
-                (and
+                (and (= (len parts) 1) (= (nth (nth parts 0) 0) "str"))
-                  (= (len parts) 1)
-                  (= (nth (nth parts 0) 0) "str"))
                 (nth (nth parts 0) 1)
                 parts)))))
       (define
@@ -467,7 +399,7 @@
                 ((ty (dict-get tk "type")) (vv (dict-get tk "value")))
                 (cond
                   ((= ty "punct")
-                    (and (not (= vv ")")) (not (= vv "]")) (not (= vv "}"))))
+                    (and (not (= vv ")")) (not (= vv "]"))))
                   ((= ty "op") true)
                   ((= ty "keyword")
                     (contains?
@@ -521,13 +453,9 @@
                       (append! buf (cur))
                       (advance! 1)
                       (body-loop)))
-                  ((and (= (cur) "/") (not in-class))
+                  ((and (= (cur) "/") (not in-class)) (advance! 1))
-                    (advance! 1))
                   (else
-                    (begin
+                    (begin (append! buf (cur)) (advance! 1) (body-loop))))))
-                      (append! buf (cur))
-                      (advance! 1)
-                      (body-loop))))))
             (body-loop)
             (let
               ((flags-buf (list)))
@@ -542,7 +470,7 @@
                       (advance! 1)
                       (flags-loop)))))
               (flags-loop)
-              {:flags (join "" flags-buf) :pattern (join "" buf)}))))
+              {:pattern (join "" buf) :flags (join "" flags-buf)}))))
       (define
         try-op-4!
         (fn
@@ -582,113 +510,64 @@
         (fn
           (start)
           (cond
-            ((at? "==")
+            ((at? "==") (do (js-emit! "op" "==" start) (advance! 2) true))
-              (do (js-emit! "op" "==" start) (advance! 2) true))
+            ((at? "!=") (do (js-emit! "op" "!=" start) (advance! 2) true))
-            ((at? "!=")
+            ((at? "<=") (do (js-emit! "op" "<=" start) (advance! 2) true))
-              (do (js-emit! "op" "!=" start) (advance! 2) true))
+            ((at? ">=") (do (js-emit! "op" ">=" start) (advance! 2) true))
-            ((at? "<=")
+            ((at? "&&") (do (js-emit! "op" "&&" start) (advance! 2) true))
-              (do (js-emit! "op" "<=" start) (advance! 2) true))
+            ((at? "||") (do (js-emit! "op" "||" start) (advance! 2) true))
-            ((at? ">=")
+            ((at? "??") (do (js-emit! "op" "??" start) (advance! 2) true))
-              (do (js-emit! "op" ">=" start) (advance! 2) true))
+            ((at? "=>") (do (js-emit! "op" "=>" start) (advance! 2) true))
-            ((at? "&&")
+            ((at? "**") (do (js-emit! "op" "**" start) (advance! 2) true))
-              (do (js-emit! "op" "&&" start) (advance! 2) true))
+            ((at? "<<") (do (js-emit! "op" "<<" start) (advance! 2) true))
-            ((at? "||")
+            ((at? ">>") (do (js-emit! "op" ">>" start) (advance! 2) true))
-              (do (js-emit! "op" "||" start) (advance! 2) true))
+            ((at? "++") (do (js-emit! "op" "++" start) (advance! 2) true))
-            ((at? "??")
+            ((at? "--") (do (js-emit! "op" "--" start) (advance! 2) true))
-              (do (js-emit! "op" "??" start) (advance! 2) true))
+            ((at? "+=") (do (js-emit! "op" "+=" start) (advance! 2) true))
-            ((at? "=>")
+            ((at? "-=") (do (js-emit! "op" "-=" start) (advance! 2) true))
-              (do (js-emit! "op" "=>" start) (advance! 2) true))
+            ((at? "*=") (do (js-emit! "op" "*=" start) (advance! 2) true))
-            ((at? "**")
+            ((at? "/=") (do (js-emit! "op" "/=" start) (advance! 2) true))
-              (do (js-emit! "op" "**" start) (advance! 2) true))
+            ((at? "%=") (do (js-emit! "op" "%=" start) (advance! 2) true))
-            ((at? "<<")
+            ((at? "&=") (do (js-emit! "op" "&=" start) (advance! 2) true))
-              (do (js-emit! "op" "<<" start) (advance! 2) true))
+            ((at? "|=") (do (js-emit! "op" "|=" start) (advance! 2) true))
-            ((at? ">>")
+            ((at? "^=") (do (js-emit! "op" "^=" start) (advance! 2) true))
-              (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 "(")
+            ((= ch "(") (do (js-emit! "punct" "(" start) (advance! 1)))
-              (do (js-emit! "punct" "(" start) (advance! 1)))
+            ((= ch ")") (do (js-emit! "punct" ")" start) (advance! 1)))
-            ((= ch ")")
+            ((= ch "[") (do (js-emit! "punct" "[" start) (advance! 1)))
-              (do (js-emit! "punct" ")" start) (advance! 1)))
+            ((= ch "]") (do (js-emit! "punct" "]" start) (advance! 1)))
-            ((= ch "[")
+            ((= ch "{") (do (js-emit! "punct" "{" start) (advance! 1)))
-              (do (js-emit! "punct" "[" start) (advance! 1)))
+            ((= ch "}") (do (js-emit! "punct" "}" start) (advance! 1)))
-            ((= ch "]")
+            ((= ch ",") (do (js-emit! "punct" "," start) (advance! 1)))
-              (do (js-emit! "punct" "]" start) (advance! 1)))
+            ((= ch ";") (do (js-emit! "punct" ";" start) (advance! 1)))
-            ((= ch "{")
+            ((= ch ":") (do (js-emit! "punct" ":" start) (advance! 1)))
-              (do (js-emit! "punct" "{" start) (advance! 1)))
+            ((= ch ".") (do (js-emit! "punct" "." start) (advance! 1)))
-            ((= ch "}")
+            ((= ch "?") (do (js-emit! "op" "?" start) (advance! 1)))
-              (do (js-emit! "punct" "}" start) (advance! 1)))
+            ((= ch "+") (do (js-emit! "op" "+" start) (advance! 1)))
-            ((= ch ",")
+            ((= ch "-") (do (js-emit! "op" "-" start) (advance! 1)))
-              (do (js-emit! "punct" "," start) (advance! 1)))
+            ((= ch "*") (do (js-emit! "op" "*" start) (advance! 1)))
-            ((= ch ";")
+            ((= ch "/") (do (js-emit! "op" "/" start) (advance! 1)))
-              (do (js-emit! "punct" ";" start) (advance! 1)))
+            ((= ch "%") (do (js-emit! "op" "%" start) (advance! 1)))
-            ((= ch ":")
+            ((= ch "=") (do (js-emit! "op" "=" start) (advance! 1)))
-              (do (js-emit! "punct" ":" start) (advance! 1)))
+            ((= ch "<") (do (js-emit! "op" "<" start) (advance! 1)))
-            ((= ch ".")
+            ((= ch ">") (do (js-emit! "op" ">" start) (advance! 1)))
-              (do (js-emit! "punct" "." start) (advance! 1)))
+            ((= ch "!") (do (js-emit! "op" "!" start) (advance! 1)))
-            ((= ch "?")
+            ((= ch "&") (do (js-emit! "op" "&" start) (advance! 1)))
-              (do (js-emit! "op" "?" start) (advance! 1)))
+            ((= ch "|") (do (js-emit! "op" "|" start) (advance! 1)))
-            ((= ch "+")
+            ((= ch "^") (do (js-emit! "op" "^" start) (advance! 1)))
-              (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 "\\")
-              (error "Unexpected char '\\' in source"))
             (else (advance! 1)))))
       (define
         scan!
         (fn
           ()
           (do
-            (set! nl-before false)
             (skip-ws!)
             (when
               (< pos src-len)

lib/js/parser.sx

@@ -153,32 +153,6 @@
           (do (jp-advance! st) (list (quote js-ident) "this")))
         ((and (= (get t :type) "keyword") (= (get t :value) "new"))
           (do (jp-advance! st) (jp-parse-new-expr st)))
-        ((and (= (get t :type) "keyword") (= (get t :value) "function"))
-          (do
-            (jp-advance! st)
-            (let
-              ((nm
-                 (if
-                   (= (get (jp-peek st) :type) "ident")
-                   (let ((n (get (jp-peek st) :value))) (do (jp-advance! st) n))
-                   nil)))
-              (let
-                ((params (jp-parse-param-list st)))
-                (let
-                  ((body (jp-parse-fn-body st)))
-                  (list (quote js-funcexpr) nm params body))))))
-        ((and (= (get t :type) "keyword") (= (get t :value) "true"))
-          (do (jp-advance! st) (list (quote js-bool) true)))
-        ((and (= (get t :type) "keyword") (= (get t :value) "false"))
-          (do (jp-advance! st) (list (quote js-bool) false)))
-        ((and (= (get t :type) "keyword") (= (get t :value) "null"))
-          (do (jp-advance! st) (list (quote js-null))))
-        ((and (= (get t :type) "keyword") (= (get t :value) "undefined"))
-          (do (jp-advance! st) (list (quote js-undef))))
-        ((= (get t :type) "number")
-          (do (jp-advance! st) (list (quote js-num) (get t :value))))
-        ((= (get t :type) "string")
-          (do (jp-advance! st) (list (quote js-str) (get t :value))))
         ((and (= (get t :type) "punct") (= (get t :value) "("))
           (jp-parse-paren-or-arrow st))
         (else
@@ -237,7 +211,7 @@
               (let
                 ((params (jp-parse-param-list st)))
                 (let
-                  ((body (jp-parse-fn-body st)))
+                  ((body (jp-parse-block st)))
                   (list (quote js-funcexpr-async) nm params body))))))
         ((= (get t :type) "ident")
           (do
@@ -389,7 +363,7 @@
               (let
                 ((params (jp-parse-param-list st)))
                 (let
-                  ((body (jp-parse-fn-body st)))
+                  ((body (jp-parse-block st)))
                   (list (quote js-funcexpr) nm params body))))))
         ((= (get t :type) "ident")
           (do
@@ -444,51 +418,16 @@
               (dict-set! st :idx saved)
               (jp-advance! st)
               (let
-                ((e (jp-parse-comma-seq st)))
+                ((e (jp-parse-assignment st)))
                 (jp-expect! st "punct" ")")
-                (jp-paren-wrap e))))
+                e)))
           (do
             (dict-set! st :idx saved)
             (jp-advance! st)
             (let
-              ((e (jp-parse-comma-seq st)))
+              ((e (jp-parse-assignment st)))
               (jp-expect! st "punct" ")")
-              (jp-paren-wrap e))))))))
+              e)))))))
-
-(define
-  jp-paren-wrap
-  (fn
-    (e)
-    (cond
-      ((and (list? e) (= (first e) (quote js-unop)))
-        (list (quote js-paren) e))
-      (else e))))
-
-(define
-  jp-parse-comma-seq
-  (fn
-    (st)
-    (let
-      ((first-expr (jp-parse-assignment st)))
-      (if
-        (jp-at? st "punct" ",")
-        (jp-parse-comma-seq-rest st (list first-expr))
-        first-expr))))
-
-(define
-  jp-parse-comma-seq-rest
-  (fn
-    (st acc)
-    (do
-      (jp-advance! st)
-      (let
-        ((next-expr (jp-parse-assignment st)))
-        (let
-          ((acc2 (append acc (list next-expr))))
-          (if
-            (jp-at? st "punct" ",")
-            (jp-parse-comma-seq-rest st acc2)
-            (cons (quote js-comma) (list acc2))))))))
 
 (define
   jp-collect-params
@@ -546,11 +485,6 @@
     (st elems)
     (cond
       ((jp-at? st "punct" "]") nil)
-      ((jp-at? st "punct" ",")
-        (begin
-          (append! elems (list (quote js-undef)))
-          (jp-advance! st)
-          (jp-array-loop st elems)))
       (else
         (begin
           (cond
@@ -624,20 +558,6 @@
             (jp-advance! st)
             (jp-expect! st "punct" ":")
             (append! kvs {:value (jp-parse-assignment st) :key (get t :value)})))
-        ((and (= (get t :type) "punct") (= (get t :value) "["))
-          (do
-            (jp-advance! st)
-            (let
-              ((key-expr (jp-parse-assignment st)))
-              (jp-expect! st "punct" "]")
-              (jp-expect! st "punct" ":")
-              (append!
-                kvs
-                {:value (jp-parse-assignment st) :computed-key key-expr :key ""}))))
-        ((and (= (get t :type) "punct") (= (get t :value) "..."))
-          (do
-            (jp-advance! st)
-            (append! kvs {:spread (jp-parse-assignment st)})))
         (else (error (str "Unexpected in object: " (get t :type))))))))
 
 (define
@@ -709,7 +629,7 @@
                       st
                       (list (quote js-optchain-member) left (get t :value))))
                   (error "expected ident, [ or ( after ?.")))))))
-      ((and (or (jp-at? st "op" "++") (jp-at? st "op" "--")) (not (jp-token-nl? st)))
+      ((or (jp-at? st "op" "++") (jp-at? st "op" "--"))
         (let
           ((op (get (jp-peek st) :value)))
           (jp-advance! st)
@@ -762,12 +682,6 @@
             (cond
               ((< prec 0) left)
               ((< prec min-prec) left)
-              ((and (= op "**") (list? left) (= (first left) (quote js-unop)))
-                (error
-                  (str
-                    "SyntaxError: Unary operator '"
-                    (nth left 1)
-                    "' used immediately before exponentiation expression")))
               (else
                 (do
                   (jp-advance! st)
@@ -921,12 +835,6 @@
   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
@@ -1144,63 +1052,15 @@
         ((c (jp-parse-assignment st)))
         (do
           (jp-expect! st "punct" ")")
-          (jp-disallow-decl-stmt! st "if")
           (let
             ((t (jp-parse-stmt st)))
             (if
               (jp-at? st "keyword" "else")
               (do
                 (jp-advance! st)
-                (jp-disallow-decl-stmt! st "else")
                 (list (quote js-if) c t (jp-parse-stmt st)))
               (list (quote js-if) c t nil))))))))
 
-(define
-  jp-disallow-decl-stmt!
-  (fn
-    (st context)
-    (let
-      ((t (jp-peek st)))
-      (cond
-        ((and (= (get t :type) "keyword")
-              (or (= (get t :value) "let")
-                  (= (get t :value) "const")
-                  (= (get t :value) "function")
-                  (= (get t :value) "class")))
-          (cond
-            ((and (= (get t :value) "let")
-                  (or (= (get (jp-peek-at st 1) :type) "ident")
-                      (and (= (get (jp-peek-at st 1) :type) "punct")
-                           (or (= (get (jp-peek-at st 1) :value) "[")
-                               (= (get (jp-peek-at st 1) :value) "{")))))
-              (error
-                (str
-                  "SyntaxError: Lexical declaration cannot appear in single-statement context: "
-                  context)))
-            ((or (= (get t :value) "const")
-                 (= (get t :value) "function")
-                 (= (get t :value) "class"))
-              (error
-                (str
-                  "SyntaxError: "
-                  (get t :value)
-                  " declaration cannot appear in single-statement context: "
-                  context)))
-            (else nil)))
-        (else nil)))))
-
-(define
-  jp-bump!
-  (fn
-    (st key)
-    (dict-set! st key (+ (get st key) 1))))
-
-(define
-  jp-decr!
-  (fn
-    (st key)
-    (dict-set! st key (- (get st key) 1))))
-
 (define
   jp-parse-while-stmt
   (fn
@@ -1212,11 +1072,7 @@
         ((c (jp-parse-assignment st)))
         (do
           (jp-expect! st "punct" ")")
-          (jp-disallow-decl-stmt! st "while")
+          (let ((body (jp-parse-stmt st))) (list (quote js-while) c body)))))))
-          (jp-bump! st :loop-depth)
-          (let ((body (jp-parse-stmt st)))
-            (jp-decr! st :loop-depth)
-            (list (quote js-while) c body)))))))
 
 (define
   jp-parse-do-while-stmt
@@ -1224,11 +1080,8 @@
     (st)
     (do
       (jp-advance! st)
-      (jp-disallow-decl-stmt! st "do")
-      (jp-bump! st :loop-depth)
       (let
         ((body (jp-parse-stmt st)))
-        (jp-decr! st :loop-depth)
         (do
           (if
             (jp-at? st "keyword" "while")
@@ -1273,11 +1126,8 @@
                   (let
                     ((iter (jp-parse-assignment st)))
                     (jp-expect! st "punct" ")")
-                    (jp-disallow-decl-stmt! st "for-of/in")
-                    (jp-bump! st :loop-depth)
                     (let
                       ((body (jp-parse-stmt st)))
-                      (jp-decr! st :loop-depth)
                       (list (quote js-for-of-in) iter-kind ident iter body)))))))
           (else
             (let
@@ -1288,11 +1138,8 @@
                 (let
                   ((step (if (jp-at? st "punct" ")") nil (jp-parse-assignment st))))
                   (jp-expect! st "punct" ")")
-                  (jp-disallow-decl-stmt! st "for")
-                  (jp-bump! st :loop-depth)
                   (let
                     ((body (jp-parse-stmt st)))
-                    (jp-decr! st :loop-depth)
                     (list (quote js-for) init cond-ast step body)))))))))))
 
 (define
@@ -1315,14 +1162,10 @@
     (st)
     (do
       (jp-advance! st)
-      (when
-        (= (get st :fn-depth) 0)
-        (error "SyntaxError: Illegal return statement"))
       (if
         (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
@@ -1345,7 +1188,7 @@
           (let
             ((params (jp-parse-param-list st)))
             (let
-              ((body (jp-parse-fn-body st)))
+              ((body (jp-parse-block st)))
               (list (quote js-funcdecl) nm params body))))))))
 
 (define
@@ -1364,7 +1207,7 @@
           (let
             ((params (jp-parse-param-list st)))
             (let
-              ((body (jp-parse-fn-body st)))
+              ((body (jp-parse-block st)))
               (list (quote js-funcdecl-async) nm params body))))))))
 
 (define
@@ -1413,7 +1256,7 @@
           (let
             ((params (jp-parse-param-list st)))
             (let
-              ((body (jp-parse-fn-body st)))
+              ((body (jp-parse-block st)))
               (list
                 (quote js-method)
                 (if static? "static" "instance")
@@ -1441,11 +1284,9 @@
       ((disc (jp-parse-assignment st)))
       (jp-expect! st "punct" ")")
       (jp-expect! st "punct" "{")
-      (jp-bump! st :switch-depth)
       (let
         ((cases (list)))
         (jp-parse-switch-cases st cases)
-        (jp-decr! st :switch-depth)
         (jp-expect! st "punct" "}")
         (list (quote js-switch) disc cases)))))
 
@@ -1521,40 +1362,9 @@
       ((jp-at? st "keyword" "for") (jp-parse-for-stmt st))
       ((jp-at? st "keyword" "return") (jp-parse-return-stmt st))
       ((jp-at? st "keyword" "break")
-        (do
+        (do (jp-advance! st) (jp-eat-semi st) (list (quote js-break))))
-          (jp-advance! st)
-          (cond
-            ((= (get (jp-peek st) :type) "ident")
-              (do (jp-advance! st) (jp-eat-semi st) (list (quote js-break))))
-            (else
-              (do
-                (when
-                  (and (= (get st :loop-depth) 0) (= (get st :switch-depth) 0))
-                  (error "SyntaxError: Illegal break statement"))
-                (jp-eat-semi st)
-                (list (quote js-break)))))))
       ((jp-at? st "keyword" "continue")
-        (do
+        (do (jp-advance! st) (jp-eat-semi st) (list (quote js-continue))))
-          (jp-advance! st)
-          (cond
-            ((= (get (jp-peek st) :type) "ident")
-              (do (jp-advance! st) (jp-eat-semi st) (list (quote js-continue))))
-            (else
-              (do
-                (when
-                  (= (get st :loop-depth) 0)
-                  (error "SyntaxError: Illegal continue statement"))
-                (jp-eat-semi st)
-                (list (quote js-continue)))))))
-      ((and
-         (= (get (jp-peek st) :type) "ident")
-         (= (get (jp-peek-at st 1) :type) "punct")
-         (= (get (jp-peek-at st 1) :value) ":"))
-        (do
-          (jp-advance! st)
-          (jp-advance! st)
-          (jp-disallow-decl-stmt! st "label")
-          (jp-parse-stmt st)))
       ((jp-at? st "keyword" "class") (jp-parse-class-decl st))
       ((jp-at? st "keyword" "throw") (jp-parse-throw-stmt st))
       ((jp-at? st "keyword" "try") (jp-parse-try-stmt st))
@@ -1564,7 +1374,7 @@
       ((jp-at? st "keyword" "switch") (jp-parse-switch-stmt st))
       (else
         (let
-          ((e (jp-parse-comma-seq st)))
+          ((e (jp-parse-assignment st)))
           (do (jp-eat-semi st) (list (quote js-exprstmt) e)))))))
 
 (define
@@ -1590,33 +1400,10 @@
   jp-parse-arrow-body
   (fn
     (st)
-    (jp-bump! st :fn-depth)
+    (if
-    (let
+      (jp-at? st "punct" "{")
-      ((saved-loop (get st :loop-depth)) (saved-switch (get st :switch-depth)))
+      (jp-parse-block st)
-      (dict-set! st :loop-depth 0)
+      (jp-parse-assignment st))))
-      (dict-set! st :switch-depth 0)
-      (let
-        ((body (if (jp-at? st "punct" "{") (jp-parse-block st) (jp-parse-assignment st))))
-        (jp-decr! st :fn-depth)
-        (dict-set! st :loop-depth saved-loop)
-        (dict-set! st :switch-depth saved-switch)
-        body))))
-
-(define
-  jp-parse-fn-body
-  (fn
-    (st)
-    (jp-bump! st :fn-depth)
-    (let
-      ((saved-loop (get st :loop-depth)) (saved-switch (get st :switch-depth)))
-      (dict-set! st :loop-depth 0)
-      (dict-set! st :switch-depth 0)
-      (let
-        ((body (jp-parse-block st)))
-        (jp-decr! st :fn-depth)
-        (dict-set! st :loop-depth saved-loop)
-        (dict-set! st :switch-depth saved-switch)
-        body))))
 
 (define
   js-parse
@@ -1627,7 +1414,7 @@
         (= (len tokens) 0)
         (and (= (len tokens) 1) (= (get (nth tokens 0) :type) "eof")))
       (list (quote js-program) (list))
-      (let ((st {:idx 0 :tokens tokens :arrow-candidate true :loop-depth 0 :switch-depth 0 :fn-depth 0})) (jp-parse-program st)))))
+      (let ((st {:idx 0 :tokens tokens :arrow-candidate true})) (jp-parse-program st)))))
 
 (define
   js-parse-expr
@@ -1640,4 +1427,4 @@
           (= (len tokens) 0)
           (and (= (len tokens) 1) (= (get (nth tokens 0) :type) "eof")))
         (list)
-        (let ((st {:idx 0 :tokens tokens :arrow-candidate true :loop-depth 0 :switch-depth 0 :fn-depth 0})) (jp-parse-assignment st))))))
+        (let ((st {:idx 0 :tokens tokens :arrow-candidate true})) (jp-parse-assignment st))))))

lib/js/test.sh

@@ -1323,25 +1323,6 @@ 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
 
 
@@ -2061,17 +2042,6 @@ 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 = 15.0
+DEFAULT_PER_TEST_TIMEOUT_S = 5.0
 DEFAULT_BATCH_TIMEOUT_S = 120
 
 # Cache dir for precomputed SX source of harness JS (one file per Python run).
@@ -134,9 +134,6 @@ var verifyProperty = function (obj, name, desc, opts) {
   }
 };
 var verifyPrimordialProperty = verifyProperty;
-var verifyEqualTo = function (obj, name, value) {
-  assert.sameValue(obj[name], value, name + " equals");
-};
 var verifyNotEnumerable = function (o, n, v, w, x) { };
 var verifyNotWritable = function (o, n, v, w, x) { };
 var verifyNotConfigurable = function (o, n, v, w, x) { };
@@ -149,50 +146,6 @@ var isConstructor = function (f) {
   // Best-effort: built-in functions and arrows aren't; declared `function` decls are.
   return false;
 };
-// $DONE / asyncTest — async-flag tests call $DONE(err) to signal completion.
-// Since we drain microtasks synchronously, $DONE is just a final-assertion sink.
-var $DONE = function (err) {
-  if (err) { throw new Test262Error((err && err.message) || err); }
-};
-var asyncTest = function (testFunc) {
-  Promise.resolve(testFunc()).then(function () { $DONE(); }, function (e) { $DONE(e); });
-};
-// promiseHelper.js include — used by Promise.all/race tests for ordering checks.
-var checkSequence = function (arr, message) {
-  for (var i = 0; i < arr.length; i = i + 1) {
-    if (arr[i] !== (i + 1)) {
-      throw new Test262Error((message || "Sequence") + " expected " + (i+1) + " at index " + i + " but got " + arr[i]);
-    }
-  }
-  return true;
-};
-var checkSettledPromises = function (settleds, expected, message) {
-  var msg = message ? message + " " : "";
-  if (settleds.length !== expected.length) {
-    throw new Test262Error(msg + "lengths differ: " + settleds.length + " vs " + expected.length);
-  }
-  for (var i = 0; i < settleds.length; i = i + 1) {
-    if (settleds[i].status !== expected[i].status) {
-      throw new Test262Error(msg + "status[" + i + "]: " + settleds[i].status + " vs " + expected[i].status);
-    }
-    if (expected[i].status === "fulfilled" && settleds[i].value !== expected[i].value) {
-      throw new Test262Error(msg + "value[" + i + "]: " + settleds[i].value + " vs " + expected[i].value);
-    }
-    if (expected[i].status === "rejected" && settleds[i].reason !== expected[i].reason) {
-      throw new Test262Error(msg + "reason[" + i + "]: " + settleds[i].reason + " vs " + expected[i].reason);
-    }
-  }
-};
-// decimalToHexString.js include — used by URI/escape tests.
-var decimalToHexString = function (n) {
-  var hex = "0123456789ABCDEF";
-  if (n < 0) { n = n + 65536; }
-  return hex[(n >> 12) & 15] + hex[(n >> 8) & 15] + hex[(n >> 4) & 15] + hex[n & 15];
-};
-var decimalToPercentHexString = function (n) {
-  var hex = "0123456789ABCDEF";
-  return "%" + hex[(n >> 4) & 15] + hex[n & 15];
-};
 // Trivial helper for tests that use Array.isArray-like functionality
 // (many tests reach for it via compareArray)
 """
@@ -405,8 +358,6 @@ def classify_negative_result(fm: Frontmatter, kind: str, payload: str):
             or ("expected" in low and "got" in low)
             or "js-transpile-unop" in low
             or "js-transpile-binop" in low
-            or "js-transpile-assign" in low
-            or "js-transpile" in low
             or "js-compound-update" in low
             or "parse" in low
         ):
@@ -1060,45 +1011,11 @@ def _worker_run(args):
 # ---------------------------------------------------------------------------
 
 
-_HARNESS_INCLUDE_CACHE: dict = {}
-
-# Only inline these small harness files per-test. Large ones like propertyHelper.js
-# multiply js-eval/JIT cost by ~5-10x and push tests over the per-test timeout.
-_INLINE_INCLUDES = {"nans.js", "sta.js", "byteConversionValues.js", "compareArray.js"}
-
-
-def _load_harness_include(name: str) -> str:
-    """Read an upstream harness include file (e.g. nans.js).
-    Returns empty string if the file isn't present.
-    """
-    if name in _HARNESS_INCLUDE_CACHE:
-        return _HARNESS_INCLUDE_CACHE[name]
-    path = HARNESS_DIR / name
-    try:
-        src = path.read_text()
-    except OSError:
-        src = ""
-    _HARNESS_INCLUDE_CACHE[name] = src
-    return src
-
-
 def assemble_source(t):
     """Return JS source to feed to js-eval. Harness is preloaded, so we only
-    append the test source (plus a small allowlist of per-test includes).
+    append the test source (plus negative-test prep if needed).
     """
-    if not getattr(t.fm, "includes", None):
+    return t.src
-        return t.src
-    parts = []
-    for inc in t.fm.includes:
-        if inc not in _INLINE_INCLUDES:
-            continue
-        chunk = _load_harness_include(inc)
-        if chunk:
-            parts.append(chunk)
-    if not parts:
-        return t.src
-    parts.append(t.src)
-    return "\n".join(parts)
 
 
 def aggregate(results):
@@ -1276,7 +1193,7 @@ def main(argv):
     shards = [[] for _ in range(n_workers)]
     for i, t in enumerate(tests):
         shards[i % n_workers].append(
-            (t.rel, t.category, assemble_source(t), t.fm.negative_phase, t.fm.negative_type)
+            (t.rel, t.category, t.src, t.fm.negative_phase, t.fm.negative_type)
         )
 
     t_run_start = time.monotonic()

lib/js/test262-scoreboard.json

@@ -1,53 +1,137 @@
 {
   "totals": {
-    "pass": 4,
+    "pass": 162,
-    "fail": 10,
+    "fail": 128,
-    "skip": 16,
+    "skip": 1597,
-    "timeout": 0,
+    "timeout": 10,
-    "total": 30,
+    "total": 1897,
-    "runnable": 14,
+    "runnable": 300,
-    "pass_rate": 28.6
+    "pass_rate": 54.0
   },
   "categories": [
     {
-      "category": "built-ins/Function",
+      "category": "built-ins/Math",
-      "total": 30,
+      "total": 327,
-      "pass": 4,
+      "pass": 43,
-      "fail": 10,
+      "fail": 56,
-      "skip": 16,
+      "skip": 227,
-      "timeout": 0,
+      "timeout": 1,
-      "pass_rate": 28.6,
+      "pass_rate": 43.0,
       "top_failures": [
         [
-          "SyntaxError (parse/unsupported syntax)",
+          "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,
+      "skip": 1123,
+      "timeout": 5,
+      "pass_rate": 42.0,
+      "top_failures": [
+        [
+          "Test262Error (assertion failed)",
+          44
+        ],
+        [
+          "Timeout",
+          5
         ],
         [
           "ReferenceError (undefined symbol)",
-          3
+          2
         ],
         [
-          "TypeError (other)",
+          "Unhandled: Not callable: {:__proto__ {:toLowerCase <lambda(&rest, args)",
-          3
+          2
+        ],
+        [
+          "Unhandled: Not callable: \\\\\\",
+          2
         ]
       ]
+    },
+    {
+      "category": "built-ins/StringIteratorPrototype",
+      "total": 7,
+      "pass": 0,
+      "fail": 0,
+      "skip": 7,
+      "timeout": 0,
+      "pass_rate": 0.0,
+      "top_failures": []
     }
   ],
   "top_failure_modes": [
     [
-      "SyntaxError (parse/unsupported syntax)",
+      "Test262Error (assertion failed)",
-      4
+      83
+    ],
+    [
+      "TypeError: not a function",
+      36
+    ],
+    [
+      "Timeout",
+      10
     ],
     [
       "ReferenceError (undefined symbol)",
-      3
+      2
     ],
     [
-      "TypeError (other)",
+      "Unhandled: Not callable: {:__proto__ {:toLowerCase <lambda(&rest, args)",
-      3
+      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
     ]
   ],
   "pinned_commit": "d5e73fc8d2c663554fb72e2380a8c2bc1a318a33",
-  "elapsed_seconds": 11.2,
+  "elapsed_seconds": 274.5,
   "workers": 1
 }

lib/js/test262-scoreboard.md

@@ -1,26 +1,47 @@
 # test262 scoreboard
 
 Pinned commit: `d5e73fc8d2c663554fb72e2380a8c2bc1a318a33`
-Wall time: 11.2s
+Wall time: 274.5s
 
-**Total:** 4/14 runnable passed (28.6%). Raw: pass=4 fail=10 skip=16 timeout=0 total=30.
+**Total:** 162/300 runnable passed (54.0%). Raw: pass=162 fail=128 skip=1597 timeout=10 total=1897.
 
 ## Top failure modes
 
-- **4x** SyntaxError (parse/unsupported syntax)
+- **83x** Test262Error (assertion failed)
-- **3x** ReferenceError (undefined symbol)
+- **36x** TypeError: not a function
-- **3x** TypeError (other)
+- **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: >>>\
 
 ## Categories (worst pass-rate first, min 10 runnable)
 
 | Category | Pass | Fail | Skip | Timeout | Total | Pass % |
 |---|---:|---:|---:|---:|---:|---:|
-| built-ins/Function | 4 | 10 | 16 | 0 | 30 | 28.6% |
+| 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% |
 
 ## Per-category top failures (min 10 runnable, worst first)
 
-### built-ins/Function  (4/14 — 28.6%)
+### built-ins/String  (42/100 — 42.0%)
 
-- **4x** SyntaxError (parse/unsupported syntax)
+- **44x** Test262Error (assertion failed)
-- **3x** ReferenceError (undefined symbol)
+- **5x** Timeout
-- **3x** TypeError (other)
+- **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

lib/js/transpile.sx

@@ -98,7 +98,6 @@
             (list (js-sym "js-regex-new") (nth ast 1) (nth ast 2)))
           ((js-tag? ast "js-null") nil)
           ((js-tag? ast "js-undef") (list (js-sym "quote") :js-undefined))
-          ((js-tag? ast "js-paren") (js-transpile (nth ast 1)))
           ((js-tag? ast "js-ident") (js-transpile-ident (nth ast 1)))
           ((js-tag? ast "js-unop")
             (js-transpile-unop (nth ast 1) (nth ast 2)))
@@ -117,8 +116,7 @@
           ((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-tag? ast "js-block") (js-transpile-stmts (nth ast 1)))
-            (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")
@@ -166,8 +164,6 @@
             (js-transpile-new (nth ast 1) (nth ast 2)))
           ((js-tag? ast "js-class")
             (js-transpile-class (nth ast 1) (nth ast 2) (nth ast 3)))
-          ((js-tag? ast "js-comma")
-            (cons (js-sym "begin") (map js-transpile (nth ast 1))))
           ((js-tag? ast "js-throw") (js-transpile-throw (nth ast 1)))
           ((js-tag? ast "js-try")
             (js-transpile-try (nth ast 1) (nth ast 2) (nth ast 3)))
@@ -225,23 +221,7 @@
               (js-sym "js-delete-prop")
               (js-transpile (nth arg 1))
               (js-transpile (nth arg 2))))
-          ((js-tag? arg "js-ident") false)
-          ((js-tag? arg "js-paren") (js-transpile-unop op (nth arg 1)))
           (else true)))
-      ((and (= op "typeof") (js-tag? arg "js-ident"))
-        (let
-          ((name (nth arg 1)))
-          (list
-            (js-sym "if")
-            (list
-              (js-sym "or")
-              (list
-                (js-sym "env-has?")
-                (list (js-sym "current-env"))
-                name)
-              (list (js-sym "dict-has?") (js-sym "js-global") name))
-            (list (js-sym "js-typeof") (js-transpile arg))
-            "undefined")))
       (else
         (let
           ((a (js-transpile arg)))
@@ -251,8 +231,7 @@
             ((= op "!") (list (js-sym "js-not") a))
             ((= op "~") (list (js-sym "js-bitnot") a))
             ((= op "typeof") (list (js-sym "js-typeof") a))
-            ((= op "void")
+            ((= op "void") (list (js-sym "quote") :js-undefined))
-              (list (js-sym "begin") a (list (js-sym "quote") :js-undefined)))
             (else (error (str "js-transpile-unop: unsupported op: " op)))))))))
 
 ;; ── Array literal ─────────────────────────────────────────────────
@@ -316,21 +295,6 @@
               (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)))
-      ((= op "<<")
-        (list (js-sym "js-shl") (js-transpile l) (js-transpile r)))
-      ((= op ">>")
-        (list (js-sym "js-shr") (js-transpile l) (js-transpile r)))
-      ((= op "&")
-        (list (js-sym "js-bitand") (js-transpile l) (js-transpile r)))
-      ((= op "|")
-        (list (js-sym "js-bitor") (js-transpile l) (js-transpile r)))
-      ((= op "^")
-        (list (js-sym "js-bitxor") (js-transpile l) (js-transpile r)))
       (else (error (str "js-transpile-binop: unsupported op: " op))))))
 
 ;; ── Object literal ────────────────────────────────────────────────
@@ -409,19 +373,7 @@
     (list
       (js-sym "js-new-call")
       (js-transpile callee)
-      (cond
+      (cons (js-sym "list") (map js-transpile args)))))
-        ((js-has-spread? args)
-          (cons
-            (js-sym "js-array-spread-build")
-            (map
-              (fn
-                (e)
-                (if
-                  (js-tag? e "js-spread")
-                  (list (js-sym "list") "js-spread" (js-transpile (nth e 1)))
-                  (list (js-sym "list") "js-value" (js-transpile e))))
-              args)))
-        (else (cons (js-sym "js-args") (map js-transpile args)))))))
 
 (define
   js-transpile-array
@@ -439,7 +391,7 @@
               (list (js-sym "list") "js-spread" (js-transpile (nth e 1)))
               (list (js-sym "list") "js-value" (js-transpile e))))
           elts))
-      (cons (js-sym "js-make-list") (map js-transpile elts)))))
+      (cons (js-sym "list") (map js-transpile elts)))))
 
 (define
   js-has-spread?
@@ -469,7 +421,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 "js-args") (map js-transpile args)))))
+      (cons (js-sym "list") (map js-transpile args)))))
 
 ;; Transpile a JS expression string to SX source text (for inspection
 ;; in tests). Useful for asserting the exact emitted tree.
@@ -479,28 +431,18 @@
     (entries)
     (list
       (js-sym "let")
-      (list (list (js-sym "_obj") (list (js-sym "js-make-obj"))))
+      (list (list (js-sym "_obj") (list (js-sym "dict"))))
       (cons
         (js-sym "begin")
         (append
           (map
             (fn
               (entry)
-              (cond
+              (list
-                ((contains? (keys entry) :spread)
+                (js-sym "dict-set!")
-                  (list
+                (js-sym "_obj")
-                    (js-sym "js-obj-spread!")
+                (get entry :key)
-                    (js-sym "_obj")
+                (js-transpile (get entry :value))))
-                    (js-transpile (get entry :spread))))
-                (else
-                  (list
-                    (js-sym "js-obj-set!")
-                    (js-sym "_obj")
-                    (if
-                      (contains? (keys entry) :computed-key)
-                      (list (js-sym "js-to-string") (js-transpile (get entry :computed-key)))
-                      (get entry :key))
-                    (js-transpile (get entry :value))))))
             entries)
           (list (js-sym "_obj")))))))
 
@@ -544,95 +486,6 @@
                 (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
@@ -724,12 +577,6 @@
             (list (js-sym "js-undefined?") lhs-expr))
           rhs-expr
           lhs-expr))
-      ((= op "<<=") (list (js-sym "js-shl") lhs-expr rhs-expr))
-      ((= op ">>=") (list (js-sym "js-shr") lhs-expr rhs-expr))
-      ((= op ">>>=") (list (js-sym "js-unsigned-rshift") lhs-expr rhs-expr))
-      ((= op "&=") (list (js-sym "js-bitand") lhs-expr rhs-expr))
-      ((= op "|=") (list (js-sym "js-bitor") lhs-expr rhs-expr))
-      ((= op "^=") (list (js-sym "js-bitxor") lhs-expr rhs-expr))
       (else (error (str "js-compound-update: unsupported op: " op))))))
 
 (define
@@ -959,7 +806,7 @@
                 (if
                   (= iter-kind "of")
                   (list (js-sym "js-iterable-to-list") iter-sx)
-                  (list (js-sym "js-for-in-keys") iter-sx))))
+                  (list (js-sym "js-object-keys") iter-sx))))
             (list
               (js-sym "for-each")
               (list
@@ -988,7 +835,7 @@
   (fn
     (params)
     (cond
-      ((empty? params) (list (js-sym "&rest") (js-sym "__extra_args__")))
+      ((empty? params) (list))
       ((and (list? (first params)) (js-tag? (first params) "js-rest"))
         (list (js-sym "&rest") (js-sym (nth (first params) 1))))
       (else
@@ -996,27 +843,6 @@
           (js-param-sym (first params))
           (js-build-param-list (rest params)))))))
 
-(define
-  js-arguments-build-form
-  (fn
-    (params)
-    (list (js-sym "js-list-copy") (js-arguments-build-form-raw params))))
-
-(define
-  js-arguments-build-form-raw
-  (fn
-    (params)
-    (cond
-      ((empty? params)
-        (js-sym "__extra_args__"))
-      ((and (list? (first params)) (js-tag? (first params) "js-rest"))
-        (js-sym (nth (first params) 1)))
-      (else
-        (list
-          (js-sym "cons")
-          (js-param-sym (first params))
-          (js-arguments-build-form-raw (rest params)))))))
-
 (define
   js-param-init-forms
   (fn
@@ -1050,7 +876,7 @@
   (fn
     (stmts)
     (let
-      ((hoisted (append (js-var-hoist-forms (js-dedup-names (js-collect-var-names stmts) (list))) (js-collect-funcdecls stmts))))
+      ((hoisted (js-collect-funcdecls stmts)))
       (let
         ((rest-stmts (js-transpile-stmt-list stmts)))
         (cons (js-sym "begin") (append hoisted rest-stmts))))))
@@ -1109,12 +935,12 @@
 
 (define
   js-transpile-var
-  (fn (kind decls) (cons (js-sym "begin") (js-vardecl-forms decls (= kind "var")))))
+  (fn (kind decls) (cons (js-sym "begin") (js-vardecl-forms decls))))
 
 (define
   js-vardecl-forms
   (fn
-    (decls is-var)
+    (decls)
     (cond
       ((empty? decls) (list))
       (else
@@ -1124,10 +950,10 @@
             ((js-tag? d "js-vardecl")
               (cons
                 (list
-                  (js-sym (if is-var "set!" "define"))
+                  (js-sym "define")
                   (js-sym (nth d 1))
                   (js-transpile (nth d 2)))
-                (js-vardecl-forms (rest decls) is-var)))
+                (js-vardecl-forms (rest decls))))
             ((js-tag? d "js-vardecl-obj")
               (let
                 ((names (nth d 1))
@@ -1138,7 +964,7 @@
                   (js-vardecl-obj-forms
                     names
                     tmp-sym
-                    (js-vardecl-forms (rest decls) is-var)))))
+                    (js-vardecl-forms (rest decls))))))
             ((js-tag? d "js-vardecl-arr")
               (let
                 ((names (nth d 1))
@@ -1150,7 +976,7 @@
                     names
                     tmp-sym
                     0
-                    (js-vardecl-forms (rest decls) is-var)))))
+                    (js-vardecl-forms (rest decls))))))
             (else (error "js-vardecl-forms: unexpected decl"))))))))
 
 (define
@@ -1450,28 +1276,7 @@
     (let
       ((body-tr (js-transpile body)))
       (let
-        ((with-catch
+        ((with-catch (cond ((= catch-part nil) body-tr) (else (let ((pname (nth catch-part 0)) (cbody (nth catch-part 1))) (list (js-sym "guard") (list (if (= pname nil) (js-sym "__exc__") (js-sym pname)) (list (js-sym "else") (js-transpile cbody))) body-tr))))))
-           (cond
-             ((= catch-part nil) body-tr)
-             (else
-               (let
-                 ((pname (nth catch-part 0))
-                   (cbody (nth catch-part 1))
-                   (raw-sym (js-sym "__raw_exc__")))
-                 (list
-                   (js-sym "guard")
-                   (list
-                     raw-sym
-                     (list
-                       (js-sym "else")
-                       (cond
-                         ((= pname nil) (js-transpile cbody))
-                         (else
-                           (list
-                             (js-sym "let")
-                             (list (list (js-sym pname) (list (js-sym "js-wrap-exn") raw-sym)))
-                             (js-transpile cbody))))))
-                   body-tr))))))
         (cond
           ((= finally-part nil) with-catch)
           (else
@@ -1492,7 +1297,7 @@
           (if
             (and (list? body) (js-tag? body "js-block"))
             (let
-              ((hoisted (append (js-var-hoist-forms (js-dedup-names (js-collect-var-names (nth body 1)) (list))) (js-collect-funcdecls (nth body 1)))))
+              ((hoisted (js-collect-funcdecls (nth body 1))))
               (append hoisted (js-transpile-stmt-list (nth body 1))))
             (list (js-transpile body)))))
       (list
@@ -1500,9 +1305,7 @@
         param-syms
         (list
           (js-sym "let")
-          (list
+          (list (list (js-sym "this") (list (js-sym "js-this"))))
-            (list (js-sym "this") (list (js-sym "js-this")))
-            (list (js-sym "arguments") (js-arguments-build-form params)))
           (list
             (js-sym "let")
             (list
@@ -1513,7 +1316,7 @@
                   (list
                     (js-sym "fn")
                     (list (js-sym "__return__"))
-                    (cons (js-sym "begin") (append (append inits body-forms) (list nil)))))))
+                    (cons (js-sym "begin") (append inits body-forms))))))
             (list
               (js-sym "if")
               (list (js-sym "=") (js-sym "__r__") nil)
@@ -1530,7 +1333,7 @@
           (if
             (and (list? body) (js-tag? body "js-block"))
             (let
-              ((hoisted (append (js-var-hoist-forms (js-dedup-names (js-collect-var-names (nth body 1)) (list))) (js-collect-funcdecls (nth body 1)))))
+              ((hoisted (js-collect-funcdecls (nth body 1))))
               (append hoisted (js-transpile-stmt-list (nth body 1))))
             (list (js-transpile body)))))
       (list
@@ -1598,7 +1401,7 @@
   (fn
     (src)
     (let
-      ((result (eval-expr (list (quote let) (list (list (js-sym "this") (list (js-sym "js-this")))) (js-transpile (js-parse (js-tokenize src)))))))
+      ((result (eval-expr (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: `loops/js`.
+- Branch: `architecture`. HEAD: `14b6586e` (HS-related, not js-on-sx).
 - `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:** `loops/js`. Commit, then push to `origin/loops/js`. Never touch `main`.
+- **Branch:** `architecture`. Commit locally. Never push. 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/forth-on-sx.md

@@ -69,36 +69,333 @@ Representation:
 - [x] Tests in `lib/forth/tests/test-phase2.sx` — 26/26 pass
 
 ### Phase 3 — control flow + first Hayes tests green
-- [ ] `IF`, `ELSE`, `THEN` — compile to SX `if`
+- [x] `IF`, `ELSE`, `THEN` — compile to SX `if`
-- [ ] `BEGIN`, `UNTIL`, `WHILE`, `REPEAT`, `AGAIN` — compile to loops
+- [x] `BEGIN`, `UNTIL`, `WHILE`, `REPEAT`, `AGAIN` — compile to loops
-- [ ] `DO`, `LOOP`, `+LOOP`, `I`, `J`, `LEAVE` — counted loops (needs a return stack)
+- [x] `DO`, `LOOP`, `+LOOP`, `I`, `J`, `LEAVE` — counted loops (needs a return stack)
-- [ ] Return stack: `>R`, `R>`, `R@`, `2>R`, `2R>`, `2R@`
+- [x] Return stack: `>R`, `R>`, `R@`, `2>R`, `2R>`, `2R@`
-- [ ] Vendor John Hayes' test suite to `lib/forth/ans-tests/`
+- [x] Vendor John Hayes' test suite to `lib/forth/ans-tests/`
-- [ ] `lib/forth/conformance.sh` + runner; `scoreboard.json` + `scoreboard.md`
+- [x] `lib/forth/conformance.sh` + runner; `scoreboard.json` + `scoreboard.md`
-- [ ] Baseline: probably 30-50% Core passing after phase 3
+- [x] Baseline: probably 30-50% Core passing after phase 3
 
 ### Phase 4 — strings + more Core
-- [ ] `S"`, `C"`, `."`, `TYPE`, `COUNT`, `CMOVE`, `FILL`, `BLANK`
+- [x] `S"`, `C"`, `."`, `TYPE`, `COUNT`, `CMOVE`, `FILL`, `BLANK`
-- [ ] `CHAR`, `[CHAR]`, `KEY`, `ACCEPT`
+- [x] `CHAR`, `[CHAR]`, `KEY`, `ACCEPT`
-- [ ] `BASE` manipulation: `DECIMAL`, `HEX`
+- [x] `BASE` manipulation: `DECIMAL`, `HEX`
-- [ ] `DEPTH`, `SP@`, `SP!`
+- [x] `DEPTH`, `SP@`, `SP!`
-- [ ] Drive Hayes Core pass-rate up
+- [x] Drive Hayes Core pass-rate up
 
 ### Phase 5 — Core Extension + optional word sets
-- [ ] Full Core + Core Extension
+- [x] Memory: `CREATE`, `HERE`, `ALLOT`, `,`, `C,`, `CELL+`, `CELLS`, `ALIGN`, `ALIGNED`, `2!`, `2@`
-- [ ] File Access word set (via SX IO)
+- [x] Unsigned compare: `U<`, `U>`
-- [ ] String word set (`SLITERAL`, `COMPARE`, `SEARCH`)
+- [x] Mixed/double-cell math: `S>D`, `M*`, `UM*`, `UM/MOD`, `FM/MOD`, `SM/REM`, `*/`, `*/MOD`
-- [ ] Target: 100% Hayes Core
+- [x] Double-cell ops: `D+`, `D-`, `D=`, `D<`, `D0=`, `2DUP`, `2DROP`, `2OVER`, `2SWAP` (already), plus `D>S`, `DABS`, `DNEGATE`
+- [x] Number formatting: `<#`, `#`, `#S`, `#>`, `HOLD`, `SIGN`, `.R`, `U.`, `U.R`
+- [x] Parsing/dictionary: `WORD`, `FIND`, `EXECUTE`, `'`, `[']`, `LITERAL`, `POSTPONE`, `>BODY` (DOES> deferred — needs runtime-rebind of last CREATE)
+- [x] Source/state: `EVALUATE`, `STATE`, `[`, `]` (`SOURCE`/`>IN` stubbed; tokenized input means the exact byte/offset semantics aren't useful here)
+- [x] Misc Core: `WITHIN`, `MAX`/`MIN` (already), `ABORT`, `ABORT"`, `EXIT`, `UNLOOP`
+- [x] File Access word set (in-memory — `read-file` is not reachable from the epoch eval env)
+- [x] String word set (`SLITERAL`, `COMPARE`, `SEARCH`)
+- [x] Target: 100% Hayes Core (97% achieved — remaining 5 errors all in `GI5`'s multi-`WHILE`-per-`BEGIN` non-standard pattern, plus one stuck `dict-set!` chunk and 14 numeric-edge fails)
 
 ### Phase 6 — speed
-- [ ] Inline primitive calls during compile (skip dict lookup)
+- [x] Inline primitive calls during compile (skip dict lookup)
-- [ ] Tail-call optimise colon-def endings
+- [x] Tail-call optimise colon-def endings
-- [ ] JIT cooperation: mark compiled colon-defs as VM-eligible
+- [x] JIT cooperation: mark compiled colon-defs as VM-eligible
 
 ## Progress log
 
 _Newest first._
 
+- **Phase 6 close — JIT cooperation hooks (Hayes unchanged at 618/638).**
+  Every word record now carries `:vm-eligible? true` and a
+  `:call-count` counter that `forth-execute-word` bumps on every
+  invocation. The flag is a hint for downstream JIT consumers — our
+  bodies are plain SX lambdas already, so the existing SX VM's
+  on-first-call JIT lifts them into bytecode automatically; the
+  metadata just makes that fact discoverable. Added
+  `forth-hot-words state threshold` returning `(name count)`
+  pairs above a threshold so a future tracing JIT can pick out
+  hot definitions to specialise. Phase 6 boxes all ticked.
+  All 306 internal tests green; Hayes Core stays at 618/638.
+
+- **Phase 6 — TCO at colon-def endings (Hayes unchanged at 618/638).**
+  `forth-run-body` now special-cases the final op when it's a plain
+  function (not a branch dict): we call it in tail position with no
+  pc-increment and no recursive `forth-run-body` call. This means
+  the SX CEK can collapse the continuation frame, so chains like
+  `: A ... B ; : B ... C ; …` and `RECURSE` deep-recursion test
+  cases run without piling up frames at each colon-def boundary.
+  All 306 internal tests still green; verified 5000-deep
+  `COUNTDOWN RECURSE` still terminates fine.
+
+- **Phase 6 — inline primitive calls (Hayes unchanged at 618/638).**
+  `forth-compile-call` now appends the looked-up word's body fn
+  directly to the colon-def body instead of wrapping it in
+  `(fn (s) (forth-execute-word s w))`. `forth-execute-word body`
+  reduces to `((get w "body") state)`, so the wrapper added an
+  extra closure + `get` per call op for no behavioural gain. Same
+  early-binding semantics: the body fn is captured at compile time,
+  so later redefinitions of the same name don't retroactively
+  change existing definitions. All 306 internal tests still green;
+  Hayes Core stays at 618/638. Pure optimisation.
+
+- **Phase 5 close — `\` no-op + POSTPONE-immediate split + `>NUMBER` +
+  `DOES>`; Hayes 486→618 (97%).** Big closing-out iteration.
+  Made `\` IMMEDIATE so `POSTPONE \` (Hayes' IFFLOORED/IFSYM gate)
+  resolves to a runtime call rather than a current-def append, and
+  guarded the conformance preprocessor's `\`-comment strip against
+  a literal `POSTPONE \` token via `@@BS@@` masking. Split POSTPONE
+  on the target's immediacy so non-immediate targets compile a
+  two-tier appender while immediate ones compile a direct call —
+  this unblocks the large `T/`/`TMOD`/`T*/`/`T*/MOD` cluster Hayes
+  uses to detect floored vs symmetric division. `>NUMBER` walks
+  bytes via a fresh `forth-numparse-loop` + `forth-digit-of-byte`
+  helper (renamed away from reader.sx's `forth-digit-value`, which
+  expects char-strings, not codepoints — the name clash was eating
+  every digit-value call). Implemented `DOES>` by:
+  1) tracking the last CREATE on `state.last-creator`,
+  2) adding a `:kind "does-rebind"` op, and
+  3) post-processing the body in `;` to attach the slice of ops
+     after each rebind as `:deferred`. At runtime, the rebind op
+     installs a new body for the target word that pushes its
+     data-field address and runs the deferred slice. Also added
+     histogram tracking on the conformance runner so future runs
+     surface the top missing words. Hayes: 618/638 pass (97%),
+     14 fail, 6 error (5× GI5 multi-WHILE, 1× dict-set! chunk).
+
+- **Phase 5 — String word set `COMPARE`/`SEARCH`/`SLITERAL` (+9).**
+  `COMPARE` walks bytes via the new `forth-compare-bytes-loop`,
+  returning -1/0/1 with standard prefix semantics (shorter string
+  compares less than its extension). `SEARCH` scans the haystack
+  with a helper `forth-search-bytes` and `forth-match-at`, returning
+  the tail after the first match or the original string with flag=0.
+  Empty needle returns at offset 0 with flag=-1 per ANS. `SLITERAL`
+  is IMMEDIATE: pops `(c-addr u)` at compile time, copies the bytes
+  into a fresh allocation, and emits the two pushes so the compiled
+  word yields the interned string at runtime.
+
+- **Phase 5 — File Access word set (in-memory backing; +4).**
+  `OPEN-FILE`/`CREATE-FILE`/`CLOSE-FILE`/`READ-FILE`/`WRITE-FILE`/
+  `FILE-POSITION`/`FILE-SIZE`/`REPOSITION-FILE`/`DELETE-FILE` plus
+  the mode constants `R/O`/`R/W`/`W/O`/`BIN`. File handles live on
+  `state.files` (fileid → {content, pos, path}) with a
+  `state.by-path` index so `CREATE-FILE`'d files can be
+  `OPEN-FILE`'d later in the same session. Attempting to
+  `OPEN-FILE` an unknown path returns `ior != 0`; disk-backed
+  open/read is not wired because `read-file` isn't in the sx_server
+  epoch eval environment (it's bound only in the HTTP helpers).
+  Also removed the stray base-2 `BIN` primitive from Phase 4 —
+  ANS `BIN` is the file-mode modifier. Hayes Core unchanged at
+  486/638 since core.fr doesn't exercise file words.
+
+- **Phase 5 — `WITHIN`/`ABORT`/`ABORT"`/`EXIT`/`UNLOOP` (+7;
+  Hayes 477→486, 76%).** `WITHIN` uses the ANS two's-complement
+  trick: `(n1-n2) U< (n3-n2)`. `ABORT` wipes the data/return/control
+  stacks and raises — the conformance runner catches it at the
+  chunk boundary. `ABORT"` parses its message like `S"`, then at
+  runtime pops a flag and raises only if truthy. `EXIT` adds a new
+  `:kind "exit"` op that the PC-driven body runner treats as a
+  jump-to-end; added a matching cond clause in `forth-step-op`.
+  `UNLOOP` pops two from the return stack — usable paired with
+  `EXIT` to bail from inside `DO`/`LOOP`.
+
+- **Phase 5 — `[`, `]`, `STATE`, `EVALUATE` (+5; Hayes 463→477, 74%).**
+  `[` (IMMEDIATE) clears `state.compiling`, `]` sets it. `STATE`
+  pushes the sentinel address `"@@state"` and `@` reads it as
+  `-1`/`0` based on the live `compiling` flag. `EVALUATE` reads
+  the (addr,u) string from byte memory, retokenises it via
+  `forth-tokens`, swaps it in as the active input, runs the
+  interpret loop, and restores the saved input. `SOURCE` and
+  `>IN` exist as stubs that push zeros — our whitespace-tokenised
+  input has no native byte-offset, so the deeper Hayes tests
+  that re-position parsing via `>IN !` stay marked as errors
+  rather than silently misbehaving.
+
+- **Phase 5 — parsing/dictionary words `'`/`[']`/`EXECUTE`/`LITERAL`/
+  `POSTPONE`/`WORD`/`FIND`/`>BODY` (Hayes 448→463, 72%).** xt is
+  represented as the SX dict reference of the word record, so
+  `'`/`[']` push the looked-up record and `EXECUTE` calls
+  `forth-execute-word` on the popped value. `LITERAL` (IMMEDIATE)
+  pops a value at compile time and emits a push-op. `POSTPONE`
+  (IMMEDIATE) compiles into the *outer* def an op that, when run
+  during a *later* compile, appends a call-w op to whatever def is
+  current — the standard two-tier compile semantic. Added
+  `state.last-defined` tracked by every primitive/colon definition
+  so `IMMEDIATE` can target the most-recent word even after `;`
+  closes the def. CREATE now stashes its data-field address on the
+  word record so `>BODY` can recover it. `WORD`/`FIND` use the byte
+  memory and counted-string layout already in place.
+  `DOES>` is deferred — needs a runtime mechanism to rebind the
+  last-CREATE'd word's action.
+
+- **Phase 5 — pictured numeric output: `<#`/`#`/`#S`/`#>`/`HOLD`/`SIGN` +
+  `U.`/`U.R`/`.R` (+9; Hayes 446→448, 70%).** Added a `state.hold`
+  list of single-character strings — `<#` resets it, `HOLD` and
+  `SIGN` prepend, `#` divides ud by BASE and prepends one digit,
+  `#S` loops `#` until ud is zero (running once even on zero),
+  `#>` drops ud and copies the joined hold buffer into mem,
+  pushing `(addr, len)`. `U.` / `.R` / `U.R` use a separate
+  `forth-num-to-string` for one-shot decimal/hex output and
+  `forth-spaces-str` for right-justify padding.
+
+- **Phase 5 — double-cell ops `D+`/`D-`/`DNEGATE`/`DABS`/`D=`/`D<`/`D0=`/
+  `D0<`/`DMAX`/`DMIN` (+18; Hayes unchanged).** Doubles get rebuilt
+  from `(lo, hi)` cells via `forth-double-from-cells-s`, the op runs
+  in bignum, and we push back via `forth-double-push-s`. Hayes Core
+  doesn't exercise D-words (those live in Gerry Jackson's separate
+  `doublest.fth` Double word-set tests we have not vendored), so the
+  scoreboard stays at 446/638 — but the words now exist for any
+  consumer that needs them.
+
+- **Phase 5 — mixed/double-cell math; Hayes 342→446 (69%).** Added
+  `S>D`, `D>S`, `M*`, `UM*`, `UM/MOD`, `FM/MOD`, `SM/REM`, `*/`, `*/MOD`.
+  Doubles ride on the stack as `(lo, hi)` with `hi` on top.
+  Helpers `forth-double-push-{u,s}` / `forth-double-from-cells-{u,s}`
+  split & rebuild via 32-bit unsigned mod/div, picking the negative
+  path explicitly so we don't form `2^64 + small` (float precision
+  drops at ULP=2^12 once you cross 2^64). `M*`/`UM*` use bignum
+  multiply then split; `*/`/`*/MOD` use bignum intermediate and
+  truncated division. Hayes: 446 pass / 185 error / 7 fail.
+
+- **Phase 5 — memory primitives + unsigned compare; Hayes 268→342 (53%).**
+  Added `CREATE`/`HERE`/`ALLOT`/`,`/`C,`/`CELL+`/`CELLS`/`ALIGN`/`ALIGNED`/
+  `2!`/`2@`/`U<`/`U>`. Generalised `@`/`!`/`+!` to dispatch on address
+  type: string addresses still go through `state.vars` (VARIABLE/VALUE
+  cells) while integer addresses now fall through to `state.mem` —
+  letting CREATE-allocated cells coexist with existing variables.
+  Decomposed the original "Full Core + Core Extension" box into
+  smaller unticked sub-bullets so iterations land per cluster.
+  Hayes: 342 pass / 292 error / 4 fail (53%). 237/237 internal.
+
+- **Phase 4 close — LSHIFT/RSHIFT, 32-bit arith truncation, early
+  binding; Hayes 174→268 (42%).** Added `LSHIFT` / `RSHIFT` as logical
+  shifts on 32-bit unsigned values, converted through
+  `forth-to-unsigned`/`forth-from-unsigned`. All arithmetic
+  primitives (`+` `-` `*` `/` `MOD` `NEGATE` `ABS` `1+` `1-` `2+`
+  `2-` `2*` `2/`) now clip results to 32-bit signed via a new
+  `forth-clip` helper, so loop idioms that rely on `2*` shifting the
+  MSB out (e.g. Hayes' `BITS` counter) actually terminate.
+  Changed colon-def call compilation from late-binding to early
+  binding: `forth-compile-call` now resolves the target word at
+  compile time, which makes `: GDX 123 ; : GDX GDX 234 ;` behave
+  per ANS (inner `GDX` → old def, not infinite recursion). `RECURSE`
+  keeps its late-binding thunk via the new `forth-compile-recurse`
+  helper. Raised `MAX_CHUNKS` default to 638 (full `core.fr`) now
+  that the BITS and COUNT-BITS loops terminate. Hayes: 268 pass /
+  368 error / 2 fail.
+
+- **Phase 4 — `SP@`/`SP!` (+4; Hayes unchanged; `DEPTH` was already present).**
+  `SP@` pushes the current data-stack depth (our closest analogue to a
+  stack pointer — SX lists have no addressable backing). `SP!` pops a
+  target depth and truncates the stack via `drop` on the dstack list.
+  This preserves the save/restore idiom `SP@ … SP!` even though the
+  returned "pointer" is really a count.
+
+- **Phase 4 — `BASE`/`DECIMAL`/`HEX`/`BIN`/`OCTAL` (+9; Hayes unchanged).**
+  Moved `base` from its top-level state slot into `state.vars["base"]`
+  so the regular `@`/`!`/VARIABLE machinery works on it.
+  `BASE` pushes the sentinel address `"base"`; `DECIMAL`/`HEX`/`BIN`/
+  `OCTAL` are thin primitives that write into that slot. Parser
+  reads through `vars` now. Hayes unchanged because the runner had
+  already been stubbing `HEX`/`DECIMAL` — now real words, stubs
+  removed from `hayes-runner.sx`.
+
+- **Phase 4 — `CHAR`/`[CHAR]`/`KEY`/`ACCEPT` (+7 / Hayes 168→174).**
+  `CHAR` parses the next token and pushes the first-char code. `[CHAR]`
+  is IMMEDIATE: in compile mode it embeds the code as a compiled push
+  op, in interpret mode it pushes inline. `KEY`/`ACCEPT` read from an
+  optional `state.keybuf` string — empty buffer makes `KEY` raise
+  `"no input available"` (matches ANS when stdin is closed) and
+  `ACCEPT` returns `0`. Enough for Hayes to get past CHAR-gated
+  clusters; real interactive IO lands later.
+
+- **Phase 4 — strings: `S"`/`C"`/`."`/`TYPE`/`COUNT`/`CMOVE`/`CMOVE>`/`MOVE`/`FILL`/`BLANK`/`C@`/`C!`/`CHAR+`/`CHARS` (+16 / Hayes 165→168).**
+  Added a byte-addressable memory model to state: `mem` (dict keyed by
+  stringified address → integer byte) and `here` (next-free integer
+  addr). Helpers `forth-alloc-bytes!` / `forth-mem-write-string!` /
+  `forth-mem-read-string`. `S"`/`C"`/`."` are IMMEDIATE parsing words
+  that consume tokens until one ends with `"`, then either copy content
+  into memory at compile time (and emit a push of `addr`/`addr len` for
+  the colon-def body) or do it inline in interpret mode. `TYPE` emits
+  `u` bytes from `addr` via `char-from-code`. `COUNT` reads the length
+  byte at a counted-string address and pushes (`addr+1`, `u`). `FILL`,
+  `BLANK` (FILL with space), `CMOVE` (forward), `CMOVE>` (backward),
+  and `MOVE` (auto-directional) mutate the byte dict. 193/193 internal
+  tests, Hayes 168/590 (+3).
+
+- **Phase 3 — Hayes conformance runner + baseline scoreboard (165/590, 28%).**
+  `lib/forth/conformance.sh` preprocesses `ans-tests/core.fr` (strips `\`
+  and `( ... )` comments + `TESTING` lines), splits the source on every
+  `}T` so each Hayes test plus the small declaration blocks between
+  them are one safe-resume chunk, and emits an SX driver that feeds
+  the chunks through `lib/forth/hayes-runner.sx`. The runner registers
+  `T{`/`->`/`}T` as Forth primitives that snapshot the dstack depth on
+  `T{`, record actual on `->`, compare on `}T`, and install stub
+  `HEX`/`DECIMAL`/`TESTING` so metadata doesn't halt the stream. Errors
+  raised inside a chunk are caught by `guard` and the state is reset,
+  so one bad test does not break the rest. Outputs
+  `scoreboard.json` + `scoreboard.md`.
+
+  First-run baseline: 165 pass / 425 error / 0 fail on the first 590
+  chunks. The default cap sits at 590 because `core.fr` chunks beyond
+  that rely on unsigned-integer wrap-around (e.g. `COUNT-BITS` with
+  `BEGIN DUP WHILE … 2* REPEAT`) which never terminates on our
+  bignum-based Forth; raise `MAX_CHUNKS` once those tests unblock.
+  Majority of errors are missing Phase-4 words (`RSHIFT`, `LSHIFT`,
+  `CELLS`, `S"`, `CHAR`, `SOURCE`, etc.) — each one implemented should
+  convert a cluster of errors to passes.
+
+- **Phase 3 — vendor Gerry Jackson's forth2012-test-suite.** Added
+  `lib/forth/ans-tests/{tester.fr, core.fr, coreexttest.fth}` from
+  https://github.com/gerryjackson/forth2012-test-suite (master, fetched
+  2026-04-24). `tester.fr` is Hayes' `T{ ... -> ... }T` harness; `core.fr`
+  is the ~1000-line Core word tests; `coreexttest.fth` is Core Ext
+  (parked for later phases). Files are pristine — the conformance runner
+  (next iteration) will consume them.
+
+- **Phase 3 — `DO`/`LOOP`/`+LOOP`/`I`/`J`/`LEAVE` + return stack words (+16).**
+  Counted loops compile onto the same PC-driven body runner. DO emits an
+  enter-op (pops limit+start from data stack, pushes them to rstack) and
+  pushes a `{:kind "do" :back PC :leaves ()}` marker onto cstack. LOOP/+LOOP
+  emit a dict op (`:kind "loop"`/`"+loop"` with target=back-cell). The step
+  handler pops index & reads limit, increments, and either restores the
+  updated index + jumps back, or drops the frame and advances. LEAVE walks
+  cstack for the innermost DO marker, emits a `:kind "leave"` dict op with
+  a fresh target cell, and registers it on the marker's leaves list. LOOP
+  patches all registered leave-targets to the exit PC and drops the marker.
+  The leave op pops two from rstack (unloop) and branches. `I` peeks rtop;
+  `J` reads rstack index 2 (below inner frame). Added non-immediate
+  return-stack words `>R`, `R>`, `R@`, `2>R`, `2R>`, `2R@`. Nested
+  DO/LOOP with J tested; LEAVE in nested loops exits only the inner.
+  177/177 green.
+
+- **Phase 3 — `BEGIN`/`UNTIL`/`WHILE`/`REPEAT`/`AGAIN` (+9).** Indefinite-loop
+  constructs built on the same PC-driven body runner introduced for `IF`.
+  BEGIN records the current body length on `state.cstack` (a plain numeric
+  back-target). UNTIL/AGAIN pop that back-target and emit a `bif`/`branch`
+  op whose target cell is set to the recorded PC. WHILE emits a forward
+  `bif` with a fresh target cell and pushes it on the cstack *above* the
+  BEGIN marker; REPEAT pops both (while-target first, then back-pc), emits
+  an unconditional branch back to BEGIN, then patches the while-target to
+  the current body length — so WHILE's false flag jumps past the REPEAT.
+  Mixed compile-time layout (numeric back-targets + dict forward targets
+  on the same cstack) is OK because the immediate words pop them in the
+  order they expect. AGAIN works structurally but lacks a test without a
+  usable mid-loop exit; revisit once `EXIT` lands. 161/161 green.
+
+- **Phase 3 start — `IF`/`ELSE`/`THEN` (+18).** `lib/forth/compiler.sx`
+  + `tests/test-phase3.sx`. Colon-def body switched from `for-each` to
+  a PC-driven runner so branch ops can jump: ops now include dict tags
+  `{"kind" "bif"|"branch" "target" cell}` alongside the existing
+  `(fn (s) ...)` shape. IF compiles a `bif` with a fresh target cell
+  pushed to `state.cstack`; ELSE emits an unconditional `branch`,
+  patches the IF's target to the instruction after this branch, and
+  pushes the new target; THEN patches the most recent target to the
+  current body length. Nested IF/ELSE/THEN works via the cstack.
+  Also fixed `EMIT`: `code-char` → `char-from-code` (spec-correct
+  primitive name) so Phase 1/2 tests run green on sx_server.
+  152/152 (Phase 1 + 2 + 3) green.
+
 - **Phase 2 complete — colon defs, compile mode, VARIABLE/CONSTANT/VALUE/TO, @/!/+! (+26).**
   `lib/forth/compiler.sx` plus `tests/test-phase2.sx`.
   Colon-def body is a list of ops (one per source token) wrapped in a single

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 (`//`, `/* */`)
-- [x] Automatic Semicolon Insertion (defer — initially require semicolons)
+- [ ] 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`)
-- [x] `var` hoisting (shallow — collects direct `var` decls, emits `(define name :js-undefined)` before funcdecls)
+- [ ] `var` hoisting (deferred — treated as `let` for now)
 - [ ] `let`/`const` TDZ (deferred)
 
 ### Phase 8 — Objects, prototypes, `this`
@@ -158,272 +158,6 @@ 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-10 — **`String.prototype.repeat` no longer arity-collides with itself; raises RangeError on negative or +Infinity counts.** Earlier JSON.stringify iteration introduced a 2-arg `js-string-repeat` that shadowed the existing 3-arg `(s n acc)` accumulator implementation, breaking every `s.repeat(n)` call with "expects 2 args, got 3". Renamed the accumulator helper to `js-string-repeat-loop` and made `js-string-repeat` a 2-arg facade that delegates. Hooked the repeat method to raise RangeError when `count < 0` or `count = Infinity` per spec. Result: built-ins/String/prototype/repeat 7/13 → 11/13 (+4). conformance.sh: 148/148.
-
-- 2026-05-10 — **test262-runner inlines small upstream harness includes (`nans.js`, `sta.js`, `byteConversionValues.js`, `compareArray.js`) per-test.** The runner parsed `includes:` frontmatter but never used it, so tests like `built-ins/isNaN/return-true-nan.js` (which depends on `var NaNs = [...]`) failed with "ReferenceError: undefined symbol". Added `_load_harness_include` (cached) and `assemble_source` now prepends each allowlisted include's source to the test. Allowlist excludes large helpers like `propertyHelper.js` because per-test js-eval+JIT cost on a 371-line harness pushes tests over the 15s per-test timeout (regressed Math/abs 7/7 → 4/7 in a first-pass attempt before allowlisting). Result: built-ins/isNaN 2/7 → 3/7. conformance.sh: 148/148.
-
-- 2026-05-10 — **Real `Date.prototype.setFullYear/setMonth/setDate/setHours/setMinutes/setSeconds/setMilliseconds` (+ UTC variants) and a corrected `setTime`.** All Date setters were missing — only `setTime` existed and didn't validate. Added a unified `js-date-setter(d, field, args)` that decomposes the current ms into `(y mo da hh mm ss msv)` via `js-date-decompose`, splices in the `args` per the field's optional-arg contract (e.g. `setHours(h, m?, s?, ms?)`), recomposes via `js-date-civil-to-days`, and TimeClips at ±8.64e15. NaN args anywhere → ms set to NaN. Wired all 14 setters to the helper. Hit a parser gotcha: SX `cond` clause body is single-form only — multi-expression bodies like `(else (dict-set! ...) new-ms)` silently treat the second form as `(<first-result> new-ms)` ("Not callable: false"). Wrapped these in `(begin ...)`. Result: setFullYear 5/18 → 13/18 (+8). setHours 5/21 → 15/21 (+10). setMonth 3/15 → 9/15 (+6). setMinutes 4/16 → 10/16 (+6). setSeconds 3/15 → 9/15 (+6). setDate 2/12 → 6/12 (+4). setMilliseconds 2/12 → 6/12 (+4). setTime 4/9 → 6/9 (+2). conformance.sh: 148/148.
-
-- 2026-05-10 — **`Object.assign` keys now visible to `Object.keys` / `JSON.stringify`.** `Object.assign({}, {a:1})` was mutating the target via `dict-set!` which bypasses our `__js_order__` insertion-order side table; `Object.keys(t)` (which iterates `__js_order__` when present) returned `[]`, and `JSON.stringify` saw nothing. Switched `js-object-assign` to use `js-set-prop` (which calls `js-obj-order-add!` on new keys) for both dict and string sources. Result: built-ins/Object/assign 13/25 → 14/25. conformance.sh: 148/148.
-
-- 2026-05-10 — **User functions' `prototype` chain through Object.prototype + auto-set `constructor`.** Per ES spec, every function's `prototype` slot defaults to `{ constructor: F, __proto__: Object.prototype }`. Our `js-get-ctor-proto` lazily created a fresh empty `(dict)` for user functions on first access — so `(new F) instanceof Object` was `false`, `F.prototype.constructor` was undefined, and `x.constructor === F` failed. Now the lazy-init seeds the proto with `__proto__ → Object.prototype` and `constructor → F` before caching in `__js_proto_table__`. Result: language/expressions/instanceof 25/30 → 26/30. conformance.sh: 148/148.
-
-- 2026-05-10 — **Postfix `++`/`--` reject a preceding LineTerminator (ASI).** Per ES spec, `x\n++;` is a syntax error: no LineTerminator allowed between LHS and postfix `++`/`--`. Our `jp-parse-postfix` was matching `++`/`--` regardless of whether the preceding token had `:nl true`. Added `(not (jp-token-nl? st))` guard so newline-before-`++` makes the postfix arm fall through, the `++` then becomes a prefix-expr starting a new statement, which fails to parse and the runner classifies as SyntaxError. Result: language/expressions/postfix-increment 16/30 → 18/30 (+2). postfix-decrement 16/30 → 18/30 (+2). conformance.sh: 148/148.
-
-- 2026-05-10 — **Parse-time SyntaxError when `let`/`const`/`function`/`class` appear as a single-statement body of `if`/`while`/`do`/`for`/labeled.** Per ES grammar, those positions accept a Statement, not a Declaration — only block bodies (`{ ... }`) may contain Declarations. Added `jp-disallow-decl-stmt!` helper that, when the next token is a Declaration keyword in single-statement context, raises SyntaxError. The `let` arm checks for `let <ident>`, `let [`, or `let {` to avoid mis-rejecting `let;` (where `let` is just an identifier expression). Hook calls in `jp-parse-if-stmt` (then + else branches), `jp-parse-while-stmt`, `jp-parse-do-while-stmt`, both for-of/in and C-for body sites, and the labeled-statement entry. Result: language/statements/while 16/30 → 20/30. statements/labeled 4/15 → 7/15. statements/if 20/30 → 21/30. conformance.sh: 148/148.
-
-- 2026-05-10 — **Parse-time SyntaxError for `break`/`continue` outside loops/switches and `return` outside functions; `void <expr>` evaluates `<expr>` for side effects.** Parser tracks `:loop-depth`, `:switch-depth`, and `:fn-depth` on the state dict (initialized to 0). `jp-parse-while-stmt`, `jp-parse-do-while-stmt`, `jp-parse-for-stmt` (both for-of/in and C-for) bump `:loop-depth` around body parsing; `jp-parse-switch-stmt` bumps `:switch-depth`; new `jp-parse-fn-body` and `jp-parse-arrow-body` save+reset loop/switch depth and bump `:fn-depth` (so `break` inside an outer loop's nested function is rejected). Bare `break` requires `loop-depth > 0 OR switch-depth > 0`; bare `continue` requires `loop-depth > 0`; `return` requires `fn-depth > 0`. Separately, `void <expr>` was compiling to just `:js-undefined` (dropping the expression entirely); now `(begin <expr> :js-undefined)` so side effects fire. Result: language/statements/return 4/15 → 14/15 (+10). statements/break 9/20 → 12/20. statements/continue 12/24 → 15/24. expressions/void 7/9 → 8/9. conformance.sh: 148/148.
-
-- 2026-05-10 — **`Math.hypot` and `Math.cbrt` honour spec edges for NaN, ±Infinity, and ±0.** `Math.hypot(NaN, Infinity)` was returning NaN instead of +Infinity (spec: any ±Infinity arg dominates NaN). Rewrote `js-math-hypot` to scan args once tracking inf/nan flags, return +Infinity if any arg is ±Infinity, else NaN if any was NaN, else `sqrt(sum of squares)`. `Math.cbrt(NaN)` was 0 (because `pow(NaN, 1/3)` produced 0 in our path); also `Math.cbrt(-0)` returned +0 instead of -0. Added explicit short-circuits: NaN→NaN, ±Infinity→arg, ±0→arg, plus changed `(/ 1 3)` (rational) to `(/ 1.0 3.0)` (inexact) to avoid rational fractional-power oddities. Result: built-ins/Math/hypot 9/11 → 10/11. Math/cbrt 3/4 → 4/4. conformance.sh: 148/148.
-
-- 2026-05-10 — **`globalThis.globalThis === globalThis`; `Number.prototype.toFixed` honours digit-range and ≥1e21 fallback.** (1) `globalThis` was bound to `nil` in the global object literal (originally to dodge an inspect-cycle hang) — added `(dict-set! js-global "globalThis" js-global)` after the literal so `globalThis.globalThis === globalThis` per spec. (2) `Number.prototype.toFixed` rewrites: RangeError when fractionDigits is NaN or outside `[0,100]` (was silently producing garbage), and for `|x| >= 1e21` returns `js-number-to-string` (the value's own ToString) per spec step 9. conformance.sh: 148/148.
-
-- 2026-05-10 — **`delete <ident>` returns `false` instead of `true` per non-strict spec.** ES non-strict semantics: `delete x` where `x` is a declared binding (variable / function / parameter) returns `false` and does not unbind. Our transpiler was emitting `true` for any `delete <expr>` whose argument wasn't a member or index access. Now `delete <js-ident>` → `false`, and `delete <js-paren expr>` recurses on the inner expression so `delete (1+2)` still works. Result: language/expressions/delete 14/30 → 18/30 (+4). conformance.sh: 148/148.
-
-- 2026-05-10 — **Parser rejects unary-op directly before `**` (e.g. `-1 ** 2`, `delete o.p ** 2`, `!x ** 2`, `~x ** 2`) per ES spec.** ES disallows `UnaryExpression ** ExponentiationExpression`; only `UpdateExpression ** ExponentiationExpression` and `(<UnaryExpr>) ** ...` are legal. Added a guard in `jp-binary-loop`: when op is `**` and the LHS is a `(js-unop ...)` node, raise SyntaxError. Parens are made transparent for everything except this check via a new `jp-paren-wrap` helper that emits `(js-paren <unop>)` only when wrapping an explicit unary op (so `(-1) ** 2` parses fine), and a new `js-paren` AST tag in `js-transpile` that just unwraps. Result: language/expressions/exponentiation 25/30 → 28/30 (+3). conformance.sh: 148/148.
-
-- 2026-05-10 — **`Math.round` / `Math.max` / `Math.min` honour spec edge cases for NaN, ±Infinity, and ±0.** `Math.round(NaN)` was returning 0 because `floor(NaN+0.5)` doesn't propagate NaN; ditto `±Infinity` paths. `Math.max({})` silently returned `-Infinity` (initial accumulator) because the first arg wasn't ToNumber'd. `Math.max(0, -0)` returned `-0` because `>` doesn't distinguish them. Rewrites: round NaN/±Infinity/±0 short-circuits; max/min ToNumber the first arg, propagate NaN immediately, and use a `js-is-positive-zero?` (rational-safe) tiebreaker so `Math.max(0, -0) === 0` per spec. Result: built-ins/Math/round 5/10 → 8/10 (+3). Math/max 6/9 → 8/9 (+2). Math/min 6/9 → 8/9 (+2). conformance.sh: 148/148.
-
-- 2026-05-10 — **`Map.prototype.*` and `Set.prototype.*` raise TypeError when called on non-Map / non-Set `this`.** All five `js-map-do-*` and four `js-set-do-*` helpers were assuming `this` had `__map_keys__` / `__set_items__`, so `Map.prototype.clear.call({})` silently returned undefined (after creating dangling state) instead of throwing. Added `js-map-check!` / `js-set-check!` guards run as the first step of each method; raise spec-correct `TypeError` instances. Result: built-ins/Map 18/30 → 22/30 (+4). built-ins/Set 15/30 → 28/30 (+13). conformance.sh: 148/148.
-
-- 2026-05-10 — **`Date.UTC` / `new Date(...)` propagate NaN/±Infinity arguments and return NaN.** `Date.UTC()` (no args) returned 0 instead of NaN; `Date.UTC(NaN, ...)` did the math and produced bogus ms; `new Date(year, NaN)` constructed a normal Date instead of an invalid one. Added `js-date-args-have-nan?` (also detects ±Infinity and propagates from rationals) used by both `Date.UTC` and the multi-arg constructor branch; UTC now returns NaN on no-arg / any-NaN-arg / out-of-range result, and `new Date(args)` stores NaN in `__date_value__` when any arg is NaN. Also fixed `js-date-from-one(undefined)` to return NaN. Result: built-ins/Date/UTC 6/16 → 10/16 (+4). Date 17/30 → 26/30 (timeouts dropped from 12 → 4 because invalid Dates now short-circuit). conformance.sh: 148/148.
-
-- 2026-05-10 — **Real `Date` construction + getters via Howard-Hinnant civil-day arithmetic.** `js-date-from-parts` now computes a true ms-since-epoch from `(year, month, day, hour, min, sec, ms)` via `js-date-civil-to-days` (the inverse of last iteration's `days-to-ymd`), with the legacy 2-digit-year coercion (0..99 → 1900+y). `getFullYear/Month/Date/Day/Hours/Minutes/Seconds/Milliseconds` (UTC + non-UTC) all share a new `js-date-getter`: TypeErrors on non-Date this, returns NaN on invalid time, otherwise decomposes ms into y/m/d/h/m/s/ms/dow. Plus added `Date.prototype.constructor = Date` (was missing). Result: each of the 8 Date getter categories went 2/6 → 5/6 (+3 each, +24 total). Date toISOString 11/16 → 13/16. Some Date construction-loop tests now exceed the 15s per-test timeout — the new civil math is heavier than the old (year-1970)*ms-per-year approximation, but correctness wins. conformance.sh: 148/148.
-
-- 2026-05-10 — **`Date.prototype.toISOString` produces real `YYYY-MM-DDTHH:mm:ss.sssZ` and validates input.** Old `js-date-iso` only computed the year and hardcoded the rest as `01-01T00:00:00.000Z`. Added: (1) TypeError when this isn't a Date (no `__js_is_date__` slot); (2) RangeError when ms is NaN, undefined, or |ms| > 8.64e15; (3) full date breakdown via Howard-Hinnant `days_to_civil` algorithm (`js-date-days-to-ymd`) → year/month/day, plus modular hours/min/sec/ms; (4) extended-year format `±YYYYYY` for years outside 0..9999. Result: built-ins/Date/prototype/toISOString 7/16 → 11/16 (+4). Date 21/30. conformance.sh: 148/148.
-
-- 2026-05-10 — **`JSON.stringify` honours `replacer` (function + array forms), `space`, and `toJSON`.** Previous impl ignored the second/third arguments entirely and never called `toJSON`. Rewrote around a `js-json-serialize-property(key, holder, rep-fn, rep-keys, gap, indent)` core: walks `toJSON` first, then replacer-fn (with `holder` as `this`); arrays-as-replacer become a property-name allowlist; numeric `space` clamped to 0..10 spaces, string `space` truncated to 10 chars, non-empty gap activates indented output with `:` → `: ` separator. Number wrapper / String wrapper / Boolean wrapper unwrap before serialization; non-finite numbers serialize as `"null"`; functions serialize as `undefined`. Result: built-ins/JSON/stringify 6/30 → 14/30 (+8). conformance.sh: 148/148.
-
-- 2026-05-10 — **`JSON.parse` raises spec-correct `SyntaxError` instances and rejects malformed input.** Previously `JSON.parse("12 34")` silently returned `12` (no trailing-content check), `JSON.parse('""')` accepted control chars in strings, an unterminated string read off the end, and the inner `(error "JSON: ...")` calls produced generic Errors not `instanceof SyntaxError`. Added: (1) post-value whitespace skip + trailing-content check in `js-json-parse`; (2) control-char rejection (code < 0x20) and unterminated-string check in `js-json-parse-string-loop`; (3) all internal "JSON: ..." errors now `(raise (js-new-call SyntaxError ...))`. Result: built-ins/JSON/parse 7/30 → 25/30 (+18). JSON 26/30. conformance.sh: 148/148.
-
-- 2026-05-10 — **`arguments` object inside functions is now a mutable list.** `js-arguments-build-form` produced `(cons p1 (cons p2 __extra_args__))` which yielded a structurally-shared (immutable) list — `arguments[1] = 7; arguments[1]++` raised "set-nth!: list is immutable". Wrapping the build in `js-list-copy` so each function entry constructs a fresh mutable list. Existing reads (`arguments.length`, `arguments[i]`) unaffected. Result: language/expressions/postfix-increment 14/30 → 15/30. conformance.sh: 148/148.
-
-- 2026-05-10 — **`String.prototype.split(undefined)` returns `[wholeString]`; function-expression bodies have spec-correct implicit `undefined` return.** (1) `js-string-method "split"` was calling `js-to-string` on the separator unconditionally, so `"undefinedd".split(undefined)` produced `["", "d"]` (split by `"undefined"`); also `limit=0` returned the whole-string list instead of `[]`. New arms: `undefined` separator → `[s]`, `limit=0` → `[]`, otherwise existing string-split. (2) Function expressions wrapped the body in `(call/cc (fn (__return__) (begin <stmts>)))` and used the begin's last expression as the implicit return value. So `function F(){ this.x = function(){return 99} }` returned the inner lambda (because `js-set-prop` returns the rhs), and `new F()` saw a callable return and replaced the freshly-allocated `this` with it — so `i.x` was missing. Append `nil` to the begin so the implicit completion is always `:js-undefined`; explicit `return` still works via call/cc as before. Result: built-ins/String/prototype/split 8/30 → 10/30. Constructors with function-valued `this.X` now keep their assignments. conformance.sh: 148/148.
-
-- 2026-05-10 — **Number/Boolean primitive method dispatch falls back to `Number.prototype` / `Boolean.prototype`.** When a user assigned a String method onto `Number.prototype` (e.g. `Number.prototype.toUpperCase = String.prototype.toUpperCase; NaN.toUpperCase()`), `js-invoke-number-method` rejected the unknown key with "is not a function (on number)" — it never walked the prototype. Added a fallback in both `js-invoke-number-method` and `js-invoke-boolean-method`: on unknown keys, `js-dict-get-walk` the constructor prototype; if found, `js-call-with-this` it. Result: built-ins/String/prototype/toUpperCase 16/25 → 19/25 (+3). Boolean 29/30. conformance.sh: 148/148.
-
-- 2026-05-10 — **`String.prototype.*` ToString-coerces non-string/non-undef this; `.call` / `.apply` skip global-coercion for built-in callables.** `String.prototype.trim.call(false)` was returning `"[object Object]"` because (a) `.call`/`.apply` blanket-coerced null/undefined `thisArg` to `js-global-this`, swallowing the original null, and (b) `js-string-proto-fn` fell back to `"[object Object]"` for any non-string this. (1) `js-string-proto-fn` now ToString-coerces primitive thisVal and raises TypeError for null/undefined (matches `RequireObjectCoercible` semantics for built-in String methods). (2) New `js-call-this-coerce` helper applies the legacy `js-coerce-this-arg` only when `recv` is a user lambda/component; built-in dict-with-`__callable__` methods get the raw `thisArg` (so they can see and reject null/undefined themselves, or accept primitive thisArgs without ToObject). Result: built-ins/String/prototype/trim 7/30 → 30/30 (+23). Function/prototype/apply 10/30 → 21/30. expressions/array 21/30 → 22/30. conformance.sh: 148/148.
-
-- 2026-05-10 — **`**` / `Math.pow` honour JS spec edge cases for NaN, ±0, abs(base)=1+Infinity, plus `Number.prototype.valueOf` accepts ignored args.** (1) New `js-pow-spec` shared by `js-pow` (operator) and `js-math-pow`: NaN exponent → NaN, exponent 0 → 1 (even with NaN base), NaN base + non-zero exp → NaN, abs(base)=1 with exp=±Infinity → NaN. Underlying `pow` handles the rest. (2) Number.prototype.valueOf was `(fn () ...)` and rejected the spec-allowed extra arg with "lambda expects 0 args, got 1"; now `(fn (&rest args) ...)`. Result: language/expressions/exponentiation 23/30 → 25/30 (+2). built-ins/Math/pow 27/27 holds. conformance.sh: 148/148.
-
-- 2026-05-10 — **`Number.prototype.toString(radix)` no longer crashes on rational division-by-zero.** `js-num-to-str-radix` was probing for ±Infinity by comparing against `(/ 1 0)` / `(/ -1 0)` — but on the rational arithmetic path that throws "rational: division by zero" before the comparison ever happens, so every `Number(x).toString(radix)` call exploded. Replaced the probes with `(js-infinity-value)` / `(- 0 (js-infinity-value))` and the NaN check with `js-number-is-nan`. Result: built-ins/Number/prototype/toString 0/30 → 29/30 (+29). Number 26/30. conformance.sh: 148/148.
-
-- 2026-05-10 — **Array literal elision (holes), `list instanceof Array`, `array.toString` identity.** Three coupled fixes for `language/expressions/array`. (1) Parser: `jp-array-loop` accepts a leading or interior `,` as elision and pushes `(js-undef)`, so `[,]`, `[,,3,,,]`, `[1,,3]` parse and produce length 1, 5, 3. (2) Runtime: `js-instanceof` adds a `(list? obj)` arm that returns true when the right-hand side is `Array` (or `Object`). (3) Runtime: `js-get-prop` for `key="toString"` on a list returns the actual `Array.prototype.toString` slot via `js-dict-get-walk` instead of a fresh `js-array-method` callable, so `[1,2,3].toString === Array.prototype.toString`. `toLocaleString` left on the legacy arm — its proto entry is a dict-with-`__callable__` whose body re-enters `js-invoke-method`, which would loop. Result: language/expressions/array 13/30 → 21/30 (+8). conformance.sh: 148/148.
-
-- 2026-05-10 — **`Object.getOwnPropertyDescriptor` skips internal `__proto__` and `__js_order__` keys.** Was returning a regular property descriptor for our internal `__proto__` and `__js_order__` markers — `Object.getOwnPropertyDescriptor({__proto__: null}, "__proto__")` returned `{configurable, enumerable, value: null, writable}` instead of `undefined` per spec. Added a `(js-key-internal? sk)` short-circuit in the descriptor path that returns `:js-undefined` for internal keys. Result: language/expressions/object 13/30 → 16/30. Object 30/30 holds, getOwnPropertyDescriptor 28/30. conformance.sh: 148/148.
-
-- 2026-05-09 — **Object literal spread `{...src}` parses + executes.** Per ES spec, object literals can include `...expr` to copy own enumerable properties from a source. `jp-parse-object-entry` was rejecting the leading `...` punct. Added a parser branch that records the AST under `:spread`. `js-transpile-object` emits `(js-obj-spread! _obj <src-expr>)` for spread entries, alongside the existing `(js-obj-set! _obj k v)` for regular entries. New `js-obj-spread!` runtime helper: dict source copies own enumerable keys (skipping internal `__js_order__` / `__proto__`); string source copies each character at its numeric index; list source copies elements at their numeric index; null/undefined no-op. Result: language/expressions/array 5/30 → 13/30 (+8). Object 30/30 holds. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Object.getOwnPropertyNames` throws on null/undefined and includes `"length"` for strings/arrays.** Was returning `(list)` for non-list/non-dict inputs; per spec it ToObject's the argument and returns own keys including the implicit `"length"` property for strings/arrays. Added explicit branches: null/undefined → TypeError, string → `["0","1",…,"n-1","length"]` via `js-string-keys-loop` then append, list → indices + `"length"`, dict → existing ordered path. Result: built-ins/Object/getOwnPropertyNames 19/30 → 20/30. Object 30/30 holds. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Object.values`/`entries` throw on null/undefined and walk strings.** Same shape as the previous `Object.keys` fix. Both methods returned `(list)` for non-dict input; per spec they ToObject the argument and yield the property values / `[k, v]` pairs. Added explicit branches: null/undefined → TypeError, string → walk character indices, dict → iterate own enumerable keys (skipping internal `__js_order__` / `__proto__`). Result: built-ins/Object/values 5/16 → 8/16, entries 5/17 → 9/17. Object 30/30 holds. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Object.keys` throws TypeError on null/undefined and walks indices on strings/arrays.** Was returning `(list)` for non-dict input — `Object.keys(null)` silently returned `[]` instead of throwing per spec, and `Object.keys("abc")` returned `[]` instead of `["0","1","2"]`. Added explicit branches: null/undefined → TypeError, string/list → `["0","1",..."n-1"]` via `js-string-keys-loop`. Result: built-ins/Object/keys 19/30 → 22/30. Object 30/30, Map 18/30 unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Object.assign` ToObject's target, throws TypeError on null/undefined, copies own enumerable props from string sources.** Was returning the raw target unchanged when given a primitive (`Object.assign("a")` returned the string `"a"`), and silently no-op'd on null/undefined target instead of throwing per spec. Now coerces target via `js-coerce-this-arg` (boxes primitives), guards null/undefined with TypeError, and walks each source: dict → copy own keys (skipping internal `__js_order__` / `__proto__`), string → copy each character at numeric index, null/undefined → skip. Now `Object.assign("a")` returns a String wrapper whose `valueOf()` is `"a"`, and `Object.assign(null)` throws TypeError. Result: built-ins/Object/assign 5/25 → 13/25 (+8). Object 30/30 holds. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Number.prototype.toFixed`/`toString`/etc. unwrap Number wrappers and throw TypeError on non-Number receivers.** Was passing `(js-this)` straight through to `js-number-to-fixed`, so calling `Number.prototype.toFixed(1)` directly on `Number.prototype` (a Number wrapper dict) raised `"Expected number, got dict"`. Per spec, these methods must extract the Number primitive value (from primitive or wrapper) and throw TypeError otherwise. Added `js-number-this-val` helper that handles primitive number, rational, `__js_number_value__`-marked wrapper, and raises TypeError for everything else. Routed all six Number.prototype methods through it. Result: built-ins/Number/prototype/toFixed 5/13 → 7/13. Number 26/30 holds. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Array.prototype` methods carry spec lengths and names.** Continuation of the same fix. `js-array-proto-fn` was returning bare lambdas → `Array.prototype.push.length === 0` instead of `1`. Added `js-array-proto-fn-length` (lookup table for the ~30 method names — `push:1`, `slice:2`, `splice:2`, `concat:1`, `forEach:1`, `every:1`, `flat:0`, etc.) and changed the helper to return the dict-with-`__callable__` form. Now `Array.prototype.push.length === 1`, `Array.prototype.slice.length === 2`. Array 27/50, Array.prototype 8/30, Object 30/30 unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Number.prototype` and `String.prototype` methods carry spec lengths and names.** Same shape as the earlier Function.prototype fix. Number.prototype.{toFixed/toExponential/toPrecision/toString/valueOf/toLocaleString} were bare `(fn ...)` lambdas → length 0 → tests assert e.g. `Number.prototype.toExponential.length === 1`. Wrapped each in a dict-with-`__callable__` with `:length` and `:name`. For String.prototype, `js-string-proto-fn` was a single helper applied to ~30 method names; added `js-string-proto-fn-length` (lookup table for spec-defined lengths: `concat:1`, `indexOf:1`, `slice:2`, `substring:2`, `replace:2`, etc.) and changed the helper to return the dict form, so all string methods now report correctly. Result: built-ins/Number/prototype 18/30 → 20/30, String/prototype 18/30 → 21/30. Number 26/30 holds, String 29/30. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Boolean.prototype.toString`/`valueOf` throw TypeError on non-Boolean receivers.** Per spec, both methods are not generic — calling them with a `this` that isn't a Boolean primitive or wrapper must throw TypeError. Was silently returning `"true"`/`"false"` based on whether the receiver was truthy (`s1.toString = Boolean.prototype.toString; s1.toString()` returned `"true"` for any non-empty string instead of throwing). Added an `else (raise (js-new-call TypeError ...))` branch to both prototype methods. Result: built-ins/Boolean 28/30 → 29/30. Object 30/30 holds. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Array.prototype.reduce`/`reduceRight` callback receives `(acc, cur, idx, array)`.** Was calling `(f acc cur)` — only two args, no index, no source array. Per spec the reducer signature is `(accumulator, currentValue, currentIndex, array)`. Updated `js-list-reduce-loop` and `js-list-reduce-right-loop` to call via `js-call-with-this js-undefined f (list acc cur i arr)`. Result: built-ins/Array/prototype/reduce 6/30 → 8/30, reduceRight 6/30 → 8/30. Object 30/30 holds. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Array.prototype.find`/`findIndex`/`some`/`every` honour `thisArg` and pass `(value, index, array)`.** Same shape as the previous `forEach`/`map`/`filter` fix — these were calling `(f x)` directly. Updated each prototype method to extract optional `thisArg` (defaulting to globalThis when null/undefined) and route through `js-call-with-this` with the full `(value, index, array)` triple. Updated `js-list-find-loop` / `js-list-find-index-loop` / `js-list-some-loop` / `js-list-every-loop` to match. Result: built-ins/Array/prototype/find 5/30 → 6/30. Modest delta this round (most remaining failures need deeper Array semantics — sparse arrays, ToLength on `length`, etc.). Object 30/30, Map 18/30 unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Array.prototype.forEach`/`map`/`filter` honour `thisArg` and pass `(value, index, array)` to callback.** Was calling the callback with just `(value)` from a bare `(f x)` and ignoring the optional second `thisArg` parameter. Per spec, the callback receives `(value, index, array)` and `this` is `thisArg ?? globalThis` in non-strict. Updated the prototype methods to take `&rest args`, extract `thisArg` (defaulting to globalThis when null/undefined), and route through `js-call-with-this` with the full triple. Updated `js-list-foreach-loop` / `js-list-map-loop` / `js-list-filter-loop` accordingly. Result: built-ins/Array/prototype/forEach 2/30 → 9/30, filter 5/30 → 10/30. Array 18/30, Object 30/30, Map 18/30 unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Map.prototype.forEach` / `Set.prototype.forEach` honour `thisArg` and pass `(value, key, collection)` to callback.** Was hardcoding `js-undefined` as the callback receiver and only passing `(value, key)`. Per spec, the callback receives `(value, key, collection)` and `this` is `thisArg ?? globalThis` in non-strict. Updated `js-map-do-foreach` / `js-set-do-foreach` to accept an optional `thisArg`, defaulting to `globalThis` when null/undefined; the prototype methods now route the second positional arg through. Result: built-ins/Map/prototype 11/30 → 13/30, built-ins/Set/prototype +similar. Map 18/30 holds. conformance.sh: 148/148.
-
-- 2026-05-09 — **`for…in` walks the prototype chain (with shadowing) but stops at native prototypes.** Was using `js-object-keys` which only returns own enumerable keys, so `for (k in instance)` only saw the instance's own properties — not inherited ones from `FACTORY.prototype`. Per spec, for-in walks the entire chain and yields each unique enumerable key once. Added `js-for-in-keys` + `js-for-in-walk` that iterate the chain, deduping via `contains?`. Stops at `Object.prototype` / `Array.prototype` / etc. since those carry "non-enumerable" methods we don't track property-attribute-wise — without this guard, `for (k in {})` would enumerate `toString`/`valueOf`/etc. Result: language/statements/for-in 10/30 → 12/30. Object 30/30, Array 18/30 unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **Parser swallows label declarations + accepts optional ident on `break`/`continue`.** Was rejecting `outer: while (...) { break outer; }` at parse time. Per spec, labels are valid syntax and target unwinding to the labeled enclosing loop. Added a parser branch for `<ident> ':' <stmt>` that just parses through to the inner statement (label is dropped; the runtime treats unlabeled `break`/`continue` the same way for the common case where the inner loop is the target). Also extended `break`/`continue` to optionally consume a trailing ident. Result: language/statements/while 14/30 → 16/30, for 27/30 → 28/30. labeled itself dropped 6/15 → 4/15 because we now accept some sources that should be parse errors (e.g. `label: let x;` is a SyntaxError per spec) — net positive across the suite. Object 30/30, Array 18/30 unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`new function(){...}(args)` and `new f(...rest)` now parse and execute.** Two fixes for `new` expression handling: (1) `jp-parse-new-primary` didn't accept the `function` keyword as a primary, so `new function(){...}` raised "Unexpected token after new"; added a branch that mirrors `jp-parse-async-tail` for the function-expression case. (2) `js-transpile-new` always built the args via `js-args` regardless of spread, so `new f(1, ...[])` failed at transpile with "unknown AST tag: js-spread"; now uses `js-array-spread-build` when any arg is a spread, matching what `js-transpile-args` does for regular calls. Result: language/expressions/new 16/30 → 19/30. Object 30/30, Array 18/30, language/expressions/call 21/30 unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **Parser accepts `new <literal>` (boolean/number/string/null/undefined) and lets it throw TypeError at runtime.** Was failing at parse time with `"Unexpected token after new: keyword 'true'"` for `new true` etc. Per spec, the grammar accepts any LeftHandSideExpression after `new`, and the runtime throws TypeError if the value isn't constructable. Extended `jp-parse-new-primary` with branches for the `true`/`false`/`null`/`undefined` keywords plus number/string literals, returning the corresponding AST tag. `js-new-call`'s existing `(not (js-function? ctor))` guard then raises the right TypeError. Result: language/expressions/new 11/30 → 16/30. Object 30/30 holds. conformance.sh: 148/148.
-
-- 2026-05-09 — **`bind` returns a dict-with-`__callable__` so bound functions are mutable + carry spec metadata.** Was returning a bare `(fn ...)` lambda — `obj.property = 12` on the bound result silently no-op'd because `js-set-prop` on a lambda only handles the `"prototype"` key. Now bind returns `{:__callable__ <closure> :length <target.length - bound.length, clamped at 0> :name "bound" :__js_bound_target__ recv}`. Notably skipped the `"bound " + target.name` style — for dict constructors (`Number`, `String`) `js-extract-fn-name` calls `inspect` which walks the entire prototype chain and is pathologically slow on those huge dicts (timed out 6 tests). Result: built-ins/Function/prototype/bind 22/30 → 24/30, Function/prototype 19/30 maintained. Object 30/30, Array 18/30 unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Function.prototype.call` / `apply` box primitive `thisArg` per non-strict ToObject.** Per spec, in non-strict mode the called function receives `ToObject(thisArg)` as `this` — so `f.call(1)` should see a `Number(1)` wrapper, not the raw primitive. We were passing primitives through unchanged, so `this.touched = true` inside the function silently no-op'd (`js-set-prop` on a number returns val unchanged). Extracted a `js-coerce-this-arg` helper that does the spec coercion: undefined/null → globalThis, number/rational → `new Number(v)`, string → `new String(v)`, boolean → `new Boolean(v)`, else as-is. Result: built-ins/Function/prototype/call 19/30 → 23/30, apply 22/30 → 25/30. bind 22/30, Object 30/30 unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Function.prototype.bind` throws TypeError when target isn't callable.** Per spec step 2 of `bind`, if the target (the receiver) isn't callable, throw TypeError. We were happily building a `(fn (&rest more) ...)` closure that would later fail to call — long after the bind() invocation. Added a `(not (js-function? recv))` guard at the top of the bind branch in `js-invoke-function-method` that raises a `TypeError` instance via `js-new-call`. Now `Function.prototype.bind.call(undefined)` etc. throw at the bind call site. Result: built-ins/Function/prototype/bind 14/30 → 22/30 (+8), call 18/30 → 19/30. Object 30/30. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Function.prototype.{call, apply, bind}` carry their spec lengths and names.** Per spec, `Function.prototype.call.length === 1`, `apply.length === 2`, `bind.length === 1`. We were storing them as bare lambdas with `&rest args`, so `js-fn-length` fell back to the param-counting path which yielded 0. Wrapped each in the dict-with-`__callable__` pattern with explicit `length` and `name` slots; `toString` got `length: 0`. Result: built-ins/Function/prototype/apply 18/30 → 22/30, call 17/30 → 18/30. bind 14/30 holds (its remaining failures are deeper bind semantics — bound length, target check). Object 30/30. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Function.prototype.{call, apply, bind, toString}` delegate to the real implementation when invoked through the proto chain.** Was: stub functions returning `:js-undefined` / a no-op closure. So `Number.bind(null)` resolved through `Number.__proto__ === Function.prototype` to the stub bind, which returned `(fn () :js-undefined)` instead of an actual bound function. Replaced each stub with `(fn (&rest args) (js-invoke-function-method (js-this) "<name>" args))`, so the prototype methods route to the same implementation that `js-invoke-method` uses when calling on a lambda directly. Now `Number.bind(null)(42) === 42`. Result: built-ins/Function/prototype/bind 9/30 → 14/30, call 12/30 → 17/30, apply 16/30 → 18/30. Object 30/30 holds. conformance.sh: 148/148.
-
-- 2026-05-09 — **Functions inherit through their `__proto__` chain in `js-dict-get-walk`; `fn.prototype = X` actually persists.** Two related fixes around the function-as-object semantics: (1) `js-dict-get-walk` was returning undefined the moment it hit any non-dict in the proto chain — but the chain often runs through a function (e.g. `obj.__proto__ === proto` where `proto` is itself a function returned by `Function()`). Now treats lambda/function/component as if they have `__proto__ === Function.prototype` and continues the walk. (2) `js-set-prop` was a no-op when called on a function with key `"prototype"` (returned val without storing) — so `FACTORY.prototype = proto` silently dropped on the floor. Now redirects to `__js_proto_table__` so the next `new FACTORY` picks up the right proto. Result: built-ins/Function/prototype/call 7/30 → 12/30, apply 12/30 → 16/30. Object 30/30, Map 18/30, Array 18/30 unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Function.prototype.call` / `apply` substitute global as `this` when caller passes null/undefined.** Per non-strict ES, `f.apply(null)` and `f.call(undefined)` should bind `this` to the global object inside `f`. We were passing `null`/`undefined` straight through to `js-call-with-this`, so `this.field = "green"` (the test pattern) silently failed because the function's `this` was still undefined and `this.field` did nothing. Updated both clauses in `js-invoke-function-method` to swap in `js-global-this` when the caller's `this`-arg is null or `:js-undefined`. Result: built-ins/Function/prototype 4/30 → 11/30 (+7), apply 0+ → 12/30, call 0+ → 7/30. Object 30/30 holds. conformance.sh: 148/148.
-
-- 2026-05-09 — **`js-global` exposes more built-in constructors and helpers.** Was missing `Function` (so `typeof this.Function === "undefined"`), the seven Error subclasses, the URI helpers, `eval`, `Promise`, and stubs for `Symbol` / `AggregateError` / `SuppressedError`. Added all of them. Did NOT add `globalThis` as a self-reference — that creates a cycle which makes `inspect` (used by `js-ctor-id`) hang on every error path that tries to format a constructor identity. Result: built-ins/global 19/29 → 22/27. Object 30/30, property-accessors 14/21 unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **Top-level expression statements support the comma operator.** Was using `jp-parse-assignment` for the expression in `jp-parse-stmt`'s fallback branch, so `false, true;` raised "Unexpected token: punct ','". Switched to `jp-parse-comma-seq`, which already returns either a plain assignment (no comma seen) or a `js-comma` AST. Per spec, ExpressionStatement → Expression, and Expression includes the comma operator. Result: language/expressions/comma 1/5 → 3/5, language/statements 22/30 → 23/30. Object/Array/Map unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`instanceof` accepts function operands.** `js-instanceof` was returning false on the very first check `(not (= (type-of obj) "dict"))` for any non-dict left-hand side — but functions are objects too, so `MyFunct instanceof Function` should be true (functions inherit from `Function.prototype`) and `MyFunct instanceof Object` likewise. Added a `js-function?` arm that special-cases against `Function.prototype` and `Object.prototype`, and falls through to the proto-walk if the function happens to also have a `__proto__` slot (dict-with-`__callable__` constructors do). Result: language/expressions/instanceof 20/30 → 24/30. Object 30/30, Error 22/30, Function 4/30 unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **Relational operators ToPrimitive their operands (string-vs-numeric decision); `<= / >=` short-circuit to false on NaN.** `js-lt` was checking only `(type-of)` for `"string"` to pick the string-compare branch, so `{} < function(){return 1}` fell into `(< NaN NaN)` (returning false) while `{}.toString() < fn.toString()` returned true (lex). Reused `js-add-unwrap` (now extended to coerce lambda/function/component to their `js-to-string` representation, matching the function's `[object Function]` / `function () { [native code] }` semantics) so both operands are first reduced to primitives. Added explicit NaN check in the numeric branch of `js-lt` and `js-le`. `js-le` no longer does `(not (js-lt b a))` — that gave the wrong answer on NaN (NaN ≤ x must be false, not !(x < NaN) = true). `js-ge` similarly switched to `(js-le b a)`. Result: language/expressions/less-than 23/30 → 24/30, greater-than 23/30 → 24/30, addition 24/30 → 25/30. Object 30/30 maintained. conformance.sh: 148/148.
-
-- 2026-05-09 — **`Error(msg)` / `TypeError(msg)` / etc. (called without `new`) now return a proper instance.** Was checking `(if (= (type-of this) "dict") <init> nil)` and falling through to return undefined when called as a plain function — but per spec, every Error subclass must return a new instance regardless of `new`. Refactored each constructor to `(js-error-init! (js-error-receiver Ctor) "Name" args)`: `js-error-receiver` returns `this` if it's a dict (the `new`-call case) and otherwise re-enters via `js-new-call ctor (list)` to create a properly-prototyped instance; `js-error-init!` sets `message`, `name`, `__js_error_data__`. Cleaner than the seven near-identical duplicated bodies. Result: built-ins/Error 17/30 → 22/30 (+5), language/expressions/instanceof 18/30 → 20/30. NativeErrors holds at 27/30. conformance.sh: 148/148.
-
-- 2026-05-09 — **`typeof <undeclaredIdent>` returns `"undefined"` instead of throwing ReferenceError.** Per JS spec, `typeof` on an unresolvable Reference is special-cased — it must return `"undefined"` without throwing. We were transpiling `typeof X` to `(js-typeof <symbol-X>)`, and the symbol lookup itself errored for undeclared globals. New transpiler branch in `js-transpile-unop`: when the operand is a `js-ident`, emit `(if (or (env-has? (current-env) "name") (dict-has? js-global "name")) (js-typeof <name>) "undefined")` — checks both the lexical env (for local var/let/const/parameters) and the global object, and only references the symbol when the if branch is taken (SX `if` is lazy, so the unbound symbol in the false branch never errors). Result: language/expressions/typeof 9/13 → 10/13, built-ins/Object 29/30 → 30/30 (full pass — the `S15.2.1.1_A2_T11.js` test was using `typeof obj` on an undeclared name). conformance.sh: 148/148.
-
-- 2026-05-09 — **`==` returns false when either side is NaN, even across the numeric/string paths.** `js-loose-eq` was converting both sides to numbers (`Number.NaN == "string"` → `NaN == NaN`) and using SX `(=)`, which apparently returns true when both NaN values are the same reference. Per JS, NaN compares unequal to everything including itself. Wrapped both cross-type numeric/string branches in `(or (js-number-is-nan an) (js-number-is-nan bn))` short-circuits to false. Result: language/expressions/equals 20/30 → 23/30. strict-equals/Number/Object unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **Lexer: `}` ends the regex context, like `)` and `]`.** Was treating `/` after `}` as the start of a regex literal, so `({}) / function(){return 1}` lexed `} / function(){...})` as `}` + regex `/ function(){return 1}/`. Per JS, after `}` of an object literal we're in expression-end position and `/` is division. The "block vs object" distinction is context-sensitive, but in practice expression-position `}` is the common case and there is no statement/block hazard for our parser since blocks at expression position don't typically have a following `/`. Single-char addition to the no-regex-context check. Result: language/expressions/division 25/30 → 26/30. asi/Map/Object unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`js-to-number` of functions/lists returns NaN / sensible coercion (was 0).** `js-to-number` had no clauses for `lambda`/`function`/`component`/`list` types, so they fell into the `(else 0)` arm. Per spec: ToNumber of any function is NaN, and ToNumber of an Array goes through ToPrimitive which calls `Array.prototype.toString` (the comma-join), so `[]` → "" → 0, `[5]` → "5" → 5, and `[1,2]` → "1,2" → NaN. Added explicit lambda/function/component clauses (return NaN) and a list clause (length 0 → 0, length 1 → recurse, else NaN). Now `function(){return 1} - function(){return 1}` is NaN instead of 0. Result: language/expressions/subtraction 25/30 → 26/30; multiplication 90%, division 83% confirmed unchanged-or-better. Object/Array/Number unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`+` operator now ToPrimitive's plain Objects + Dates via `valueOf`/`toString`.** Followup to the wrapper-unwrap fix. `js-add-unwrap` only handled `__js_string_value__` / `__js_number_value__` / `__js_boolean_value__` markers — for plain `{}` or `new Date()`, it returned the dict as-is, which then fell into `js-to-number` and produced `NaN`. Added two helpers: `js-add-toprim-default` calls `valueOf()` first (the "default" hint, used by `+`), and falls back to `toString()` if valueOf returns an object; for Date instances (`__js_is_date__` marker) we go straight to `toString` per spec. `js-add-call-method` walks the proto chain via `js-dict-get-walk`, calls the method with the receiver bound, and gives up if the slot is missing or not callable. Now `date + date === date.toString() + date.toString()`. Result: language/expressions/addition 23/30 → 24/30. Object/Array unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`+` operator unwraps Number/String/Boolean wrapper objects before deciding string-vs-numeric.** `js-add` was only checking `(type-of a)` / `(type-of b)` for `"string"` to decide string concat — but a `new String("1")` instance is type `"dict"`, so `new String("1") + "1"` was falling into the numeric branch and producing `2` instead of `"11"`. Added `js-add-unwrap` (mirrors ToPrimitive for the wrapper cases): if a dict has `__js_string_value__` / `__js_number_value__` / `__js_boolean_value__`, return the inner primitive. Then `js-add` applies the string-concat-vs-numeric decision to the unwrapped values. Result: language/expressions/addition 19/30 → 23/30. String stays 30/30. Number/Object unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **Rational handling in `js-typeof` / `js-to-string` / `js-strict-eq` / `js-loose-eq` / `Object.prototype.toString`.** Followup to the `js-to-number` fix. SX rationals were leaking into other paths: `typeof 1/2` returned `"object"` (should be `"number"`), `String(1/2)` fell into the dict branch and returned `"[object Object]"`, and `1/2 === 0.5` was false because strict-eq compared types and `"rational"` ≠ `"number"`. Added rational arms to `js-typeof` and `js-object-tostring-class`, normalised rationals via `(exact->inexact)` in `js-to-string`'s number branch, and introduced a `js-numeric-type?` / `js-numeric-norm` pair that lets strict-eq and loose-eq treat both numeric kinds uniformly. Result: language/expressions/strict-equals 16/22 → 19/22; Math 30/30 confirmed (no regression — but it never had one). Object/Array/Map unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`js-to-number` now coerces SX rationals via `exact->inexact`.** SX `(/ 59 16)` returns the rational `59/16` with `(type-of)` `"rational"` — not `"number"` — so `js-to-number` was falling through to the dict branch and ultimately returning `0`. That broke any path that did integer-divide intermediate math (e.g. `js-hex-2` for percent-encoding: `(js-math-trunc (/ 59 16))` was returning 0, so `encodeURIComponent(";")` produced `"%0B"` instead of `"%3B"`). Added a `((= (type-of v) "rational") (exact->inexact v))` clause in `js-to-number` between the existing `"number"` and `"string"` branches. Result: built-ins/encodeURIComponent 9/30 → 15/30, built-ins/encodeURI 22/60 → 28/60, built-ins/decodeURI 11/60 → 20/60. Object/Array unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`parseFloat("+")` / `parseFloat("-")` / `parseFloat(".")` return NaN (were returning 0).** `js-float-prefix-end` happily consumed leading `+`/`-` and dot characters even with no digits — and `js-parse-num-safe` of those characters returned 0. Per spec, the prefix must contain at least one digit. Added a `js-str-has-digit?` walker called between `js-float-prefix-end` and `js-parse-num-safe`; if no digit is present in the consumed slice, return NaN. Result: built-ins/parseFloat 20/30 → 23/30, built-ins/parseInt 22/30 → 24/30. Number unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **`parseFloat` recognises `"Infinity"` / `"±Infinity"` prefixes (not just exact matches).** Per spec, parseFloat parses the longest StrDecimalLiteral prefix — `Infinity` is one — so `parseFloat("Infinity1")`, `parseFloat("Infinityx")`, `parseFloat("Infinity+1")` should all return `Infinity`. Was only matching `s === "Infinity"` / `"+Infinity"` / `"-Infinity"` exactly. Added `js-float-has-infinity-prefix?` helper and three new branches at the top of `js-parse-float-prefix`. Result: built-ins/parseFloat 17/30 → 20/30. conformance.sh: 148/148.
-
-- 2026-05-09 — **JS lexer rejects bare `\` in source (e.g. `{` outside an identifier-escape context).** Was silently advancing past unknown chars in the punctuator-fallback branch, so `{` became `\` (skipped) + ident `u007B`, and `((1))` parsed as something close to `(1)` after our SX-string layer pre-converted half of them. Now `(else (advance! 1))` is a `(error "Unexpected char '\\' in source")` for `\` specifically (other unknown chars still advance — keeps multi-byte UTF-8 idents working at the byte level). Result: language/punctuators 1/11 → 11/11 (full pass), language/literals 25/30 → 28/30, language/identifiers 11/30 → 13/30. Object/Map unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **Negative-test classifier maps `js-transpile-assign` and any `js-transpile-*` error to SyntaxError.** `language/types/boolean/S8.3_A2.{1,2}.js` (testing `true=1`/`false=0` reject) raises `js-transpile-assign: unsupported target` at our transpile pass — that's a parse-phase error in test262's sense (the source is structurally invalid before any runtime evaluation), but the runner's classifier didn't recognise the prefix and reported the test as failing. Added `js-transpile-assign` and the broader `js-transpile` prefix to the SyntaxError-mappable patterns in `classify_negative_result`. Result: language/types 26/30 → 28/30 (the two `true = 1` / `false = 0` tests). conformance.sh: 148/148.
-
-- 2026-05-09 — **`Object.getOwnPropertyDescriptor` now returns descriptors for arrays and strings, not just dicts.** Was: `(if (and (dict? o) ...) {...} :js-undefined)` — every list and string returned `undefined`. Extended: lists give `{value: arr[i], writable: true, enumerable: true, configurable: true}` for valid integer indices, plus `{value: arr.length, writable: true, enumerable: false, configurable: false}` for `"length"`. Strings give read-only descriptors for `"length"` and individual code units. The integer-index test reuses `js-int-key?` (added earlier for `__js_order__` integer-key sorting). Result: built-ins/Object/getOwnPropertyDescriptor 50/60 → 54/60, language/arguments-object 12/30 → 13/30. Array unchanged. conformance.sh: 148/148.
-
-- 2026-05-09 — **Fixed `RegExp.prototype.test/exec` calling `nil` as a function when no regex platform impl is registered.** `js-regex-invoke-method` was checking `(js-undefined? impl)` to decide whether to fall back to the stub — but `(get __js_regex_platform__ "test")` returns `nil` (not `:js-undefined`) when the key is absent, so the check was false and the next branch `(impl rx arg)` tried to call `nil`. The OCaml CEK reports this as `Not callable: <next-arg>` (showing the regex receiver in the error, which made the failure look like the regex itself wasn't callable). Changed both `test` and `exec` clauses to `(or (js-undefined? impl) (= impl nil))`. Now `RegExp("0").exec("1")` returns `null` (correctly, no match) instead of crashing. Result: language/literals 24/30 → 25/30. RegExp unchanged (still needs a real engine for the rest). conformance.sh: 148/148.
-
-- 2026-05-09 — **`RegExp` constructor exposed as a global.** Was undefined — every test in `built-ins/RegExp` died at `new RegExp(...)` with ReferenceError. The internals (`js-regex-new`, `js-regex?`, `js-regex-stub-test`, `js-regex-stub-exec`) already existed for regex literals; this iteration just wraps them as a JS-visible constructor with the dict-with-`__callable__` pattern. Constructor handles `new RegExp(/x/, "g")` (re-flags an existing regex), `new RegExp(pattern)` and `new RegExp(pattern, flags)`. Prototype methods: `test`, `exec`, `toString`, `compile` (matching the stub semantics — substring search with `i` flag honoured, no real regex engine). Added `RegExp` to `js-global` and the post-init `__proto__` chain. Result: built-ins/RegExp 0/30 → 1/30; the rest still need a real regex engine (or fail on character-class escapes / lookaheads / etc.). conformance.sh: 148/148.
-
-- 2026-05-08 — **`js-is-space?` recognises the full ES whitespace set** (was only ` \t\n\r`). `parseFloat("1.1")`, `parseFloat(" 1.1")`, etc. now strip leading whitespace correctly per spec. Added: form feed (12), vertical tab (11), NBSP (160), Ogham space mark (5760), the en/em-width run 8192–8202, line/paragraph separator (8232/8233), narrow no-break space (8239), medium math space (8287), ideographic space (12288), ZWNBSP/BOM (65279). Single helper used by every trim/whitespace path (`parseFloat`, `parseInt`, `String.prototype.trim*`, `js-string-to-number`, JSON parse-ws). Result: built-ins/parseFloat 15/30 → 17/30. String/Number/parseInt unchanged. conformance.sh: 148/148.
-
-- 2026-05-08 — **NativeError prototype chain wired: `Object.getPrototypeOf(EvalError) === Error`, `Error.prototype.constructor === Error`, `[object Error]` brand.** Three pieces: (1) `js-object-tostring-class` now recognises `__js_error_data__` (returns `"[object Error]"`), `__js_is_date__` (`"[object Date]"`), `__map_keys__` / `__set_items__` (`"[object Map]"` / `"[object Set]"`) — these were all falling through to `"[object Object]"`. (2) New `__js_ctor_proto__` side-table maps lambda-ctor identity → its [[Prototype]] constructor; `js-object-get-prototype-of` consults it for non-dict callables. Populated for all six native error subclasses (TypeError/RangeError/SyntaxError/ReferenceError/URIError/EvalError) → Error. (3) Each subclass's `prototype.__proto__` set to `Error.prototype`, and `Error.prototype` gets `name`, `message`, `constructor` populated; each subclass prototype also gets its own `name` and `constructor`. Result: built-ins/NativeErrors 14/30 → 27/30 (+13), built-ins/Error 11/30 → 17/30 (+6). Object/Map/Array unchanged. conformance.sh: 148/148.
-
-- 2026-05-08 — **Object literals get `__proto__: Object.prototype`; try/catch wraps SX error strings into JS Error instances.** Two fixes that work together: (1) `js-make-obj` now sets `__proto__` to `(get Object "prototype")` on every plain object literal `{}` — was missing, so `({}) instanceof Object` was `false`. (2) `js-transpile-try` now wraps the catch param via `js-wrap-exn` — when SX throws an `Eval_error("TypeError: ...")` / `("RangeError: ...")` / `("SyntaxError: ...")` etc. into the catch body, the user previously got a plain string. Now each prefix dispatches to the matching `js-new-call` so `e instanceof TypeError` etc. is truthy. Note: `Eval_error("Undefined symbol: y")` is NOT caught by SX `guard` at all, so the `1 + y → ReferenceError` shape remains unfixable from JS land — out of scope (would need OCaml-side change to make symbol lookup raisable). Result: language/expressions/instanceof 13/30 → 18/30 (+5). Object/Map/Array unchanged. conformance.sh: 148/148.
-
-- 2026-05-08 — **`Date` constructor + prototype stubs.** `Date` was undefined globally — every test in `built-ins/Date` died at `new Date(...)` with ReferenceError. Implemented as a dict-with-`__callable__` (same pattern as `Map`/`Set`/`Object`). Constructor accepts 0 args (epoch 0), 1 number arg (ms), 1 string arg (parses leading `YYYY` to compute approx ms via `(year-1970)*31557600000`), or 2+ args (year, month, day → simple ms calc). `__date_value__` is the internal slot. Statics: `Date.now()`, `Date.parse(s)`, `Date.UTC(...)`. Prototype: `getTime` / `valueOf` / `setTime`, all `getX` / `getUTCX` (most return 0/1 — only `getFullYear` actually computes), `toISOString` / `toJSON` / `toString` / `toUTCString` produce `YYYY-01-01T00:00:00.000Z` from the stored year, plus the locale variants. Wired `Date` into `js-global` and the post-init `__proto__` chain. The maths is approximate (ignores leap years, varying month lengths, timezone offsets) — but the structural tests `typeof new Date(...) === "object"` and the basic flow now work. Result: built-ins/Date 0/30 → 3/30 (rest timeouts/assertions on month-rollover/leap-year math we don't model). conformance.sh: 148/148.
-
-- 2026-05-08 — **`Error.isError` static + `[[ErrorData]]` slot + `verifyEqualTo` harness helper.** Added `Error.isError(v)` per the Stage-3 proposal: returns `true` only for objects with the internal `[[ErrorData]]` slot. Implemented as `__js_error_data__: true` set on `this` by every Error subclass constructor (Error/TypeError/RangeError/SyntaxError/ReferenceError/URIError/EvalError); `js-error-is-error` walks `__proto__` looking for the marker. Wired through the lambda-static-prop path next to the existing `Promise.resolve` / `Promise.reject` lookup. Defined `AggregateError` and `SuppressedError` as `:js-undefined` so `typeof AggregateError !== 'undefined'` resolves cleanly (without these, the bare ident lookup throws ReferenceError). Added `verifyEqualTo` to the harness — `propertyHelper.js` includes it, used by `Error/message_property.js` etc. Result: built-ins/Error 6/30 → 11/30 (+5), Error/isError sub-suite 0/9 → 5/9. Map/Object unchanged. conformance.sh: 148/148.
-
-- 2026-05-08 — **Harness: `$DONE` / `asyncTest` and `checkSequence` / `checkSettledPromises` stubs added.** Async-flagged Promise tests call `$DONE(err?)` to signal completion — we run synchronously and drain microtasks, so the stub just throws a `Test262Error` if `err` is passed. `asyncTest(fn)` wraps the test fn in `Promise.resolve().then(..., $DONE)`. `checkSequence(arr, msg)` (from `promiseHelper.js`) verifies `arr[i] === i+1` — used by ordering tests on `Promise.all` / `Promise.race`. `checkSettledPromises(actual, expected, msg)` matches what `Promise.allSettled` tests expect. Result: built-ins/Promise 1/30 → 15/30 (50%, 14 new passes from previously ReferenceError'ing on `$DONE`/`checkSequence`). conformance.sh: 148/148.
-
-- 2026-05-08 — **`Map` and `Set` constructors with full instance API.** Both were undefined globally — every test in those categories died at `new Map()` / `new Set()` with ReferenceError. Implemented as plain SX storage on the instance dict (`__map_keys__` + `__map_vals__` parallel lists for Map, `__set_items__` for Set) using SX `=` for key/value comparisons. Wired prototype methods: `.get`, `.set`, `.has`, `.delete`, `.clear`, `.forEach`, `.keys`, `.values`, `.entries` for Map; `.add`, `.has`, `.delete`, `.clear`, `.forEach`, `.keys`, `.values`, `.entries` for Set. `.size` is a real own property updated on every mutation (no getters). Constructors use the dict-with-`__callable__` pattern (like `Object`) so `Map.length`, `Map.name`, `Map.prototype` work as regular dict reads. Constructor accepts an iterable of `[k,v]` pairs (Map) or values (Set). Added `Map`/`Set` to `js-global` and to the prototype-chain post-init block. Result: built-ins/Map 1/30 → 18/30 (60%), built-ins/Set 0/30 → 15/30 (50%, rest mostly timeouts on iterator-protocol tests). conformance.sh: 148/148.
-
-- 2026-05-08 — **`decodeURI` / `decodeURIComponent` actually decode (and throw URIError on malformed input); harness `decimalToHexString` helper added.** Both were `(fn (v) (js-to-string v))` — passthrough stubs. Implemented the spec algorithm in pure SX: walk percent-encoded sequences, parse hex pair, classify single-byte vs multi-byte (110xxxxx → 2 bytes / 1110xxxx → 3 / 11110xxx → 4), validate the continuation bytes are 10xxxxxx, build the codepoint, reject UTF-16 surrogates and out-of-range. `decodeURI` keeps reserved bytes (`;/?:@&=+$,#`) as literal `%XX`. Malformed sequences throw `URIError` via existing constructor. Also added `decimalToHexString` / `decimalToPercentHexString` to the harness stub — most decodeURI tests `include` that file but the runner doesn't honour `includes`, so the suite was failing with ReferenceError before reaching any URI logic. Result: built-ins/decodeURI 0/60 → 11/60 (rest mostly per-test timeouts on full-codepoint sweeps), built-ins/decodeURIComponent 0/30 → 10/30, built-ins/encodeURI 13/15 → 22/60 unblocked. conformance.sh: 148/148.
-
-- 2026-05-08 — **Object literals: computed keys `[expr]: val`, insertion-order tracking, integer-key-first ordering for `getOwnPropertyNames`.** Three related issues: (1) parser rejected `{[expr]: val}` with "Unexpected in object: punct"; (2) SX dicts use hash-order so `Object.getOwnPropertyNames` returned keys in non-insertion order; (3) `var list = {...}` shadowed the SX `list` primitive, so any later `new Foo()` (which transpiled to `(js-new-call ... (list ...))`) crashed with "Not callable: <dict>". Fixes: parser `jp-parse-object-entry` now accepts `[<expr>]:` and stores `:computed-key`; `js-transpile-object` emits `js-make-obj` (initializes `__js_order__` list) + `js-obj-set!` (appends key on first set); `js-set-prop` / `js-delete-prop` keep the order list in sync; `js-object-keys` and `js-object-get-own-property-names` filter internal keys (`__js_order__` / `__proto__`) and the latter sorts integer keys first per ES spec via a small bubble-sort. Replaced `(list ...)` emissions for `js-new-call` args and array literals with `(js-args ...)` and `(js-make-list ...)` (closure-captured) — the latter remains mutable. Fixes 0/2 → 2/2 on `language/computed-property-names/basics`, +3 on built-ins/Array (Array.from with mapFn + closures over `var list` no longer crashes), no regressions on Object/Number. conformance.sh: 148/148.
-
-- 2026-05-08 — **Bitwise ops `& | ^ << >>` (+ compound assigns) now transpile and evaluate.** Previously the transpiler raised `unsupported op: &/>>/<<` for any source using them, and the punctuator suite (0/11) plus a wider scatter of Number/expression tests bombed on first reference. Added pure-SX runtime helpers: `js-to-uint32` / `js-to-int32` / `js-uint32-to-int32` for ToUint32/ToInt32 coercion; `js-bitwise-loop` that walks all 32 bit positions emitting `and`/`or`/`xor` (no native bit primitive available); `js-bitand` / `js-bitor` / `js-bitxor` and `js-shl` / `js-shr` (shr uses `floor(ai / 2^sh)` which is correct for signed values). Wired `<<`, `>>`, `&`, `|`, `^` into `js-transpile-binop`, and the corresponding `<<=`, `>>=`, `>>>=`, `&=`, `|=`, `^=` into `js-compound-update`. Lexer + parser already produced the tokens with correct precedence. language/punctuators: 0/11 → 1/11 (the remaining 10 are negative tests for `\u`-escaped punctuator rejection). Also unblocks the 8x `&`, 2x `>>`, 1x `<<` "unsupported op" failures from the prior broad sweep. conformance.sh: 148/148.
-
-- 2026-05-08 — **`Function(arg1, arg2, ..., body)` constructor compiles + evaluates JS source.** Was unconditionally throwing `"TypeError: Function constructor not supported"`. Now `js-function-ctor` joins the param strings with commas, wraps the body in `(function(<params>){<body>})`, and runs it through `js-eval`. Side helpers (`js-fn-args-to-strs`, `js-fn-take-init`, `js-fn-take-last`, `js-fn-join-commas`) keep the implementation self-contained and use existing primitives. Now `Function('a', 'b', 'return a + b')(3,4) === 7`. built-ins/Function: 0/14 → 4/14. conformance.sh: 148/148.
-
-- 2026-05-08 — **`arguments` object inside JS functions; `Array.from` calls mapFn correctly.** Three related fixes: (1) Every JS function body now binds `arguments` to `(cons p1 (cons p2 ... __extra_args__))` — a list of all received args, declared and rest. (2) `Array.from(iter, mapFn)` now invokes mapFn through `js-call-with-this` with the index as second arg (was `(map-fn x)` direct, missing index and inheriting outer `this`). (3) Defaults the `thisArg` to `js-global-this` when caller didn't pass one (per non-strict ES). Now `function f() { return arguments[1]; } f(1, 2)` returns 2; `Array.from([1,2,3], (v, i) => v + i*100)` returns `[1, 102, 203]`. conformance.sh: 148/148.
-
-- 2026-05-08 — **`String(arr)` consults `Array.prototype.toString` (not the hardcoded join).** Was always emitting the comma-joined elements via `js-list-join`, so user-visible mutations of `Array.prototype.toString` had no effect on `String(arr)` / `"" + arr`. Now look up the override via `js-dict-get-walk` and call it on the list as `this`; fall back to `(js-list-join v ",")` when the override doesn't return a string. Default behaviour preserved (Array.prototype.toString already calls `js-list-join`). built-ins/String fail count: 11 → 9. conformance.sh: 148/148.
-
-- 2026-05-08 — **Top-level `this` resolves to the global object.** Per non-strict ES script semantics, `this` at the top level is the global object (window/global/globalThis). Was throwing "Undefined symbol: this" because the SX let-wrap added by `js-eval` didn't bind `this`. Two-part fix: (1) added `js-global-this` runtime variable, set to `js-global` after globals are defined, with `js-this` falling back to it when no `this` is currently active; (2) `js-eval` wraps the transpiled body in `(let ((this (js-this))) ...)` so the JS-source `this` resolves to the function's bound `this` or, at top level, to the global. Fixes `String(this)`, `this.Object === Object`, etc. built-ins/Object: 46/50 → 47/50. conformance.sh: 148/148.
-
-- 2026-05-08 — **Comma operator `(a, b, c)` parses and evaluates left-to-right, returning last.** Was failing with `Expected punct ')' got punct ','` because `jp-try-arrow-or-paren` only consumed a single assignment expression. Added `jp-parse-comma-seq` / `jp-parse-comma-seq-rest` helpers that build a `js-comma` AST node with the list of expressions; the transpiler emits `(begin ...)` which evaluates each in order and returns the last. Fixes `Object((null,2,3),1,2)`-style tests. built-ins/Object: 44/50 → 46/50. conformance.sh: 148/148.
-
-- 2026-05-08 — **ToPrimitive treats functions as non-primitive in `js-to-string` / `js-to-number`.** Per ES, ToPrimitive only accepts strings/numbers/booleans/null/undefined as primitives — objects AND functions must trigger the next conversion step. Was treating function returns from toString/valueOf as primitives (recursing to extract a string), so a `toString` returning a function wouldn't fall through to `valueOf`. Widened the dict-only check to `(or (= type "dict") (js-function? result))` in both ToPrimitive paths. Now `var o = {toString: () => function(){}, valueOf: () => { throw 'x' }}; new String(o)` propagates `'x'` from valueOf. built-ins/String: 85/99 → 86/99. conformance.sh: 148/148.
-
-- 2026-05-08 — **`fn.toString()` and `String(fn)` honour `Function.prototype.toString` overrides.** Two hardcoded paths returned `"function () { [native code] }"` regardless of any user override: the function-method dispatch in `js-invoke-function-method`, and the lambda branch of `js-to-string`. Both now look up `Function.prototype.toString` via `js-dict-get-walk` and invoke it on the function (`recv`/`v`) when available, falling back to the native marker only if no override exists. Now `Function.prototype.toString = ...; (function(){}).toString()` returns the override, and `new String(fn)` stores the override result. built-ins/String: 84/99 → 85/99. conformance.sh: 148/148.
-
-- 2026-05-08 — **Native prototypes carry the wrapped primitive marker.** Per ES, `Boolean.prototype` is a Boolean wrapper around `false`, `Number.prototype` wraps `0`, `String.prototype` wraps `""`. So `Boolean.prototype == false` (loose-eq unwraps), `Object.prototype.toString.call(Number.prototype) === "[object Number]"`, etc. Set `__js_boolean_value__: false` / `__js_number_value__: 0` / `__js_string_value__: ""` on the respective prototypes in the post-init block. built-ins/Boolean: 23/27 → 24/27, String: 80/99 → 84/99. conformance.sh: 148/148.
-
-- 2026-05-08 — **`js-to-number` throws TypeError when valueOf+toString both return non-primitive.** Mirrors the earlier `js-to-string` fix. Per spec, `Number(obj)` must throw if `ToPrimitive` cannot extract a primitive. Was returning `NaN` silently. Replaced the inner `(js-nan-value)` fallback with `(raise (js-new-call TypeError ...))`. built-ins/Number: 45/50 → 46/50. conformance.sh: 148/148.
-
-- 2026-05-08 — **`Array.prototype` / `Number.prototype` / etc. inherit from `Object.prototype`.** Per ES, every native prototype's `[[Prototype]]` is `Object.prototype` (and `Function.prototype.[[Prototype]]` is also `Object.prototype`). Was missing those `__proto__` links, so `Object.prototype.isPrototypeOf(Boolean.prototype)` returned false (the explicit isPrototypeOf walks `__proto__`, not the recent fallback). Added 5 `dict-set!` lines to the post-init block at the end of `runtime.sx`. built-ins/Boolean: 22/27 → 23/27, built-ins/Number: 44/50 → 45/50. conformance.sh: 148/148.
-
-- 2026-05-08 — **`delete obj.key` actually removes the key.** `js-delete-prop` was setting the value to `js-undefined` instead of removing the key, so subsequent `'key' in obj` returned true and proto-chain lookup didn't fall through to the parent. Switched to `dict-delete!` (existing SX primitive). Now `delete Boolean.prototype.toString; Boolean.prototype.toString()` correctly walks up to `Object.prototype.toString` and returns `"[object Boolean]"`. built-ins/Boolean: 21/27 → 22/27. conformance.sh: 148/148.
-
-- 2026-05-08 — **`Boolean(NaN) === false` (and `!NaN === true`).** `js-to-boolean` was returning `true` for NaN because NaN ≠ 0 by IEEE semantics, so the `(= v 0)` test fell through to the truthy-else clause. Per ES, NaN is one of the falsy values. Added a `(js-number-is-nan v)` clause. built-ins/Boolean: 19/27 → 21/27. conformance.sh: 148/148.
-
-- 2026-05-08 — **Global `eval(src)` actually evaluates the source.** Was returning the input string unchanged: `eval('1+2')` returned `"1+2"`, not `3`. Per spec, `eval(string)` parses and evaluates as JS; non-string input passes through. Wired the runtime stub through `js-eval` (which already does the lex/parse/transpile/eval pipeline) when the arg is a string. Fixes `String(eval('var x'))`, the harness internal `eval(...)`, and any test that calls `eval` for runtime evaluation. built-ins/String fail count: 13 → 11. conformance.sh: 148/148.
-
-- 2026-05-08 — **`new <non-callable>` throws TypeError instead of hanging.** `new (new Object(""))` (calling `new` on a String wrapper dict) hung because `js-new-call` called `js-get-ctor-proto` which fell through to `js-ctor-id` which called `inspect ctor` — and `inspect` on a wrapper-with-proto-chain recurses through the prototype's lambdas forever. Added a `(js-function? ctor)` precheck at the top of `js-new-call`: when the receiver isn't callable, raise a `TypeError` instance instead. Now `try { new x } catch(e) { e instanceof TypeError }` returns `true` for non-callable `x`. conformance.sh: 148/148. String 80/99, Array 23/45 maintained.
-
-- 2026-05-08 — **JS functions accept extra args silently (per spec).** SX strictly arity-checks: `(fn (a) ...)` rejects 2 args, but JS allows passing more args than declared (the extras are accessible via `arguments`). Was raising `f expects 1 args, got 2` whenever Array.from passed `(value, index)` to a 1-arg mapFn, etc. Fixed in `js-build-param-list` (transpile.sx): every JS function param list now ends with `&rest __extra_args__` (unless an explicit rest param is already present), so extras are silently absorbed. Headline scoreboards unchanged but unblocks a class of harness-mediated failures. conformance.sh: 148/148.
-
-- 2026-05-08 — **Lowered array padding bail-out from 2^32-1 to 1M.** Yesterday's 2^32-1 threshold still allowed indices like `2147483648` to pad billions of `js-undefined` entries, hanging the worker. Without sparse-array support there's no semantic value in supporting >1M sparse padding; lowering the bail to 1M turns those tests into fast assertion failures instead of timeouts. Removes another timeout (Array 7→1). built-ins/Array stays at 23/45, but the run is faster and no longer wall-time-bound. conformance.sh: 148/148.
-
-- 2026-05-08 — **Out-of-range array indices and lengths no longer hang.** `arr[4294967295] = 'x'` and `arr.length = 4294967295` were padding the SX list with `js-undefined` for ~4 billion entries — guaranteed timeout. Per ES spec, indices ≥ 2^32-1 aren't array indices (they're regular properties, which we can't store on a list). Added a `(>= i 4294967295)` bail-out clause to both `js-list-set!` (numeric index path) and the `length` setter; both now no-op at that bound. Removed 5 of the 7 Array timeouts. built-ins/Array: 21/45 → 23/45. conformance.sh: 148/148.
-
-- 2026-05-08 — **Built-in `.length` returns spec-defined values for variadic functions.** `String.fromCharCode.length`, `Math.max.length`, `Array.from.length` were all returning `0` because the underlying SX lambdas use `&rest args` with no required params — but the spec assigns each built-in a specific length (`fromCharCode === 1`, `max === 2`, etc.). Added `js-builtin-fn-length` that maps the unmapped JS name to its spec length (12 entries covering fromCharCode, fromCodePoint, raw, of, from, isArray, max, min, hypot, atan2, imul, pow). `js-fn-length` consults this table first and falls back to counting real params. built-ins/String: 79/99 → 80/99, built-ins/Array: 20/45 → 21/45. conformance.sh: 148/148.
-
-- 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.