watr 3.1.0 → 3.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watr",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Ligth & fast WAT compiler",
   "main": "watr.js",
   "exports": {
@@ -42,9 +42,6 @@
   },
   "homepage": "https://github.com/dy/watr#readme",
   "devDependencies": {
-    "tst": "^7.3.0",
-    "wabt": "^1.0.28",
-    "wassemble": "^0.0.2",
-    "wat-compiler": "^1.0.0"
+    "tst": "^8.0.2"
   }
 }

package/readme.md

@@ -1,9 +1,11 @@
-# watr [![test](https://github.com/audio-lab/watr/actions/workflows/test.js.yml/badge.svg)](https://github.com/audio-lab/watr/actions/workflows/test.js.yml) [![npm bundle size](https://img.shields.io/bundlephobia/minzip/watr/latest?color=brightgreen&label=gzip)](https://bundlephobia.com/package/watr) [![npm](https://img.shields.io/npm/v/watr?color=red)](https://npmjs.org/watr)
+# watr [![test](https://github.com/audio-lab/watr/actions/workflows/test.js.yml/badge.svg)](https://github.com/audio-lab/watr/actions/workflows/test.js.yml) [![npm bundle size](https://img.shields.io/bundlephobia/minzip/watr/latest?color=brightgreen&label=gzip)](https://bundlephobia.com/package/watr) [![npm](https://img.shields.io/npm/v/watr?color=white)](https://npmjs.org/watr)
 
