jz 0.5.0 → 0.5.1

package/module/core.js

@@ -722,6 +722,32 @@ export default (ctx) => {
       if (tpEmitter && tpEmitter.length <= 1) return tpEmitter(obj)
     }
 
+    // valueOf/toString are ToPrimitive hooks (ES2024 7.1.1) that an own data
+    // property shadows. On a heap receiver carrying a dynamic-prop sidecar
+    // (array/typed/object), reading `obj.valueOf`/`obj.toString` must return an
+    // assigned override when present, else the inherited builtin. Without this,
+    // the arity-1 builtin emitter below (returns the receiver) masks the
+    // override. The method-call path in src/emit.js runs the parallel probe and
+    // additionally covers statically-unknown receivers (e.g. `arr[0].valueOf()`);
+    // a bare read of an unknown-type receiver can't yield a builtin-as-value
+    // here anyway, so this read path stays scoped to known sidecar types.
+    if ((prop === 'valueOf' || prop === 'toString') && ctx.closure.call &&
+        (ptVt === VAL.ARRAY || ptVt === VAL.TYPED || ptVt === VAL.OBJECT)) {
+      const builtin = ctx.core.emit[`.${ptVt}:${prop}`] || ctx.core.emit[`.${prop}`]
+      if (builtin && builtin.length <= 1) {
+        const o = temp('vo'), p = temp('vp')
+        inc('__dyn_get_expr', '__ptr_type')
+        return typed(['block', ['result', 'f64'],
+          ['local.set', `$${o}`, asF64(emit(obj))],
+          ['local.set', `$${p}`, ['f64.reinterpret_i64',
+            ['call', '$__dyn_get_expr', ['i64.reinterpret_f64', ['local.get', `$${o}`]], asI64(emit(['str', prop]))]]],
+          ['if', ['result', 'f64'],
+            ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${p}`]]], ['i32.const', PTR.CLOSURE]],
+            ['then', ['local.get', `$${p}`]],
+            ['else', asF64(builtin(o))]]], 'f64')
+      }
+    }
+
     // Module-registered property emitter (.size, etc.)
     const propKey = `.${prop}`
     const propEmitter = ctx.core.emit[propKey]

package/module/math.js

@@ -12,7 +12,7 @@
  * @module math
  */
 
-import { typed, asF64, asI32, toI32, toNumF64, temp, arrayLoop, isLit, litVal } from '../src/ir.js'
+import { typed, asF64, asI32, toI32, toNumF64, temp, arrayLoop, isLit, litVal, isPureIR } from '../src/ir.js'
 import { emit } from '../src/emit.js'
 import { emitter } from '../src/ctx.js'
 import { repOf } from '../src/analyze.js'
@@ -182,8 +182,56 @@ export default (ctx) => {
   ctx.core.emit['math.log10'] = emitter(['math.log10'], a => call('math.log10', a))
   ctx.core.emit['math.log1p'] = emitter(['math.log1p'], a => call('math.log1p', a))
 
-  // Power
-  ctx.core.emit['math.pow'] = emitter(['math.pow'], (a, b) => call('math.pow', a, b))
+  // Power. Constant-integer-exponent `Math.pow(x,n)` / `x ** n` (|n| ≤ POW_FOLD_MAX)
+  // lower to inline square-and-multiply instead of a $math.pow call. The fold is
+  // bit-identical to $math.pow's integer fast path: that path runs the same LSB-first
+  // square-and-multiply, and an f64 product's magnitude is the rounded product of the
+  // operand magnitudes regardless of sign — so multiplying the *signed* base reproduces
+  // both the exact bits and the result sign (negative iff x<0 ∧ n odd, which is exactly
+  // its `neg_base`). A program whose only pow use is folded then never pulls the
+  // math.pow/exp/log stdlib. `**`'s exponent is parsed as a bare number (incl. negatives).
+  const POW_FOLD_MAX = 8
+  const get = name => ['local.get', `$${name}`]
+  const constInt = b => {
+    const v = typeof b === 'number' ? b
+      : (Array.isArray(b) && b.length === 2 && b[0] == null && typeof b[1] === 'number') ? b[1]
+      : null
+    return v != null && Number.isInteger(v) ? v : null
+  }
+  const foldPow = (a, n) => {
+    const baseIR = toNumF64(a, emit(a))
+    // pow(x,0) === 1 for every x (NaN/±0/±Inf included). Keep the base's side
+    // effects (a call, a throwing valueOf), discard its value, yield 1.
+    if (n === 0) return isPureIR(baseIR)
+      ? typed(['f64.const', 1], 'f64')
+      : typed(['block', ['result', 'f64'], ['drop', baseIR], ['f64.const', 1]], 'f64')
+    const b = temp('pw')
+    const stmts = [['local.set', `$${b}`, baseIR]]
+    // square-and-multiply, LSB-first — mirrors $math.pow's loop association exactly,
+    // so the rounding tree (and thus the last bit) matches.
+    let sq = b, res = null, minted = false
+    for (let m = Math.abs(n); m > 0; m >>= 1) {
+      if (m & 1) {
+        if (res === null) res = sq                 // lowest set bit: result := this square (skip ×1)
+        else { const r = temp('pw'); stmts.push(['local.set', `$${r}`, ['f64.mul', get(res), get(sq)]]); res = r; minted = true }
+      }
+      if (m >> 1) { const s = temp('pw'); stmts.push(['local.set', `$${s}`, ['f64.mul', get(sq), get(sq)]]); sq = s; minted = true }
+    }
+    let result = get(res)
+    if (n < 0) { result = ['f64.div', ['f64.const', 1], result]; minted = true }   // y<0 → reciprocal, as $math.pow does
+    // A NaN minted by f64.mul/div has a platform-nondeterministic sign; jz's value
+    // model requires the one canonical number-NaN, so `canon` folds it back. Skip when
+    // the base provably can't be NaN (same test min/max uses) or when no op was minted
+    // (|n|=1 hands the base straight through, already canonical).
+    const inner = typed(['block', ['result', 'f64'], ...stmts, result], 'f64')
+    return (minted && !neverNaN(a, baseIR)) ? canon(inner) : inner
+  }
+  const powCall = emitter(['math.pow'], (a, b) => call('math.pow', a, b))
+  ctx.core.emit['math.pow'] = (a, b) => {
+    const n = constInt(b)
+    return n !== null && Math.abs(n) <= POW_FOLD_MAX ? foldPow(a, n) : powCall(a, b)
+  }
+  ctx.core.emit['math.pow'].deps = powCall.deps   // metadata parity (tabulation/analysis)
   ctx.core.emit['**'] = ctx.core.emit['math.pow']
   ctx.core.emit['math.cbrt'] = emitter(['math.cbrt'], a => call('math.cbrt', a))
   ctx.core.emit['math.hypot'] = emitter(['math.hypot'], (a, b, ...rest) => {

package/module/string.js

@@ -1628,6 +1628,11 @@ export default (ctx) => {
 
   ctx.core.emit['.encode'] = (obj, str) => {
     inc('__str_encode')
+    // .encode() yields a runtime PTR.TYPED/u8 array (see __mkptr above). Downstream
+    // indexing/spread dispatch through __typed_idx, whose element-unaware fallback
+    // (f64.load, stride 8) is only valid when no typed array can flow in. Enabling
+    // the feature pulls the element-aware variant — same invariant `.length` follows.
+    ctx.features.typedarray = true
     return typed(['call', '$__str_encode', asI64(emit(str))], 'f64')
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jz",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Functional JS subset compiling to WASM",
   "main": "index.js",
   "type": "module",

package/src/emit.js

@@ -789,11 +789,16 @@ function emitSpreadCopy(dest, posLocal, srcLocal, srcLenLocal, staticVT) {
           ['then', (inc('__str_idx'), ['call', '$__str_idx', srcI64(), ['local.get', `$${sidx}`]])],
           ['else', (inc('__typed_idx'), ['call', '$__typed_idx', srcI64(), ['local.get', `$${sidx}`]])]]
       : (inc('__typed_idx'), ['call', '$__typed_idx', srcI64(), ['local.get', `$${sidx}`]])
-    return ['block', `$break${loopId}`, ['loop', `$loop${loopId}`,
-      ['br_if', `$break${loopId}`, ['i32.ge_s', ['local.get', `$${sidx}`], ['local.get', `$${srcLenLocal}`]]],
-      ['f64.store', destAddr(['i32.add', ['local.get', `$${posLocal}`], ['local.get', `$${sidx}`]]), elem],
-      ['local.set', `$${sidx}`, ['i32.add', ['local.get', `$${sidx}`], ['i32.const', 1]]],
-      ['br', `$loop${loopId}`]]]
+    // Reset the counter on each entry — WASM zeroes locals once at function
+    // entry, but this loop re-executes when the spread sits inside a JS loop;
+    // a stale `sidx` (= prior srcLen) would skip the copy entirely.
+    return ['block', `$break${loopId}`,
+      ['local.set', `$${sidx}`, ['i32.const', 0]],
+      ['loop', `$loop${loopId}`,
+        ['br_if', `$break${loopId}`, ['i32.ge_s', ['local.get', `$${sidx}`], ['local.get', `$${srcLenLocal}`]]],
+        ['f64.store', destAddr(['i32.add', ['local.get', `$${posLocal}`], ['local.get', `$${sidx}`]]), elem],
+        ['local.set', `$${sidx}`, ['i32.add', ['local.get', `$${sidx}`], ['i32.const', 1]]],
+        ['br', `$loop${loopId}`]]]
   }
   const advance = ['local.set', `$${posLocal}`,
     ['i32.add', ['local.get', `$${posLocal}`], ['local.get', `$${srcLenLocal}`]]]
@@ -2067,7 +2072,16 @@ export const emitter = {
   // i32 / lit values are already numeric — the toNumF64 wrap is skipped to keep
   // the numeric fast path at one wasm instruction. Non-numeric (NaN-boxed string,
   // unknown type) routes through __to_num so "2026" | 0 === 2026.
-  '~':   a => { const v = emit(a); return isLit(v) ? emitNum(~litVal(v)) : typed(['i32.xor', toI32(isI32Num(v) ? v : toNumF64(a, v)), typed(['i32.const', -1], 'i32')], 'i32') },
+  // `~~x` is the idiomatic int32 truncation: the two xor-with-(-1) cancel, leaving
+  // a single toI32 (whose NaN/Infinity guard runs once, unchanged). Fold it here so
+  // DSP/bytebeat `~~` doesn't emit a dead double-xor watr won't remove.
+  '~':   a => {
+    if (Array.isArray(a) && a[0] === '~') {
+      const inner = a[1], iv = emit(inner)
+      return isLit(iv) ? emitNum(~~litVal(iv)) : typed(toI32(isI32Num(iv) ? iv : toNumF64(inner, iv)), 'i32')
+    }
+    const v = emit(a); return isLit(v) ? emitNum(~litVal(v)) : typed(['i32.xor', toI32(isI32Num(v) ? v : toNumF64(a, v)), typed(['i32.const', -1], 'i32')], 'i32')
+  },
   ...Object.fromEntries([
     ['&', 'and'], ['|', 'or'], ['^', 'xor'], ['<<', 'shl'], ['>>', 'shr_s'],
   ].map(([op, fn]) => [op, (a, b) => {
@@ -2571,6 +2585,35 @@ export const emitter = {
         }
       }
 
+      // valueOf/toString are ToPrimitive hooks (ES2024 7.1.1) that an own data
+      // property shadows. An assigned `obj.valueOf`/`obj.toString` must win over
+      // the builtin emitter for any receiver that can carry a dynamic-prop
+      // sidecar — a sidecar-bearing static type (array/typed/object) OR a
+      // statically-unknown receiver (e.g. an array-element read `arr[0]`, whose
+      // type is only known at runtime). Probe the sidecar and call it when it
+      // holds a closure, else fall back to the builtin (generic when untyped:
+      // `.valueOf` returns the receiver, `.toString` runs type-aware __to_str).
+      // Parallels the member-READ check in module/core.js emitPropAccess (which
+      // stays scoped to known sidecar types). (watr's `str()` attaches
+      // `bytes.valueOf = () => s`, recovered via `.valueOf()`.)
+      if ((method === 'valueOf' || method === 'toString') && ctx.closure.call
+          && !parsed.hasSpread && parsed.normal.length === 0
+          && (vt === VAL.ARRAY || vt === VAL.TYPED || vt === VAL.OBJECT || !vt)) {
+        const builtin = (vt && ctx.core.emit[`.${vt}:${method}`]) || ctx.core.emit[`.${method}`]
+        if (builtin) {
+          const objTmp = temp('vobj'), propTmp = temp('vprop')
+          inc('__dyn_get_expr', '__ptr_type')
+          return typed(['block', ['result', 'f64'],
+            ['local.set', `$${objTmp}`, asF64(emit(obj))],
+            ['local.set', `$${propTmp}`, ['f64.reinterpret_i64',
+              ['call', '$__dyn_get_expr', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]], asI64(emit(['str', method]))]]],
+            ['if', ['result', 'f64'],
+              ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${propTmp}`]]], ['i32.const', PTR.CLOSURE]],
+              ['then', ctx.closure.call(typed(['local.get', `$${propTmp}`], 'f64'), [])],
+              ['else', asF64(callMethod(objTmp, builtin))]]], 'f64')
+        }
+      }
+
       // Known type → static dispatch
       if (vt && ctx.core.emit[`.${vt}:${method}`]) {
         return callMethod(obj, ctx.core.emit[`.${vt}:${method}`])

package/src/jzify.js

@@ -368,6 +368,18 @@ function functionBodyBlock(body) {
 /** Prototype identity check: X.prototype.Y */
 const isProto = n => Array.isArray(n) && n[0] === '.' && Array.isArray(n[1]) && n[1][0] === '.' && n[1][2] === 'prototype'
 
+/** `obj.M <eq> Ctor.prototype.M` is not a real reference comparison — jz has no
+ *  prototype objects — it asks whether `obj` overrides `M`, which is exactly
+ *  `obj.hasOwnProperty('M')`. Returns that call node when the shape matches
+ *  (a member access `obj.M` against a same-named prototype method), else null. */
+const methodOverrideHasOwn = (a, b) => {
+  const proto = isProto(a) ? a : isProto(b) ? b : null
+  if (!proto) return null
+  const other = proto === a ? b : a
+  if (!Array.isArray(other) || other[0] !== '.' || other[2] !== proto[2]) return null
+  return ['()', ['.', transform(other[1]), 'hasOwnProperty'], [null, proto[2]]]
+}
+
 const TYPED_ARRAYS = new Set(['Float64Array','Float32Array','Int32Array','Uint32Array',
   'Int16Array','Uint16Array','Int8Array','Uint8Array',
   'ArrayBuffer','BigInt64Array','BigUint64Array','DataView'])
@@ -906,18 +918,8 @@ const handlers = {
 
   'switch'(disc, ...cases) {
     const clean = cases.map(c => {
-      if (c[0] === 'case' && Array.isArray(c[2]) && c[2][0] === ';') {
-        const body = c[2].slice(1).filter(s => typeof s !== 'number')
-        const stripped = stripTerminalSwitchBreak(body.length === 1 ? body[0] : [';', ...body])
-        return ['case', c[1], stripped]
-      }
-      if (c[0] === 'default' && Array.isArray(c[1]) && c[1][0] === ';') {
-        const body = c[1].slice(1).filter(s => s != null && typeof s !== 'number')
-        const stripped = stripTerminalSwitchBreak(body.length === 1 ? body[0] : [';', ...body])
-        return ['default', stripped]
-      }
-      if (c[0] === 'case') return ['case', c[1], stripTerminalSwitchBreak(c[2])]
-      if (c[0] === 'default') return ['default', stripTerminalSwitchBreak(c[1])]
+      if (c[0] === 'case') return ['case', c[1], normalizeCaseBody(c[2])]
+      if (c[0] === 'default') return ['default', normalizeCaseBody(c[1])]
       return c
     })
     return transformSwitch(disc, clean)
@@ -925,12 +927,14 @@ const handlers = {
 
   // Equality keeps the JS loose/strict distinction (jz core now lowers both):
   // `==`/`!=` stay loose, `===`/`!==` stay strict. A comparison against a prototype
-  // object (e.g. `x.constructor === Object`) folds to a boolean — jz has no
-  // prototype objects, so identity against one is decided statically.
-  '=='(a, b) { return isProto(a) || isProto(b) ? 1 : ['==', transform(a), transform(b)] },
-  '!='(a, b) { return isProto(a) || isProto(b) ? 0 : ['!=', transform(a), transform(b)] },
-  '==='(a, b) { if (isProto(a) || isProto(b)) return 1 },
-  '!=='(a, b) { if (isProto(a) || isProto(b)) return 0 },
+  // object folds to a boolean — jz has no prototype objects, so identity against one
+  // is decided statically. The one exception is `obj.M <eq> Ctor.prototype.M`: that
+  // probes whether `obj` overrides the builtin `M`, so it lowers to a runtime
+  // `obj.hasOwnProperty('M')` (equal ⇒ not overridden, unequal ⇒ overridden).
+  '=='(a, b) { const own = methodOverrideHasOwn(a, b); if (own) return ['!', own]; return isProto(a) || isProto(b) ? 1 : ['==', transform(a), transform(b)] },
+  '!='(a, b) { const own = methodOverrideHasOwn(a, b); if (own) return own; return isProto(a) || isProto(b) ? 0 : ['!=', transform(a), transform(b)] },
+  '==='(a, b) { const own = methodOverrideHasOwn(a, b); if (own) return ['!', own]; if (isProto(a) || isProto(b)) return 1 },
+  '!=='(a, b) { const own = methodOverrideHasOwn(a, b); if (own) return own; if (isProto(a) || isProto(b)) return 0 },
 
   // new → call (keep TypedArrays)
   'new'(ctor, ...cargs) {
@@ -1474,18 +1478,12 @@ function cloneAst(node) {
   return node.map(cloneAst)
 }
 
-function stripTerminalSwitchBreak(body) {
-  if (!Array.isArray(body)) return body
-  if (body[0] === 'break') return null
-  if (body[0] === '{}') {
-    const inner = stripTerminalSwitchBreak(body[1])
-    if (inner == null) return ['{}', [';']]
-    return ['{}', Array.isArray(inner) && inner[0] === ';' ? inner : [';', inner]]
-  }
-  if (body[0] !== ';') return body
-
-  const stmts = body.slice(1)
-  if (Array.isArray(stmts.at(-1)) && stmts.at(-1)[0] === 'break') stmts.pop()
+/** Flatten a switch clause body to a single node, dropping ASI position markers.
+ * Unlike a plain statement list this keeps any `break` intact — transformSwitch
+ * needs the breaks to gate fall-through; it rewrites them to a sticky flag. */
+function normalizeCaseBody(body) {
+  if (!Array.isArray(body) || body[0] !== ';') return body
+  const stmts = body.slice(1).filter(s => s != null && typeof s !== 'number')
   return stmts.length === 0 ? null : stmts.length === 1 ? stmts[0] : [';', ...stmts]
 }
 
@@ -1523,31 +1521,60 @@ function rewriteSwitchBreaks(node, flag) {
   return node.map((part, i) => i === 0 ? part : rewriteSwitchBreaks(part, flag))
 }
 
-/** Transform switch statement to if/else chain. */
+/** Transform a switch into structured control flow with faithful fall-through.
+ *
+ * A pure if/else-if chain (the former lowering) can't express fall-through,
+ * stacked labels, or a `default` clause that isn't last \u2014 it ran only the first
+ * matching body. The correct model is two-phase, evaluated once with no goto:
+ *
+ *   1. ENTRY \u2014 compare the discriminant against each `case` label in source
+ *      order; the first `===` match fixes the entry index. No case matches \u2192
+ *      entry = the `default` clause's source index (or past-end if none).
+ *   2. RUN \u2014 walk clauses in source order; `entry <= i` runs clause i, so every
+ *      clause from the entry onward executes (fall-through). A `break` flips the
+ *      sticky `brk` flag (via rewriteSwitchBreaks) and gates the rest.
+ *
+ * The discriminant is bound to a temp only when re-reading it isn't free/safe; a
+ * bare identifier is compared directly \u2014 a synthetic temp would shed its STRING
+ * val-type and mis-fold string `case`s to `false` under strict-=== folding. */
 let swIdx = 0
 function transformSwitch(discriminant, cases) {
   const disc = transform(discriminant)
-  const tmp = `\uE000sw${swIdx++}`
+  const simple = typeof disc === 'string' || (Array.isArray(disc) && disc[0] == null)
+  const tmp = simple ? disc : `\uE000sw${swIdx++}`
+  const start = `\uE000swst${swIdx++}`
   const needsBreakFlag = cases.some(c => hasOwnSwitchBreak(c[0] === 'case' ? c[2] : c[1]))
   const brk = needsBreakFlag ? `\uE000swbrk${swIdx++}` : null
 
-  // Collect case/default
-  const stmts = [['let', ['=', tmp, disc]]]
-  if (brk) stmts.push(['let', ['=', brk, [null, false]]])
-  let chain = null
+  const n = cases.length
+  let defaultIdx = -1
+  const bodies = cases.map((c, i) => {
+    if (c[0] === 'default') { defaultIdx = i; return transform(c[1]) }
+    return transform(c[2])
+  })
 
-  for (let i = cases.length - 1; i >= 0; i--) {
-    const c = cases[i]
-    if (c[0] === 'default') {
-      const body = transform(c[1])
-      chain = brk ? rewriteSwitchBreaks(body, brk) : body
-    } else if (c[0] === 'case') {
-      const cond = ['===', tmp, transform(c[1])]
-      const body = transform(c[2])
-      const lowered = brk ? rewriteSwitchBreaks(body, brk) : body
-      chain = chain != null ? ['if', cond, lowered, chain] : ['if', cond, lowered]
-    }
+  const stmts = []
+  if (!simple) stmts.push(['let', ['=', tmp, disc]])
+
+  // Phase 1 \u2014 entry index. Init to default's position (or n = "no clause runs"),
+  // then let the first matching label override it via an if/else-if chain.
+  stmts.push(['let', ['=', start, [null, defaultIdx >= 0 ? defaultIdx : n]]])
+  let chain = null
+  for (let i = n - 1; i >= 0; i--) {
+    if (cases[i][0] !== 'case') continue
+    const hit = ['=', start, [null, i]]
+    const cond = ['===', tmp, transform(cases[i][1])]
+    chain = chain != null ? ['if', cond, hit, chain] : ['if', cond, hit]
   }
   if (chain) stmts.push(chain)
+  if (brk) stmts.push(['let', ['=', brk, [null, false]]])
+
+  // Phase 2 \u2014 run clauses from the entry index, falling through until a break.
+  for (let i = 0; i < n; i++) {
+    if (bodies[i] == null) continue
+    const body = brk ? rewriteSwitchBreaks(bodies[i], brk) : bodies[i]
+    const reached = ['<=', start, [null, i]]
+    stmts.push(['if', brk ? ['&&', ['!', brk], reached] : reached, body])
+  }
   return [';', ...stmts]
 }

package/src/prepare.js

@@ -91,6 +91,13 @@ const addHostImport = (mod, name, alias, spec) => {
 
 const isImportMeta = node => Array.isArray(node) && node[0] === '.' && node[1] === 'import' && node[2] === 'meta'
 const isImportMetaProp = (node, prop) => Array.isArray(node) && node[0] === '.' && isImportMeta(node[1]) && node[2] === prop
+// In a pure boolean position (consumer reads only truthiness) `!!e` is exactly `e`.
+// Drop redundant double-negation; recurse so `!!!!e → e`. NOT valid for `&&`/`||`
+// operands — those are value-preserving (`!!a && b` returns `false`, not `a`).
+const stripBoolNot = c => {
+  while (Array.isArray(c) && c[0] === '!' && Array.isArray(c[1]) && c[1][0] === '!') c = c[1][1]
+  return c
+}
 const stringValue = node => Array.isArray(node) && node[0] == null && typeof node[1] === 'string' ? node[1] : null
 const flatArgs = args => args.length === 1 && Array.isArray(args[0]) && args[0][0] === ',' ? args[0].slice(1) : args
 const MUTATING_ARRAY_METHODS = new Set(['copyWithin', 'fill', 'pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'])
@@ -1357,13 +1364,13 @@ const handlers = {
 
   // Block-scoped control flow: push scope for bodies so inner let/const shadows correctly
   'if': (cond, then, els) => {
-    const c = prep(cond)
+    const c = prep(stripBoolNot(cond))
     pushScope(); const t = prep(then); popScope()
     if (els != null) { pushScope(); const e = prep(els); popScope(); return ['if', c, t, e] }
     return ['if', c, t]
   },
   'while': (cond, body) => {
-    const c = prep(cond)
+    const c = prep(stripBoolNot(cond))
     pushScope(); const b = prep(body); popScope()
     return ['while', c, b]
   },
@@ -1555,7 +1562,7 @@ const handlers = {
   },
 
   // Ternary: parser emits '?' not '?:'
-  '?'(cond, then, els) { return ['?:', prep(cond), prep(then), prep(els)] },
+  '?'(cond, then, els) { return ['?:', prep(stripBoolNot(cond)), prep(then), prep(els)] },
 
   // ++/-- prefix vs postfix: parser sends trailing null for postfix
   // Postfix i++ = (++i) - 1: increment happens, arithmetic recovers old value
@@ -1721,6 +1728,7 @@ const handlers = {
     let r
     if (Array.isArray(head) && head[0] === ';') {
       let [, init, cond, step] = head
+      cond = stripBoolNot(cond)
       // Hoist .length / .size / .byteLength from for-condition:
       //   `i < arr.length` → `let __len = arr.length | 0; ... i < __len`
       // The `| 0` forces i32 even for unknown-typed receivers (where __length