jz 0.8.0 → 0.9.0

package/jzify/hoist-vars.js

@@ -5,8 +5,21 @@
 
 import { JZ_BLOCK_OPS } from '../src/ast.js'
 
+// A `'[]'`-tagged node is ambiguous pre-prepare(): an array literal/destructure
+// pattern (`[a, b]` → `['[]', commaSeqOrSingleElem]`, length ≤ 2 — empty `[]`
+// is length 1, one element is length 2, 2+ elements comma-wrap into that one
+// slot) and an element-access expression (`arr[i]` → `['[]', receiver, index]`,
+// ALWAYS exactly length 3 — two separate args, never comma-wrapped) share the
+// tag until prepare() splits them into `'['` (literal) vs `'[]'` (access).
+// Length disambiguates: without it, `arr[i] = v` misclassifies as a
+// destructuring assignment and gets walked as a pattern (`arr`/`i` treated as
+// binding targets) instead of falling through to the plain-assignment path.
+// Native jzify happens to reconstruct byte-identical IR either way for this
+// shape (both the pattern-walk and the generic-transform fallback are no-ops
+// on a receiver-name + literal-index pair) — masking it there; the self-hosted
+// kernel exercises the (wrong) pattern-walk's own compiled path and diverges.
 export const isDestructurePat = p =>