-Light & fast WASM compiler. An alternative to [wabt/wat2wasm](https://github.com/AssemblyScript/wabt.js) or [spec/wast]().<br/>
-Useful for high-level languages or dynamic (in-browser) compilation.<br>
+Light & fast WAT compiler.<br/>
+Useful for high-level languages or dynamic (in-browser) compilation.<br/>
 Supports full [spec text syntax](https://webassembly.github.io/spec/core/text/index.html) and [official testsuite](https://github.com/WebAssembly/testsuite).
 
+**[REPL](https://dy.github.io/watr/docs/repl)**
+
 ## Usage
 
 ### Compile
@@ -55,18 +57,19 @@ print(src, {
   indent: '  ',
   newline: '\n',
 })
-// (func (export "double")
-//   (param f64) (result f64)
-//     (f64.mul
-//       (local.get 0)
-//       (f64.const 2)))
+// (func
+//   (export "double")
+//   (param f64)
+//   (result f64)
+//   (f64.mul (local.get 0) (f64.const 2))
+// )
 
 // minify
 print(src, {
   indent: false,
   newline: false
 })
-// (func (export "double")(param f64)(result f64)(f64.mul (local.get 0)(f64.const 2)))
+// (func(export "double")(param f64)(result f64)(f64.mul(local.get 0)(f64.const 2)))
 ```
 
 <!-- See [REPL](https://audio-lab.github.io/watr/repl.html).-->
@@ -74,24 +77,15 @@ print(src, {
 ## Status
 
 * [x] core
-* [x] [mutable globals](https://github.com/WebAssembly/mutable-global)
-* [x] [extended const](https://github.com/WebAssembly/extended-const/blob/main/proposals/extended-const/Overview.md)
-* [x] [nontrapping float to int](https://github.com/WebAssembly/nontrapping-float-to-int-conversions)
-* [x] [sign extension](https://github.com/WebAssembly/sign-extension-ops)
-* [x] [multi-value](https://github.com/WebAssembly/spec/blob/master/proposals/multi-value/Overview.md)
-* [x] [bulk memory ops](https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md)
-* [x] [multiple memories](https://github.com/WebAssembly/multi-memory/blob/master/proposals/multi-memory/Overview.md)
-* [x] [simd](https://github.com/WebAssembly/simd/blob/master/proposals/simd/SIMD.md)
-* [x] [relaxed simd](https://github.com/WebAssembly/relaxed-simd)
-* [x] [fixed-width simd](https://github.com/WebAssembly/simd/blob/master/proposals/simd/SIMD.md)
+* [x] [mutable globals](https://github.com/WebAssembly/mutable-global), [extended const](https://github.com/WebAssembly/extended-const/blob/main/proposals/extended-const/Overview.md), [nontrapping float to int](https://github.com/WebAssembly/nontrapping-float-to-int-conversions), [sign extension](https://github.com/WebAssembly/sign-extension-ops)
+* [x] [multi-value](https://github.com/WebAssembly/spec/blob/master/proposals/multi-value/Overview.md), [bulk memory ops](https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md), [multiple memories](https://github.com/WebAssembly/multi-memory/blob/master/proposals/multi-memory/Overview.md)
+* [x] [simd](https://github.com/WebAssembly/simd/blob/master/proposals/simd/SIMD.md), [relaxed simd](https://github.com/WebAssembly/relaxed-simd), [fixed-width simd](https://github.com/WebAssembly/simd/blob/master/proposals/simd/SIMD.md)
 * [x] [tail_call](https://github.com/WebAssembly/tail-call)
-* [x] [ref types](https://github.com/WebAssembly/reference-types/blob/master/proposals/reference-types/Overview.md)
-* [x] [func refs](https://github.com/WebAssembly/function-references/blob/main/proposals/function-references/Overview.md)
-* [ ] [gc](https://github.com/WebAssembly/gc)
+* [x] [ref types](https://github.com/WebAssembly/reference-types/blob/master/proposals/reference-types/Overview.md), [func refs](https://github.com/WebAssembly/function-references/blob/main/proposals/function-references/Overview.md)
+* [x] [gc](https://github.com/WebAssembly/gc)
 * [ ] [exceptions](https://github.com/WebAssembly/exception-handling)
 * [ ] [memory64](https://github.com/WebAssembly/memory64)
-* [ ] [annotations](https://github.com/WebAssembly/annotations)
-* [ ] [code_metadata](https://github.com/WebAssembly/tool-conventions/blob/main/CodeMetadata.md)
+* [ ] [annotations](https://github.com/WebAssembly/annotations), [code_metadata](https://github.com/WebAssembly/tool-conventions/blob/main/CodeMetadata.md)
 * [ ] [js strings](https://github.com/WebAssembly/js-string-builtins/blob/main/proposals/js-string-builtins/Overview.md)
 
 ## Alternatives

package/src/compile.js

@@ -1,12 +1,13 @@
 import * as encode from './encode.js'
-import { uleb } from './encode.js'
-import { SECTION, TYPE, KIND, INSTR, HEAPTYPE, REFTYPE } from './const.js'
+import { uleb, i32, i64 } from './encode.js'
+import { SECTION, TYPE, KIND, INSTR, HEAPTYPE, DEFTYPE, RECTYPE, REFTYPE } from './const.js'
 import parse from './parse.js'
+import { clone, err } from './util.js'
 
 // build instructions index
-INSTR.forEach((op, i) => INSTR[op] = i >= 0x11a ? [0xfd, i - 0x11a] : i >= 0xfc ? [0xfc, i - 0xfc] : [i]);
+INSTR.forEach((op, i) => INSTR[op] = i >= 0x133 ? [0xfd, i - 0x133] : i >= 0x11b ? [0xfc, i - 0x11b] : i >= 0xfb ? [0xfb, i - 0xfb] : [i]);
+
 
-// console.log(INSTR)
 /**
  * Converts a WebAssembly Text Format (WAT) tree to a WebAssembly binary format (WASM).
  *
@@ -35,25 +36,39 @@ export default function watr(nodes) {
     return watr(nodes.map(i => i.slice(1, -1)).join(''))
   }
 
-  // Scopes are stored directly on section array by key, eg. section.func.$name = idx
-  const sections = []
-  for (let kind in SECTION) (sections[SECTION[kind]] = sections[kind] = []).name = kind
-  sections._ = {} // implicit types
+  // 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._ = {} // implicit types
+
+  let subc // current subtype count
 
-  for (let [kind, ...node] of nodes) {
+  // prepare/normalize nodes
+  while (nodes.length) {
+    let [kind, ...node] = nodes.shift()
     let imported // if node needs to be imported
+    let rec // number of subtypes under rec type
+
+    // (rec (type $a (sub final? $sup* (func ...))...) (type $b ...)) -> save subtypes
+    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
+      if (node.length > 1) rec = subc = node.length, nodes.unshift(...node), node = nodes.shift(), kind = node.shift()
+      else kind = (node = node[0]).shift()
+    }
 
     // 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()
+    else if (kind === 'import') [kind, ...node] = (imported = node).pop()
 
     // index, 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
+    let items = ctx[kind];
+    let name = alias(node, items)
 
     // 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') sections.export.push([node.shift()[1], [kind, idx]])
+    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()
@@ -64,7 +79,7 @@ export default function watr(nodes) {
       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])
+        ctx.elem.push([['table', name || items.length], ['i32.const', '0'], reftype, ...els])
       }
     }
 
@@ -72,39 +87,64 @@ export default function watr(nodes) {
     // (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
-      sections.data.push([['memory', idx], ['i32.const', 0], ...data])
+      ctx.data.push([['memory', items.length], ['i32.const', 0], ...data])
       node = [m, m]
     }
 
     // keep start name
-    else if (kind === 'start') name && node.push(name);
+    else if (kind === 'start') name && node.push(name)
+
+    // normalize type definition to (func|array|struct dfn) form
+    // (type (func param* result*))
+    // (type (array (mut i8)))
+    // (type (struct (field a)*)
+    // (type (sub final? $nm* (struct|array|func ...)))
+    else if (kind === 'type') {
+      let [dfn] = node
+      let issub = subc-- > 0
+      let subkind = issub && 'subfinal', supertypes = []
+      if (dfn[0] === 'sub') {
+        subkind = dfn.shift(), dfn[0] === 'final' && (subkind += dfn.shift())
+        dfn = (supertypes = dfn).pop() // last item is definition
+      }
 
-    // [func, [param, result]] -> [param, result], alias
-    else if (kind === 'type') node[0].shift(), node = paramres(node[0]), sections.type['$' + node.join('>')] ??= idx
+      let ckind = dfn.shift() // composite type kind
+      if (ckind === 'func') dfn = paramres(dfn), ctx.type['$' + dfn.join('>')] ??= ctx.type.length
+      else if (ckind === 'struct') dfn = fieldseq(dfn, 'field', true)
+      else if (ckind === 'array') dfn = dfn.shift()
+
+      node = [ckind, dfn, subkind, supertypes, rec ? [ctx.type.length, rec] : issub]
+    }
 
     // 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
+      let [idx, param, result] = typeuse(node, ctx);
+      idx ?? (ctx._[idx = '$' + param + '>' + result] = [param, result]);
+      // we save idx because type can be defined after
+      !imported && nodes.push(['code', [idx, param, result], ...plain(node, ctx)]) // pass param since they may have names
       node.unshift(['type', idx])
     }
 
     // import writes to import section amd adds placeholder for (kind) section
-    if (imported) sections.import.push([...imported, [kind, ...node]]), node = null
+    if (imported) ctx.import.push([...imported, [kind, ...node]]), node = null
 
-    sections[kind].push(node)
+    items.push(node)
   }
 
   // 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
+  for (let n in ctx._) ctx.type[n] ??= (ctx.type.push(['func', ctx._[n]]) - 1)
 
   // patch datacount if data === 0
-  if (!sections.data.length) sections.datacount.length = 0
+  // FIXME: let's try to return empty in datacount builder, since we filter after builder as well
+  // if (!ctx.data.length) ctx.datacount.length = 0
 
   // convert nodes to bytes
   const bin = (kind, count = true) => {
-    let items = sections[kind].filter(Boolean).map(item => build[kind](item, sections))
+    const items = ctx[kind]
+      .filter(Boolean)  // filter out (type, imported) placeholders
+      .map(item => build[kind](item, ctx))
+      .filter(Boolean)  // filter out unrenderable things (subtype or data.length)
+
     return !items.length ? [] : [kind, ...vec(count ? vec(items) : items)]
   }
 
@@ -128,114 +168,105 @@ export default function watr(nodes) {
   ])
 }
 
+// consume name eg. $t ...
+const alias = (node, list) => {
+  let name = (node[0]?.[0] === '$' || node[0]?.[0] == null) && node.shift();
+  if (name) name in list ? err(`Duplicate ${list.name} ${name}`) : list[name] = list.length; // save alias
+  return name
+}
+
 // 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 = []
+  let out = [], stack = [], label
 
   while (nodes.length) {
     let node = nodes.shift()
 
+    // lookup is slower than sequence of known ifs
     if (typeof node === 'string') {
       out.push(node)
 
-      if (abbr[node]) out.push(...abbr[node](nodes, ctx))
+      // block typeuse?
+      if (node === 'block' || node === 'if' || node === 'loop') {
+        // (loop $l?)
+        if (nodes[0]?.[0] === '$') label = nodes.shift(), out.push(label), stack.push(label)
+
+        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 label ${label}`)
+      }
+
+      // select (result i32 i32 i32)?
+      else if (node === 'select') {
+        out.push(paramres(nodes, 0)[1])
+      }
+
+      // call_indirect $table? $typeidx
+      // return_call_indirect $table? $typeidx
+      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)
+        out.push(tableidx, ['type', idx ?? (ctx._[idx = '$' + param + '>' + result] = [param, result], idx)])
+      }
+
+      // 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
+      }
+
+      // 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())
+
+      // table.* tableidx?
+      else if (node.startsWith('table.')) {
+        out.push(nodes[0]?.[0] === '$' || !isNaN(nodes[0]) ? nodes.shift() : 0)
+
+        // table.copy tableidx? tableidx?
+        if (node === 'table.copy') out.push(nodes[0][0] === '$' || !isNaN(nodes[0]) ? nodes.shift() : 0)
+      }
     }
 
