jz 0.4.0 → 0.5.0

package/module/json.js

@@ -8,9 +8,9 @@
  * @module json
  */
 
-import { typed, asF64, asI64, temp, tempI32, nullExpr, allocPtr, slotAddr, mkPtrIR, extractF64Bits, appendStaticSlots, NULL_WAT } from '../src/ir.js'
-import { emit } from '../src/emit.js'
-import { T } from '../src/analyze.js'
+import { typed, asF64, asI64, temp, tempI32, nullExpr, undefExpr, allocPtr, slotAddr, mkPtrIR, extractF64Bits, appendStaticSlots, NULL_WAT, UNDEF_NAN, UNDEF_WAT } from '../src/ir.js'
+import { emit, emitBoolStr } from '../src/emit.js'
+import { T, valTypeOf, VAL } from '../src/analyze.js'
 import { err, inc, PTR, LAYOUT } from '../src/ctx.js'
 import { strHashLiteral } from './collection.js'
 
@@ -21,6 +21,43 @@ function jsonConstString(ctx, expr) {
   return null
 }
 
+// Sentinel distinct from any JS value `JSON.stringify` could hold (`undefined`
+// is a legitimate literal — an array hole or a bare `undefined`).
+const NOT_LIT = Symbol('not-literal')
+
+// Evaluate a prepared AST node to its constant JS value, or NOT_LIT if any
+// part is dynamic. Mirrors the literal grammar prepare produces: `[null, v]`
+// for primitives, `['str', s]`, `['[' …]` arrays, `['{}' …]` objects.
+function literalValue(node) {
+  if (node === undefined) return undefined            // array hole
+  if (!Array.isArray(node)) return NOT_LIT
+  const op = node[0]
+  if (op == null) return node[1]                      // number | string | bool | null | undefined
+  if (op === 'str') return node[1]
+  if (op === 'u-') { const v = literalValue(node[1]); return v === NOT_LIT ? NOT_LIT : -v }
+  if (op === '[') {
+    const arr = []
+    for (let i = 1; i < node.length; i++) {
+      const v = literalValue(node[i])
+      if (v === NOT_LIT) return NOT_LIT
+      arr.push(v)
+    }
+    return arr
+  }
+  if (op === '{}') {
+    const obj = {}
+    for (let i = 1; i < node.length; i++) {
+      const e = node[i]
+      if (!Array.isArray(e) || e[0] !== ':' || (typeof e[1] !== 'string' && typeof e[1] !== 'number')) return NOT_LIT
+      const v = literalValue(e[2])
+      if (v === NOT_LIT) return NOT_LIT
+      obj[e[1]] = v
+    }
+    return obj
+  }
+  return NOT_LIT
+}
+
 function jsonShapeString(ctx, expr) {
   if (typeof expr === 'string') return ctx.scope.shapeStrs?.get(expr) ?? null
   return null
@@ -42,15 +79,19 @@ function hashCapFor(n) {
 
 export default (ctx) => {
   Object.assign(ctx.core.stdlibDeps, {
-    __stringify: ['__json_val', '__jput', '__jput_str', '__jput_num', '__mkstr'],
-    __json_val: ['__ptr_type', '__len', '__ptr_offset', '__jput', '__jput_num', '__jput_str', '__json_hash', '__json_obj'],
-    __json_hash: ['__ptr_offset', '__jput', '__jput_str', '__json_val'],
-    __json_obj: ['__ptr_offset', '__ptr_aux', '__len', '__jput', '__jput_str', '__json_val'],
+    __stringify: ['__json_val', '__json_setgap', '__json_omit', '__jput', '__jput_str', '__jput_num', '__mkstr'],
+    __json_setgap: ['__alloc', '__ptr_type', '__str_byteLen', '__char_at'],
+    __json_omit: ['__ptr_type'],
+    __json_enter: ['__alloc'],
+    __jindent: ['__jput'],
+    __json_val: ['__ptr_type', '__len', '__ptr_offset', '__jput', '__jindent', '__jput_num', '__jput_str', '__json_enter', '__json_leave', '__json_hash', '__json_obj'],
+    __json_hash: ['__ptr_offset', '__jput', '__jindent', '__jput_str', '__json_omit', '__json_enter', '__json_leave', '__json_val'],
+    __json_obj: ['__ptr_offset', '__ptr_aux', '__len', '__jput', '__jindent', '__jput_str', '__json_omit', '__json_enter', '__json_leave', '__json_val'],
     __jput_num: ['__ftoa'],
     __jput_str: ['__char_at', '__str_byteLen'],
     __jp: ['__jp_val', '__jp_str', '__jp_num', '__jp_arr', '__jp_obj', '__sso_char', '__ptr_aux', '__ptr_type', '__ptr_offset', '__str_byteLen'],
     __jp_val: ['__jp_str', '__jp_num', '__jp_arr', '__jp_obj'],
-    __jp_str: ['__sso_char', '__char_at', '__str_byteLen', '__hex4', '__utf8_enc'],
+    __jp_str: ['__sso_char', '__char_at', '__str_byteLen', '__hex4', '__ishex', '__utf8_enc'],
     __hex4: ['__hex1'],
     __jp_num: ['__pow10'],
     __jp_arr: ['__jp_val'],
@@ -87,15 +128,15 @@ export default (ctx) => {
       const keys = Object.keys(v)
       // Empty object: minimal OBJECT with no slots.
       if (keys.length === 0) {
-        return mkPtrIR(PTR.OBJECT, 0, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', 1]])
+        return mkPtrIR(PTR.OBJECT, 0, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', ctx.abi.object.ops.allocSlots(0)]])
       }
       const schemaId = ctx.schema.register(keys)
       const t = tempI32('jobj')
       const body = [
-        ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', keys.length]]],
+        ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', ctx.abi.object.ops.allocSlots(keys.length)]]],
       ]
       for (let i = 0; i < keys.length; i++) {
-        body.push(['f64.store', slotAddr(t, i), asF64(emitJsonConstValue(v[keys[i]]))])
+        body.push(ctx.abi.object.ops.store(['local.get', `$${t}`], i, asF64(emitJsonConstValue(v[keys[i]]))))
       }
       body.push(mkPtrIR(PTR.OBJECT, schemaId, ['local.get', `$${t}`]))
       return typed(['block', ['result', 'f64'], ...body], 'f64')
@@ -113,6 +154,19 @@ export default (ctx) => {
   ctx.scope.globals.set('__jpos', '(global $__jpos (mut i32) (i32.const 0))')
   ctx.scope.globals.set('__jcap', '(global $__jcap (mut i32) (i32.const 0))')
   ctx.scope.globals.set('__schema_tbl', '(global $__schema_tbl (mut i32) (i32.const 0))')
+  // Pretty-print state for the `space` argument. $__jgap points at the gap
+  // string bytes ($__jgaplen of them); $__jdepth is the live nesting depth.
+  // $__jgaplen == 0 ⇒ compact mode — every indent emission below is gated on
+  // it, so the no-space path stays byte-identical to the unindented output.
+  ctx.scope.globals.set('__jgap', '(global $__jgap (mut i32) (i32.const 0))')
+  ctx.scope.globals.set('__jgaplen', '(global $__jgaplen (mut i32) (i32.const 0))')
+  ctx.scope.globals.set('__jdepth', '(global $__jdepth (mut i32) (i32.const 0))')
+  // Cycle-detection stack: the i64 values of the containers currently open on
+  // the recursion path. JSON.stringify of a structure that points back at an
+  // ancestor must throw a TypeError. $__jstack is a lazily-allocated buffer of
+  // up to 256 entries; $__jsp is the live depth.
+  ctx.scope.globals.set('__jstack', '(global $__jstack (mut i32) (i32.const 0))')
+  ctx.scope.globals.set('__jsp', '(global $__jsp (mut i32) (i32.const 0))')
 
   // __jput(byte: i32) — append one byte to output buffer
   ctx.core.stdlib['__jput'] = `(func $__jput (param $b i32)
@@ -126,23 +180,88 @@ export default (ctx) => {
     (i32.store8 (i32.add (global.get $__jbuf) (global.get $__jpos)) (local.get $b))
     (global.set $__jpos (i32.add (global.get $__jpos) (i32.const 1))))`
 
-  // __jput_str(ptr: i64) — append string chars (without quotes) to buffer
+  // __jindent — emit a newline followed by $__jdepth copies of the gap string.
+  // No-op in compact mode ($__jgaplen == 0), so callers can invoke it
+  // unconditionally and the unindented output stays exactly as before.
+  ctx.core.stdlib['__jindent'] = `(func $__jindent
+    (local $i i32) (local $j i32)
+    (if (i32.eqz (global.get $__jgaplen)) (then (return)))
+    (call $__jput (i32.const 10))
+    (block $d (loop $l
+      (br_if $d (i32.ge_s (local.get $i) (global.get $__jdepth)))
+      (local.set $j (i32.const 0))
+      (block $d2 (loop $l2
+        (br_if $d2 (i32.ge_s (local.get $j) (global.get $__jgaplen)))
+        (call $__jput (i32.load8_u (i32.add (global.get $__jgap) (local.get $j))))
+        (local.set $j (i32.add (local.get $j) (i32.const 1)))
+        (br $l2)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $l))))`
+
+  // __json_setgap(space: i64) — derive the indentation gap from the third
+  // JSON.stringify argument. Number → min(10, ToInteger) spaces; String →
+  // first min(10) code units; anything else → compact. Resets $__jdepth.
+  ctx.core.stdlib['__json_setgap'] = `(func $__json_setgap (param $sp i64)
+    (local $f f64) (local $n i32) (local $i i32) (local $g i32)
+    (global.set $__jdepth (i32.const 0))
+    (global.set $__jgaplen (i32.const 0))
+    (local.set $f (f64.reinterpret_i64 (local.get $sp)))
+    (if (f64.eq (local.get $f) (local.get $f))
+      (then
+        (local.set $n (i32.trunc_sat_f64_s (local.get $f)))
+        (if (i32.gt_s (local.get $n) (i32.const 10)) (then (local.set $n (i32.const 10))))
+        (if (i32.lt_s (local.get $n) (i32.const 1)) (then (return)))
+        (local.set $g (call $__alloc (local.get $n)))
+        (block $d (loop $l
+          (br_if $d (i32.ge_s (local.get $i) (local.get $n)))
+          (i32.store8 (i32.add (local.get $g) (local.get $i)) (i32.const 32))
+          (local.set $i (i32.add (local.get $i) (i32.const 1)))
+          (br $l)))
+        (global.set $__jgap (local.get $g))
+        (global.set $__jgaplen (local.get $n))
+        (return)))
+    (if (i32.eq (call $__ptr_type (local.get $sp)) (i32.const ${PTR.STRING}))
+      (then
+        (local.set $n (call $__str_byteLen (local.get $sp)))
+        (if (i32.gt_s (local.get $n) (i32.const 10)) (then (local.set $n (i32.const 10))))
+        (if (i32.eqz (local.get $n)) (then (return)))
+        (local.set $g (call $__alloc (local.get $n)))
+        (block $d (loop $l
+          (br_if $d (i32.ge_s (local.get $i) (local.get $n)))
+          (i32.store8 (i32.add (local.get $g) (local.get $i))
+            (call $__char_at (local.get $sp) (local.get $i)))
+          (local.set $i (i32.add (local.get $i) (i32.const 1)))
+          (br $l)))
+        (global.set $__jgap (local.get $g))
+        (global.set $__jgaplen (local.get $n)))))`
+
+  // __jput_str(ptr: i64) — append string chars (without quotes) to buffer.
+  // Per QuoteJSONString: every code unit U+0000..U+001F must be escaped — the
+  // five with short forms (\b \t \n \f \r) plus \uXXXX for the rest.
   ctx.core.stdlib['__jput_str'] = `(func $__jput_str (param $ptr i64)
-    (local $len i32) (local $i i32) (local $ch i32)
+    (local $len i32) (local $i i32) (local $ch i32) (local $n i32)
     (local.set $len (call $__str_byteLen (local.get $ptr)))
     (local.set $i (i32.const 0))
     (block $d (loop $l
       (br_if $d (i32.ge_s (local.get $i) (local.get $len)))
       (local.set $ch (call $__char_at (local.get $ptr) (local.get $i)))
       ;; Escape special JSON chars
-      (if (i32.le_u (local.get $ch) (i32.const 13))
+      (if (i32.lt_u (local.get $ch) (i32.const 32))
         (then
           (if (i32.eq (local.get $ch) (i32.const 10)) (then (call $__jput (i32.const 92)) (call $__jput (i32.const 110)))
           (else (if (i32.eq (local.get $ch) (i32.const 13)) (then (call $__jput (i32.const 92)) (call $__jput (i32.const 114)))
           (else (if (i32.eq (local.get $ch) (i32.const 9)) (then (call $__jput (i32.const 92)) (call $__jput (i32.const 116)))
           (else (if (i32.eq (local.get $ch) (i32.const 8)) (then (call $__jput (i32.const 92)) (call $__jput (i32.const 98)))
           (else (if (i32.eq (local.get $ch) (i32.const 12)) (then (call $__jput (i32.const 92)) (call $__jput (i32.const 102)))
-            (else (call $__jput (local.get $ch)))))))))))))
+          (else
+            ;; \\u00XX — control char with no short escape
+            (call $__jput (i32.const 92)) (call $__jput (i32.const 117))
+            (call $__jput (i32.const 48)) (call $__jput (i32.const 48))
+            (call $__jput (i32.add (i32.const 48) (i32.shr_u (local.get $ch) (i32.const 4))))
+            (local.set $n (i32.and (local.get $ch) (i32.const 15)))
+            (if (i32.ge_u (local.get $n) (i32.const 10))
+              (then (call $__jput (i32.add (local.get $n) (i32.const 87))))
+              (else (call $__jput (i32.add (local.get $n) (i32.const 48))))))))))))))))
         (else
           (if (i32.eq (local.get $ch) (i32.const 34)) (then (call $__jput (i32.const 92)) (call $__jput (i32.const 34)))
           (else (if (i32.eq (local.get $ch) (i32.const 92)) (then (call $__jput (i32.const 92)) (call $__jput (i32.const 92)))
@@ -154,6 +273,41 @@ export default (ctx) => {
   ctx.core.stdlib['__jput_num'] = `(func $__jput_num (param $val f64)
     (call $__jput_str (i64.reinterpret_f64 (call $__ftoa (local.get $val) (i32.const 0) (i32.const 0)))))`
 
+  // __json_omit(val: i64) → i32 — 1 if the value serializes to nothing
+  // (undefined or a function/CLOSURE). Per the JSON spec such values are
+  // dropped from objects, rendered as null in arrays, and make a top-level
+  // JSON.stringify return undefined.
+  ctx.core.stdlib['__json_omit'] = `(func $__json_omit (param $val i64) (result i32)
+    (local $f f64)
+    (local.set $f (f64.reinterpret_i64 (local.get $val)))
+    (if (f64.eq (local.get $f) (local.get $f)) (then (return (i32.const 0))))
+    (if (i64.eq (local.get $val) (i64.const ${UNDEF_NAN})) (then (return (i32.const 1))))
+    (i32.eq (call $__ptr_type (local.get $val)) (i32.const ${PTR.CLOSURE})))`
+
+  // __json_enter(val: i64) — push a container onto the cycle stack, throwing a
+  // TypeError ($__jz_err) if it is already an open ancestor (a circular ref).
+  ctx.core.stdlib['__json_enter'] = `(func $__json_enter (param $val i64)
+    (local $i i32) (local $st i32)
+    (local.set $st (global.get $__jstack))
+    (if (i32.eqz (local.get $st))
+      (then
+        (local.set $st (call $__alloc (i32.const 2048)))
+        (global.set $__jstack (local.get $st))))
+    (block $d (loop $l
+      (br_if $d (i32.ge_s (local.get $i) (global.get $__jsp)))
+      (if (i64.eq (i64.load (i32.add (local.get $st) (i32.shl (local.get $i) (i32.const 3)))) (local.get $val))
+        (then (throw $__jz_err (f64.const 0))))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $l)))
+    ;; A structure deeper than the buffer is treated as non-serializable.
+    (if (i32.ge_s (global.get $__jsp) (i32.const 256)) (then (throw $__jz_err (f64.const 0))))
+    (i64.store (i32.add (local.get $st) (i32.shl (global.get $__jsp) (i32.const 3))) (local.get $val))
+    (global.set $__jsp (i32.add (global.get $__jsp) (i32.const 1))))`
+
+  // __json_leave — pop the most recent container off the cycle stack.
+  ctx.core.stdlib['__json_leave'] = `(func $__json_leave
+    (global.set $__jsp (i32.sub (global.get $__jsp) (i32.const 1))))`
+
   // __json_val(val: i64) — stringify any value, append to buffer
   ctx.core.stdlib['__json_val'] = `(func $__json_val (param $val i64)
     (local $type i32) (local $len i32) (local $i i32) (local $off i32) (local $f f64)
@@ -182,17 +336,27 @@ export default (ctx) => {
     ;; Array
     (if (i32.eq (local.get $type) (i32.const ${PTR.ARRAY}))
       (then
+        (call $__json_enter (local.get $val))
         (call $__jput (i32.const 91))  ;; [
         (local.set $len (call $__len (local.get $val)))
         (local.set $off (call $__ptr_offset (local.get $val)))
         (local.set $i (i32.const 0))
+        ;; A non-empty array opens one indent level; an empty array stays compact.
+        (if (i32.gt_s (local.get $len) (i32.const 0))
+          (then (global.set $__jdepth (i32.add (global.get $__jdepth) (i32.const 1)))))
         (block $d (loop $l
           (br_if $d (i32.ge_s (local.get $i) (local.get $len)))
           (if (local.get $i) (then (call $__jput (i32.const 44))))  ;; ,
+          (call $__jindent)
           (call $__json_val (i64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3)))))
           (local.set $i (i32.add (local.get $i) (i32.const 1)))
           (br $l)))
+        (if (i32.gt_s (local.get $len) (i32.const 0))
+          (then
+            (global.set $__jdepth (i32.sub (global.get $__jdepth) (i32.const 1)))
+            (call $__jindent)))
         (call $__jput (i32.const 93))  ;; ]
+        (call $__json_leave)
         (return)))
     ;; HASH/MAP — iterate entries: {"key":val,...}
     (if (i32.or (i32.eq (local.get $type) (i32.const ${PTR.HASH}))
@@ -208,27 +372,37 @@ export default (ctx) => {
   // __json_hash(val: i64) — stringify HASH/MAP: iterate slots, emit {"key":val,...}
   // Slot layout: 24 bytes each — [hash:f64][key:f64][val:f64]. Empty slots have hash==0.
   ctx.core.stdlib['__json_hash'] = `(func $__json_hash (param $val i64)
-    (local $off i32) (local $cap i32) (local $i i32) (local $slot i32) (local $first i32)
+    (local $off i32) (local $cap i32) (local $i i32) (local $slot i32) (local $first i32) (local $pv i64)
     (local.set $off (call $__ptr_offset (local.get $val)))
     (local.set $cap (i32.load (i32.sub (local.get $off) (i32.const 4))))
     (local.set $first (i32.const 1))
+    (call $__json_enter (local.get $val))
     (call $__jput (i32.const 123))
+    (global.set $__jdepth (i32.add (global.get $__jdepth) (i32.const 1)))
     (block $d (loop $l
       (br_if $d (i32.ge_s (local.get $i) (local.get $cap)))
       (local.set $slot (i32.add (local.get $off) (i32.mul (local.get $i) (i32.const 24))))
       (if (f64.ne (f64.load (local.get $slot)) (f64.const 0))
         (then
-          (if (i32.eqz (local.get $first))
-            (then (call $__jput (i32.const 44))))
-          (local.set $first (i32.const 0))
-          (call $__jput (i32.const 34))
-          (call $__jput_str (i64.load (i32.add (local.get $slot) (i32.const 8))))
-          (call $__jput (i32.const 34))
-          (call $__jput (i32.const 58))
-          (call $__json_val (i64.load (i32.add (local.get $slot) (i32.const 16))))))
+          (local.set $pv (i64.load (i32.add (local.get $slot) (i32.const 16))))
+          (if (i32.eqz (call $__json_omit (local.get $pv)))
+            (then
+              (if (i32.eqz (local.get $first))
+                (then (call $__jput (i32.const 44))))
+              (local.set $first (i32.const 0))
+              (call $__jindent)
+              (call $__jput (i32.const 34))
+              (call $__jput_str (i64.load (i32.add (local.get $slot) (i32.const 8))))
+              (call $__jput (i32.const 34))
+              (call $__jput (i32.const 58))
+              (if (global.get $__jgaplen) (then (call $__jput (i32.const 32))))
+              (call $__json_val (local.get $pv))))))
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (br $l)))
-    (call $__jput (i32.const 125)))`
+    (global.set $__jdepth (i32.sub (global.get $__jdepth) (i32.const 1)))
+    (if (i32.eqz (local.get $first)) (then (call $__jindent)))
+    (call $__jput (i32.const 125))
+    (call $__json_leave))`
 
   // __json_obj(val: f64) — stringify OBJECT using runtime schema name table.
   // Schema name table: global $__schema_tbl → array of f64 pointers.
@@ -236,7 +410,7 @@ export default (ctx) => {
   // Object props are sequential f64 at ptr_offset, indexed same as schema.
   ctx.core.stdlib['__json_obj'] = `(func $__json_obj (param $val i64)
     (local $off i32) (local $sid i32) (local $keys i32) (local $nkeys i32)
-    (local $i i32) (local $koff i32)
+    (local $i i32) (local $koff i32) (local $first i32) (local $pv i64)
     (local.set $off (call $__ptr_offset (local.get $val)))
     (local.set $sid (call $__ptr_aux (local.get $val)))
     ;; Load keys array from schema table: schema_tbl + sid * 8
@@ -245,25 +419,41 @@ export default (ctx) => {
     (local.set $nkeys (call $__len
       (i64.load (i32.add (global.get $__schema_tbl) (i32.shl (local.get $sid) (i32.const 3))))))
     (local.set $koff (local.get $keys))
+    (local.set $first (i32.const 1))
+    (call $__json_enter (local.get $val))
     (call $__jput (i32.const 123))
+    (global.set $__jdepth (i32.add (global.get $__jdepth) (i32.const 1)))
     (block $d (loop $l
       (br_if $d (i32.ge_s (local.get $i) (local.get $nkeys)))
-      (if (local.get $i) (then (call $__jput (i32.const 44))))
-      (call $__jput (i32.const 34))
-      (call $__jput_str (i64.load (i32.add (local.get $koff) (i32.shl (local.get $i) (i32.const 3)))))
-      (call $__jput (i32.const 34))
-      (call $__jput (i32.const 58))
-      (call $__json_val (i64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3)))))
+      (local.set $pv (i64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3)))))
+      (if (i32.eqz (call $__json_omit (local.get $pv)))
+        (then
+          (if (i32.eqz (local.get $first)) (then (call $__jput (i32.const 44))))
+          (local.set $first (i32.const 0))
+          (call $__jindent)
+          (call $__jput (i32.const 34))
+          (call $__jput_str (i64.load (i32.add (local.get $koff) (i32.shl (local.get $i) (i32.const 3)))))
+          (call $__jput (i32.const 34))
+          (call $__jput (i32.const 58))
+          (if (global.get $__jgaplen) (then (call $__jput (i32.const 32))))
+          (call $__json_val (local.get $pv))))
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (br $l)))
-    (call $__jput (i32.const 125)))`
+    (global.set $__jdepth (i32.sub (global.get $__jdepth) (i32.const 1)))
+    (if (i32.eqz (local.get $first)) (then (call $__jindent)))
+    (call $__jput (i32.const 125))
+    (call $__json_leave))`
 
-  // __stringify(val: i64) → f64 (NaN-boxed string)
-  ctx.core.stdlib['__stringify'] = `(func $__stringify (param $val i64) (result f64)
-    ;; Reset output buffer
+  // __stringify(val: i64, space: i64) → f64 (NaN-boxed string)
+  ctx.core.stdlib['__stringify'] = `(func $__stringify (param $val i64) (param $space i64) (result f64)
+    ;; Top-level undefined / function serializes to nothing → return undefined.
+    (if (call $__json_omit (local.get $val)) (then (return ${UNDEF_WAT})))
+    ;; Reset output buffer + cycle stack
+    (global.set $__jsp (i32.const 0))
     (global.set $__jbuf (call $__alloc (i32.const 256)))
     (global.set $__jpos (i32.const 0))
     (global.set $__jcap (i32.const 256))
+    (call $__json_setgap (local.get $space))
     (call $__json_val (local.get $val))
     ;; Create string from buffer
     (call $__mkstr (global.get $__jbuf) (global.get $__jpos)))`
@@ -278,6 +468,11 @@ export default (ctx) => {
   // and skips the redundant __str_hash call inside the generic insert. 0 is a
   // sentinel meaning "string had escapes — recompute via __str_hash".
   ctx.scope.globals.set('__jp_keyh', '(global $__jp_keyh (mut i32) (i32.const 0))')
+  // Sticky syntax-error flag. Set by any parser sub-routine on malformed input;
+  // checked once by __jp after the top-level value, which throws if it is set.
+  // Sticky (never cleared mid-parse) so recursive descent need not thread an
+  // error result through every call — __jp resets it per invocation.
+  ctx.scope.globals.set('__jp_err', '(global $__jp_err (mut i32) (i32.const 0))')
   // Runtime schema infrastructure. __schema_next points at the first free slot
   // in $__schema_tbl reserved for runtime registration; compile.js initializes
   // it to ctx.schema.list.length when __jp_obj is included. The schema cache
@@ -300,17 +495,19 @@ export default (ctx) => {
 
   // Whitespace skip — inlined at every call site as a tight loop. Compact
   // JSON often has zero whitespace between tokens, so the dominant case is
-  // a single peek + break. WS chars (9/10/13/32) all fit in [0..32]; we
-  // exit on anything > 32 unsigned. The sentinel byte (PEEK returns -1
-  // sign-extended) is 0xFFFFFFFF unsigned — > 32 — so the same check
-  // handles EOF without a separate guard. Other control chars in [0..8],
-  // [11..12], [14..31] would be falsely consumed as WS, but those aren't
-  // valid in well-formed JSON anyway.
+  // a single peek + break. Per the JSON grammar only tab (9), LF (10), CR
+  // (13) and space (32) are JSONWhitespace; every other byte — including
+  // other control chars and non-ASCII Unicode spaces — ends the run, so a
+  // stray VT/FF or U+2028 surfaces to the value dispatcher as a syntax
+  // error. The sentinel byte (PEEK returns -1) matches none of the four and
+  // ends the run too, so EOF needs no separate guard.
   let WS_ID = 0
   const WS = () => {
     const id = WS_ID++
     return `(block $jpws_d${id} (loop $jpws_l${id}
-      (br_if $jpws_d${id} (i32.gt_u ${PEEK} (i32.const 32)))
+      (br_if $jpws_d${id} (i32.eqz (i32.or
+        (i32.or (i32.eq ${PEEK} (i32.const 32)) (i32.eq ${PEEK} (i32.const 9)))
+        (i32.or (i32.eq ${PEEK} (i32.const 10)) (i32.eq ${PEEK} (i32.const 13))))))
       ${ADV(1)}
       (br $jpws_l${id})))`
   }
@@ -328,6 +525,21 @@ export default (ctx) => {
       (then (return (i32.sub (i32.or (local.get $c) (i32.const 0x20)) (i32.const 87)))))
     (i32.const 0))`
 
+  // Strict hex-digit predicate — 1 iff $c is [0-9A-Fa-f], else 0. Used to
+  // validate \uXXXX escapes (__hex1 itself is lenient and returns 0 for
+  // non-hex, which would silently accept `\u0X50`).
+  ctx.core.stdlib['__ishex'] = `(func $__ishex (param $c i32) (result i32)
+    (i32.or
+      (i32.le_u (i32.sub (local.get $c) (i32.const 48)) (i32.const 9))
+      (i32.le_u (i32.sub (i32.or (local.get $c) (i32.const 0x20)) (i32.const 97)) (i32.const 5))))`
+
+  // All four bytes at the current parse position are hex digits.
+  const HEX4_VALID = `(i32.and
+    (i32.and (call $__ishex (i32.load8_u (i32.add (global.get $__jpstr) (global.get $__jppos))))
+             (call $__ishex (i32.load8_u (i32.add (global.get $__jpstr) (i32.add (global.get $__jppos) (i32.const 1))))))
+    (i32.and (call $__ishex (i32.load8_u (i32.add (global.get $__jpstr) (i32.add (global.get $__jppos) (i32.const 2)))))
+             (call $__ishex (i32.load8_u (i32.add (global.get $__jpstr) (i32.add (global.get $__jppos) (i32.const 3)))))))`
+
   // Read 4 hex bytes at absolute address $p → 16-bit value.
   ctx.core.stdlib['__hex4'] = `(func $__hex4 (param $p i32) (result i32)
     (i32.or (i32.or (i32.or
@@ -366,6 +578,9 @@ export default (ctx) => {
       (local.set $ch ${PEEK})
       (br_if $d (i32.eq (local.get $ch) (i32.const 34)))
       (br_if $d (i32.eq (local.get $ch) (i32.const -1)))
+      ;; Unescaped control char (U+0000..U+001F) is not a valid JSONStringCharacter.
+      (if (i32.lt_u (local.get $ch) (i32.const 32))
+        (then (global.set $__jp_err (i32.const 1)) (br $d)))
       ;; Mark non-simple: escape (\\=92) or non-ASCII (load8_s gives <0 for byte≥128).
       (if (i32.or (i32.eq (local.get $ch) (i32.const 92)) (i32.lt_s (local.get $ch) (i32.const 0)))
         (then (local.set $simple (i32.const 0))))
@@ -384,6 +599,9 @@ export default (ctx) => {
           (local.set $len (i32.add (local.get $len) (i32.const 1)))
           ${ADV(1)}))
       (br $l)))
+    ;; Loop exited on the closing quote (34) or EOF (-1); the latter means an
+    ;; unterminated string literal.
+    (if (i32.eq (local.get $ch) (i32.const -1)) (then (global.set $__jp_err (i32.const 1))))
     ;; Stash hash. 0/1 bumped to 2 to match __str_hash convention; escape strings
     ;; (simple==0) get sentinel 0 so __jp_obj falls back to non-prehashed insert.
     (global.set $__jp_keyh
@@ -422,6 +640,7 @@ export default (ctx) => {
           ${ADV(1)}
           (if (i32.eq (local.get $ch) (i32.const 117))  ;; \\uXXXX
             (then
+              (if (i32.eqz ${HEX4_VALID}) (then (global.set $__jp_err (i32.const 1))))
               (local.set $cp (call $__hex4 (i32.add (global.get $__jpstr) (global.get $__jppos))))
               ${ADV(4)}
               ;; High surrogate immediately followed by \\uXXXX low surrogate → combine.
@@ -431,6 +650,7 @@ export default (ctx) => {
                              (i32.eq (i32.load8_u (i32.add (global.get $__jpstr) (i32.add (global.get $__jppos) (i32.const 1)))) (i32.const 117))))
                 (then
                   ${ADV(2)}
+                  (if (i32.eqz ${HEX4_VALID}) (then (global.set $__jp_err (i32.const 1))))
                   (local.set $i (call $__hex4 (i32.add (global.get $__jpstr) (global.get $__jppos))))
                   ${ADV(4)}
                   (local.set $cp (i32.add (i32.const 0x10000)
@@ -525,7 +745,11 @@ export default (ctx) => {
       ${WS()}
       (local.set $ch ${PEEK})
       (br_if $d (i32.eq (local.get $ch) (i32.const 93)))
-      (if (i32.eq (local.get $ch) (i32.const 44)) (then ${ADV(1)}))
+      ;; After an element only a comma (more) or close-bracket (done) is
+      ;; valid; anything else (incl. EOF) is a syntax error. Break to terminate.
+      (if (i32.eq (local.get $ch) (i32.const 44))
+        (then ${ADV(1)})
+        (else (global.set $__jp_err (i32.const 1)) (br $d)))
       (br $l)))
     ${ADV(1)}
     (i32.store (i32.sub (local.get $ptr) (i32.const 8)) (local.get $len))
@@ -654,7 +878,11 @@ export default (ctx) => {
       ${WS()}
       (local.set $ch ${PEEK})
       (br_if $d (i32.eq (local.get $ch) (i32.const 125)))
-      (if (i32.eq (local.get $ch) (i32.const 44)) (then ${ADV(1)}))
+      ;; After a member only a comma (more) or close-brace (done) is
+      ;; valid; anything else (incl. EOF) is a syntax error. Break to terminate.
+      (if (i32.eq (local.get $ch) (i32.const 44))
+        (then ${ADV(1)})
+        (else (global.set $__jp_err (i32.const 1)) (br $d)))
       (br $l)))
     ${ADV(1)}
     ;; Resolve schema sid (cached or freshly registered).
@@ -673,6 +901,19 @@ export default (ctx) => {
       (br $vl)))
     (call $__mkptr (i32.const ${PTR.OBJECT}) (local.get $sid) (local.get $obj)))`
 
+  // Verify a bare keyword literal: the dispatch char is already known to be
+  // word[0]; AND-check word[1..] against the bytes after the parse position.
+  // Past-end reads land in the 0xFF sentinel pad, which matches nothing.
+  const litMatch = (word) => {
+    const tests = [...word].slice(1).map((c, i) =>
+      `(i32.eq (i32.load8_u (i32.add (global.get $__jpstr) (i32.add (global.get $__jppos) (i32.const ${i + 1})))) (i32.const ${c.charCodeAt(0)}))`)
+    return tests.reduce((a, b) => `(i32.and ${a} ${b})`)
+  }
+  const litCase = (ch, word, valIR, adv) => `(if (i32.eq (local.get $ch) (i32.const ${ch}))
+      (then (if ${litMatch(word)}
+        (then ${ADV(adv)} (return ${valIR}))
+        (else (global.set $__jp_err (i32.const 1)) (return ${NULL_WAT})))))`
+
   // Main value dispatcher
   ctx.core.stdlib['__jp_val'] = `(func $__jp_val (result f64)
     (local $ch i32)
@@ -687,12 +928,11 @@ export default (ctx) => {
     (if (i32.or (i32.and (i32.ge_s (local.get $ch) (i32.const 48)) (i32.le_s (local.get $ch) (i32.const 57)))
                 (i32.eq (local.get $ch) (i32.const 45)))
       (then (return (call $__jp_num))))
-    (if (i32.eq (local.get $ch) (i32.const 116))
-      (then ${ADV(4)} (return (f64.const 1))))
-    (if (i32.eq (local.get $ch) (i32.const 102))
-      (then ${ADV(5)} (return (f64.const 0))))
-    (if (i32.eq (local.get $ch) (i32.const 110))
-      (then ${ADV(4)} (return ${NULL_WAT})))
+    ${litCase(116, 'true', '(f64.const 1)', 4)}
+    ${litCase(102, 'false', '(f64.const 0)', 5)}
+    ${litCase(110, 'null', NULL_WAT, 4)}
+    ;; No production matched — malformed JSON value.
+    (global.set $__jp_err (i32.const 1))
     ${NULL_WAT})`
 
   function canSpecializeJsonShape(v) {
@@ -859,7 +1099,7 @@ ${localDecls}
   // overshoot from speculative peek/adv on malformed input still hits sentinel,
   // not unallocated memory.
   ctx.core.stdlib['__jp'] = `(func $__jp (param $str i64) (result f64)
-    (local $len i32) (local $buf i32) (local $i i32)
+    (local $len i32) (local $buf i32) (local $i i32) (local $r f64)
     (local.set $len (call $__str_byteLen (local.get $str)))
     (local.set $buf (call $__alloc (i32.add (local.get $len) (i32.const 8))))
     ;; Pre-fill 8 sentinel bytes at end (writes overlapping a 64-bit slot).
@@ -879,21 +1119,87 @@ ${localDecls}
     (global.set $__jpstr (local.get $buf))
     (global.set $__jplen (local.get $len))
     (global.set $__jppos (i32.const 0))
-    (call $__jp_val))`
+    (global.set $__jp_err (i32.const 0))
+    (local.set $r (call $__jp_val))
+    ;; Any non-whitespace byte after the top-level value is a syntax error.
+    ${WS()}
+    (if (i32.ne ${PEEK} (i32.const -1)) (then (global.set $__jp_err (i32.const 1))))
+    (if (global.get $__jp_err) (then (throw $__jz_err (f64.const 0))))
+    (local.get $r))`
 
   // === Emitters ===
 
-  ctx.core.emit['JSON.stringify'] = (x) => {
+  // JSON.stringify(value [, replacer [, space ]]).
+  //
+  // Compile-time fold: when `value` is a fully-literal tree — and `replacer` /
+  // `space` are likewise constant — the result is computed with the host
+  // `JSON.stringify` and emitted as a single string constant. This is the
+  // mirror of the `JSON.parse` const-fold: spec-exact (replacer-array filtering,
+  // dedup, key order, indentation all come free from the host), and it removes
+  // the runtime call entirely. The runtime `__stringify` path (which ignores a
+  // replacer) handles every non-constant case unchanged.
+  ctx.core.emit['JSON.stringify'] = (x, replacer, space) => {
+    const folded = foldStringify(x, replacer, space)
+    if (folded !== undefined) return folded
+    // Scalar boolean: the working-rep is the 0/1 number carrier, so the runtime
+    // tag-walker would emit "0"/"1". A boolean's JSON is the bare word
+    // true/false — exactly emitBoolStr. Guard on `replacer == null`: a replacer
+    // function may rewrite the top-level value, in which case fall to runtime.
+    if (replacer == null && valTypeOf(x) === VAL.BOOL) return emitBoolStr(x)
     inc('__stringify')
-    return typed(['call', '$__stringify', asI64(emit(x))], 'f64')
+    const spaceIR = asI64(space == null ? undefExpr() : emit(space))
+    return typed(['call', '$__stringify', asI64(emit(x)), spaceIR], 'f64')
+  }
+
+  // Returns folded IR, or `undefined` when any argument is non-constant.
+  function foldStringify(x, replacer, space) {
+    const val = literalValue(x)
+    if (val === NOT_LIT) return undefined
+
+    let rep
+    if (replacer != null) {
+      const rv = literalValue(replacer)
+      if (rv === NOT_LIT) {
+        const arr = jsonShapeStrings(ctx, replacer)   // const-bound string array
+        if (arr == null) return undefined
+        rep = arr
+      } else if (rv == null) {
+        rep = undefined                               // null / undefined replacer
+      } else if (Array.isArray(rv)) {
+        rep = rv
+      } else {
+        return undefined                              // function replacer — can't fold
+      }
+    }
+
+    let sp
+    if (space != null) {
+      sp = literalValue(space)
+      if (sp === NOT_LIT) return undefined
+    }
+
+    let result
+    try { result = JSON.stringify(val, rep, sp) }
+    catch { return undefined }
+    return result === undefined ? undefExpr() : asF64(emit(['str', result]))
   }
 
   ctx.core.emit['JSON.parse'] = (x) => {
+    // A non-string primitive literal argument is coerced via ToString, then
+    // parsed: JSON.parse(0) → "0", JSON.parse(null) → "null", JSON.parse() →
+    // "undefined" (which parses to a SyntaxError, the spec-correct outcome).
+    // Literals reach the emitter as `[null, value]` nodes.
+    if (x === undefined) x = ['str', 'undefined']
+    else if (Array.isArray(x) && x[0] == null && typeof x[1] !== 'string')
+      x = ['str', x[1] == null ? 'null' : String(x[1])]
     const src = jsonConstString(ctx, x)
     if (src != null) {
       try { return emitJsonConstValue(JSON.parse(src)) }
       catch { /* fall through to runtime parser for invalid JSON so runtime behavior stays unchanged */ }
     }
+    // The runtime parser (and any shape parser that falls back to it) raises a
+    // SyntaxError via $__jz_err on malformed input, so the throw tag must exist.
+    ctx.runtime.throws = true
     const shapeSrcs = jsonShapeStrings(ctx, x)
     if (shapeSrcs) {
       try {