watr 4.2.0 → 4.3.0

package/src/compile.js

@@ -7,7 +7,7 @@ import { err, unescape, str } from './util.js'
 
 /**
  * Clean up AST: remove comments, normalize quoted ids, convert strings to bytes.
- * Preserves @custom and @metadata.code.* annotations. Preserves .i for error reporting.
+ * Preserves @custom and @metadata.code.* annotations. Preserves .loc for error reporting.
  *
  * @param {any} node - AST node
  * @param {Array} [result] - Internal accumulator
@@ -25,8 +25,8 @@ const cleanup = (node, result) => !Array.isArray(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)
+  // unwrap single-element array containing module (after removing comments), preserve .loc
+  (result = node.map(cleanup).filter(n => n != null), result.loc = node.loc, result.length === 1 && result[0]?.[0] === 'module' ? result[0] : result)
 
 
 /**
@@ -39,7 +39,7 @@ export default function compile(nodes) {
   // normalize to (module ...) form
   if (typeof nodes === 'string') err.src = nodes, nodes = parse(nodes) || []
   else err.src = '' // clear source if AST passed directly
-  err.i = 0
+  err.loc = 0
 
   nodes = cleanup(nodes) || []
 
@@ -56,6 +56,20 @@ export default function compile(nodes) {
   // quote "a" "b"
   if (nodes[idx] === 'quote') return compile(nodes.slice(++idx).map(v => v.valueOf().slice(1, -1)).flat().join(''))
 
+  // expand grouped imports: (import "mod" (item "name" type)*) -> individual imports
+  // compact import section (Phase 3)
+  nodes = nodes.flatMap((n, i) => {
+    if (i < idx || !Array.isArray(n) || n[0] !== 'import') return [n]
+    const [, mod, ...rest] = n
+    if (!rest.some(r => Array.isArray(r) && r[0] === 'item')) return [n]
+    const lastIsType = Array.isArray(rest.at(-1)) && rest.at(-1)[0] !== 'item'
+    if (lastIsType) {
+      const type = rest.at(-1)
+      return rest.slice(0, -1).filter(r => r[0] === 'item').map(([, nm]) => ['import', mod, nm, type])
+    }
+    return rest.filter(r => r[0] === 'item').map(([, nm, type]) => ['import', mod, nm, type])
+  })
+
   // 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
@@ -64,12 +78,22 @@ export default function compile(nodes) {
   // initialize types
   nodes.slice(idx).filter((n) => {
     if (!Array.isArray(n)) {
-      let pos = err.src?.indexOf(n, err.i)
-      if (pos >= 0) err.i = pos
+      // find token as standalone word (not substring of another token)
+      let pos = err.loc, src = err.src, c
+      while ((pos = src.indexOf(n, pos)) >= 0) {
+        c = src.charCodeAt(pos - 1)
+        // check not preceded by word char or $
+        if (pos > 0 && (c > 47 && c < 58 || c > 64 && c < 91 || c > 96 && c < 123 || c === 95 || c === 36)) { pos++; continue }
+        c = src.charCodeAt(pos + n.length)
+        // check not followed by word char
+        if (c > 47 && c < 58 || c > 64 && c < 91 || c > 96 && c < 123 || c === 95) { pos++; continue }
+        break
+      }
+      if (pos >= 0) err.loc = pos
       err(`Unexpected token ${n}`)
     }
     let [kind, ...node] = n
-    err.i = n.i // track position for errors
+    err.loc = n.loc // track position for errors
     // (@custom "name" placement? data) - custom section support
     if (kind === '@custom') {
       ctx.custom.push(node)
@@ -81,8 +105,12 @@ export default function compile(nodes) {
       // add rest of subtypes as regular type nodes with subtype flag
       for (let i = 0; i < node.length; i++) {
         let [, ...subnode] = node[i]
-        name(subnode, ctx.type);
-        (subnode = typedef(subnode, ctx)).push(i ? true : [ctx.type.length, node.length])
+        name(subnode, ctx.type)
+        // extract top-level descriptor/describes (custom descriptors, Phase 3)
+        const tdesc = []
+        while (subnode[0]?.[0] === 'descriptor' || subnode[0]?.[0] === 'describes') tdesc.push(subnode.shift())
+        ;(subnode = typedef(subnode, ctx)).push(i ? true : [ctx.type.length, node.length])
+        if (tdesc.length) subnode.desc = subnode.desc ? [...tdesc, ...subnode.desc] : tdesc
         ctx.type.push(subnode)
       }
     }
@@ -91,8 +119,13 @@ export default function compile(nodes) {
     // (type (struct (field a)*)
     // (type (sub final? $nm* (struct|array|func ...)))
     else if (kind === 'type') {
-      name(node, ctx.type);
-      ctx.type.push(typedef(node, ctx));
+      name(node, ctx.type)
+      // extract top-level descriptor/describes (custom descriptors, Phase 3)
+      const tdesc = []
+      while (node[0]?.[0] === 'descriptor' || node[0]?.[0] === 'describes') tdesc.push(node.shift())
+      const td = typedef(node, ctx)
+      if (tdesc.length) td.desc = td.desc ? [...tdesc, ...td.desc] : tdesc
+      ctx.type.push(td)
     }
     // other sections may have id
     else if (kind === 'start' || kind === 'export') ctx[kind].push(node)
@@ -103,7 +136,7 @@ export default function compile(nodes) {
     // prepare/normalize nodes
     .forEach((n) => {
       let [kind, ...node] = n
-      err.i = n.i // track position for errors
+      err.loc = n.loc // track position for errors
       let imported // if node needs to be imported
 
       // import abbr
@@ -136,7 +169,8 @@ export default function compile(nodes) {
       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)
+          const ps = (node.find(n => Array.isArray(n) && n[0] === 'pagesize')?.[1]) ?? 65536
+          let [, ...data] = node.splice(idx, 1)[0], m = '' + Math.ceil(data.reduce((s, d) => s + d.length, 0) / ps)
           ctx.data.push([['memory', items.length], [is64 ? 'i64.const' : 'i32.const', is64 ? 0n : 0], ...data])
           node = is64 ? ['i64', m, m] : [m, m]
         }
@@ -266,7 +300,7 @@ function normalize(nodes, ctx) {
     }
     else if (Array.isArray(node)) {
       const op = node[0]
-      node.i != null && (err.i = node.i) // track position for errors
+      node.loc != null && (err.loc = node.loc) // track position for errors
 
       // code metadata annotations - pass through as marker with metadata type and data
       // (@metadata.code.<type> data:str)
@@ -308,7 +342,7 @@ function normalize(nodes, ctx) {
       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())
+        while (parts.length && (!Array.isArray(parts[0]) || 'type,param,result,ref,exact,on'.includes(parts[0][0]))) imm.push(parts.shift())
         out.push(...normalize(parts, ctx), op, ...imm)
         nodes.unshift(...out.splice(out.length - 1 - imm.length))
       }
@@ -408,18 +442,20 @@ const name = (node, list) => {
 }
 
 /**
- * Parse type definition: func, array, struct, or sub(type).
- * Handles recursive types and subtyping.
+ * Parse type definition: func, array, struct, cont, or sub(type).
+ * Handles recursive types, subtyping, and custom descriptor clauses (Phase 3).
  *
- * @param {Array} node - [definition] where definition is func/array/struct/sub
+ * @param {Array} node - [definition] where definition is func/array/struct/cont/sub
  * @param {Object} ctx - Compilation context
- * @returns {[string, any, string, string[]]} [kind, fields, subkind, supertypes]
+ * @returns {Array} [kind, fields, subkind, supertypes] with optional .desc property
  */
 const typedef = ([dfn], ctx) => {
-  let subkind = 'subfinal', supertypes = [], compkind
+  let subkind = 'subfinal', supertypes = [], compkind, desc = []
   if (dfn[0] === 'sub') {
     subkind = dfn.shift(), dfn[0] === 'final' && (subkind += dfn.shift())
     dfn = (supertypes = dfn).pop() // last item is definition
+    // extract descriptor/describes from supertypes (custom descriptors, Phase 3)
+    supertypes = supertypes.filter(n => Array.isArray(n) && (n[0] === 'descriptor' || n[0] === 'describes') ? (desc.push(n), false) : true)
   }
 
   [compkind, ...dfn] = dfn // composite type kind
@@ -427,8 +463,11 @@ const typedef = ([dfn], ctx) => {
   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
+  // cont type: (cont $ft) - continuation wrapping function type (stack switching, Phase 3)
 
-  return [compkind, dfn, subkind, supertypes]
+  const result = [compkind, dfn, subkind, supertypes]
+  if (desc.length) result.desc = desc
+  return result
 }
 
 
@@ -450,40 +489,50 @@ const build = [
   // (func params result)
   // (array i8)
   // (struct ...fields)
-  ([kind, fields, subkind, supertypes, rec], ctx) => {
+  // (cont $ft) - stack switching (Phase 3)
+  (node, ctx) => {
+    const [kind, fields, subkind, supertypes, rec] = node
     if (rec === true) return // ignore rec subtypes cept for 1st one
 
-    let details
+    // descriptor/describes prefix bytes (custom descriptors, Phase 3)
+    const descPfx = (node.desc ?? []).flatMap(([clause, ref]) =>
+      [clause === 'descriptor' ? 0x4D : 0x4C, ...uleb(id(ref, ctx.type))])
+
+    // build comptype bytes without sub wrapper or descriptor prefix
+    const comptype = (k, f) => {
+      if (k === 'func') return [DEFTYPE.func, ...vec(f[0].map(t => reftype(t, ctx))), ...vec(f[1].map(t => reftype(t, ctx)))]
+      if (k === 'array') return [DEFTYPE.array, ...fieldtype(f, ctx)]
+      if (k === 'struct') return [DEFTYPE.struct, ...vec(f.map(t => fieldtype(t, ctx)))]
+      if (k === 'cont') return [DEFTYPE.cont, ...uleb(id(f[0] ?? f, ctx.type))]
+      return [DEFTYPE[k]]
+    }
+
     // (rec (sub ...)*)
     if (rec) {
-      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)
+      let [from, length] = rec
+      const subtypes = Array.from({ length }, (_, i) => {
+        const t = ctx.type[from + i], sub = t.slice(0, 4)
+        if (t.desc) sub.desc = t.desc
+        return build[SECTION.type](sub, ctx)
+      })
+      return [DEFTYPE.rec, ...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[subkind], ...vec(supertypes.map(n => id(n, ctx.type))), ...descPfx, ...comptype(kind, fields)]
     }
 
-    return [DEFTYPE[kind], ...details]
+    return [...descPfx, ...comptype(kind, fields)]
   },
 
   // (import "math" "add" (func|table|global|memory|tag dfn?))
   ([mod, field, [kind, ...dfn]], ctx) => {
-    let details
+    let details, kindByte = KIND[kind]
 
     if (kind === 'func') {
+      // exact func import: (func exact (type $t)) - custom descriptors (Phase 3)
+      const isExact = dfn[0] === 'exact' && dfn.shift()
+      if (isExact) kindByte = 0x20
       // 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))
@@ -503,7 +552,7 @@ const build = [
     }
     else err(`Unknown kind ${kind}`)
 
-    return ([...vec(mod), ...vec(field), KIND[kind], ...details])
+    return ([...vec(mod), ...vec(field), kindByte, ...details])
   },
 
   // (func $name? ...params result ...body)
@@ -667,6 +716,7 @@ const build = [
   // (data (i32.const 0) "\aa" "\bb"?)
   // (data (memory ref) (offset (i32.const 0)) "\aa" "\bb"?)
   // (data (global.get $x) "\aa" "\bb"?)
+  // (data (i8 1 2 3) ...) numeric values (WAT numeric values, Phase 2)
   (inits, ctx) => {
     let offset, memidx = 0
 
@@ -697,7 +747,7 @@ const build = [
             // passive: 1
             [1]
       ),
-      ...vec(inits.flat())
+      ...vec(inits.flatMap(item => numdata(item) ?? [...item]))
     ])
   },
 
@@ -710,10 +760,15 @@ const build = [
 
 // 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
+// (exact $T) support added for custom descriptors (Phase 3): encoded as 0x62 typeidx
 const reftype = (t, ctx) => (
   t[0] === 'ref' ?
     t[1] == 'null' ?
+      // (ref null (exact $T)) - exact nullable ref
+      Array.isArray(t[2]) && t[2][0] === 'exact' ? [TYPE.refnull, 0x62, ...uleb(id(t[2][1], ctx.type))] :
       TYPE[t[2]] ? [TYPE[t[2]]] : [TYPE.refnull, ...uleb(id(t[t.length - 1], ctx.type))] :
+      // (ref (exact $T)) - exact non-null ref
+      Array.isArray(t[1]) && t[1][0] === 'exact' ? [TYPE.ref, 0x62, ...uleb(id(t[1][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}`)]
@@ -760,11 +815,11 @@ const IMM = {
     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)) },
+  ref_null: (n, c) => { let t = n.shift(); return Array.isArray(t) && t[0] === 'exact' ? [0x62, ...uleb(id(t[1], c.type))] : 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()] },
+  reftype2: (n, c) => { let b = blockid(n.shift(), c.block), h1 = reftype(n.shift(), c), h2 = reftype(n.shift(), c), ht = h => h.length > 1 ? h.slice(1) : h; return [((h2[0] !== TYPE.ref) << 1) | (h1[0] !== TYPE.ref), ...uleb(b), ...ht(h1), ...ht(h2)] },
   v128const: (n) => {
     let [t, num] = n.shift().split('x'), bits = +t.slice(1), stride = bits >>> 3; num = +num
     if (t[0] === 'i') {
@@ -818,7 +873,45 @@ const IMM = {
   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))]
+  tableidx_tableidx: (n, c) => [...uleb(id(n.shift(), c.table)), ...uleb(id(n.shift(), c.table))],
+
+  // stack switching handlers (Phase 3)
+  cont_bind: (n, c) => [...uleb(id(n.shift(), c.type)), ...uleb(id(n.shift(), c.type))],
+  switch_cont: (n, c) => [...uleb(id(n.shift(), c.type)), ...uleb(id(n.shift(), c.tag))],
+  resume: (n, c) => {
+    const typeidx = uleb(id(n.shift(), c.type))
+    const handlers = []; let cnt = 0
+    while (n[0]?.[0] === 'on') {
+      const [, tag, label] = n.shift()
+      if (label === 'switch') handlers.push(0x01, ...uleb(id(tag, c.tag)))
+      else handlers.push(0x00, ...uleb(id(tag, c.tag)), ...uleb(blockid(label, c.block)))
+      cnt++
+    }
+    return [...typeidx, ...uleb(cnt), ...handlers]
+  },
+  resume_throw: (n, c) => {
+    const typeidx = uleb(id(n.shift(), c.type))
+    const exnidx = uleb(id(n.shift(), c.tag))
+    const handlers = []; let cnt = 0
+    while (n[0]?.[0] === 'on') {
+      const [, tag, label] = n.shift()
+      if (label === 'switch') handlers.push(0x01, ...uleb(id(tag, c.tag)))
+      else handlers.push(0x00, ...uleb(id(tag, c.tag)), ...uleb(blockid(label, c.block)))
+      cnt++
+    }
+    return [...typeidx, ...exnidx, ...uleb(cnt), ...handlers]
+  },
+  resume_throw_ref: (n, c) => {
+    const typeidx = uleb(id(n.shift(), c.type))
+    const handlers = []; let cnt = 0
+    while (n[0]?.[0] === 'on') {
+      const [, tag, label] = n.shift()
+      if (label === 'switch') handlers.push(0x01, ...uleb(id(tag, c.tag)))
+      else handlers.push(0x00, ...uleb(id(tag, c.tag)), ...uleb(blockid(label, c.block)))
+      cnt++
+    }
+    return [...typeidx, ...uleb(cnt), ...handlers]
+  }
 };
 
 // per-op imm handlers
@@ -851,7 +944,7 @@ const instr = (nodes, ctx) => {
 
     // Array = unknown instruction passed through from normalize
     if (Array.isArray(op)) {
-      op.i != null && (err.i = op.i)
+      op.loc != null && (err.loc = op.loc)
       err(`Unknown instruction ${op[0]}`)
     }
 
@@ -929,23 +1022,46 @@ const align = (op) => {
   return Math.log2(m ? (m[2] === 'x' ? 8 : m[1] / 8) : +group / 8)
 }
 
+// Convert WAT numeric data (i8/i16/i32/i64/f32/f64 lists) to bytes (Phase 2: WAT numeric values)
+const numdata = (item) => {
+  if (!Array.isArray(item)) return null
+  const [t, ...vs] = item
+  if (t !== 'i8' && t !== 'i16' && t !== 'i32' && t !== 'i64' && t !== 'f32' && t !== 'f64') return null
+  const out = [], dv = new DataView(new ArrayBuffer(8))
+  for (const v of vs) {
+    if (t === 'i8') out.push((i32.parse(v) & 0xFF + 0x100) & 0xFF)
+    else if (t === 'i16') (dv.setInt16(0, i32.parse(v), true), out.push(...new Uint8Array(dv.buffer, 0, 2)))
+    else if (t === 'i32') (dv.setInt32(0, i32.parse(v), true), out.push(...new Uint8Array(dv.buffer, 0, 4)))
+    else if (t === 'i64') (dv.setBigInt64(0, BigInt(v), true), out.push(...new Uint8Array(dv.buffer, 0, 8)))
+    else if (t === 'f32') out.push(...encode.f32(v))
+    else if (t === 'f64') out.push(...encode.f64(v))
+  }
+  return out
+}
+
 // build limits sequence (consuming)
 // Memory64: i64 index type uses flags 0x04-0x07 (bit 2 = is_64)
+// Custom page sizes (Phase 3): (pagesize N) attr adds bit 3, appends log2(pagesize) as u32
 const limits = (node) => {
   const is64 = node[0] === 'i64' && node.shift()
   const shared = node[node.length - 1] === 'shared' && node.pop()
+  // custom page size: (pagesize N) sub-node
+  const psIdx = node.findIndex(n => Array.isArray(n) && n[0] === 'pagesize')
+  let psLog2 = -1
+  if (psIdx >= 0) psLog2 = Math.log2(+node.splice(psIdx, 1)[0][1])
   const hasMax = !isNaN(parseInt(node[1]))
-  const flag = (is64 ? 4 : 0) | (shared ? 2 : 0) | (hasMax ? 1 : 0)
+  const flag = (psLog2 >= 0 ? 8 : 0) | (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
+  const ps = psLog2 >= 0 ? uleb(psLog2) : []
 
   return hasMax
-    ? [flag, ...uleb(parse(node.shift())), ...uleb(parse(node.shift()))]
-    : [flag, ...uleb(parse(node.shift()))]
+    ? [flag, ...uleb(parse(node.shift())), ...uleb(parse(node.shift())), ...ps]
+    : [flag, ...uleb(parse(node.shift())), ...ps]
 }
 
 // check if node is valid int in a range

package/src/const.js

@@ -48,15 +48,21 @@ export const INSTR = [
   'i32.extend8_s', 'i32.extend16_s', 'i64.extend8_s', 'i64.extend16_s', 'i64.extend32_s', , , , , , , , , , , ,
   // 0xd0-0xd6: reference
   'ref.null ref_null', 'ref.is_null', 'ref.func funcidx', 'ref.eq', 'ref.as_non_null', 'br_on_null labelidx', 'br_on_non_null labelidx',
-  // 0xd7-0xfa: padding to 0xfb (36 empty slots)
-  , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,
+  // 0xd7-0xdf: padding (9 empty slots)
+  , , , , , , , , ,
+  // 0xe0-0xe6: stack switching (Phase 3)
+  'cont.new typeidx', 'cont.bind cont_bind', 'suspend tagidx', 'resume resume', 'resume_throw resume_throw', 'resume_throw_ref resume_throw_ref', 'switch switch_cont',
+  // 0xe7-0xfa: padding (20 empty slots)
+  , , , , , , , , , , , , , , , , , , , ,
   // 0xfb: GC instructions (nested array for multi-byte opcodes)
   [
     'struct.new typeidx', 'struct.new_default typeidx', 'struct.get typeidx_field', 'struct.get_s typeidx_field', 'struct.get_u typeidx_field', 'struct.set typeidx_field',
     'array.new typeidx', 'array.new_default typeidx', 'array.new_fixed typeidx_multi', 'array.new_data typeidx_dataidx', 'array.new_elem typeidx_elemidx',
     'array.get typeidx', 'array.get_s typeidx', 'array.get_u typeidx', 'array.set typeidx', 'array.len', 'array.fill typeidx', 'array.copy typeidx_typeidx',
     'array.init_data typeidx_dataidx', 'array.init_elem typeidx_elemidx', 'ref.test reftype', '', 'ref.cast reftype', '', 'br_on_cast reftype2', 'br_on_cast_fail reftype2',
-    'any.convert_extern', 'extern.convert_any', 'ref.i31', 'i31.get_s', 'i31.get_u'
+    'any.convert_extern', 'extern.convert_any', 'ref.i31', 'i31.get_s', 'i31.get_u',
+    // custom descriptors (Phase 3): 0xFB 0x20-0x26
+    , 'struct.new_desc typeidx', 'struct.new_default_desc typeidx', 'ref.get_desc typeidx', 'ref.cast_desc_eq reftype', , 'br_on_cast_desc_eq reftype2', 'br_on_cast_desc_eq_fail reftype2'
   ],
 
   // 0xfc: Bulk memory/table operations (nested array)
@@ -146,9 +152,11 @@ export const TYPE = {
   i8: 0x78, i16: 0x77, i32: 0x7f, i64: 0x7e, f32: 0x7d, f64: 0x7c, void: 0x40, v128: 0x7B,
   // Heap types
   exn: 0x69, noexn: 0x74, nofunc: 0x73, noextern: 0x72, none: 0x71, func: 0x70, extern: 0x6F, any: 0x6E, eq: 0x6D, i31: 0x6C, struct: 0x6B, array: 0x6A,
+  cont: 0x68, nocont: 0x75,  // stack switching (Phase 3)
   // Reference type abbreviations (absheaptype abbrs)
   nullfuncref: 0x73, nullexternref: 0x72, nullexnref: 0x74, nullref: 0x71,
   funcref: 0x70, externref: 0x6F, exnref: 0x69, anyref: 0x6E, eqref: 0x6D, i31ref: 0x6C, structref: 0x6B, arrayref: 0x6A,
+  contref: 0x68, nocontref: 0x75,  // stack switching abbreviations
   // ref, refnull
   ref: 0x64, // -0x1c
   refnull: 0x63, // -0x1d
@@ -157,7 +165,7 @@ export const TYPE = {
 }
 
 // Type definition codes (different from heap types - func is 0x60 not 0x70)
-export const DEFTYPE = { func: 0x60, struct: 0x5F, array: 0x5E, sub: 0x50, subfinal: 0x4F, rec: 0x4E }
+export const DEFTYPE = { func: 0x60, struct: 0x5F, array: 0x5E, cont: 0x5D, sub: 0x50, subfinal: 0x4F, rec: 0x4E }
 
 // Import/export kind codes
 export const KIND = { func: 0, table: 1, memory: 2, global: 3, tag: 4 }

package/src/optimize.js

@@ -178,7 +178,9 @@ const treeshake = (ast) => {
 
   // Mark start function as used
   for (const start of starts) {
-    const ref = start[1]
+    let ref = start[1]
+    // Convert numeric string refs to numbers
+    if (typeof ref === 'string' && ref[0] !== '$') ref = +ref
     if (funcs.has(ref)) funcs.get(ref).used = true
   }
 
@@ -970,7 +972,18 @@ const inline = (ast) => {
 
     // Only inline: no locals, <= 2 params, single expression body, not exported
     if (params && !hasLocals && !hasExport && params.length <= 2 && body.length === 1) {
-      inlinable.set(name, { body: body[0], params })
+      // Check if function mutates any of its params (local.set/tee on param)
+      const paramNames = new Set(params.map(p => p.name))
+      let mutatesParam = false
+      walk(body[0], (n) => {
+        if (!Array.isArray(n)) return
+        if ((n[0] === 'local.set' || n[0] === 'local.tee') && paramNames.has(n[1])) {
+          mutatesParam = true
+        }
+      })
+      if (!mutatesParam) {
+        inlinable.set(name, { body: body[0], params })
+      }
     }
   }
 

package/src/parse.js

@@ -2,7 +2,7 @@ import { err } from "./util.js"
 
 /**
  * Parses a wasm text string and constructs a nested array structure (AST).
- * Each array node has `.i` property with source offset for error reporting.
+ * Each array node has `.loc` property with source offset for error reporting.
  *
  * @param {string} str - The input string with WAT code to parse.
  * @returns {Array} An array representing the nested syntax tree (AST).
@@ -13,7 +13,7 @@ export default (str) => {
   const commit = () => buf && (level.push(buf), buf = '')
 
   const parseLevel = (pos) => {
-    level.i = pos // store start position for error reporting
+    level.loc = pos // store start position for error reporting
     for (let c, root, p; i < str.length;) {
       c = str.charCodeAt(i)
 

package/src/util.js

@@ -1,13 +1,13 @@
 /**
  * Throws an error with optional source position.
- * Uses err.src for source and err.i for default position.
- * If pos provided or err.i set, appends "at line:col".
+ * Uses err.src for source and err.loc for default position.
+ * If pos provided or err.loc set, appends "at line:col".
  *
  * @param {string} text - Error message
- * @param {number} [pos] - Byte offset in source (defaults to err.i)
+ * @param {number} [pos] - Byte offset in source (defaults to err.loc)
  * @throws {Error}
  */
-export const err = (text, pos=err.i) => {
+export const err = (text, pos=err.loc) => {
   if (pos != null && err.src) {
     let line = 1, col = 1
     for (let i = 0; i < pos && i < err.src.length; i++) {

package/types/src/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AA+BA;;;;;GAKG;AACH,uCAHW,MAAM,QAAM,GACV,UAAU,CAmLtB"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AA+BA;;;;;GAKG;AACH,uCAHW,MAAM,QAAM,GACV,UAAU,CAqNtB"}

package/types/src/const.d.ts

@@ -40,6 +40,8 @@ export namespace TYPE {
     export let i31: number;
     export let struct: number;
     export let array: number;
+    export let cont: number;
+    export let nocont: number;
     export let nullfuncref: number;
     export let nullexternref: number;
     export let nullexnref: number;
@@ -52,6 +54,8 @@ export namespace TYPE {
     export let i31ref: number;
     export let structref: number;
     export let arrayref: number;
+    export let contref: number;
+    export let nocontref: number;
     export let ref: number;
     export let refnull: number;
     export let sub: number;
@@ -65,6 +69,8 @@ export namespace DEFTYPE {
     export { struct_1 as struct };
     let array_1: number;
     export { array_1 as array };
+    let cont_1: number;
+    export { cont_1 as cont };
     let sub_1: number;
     export { sub_1 as sub };
     let subfinal_1: number;

package/types/src/const.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../src/const.js"],"names":[],"mappings":"AAIA,0CAqIC"}
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../src/const.js"],"names":[],"mappings":"AAIA,0CA2IC"}

package/types/src/optimize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAonCA;;;;;;;;;;;GAWG;AACH,sCATW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SAwB/B;AAzjCD;;;;;GAKG;AACH,6CA4LC;AAyHD;;;;GAIG;AACH,wCAmCC;AAwQD;;;;GAIG;AACH,4CAuBC;AA+CD;;;;;GAKG;AACH,8CAqDC;AApTD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CA6DC;AAID;;;;GAIG;AACH,0CA0EC;AAiJD;;;;;GAKG;AACH,6CAuEC;AAID;;;;GAIG;AACH,0CA6EC;AAt9BD;;;;GAIG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAe/B"}
+{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAioCA;;;;;;;;;;;GAWG;AACH,sCATW,QAAM,MAAM,SACZ,OAAO,GAAC,MAAM,MAAO,SAwB/B;AAtkCD;;;;;GAKG;AACH,6CA8LC;AAyHD;;;;GAIG;AACH,wCAmCC;AAwQD;;;;GAIG;AACH,4CAuBC;AA+CD;;;;;GAKG;AACH,8CAqDC;AApTD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CA6DC;AAID;;;;GAIG;AACH,0CA0EC;AAiJD;;;;;GAKG;AACH,6CAuEC;AAID;;;;GAIG;AACH,0CAwFC;AAn+BD;;;;GAIG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAe/B"}

package/types/src/util.d.ts

@@ -1,10 +1,10 @@
 /**
  * Throws an error with optional source position.
- * Uses err.src for source and err.i for default position.
- * If pos provided or err.i set, appends "at line:col".
+ * Uses err.src for source and err.loc for default position.
+ * If pos provided or err.loc set, appends "at line:col".
  *
  * @param {string} text - Error message
- * @param {number} [pos] - Byte offset in source (defaults to err.i)
+ * @param {number} [pos] - Byte offset in source (defaults to err.loc)
  * @throws {Error}
  */
 export const err: (text: string, pos?: number) => never;

package/types/src/util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,mBAAoB,MAJT,MAIa,EAAE,MAHf,MAGwB,WAUlC;AAOM,2CAAkF;AAEzF,8DAA8D;AAC9D,2BAAiD;AAEjD,6DAA6D;AAC7D,2BAAiD;AAe1C,uBAHI,MAAM,GACJ,MAAM,EAAE,CA8BpB;AAUM,4BAHI,MAAM,GACJ,MAAM,CAE6C"}
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,mBAAoB,MAJT,MAIa,EAAE,MAHf,MAG0B,WAUpC;AAOM,2CAAkF;AAEzF,8DAA8D;AAC9D,2BAAiD;AAEjD,6DAA6D;AAC7D,2BAAiD;AAe1C,uBAHI,MAAM,GACJ,MAAM,EAAE,CA8BpB;AAUM,4BAHI,MAAM,GACJ,MAAM,CAE6C"}