watr 5.0.0 → 5.1.1

package/dist/watr.js

@@ -19,17 +19,27 @@ __export(encode_exports, {
 });
 
 // src/util.js
-var err = (text, pos = err.loc) => {
-  if (pos != null && err.src) {
+var errLoc;
+var errSrc;
+var err = (text, pos = errLoc) => {
+  if (pos != null && errSrc) {
     let line = 1, col = 1;
-    for (let i = 0; i < pos && i < err.src.length; i++) {
-      if (err.src[i] === "\n") line++, col = 1;
+    for (let i = 0; i < pos && i < errSrc.length; i++) {
+      if (errSrc.charCodeAt(i) === 10) line++, col = 1;
       else col++;
     }
     text += ` at ${line}:${col}`;
   }
   throw Error(text);
 };
+var setErrLoc = (loc) => {
+  errLoc = loc;
+};
+var setErrSrc = (src) => {
+  errSrc = src;
+};
+var getErrLoc = () => errLoc;
+var getErrSrc = () => errSrc;
 var sepRE = /^_|_$|[^\da-f]_|_[^\da-f]/i;
 var intRE = /^[+-]?(?:0x[\da-f]+|\d+)$/i;
 var tenc = new TextEncoder();
@@ -94,8 +104,17 @@ function uleb5(value) {
   }
   return result;
 }
+var I32_MEMO = /* @__PURE__ */ new Map();
 function i32(n, buffer = []) {
-  if (typeof n === "string") n = i32.parse(n);
+  if (typeof n === "string") {
+    let v = I32_MEMO.get(n);
+    if (v === void 0) {
+      v = i32.parse(n);
+      if (I32_MEMO.size > 65536) I32_MEMO.clear();
+      I32_MEMO.set(n, v);
+    }
+    n = v;
+  }
   while (true) {
     const byte = Number(n & 127);
     n >>= 7;
@@ -160,7 +179,7 @@ i64.parse = (n) => {
 var F32_SIGN = 2147483648;
 var F32_NAN = 2139095040;
 var F32_QUIET = 4194304;
-function f32(input, value, idx) {
+function f32(input, out, value, idx) {
   if (typeof input === "string" && (idx = input.indexOf("nan")) >= 0) {
     if (input[idx + 3] === ":") {
       const tail = input.slice(idx + 4);
@@ -173,12 +192,27 @@ function f32(input, value, idx) {
     value = typeof input === "string" ? f32.parse(input) : input;
     _f32[0] = value;
   }
+  if (out) {
+    out.push(_u8[0], _u8[1], _u8[2], _u8[3]);
+    return;
+  }
   return [_u8[0], _u8[1], _u8[2], _u8[3]];
 }
 var F64_SIGN = 0x8000000000000000n;
 var F64_NAN = 0x7ff0000000000000n;
 var F64_QUIET = 0x8000000000000n;
-function f64(input, value, idx) {
+var F64_MEMO = /* @__PURE__ */ new Map();
+function f64(input, out, value, idx) {
+  if (typeof input === "string") {
+    const m = F64_MEMO.get(input);
+    if (m !== void 0) {
+      if (out) {
+        out.push(m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7]);
+        return;
+      }
+      return m.slice();
+    }
+  }
   if (typeof input === "string" && (idx = input.indexOf("nan")) >= 0) {
     if (input[idx + 3] === ":") {
       const tail = input.slice(idx + 4);
@@ -191,6 +225,14 @@ function f64(input, value, idx) {
     value = typeof input === "string" ? f64.parse(input) : input;
     _f64[0] = value;
   }
+  if (typeof input === "string") {
+    if (F64_MEMO.size > 65536) F64_MEMO.clear();
+    F64_MEMO.set(input, [_u8[0], _u8[1], _u8[2], _u8[3], _u8[4], _u8[5], _u8[6], _u8[7]]);
+  }
+  if (out) {
+    out.push(_u8[0], _u8[1], _u8[2], _u8[3], _u8[4], _u8[5], _u8[6], _u8[7]);
+    return;
+  }
   return [_u8[0], _u8[1], _u8[2], _u8[3], _u8[4], _u8[5], _u8[6], _u8[7]];
 }
 f64.parse = (input, max = Number.MAX_VALUE) => {
@@ -226,18 +268,18 @@ var v128 = (input) => {
 };
 
 // src/const.js
-var INSTR = [
+var TABLE = [
   // 0x00-0x0a: control
   "unreachable",
   "nop",
   "block block",
   "loop block",
   "if block",
-  "else null",
-  "then null",
-  ,
+  "else",
+  "then",
+  8,
   "throw tagidx",
-  ,
+  10,
   "throw_ref",
   // 0x0b-0x19: control
   "end end",
@@ -251,16 +293,11 @@ var INSTR = [
   "return_call_indirect call_indirect",
   "call_ref typeidx",
   "return_call_ref typeidx",
-  ,
-  ,
-  ,
-  ,
   // 0x1a-0x1f: parametric
+  26,
   "drop",
   "select select",
-  "",
-  ,
-  ,
+  31,
   "try_table try_table",
   // 0x20-0x27: variable
   "local.get localidx",
@@ -270,8 +307,8 @@ var INSTR = [
   "global.set globalidx",
   "table.get tableidx",
   "table.set tableidx",
-  ,
   // 0x28-0x3e: memory
+  40,
   "i32.load memarg",
   "i64.load memarg",
   "f32.load memarg",
@@ -441,18 +478,8 @@ var INSTR = [
   "i64.extend8_s",
   "i64.extend16_s",
   "i64.extend32_s",
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
   // 0xd0-0xd6: reference
+  208,
   "ref.null ref_null",
   "ref.is_null",
   "ref.func funcidx",
@@ -460,16 +487,8 @@ var INSTR = [
   "ref.as_non_null",
   "br_on_null labelidx",
   "br_on_non_null labelidx",
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
   // 0xe0-0xe6: stack switching (Phase 3)
+  224,
   "cont.new typeidx",
   "cont.bind cont_bind",
   "suspend tagidx",
@@ -477,772 +496,534 @@ var INSTR = [
   "resume_throw resume_throw",
   "resume_throw_ref resume_throw_ref",
   "switch switch_cont",
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  // 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.test_null reftype",
-    "ref.cast reftype",
-    "ref.cast_null reftype",
-    "br_on_cast reftype2",
-    "br_on_cast_fail reftype2",
-    "any.convert_extern",
-    "extern.convert_any",
-    "ref.i31",
-    "i31.get_s",
-    "i31.get_u",
-    ,
-    "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",
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    // 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 + rounding mode control (nested array)
-  [
-    "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 dataidx_memoryidx",
-    "data.drop dataidx",
-    "memory.copy memoryidx_memoryidx",
-    "memory.fill memoryidx?",
-    "table.init reversed",
-    "elem.drop elemidx",
-    "table.copy tableidx_tableidx",
-    "table.grow tableidx",
-    "table.size tableidx",
-    "table.fill tableidx",
-    ,
-    "i64.add128",
-    "i64.sub128",
-    "i64.mul_wide_s",
-    "i64.mul_wide_u",
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    // 0x80-0xBB: rounding mode control
-    "f32.sqrt_ceil",
-    "f32.add_ceil",
-    "f32.sub_ceil",
-    "f32.mul_ceil",
-    "f32.div_ceil",
-    "f64.sqrt_ceil",
-    "f64.add_ceil",
-    "f64.sub_ceil",
-    "f64.mul_ceil",
-    "f64.div_ceil",
-    "f32.convert_ceil_i32_s",
-    "f32.convert_ceil_i32_u",
-    "f32.convert_ceil_i64_s",
-    "f32.convert_ceil_i64_u",
-    "f32.demote_ceil_f64",
-    "f64.convert_ceil_i32_s",
-    "f64.convert_ceil_i32_u",
-    "f64.convert_ceil_i64_s",
-    "f64.convert_ceil_i64_u",
-    "f64.promote_ceil_f32",
-    "f32.sqrt_floor",
-    "f32.add_floor",
-    "f32.sub_floor",
-    "f32.mul_floor",
-    "f32.div_floor",
-    "f64.sqrt_floor",
-    "f64.add_floor",
-    "f64.sub_floor",
-    "f64.mul_floor",
-    "f64.div_floor",
-    "f32.convert_floor_i32_s",
-    "f32.convert_floor_i32_u",
-    "f32.convert_floor_i64_s",
-    "f32.convert_floor_i64_u",
-    "f32.demote_floor_f64",
-    "f64.convert_floor_i32_s",
-    "f64.convert_floor_i32_u",
-    "f64.convert_floor_i64_s",
-    "f64.convert_floor_i64_u",
-    "f64.promote_floor_f32",
-    "f32.sqrt_trunc",
-    "f32.add_trunc",
-    "f32.sub_trunc",
-    "f32.mul_trunc",
-    "f32.div_trunc",
-    "f64.sqrt_trunc",
-    "f64.add_trunc",
-    "f64.sub_trunc",
-    "f64.mul_trunc",
-    "f64.div_trunc",
-    "f32.convert_trunc_i32_s",
-    "f32.convert_trunc_i32_u",
-    "f32.convert_trunc_i64_s",
-    "f32.convert_trunc_i64_u",
-    "f32.demote_trunc_f64",
-    "f64.convert_trunc_i32_s",
-    "f64.convert_trunc_i32_u",
-    "f64.convert_trunc_i64_s",
-    "f64.convert_trunc_i64_u",
-    "f64.promote_trunc_f32"
-  ],
-  // 0xfd: SIMD instructions (nested array)
-  [
-    "v128.load memarg",
-    "v128.load8x8_s memarg",
-    "v128.load8x8_u memarg",
-    "v128.load16x4_s memarg",
-    "v128.load16x4_u memarg",
-    "v128.load32x2_s memarg",
-    "v128.load32x2_u memarg",
-    "v128.load8_splat memarg",
-    "v128.load16_splat memarg",
-    "v128.load32_splat memarg",
-    "v128.load64_splat memarg",
-    "v128.store memarg",
-    "v128.const v128const",
-    "i8x16.shuffle shuffle",
-    "i8x16.swizzle",
-    "i8x16.splat",
-    "i16x8.splat",
-    "i32x4.splat",
-    "i64x2.splat",
-    "f32x4.splat",
-    "f64x2.splat",
-    "i8x16.extract_lane_s laneidx",
-    "i8x16.extract_lane_u laneidx",
-    "i8x16.replace_lane laneidx",
-    "i16x8.extract_lane_s laneidx",
-    "i16x8.extract_lane_u laneidx",
-    "i16x8.replace_lane laneidx",
-    "i32x4.extract_lane laneidx",
-    "i32x4.replace_lane laneidx",
-    "i64x2.extract_lane laneidx",
-    "i64x2.replace_lane laneidx",
-    "f32x4.extract_lane laneidx",
-    "f32x4.replace_lane laneidx",
-    "f64x2.extract_lane laneidx",
-    "f64x2.replace_lane laneidx",
-    "i8x16.eq",
-    "i8x16.ne",
-    "i8x16.lt_s",
-    "i8x16.lt_u",
-    "i8x16.gt_s",
-    "i8x16.gt_u",
-    "i8x16.le_s",
-    "i8x16.le_u",
-    "i8x16.ge_s",
-    "i8x16.ge_u",
-    "i16x8.eq",
-    "i16x8.ne",
-    "i16x8.lt_s",
-    "i16x8.lt_u",
-    "i16x8.gt_s",
-    "i16x8.gt_u",
-    "i16x8.le_s",
-    "i16x8.le_u",
-    "i16x8.ge_s",
-    "i16x8.ge_u",
-    "i32x4.eq",
-    "i32x4.ne",
-    "i32x4.lt_s",
-    "i32x4.lt_u",
-    "i32x4.gt_s",
-    "i32x4.gt_u",
-    "i32x4.le_s",
-    "i32x4.le_u",
-    "i32x4.ge_s",
-    "i32x4.ge_u",
-    "f32x4.eq",
-    "f32x4.ne",
-    "f32x4.lt",
-    "f32x4.gt",
-    "f32x4.le",
-    "f32x4.ge",
-    "f64x2.eq",
-    "f64x2.ne",
-    "f64x2.lt",
-    "f64x2.gt",
-    "f64x2.le",
-    "f64x2.ge",
-    "v128.not",
-    "v128.and",
-    "v128.andnot",
-    "v128.or",
-    "v128.xor",
-    "v128.bitselect",
-    "v128.any_true",
-    "v128.load8_lane memlane",
-    "v128.load16_lane memlane",
-    "v128.load32_lane memlane",
-    "v128.load64_lane memlane",
-    "v128.store8_lane memlane",
-    "v128.store16_lane memlane",
-    "v128.store32_lane memlane",
-    "v128.store64_lane memlane",
-    "v128.load32_zero memarg",
-    "v128.load64_zero memarg",
-    "f32x4.demote_f64x2_zero",
-    "f64x2.promote_low_f32x4",
-    "i8x16.abs",
-    "i8x16.neg",
-    "i8x16.popcnt",
-    "i8x16.all_true",
-    "i8x16.bitmask",
-    "i8x16.narrow_i16x8_s",
-    "i8x16.narrow_i16x8_u",
-    "f32x4.ceil",
-    "f32x4.floor",
-    "f32x4.trunc",
-    "f32x4.nearest",
-    "i8x16.shl",
-    "i8x16.shr_s",
-    "i8x16.shr_u",
-    "i8x16.add",
-    "i8x16.add_sat_s",
-    "i8x16.add_sat_u",
-    "i8x16.sub",
-    "i8x16.sub_sat_s",
-    "i8x16.sub_sat_u",
-    "f64x2.ceil",
-    "f64x2.floor",
-    "i8x16.min_s",
-    "i8x16.min_u",
-    "i8x16.max_s",
-    "i8x16.max_u",
-    "f64x2.trunc",
-    "i8x16.avgr_u",
-    "i16x8.extadd_pairwise_i8x16_s",
-    "i16x8.extadd_pairwise_i8x16_u",
-    "i32x4.extadd_pairwise_i16x8_s",
-    "i32x4.extadd_pairwise_i16x8_u",
-    "i16x8.abs",
-    "i16x8.neg",
-    "i16x8.q15mulr_sat_s",
-    "i16x8.all_true",
-    "i16x8.bitmask",
-    "i16x8.narrow_i32x4_s",
-    "i16x8.narrow_i32x4_u",
-    "i16x8.extend_low_i8x16_s",
-    "i16x8.extend_high_i8x16_s",
-    "i16x8.extend_low_i8x16_u",
-    "i16x8.extend_high_i8x16_u",
-    "i16x8.shl",
-    "i16x8.shr_s",
-    "i16x8.shr_u",
-    "i16x8.add",
-    "i16x8.add_sat_s",
-    "i16x8.add_sat_u",
-    "i16x8.sub",
-    "i16x8.sub_sat_s",
-    "i16x8.sub_sat_u",
-    "f64x2.nearest",
-    "i16x8.mul",
-    "i16x8.min_s",
-    "i16x8.min_u",
-    "i16x8.max_s",
-    "i16x8.max_u",
-    ,
-    "i16x8.avgr_u",
-    "i16x8.extmul_low_i8x16_s",
-    "i16x8.extmul_high_i8x16_s",
-    "i16x8.extmul_low_i8x16_u",
-    "i16x8.extmul_high_i8x16_u",
-    "i32x4.abs",
-    "i32x4.neg",
-    ,
-    "i32x4.all_true",
-    "i32x4.bitmask",
-    ,
-    ,
-    "i32x4.extend_low_i16x8_s",
-    "i32x4.extend_high_i16x8_s",
-    "i32x4.extend_low_i16x8_u",
-    "i32x4.extend_high_i16x8_u",
-    "i32x4.shl",
-    "i32x4.shr_s",
-    "i32x4.shr_u",
-    "i32x4.add",
-    ,
-    ,
-    "i32x4.sub",
-    ,
-    ,
-    ,
-    "i32x4.mul",
-    "i32x4.min_s",
-    "i32x4.min_u",
-    "i32x4.max_s",
-    "i32x4.max_u",
-    "i32x4.dot_i16x8_s",
-    ,
-    "i32x4.extmul_low_i16x8_s",
-    "i32x4.extmul_high_i16x8_s",
-    "i32x4.extmul_low_i16x8_u",
-    "i32x4.extmul_high_i16x8_u",
-    "i64x2.abs",
-    "i64x2.neg",
-    ,
-    "i64x2.all_true",
-    "i64x2.bitmask",
-    ,
-    ,
-    "i64x2.extend_low_i32x4_s",
-    "i64x2.extend_high_i32x4_s",
-    "i64x2.extend_low_i32x4_u",
-    "i64x2.extend_high_i32x4_u",
-    "i64x2.shl",
-    "i64x2.shr_s",
-    "i64x2.shr_u",
-    "i64x2.add",
-    ,
-    ,
-    "i64x2.sub",
-    ,
-    ,
-    ,
-    "i64x2.mul",
-    "i64x2.eq",
-    "i64x2.ne",
-    "i64x2.lt_s",
-    "i64x2.gt_s",
-    "i64x2.le_s",
-    "i64x2.ge_s",
-    "i64x2.extmul_low_i32x4_s",
-    "i64x2.extmul_high_i32x4_s",
-    "i64x2.extmul_low_i32x4_u",
-    "i64x2.extmul_high_i32x4_u",
-    "f32x4.abs",
-    "f32x4.neg",
-    ,
-    "f32x4.sqrt",
-    "f32x4.add",
-    "f32x4.sub",
-    "f32x4.mul",
-    "f32x4.div",
-    "f32x4.min",
-    "f32x4.max",
-    "f32x4.pmin",
-    "f32x4.pmax",
-    "f64x2.abs",
-    "f64x2.neg",
-    ,
-    "f64x2.sqrt",
-    "f64x2.add",
-    "f64x2.sub",
-    "f64x2.mul",
-    "f64x2.div",
-    "f64x2.min",
-    "f64x2.max",
-    "f64x2.pmin",
-    "f64x2.pmax",
-    "i32x4.trunc_sat_f32x4_s",
-    "i32x4.trunc_sat_f32x4_u",
-    "f32x4.convert_i32x4_s",
-    "f32x4.convert_i32x4_u",
-    "i32x4.trunc_sat_f64x2_s_zero",
-    "i32x4.trunc_sat_f64x2_u_zero",
-    "f64x2.convert_low_i32x4_s",
-    "f64x2.convert_low_i32x4_u",
-    "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"
-  ],
+  // 0xfb: GC instructions
+  16449536,
+  "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.test_null reftype",
+  "ref.cast reftype",
+  "ref.cast_null reftype",
+  "br_on_cast reftype2",
+  "br_on_cast_fail reftype2",
+  "any.convert_extern",
+  "extern.convert_any",
+  "ref.i31",
+  "i31.get_s",
+  "i31.get_u",
+  // custom descriptors (Phase 3): 0xFB 0x20-0x26
+  16449568,
+  "struct.new_desc typeidx",
+  "struct.new_default_desc typeidx",
+  "ref.get_desc typeidx",
+  "ref.cast_desc_eq reftype",
+  16449573,
+  "br_on_cast_desc_eq reftype2",
+  "br_on_cast_desc_eq_fail reftype2",
+  // stringref: 0xFB 0x80-0xB7
+  16449664,
+  "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?",
+  16449680,
+  "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?",
+  16449688,
+  "string.as_wtf16",
+  "stringview_wtf16.length",
+  "stringview_wtf16.get_codeunit",
+  "stringview_wtf16.encode memoryidx?",
+  "stringview_wtf16.slice",
+  16449696,
+  "string.as_iter",
+  "stringview_iter.next",
+  "stringview_iter.advance",
+  "stringview_iter.rewind",
+  "stringview_iter.slice",
+  16449712,
+  "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 + rounding mode control
+  16515072,
+  "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 dataidx_memoryidx",
+  "data.drop dataidx",
+  "memory.copy memoryidx_memoryidx",
+  "memory.fill memoryidx?",
+  "table.init reversed",
+  "elem.drop elemidx",
+  "table.copy tableidx_tableidx",
+  "table.grow tableidx",
+  "table.size tableidx",
+  "table.fill tableidx",
+  16515091,
+  "i64.add128",
+  "i64.sub128",
+  "i64.mul_wide_s",
+  "i64.mul_wide_u",
+  // 0x80-0xBB: rounding mode control
+  16515200,
+  "f32.sqrt_ceil",
+  "f32.add_ceil",
+  "f32.sub_ceil",
+  "f32.mul_ceil",
+  "f32.div_ceil",
+  "f64.sqrt_ceil",
+  "f64.add_ceil",
+  "f64.sub_ceil",
+  "f64.mul_ceil",
+  "f64.div_ceil",
+  "f32.convert_ceil_i32_s",
+  "f32.convert_ceil_i32_u",
+  "f32.convert_ceil_i64_s",
+  "f32.convert_ceil_i64_u",
+  "f32.demote_ceil_f64",
+  "f64.convert_ceil_i32_s",
+  "f64.convert_ceil_i32_u",
+  "f64.convert_ceil_i64_s",
+  "f64.convert_ceil_i64_u",
+  "f64.promote_ceil_f32",
+  "f32.sqrt_floor",
+  "f32.add_floor",
+  "f32.sub_floor",
+  "f32.mul_floor",
+  "f32.div_floor",
+  "f64.sqrt_floor",
+  "f64.add_floor",
+  "f64.sub_floor",
+  "f64.mul_floor",
+  "f64.div_floor",
+  "f32.convert_floor_i32_s",
+  "f32.convert_floor_i32_u",
+  "f32.convert_floor_i64_s",
+  "f32.convert_floor_i64_u",
+  "f32.demote_floor_f64",
+  "f64.convert_floor_i32_s",
+  "f64.convert_floor_i32_u",
+  "f64.convert_floor_i64_s",
+  "f64.convert_floor_i64_u",
+  "f64.promote_floor_f32",
+  "f32.sqrt_trunc",
+  "f32.add_trunc",
+  "f32.sub_trunc",
+  "f32.mul_trunc",
+  "f32.div_trunc",
+  "f64.sqrt_trunc",
+  "f64.add_trunc",
+  "f64.sub_trunc",
+  "f64.mul_trunc",
+  "f64.div_trunc",
+  "f32.convert_trunc_i32_s",
+  "f32.convert_trunc_i32_u",
+  "f32.convert_trunc_i64_s",
+  "f32.convert_trunc_i64_u",
+  "f32.demote_trunc_f64",
+  "f64.convert_trunc_i32_s",
+  "f64.convert_trunc_i32_u",
+  "f64.convert_trunc_i64_s",
+  "f64.convert_trunc_i64_u",
+  "f64.promote_trunc_f32",
+  // 0xfd: SIMD instructions
+  16580608,
+  "v128.load memarg",
+  "v128.load8x8_s memarg",
+  "v128.load8x8_u memarg",
+  "v128.load16x4_s memarg",
+  "v128.load16x4_u memarg",
+  "v128.load32x2_s memarg",
+  "v128.load32x2_u memarg",
+  "v128.load8_splat memarg",
+  "v128.load16_splat memarg",
+  "v128.load32_splat memarg",
+  "v128.load64_splat memarg",
+  "v128.store memarg",
+  "v128.const v128const",
+  "i8x16.shuffle shuffle",
+  "i8x16.swizzle",
+  "i8x16.splat",
+  "i16x8.splat",
+  "i32x4.splat",
+  "i64x2.splat",
+  "f32x4.splat",
+  "f64x2.splat",
+  "i8x16.extract_lane_s laneidx",
+  "i8x16.extract_lane_u laneidx",
+  "i8x16.replace_lane laneidx",
+  "i16x8.extract_lane_s laneidx",
+  "i16x8.extract_lane_u laneidx",
+  "i16x8.replace_lane laneidx",
+  "i32x4.extract_lane laneidx",
+  "i32x4.replace_lane laneidx",
+  "i64x2.extract_lane laneidx",
+  "i64x2.replace_lane laneidx",
+  "f32x4.extract_lane laneidx",
+  "f32x4.replace_lane laneidx",
+  "f64x2.extract_lane laneidx",
+  "f64x2.replace_lane laneidx",
+  "i8x16.eq",
+  "i8x16.ne",
+  "i8x16.lt_s",
+  "i8x16.lt_u",
+  "i8x16.gt_s",
+  "i8x16.gt_u",
+  "i8x16.le_s",
+  "i8x16.le_u",
+  "i8x16.ge_s",
+  "i8x16.ge_u",
+  "i16x8.eq",
+  "i16x8.ne",
+  "i16x8.lt_s",
+  "i16x8.lt_u",
+  "i16x8.gt_s",
+  "i16x8.gt_u",
+  "i16x8.le_s",
+  "i16x8.le_u",
+  "i16x8.ge_s",
+  "i16x8.ge_u",
+  "i32x4.eq",
+  "i32x4.ne",
+  "i32x4.lt_s",
+  "i32x4.lt_u",
+  "i32x4.gt_s",
+  "i32x4.gt_u",
+  "i32x4.le_s",
+  "i32x4.le_u",
+  "i32x4.ge_s",
+  "i32x4.ge_u",
+  "f32x4.eq",
+  "f32x4.ne",
+  "f32x4.lt",
+  "f32x4.gt",
+  "f32x4.le",
+  "f32x4.ge",
+  "f64x2.eq",
+  "f64x2.ne",
+  "f64x2.lt",
+  "f64x2.gt",
+  "f64x2.le",
+  "f64x2.ge",
+  "v128.not",
+  "v128.and",
+  "v128.andnot",
+  "v128.or",
+  "v128.xor",
+  "v128.bitselect",
+  "v128.any_true",
+  "v128.load8_lane memlane",
+  "v128.load16_lane memlane",
+  "v128.load32_lane memlane",
+  "v128.load64_lane memlane",
+  "v128.store8_lane memlane",
+  "v128.store16_lane memlane",
+  "v128.store32_lane memlane",
+  "v128.store64_lane memlane",
+  "v128.load32_zero memarg",
+  "v128.load64_zero memarg",
+  "f32x4.demote_f64x2_zero",
+  "f64x2.promote_low_f32x4",
+  "i8x16.abs",
+  "i8x16.neg",
+  "i8x16.popcnt",
+  "i8x16.all_true",
+  "i8x16.bitmask",
+  "i8x16.narrow_i16x8_s",
+  "i8x16.narrow_i16x8_u",
+  "f32x4.ceil",
+  "f32x4.floor",
+  "f32x4.trunc",
+  "f32x4.nearest",
+  "i8x16.shl",
+  "i8x16.shr_s",
+  "i8x16.shr_u",
+  "i8x16.add",
+  "i8x16.add_sat_s",
+  "i8x16.add_sat_u",
+  "i8x16.sub",
+  "i8x16.sub_sat_s",
+  "i8x16.sub_sat_u",
+  "f64x2.ceil",
+  "f64x2.floor",
+  "i8x16.min_s",
+  "i8x16.min_u",
+  "i8x16.max_s",
+  "i8x16.max_u",
+  "f64x2.trunc",
+  "i8x16.avgr_u",
+  "i16x8.extadd_pairwise_i8x16_s",
+  "i16x8.extadd_pairwise_i8x16_u",
+  "i32x4.extadd_pairwise_i16x8_s",
+  "i32x4.extadd_pairwise_i16x8_u",
+  "i16x8.abs",
+  "i16x8.neg",
+  "i16x8.q15mulr_sat_s",
+  "i16x8.all_true",
+  "i16x8.bitmask",
+  "i16x8.narrow_i32x4_s",
+  "i16x8.narrow_i32x4_u",
+  "i16x8.extend_low_i8x16_s",
+  "i16x8.extend_high_i8x16_s",
+  "i16x8.extend_low_i8x16_u",
+  "i16x8.extend_high_i8x16_u",
+  "i16x8.shl",
+  "i16x8.shr_s",
+  "i16x8.shr_u",
+  "i16x8.add",
+  "i16x8.add_sat_s",
+  "i16x8.add_sat_u",
+  "i16x8.sub",
+  "i16x8.sub_sat_s",
+  "i16x8.sub_sat_u",
+  "f64x2.nearest",
+  "i16x8.mul",
+  "i16x8.min_s",
+  "i16x8.min_u",
+  "i16x8.max_s",
+  "i16x8.max_u",
+  16580763,
+  "i16x8.avgr_u",
+  "i16x8.extmul_low_i8x16_s",
+  "i16x8.extmul_high_i8x16_s",
+  "i16x8.extmul_low_i8x16_u",
+  "i16x8.extmul_high_i8x16_u",
+  "i32x4.abs",
+  "i32x4.neg",
+  16580771,
+  "i32x4.all_true",
+  "i32x4.bitmask",
+  16580775,
+  "i32x4.extend_low_i16x8_s",
+  "i32x4.extend_high_i16x8_s",
+  "i32x4.extend_low_i16x8_u",
+  "i32x4.extend_high_i16x8_u",
+  "i32x4.shl",
+  "i32x4.shr_s",
+  "i32x4.shr_u",
+  "i32x4.add",
+  16580785,
+  "i32x4.sub",
+  16580789,
+  "i32x4.mul",
+  "i32x4.min_s",
+  "i32x4.min_u",
+  "i32x4.max_s",
+  "i32x4.max_u",
+  "i32x4.dot_i16x8_s",
+  16580796,
+  "i32x4.extmul_low_i16x8_s",
+  "i32x4.extmul_high_i16x8_s",
+  "i32x4.extmul_low_i16x8_u",
+  "i32x4.extmul_high_i16x8_u",
+  "i64x2.abs",
+  "i64x2.neg",
+  16580803,
+  "i64x2.all_true",
+  "i64x2.bitmask",
+  16580807,
+  "i64x2.extend_low_i32x4_s",
+  "i64x2.extend_high_i32x4_s",
+  "i64x2.extend_low_i32x4_u",
+  "i64x2.extend_high_i32x4_u",
+  "i64x2.shl",
+  "i64x2.shr_s",
+  "i64x2.shr_u",
+  "i64x2.add",
+  16580817,
+  "i64x2.sub",
+  16580821,
+  "i64x2.mul",
+  "i64x2.eq",
+  "i64x2.ne",
+  "i64x2.lt_s",
+  "i64x2.gt_s",
+  "i64x2.le_s",
+  "i64x2.ge_s",
+  "i64x2.extmul_low_i32x4_s",
+  "i64x2.extmul_high_i32x4_s",
+  "i64x2.extmul_low_i32x4_u",
+  "i64x2.extmul_high_i32x4_u",
+  "f32x4.abs",
+  "f32x4.neg",
+  16580835,
+  "f32x4.sqrt",
+  "f32x4.add",
+  "f32x4.sub",
+  "f32x4.mul",
+  "f32x4.div",
+  "f32x4.min",
+  "f32x4.max",
+  "f32x4.pmin",
+  "f32x4.pmax",
+  "f64x2.abs",
+  "f64x2.neg",
+  16580847,
+  "f64x2.sqrt",
+  "f64x2.add",
+  "f64x2.sub",
+  "f64x2.mul",
+  "f64x2.div",
+  "f64x2.min",
+  "f64x2.max",
+  "f64x2.pmin",
+  "f64x2.pmax",
+  "i32x4.trunc_sat_f32x4_s",
+  "i32x4.trunc_sat_f32x4_u",
+  "f32x4.convert_i32x4_s",
+  "f32x4.convert_i32x4_u",
+  "i32x4.trunc_sat_f64x2_s_zero",
+  "i32x4.trunc_sat_f64x2_u_zero",
+  "f64x2.convert_low_i32x4_s",
+  "f64x2.convert_low_i32x4_u",
+  "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",
   // 0xfe: atomic/thread instructions
-  [
-    "memory.atomic.notify memarg",
-    "memory.atomic.wait32 memarg",
-    "memory.atomic.wait64 memarg",
-    "atomic.fence opt_memory",
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    ,
-    "i32.atomic.load memarg",
-    "i64.atomic.load memarg",
-    "i32.atomic.load8_u memarg",
-    "i32.atomic.load16_u memarg",
-    "i64.atomic.load8_u memarg",
-    "i64.atomic.load16_u memarg",
-    "i64.atomic.load32_u memarg",
-    "i32.atomic.store memarg",
-    "i64.atomic.store memarg",
-    "i32.atomic.store8 memarg",
-    "i32.atomic.store16 memarg",
-    "i64.atomic.store8 memarg",
-    "i64.atomic.store16 memarg",
-    "i64.atomic.store32 memarg",
-    "i32.atomic.rmw.add memarg",
-    "i64.atomic.rmw.add memarg",
-    "i32.atomic.rmw8.add_u memarg",
-    "i32.atomic.rmw16.add_u memarg",
-    "i64.atomic.rmw8.add_u memarg",
-    "i64.atomic.rmw16.add_u memarg",
-    "i64.atomic.rmw32.add_u memarg",
-    "i32.atomic.rmw.sub memarg",
-    "i64.atomic.rmw.sub memarg",
-    "i32.atomic.rmw8.sub_u memarg",
-    "i32.atomic.rmw16.sub_u memarg",
-    "i64.atomic.rmw8.sub_u memarg",
-    "i64.atomic.rmw16.sub_u memarg",
-    "i64.atomic.rmw32.sub_u memarg",
-    "i32.atomic.rmw.and memarg",
-    "i64.atomic.rmw.and memarg",
-    "i32.atomic.rmw8.and_u memarg",
-    "i32.atomic.rmw16.and_u memarg",
-    "i64.atomic.rmw8.and_u memarg",
-    "i64.atomic.rmw16.and_u memarg",
-    "i64.atomic.rmw32.and_u memarg",
-    "i32.atomic.rmw.or memarg",
-    "i64.atomic.rmw.or memarg",
-    "i32.atomic.rmw8.or_u memarg",
-    "i32.atomic.rmw16.or_u memarg",
-    "i64.atomic.rmw8.or_u memarg",
-    "i64.atomic.rmw16.or_u memarg",
-    "i64.atomic.rmw32.or_u memarg",
-    "i32.atomic.rmw.xor memarg",
-    "i64.atomic.rmw.xor memarg",
-    "i32.atomic.rmw8.xor_u memarg",
-    "i32.atomic.rmw16.xor_u memarg",
-    "i64.atomic.rmw8.xor_u memarg",
-    "i64.atomic.rmw16.xor_u memarg",
-    "i64.atomic.rmw32.xor_u memarg",
-    "i32.atomic.rmw.xchg memarg",
-    "i64.atomic.rmw.xchg memarg",
-    "i32.atomic.rmw8.xchg_u memarg",
-    "i32.atomic.rmw16.xchg_u memarg",
-    "i64.atomic.rmw8.xchg_u memarg",
-    "i64.atomic.rmw16.xchg_u memarg",
-    "i64.atomic.rmw32.xchg_u memarg",
-    "i32.atomic.rmw.cmpxchg memarg",
-    "i64.atomic.rmw.cmpxchg memarg",
-    "i32.atomic.rmw8.cmpxchg_u memarg",
-    "i32.atomic.rmw16.cmpxchg_u memarg",
-    "i64.atomic.rmw8.cmpxchg_u memarg",
-    "i64.atomic.rmw16.cmpxchg_u memarg",
-    "i64.atomic.rmw32.cmpxchg_u memarg"
-  ]
+  16646144,
+  "memory.atomic.notify memarg",
+  "memory.atomic.wait32 memarg",
+  "memory.atomic.wait64 memarg",
+  "atomic.fence opt_memory",
+  16646160,
+  "i32.atomic.load memarg",
+  "i64.atomic.load memarg",
+  "i32.atomic.load8_u memarg",
+  "i32.atomic.load16_u memarg",
+  "i64.atomic.load8_u memarg",
+  "i64.atomic.load16_u memarg",
+  "i64.atomic.load32_u memarg",
+  "i32.atomic.store memarg",
+  "i64.atomic.store memarg",
+  "i32.atomic.store8 memarg",
+  "i32.atomic.store16 memarg",
+  "i64.atomic.store8 memarg",
+  "i64.atomic.store16 memarg",
+  "i64.atomic.store32 memarg",
+  "i32.atomic.rmw.add memarg",
+  "i64.atomic.rmw.add memarg",
+  "i32.atomic.rmw8.add_u memarg",
+  "i32.atomic.rmw16.add_u memarg",
+  "i64.atomic.rmw8.add_u memarg",
+  "i64.atomic.rmw16.add_u memarg",
+  "i64.atomic.rmw32.add_u memarg",
+  "i32.atomic.rmw.sub memarg",
+  "i64.atomic.rmw.sub memarg",
+  "i32.atomic.rmw8.sub_u memarg",
+  "i32.atomic.rmw16.sub_u memarg",
+  "i64.atomic.rmw8.sub_u memarg",
+  "i64.atomic.rmw16.sub_u memarg",
+  "i64.atomic.rmw32.sub_u memarg",
+  "i32.atomic.rmw.and memarg",
+  "i64.atomic.rmw.and memarg",
+  "i32.atomic.rmw8.and_u memarg",
+  "i32.atomic.rmw16.and_u memarg",
+  "i64.atomic.rmw8.and_u memarg",
+  "i64.atomic.rmw16.and_u memarg",
+  "i64.atomic.rmw32.and_u memarg",
+  "i32.atomic.rmw.or memarg",
+  "i64.atomic.rmw.or memarg",
+  "i32.atomic.rmw8.or_u memarg",
+  "i32.atomic.rmw16.or_u memarg",
+  "i64.atomic.rmw8.or_u memarg",
+  "i64.atomic.rmw16.or_u memarg",
+  "i64.atomic.rmw32.or_u memarg",
+  "i32.atomic.rmw.xor memarg",
+  "i64.atomic.rmw.xor memarg",
+  "i32.atomic.rmw8.xor_u memarg",
+  "i32.atomic.rmw16.xor_u memarg",
+  "i64.atomic.rmw8.xor_u memarg",
+  "i64.atomic.rmw16.xor_u memarg",
+  "i64.atomic.rmw32.xor_u memarg",
+  "i32.atomic.rmw.xchg memarg",
+  "i64.atomic.rmw.xchg memarg",
+  "i32.atomic.rmw8.xchg_u memarg",
+  "i32.atomic.rmw16.xchg_u memarg",
+  "i64.atomic.rmw8.xchg_u memarg",
+  "i64.atomic.rmw16.xchg_u memarg",
+  "i64.atomic.rmw32.xchg_u memarg",
+  "i32.atomic.rmw.cmpxchg memarg",
+  "i64.atomic.rmw.cmpxchg memarg",
+  "i32.atomic.rmw8.cmpxchg_u memarg",
+  "i32.atomic.rmw16.cmpxchg_u memarg",
+  "i64.atomic.rmw8.cmpxchg_u memarg",
+  "i64.atomic.rmw16.cmpxchg_u memarg",
+  "i64.atomic.rmw32.cmpxchg_u memarg"
 ];
+var OPCODE = {};
+var IMM = {};
+for (let i = 0, code = 0; i < TABLE.length; i++) {
+  const item = TABLE[i];
+  if (typeof item === "number") {
+    code = item;
+    continue;
+  }
+  const sp = item.indexOf(" ");
+  const nm = sp < 0 ? item : item.slice(0, sp);
+  if (sp >= 0) IMM[nm] = item.slice(sp + 1);
+  OPCODE[nm] = code++;
+}
 var resultType = (op) => {
   if (typeof op !== "string") return null;
   const dot = op.indexOf(".");
@@ -1356,7 +1137,7 @@ var parse_default = (str2) => {
 };
 
 // src/compile.js
-var isDroppable = (n) => typeof n === "string" && (n[0] === ";" || n[1] === ";") || Array.isArray(n) && n[0]?.[0] === "@" && n[0] !== "@custom" && !n[0]?.startsWith?.("@metadata.code.");
+var isDroppable = (n) => typeof n === "string" && (n[0] === ";" || n[0] === "(" && n[1] === ";") || Array.isArray(n) && n[0]?.[0] === "@" && n[0] !== "@custom" && !n[0]?.startsWith?.("@metadata.code.");
 var cleanup = (node, result) => {
   if (typeof node === "string") return (
     // normalize quoted ids: $"name" -> $name (if no escapes), else $unescaped
@@ -1371,9 +1152,9 @@ var cleanup = (node, result) => {
   return result.length === 1 && result[0]?.[0] === "module" ? result[0] : result;
 };
 function assemble(nodes, sizeOnly) {
-  if (typeof nodes === "string") err.src = nodes, nodes = parse_default(nodes) || [];
-  else err.src = "";
-  err.loc = 0;
+  if (typeof nodes === "string") setErrSrc(nodes), nodes = parse_default(nodes) || [];
+  else setErrSrc("");
+  setErrLoc(0);
   nodes = isDroppable(nodes) ? [] : cleanup(nodes) ?? [];
   let idx = 0;
   if (nodes[0] === "module") idx++, isId(nodes[idx]) && idx++;
@@ -1399,7 +1180,7 @@ function assemble(nodes, sizeOnly) {
   ctx.metadata = {};
   nodes.slice(idx).filter((n) => {
     if (!Array.isArray(n)) {
-      let pos = err.loc, src = err.src, c;
+      let pos = getErrLoc(), src = getErrSrc(), c;
       while ((pos = src.indexOf(n, pos)) >= 0) {
         c = src.charCodeAt(pos - 1);
         if (pos > 0 && (c > 47 && c < 58 || c > 64 && c < 91 || c > 96 && c < 123 || c === 95 || c === 36)) {
@@ -1413,11 +1194,11 @@ function assemble(nodes, sizeOnly) {
         }
         break;
       }
-      if (pos >= 0) err.loc = pos;
+      if (pos >= 0) setErrLoc(pos);
       err(`Unexpected token ${n}`);
     }
     let [kind, ...node] = n;
-    err.loc = n.loc;
+    setErrLoc(n.loc);
     if (kind === "@custom") {
       ctx.custom.push(node);
     } else if (kind === "rec") {
@@ -1441,7 +1222,7 @@ function assemble(nodes, sizeOnly) {
     else return true;
   }).forEach((n) => {
     let [kind, ...node] = n;
-    err.loc = n.loc;
+    setErrLoc(n.loc);
     let imported;
     if (kind === "import") [kind, ...node] = (imported = node).pop();
     let items = ctx[kind];
@@ -1522,7 +1303,13 @@ function assemble(nodes, sizeOnly) {
     return 8 + codeSecLen + others.reduce((s, sec) => s + sec.length, 0);
   }
   const codeItems = ctx.code.filter(Boolean).map((item) => build[SECTION.code](item, ctx)).filter(Boolean);
-  const codeSection = codeItems.length ? [SECTION.code, ...vec(vec(codeItems))] : [];
+  let codeSection = [];
+  if (codeItems.length) {
+    const inner = uleb(codeItems.length);
+    for (const it of codeItems) for (let i = 0; i < it.length; i++) inner.push(it[i]);
+    codeSection = [SECTION.code, ...uleb(inner.length)];
+    for (let i = 0; i < inner.length; i++) codeSection.push(inner[i]);
+  }
   const metaSection = binMeta();
   const dataSection = bin(SECTION.data);
   const stringsSection = ctx.strings.length ? [SECTION.strings, ...vec([0, ...vec(ctx.strings.map((s) => vec(s)))])] : [];
@@ -1544,19 +1331,17 @@ function assemble(nodes, sizeOnly) {
     metaSection,
     dataSection
   ];
-  const wasm = Uint8Array.from([
-    0,
-    97,
-    115,
-    109,
-    // magic
-    1,
-    0,
-    0,
-    0,
-    // version
-    ...sections.flat()
-  ]);
+  let total = 8;
+  for (const sec of sections) total += sec.length;
+  const wasm = new Uint8Array(total);
+  wasm.set([0, 97, 115, 109, 1, 0, 0, 0]);
+  let off = 8;
+  for (const sec of sections) {
+    if (sec.length) {
+      wasm.set(sec, off);
+      off += sec.length;
+    }
+  }
   const md = metadataOffsets();
   if (md) wasm.metadata = md;
   return wasm;
@@ -1568,9 +1353,9 @@ function assemble(nodes, sizeOnly) {
     const codeBase = 8 + sections.slice(0, sections.indexOf(codeSection)).reduce((n, s) => n + s.length, 0);
     const itemsBase = codeBase + codeSection.length - codeItems.reduce((n, it) => n + it.length, 0);
     const bodyBase = [];
-    for (let i = 0, off = itemsBase; i < codeItems.length; i++) {
-      bodyBase[i] = off + (ctx.codeSizePrefix?.[i] ?? 0);
-      off += codeItems[i].length;
+    for (let i = 0, off2 = itemsBase; i < codeItems.length; i++) {
+      bodyBase[i] = off2 + (ctx.codeSizePrefix?.[i] ?? 0);
+      off2 += codeItems[i].length;
     }
     const importedFuncs = ctx.import.filter((imp) => imp[2][0] === "func").length;
     for (const type in ctx.metadata) {
@@ -1590,41 +1375,61 @@ function compile(nodes) {
 var isIdx = (n) => n?.[0] === "$" || !isNaN(n);
 var isId = (n) => n?.[0] === "$";
 var isMemParam = (n) => n?.[0] === "a" || n?.[0] === "o";
-function normalize(nodes, ctx) {
-  const out = [];
-  nodes = [...nodes];
+var NCLS = null;
+var nclsOf = (op) => {
+  if (!NCLS) {
+    NCLS = /* @__PURE__ */ Object.create(null);
+    for (const k in OPCODE) {
+      if (k === "block" || k === "if" || k === "loop") NCLS[k] = 1;
+      else if (k === "else" || k === "end") NCLS[k] = 2;
+      else if (k === "select") NCLS[k] = 3;
+      else if (k.endsWith("call_indirect")) NCLS[k] = 4;
+      else if (k === "table.init") NCLS[k] = 5;
+      else if (k === "table.copy" || k === "memory.copy") NCLS[k] = 6;
+      else if (k.startsWith("table.")) NCLS[k] = 7;
+      else if (k === "memory.init") NCLS[k] = 8;
+      else if (k === "data.drop" || k === "array.new_data" || k === "array.init_data") NCLS[k] = 9;
+      else if (k.startsWith("memory.") || k.endsWith("load") || k.endsWith("store")) NCLS[k] = 10;
+    }
+  }
+  return NCLS[op];
+};
+function normalize(nodes, ctx, out = [], owned = false) {
+  if (!owned) nodes = [...nodes];
   while (nodes.length) {
     let node = nodes.shift();
     if (typeof node === "string") {
       out.push(node);
-      if (node === "block" || node === "if" || node === "loop") {
+      const cls = nclsOf(node);
+      if (cls === void 0) continue;
+      if (cls === 1) {
         if (isId(nodes[0])) out.push(nodes.shift());
         out.push(blocktype(nodes, ctx));
-      } else if (node === "else" || node === "end") {
+      } else if (cls === 2) {
         if (isId(nodes[0])) nodes.shift();
-      } else if (node === "select") out.push(paramres(nodes)[1]);
-      else if (node.endsWith("call_indirect")) {
+      } else if (cls === 3) out.push(paramres(nodes)[1]);
+      else if (cls === 4) {
         let tableidx = isIdx(nodes[0]) ? nodes.shift() : 0, [idx, param, result] = typeuse(nodes, ctx);
         out.push(tableidx, ["type", idx ?? regtype(param, result, ctx)]);
-      } else if (node === "table.init") out.push(isIdx(nodes[1]) ? nodes.shift() : 0, nodes.shift());
-      else if (node === "table.copy" || node === "memory.copy") out.push(isIdx(nodes[0]) ? nodes.shift() : 0, isIdx(nodes[0]) ? nodes.shift() : 0);
-      else if (node.startsWith("table.")) out.push(isIdx(nodes[0]) ? nodes.shift() : 0);
-      else if (node === "memory.init") {
+      } else if (cls === 5) out.push(isIdx(nodes[1]) ? nodes.shift() : 0, nodes.shift());
+      else if (cls === 6) out.push(isIdx(nodes[0]) ? nodes.shift() : 0, isIdx(nodes[0]) ? nodes.shift() : 0);
+      else if (cls === 7) out.push(isIdx(nodes[0]) ? nodes.shift() : 0);
+      else if (cls === 8) {
         out.push(...isIdx(nodes[1]) ? [nodes.shift(), nodes.shift()].reverse() : [nodes.shift(), 0]);
         ctx.datacount && (ctx.datacount[0] = true);
-      } else if (node === "data.drop" || node === "array.new_data" || node === "array.init_data") {
+      } else if (cls === 9) {
         node === "data.drop" && out.push(nodes.shift());
         ctx.datacount && (ctx.datacount[0] = true);
-      } else if ((node.startsWith("memory.") || node.endsWith("load") || node.endsWith("store")) && isIdx(nodes[0])) out.push(nodes.shift());
+      } else if (isIdx(nodes[0])) out.push(nodes.shift());
     } else if (Array.isArray(node)) {
       let op = node[0];
-      node.loc != null && (err.loc = node.loc);
+      node.loc != null && setErrLoc(node.loc);
       if (op?.startsWith?.("@metadata.code.")) {
         let type = op.slice(15);
         out.push(["@metadata", type, node[1]]);
         continue;
       }
-      if (typeof op !== "string" || !Array.isArray(INSTR[op])) {
+      if (typeof op !== "string" || typeof OPCODE[op] !== "number") {
         out.push(node);
         continue;
       }
@@ -1632,16 +1437,23 @@ function normalize(nodes, ctx) {
       if (op === "block" || op === "loop") {
         out.push(op);
         if (isId(parts[0])) out.push(parts.shift());
-        out.push(blocktype(parts, ctx), ...normalize(parts, ctx), "end");
+        out.push(blocktype(parts, ctx));
+        normalize(parts, ctx, out, true);
+        out.push("end");
       } else if (op === "if") {
         let then = [], els = [];
-        if (parts.at(-1)?.[0] === "else") els = normalize(parts.pop().slice(1), ctx);
-        if (parts.at(-1)?.[0] === "then") then = normalize(parts.pop().slice(1), ctx);
+        if (parts.at(-1)?.[0] === "else") els = normalize(parts.pop().slice(1), ctx, [], true);
+        if (parts.at(-1)?.[0] === "then") then = normalize(parts.pop().slice(1), ctx, [], true);
         let immed = [op];
         if (isId(parts[0])) immed.push(parts.shift());
         immed.push(blocktype(parts, ctx));
-        out.push(...normalize(parts, ctx), ...immed, ...then);
-        els.length && out.push("else", ...els);
+        normalize(parts, ctx, out, true);
+        for (let i = 0; i < immed.length; i++) out.push(immed[i]);
+        for (let i = 0; i < then.length; i++) out.push(then[i]);
+        if (els.length) {
+          out.push("else");
+          for (let i = 0; i < els.length; i++) out.push(els[i]);
+        }
         out.push("end");
       } else if (op === "try_table") {
         out.push(op);
@@ -1650,17 +1462,20 @@ function normalize(nodes, ctx) {
         while (parts[0]?.[0] === "catch" || parts[0]?.[0] === "catch_ref" || parts[0]?.[0] === "catch_all" || parts[0]?.[0] === "catch_all_ref") {
           out.push(parts.shift());
         }
-        out.push(...normalize(parts, ctx), "end");
+        normalize(parts, ctx, out, true);
+        out.push("end");
       } else if (op === "ref.test" || op === "ref.cast") {
         const type = parts[0];
         const isNullable = !Array.isArray(type) || type[1] === "null" || type[0] !== "ref";
         if (isNullable) op += "_null";
-        out.push(...normalize(parts.slice(1), ctx), op, type);
+        normalize(parts.slice(1), ctx, out, true);
+        out.push(op, type);
         nodes.unshift(...out.splice(out.length - 2));
       } else {
         const imm = [];
         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);
+        normalize(parts, ctx, out, true);
+        out.push(op, ...imm);
         nodes.unshift(...out.splice(out.length - 1 - imm.length));
       }
     } else out.push(node);
@@ -1887,8 +1702,10 @@ var build = [
       ((ctx.metadata ??= {})[type] ??= []).push([funcIdx, ctx.meta[type]]);
     }
     ctx.local = ctx.block = ctx.meta = null;
-    const item = vec([...locals, ...bytes]);
-    (ctx.codeSizePrefix ??= [])[codeIdx] = item.length - locals.length - bytes.length;
+    const item = uleb(locals.length + bytes.length);
+    (ctx.codeSizePrefix ??= [])[codeIdx] = item.length;
+    for (let i = 0; i < locals.length; i++) item.push(locals[i]);
+    for (let i = 0; i < bytes.length; i++) item.push(bytes[i]);
     return item;
   },
   // (data (i32.const 0) "\aa" "\bb"?)
@@ -1936,17 +1753,28 @@ var reftype = (t, ctx) => t[0] === "ref" ? t[1] == "null" ? (
   [TYPE[t] ?? err(`Unknown type ${t}`)]
 );
 var fieldtype = (t, ctx, mut = t[0] === "mut" ? 1 : 0) => [...reftype(mut ? t[1] : t, ctx), mut];
-var IMM = {
-  null: () => [],
+var wleb = (v, out) => {
+  if (out) {
+    uleb(v, out);
+    return;
+  }
+  return uleb(v);
+};
+var HANDLER = {
   reversed: (n, c) => {
     let t = n.shift(), e = n.shift();
     return [...uleb(id(e, c.elem)), ...uleb(id(t, c.table))];
   },
-  block: (n, c) => {
+  block: (n, c, op, out) => {
     c.block.push(1);
     isId(n[0]) && (c.block[n.shift()] = c.block.length);
     let t = n.shift();
-    return !t ? [TYPE.void] : t[0] === "result" ? reftype(t[1], c) : uleb(id(t[1], c.type));
+    const b = !t ? [TYPE.void] : t[0] === "result" ? reftype(t[1], c) : uleb(id(t[1], c.type));
+    if (out) {
+      for (let i = 0; i < b.length; i++) out.push(b[i]);
+      return;
+    }
+    return b;
   },
   try_table: (n, c) => {
     isId(n[0]) && (c.block[n.shift()] = c.block.length + 1);
@@ -1964,8 +1792,13 @@ var IMM = {
     return [...result, ...uleb(count), ...catches];
   },
   end: (_n, c) => (c.block.pop(), []),
-  call_indirect: (n, c) => {
+  call_indirect: (n, c, op, out) => {
     let t = n.shift(), [, idx] = n.shift();
+    if (out) {
+      uleb(id(idx, c.type), out);
+      uleb(id(t, c.table), out);
+      return;
+    }
     return [...uleb(id(idx, c.type)), ...uleb(id(t, c.table))];
   },
   br_table: (n, c) => {
@@ -1981,8 +1814,8 @@ var IMM = {
     let t = n.shift();
     return Array.isArray(t) && t[0] === "exact" ? [98, ...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)),
+  memarg: (n, c, op, out) => memargEnc(n, op, isIdx(n[0]) && !isMemParam(n[0]) ? id(n.shift(), c.memory) : 0, out),
+  opt_memory: (n, c, op, out) => wleb(id(isIdx(n[0]) ? n.shift() : 0, c.memory), out),
   reftype: (n, c) => {
     let ht = reftype(n.shift(), c);
     return ht.length > 1 ? ht.slice(1) : ht;
@@ -2013,30 +1846,50 @@ var IMM = {
     const memIdx = isId(n[0]) || isIdx(n[0]) && (isMemParam(n[1]) || isIdx(n[1])) ? id(n.shift(), c.memory) : 0;
     return [...memargEnc(n, op, memIdx), ...uleb(parseUint(n.shift()))];
   },
-  "*": (n) => uleb(n.shift()),
-  // *idx types
-  labelidx: (n, c) => uleb(blockid(n.shift(), c.block)),
-  laneidx: (n) => [parseUint(n.shift(), 255)],
-  funcidx: (n, c) => uleb(id(n.shift(), c.func)),
-  typeidx: (n, c) => uleb(id(n.shift(), c.type)),
-  tableidx: (n, c) => uleb(id(n.shift(), c.table)),
-  memoryidx: (n, c) => uleb(id(n.shift(), c.memory)),
-  globalidx: (n, c) => uleb(id(n.shift(), c.global)),
-  localidx: (n, c) => uleb(id(n.shift(), c.local)),
-  dataidx: (n, c) => uleb(id(n.shift(), c.data)),
-  elemidx: (n, c) => uleb(id(n.shift(), c.elem)),
-  tagidx: (n, c) => uleb(id(n.shift(), c.tag)),
-  "memoryidx?": (n, c) => uleb(id(isIdx(n[0]) ? n.shift() : 0, c.memory)),
-  stringidx: (n, c) => {
+  // *idx types — write-mode (out present) pushes in place and returns undefined;
+  // return-mode hands back a fresh array. The sentinel is EXPLICIT: a boxed-
+  // pointer identity compare (`returned !== out`) misfires under the jz kernel.
+  labelidx: (n, c, op, out) => wleb(blockid(n.shift(), c.block), out),
+  laneidx: (n, c, op, out) => {
+    const v = parseUint(n.shift(), 255);
+    if (out) {
+      out.push(v);
+      return;
+    }
+    return [v];
+  },
+  funcidx: (n, c, op, out) => wleb(id(n.shift(), c.func), out),
+  typeidx: (n, c, op, out) => wleb(id(n.shift(), c.type), out),
+  tableidx: (n, c, op, out) => wleb(id(n.shift(), c.table), out),
+  memoryidx: (n, c, op, out) => wleb(id(n.shift(), c.memory), out),
+  globalidx: (n, c, op, out) => wleb(id(n.shift(), c.global), out),
+  localidx: (n, c, op, out) => wleb(id(n.shift(), c.local), out),
+  dataidx: (n, c, op, out) => wleb(id(n.shift(), c.data), out),
+  elemidx: (n, c, op, out) => wleb(id(n.shift(), c.elem), out),
+  tagidx: (n, c, op, out) => wleb(id(n.shift(), c.tag), out),
+  "memoryidx?": (n, c, op, out) => wleb(id(isIdx(n[0]) ? n.shift() : 0, c.memory), out),
+  stringidx: (n, c, op, out) => {
     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);
+    return wleb(idx, out);
   },
   // Value type
-  i32: (n) => i32(n.shift()),
-  i64: (n) => i64(n.shift()),
-  f32: (n) => f32(n.shift()),
-  f64: (n) => f64(n.shift()),
+  i32: (n, c, op, out) => {
+    if (out) {
+      i32(n.shift(), out);
+      return;
+    }
+    return i32(n.shift());
+  },
+  i64: (n, c, op, out) => {
+    if (out) {
+      i64(n.shift(), out);
+      return;
+    }
+    return i64(n.shift());
+  },
+  f32: (n, c, op, out) => f32(n.shift(), out),
+  f64: (n, c, op, out) => f64(n.shift(), out),
   v128: (n) => v128(n.shift()),
   // Combinations
   typeidx_field: (n, c) => {
@@ -2091,13 +1944,6 @@ var IMM = {
     return [...typeidx, ...uleb(cnt), ...handlers];
   }
 };
-var HANDLER = {};
-(function populate(items, pre) {
-  for (let op = 0, item, nm, imm; op < items.length; op++) if (item = items[op]) {
-    if (Array.isArray(item)) populate(item, op);
-    else [nm, imm] = item.split(" "), INSTR[nm] = pre ? [pre, ...uleb(op)] : [op], imm && (HANDLER[nm] = IMM[imm]);
-  }
-})(INSTR);
 var instr = (nodes, ctx) => {
   let out = [], meta = [];
   while (nodes?.length) {
@@ -2107,26 +1953,91 @@ var instr = (nodes, ctx) => {
       continue;
     }
     if (Array.isArray(op)) {
-      op.loc != null && (err.loc = op.loc);
+      op.loc != null && setErrLoc(op.loc);
       err(`Unknown instruction ${op[0]}`);
     }
-    let [...bytes] = INSTR[op] || err(`Unknown instruction ${op}`);
-    if (HANDLER[op]) {
-      if (op === "select" && nodes[0]?.length) bytes[0]++;
-      else if (HANDLER[op] === IMM.reftype && !op.endsWith("_null") && (nodes[0][1] === "null" || nodes[0][0] !== "ref")) {
-        bytes[bytes.length - 1]++;
-      }
-      bytes.push(...HANDLER[op](nodes, ctx, op));
-    }
+    const code = OPCODE[op];
+    if (typeof code !== "number") err(`Unknown instruction ${op}`);
     if (meta.length) {
       for (const [type, data] of meta) (ctx.meta[type] ??= []).push([out.length, data]);
       meta = [];
     }
-    out.push(...bytes);
+    const at = out.length;
+    if (code > 65535) {
+      out.push(code >>> 16);
+      uleb(code & 65535, out);
+    } else out.push(code);
+    const imm = IMM[op];
+    if (imm) {
+      if (op === "select" && nodes[0]?.length) out[at]++;
+      else if (imm === "reftype" && !op.endsWith("_null") && (nodes[0][1] === "null" || nodes[0][0] !== "ref")) {
+        out[out.length - 1]++;
+      }
+      const b = HANDLER[imm](nodes, ctx, op, out);
+      if (b) for (let i = 0; i < b.length; i++) out.push(b[i]);
+    }
   }
   return out.push(11), out;
 };
-var ulebSize = (n) => uleb(n).length;
+var ulebSize = (n) => {
+  if (typeof n !== "number" || n < 0) return uleb(n).length;
+  let k = 1;
+  n >>>= 7;
+  while (n) k++, n >>>= 7;
+  return k;
+};
+var slebSize32 = (n) => {
+  if (typeof n === "string") n = i32.parse(n);
+  let k = 1;
+  while (true) {
+    const byte = n & 127;
+    n >>= 7;
+    if (n === 0 && (byte & 64) === 0 || n === -1 && (byte & 64) !== 0) return k;
+    k++;
+  }
+};
+var memargSize = (nodes, op, memIdx = 0) => {
+  const [a, o] = memarg(nodes), alignVal = (a ?? align(op)) | (memIdx && 64);
+  return memIdx ? ulebSize(alignVal) + ulebSize(memIdx) + ulebSize(o ?? 0) : ulebSize(alignVal) + ulebSize(o ?? 0);
+};
+var SIZE_HANDLER = {};
+for (const k in HANDLER) SIZE_HANDLER[k] = (n, c, op) => HANDLER[k](n, c, op).length;
+Object.assign(SIZE_HANDLER, {
+  i32: (n) => slebSize32(n.shift()),
+  f32: (n) => (n.shift(), 4),
+  f64: (n) => (n.shift(), 8),
+  localidx: (n, c) => ulebSize(id(n.shift(), c.local)),
+  funcidx: (n, c) => ulebSize(id(n.shift(), c.func)),
+  typeidx: (n, c) => ulebSize(id(n.shift(), c.type)),
+  tableidx: (n, c) => ulebSize(id(n.shift(), c.table)),
+  memoryidx: (n, c) => ulebSize(id(n.shift(), c.memory)),
+  globalidx: (n, c) => ulebSize(id(n.shift(), c.global)),
+  dataidx: (n, c) => ulebSize(id(n.shift(), c.data)),
+  elemidx: (n, c) => ulebSize(id(n.shift(), c.elem)),
+  tagidx: (n, c) => ulebSize(id(n.shift(), c.tag)),
+  labelidx: (n, c) => ulebSize(blockid(n.shift(), c.block)),
+  laneidx: (n) => (parseUint(n.shift(), 255), 1),
+  memarg: (n, c, op) => memargSize(n, op, isIdx(n[0]) && !isMemParam(n[0]) ? id(n.shift(), c.memory) : 0),
+  opt_memory: (n, c) => ulebSize(id(isIdx(n[0]) ? n.shift() : 0, c.memory)),
+  "memoryidx?": (n, c) => ulebSize(id(isIdx(n[0]) ? n.shift() : 0, c.memory)),
+  call_indirect: (n, c) => {
+    const t = n.shift(), [, ti] = n.shift();
+    return ulebSize(id(ti, c.type)) + ulebSize(id(t, c.table));
+  },
+  block: (n, c) => {
+    c.block.push(1);
+    isId(n[0]) && (c.block[n.shift()] = c.block.length);
+    const t = n.shift();
+    return !t ? 1 : t[0] === "result" ? reftype(t[1], c).length : ulebSize(id(t[1], c.type));
+  },
+  end: (_n, c) => (c.block.pop(), 0),
+  stringidx: (n, c) => {
+    const str2 = n.shift(), key = str2.valueOf();
+    let idx = c.strings.findIndex((x) => x.valueOf() === key);
+    if (idx < 0) idx = c.strings.push(str2) - 1;
+    return ulebSize(idx);
+  }
+});
 var instrSize = (nodes, ctx) => {
   let size = 0, meta = [];
   while (nodes?.length) {
@@ -2136,12 +2047,13 @@ var instrSize = (nodes, ctx) => {
       continue;
     }
     if (Array.isArray(op)) {
-      op.loc != null && (err.loc = op.loc);
+      op.loc != null && setErrLoc(op.loc);
       err(`Unknown instruction ${op[0]}`);
     }
-    const opc = INSTR[op] || err(`Unknown instruction ${op}`);
-    let n = opc.length;
-    if (HANDLER[op]) n += HANDLER[op](nodes, ctx, op).length;
+    const code = OPCODE[op];
+    if (typeof code !== "number") err(`Unknown instruction ${op}`);
+    let n = code > 65535 ? 1 + ulebSize(code & 65535) : 1;
+    if (IMM[op]) n += SIZE_HANDLER[IMM[op]](nodes, ctx, op);
     if (meta.length) {
       for (const [type, data] of meta) (ctx.meta[type] ??= []).push([size, data]);
       meta = [];
@@ -2183,7 +2095,7 @@ var codeItemSize = (body, ctx) => {
   return ulebSize(bodyLen) + bodyLen;
 };
 var expr = (node, ctx) => instr(normalize([node], ctx), ctx);
-var id = (nm, list, n) => (n = isId(nm) ? list[nm] : +nm, n in list ? n : err(`Unknown ${list.name} ${nm}`));
+var id = (nm, list, n) => (n = isId(nm) ? list[nm] : +nm, n >= 0 && n < list.length ? n : n in list ? n : err(`Unknown ${list.name} ${nm}`));
 var blockid = (nm, block, i) => (i = isId(nm) ? block.length - block[nm] : +nm, isNaN(i) || i > block.length ? err(`Bad label ${nm}`) : i);
 var memarg = (args) => {
   let align2, offset, k, v;
@@ -2193,8 +2105,14 @@ var memarg = (args) => {
   if (align2) (align2 = Math.log2(align2)) % 1 && err(`Bad align ${align2}`);
   return [align2, offset];
 };
-var memargEnc = (nodes, op, memIdx = 0) => {
+var memargEnc = (nodes, op, memIdx = 0, out) => {
   const [a, o] = memarg(nodes), alignVal = (a ?? align(op)) | (memIdx && 64);
+  if (out) {
+    uleb(alignVal, out);
+    if (memIdx) uleb(memIdx, out);
+    uleb(o ?? 0, out);
+    return;
+  }
   return memIdx ? [...uleb(alignVal), ...uleb(memIdx), ...uleb(o ?? 0)] : [...uleb(alignVal), ...uleb(o ?? 0)];
 };
 var align = (op) => {
@@ -2253,7 +2171,7 @@ function print(tree, options = {}) {
   if (typeof tree[0] === "string" && tree[0][0] !== ";") return printNode(tree);
   return tree.filter((node) => comments || !isComment(node)).map((node) => printNode(node)).join(newline);
   function isComment(node) {
-    return typeof node === "string" && node[1] === ";";
+    return typeof node === "string" && (node[0] === ";" || node[0] === "(" && node[1] === ";");
   }
   function printNode(node, level = 0) {
     if (!Array.isArray(node)) return node;
@@ -2272,7 +2190,7 @@ function print(tree, options = {}) {
     let curIndent = indent.repeat(level + 1);
     for (let i = 1; i < node.length; i++) {
       const sub = node[i]?.valueOf?.() ?? node[i];
-      if (typeof sub === "string" && sub[1] === ";") {
+      if (typeof sub === "string" && (sub[0] === ";" || sub[0] === "(" && sub[1] === ";")) {
         if (!comments) continue;
         if (sub[0] === ";") {
           if (newline) {