watr 3.3.0 → 4.0.0

package/src/compile.js

@@ -1,60 +1,87 @@
 import * as encode from './encode.js'
 import { uleb, i32, i64 } from './encode.js'
-import { SECTION, TYPE, KIND, INSTR, HEAPTYPE, DEFTYPE, RECTYPE, REFTYPE, ESCAPE } from './const.js'
+import { SECTION, TYPE, KIND, INSTR, DEFTYPE } from './const.js'
 import parse from './parse.js'
-import { clone, err, str } from './util.js'
+import { err, unescape, str } from './util.js'
 
-// build instructions index
-INSTR.forEach((op, i) => INSTR[op] = i >= 0x133 ? [0xfd, i - 0x133] : i >= 0x11b ? [0xfc, i - 0x11b] : i >= 0xfb ? [0xfb, i - 0xfb] : [i]);
 
-// recursively strip all annotation nodes from AST, except @custom and @metadata.code.*
-const unannot = (node) => Array.isArray(node) ? (node[0]?.[0] === '@' && node[0] !== '@custom' && !node[0]?.startsWith?.('@metadata.code.') ? null : node.map(unannot).filter(n => n != null)) : node
+/**
+ * Clean up AST: remove comments, normalize quoted ids, convert strings to bytes.
+ * Preserves @custom and @metadata.code.* annotations. Preserves .i for error reporting.
+ *
+ * @param {any} node - AST node
+ * @param {Array} [result] - Internal accumulator
+ * @returns {any} Cleaned node
+ */
+const cleanup = (node, result) => !Array.isArray(node) ? (
+  typeof node !== 'string' ? node :
+  // skip comments: ;; ... or (; ... ;)
+  node[0] === ';' || node[1] === ';' ? null :
+  // normalize quoted ids: $"name" -> $name (if no escapes), else $unescaped
+  node[0] === '$' && node[1] === '"' ? (node.includes('\\') ? '$' + unescape(node.slice(1)) : '$' + node.slice(2, -1)) :
+  // convert string literals to byte arrays with valueOf
+  node[0] === '"' ? str(node) :
+  node
+) :
+  // remove annotations like (@name ...) except @custom and @metadata.code.*
+  node[0]?.[0] === '@' && node[0] !== '@custom' && !node[0]?.startsWith?.('@metadata.code.') ? null :
+  // unwrap single-element array containing module (after removing comments), preserve .i
+  (result = node.map(cleanup).filter(n => n != null), result.i = node.i, result.length === 1 && result[0]?.[0] === 'module' ? result[0] : result)
+
 
 /**
  * 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 function watr(nodes) {
+export default function compile(nodes) {
   // normalize to (module ...) form
-  if (typeof nodes === 'string') nodes = parse(nodes);
-  else nodes = clone(nodes)
+  if (typeof nodes === 'string') err.src = nodes, nodes = parse(nodes) || []
+  else err.src = '' // clear source if AST passed directly
+  err.i = 0
 
-  // strip annotations (text-format only), except @custom which becomes binary custom sections
-  nodes = unannot(nodes) || []
+  nodes = cleanup(nodes) || []
+
+  let idx = 0
 
   // module abbr https://webassembly.github.io/spec/core/text/modules.html#id10
-  if (nodes[0] === 'module') nodes.shift(), nodes[0]?.[0] === '$' && nodes.shift()
+  if (nodes[0] === 'module') idx++, isId(nodes[idx]) && idx++
   // 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))
-  }
+  if (nodes[idx] === 'binary') return Uint8Array.from(nodes.slice(++idx).flat())
+
   // quote "a" "b"
-  else if (nodes[0] === 'quote') {
-    nodes.shift()
-    return watr(nodes.map(s => s.slice(1, -1)).join(''))
-  }
+  if (nodes[idx] === 'quote') return compile(nodes.slice(++idx).map(v => v.valueOf().slice(1, -1)).flat().join(''))
 
   // scopes are aliased by key as well, eg. section.func.$name = section[SECTION.func] = idx
   const ctx = []
   for (let kind in SECTION) (ctx[SECTION[kind]] = ctx[kind] = []).name = kind
+  ctx.metadata = {} // code metadata storage: { type: [[funcIdx, [[pos, data]...]]] }
 
   // initialize types
-  nodes.filter(([kind, ...node]) => {
+  nodes.slice(idx).filter((n) => {
+    if (!Array.isArray(n)) {
+      let pos = err.src?.indexOf(n, err.i)
+      if (pos >= 0) err.i = pos
+      err(`Unexpected token ${n}`)
+    }
+    let [kind, ...node] = n
+    err.i = n.i // track position for errors
+    // (@custom "name" placement? data) - custom section support
+    if (kind === '@custom') {
+      ctx.custom.push(node)
+    }
     // (rec (type $a (sub final? $sup* (func ...))...) (type $b ...)) -> save subtypes
-    if (kind === 'rec') {
+    else if (kind === 'rec') {
       // node contains a list of subtypes, (type ...) or (type (sub final? ...))
       // convert rec type into regular type (first subtype) with stashed subtypes length
       // add rest of subtypes as regular type nodes with subtype flag
       for (let i = 0; i < node.length; i++) {
         let [, ...subnode] = node[i]
-        alias(subnode, ctx.type);
+        name(subnode, ctx.type);
         (subnode = typedef(subnode, ctx)).push(i ? true : [ctx.type.length, node.length])
         ctx.type.push(subnode)
       }
@@ -64,13 +91,9 @@ export default function watr(nodes) {
     // (type (struct (field a)*)
     // (type (sub final? $nm* (struct|array|func ...)))
     else if (kind === 'type') {
-      alias(node, ctx.type);
+      name(node, ctx.type);
       ctx.type.push(typedef(node, ctx));
     }
-    // (@custom "name" placement? data)
-    else if (kind === '@custom') {
-      ctx.custom.push(node)  // node is just the arguments, not including @custom
-    }
     // other sections may have id
     else if (kind === 'start' || kind === 'export') ctx[kind].push(node)
 
@@ -78,7 +101,9 @@ export default function watr(nodes) {
   })
 
     // prepare/normalize nodes
-    .forEach(([kind, ...node]) => {
+    .forEach((n) => {
+      let [kind, ...node] = n
+      err.i = n.i // track position for errors
       let imported // if node needs to be imported
 
       // import abbr
@@ -87,31 +112,34 @@ export default function watr(nodes) {
 
       // index, alias
       let items = ctx[kind];
-      let name = alias(node, items);
+      if (!items) err(`Unknown section ${kind}`)
+      name(node, items);
 
       // export abbr
-      // (table|memory|global|func id? (export n)* ...) -> (table|memory|global|func id ...) (export n (table|memory|global|func id))
+      // (table|memory|global|func|tag id? (export n)* ...) -> (table|memory|global|func|tag id ...) (export n (table|memory|global|func id))
       while (node[0]?.[0] === 'export') ctx.export.push([node.shift()[1], [kind, items?.length]])
 
       // for import nodes - redirect output to import
       if (node[0]?.[0] === 'import') [, ...imported] = node.shift()
 
-      // table abbr
+      // table abbr: (table id? i64? reftype (elem ...)) -> (table id? i64? n n reftype) + (elem ...)
       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]
-          ctx.elem.push([['table', name || items.length], ['i32.const', '0'], reftype, ...els])
+        const is64 = node[0] === 'i64', idx = is64 ? 1 : 0
+        if (node[idx + 1]?.[0] === 'elem') {
+          let [reftype, [, ...els]] = [node[idx], node[idx + 1]]
+          node = is64 ? ['i64', els.length, els.length, reftype] : [els.length, els.length, reftype]
+          ctx.elem.push([['table', items.length], ['offset', [is64 ? 'i64.const' : 'i32.const', is64 ? 0n : 0]], reftype, ...els])
         }
       }
 
-      // data abbr
-      // (memory id? (data str)) -> (memory id? n n) (data (memory id) (i32.const 0) str)
-      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
-        ctx.data.push([['memory', items.length], ['i32.const', 0], ...data])
-        node = [m, m]
+      // data abbr: (memory id? i64? (data str)) -> (memory id? i64? n n) + (data ...)
+      else if (kind === 'memory') {
+        const is64 = node[0] === 'i64', idx = is64 ? 1 : 0
+        if (node[idx]?.[0] === 'data') {
+          let [, ...data] = node.splice(idx, 1)[0], m = '' + Math.ceil(data.reduce((s, d) => s + d.length, 0) / 65536)
+          ctx.data.push([['memory', items.length], [is64 ? 'i64.const' : 'i32.const', is64 ? 0n : 0], ...data])
+          node = is64 ? ['i64', m, m] : [m, m]
+        }
       }
 
       // dupe to code section, save implicit type
@@ -119,22 +147,22 @@ export default function watr(nodes) {
         let [idx, param, result] = typeuse(node, ctx);
         idx ??= regtype(param, result, ctx)
 
-        // we save idx because type can be defined after
-        !imported && ctx.code.push([[idx, param, result], ...plain(node, ctx)]) // pass param since they may have names
-        node.unshift(['type', idx])
+        // flatten + normalize function body
+        !imported && ctx.code.push([[idx, param, result], ...normalize(node, ctx)])
+        node = [['type', idx]]
       }
 
       // tag has a type similar to func
       else if (kind === 'tag') {
         let [idx, param] = typeuse(node, ctx);
         idx ??= regtype(param, [], ctx)
-        node.unshift(['type', idx])
+        node = [['type', idx]]
       }
 
       // import writes to import section amd adds placeholder for (kind) section
       if (imported) ctx.import.push([...imported, [kind, ...node]]), node = null
 
-      items?.push(node)
+      items.push(node)
     })
 
   // convert nodes to bytes
@@ -150,8 +178,22 @@ export default function watr(nodes) {
     return !items.length ? [] : [kind, ...vec(count ? vec(items) : items)]
   }
 
+  // Generate metadata custom sections
+  const binMeta = () => {
+    const sections = []
+    for (const type in ctx.metadata) {
+      const name = vec(str(`"metadata.code.${type}"`))
+      const content = vec(ctx.metadata[type].map(([funcIdx, instances]) =>
+        [...uleb(funcIdx), ...vec(instances.map(([pos, data]) => [...uleb(pos), ...vec(data)]))]
+      ))
+      sections.push(0, ...vec([...name, ...content]))
+    }
+    return sections
+  }
+
+
   // build final binary
-  const out = [
+  return Uint8Array.from([
     0x00, 0x61, 0x73, 0x6d, // magic
     0x01, 0x00, 0x00, 0x00, // version
     ...bin(SECTION.custom),
@@ -166,263 +208,243 @@ export default function watr(nodes) {
     ...bin(SECTION.start, false),
     ...bin(SECTION.elem),
     ...bin(SECTION.datacount, false),
-  ]
-
-  // Build code section first (populates ctx.meta)
-  const codeSection = bin(SECTION.code)
-
-  // Build code metadata custom sections: metadata.code.<type>
-  for (const type in ctx.meta) {
-    const name = vec(str(`"metadata.code.${type}"`))
-    const content = vec(ctx.meta[type].map(([funcIdx, instances]) =>
-      [...uleb(funcIdx), ...vec(instances.map(([pos, data]) => [...uleb(pos), ...vec(str(data))]))]
-    ))
-    out.push(0, ...vec([...name, ...content]))
-  }
-
-  out.push(...codeSection, ...bin(SECTION.data))
-
-  return Uint8Array.from(out)
-}
-
-// consume name eg. $t ...
-const alias = (node, list) => {
-  let name = (node[0]?.[0] === '$' || node[0]?.[0] == null) && node.shift();
-  if (name && list) name in list ? err(`Duplicate ${list.name} ${name}`) : list[name] = list.length; // save alias
-  return name
+    ...bin(SECTION.code),
+    ...binMeta(),
+    ...bin(SECTION.data)
+  ])
 }
 
-// (type $id? (func param* result*))
-// (type $id? (array (mut i8)))
-// (type $id? (struct (field a)*)
-// (type $id? (sub final? $nm* (struct|array|func ...)))
-const typedef = ([dfn], ctx) => {
-  let subkind = 'subfinal', supertypes = [], compkind
-  if (dfn[0] === 'sub') {
-    subkind = dfn.shift(), dfn[0] === 'final' && (subkind += dfn.shift())
-    dfn = (supertypes = dfn).pop() // last item is definition
-  }
-
-  [compkind, ...dfn] = dfn // composite type kind
 
-  if (compkind === 'func') dfn = paramres(dfn), ctx.type['$' + dfn.join('>')] ??= ctx.type.length
-  else if (compkind === 'struct') dfn = fieldseq(dfn, 'field', true)
-  else if (compkind === 'array') [dfn] = dfn
-
-  return [compkind, dfn, subkind, supertypes]
-}
-
-// register (implicit) type
-const regtype = (param, result, ctx, idx = '$' + param + '>' + result) => (
-  (ctx.type[idx] ??= ctx.type.push(['func', [param, result]]) - 1),
-  idx
-)
-
-// 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
-
-  // explicit type (type 0|$name)
-  if (nodes[0]?.[0] === 'type') {
-    [, idx] = nodes.shift();
-    [param, result] = paramres(nodes, names);
-
-    const [, srcParamRes] = ctx.type[id(idx, ctx.type)] ?? err(`Unknown type ${idx}`)
-
-    // check type consistency (excludes forward refs)
-    if ((param.length || result.length) && srcParamRes.join('>') !== param + '>' + result) err(`Type ${idx} mismatch`)
-
-    return [idx, ...srcParamRes]
-  }
-
-  // implicit type (param i32 i32)(result i32)
-  return [idx, ...paramres(nodes, names)]
-}
-
-// consume (param t+)* (result t+)* sequence
-const paramres = (nodes, names = true) => {
-  // let param = [], result = []
-
-  // collect param (param i32 i64) (param $x? i32)
-  let param = fieldseq(nodes, 'param', names)
-
-  // collect result eg. (result f64 f32)(result i32)
-  let result = fieldseq(nodes, 'result')
-
-  if (nodes[0]?.[0] === 'param') err(`Unexpected param`)
-
-  return [param, result]
-}
-
-// collect sequence of field, eg. (param a) (param b c), (field a) (field b c) or (result a b) (result c)
-// optionally allow or not names
-const fieldseq = (nodes, field, names = false) => {
-  let seq = []
-  // collect field eg. (field f64 f32)(field i32)
-  while (nodes[0]?.[0] === field) {
-    let [, ...args] = nodes.shift()
-    let name = args[0]?.[0] === '$' && args.shift()
-    // expose name refs, if allowed
-    if (name) {
-      if (names) name in seq ? err(`Duplicate ${field} ${name}`) : seq[name] = seq.length
-      else err(`Unexpected ${field} name ${name}`)
-    }
-    seq.push(...args)
-  }
-  return seq
-}
-
-// consume blocktype - makes sure either type or single result is returned
-const blocktype = (nodes, ctx) => {
-  let [idx, param, result] = typeuse(nodes, ctx, 0)
-
-  // get type - can be either idx or valtype (numtype | reftype)
-  if (!param.length && !result.length) return
-
-  // (result i32) - doesn't require registering type
-  if (!param.length && result.length === 1) return ['result', ...result]
-
-  // register implicit type
-  idx ??= regtype(param, result, ctx)
-
-  return ['type', idx]
-}
-
-// 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 = [], stack = [], label
-  // helper: check if node is immediate (not array operand)
-  const isImm = n => typeof n === 'string' || typeof n === 'number'
+/** Check if node is a valid index reference ($name or number) */
+const isIdx = n => n?.[0] === '$' || !isNaN(n)
+/** Check if node is an identifier (starts with $) */
+const isId = n => n?.[0] === '$'
+/** Check if node is align/offset memory parameter */
+const isMemParam = n => n?.[0] === 'a' || n?.[0] === 'o'
 
