jz 0.4.0 → 0.5.1

package/src/prepare.js

@@ -24,9 +24,9 @@
 
 import { parse } from 'subscript/feature/jessie'
 import { ctx, err, derive } from './ctx.js'
-import { T, STMT_OPS, VAL, valTypeOf, typedElemCtor, extractParams, collectParamNames, classifyParam, observeNodeFacts, staticPropertyKey } from './analyze.js'
+import { T, STMT_OPS, VAL, extractParams, collectParamNames, classifyParam, observeNodeFacts, staticObjectProps, staticPropertyKey } from './analyze.js'
+import { recordGlobalRep } from './infer.js'
 import { isFuncRef } from './ir.js'
-import { fuseSparseMapReads } from './fuse.js'
 import {
   CTORS, TIMER_NAMES,
   hasModule, includeModule,
@@ -38,6 +38,8 @@ import {
 
 let depth = 0  // arrow nesting depth (0=top-level, >0=inside function)
 let scopes = []  // block scope stack: [{names: Set, renames: Map}]
+let staticConstScopes = []  // lexical const facts: [{strings: Map, arrays: Map}]
+let assignedStaticGlobals = null
 // Per-arrow set of names already declared anywhere in the function body. Used
 // to force a rename when the same identifier is declared in two sibling blocks
 // (else-if arms, separate { ... } chunks): without renaming, both decls lower
@@ -89,10 +91,106 @@ 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'])
 
+function staticStringArrayValues(expr) {
+  if (!Array.isArray(expr) || expr[0] !== '[]' || expr.length !== 2) return null
+  const raw = Array.isArray(expr[1]) && expr[1][0] === ',' ? expr[1].slice(1) : [expr[1]]
+  const out = []
+  for (const item of raw) {
+    const s = staticStringExpr(item)
+    if (s == null) return null
+    out.push(s)
+  }
+  return out
+}
+
+function immediateStaticStringExpr(node) {
+  const lit = stringValue(node)
+  if (lit != null) return lit
+  if (Array.isArray(node) && node[0] === 'str' && typeof node[1] === 'string') return node[1]
+  if (!Array.isArray(node)) return null
+  const [op, ...args] = node
+  if (op === '+') {
+    const a = immediateStaticStringExpr(args[0])
+    const b = immediateStaticStringExpr(args[1])
+    return a != null && b != null ? a + b : null
+  }
+  if (op === '`') {
+    let out = ''
+    for (const part of args) {
+      const s = immediateStaticStringExpr(part)
+      if (s == null) return null
+      out += s
+    }
+    return out
+  }
+  return null
+}
+
+function immediateStaticStringArrayValues(expr) {
+  if (!Array.isArray(expr) || expr[0] !== '[]' || expr.length !== 2) return null
+  const raw = Array.isArray(expr[1]) && expr[1][0] === ',' ? expr[1].slice(1) : [expr[1]]
+  const out = []
+  for (const item of raw) {
+    const s = immediateStaticStringExpr(item)
+    if (s == null) return null
+    out.push(s)
+  }
+  return out
+}
+
+function eachTopLevelStatement(node, fn) {
+  if (Array.isArray(node) && node[0] === ';') {
+    for (let i = 1; i < node.length; i++) fn(node[i])
+  } else {
+    fn(node)
+  }
+}
+
+function collectAssignmentWrites(node, writes) {
+  if (!Array.isArray(node)) return
+  const [op, lhs] = node
+  if (op === '=' && typeof lhs === 'string') writes.set(lhs, (writes.get(lhs) || 0) + 1)
+  if ((op === '++' || op === '--') && typeof lhs === 'string') writes.set(lhs, (writes.get(lhs) || 0) + 1)
+  for (let i = 1; i < node.length; i++) collectAssignmentWrites(node[i], writes)
+}
+
+function collectTopLevelStaticAssignments(node, facts) {
+  if (!Array.isArray(node)) return
+  if (node[0] === ',') {
+    for (let i = 1; i < node.length; i++) collectTopLevelStaticAssignments(node[i], facts)
+    return
+  }
+  if (node[0] !== '=' || typeof node[1] !== 'string') return
+  const str = immediateStaticStringExpr(node[2])
+  const arr = immediateStaticStringArrayValues(node[2])
+  if (str != null || arr) facts.set(node[1], { str, arr })
+}
+
+function seedStaticGlobalAssignments(node) {
+  // jzify hoists function declarations ahead of `var` initializer assignments.
+  // Seed one-write static globals before preparing those function bodies so
+  // compile-time-only consumers (for example `new RegExp(`${PART}`)`) can still
+  // resolve the same constants they would see after module initialization.
+  const writes = new Map()
+  const facts = new Map()
+  collectAssignmentWrites(node, writes)
+  eachTopLevelStatement(node, stmt => collectTopLevelStaticAssignments(stmt, facts))
+  for (const [name, fact] of facts) {
+    if (writes.get(name) === 1) bindStaticGlobal(name, fact.str, fact.arr)
+  }
+}
+
 function stringArrayValues(expr) {
   if (!Array.isArray(expr) || expr[0] !== '[' || expr.length === 1) return null
   const out = []
@@ -108,6 +206,63 @@ function staticString(value) {
   return ['str', value]
 }
 
+function lookupStaticString(name) {
+  const resolved = scopes.length && isDeclared(name) ? resolveScope(name) : (ctx.scope.chain[name] || name)
+  for (let i = staticConstScopes.length - 1; i >= 0; i--) {
+    const v = staticConstScopes[i].strings.get(resolved)
+    if (v != null) return v
+  }
+  return ctx.scope.shapeStrs?.get(resolved) ?? ctx.scope.constStrs?.get(resolved) ?? null
+}
+
+function lookupStaticStringArray(name) {
+  const resolved = scopes.length && isDeclared(name) ? resolveScope(name) : (ctx.scope.chain[name] || name)
+  for (let i = staticConstScopes.length - 1; i >= 0; i--) {
+    const v = staticConstScopes[i].arrays.get(resolved)
+    if (v) return v
+  }
+  return ctx.scope.shapeStrArrays?.get(resolved) ?? null
+}
+
+function staticStringExpr(node) {
+  const lit = stringValue(node)
+  if (lit != null) return lit
+  if (Array.isArray(node) && node[0] === 'str' && typeof node[1] === 'string') return node[1]
+  if (typeof node === 'string') return lookupStaticString(node)
+  if (!Array.isArray(node)) return null
+  const [op, ...args] = node
+  if (op === '+') {
+    const a = staticStringExpr(args[0])
+    const b = staticStringExpr(args[1])
+    return a != null && b != null ? a + b : null
+  }
+  if (op === '`') {
+    let out = ''
+    for (const part of args) {
+      const s = staticStringExpr(part)
+      if (s == null) return null
+      out += s
+    }
+    return out
+  }
+  if (op === '``' && Array.isArray(args[0]) && args[0][0] === '.' && args[0][1] === 'String' && args[0][2] === 'raw') {
+    let out = ''
+    for (const part of args.slice(1)) {
+      const s = staticStringExpr(part)
+      if (s == null) return null
+      out += s
+    }
+    return out
+  }
+  if (op === '()' && Array.isArray(args[0]) && args[0][0] === '.' && args[0][2] === 'join' && typeof args[0][1] === 'string') {
+    const arr = lookupStaticStringArray(args[0][1])
+    if (!arr) return null
+    const sep = args.length > 1 && args[1] != null ? staticStringExpr(args[1]) : ','
+    return sep != null ? arr.join(sep) : null
+  }
+  return null
+}
+
 function importMetaUrl() {
   if (!ctx.transform.importMetaUrl) err('`import.meta.url` requires compile option `importMetaUrl`')
   return ctx.transform.importMetaUrl
@@ -119,17 +274,6 @@ function resolveImportMeta(spec) {
   catch { err(`Cannot resolve import.meta specifier '${spec}' from '${base}'`) }
 }
 
-function recordGlobalValueFact(name, expr) {
-  if (typeof name !== 'string') return
-  const vt = valTypeOf(expr)
-  if (vt) {
-    ;(ctx.scope.globalValTypes ||= new Map()).set(name, vt)
-    if (vt === VAL.REGEX && ctx.runtime.regex) ctx.runtime.regex.vars.set(name, expr)
-  }
-  const ctor = typedElemCtor(expr)
-  if (ctor) (ctx.scope.globalTypedElem ||= new Map()).set(name, ctor)
-}
-
 function recordModuleInitFacts(root) {
   const facts = ctx.module.initFacts ||= {
     dynVars: new Set(), anyDyn: false, hasSchemaLiterals: false,
@@ -182,10 +326,13 @@ function recordModuleInitFacts(root) {
 export default function prepare(node) {
   depth = 0
   scopes = []
+  staticConstScopes = []
+  assignedStaticGlobals = new Set()
   funcLocalNames = [new Set()]
   includeModule('core')
   normalizeIdents(node)
-  fuseSparseMapReads(node)  // AST-level fusion; needs pre-resolution shape — see src/fuse.js
+  fuseSparseMapReads(node)  // AST-level fusion; needs pre-resolution shape — defined at end of file
+  seedStaticGlobalAssignments(node)
   const ast = prep(node)
   // Top-level functions referenced as first-class values (e.g. `let o = { fn: g }`,
   // `arr.push(g)`, `return g`) need trampoline emission, which depends on the fn
@@ -250,7 +397,7 @@ export default function prepare(node) {
 
   // Invalidate shapeStrs for any module-level binding that's later assigned to.
   // shapeStrs is "effectively-const string literals at module scope" — used by
-  // analyze.js's jsonConstString to enable shape inference on `let SRC = '{...}'`
+  // shape.js's jsonConstString to enable shape inference on `let SRC = '{...}'`
   // patterns (bench convention) without enabling the const-only static fold.
   // The scan must skip `=` nodes that are children of `let`/`const`/`export` —
   // those are decl-initializers, not reassignments.
@@ -281,7 +428,7 @@ export default function prepare(node) {
 
 // Named constants → numeric literals
 export const JZ_NULL = Symbol('null')
-const CONSTANTS = { 'true': 1, 'false': 0, 'null': JZ_NULL, 'undefined': JZ_NULL }
+const CONSTANTS = { 'true': true, 'false': false, 'null': JZ_NULL, 'undefined': JZ_NULL }
 // NaN/Infinity stay as special f64 values in emit()
 const F64_CONSTANTS = { 'NaN': NaN, 'Infinity': Infinity }
 
@@ -297,6 +444,34 @@ function isDeclared(name) {
   return scopes.some(s => s.has(name))
 }
 
+function pushScope(scope = new Map()) {
+  scopes.push(scope)
+  staticConstScopes.push({ strings: new Map(), arrays: new Map() })
+}
+
+function popScope() {
+  scopes.pop()
+  staticConstScopes.pop()
+}
+
+function bindStaticConst(name, str, arr) {
+  const frame = staticConstScopes.at(-1)
+  if (!frame || typeof name !== 'string') return
+  if (str != null) frame.strings.set(name, str)
+  if (arr) frame.arrays.set(name, arr)
+}
+
+function bindStaticGlobal(name, str, arr) {
+  if (typeof name !== 'string') return
+  if (str != null) (ctx.scope.shapeStrs ||= new Map()).set(name, str)
+  if (arr) (ctx.scope.shapeStrArrays ||= new Map()).set(name, arr)
+}
+
+function deleteStaticGlobal(name) {
+  ctx.scope.shapeStrs?.delete(name)
+  ctx.scope.shapeStrArrays?.delete(name)
+}
+
 const hasFunc = name => ctx.func.names.has(name)
 
 const renameFunc = (func, nextName) => {
@@ -307,33 +482,81 @@ const renameFunc = (func, nextName) => {
 
 /** Map JS typeof strings to jz type checks. Codes < 0 trigger specialized emitTypeofCmp paths. */
 const TYPEOF_MAP = { 'number': -1, 'string': -2, 'undefined': -3, 'boolean': -4, 'object': -5, 'function': -6, 'bigint': -7 }
+// Spec §13.5.3: `typeof undeclared_x` returns 'undefined' without throwing.
+// True iff `name` is a bare identifier with no resolution path. Mirrors the
+// resolution chain inside `prep()` so we don't speculate emit-time failures.
+function isUnresolvableBareIdent(name) {
+  if (typeof name !== 'string') return false
+  if (name in CONSTANTS || name in F64_CONSTANTS) return false
+  if (name === 'Boolean' || name === 'Number') return false
+  if (PROHIBITED[name]) return false
+  if (scopes.length && isDeclared(name)) return false
+  if (ctx.scope.chain[name]) return false
+  if (GLOBALS[name]) return false
+  if (ctx.func.names.has(name)) return false
+  if (ctx.func?.locals?.has?.(name)) return false
+  // Top-level decls live in ctx.scope.globals / userGlobals (set by prepDecl at
+  // depth 0). Current arrow's local names are tracked in funcLocalNames.
+  if (ctx.scope.globals?.has?.(name)) return false
+  if (ctx.scope.userGlobals?.has?.(name)) return false
+  const fnNames = funcLocalNames[funcLocalNames.length - 1]
+  if (fnNames?.has(name)) return false
+  return true
+}
 // Constant fold typeof for known builtin namespaces (e.g. Math.exp). prep(x) resolves Math.exp → 'math.exp'.
 function staticTypeofString(x) {
+  // Spec §13.5.3: unresolvable bare ref → 'undefined'.
+  if (isUnresolvableBareIdent(x)) return 'undefined'
   // Bare callable global: parseInt, parseFloat, isNaN, isFinite, Error, BigInt, etc.
   if (typeof x === 'string' && !ctx.func?.locals?.has(x) && GLOBALS[x] && ctx.core.emit?.[x]?.length > 0) return 'function'
   const px = prep(x)
   if (typeof px === 'string' && px.includes('.') && ctx.core.emit?.[px]?.length > 0) return 'function'
   return null
 }
+// Builtin-namespace constructors expose `prototype`/`length`/`name` as own
+// properties; plain namespaces (Math, JSON, Reflect, Atomics) do not.
+const NS_CTORS = new Set(['Number', 'String', 'Boolean', 'BigInt', 'Object',
+  'Array', 'Symbol', 'Error', 'Date', 'RegExp', 'Function', 'Map', 'Set',
+  'Promise', 'ArrayBuffer', 'DataView', 'WeakMap', 'WeakSet'])
+// `NS.hasOwnProperty("member")` is a compile-time question: jz models a
+// builtin namespace as a set of emit keys, so a member is owned iff jz emits
+// it — plus the universal constructor trio for constructor namespaces.
+function namespaceHasOwn(mod, name, member) {
+  if (ctx.core.emit[`${mod}.${member}`] != null) return true
+  return NS_CTORS.has(name) && (member === 'prototype' || member === 'length' || member === 'name')
+}
 function resolveTypeof(node) {
   const [op, a, b] = node
+  // `typeof` always yields a string, so `==`/`===` (and `!=`/`!==`) are
+  // equivalent here — both collapse to the same type check.
+  const eqLike = op === '==' || op === '==='
   // typeof x == 'string' → type check
   if (Array.isArray(a) && a[0] === 'typeof' && Array.isArray(b) && b[0] == null && typeof b[1] === 'string') {
     const known = staticTypeofString(a[1])
-    if (known != null) return [, op === '==' ? known === b[1] : known !== b[1]]
+    if (known != null) return [, eqLike ? known === b[1] : known !== b[1]]
     const code = TYPEOF_MAP[b[1]]
     if (code != null) return [op, ['typeof', a[1]], [, code]]
   }
   // 'string' == typeof x
   if (Array.isArray(b) && b[0] === 'typeof' && Array.isArray(a) && a[0] == null && typeof a[1] === 'string') {
     const known = staticTypeofString(b[1])
-    if (known != null) return [, op === '==' ? known === a[1] : known !== a[1]]
+    if (known != null) return [, eqLike ? known === a[1] : known !== a[1]]
     const code = TYPEOF_MAP[a[1]]
     if (code != null) return [op, ['typeof', b[1]], [, code]]
   }
   return node
 }
 
+// Prepare a strict `===`/`!==`. resolveTypeof may fold `typeof x === 'type'` to a
+// literal or rewrite it to a numeric-code compare; either way we prep the result's
+// operands directly. The strict op stays intact (no collapse to loose `==`) so
+// emit can apply the no-coercion type-mismatch fold.
+function prepStrictEq(op, a, b) {
+  const r = resolveTypeof([op, a, b])
+  if (r[0] !== op) return prep(r)            // folded to a literal — re-prep is safe
+  return [op, prep(r[1]), prep(r[2])]        // keep strict op; prep operands only
+}
+
 const cloneNode = (node) => {
   if (!Array.isArray(node)) return node
   const copy = node.map(cloneNode)
@@ -341,12 +564,40 @@ const cloneNode = (node) => {
   return copy
 }
 
+/** True if `node` contains a `break`/`continue` that belongs to it — i.e. not
+ *  one nested inside its own function. (Nested loops are intentionally counted:
+ *  an over-detection only opts into the safe frame-carrying lowering below.) */
+const hasLoopJump = (node) => {
+  if (!Array.isArray(node)) return false
+  const op = node[0]
+  if (op === 'break' || op === 'continue') return true
+  if (op === '=>' || op === 'function') return false
+  return node.some(hasLoopJump)
+}
+
+/** Retarget a for-in iteration's *own* unlabeled `break`/`continue` to explicit
+ *  block labels — `break` to the construct-wide label, `continue` to this
+ *  iteration's label. Nested loops/functions own their jumps and are skipped;
+ *  labeled jumps already name their target and are left untouched. */
+const retargetLoopJumps = (node, brkLabel, contLabel) => {
+  if (!Array.isArray(node)) return node
+  const op = node[0]
+  if (op === 'break' && node.length === 1) return ['break', brkLabel]
+  if (op === 'continue' && node.length === 1) return ['break', contLabel]
+  if (op === 'for' || op === 'for-in' || op === 'while' || op === 'do'
+      || op === '=>' || op === 'function') return node
+  return node.map(c => retargetLoopJumps(c, brkLabel, contLabel))
+}
+
 function prep(node) {
   if (Array.isArray(node)) includeForOp(node[0])
   if (Array.isArray(node) && node.loc != null) ctx.error.loc = node.loc
   if (node == null) return [, 0] // null/undefined → 0 literal
-  if (node === true) return [, 1]
-  if (node === false) return [, 0]
+  // Keep boolean identity (was folded to 1/0). The working representation is
+  // still i32/f64 0/1 — emit lowers the raw boolean — but valTypeOf now reads
+  // VAL.BOOL off the literal, so typeof/String/JSON/host boundary stay faithful.
+  if (node === true) return [, true]
+  if (node === false) return [, false]
   if (!Array.isArray(node)) {
     if (typeof node === 'string') {
       if (node in CONSTANTS) return [, CONSTANTS[node]]
@@ -379,7 +630,11 @@ function prep(node) {
   return handler ? handler(...args) : [op, ...args.map(prep)]
 }
 
-// FIXME: can we jzify some of these?
+// Strict-jz prohibitions. `class` and `arguments` are *also* listed here but
+// only reach this point when jzify is off — jzify lowers `class` to a factory
+// arrow and rewrites `arguments` to a rest param before prepare runs. The
+// remainder (`with`, `this`, `super`, `yield`, `eval`) have no safe lowering
+// and stay errors in both modes.
 const PROHIBITED = { 'with': '`with` not supported', 'class': '`class` not supported', 'yield': '`yield` not supported',
   'this': '`this` not supported: use explicit parameter',
   'super': '`super` not supported: no class inheritance',
@@ -405,7 +660,21 @@ export const GLOBALS = {
   isFinite: 'number',
   parseInt: 'number',
   parseFloat: 'number',
+  encodeURIComponent: 'encodeURIComponent',
+  decodeURIComponent: 'decodeURIComponent',
   Error: 'Error',
+  // Error subclasses: distinct names in JS, but jz doesn't carry typed error
+  // info — `throw` accepts any value and stringification goes through the
+  // host. Treat them all as Error-shaped passthrough constructors so user
+  // code that throws specific subclasses (`throw new SyntaxError(msg)`) compiles
+  // identically. If we ever model `instanceof SyntaxError`, this is where to
+  // distinguish them; until then the surfaced message is what matters.
+  TypeError: 'Error',
+  SyntaxError: 'Error',
+  RangeError: 'Error',
+  ReferenceError: 'Error',
+  URIError: 'Error',
+  EvalError: 'Error',
   BigInt: 'BigInt',
   TextEncoder: 'TextEncoder',
   TextDecoder: 'TextDecoder',
@@ -442,6 +711,27 @@ function scalarArrayDestruct(pattern, rhs) {
   return prep([';', ['let', ...decls], ...assigns])
 }
 
+function declareGlobal(name, user = true) {
+  if (depth !== 0 || typeof name !== 'string') return name
+  if (ctx.scope.globals.has(name)) err(`'${name}' conflicts with a compiler internal — choose a different name`)
+  ctx.scope.globals.set(name, `(global $${name} (mut f64) (f64.const 0))`)
+  if (user) ctx.scope.userGlobals.add(name)
+  return name
+}
+
+function bindingNames(pattern, out = new Set()) {
+  if (typeof pattern === 'string') out.add(pattern)
+  else if (Array.isArray(pattern)) {
+    if (pattern[0] === '...' && typeof pattern[1] === 'string') out.add(pattern[1])
+    else if (pattern[0] === '=') bindingNames(pattern[1], out)
+    else if (pattern[0] === ':') bindingNames(pattern[2], out)
+    else if (pattern[0] === '[]' || pattern[0] === '{}' || pattern[0] === ',') {
+      for (const item of pattern.slice(1)) bindingNames(item, out)
+    }
+  }
+  return out
+}
+
 function pushPatternAssign(target, valueExpr, out, decls = null) {
   if (Array.isArray(target) && target[0] === '=') {
     pushPatternAssign(target[1], ['??', valueExpr, prep(target[2])], out, decls)
@@ -556,19 +846,51 @@ function prepDecl(op, ...inits) {
         if (ctx.scope.globals.has(declName)) err(`'${declName}' conflicts with a compiler internal — choose a different name`)
         ctx.scope.globals.set(declName, `(global $${declName} (mut f64) (f64.const 0))`)
         ctx.scope.userGlobals.add(declName)
+      } else if (typeof declName === 'string') {
+        // Bare hoisted decl inside a function (var X jzified to `let X` at top
+        // of arrow + a later `X = …` assignment). Without registering here, the
+        // name is invisible to scope predicates like `isUnresolvableBareIdent`
+        // until the assignment runs — which is after any reference to it.
+        const fnNames = funcLocalNames[funcLocalNames.length - 1]
+        if (fnNames) fnNames.add(declName)
+        if (scopes.length > 0) scopes[scopes.length - 1].set(declName, declName)
       }
       rest.push(declName)
       continue
     }
-    const [, name, init] = i, normed = prep(init)
+    const [, name, init] = i
+    const staticStr = op === 'const' ? staticStringExpr(init) : null
+    const staticArr = op === 'const' ? staticStringArrayValues(init) : null
+    const normed = prep(init)
 
     if (isDestructPattern(name)) {
+      // Register each binding both as a module global (depth 0) and in the
+      // current arrow's local scope (depth ≠ 0). Without the local registration
+      // the name is invisible to `isUnresolvableBareIdent`, so a later
+      // `typeof x` would mis-fold to 'undefined' (spec §13.5.3) before emit ever
+      // sees the binding — see the bare-hoisted-decl branch above for the same fix.
+      const fnNames = funcLocalNames[funcLocalNames.length - 1]
+      for (const n of bindingNames(name)) {
+        declareGlobal(n)
+        if (depth !== 0 && typeof n === 'string') {
+          if (fnNames) fnNames.add(n)
+          if (scopes.length > 0) scopes[scopes.length - 1].set(n, n)
+        }
+      }
+      // A bare-identifier source needs no temp: reads are idempotent and
+      // side-effect-free, so we destructure straight off it. This keeps each
+      // element's static type tag (e.g. `let [, x] = strs` resolves `x` to the
+      // same STRING that `strs[1]` would) — a copy temp drops the array's
+      // element-type shape and `typeof x` would degrade to 'undefined'.
+      if (typeof normed === 'string') {
+        expandDestruct(name, normed, rest)
+        continue
+      }
       const tmp = `${T}d${ctx.func.uniq++}`
+      declareGlobal(tmp, false)
       rest.push(['=', tmp, normed])
       // Propagate schema to temp so rest destructuring can resolve it
-      if (typeof normed === 'string' && ctx.schema.vars.has(normed))
-        ctx.schema.vars.set(tmp, ctx.schema.vars.get(normed))
-      else if (Array.isArray(normed) && normed[0] === '{}') {
+      if (Array.isArray(normed) && normed[0] === '{}') {
         const p = normed.slice(1).filter(p => Array.isArray(p) && p[0] === ':').map(p => p[1])
         if (p.length) ctx.schema.vars.set(tmp, ctx.schema.register(p))
       }
@@ -590,18 +912,19 @@ function prepDecl(op, ...inits) {
         scopes[scopes.length - 1].set(name, name)
       }
       if (typeof declName === 'string' && fnNames) fnNames.add(declName)
+      if (op === 'const') bindStaticConst(declName, staticStr, staticArr)
       // Track const for reassignment checks — only module-scope consts (depth 0)
       if (typeof declName === 'string' && depth === 0) {
         if (ctx.module.currentPrefix) {
           declName = `${ctx.module.currentPrefix}$${declName}`
           ctx.scope.chain[name] = declName
         }
+        if (op === 'const') bindStaticGlobal(declName, staticStr, staticArr)
         if (op === 'const') {
           if (!ctx.scope.consts) ctx.scope.consts = new Set()
           ctx.scope.consts.add(declName)
-          if (Array.isArray(normed) && normed[0] === 'str' && typeof normed[1] === 'string')
-            (ctx.scope.constStrs ||= new Map()).set(declName, normed[1])
-          const strs = stringArrayValues(normed)
+          if (staticStr != null) (ctx.scope.constStrs ||= new Map()).set(declName, staticStr)
+          const strs = staticArr || stringArrayValues(normed)
           if (strs) (ctx.scope.shapeStrArrays ||= new Map()).set(declName, strs)
         } else if (op === 'let' && ctx.scope.consts?.has(declName)) {
           ctx.scope.consts.delete(declName)
@@ -614,7 +937,7 @@ function prepDecl(op, ...inits) {
         // entry whose name is later assigned to.
         if (Array.isArray(normed) && normed[0] === 'str' && typeof normed[1] === 'string')
           (ctx.scope.shapeStrs ||= new Map()).set(declName, normed[1])
-        recordGlobalValueFact(declName, normed)
+        recordGlobalRep(declName, normed)
       }
       // Track object schemas (after prefix so schema is keyed to final name)
       if (typeof declName === 'string' && Array.isArray(normed) && normed[0] === '{}' && normed.length > 1) {
@@ -641,6 +964,119 @@ function prepDecl(op, ...inits) {
   return rest.length ? [op, ...rest] : null
 }
 
+// --- `'()'` call-handler helpers --------------------------------------------
+// The call handler is a thin dispatcher: it tries the compile-time folds
+// below (each gated by callee shape, so at most one fires), then resolves the
+// callee, then assembles the call. Each helper moves one concern out of line.
+
+// `import.meta.resolve("spec")` → the resolved URL as a static string.
+function foldImportMetaResolve(callee, args) {
+  if (!isImportMetaProp(callee, 'resolve')) return undefined
+  const callArgs = flatArgs(args).filter(a => a != null)
+  if (callArgs.length !== 1) err('`import.meta.resolve` requires one string literal argument')
+  const spec = stringValue(callArgs[0])
+  if (spec == null) err('`import.meta.resolve` supports only string literal arguments')
+  return staticString(resolveImportMeta(spec))
+}
+
+// String-callee constructor / named-builtin folds: `Array(n)` and the `CTORS`
+// set redirect to the `new` handler; `BigInt64Array`/`BigUint64Array` build a
+// direct module call. `includeForNamedCall` is probed for every string callee
+// — that probe is also how a module-backed builtin gets its modules included.
+// Returns the replacement IR, or `undefined` for an ordinary call.
+function dispatchConstructorCall(callee, args) {
+  if (typeof callee !== 'string') return undefined
+  if (callee === 'Array') {
+    const callArgs = flatArgs(args).filter(a => a != null)
+    if (callArgs.length === 1) return handlers['new'](['()', callee, callArgs[0]])
+  }
+  if (CTORS.includes(callee)) return handlers['new'](['()', callee, ...args])
+  if (includeForNamedCall(callee) && (callee === 'BigInt64Array' || callee === 'BigUint64Array'))
+    return ['()', callee, ...args.filter(a => a != null).map(prep)]
+  return undefined
+}
+
+// Compile-time namespace introspection on a `obj.prop(...)` callee:
+// `Array.isArray(NS)` on a bare builtin global folds to `false` (a namespace
+// value is never an array); `NS.hasOwnProperty("member")` on a builtin
+// namespace folds to a literal — no runtime namespace object. Returns the
+// folded literal IR, or `undefined` when nothing folds.
+function foldNamespaceIntrospection(callee, args) {
+  if (!Array.isArray(callee) || callee[0] !== '.') return undefined
+  const [, obj, prop] = callee
+  if (obj === 'Array' && prop === 'isArray') {
+    const cargs = flatArgs(args).filter(a => a != null)
+    const a0 = cargs.length === 1 ? cargs[0] : null
+    if (typeof a0 === 'string' && GLOBALS[a0] && !(scopes.length && isDeclared(a0)) && !hasFunc(a0))
+      return [, 0]
+  }
+  if (prop === 'hasOwnProperty' && typeof obj === 'string' && !(scopes.length && isDeclared(obj))) {
+    const mod = ctx.scope.chain[obj]
+    if (mod && !mod.includes('.') && hasModule(mod)) {
+      const cargs = flatArgs(args).filter(a => a != null)
+      const member = cargs.length === 1 ? stringValue(cargs[0]) : null
+      // Include the module so its emit keys (the namespace's member set) are
+      // registered; unreferenced emitters/data dead-strip in compile.
+      if (member != null) { includeModule(mod); return [, namespaceHasOwn(mod, obj, member) ? 1 : 0] }
+    }
+  }
+  return undefined
+}
+
+// Resolve a callee to its lowered form, triggering module autoloads along the
+// way: a bare identifier through the scope chain, an `obj.prop` member call
+// through host imports / named-call / generic-method / namespace tables, and
+// any other expression through `prep` (a callable runtime value).
+function resolveCallee(callee, args) {
+  if (typeof callee === 'string') {
+    const local = scopes.length && isDeclared(callee)
+    const resolved = local ? null : ctx.scope.chain[callee]
+    if (local) return resolveScope(callee)
+    if (resolved?.includes('.')) return resolved
+    if (resolved && hasFunc(resolved)) return resolved
+    if (resolved && !resolved.includes('.')) {
+      if (hasModule(resolved) && !ctx.module.imports.some(i => i[3]?.[1] === `$${resolved}`)) includeModule(resolved)
+      return callee
+    }
+    if (depth > 0 && !resolved && !ctx.func.exports[callee] && !ctx.module.imports.some(i => i[3]?.[1] === `$${callee}`))
+      includeForCallableValue()
+    return callee
+  }
+  if (Array.isArray(callee) && callee[0] === '.') {
+    const [, obj, prop] = callee
+    const key = typeof obj === 'string' && typeof prop === 'string' ? `${obj}.${prop}` : null
+    if (key && ctx.module.hostImports?.[obj]?.[prop]) {
+      const spec = ctx.module.hostImports[obj][prop]
+      const alias = `${obj}$${prop}`
+      addHostImport(obj, prop, alias, spec)
+      return alias
+    }
+    if (key && includeForNamedCall(key)) return key
+    if (includeForGenericMethod(prop)) return prep(callee)
+    const mod = ctx.scope.chain[obj]
+    if (typeof obj === 'string' && mod && !mod.includes('.') && hasModule(mod))
+      return (includeModule(mod), mod + '.' + prop)
+    return prep(callee)
+  }
+  includeForCallableValue()
+  return prep(callee)
+}
+
+// A lone parenthesized comma-expression argument — `f((a, b, c))` — is ONE
+// argument whose value is the last comma operand. The parser keeps it wrapped
+// (`['()', [',', …]]`); prep would strip the grouping, leaving a bare comma
+// that emit can no longer tell apart from an arg list and splats into N args.
+// With ≥2 args an outer arg-list comma already nests it — only the sole-arg
+// case loses the distinction. Re-nest it under a 1-element arg-list comma.
+function renestSoleCommaArg(args) {
+  if (args.length === 1 && Array.isArray(args[0]) && args[0][0] === '()' && args[0].length === 2) {
+    const ungroup = n => Array.isArray(n) && n[0] === '()' && n.length === 2 ? ungroup(n[1]) : n
+    const core = ungroup(args[0])
+    if (Array.isArray(core) && core[0] === ',') return [[',', args[0]]]
+  }
+  return args
+}
+
 const handlers = {
   // Spread operator: [...expr] in arrays, f(...args) in calls, {...obj} in objects
   '...'(expr) {
@@ -655,11 +1091,23 @@ const handlers = {
   'class': () => err('class not supported: use object literals'),
   'yield': () => err('generators not supported: use loops'),
   'debugger': () => null,
-  'delete': () => err('delete not supported: object shape is fixed'),
+  // Static-key delete (.x, ["x"], [literal]) would change the fixed schema → reject.
+  // Computed-key delete (obj[expr]) — including jessie's `delete ctx[k]` — lowers
+  // to runtime __dyn_del against the per-object shadow property store.
+  'delete'(target) {
+    const t = prep(target)
+    if (Array.isArray(t) && t[0] === '[]' && t.length === 3) {
+      const key = t[2]
+      const isLiteralKey = Array.isArray(key) && key[0] == null && key.length === 2
+      if (!isLiteralKey) return ['delete', t[1], key]
+    }
+    err('delete not supported: object shape is fixed')
+  },
   'in'(key, obj) { return ['in', prep(key), prep(obj)] },
   'instanceof': () => err('instanceof not supported: use typeof'),
   'with': () => err('`with` not supported: deprecated'),
   ':': () => err('labeled statements not supported'),
+  'label'(name, body) { return ['label', name, prep(body)] },
   'var': () => err('`var` not supported: use let/const'),
   'function': () => err('`function` not supported: use arrow functions'),
 
@@ -681,23 +1129,60 @@ const handlers = {
       expandDestruct(lhs, tmp, stmts, decls)
       return prep([';', ['let', ...decls], ...stmts])
     }
-    // Parser ambiguity: }[pattern] = rhs mis-parsed as subscript when it's stmt; [pattern] = rhs
-    // Detect: ['[]', stmtExpr, commaExpr] with spread in comma → split into stmt + destructuring
-    if (Array.isArray(lhs) && lhs[0] === '[]' && lhs.length === 3) {
-      const hasSpr = n => Array.isArray(n) && (n[0] === '...' || n.some(hasSpr))
-      if (hasSpr(lhs[2])) {
-        const preStmt = lhs[1]
-        const pattern = ['[]', lhs[2]]
-        return prep([';', preStmt, ['=', pattern, rhs]])
+    // Function property assignment: fn.prop = arrow → extract as top-level function fn$prop.
+    // A property can be reassigned — esbuild/jessie wrapper-composition does
+    // `p.s = ...; var old = p.s; p.s = () => old()...`. Each assignment extracts
+    // its own top-level function; the property holds whichever was assigned last,
+    // and an earlier snapshot keeps pointing at the prior one. Collide → fresh name.
+    // The base resolves through the scope chain first so an *imported* function
+    // (mangled to `_mod$fn`) is recognised the same as a local one — the
+    // subscript parser's plugin model mutates `parse.step` etc. across modules,
+    // and a reassignment in module B must mark module A's call sites mutable.
+    if (depth === 0 && Array.isArray(lhs) && lhs[0] === '.' && typeof lhs[1] === 'string'
+      && Array.isArray(rhs) && rhs[0] === '=>') {
+      const fnBase = ctx.scope.chain[lhs[1]] || lhs[1]
+      if (hasFunc(fnBase)) {
+        let name = `${fnBase}$${lhs[2]}`
+        // Reassignment → the property is mutable; record it so `fn.prop()` calls
+        // emit a dynamic property read + indirect call instead of a direct call.
+        if (ctx.func.names.has(name)) {
+          ctx.func.multiProp.add(`${fnBase}.${lhs[2]}`)
+          do name = `${fnBase}$${lhs[2]}$${ctx.func.uniq++}`; while (ctx.func.names.has(name))
+        }
+        // Build the target `.` node directly from the resolved base — re-`prep`ing
+        // the lhs would resolve a multiProp `fn.prop` to an rvalue (closure
+        // materialization block), which is not a valid assignment target.
+        if (defFunc(name, prep(rhs))) return ['=', ['.', fnBase, lhs[2]], name]
       }
     }
-    // Function property assignment: fn.prop = arrow → extract as top-level function fn$prop
-    if (depth === 0 && Array.isArray(lhs) && lhs[0] === '.' && typeof lhs[1] === 'string'
-      && hasFunc(lhs[1]) && Array.isArray(rhs) && rhs[0] === '=>') {
-      const name = `${lhs[1]}$${lhs[2]}`
-      if (defFunc(name, prep(rhs))) return ['=', prep(lhs), name]
+    const staticStr = staticStringExpr(rhs)
+    const staticArr = staticStringArrayValues(rhs)
+    const plhs = prep(lhs)
+    const prhs = prep(rhs)
+    if (depth === 0 && typeof plhs === 'string' && ctx.scope.globals.has(plhs)) {
+      // First assignment fixes the global's representation + object schema.
+      if (!ctx.scope.globalReps?.has(plhs)) {
+        recordGlobalRep(plhs, prhs)
+        if (Array.isArray(prhs) && prhs[0] === '{}') {
+          const props = staticObjectProps(prhs.slice(1))
+          if (props) ctx.schema.vars.set(plhs, ctx.schema.register(props.names))
+        }
+      }
+      // Static string/array facts hold only while every assignment is constant.
+      if (!assignedStaticGlobals.has(plhs) && (staticStr != null || staticArr)) bindStaticGlobal(plhs, staticStr, staticArr)
+      else deleteStaticGlobal(plhs)
+      assignedStaticGlobals.add(plhs)
+    }
+    // Local object-literal assignment to a not-yet-shaped variable — e.g. a `var`
+    // that jzify hoisted into `let x; x = {…}`. Recording the schema here lets the
+    // binding behave like `let x = {…}`: fixed-slot field access and for-in unroll.
+    // First assignment fixes the shape (mirrors the global rule above).
+    else if (typeof plhs === 'string' && Array.isArray(prhs) && prhs[0] === '{}'
+        && !ctx.schema.vars.has(plhs)) {
+      const props = staticObjectProps(prhs.slice(1))
+      if (props) ctx.schema.vars.set(plhs, ctx.schema.register(props.names))
     }
-    return ['=', prep(lhs), prep(rhs)]
+    return ['=', plhs, prhs]
   },
 
   // try/catch/throw
@@ -730,16 +1215,14 @@ const handlers = {
   },
 
   // Tagged template: tag`a${x}b` → tag(['a','b'], x)
-  // Parser drops empty string segments; reinsert them to satisfy the strings.length === exprs.length + 1 invariant.
   '``'(tag, ...parts) {
+    const raw = staticStringExpr(['``', tag, ...parts])
+    if (raw != null) return staticString(raw)
     const strs = [], exprs = []
-    let prev = false
     for (const p of parts) {
-      const isStr = Array.isArray(p) && p[0] == null && typeof p[1] === 'string'
-      if (isStr) { strs.push(p); prev = true }
-      else { if (!prev) strs.push([null, '']); exprs.push(p); prev = false }
+      if (Array.isArray(p) && p[0] == null && typeof p[1] === 'string') strs.push(p)
+      else exprs.push(p)
     }
-    if (!prev) strs.push([null, ''])
     const arr = strs.length === 1 ? ['[]', strs[0]] : ['[]', [',', ...strs]]
     const callArgs = exprs.length === 0 ? arr : [',', arr, ...exprs]
     return prep(['()', tag, callArgs])
@@ -747,6 +1230,9 @@ const handlers = {
 
   // Import
   'import'(fromNode) {
+    // Bare side-effect: `import './sub.js'` → AST is ['import', [null, 'path']]
+    if (Array.isArray(fromNode) && fromNode[0] == null && typeof fromNode[1] === 'string')
+      return handlers['from'](null, fromNode)
     if (!Array.isArray(fromNode) || fromNode[0] !== 'from')
       return err('Dynamic import() not supported')
     return handlers['from'](fromNode[1], fromNode[2])
@@ -863,9 +1349,13 @@ const handlers = {
     err(`Unknown module '${mod}'. Provide it via { modules: { '${mod}': source } } or { imports: { '${mod}': {...} } }`)
   },
 
-  // === is == in jz (all comparisons are strict). Also handle typeof x === 'type' patterns.
-  '==='(a, b) { return prep(resolveTypeof(['==', a, b])) },
-  '!=='(a, b) { return prep(resolveTypeof(['!=', a, b])) },
+  // `===`/`!==` keep strict semantics (no coercion); emit folds a statically-known
+  // type mismatch to false and otherwise shares the loose `==`/`!=` same-type path.
+  // resolveTypeof still collapses `typeof x === 'type'` to a compile-time check.
+  // Prep operands directly (not via `prep` on the node) so the strict op survives
+  // to emit instead of re-dispatching this handler forever.
+  '==='(a, b) { return prepStrictEq('===', a, b) },
+  '!=='(a, b) { return prepStrictEq('!==', a, b) },
 
   // Statements
   ';': (...stmts) => [';', ...stmts.map(prep).filter(x => x != null)],
@@ -874,14 +1364,14 @@ const handlers = {
 
   // Block-scoped control flow: push scope for bodies so inner let/const shadows correctly
   'if': (cond, then, els) => {
-    const c = prep(cond)
-    scopes.push(new Map()); const t = prep(then); scopes.pop()
-    if (els != null) { scopes.push(new Map()); const e = prep(els); scopes.pop(); return ['if', c, t, e] }
+    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)
-    scopes.push(new Map()); const b = prep(body); scopes.pop()
+    const c = prep(stripBoolNot(cond))
+    pushScope(); const b = prep(body); popScope()
     return ['while', c, b]
   },
 
@@ -964,7 +1454,7 @@ const handlers = {
     for (const n of collectParamNames(raw)) fnScope.set(n, n)
 
     depth++
-    scopes.push(fnScope)
+    pushScope(fnScope)
     funcLocalNames.push(new Set(collectParamNames(raw)))
 
     const nextParams = []
@@ -986,6 +1476,14 @@ const handlers = {
       }
     }
     let preparedBody = prep(body)
+    // An expression-bodied arrow returning an empty object literal — `() => ({})`
+    // — preps to a bare `['{}']`, structurally identical to an empty block body.
+    // The grouping `()` that marked it an expression is unwrapped by then, so
+    // wrap it in an explicit `return` — otherwise downstream block/expression
+    // classification (compile.js `isBlockBody`) misreads it as an empty block.
+    if (!(Array.isArray(body) && body[0] === '{}')
+        && Array.isArray(preparedBody) && preparedBody[0] === '{}' && preparedBody.length === 1)
+      preparedBody = ['{}', [';', ['return', ['{}']]]]
     if (bodyPrefix.length) {
       const prefix = bodyPrefix.filter(x => x != null)
       if (Array.isArray(preparedBody) && preparedBody[0] === '{}' && Array.isArray(preparedBody[1]) && preparedBody[1][0] === ';')
@@ -997,7 +1495,7 @@ const handlers = {
     }
     const inner = nextParams.length === 0 ? null : nextParams.length === 1 ? nextParams[0] : [',', ...nextParams]
     const result = ['=>', Array.isArray(params) && params[0] === '()' ? ['()', inner] : inner, preparedBody]
-    scopes.pop()
+    popScope()
     funcLocalNames.pop()
     depth--
     return result
@@ -1029,6 +1527,8 @@ const handlers = {
     return ['?.()', prep(callee), ...items.map(prep)]
   },
   // Boolean literals NaN-box as f64 — typeof at runtime returns 'number'. Fold here so the JS-spec value survives.
+  // Unresolvable bare refs fold to 'undefined' via staticTypeofString (spec §13.5.3) —
+  // the only place a stray identifier doesn't ReferenceError.
   'typeof'(a) {
     if (Array.isArray(a) && a[0] == null && typeof a[1] === 'boolean') { includeForStringOnly(); return ['str', 'boolean'] }
     const known = staticTypeofString(a)
@@ -1044,7 +1544,17 @@ const handlers = {
       includeForNumericCoercion()
       return ['u+', na]
     }
-    return ['+', prep(a), prep(b)]
+    const pa = prep(a), pb = prep(b)
+    // Compile-time fold of literal string concat. The combined bytes flow
+    // through the `str` emitter as a single literal — SSO if ≤4 ASCII (zero
+    // heap), otherwise one dataDedup entry (still cheaper than runtime
+    // __str_concat_raw + heap alloc). Bottom-up, so `'a' + 'b' + 'c'` folds
+    // left-associatively into one literal.
+    if (Array.isArray(pa) && pa[0] === 'str' && typeof pa[1] === 'string' &&
+        Array.isArray(pb) && pb[0] === 'str' && typeof pb[1] === 'string') {
+      return ['str', pa[1] + pb[1]]
+    }
+    return ['+', pa, pb]
   },
   '-'(a, b) {
     if (b === undefined) { const na = prep(a); return isLit(na) && typeof na[1] === 'number' ? [, -na[1]] : ['u-', na] }
@@ -1052,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
@@ -1079,73 +1589,18 @@ const handlers = {
 '()'(callee, ...args) {
     // Grouping: (expr) → ['()', expr] with no args. Call: f() → ['()', 'f', null] with null arg.
     if (args.length === 0) return prep(callee)
+    if (typeof callee === 'string' && PROHIBITED[callee]) err(PROHIBITED[callee])
 
-    if (isImportMetaProp(callee, 'resolve')) {
-      const callArgs = flatArgs(args).filter(a => a != null)
-      if (callArgs.length !== 1) err('`import.meta.resolve` requires one string literal argument')
-      const spec = stringValue(callArgs[0])
-      if (spec == null) err('`import.meta.resolve` supports only string literal arguments')
-      return staticString(resolveImportMeta(spec))
-    }
-
-    const hasRealArgs = args.some(a => a != null)
+    // Compile-time folds: the callee names something resolvable now. Each fold
+    // is gated by callee shape, so at most one of the three fires.
+    const folded = foldImportMetaResolve(callee, args)
+      ?? dispatchConstructorCall(callee, args)
+      ?? foldNamespaceIntrospection(callee, args)
+    if (folded !== undefined) return folded
 
-    if (typeof callee === 'string') {
-      if (PROHIBITED[callee]) err(PROHIBITED[callee])
-      if (CTORS.includes(callee)) return handlers['new'](['()', callee, ...args])
+    callee = resolveCallee(callee, args)
+    args = renestSoleCommaArg(args)
 
-      if (includeForNamedCall(callee)) {
-        if (callee === 'BigInt64Array' || callee === 'BigUint64Array') {
-          return ['()', callee, ...args.filter(a => a != null).map(prep)]
-        }
-      }
-
-      const local = scopes.length && isDeclared(callee)
-      const resolved = local ? null : ctx.scope.chain[callee]
-      if (local) callee = resolveScope(callee)
-      else if (resolved?.includes('.')) callee = resolved
-      else if (resolved && hasFunc(resolved)) callee = resolved
-      else if (resolved && !resolved.includes('.')) {
-        if (hasModule(resolved) && !ctx.module.imports.some(i => i[3]?.[1] === `$${resolved}`)) includeModule(resolved)
-      }
-      else if (depth > 0 && !resolved && !ctx.func.exports[callee] && !ctx.module.imports.some(i => i[3]?.[1] === `$${callee}`)) {
-        includeForCallableValue()
-      }
-    } else if (Array.isArray(callee) && callee[0] === '.') {
-      const [, obj, prop] = callee
-      const key = typeof obj === 'string' && typeof prop === 'string' ? `${obj}.${prop}` : null
-      if (key && ctx.module.hostImports?.[obj]?.[prop]) {
-        const spec = ctx.module.hostImports[obj][prop]
-        const alias = `${obj}$${prop}`
-        addHostImport(obj, prop, alias, spec)
-        callee = alias
-      } else if (key && includeForNamedCall(key)) {
-        callee = key
-      } else if (includeForGenericMethod(prop)) {
-        callee = prep(callee)
-      } else {
-        const mod = ctx.scope.chain[obj]
-        if (typeof obj === 'string' && mod && !mod.includes('.') && hasModule(mod)) {
-          callee = (includeModule(mod), mod + '.' + prop)
-        } else {
-          callee = prep(callee)
-        }
-      }
-    } else {
-      includeForCallableValue()
-      callee = prep(callee)
-    }
-
-    // Drop trailing-comma sentinel inside a comma group: `f(a, b,)` parses as
-    // ['()', 'f', [',', a, b, null]] — without trimming, the trailing null
-    // becomes a [, 0] literal and inflates arguments.length.
-    if (args.length === 1 && Array.isArray(args[0]) && args[0][0] === ',') {
-      let end = args[0].length
-      while (end > 1 && args[0][end - 1] == null) end--
-      if (end < args[0].length) {
-        args[0] = end === 2 ? args[0][1] : args[0].slice(0, end)
-      }
-    }
     const preppedArgs = args.filter(a => a != null).map(prep)
     for (const a of preppedArgs) {
       if (typeof a === 'string' && hasFunc(a)) {
@@ -1165,7 +1620,9 @@ const handlers = {
       const inner = args[0]
       includeForArrayLiteral()
       if (inner == null) return ['[']
-      if (Array.isArray(inner) && inner[0] === ',') { const items = inner.slice(1); if (items.length && items[items.length - 1] === null) items.pop(); return ['[', ...items.map(item => item == null ? [, JZ_NULL] : prep(item))] }
+      // jessie consumes the trailing comma itself; every remaining `null` in the
+      // element list is a genuine elision (`[,]` → length 1, `[1,,]` → length 2).
+      if (Array.isArray(inner) && inner[0] === ',') { const items = inner.slice(1); return ['[', ...items.map(item => item == null ? [, undefined] : prep(item))] }
       return ['[', prep(inner)]
     }
     if (typeof args[0] === 'string' && ctx.module.namespaces?.[args[0]]) {
@@ -1185,9 +1642,9 @@ const handlers = {
 
   // Bare block statement: push scope for let/const shadowing
   '{'(inner) {
-    scopes.push(new Map())
+    pushScope()
     const result = ['{', prep(inner)]
-    scopes.pop()
+    popScope()
     return result
   },
 
@@ -1196,14 +1653,44 @@ const handlers = {
     // Detect block body vs object literal
     if (Array.isArray(inner) && STMT_OPS.has(inner[0])) {
       // Block body: push block scope for let/const shadowing
-      scopes.push(new Map())
+      pushScope()
       const result = ['{}', prep(inner)]
-      scopes.pop()
+      popScope()
       return result
     }
 
     includeForObjectLiteral()
     if (inner == null) return ['{}']
+    const items = Array.isArray(inner) && inner[0] === ','
+      ? inner.slice(1)
+      : [inner]
+
+    // Computed keys: `{[k]: v}` where `k` isn't compile-time foldable. jz's
+    // object layout is slot-based (fixed schema at the literal site), so a
+    // truly-dynamic key can't slot in. Lower to the existing dict path:
+    //   {a:1, [k]:v, b:2}  →  ((__t) => (__t[k]=v, __t))({a:1, b:2})
+    // Static-but-non-string keys still fold via `staticPropertyKey` below.
+    const isComputed = p => Array.isArray(p) && p[0] === ':'
+      && typeof p[1] !== 'string' && staticPropertyKey(p[1]) == null
+    if (items.some(isComputed)) {
+      const staticItems = items.filter(p => !isComputed(p))
+      const computedItems = items.filter(isComputed)
+      const tmp = `${T}o${ctx.func.uniq++}`
+      // Body: comma sequence of dict-sets, terminated with the tmp itself.
+      // Computed key shape from parser is `[':', ['[]', keyExpr], valExpr]` —
+      // unwrap the `['[]', keyExpr]` to grab keyExpr directly.
+      const assigns = computedItems.map(p => {
+        const keyExpr = Array.isArray(p[1]) && p[1][0] === '[]' ? p[1][1] : p[1]
+        return ['=', ['[]', tmp, keyExpr], p[2]]
+      })
+      const body = [',', ...assigns, tmp]
+      const arrow = ['=>', ['()', tmp], body]
+      const arg = staticItems.length === 1 ? ['{}', staticItems[0]]
+        : staticItems.length ? ['{}', [',', ...staticItems]]
+        : ['{}']
+      return prep(['()', arrow, arg])
+    }
+
     // Process properties: shorthand 'x' → [':', 'x', 'x'], or [':', key, val] → prep val only
     const prop = p => {
       if (typeof p === 'string') return [':', p, prep(p)]
@@ -1214,13 +1701,6 @@ const handlers = {
       }
       return prep(p)
     }
-    // Drop trailing-comma artifacts: subscript represents `{a:1, b,}` as
-    // `[",", [":","a",1], "b", null]` — the trailing `null` would prep to a
-    // literal-0 entry, leaving the literal carrying a phantom slot and
-    // shifting any subsequent slot-position resolution.
-    const items = Array.isArray(inner) && inner[0] === ','
-      ? inner.slice(1).filter(p => p != null)
-      : [inner]
     let prepped = items.map(prop)
     // ES spec: duplicate keys allowed; key takes first-seen position, last-seen value.
     const lastValue = new Map()
@@ -1244,10 +1724,11 @@ const handlers = {
 
   // For loop
   'for'(head, body) {
-    scopes.push(new Map())
+    pushScope()
     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
@@ -1297,30 +1778,54 @@ const handlers = {
       if (sid != null) {
         // Known schema → compile-time unrolling with string keys
         const keys = ctx.schema.list[sid]
-        if (!keys || !keys.length) { scopes.pop(); return null }
+        if (!keys || !keys.length) { popScope(); return null }
         includeForKnownKeyIteration()
-        const stmts = []
-        for (let i = 0; i < keys.length; i++) {
-          stmts.push(i === 0
-            ? ['let', ['=', varName, [, keys[i]]]]
-            : ['=', varName, [, keys[i]]])
-          stmts.push(cloneNode(body))
+        if (!hasLoopJump(body)) {
+          // No break/continue → flat unroll, no loop frame needed.
+          const stmts = []
+          for (let i = 0; i < keys.length; i++) {
+            stmts.push(i === 0
+              ? ['let', ['=', varName, [, keys[i]]]]
+              : ['=', varName, [, keys[i]]])
+            stmts.push(cloneNode(body))
+          }
+          r = prep([';', ...stmts])
+        } else {
+          // break/continue present → an unrolled loop still needs its frames.
+          // Wrap each iteration in a labeled block (continue target) and the
+          // whole run in an outer labeled block (break target): `break` exits
+          // the construct, `continue` falls through to the next iteration.
+          const brkL = `${T}fibrk${ctx.func.uniq++}`
+          const decl = prep(['let', ['=', varName, [, keys[0]]]])
+          const parts = [decl]
+          for (let i = 0; i < keys.length; i++) {
+            const contL = `${T}ficont${ctx.func.uniq++}`
+            const iter = prep(i === 0
+              ? cloneNode(body)
+              : [';', ['=', varName, [, keys[i]]], cloneNode(body)])
+            parts.push(['label', contL, retargetLoopJumps(iter, brkL, contL)])
+          }
+          r = ['label', brkL, [';', ...parts]]
         }
-        r = prep([';', ...stmts])
       } else {
         // Dynamic object → HASH runtime iteration
         includeForRuntimeKeyIteration()
         r = ['for-in', varName, prep(src), prep(body)]
       }
     } else {
-      r = ['for', prep(head), prep(body)]
+      // Some parser/jzify shapes for `for (;;)` and `for (; cond; )` arrive
+      // as a null or bare-condition head instead of the canonical
+      // `[';', init, cond, step]` tuple. Normalize them before emit so they
+      // remain ordinary for-loops, not malformed two-slot nodes.
+      r = ['for', null, head == null ? null : prep(head), null, prep(body)]
     }
-    scopes.pop()
+    popScope()
     return r
   },
 
   // Property access - resolve namespaces or object/array properties
   '.'(obj, prop) {
+    prop = typeof prop === 'string' ? prop : staticPropertyKey(prop)
     if (prop === 'caller' || prop === 'callee') err('`.caller` and `.callee` are prohibited: deprecated stack introspection')
     if (prop === 'url' && isImportMeta(obj)) return staticString(importMetaUrl())
     const mod = ctx.scope.chain[obj]
@@ -1358,6 +1863,20 @@ const handlers = {
       }
     }
 
+    // `new RegExp("pattern", "flags?")` with string-literal pattern → compile
+    // like a regex literal `/pattern/flags`. Dynamic pattern is not supported
+    // (would require a runtime regex interpreter). Reported as build blocker #6.
+    if (name === 'RegExp') {
+      const literalArgs = ctorArgs.filter(a => a != null)
+      const pattern = staticStringExpr(literalArgs[0])
+      if (pattern == null)
+        err('new RegExp() requires a string-literal pattern; dynamic regex construction is not supported')
+      const flags = literalArgs.length > 1 ? staticStringExpr(literalArgs[1]) : ''
+      if (flags == null)
+        err('new RegExp() flags must be a string literal')
+      return prep(['//', pattern, flags || undefined])
+    }
+
     // Wrap multi-arg ctor arg lists back into a single comma-group — the '()' op
     // expects callArgs as a single element (possibly comma-grouped).
     const wrapArgs = (args) => args.length === 0 ? [null]
@@ -1525,7 +2044,7 @@ function prepareModule(specifier, source) {
     const mangled = `${prefix}$${localName}`
     moduleExports.set(exportName, mangled)
     const func = ctx.func.list.find(f => f.name === localName)
-    if (func) renameFunc(func, mangled)
+    if (func) { renameFunc(func, mangled); func._modulePrefix = prefix }
     if (ctx.scope.globals.has(localName)) {
       const wat = ctx.scope.globals.get(localName).replace(`$${localName}`, `$${mangled}`)
       ctx.scope.globals.delete(localName)
@@ -1587,15 +2106,17 @@ function prepareModule(specifier, source) {
   }
 
   // Rename ALL non-exported functions created during this module's prep
-  // (fn property assignments like f32.parse, internal helpers like cleanInt)
+  // (fn property assignments like f32.parse, internal helpers like cleanInt).
+  // Funcs added by nested prepareModule calls are tagged with `_modulePrefix`
+  // by their own pass; skip those so prefixes don't stack (`a$b$name`).
   for (let i = savedFuncCount; i < ctx.func.list.length; i++) {
     const func = ctx.func.list[i]
     if (func.raw || func.name.startsWith(prefix + '$')) continue
-    // Skip functions from sub-imports (already prefixed with another module's prefix)
-    if (func.name.includes('__') && func.name.includes('$')) continue
+    if (func._modulePrefix && func._modulePrefix !== prefix) continue
     const mangled = `${prefix}$${func.name}`
     moduleExports.set(func.name, mangled)
     renameFunc(func, mangled)
+    func._modulePrefix = prefix
   }
 
   // Add mangled non-exported globals to moduleExports for walk renaming
@@ -1627,6 +2148,8 @@ function prepareModule(specifier, source) {
     for (let i = savedFuncCount; i < ctx.func.list.length; i++) {
       const func = ctx.func.list[i]
       if (!func.body) continue
+      // Sub-module funcs already had their own walk; parent's rename map doesn't apply.
+      if (func._modulePrefix && func._modulePrefix !== prefix) continue
       const funcParams = new Set(func.sig?.params?.map(p => p.name) || [])
       walk(func.body, funcParams)
       if (func.defaults) for (const [k, v] of Object.entries(func.defaults)) func.defaults[k] = walk(v, funcParams)
@@ -1652,3 +2175,160 @@ function prepareModule(specifier, source) {
   ctx.module.resolvedModules.set(specifier, result)
   return result
 }
+
+// =============================================================================
+// AST-level fusion passes (pre-resolution)
+// =============================================================================
+// Unlike src/optimize.js (a pure WAT IR→IR rewrite, post-emission), these
+// rewrites need the *raw, pre-resolution* AST shape — bindings still named,
+// arrow bodies still inline — so they run inside prepare(), before scope
+// resolution and emit. They mutate the AST in place; shape guards are strict
+// enough that misfires are impossible.
+
+/** Sparse-read .map fusion: rewrite `const b = a.map(arrow); for(...; j<b.length; ...) USE(b[j])`
+ *  into a fused for-loop that inlines `arrow(a[j])` at the read site, eliminating the materialized
+ *  intermediate array. Only fires on shapes where every use of `b` is a numeric `b[idx]` read or a
+ *  `b.length` read, the arrow is pure with a single named param, and `b` is not referenced after the
+ *  consumer for-loop. Preserves observable behavior because the arrow's pure-expression body has no
+ *  order-dependent effects. */
+function fuseSparseMapReads(root) {
+  walkSparse(root)
+}
+function walkSparse(node) {
+  if (!Array.isArray(node)) return
+  for (let i = 1; i < node.length; i++) walkSparse(node[i])
+  if (node[0] === ';') tryFuseInBlock(node)
+}
+function tryFuseInBlock(seq) {
+  for (let i = 1; i < seq.length - 1; i++) {
+    const fused = tryFusePair(seq[i], seq[i + 1], seq, i)
+    if (fused) {
+      seq.splice(i, 2, ...fused)
+      i--  // re-examine same position (chained fusions)
+    }
+  }
+}
+function tryFusePair(decl, forNode, seq, declIdx) {
+  if (!Array.isArray(decl) || (decl[0] !== 'const' && decl[0] !== 'let')) return null
+  if (decl.length !== 2) return null  // single binding only
+  const bind = decl[1]
+  if (!Array.isArray(bind) || bind[0] !== '=' || typeof bind[1] !== 'string') return null
+  const NAME = bind[1], rhs = bind[2]
+  if (!Array.isArray(rhs) || rhs[0] !== '()') return null
+  const callee = rhs[1]
+  if (!Array.isArray(callee) || callee[0] !== '.' || callee[2] !== 'map') return null
+  const RECV = callee[1]
+  if (typeof RECV !== 'string' || RECV === NAME) return null
+  const arrow = rhs[2]
+  if (!Array.isArray(arrow) || arrow[0] !== '=>') return null
+  // Single-name param only: `x => …` or `(x) => …`
+  const ap = arrow[1]
+  const PARAM = typeof ap === 'string' ? ap :
+    (Array.isArray(ap) && ap[0] === '()' && typeof ap[1] === 'string' ? ap[1] : null)
+  if (!PARAM || PARAM === NAME || PARAM === RECV) return null
+  // Body: single-expression arrow only (block bodies skipped — could extend later).
+  const aBody = arrow[2]
+  if (Array.isArray(aBody) && aBody[0] === '{}') return null
+  if (!isPureSparseArrowBody(aBody, PARAM)) return null
+  // For-loop: ['for', [';', initStmt, cond, inc], body]
+  if (!Array.isArray(forNode) || forNode[0] !== 'for' || forNode.length !== 3) return null
+  const head = forNode[1]
+  if (!Array.isArray(head) || head[0] !== ';' || head.length !== 4) return null
+  const cond = head[2], forBody = forNode[2]
+  // Verify `NAME` is used only as `NAME[idx]` or `NAME.length` inside cond+forBody.
+  if (!hasOnlySparseUses(cond, NAME)) return null
+  if (!hasOnlySparseUses(forBody, NAME)) return null
+  if (!hasAnyIndexedRead(forBody, NAME) && !hasAnyIndexedRead(cond, NAME)) return null
+  // `NAME` must not be read after the for-loop in the same block.
+  for (let k = declIdx + 2; k < seq.length; k++) {
+    if (refsName(seq[k], NAME)) return null
+  }
+  // RECV must not be reassigned inside the for-loop (would invalidate substitution).
+  if (assignsName(forNode, RECV) || assignsName(forNode, NAME)) return null
+  // PARAM must not collide with any binding inside forBody (otherwise substitution shadows wrongly).
+  if (bindsName(forNode, PARAM)) return null
+  // Apply substitution: NAME.length → RECV.length; NAME[idx] → arrowBody[PARAM ← RECV[idx]].
+  const newCond = substSparse(cond, NAME, RECV, PARAM, aBody)
+  const newBody = substSparse(forBody, NAME, RECV, PARAM, aBody)
+  const newHead = [';', head[1], newCond, head[3]]
+  return [['for', newHead, newBody]]
+}
+function isPureSparseArrowBody(n, PARAM) {
+  if (typeof n === 'string') return true
+  if (!Array.isArray(n)) return true
+  const op = n[0]
+  // Calls / new / assignments / increments are unsafe for repeated-substitution semantics.
+  if (op === '()' || op === '?.()' || op === 'new' || op === '++' || op === '--') return false
+  if (op === '=>') return false  // nested closure is opaque
+  if (typeof op === 'string' && op !== '=>' && op !== '===' && op !== '!==' && op !== '==' && op !== '!=' && op !== '<=' && op !== '>=' && op.endsWith('=') && op !== '=') return false
+  if (op === '=') return false
+  for (let i = 1; i < n.length; i++) if (!isPureSparseArrowBody(n[i], PARAM)) return false
+  return true
+}
+function hasOnlySparseUses(n, NAME) {
+  if (typeof n === 'string') return n !== NAME
+  if (!Array.isArray(n)) return true
+  const op = n[0]
+  if (op === '[]' && n.length === 3 && n[1] === NAME) return hasOnlySparseUses(n[2], NAME)  // NAME[idx] — idx must not reference NAME
+  if (op === '.' && n[1] === NAME) {
+    if (n[2] === 'length') return true
+    return false  // any other property access on NAME is opaque
+  }
+  for (let i = 1; i < n.length; i++) if (!hasOnlySparseUses(n[i], NAME)) return false
+  return true
+}
+function hasAnyIndexedRead(n, NAME) {
+  if (!Array.isArray(n)) return false
+  if (n[0] === '[]' && n.length === 3 && n[1] === NAME) return true
+  for (let i = 1; i < n.length; i++) if (hasAnyIndexedRead(n[i], NAME)) return true
+  return false
+}
+function refsName(n, NAME) {
+  if (typeof n === 'string') return n === NAME
+  if (!Array.isArray(n)) return false
+  for (let i = 1; i < n.length; i++) if (refsName(n[i], NAME)) return true
+  return false
+}
+function assignsName(n, NAME) {
+  if (!Array.isArray(n)) return false
+  const op = n[0]
+  if ((op === '=' || op === '++' || op === '--' ||
+       (typeof op === 'string' && op.endsWith('=') && op !== '==' && op !== '===' && op !== '!=' && op !== '!==' && op !== '<=' && op !== '>='))
+      && n[1] === NAME) return true
+  for (let i = 1; i < n.length; i++) if (assignsName(n[i], NAME)) return true
+  return false
+}
+function bindsName(n, NAME) {
+  if (!Array.isArray(n)) return false
+  const op = n[0]
+  if ((op === 'let' || op === 'const')) {
+    for (let i = 1; i < n.length; i++) {
+      const bind = n[i]
+      if (Array.isArray(bind) && bind[0] === '=' && bind[1] === NAME) return true
+    }
+  }
+  if (op === '=>') {
+    const p = n[1]
+    if (p === NAME) return true
+    if (Array.isArray(p)) {
+      if (p[0] === '()' && p[1] === NAME) return true
+      // skip deeper destructuring forms — conservative
+    }
+  }
+  for (let i = 1; i < n.length; i++) if (bindsName(n[i], NAME)) return true
+  return false
+}
+function substSparse(n, NAME, RECV, PARAM, arrowBody) {
+  if (typeof n !== 'object' || n === null || !Array.isArray(n)) return n
+  if (n[0] === '.' && n[1] === NAME && n[2] === 'length') return ['.', RECV, 'length']
+  if (n[0] === '[]' && n.length === 3 && n[1] === NAME) {
+    const idx = substSparse(n[2], NAME, RECV, PARAM, arrowBody)
+    return cloneAndBind(arrowBody, PARAM, ['[]', RECV, idx])
+  }
+  return n.map((c, i) => i === 0 ? c : substSparse(c, NAME, RECV, PARAM, arrowBody))
+}
+function cloneAndBind(node, PARAM, replacement) {
+  if (node === PARAM) return replacement
+  if (!Array.isArray(node)) return node
+  return node.map((c, i) => i === 0 ? c : cloneAndBind(c, PARAM, replacement))
+}