-    // FIXME: try to move this to abbr
     else {
-      node = plain(node, ctx)
-
       // (block ...) -> block ... end
       if (node[0] === 'block' || node[0] === 'loop') {
-        out.push(...node, 'end')
+        out.push(...plain(node, ctx), 'end')
       }
 
       // (if ...) -> if ... end
       else if (node[0] === 'if') {
-        let thenelse = [], blocktype = [node.shift()]
+        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') thenelse.unshift(...node.pop())
-        if (node[node.length - 1]?.[0] === 'then') thenelse.unshift(...node.pop())
+        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)
 
         // label?
-        if (node[0]?.[0] === '$') blocktype.push(node.shift())
+        if (node[0]?.[0] === '$') immed.push(node.shift())
 
-        // blocktype? - (param) are removed already via plain
-        if (node[0]?.[0] === 'type' || node[0]?.[0] === 'result') blocktype.push(node.shift());
+        // blocktype?
+        immed.push(blocktype(node, ctx))
 
-        // ignore empty else
-        // https://webassembly.github.io/spec/core/text/instructions.html#abbreviations
-        if (thenelse[thenelse.length - 1] === 'else') thenelse.pop()
+        if (typeof node[0] === 'string') err('Unfolded condition')
 
-        out.push(...node, ...blocktype, ...thenelse, 'end')
+        out.push(...plain(node, ctx), ...immed, ...then, ...els, 'end')
       }
-      else out.push(node)
+      else out.push(plain(node, ctx))
     }
   }
 
   return out
 }
 
-const abbr = {
-  // block typeuse?
-  block: (nodes, ctx) => {
-    let out = []
-
-    // (loop $l?)
-    if (nodes[0]?.[0] === '$') out.push(nodes.shift())
-
-    let [idx, param, result] = typeuse(nodes, ctx, 0)
-
-    // 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])
-
-    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],
-}
-
 // 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) => {
