jz 0.1.0 → 0.2.0

package/src/prepare.js

@@ -22,13 +22,45 @@
  * @module prepare
  */
 
-import { parse } from 'subscript/jessie'
+import { parse } from 'subscript/feature/jessie'
 import { ctx, err, derive } from './ctx.js'
-import { T, STMT_OPS, VAL, extractParams, collectParamNames, classifyParam } from './analyze.js'
-import * as mods from '../module/index.js'
+import { T, STMT_OPS, VAL, valTypeOf, typedElemCtor, extractParams, collectParamNames, classifyParam, observeNodeFacts, staticPropertyKey } from './analyze.js'
+import { isFuncRef } from './ir.js'
+import {
+  CTORS, TIMER_NAMES,
+  hasModule, includeModule,
+  includeForArrayAccess, includeForArrayLiteral, includeForArrayPattern, includeForCallableValue,
+  includeForGenericMethod, includeForKnownKeyIteration, includeForNamedCall, includeForNumericCoercion,
+  includeForObjectLiteral, includeForObjectPattern, includeForOp, includeForProperty, includeForRuntimeCtor,
+  includeForRuntimeKeyIteration, includeForStringOnly, includeForStringValue, includeForTimerRuntime,
+} from './autoload.js'
 
 let depth = 0  // arrow nesting depth (0=top-level, >0=inside function)
 let scopes = []  // block scope stack: [{names: Set, renames: Map}]