-  Array.isArray(p) && (p[0] === '[]' || p[0] === '{}' || (p[0] === '=' && isDestructurePat(p[1])))
+  Array.isArray(p) && ((p[0] === '[]' && p.length !== 3) || p[0] === '{}' || (p[0] === '=' && isDestructurePat(p[1])))
 
 export function hoistVars(node, names) {
   if (node == null || !Array.isArray(node)) return node
@@ -28,6 +41,10 @@ export function hoistVars(node, names) {
     if (Array.isArray(lhs) && lhs[0] === 'var' && typeof lhs[1] === 'string' && lhs.length === 2) {
       names.add(lhs[1])
       lhs = lhs[1]
+    } else if (Array.isArray(lhs) && lhs[0] === 'var' && lhs.length === 2 && isDestructurePat(lhs[1])) {
+      // `for (var [a, b] of …)` — hoist the pattern's bindings, keep an
+      // assignment-form head (the generic var branch DROPPED the declarator).
+      lhs = hoistVarPattern(lhs[1], names)
     } else {
       lhs = hoistVars(lhs, names)
     }
@@ -53,6 +70,12 @@ export function hoistVars(node, names) {
         (head[1][0] === 'in' || head[1][0] === 'of') && typeof head[1][1] === 'string') {
       names.add(head[1][1])
       h2 = [head[1][0], head[1][1], hoistVars(head[1][2], names)]
+    } else if (Array.isArray(head) && head[0] === 'var' && Array.isArray(head[1]) &&
+        (head[1][0] === 'in' || head[1][0] === 'of') && isDestructurePat(head[1][1])) {
+      // `for (var [a, b] of …)` / `for (var {x} in …)` — hoist the pattern's
+      // bindings, keep an assignment-form head (a silently DROPPED head here
+      // was the "'y' is not in scope" class).
+      h2 = [head[1][0], hoistVarPattern(head[1][1], names), hoistVars(head[1][2], names)]
     } else if (Array.isArray(head) && head[0] === ';') {
       h2 = [';']
       for (let i = 1; i < head.length; i++) h2.push(hoistVars(head[i], names))
@@ -61,6 +84,33 @@ export function hoistVars(node, names) {
     }
     return ['for', h2, hoistVars(node[2], names)]
   }
+  // `export var x = 1, y` — the var splits into a hoisted `let` + in-place
+  // assignment, so the `export` keyword can't stay on the declarator
+  // (`export x = 1` is not JS). Assignments stay in place; the export moves
+  // to a clause: `x = 1; export { x, y }` — live bindings, same semantics.
+  // A function-valued declarator instead keeps decl+init together in place
+  // (`export let f = fn`) so the compiler sees a function binding, not a
+  // closure-valued global — mirrors the `;`-handler's arrow-in-place rule.
+  if (op === 'export' && Array.isArray(node[1]) && node[1][0] === 'var') {
+    const isFnInit = v => Array.isArray(v) && (v[0] === '=>' || v[0] === 'function')
+    const stmts = [], exported = []
+    for (let i = 1; i < node[1].length; i++) {
+      const d = node[1][i]
+      if (typeof d === 'string') { names.add(d); exported.push(d) }
+      else if (Array.isArray(d) && d[0] === '=' && typeof d[1] === 'string') {
+        if (isFnInit(d[2])) { stmts.push(['export', ['let', ['=', d[1], hoistVars(d[2], names)]]]); continue }
+        names.add(d[1]); exported.push(d[1])
+        stmts.push(['=', d[1], hoistVars(d[2], names)])
+      } else if (Array.isArray(d) && d[0] === '=' && isDestructurePat(d[1])) {
+        const local = new Set()
+        stmts.push(['=', hoistVarPattern(d[1], local), hoistVars(d[2], names)])
+        for (const n of local) { names.add(n); exported.push(n) }
+      }
+    }
+    if (exported.length) stmts.push(['export', ['{}', exported.length === 1 ? exported[0] : [',', ...exported]]])
+    if (!stmts.length) return null
+    return stmts.length === 1 ? stmts[0] : [';', ...stmts]
+  }
   if (op === 'var') {
     const decls = []
     for (let i = 1; i < node.length; i++) {
@@ -69,6 +119,13 @@ export function hoistVars(node, names) {
       if (Array.isArray(d) && d[0] === '=' && typeof d[1] === 'string') {
         names.add(d[1])
         decls.push(['=', d[1], hoistVars(d[2], names)])
+        continue
+      }
+      // `var [a, b] = src` / `var {x} = src` — hoist every pattern binding,
+      // keep the declarator as an assignment-form destructure (a silently
+      // DROPPED declarator here was the "'b' is not in scope" class).
+      if (Array.isArray(d) && d[0] === '=' && isDestructurePat(d[1])) {
+        decls.push(['=', hoistVarPattern(d[1], names), hoistVars(d[2], names)])
       }
     }
     if (decls.length === 0) return null
@@ -128,6 +185,21 @@ export function hoistPattern(node, names) {
   return hoistVars(node, names)
 }
 
+// `var`-declared pattern: every bare leaf in binding position is a hoisted
+// name (the declarator itself becomes a plain assignment). let/const patterns
+// keep hoistPattern above — their names are declared by the surviving `let`,
+// so collecting them here would predeclare duplicates.
+function hoistVarPattern(node, names) {
+  if (typeof node === 'string') { names.add(node); return node }
+  if (node == null || !Array.isArray(node)) return node
+  const op = node[0]
+  if (op === '=') return ['=', hoistVarPattern(node[1], names), hoistVars(node[2], names)]
+  if (op === ':') return [':', hoistVars(node[1], names), hoistVarPattern(node[2], names)]
+  if (op === '...') return ['...', hoistVarPattern(node[1], names)]
+  if (op === '[]' || op === '{}' || op === ',') return [op, ...node.slice(1).map(n => hoistVarPattern(n, names))]
+  return hoistVars(node, names)
+}
+
 export function prependDecls(body, names) {
   const decl = ['let', ...names]
   if (Array.isArray(body) && body[0] === ';') return [';', decl, ...body.slice(1)]

package/jzify/index.js

@@ -8,13 +8,16 @@
  */
 
 import { JZIFY_CLASS_ERRORS as JC } from '../src/op-policy.js'
+import { parse } from '../src/parse.js'
+import { createAsyncLowering, ASYNC_RUNTIME, ASYNC_GEN_RUNTIME } from './async.js'
 import { createNames } from './names.js'
 import { foldStaticExportHelpers, foldStaticBundlerHelpers, canonicalizeObjectIdioms } from './bundler.js'
 import { createSwitchLowering, normalizeCaseBody } from './switch.js'
-import { createClassLowering } from './classes.js'
+import { createClassLowering, foldPseudoClassical } from './classes.js'
 import { hoistVars, prependDecls } from './hoist-vars.js'
 import { createArgumentsLowering } from './arguments.js'
-import { createTransform } from './transform.js'
+import { createTransform, bindGenerators } from './transform.js'
+import { createGeneratorLowering, ITER_HELPERS_RUNTIME, ITER_ARR_RUNTIME } from './generators.js'
 
 const names = createNames()
 const { lowerArguments, transformPattern, bindTransform } = createArgumentsLowering(names)
@@ -34,9 +37,72 @@ let transform, transformScope
 }))
 bindTransform(transform)
 
-;({ lowerClass, lowerObjectLiteralThis, lowerArrayConstructor } = createClassLowering({ transform, names, JC }))
+const constStrings = new Map()
+;({ lowerClass, lowerObjectLiteralThis, lowerArrayConstructor } = createClassLowering({ transform, names, JC, constStrings }))
+const generatorNames = new Set()
+// Program mints iterator objects (generators anywhere, hand-rolled `next()`
+// members, `[Symbol.iterator]` methods) — gates the for-of protocol fork so
+// programs without iterator producers compile byte-identically.
+const iterProto = { on: false }
+const genErr = (msg) => { throw new Error('jzify: ' + msg) }
+const { lowerGenerator, desugarForOfGenerator, desugarForOfProtocol, unwindChain, fuseTerminal, fusedLoop, isTerminal } = createGeneratorLowering({ transform, err: genErr, generatorNames, genTemp: (t) => names.genTemp(t), iterProto })
+const { lowerAsync, lowerAsyncGen, noteAsync, asyncUsed, agenUsed, resetAsync } = createAsyncLowering({ genTemp: (t) => names.genTemp(t), err: genErr })
+bindGenerators({ lowerGenerator, desugarForOfGenerator, desugarForOfProtocol, lowerAsync, lowerAsyncGen, noteAsync, generatorNames, iterProto, unwindChain, fuseTerminal, fusedLoop, isTerminal })
 transformSwitch = createSwitchLowering(transform, names)
 
+// Spread normalization for iterator values — injected only when a spread site
+// wrapped in __drain (iterProto.drain). Arrays/strings/Sets/Maps pass through
+// untouched (the existing spread machinery owns them); machines and
+// @@iterator providers materialize.
+const ITER_RUNTIME = `
+let __it_drain = (v) => {
+  if (v == null) return v
+  if (typeof v === 'object' && v['@@iterator'] != null) v = v['@@iterator']()
+  if (typeof v !== 'object' || v.next == null) return v
+  let r = v.next(), a = []
+  while (!r.done) { a.push(r.value); r = v.next() }
+  return a
+}
+`
+
+const isSymbolWellKnown = (n, which) => Array.isArray(n) && n[0] === '.' && n[1] === 'Symbol' && n[2] === which
+const WELL_KNOWN = { iterator: '@@iterator', dispose: '@@dispose', asyncIterator: '@@asyncIterator' }
+// Iterator-helper method names (ES2025) — a CALL of one of these on any
+// receiver, in a program that mints iterators, gates decorated generator
+// objects (__it_mk). Fusable chains still fuse; this covers value positions.
+const ITER_HELPER_NAMES = new Set(['map', 'filter', 'take', 'drop', 'flatMap',
+  'toArray', 'reduce', 'forEach', 'some', 'every', 'find'])
+// Entry walk, two jobs in one pass:
+// 1. Canonicalize well-known-symbol shapes to reserved literal props — a
+//    fixed-shape object has no symbol slots, so `[Symbol.iterator]` becomes
+//    the '@@iterator' prop in BOTH key position (computed member/method) and
+//    access position (`x[Symbol.iterator]`).
+// 2. Detect iterator producers for the protocol-fork gate, and helper-method
+//    use / `instanceof Iterator` for the decorated-iterator gate.
+function canonSymbols(node) {
+  if (!Array.isArray(node)) return node
+  const [op] = node
+  if (op === 'function*') iterProto.on = true
+  if (op === ':' && (node[1] === 'next' || node[1] === '@@iterator') &&
+      Array.isArray(node[2]) && (node[2][0] === '=>' || node[2][0] === 'function' || node[2][0] === 'function*'))
+    iterProto.on = true
+  if (op === '()' && Array.isArray(node[1]) && node[1][0] === '.' && ITER_HELPER_NAMES.has(node[1][2]))
+    iterProto.helpers = true
+  if (op === 'instanceof' && node[2] === 'Iterator') iterProto.helpers = true
+  // computed key: [':', ['[]', Symbol.X], value]
+  if (op === ':' && Array.isArray(node[1]) && node[1][0] === '[]' && node[1].length === 2) {
+    for (const [k, prop] of Object.entries(WELL_KNOWN))
+      if (isSymbolWellKnown(node[1][1], k)) { node[1] = prop; if (prop === '@@iterator') iterProto.on = true }
+  }
+  // access: ['[]', obj, Symbol.X] → ['.', obj, '@@X']
+  if (op === '[]' && node.length === 3) {
+    for (const [k, prop] of Object.entries(WELL_KNOWN))
+      if (isSymbolWellKnown(node[2], k)) { node[0] = '.'; node[2] = prop }
+  }
+  for (let i = 1; i < node.length; i++) canonSymbols(node[i])
+  return node
+}
+
 /**
  * Transform AST in-place. Returns transformed AST.
  * @param {Array} ast - subscript/jessie parsed AST
@@ -44,8 +110,61 @@ transformSwitch = createSwitchLowering(transform, names)
  */
 export default function jzify(ast) {
   names.reset()
+  // Module-scope `const K = 'str'` bindings — lets class lowering fold computed
+  // member names `[K]() {}` (const guarantees the binding never changes).
+  constStrings.clear()
+  generatorNames.clear()
+  iterProto.on = false
+  iterProto.helpers = false
+  iterProto.helpersUsed = false
+  iterProto.arr = false
+  iterProto.fromUsed = false
+  ast = canonSymbols(ast)
+  if (Array.isArray(ast)) {
+    const stmts = ast[0] === ';' ? ast.slice(1) : [ast]
+    for (const st of stmts) {
+      if (Array.isArray(st) && st[0] === 'function*' && typeof st[1] === 'string' && st[1]) generatorNames.add(st[1])
+      if (Array.isArray(st) && st[0] === 'export' && Array.isArray(st[1]) && st[1][0] === 'function*' && st[1][1]) generatorNames.add(st[1][1])
+      if (!Array.isArray(st) || st[0] !== 'const') continue
+      for (let i = 1; i < st.length; i++) {
+        const d = st[i]
+        if (Array.isArray(d) && d[0] === '=' && typeof d[1] === 'string' &&
+            Array.isArray(d[2]) && d[2][0] == null && typeof d[2][1] === 'string')
+          constStrings.set(d[1], d[2][1])
+      }
+    }
+  }
   const hoisted = new Set()
   ast = hoistVars(ast, hoisted)
   if (hoisted.size) ast = prependDecls(ast, hoisted)
-  return foldStaticBundlerHelpers(foldStaticExportHelpers(canonicalizeObjectIdioms(transformScope(ast))))
+  if (Array.isArray(ast) && ast[0] === ';') ast = [';', ...foldPseudoClassical(ast.slice(1))]
+  resetAsync()
+  iterProto.drain = false
+  let out = transformScope(ast)
+  const prepend = (src) => {
+    // runtimes ride the same well-known-symbol canonicalization as user code
+    // ([Symbol.iterator] → '@@iterator' in key/access/assign positions) — the
+    // dot-canonical form keeps writes and prehashed dot-reads on ONE path.
+    const rt = transformScope(canonSymbols(parse(src)))
+    const rtStmts = Array.isArray(rt) && rt[0] === ';' ? rt.slice(1) : [rt]
+    const outStmts = Array.isArray(out) && out[0] === ';' ? out.slice(1) : [out]
+    out = [';', ...rtStmts, ...outStmts]
+  }
+  // spread-of-iterator sites wrapped in __drain → splice the helper
+  // (pass-through for arrays/strings; materializes machines/providers).
+  if (iterProto.drain) prepend(ITER_RUNTIME)
+  // Array.from-over-iterators sites → splice __it_arr (materialize/copy).
+  if (iterProto.arr) prepend(ITER_ARR_RUNTIME)
+  // helper-bearing generator mints (__it_mk) or literal-receiver
+  // [Symbol.iterator]() mints (__it_from) → splice the decorated-iterator
+  // factory. Programs without value-position helpers never take this shape.
+  if (iterProto.helpersUsed || iterProto.fromUsed) prepend(ITER_HELPERS_RUNTIME)
+  // async generators → splice the tagged-yield driver (before the promise
+  // runtime prepend so it lands AFTER it in module order — it calls __p_*).
+  if (agenUsed()) prepend(ASYNC_GEN_RUNTIME)
+  // async somewhere in the program → splice the plain-jz promise runtime
+  // (microtask queue, __async_run driver, promise shape + boundary readers)
+  // ahead of user code. Sync programs never reach this — byte-identical.
+  if (asyncUsed()) prepend(ASYNC_RUNTIME)
+  return foldStaticBundlerHelpers(foldStaticExportHelpers(canonicalizeObjectIdioms(out)))
 }

package/jzify/names.js

@@ -33,5 +33,6 @@ export function createNames() {
     classStatic: () => `\uE003class${staticClassIdx++}`,
     classSuperArg: i => `\uE003superArg${classIdx}_${i}`,
     classSuper: i => `\uE003super${classIdx}_${i}`,
+    genTemp: (tag) => `\uE004${tag}${swIdx++}`,
   }
 }

package/jzify/transform.js

@@ -73,6 +73,9 @@ const arrowParams = params => Array.isArray(params) && params[0] === '()' ? para
  * @param {() => Function} opts.lowerObjectLiteralThis
  * @param {() => Function} opts.lowerArrayConstructor
  */
+let _gen = null
+export const bindGenerators = (g) => { _gen = g }
+
 export function createTransform(opts) {
   const { names, lowerArguments, transformPattern, normalizeCaseBody, transformSwitch } = opts
   const lowerClass = (...a) => opts.lowerClass()(...a)
@@ -103,13 +106,42 @@ export function createTransform(opts) {
     return decl
   }
 
+  // `using x = res` (ERM): bind, resolve [Symbol.dispose] up front (TypeError
+  // if absent on a non-null resource — spec checks at binding), then wrap the
+  // REST of the scope in try/finally calling it. Multiple resources nest —
+  // LIFO disposal falls out of the nesting. Divergence (documented): if both
+  // the body and a dispose throw, the dispose error propagates (no
+  // SuppressedError aggregation).
+  function lowerUsing(declarators, remaining) {
+    const NULL = [null, null]
+    const dispose = (name) => ['if', ['!=', name, NULL], ['()', ['.', name, '@@dispose'], null]]
+    let inner = remaining.length ? transformScope([';', ...remaining]) : null
+    for (let k = declarators.length - 1; k >= 0; k--) {
+      const [, name, init] = declarators[k]
+      inner = [';',
+        ['let', ['=', name, transform(init)]],
+        ['if', ['&&', ['!=', name, NULL], ['==', ['.', name, '@@dispose'], NULL]],
+          ['throw', [null, 'using: value has no [Symbol.dispose]() method']]],
+        ['try', inner ?? ['{}', null], ['finally', dispose(name)]],
+      ]
+    }
+    return inner
+  }
+
   function transformScope(node) {
     if (!Array.isArray(node)) return transform(node)
 
     const [op, ...args] = node
 
     if (op === 'function' && args[0]) return hoistFnDecl(...args)
+    if (op === 'function*' && args[0] && _gen)
+      return ['const', ['=', args[0], _gen.lowerGenerator(args[1], args[2])]]
+    if (op === 'async' && Array.isArray(args[0]) && args[0][0] === 'function' && args[0][1] && _gen?.lowerAsync)
+      return ['const', ['=', args[0][1], transform(_gen.lowerAsync(args[0][2], args[0][3]))]]
+    if (op === 'async' && Array.isArray(args[0]) && args[0][0] === 'function*' && args[0][1] && _gen?.lowerAsyncGen)
+      return ['const', ['=', args[0][1], transform(_gen.lowerAsyncGen(args[0][2], args[0][3]))]]
     if (op === 'class' && args[0]) return ['let', ['=', args[0], lowerClass(...args)]]
+    if (op === 'using') return lowerUsing(args, [])
 
     if (op === ';') {
       const hoisted = [], rest = []
@@ -119,10 +151,41 @@ export function createTransform(opts) {
           hoisted.push(hoistFnDecl(stmt[1], stmt[2], stmt[3]))
           continue
         }
+        if (Array.isArray(stmt) && stmt[0] === 'function*' && stmt[1] && _gen) {
+          hoisted.push(['const', ['=', stmt[1], _gen.lowerGenerator(stmt[2], stmt[3])]])
+          continue
+        }
+        // async function DECLARATION — hoists like any function declaration.
+        if (Array.isArray(stmt) && stmt[0] === 'async' && Array.isArray(stmt[1]) &&
+            stmt[1][0] === 'function' && stmt[1][1] && _gen?.lowerAsync) {
+          hoisted.push(['const', ['=', stmt[1][1], transform(_gen.lowerAsync(stmt[1][2], stmt[1][3]))]])
+          continue
+        }
+        // async GENERATOR declaration — same hoisting, tagged-yield machine.
+        if (Array.isArray(stmt) && stmt[0] === 'async' && Array.isArray(stmt[1]) &&
+            stmt[1][0] === 'function*' && stmt[1][1] && _gen?.lowerAsyncGen) {
+          hoisted.push(['const', ['=', stmt[1][1], transform(_gen.lowerAsyncGen(stmt[1][2], stmt[1][3]))]])
+          continue
+        }
         if (Array.isArray(stmt) && stmt[0] === 'class' && stmt[1]) {
           rest.push(['let', ['=', stmt[1], lowerClass(stmt[1], stmt[2], stmt[3])]])
           continue
         }
+        // `using` consumes the REST of the scope into its try body (disposal
+        // runs at scope exit however the scope exits).
+        if (Array.isArray(stmt) && stmt[0] === 'using') {
+          rest.push(lowerUsing(stmt.slice(1), args.slice(i + 1)))
+          break
+        }
+        // Labeled BLOCK in statement position (`lbl: { … }`): unambiguous here —
+        // a ':' STATEMENT can't be an object prop. '{}' stays out of
+        // LABEL_BODY_OPS (the expression-context disambiguator), so literal
+        // props `k: {…}` never label.
+        if (Array.isArray(stmt) && stmt[0] === ':' && typeof stmt[1] === 'string' &&
+            Array.isArray(stmt[2]) && stmt[2][0] === '{}') {
+          rest.push(['label', stmt[1], transform(stmt[2])])
+          continue
+        }
         const t = transform(stmt)
         if (t == null) continue
         if (Array.isArray(t) && t[0] === 'const' && t._hoisted) {
@@ -154,12 +217,98 @@ export function createTransform(opts) {
     return transform(node)
   }
 
+  // Promise statics → the injected plain-jz runtime helpers.
+  const P_STATIC = {
+    resolve: '__p_resolve', reject: '__p_reject', all: '__p_all', race: '__p_race',
+    allSettled: '__p_allSettled', any: '__p_any', try: '__p_try', withResolvers: '__p_withResolvers',
+  }
+
+  // Spread of a possibly-iterator value (iterator-minting programs only):
+  // `...E` → `...__drain(E)` — pass-through for arrays/strings, materializes
+  // machines/@@iterator providers. Array literals skip (statically safe).
+  const wrapSpreadDrain = (e) => {
+    if (!_gen?.iterProto?.on) return null
+    const v = e[1]
+    if (Array.isArray(v) && (v[0] === '[]' || v[0] == null)) return null
+    _gen.iterProto.drain = true
+    return ['...', ['()', '__it_drain', transform(v)]]
+  }
+  const wrapArg = (a) => (Array.isArray(a) && a[0] === '...' && wrapSpreadDrain(a)) || transform(a)
+
   const handlers = {
+    // async function/arrow → (...aa) => __async_run((function* …)(...aa))
+    'async'(inner) {
+      if (!_gen?.lowerAsync || !Array.isArray(inner)) return
+      if (inner[0] === 'function*') return transform(_gen.lowerAsyncGen(inner[2], inner[3]))
+      if (inner[0] === 'function') return transform(_gen.lowerAsync(inner[2], inner[3]))
+      if (inner[0] === '=>') {
+        const params = Array.isArray(inner[1]) && inner[1][0] === '()' ? inner[1][1] : inner[1]
+        return transform(_gen.lowerAsync(params, inner[2]))
+      }
+      // `async function () {}()` — the parser binds the CALL inside the async
+      // wrapper; lower the callee, keep the call.
+      if (inner[0] === '()' && Array.isArray(inner[1]) && (inner[1][0] === 'function' || inner[1][0] === '=>'))
+        return transform(['()', ['async', inner[1]], ...inner.slice(2)])
+    },
+
     '()'(callee, ...rest) {
+      // Promise API rides the async runtime: new Promise(fn) arrives here as a
+      // plain call (the `new` handler unwraps unknown ctors), statics by name.
+      if (_gen?.noteAsync) {
+        if (callee === 'Promise' && rest.length) {
+          _gen.noteAsync()
+          return ['()', '__p_exec', ...rest.map(a => a == null ? a : transform(a))]
+        }
+        if (Array.isArray(callee) && callee[0] === '.' && callee[1] === 'Promise' && P_STATIC[callee[2]]) {
+          _gen.noteAsync()
+          return ['()', P_STATIC[callee[2]], ...rest.map(a => a == null ? a : transform(a))]
+        }
+      }
+      // Terminal iterator helper (toArray/reduce/forEach/some/every/find) on a
+      // chain rooted at a known generator call → fused IIFE loop.
+      if (_gen && Array.isArray(callee) && callee[0] === '.') {
+        const chain = _gen.unwindChain(['()', callee, ...rest])
+        if (chain && chain.stages.length && _gen.isTerminal(chain.stages[chain.stages.length - 1].h)) {
+          const fused = _gen.fuseTerminal(chain, names.genTemp)
+          if (fused) return transform(fused)
+        }
+      }
       if (callee === 'Array') {
         const lit = lowerArrayConstructor(rest[0])
         if (lit) return lit
       }
+      // `[…literal][Symbol.iterator]()` / `'s'[Symbol.iterator]()` — mint a
+      // decorated indexed iterator (array/string values as iterators). Literal
+      // receivers only: name/expression receivers keep the plain dot-call
+      // (machines answer it themselves; the protocol desugar's own probe-call
+      // must not re-enter here).
+      if (_gen && Array.isArray(callee) && callee[0] === '.' && callee[2] === '@@iterator' &&
+          rest.every(a => a == null) && Array.isArray(callee[1]) &&
+          ((callee[1][0] === '[]' && callee[1].length === 2) || (callee[1][0] == null && typeof callee[1][1] === 'string'))) {
+        _gen.iterProto.fromUsed = true
+        return ['()', '__it_from', transform(callee[1])]
+      }
+      // Array.from over iterator values (iterator-minting programs only):
+      // protocol values materialize via __it_arr; arrays copy; array-likes
+      // build by length. `Array.from(x, fn)` maps the materialized array.
+      if (_gen?.iterProto?.on && Array.isArray(callee) && callee[0] === '.' &&
+          callee[1] === 'Array' && callee[2] === 'from' && rest.length === 1) {
+        _gen.iterProto.arr = true
+        const args = Array.isArray(rest[0]) && rest[0][0] === ',' ? rest[0].slice(1) : [rest[0]]
+        const drained = ['()', '__it_arr', transform(args[0])]
+        if (args.length >= 2) return ['()', ['.', drained, 'map'], transform(args[1])]
+        return drained
+      }
+      // spread ARG of a possibly-iterator value → __drain (iterator programs only)
+      if (_gen?.iterProto?.on && rest.length === 1 && Array.isArray(rest[0])) {
+        const args = rest[0]
+        if (args[0] === ',' && args.slice(1).some(x => Array.isArray(x) && x[0] === '...'))
+          return ['()', transform(callee), [',', ...args.slice(1).map(wrapArg)]]
+        if (args[0] === '...') {
+          const w = wrapSpreadDrain(args)
+          if (w) return ['()', transform(callee), w]
+        }
+      }
       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, functionBodyBlock(body))
@@ -217,6 +366,43 @@ export function createTransform(opts) {
       return ['let', ...args.map(transform)]
     },
 
+    'function*'(name, params, body) {
+      // Expression form (`let g = function* () {…}`). Named statement forms are
+      // hoisted in transformScope like plain function declarations.
+      if (!_gen) return
+      return _gen.lowerGenerator(params, body)
+    },
+
+    '[]'(payload, idx) {
+      // 2-arg form is INDEXING (obj[key]) — not ours. The 1-arg form is the
+      // array LITERAL: rewrite a spread of a generator / helper chain into a
+      // spread of the FUSED toArray (a plain array) — the existing
+      // array-spread machinery takes it from there. In an iterator-minting
+      // program, any OTHER spread of a non-literal wraps in __drain (returns
+      // the value untouched unless it's an iterator — then materializes it).
+      if (!_gen || idx !== undefined) return
+      const rewrite = (e) => {
+        if (!Array.isArray(e) || e[0] !== '...') return null
+        if (Array.isArray(e[1])) {
+          const chain = _gen.unwindChain(e[1])
+          if (chain && (!chain.stages.length || !_gen.isTerminal(chain.stages[chain.stages.length - 1].h))) {
+            const fused = _gen.fuseTerminal({ root: chain.root, stages: [...chain.stages, { h: 'toArray', args: [] }] }, names.genTemp)
+            if (fused) return ['...', transform(fused)]
+          }
+        }
+        return wrapSpreadDrain(e)
+      }
+      if (payload === undefined) return
+      if (Array.isArray(payload) && payload[0] === ',') {
+        let hit = false
+        const mapped = payload.slice(1).map((e) => { const r = rewrite(e); if (r) hit = true; return r ?? transform(e) })
+        if (hit) return ['[]', [',', ...mapped]]
+        return
+      }
+      const one = rewrite(payload)
+      if (one) return ['[]', one]
+    },
+
     ':'(label, body) {
       if (typeof label === 'string' && Array.isArray(body) && LABEL_BODY_OPS.has(body[0]))
         return ['label', label, transform(body)]
@@ -246,6 +432,17 @@ export function createTransform(opts) {
         if (lit) return lit
       }
       const name = typeof ctor === 'string' ? ctor : (Array.isArray(ctor) && ctor[0] === '()' ? ctor[1] : null)
+      // SharedArrayBuffer canonicalizes to ArrayBuffer: within one module the
+      // buffer IS jz's linear memory — sharedness is a jz.pool linking concern
+      // (sharedMemory: true), not a per-buffer object property. Atomics accept
+      // proven Int32Array views either way. (`new X(args)` parses with the
+      // args INSIDE the ctor call node — rename the callee, keep the rest.)
+      if (name === 'SharedArrayBuffer') {
+        const ctor2 = Array.isArray(ctor) && ctor[0] === '()'
+          ? ['()', 'ArrayBuffer', ...ctor.slice(2).map(transform)]
+          : 'ArrayBuffer'
+        return ['new', ctor2, ...cargs.map(transform)]
+      }
       // Preserve `new` for native constructors the compiler resolves under its own
       // `new` handler (prepare/index.js): typed arrays/Array/RegExp need the `new`
       // form, and `new URL(rel, import.meta.url)` lowers to a static href string there.
@@ -256,8 +453,21 @@ export function createTransform(opts) {
     },
 
     'instanceof'(val, ctor) {
+      // promise-shape probe — promises are fixed-shape objects, no ctor chain
+      if (ctor === 'Promise' && _gen?.noteAsync) {
+        _gen.noteAsync()
+        const t0 = transform(val)
+        return ['&&', ['!=', t0, [null, null]], ['==', ['.', t0, '__p'], [null, 1]]]
+      }
+      // iterator-shape probe — anything driving the protocol (a callable next)
+      // is an Iterator to jz; arrays/strings probe false (no `next` prop).
+      if (ctor === 'Iterator' && _gen) {
+        const t0 = transform(val)
+        return ['&&', ['===', ['typeof', t0], [null, 'object']], ['!=', ['.', t0, 'next'], [null, null]]]
+      }
       const t = transform(val)
-      const name = typeof ctor === 'string' ? ctor : (Array.isArray(ctor) && ctor[0] === '()' ? ctor[1] : null)
+      let name = typeof ctor === 'string' ? ctor : (Array.isArray(ctor) && ctor[0] === '()' ? ctor[1] : null)
+      if (name === 'SharedArrayBuffer') name = 'ArrayBuffer'   // same canonicalization as `new`
       const fold = staticInstanceofFold(val, name)
       if (fold != null) return [null, fold]
       if (typeof name === 'string' && ERROR_INSTANCEOF.has(name)) {
@@ -288,6 +498,34 @@ export function createTransform(opts) {
     // (`for (; i < n; i++)` ran zero/garbage iterations). for-of/for-in heads aren't
     // `;`-lists, so they pass through transform unchanged.
     'for'(head, body) {
+      // for-of over a KNOWN generator call → while-next desugar (the generator
+      // object is plain closures + a fixed-shape result record).
+      if (_gen && Array.isArray(head) && head[0] === 'of' &&
+          Array.isArray(head[2]) && head[2][0] === '()' &&
+          typeof head[2][1] === 'string' && _gen.generatorNames.has(head[2][1]))
+        return transform(_gen.desugarForOfGenerator(head[1], transform(head[2]), body, names.genTemp))
+      // for-of over an iterator-HELPER CHAIN rooted at a known generator call
+      // → one fused while-next loop (map/filter/take/drop compose in place).
+      if (_gen && Array.isArray(head) && head[0] === 'of' && Array.isArray(head[2])) {
+        const chain = _gen.unwindChain(head[2])
+        if (chain && chain.stages.length && chain.stages.every(st => !_gen.isTerminal(st.h))) {
+          const name = Array.isArray(head[1]) ? head[1][1] : head[1]
+          const bodyStmts = Array.isArray(body) && body[0] === ';' ? body.slice(1) : [body]
+          const x = names.genTemp('gx')
+          const fused = _gen.fusedLoop(chain.root, chain.stages, names.genTemp, x,
+            () => [['let', ['=', name, x]], ...bodyStmts])
+          return transform(fused)
+        }
+      }
+      // 'of-idx' — the protocol fork's array arm: plain indexed for-of, no re-fork.
+      if (Array.isArray(head) && head[0] === 'of-idx') {
+        const t = transform(['of', head[1], head[2]])
+        return ['for', t, transform(body)]
+      }
+      // for-of over an UNKNOWN source in an iterator-minting program → runtime
+      // protocol fork (probe once, drive next() lazily, else indexed path).
+      if (_gen && _gen.iterProto?.on && Array.isArray(head) && head[0] === 'of')
+        return transform(_gen.desugarForOfProtocol(head[1], head[2], body, names.genTemp))
       if (Array.isArray(head) && head[0] === ';')
         return ['for', [';', ...head.slice(1).map(s => s == null ? s : transform(s))], transform(body)]
       return ['for', transform(head), transform(body)]