@@ -248,7 +279,7 @@ const typeuse = (nodes, ctx, names) => {
 
     // 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`)
+      if (ctx.type[id(idx, ctx.type)][1].join('>') !== param + '>' + result) err(`Type ${idx} mismatch`)
 
     return [idx]
   }
@@ -261,54 +292,111 @@ const typeuse = (nodes, ctx, names) => {
 
 // consume (param t+)* (result t+)* sequence
 const paramres = (nodes, names = true) => {
-  let param = [], result = []
+  // let param = [], result = []
 
   // collect param (param i32 i64) (param $x? i32)
-  while (nodes[0]?.[0] === 'param') {
+  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()
-    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)
+    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
+}
 
-  // 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)
-  }
+// consume blocktype - makes sure either type or single result is returned
+const blocktype = (nodes, ctx) => {
+  let [idx, param, result] = typeuse(nodes, ctx, 0)
 
-  if (nodes[0]?.[0] === 'param') err(`Unexpected param`)
+  // direct idx (no params/result needed)
+  if (idx != null) return ['type', idx]
 
-  return [param, result]
+  // 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]
+
+  // (param i32 i32)? (result i32 i32) - implicit type
+  ctx._[idx = '$' + param + '>' + result] = [param, result]
+  return ['type', idx]
 }
 
+
 // 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)))]),