+// 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
+// to the same WASM local, but downstream optimizations (directClosures) gate
+// on per-decl `isReassigned`, not per-WASM-local — they'd read a stale binding.
+let funcLocalNames = []
+
+// ES spec: identifier with \uHHHH or \u{...} escape is equivalent to the decoded
+// form. subscript preserves raw spelling in the AST; normalize once before prep.
+const IDESC = /\\u\{([0-9a-fA-F]+)\}|\\u([0-9a-fA-F]{4})/g
+const decodeIdent = s => s.includes('\\u')
+  ? s.replace(IDESC, (_, b, p) => String.fromCodePoint(parseInt(b || p, 16)))
+  : s
+
+const normalizeIdents = node => {
+  if (!Array.isArray(node)) return
+  // Literal-value wrapper [null, X] / [undefined, X]: X is a value, not an identifier
+  if (node.length === 2 && node[0] == null) return
+  for (let i = 1; i < node.length; i++) {
+    const v = node[i]
+    if (typeof v === 'string') node[i] = decodeIdent(v)
+    else if (Array.isArray(v)) normalizeIdents(v)
+  }
+}
 
 const hostReturnValType = spec => {
   if (!spec || typeof spec === 'function') return null
@@ -41,15 +73,102 @@ const hostReturnValType = spec => {
 
 const addHostImport = (mod, name, alias, spec) => {
   const nParams = typeof spec === 'function' ? spec.length : (spec?.params || 0)
-  const params = Array(nParams).fill(['param', 'f64'])
+  // User-supplied imports carry NaN-boxed values via i64 (not f64) so V8 cannot
+  // canonicalize the NaN payload across the wasm↔JS function boundary —
+  // same hazard as env.print / __ext_*. Call sites wrap args with asI64()
+  // and unwrap the i64 return with f64.reinterpret_i64.
+  const params = Array(nParams).fill(['param', 'i64'])
   if (!ctx.module.imports.some(i => i[3]?.[1] === `$${alias}`)) {
-    ctx.module.imports.push(['import', `"${mod}"`, `"${name}"`, ['func', `$${alias}`, ...params, ['result', 'f64']]])
+    ctx.module.imports.push(['import', `"${mod}"`, `"${name}"`, ['func', `$${alias}`, ...params, ['result', 'i64']]])
   }
   ctx.scope.chain[alias] = alias
   const vt = hostReturnValType(spec)
   if (vt) ctx.module.hostImportValTypes.set(alias, vt)
 }
 
+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
+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 stringArrayValues(expr) {
+  if (!Array.isArray(expr) || expr[0] !== '[' || expr.length === 1) return null
+  const out = []
+  for (const item of expr.slice(1)) {
+    if (!Array.isArray(item) || item[0] !== 'str' || typeof item[1] !== 'string') return null
+    out.push(item[1])
+  }
+  return out
+}
+
+function staticString(value) {
+  includeForStringValue()
+  return ['str', value]
+}
+
+function importMetaUrl() {
+  if (!ctx.transform.importMetaUrl) err('`import.meta.url` requires compile option `importMetaUrl`')
+  return ctx.transform.importMetaUrl
+}
+
+function resolveImportMeta(spec) {
+  const base = importMetaUrl()
+  try { return new URL(spec, base).href }
+  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,
+    hasFuncValue: false, timerNames: new Set(),
+    maxDef: 0, maxCall: 0, hasRest: false, hasSpread: false,
+  }
+  const visitFuncValue = (node) => {
+    if (facts.hasFuncValue || !Array.isArray(node)) return
+    const [op, ...args] = node
+    if (op === '()') {
+      for (let i = 1; i < args.length; i++) {
+        const a = args[i]
+        if (isFuncRef(a, ctx.func.names)) { facts.hasFuncValue = true; return }
+        visitFuncValue(a)
+      }
+      return
+    }
+    if (op === '.' || op === '?.') {
+      if (isFuncRef(args[0], ctx.func.names)) { facts.hasFuncValue = true; return }
+      visitFuncValue(args[0])
+      return
+    }
+    if (op === '=>') { visitFuncValue(args[1]); return }
+    for (const a of args) {
+      if (isFuncRef(a, ctx.func.names)) { facts.hasFuncValue = true; return }
+      visitFuncValue(a)
+    }
+  }
+  const walk = (node) => {
+    if (!Array.isArray(node)) {
+      if (typeof node === 'string' && TIMER_NAMES.has(node)) facts.timerNames.add(node)
+      return
+    }
+    observeNodeFacts(node, facts)
+    for (const a of node.slice(1)) walk(a)
+  }
+  visitFuncValue(root)
+  walk(root)
+}
+
 /**
  * @typedef {null|number|string|ASTNode[]} ASTNode
  */
@@ -62,18 +181,28 @@ const addHostImport = (mod, name, alias, spec) => {
 export default function prepare(node) {
   depth = 0
   scopes = []
+  funcLocalNames = [new Set()]
   includeModule('core')
+  normalizeIdents(node)
   fuseSparseMapReads(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
   // module's closure.table machinery. defFunc paths don't trigger fn-module load,
   // so scan post-prep and include `fn` if any user func appears in a value position.
-  if (!ctx.module.modules.fn && ctx.func.list.length) {
+  // Same scan also catches inline arrows that survive prep (e.g. `{ m: (x) => x }`)
+  // — defFunc only lifts arrows that are the direct RHS of a let/const/export default,
+  // and depth-0 arrows in any other position (object property, ternary arm, return
+  // value, ...) skip the depth>0 prep-time include, so they reach emit unsupported
+  // unless we catch them here.
+  if (!ctx.module.modules.fn) {
     const funcNames = new Set(ctx.func.list.map(f => f.name))
     const visit = (n) => {
       if (!Array.isArray(n)) return false
       const [op, ...args] = n
+      // Any inline arrow surviving prep is a closure value (defFunc-lifted ones
+      // are extracted from the AST into ctx.func.list).
+      if (op === '=>') return true
       if (op === '()') {
         // callee at args[0]: skip if it's a bare func name (direct call); recurse rest
         if (typeof args[0] !== 'string' || !funcNames.has(args[0])) {
@@ -91,10 +220,6 @@ export default function prepare(node) {
         if (typeof args[0] === 'string' && funcNames.has(args[0])) return true
         return visit(args[0])
       }
-      if (op === '=>') {
-        // body only — params are bindings, not refs
-        return visit(args[1])
-      }
       for (const a of args) {
         if (typeof a === 'string' && funcNames.has(a)) return true
         if (visit(a)) return true
@@ -103,13 +228,12 @@ export default function prepare(node) {
     }
     let needs = visit(ast)
     if (!needs) for (const f of ctx.func.list) if (f.body && visit(f.body)) { needs = true; break }
-    if (!needs && ctx.module.moduleInits) for (const mi of ctx.module.moduleInits) if (visit(mi)) { needs = true; break }
-    if (needs) includeModule('fn')
+    if (!needs && ctx.module.initFacts?.hasFuncValue) needs = true
+    if (needs) includeForCallableValue()
   }
 
   // Native timers: inline WASM timer queue when referenced (no host imports needed)
-  const TIMER_NAMES = new Set(['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval'])
-  const usedTimers = new Set()
+  const usedTimers = new Set(ctx.module.initFacts?.timerNames || [])
   const scanTimers = (n) => {
     if (!Array.isArray(n)) {
       if (typeof n === 'string' && TIMER_NAMES.has(n)) usedTimers.add(n)
@@ -117,12 +241,38 @@ export default function prepare(node) {
     }
     for (let i = 0; i < n.length; i++) scanTimers(n[i])
   }
-  const allNodes = [ast, ...ctx.func.list.map(f => f.body), ...(ctx.module.moduleInits || [])]
+  const allNodes = [ast, ...ctx.func.list.map(f => f.body)]
   for (const node of allNodes) scanTimers(node)
   if (usedTimers.size) {
-    ctx.features.timers = true  // Timer module included — compile.js needs to emit __timer_init
-    includeModule('timer')
-    includeModule('fn')   // call_indirect dispatch for callbacks
+    includeForTimerRuntime()
+  }
+
+  // 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 = '{...}'`
+  // 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.
+  if (ctx.scope.shapeStrs?.size || ctx.scope.shapeStrArrays?.size) {
+    const writes = new Set()
+    const scan = (n, inDecl) => {
+      if (!Array.isArray(n)) return
+      const [op, lhs] = n
+      if (op === '=' && typeof lhs === 'string' && !inDecl) writes.add(lhs)
+      if (op === '=' && Array.isArray(lhs) && lhs[0] === '[]' && typeof lhs[1] === 'string' && !inDecl) writes.add(lhs[1])
+      // Compound assigns desugar to `=`; increments emit as `++`/`--` post-prep.
+      if ((op === '++' || op === '--') && typeof lhs === 'string') writes.add(lhs)
+      if ((op === '++' || op === '--') && Array.isArray(lhs) && lhs[0] === '[]' && typeof lhs[1] === 'string') writes.add(lhs[1])
+      if (op === '()' && Array.isArray(lhs) && lhs[0] === '.' && typeof lhs[1] === 'string' && MUTATING_ARRAY_METHODS.has(lhs[2])) writes.add(lhs[1])
+      const childInDecl = (op === 'let' || op === 'const' || op === 'var' || op === 'export')
+      for (let i = 1; i < n.length; i++) scan(n[i], childInDecl)
+    }
+    scan(ast, false)
+    for (const f of ctx.func.list) if (f.body) scan(f.body, false)
+    for (const name of writes) {
+      ctx.scope.shapeStrs?.delete(name)
+      ctx.scope.shapeStrArrays?.delete(name)
+    }
   }
 
   return ast
@@ -146,73 +296,43 @@ function isDeclared(name) {
   return scopes.some(s => s.has(name))
 }
 
+const hasFunc = name => ctx.func.names.has(name)
+
+const renameFunc = (func, nextName) => {
+  ctx.func.names.delete(func.name)
+  func.name = nextName
+  ctx.func.names.add(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 }
+const TYPEOF_MAP = { 'number': -1, 'string': -2, 'undefined': -3, 'boolean': -4, 'object': -5, 'function': -6, 'bigint': -7 }
+// Constant fold typeof for known builtin namespaces (e.g. Math.exp). prep(x) resolves Math.exp → 'math.exp'.
+function staticTypeofString(x) {
+  // 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
+}
 function resolveTypeof(node) {
   const [op, a, b] = node
   // 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]]
     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]]
     const code = TYPEOF_MAP[a[1]]
     if (code != null) return [op, ['typeof', b[1]], [, code]]
   }
   return node
 }
 
-// Property-based narrowing: unambiguous prop names limit module load.
-// Map value is the exact module set for that property (always includes 'core').
-// Properties not in this table fall back to the generic '.' receiver-type heuristic.
-// Uses null-prototype dict so inherited names (constructor, toString) don't match.
-const PROP_MODULES = Object.assign(Object.create(null), {
-  // array-only methods
-  push: ['core', 'array'], pop: ['core', 'array'], shift: ['core', 'array'], unshift: ['core', 'array'],
-  splice: ['core', 'array'], reverse: ['core', 'array'], sort: ['core', 'array'], fill: ['core', 'array'],
-  map: ['core', 'array'], filter: ['core', 'array'], reduce: ['core', 'array'], reduceRight: ['core', 'array'],
-  forEach: ['core', 'array'], find: ['core', 'array'], findIndex: ['core', 'array'],
-  findLast: ['core', 'array'], findLastIndex: ['core', 'array'],
-  every: ['core', 'array'], some: ['core', 'array'], flat: ['core', 'array'], flatMap: ['core', 'array'],
-  join: ['core', 'array'], copyWithin: ['core', 'array'], at: ['core', 'array'],
-  // string-only methods
-  charAt: ['core', 'string'], charCodeAt: ['core', 'string'], codePointAt: ['core', 'string'],
-  toUpperCase: ['core', 'string'], toLowerCase: ['core', 'string'], trim: ['core', 'string'],
-  trimStart: ['core', 'string'], trimEnd: ['core', 'string'],
-  split: ['core', 'string'], replace: ['core', 'string'], replaceAll: ['core', 'string'],
-  repeat: ['core', 'string'], startsWith: ['core', 'string'], endsWith: ['core', 'string'],
-  padStart: ['core', 'string'], padEnd: ['core', 'string'], normalize: ['core', 'string'],
-  matchAll: ['core', 'string'], match: ['core', 'string'],
-  substring: ['core', 'string'], substr: ['core', 'string'],
-  // collection-only methods
-  add: ['core', 'collection'], clear: ['core', 'collection'],
-  // string + array (cross-type but not object/collection)
-  slice: ['core', 'string', 'array'], concat: ['core', 'string', 'array'],
-  indexOf: ['core', 'string', 'array'], lastIndexOf: ['core', 'string', 'array'],
-  includes: ['core', 'string', 'array'],
-  // string + array + typedarray (length shared across all sequence types)
-  length: ['core', 'string', 'array', 'typedarray'],
-  // Note: toString/toFixed/toPrecision/toExponential not narrowed — they only have
-  // number-schema emitters; unknown receivers fall through to __ext_call (collection module).
-})
-
-const OP_MODULES = {
-  // '.' handled inline (see '.' handler) for property-based narrowing
-  '?.': ['core', 'string', 'collection'],
-  '?.[]': ['core', 'array', 'collection'],
-  '?.()': ['core', 'fn'],
-  'u+': ['number', 'string'],
-  'in': ['core', 'collection', 'string'],
-  '==': ['core', 'string'],
-  '!=': ['core', 'string'],
-  'typeof': ['core', 'string'],
-  '[': ['core', 'array'],
-  '{': ['core', 'object', 'string', 'collection'],
-  '//': ['core', 'string', 'regex'],
-}
-const dict = obj => Object.assign(Object.create(null), obj)
-
 const cloneNode = (node) => {
   if (!Array.isArray(node)) return node
   const copy = node.map(cloneNode)
@@ -220,64 +340,6 @@ const cloneNode = (node) => {
   return copy
 }
 
-// Call-site module inclusion. Keyed by either a bare callee name (e.g. 'parseFloat')
-// or a dotted path ('console.log'). Value is the module set to load.
-// The lookup fires from the '()' handler before scope resolution.
-// Architectural note: fully eliminating this (auto-imports via jzify) was considered but
-// rejected — Object.fromEntries needs collection+string while o.x does not, so MOD_DEPS
-// transitive inclusion alone over-loads simple paths. This table pinpoints load per callee.
-const CALL_MODULES = dict({
-  // Bare-identifier calls
-  'ArrayBuffer': ['core', 'typedarray'],
-  'DataView': ['core', 'typedarray'],
-  'BigInt64Array': ['core', 'typedarray'],
-  'BigUint64Array': ['core', 'typedarray'],
-  'parseFloat': ['number', 'string'],
-  'parseInt': ['number', 'string'],
-  'String': ['core', 'string', 'number'],
-  'Number': ['number', 'string'],
-  'Boolean': ['number'],
-  'TextEncoder': ['core', 'string'],
-  'TextDecoder': ['core', 'string'],
-  'Error': ['core', 'string'],
-  'BigInt': ['number'],
-  // Namespace.method calls
-  'console.log': ['core', 'string', 'number', 'console'],
-  'console.warn': ['core', 'string', 'number', 'console'],
-  'console.error': ['core', 'string', 'number', 'console'],
-  'Object.fromEntries': ['collection', 'string'],
-  'Object.keys': ['string'],
-  'Object.entries': ['string'],
-  'Date.now': ['core', 'console'],
-  'performance.now': ['core', 'console'],
-  'String.fromCharCode': ['core', 'string'],
-  'String.fromCodePoint': ['core', 'string'],
-  'BigInt.asIntN': ['number'],
-  'BigInt.asUintN': ['number'],
-  'Float64Array.from': ['core', 'typedarray', 'array'],
-  'Float32Array.from': ['core', 'typedarray', 'array'],
-  'Int32Array.from': ['core', 'typedarray', 'array'],
-  'Uint32Array.from': ['core', 'typedarray', 'array'],
-  'Int16Array.from': ['core', 'typedarray', 'array'],
-  'Uint16Array.from': ['core', 'typedarray', 'array'],
-  'Int8Array.from': ['core', 'typedarray', 'array'],
-  'Uint8Array.from': ['core', 'typedarray', 'array'],
-  'ArrayBuffer.isView': ['core', 'typedarray'],
-})
-
-// Method-call inclusion for unknown-receiver cases (e.g. `(x) => x.toFixed(2)`).
-// Keyed by bare method name — fires only when receiver can't be resolved to a namespace.
-const GENERIC_METHOD_MODULES = dict({
-  'toString': ['core', 'string', 'number'],
-  'toFixed': ['core', 'string', 'number'],
-  'toPrecision': ['core', 'string', 'number'],
-  'toExponential': ['core', 'string', 'number'],
-})
-
-// Constructor names that users may call without `new` — `Float64Array(5)` → `new Float64Array(5)`.
-// Keeps user source ergonomic; these cannot be plain function calls in JS semantics anyway.
-const CTORS = ['Float64Array','Float32Array','Int32Array','Uint32Array','Int16Array','Uint16Array','Int8Array','Uint8Array','BigInt64Array','BigUint64Array','Set','Map']
-
 /** 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. Pre-prep AST mutation; only fires on shapes where every use of `b` is a
@@ -427,7 +489,7 @@ function cloneAndBind(node, PARAM, replacement) {
 }
 
 function prep(node) {
-  if (Array.isArray(node) && OP_MODULES[node[0]]) includeMods(...OP_MODULES[node[0]])
+  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]
@@ -438,7 +500,9 @@ function prep(node) {
       if (node in F64_CONSTANTS) return [, F64_CONSTANTS[node]]
       if (PROHIBITED[node]) err(PROHIBITED[node])
       // Boolean/Number as value → identity arrow (for .filter(Boolean), .map(Number) etc.)
-      if (node === 'Boolean' || node === 'Number') { includeMods('core', 'fn'); return ['=>', 'x', 'x'] }
+      if (node === 'Boolean' || node === 'Number') { includeForCallableValue(); return ['=>', 'x', 'x'] }
+      // Block locals shadow module imports/globals, even when the local keeps the same name.
+      if (scopes.length && isDeclared(node)) return resolveScope(node)
       const resolved = ctx.scope.chain[node]
       if (resolved?.includes('.')) return resolved
       // Cross-module import: mangled name (e.g. __util_js$clone)
@@ -453,7 +517,7 @@ function prep(node) {
   if (op === 'void' && ctx.transform.strict) err('strict mode: `void` is prohibited. It diverges from JS by evaluating to 0.')
   if (op == null) {
     if (typeof args[0] === 'string') {
-      includeMods('core', 'string', 'number')
+      includeForStringValue()
       return ['str', args[0]]  // string literal
     }
     return [, args[0]]  // number literal
@@ -483,6 +547,7 @@ export const GLOBALS = {
   Object: 'Object',
   Symbol: 'Symbol',
   JSON: 'JSON',
+  Date: 'Date',
   isNaN: 'number',
   isFinite: 'number',
   parseInt: 'number',
@@ -496,6 +561,34 @@ export const GLOBALS = {
 const patternItems = (node) => node?.[0] === ',' ? node.slice(1) : [node]
 const isDestructPattern = (node) => Array.isArray(node) && (node[0] === '[]' || node[0] === '{}')
 
+const simpleArrayPatternItems = (pattern) => {
+  if (!Array.isArray(pattern) || pattern[0] !== '[]' || pattern.length !== 2) return null
+  const items = patternItems(pattern[1])
+  return items.every(item => typeof item === 'string') ? items : null
+}
+
+const arrayLiteralItems = (expr) => {
+  if (!Array.isArray(expr) || expr[0] !== '[]' || expr.length !== 2) return null
+  if (expr[1] == null) return []
+  const items = patternItems(expr[1])
+  return items.every(item => item != null && !(Array.isArray(item) && item[0] === '...')) ? items : null
+}
+
+function scalarArrayDestruct(pattern, rhs) {
+  const targets = simpleArrayPatternItems(pattern)
+  const values = arrayLiteralItems(rhs)
+  if (!targets || !values || targets.length !== values.length) return null
+
+  const decls = []
+  const assigns = []
+  for (let i = 0; i < targets.length; i++) {
+    const tmp = `${T}d${ctx.func.uniq++}`
+    decls.push(['=', tmp, prep(values[i])])
+    assigns.push(['=', targets[i], tmp])
+  }
+  return prep([';', ['let', ...decls], ...assigns])
+}
+
 function pushPatternAssign(target, valueExpr, out, decls = null) {
   if (Array.isArray(target) && target[0] === '=') {
     pushPatternAssign(target[1], ['??', valueExpr, prep(target[2])], out, decls)
@@ -517,7 +610,7 @@ function expandDestruct(pattern, source, out, decls = null) {
   if (!isDestructPattern(pattern)) return
 
   if (pattern[0] === '[]') {
-    includeMods('core', 'array', 'collection')
+    includeForArrayPattern()
     const items = patternItems(pattern[1])
     for (let j = 0; j < items.length; j++) {
       const item = items[j]
@@ -533,7 +626,7 @@ function expandDestruct(pattern, source, out, decls = null) {
     return
   }
 
-  includeMods('core', 'object', 'string', 'collection')
+  includeForObjectPattern()
   const items = patternItems(pattern[1])
 
   // Collect explicit keys and detect rest pattern
@@ -592,6 +685,11 @@ function expandDestruct(pattern, source, out, decls = null) {
 function prepDecl(op, ...inits) {
   const rest = []
   for (const i of inits) {
+    if (Array.isArray(i) && i[0] === '()' && typeof i[1] === 'string' && Array.isArray(i[2]) && i[2][0] === '=' && isDestructPattern(i[2][1])) {
+      if (rest.length === 0 && inits.length === 1) return [';', [op, i[1]], prep(i[2])]
+      err('destructuring assignment after declaration must be a separate statement')
+    }
+
     if (!Array.isArray(i) || i[0] !== '=') { rest.push(i); continue }
     const [, name, init] = i, normed = prep(init)
 
@@ -611,13 +709,18 @@ function prepDecl(op, ...inits) {
 
     if (!defFunc(name, normed)) {
       let declName = name
-      // Block scope: rename if shadowing an outer declaration
-      if (typeof name === 'string' && scopes.length > 0 && isDeclared(name)) {
+      // Block scope: rename if shadowing an outer declaration, OR if a sibling
+      // block at the same arrow scope already declared this name (sibling
+      // blocks both lower to the same WASM local; see funcLocalNames comment).
+      const fnNames = funcLocalNames[funcLocalNames.length - 1]
+      const inCurrentBlock = scopes.length > 0 && scopes[scopes.length - 1].has(name)
+      if (typeof name === 'string' && scopes.length > 0 && (isDeclared(name) || (fnNames?.has(name) && !inCurrentBlock))) {
         declName = `${name}${T}${ctx.func.uniq++}`
         scopes[scopes.length - 1].set(name, declName)
       } else if (typeof name === 'string' && scopes.length > 0) {
         scopes[scopes.length - 1].set(name, name)
       }
+      if (typeof declName === 'string' && fnNames) fnNames.add(declName)
       // Track const for reassignment checks — only module-scope consts (depth 0)
       if (typeof declName === 'string' && depth === 0) {
         if (ctx.module.currentPrefix) {
@@ -629,10 +732,20 @@ function prepDecl(op, ...inits) {
           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 (strs) (ctx.scope.shapeStrArrays ||= new Map()).set(declName, strs)
         } else if (op === 'let' && ctx.scope.consts?.has(declName)) {
           ctx.scope.consts.delete(declName)
           ctx.scope.constStrs?.delete(declName)
+          ctx.scope.shapeStrArrays?.delete(declName)
         }
+        // Effectively-const string literals: shape inference for `let SRC = '{...}'`
+        // patterns (bench convention to defeat compile-time JSON.parse fold without
+        // losing schema knowledge). Recorded on init; post-prep scan removes any
+        // 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)
       }
       // Track object schemas (after prefix so schema is keyed to final name)
       if (typeof declName === 'string' && Array.isArray(normed) && normed[0] === '{}' && normed.length > 1) {
@@ -662,8 +775,7 @@ function prepDecl(op, ...inits) {
 const handlers = {
   // Spread operator: [...expr] in arrays, f(...args) in calls, {...obj} in objects
   '...'(expr) {
-    // Spread is valid in arrays, calls, and objects - just prep the inner expression
-    includeModule('array')
+    includeForArrayLiteral()
     return ['...', prep(expr)]
   },
 
@@ -673,6 +785,7 @@ const handlers = {
   'await': () => err('async/await not supported: WASM is synchronous'),
   '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'),
   'in'(key, obj) { return ['in', prep(key), prep(obj)] },
   'instanceof': () => err('instanceof not supported: use typeof'),
@@ -686,6 +799,9 @@ const handlers = {
     // Destructuring assignment: [a, ...r] = expr or ({x: a} = expr)
     // Distinguishing from index assignment: destructuring patterns have exactly one payload node.
     if (isDestructPattern(lhs) && lhs.length === 2) {
+      const scalar = scalarArrayDestruct(lhs, rhs)
+      if (scalar) return scalar
+
       const normed = prep(rhs)
       const tmp = `${T}d${ctx.func.uniq++}`
       const decls = [['=', tmp, normed]]
@@ -708,9 +824,9 @@ const handlers = {
     }
     // 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'
-      && ctx.func.list.some(f => f.name === lhs[1]) && Array.isArray(rhs) && rhs[0] === '=>') {
+      && hasFunc(lhs[1]) && Array.isArray(rhs) && rhs[0] === '=>') {
       const name = `${lhs[1]}$${lhs[2]}`
-      if (defFunc(name, prep(rhs))) return null  // extracted as function, no assignment needed
+      if (defFunc(name, prep(rhs))) return ['=', prep(lhs), name]
     }
     return ['=', prep(lhs), prep(rhs)]
   },
@@ -736,16 +852,12 @@ const handlers = {
   },
   'throw'(expr) { return ['throw', prep(expr)] },
 
-  // Template literal: [``, part, ...] → chain of str_concat calls
-  // First node is always a string (empty if template starts with ${...}) so concat dispatches correctly.
+  // Template literal: [``, part, ...] → fused single-allocation string concat.
   '`'(...parts) {
-    includeMods('core', 'string', 'number')
+    includeForStringValue()
     const nodes = parts.map(p =>
       Array.isArray(p) && p[0] == null && typeof p[1] === 'string' ? ['str', p[1]] : prep(p))
-    // Ensure first element is a string so concat chain starts with string dispatch
-    if (nodes.length && !(Array.isArray(nodes[0]) && nodes[0][0] === 'str'))
-      nodes.unshift(['str', ''])
-    return nodes.reduce((acc, n) => ['()', ['.', acc, 'concat'], n])
+    return ['strcat', ...nodes]
   },
 
   // Tagged template: tag`a${x}b` → tag(['a','b'], x)
@@ -781,7 +893,7 @@ const handlers = {
     if (hostMod && Array.isArray(specifiers) && specifiers[0] === '{}') {
       const inner = specifiers[1]
       if (inner != null) {
-        const items = Array.isArray(inner) && inner[0] === ',' ? inner.slice(1) : [inner]
+        const items = (Array.isArray(inner) && inner[0] === ',' ? inner.slice(1) : [inner]).filter(x => x != null)
         const builtinItems = []
         for (const item of items) {
           const name = typeof item === 'string' ? item : item[1]
@@ -794,7 +906,7 @@ const handlers = {
           }
         }
         if (builtinItems.length === 0) return null
-        if (!mods[MOD_ALIAS[mod] || mod]) {
+        if (!hasModule(mod)) {
           const name = typeof builtinItems[0] === 'string' ? builtinItems[0] : builtinItems[0][1]
           err(`'${name}' not declared in host module '${mod}'`)
         }
@@ -805,7 +917,7 @@ const handlers = {
     }
 
     // Tier 1: Built-in module
-    if (mods[MOD_ALIAS[mod] || mod]) {
+    if (hasModule(mod)) {
       includeModule(mod)
       const bind = (name, alias) => {
         const key = mod + '.' + name
@@ -819,7 +931,7 @@ const handlers = {
       if (Array.isArray(remaining) && remaining[0] === '{}') {
         const inner = remaining[1]
         if (inner == null) return null
-        const items = Array.isArray(inner) && inner[0] === ',' ? inner.slice(1) : [inner]
+        const items = (Array.isArray(inner) && inner[0] === ',' ? inner.slice(1) : [inner]).filter(x => x != null)
         for (const item of items)
           if (typeof item === 'string') bind(item)
           else if (Array.isArray(item) && item[0] === 'as') bind(item[1], item[2])
@@ -850,7 +962,7 @@ const handlers = {
       if (Array.isArray(specifiers) && specifiers[0] === '{}') {
         const inner = specifiers[1]
         if (inner == null) return null
-        const items = Array.isArray(inner) && inner[0] === ',' ? inner.slice(1) : [inner]
+        const items = (Array.isArray(inner) && inner[0] === ',' ? inner.slice(1) : [inner]).filter(x => x != null)
         for (const item of items) {
           const name = typeof item === 'string' ? item : item[1]
           const alias = typeof item === 'string' ? item : item[2]
@@ -867,7 +979,7 @@ const handlers = {
       if (Array.isArray(specifiers) && specifiers[0] === '{}') {
         const inner = specifiers[1]
         if (inner == null) return null
-        const items = Array.isArray(inner) && inner[0] === ',' ? inner.slice(1) : [inner]
+        const items = (Array.isArray(inner) && inner[0] === ',' ? inner.slice(1) : [inner]).filter(x => x != null)
         for (const item of items) {
           const name = typeof item === 'string' ? item : item[1]
           const alias = typeof item === 'string' ? item : item[2]
@@ -909,6 +1021,34 @@ const handlers = {
       for (const i of decl.slice(1))
         if (Array.isArray(i) && i[0] === '=' && typeof i[1] === 'string')
           ctx.func.exports[i[1]] = true
+    // export { name, name as alias } from './mod' or export * from './mod'
+    if (Array.isArray(decl) && decl[0] === 'from') {
+      const mod = decl[2]?.[1]
+      if (!mod || typeof mod !== 'string') return null
+      // Source module re-export
+      if (ctx.module.importSources?.[mod]) {
+        const resolved = prepareModule(mod, ctx.module.importSources[mod])
+        if (decl[1] === '*') {
+          // export * from './mod' → register all exports
+          for (const [name, mangled] of resolved.exports) {
+            if (name !== 'default') ctx.func.exports[name] = mangled
+          }
+        } else if (Array.isArray(decl[1]) && decl[1][0] === '{}') {
+          // export { a, b as c } from './mod'
+          const inner = decl[1][1]
+          if (inner == null) return null
+          const items = (Array.isArray(inner) && inner[0] === ',' ? inner.slice(1) : [inner]).filter(x => x != null)
+          for (const item of items) {
+            const name = typeof item === 'string' ? item : item[1]
+            const alias = typeof item === 'string' ? item : item[2]
+            const mangled = resolved.exports.get(name)
+            if (!mangled) err(`'${name}' is not exported from '${mod}'`)
+            ctx.func.exports[alias] = mangled
+          }
+        }
+      }
+      return null
+    }
     // export { name1, name2 as alias } → register named exports
     if (Array.isArray(decl) && decl[0] === '{}') {
       const inner = decl[1]
@@ -930,7 +1070,7 @@ const handlers = {
     if (Array.isArray(decl) && decl[0] === 'default') {
       const val = decl[1]
       // export default name → export existing name as 'default'
-      if (typeof val === 'string' && (ctx.func.list.some(f => f.name === val) || ctx.scope.globals.has(val))) {
+      if (typeof val === 'string' && (hasFunc(val) || ctx.scope.globals.has(val))) {
         ctx.func.exports['default'] = val  // alias
         return null
       }
@@ -949,13 +1089,14 @@ const handlers = {
 
   // Arrow: don't prep params. Track depth for nested function detection.
   '=>': (params, body) => {
-    if (depth > 0) { includeMods('core', 'fn') }
+    if (depth > 0) { includeForCallableValue() }
     const raw = extractParams(params)
     const fnScope = new Map()
     for (const n of collectParamNames(raw)) fnScope.set(n, n)
 
     depth++
     scopes.push(fnScope)
+    funcLocalNames.push(new Set(collectParamNames(raw)))
 
     const nextParams = []
     const bodyPrefix = []
@@ -988,6 +1129,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()
+    funcLocalNames.pop()
     depth--
     return result
   },
@@ -1019,7 +1161,9 @@ const handlers = {
   },
   // Boolean literals NaN-box as f64 — typeof at runtime returns 'number'. Fold here so the JS-spec value survives.
   'typeof'(a) {
-    if (Array.isArray(a) && a[0] == null && typeof a[1] === 'boolean') { includeMods('core', 'string'); return ['str', 'boolean'] }
+    if (Array.isArray(a) && a[0] == null && typeof a[1] === 'boolean') { includeForStringOnly(); return ['str', 'boolean'] }
+    const known = staticTypeofString(a)
+    if (known != null) { includeForStringOnly(); return ['str', known] }
     return ['typeof', prep(a)]
   },
 
@@ -1028,7 +1172,7 @@ const handlers = {
     if (b === undefined) {
       const na = prep(a)
       if (isLit(na) && typeof na[1] === 'number') return na
-      includeMods('number', 'string')
+      includeForNumericCoercion()
       return ['u+', na]
     }
     return ['+', prep(a), prep(b)]
@@ -1060,36 +1204,43 @@ const handlers = {
     return ['//', pattern, flags]
   },
 
-  // auto-include math for ** operator
-  '**'(a, b) { includeModule('math'); return ['**', prep(a), prep(b)] },
+  '**'(a, b) { return ['**', prep(a), prep(b)] },
 
   // Function call or grouping parens
 '()'(callee, ...args) {
     // Grouping: (expr) → ['()', expr] with no args. Call: f() → ['()', 'f', null] with null arg.
     if (args.length === 0) return prep(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)
 
     if (typeof callee === 'string') {
       if (PROHIBITED[callee]) err(PROHIBITED[callee])
       if (CTORS.includes(callee)) return handlers['new'](['()', callee, ...args])
 
-      const mods = CALL_MODULES[callee]
-      if (mods) {
-        includeMods(...mods)
+      if (includeForNamedCall(callee)) {
         if (callee === 'BigInt64Array' || callee === 'BigUint64Array') {
           return ['()', callee, ...args.filter(a => a != null).map(prep)]
         }
       }
 
-      const resolved = ctx.scope.chain[callee]
-      if (resolved?.includes('.')) callee = resolved
-      else if (resolved && ctx.func.list.some(f => f.name === resolved)) callee = resolved
+      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 (!ctx.module.imports.some(i => i[3]?.[1] === `$${resolved}`)) includeModule(resolved)
+        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}`)) {
-        includeMods('core', 'fn')
+        includeForCallableValue()
       }
     } else if (Array.isArray(callee) && callee[0] === '.') {
       const [, obj, prop] = callee
@@ -1099,29 +1250,37 @@ const handlers = {
         const alias = `${obj}$${prop}`
         addHostImport(obj, prop, alias, spec)
         callee = alias
-      } else if (key && CALL_MODULES[key]) {
-        includeMods(...CALL_MODULES[key])
+      } else if (key && includeForNamedCall(key)) {
         callee = key
-      } else if (GENERIC_METHOD_MODULES[prop]) {
-        includeMods(...GENERIC_METHOD_MODULES[prop])
+      } else if (includeForGenericMethod(prop)) {
         callee = prep(callee)
       } else {
         const mod = ctx.scope.chain[obj]
-        if (typeof obj === 'string' && mod && !mod.includes('.') && mods[MOD_ALIAS[mod] || mod]) {
+        if (typeof obj === 'string' && mod && !mod.includes('.') && hasModule(mod)) {
           callee = (includeModule(mod), mod + '.' + prop)
         } else {
           callee = prep(callee)
         }
       }
     } else {
-      includeMods('core', 'fn')
+      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' && ctx.func.list.some(f => f.name === a)) {
-        includeMods('core', 'fn'); break
+      if (typeof a === 'string' && hasFunc(a)) {
+        includeForCallableValue(); break
       }
     }
     const result = ['()', callee, ...preppedArgs]
@@ -1135,13 +1294,13 @@ const handlers = {
   '[]'(...args) {
     if (args.length === 1) {
       const inner = args[0]
-      includeMods('core', 'array')
+      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))] }
       return ['[', prep(inner)]
     }
     if (typeof args[0] === 'string' && ctx.module.namespaces?.[args[0]]) {
-      includeMods('core', 'string')
+      includeForStringOnly()
       const key = prep(args[1])
       const exports = [...ctx.module.namespaces[args[0]].entries()]
       let fallback = [, undefined]
@@ -1151,7 +1310,7 @@ const handlers = {
       }
       return fallback
     }
-    includeMods('core', 'array', 'collection')
+    includeForArrayAccess()
     return ['[]', prep(args[0]), prep(args[1])]
   },
 
@@ -1174,17 +1333,40 @@ const handlers = {
       return result
     }
 
-    includeMods('core', 'object')
+    includeForObjectLiteral()
     if (inner == null) return ['{}']
     // Process properties: shorthand 'x' → [':', 'x', 'x'], or [':', key, val] → prep val only
     const prop = p => {
       if (typeof p === 'string') return [':', p, prep(p)]
-      if (Array.isArray(p) && p[0] === ':') return [':', p[1], prep(p[2])]
+      if (Array.isArray(p) && p[0] === ':') {
+        const key = typeof p[1] === 'string' ? p[1] : staticPropertyKey(p[1])
+        if (key == null) err('computed property name not supported for fixed-shape object: use a compile-time string/number key')
+        return [':', key, prep(p[2])]
+      }
       return prep(p)
     }
-    const result = Array.isArray(inner) && inner[0] === ','
-      ? ['{}', ...inner.slice(1).map(prop)]
-      : ['{}', prop(inner)]
+    // 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()
+    for (const p of prepped) if (Array.isArray(p) && p[0] === ':') lastValue.set(p[1], p[2])
+    if (lastValue.size < prepped.filter(p => Array.isArray(p) && p[0] === ':').length) {
+      const seen = new Set()
+      prepped = prepped.filter(p => {
+        if (!Array.isArray(p) || p[0] !== ':') return true
+        if (seen.has(p[1])) return false
+        seen.add(p[1])
+        p[2] = lastValue.get(p[1])
+        return true
+      })
+    }
+    const result = ['{}', ...prepped]
     // Register schema so property access works for function params (duck typing)
     const props = result.slice(1).filter(p => Array.isArray(p) && p[0] === ':').map(p => p[1])
     if (props.length && ctx.schema.register) ctx.schema.register(props)
@@ -1198,15 +1380,19 @@ const handlers = {
     if (Array.isArray(head) && head[0] === ';') {
       let [, init, cond, step] = head
       // Hoist .length / .size / .byteLength from for-condition:
-      //   `i < arr.length` → `let __len = arr.length; ... i < __len`
-      // All three return i32 (TYPED/ARRAY/STRING/BUFFER/SET/MAP), so the hoisted
-      // local stays i32 once exprType narrows it.
+      //   `i < arr.length` → `let __len = arr.length | 0; ... i < __len`
+      // The `| 0` forces i32 even for unknown-typed receivers (where __length
+      // returns f64). NaN→0 via i32.trunc_sat matches JS semantics: a NaN bound
+      // makes `i < NaN` false on both representations, so the loop is skipped
+      // either way. Keeping the hoisted bound i32 lets the counter `i` stay i32
+      // through the comparison and `i++`, eliminating the per-iteration
+      // f64.convert_i32_s + f64.lt + f64.add + i32.trunc_sat_f64_s sequence.
       if (cond && Array.isArray(cond) && (cond[0] === '<' || cond[0] === '<=' || cond[0] === '>' || cond[0] === '>=')) {
         const lenExpr = cond[0] === '<' || cond[0] === '<=' ? cond[2] : cond[1]
         if (Array.isArray(lenExpr) && lenExpr[0] === '.' &&
             (lenExpr[2] === 'length' || lenExpr[2] === 'size' || lenExpr[2] === 'byteLength')) {
           const lenVar = `${T}len${ctx.func.uniq++}`
-          const lenDecl = ['let', ['=', lenVar, lenExpr]]
+          const lenDecl = ['let', ['=', lenVar, ['|', lenExpr, [, 0]]]]
           init = init ? [';', init, lenDecl] : lenDecl
           if (cond[0] === '<' || cond[0] === '<=') cond = [cond[0], cond[1], lenVar]
           else cond = [cond[0], lenVar, cond[2]]
@@ -1223,9 +1409,12 @@ const handlers = {
       const lenVar = `${T}len${ctx.func.uniq++}`
       const trivial = typeof src === 'string'
       const arrVar = trivial ? src : `${T}arr${ctx.func.uniq++}`
+      // Wrap .length in `| 0` so the hoisted bound is i32 even for unknown
+      // receivers (same rationale as the for-cond hoist above).
+      const lenE = ['|', ['.', arrVar, 'length'], [, 0]]
       const decls = trivial
-        ? ['let', ['=', idx, [, 0]], ['=', lenVar, ['.', arrVar, 'length']]]
-        : ['let', ['=', arrVar, src], ['=', idx, [, 0]], ['=', lenVar, ['.', arrVar, 'length']]]
+        ? ['let', ['=', idx, [, 0]], ['=', lenVar, lenE]]
+        : ['let', ['=', arrVar, src], ['=', idx, [, 0]], ['=', lenVar, lenE]]
       const cond = ['<', idx, lenVar]
       const step = ['++', idx]
       const inner = [';', ['let', ['=', varName, ['[]', arrVar, idx]]], body]
@@ -1233,14 +1422,14 @@ const handlers = {
     } else if (Array.isArray(head) && head[0] === 'in') {
       // for (let k in obj) → unroll at compile time when schema known, else HASH runtime iteration
       const [, decl, src] = head
-      const varName = Array.isArray(decl) && decl[0] === 'let' ? decl[1] : decl
+      const varName = Array.isArray(decl) && (decl[0] === 'let' || decl[0] === 'const') ? decl[1] : decl
       const srcName = typeof src === 'string' ? (ctx.scope.chain[src] || src) : null
-      const sid = typeof srcName === 'string' && ctx.schema.vars.get(srcName)
+      const sid = typeof srcName === 'string' ? ctx.schema.vars.get(srcName) : null
       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 }
-        includeMods('core', 'string')
+        includeForKnownKeyIteration()
         const stmts = []
         for (let i = 0; i < keys.length; i++) {
           stmts.push(i === 0
@@ -1251,7 +1440,7 @@ const handlers = {
         r = prep([';', ...stmts])
       } else {
         // Dynamic object → HASH runtime iteration
-        includeMods('core', 'string', 'collection')
+        includeForRuntimeKeyIteration()
         r = ['for-in', varName, prep(src), prep(body)]
       }
     } else {
@@ -1263,24 +1452,22 @@ const handlers = {
 
   // Property access - resolve namespaces or object/array properties
   '.'(obj, 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]
     // Only treat as module namespace if it's a known built-in module (not a mangled import name)
-    if (typeof obj === 'string' && mod && !mod.includes('.') && mods[MOD_ALIAS[mod] || mod])
-      return includeModule(mod), mod + '.' + prop
+    if (typeof obj === 'string' && mod && !mod.includes('.') && hasModule(mod)) {
+      includeModule(mod)
+      const key = mod + '.' + prop
+      if (ctx.core.emit[key]?.length > 0) includeForCallableValue()
+      return key
+    }
     // Source module namespace: import * as X → X.prop resolved to mangled name
     if (typeof obj === 'string' && ctx.module.namespaces?.[obj]) {
       const mangled = ctx.module.namespaces[obj].get(prop)
       if (mangled) return mangled
     }
-    // Typed-array/buffer properties auto-include typedarray module
-    if (prop === 'byteLength' || prop === 'byteOffset' || prop === 'buffer') {
-      includeMods('core', 'typedarray')
-    }
-    // Narrowing: unambiguous property name limits module load; otherwise pessimistic.
-    // Receiver-literal narrowing would still need collection for __dyn_get_expr fallback
-    // on unknown props, so it saves nothing — stick with property-name narrowing only.
-    if (typeof prop === 'string' && PROP_MODULES[prop]) includeMods(...PROP_MODULES[prop])
-    else includeMods('core', 'object', 'array', 'string', 'collection')
+    includeForProperty(prop)
     return ['.', prep(obj), prop]
   },
 
@@ -1292,20 +1479,21 @@ const handlers = {
     if (ctorArgs.length === 1 && Array.isArray(ctorArgs[0]) && ctorArgs[0][0] === ',')
       ctorArgs = ctorArgs[0].slice(1)
 
+    if (name === 'URL') {
+      const literalArgs = ctorArgs.filter(a => a != null)
+      if (literalArgs.length === 2 && isImportMetaProp(literalArgs[1], 'url')) {
+        const spec = stringValue(literalArgs[0])
+        if (spec == null) err('`new URL(relative, import.meta.url)` supports only string literal relatives')
+        return staticString(resolveImportMeta(spec))
+      }
+    }
+
     // 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]
       : args.length === 1 ? [prep(args[0])]
       : [[',', ...args.map(prep)]]
-    // TypedArray / buffer constructors
-    const typedArrays = ['Float64Array','Float32Array','Int32Array','Uint32Array','Int16Array','Uint16Array','Int8Array','Uint8Array','BigInt64Array','BigUint64Array','ArrayBuffer','DataView']
-    if (typedArrays.includes(name)) {
-      includeMods('core', 'typedarray')
-      return ['()', `new.${name}`, ...wrapArgs(ctorArgs)]
-    }
-    // Set/Map constructors
-    if (name === 'Set' || name === 'Map') {
-      includeMods('core', 'collection')
+    if (includeForRuntimeCtor(name)) {
       return ['()', `new.${name}`, ...wrapArgs(ctorArgs)]
     }
 
@@ -1317,37 +1505,6 @@ const handlers = {
   }
 }
 
-// Namespace → module mapping (namespaces that share a module)
-const MOD_ALIAS = { Number: 'number', Array: 'array', Object: 'object', Symbol: 'symbol', JSON: 'json', BigInt: 'number', Error: 'core', TextEncoder: 'string', TextDecoder: 'string' }
-/** Auto-inclusion graph: loading a module also loads its listed prerequisites.
- *  Not a strict ordering: module init() functions only register emitters/stdlib entries,
- *  so relative init order does not affect correctness — emitters are looked up lazily
- *  at compile time. Cycles (e.g. number ↔ string) are broken via the in-progress guard. */
-const MOD_DEPS = {
-  number: ['core', 'string'],
-  string: ['core', 'number'],
-  array: ['core'],
-  object: ['core'],
-  collection: ['core', 'number'],
-  symbol: ['core'],
-  json: ['core', 'string', 'number', 'collection'],
-  console: ['core', 'string', 'number'],
-  regex: ['core', 'string', 'array'],
-}
-
-const includeMods = (...names) => names.forEach(includeModule)
-
-/** Register a module and its transitive deps. Idempotent; cycle-safe via early-mark. */
-function includeModule(name) {
-  const modName = MOD_ALIAS[name] || name
-  const init = mods[modName]
-  if (!init) return err(`Module not found: ${name}`)
-  if (ctx.module.modules[modName]) return
-  ctx.module.modules[modName] = true  // mark before deps so cycles terminate
-  for (const dep of MOD_DEPS[modName] || []) includeModule(dep)
-  init(ctx)  // modules receive ctx explicitly instead of importing it
-}
-
 /** Merge source schemas into target via Object.assign for compile-time schema inference. */
 function inferAssignSchema(callNode) {
   // After prep, args may be comma-grouped: ['()', callee, [',', target, s1, s2]]
@@ -1421,6 +1578,7 @@ function defFunc(name, node) {
   const funcInfo = { name, body, exported, sig, ...(hasDefaults && { defaults }) }
   if (hasRest.length) funcInfo.rest = hasRest[0]  // track rest param name
   ctx.func.list.push(funcInfo)
+  ctx.func.names.add(name)
   return true
 }
 
@@ -1493,6 +1651,19 @@ function prepareModule(specifier, source) {
 
   // Collect exports: rename exported funcs with prefix
   const moduleExports = new Map()
+  const exportLocal = (exportName, localName) => {
+    const mangled = `${prefix}$${localName}`
+    moduleExports.set(exportName, mangled)
+    const func = ctx.func.list.find(f => f.name === localName)
+    if (func) renameFunc(func, mangled)
+    if (ctx.scope.globals.has(localName)) {
+      const wat = ctx.scope.globals.get(localName).replace(`$${localName}`, `$${mangled}`)
+      ctx.scope.globals.delete(localName)
+      ctx.scope.globals.set(mangled, wat)
+      if (ctx.scope.userGlobals.has(localName)) { ctx.scope.userGlobals.delete(localName); ctx.scope.userGlobals.add(mangled) }
+      if (ctx.scope.globalTypes.has(localName)) { ctx.scope.globalTypes.set(mangled, ctx.scope.globalTypes.get(localName)); ctx.scope.globalTypes.delete(localName) }
+    }
+  }
   for (const name of Object.keys(ctx.func.exports)) {
     const val = ctx.func.exports[name]
     // Default export alias: export default existingName → map 'default' to that name's mangled form
@@ -1500,19 +1671,29 @@ function prepareModule(specifier, source) {
       // Will resolve after all named exports are mangled
       continue
     }
-    const mangled = `${prefix}$${name}`
-    moduleExports.set(name, mangled)
-    // Rename the function in ctx.func.list
-    const func = ctx.func.list.find(f => f.name === name)
-    if (func) func.name = mangled
-    // Rename globals
-    if (ctx.scope.globals.has(name)) {
-      const wat = ctx.scope.globals.get(name).replace(`$${name}`, `$${mangled}`)
-      ctx.scope.globals.delete(name)
-      ctx.scope.globals.set(mangled, wat)
-      if (ctx.scope.userGlobals.has(name)) { ctx.scope.userGlobals.delete(name); ctx.scope.userGlobals.add(mangled) }
-      if (ctx.scope.globalTypes.has(name)) { ctx.scope.globalTypes.set(mangled, ctx.scope.globalTypes.get(name)); ctx.scope.globalTypes.delete(name) }
+    // Re-export alias: export { x } from './mod' → pass through inner module's mangled name
+    if (typeof val === 'string') {
+      if (val.startsWith(prefix + '$')) {
+        moduleExports.set(name, val)
+        continue
+      }
+      // Re-export of a binding imported from another module: val already carries
+      // that other module's prefix (e.g. `__c$x`). Renaming it under our own
+      // prefix would break in-module call sites that still reference the
+      // original mangled name. Pass through verbatim.
+      if (val.includes('$') &&
+          (ctx.func.list.some(f => f.name === val) || ctx.scope.globals.has(val))) {
+        moduleExports.set(name, val)
+        continue
+      }
+      if (ctx.func.list.some(f => f.name === val || f.name === `${prefix}$${val}`) || ctx.scope.globals.has(val) || ctx.scope.globals.has(`${prefix}$${val}`)) {
+        exportLocal(name, val)
+        continue
+      }
+      moduleExports.set(name, val)
+      continue
     }
+    exportLocal(name, name)
   }
   // Resolve default export alias after named exports are mangled
   if (typeof ctx.func.exports['default'] === 'string') {
@@ -1525,7 +1706,7 @@ function prepareModule(specifier, source) {
       const mangled = `${prefix}$${alias}`
       moduleExports.set('default', mangled)
       const func = ctx.func.list.find(f => f.name === alias)
-      if (func) func.name = mangled
+      if (func) renameFunc(func, mangled)
       if (ctx.scope.globals.has(alias)) {
         const wat = ctx.scope.globals.get(alias).replace(`$${alias}`, `$${mangled}`)
         ctx.scope.globals.delete(alias)
@@ -1544,7 +1725,7 @@ function prepareModule(specifier, source) {
     if (func.name.includes('__') && func.name.includes('$')) continue
     const mangled = `${prefix}$${func.name}`
     moduleExports.set(func.name, mangled)
-    func.name = mangled
+    renameFunc(func, mangled)
   }
 
   // Add mangled non-exported globals to moduleExports for walk renaming
@@ -1584,6 +1765,7 @@ function prepareModule(specifier, source) {
   if (moduleInit) {
     if (!ctx.module.moduleInits) ctx.module.moduleInits = []
     ctx.module.moduleInits.push(moduleInit)
+    recordModuleInitFacts(moduleInit)
   }
 
   // Restore caller state