jz 0.1.0 → 0.1.1

package/src/ctx.js

@@ -109,6 +109,7 @@ export function reset(proto, globals) {
     resolvedModules: new Map(),
     moduleStack: [],
     moduleInits: [],
+    initFacts: null,
     currentPrefix: null,
   }
 

package/src/emit.js

@@ -1877,20 +1877,30 @@ export const emitter = {
         const combined = reconstructArgsWithSpreads(parsed.normal, parsed.spreads)
         const arrayIR = buildArrayWithSpreads(combined)
         const propRead = typed(['call', '$__dyn_get_expr', ['local.get', `$${objTmp}`], asF64(emit(['str', method]))], 'f64')
+        const propTmp = `${T}mprop${ctx.func.uniq++}`
+        ctx.func.locals.set(propTmp, 'f64')
         if (usesDynProps(vt)) {
-          inc('__dyn_get_expr')
+          inc('__dyn_get_expr', '__ptr_type')
           return typed(['block', ['result', 'f64'],
             ['local.set', `$${objTmp}`, asF64(emit(obj))],
-            ctx.closure.call(propRead, [arrayIR], true)], 'f64')
+            ['local.set', `$${propTmp}`, propRead],
+            ['if', ['result', 'f64'],
+              ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${propTmp}`]], ['i32.const', PTR.CLOSURE]],
+              ['then', ctx.closure.call(typed(['local.get', `$${propTmp}`], 'f64'), [arrayIR], true)],
+              ['else', undefExpr()]]], 'f64')
         }
-        inc('__dyn_get_expr', '__ext_call')
+        inc('__dyn_get_expr', '__ext_call', '__ptr_type')
         ctx.features.external = true
         return typed(['block', ['result', 'f64'],
           ['local.set', `$${objTmp}`, asF64(emit(obj))],
+          ['local.set', `$${propTmp}`, propRead],
           ['if', ['result', 'f64'],
-            ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${objTmp}`]], ['i32.const', PTR.EXTERNAL]],
-            ['then', ['call', '$__ext_call', ['local.get', `$${objTmp}`], asF64(emit(['str', method])), arrayIR]],
-            ['else', ctx.closure.call(propRead, [arrayIR], true)]]], 'f64')
+            ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${propTmp}`]], ['i32.const', PTR.CLOSURE]],
+            ['then', ctx.closure.call(typed(['local.get', `$${propTmp}`], 'f64'), [arrayIR], true)],
+            ['else', ['if', ['result', 'f64'],
+              ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${objTmp}`]], ['i32.const', PTR.EXTERNAL]],
+              ['then', ['call', '$__ext_call', ['local.get', `$${objTmp}`], asF64(emit(['str', method])), arrayIR]],
+              ['else', undefExpr()]]]]], 'f64')
       }
 
       // Unknown callee - assume external method

package/src/host.js

@@ -435,36 +435,31 @@ export const wrap = (memSrc, inst) => {
   return exports
 }
 