+  // type kinds
+  // (func params result)
+  // (array i8)
+  // (struct ...fields)
+  ([kind, fields, subkind, supertypes, rec], ctx) => {
+    if (rec === true) return // ignore rec subtypes cept for 1st one
+
+    let details
+    // (rec (sub ...)*)
+    if (rec) {
+      // FIXME: rec of one type
+      kind = 'rec'
+      let [from, length] = rec, subtypes = Array.from({ length }, (_, i) => build[SECTION.type](ctx.type[from + i].slice(0, 4), ctx))
+      details = vec(subtypes)
+    }
+    // (sub final? sups* (type...))
+    else if (subkind === 'sub' || supertypes?.length) {
+      details = [...vec(supertypes.map(n => id(n, ctx.type))), ...build[SECTION.type]([kind, fields], ctx)]
+      kind = subkind
+    }
+
+    else if (kind === 'func') {
+      details = [...vec(fields[0].map(t => reftype(t, ctx))), ...vec(fields[1].map(t => reftype(t, ctx)))]
+    }
+    else if (kind === 'array') {
+      details = fieldtype(fields, ctx)
+    }
+    else if (kind === 'struct') {
+      details = vec(fields.map(t => fieldtype(t, ctx)))
+    }
+
+    return [DEFTYPE[kind], ...details]
+  },
 
   // (import "math" "add" (func|table|global|memory typedef?))
   ([mod, field, [kind, ...dfn]], ctx) => {
     let details
 
-    if (kind[0] === 'f') {
+    if (kind === 'func') {
       // 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') {
+    else if (kind === 'memory') {
       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 === 'global') {
+      details = fieldtype(dfn[0], ctx)
     }
-    else if (kind[0] === 't') {
-      details = [...type(dfn.pop(), ctx), ...limits(dfn)]
+    else if (kind === 'table') {
+      details = [...reftype(dfn.pop(), ctx), ...limits(dfn)]
     }
+    else err(`Unknown kind ${kind}`)
 
     return ([...vec(str(mod.slice(1, -1))), ...vec(str(field.slice(1, -1))), KIND[kind], ...details])
   },
@@ -318,20 +406,15 @@ const build = [,
 
   // (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]
+    let lims = limits(node), t = reftype(node.shift(), ctx), [init] = node
+    return init ? [0x40, 0x00, ...t, ...lims, ...expr(init, ctx)] : [...t, ...lims]
   },
 
   // (memory id? export* min max shared)
   (node, ctx) => limits(node),
 
   // (global $id? (mut i32) (i32.const 42))
-  (node, ctx) => {
-    let [t] = node, mut = t[0] === 'mut' ? 1 : 0
-
-    let [, init] = node
-    return ([...type(mut ? t[1] : t, ctx), mut, ...expr(init, ctx)])
-  },
+  ([t, init], ctx) => [...fieldtype(t, ctx), ...expr(init, ctx)],
 
   //  (export "name" (func|table|mem $name|idx))
   ([nm, [kind, l]], ctx) => ([...vec(str(nm.slice(1, -1))), KIND[kind], ...uleb(id(l, ctx[kind]))]),
@@ -342,74 +425,77 @@ const build = [,
   // (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
   (parts, ctx) => {
-    let tabidx, offset, mode = 0b000, reftype
+    let passive = 0, declare = 0, elexpr = 0, nofunc = 0, tabidx, offset, rt
 
     // declare?
-    if (parts[0] === 'declare') parts.shift(), mode |= 0b010
+    if (parts[0] === 'declare') parts.shift(), declare = 1
 
     // table?
     if (parts[0][0] === 'table') {
       [, tabidx] = parts.shift()
       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 = expr(offset, ctx)
     }
-    else mode |= 0b001 // passive
-
-    // 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()
+    // no offset = passive
+    else if (!declare) passive = 1
 
-    // legacy abbr if func is skipped
-    if (!reftype) !tabidx ? reftype = 'funcref' : err(`Undefined reftype`)
+    // funcref|externref|(ref ...)
+    if (REFTYPE[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()]]
+    // or anything else
+    else rt = [HEAPTYPE.func]
 
-    // 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
-    else if (!parts.length) mode &= 0b011
-
-    // simplify els sequence
+    // deabbr els sequence, detect expr usage
     parts = parts.map(el => {
       if (el[0] === 'item') [, ...el] = el
       if (el[0] === 'ref.func') [, el] = el
-      // (ref.null func) and other expressions turn expr init mode
-      if (typeof el !== 'string') mode |= 0b100
+      // (ref.null func) and other expressions turn expr els mode
+      if (typeof el !== 'string') elexpr = 1
       return el
     })
 
+    // 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
+
+    // mode:
+    // bit 0 indicates a passive or declarative segment
+    // bit 1 indicates the presence of an explicit table index for an active segment
+    // and otherwise distinguishes passive from declarative segments
+    // bit 2 indicates the use of element type and element expressions instead of elemkind=0x00 and element indices.
+    let mode = (elexpr << 2) | ((passive || declare ? declare : (!!tabidx || nofunc)) << 1) | (passive || declare);
+
     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) :
+        // 0b000 e:expr y*:vec(funcidx)                     | type=(ref func), init ((ref.func y)end)*, active (table=0,offset=e)
+        mode === 0b000 ? offset :
           // 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, ctx), 0x00] :
+            mode === 0b010 ? [...uleb(tabidx || 0), ...offset, 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) :
+                // 0b100 e:expr el*:vec(expr)                       | type=(ref null func), init el*, active (table=0, offset=e)
+                mode === 0b100 ? offset :
                   // 0b101 et:reftype el*:vec(expr)                   | type=et, init el*, passive
-                  mode === 0b101 ? type(reftype, ctx) :
+                  mode === 0b101 ? rt :
                     // 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, ctx), ...type(reftype, ctx)] :
+                    mode === 0b110 ? [...uleb(tabidx || 0), ...offset, ...rt] :
                       // 0b111 et:reftype el*:vec(expr)                   | type=et, init el*, passive declare
-                      type(reftype, ctx)
+                      rt
       ),
       ...vec(
-        parts.map(mode & 0b100 ?
+        parts.map(elexpr ?
           // ((ref.func y)end)*
           el => expr(typeof el === 'string' ? ['ref.func', el] : el, ctx) :
           // el*
@@ -422,7 +508,7 @@ const build = [,
   // (code)
   (body, ctx) => {
     let [typeidx, param] = body.shift()
-    if (!param) [param] = ctx.type[id(typeidx, ctx.type)]
+    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
@@ -435,7 +521,11 @@ const build = [,
     // collect locals
     while (body[0]?.[0] === 'local') {
       let [, ...types] = body.shift()
-      if (types[0]?.[0] === '$') ctx.local[types.shift()] = ctx.local.length
+      if (types[0]?.[0] === '$') {
+        let name = types.shift()
+        if (name in ctx.local) err(`Duplicate local ${name}`)
+        else ctx.local[name] = ctx.local.length
+      }
       ctx.local.push(...types)
     }
 
@@ -451,7 +541,7 @@ const build = [,
     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])
+    return vec([...vec(loctypes.map(([n, t]) => [...uleb(n), ...reftype(t, ctx)])), ...bytes])
   },
 
   // (data (i32.const 0) "\aa" "\bb"?)
@@ -490,10 +580,20 @@ const build = [,
   (nodes, ctx) => uleb(ctx.data.length)
 ]
 
-// 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}`)]
+// build reftype, either direct absheaptype or wrapped heaptype 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))] :
+    // abbrs
+    [TYPE[t] ?? err(`Unknown type ${t}`)]
+);
+
+// build type with mutable flag (mut t) or t
+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) => {
@@ -512,50 +612,43 @@ const instr = (nodes, ctx) => {
   [...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) {
+  // gc-related
+  // https://webassembly.github.io/gc/core/binary/instructions.html#reference-instructions
+  if (code === 0x0fb) {
     [, 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))
+
+    // 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(nodes.shift(), 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)))
     }
-    // (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()))
+    // ref.test|cast (ref null? $t|heaptype)
+    else if (code >= 20 && code <= 23) {
+      // FIXME: normalizer is supposed to resolve this
+      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)
     }
-    // (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()))
+    // br_on_cast[_fail] $l? (ref null? ht1) (ref null? ht2)
+    // FIXME: normalizer should resolve anyref|etc to (ref null any|etc)
+    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
     }
   }
 
@@ -592,24 +685,82 @@ const instr = (nodes, ctx) => {
     }
   }
 
+  // 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())))
+    }
+  }
+
   // control block abbrs
   // block ..., loop ..., if ...
   else if (code === 2 || code === 3 || code === 4) {
     ctx.block.push(code)
 
-    // (block $x) (loop $y)
+    // (block $x) (loop $y) - save label pointer
+    // FIXME: do in normalizer
     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]]] : []
+    let t = nodes.shift();
 
     // void
-    if (!param?.length && !result?.length) immed.push(TYPE.void)
+    if (!t) 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))
+    // 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))
+    else {
+      let typeidx = id(t[1], ctx.type), [param, result] = ctx.type[typeidx][1]
+      // (type $idx (func (result i32)))
+      if (!param?.length && result.length === 1) immed.push(...reftype(result[0], ctx))
+      // (type idx)
+      else immed.push(...uleb(typeidx))
+    }
   }
   // else
   else if (code === 5) { }
