watr 4.2.1 → 4.3.1

package/src/compile.js

@@ -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
@@ -91,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)
       }
     }
@@ -101,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)
@@ -146,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]
         }
@@ -202,6 +226,14 @@ export default function compile(nodes) {
   }
 
 
+  // pre-compute sections that may collect string constants (for strings section ordering)
+  const globalSection = bin(SECTION.global)
+  const elemSection = bin(SECTION.elem)
+  const codeSection = bin(SECTION.code)
+  const metaSection = binMeta()
+  const dataSection = bin(SECTION.data)
+  const stringsSection = ctx.strings.length ? [SECTION.strings, ...vec([0x00, ...vec(ctx.strings.map(s => vec(s)))])] : []
+
   // build final binary
   return Uint8Array.from([
     0x00, 0x61, 0x73, 0x6d, // magic
@@ -213,14 +245,15 @@ export default function compile(nodes) {
     ...bin(SECTION.table),
     ...bin(SECTION.memory),
     ...bin(SECTION.tag),
-    ...bin(SECTION.global),
+    ...stringsSection,
+    ...globalSection,
     ...bin(SECTION.export),
     ...bin(SECTION.start, false),
-    ...bin(SECTION.elem),
+    ...elemSection,
     ...bin(SECTION.datacount, false),
-    ...bin(SECTION.code),
-    ...binMeta(),
-    ...bin(SECTION.data)
+    ...codeSection,
+    ...metaSection,
+    ...dataSection
   ])
 }
 
@@ -318,7 +351,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]) || parts[0].valueOf !== Array.prototype.valueOf || '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))
       }
@@ -418,18 +451,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
@@ -437,8 +472,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
 }
 
 
@@ -460,40 +498,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))
@@ -513,7 +561,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)
@@ -677,6 +725,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
 
@@ -707,7 +756,7 @@ const build = [
             // passive: 1
             [1]
       ),
-      ...vec(inits.flat())
+      ...vec(inits.flatMap(item => numdata(item) ?? [...item]))
     ])
   },
 