-/**
- * Compile, instantiate, and wrap exports (with WASI + rest-param support).
- * `compile` is the jz.compile function (injected to avoid importing the compiler core).
- */
-export const instantiate = (compile, code, opts = {}) => {
-  const extMap = [null]
-  let mem = null
+const prepareInterop = (opts) => {
+  const state = { extMap: [null], mem: null }
   opts._interp = opts._interp || {}
   opts._interp.__ext_prop = (objPtr, propPtr) => {
-    const obj = extMap[offset(objPtr)]
-    const prop = mem.read(propPtr)
-    return mem.wrapVal(typeof obj[prop] === 'function' ? obj[prop].bind(obj) : obj[prop])
+    const obj = state.extMap[offset(objPtr)]
+    const prop = state.mem.read(propPtr)
+    return state.mem.wrapVal(typeof obj[prop] === 'function' ? obj[prop].bind(obj) : obj[prop])
   }
   opts._interp.__ext_has = (objPtr, propPtr) => {
-    return (mem.read(propPtr) in extMap[offset(objPtr)]) ? 1 : 0
+    return (state.mem.read(propPtr) in state.extMap[offset(objPtr)]) ? 1 : 0
   }
   opts._interp.__ext_set = (objPtr, propPtr, valPtr) => {
-    extMap[offset(objPtr)][mem.read(propPtr)] = mem.read(valPtr)
+    state.extMap[offset(objPtr)][state.mem.read(propPtr)] = state.mem.read(valPtr)
     return 1
   }
   opts._interp.__ext_call = (objPtr, propPtr, argsPtr) => {
-    const obj = extMap[offset(objPtr)]
-    const prop = mem.read(propPtr)
-    const args = mem.read(argsPtr)
-    return mem.wrapVal(obj[prop].apply(obj, args))
+    const obj = state.extMap[offset(objPtr)]
+    const prop = state.mem.read(propPtr)
+    const args = state.mem.read(argsPtr)
+    return state.mem.wrapVal(obj[prop].apply(obj, args))
   }
+  return state
+}
 
-  const wasm = compile(code, opts)
-  opts.extMap = extMap
-  const mod = new WebAssembly.Module(wasm)
+const buildImports = (mod, opts, state) => {
   const needsWasi = WebAssembly.Module.imports(mod).some(i => i.module === 'wasi_snapshot_preview1')
   const imports = needsWasi ? wasi(opts) : {}
   if (opts._interp) imports.env = { ...imports.env, ...opts._interp }
@@ -477,8 +472,8 @@ export const instantiate = (compile, code, opts = {}) => {
       const fn = typeof spec === 'function' ? spec : (spec && typeof spec === 'object' ? spec.fn : null)
       if (typeof fn === 'function')
         imports[modName][name] = (...args) => {
-          const ret = fn.call(fns, ...args.map(a => mem ? mem.read(a) : a))
-          return mem ? mem.wrapVal(ret) : coerce(ret)
+          const ret = fn.call(fns, ...args.map(a => state.mem ? state.mem.read(a) : a))
+          return state.mem ? state.mem.wrapVal(ret) : coerce(ret)
         }
     }
   }
@@ -495,13 +490,15 @@ export const instantiate = (compile, code, opts = {}) => {
       const host = globalThis[imp.name]
       if (host !== undefined) {
         if (!imports.env) imports.env = {}
-        let id = extMap.indexOf(host); if (id === -1) { id = extMap.length; extMap.push(host) }
+        let id = state.extMap.indexOf(host); if (id === -1) { id = state.extMap.length; state.extMap.push(host) }
         imports.env[imp.name] = new WebAssembly.Global({ value: 'f64', mutable: true }, ptr(11, 0, id))
       }
     }
   }