@@ -638,7 +789,8 @@ const instr = (nodes, ctx) => {
     immed.push(
       ...uleb(id(nodes[1][1], ctx.type)),
       ...uleb(id(nodes.shift(), ctx.table))
-    ), nodes.shift()
+    )
+    nodes.shift()
   }
 
   // call_ref $type
@@ -654,19 +806,14 @@ const instr = (nodes, ctx) => {
   // 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))
+    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] === '$')) {
-      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.push(...uleb(blockid(nodes.shift(), ctx.block)))
     }
     args.unshift(...uleb(args.length - 1))
     immed.push(...args)
@@ -676,7 +823,7 @@ const instr = (nodes, ctx) => {
   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))))
+    if (result.length) immed.push(immed.pop() + 1, ...vec(result.map(t => reftype(t, ctx))))
   }
 
   // ref.func $id
@@ -687,7 +834,7 @@ const instr = (nodes, ctx) => {
   // ref.null func
   else if (code == 0xd0) {
     let t = nodes.shift()
-    immed.push(HEAPTYPE[t] || id(t, ctx.type)) // func->funcref, extern->externref
+    immed.push(...(HEAPTYPE[t] ? [HEAPTYPE[t]] : uleb(id(t, ctx.type)))) // func->funcref, extern->externref
   }
 
   // binary/unary (i32.add a b) - no immed
@@ -710,7 +857,7 @@ const instr = (nodes, ctx) => {
     immed.push(0)
   }
 
-  // table.get $id
+  // table.get|set $id
   else if (code == 0x25 || code == 0x26) {
     immed.push(...uleb(id(nodes.shift(), ctx.table)))
   }
@@ -723,6 +870,16 @@ const instr = (nodes, ctx) => {
 // instantiation time value initializer (consuming) - we redirect to instr
 const expr = (node, ctx) => [...instr([node], ctx), 0x0b]
 
+// 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}`))
+
+// 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,
+  isNaN(i) || i > block.length ? err(`Bad label ${nm}`) : i
+)
+
 // consume align/offset params
 const memarg = (args) => {
   let align, offset, k, v
@@ -734,10 +891,6 @@ const memarg = (args) => {
   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,
@@ -754,7 +907,14 @@ const align = (op) => {
 }
 
 // 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())]
+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()))]
+)
+
+// 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
+
 
 // escape codes
 const escape = { n: 10, r: 13, t: 9, v: 1, '"': 34, "'": 39, '\\': 92 }
