watr 3.0.0 → 3.1.0

package/src/compile.js

@@ -1,437 +1,351 @@
 import * as encode from './encode.js'
 import { uleb } from './encode.js'
-import { SECTION, ALIGN, TYPE, KIND, INSTR } from './const.js'
+import { SECTION, TYPE, KIND, INSTR, HEAPTYPE, REFTYPE } from './const.js'
 import parse from './parse.js'
 
 // build instructions index
-INSTR.forEach((instr, i) => {
-  let [op, ...imm] = instr.split(':'), a, b
-
-  // TODO
-  // wrap codes
-  // const code = i >= 0x10f ? [0xfd, i - 0x10f] : i >= 0xfc ? [0xfc, i - 0xfc] : i
-  INSTR[op] = i
-
-  // // handle immediates
-  // INSTR[op] = !imm.length ? () => code :
-  //   imm.length === 1 ? (a = immedname(imm[0]), nodes => [...code, ...a(nodes)]) :
-  //     (imm = imm.map(immedname), nodes => [...code, ...imm.flatMap(imm => imm(nodes))])
-})
+INSTR.forEach((op, i) => INSTR[op] = i >= 0x11a ? [0xfd, i - 0x11a] : i >= 0xfc ? [0xfc, i - 0xfc] : [i]);
 
+// console.log(INSTR)
 /**
  * Converts a WebAssembly Text Format (WAT) tree to a WebAssembly binary format (WASM).
  *
  * @param {string|Array} nodes - The WAT tree or string to be compiled to WASM binary.
+ * @param {Object} opt - opt.fullSize for fixed-width uleb encoding
  * @returns {Uint8Array} The compiled WASM binary data.
  */