-  const hasImports = Object.keys(imports).some(k => k !== '_setMemory')
-  const inst = new WebAssembly.Instance(mod, hasImports ? imports : undefined)
+  return { imports, needsWasi }
+}
+
+const finishInstantiation = (mod, inst, imports, needsWasi, opts, state) => {
   if (needsWasi) imports._setMemory(inst.exports.memory)
 
   // Drive WASM timer queue via JS scheduling (non-blocking)
@@ -517,8 +514,23 @@ export const instantiate = (compile, code, opts = {}) => {
 
   // For shared memory, resolve memory from import; for own memory, from export
   const rawMemory = opts.memory || inst.exports.memory
-  const memSrc = { module: mod, instance: inst, exports: { ...inst.exports, memory: rawMemory }, extMap }
+  const memSrc = { module: mod, instance: inst, exports: { ...inst.exports, memory: rawMemory }, extMap: state.extMap }
   const enhanced = memory(memSrc)
-  mem = enhanced
+  state.mem = enhanced
   return { exports: wrap(memSrc), memory: enhanced, instance: inst, module: mod }
 }
+
+/**
+ * Compile, instantiate, and wrap exports (with WASI + rest-param support).
+ * `compile` is the jz.compile function (injected to avoid importing the compiler core).
+ */
+export const instantiate = (compile, code, opts = {}) => {
+  const state = prepareInterop(opts)
+  const wasm = compile(code, opts)
+  opts.extMap = state.extMap
+  const mod = new WebAssembly.Module(wasm)
+  const { imports, needsWasi } = buildImports(mod, opts, state)
+  const hasImports = Object.keys(imports).some(k => k !== '_setMemory')
+  const inst = new WebAssembly.Instance(mod, hasImports ? imports : undefined)
+  return finishInstantiation(mod, inst, imports, needsWasi, opts, state)
+}

package/src/jzify.js

@@ -122,21 +122,33 @@ function paramList(params) {
 }
 
 function lowerArguments(params, body) {
-  if (!usesArguments(body)) return [params, body]
+  if (!usesArguments(params) && !usesArguments(body)) return [params, body]
   const name = `\uE001arg${argsIdx++}`
-  const items = paramList(params)
-  items.push(['...', name])
-  const inner = items.length === 1 ? items[0] : [',', ...items]
-  return [['()', inner], renameArguments(body, name)]
+  const decls = []
+  for (const [idx, param] of paramList(params).entries()) {
+    if (Array.isArray(param) && param[0] === '...') {
+      decls.push(['=', param[1], ['()', ['.', name, 'slice'], [null, idx]]])
+      continue
+    }
+    if (Array.isArray(param) && param[0] === '=') {
+      decls.push(['=', param[1], ['??', ['[]', name, [null, idx]], renameArguments(param[2], name)]])
+      continue
+    }
+    decls.push(['=', param, ['[]', name, [null, idx]]])
+  }
+  const renamed = renameArguments(body, name)
+  return [['()', ['...', name]], decls.length ? [';', ['let', ...decls], renamed] : renamed]
 }
 
+const arrowParams = params => Array.isArray(params) && params[0] === '()' ? params : ['()', params]
+
 const handlers = {
   // Named IIFE: (function name(p){b})(a) → let name = arrow; name(a)
   '()'(callee, ...rest) {
     if (Array.isArray(callee) && callee[0] === '()' && Array.isArray(callee[1]) && callee[1][0] === 'function' && callee[1][1]) {
       const [, name, params, body] = callee[1]
       const [p2, b2] = lowerArguments(params, body)
-      return [';', ['let', ['=', name, ['=>', p2, wrapArrowBody(b2)]]], ['()', name, ...rest.map(transform)]]
+      return [';', ['let', ['=', name, ['=>', arrowParams(p2), wrapArrowBody(b2)]]], ['()', name, ...rest.map(transform)]]
     }
   },
 
@@ -148,7 +160,14 @@ const handlers = {
     return arrow
   },
 
-  'var'(...args) { return ['let', ...args.map(transform)] },
+  'var'(...args) {
+    // for-in/for-of: ['var', ['in', 'k', obj]] → ['in', ['let', 'k'], obj]
+    if (args.length === 1 && Array.isArray(args[0]) && (args[0][0] === 'in' || args[0][0] === 'of')) {
+      const [, name, src] = args[0]
+      return [args[0][0], ['let', typeof name === 'string' ? name : transform(name)], transform(src)]
+    }
+    return ['let', ...args.map(transform)]
+  },
 
   '='(lhs, rhs) {
     // var assignment: ['=', ['var', name], init] → let
@@ -205,16 +224,14 @@ const handlers = {
     return ['===', ['typeof', t], [null, 'object']]
   },
 
-  // do { body } while (cond) → for (let _once = true; _once || cond; _once = false) body
-  // Avoids body duplication; matches JS continue semantics (continue runs cond, not body).
+  // do { body } while (cond) → let _once = true; while (_once || cond) { _once = false; body }
+  // Avoids body duplication and preserves continue: `continue` jumps back to the
+  // while condition after the one-shot flag has been cleared.
   'do'(body, cond) {
     const flag = `do${doIdx++}`
-    return ['for',
-      [';',
-        ['let', ['=', flag, [null, true]]],
-        ['||', flag, transform(cond)],
-        ['=', flag, [null, false]]],
-      transform(body)]
+    return [';',
+      ['let', ['=', flag, [null, true]]],
+      ['while', ['||', flag, transform(cond)], ['{}', [';', ['=', flag, [null, false]], transform(body)]]]]
   },
 
   // Block body: recurse as scope for hoisting
@@ -316,6 +333,9 @@ export function codegen(node, depth = 0) {
       const [head, body] = a
       if (Array.isArray(head) && (head[0] === 'of' || head[0] === 'in'))
         return 'for (' + codegen(head[1]) + ' ' + head[0] + ' ' + codegen(head[2]) + ') ' + codegen(body, depth)
+      // ['let'/'const', ['in'/'of', name, obj]] — subscript wraps var→let around in/of
+      if (Array.isArray(head) && (head[0] === 'let' || head[0] === 'const') && Array.isArray(head[1]) && (head[1][0] === 'in' || head[1][0] === 'of'))
+        return 'for (' + head[0] + ' ' + codegen(head[1][1]) + ' ' + head[1][0] + ' ' + codegen(head[1][2]) + ') ' + codegen(body, depth)
       return 'for (' + codegen(head) + ') ' + codegen(body, depth)
     }
     return 'for (' + (codegen(a[0]) || '') + '; ' + (codegen(a[1]) || '') + '; ' + (codegen(a[2]) || '') + ') ' + codegen(a[3], depth)
@@ -324,7 +344,11 @@ export function codegen(node, depth = 0) {
   if (op === 'throw') return 'throw ' + codegen(a[0])
   if (op === 'break') return 'break'
   if (op === 'continue') return 'continue'
-  if (op === 'catch') return 'try ' + codegen(a[0], depth) + ' catch (' + a[1] + ') ' + codegen(a[2], depth)
+  // catch with optional binding: ['catch', tryBlock, catchBody] or ['catch', tryBlock, paramName, catchBody]
+  if (op === 'catch') {
+    if (a.length === 3) return 'try ' + codegen(a[0], depth) + ' catch (' + a[1] + ') ' + codegen(a[2], depth)
+    return 'try ' + codegen(a[0], depth) + ' catch ' + codegen(a[1], depth)
+  }
 
   // Arrow
   if (op === '=>') {
@@ -358,8 +382,11 @@ export function codegen(node, depth = 0) {
 
   // Comma
   if (op === ',') return a.map(x => codegen(x)).join(', ')
-  // Template literal
-  if (op === '`') return '`' + a.map((p, i) => i % 2 ? '${' + codegen(p) + '}' : (p?.[1] ?? '')).join('') + '`'
+  // Template literal: alternating string/expr parts. String parts are [null, "str"], expr parts are AST nodes.
+  if (op === '`') return '`' + a.map(p => {
+    if (Array.isArray(p) && p[0] == null && typeof p[1] === 'string') return p[1].replace(/[`\\$]/g, c => '\\' + c)
+    return '${' + codegen(p) + '}'
+  }).join('') + '`'
 
   // Spread
   if (op === '...') return '...' + codegen(a[0])

package/src/key.js

@@ -0,0 +1,73 @@
+/** Static property-key evaluation for computed member names. */
+
+const NO_VALUE = Symbol('no-static-property-key')
+
+export function staticPropertyKey(node) {
+  const value = staticValue(node)
+  return value === NO_VALUE ? null : String(value)
+}
+
+function staticValue(node) {
+  if (node === undefined) return undefined
+  if (node === null || typeof node === 'number' || typeof node === 'string' || typeof node === 'boolean') return node
+  if (!Array.isArray(node)) return NO_VALUE
+
+  const [op, ...args] = node
+  if (op == null) return args.length ? args[0] : undefined
+  if (op === 'str') return args[0]
+  if (op === '[]' && args.length === 1) return staticValue(args[0])
+  if (op === '()' && args[0] === 'String' && args.length === 2) {
+    const value = staticValue(args[1])
+    return value === NO_VALUE ? NO_VALUE : String(value)
+  }
+  if (op === '()' && args[0] === 'Number' && args.length === 2) {
+    const value = staticValue(args[1])
+    return value === NO_VALUE ? NO_VALUE : Number(value)
+  }
+  if (op === '?:' || op === '?') {
+    const cond = staticValue(args[0])
+    return cond === NO_VALUE ? NO_VALUE : staticValue(cond ? args[1] : args[2])
+  }
+  if (op === '&&' || op === '||') {
+    const left = staticValue(args[0])
+    if (left === NO_VALUE) return NO_VALUE
+    return op === '&&' ? (left ? staticValue(args[1]) : left) : (left ? left : staticValue(args[1]))
+  }
+  if (op === '??') {
+    const left = staticValue(args[0])
+    return left === NO_VALUE ? NO_VALUE : left == null ? staticValue(args[1]) : left
+  }
+
+  if (args.length === 1) {
+    const value = staticValue(args[0])
+    if (value === NO_VALUE) return NO_VALUE
+    if (op === 'u+') return +value
+    if (op === 'u-') return -value
+    if (op === '!') return !value
+    if (op === '~') return ~value
+    return NO_VALUE
+  }
+
+  if (args.length === 2) {
+    const left = staticValue(args[0])
+    const right = staticValue(args[1])
+    if (left === NO_VALUE || right === NO_VALUE) return NO_VALUE
+    switch (op) {
+      case '+': return typeof left === 'string' || typeof right === 'string' ? String(left) + String(right) : Number(left) + Number(right)
+      case '-': return Number(left) - Number(right)
+      case '*': return Number(left) * Number(right)
+      case '/': return Number(left) / Number(right)
+      case '%': return Number(left) % Number(right)
+      case '**': return Number(left) ** Number(right)
+      case '&': return Number(left) & Number(right)
+      case '|': return Number(left) | Number(right)
+      case '^': return Number(left) ^ Number(right)
+      case '<<': return Number(left) << Number(right)
+      case '>>': return Number(left) >> Number(right)
+      case '>>>': return Number(left) >>> Number(right)
+      default: return NO_VALUE
+    }
+  }
+
+  return NO_VALUE
+}