jz 0.1.1 → 0.2.0

package/src/prepare.js

@@ -22,11 +22,10 @@
  * @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, valTypeOf, typedElemCtor, extractParams, collectParamNames, classifyParam } from './analyze.js'
-import { staticPropertyKey } from './key.js'
-import { normalizeSource } from './source.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,
@@ -38,6 +37,30 @@ import {
 
 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
@@ -50,15 +73,51 @@ 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)
@@ -76,26 +135,25 @@ function recordModuleInitFacts(root) {
     hasFuncValue: false, timerNames: new Set(),
     maxDef: 0, maxCall: 0, hasRest: false, hasSpread: false,
   }
-  const isLiteralStr = idx => Array.isArray(idx) && idx[0] === 'str' && typeof idx[1] === 'string'
   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 (typeof a === 'string' && ctx.func.names.has(a)) { facts.hasFuncValue = true; return }
+        if (isFuncRef(a, ctx.func.names)) { facts.hasFuncValue = true; return }
         visitFuncValue(a)
       }
       return
     }
     if (op === '.' || op === '?.') {
-      if (typeof args[0] === 'string' && ctx.func.names.has(args[0])) { facts.hasFuncValue = true; return }
+      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 (typeof a === 'string' && ctx.func.names.has(a)) { facts.hasFuncValue = true; return }
+      if (isFuncRef(a, ctx.func.names)) { facts.hasFuncValue = true; return }
       visitFuncValue(a)
     }
   }
@@ -104,29 +162,8 @@ function recordModuleInitFacts(root) {
       if (typeof node === 'string' && TIMER_NAMES.has(node)) facts.timerNames.add(node)
       return
     }
-    const [op, ...args] = node
-    if (op === '[]') {
-      const [obj, idx] = args
-      if (!isLiteralStr(idx)) { facts.anyDyn = true; if (typeof obj === 'string') facts.dynVars.add(obj) }
-    } else if (op === 'for-in') {
-      facts.anyDyn = true
-      if (typeof args[1] === 'string') facts.dynVars.add(args[1])
-    } else if (op === '{}') {
-      facts.hasSchemaLiterals = true
-    } else if (op === '=>') {
-      let fixedN = 0
-      for (const r of extractParams(args[0])) {
-        if (classifyParam(r).kind === 'rest') facts.hasRest = true
-        else fixedN++
-      }
-      if (fixedN > facts.maxDef) facts.maxDef = fixedN
-    } else if (op === '()') {
-      const a = args[1]
-      const callArgs = a == null ? [] : (Array.isArray(a) && a[0] === ',') ? a.slice(1) : [a]
-      if (callArgs.some(x => Array.isArray(x) && x[0] === '...')) facts.hasSpread = true
-      if (callArgs.length > facts.maxCall) facts.maxCall = callArgs.length
-    }
-    for (const a of args) walk(a)
+    observeNodeFacts(node, facts)
+    for (const a of node.slice(1)) walk(a)
   }
   visitFuncValue(root)
   walk(root)
@@ -144,18 +181,28 @@ function recordModuleInitFacts(root) {
 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])) {
@@ -173,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
@@ -204,6 +247,34 @@ export default function prepare(node) {
     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
 }
 
@@ -234,16 +305,28 @@ 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 }
+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]]
   }
@@ -418,6 +501,8 @@ function prep(node) {
       if (PROHIBITED[node]) err(PROHIBITED[node])
       // Boolean/Number as value → identity arrow (for .filter(Boolean), .map(Number) etc.)
       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)
@@ -462,6 +547,7 @@ export const GLOBALS = {
   Object: 'Object',
   Symbol: 'Symbol',
   JSON: 'JSON',
+  Date: 'Date',
   isNaN: 'number',
   isFinite: 'number',
   parseInt: 'number',
@@ -475,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)
@@ -595,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) {
@@ -613,10 +732,19 @@ 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)
@@ -671,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]]
@@ -695,7 +826,7 @@ const handlers = {
     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 null  // extracted as function, no assignment needed
+      if (defFunc(name, prep(rhs))) return ['=', prep(lhs), name]
     }
     return ['=', prep(lhs), prep(rhs)]
   },
@@ -762,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]
@@ -800,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])
@@ -831,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]
@@ -848,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]
@@ -890,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]
@@ -937,6 +1096,7 @@ const handlers = {
 
     depth++
     scopes.push(fnScope)
+    funcLocalNames.push(new Set(collectParamNames(raw)))
 
     const nextParams = []
     const bodyPrefix = []
@@ -969,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
   },
@@ -1001,6 +1162,8 @@ 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') { includeForStringOnly(); return ['str', 'boolean'] }
+    const known = staticTypeofString(a)
+    if (known != null) { includeForStringOnly(); return ['str', known] }
     return ['typeof', prep(a)]
   },
 
@@ -1048,6 +1211,14 @@ const handlers = {
     // 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') {
@@ -1060,11 +1231,13 @@ const handlers = {
         }
       }
 
-      const resolved = ctx.scope.chain[callee]
-      if (resolved?.includes('.')) 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}`)) {
         includeForCallableValue()
@@ -1094,6 +1267,16 @@ const handlers = {
       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)) {
@@ -1162,9 +1345,28 @@ const handlers = {
       }
       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)
@@ -1178,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]]
@@ -1203,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]
@@ -1213,9 +1422,9 @@ 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]
@@ -1244,10 +1453,15 @@ 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('.') && hasModule(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)
@@ -1265,6 +1479,15 @@ 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]
@@ -1420,7 +1643,7 @@ function prepareModule(specifier, source) {
   ctx.module.currentPrefix = prefix
 
   // Parse + prepare imported source (may trigger recursive imports)
-  let ast = parse(normalizeSource(source))
+  let ast = parse(source)
   if (ctx.transform.jzify) ast = ctx.transform.jzify(ast)
   const savedDepth = depth; depth = 0
   const moduleInit = prep(ast)
@@ -1428,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
@@ -1435,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) renameFunc(func, 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') {