-export default (nodes) => {
+export default function watr(nodes) {
   // normalize to (module ...) form
-  if (typeof nodes === 'string') nodes = parse(nodes); else nodes = [...nodes]
+  if (typeof nodes === 'string') nodes = parse(nodes);
+  else nodes = clone(nodes)
 
   // module abbr https://webassembly.github.io/spec/core/text/modules.html#id10
-  if (nodes[0] === 'module') nodes.shift(), id(nodes)
+  if (nodes[0] === 'module') nodes.shift(), nodes[0]?.[0] === '$' && nodes.shift()
+  // single node, not module
   else if (typeof nodes[0] === 'string') nodes = [nodes]
 
+  // binary abbr "\00" "\0x61" ...
+  if (nodes[0] === 'binary') {
+    nodes.shift()
+    return Uint8Array.from(str(nodes.map(i => i.slice(1, -1)).join('')))
+  }
+  // quote "a" "b"
+  else if (nodes[0] === 'quote') {
+    nodes.shift()
+    return watr(nodes.map(i => i.slice(1, -1)).join(''))
+  }
+
   // Scopes are stored directly on section array by key, eg. section.func.$name = idx
-  // FIXME: make direct binary instead (faster)
   const sections = []
-  for (let kind in SECTION) sections.push(sections[kind] = [])
+  for (let kind in SECTION) (sections[SECTION[kind]] = sections[kind] = []).name = kind
+  sections._ = {} // implicit types
 
-  const binary = [
-    0x00, 0x61, 0x73, 0x6d, // magic
-    0x01, 0x00, 0x00, 0x00, // version
-  ]
+  for (let [kind, ...node] of nodes) {
+    let imported // if node needs to be imported
 
-  // sort nodes by sections
-  // TODO: make this more elegant
-  let nodeGroups = []
-  for (let kind in SECTION) nodeGroups.push(nodeGroups[kind] = [])
+    // import abbr
+    // (import m n (table|memory|global|func id? type)) -> (table|memory|global|func id? (import m n) type)
+    if (kind === 'import') [kind, ...node] = (imported = node).pop()
 
-  for (let [kind, ...node] of nodes) {
     // index, alias
-    let name = id(node), idx = nodeGroups[kind].length;
-    if (name) sections[kind][name] = idx; // save alias
+    let name = node[0]?.[0] === '$' && node.shift(), idx = sections[kind].length;
+    if (name) name in sections[kind] ? err(`Duplicate ${kind} ${name}`) : sections[kind][name] = idx; // save alias
 
     // export abbr
     // (table|memory|global|func id? (export n)* ...) -> (table|memory|global|func id ...) (export n (table|memory|global|func id))
-    while (node[0]?.[0] === 'export') nodeGroups.export.push([node.shift()[1], [kind, idx]])
+    while (node[0]?.[0] === 'export') sections.export.push([node.shift()[1], [kind, idx]])
 
-    // import abbr
-    // (table|memory|global|func id? (import m n) type) -> (import m n (table|memory|global|func id? type))
-    if (node[0]?.[0] === 'import') node = [...node.shift(), [kind, ...(name ? [name] : []), ...node]], kind = node.shift()
+    // for import nodes - redirect output to import
+    if (node[0]?.[0] === 'import') [, ...imported] = node.shift()
 
     // table abbr
-    // (table id? reftype (elem ...{n})) -> (table id? n n reftype) (elem (table id) (i32.const 0) reftype ...)
-    if (node[1]?.[0] === 'elem') {
-      let [reftype, [, ...els]] = node
-      node = [els.length, els.length, reftype]
-      nodeGroups.elem.push([['table', name || nodeGroups.table.length], ['i32.const', '0'],  typeof els[0] === 'string' ? 'func' : reftype, ...els])
+    if (kind === 'table') {
+      // (table id? reftype (elem ...{n})) -> (table id? n n reftype) (elem (table id) (i32.const 0) reftype ...)
+      if (node[1]?.[0] === 'elem') {
+        let [reftype, [, ...els]] = node
+        node = [els.length, els.length, reftype]
+        sections.elem.push([['table', name || sections.table.length], ['i32.const', '0'], reftype, ...els])
+      }
     }
 
     // data abbr
     // (memory id? (data str)) -> (memory id? n n) (data (memory id) (i32.const 0) str)
-    if (node[0]?.[0] === 'data') {
-      let [,...data] = node.shift(), m = ''+Math.ceil(data.map(s => s.slice(1,-1)).join('').length / 65536) // FIXME: figure out actual data size
-      nodeGroups.data.push([['memory', idx], ['i32.const',0], ...data])
+    else if (kind === 'memory' && node[0]?.[0] === 'data') {
+      let [, ...data] = node.shift(), m = '' + Math.ceil(data.map(s => s.slice(1, -1)).join('').length / 65536) // FIXME: figure out actual data size
+      sections.data.push([['memory', idx], ['i32.const', 0], ...data])
       node = [m, m]
     }
 
+    // keep start name
+    else if (kind === 'start') name && node.push(name);
 
-    // import increments corresponding section index
-    // FIXME: can be turned into shallow node
-    if (kind === 'import') {
-      let [mod, field, [kind, ...dfn]] = node
-      let name = id(dfn)
-      if (name) sections[kind][name] = nodeGroups[kind].length
-      nodeGroups[kind].length++
-      node[2] = [kind, ...dfn]
-    }
-    else if (kind === 'start') {name && node.unshift(name);}
+    // [func, [param, result]] -> [param, result], alias
+    else if (kind === 'type') node[0].shift(), node = paramres(node[0]), sections.type['$' + node.join('>')] ??= idx
 
-    nodeGroups[kind].push(node)
-  }
-
-  // build sections binaries
-  for (let kind in SECTION) nodeGroups[kind].map((node,i) => !node ? [] : build[kind](i, node, sections))
-
-  // build final binary
-  for (let secCode = 0; secCode < sections.length; secCode++) {
-    let items = sections[secCode], bytes = [], count = 0
-    for (let item of items) {
-      if (!item) { continue } // ignore empty items (like import placeholders)
-      count++ // count number of items in section
-      bytes.push(...item)
+    // dupe to code section, save implicit type
+    else if (kind === 'func') {
+      let [idx, param, result] = typeuse(node, sections);
+      idx ?? (sections._[idx = '$' + param + '>' + result] = [param, result]);
+      !imported && nodes.push(['code', [idx, param, result], ...plain(node, sections)]) // pass param since they may have names
+      node.unshift(['type', idx])
     }
-    // ignore empty sections
-    if (!bytes.length) continue
-    // skip start section count - write length
-    if (secCode !== 8) bytes.unshift(...uleb(count))
-    binary.push(secCode, ...vec(bytes))
-  }
 
-  return new Uint8Array(binary)
-}
+    // import writes to import section amd adds placeholder for (kind) section
+    if (imported) sections.import.push([...imported, [kind, ...node]]), node = null
 
-// consume $id
-const id = nodes => nodes[0]?.[0] === '$' && nodes.shift()
+    sections[kind].push(node)
+  }
 
-// build section binary (non consuming)
-const build = {
-  // (type $id? (func params result))
-  // we cannot squash types since indices can refer to them
-  type(idx, [...node], ctx) {
-    let [, ...sig] = node?.[0] || [], [param, result] = paramres(sig)
-
-    ctx.type[idx] = Object.assign(
-      [TYPE.func, ...vec(param.map(t => TYPE[t])), ...vec(result.map(t => TYPE[t]))],
-      { param, result } // save params for the type name
-    )
-    ctx.type[param + '>' + result] ??= idx // alias for quick search (don't increment if exists)
-  },
+  // add implicit types - main types receive aliases, implicit types are added if no explicit types exist
+  for (let n in sections._) sections.type[n] ??= sections.type.push(sections._[n]) - 1
 
-  // (import "math" "add" (func|table|global|memory typedef?))
-  import(_, [mod, field, [kind, ...dfn]], ctx) {
-    let details
+  // patch datacount if data === 0
+  if (!sections.data.length) sections.datacount.length = 0
 
-    if (kind === 'func') {
-      // we track imported funcs in func section to share namespace, and skip them on final build
-      let [typeIdx] = typeuse(dfn, ctx)
-      details = uleb(typeIdx)
-    }
-    else if (kind === 'memory') {
-      details = limits(dfn)
-    }
-    else if (kind === 'global') {
-      let [type] = dfn, mut = type[0] === 'mut' ? 1 : 0
-      details = [TYPE[mut ? type[1] : type], mut]
-    }
-    else if (kind === 'table') {
-      details = [TYPE[dfn.pop()], ...limits(dfn)]
-    }
+  // convert nodes to bytes
+  const bin = (kind, count = true) => {
+    let items = sections[kind].filter(Boolean).map(item => build[kind](item, sections))
+    return !items.length ? [] : [kind, ...vec(count ? vec(items) : items)]
+  }
 
-    ctx.import.push([...str(mod), ...str(field), KIND[kind], ...details])
-  },
+  // build final binary
+  return Uint8Array.from([
+    0x00, 0x61, 0x73, 0x6d, // magic
+    0x01, 0x00, 0x00, 0x00, // version
+    ...bin(SECTION.custom),
+    ...bin(SECTION.type),
+    ...bin(SECTION.import),
+    ...bin(SECTION.func),
+    ...bin(SECTION.table),
+    ...bin(SECTION.memory),
+    ...bin(SECTION.global),
+    ...bin(SECTION.export),
+    ...bin(SECTION.start, false),
+    ...bin(SECTION.elem),
+    ...bin(SECTION.datacount, false),
+    ...bin(SECTION.code),
+    ...bin(SECTION.data)
+  ])
+}
 
-  // (func $name? ...params result ...body)
-  func(idx, [...node], ctx) {
-    const [typeidx, param, result] = typeuse(node, ctx)
+// abbr blocks, loops, ifs; collect implicit types via typeuses; resolve optional immediates
+// https://webassembly.github.io/spec/core/text/instructions.html#folded-instructions
+const plain = (nodes, ctx) => {
+  let out = []
 
-    ctx.func[idx] = uleb(typeidx)
+  while (nodes.length) {
+    let node = nodes.shift()
 
-    // build code section
-    let blocks = [] // control instructions / blocks stack
-    let locals = [] // list of local variables
+    if (typeof node === 'string') {
+      out.push(node)
 
-    // collect locals
-    while (node[0]?.[0] === 'local') {
-      let [, ...types] = node.shift(), name
-      if (types[0]?.[0] === '$')
-        param[name = types.shift()] ? err('Ambiguous name ' + name) : // FIXME: not supposed to happen
-          locals[name] = param.length + locals.length
-      locals.push(...types.map(t => TYPE[t]))
+      if (abbr[node]) out.push(...abbr[node](nodes, ctx))
     }
 
-    // convert sequence of instructions from input nodes to out bytes
-    // FIXME: make external func
-    const consume = (nodes, out = []) => {
-      if (!nodes?.length) return out
+    // FIXME: try to move this to abbr
+    else {
+      node = plain(node, ctx)
 
-      let op = nodes.shift(), opCode, args = nodes, immed, id, group
-
-      // flatten groups, eg. (cmd z w) -> z w cmd
-      if (group = Array.isArray(op)) {
-        args = [...op] // op is immutable
-        opCode = INSTR[op = args.shift()]
-      }
-      else opCode = INSTR[op]
-
-      // v128s: (v128.load x) etc
-      // https://github.com/WebAssembly/simd/blob/master/proposals/simd/BinarySIMD.md
-      if (opCode >= 0x10f) {
-        opCode -= 0x10f
-        immed = [0xfd, ...uleb(opCode)]
-        // (v128.load)
-        if (opCode <= 0x0b) {
-          const o = memarg(args)
-          immed.push(Math.log2(o.align ?? ALIGN[op]), ...uleb(o.offset ?? 0))
-        }
-        // (v128.load_lane offset? align? idx)
-        else if (opCode >= 0x54 && opCode <= 0x5d) {
-          const o = memarg(args)
-          immed.push(Math.log2(o.align ?? ALIGN[op]), ...uleb(o.offset ?? 0))
-          // (v128.load_lane_zero)
-          if (opCode <= 0x5b) immed.push(...uleb(args.shift()))
-        }
-        // (i8x16.shuffle 0 1 ... 15 a b)
-        else if (opCode === 0x0d) {
-          // i8, i16, i32 - bypass the encoding
-          for (let i = 0; i < 16; i++) immed.push(encode.i32.parse(args.shift()))
-        }
-        // (v128.const i32x4)
-        else if (opCode === 0x0c) {
-          args.unshift(op)
-          immed = expr(args, ctx)
-        }
-        // (i8x16.extract_lane_s 0 ...)
-        else if (opCode >= 0x15 && opCode <= 0x22) {
-          immed.push(...uleb(args.shift()))
-        }
-        opCode = null // ignore opcode
+      // (block ...) -> block ... end
+      if (node[0] === 'block' || node[0] === 'loop') {
+        out.push(...node, 'end')
       }
 
-      // bulk memory: (memory.init) (memory.copy) etc
-      // https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md#instruction-encoding
-      else if (opCode >= 0xfc) {
-        immed = [0xfc, ...uleb(opCode -= 0xfc)]
-        // memory.init idx, memory.drop idx, table.init idx, table.drop idx
-        if (!(opCode & 0b10)) immed.push(...uleb(args.shift()))
-        else immed.push(0)
-        // even opCodes (memory.init, memory.copy, table.init, table.copy) have 2nd predefined immediate
-        if (!(opCode & 0b1)) immed.push(0)
-        opCode = null // ignore opcode
-      }
+      // (if ...) -> if ... end
+      else if (node[0] === 'if') {
+        let thenelse = [], blocktype = [node.shift()]
+        // (if label? blocktype? cond*? (then instr*) (else instr*)?) -> cond*? if label? blocktype? instr* else instr*? end
+        // https://webassembly.github.io/spec/core/text/instructions.html#control-instructions
+        if (node[node.length - 1]?.[0] === 'else') thenelse.unshift(...node.pop())
+        if (node[node.length - 1]?.[0] === 'then') thenelse.unshift(...node.pop())
 
-      // ref.func $id
-      else if (opCode == 0xd2) {
-        immed = uleb(args[0][0] === '$' ? ctx.func[args.shift()] : +args.shift())
-      }
-      // ref.null
-      else if (opCode == 0xd0) {
-        immed = [TYPE[args.shift() + 'ref']] // func->funcref, extern->externref
-      }
+        // label?
+        if (node[0]?.[0] === '$') blocktype.push(node.shift())
 
-      // binary/unary (i32.add a b) - no immed
-      else if (opCode >= 0x45) { }
+        // blocktype? - (param) are removed already via plain
+        if (node[0]?.[0] === 'type' || node[0]?.[0] === 'result') blocktype.push(node.shift());
 
-      // (i32.store align=n offset=m at value) etc
-      else if (opCode >= 0x28 && opCode <= 0x3e) {
-        // FIXME: figure out point in Math.log2 aligns
-        let o = memarg(args)
-        immed = [Math.log2(o.align ?? ALIGN[op]), ...uleb(o.offset ?? 0)]
-      }
+        // ignore empty else
+        // https://webassembly.github.io/spec/core/text/instructions.html#abbreviations
+        if (thenelse[thenelse.length - 1] === 'else') thenelse.pop()
 
-      // (i32.const 123), (f32.const 123.45) etc
-      else if (opCode >= 0x41 && opCode <= 0x44) {
-        immed = encode[op.split('.')[0]](args.shift())
+        out.push(...node, ...blocktype, ...thenelse, 'end')
       }
+      else out.push(node)
+    }
+  }
 
-      // (local.get $id), (local.tee $id x)
-      else if (opCode >= 0x20 && opCode <= 0x22) {
-        immed = uleb(args[0]?.[0] === '$' ? param[id = args.shift()] ?? locals[id] ?? err('Unknown local ' + id) : +args.shift())
-      }
+  return out
+}
 
-      // (global.get $id), (global.set $id)
-      else if (opCode == 0x23 || opCode == 0x24) {
-        immed = uleb(args[0]?.[0] === '$' ? ctx.global[args.shift()] : +args.shift())
-      }
+const abbr = {
+  // block typeuse?
+  block: (nodes, ctx) => {
+    let out = []
 
-      // (call id ...nodes)
-      else if (opCode == 0x10) {
-        let fnName = args.shift()
-        immed = uleb(id = fnName[0] === '$' ? ctx.func[fnName] : +fnName);
-        // FIXME: how to get signature of imported function
-      }
+    // (loop $l?)
+    if (nodes[0]?.[0] === '$') out.push(nodes.shift())
 
-      // (call_indirect tableIdx? (type $typeName) (idx) ...nodes)
-      else if (opCode == 0x11) {
-        let tableidx = args[0]?.[0] === '$' ? ctx.table[args.shift()] : 0
-        let [typeidx] = typeuse(args, ctx)
-        immed = [...uleb(typeidx), ...uleb(tableidx)]
-      }
+    let [idx, param, result] = typeuse(nodes, ctx, 0)
 
-      // (block ...), (loop ...), (if ...)
-      else if (opCode === 2 || opCode === 3 || opCode === 4) {
-        blocks.push(opCode)
+    // direct idx (no params/result needed)
+    if (idx != null) out.push(['type', idx])
+    // get type - can be either idx or valtype (numtype | reftype)
+    else if (!param.length && !result.length);
+    // (result i32) - doesn't require registering type
+    else if (!param.length && result.length === 1) out.push(['result', ...result])
+    // (param i32 i32)? (result i32 i32) - implicit type
+    else ctx._[idx = '$' + param + '>' + result] = [param, result], out.push(['type', idx])
 
-        // (block $x) (loop $y)
-        if (args[0]?.[0] === '$') (blocks[args.shift()] = blocks.length)
+    return out
+  },
+  loop: (nodes, ctx) => abbr.block(nodes, ctx),
+  if: (nodes, ctx) => abbr.block(nodes, ctx),
+
+  // select (result i32 i32 i32)?
+  select: (nodes, ctx) => [paramres(nodes, 0)[1]],
+
+  // call_indirect $table? $typeidx
+  // return_call_indirect $table? $typeidx
+  call_indirect: (nodes, ctx) => {
+    let tableidx = nodes[0]?.[0] === '$' || !isNaN(nodes[0]) ? nodes.shift() : 0
+    let [idx, param, result] = typeuse(nodes, ctx, 0)
+    return [tableidx, ['type', idx ?? (ctx._[idx = '$' + param + '>' + result] = [param, result], idx)]]
+  },
+  return_call_indirect: (nodes, ctx) => abbr.call_indirect(nodes, ctx),
+
+  // else $label
+  else: (nodes, ctx) => (nodes[0]?.[0] === '$' && nodes.shift(), []),
+  // end $label
+  end: (nodes, ctx) => (nodes[0]?.[0] === '$' && nodes.shift(), []),
+
+  // mark datacount section as required
+  'memory.init': (nodes, ctx) => (ctx.datacount[0] = true, []),
+  'data.drop': (nodes, ctx) => (ctx.datacount[0] = true, []),
+
+  // table.init tableidx? elemidx -> table.init tableidx elemidx
+  'table.init': (nodes, ctx) => [(nodes[1][0] === '$' || !isNaN(nodes[1])) ? nodes.shift() : 0, nodes.shift()],
+
+  // table.* tableidx?
+  'table.get': (nodes, ctx) => [nodes[0]?.[0] === '$' || !isNaN(nodes[0]) ? nodes.shift() : 0],
+  'table.set': (nodes, ctx) => abbr['table.get'](nodes, ctx),
+  'table.fill': (nodes, ctx) => abbr['table.get'](nodes, ctx),
+  'table.size': (nodes, ctx) => abbr['table.get'](nodes, ctx),
+  'table.grow': (nodes, ctx) => abbr['table.get'](nodes, ctx),
+  // table.copy tableidx? tableidx?
+  'table.copy': (nodes, ctx) => [...abbr['table.get'](nodes, ctx), nodes[0][0] === '$' || !isNaN(nodes[0]) ? nodes.shift() : 0],
+}
 
-        // get type - can be either typeidx or valtype (numtype | reftype)
-        // (result i32) - doesn't require registering type
-        if (args[0]?.[0] === 'result' && args[0].length < 3) {
-          let [, type] = args.shift()
-          immed = [TYPE[type]]
-        }
-        // (result i32 i32)
-        else if (args[0]?.[0] === 'result' || args[0]?.[0] === 'param') {
-          let [typeidx] = typeuse(args, ctx)
-          immed = uleb(typeidx)
-        }
-        // FIXME: that def can be done nicer
-        else if (args[0]?.[0] === 'type') {
-          let [typeidx, params, result] = typeuse(args, ctx)
-          if (!params.length && !result.length) immed = [TYPE.void]
-          else if (!param.length && result.length === 1) immed = [TYPE[result[0]]]
-          else immed = uleb(typeidx)
-        }
-        else {
-          immed = [TYPE.void]
-        }
+// consume typeuse nodes, return type index/params, or null idx if no type
+// https://webassembly.github.io/spec/core/text/modules.html#type-uses
+const typeuse = (nodes, ctx, names) => {
+  let idx, param, result
 
-        if (group) {
-          // (block xxx) -> block xxx end
-          nodes.unshift('end')
-
-          if (opCode < 4) while (args.length) nodes.unshift(args.pop())
-          // (if cond a) -> cond if a end
-          else if (args.length < 3) nodes.unshift(args.pop())
-          // (if cond (then a) (else b)) -> `cond if a else b end`
-          else {
-            nodes.unshift(args.pop())
-            // (if cond a b) -> (if cond a else b)
-            if (nodes[0][0] !== 'else') nodes.unshift('else')
-            // (if a b (else)) -> (if a b)
-            else if (nodes[0].length < 2) nodes.shift()
-            nodes.unshift(args.pop())
-          }
-        }
-      }
+  // explicit type (type 0|$name)
+  if (nodes[0]?.[0] === 'type') {
+    [, idx] = nodes.shift();
+    [param, result] = paramres(nodes, names);
 
-      // (else)
-      else if (opCode === 5) {
-        // (else xxx) -> else xxx
-        if (group) while (args.length) nodes.unshift(args.pop())
-      }
-      // (then)
-      else if (opCode === 6) {
-        opCode = null // ignore opcode
-      }
+    // check type consistency (excludes forward refs)
+    if ((param.length || result.length) && idx in ctx.type)
+      if (ctx.type[id(idx, ctx.type)].join('>') !== param + '>' + result) err(`Type ${idx} mismatch`)
 
-      // (end)
-      else if (opCode == 0x0b) blocks.pop()
+    return [idx]
+  }
 
-      // (br $label result?)
-      // (br_if $label cond result?)
-      else if (opCode == 0x0c || opCode == 0x0d) {
-        // br index indicates how many block items to pop
-        immed = uleb(args[0]?.[0] === '$' ? blocks.length - blocks[args.shift()] : args.shift())
-      }
+  // implicit type (param i32 i32)(result i32)
+  [param, result] = paramres(nodes, names)
 
-      // (br_table 1 2 3 4  0  selector result?)
-      else if (opCode == 0x0e) {
-        immed = []
-        while (args[0] && !Array.isArray(args[0])) {
-          id = args.shift()
-          immed.push(...uleb(id[0][0] === '$' ? blocks.length - blocks[id] : id))
-        }
-        immed.unshift(...uleb(immed.length - 1))
-      }
+  return [, param, result]
+}
 
-      // FIXME multiple memory (memory.grow $idx?)
-      else if (opCode == 0x3f || opCode == 0x40) {
-        immed = [0]
-      }
+// consume (param t+)* (result t+)* sequence
+const paramres = (nodes, names = true) => {
+  let param = [], result = []
 
-      // (table.get $id)
-      else if (opCode == 0x25 || opCode == 0x26) {
-        immed = uleb(args[0]?.[0] === '$' ? ctx.table[args.shift()] : +args.shift())
-      }
+  // collect param (param i32 i64) (param $x? i32)
+  while (nodes[0]?.[0] === 'param') {
+    let [, ...args] = nodes.shift()
+    args = args.map(t => t[0] === 'ref' && t[2] ? (HEAPTYPE[t[2]] ? (t[2]+t[0]) : t) : t); // deabbr
+    let name = args[0]?.[0] === '$' && args.shift()
+    // expose name refs, if allowed
+    if (name) names ? param[name] = param.length : err(`Unexpected param name ${name}`)
+    param.push(...args)
+  }
 
-      // table.grow id, table.size id, table.fill id
-      else if (opCode >= 0x0f && opCode <= 0x11) {
-        immed = []
-      }
+  // collect result eg. (result f64 f32)(result i32)
+  while (nodes[0]?.[0] === 'result') {
+    let [, ...args] = nodes.shift()
+    args = args.map(t => t[0] === 'ref' && t[2] ? (HEAPTYPE[t[2]] ? (t[2]+t[0]) : t) : t); // deabbr
+    result.push(...args)
+  }
 
-      else if (opCode == null) err(`Unknown instruction \`${op}\``)
+  if (nodes[0]?.[0] === 'param') err(`Unexpected param`)
 
-      // if group (cmd im1 im2 arg1 arg2) - insert any remaining args first: arg1 arg2
-      // because inline case has them in stack already
-      if (group) while (args.length) consume(args, out)
+  return [param, result]
+}
 
-      if (opCode != null) out.push(opCode)
-      if (immed) out.push(...immed)
-    }
+// build section binary [by section codes] (non consuming)
+const build = [,
+  // (type $id? (func params result))
+  ([param, result], ctx) => ([0x60, ...vec(param.map(t => type(t, ctx))), ...vec(result.map(t => type(t, ctx)))]),
 
-    const bytes = []
-    // FIXME: avoid passing bytes from outside, push result instead
-    while (node.length) consume(node, bytes)
-    bytes.push(0x0b)
+  // (import "math" "add" (func|table|global|memory typedef?))
+  ([mod, field, [kind, ...dfn]], ctx) => {
+    let details
 
-    // squash locals into (n:u32 t:valtype)*, n is number and t is type
-    let loctypes = locals.reduce((a, type) => (type == a[a.length - 1]?.[1] ? a[a.length - 1][0]++ : a.push([1, type]), a), [])
+    if (kind[0] === 'f') {
+      // we track imported funcs in func section to share namespace, and skip them on final build
+      let [[, typeidx]] = dfn
+      details = uleb(id(typeidx, ctx.type))
+    }
+    else if (kind[0] === 'm') {
+      details = limits(dfn)
+    }
+    else if (kind[0] === 'g') {
+      let [t] = dfn, mut = t[0] === 'mut' ? 1 : 0
+      details = [...type(mut ? t[1] : t, ctx), mut]
+    }
+    else if (kind[0] === 't') {
+      details = [...type(dfn.pop(), ctx), ...limits(dfn)]
+    }
 
-    // https://webassembly.github.io/spec/core/binary/modules.html#code-section
-    ctx.code[idx] = vec([...uleb(loctypes.length), ...loctypes.flatMap(([n, t]) => [...uleb(n), t]), ...bytes])
+    return ([...vec(str(mod.slice(1, -1))), ...vec(str(field.slice(1, -1))), KIND[kind], ...details])
   },
 
-  // (table id? 1 2? funcref)
-  table(idx, [...node], ctx) {
-    ctx.table[idx] = [TYPE[node.pop()], ...limits(node)]
+  // (func $name? ...params result ...body)
+  ([[, typeidx]], ctx) => (uleb(id(typeidx, ctx.type))),
+
+  // (table 1 2 funcref)
+  (node, ctx) => {
+    let lims = limits(node), t = type(node.shift(), ctx), [init] = node
+    return init ? [0x40, 0x00, ...t, ...lims, ...expr(init, ctx)]  : [...t, ...lims]
   },
 
   // (memory id? export* min max shared)
-  memory(idx, [...node], ctx) {
-    ctx.memory[idx] = limits(node)
-  },
+  (node, ctx) => limits(node),
 
   // (global $id? (mut i32) (i32.const 42))
-  global(idx, [...node], ctx) {
-    let [type] = node, mut = type[0] === 'mut' ? 1 : 0
+  (node, ctx) => {
+    let [t] = node, mut = t[0] === 'mut' ? 1 : 0
 
-    let [, [...init]] = node
-    ctx.global[idx] = [TYPE[mut ? type[1] : type], mut, ...expr(init, ctx), 0x0b]
+    let [, init] = node
+    return ([...type(mut ? t[1] : t, ctx), mut, ...expr(init, ctx)])
   },
 
   //  (export "name" (func|table|mem $name|idx))
-  export(_, [nm, [kind, id]], ctx) {
-    // put placeholder to future-init
-    let idx = id[0] === '$' ? ctx[kind][id] : +id
-    ctx.export.push([...str(nm), KIND[kind], ...uleb(idx)])
-  },
+  ([nm, [kind, l]], ctx) => ([...vec(str(nm.slice(1, -1))), KIND[kind], ...uleb(id(l, ctx[kind]))]),
 
   // (start $main)
-  start(_,[id], ctx) {
-    id = id[0] === '$' ? ctx.func[id] : +id
-    ctx.start[0] = uleb(id)
-  },
+  ([l], ctx) => uleb(id(l, ctx.func)),
 
+  // (elem elem*) - passive
+  // (elem declare elem*) - declarative
+  // (elem (table idx)? (offset expr)|(expr) elem*) - active
+  // elems := funcref|externref (item expr)|expr (item expr)|expr
+  // idxs := func? $id0 $id1
   // ref: https://webassembly.github.io/spec/core/binary/modules.html#element-section
-  // passive: (elem elem*)
-  // declarative: (elem declare elem*)
-  // active: (elem (table idx)? (offset expr)|(expr) elem*)
-  // elems: funcref|externref (item expr)|expr (item expr)|expr
-  // idxs: func? $id0 $id1
-  elem(idx,[...parts], ctx) {
+  (parts, ctx) => {
     let tabidx, offset, mode = 0b000, reftype
 
     // declare?
@@ -440,218 +354,425 @@ const build = {
     // table?
     if (parts[0][0] === 'table') {
       [, tabidx] = parts.shift()
-      tabidx = tabidx[0] === '$' ? ctx.table[tabidx] : +tabidx
+      tabidx = id(tabidx, ctx.table)
       // ignore table=0
       if (tabidx) mode |= 0b010
     }
 
     // (offset expr)|expr
     if (parts[0]?.[0] === 'offset' || (Array.isArray(parts[0]) && parts[0][0] !== 'item' && !parts[0][0].startsWith('ref'))) {
-      [...offset] = parts.shift()
-      if (offset[0] === 'offset') [, [...offset]] = offset
+      offset = parts.shift()
+      if (offset[0] === 'offset') [, offset] = offset
     }
     else mode |= 0b001 // passive
 
-    // funcref|externref|func
-    if (parts[0]?.[0]!=='$') reftype = parts.shift()
-    // externref makes explicit table index
-    if (reftype === 'externref') offset ||= ['i32.const', 0], mode = 0b110
+    // func ... === funcref ..., https://webassembly.github.io/function-references/core/text/modules.html#id7
+    if (HEAPTYPE[parts[0]]) parts[0] += 'ref'
+    // reftype: funcref|externref|(ref ...)
+    if (parts[0] === 'funcref' || parts[0] === 'externref' || parts[0]?.[0] === 'ref') reftype = parts.shift()
+
+    // legacy abbr if func is skipped
+    if (!reftype) !tabidx ? reftype = 'funcref' : err(`Undefined reftype`)
 
+    // externref makes explicit table index
+    if (reftype === 'externref' || reftype[0] === 'ref') offset ||= ['i32.const', 0], mode = 0b110
     // reset to simplest mode if no actual elements
-    if (!parts.length) mode &= 0b011
+    else if (!parts.length) mode &= 0b011
 
-    // simplify els
+    // simplify els sequence
     parts = parts.map(el => {
-      if (el[0] === 'item') [, el] = el
+      if (el[0] === 'item') [, ...el] = el
       if (el[0] === 'ref.func') [, el] = el
-      // (ref.null func) and other expressions
+      // (ref.null func) and other expressions turn expr init mode
       if (typeof el !== 'string') mode |= 0b100
       return el
     })
 
-    ctx.elem[idx] = ([
+    return ([
       mode,
       ...(
         // 0b000 e:expr y*:vec(funcidx)                     | type=funcref, init ((ref.func y)end)*, active (table=0,offset=e)
-        mode === 0b000 ? [...expr(offset, ctx), 0x0b] :
+        mode === 0b000 ? expr(offset, ctx) :
           // 0b001 et:elkind y*:vec(funcidx)                  | type=0x00, init ((ref.func y)end)*, passive
           mode === 0b001 ? [0x00] :
             // 0b010 x:tabidx e:expr et:elkind y*:vec(funcidx)  | type=0x00, init ((ref.func y)end)*, active (table=x,offset=e)
-            mode === 0b010 ? [...uleb(tabidx || 0), ...expr(offset), 0x0b, 0x00] :
+            mode === 0b010 ? [...uleb(tabidx || 0), ...expr(offset, ctx), 0x00] :
               // 0b011 et:elkind y*:vec(funcidx)                  | type=0x00, init ((ref.func y)end)*, passive declare
               mode === 0b011 ? [0x00] :
                 // 0b100 e:expr el*:vec(expr)                       | type=funcref, init el*, active (table=0, offset=e)
-                mode === 0b100 ? [...expr(offset, ctx), 0x0b] :
+                mode === 0b100 ? expr(offset, ctx) :
                   // 0b101 et:reftype el*:vec(expr)                   | type=et, init el*, passive
-                  mode === 0b101 ? [TYPE[reftype]] :
+                  mode === 0b101 ? type(reftype, ctx) :
                     // 0b110 x:tabidx e:expr et:reftype el*:vec(expr)   | type=et, init el*, active (table=x, offset=e)
-                    mode === 0b110 ? [...uleb(tabidx || 0), ...expr(offset), 0x0b, TYPE[reftype]] :
+                    mode === 0b110 ? [...uleb(tabidx || 0), ...expr(offset, ctx), ...type(reftype, ctx)] :
                       // 0b111 et:reftype el*:vec(expr)                   | type=et, init el*, passive declare
-                      [TYPE[reftype]]
+                      type(reftype, ctx)
       ),
-      ...uleb(parts.length),
-      ...parts.flatMap(mode & 0b100 ?
-        // ((ref.func y)end)*
-        el => [...expr(typeof el === 'string' ? ['ref.func', el] : [...el], ctx), 0x0b] :
-        // el*
-        el => uleb(el[0] === '$' ? ctx.func[el] : +el)
+      ...vec(
+        parts.map(mode & 0b100 ?
+          // ((ref.func y)end)*
+          el => expr(typeof el === 'string' ? ['ref.func', el] : el, ctx) :
+          // el*
+          el => uleb(id(el, ctx.func))
+        )
       )
     ])
   },
 
+  // (code)
+  (body, ctx) => {
+    let [typeidx, param] = body.shift()
+    if (!param) [param] = ctx.type[id(typeidx, ctx.type)]
+
+    // provide param/local in ctx
+    ctx.local = Object.create(param) // list of local variables - some of them are params
+    ctx.block = [] // control instructions / blocks stack
+
+    // display names for error messages
+    ctx.local.name = 'local'
+    ctx.block.name = 'block'
+
+    // collect locals
+    while (body[0]?.[0] === 'local') {
+      let [, ...types] = body.shift()
+      if (types[0]?.[0] === '$') ctx.local[types.shift()] = ctx.local.length
+      ctx.local.push(...types)
+    }
+
+    const bytes = []
+    while (body.length) bytes.push(...instr(body, ctx))
+    bytes.push(0x0b)
+
+    // squash locals into (n:u32 t:valtype)*, n is number and t is type
+    // we skip locals provided by params
+    let loctypes = ctx.local.slice(param.length).reduce((a, type) => (type == a[a.length - 1]?.[1] ? a[a.length - 1][0]++ : a.push([1, type]), a), [])
+
+    // cleanup tmp state
+    ctx.local = ctx.block = null
+
+    // https://webassembly.github.io/spec/core/binary/modules.html#code-section
+    return vec([...vec(loctypes.map(([n, t]) => [...uleb(n), ...type(t, ctx)])), ...bytes])
+  },
+
   // (data (i32.const 0) "\aa" "\bb"?)
   // (data (memory ref) (offset (i32.const 0)) "\aa" "\bb"?)
   // (data (global.get $x) "\aa" "\bb"?)
-  data(idx, [...inits], ctx) {
-    let offset, mem = [0]
+  (inits, ctx) => {
+    let offset, memidx = 0
 
     // (memory ref)?
     if (inits[0]?.[0] === 'memory') {
-      [, mem] = inits.shift()
-      mem = mem[0] === '$' ? ctx.memory[mem] : +mem
-      mem = !mem ? [0] : [2, ...uleb(mem)]
+      [, memidx] = inits.shift()
+      memidx = id(memidx, ctx.memory)
     }
 
     // (offset (i32.const 0)) or (i32.const 0)
     if (typeof inits[0] !== 'string') {
       offset = inits.shift()
       if (offset[0] === 'offset') [, offset] = offset
+      offset ?? err('Bad offset', offset)
     }
-    else offset = ['i32.const', 0]
-    ctx.data[idx] = [...mem, ...expr([...offset], ctx), 0x0b, ...str(inits.map(i => i.slice(1, -1)).join(''))]
-  }
-}
 
-// serialize binary array
-const vec = a => [...uleb(a.length), ...a]
+    return ([
+      ...(
+        // active: 2, x=memidx, e=expr
+        memidx ? [2, ...uleb(memidx), ...expr(offset, ctx)] :
+          // active: 0, e=expr
+          offset ? [0, ...expr(offset, ctx)] :
+            // passive: 1
+            [1]
+      ),
+      ...vec(str(inits.map(i => i.slice(1, -1)).join('')))
+    ])
+  },
 
-// instantiation time const initializer (consuming)
-const expr = (node, ctx) => {
-  let op = node.shift(), [type, cmd] = op.split('.')
+  // datacount
+  (nodes, ctx) => uleb(ctx.data.length)
+]
 
-  // (global.get idx)
-  if (type === 'global') return [0x23, ...uleb(node[0][0] === '$' ? ctx.global[node[0]] : +node)]
+// insert type, either direct or ref type
+const type = (t, ctx) =>
+  t[0] === 'ref' ? ([t[1] == 'null' ? TYPE.refnull : TYPE.ref, ...uleb(TYPE[t[t.length - 1]] || id(t[t.length - 1], ctx.type))])
+    : [TYPE[t] ?? err(`Unknown type ${t}`)]
 
-  // (v128.const i32x4 1 2 3 4)
-  if (type === 'v128') return [0xfd, 0x0c, ...v128(node)]
+// consume one instruction from nodes sequence
+const instr = (nodes, ctx) => {
+  if (!nodes?.length) return []
 
-  // (i32.const 1)
-  if (cmd === 'const') return [0x41 + ['i32', 'i64', 'f32', 'f64'].indexOf(type), ...encode[type](node[0])]
+  let out = [], op = nodes.shift(), immed, code
 
-  // (ref.func $x) or (ref.null func|extern)
-  if (type === 'ref') {
-    return cmd === 'func' ?
-      [0xd2, ...uleb(node[0][0] === '$' ? ctx.func[node[0]] : +node)] :
-      // heaptype
-      [0xd0, TYPE[node[0] + 'ref']] // func->funcref, extern->externref
+  // consume group
+  if (Array.isArray(op)) {
+    immed = instr(op, ctx)
+    while (op.length) out.push(...instr(op, ctx))
+    out.push(...immed)
+    return out
   }
 
-  // (i32.add a b), (i32.mult a b) etc
-  return [
-    ...expr(node.shift(), ctx),
-    ...expr(node.shift(), ctx),
-    INSTR[op]
-  ]
-}
+  [...immed] = isNaN(op[0]) && INSTR[op] || err(`Unknown instruction ${op}`)
+  code = immed[0]
+
+  // v128s: (v128.load x) etc
+  // https://github.com/WebAssembly/simd/blob/master/proposals/simd/BinarySIMD.md
+  if (code === 0xfd) {
+    [, code] = immed
+    immed = [0xfd, ...uleb(code)]
+    // (v128.load)
+    if (code <= 0x0b) {
+      const [a, o] = memarg(nodes)
+      immed.push(...uleb((a ?? align(op))), ...uleb(o ?? 0))
+    }
+    // (v128.load_lane offset? align? idx)
+    else if (code >= 0x54 && code <= 0x5d) {
+      const [a, o] = memarg(nodes)
+      immed.push(...uleb((a ?? align(op))), ...uleb(o ?? 0))
+      // (v128.load_lane_zero)
+      if (code <= 0x5b) immed.push(...uleb(nodes.shift()))
+    }
+    // (i8x16.shuffle 0 1 ... 15 a b)
+    else if (code === 0x0d) {
+      // i8, i16, i32 - bypass the encoding
+      for (let i = 0; i < 16; i++) immed.push(encode.i32.parse(nodes.shift()))
+    }
+    // (v128.const i32x4 1 2 3 4)
+    else if (code === 0x0c) {
+      let [t, n] = nodes.shift().split('x'), stride = t.slice(1) >>> 3 // i16 -> 2, f32 -> 4
+      n = +n
+      // i8, i16, i32 - bypass the encoding
+      if (t[0] === 'i') {
+        let arr = n === 16 ? new Uint8Array(16) : n === 8 ? new Uint16Array(8) : n === 4 ? new Uint32Array(4) : new BigInt64Array(2)
+        for (let i = 0; i < n; i++) {
+          arr[i] = encode[t].parse(nodes.shift())
+        }
+        immed.push(...(new Uint8Array(arr.buffer)))
+      }
+      // f32, f64 - encode
+      else {
+        let arr = new Uint8Array(16)
+        for (let i = 0; i < n; i++) arr.set(encode[t](nodes.shift()), i * stride)
+        immed.push(...arr)
+      }
+    }
+    // (i8x16.extract_lane_s 0 ...)
+    else if (code >= 0x15 && code <= 0x22) {
+      immed.push(...uleb(nodes.shift()))
+    }
+  }
 
-// (v128.const i32x4 1 2 3 4)
-const v128 = (args) => {
-  let [t, n] = args.shift().split('x'),
-    stride = t.slice(1) >>> 3 // i16 -> 2, f32 -> 4
+  // bulk memory: (memory.init) (memory.copy) (data.drop) (memory.fill)
+  // table ops: (table.init|copy|grow|size|fill) (elem.drop)
+  // https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md#instruction-encoding
+  else if (code == 0xfc) {
+    [, code] = immed
 
-  n = +n
+    // memory.init idx, data.drop idx,
+    if (code === 0x08 || code === 0x09) {
+      immed.push(...uleb(id(nodes.shift(), ctx.data)))
+    }
+
+    // memory placeholders
+    if (code == 0x08 || code == 0x0b) immed.push(0)
+    else if (code === 0x0a) immed.push(0, 0)
 
-  // i8, i16, i32 - bypass the encoding
-  if (t[0] === 'i') {
-    let arr = n === 16 ? new Uint8Array(16) : n === 8 ? new Uint16Array(8) : n === 4 ? new Uint32Array(4) : new BigInt64Array(2)
-    for (let i = 0; i < n; i++) {
-      arr[i] = encode[t].parse(args.shift())
+    // elem.drop elemidx
+    if (code === 0x0d) {
+      immed.push(...uleb(id(nodes.shift(), ctx.elem)))
+    }
+    // table.init tableidx elemidx -> 0xfc 0x0c elemidx tableidx
+    else if (code === 0x0c) {
+      immed.push(...uleb(id(nodes[1], ctx.elem)), ...uleb(id(nodes.shift(), ctx.table)))
+      nodes.shift()
+    }
+    // table.* tableidx?
+    // abbrs https://webassembly.github.io/spec/core/text/instructions.html#id1
+    else if (code >= 0x0c && code < 0x13) {
+      immed.push(...uleb(id(nodes.shift(), ctx.table)))
+      // table.copy tableidx? tableidx?
+      if (code === 0x0e) immed.push(...uleb(id(nodes.shift(), ctx.table)))
     }
-    return new Uint8Array(arr.buffer)
   }
 
-  // f32, f64 - encode
-  let arr = new Uint8Array(16)
-  for (let i = 0; i < n; i++) {
-    arr.set(encode[t](args.shift()), i * stride)
+  // control block abbrs
+  // block ..., loop ..., if ...
+  else if (code === 2 || code === 3 || code === 4) {
+    ctx.block.push(code)
+
+    // (block $x) (loop $y)
+    if (nodes[0]?.[0] === '$') ctx.block[nodes.shift()] = ctx.block.length
+
+    let typeidx = nodes[0]?.[0] === 'type' && id(nodes.shift()[1], ctx.type)
+
+    let [param, result] = typeidx !== false ? ctx.type[typeidx] : nodes[0]?.[0] === 'result' ? [, [nodes.shift()[1]]] : []
+
+    // void
+    if (!param?.length && !result?.length) immed.push(TYPE.void)
+    // (result i32) - doesn't require registering type
+    else if (!param?.length && result.length === 1) immed.push(...type(result[0], ctx))
+    // (type idx)
+    else immed.push(...uleb(typeidx))
+  }
+  // else
+  else if (code === 5) { }
+  // then
+  else if (code === 6) immed = [] // ignore
+
+  // local.get $id, local.tee $id x
+  else if (code == 0x20 || code == 0x21 || code == 0x22) {
+    immed.push(...uleb(id(nodes.shift(), ctx.local)))
   }
 
-  return arr
-}
+  // global.get $id, global.set $id
+  else if (code == 0x23 || code == 0x24) {
+    immed.push(...uleb(id(nodes.shift(), ctx.global)))
+  }
 
-// https://webassembly.github.io/spec/core/text/modules.html#type-uses
-// consume (type $id|id) (param t+)* (result t+)*
-const typeuse = (nodes, ctx) => {
-  let idx, param, result, alias
+  // call $func ...nodes
+  // return_call $func
+  else if (code == 0x10 || code == 0x12) {
+    immed.push(...uleb(id(nodes.shift(), ctx.func)))
+  }
 
-  // existing/new type (type 0|$name)
-  if (nodes[0]?.[0] === 'type') {
-    [, idx] = nodes.shift();
+  // call_indirect $table (type $typeName) ...nodes
+  // return_call_indirect $table (type $typeName) ... nodes
+  else if (code == 0x11 || code == 0x13) {
+    immed.push(
+      ...uleb(id(nodes[1][1], ctx.type)),
+      ...uleb(id(nodes.shift(), ctx.table))
+    ), nodes.shift()
+  }
+
+  // call_ref $type
+  // return_call_ref $type
+  else if (code == 0x14 || code == 0x15) {
+    immed.push(...uleb(id(nodes.shift(), ctx.type)))
+  }
+
+  // end
+  else if (code == 0x0b) ctx.block.pop()
+
+  // br $label result?
+  // br_if $label cond result?
+  // br_on_null $l, br_on_non_null $l
+  else if (code == 0x0c || code == 0x0d || code == 0xd5 || code == 0xd6) {
+    // br index indicates how many block items to pop
+    let l = nodes.shift(), i = l?.[0] === '$' ? ctx.block.length - ctx.block[l] : +l
+    i <= ctx.block.length || err(`Bad label ${l}`)
+    immed.push(...uleb(i))
+  }
 
-    // (type 0), (type $n) - existing type
-    if (ctx.type[idx] != null) {
-      paramres(nodes);
-      if (idx[0] === '$') idx = ctx.type[idx];
-      ({ param, result } = ctx.type[idx] ?? err('Bad type ' + idx));
-      return [+idx, param, result]
+  // br_table 1 2 3 4  0  selector result?
+  else if (code == 0x0e) {
+    let args = []
+    while (nodes[0] && (!isNaN(nodes[0]) || nodes[0][0] === '$')) {
+      let l = nodes.shift(), i = l[0][0] === '$' ? ctx.block.length - ctx.block[l] : +l
+      i <= ctx.block.length || err(`Bad label ${l}`)
+      args.push(...uleb(i))
     }
+    args.unshift(...uleb(args.length - 1))
+    immed.push(...args)
   }
 
-  // if new type - find existing match
-  ;[param, result] = paramres(nodes), alias = param + '>' + result
-  // or register new type
-  if (ctx.type[alias] == null) {
-    build.type(ctx.type.length, [[, ['param', ...param], ['result', ...result]]], ctx)
+  // select (result t+)
+  else if (code == 0x1b) {
+    let result = nodes.shift()
+    // 0x1b -> 0x1c
+    if (result.length) immed.push(immed.pop() + 1, ...vec(result.map(t => type(t, ctx))))
   }
 
-  return [ctx.type[alias], param, result]
-}
+  // ref.func $id
+  else if (code == 0xd2) {
+    immed.push(...uleb(id(nodes.shift(), ctx.func)))
+  }
 
-// consume (param t+)* (result t+)* sequence
-const paramres = (nodes) => {
-  let param = [], result = []
+  // ref.null func
+  else if (code == 0xd0) {
+    let t = nodes.shift()
+    immed.push(HEAPTYPE[t] || id(t, ctx.type)) // func->funcref, extern->externref
+  }
 
-  // collect param (param i32 i64) (param $x? i32)
-  while (nodes[0]?.[0] === 'param') {
-    let [, ...args] = nodes.shift()
-    let name = args[0]?.[0] === '$' && args.shift()
-    if (name) param[name] = param.length // expose name refs
-    param.push(...args)
+  // binary/unary (i32.add a b) - no immed
+  else if (code >= 0x45) { }
+
+  // i32.store align=n offset=m
+  else if (code >= 0x28 && code <= 0x3e) {
+    let [a, o] = memarg(nodes)
+    immed.push(...uleb((a ?? align(op))), ...uleb(o ?? 0))
   }
 
-  // collect result eg. (result f64 f32)(result i32)
-  while (nodes[0]?.[0] === 'result') {
-    let [, ...args] = nodes.shift()
-    result.push(...args)
+  // i32.const 123, f32.const 123.45
+  else if (code >= 0x41 && code <= 0x44) {
+    immed.push(...encode[op.split('.')[0]](nodes.shift()))
   }
 
-  return [param, result]
+  // memory.grow|size $idx - mandatory 0x00
+  // https://webassembly.github.io/spec/core/binary/instructions.html#memory-instructions
+  else if (code == 0x3f || code == 0x40) {
+    immed.push(0)
+  }
+
+  // table.get $id
+  else if (code == 0x25 || code == 0x26) {
+    immed.push(...uleb(id(nodes.shift(), ctx.table)))
+  }
+
+  out.push(...immed)
+
+  return out
 }
 
-// consume align/offset/etc params
+// instantiation time value initializer (consuming) - we redirect to instr
+const expr = (node, ctx) => [...instr([node], ctx), 0x0b]
+
+// consume align/offset params
 const memarg = (args) => {
-  let ao = {}, kv
-  while (args[0]?.includes('=')) kv = args.shift().split('='), ao[kv[0]] = Number(kv[1])
-  return ao
+  let align, offset, k, v
+  while (args[0]?.includes('=')) [k, v] = args.shift().split('='), k === 'offset' ? offset = +v : k === 'align' ? align = +v : err(`Unknown param ${k}=${v}`)
+
+  if (offset < 0 || offset > 0xffffffff) err(`Bad offset ${offset}`)
+  if (align <= 0 || align > 0xffffffff) err(`Bad align ${align}`)
+  if (align) ((align = Math.log2(align)) % 1) && err(`Bad align ${align}`)
+  return [align, offset]
 }
 
+// deref id node to idx
+const id = (n, list) => (n = n[0] === '$' ? list[n] : !isNaN(n) && +n, n in list ? n : err(`Unknown ${list.name} ${n}`))
+
+// ref:
+// const ALIGN = {
+//   'i32.load': 4, 'i64.load': 8, 'f32.load': 4, 'f64.load': 8,
+//   'i32.load8_s': 1, 'i32.load8_u': 1, 'i32.load16_s': 2, 'i32.load16_u': 2,
+//   'i64.load8_s': 1, 'i64.load8_u': 1, 'i64.load16_s': 2, 'i64.load16_u': 2, 'i64.load32_s': 4, 'i64.load32_u': 4, 'i32.store': 4,
+//   'i64.store': 8, 'f32.store': 4, 'f64.store': 8, 'i32.store8': 1, 'i32.store16': 2, 'i64.store8': 1, 'i64.store16': 2, 'i64.store32': 4,
+//   'v128.load': 16, 'v128.load8x8_s': 8, 'v128.load8x8_u': 8, 'v128.load16x4_s': 8, 'v128.load16x4_u': 8, 'v128.load32x2_s': 8, 'v128.load32x2_u': 8, 'v128.load8_splat': 1, 'v128.load16_splat': 2, 'v128.load32_splat': 4, 'v128.load64_splat': 8, 'v128.store': 16,
+//   'v128.load': 16, 'v128.load8_lane': 1, 'v128.load16_lane': 2, 'v128.load32_lane': 4, 'v128.load64_lane': 8, 'v128.store8_lane': 1, 'v128.store16_lane': 2, 'v128.store32_lane': 4, 'v128.store64_lane': 8, 'v128.load32_zero': 4, 'v128.load64_zero': 8
+// }
+const align = (op) => {
+  let [group, opname] = op.split('.'); // v128.load8x8_u -> group = v128, opname = load8x8_u
+  let [lsize] = (opname[0] === 'l' ? opname.slice(4) : opname.slice(5)).split('_') // load8x8_u -> lsize = 8x8
+  let [size, x] = lsize ? lsize.split('x') : [group.slice(1)] // 8x8 -> size = 8
+  return Math.log2(x ? 8 : +size / 8)
+}
+
+// build limits sequence (consuming)
+const limits = (node) => isNaN(parseInt(node[1])) ? [0, ...uleb(node.shift())] : [node[2] === 'shared' ? 3 : 1, ...uleb(node.shift()), ...uleb(node.shift())]
+
 // escape codes
-const escape = { n: 10, r: 13, t: 9, v: 1, '\\': 92 }
+const escape = { n: 10, r: 13, t: 9, v: 1, '"': 34, "'": 39, '\\': 92 }
 
 // build string binary
 const str = str => {
-  str = str[0] === '"' ? str.slice(1, -1) : str
   let res = [], i = 0, c, BSLASH = 92
   // https://webassembly.github.io/spec/core/text/values.html#strings
   for (; i < str.length;) {
     c = str.charCodeAt(i++)
     res.push(c === BSLASH ? escape[str[i++]] || parseInt(str.slice(i - 1, ++i), 16) : c)
   }
-
-  return vec(res)
+  return res
 }
 
-// build limits sequence (non-consuming)
-const limits = ([min, max, shared]) => isNaN(parseInt(max)) ? [0, ...uleb(min)] : [shared === 'shared' ? 3 : 1, ...uleb(min), ...uleb(max)]
+// serialize binary array
+const vec = a => [...uleb(a.length), ...a.flat()]
 
 const err = text => { throw Error(text) }
+
+const clone = items => items.map(item => Array.isArray(item) ? clone(item) : item)