jz 0.1.0 → 0.1.1

package/src/prepare.js

@@ -24,8 +24,17 @@
 
 import { parse } from 'subscript/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 } from './analyze.js'
+import { staticPropertyKey } from './key.js'
+import { normalizeSource } from './source.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}]
@@ -50,6 +59,79 @@ const addHostImport = (mod, name, alias, spec) => {
   if (vt) ctx.module.hostImportValTypes.set(alias, vt)
 }
 
+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 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 }
+        visitFuncValue(a)
+      }
+      return
+    }
+    if (op === '.' || op === '?.') {
+      if (typeof args[0] === 'string' && ctx.func.names.has(args[0])) { 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 }
+      visitFuncValue(a)
+    }
+  }
+  const walk = (node) => {
+    if (!Array.isArray(node)) {
+      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)
+  }
+  visitFuncValue(root)
+  walk(root)
+}
+
 /**
  * @typedef {null|number|string|ASTNode[]} ASTNode
  */
@@ -103,13 +185,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 +198,10 @@ 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()
   }
 
   return ast
@@ -146,6 +225,14 @@ 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 }
 function resolveTypeof(node) {
@@ -163,56 +250,6 @@ function resolveTypeof(node) {
   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 +257,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 +406,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 +417,7 @@ 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'] }
       const resolved = ctx.scope.chain[node]
       if (resolved?.includes('.')) return resolved
       // Cross-module import: mangled name (e.g. __util_js$clone)
@@ -453,7 +432,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
@@ -517,7 +496,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 +512,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 +571,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)
 
@@ -633,6 +617,7 @@ function prepDecl(op, ...inits) {
           ctx.scope.consts.delete(declName)
           ctx.scope.constStrs?.delete(declName)
         }
+        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 +647,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 +657,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'),
@@ -708,7 +693,7 @@ 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
     }
@@ -736,16 +721,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)
@@ -794,7 +775,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 +786,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
@@ -930,7 +911,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,7 +930,7 @@ 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)
@@ -1019,7 +1000,7 @@ 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'] }
     return ['typeof', prep(a)]
   },
 
@@ -1028,7 +1009,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,8 +1041,7 @@ 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) {
@@ -1074,9 +1054,7 @@ const handlers = {
       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)]
         }
@@ -1084,12 +1062,12 @@ const handlers = {
 
       const resolved = ctx.scope.chain[callee]
       if (resolved?.includes('.')) callee = resolved
-      else if (resolved && ctx.func.list.some(f => f.name === resolved)) 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)
       }
       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 +1077,27 @@ 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)
     }
 
     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 +1111,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 +1127,7 @@ const handlers = {
       }
       return fallback
     }
-    includeMods('core', 'array', 'collection')
+    includeForArrayAccess()
     return ['[]', prep(args[0]), prep(args[1])]
   },
 
@@ -1174,12 +1150,16 @@ 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] === ','
@@ -1240,7 +1220,7 @@ const handlers = {
         // 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 +1231,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 +1243,17 @@ 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')
     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])
+    if (typeof obj === 'string' && mod && !mod.includes('.') && hasModule(mod))
       return includeModule(mod), mod + '.' + prop
     // 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]
   },
 
@@ -1297,15 +1270,7 @@ const handlers = {
     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 +1282,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 +1355,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
 }
 
@@ -1485,7 +1420,7 @@ function prepareModule(specifier, source) {
   ctx.module.currentPrefix = prefix
 
   // Parse + prepare imported source (may trigger recursive imports)
-  let ast = parse(source)
+  let ast = parse(normalizeSource(source))
   if (ctx.transform.jzify) ast = ctx.transform.jzify(ast)
   const savedDepth = depth; depth = 0
   const moduleInit = prep(ast)
@@ -1504,7 +1439,7 @@ function prepareModule(specifier, source) {
     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
+    if (func) renameFunc(func, mangled)
     // Rename globals
     if (ctx.scope.globals.has(name)) {
       const wat = ctx.scope.globals.get(name).replace(`$${name}`, `$${mangled}`)
@@ -1525,7 +1460,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 +1479,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 +1519,7 @@ function prepareModule(specifier, source) {
   if (moduleInit) {
     if (!ctx.module.moduleInits) ctx.module.moduleInits = []
     ctx.module.moduleInits.push(moduleInit)
+    recordModuleInitFacts(moduleInit)
   }
 
   // Restore caller state