@@ -772,7 +932,3 @@ const str = str => {
 
 // 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)

package/src/const.js

@@ -1,8 +1,8 @@
 // https://webassembly.github.io/spec/core/appendix/index-instructions.html
 export const INSTR = [
   'unreachable', 'nop', 'block', 'loop', 'if', 'else', 'then', , , , ,
-  'end', 'br', 'br_if', 'br_table', 'return', 'call', 'call_indirect', 'return_call', 'return_call_indirect','call_ref' ,'return_call_ref' , , , , ,
-  'drop', 'select', 'select2', , , ,
+  'end', 'br', 'br_if', 'br_table', 'return', 'call', 'call_indirect', 'return_call', 'return_call_indirect', 'call_ref', 'return_call_ref', , , , ,
+  'drop', 'select', '', , , ,
   'local.get', 'local.set', 'local.tee', 'global.get', 'global.set', 'table.get', 'table.set', ,
   'i32.load', 'i64.load', 'f32.load', 'f64.load',
   'i32.load8_s', 'i32.load8_u', 'i32.load16_s', 'i32.load16_u',
@@ -26,14 +26,17 @@ export const INSTR = [
   'f64.convert_i32_s', 'f64.convert_i32_u', 'f64.convert_i64_s', 'f64.convert_i64_u', 'f64.promote_f32',
   'i32.reinterpret_f32', 'i64.reinterpret_f64', 'f32.reinterpret_i32', 'f64.reinterpret_i64',
   'i32.extend8_s', 'i32.extend16_s', 'i64.extend8_s', 'i64.extend16_s', 'i64.extend32_s', , , , , , , , , , , ,
-  'ref.null', 'ref.is_null', 'ref.func', ,'ref.as_non_null' ,'br_on_null' ,'br_on_non_null' , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,
+  'ref.null', 'ref.is_null', 'ref.func', 'ref.eq', 'ref.as_non_null', 'br_on_null', 'br_on_non_null', , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,
 
-  // 0xFC 0xNN (0xfc shift)
+  // 0xFB 0xNN (0xFB shift)
+  'struct.new', 'struct.new_default', 'struct.get', 'struct.get_s', 'struct.get_u', 'struct.set', 'array.new', 'array.new_default', 'array.new_fixed', 'array.new_data', 'array.new_elem', 'array.get', 'array.get_s', 'array.get_u', 'array.set', 'array.len', 'array.fill', 'array.copy', 'array.init_data', 'array.init_elem', 'ref.test', '', 'ref.cast', '', 'br_on_cast', 'br_on_cast_fail', 'any.convert_extern', 'extern.convert_any', 'ref.i31', 'i31.get_s', 'i31.get_u', ,
+
+  // 0xFC 0xNN (0x11b shift)
   'i32.trunc_sat_f32_s', 'i32.trunc_sat_f32_u', 'i32.trunc_sat_f64_s', 'i32.trunc_sat_f64_u', 'i64.trunc_sat_f32_s', 'i64.trunc_sat_f32_u', 'i64.trunc_sat_f64_s', 'i64.trunc_sat_f64_u',
   'memory.init', 'data.drop', 'memory.copy', 'memory.fill', 'table.init', 'elem.drop', 'table.copy', 'table.grow', 'table.size', 'table.fill', ,
-  'i64.add128', 'i64.sub128', 'i64.mul_wide_s', 'i64.mul_wide_u', , , , , , , ,
+  'i64.add128', 'i64.sub128', 'i64.mul_wide_s', 'i64.mul_wide_u', ,
 
-  // 0xFD 0xNN (0x10f shift)
+  // 0xFD 0xNN (0x133 shift)
   'v128.load', 'v128.load8x8_s', 'v128.load8x8_u', 'v128.load16x4_s', 'v128.load16x4_u', 'v128.load32x2_s', 'v128.load32x2_u', 'v128.load8_splat', 'v128.load16_splat', 'v128.load32_splat', 'v128.load64_splat', 'v128.store', 'v128.const', 'i8x16.shuffle',
   'i8x16.swizzle', 'i8x16.splat', 'i16x8.splat', 'i32x4.splat', 'i64x2.splat', 'f32x4.splat', 'f64x2.splat',
   'i8x16.extract_lane_s', 'i8x16.extract_lane_u', 'i8x16.replace_lane', 'i16x8.extract_lane_s', 'i16x8.extract_lane_u', 'i16x8.replace_lane', 'i32x4.extract_lane', 'i32x4.replace_lane', 'i64x2.extract_lane', 'i64x2.replace_lane', 'f32x4.extract_lane', 'f32x4.replace_lane', 'f64x2.extract_lane', 'f64x2.replace_lane',
@@ -47,7 +50,24 @@ export const INSTR = [
   'i8x16.relaxed_swizzle', 'i32x4.relaxed_trunc_f32x4_s', 'i32x4.relaxed_trunc_f32x4_u', 'i32x4.relaxed_trunc_f64x2_s_zero', 'i32x4.relaxed_trunc_f64x2_u_zero', 'f32x4.relaxed_madd', 'f32x4.relaxed_nmadd', 'f64x2.relaxed_madd', 'f64x2.relaxed_nmadd', 'i8x16.relaxed_laneselect', 'i16x8.relaxed_laneselect', 'i32x4.relaxed_laneselect', 'i64x2.relaxed_laneselect', 'f32x4.relaxed_min', 'f32x4.relaxed_max', 'f64x2.relaxed_min', 'f64x2.relaxed_max', 'i16x8.relaxed_q15mulr_s', 'i16x8.relaxed_dot_i8x16_i7x16_s', 'i32x4.relaxed_dot_i8x16_i7x16_add_s'
 ],
   SECTION = { custom: 0, type: 1, import: 2, func: 3, table: 4, memory: 5, global: 6, export: 7, start: 8, elem: 9, datacount: 12, code: 10, data: 11 },
-  HEAPTYPE = {func: 0x70, extern: 0x6F},
-  REFTYPE = {funcref: 0x70 /* -0x10 */, externref: 0x6F /* -0x11 */, ref: 0x64 /* -0x1c */, refnull: 0x63 /* -0x1d */},
-  TYPE = { i32: 0x7f, i64: 0x7e, f32: 0x7d, f64: 0x7c, void: 0x40, v128: 0x7B, ...HEAPTYPE, ...REFTYPE },
+  RECTYPE = { sub: 0x50, subfinal: 0x4F, rec: 0x4E },
+  DEFTYPE = { func: 0x60, struct: 0x5F, array: 0x5E, ...RECTYPE },
+  HEAPTYPE = { nofunc: 0x73, noextern: 0x72, none: 0x71, func: 0x70, extern: 0x6F, any: 0x6E, eq: 0x6D, i31: 0x6C, struct: 0x6B, array: 0x6A },
+  REFTYPE = {
+    // absheaptype abbrs
+    nullfuncref: HEAPTYPE.nofunc,
+    nullexternref: HEAPTYPE.noextern,
+    nullref: HEAPTYPE.none,
+    funcref: HEAPTYPE.func,
+    externref: HEAPTYPE.extern,
+    anyref: HEAPTYPE.any,
+    eqref: HEAPTYPE.eq,
+    i31ref: HEAPTYPE.i31,
+    structref: HEAPTYPE.struct,
+    arrayref: HEAPTYPE.array,
+
+    // ref, refnull
+    ref: 0x64 /* -0x1c */, refnull: 0x63 /* -0x1d */
+  },
+  TYPE = { i8: 0x78, i16: 0x77, i32: 0x7f, i64: 0x7e, f32: 0x7d, f64: 0x7c, void: 0x40, v128: 0x7B, ...HEAPTYPE, ...REFTYPE },
   KIND = { func: 0, table: 1, memory: 2, global: 3 }

package/src/encode.js

@@ -1,3 +1,5 @@
+import { err, intRE, sepRE } from './util.js'
+
 // encoding ref: https://github.com/j-s-n/WebBS/blob/master/compiler/byteCode.js
 
 // uleb
@@ -48,11 +50,13 @@ export function i32(n, buffer = []) {
   return buffer
 }
 
+// for tests complacency we check format
+const cleanInt = (v) => (!sepRE.test(v) && intRE.test(v=v.replaceAll('_',''))) ? v : err(`Bad int ${v}`)
 
 // alias
 export const i8 = i32, i16 = i32
 
-i32.parse = n => parseInt(n.replaceAll('_', ''))
+i32.parse = n => parseInt(cleanInt(n))
 
 // bigleb
 export function i64(n, buffer = []) {
@@ -70,10 +74,10 @@ export function i64(n, buffer = []) {
   return buffer
 }
 i64.parse = n => {
-  n = n.replaceAll('_', '')
-  n = n[0] === '-' ? -BigInt(n.slice(1)) : BigInt(n)
+  n = cleanInt(n)
+  n = n[0] === '-' ? -BigInt(n.slice(1)) : BigInt(n) // can be -0x123
   byteView.setBigInt64(0, n)
-  return n = byteView.getBigInt64(0)
+  return byteView.getBigInt64(0)
 }
 
 const byteView = new DataView(new Float64Array(1).buffer)

package/src/print.js

@@ -1,69 +1,57 @@
 import parse from './parse.js';
 
-let indent = '', newline = '\n'
 
 /**
- * Formats a tree or a WAT string.
+ * Formats a tree or a WAT (WebAssembly Text) string into a readable format.
  *
- * @param {string | Array} tree - The code to print. If a string is provided, it will be parsed first.
- * @param {Object} [options] - Printing options.
- * @param {string} [options.indent='  '] - The string used for one level of indentation.
- * @param {string} [options.newline='\n'] - The string used for line breaks.
+ * @param {string | Array} tree - The code to print. If a string is provided, it will be parsed into a tree structure first.
+ * @param {Object} [options={}] - Optional settings for printing.
+ * @param {string} [options.indent='  '] - The string used for one level of indentation. Defaults to two spaces.
+ * @param {string} [options.newline='\n'] - The string used for line breaks. Defaults to a newline character.
  * @returns {string} The formatted WAT string.
  */
 export default function print(tree, options = {}) {
   if (typeof tree === 'string') tree = parse(tree);
 
-  ({ indent='  ', newline='\n' } = options);
-  indent ||= '', newline ||= '';
+  let { indent='  ', newline='\n' } = options;
+  indent ||= '', newline ||= ''; // false -> str
 
   return typeof tree[0] === 'string' ? printNode(tree) : tree.map(node => printNode(node)).join(newline)
-}
 
-const INLINE = [
-  'param',
-  'local',
-  'drop',
-  'f32.const',
-  'f64.const',
-  'i32.const',
-  'i64.const',
-  'local.get',
-  'global.get',
-  'memory.size',
-  'result',
-  'export',
-  'unreachable',
-  'nop'
-]
+  function printNode(node, level = 0) {
+    if (!Array.isArray(node)) return node
 
-function printNode(node, level = 0) {
-  if (!Array.isArray(node)) return node + ''
+    let content = node[0]
 
-  let content = node[0]
+    // flat node (no deep subnodes), eg. (i32.const 1), (module (export "") 1)
+    let flat = !!newline && node.length < 4
+    let curIndent = indent.repeat(level + 1)
 
-  for (let i = 1; i < node.length; i++) {
-    // new node doesn't need space separator, eg. [x,[y]] -> `x(y)`
-    if (Array.isArray(node[i])) {
-      // inline nodes like (param x)(param y)
-      // (func (export "xxx")..., but not (func (export "a")(param "b")...
+    for (let i = 1; i < node.length; i++) {
+      // (<keyword> ...)
+      if (Array.isArray(node[i])) {
+        // check if it's still flat
+        if (flat) flat = node[i].every(subnode => !Array.isArray(subnode))
 
-      if (
-        INLINE.includes(node[i][0]) &&
-        (!Array.isArray(node[i - 1]) || INLINE.includes(node[i - 1][0]))
-      ) {
-        if (!Array.isArray(node[i - 1])) content += ` `
-      } else {
-        content += newline
-        if (node[i]) content += indent.repeat(level + 1)
+        // new line
+        content += newline + curIndent + printNode(node[i], level + 1)
+      }
+      // data chunks "\00..."
+      else if (node[0] === 'data')   {
+        flat = false;
+        if (newline || content[content.length-1] !== ')') content += newline || ' '
+        content += curIndent + node[i]
+      }
+      // inline nodes
+      else {
+        if (newline || content[content.length-1] !== ')') content += ' '
+        content += node[i]
       }
-
-      content += printNode(node[i], level + 1)
-    }
-    else {
-      content += ` `
-      content += node[i]
     }
+
+    // shrink unnecessary spaces
+    if (flat) return `(${content.replaceAll(newline + curIndent + '(', ' (')})`
+
+    return `(${content + newline + indent.repeat(level)})`
   }
-  return `(${content})`
 }

package/src/util.js

@@ -0,0 +1,8 @@
+
+export const err = text => { throw Error(text) }
+
+export const clone = items => items.map(item => Array.isArray(item) ? clone(item) : item)
+
+export const sepRE = /^_|_$|[^\da-f]_|_[^\da-f]/i
+
+export const intRE = /^[+-]?(?:0x[\da-f]+|\d+)$/i