+/**
+ * Normalize and flatten function body to stack form.
+ * Converts folded S-expressions to linear instruction sequence.
+ * Handles blocks, if/then/else, try_table, and metadata annotations.
+ *
+ * @param {Array} nodes - Function body nodes
+ * @param {Object} ctx - Compilation context with type info
+ * @returns {Array} Flattened instruction sequence
+ */
+function normalize(nodes, ctx) {
+  const out = []
+  nodes = [...nodes]
   while (nodes.length) {
     let node = nodes.shift()
-
-    // code metadata annotations - pass through as marker with metadata type and data
-    // (@metadata.code.<type> data:str)
-    if (Array.isArray(node) && node[0]?.startsWith?.('@metadata.code.')) {
-      let type = node[0].slice(15) // remove '@metadata.code.' prefix
-      out.push(['@metadata', type, node[1]])
-      continue
-    }
-
-    // lookup is slower than sequence of known ifs
     if (typeof node === 'string') {
       out.push(node)
-
-      // block typeuse?
       if (node === 'block' || node === 'if' || node === 'loop') {
-        // (loop $l?)
-        if (nodes[0]?.[0] === '$') label = nodes.shift(), out.push(label), stack.push(label)
-
+        if (isId(nodes[0])) out.push(nodes.shift())
         out.push(blocktype(nodes, ctx))
       }
-
-      // else $label
-      // end $label - make sure it matches block label
       else if (node === 'else' || node === 'end') {
-        if (nodes[0]?.[0] === '$') (node === 'end' ? stack.pop() : label) !== (label = nodes.shift()) && err(`Mismatched ${node} label ${label}`)
-      }
-
-      // select (result i32 i32 i32)?
-      else if (node === 'select') {
-        out.push(paramres(nodes, 0)[1])
+        if (isId(nodes[0])) nodes.shift()
       }
-
-      // call_indirect $table? $typeidx
-      // return_call_indirect $table? $typeidx
+      else if (node === 'select') out.push(paramres(nodes)[1])
       else if (node.endsWith('call_indirect')) {
-        let tableidx = nodes[0]?.[0] === '$' || !isNaN(nodes[0]) ? nodes.shift() : 0
-        let [idx, param, result] = typeuse(nodes, ctx, 0)
+        let tableidx = isIdx(nodes[0]) ? nodes.shift() : 0, [idx, param, result] = typeuse(nodes, ctx)
         out.push(tableidx, ['type', idx ?? regtype(param, result, ctx)])
       }
-
-      // mark datacount section as required
-      else if (node === 'memory.init' || node === 'data.drop' || node === 'array.new_data' || node === 'array.init_data') {
-        ctx.datacount[0] = true
-        // memory.init memidx? dataidx
-        if (node === 'memory.init') out.push(isImm(nodes[1]) ? nodes.shift() : 0, isImm(nodes[0]) ? nodes.shift() : 0)
+      else if (node === 'table.init') out.push(isIdx(nodes[1]) ? nodes.shift() : 0, nodes.shift())
+      else if (node === 'table.copy' || node === 'memory.copy') out.push(isIdx(nodes[0]) ? nodes.shift() : 0, isIdx(nodes[0]) ? nodes.shift() : 0)
+      else if (node.startsWith('table.')) out.push(isIdx(nodes[0]) ? nodes.shift() : 0)
+      else if (node === 'memory.init') {
+        out.push(...(isIdx(nodes[1]) ? [nodes.shift(), nodes.shift()].reverse() : [nodes.shift(), 0]))
+        ctx.datacount && (ctx.datacount[0] = true)
       }
-
-      // memory.* memidx? - multi-memory proposal
-      else if (node === 'memory.size' || node === 'memory.grow' || node === 'memory.fill') {
-        out.push(isImm(nodes[0]) ? nodes.shift() : 0)
+      else if (node === 'data.drop' || node === 'array.new_data' || node === 'array.init_data') {
+        node === 'data.drop' && out.push(nodes.shift())
+        ctx.datacount && (ctx.datacount[0] = true)
+      }
+      // memory.* instructions and load/store with optional memory index
+      else if ((node.startsWith('memory.') || node.endsWith('load') || node.endsWith('store')) && isIdx(nodes[0])) out.push(nodes.shift())
+    }
+    else if (Array.isArray(node)) {
+      const op = node[0]
+      node.i != null && (err.i = node.i) // track position for errors
+
+      // code metadata annotations - pass through as marker with metadata type and data
+      // (@metadata.code.<type> data:str)
+      if (op?.startsWith?.('@metadata.code.')) {
+        let type = op.slice(15) // remove '@metadata.code.' prefix
+        out.push(['@metadata', type, node[1]])
+        continue
       }
 
-      // memory.copy dstmem? srcmem?
-      else if (node === 'memory.copy') {
-        out.push(isImm(nodes[0]) ? nodes.shift() : 0, isImm(nodes[0]) ? nodes.shift() : 0)
+      // Check if node is a valid instruction (string with opcode in INSTR)
+      if (typeof op !== 'string' || !Array.isArray(INSTR[op])) { out.push(node); continue }
+      const parts = node.slice(1)
+      if (op === 'block' || op === 'loop') {
+        out.push(op)
+        if (isId(parts[0])) out.push(parts.shift())
+        out.push(blocktype(parts, ctx), ...normalize(parts, ctx), 'end')
+      }
+      else if (op === 'if') {
+        let then = [], els = []
+        if (parts.at(-1)?.[0] === 'else') els = normalize(parts.pop().slice(1), ctx)
+        if (parts.at(-1)?.[0] === 'then') then = normalize(parts.pop().slice(1), ctx)
+        let immed = [op]
+        if (isId(parts[0])) immed.push(parts.shift())
+        immed.push(blocktype(parts, ctx))
+        out.push(...normalize(parts, ctx), ...immed, ...then)
+        els.length && out.push('else', ...els)
+        out.push('end')
+      }
+      else if (op === 'try_table') {
+        out.push(op)
+        if (isId(parts[0])) out.push(parts.shift())
+        out.push(blocktype(parts, ctx))
+        // Collect catch clauses
+        while (parts[0]?.[0] === 'catch' || parts[0]?.[0] === 'catch_ref' || parts[0]?.[0] === 'catch_all' || parts[0]?.[0] === 'catch_all_ref') {
+          out.push(parts.shift())
+        }
+        out.push(...normalize(parts, ctx), 'end')
+      }
+      else {
+        const imm = []
+        // Collect immediate operands (non-arrays or special forms like type/param/result/ref)
+        while (parts.length && (!Array.isArray(parts[0]) || 'type,param,result,ref'.includes(parts[0][0]))) imm.push(parts.shift())
+        out.push(...normalize(parts, ctx), op, ...imm)
+        nodes.unshift(...out.splice(out.length - 1 - imm.length))
       }
+    } else out.push(node)
+  }
+  return out
+}
 
-      // table.init tableidx? elemidx -> table.init tableidx elemidx
-      else if (node === 'table.init') out.push((nodes[1][0] === '$' || !isNaN(nodes[1])) ? nodes.shift() : 0, nodes.shift())
+/**
+ * Register implicit function type, return type index.
+ * Creates canonical name like '$i32,i32>i32' for deduplication.
+ *
+ * @param {string[]} param - Parameter types
+ * @param {string[]} result - Result types
+ * @param {Object} ctx - Compilation context
+ * @param {string} [idx] - Type identifier
+ * @returns {string} Type index/identifier
+ */
+const regtype = (param, result, ctx, idx = '$' + param + '>' + result) => (ctx.type[idx] ??= ctx.type.push(['func', [param, result]]) - 1, idx)
 
-      // table.* tableidx?
-      else if (node.startsWith('table.')) {
-        out.push(nodes[0]?.[0] === '$' || !isNaN(nodes[0]) ? nodes.shift() : 0)
+/**
+ * Collect field sequence: (field a) (field b c) → [a, b, c].
+ * Tracks named fields for index lookup.
+ *
+ * @param {Array} nodes - Nodes to consume from
+ * @param {string} field - Field keyword ('param', 'result', 'field')
+ * @returns {Array} Collected values with named indices
+ */
+const fieldseq = (nodes, field) => {
+  let seq = []
+  while (nodes[0]?.[0] === field) {
+    let [, ...args] = nodes.shift(), nm = isId(args[0]) && args.shift()
+    if (nm) nm in seq ? (() => { throw Error(`Duplicate ${field} ${nm}`) })() : seq[nm] = seq.length
+    seq.push(...args)
+  }
+  return seq
+}
 
-        // table.copy tableidx? tableidx?
-        if (node === 'table.copy') out.push(nodes[0][0] === '$' || !isNaN(nodes[0]) ? nodes.shift() : 0)
-      }
-    }
+/**
+ * Consume (param ...)* (result ...)* from nodes.
+ *
+ * @param {Array} nodes - Nodes to consume from
+ * @returns {[string[], string[]]} [params, results]
+ */
+const paramres = (nodes) => {
+  let param = fieldseq(nodes, 'param'), result = fieldseq(nodes, 'result')
+  if (nodes[0]?.[0] === 'param') throw Error('Unexpected param')
+  return [param, result]
+}
 
-    else {
-      // (block ...) -> block ... end
-      if (node[0] === 'block' || node[0] === 'loop') {
-        out.push(...plain(node, ctx), 'end')
-      }
+/**
+ * Consume typeuse: (type idx)? (param ...)* (result ...)*.
+ * Resolves type reference or returns inline signature.
+ *
+ * @param {Array} nodes - Nodes to consume from
+ * @param {Object} ctx - Compilation context with type table
+ * @returns {[string|undefined, string[], string[]]} [typeIdx, params, results]
+ */
+const typeuse = (nodes, ctx) => {
+  if (nodes[0]?.[0] !== 'type') return [, ...paramres(nodes)]
+  let [, idx] = nodes.shift(), [param, result] = paramres(nodes)
+  const entry = ctx.type[(typeof idx === 'string' && isNaN(idx)) ? ctx.type[idx] : +idx]
+  if (!entry) throw Error(`Unknown type ${idx}`)
+  if ((param.length || result.length) && entry[1].join('>') !== param + '>' + result) throw Error(`Type ${idx} mismatch`)
+  return [idx, ...entry[1]]
+}
 
-      // (if ...) -> if ... end
-      else if (node[0] === 'if') {
-        // Pop pending metadata (branch_hint) if present
-        let meta = out[out.length - 1]?.[0] === '@metadata' && out.pop()
-
-        let then = [], els = [], immed = [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') {
-          els = plain(node.pop(), ctx)
-          // ignore empty else
-          // https://webassembly.github.io/spec/core/text/instructions.html#abbreviations
-          if (els.length === 1) els.length = 0
-        }
-        if (node[node.length - 1]?.[0] === 'then') then = plain(node.pop(), ctx)
+/**
+ * Resolve blocktype: void | (result t) | (type idx).
+ * Returns abbreviated form when possible.
+ *
+ * @param {Array} nodes - Nodes to consume from
+ * @param {Object} ctx - Compilation context
+ * @returns {Array|undefined} Blocktype node or undefined for void
+ */
+const blocktype = (nodes, ctx) => {
+  let [idx, param, result] = typeuse(nodes, ctx)
+  if (!param.length && !result.length) return
+  if (!param.length && result.length === 1) return ['result', ...result]
+  return ['type', idx ?? regtype(param, result, ctx)]
+}
 
-        // label?
-        if (node[0]?.[0] === '$') immed.push(node.shift())
 
-        // blocktype?
-        immed.push(blocktype(node, ctx))
 
-        if (typeof node[0] === 'string') err('Unfolded condition')
+/**
+ * Consume and register section item name (e.g., $foo).
+ * Stores alias in list for later index resolution.
+ *
+ * @param {Array} node - Node array (mutated)
+ * @param {Array} list - Section list with name property
+ * @returns {string|false} Name if found, false otherwise
+ */
+const name = (node, list) => {
+  let nm = isId(node[0]) && node.shift();
+  if (nm) nm in list ? err(`Duplicate ${list.name} ${nm}`) : list[nm] = list.length; // save alias
+  return nm
+}
 
-        // conditions, metadata (if any), if, then, else, end
-        out.push(...plain(node, ctx), ...(meta ? [meta] : []), ...immed, ...then, ...els, 'end')
-      }
-      else out.push(plain(node, ctx))
-    }
+/**
+ * Parse type definition: func, array, struct, or sub(type).
+ * Handles recursive types and subtyping.
+ *
+ * @param {Array} node - [definition] where definition is func/array/struct/sub
+ * @param {Object} ctx - Compilation context
+ * @returns {[string, any, string, string[]]} [kind, fields, subkind, supertypes]
+ */
+const typedef = ([dfn], ctx) => {
+  let subkind = 'subfinal', supertypes = [], compkind
+  if (dfn[0] === 'sub') {
+    subkind = dfn.shift(), dfn[0] === 'final' && (subkind += dfn.shift())
+    dfn = (supertypes = dfn).pop() // last item is definition
   }
 
-  return out
+  [compkind, ...dfn] = dfn // composite type kind
+
+  if (compkind === 'func') dfn = paramres(dfn), ctx.type['$' + dfn.join('>')] ??= ctx.type.length
+  else if (compkind === 'struct') dfn = fieldseq(dfn, 'field')
+  else if (compkind === 'array') [dfn] = dfn
+
+  return [compkind, dfn, subkind, supertypes]
 }
 
 
 // build section binary [by section codes] (non consuming)
 const build = [
-  // (@custom "name" placement? data)
-  // placement is optional: (before|after section) or (before first)|(after last)
-  // For now we ignore placement and just output the custom section
+  // (@custom "name" placement? data) - custom section builder
   ([name, ...rest], ctx) => {
-    // Check if second arg is placement directive
+    // Check if second arg is placement directive (before|after section)
     let data = rest
     if (rest[0]?.[0] === 'before' || rest[0]?.[0] === 'after') {
       // Skip placement for now - would need more complex section ordering
       data = rest.slice(1)
     }
-
     // Custom section format: name (vec string) + raw content bytes
-    return [...vec(str(name)), ...str(...data)]
+    // parse already returns strings as byte arrays, so just vec them
+    return [...vec(name), ...data.flat()]
   },
   // type kinds
   // (func params result)
@@ -457,7 +479,7 @@ const build = [
     return [DEFTYPE[kind], ...details]
   },
 
-  // (import "math" "add" (func|table|global|memory dfn?))
+  // (import "math" "add" (func|table|global|memory|tag dfn?))
   ([mod, field, [kind, ...dfn]], ctx) => {
     let details
 
@@ -481,7 +503,7 @@ const build = [
     }
     else err(`Unknown kind ${kind}`)
 
-    return ([...vec(str(mod)), ...vec(str(field)), KIND[kind], ...details])
+    return ([...vec(mod), ...vec(field), KIND[kind], ...details])
   },
 
   // (func $name? ...params result ...body)
@@ -499,8 +521,8 @@ const build = [
   // (global $id? (mut i32) (i32.const 42))
   ([t, init], ctx) => [...fieldtype(t, ctx), ...expr(init, ctx)],
 
-  //  (export "name" (func|table|mem $name|idx))
-  ([nm, [kind, l]], ctx) => ([...vec(str(nm)), KIND[kind], ...uleb(id(l, ctx[kind]))]),
+  // (export "name" (func|table|mem $name|idx))
+  ([nm, [kind, l]], ctx) => ([...vec(nm), KIND[kind], ...uleb(id(l, ctx[kind]))]),
 
   // (start $main)
   ([l], ctx) => uleb(id(l, ctx.func)),
@@ -516,10 +538,15 @@ const build = [
     if (parts[0] === 'declare') parts.shift(), declare = 1
 
     // table?
-    if (parts[0][0] === 'table') {
+    if (parts[0]?.[0] === 'table') {
       [, tabidx] = parts.shift()
       tabidx = id(tabidx, ctx.table)
     }
+    // Handle abbreviated form: (elem tableidx (offset ...) ...) where tableidx is directly a number/identifier
+    else if ((typeof parts[0] === 'string' || typeof parts[0] === 'number') &&
+             (parts[1]?.[0] === 'offset' || (Array.isArray(parts[1]) && parts[1][0] !== 'item' && !parts[1][0]?.startsWith('ref')))) {
+      tabidx = id(parts.shift(), ctx.table)
+    }
 
     // (offset expr)|expr
     if (parts[0]?.[0] === 'offset' || (Array.isArray(parts[0]) && parts[0][0] !== 'item' && !parts[0][0].startsWith('ref'))) {
@@ -531,15 +558,17 @@ const build = [
     else if (!declare) passive = 1
 
     // funcref|externref|(ref ...)
-    if (REFTYPE[parts[0]] || parts[0]?.[0] === 'ref') rt = reftype(parts.shift(), ctx)
+    if (TYPE[parts[0]] || parts[0]?.[0] === 'ref') rt = reftype(parts.shift(), ctx)
     // func ... abbr https://webassembly.github.io/function-references/core/text/modules.html#id7
-    else if (parts[0] === 'func') rt = [HEAPTYPE[parts.shift()]]
+    else if (parts[0] === 'func') rt = [TYPE[parts.shift()]]
     // or anything else
-    else rt = [HEAPTYPE.func]
+    else rt = [TYPE.func]
 
     // deabbr els sequence, detect expr usage
     parts = parts.map(el => {
-      if (el[0] === 'item') [, ...el] = el
+      // (item ref.func $f) or (item (ref.func $f)) → $f
+      if (el[0] === 'item') el = el.length === 3 && el[1] === 'ref.func' ? el[2] : el[1]
+      // (ref.func $f) → $f
       if (el[0] === 'ref.func') [, el] = el
       // (ref.null func) and other expressions turn expr els mode
       if (typeof el !== 'string') elexpr = 1
@@ -548,7 +577,7 @@ const build = [
 
     // reftype other than (ref null? func) forces table index via nofunc flag
     // also it forces elexpr
-    if (rt[0] !== REFTYPE.funcref) nofunc = 1, elexpr = 1
+    if (rt[0] !== TYPE.funcref) nofunc = 1, elexpr = 1
 
     // mode:
     // bit 0 indicates a passive or declarative segment
@@ -608,38 +637,31 @@ const build = [
     // collect locals
     while (body[0]?.[0] === 'local') {
       let [, ...types] = body.shift()
-      if (types[0]?.[0] === '$') {
-        let name = types.shift()
-        if (name in ctx.local) err(`Duplicate local ${name}`)
-        else ctx.local[name] = ctx.local.length
+      if (isId(types[0])) {
+        let nm = types.shift()
+        if (nm in ctx.local) err(`Duplicate local ${nm}`)
+        else ctx.local[nm] = ctx.local.length
       }
       ctx.local.push(...types)
     }
 
-    ctx._meta = null
-    const bytes = []
-    while (body.length) bytes.push(...instr(body, ctx))
-    bytes.push(0x0b)
-
-    // Extract metadata placeholders (arrays), group by type
-    const metaByType = {}, cleanBytes = []
-    for (const b of bytes)
-      if (Array.isArray(b)) for (const [type, data] of b) (metaByType[type] ??= []).push([cleanBytes.length, data])
-      else cleanBytes.push(b)
+    // Setup metadata tracking for this function
+    ctx.meta = {}
+    const bytes = instr(body, ctx)
 
-    // Store metadata for this function, grouped by type
+    // Store collected metadata for this function
     const funcIdx = ctx.import.filter(imp => imp[2][0] === 'func').length + codeIdx
-    for (const type in metaByType) ((ctx.meta ??= {})[type] ??= []).push([funcIdx, metaByType[type]])
+    for (const type in ctx.meta) ((ctx.metadata ??= {})[type] ??= []).push([funcIdx, ctx.meta[type]])
 
     // 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
+    ctx.local = ctx.block = ctx.meta = null
 
     // https://webassembly.github.io/spec/core/binary/modules.html#code-section
-    return vec([...vec(loctypes.map(([n, t]) => [...uleb(n), ...reftype(t, ctx)])), ...cleanBytes])
+    return vec([...vec(loctypes.map(([n, t]) => [...uleb(n), ...reftype(t, ctx)])), ...bytes])
   },
 
   // (data (i32.const 0) "\aa" "\bb"?)
@@ -653,12 +675,17 @@ const build = [
       [, memidx] = inits.shift()
       memidx = id(memidx, ctx.memory)
     }
+    // Handle abbreviated form: (data memidx (offset ...) ...) where memidx is directly a number/identifier
+    else if ((typeof inits[0] === 'string' || typeof inits[0] === 'number') &&
+             (inits[1]?.[0] === 'offset' || (Array.isArray(inits[1]) && typeof inits[1][0] === 'string'))) {
+      memidx = id(inits.shift(), ctx.memory)
+    }
 
     // (offset (i32.const 0)) or (i32.const 0)
-    if (typeof inits[0] !== 'string' && inits[0]) {
+    if (Array.isArray(inits[0]) && typeof inits[0]?.[0] === 'string') {
       offset = inits.shift()
-      if (offset?.[0] === 'offset') [, offset] = offset
-      else offset ?? err('Bad offset', offset)
+      if (offset[0] === 'offset') [, offset] = offset
+      offset ?? err('Bad offset', offset)
     }
 
     return ([
@@ -670,23 +697,24 @@ const build = [
             // passive: 1
             [1]
       ),
-      ...vec(str(...inits))
+      ...vec(inits.flat())
     ])
   },
 
   // datacount
-  (nodes, ctx) => uleb(ctx.data.length)
-]
+  (nodes, ctx) => uleb(ctx.data.length),
 
-// (tag $id? (param i32)*) - tags for exception handling
-build[SECTION.tag] = ([[, typeidx]], ctx) => [0x00, ...uleb(id(typeidx, ctx.type))]
+  // (tag $name? (type idx))
+  ([[, typeidx]], ctx) => [0x00, ...uleb(id(typeidx, ctx.type))]
+]
 
-// build reftype, either direct absheaptype or wrapped heaptype https://webassembly.github.io/gc/core/binary/types.html#reference-types
+// Build reference type encoding (ref/refnull forms, not related to regtype which handles func types)
+// https://webassembly.github.io/gc/core/binary/types.html#reference-types
 const reftype = (t, ctx) => (
   t[0] === 'ref' ?
     t[1] == 'null' ?
-      HEAPTYPE[t[2]] ? [HEAPTYPE[t[2]]] : [REFTYPE.refnull, ...uleb(id(t[t.length - 1], ctx.type))] :
-      [TYPE.ref, ...uleb(HEAPTYPE[t[t.length - 1]] || id(t[t.length - 1], ctx.type))] :
+      TYPE[t[2]] ? [TYPE[t[2]]] : [TYPE.refnull, ...uleb(id(t[t.length - 1], ctx.type))] :
+      [TYPE.ref, ...uleb(TYPE[t[t.length - 1]] || id(t[t.length - 1], ctx.type))] :
     // abbrs
     [TYPE[t] ?? err(`Unknown type ${t}`)]
 );
@@ -695,320 +723,191 @@ const reftype = (t, ctx) => (
 const fieldtype = (t, ctx, mut = t[0] === 'mut' ? 1 : 0) => [...reftype(mut ? t[1] : t, ctx), mut];
 
 
-// consume one instruction from nodes sequence
-const instr = (nodes, ctx) => {
-  if (!nodes?.length) return []
 
-  let out = [], op = nodes.shift(), immed, code
-  const isImm = n => typeof n === 'string' || typeof n === 'number'
 
-  // Handle code metadata marker - store for next instruction
-  // ['@metadata', type, data]
-  if (op?.[0] === '@metadata') {
-    ;(ctx._meta ??= []).push(op.slice(1))
-    return nodes.length ? instr(nodes, ctx) : []
-  }
 
-  // consume group
-  if (Array.isArray(op)) {
-    immed = instr(op, ctx)
-    while (op.length) out.push(...instr(op, ctx))
-    // Insert metadata placeholder before instruction
-    if (ctx._meta) out.push(ctx._meta), ctx._meta = null
-    out.push(...immed)
-    return out
+// Pre-defined instruction handlers
+const IMM = {
+  null: () => [],
+  reversed: (n, c) => { let t = n.shift(), e = n.shift(); return [...uleb(id(e, c.elem)), ...uleb(id(t, c.table))] },
+  block: (n, c) => {
+    c.block.push(1)
+    isId(n[0]) && (c.block[n.shift()] = c.block.length)
+    let t = n.shift()
+    return !t ? [TYPE.void] : t[0] === 'result' ? reftype(t[1], c) : uleb(id(t[1], c.type))
+  },
+  try_table: (n, c) => {
+    isId(n[0]) && (c.block[n.shift()] = c.block.length + 1)
+    let blocktype = n.shift()
+    let result = !blocktype ? [TYPE.void] : blocktype[0] === 'result' ? reftype(blocktype[1], c) : uleb(id(blocktype[1], c.type))
+    // Collect catch clauses BEFORE pushing try_table to block stack (catch labels are relative to outer blocks)
+    let catches = [], count = 0
+    while (n[0]?.[0] === 'catch' || n[0]?.[0] === 'catch_ref' || n[0]?.[0] === 'catch_all' || n[0]?.[0] === 'catch_all_ref') {
+      let clause = n.shift()
+      let kind = clause[0] === 'catch' ? 0x00 : clause[0] === 'catch_ref' ? 0x01 : clause[0] === 'catch_all' ? 0x02 : 0x03
+      if (kind <= 0x01) catches.push(kind, ...uleb(id(clause[1], c.tag)), ...uleb(blockid(clause[2], c.block)))
+      else catches.push(kind, ...uleb(blockid(clause[1], c.block)))
+      count++
+    }
+    c.block.push(1)  // NOW push try_table to block stack after processing catches
+    return [...result, ...uleb(count), ...catches]
+  },
+  end: (_n, c) => (c.block.pop(), []),
+  call_indirect: (n, c) => { let t = n.shift(), [, idx] = n.shift(); return [...uleb(id(idx, c.type)), ...uleb(id(t, c.table))] },
+  br_table: (n, c) => {
+    let labels = [], count = 0
+    while (n[0] && (!isNaN(n[0]) || isId(n[0]))) (labels.push(...uleb(blockid(n.shift(), c.block))), count++)
+    return [...uleb(count - 1), ...labels]
+  },
+  select: (n, c) => { let r = n.shift() || []; return r.length ? vec(r.map(t => reftype(t, c))) : [] },
+  ref_null: (n, c) => { let t = n.shift(); return TYPE[t] ? [TYPE[t]] : uleb(id(t, c.type)) },
+  memarg: (n, c, op) => memargEnc(n, op, isIdx(n[0]) && !isMemParam(n[0]) ? id(n.shift(), c.memory) : 0),
+  opt_memory: (n, c) => uleb(id(isIdx(n[0]) ? n.shift() : 0, c.memory)),
+  reftype: (n, c) => { let ht = reftype(n.shift(), c); return ht.length > 1 ? ht.slice(1) : ht },
+  reftype2: (n, c) => { let b = blockid(n.shift(), c.block), h1 = reftype(n.shift(), c), h2 = reftype(n.shift(), c); return [((h2[0] !== TYPE.ref) << 1) | (h1[0] !== TYPE.ref), ...uleb(b), h1.pop(), h2.pop()] },
+  v128const: (n) => {
+    let [t, num] = n.shift().split('x'), bits = +t.slice(1), stride = bits >>> 3; num = +num
+    if (t[0] === 'i') {
+      let arr = num === 16 ? new Uint8Array(16) : num === 8 ? new Uint16Array(8) : num === 4 ? new Uint32Array(4) : new BigUint64Array(2)
+      for (let j = 0; j < num; j++) arr[j] = encode[t].parse(n.shift())
+      return [...new Uint8Array(arr.buffer)]
+    }
+    let arr = new Uint8Array(16)
+    for (let j = 0; j < num; j++) arr.set(encode[t](n.shift()), j * stride)
+    return [...arr]
+  },
+  shuffle: (n) => {
+    let result = []
+    for (let j = 0; j < 16; j++) result.push(parseUint(n.shift(), 32))
+    if (typeof n[0] === 'string' && !isNaN(n[0])) err(`invalid lane length`)
+    return result
+  },
+  memlane: (n, c, op) => {
+    // SIMD lane: [memidx?] [offset/align]* laneidx - memidx present if isId OR (isIdx AND (next is memParam OR isIdx))
+    const memIdx = isId(n[0]) || (isIdx(n[0]) && (isMemParam(n[1]) || isIdx(n[1]))) ? id(n.shift(), c.memory) : 0
+    return [...memargEnc(n, op, memIdx), ...uleb(parseUint(n.shift()))]
+  },
+  '*': (n) => uleb(n.shift()),
+
+  // *idx types
+  labelidx: (n, c) => uleb(blockid(n.shift(), c.block)),
+  laneidx: (n) => [parseUint(n.shift(), 0xff)],
+  funcidx: (n, c) => uleb(id(n.shift(), c.func)),
+  typeidx: (n, c) => uleb(id(n.shift(), c.type)),
+  tableidx: (n, c) => uleb(id(n.shift(), c.table)),
+  memoryidx: (n, c) => uleb(id(n.shift(), c.memory)),
+  globalidx: (n, c) => uleb(id(n.shift(), c.global)),
+  localidx: (n, c) => uleb(id(n.shift(), c.local)),
+  dataidx: (n, c) => uleb(id(n.shift(), c.data)),
+  elemidx: (n, c) => uleb(id(n.shift(), c.elem)),
+  tagidx: (n, c) => uleb(id(n.shift(), c.tag)),
+  'memoryidx?': (n, c) => uleb(id(isIdx(n[0]) ? n.shift() : 0, c.memory)),
+
+  // Value type
+  i32: (n) => encode.i32(n.shift()),
+  i64: (n) => encode.i64(n.shift()),
+  f32: (n) => encode.f32(n.shift()),
+  f64: (n) => encode.f64(n.shift()),
+  v128: (n) => encode.v128(n.shift()),
+
+  // Combinations
+  typeidx_field: (n, c) => { let typeId = id(n.shift(), c.type); return [...uleb(typeId), ...uleb(id(n.shift(), c.type[typeId][1]))] },
+  typeidx_multi: (n, c) => [...uleb(id(n.shift(), c.type)), ...uleb(n.shift())],
+  typeidx_dataidx: (n, c) => [...uleb(id(n.shift(), c.type)), ...uleb(id(n.shift(), c.data))],
+  typeidx_elemidx: (n, c) => [...uleb(id(n.shift(), c.type)), ...uleb(id(n.shift(), c.elem))],
+  typeidx_typeidx: (n, c) => [...uleb(id(n.shift(), c.type)), ...uleb(id(n.shift(), c.type))],
+  dataidx_memoryidx: (n, c) => [...uleb(id(n.shift(), c.data)), ...uleb(id(n.shift(), c.memory))],
+  memoryidx_memoryidx: (n, c) => [...uleb(id(n.shift(), c.memory)), ...uleb(id(n.shift(), c.memory))],
+  tableidx_tableidx: (n, c) => [...uleb(id(n.shift(), c.table)), ...uleb(id(n.shift(), c.table))]
+};
+
+// per-op imm handlers
+const HANDLER = {};
+
+
+// Populate INSTR and IMM
+(function populate(items, pre) {
+  for (let op = 0, item, nm, imm; op < items.length; op++) if (item = items[op]) {
+    // Nested array (0xfb, 0xfc, 0xfd opcodes)
+    if (Array.isArray(item)) populate(item, op)
+    else [nm, imm] = item.split(' '), INSTR[nm] = pre ? [pre, ...uleb(op)] : [op], imm && (HANDLER[nm] = IMM[imm])
   }
+})(INSTR);
 
-  [...immed] = isNaN(op[0]) && INSTR[op] || err(`Unknown instruction ${op}`)
-  code = immed[0]
-
-  // gc-related
-  // https://webassembly.github.io/gc/core/binary/instructions.html#reference-instructions
-  if (code === 0x0fb) {
-    [, code] = immed
-
-    // struct.new $t ... array.set $t
-    if ((code >= 0 && code <= 14) || (code >= 16 && code <= 19)) {
-      let tidx = id(nodes.shift(), ctx.type)
-      immed.push(...uleb(tidx))
-
-      // struct.get|set* $t $f - read field by index from struct definition (ctx.type[structidx][dfnidx])
-      if (code >= 2 && code <= 5) immed.push(...uleb(id(nodes.shift(), ctx.type[tidx][1])))
-      // array.new_fixed $t n
-      else if (code === 8) immed.push(...uleb(nodes.shift()))
-      // array.new_data|init_data $t $d
-      else if (code === 9 || code === 18) {
-        immed.push(...uleb(id(isImm(nodes[0]) ? nodes.shift() : 0, ctx.data)))
-      }
-      // array.new_elem|init_elem $t $e
-      else if (code === 10 || code === 19) immed.push(...uleb(id(nodes.shift(), ctx.elem)))
-      // array.copy $t $t
-      else if (code === 17) immed.push(...uleb(id(nodes.shift(), ctx.type)))
-    }
-    // ref.test|cast (ref null? $t|heaptype)
-    else if (code >= 20 && code <= 23) {
-      let ht = reftype(nodes.shift(), ctx)
-      if (ht[0] !== REFTYPE.ref) immed.push(code = immed.pop() + 1) // ref.test|cast (ref null $t) is next op
-      if (ht.length > 1) ht.shift() // pop ref
-      immed.push(...ht)
-    }
-    // br_on_cast[_fail] $l? (ref null? ht1) (ref null? ht2)
-    else if (code === 24 || code === 25) {
-      let i = blockid(nodes.shift(), ctx.block),
-        ht1 = reftype(nodes.shift(), ctx),
-        ht2 = reftype(nodes.shift(), ctx),
-        castflags = ((ht2[0] !== REFTYPE.ref) << 1) | (ht1[0] !== REFTYPE.ref)
-      immed.push(castflags, ...uleb(i), ht1.pop(), ht2.pop()) // we take only abstype or
-    }
-  }
 
-  // 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
+// instruction encoder
+const instr = (nodes, ctx) => {
+  let out = [], meta = []
 
-    // memory.init memidx dataidx (binary: dataidx memidx)
-    if (code === 0x08) {
-      let m = isImm(nodes[0]) ? nodes.shift() : 0, d = isImm(nodes[0]) ? nodes.shift() : 0
-      immed.push(...uleb(id(d, ctx.data)), ...uleb(id(m, ctx.memory)))
-    }
-    // data.drop idx
-    else if (code === 0x09) {
-      immed.push(...uleb(id(nodes.shift(), ctx.data)))
-    }
-    // memory.copy dstmem srcmem
-    else if (code === 0x0a) {
-      immed.push(...uleb(id(isImm(nodes[0]) ? nodes.shift() : 0, ctx.memory)), ...uleb(id(isImm(nodes[0]) ? nodes.shift() : 0, ctx.memory)))
-    }
-    // memory.fill memidx
-    else if (code === 0x0b) {
-      immed.push(...uleb(id(isImm(nodes[0]) ? nodes.shift() : 0, ctx.memory)))
-    }
+  while (nodes?.length) {
+    let op = nodes.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)))
+    // Handle code metadata marker - store for next instruction
+    // ['@metadata', type, data]
+    if (op?.[0] === '@metadata') {
+      meta.push(op.slice(1))
+      continue
     }
-  }
 
-  // v128s: (v128.load x) etc
-  // https://github.com/WebAssembly/simd/blob/master/proposals/simd/BinarySIMD.md
-  else if (code === 0xfd) {
-    [, code] = immed
-    immed = [0xfd, ...uleb(code)]
-    // (v128.load offset? align?)
-    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(parseUint(nodes.shift(), 32))
-    }
-    // (v128.const i32x4 1 2 3 4)
-    else if (code === 0x0c) {
-      let [t, n] = nodes.shift().split('x'),
-        bits = +t.slice(1),
-        stride = bits >>> 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 BigUint64Array(2)
-        for (let i = 0; i < n; i++) {
-          let s = nodes.shift(), v = encode[t].parse(s)
-          arr[i] = v
-        }
-        immed.push(...(new Uint8Array(arr.buffer)))
-      }
-      // f32, f64 - encode
-      else {
-        let arr = new Uint8Array(16)
-        for (let i = 0; i < n; i++) {
-          let s = nodes.shift(), v = encode[t](s)
-          arr.set(v, i * stride)
-        }
-        immed.push(...arr)
-      }
-    }
-    // (i8x16.extract_lane_s 0 ...)
-    else if (code >= 0x15 && code <= 0x22) {
-      immed.push(...uleb(parseUint(nodes.shift())))
+    // Array = unknown instruction passed through from normalize
+    if (Array.isArray(op)) {
+      op.i != null && (err.i = op.i)
+      err(`Unknown instruction ${op[0]}`)
     }
-  }
-
-  // control block abbrs
-  // block ..., loop ..., if ...
-  else if (code === 2 || code === 3 || code === 4) {
-    ctx.block.push(code)
-
-    // (block $x) (loop $y) - save label pointer
-    if (nodes[0]?.[0] === '$') ctx.block[nodes.shift()] = ctx.block.length
-
-    let t = nodes.shift();
-
-    // void
-    if (!t) immed.push(TYPE.void)
-    // (result i32) - doesn't require registering type
-    // FIXME: Make sure it is signed positive integer (leb, not uleb) https://webassembly.github.io/gc/core/binary/instructions.html#control-instructions
-    else if (t[0] === 'result') immed.push(...reftype(t[1], ctx))
-    // (type idx)
-    else immed.push(...uleb(id(t[1], ctx.type)))
-  }
-  // 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)))
-  }
-
-  // global.get $id, global.set $id
-  else if (code == 0x23 || code == 0x24) {
-    immed.push(...uleb(id(nodes.shift(), ctx.global)))
-  }
-
-  // call $func ...nodes
-  // return_call $func
-  else if (code == 0x10 || code == 0x12) {
-    immed.push(...uleb(id(nodes.shift(), ctx.func)))
-  }
-
-  // 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()
+    let [...bytes] = INSTR[op] || err(`Unknown instruction ${op}`)
 
-  // 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) {
-    immed.push(...uleb(blockid(nodes.shift(), ctx.block)))
-  }
-
-  // br_table 1 2 3 4  0  selector result?
-  else if (code == 0x0e) {
-    let args = []
-    while (nodes[0] && (!isNaN(nodes[0]) || nodes[0][0] === '$')) {
-      args.push(...uleb(blockid(nodes.shift(), ctx.block)))
+    // special op handlers
+    if (HANDLER[op]) {
+      // select: becomes typed select (opcode+1) if next node is an array with result types
+      if (op === 'select' && nodes[0]?.length) bytes[0]++
+      // ref.type|cast: opcode+1 if type is nullable: (ref null $t) or (funcref, anyref, etc.)
+      else if (HANDLER[op] === IMM.reftype && (nodes[0][1] === 'null' || nodes[0][0] !== 'ref')) {
+        bytes[bytes.length - 1]++
+      }
+      bytes.push(...HANDLER[op](nodes, ctx, op))
     }
-    args.unshift(...uleb(args.length - 1))
-    immed.push(...args)
-  }
-
-  // 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 => reftype(t, ctx))))
-  }
-
-  // ref.func $id
-  else if (code == 0xd2) {
-    immed.push(...uleb(id(nodes.shift(), ctx.func)))
-  }
-
-  // ref.null func
-  else if (code == 0xd0) {
-    let t = nodes.shift()
-    immed.push(...(HEAPTYPE[t] ? [HEAPTYPE[t]] : uleb(id(t, ctx.type)))) // func->funcref, extern->externref
-  }
-
-  // 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))
-  }
-
-  // i32.const 123, f32.const 123.45
-  else if (code >= 0x41 && code <= 0x44) {
-    immed.push(...encode[op.split('.')[0]](nodes.shift()))
-  }
 
-  // memory.grow|size memidx
-  // https://webassembly.github.io/spec/core/binary/instructions.html#memory-instructions
-  else if (code == 0x3f || code == 0x40) {
-    immed.push(...uleb(id(isImm(nodes[0]) ? nodes.shift() : 0, ctx.memory)))
-  }
+    // Record metadata at current byte position
+    for (const [type, data] of meta) ((ctx.meta[type] ??= []).push([out.length, data]))
 
-  // table.get|set $id
-  else if (code == 0x25 || code == 0x26) {
-    immed.push(...uleb(id(nodes.shift(), ctx.table)))
+    out.push(...bytes)
   }
 
-  // Insert metadata placeholder before instruction in flat form
-  if (ctx._meta) out.push(ctx._meta), ctx._meta = null
-
-  out.push(...immed)
-
-  return out
+  return out.push(0x0b), out
 }
 
-// instantiation time value initializer (consuming) - we redirect to instr
-const expr = (node, ctx) => [...instr([node], ctx), 0x0b]
+// instantiation time value initializer (consuming) - normalize then encode + add end byte
+const expr = (node, ctx) => instr(normalize([node], ctx), ctx)
 
 // deref id node to numeric idx
-const id = (nm, list, n) => (n = nm[0] === '$' ? list[nm] : +nm, n in list ? n : err(`Unknown ${list.name} ${nm}`))
+const id = (nm, list, n) => (n = isId(nm) ? list[nm] : +nm, n in list ? n : err(`Unknown ${list.name} ${nm}`))
 
 // block id - same as id but for block
 // index indicates how many block items to pop
 const blockid = (nm, block, i) => (
-  i = nm?.[0] === '$' ? block.length - block[nm] : +nm,
+  i = isId(nm) ? block.length - block[nm] : +nm,
   isNaN(i) || i > block.length ? err(`Bad label ${nm}`) : i
 )
 
 // consume align/offset params
 const memarg = (args) => {
   let align, offset, k, v
-  while (args[0]?.includes('=')) {
-    [k, v] = args.shift().split('='), v = v.replaceAll('_', '')
-    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}`)
+  while (isMemParam(args[0])) [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]
 }
 
+// Encode memarg (align + offset) with default values based on instruction
+// If memIdx is non-zero, set bit 6 in alignment flags and insert memIdx after align
+const memargEnc = (nodes, op, memIdx = 0) => {
+  const [a, o] = memarg(nodes), alignVal = (a ?? align(op)) | (memIdx && 0x40)
+  return memIdx ? [...uleb(alignVal), ...uleb(memIdx), ...uleb(o ?? 0)] : [...uleb(alignVal), ...uleb(o ?? 0)]
+}
+
 // 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,
@@ -1018,20 +917,43 @@ const memarg = (args) => {
 //   '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)
+  let i = op.indexOf('.', 3) + 1, group = op.slice(1, op[0] === 'v' ? 4 : 3) // type: i32->32, v128->128
+  if (op[i] === 'a') i = op.indexOf('.', i) + 1 // skip 'atomic.'
+  if (op[0] === 'm') return op.includes('64') ? 3 : 2 // memory.*.wait64 vs wait32/notify
+  if (op[i] === 'r') { // rmw: extract size from rmw##
+    let m = op.slice(i, i + 6).match(/\d+/)
+    return m ? Math.log2(m[0] / 8) : Math.log2(+group / 8)
+  }
+  // load/store: extract size after operation name
+  let k = op[i] === 'l' ? i + 4 : i + 5, m = op.slice(k).match(/(\d+)(x|_|$)/)
+  return Math.log2(m ? (m[2] === 'x' ? 8 : m[1] / 8) : +group / 8)
 }
 
 // build limits sequence (consuming)
-const limits = (node) => (
-  isNaN(parseInt(node[1])) ? [0, ...uleb(parseUint(node.shift()))] : [node[2] === 'shared' ? 3 : 1, ...uleb(parseUint(node.shift())), ...uleb(parseUint(node.shift()))]
-)
+// Memory64: i64 index type uses flags 0x04-0x07 (bit 2 = is_64)
+const limits = (node) => {
+  const is64 = node[0] === 'i64' && node.shift()
+  const shared = node[node.length - 1] === 'shared' && node.pop()
+  const hasMax = !isNaN(parseInt(node[1]))
+  const flag = (is64 ? 4 : 0) | (shared ? 2 : 0) | (hasMax ? 1 : 0)
+  // For i64, parse as unsigned BigInt (limits are always unsigned)
+  const parse = is64 ? v => {
+    if (typeof v === 'bigint') return v
+    const str = typeof v === 'string' ? v.replaceAll('_', '') : String(v)
+    return BigInt(str)
+  } : parseUint
+
+  return hasMax
+    ? [flag, ...uleb(parse(node.shift())), ...uleb(parse(node.shift()))]
+    : [flag, ...uleb(parse(node.shift()))]
+}
 
 // check if node is valid int in a range
-// we put extra condition for index ints for tests complacency
-const parseUint = (v, max = 0xFFFFFFFF) => (typeof v === 'string' && v[0] !== '+' ? (typeof max === 'bigint' ? i64 : i32).parse(v) : typeof v === 'number' ? v : err(`Bad int ${v}`)) > max ? err(`Value out of range ${v}`) : v
+const parseUint = (v, max = 0xFFFFFFFF) => {
+  const n = typeof v === 'string' && v[0] !== '+' ? i32.parse(v) : typeof v === 'number' ? v : err(`Bad int ${v}`)
+  return n > max ? err(`Value out of range ${v}`) : n
+}
+
 
 // serialize binary array
 const vec = a => [...uleb(a.length), ...a.flat()]