@@ -720,10 +769,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}`)]
@@ -770,11 +824,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') {
@@ -812,6 +866,7 @@ const IMM = {
   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)),
+  stringidx: (n, c) => { let s = n.shift(), key = s.valueOf(), idx = c.strings.findIndex(x => x.valueOf() === key); if (idx < 0) idx = c.strings.push(s) - 1; return uleb(idx) },
 
   // Value type
   i32: (n) => encode.i32(n.shift()),
@@ -828,7 +883,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
@@ -939,23 +1032,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,37 @@ 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',
+    // 0xFB 0x28-0x7F: padding (88 empty slots)
+    ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+    // stringref: 0xFB 0x80-0xB7
+    'string.new_utf8 memoryidx?', 'string.new_wtf16 memoryidx?', 'string.const stringidx', 'string.measure_utf8', 'string.measure_wtf8', 'string.measure_wtf16',
+    'string.encode_utf8 memoryidx?', 'string.encode_wtf16 memoryidx?', 'string.concat', 'string.eq', 'string.is_usv_sequence',
+    'string.new_lossy_utf8 memoryidx?', 'string.new_wtf8 memoryidx?', 'string.encode_lossy_utf8 memoryidx?', 'string.encode_wtf8 memoryidx?',
+    , // 0x8F
+    'string.as_wtf8', 'stringview_wtf8.advance', 'stringview_wtf8.encode_utf8 memoryidx?', 'stringview_wtf8.slice',
+    'stringview_wtf8.encode_lossy_utf8 memoryidx?', 'stringview_wtf8.encode_wtf8 memoryidx?',
+    ,, // 0x96-0x97
+    'string.as_wtf16', 'stringview_wtf16.length', 'stringview_wtf16.get_codeunit', 'stringview_wtf16.encode memoryidx?', 'stringview_wtf16.slice',
+    ,,, // 0x9D-0x9F
+    'string.as_iter', 'stringview_iter.next', 'stringview_iter.advance', 'stringview_iter.rewind', 'stringview_iter.slice',
+    ,,,,,,,,,,, // 0xA5-0xAF
+    'string.new_utf8_array', 'string.new_wtf16_array', 'string.encode_utf8_array', 'string.encode_wtf16_array',
+    'string.new_lossy_utf8_array', 'string.new_wtf8_array', 'string.encode_lossy_utf8_array', 'string.encode_wtf8_array'
   ],
 
   // 0xfc: Bulk memory/table operations (nested array)
@@ -138,7 +160,7 @@ export const INSTR = [
 ]
 
 // Binary section type codes
-export const SECTION = { custom: 0, type: 1, import: 2, func: 3, table: 4, memory: 5, tag: 13, global: 6, export: 7, start: 8, elem: 9, datacount: 12, code: 10, data: 11 }
+export const SECTION = { custom: 0, type: 1, import: 2, func: 3, table: 4, memory: 5, tag: 13, strings: 14, global: 6, export: 7, start: 8, elem: 9, datacount: 12, code: 10, data: 11 }
 
 // Type codes
 export const TYPE = {
@@ -146,9 +168,13 @@ 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)
+  string: 0x67, stringview_wtf8: 0x66, stringview_wtf16: 0x60, stringview_iter: 0x61,  // stringref
   // 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
+  stringref: 0x67,  // stringref abbreviation
   // ref, refnull
   ref: 0x64, // -0x1c
   refnull: 0x63, // -0x1d
@@ -157,7 +183,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/parse.js

@@ -25,14 +25,18 @@ export default (str) => {
         c === 59 && str.charCodeAt(i + 1) === 41 ? (buf += str[i++] + str[i++], --q === 59 && (commit(), q = 0)) : // ;)
         buf += str[i++]
       )
-      // inside ;; ...\n
-      else if (q < 0) (c === 10 || c === 13 ? (buf += str[i++], commit(), q = 0) : buf += str[i++])
+      // inside ;; ..\n: q=-1 normal (has newline), q=-2 inline (no newline — ) ends comment)
+      else if (q < 0) (
+        c === 10 || c === 13 ? (buf += str[i++], commit(), q = 0) :
+        q === -2 && c === 41 ? (commit(), q = 0) :
+        buf += str[i++]
+      )
       // start "
       else if (c === 34) (buf !== '$' && commit(), q = 34, buf += str[i++])
       // start (;
       else if (c === 40 && str.charCodeAt(i + 1) === 59) (commit(), q = 60, buf = str[i++] + str[i++])
       // start ;;
-      else if (c === 59 && str.charCodeAt(i + 1) === 59) (commit(), q = -1, buf = str[i++] + str[i++])
+      else if (c === 59 && str.charCodeAt(i + 1) === 59) (commit(), q = str.indexOf('\n', i) < 0 ? -2 : -1, buf = str[i++] + str[i++])
       // start (@
       else if (c === 40 && str.charCodeAt(i + 1) === 64) (commit(), p = i, i += 2, buf = '@', depth++, (root = level).push(level = []), parseLevel(p), level = root)
       // start (

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,CA6LtB"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AA+BA;;;;;GAKG;AACH,uCAHW,MAAM,QAAM,GACV,UAAU,CA8NtB"}

package/types/src/const.d.ts

@@ -8,6 +8,7 @@ export namespace SECTION {
     export let table: number;
     export let memory: number;
     export let tag: number;
+    export let strings: number;
     export let global: number;
     let _export: number;
     export { _export as export };
@@ -40,6 +41,12 @@ 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 string: number;
+    export let stringview_wtf8: number;
+    export let stringview_wtf16: number;
+    export let stringview_iter: number;
     export let nullfuncref: number;
     export let nullexternref: number;
     export let nullexnref: number;
@@ -52,6 +59,9 @@ 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 stringref: number;
     export let ref: number;
     export let refnull: number;
     export let sub: number;
@@ -65,6 +75,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,0CA2JC"}

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

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/parse.js"],"names":[],"mappings":"AASe,+BAHJ,MAAM,SAqDhB"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/parse.js"],"names":[],"mappings":"AASe,+BAHJ,MAAM,SAyDhB"}