watr 4.6.10 → 4.7.0

package/dist/watr.js

@@ -1491,23 +1491,42 @@ function compile(nodes) {
     return !items.length ? [] : [kind, ...vec(count ? vec(items) : items.flat())];
   };
   const binMeta = () => {
-    const sections = [];
+    const sections2 = [];
     for (const type in ctx.metadata) {
       const name2 = vec(str(`"metadata.code.${type}"`));
       const content = vec(ctx.metadata[type].map(
         ([funcIdx, instances]) => [...uleb(funcIdx), ...vec(instances.map(([pos, data]) => [...uleb(pos), ...vec(data)]))]
       ));
-      sections.push(0, ...vec([...name2, ...content]));
+      sections2.push(0, ...vec([...name2, ...content]));
     }
-    return sections;
+    return sections2;
   };
   const globalSection = bin(SECTION.global);
   const elemSection = bin(SECTION.elem);
-  const codeSection = bin(SECTION.code);
+  const codeItems = ctx.code.filter(Boolean).map((item) => build[SECTION.code](item, ctx)).filter(Boolean);
+  const codeSection = codeItems.length ? [SECTION.code, ...vec(vec(codeItems))] : [];
   const metaSection = binMeta();
   const dataSection = bin(SECTION.data);
   const stringsSection = ctx.strings.length ? [SECTION.strings, ...vec([0, ...vec(ctx.strings.map((s) => vec(s)))])] : [];
-  return Uint8Array.from([
+  const sections = [
+    bin(SECTION.custom),
+    bin(SECTION.type),
+    bin(SECTION.import),
+    bin(SECTION.func),
+    bin(SECTION.table),
+    bin(SECTION.memory),
+    bin(SECTION.tag),
+    stringsSection,
+    globalSection,
+    bin(SECTION.export),
+    bin(SECTION.start, false),
+    elemSection,
+    bin(SECTION.datacount, false),
+    codeSection,
+    metaSection,
+    dataSection
+  ];
+  const wasm = Uint8Array.from([
     0,
     97,
     115,
@@ -1518,23 +1537,34 @@ function compile(nodes) {
     0,
     0,
     // version
-    ...bin(SECTION.custom),
-    ...bin(SECTION.type),
-    ...bin(SECTION.import),
-    ...bin(SECTION.func),
-    ...bin(SECTION.table),
-    ...bin(SECTION.memory),
-    ...bin(SECTION.tag),
-    ...stringsSection,
-    ...globalSection,
-    ...bin(SECTION.export),
-    ...bin(SECTION.start, false),
-    ...elemSection,
-    ...bin(SECTION.datacount, false),
-    ...codeSection,
-    ...metaSection,
-    ...dataSection
+    ...sections.flat()
   ]);
+  const md = metadataOffsets();
+  if (md) wasm.metadata = md;
+  return wasm;
+  function metadataOffsets() {
+    let has = false;
+    for (const _ in ctx.metadata) has = true;
+    if (!has) return;
+    const out = {};
+    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;
+    }
+    const importedFuncs = ctx.import.filter((imp) => imp[2][0] === "func").length;
+    for (const type in ctx.metadata) {
+      const entries = [];
+      for (const [funcIdx, instances] of ctx.metadata[type]) {
+        const base = bodyBase[funcIdx - importedFuncs];
+        for (const [pos, data] of instances) entries.push([base + pos, data]);
+      }
+      out[type] = entries.sort((a, b) => a[0] - b[0]);
+    }
+    return out;
+  }
 }
 var isIdx = (n) => n?.[0] === "$" || !isNaN(n);
 var isId = (n) => n?.[0] === "$";
@@ -1828,11 +1858,17 @@ var build = [
     }
     ctx.meta = {};
     const bytes = instr(body, ctx);
-    const funcIdx = ctx.import.filter((imp) => imp[2][0] === "func").length + codeIdx;
-    for (const type in ctx.meta) ((ctx.metadata ??= {})[type] ??= []).push([funcIdx, ctx.meta[type]]);
     let loctypes = ctx.local.slice(param.length).reduce((a, type) => (type == a[a.length - 1]?.[1] ? a[a.length - 1][0]++ : a.push([1, type]), a), []);
+    const locals = vec(loctypes.map(([n, t]) => [...uleb(n), ...reftype(t, ctx)]));
+    const funcIdx = ctx.import.filter((imp) => imp[2][0] === "func").length + codeIdx;
+    for (const type in ctx.meta) {
+      for (const inst of ctx.meta[type]) inst[0] += locals.length;
+      ((ctx.metadata ??= {})[type] ??= []).push([funcIdx, ctx.meta[type]]);
+    }
     ctx.local = ctx.block = ctx.meta = null;
-    return vec([...vec(loctypes.map(([n, t]) => [...uleb(n), ...reftype(t, ctx)])), ...bytes]);
+    const item = vec([...locals, ...bytes]);
+    (ctx.codeSizePrefix ??= [])[codeIdx] = item.length - locals.length - bytes.length;
+    return item;
   },
   // (data (i32.const 0) "\aa" "\bb"?)
   // (data (memory ref) (offset (i32.const 0)) "\aa" "\bb"?)
@@ -2061,7 +2097,10 @@ var instr = (nodes, ctx) => {
       }
       bytes.push(...HANDLER[op](nodes, ctx, op));
     }
-    for (const [type, data] of meta) (ctx.meta[type] ??= []).push([out.length, data]);
+    if (meta.length) {
+      for (const [type, data] of meta) (ctx.meta[type] ??= []).push([out.length, data]);
+      meta = [];
+    }
     out.push(...bytes);
   }
   return out.push(11), out;
@@ -3053,6 +3092,30 @@ function polyfill(ast, opts = true) {
 }
 
 // src/optimize.js
+var MAX_PROP_ROUNDS = 6;
+var MAX_INLINE_ROUNDS = 16;
+var clone2 = (node) => Array.isArray(node) ? node.map(clone2) : node;
+var walk2 = (node, fn, parent, idx) => {
+  fn(node, parent, idx);
+  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) walk2(node[i], fn, node, i);
+};
+var walkPost2 = (node, fn, parent, idx) => {
+  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) walkPost2(node[i], fn, node, i);
+  const result = fn(node, parent, idx);
+  if (result !== void 0 && parent) parent[idx] = result;
+  return result !== void 0 ? result : node;
+};
+var resultType2 = (op) => {
+  if (typeof op !== "string") return null;
+  const dot = op.indexOf(".");
+  if (dot < 0) return null;
+  const prefix = op.slice(0, dot);
+  const scalar = prefix === "i32" || prefix === "i64" || prefix === "f32" || prefix === "f64";
+  if (scalar && /^(eqz?|ne|[lg][te])(_[su])?$/.test(op.slice(dot + 1))) return "i32";
+  if (scalar || prefix === "v128") return prefix;
+  if (op === "memory.size" || op === "memory.grow") return "i32";
+  return null;
+};
 var binarySize = (ast) => {
   try {
     return compile(ast).length;
@@ -3169,7 +3232,7 @@ var treeshake = (ast) => {
     markFunc(ref);
   }
   for (const elem of elems) {
-    walk(elem, (n) => {
+    walk2(elem, (n) => {
       if (Array.isArray(n) && n[0] === "ref.func") markFunc(n[1]);
       else if (typeof n === "string" && n[0] === "$") markFunc(n);
     });
@@ -3191,7 +3254,7 @@ var treeshake = (ast) => {
     if (entry.scanned) continue;
     entry.scanned = true;
     if (entry.isImport) continue;
-    walk(entry.node, (n) => {
+    walk2(entry.node, (n) => {
       if (!Array.isArray(n)) {
         if (typeof n === "string" && n[0] === "$") markFunc(n);
         return;
@@ -3237,16 +3300,53 @@ var treeshake = (ast) => {
 var roundEven = (x) => x - Math.floor(x) !== 0.5 ? Math.round(x) : 2 * Math.round(x / 2);
 var _rb8 = new ArrayBuffer(8);
 var _rf64 = new Float64Array(_rb8);
-var _ri64 = new BigInt64Array(_rb8);
+var _ru32 = new Uint32Array(_rb8);
 var _rb4 = new ArrayBuffer(4);
 var _rf32 = new Float32Array(_rb4);
 var _ri32 = new Int32Array(_rb4);
+var _hex8 = (u) => (u >>> 0).toString(16).padStart(8, "0");
+var _twosComp16 = (mag) => {
+  let out = "", carry = 1;
+  for (let i = 15; i >= 0; i--) {
+    const d = 15 - parseInt(mag[i], 16) + carry;
+    out = (d & 15).toString(16) + out;
+    carry = d >> 4;
+  }
+  return out;
+};
+var _i64Hex16 = (v) => {
+  const h = v.toString(16);
+  return h[0] === "-" ? _twosComp16(h.slice(1).padStart(16, "0")) : h.padStart(16, "0");
+};
+var ZERO64 = "0x0000000000000000";
+var ONE64 = "0x0000000000000001";
+var NEG164 = "0xffffffffffffffff";
+var _i64Canon = (val) => {
+  if (typeof val === "string") {
+    const s = val.replaceAll("_", "");
+    if (s.length === 18 && s[1] === "x") return "0x" + s.slice(2).toLowerCase();
+    const neg = s[0] === "-", mag = s[0] === "-" || s[0] === "+" ? s.slice(1) : s;
+    return "0x" + _i64Hex16(neg ? -BigInt(mag) : BigInt(mag));
+  }
+  if (typeof val === "bigint") return "0x" + _i64Hex16(BigInt(String(val)));
+  return "0x" + _i64Hex16(BigInt(Math.trunc(val) || 0));
+};
+var _sb = (h) => (parseInt(h[2], 16) ^ 8).toString(16) + h.slice(3);
+var _i64Lo = (h) => parseInt(h.slice(10), 16) | 0;
+var _i64HiU = (h) => parseInt(h.slice(2, 10), 16) >>> 0;
+var _i64Arith = (r) => r == null ? null : "0x" + _i64Hex16(r);
+var _sgn = (h) => {
+  let v = BigInt(h);
+  if (v > 0x7fffffffffffffffn) v = v - 0x8000000000000000n - 0x8000000000000000n;
+  return v;
+};
 var i64FromF64 = (x) => {
   _rf64[0] = x;
-  return _ri64[0];
+  return "0x" + _hex8(_ru32[1]) + _hex8(_ru32[0]);
 };
-var f64FromI64 = (x) => {
-  _ri64[0] = BigInt.asIntN(64, x);
+var f64FromI64 = (h) => {
+  _ru32[1] = parseInt(h.slice(2, 10), 16);
+  _ru32[0] = parseInt(h.slice(10), 16);
   return _rf64[0];
 };
 var i32FromF32 = (x) => {
@@ -3259,8 +3359,8 @@ var f32FromI32 = (x) => {
 };
 var i32c = (fn) => (a, b) => fn(a, b) ? 1 : 0;
 var u32c = (fn) => (a, b) => fn(a >>> 0, b >>> 0) ? 1 : 0;
-var i64c = (fn) => (a, b) => fn(a, b) ? 1 : 0;
-var u64c = (fn) => (a, b) => fn(BigInt.asUintN(64, a), BigInt.asUintN(64, b)) ? 1 : 0;
+var i64c = (fn) => (a, b) => fn(_sb(a), _sb(b)) ? 1 : 0;
+var u64c = (fn) => (a, b) => fn(a, b) ? 1 : 0;
 var FOLDABLE = {
   // i32 arithmetic
   "i32.add": (a, b) => a + b | 0,
@@ -3305,25 +3405,43 @@ var FOLDABLE = {
     }
     return c;
   },
-  "i32.wrap_i64": (a) => Number(BigInt.asIntN(32, a)),
+  "i32.wrap_i64": (a) => _i64Lo(a),
   "i32.extend8_s": (a) => a << 24 >> 24,
   "i32.extend16_s": (a) => a << 16 >> 16,
-  // i64 (using BigInt)
-  "i64.add": (a, b) => BigInt.asIntN(64, a + b),
-  "i64.sub": (a, b) => BigInt.asIntN(64, a - b),
-  "i64.mul": (a, b) => BigInt.asIntN(64, a * b),
-  "i64.div_s": (a, b) => b !== 0n ? BigInt.asIntN(64, a / b) : null,
-  "i64.div_u": (a, b) => b !== 0n ? BigInt.asUintN(64, BigInt.asUintN(64, a) / BigInt.asUintN(64, b)) : null,
-  "i64.rem_s": (a, b) => b !== 0n ? BigInt.asIntN(64, a % b) : null,
-  "i64.rem_u": (a, b) => b !== 0n ? BigInt.asUintN(64, BigInt.asUintN(64, a) % BigInt.asUintN(64, b)) : null,
-  "i64.and": (a, b) => BigInt.asIntN(64, a & b),
-  "i64.or": (a, b) => BigInt.asIntN(64, a | b),
-  "i64.xor": (a, b) => BigInt.asIntN(64, a ^ b),
-  "i64.shl": (a, b) => BigInt.asIntN(64, a << (b & 63n)),
-  "i64.shr_s": (a, b) => BigInt.asIntN(64, a >> (b & 63n)),
-  "i64.shr_u": (a, b) => BigInt.asUintN(64, BigInt.asUintN(64, a) >> (b & 63n)),
-  "i64.eq": i64c((a, b) => a === b),
-  "i64.ne": i64c((a, b) => a !== b),
+  // i64 — hex-string in, hex-string out, BOTH-WORLDS-EXACT arithmetic.
+  // BigInts construct locally (in-expression — kernel kind erasure never
+  // applies), but two further kernel facts shape every folder:
+  //   (1) the kernel's BigInt is the mod-2^64 i64 CARRIER: BigInt('0xffff…')
+  //       arrives NEGATIVE there, so sign-sensitive ops (>>, /, %, unsigned
+  //       division) diverge unless the value is sign-canonicalized first;
+  //   (2) BigInt.asIntN/asUintN are unfaithful in-kernel — never used.
+  // Ring ops {+,−,×,&,|,^,<<} are mod-2^64-compatible: compute then mask with
+  // `& 0xffffffffffffffffn` (native: the wrap; kernel: AND with −1 ≡ no-op).
+  // `_sgn` yields the SIGNED value in both worlds (the subtract arm is dead
+  // in-kernel — same dead-arm trick as slebSize). shr_u is pure u32-half
+  // number math. div_u/rem_u fold only below 2^63 (signed==unsigned there);
+  // above, they skip — sound degradation, never a wrong constant.
+  "i64.add": (a, b) => _i64Arith(BigInt(a) + BigInt(b) & 0xffffffffffffffffn),
+  "i64.sub": (a, b) => _i64Arith(BigInt(a) - BigInt(b) & 0xffffffffffffffffn),
+  "i64.mul": (a, b) => _i64Arith(BigInt(a) * BigInt(b) & 0xffffffffffffffffn),
+  "i64.div_s": (a, b) => b !== ZERO64 && !(a === "0x8000000000000000" && b === NEG164) ? _i64Arith(_sgn(a) / _sgn(b) & 0xffffffffffffffffn) : null,
+  "i64.div_u": (a, b) => b !== ZERO64 && !(_i64HiU(a) >>> 31) && !(_i64HiU(b) >>> 31) ? _i64Arith(BigInt(a) / BigInt(b)) : null,
+  "i64.rem_s": (a, b) => b !== ZERO64 ? _i64Arith(_sgn(a) % _sgn(b) & 0xffffffffffffffffn) : null,
+  "i64.rem_u": (a, b) => b !== ZERO64 && !(_i64HiU(a) >>> 31) && !(_i64HiU(b) >>> 31) ? _i64Arith(BigInt(a) % BigInt(b)) : null,
+  "i64.and": (a, b) => _i64Arith(BigInt(a) & BigInt(b) & 0xffffffffffffffffn),
+  "i64.or": (a, b) => _i64Arith((BigInt(a) | BigInt(b)) & 0xffffffffffffffffn),
+  "i64.xor": (a, b) => _i64Arith((BigInt(a) ^ BigInt(b)) & 0xffffffffffffffffn),
+  "i64.shl": (a, b) => _i64Arith(BigInt(a) << (BigInt(b) & 63n) & 0xffffffffffffffffn),
+  "i64.shr_s": (a, b) => _i64Arith(_sgn(a) >> (BigInt(b) & 63n) & 0xffffffffffffffffn),
+  "i64.shr_u": (a, b) => {
+    const s = parseInt(b.slice(10), 16) & 63;
+    const hi = _i64HiU(a), lo = parseInt(a.slice(10), 16) >>> 0;
+    const rh = s >= 32 ? 0 : hi >>> s;
+    const rl = s === 0 ? lo : s >= 32 ? hi >>> s - 32 : (lo >>> s | hi << 32 - s) >>> 0;
+    return "0x" + _hex8(rh) + _hex8(rl);
+  },
+  "i64.eq": (a, b) => a === b ? 1 : 0,
+  "i64.ne": (a, b) => a !== b ? 1 : 0,
   "i64.lt_s": i64c((a, b) => a < b),
   "i64.lt_u": u64c((a, b) => a < b),
   "i64.gt_s": i64c((a, b) => a > b),
@@ -3332,12 +3450,21 @@ var FOLDABLE = {
   "i64.le_u": u64c((a, b) => a <= b),
   "i64.ge_s": i64c((a, b) => a >= b),
   "i64.ge_u": u64c((a, b) => a >= b),
-  "i64.eqz": (a) => a === 0n ? 1 : 0,
-  "i64.extend_i32_s": (a) => BigInt(a),
-  "i64.extend_i32_u": (a) => BigInt(a >>> 0),
-  "i64.extend8_s": (a) => BigInt.asIntN(64, BigInt.asIntN(8, a)),
-  "i64.extend16_s": (a) => BigInt.asIntN(64, BigInt.asIntN(16, a)),
-  "i64.extend32_s": (a) => BigInt.asIntN(64, BigInt.asIntN(32, a)),
+  "i64.eqz": (a) => a === ZERO64 ? 1 : 0,
+  "i64.extend_i32_s": (a) => "0x" + _hex8(a >> 31) + _hex8(a),
+  "i64.extend_i32_u": (a) => "0x00000000" + _hex8(a),
+  "i64.extend8_s": (a) => {
+    const v = _i64Lo(a) << 24 >> 24;
+    return "0x" + _hex8(v >> 31) + _hex8(v);
+  },
+  "i64.extend16_s": (a) => {
+    const v = _i64Lo(a) << 16 >> 16;
+    return "0x" + _hex8(v >> 31) + _hex8(v);
+  },
+  "i64.extend32_s": (a) => {
+    const v = _i64Lo(a);
+    return "0x" + _hex8(v >> 31) + _hex8(v);
+  },
   // f32/f64 (NaN/precision-aware via Math.fround)
   "f32.add": (a, b) => Math.fround(a + b),
   "f32.sub": (a, b) => Math.fround(a - b),
@@ -3369,19 +3496,33 @@ var FOLDABLE = {
   // Numeric conversions (value-preserving where representable)
   "f32.convert_i32_s": (a) => Math.fround(a | 0),
   "f32.convert_i32_u": (a) => Math.fround(a >>> 0),
-  "f32.convert_i64_s": (a) => Math.fround(Number(BigInt.asIntN(64, a))),
-  "f32.convert_i64_u": (a) => Math.fround(Number(BigInt.asUintN(64, a))),
+  // (hi|0)·2^32 + lo is the exact signed value with ONE rounding at the add —
+  // correct f64 conversion semantics, pure number math (kernel-safe).
+  "f32.convert_i64_s": (a) => Math.fround((_i64HiU(a) | 0) * 4294967296 + parseInt(a.slice(10), 16)),
+  "f32.convert_i64_u": (a) => Math.fround(_i64HiU(a) * 4294967296 + parseInt(a.slice(10), 16)),
   "f64.convert_i32_s": (a) => a | 0,
   "f64.convert_i32_u": (a) => a >>> 0,
-  "f64.convert_i64_s": (a) => Number(BigInt.asIntN(64, a)),
-  "f64.convert_i64_u": (a) => Number(BigInt.asUintN(64, a)),
+  "f64.convert_i64_s": (a) => (_i64HiU(a) | 0) * 4294967296 + parseInt(a.slice(10), 16),
+  "f64.convert_i64_u": (a) => _i64HiU(a) * 4294967296 + parseInt(a.slice(10), 16),
   "f32.demote_f64": (a) => Math.fround(a),
   "f64.promote_f32": (a) => Math.fround(a)
 };
+var _nanBitsHex = (s) => {
+  const i = s?.indexOf?.("nan");
+  if (i < 0 || i == null) return null;
+  const tail = s.slice(i + 4).replaceAll("_", "");
+  const payload = s[i + 3] === ":" && tail !== "canonical" && tail !== "arithmetic" ? BigInt(tail) : 0x8000000000000n;
+  const h = payload.toString(16).padStart(16, "0");
+  const hi = (parseInt(h.slice(0, 8), 16) | 2146435072 | (s[0] === "-" ? 2147483648 : 0)) >>> 0;
+  return "0x" + _hex8(hi) + h.slice(8);
+};
 var _parseNanF64 = (s, i = s?.indexOf?.("nan")) => {
   if (i < 0 || i == null) return null;
-  let tail = s.slice(i + 4).replaceAll("_", ""), bits = s[i + 3] === ":" && tail !== "canonical" && tail !== "arithmetic" ? BigInt(tail) : 0x8000000000000n;
-  _ri64[0] = BigInt.asIntN(64, bits | 0x7ff0000000000000n | (s[0] === "-" ? 1n << 63n : 0n));
+  const tail = s.slice(i + 4).replaceAll("_", "");
+  const payload = s[i + 3] === ":" && tail !== "canonical" && tail !== "arithmetic" ? BigInt(tail) : 0x8000000000000n;
+  const h = payload.toString(16).padStart(16, "0");
+  _ru32[1] = (parseInt(h.slice(0, 8), 16) | 2146435072 | (s[0] === "-" ? 2147483648 : 0)) >>> 0;
+  _ru32[0] = parseInt(h.slice(8), 16);
   return _rf64[0];
 };
 var _parseNanF32 = (s, i = s?.indexOf?.("nan")) => {
@@ -3393,43 +3534,67 @@ var _parseNanF32 = (s, i = s?.indexOf?.("nan")) => {
 var getConst = (node) => {
   if (!Array.isArray(node) || node.length !== 2) return null;
   const [op, val] = node;
-  if (op === "i32.const") return { type: "i32", value: (typeof val === "string" ? i32.parse(val) : val) | 0 };
-  if (op === "i64.const") return { type: "i64", value: typeof val === "string" ? i64.parse(val) : BigInt(val) };
+  if (op === "i32.const") return { type: "i32", value: (typeof val === "string" ? parseInt(val.replaceAll("_", "")) : val) | 0 };
+  if (op === "i64.const") return { type: "i64", value: _i64Canon(val) };
   if (op === "f32.const") {
     const n = _parseNanF32(val);
     return { type: "f32", value: n !== null ? n : Math.fround(Number(val)) };
   }
   if (op === "f64.const") {
     const n = _parseNanF64(val);
-    return { type: "f64", value: n !== null ? n : Number(val) };
+    const v = n !== null ? n : Number(val);
+    return { type: "f64", value: Number.isNaN(v) ? NaN : v };
   }
   return null;
 };
 var makeConst = (type, value) => {
   if (type === "i32") return ["i32.const", value | 0];
-  if (type === "i64") return ["i64.const", value];
-  if (type === "f32") return ["f32.const", Math.fround(value)];
-  if (type === "f64") return ["f64.const", value];
+  if (type === "i64") return ["i64.const", typeof value === "number" ? value : _i64Canon(value)];
+  if (type === "f32") {
+    const v = Math.fround(value);
+    return ["f32.const", Number.isNaN(v) ? "nan" : v];
+  }
+  if (type === "f64") return ["f64.const", Number.isNaN(value) ? "nan" : value];
   return null;
 };
 var fold = (ast) => {
-  return walkPost(ast, (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const fn = FOLDABLE[node[0]];
     if (!fn) return;
-    if (fn.length === 1 && node.length === 2) {
+    if (node.length === 2) {
+      if (node[0] === "i64.reinterpret_f64") {
+        const inner = node[1];
+        if (Array.isArray(inner) && inner.length === 2 && inner[0] === "f64.const" && typeof inner[1] === "string") {
+          const bits = _nanBitsHex(inner[1]);
+          if (bits) return ["i64.const", bits];
+        }
+      }
+      if (node[0] === "f64.reinterpret_i64") {
+        const c = getConst(node[1]);
+        if (c && c.type === "i64") {
+          const h = c.value.slice(2);
+          const hi = parseInt(h.slice(0, 8), 16) >>> 0;
+          const lo = parseInt(h.slice(8), 16) >>> 0;
+          const isNaN64 = (hi & 2146435072) === 2146435072 && ((hi & 1048575) !== 0 || lo !== 0);
+          if (isNaN64) return [
+            "f64.const",
+            ((hi & 2147483648) !== 0 ? "-" : "") + "nan:0x" + (hi & 1048575).toString(16).padStart(5, "0") + h.slice(8)
+          ];
+        }
+      }
       const a = getConst(node[1]);
       if (!a) return;
       const r = fn(a.value);
-      if (r === null) return;
-      return makeConst(resultType(node[0]), r);
+      if (r === null || r === void 0) return;
+      return makeConst(resultType2(node[0]), r);
     }
-    if (fn.length === 2 && node.length === 3) {
+    if (node.length === 3) {
       const a = getConst(node[1]), b = getConst(node[2]);
       if (!a || !b) return;
       const r = fn(a.value, b.value);
-      if (r === null) return;
-      return makeConst(resultType(node[0]), r);
+      if (r === null || r === void 0) return;
+      return makeConst(resultType2(node[0]), r);
     }
   });
 };
@@ -3443,39 +3608,39 @@ var rightIdentity = (neutral) => (a, b) => getConst(b)?.value === neutral ? a :
 var IDENTITIES = {
   // x + 0 → x, 0 + x → x
   "i32.add": commutativeIdentity(0),
-  "i64.add": commutativeIdentity(0n),
+  "i64.add": commutativeIdentity(ZERO64),
   // x - 0 → x
   "i32.sub": rightIdentity(0),
-  "i64.sub": rightIdentity(0n),
+  "i64.sub": rightIdentity(ZERO64),
   // x * 1 → x, 1 * x → x
   "i32.mul": commutativeIdentity(1),
-  "i64.mul": commutativeIdentity(1n),
+  "i64.mul": commutativeIdentity(ONE64),
   // x / 1 → x
   "i32.div_s": rightIdentity(1),
   "i32.div_u": rightIdentity(1),
-  "i64.div_s": rightIdentity(1n),
-  "i64.div_u": rightIdentity(1n),
+  "i64.div_s": rightIdentity(ONE64),
+  "i64.div_u": rightIdentity(ONE64),
   // x & -1 → x, -1 & x → x (all bits set)
   "i32.and": commutativeIdentity(-1),
-  "i64.and": commutativeIdentity(-1n),
+  "i64.and": commutativeIdentity(NEG164),
   // x | 0 → x, 0 | x → x
   "i32.or": commutativeIdentity(0),
-  "i64.or": commutativeIdentity(0n),
+  "i64.or": commutativeIdentity(ZERO64),
   // x ^ 0 → x, 0 ^ x → x
   "i32.xor": commutativeIdentity(0),
-  "i64.xor": commutativeIdentity(0n),
+  "i64.xor": commutativeIdentity(ZERO64),
   // x << 0 → x, x >> 0 → x
   "i32.shl": rightIdentity(0),
   "i32.shr_s": rightIdentity(0),
   "i32.shr_u": rightIdentity(0),
-  "i64.shl": rightIdentity(0n),
-  "i64.shr_s": rightIdentity(0n),
-  "i64.shr_u": rightIdentity(0n)
+  "i64.shl": rightIdentity(ZERO64),
+  "i64.shr_s": rightIdentity(ZERO64),
+  "i64.shr_u": rightIdentity(ZERO64)
   // f + 0 → x (careful with -0.0, skip for floats)
   // f * 1 → x (careful with NaN, skip for floats)
 };
 var identity = (ast) => {
-  return walkPost(ast, (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node.length !== 3) return;
     const fn = IDENTITIES[node[0]];
     if (!fn) return;
@@ -3485,7 +3650,7 @@ var identity = (ast) => {
   });
 };
 var strength = (ast) => {
-  return walkPost(ast, (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node.length !== 3) return;
     const [op, a, b] = node;
     if (op === "i32.mul") {
@@ -3501,16 +3666,12 @@ var strength = (ast) => {
       }
     }
     if (op === "i64.mul") {
-      const cb = getConst(b);
-      if (cb && cb.value > 0n && (cb.value & cb.value - 1n) === 0n) {
-        const shift = BigInt(cb.value.toString(2).length - 1);
-        return ["i64.shl", a, ["i64.const", shift]];
-      }
-      const ca = getConst(a);
-      if (ca && ca.value > 0n && (ca.value & ca.value - 1n) === 0n) {
-        const shift = BigInt(ca.value.toString(2).length - 1);
-        return ["i64.shl", b, ["i64.const", shift]];
-      }
+      const cb = getConst(b), vb = cb ? BigInt(cb.value) : null;
+      if (vb != null && vb > 0n && (vb & vb - 1n) === 0n)
+        return ["i64.shl", a, ["i64.const", vb.toString(2).length - 1]];
+      const ca = getConst(a), va = ca ? BigInt(ca.value) : null;
+      if (va != null && va > 0n && (va & va - 1n) === 0n)
+        return ["i64.shl", b, ["i64.const", va.toString(2).length - 1]];
     }
     if (op === "i32.div_u") {
       const cb = getConst(b);
@@ -3520,11 +3681,9 @@ var strength = (ast) => {
       }
     }
     if (op === "i64.div_u") {
-      const cb = getConst(b);
-      if (cb && cb.value > 0n && (cb.value & cb.value - 1n) === 0n) {
-        const shift = BigInt(cb.value.toString(2).length - 1);
-        return ["i64.shr_u", a, ["i64.const", shift]];
-      }
+      const cb = getConst(b), vb = cb ? BigInt(cb.value) : null;
+      if (vb != null && vb > 0n && (vb & vb - 1n) === 0n)
+        return ["i64.shr_u", a, ["i64.const", vb.toString(2).length - 1]];
     }
     if (op === "i32.rem_u") {
       const cb = getConst(b);
@@ -3533,24 +3692,25 @@ var strength = (ast) => {
       }
     }
     if (op === "i64.rem_u") {
-      const cb = getConst(b);
-      if (cb && cb.value > 0n && (cb.value & cb.value - 1n) === 0n) {
-        return ["i64.and", a, ["i64.const", cb.value - 1n]];
-      }
+      const cb = getConst(b), vb = cb ? BigInt(cb.value) : null;
+      if (vb != null && vb > 0n && (vb & vb - 1n) === 0n)
+        return ["i64.and", a, ["i64.const", "0x" + _i64Hex16(vb - 1n)]];
     }
   });
 };
 var branch = (ast) => {
-  return walkPost(ast, (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const op = node[0];
     if (op === "if") {
-      const { cond, thenBranch, elseBranch } = parseIf(node);
+      const { condIdx, cond, thenBranch, elseBranch } = parseIf(node);
       const c = getConst(cond);
       if (!c) return;
-      const taken = c.value !== 0 && c.value !== 0n ? thenBranch : elseBranch;
+      const taken = c.value !== 0 && c.value !== ZERO64 ? thenBranch : elseBranch;
       if (taken && taken.length > 1) {
         const contents = taken.slice(1);
+        const blockType = node.slice(1, condIdx).filter((p) => Array.isArray(p) && (p[0] === "result" || p[0] === "param"));
+        if (blockType.length) return ["block", ...blockType, ...contents];
         return contents.length === 1 ? contents[0] : ["block", ...contents];
       }
       return ["nop"];
@@ -3559,21 +3719,196 @@ var branch = (ast) => {
       const cond = node[node.length - 1];
       const c = getConst(cond);
       if (!c) return;
-      if (c.value === 0 || c.value === 0n) return ["nop"];
+      if (c.value === 0 || c.value === ZERO64) return ["nop"];
       return ["br", node[1]];
     }
     if (op === "select" && node.length >= 4) {
       const cond = node[node.length - 1];
       const c = getConst(cond);
       if (!c) return;
-      if (c.value === 0 || c.value === 0n) return node[2];
+      if (c.value === 0 || c.value === ZERO64) return node[2];
       return node[1];
     }
   });
 };
+var guardRefine = (ast) => {
+  if (Array.isArray(ast)) {
+    for (const node of ast) if (Array.isArray(node) && node[0] === "func") refineGuards(node);
+  }
+  return ast;
+};
+var EMPTY_SET = /* @__PURE__ */ new Set();
+var refineGuards = (fn) => {
+  const ptrAlias = /* @__PURE__ */ new Map();
+  const tagAlias = /* @__PURE__ */ new Map();
+  const eqFact = /* @__PURE__ */ new Map();
+  const neFact = /* @__PURE__ */ new Map();
+  const intVal = (n) => {
+    if (!Array.isArray(n) || n.length !== 2 || n[0] !== "i32.const" && n[0] !== "i64.const") return null;
+    const v = typeof n[1] === "string" ? Number(n[1].replaceAll("_", "")) : Number(n[1]);
+    return Number.isFinite(v) ? v : null;
+  };
+  const i32Val = (n) => Array.isArray(n) && n[0] === "i32.const" ? intVal(n) : null;
+  const ptrSrc = (n) => {
+    if (!Array.isArray(n)) return null;
+    if (n[0] === "i64.reinterpret_f64" && Array.isArray(n[1]) && n[1][0] === "local.get" && typeof n[1][1] === "string") return n[1][1];
+    if (n[0] === "local.get" && typeof n[1] === "string") return ptrAlias.get(n[1]) ?? null;
+    return null;
+  };
+  const tagSrc = (n) => {
+    if (!Array.isArray(n)) return null;
+    const op = n[0];
+    if (op === "local.get" && typeof n[1] === "string") return tagAlias.get(n[1]) ?? null;
+    if (op === "call" && n[1] === "$__ptr_type" && n.length === 3) return ptrSrc(n[2]);
+    const shifted = (m) => Array.isArray(m) && m[0] === "i64.shr_u" && intVal(m[2]) === 47 ? ptrSrc(m[1]) : null;
+    if (op === "i32.and" && n.length === 3) {
+      const [a, b] = i32Val(n[2]) === 15 ? [n[1], null] : i32Val(n[1]) === 15 ? [n[2], null] : [null, null];
+      if (a && Array.isArray(a) && a[0] === "i32.wrap_i64") return shifted(a[1]);
+    }
+    if (op === "i32.wrap_i64" && Array.isArray(n[1]) && n[1][0] === "i64.and") {
+      const m = n[1];
+      if (intVal(m[2]) === 15) return shifted(m[1]);
+      if (intVal(m[1]) === 15) return shifted(m[2]);
+    }
+    return null;
+  };
+  const killLocal = (name2) => {
+    ptrAlias.delete(name2);
+    tagAlias.delete(name2);
+    eqFact.delete(name2);
+    neFact.delete(name2);
+    for (const [p, x] of ptrAlias) if (x === name2) ptrAlias.delete(p);
+    for (const [t, x] of tagAlias) if (x === name2) tagAlias.delete(t);
+  };
+  const writesMemo = /* @__PURE__ */ new Map();
+  const writesOf = (n) => {
+    if (!Array.isArray(n)) return EMPTY_SET;
+    let s = writesMemo.get(n);
+    if (s) return s;
+    s = /* @__PURE__ */ new Set();
+    if ((n[0] === "local.set" || n[0] === "local.tee") && typeof n[1] === "string") s.add(n[1]);
+    for (let i = 1; i < n.length; i++) for (const w of writesOf(n[i])) s.add(w);
+    writesMemo.set(n, s);
+    return s;
+  };
+  const snap = () => [new Map(eqFact), new Map([...neFact].map(([k, s]) => [k, new Set(s)])), new Map(ptrAlias), new Map(tagAlias)];
+  const reset = (m, src) => {
+    m.clear();
+    for (const [k, v] of src) m.set(k, v);
+  };
+  const restore = ([e, n, p, t]) => {
+    reset(eqFact, e);
+    reset(neFact, n);
+    reset(ptrAlias, p);
+    reset(tagAlias, t);
+  };
+  const condFacts = (cond, sense, out) => {
+    if (!Array.isArray(cond)) return out;
+    const op = cond[0];
+    if (op === "i32.eqz") return condFacts(cond[1], !sense, out);
+    if (op === "i32.and" && sense && cond.length === 3) {
+      condFacts(cond[1], true, out);
+      condFacts(cond[2], true, out);
+      return out;
+    }
+    if (op === "i32.or" && !sense && cond.length === 3) {
+      condFacts(cond[1], false, out);
+      condFacts(cond[2], false, out);
+      return out;
+    }
+    if ((op === "i32.eq" || op === "i32.ne") && cond.length === 3) {
+      let x2 = tagSrc(cond[1]), k = i32Val(cond[2]);
+      if (x2 == null || k == null) {
+        x2 = tagSrc(cond[2]);
+        k = i32Val(cond[1]);
+      }
+      if (x2 != null && k != null) out.push({ x: x2, k, eq: op === "i32.eq" === sense });
+      return out;
+    }
+    const x = tagSrc(cond);
+    if (x != null) out.push({ x, k: 0, eq: !sense });
+    return out;
+  };
+  const addFacts = (fs) => {
+    for (const { x, k, eq } of fs) {
+      if (eq) eqFact.set(x, k);
+      else {
+        let s = neFact.get(x);
+        if (!s) neFact.set(x, s = /* @__PURE__ */ new Set());
+        s.add(k);
+      }
+    }
+  };
+  const walkSeq = (node, parent, idx) => {
+    if (!Array.isArray(node)) return;
+    const op = node[0];
+    if (op === "local.set" || op === "local.tee") {
+      if (Array.isArray(node[2])) walkSeq(node[2], node, 2);
+      const name2 = node[1];
+      if (typeof name2 !== "string") return;
+      killLocal(name2);
+      const v = node[2];
+      if (Array.isArray(v)) {
+        if (v[0] === "i64.reinterpret_f64" && Array.isArray(v[1]) && v[1][0] === "local.get" && typeof v[1][1] === "string") ptrAlias.set(name2, v[1][1]);
+        else if (v[0] === "local.get" && typeof v[1] === "string" && ptrAlias.has(v[1])) ptrAlias.set(name2, ptrAlias.get(v[1]));
+        else {
+          const tx2 = tagSrc(v);
+          if (tx2 != null) tagAlias.set(name2, tx2);
+        }
+      }
+      return;
+    }
+    if (op === "if") {
+      const { condIdx } = parseIf(node);
+      if (Array.isArray(node[condIdx])) walkSeq(node[condIdx], node, condIdx);
+      const cond = node[condIdx];
+      const { thenBranch, elseBranch } = parseIf(node);
+      const writes = writesOf(node);
+      const pre = snap();
+      addFacts(condFacts(cond, true, []));
+      if (thenBranch) for (let i = 1; i < thenBranch.length; i++) walkSeq(thenBranch[i], thenBranch, i);
+      restore(pre);
+      addFacts(condFacts(cond, false, []));
+      if (elseBranch) for (let i = 1; i < elseBranch.length; i++) walkSeq(elseBranch[i], elseBranch, i);
+      restore(pre);
+      for (const w of writes) killLocal(w);
+      return;
+    }
+    if (op === "loop") {
+      const writes = writesOf(node);
+      for (const w of writes) killLocal(w);
+      for (let i = 1; i < node.length; i++) walkSeq(node[i], node, i);
+      for (const w of writes) killLocal(w);
+      return;
+    }
+    if (op === "block") {
+      for (let i = 1; i < node.length; i++) walkSeq(node[i], node, i);
+      for (const w of writesOf(node)) killLocal(w);
+      return;
+    }
+    const tx = tagSrc(node);
+    if (tx != null && eqFact.has(tx) && parent) {
+      parent[idx] = ["i32.const", eqFact.get(tx)];
+      return;
+    }
+    if ((op === "i32.eq" || op === "i32.ne") && node.length === 3) {
+      let x = tagSrc(node[1]), k = i32Val(node[2]);
+      if (x == null || k == null) {
+        x = tagSrc(node[2]);
+        k = i32Val(node[1]);
+      }
+      if (x != null && k != null && neFact.get(x)?.has(k) && parent) {
+        parent[idx] = ["i32.const", op === "i32.eq" ? 0 : 1];
+        return;
+      }
+    }
+    for (let i = 1; i < node.length; i++) walkSeq(node[i], node, i);
+  };
+  for (let i = 1; i < fn.length; i++) walkSeq(fn[i], fn, i);
+};
 var TERMINATORS = /* @__PURE__ */ new Set(["unreachable", "return", "br", "br_table"]);
 var deadcode = (ast) => {
-  walk(ast, (node) => {
+  walk2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const kind = node[0];
     if (kind === "func" || kind === "block" || kind === "loop") {
@@ -3619,7 +3954,7 @@ var eliminateDeadInBlock = (block) => {
   }
 };
 var localReuse = (ast) => {
-  walk(ast, (node) => {
+  walk2(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "func") return;
     const localDecls = [];
     const localTypes = /* @__PURE__ */ new Map();
@@ -3640,7 +3975,7 @@ var localReuse = (ast) => {
         }
       }
     }
-    walk(node, (n) => {
+    walk2(node, (n) => {
       if (!Array.isArray(n)) return;
       const op = n[0];
       if (op === "local.get" || op === "local.set" || op === "local.tee") {
@@ -3707,13 +4042,26 @@ var isPure = (node) => {
   for (let i = 1; i < node.length; i++) if (Array.isArray(node[i]) && !isPure(node[i])) return false;
   return true;
 };
+var STRUCTURED_OPS = /* @__PURE__ */ new Set(["if", "then", "else", "block", "loop", "try"]);
+var isEagerValueOp = (op) => typeof op === "string" && !IMPURE_OPS.has(op) && !STRUCTURED_OPS.has(op) && !IMPURE_SUBSTRINGS.some((s) => op.includes(s));
+var dropEffects = (node) => {
+  if (!Array.isArray(node) || isPure(node)) return [];
+  const op = node[0];
+  if (op === "local.tee" && node.length === 3) return [["local.set", node[1], node[2]]];
+  if (isEagerValueOp(op)) {
+    const eff = [];
+    for (let i = 1; i < node.length; i++) eff.push(...dropEffects(node[i]));
+    return eff;
+  }
+  return [["drop", node]];
+};
 var countLocalUses = (node) => {
   const counts = /* @__PURE__ */ new Map();
   const ensure = (name2) => {
     if (!counts.has(name2)) counts.set(name2, { gets: 0, sets: 0, tees: 0 });
     return counts.get(name2);
   };
-  walk(node, (n) => {
+  walk2(node, (n) => {
     if (!Array.isArray(n) || n.length < 2 || typeof n[1] !== "string") return;
     if (n[0] === "local.get") ensure(n[1]).gets++;
     else if (n[0] === "local.set") ensure(n[1]).sets++;
@@ -3729,21 +4077,31 @@ var isTinyConst = (node) => {
     return v >= -64 && v <= 63;
   }
   if (c.type === "i64") {
-    const v = typeof c.value === "bigint" ? c.value : BigInt(c.value);
-    return v >= -64n && v <= 63n;
+    const v = BigInt(c.value);
+    return v <= 63n || v >= 0xffffffffffffffc0n;
   }
   return false;
 };
-var canSubst = (k) => k.pure && k.singleUse || isTinyConst(k.val);
+var isLocalCopy = (val, dest) => Array.isArray(val) && val[0] === "local.get" && val.length === 2 && typeof val[1] === "string" && val[1] !== dest;
+var canSubst = (k) => k.pure && k.singleUse || isTinyConst(k.val) || k.copy;
 var purgeRefs = (known, name2) => {
   for (const [key, tracked] of known) {
     let refs = false;
-    walk(tracked.val, (n) => {
+    walk2(tracked.val, (n) => {
       if (Array.isArray(n) && (n[0] === "local.get" || n[0] === "local.tee") && n[1] === name2) refs = true;
     });
     if (refs) known.delete(key);
   }
 };
+var purgeGlobalRefs = (known, name2) => {
+  for (const [key, tracked] of known) {
+    let refs = false;
+    walk2(tracked.val, (n) => {
+      if (Array.isArray(n) && n[0] === "global.get" && n[1] === name2) refs = true;
+    });
+    if (refs) known.delete(key);
+  }
+};
 var readsMemory = (node) => {
   if (!Array.isArray(node)) return false;
   const op = node[0];
@@ -3779,13 +4137,13 @@ var substGets = (node, known) => {
   const op = node[0];
   if (op === "local.get" && node.length === 2) {
     const k = typeof node[1] === "string" && known.get(node[1]);
-    if (k && canSubst(k)) return clone(k.val);
+    if (k && canSubst(k)) return clone2(k.val);
     return node;
   }
   let inner = known;
-  if (op === "block" || op === "loop" || op === "if") {
+  if (isBranchScope(op)) {
     let cloned = null;
-    walk(node, (n) => {
+    walk2(node, (n) => {
       if (!Array.isArray(n)) return;
       if ((n[0] === "local.set" || n[0] === "local.tee") && typeof n[1] === "string" && known.has(n[1])) {
         if (!cloned) cloned = new Map(known);
@@ -3798,12 +4156,15 @@ var substGets = (node, known) => {
     const r = substGets(node[i], inner);
     if (r !== node[i]) node[i] = r;
     if (i + 1 < node.length && Array.isArray(node[i])) {
-      walk(node[i], (n) => {
+      walk2(node[i], (n) => {
         if (!Array.isArray(n)) return;
         if ((n[0] === "local.set" || n[0] === "local.tee") && typeof n[1] === "string") {
           if (inner === known) inner = new Map(known);
           inner.delete(n[1]);
           purgeRefs(inner, n[1]);
+        } else if (n[0] === "global.set" && typeof n[1] === "string") {
+          if (inner === known) inner = new Map(known);
+          purgeGlobalRefs(inner, n[1]);
         }
       });
     }
@@ -3825,12 +4186,12 @@ var forwardPropagate = (funcNode, params, useCounts) => {
         instr2[2] = sr;
         changed = true;
       }
-      walk(instr2[2], (n) => {
+      walk2(instr2[2], (n) => {
         if (!Array.isArray(n)) return;
         if ((n[0] === "local.set" || n[0] === "local.tee") && typeof n[1] === "string") {
           known.delete(n[1]);
           purgeRefs(known, n[1]);
-        }
+        } else if (n[0] === "global.set" && typeof n[1] === "string") purgeGlobalRefs(known, n[1]);
       });
       const uses = getUseCount(instr2[1]);
       purgeRefs(known, instr2[1]);
@@ -3841,18 +4202,19 @@ var forwardPropagate = (funcNode, params, useCounts) => {
         val: instr2[2],
         pure: isPure(instr2[2]),
         readsMem: readsMemory(instr2[2]),
-        singleUse: uses.gets <= 1 && uses.sets <= 1 && uses.tees === 0
+        singleUse: uses.gets <= 1 && uses.sets <= 1 && uses.tees === 0,
+        copy: isLocalCopy(instr2[2], instr2[1])
       });
       continue;
     }
-    if (op === "block" || op === "loop" || op === "if") known.clear();
+    if (isBranchScope(op)) known.clear();
     if (op === "call" || op === "call_indirect" || op === "return_call" || op === "return_call_indirect") {
       for (const [key, tracked] of known) if (readsCallableState(tracked.val)) known.delete(key);
     }
     if (op === "local.get" && instr2.length === 2 && typeof instr2[1] === "string") {
       const tracked = known.get(instr2[1]);
       if (tracked && canSubst(tracked)) {
-        const replacement = clone(tracked.val);
+        const replacement = clone2(tracked.val);
         instr2.length = 0;
         instr2.push(...Array.isArray(replacement) ? replacement : [replacement]);
         changed = true;
@@ -3860,14 +4222,15 @@ var forwardPropagate = (funcNode, params, useCounts) => {
       }
     }
     if (op !== "block" && op !== "loop" && op !== "if") {
-      const prev = clone(instr2);
+      const prev = clone2(instr2);
       substGets(instr2, known);
       if (!equal(prev, instr2)) changed = true;
-      walk(instr2, (n) => {
-        if (Array.isArray(n) && (n[0] === "local.set" || n[0] === "local.tee") && typeof n[1] === "string") {
+      walk2(instr2, (n) => {
+        if (!Array.isArray(n)) return;
+        if ((n[0] === "local.set" || n[0] === "local.tee") && typeof n[1] === "string") {
           known.delete(n[1]);
           purgeRefs(known, n[1]);
-        }
+        } else if (n[0] === "global.set" && typeof n[1] === "string") purgeGlobalRefs(known, n[1]);
       });
       if (writesMemory(instr2)) {
         for (const [key, tracked] of known) if (tracked.readsMem) known.delete(key);
@@ -3887,7 +4250,7 @@ var eliminateSetGetPairs = (funcNode, params, useCounts) => {
     if (getNode[1] !== name2 || params.has(name2)) continue;
     const uses = useCounts.get(name2) || { gets: 0, sets: 0, tees: 0 };
     if (uses.sets !== 1 || uses.gets !== 1 || uses.tees !== 0) continue;
-    const expr2 = clone(setNode[2]);
+    const expr2 = clone2(setNode[2]);
     funcNode.splice(i, 2, ...Array.isArray(expr2) ? [expr2] : [expr2]);
     changed = true;
     i--;
@@ -3905,7 +4268,7 @@ var createLocalTees = (funcNode, params, useCounts) => {
     if (getNode[1] !== name2 || params.has(name2)) continue;
     const uses = useCounts.get(name2) || { gets: 0, sets: 0, tees: 0 };
     if (uses.sets + uses.gets + uses.tees <= 2) continue;
-    funcNode.splice(i, 2, ["local.tee", name2, clone(setNode[2])]);
+    funcNode.splice(i, 2, ["local.tee", name2, clone2(setNode[2])]);
     changed = true;
   }
   return changed;
@@ -3936,18 +4299,37 @@ var eliminateDeadStores = (funcNode, params, useCounts) => {
   }
   return changed;
 };
+var eliminateAdjacentDeadStores = (funcNode, params) => {
+  let changed = false;
+  for (let i = 1; i < funcNode.length - 1; i++) {
+    const a = funcNode[i], b = funcNode[i + 1];
+    if (!Array.isArray(a) || a[0] !== "local.set" || a.length !== 3) continue;
+    if (!Array.isArray(b) || b[0] !== "local.set" && b[0] !== "local.tee" || b.length !== 3 || b[1] !== a[1]) continue;
+    if (params.has(a[1]) || !isPure(a[2])) continue;
+    let reads = false;
+    walk2(b[2], (n) => {
+      if (Array.isArray(n) && (n[0] === "local.get" || n[0] === "local.tee") && n[1] === a[1]) reads = true;
+    });
+    if (reads) continue;
+    funcNode.splice(i, 1);
+    changed = true;
+    i--;
+  }
+  return changed;
+};
 var isScopeNode = (n) => Array.isArray(n) && (n[0] === "func" || n[0] === "block" || n[0] === "loop" || n[0] === "then" || n[0] === "else");
+var isBranchScope = (op) => op === "block" || op === "loop" || op === "if";
 var propagate = (ast) => {
-  walk(ast, (funcNode) => {
+  walk2(ast, (funcNode) => {
     if (!Array.isArray(funcNode) || funcNode[0] !== "func") return;
     const params = /* @__PURE__ */ new Set();
     for (const sub of funcNode)
       if (Array.isArray(sub) && sub[0] === "param" && typeof sub[1] === "string") params.add(sub[1]);
     const scopes = [];
-    walkPost(funcNode, (n) => {
+    walkPost2(funcNode, (n) => {
       if (isScopeNode(n)) scopes.push(n);
     });
-    for (let round = 0; round < 6; round++) {
+    for (let round = 0; round < MAX_PROP_ROUNDS; round++) {
       const useCounts = countLocalUses(funcNode);
       let progressed = false;
       for (const scope of scopes) {
@@ -3955,157 +4337,464 @@ var propagate = (ast) => {
         if (eliminateSetGetPairs(scope, params, useCounts)) progressed = true;
         if (createLocalTees(scope, params, useCounts)) progressed = true;
         if (eliminateDeadStores(scope, params, useCounts)) progressed = true;
+        if (eliminateAdjacentDeadStores(scope, params)) progressed = true;
       }
       if (!progressed) break;
     }
   });
   return ast;
 };
-var inline = (ast) => {
+var inlineUid = 0;
+var INL_HEAD = /* @__PURE__ */ new Set(["export", "type", "param", "result", "local"]);
+var inlBodyStart = (fn) => {
+  let i = 2;
+  while (i < fn.length && (typeof fn[i] === "string" || Array.isArray(fn[i]) && INL_HEAD.has(fn[i][0]))) i++;
+  return i;
+};
+var inlIsBranch = (op) => op === "br" || op === "br_if" || op === "br_table";
+var inlUnsafe = (n) => {
+  if (!Array.isArray(n)) return false;
+  const op = n[0];
+  if (op === "return_call" || op === "return_call_indirect" || op === "return_call_ref") return true;
+  if (op === "try" || op === "try_table" || op === "delegate" || op === "rethrow") return true;
+  if (inlIsBranch(op)) {
+    for (let i = 1; i < n.length; i++) if (typeof n[i] === "number" || typeof n[i] === "string" && /^\d+$/.test(n[i])) return true;
+  }
+  for (let i = 1; i < n.length; i++) if (inlUnsafe(n[i])) return true;
+  return false;
+};
+var inlCallsSelf = (n, name2) => {
+  if (!Array.isArray(n)) return false;
+  if ((n[0] === "call" || n[0] === "return_call") && n[1] === name2) return true;
+  for (let i = 1; i < n.length; i++) if (inlCallsSelf(n[i], name2)) return true;
+  return false;
+};
+var inlZeroFor = (t) => {
+  if (t === "i32") return ["i32.const", 0];
+  if (t === "i64") return ["i64.const", 0];
+  if (t === "f32") return ["f32.const", 0];
+  if (t === "f64") return ["f64.const", 0];
+  if (t === "v128") return ["v128.const", "i64x2", "0", "0"];
+  return null;
+};
+var inlNeedsReset = (body, name2) => {
+  let seen = false, conditional = false, depth = 0;
+  const visit = (n) => {
+    if (seen || !Array.isArray(n)) return;
+    const op = n[0];
+    const isSet = op === "local.set" || op === "local.tee";
+    if ((isSet || op === "local.get") && n[1] === name2) {
+      if (isSet) for (let i = 2; i < n.length && !seen; i++) visit(n[i]);
+      if (seen) return;
+      seen = true;
+      if (op === "local.get" || depth > 0) conditional = true;
+      return;
+    }
+    const isIf = op === "if";
+    for (let i = 1; i < n.length && !seen; i++) {
+      const c = n[i];
+      const cond = isIf && Array.isArray(c) && (c[0] === "then" || c[0] === "else");
+      if (cond) depth++;
+      visit(c);
+      if (cond) depth--;
+    }
+  };
+  for (const n of body) {
+    if (seen) break;
+    visit(n);
+  }
+  if (!seen) return false;
+  return conditional;
+};
+var inlCollectPinned = (n, pinned) => {
+  if (!Array.isArray(n)) return;
+  const op = n[0];
+  if (op === "export" && Array.isArray(n[2]) && n[2][0] === "func" && typeof n[2][1] === "string") pinned.add(n[2][1]);
+  else if (op === "start" && typeof n[1] === "string") pinned.add(n[1]);
+  else if (op === "ref.func" && typeof n[1] === "string") pinned.add(n[1]);
+  else if (op === "elem") {
+    for (const c of n) if (typeof c === "string" && c[0] === "$") pinned.add(c);
+  }
+  for (const c of n) inlCollectPinned(c, pinned);
+};
+var inlBuildPinned = (ast) => {
+  const pinned = /* @__PURE__ */ new Set();
+  for (const n of ast) if (!Array.isArray(n) || n[0] !== "func") inlCollectPinned(n, pinned);
+  return pinned;
+};
+var inlParse = (fn) => {
+  const params = [], locals = [];
+  let inlResult = null, ok = true, nResult = 0;
+  for (let i = 2; i < fn.length; i++) {
+    const c = fn[i];
+    if (typeof c === "string") continue;
+    if (!Array.isArray(c)) {
+      ok = false;
+      break;
+    }
+    if (c[0] === "param") {
+      if (typeof c[1] !== "string" || c[1][0] !== "$") {
+        ok = false;
+        break;
+      }
+      params.push({ name: c[1], type: c[2] });
+    } else if (c[0] === "local") {
+      if (typeof c[1] !== "string" || c[1][0] !== "$" || !inlZeroFor(c[2])) {
+        ok = false;
+        break;
+      }
+      locals.push({ name: c[1], type: c[2] });
+    } else if (c[0] === "result") {
+      nResult += c.length - 1;
+      if (c.length > 1) inlResult = c[1];
+    } else if (c[0] === "export") {
+      ok = false;
+      break;
+    } else if (c[0] === "type") continue;
+    else break;
+  }
+  if (nResult > 1) ok = false;
+  return ok ? { params, locals, inlResult } : null;
+};
+var inlBodySize = (fn) => {
+  let n = 0;
+  const count = (x) => {
+    if (!Array.isArray(x)) return;
+    n++;
+    for (let i = 1; i < x.length; i++) count(x[i]);
+  };
+  for (let i = inlBodyStart(fn); i < fn.length; i++) count(fn[i]);
+  return n;
+};
+var buildInline = (params, locals, inlResult, cBody, args) => {
+  const uid2 = ++inlineUid;
+  const exit = `$__inl${uid2}`;
+  const rename = /* @__PURE__ */ new Map();
+  for (const p of params) rename.set(p.name, `$__inl${uid2}_${p.name.slice(1)}`);
+  for (const l of locals) rename.set(l.name, `$__inl${uid2}_${l.name.slice(1)}`);
+  const labelRename = /* @__PURE__ */ new Map();
+  const collectLabels = (n) => {
+    if (!Array.isArray(n)) return;
+    if (isBranchScope(n[0]) && typeof n[1] === "string" && n[1][0] === "$" && !labelRename.has(n[1]))
+      labelRename.set(n[1], `$__inl${uid2}L_${n[1].slice(1)}`);
+    for (let i = 1; i < n.length; i++) collectLabels(n[i]);
+  };
+  for (const n of cBody) collectLabels(n);
+  const sub = (n) => {
+    if (!Array.isArray(n)) return n;
+    const op = n[0];
+    if ((op === "local.get" || op === "local.set" || op === "local.tee") && typeof n[1] === "string" && rename.has(n[1]))
+      return [op, rename.get(n[1]), ...n.slice(2).map(sub)];
+    if (op === "return") return ["br", exit, ...n.slice(1).map(sub)];
+    if (isBranchScope(op) && typeof n[1] === "string" && labelRename.has(n[1]))
+      return [op, labelRename.get(n[1]), ...n.slice(2).map(sub)];
+    if (inlIsBranch(op)) return [op, ...n.slice(1).map((c) => typeof c === "string" && labelRename.has(c) ? labelRename.get(c) : sub(c))];
+    return n.map((c, i) => i === 0 ? c : sub(c));
+  };
+  const setup = params.map((p, k) => ["local.set", rename.get(p.name), args[k]]);
+  const resets = locals.filter((l) => inlNeedsReset(cBody, l.name)).map((l) => ["local.set", rename.get(l.name), inlZeroFor(l.type)]);
+  const inner = cBody.map(sub);
+  const block = inlResult ? ["block", exit, ["result", inlResult], ...setup, ...resets, ...inner] : ["block", exit, ...setup, ...resets, ...inner];
+  const decls = [...params, ...locals].map((p) => ["local", rename.get(p.name), p.type]);
+  return { block, decls };
+};
+var INLINE_MAX_NODES = 90;
+var isV128SimdHelper = (params, inlResult) => inlResult === "v128" && params.length > 0 && params.every((p) => p.type === "v128");
+var inline = (ast, { simdOnly = false } = {}) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const inlinable = /* @__PURE__ */ new Map();
-  for (const node of ast.slice(1)) {
-    if (!Array.isArray(node) || node[0] !== "func") continue;
-    const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
-    if (!name2) continue;
-    let params = [];
-    let body = [];
-    let hasLocals = false;
-    let hasExport = false;
-    for (let i = 1; i < node.length; i++) {
-      const sub = node[i];
-      if (!Array.isArray(sub)) continue;
-      if (sub[0] === "param") {
-        if (typeof sub[1] === "string" && sub[1][0] === "$") {
-          params.push({ name: sub[1], type: sub[2] });
-        } else {
-          params = null;
-          break;
-        }
-      } else if (sub[0] === "local") {
-        hasLocals = true;
-      } else if (sub[0] === "export") {
-        hasExport = true;
-      } else if (sub[0] !== "result" && sub[0] !== "type") {
-        body.push(sub);
+  const skip = /* @__PURE__ */ new Set();
+  for (let round = 0; round < MAX_INLINE_ROUNDS; round++) {
+    const funcs = ast.filter((n) => Array.isArray(n) && n[0] === "func");
+    const funcByName = /* @__PURE__ */ new Map();
+    for (const n of funcs) if (typeof n[1] === "string") funcByName.set(n[1], n);
+    const callRefs = /* @__PURE__ */ new Map(), otherRef = /* @__PURE__ */ new Set();
+    const countRefs = (n) => {
+      if (!Array.isArray(n)) return;
+      const op = n[0];
+      if (op === "call" && typeof n[1] === "string") callRefs.set(n[1], (callRefs.get(n[1]) || 0) + 1);
+      else if (op === "return_call" && typeof n[1] === "string") otherRef.add(n[1]);
+      for (let i = 1; i < n.length; i++) countRefs(n[i]);
+    };
+    countRefs(ast);
+    const pinned = /* @__PURE__ */ new Set();
+    for (const n of ast) if (!Array.isArray(n) || n[0] !== "func") inlCollectPinned(n, pinned);
+    let calleeName = null, parsed = null;
+    for (const [name2, fn] of funcByName) {
+      if (skip.has(name2) || pinned.has(name2) || otherRef.has(name2) || SIMD_PROTECTED.has(name2)) continue;
+      if (!(callRefs.get(name2) >= 1)) continue;
+      if (inlBodySize(fn) > INLINE_MAX_NODES) continue;
+      if (inlCallsSelf(fn, name2)) continue;
+      const p = inlParse(fn);
+      if (!p) continue;
+      if (simdOnly && !isV128SimdHelper(p.params, p.inlResult)) continue;
+      let bad = false;
+      for (let i = inlBodyStart(fn); i < fn.length; i++) if (inlUnsafe(fn[i])) {
+        bad = true;
+        break;
       }
+      if (bad) continue;
+      calleeName = name2;
+      parsed = p;
+      break;
     }
-    if (params && !hasLocals && !hasExport && params.length <= 4 && body.length === 1) {
-      const paramNames = new Set(params.map((p) => p.name));
-      let mutatesParam = false;
-      let hasReturn = 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 (n[0] === "return" || n[0] === "return_call" || n[0] === "return_call_indirect") {
-          hasReturn = true;
-        }
-      });
-      if (!mutatesParam && !hasReturn) {
-        inlinable.set(name2, { body: body[0], params });
+    if (!calleeName) break;
+    const callee = funcByName.get(calleeName);
+    const { params, locals, inlResult } = parsed;
+    const cBody = callee.slice(inlBodyStart(callee));
+    const expected = callRefs.get(calleeName) || 0;
+    let replaced = 0;
+    for (const fn of funcs) {
+      if (fn === callee) continue;
+      const addDecls = [];
+      for (let i = inlBodyStart(fn); i < fn.length; i++) {
+        fn[i] = walkPost2(fn[i], (n) => {
+          if (!Array.isArray(n) || n[0] !== "call" || n[1] !== calleeName) return;
+          const args = n.slice(2);
+          if (args.length !== params.length) return;
+          const { block, decls } = buildInline(params, locals, inlResult, cBody, args);
+          addDecls.push(...decls);
+          replaced++;
+          return block;
+        });
       }
+      if (addDecls.length) fn.splice(inlBodyStart(fn), 0, ...addDecls);
     }
+    if (replaced === expected) {
+      const idx = ast.indexOf(callee);
+      if (idx >= 0) ast.splice(idx, 1);
+    } else skip.add(calleeName);
   }
-  if (inlinable.size === 0) return ast;
-  walkPost(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "call") return;
-    const fname = node[1];
-    if (!inlinable.has(fname)) return;
-    const { body, params } = inlinable.get(fname);
-    const args = node.slice(2);
-    if (params.length === 0) {
-      return clone(body);
-    }
-    const substituted = walkPost(clone(body), (n) => {
-      if (!Array.isArray(n) || n[0] !== "local.get") return;
-      const local = n[1];
-      const paramIdx = params.findIndex((p) => p.name === local);
-      if (paramIdx !== -1 && args[paramIdx]) {
-        return clone(args[paramIdx]);
-      }
-    });
-    return substituted;
-  });
   return ast;
 };
-var inlineUid = 0;
-var inlineOnce = (ast) => {
+var devirt = (ast) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const HEAD = /* @__PURE__ */ new Set(["export", "type", "param", "result", "local"]);
-  const bodyStart = (fn) => {
-    let i = 2;
-    while (i < fn.length && (typeof fn[i] === "string" || Array.isArray(fn[i]) && HEAD.has(fn[i][0]))) i++;
-    return i;
-  };
-  const isBranch = (op) => op === "br" || op === "br_if" || op === "br_table";
-  const unsafe = (n) => {
-    if (!Array.isArray(n)) return false;
-    const op = n[0];
-    if (op === "return_call" || op === "return_call_indirect" || op === "return_call_ref") return true;
-    if (op === "try" || op === "try_table" || op === "delegate" || op === "rethrow") return true;
-    if (isBranch(op)) {
-      for (let i = 1; i < n.length; i++) if (typeof n[i] === "number" || typeof n[i] === "string" && /^\d+$/.test(n[i])) return true;
+  const slots = /* @__PURE__ */ new Map(), typeDefs = /* @__PURE__ */ new Map(), funcsByName = /* @__PURE__ */ new Map(), allFuncs = [];
+  let tableMutated = false;
+  walk2(ast, (n) => {
+    if (Array.isArray(n) && typeof n[0] === "string" && (n[0] === "table.set" || n[0] === "table.grow" || n[0] === "table.init" || n[0] === "table.copy" || n[0] === "table.fill")) tableMutated = true;
+  });
+  if (tableMutated) return ast;
+  for (const node of ast.slice(1)) {
+    if (!Array.isArray(node)) continue;
+    if (node[0] === "elem") {
+      const off = node[1];
+      if (!Array.isArray(off) || off[0] !== "i32.const") return ast;
+      let base = Number(off[1]);
+      for (let i = 2; i < node.length; i++)
+        if (typeof node[i] === "string" && node[i][0] === "$") slots.set(base++, node[i]);
+    } else if (node[0] === "type" && typeof node[1] === "string") typeDefs.set(node[1], node[2]);
+    else if (node[0] === "func") {
+      allFuncs.push(node);
+      if (typeof node[1] === "string") funcsByName.set(node[1], node);
     }
-    for (let i = 1; i < n.length; i++) if (unsafe(n[i])) return true;
+  }
+  if (!slots.size) return ast;
+  const globalCands = /* @__PURE__ */ new Map();
+  const isC64 = (n, hex) => Array.isArray(n) && n[0] === "i64.const" && _i64Canon(n[1]) === hex;
+  const MASK15 = "0x0000000000007fff", SHIFT32 = "0x0000000000000020";
+  const boxConsts = (v, out) => {
+    if (!Array.isArray(v)) return false;
+    if (v[0] === "i64.const") {
+      out.push(v);
+      return true;
+    }
+    if (v[0] === "f64.const" && typeof v[1] === "string" && v[1].startsWith("nan:")) {
+      out.push(["i64.const", _i64Canon(v[1].slice(4))]);
+      return true;
+    }
+    if (v[0] === "f64.reinterpret_i64" && v.length === 2) return boxConsts(v[1], out);
+    if (v[0] === "select" && v.length === 4) return boxConsts(v[1], out) && boxConsts(v[2], out);
     return false;
   };
-  const callsSelf = (n, name2) => {
-    if (!Array.isArray(n)) return false;
-    if ((n[0] === "call" || n[0] === "return_call") && n[1] === name2) return true;
-    for (let i = 1; i < n.length; i++) if (callsSelf(n[i], name2)) return true;
+  const globalWrites = /* @__PURE__ */ new Map();
+  walk2(ast, (n) => {
+    if (!Array.isArray(n) || n[0] !== "global.set" || typeof n[1] !== "string") return;
+    if (!globalWrites.has(n[1])) globalWrites.set(n[1], []);
+    globalWrites.get(n[1]).push(n[2]);
+  });
+  const candLeaves = (v, consts, reads) => {
+    if (!Array.isArray(v)) return false;
+    if (v[0] === "i64.const") {
+      consts.push(v);
+      return true;
+    }
+    if (v[0] === "f64.const" && typeof v[1] === "string" && v[1].startsWith("nan:")) {
+      consts.push(["i64.const", _i64Canon(v[1].slice(4))]);
+      return true;
+    }
+    if ((v[0] === "f64.reinterpret_i64" || v[0] === "i64.reinterpret_f64") && v.length === 2)
+      return candLeaves(v[1], consts, reads);
+    if (v[0] === "global.get" && typeof v[1] === "string") {
+      reads.push(v[1]);
+      return true;
+    }
+    if (v[0] === "local.get" || v[0] === "local.tee") {
+      return v[0] === "local.tee" && v.length === 3 ? candLeaves(v[2], consts, reads) : false;
+    }
+    if (v[0] === "select" && v.length === 4)
+      return candLeaves(v[1], consts, reads) && candLeaves(v[2], consts, reads);
+    if (v[0] === "if") {
+      let ok = true, seenArm = false;
+      for (let i = 1; i < v.length; i++) {
+        const p = v[i];
+        if (!Array.isArray(p)) continue;
+        if (p[0] === "then" || p[0] === "else") {
+          seenArm = true;
+          if (p.length !== 2 || !candLeaves(p[1], consts, reads)) ok = false;
+        }
+      }
+      return ok && seenArm;
+    }
     return false;
   };
-  const zeroFor = (t) => {
-    if (t === "i32") return ["i32.const", 0];
-    if (t === "i64") return ["i64.const", 0n];
-    if (t === "f32") return ["f32.const", 0];
-    if (t === "f64") return ["f64.const", 0];
-    if (t === "v128") return ["v128.const", "i64x2", 0n, 0n];
-    return null;
-  };
-  const needsReset = (body, name2) => {
-    let seen = false, conditional = false, depth = 0;
-    const visit = (n) => {
-      if (seen || !Array.isArray(n)) return;
-      const op = n[0];
-      const isSet = op === "local.set" || op === "local.tee";
-      if ((isSet || op === "local.get") && n[1] === name2) {
-        if (isSet) for (let i = 2; i < n.length && !seen; i++) visit(n[i]);
-        if (seen) return;
-        seen = true;
-        if (op === "local.get" || depth > 0) conditional = true;
-        return;
+  const writeFacts = /* @__PURE__ */ new Map();
+  for (const [g, ws] of globalWrites) {
+    let consts = [], reads = [], ok = true;
+    for (const w of ws) if (!candLeaves(w, consts, reads)) {
+      ok = false;
+      break;
+    }
+    writeFacts.set(g, ok ? { consts, reads } : null);
+  }
+  let changed = true;
+  const resolved = /* @__PURE__ */ new Map();
+  while (changed) {
+    changed = false;
+    for (const [g, f] of writeFacts) {
+      if (resolved.get(g) === null) continue;
+      if (f === null) {
+        if (resolved.get(g) !== null) {
+          resolved.set(g, null);
+          changed = true;
+        }
+        continue;
+      }
+      const m = resolved.get(g) || /* @__PURE__ */ new Map();
+      const before = m.size;
+      let poisoned = false;
+      for (const c of f.consts) m.set(_i64Canon(c[1]), c);
+      for (const r of f.reads) {
+        if (writeFacts.get(r) === null || resolved.get(r) === null) {
+          poisoned = true;
+          break;
+        }
+        const rm = resolved.get(r);
+        if (rm) for (const [hex, c] of rm) m.set(hex, c);
       }
-      const isIf = op === "if";
-      for (let i = 1; i < n.length && !seen; i++) {
-        const c = n[i];
-        const cond = isIf && Array.isArray(c) && (c[0] === "then" || c[0] === "else");
-        if (cond) depth++;
-        visit(c);
-        if (cond) depth--;
+      if (poisoned) {
+        resolved.set(g, null);
+        changed = true;
+        continue;
+      }
+      if (!resolved.has(g) || m.size !== before) {
+        resolved.set(g, m);
+        changed = true;
       }
-    };
-    for (const n of body) {
-      if (seen) break;
-      visit(n);
     }
-    if (!seen) return false;
-    return conditional;
+  }
+  for (const [g, m] of resolved) globalCands.set(g, m);
+  const matchSlotOfLocal = (e) => {
+    if (!Array.isArray(e) || e[0] !== "i32.wrap_i64") return null;
+    const a = e[1];
+    if (!Array.isArray(a) || a[0] !== "i64.and") return null;
+    let sh = a[1], mk = a[2];
+    if (!isC64(mk, MASK15)) {
+      sh = a[2];
+      mk = a[1];
+    }
+    if (!isC64(mk, MASK15) || !Array.isArray(sh) || sh[0] !== "i64.shr_u" || !isC64(sh[2], SHIFT32)) return null;
+    const ri = sh[1];
+    if (!Array.isArray(ri) || ri[0] !== "i64.reinterpret_f64") return null;
+    const leaf = ri[1];
+    if (Array.isArray(leaf) && leaf[0] === "local.get" && typeof leaf[1] === "string") return { local: leaf[1] };
+    if (Array.isArray(leaf) && leaf[0] === "global.get" && typeof leaf[1] === "string") return { global: leaf[1] };
+    return null;
   };
-  const collectPinned = (n, pinned) => {
-    if (!Array.isArray(n)) return;
-    const op = n[0];
-    if (op === "export" && Array.isArray(n[2]) && n[2][0] === "func" && typeof n[2][1] === "string") pinned.add(n[2][1]);
-    else if (op === "start" && typeof n[1] === "string") pinned.add(n[1]);
-    else if (op === "ref.func" && typeof n[1] === "string") pinned.add(n[1]);
-    else if (op === "elem") {
-      for (const c of n) if (typeof c === "string" && c[0] === "$") pinned.add(c);
-    }
-    for (const c of n) collectPinned(c, pinned);
+  const tokSig = (parts) => {
+    const ps = [], rs = [];
+    for (const p of parts) {
+      if (!Array.isArray(p)) continue;
+      if (p[0] === "param") {
+        for (const t of p.slice(1)) if (typeof t === "string" && t[0] !== "$") ps.push(t);
+      } else if (p[0] === "result") rs.push(...p.slice(1));
+    }
+    return ps.join(",") + "->" + rs.join(",");
   };
-  for (let round = 0; round < 16; round++) {
+  for (const fn of allFuncs) {
+    const cands = /* @__PURE__ */ new Map();
+    for (const part of fn)
+      if (Array.isArray(part) && part[0] === "param" && typeof part[1] === "string") cands.set(part[1], null);
+    walk2(fn, (n) => {
+      if (!Array.isArray(n) || n[0] !== "local.set" && n[0] !== "local.tee" || typeof n[1] !== "string") return;
+      if (cands.get(n[1]) === null) return;
+      const out = [];
+      if (boxConsts(n[2], out)) {
+        const m = cands.get(n[1]) || /* @__PURE__ */ new Map();
+        for (const c of out) m.set(_i64Canon(c[1]), c);
+        cands.set(n[1], m);
+      } else if (Array.isArray(n[2]) && n[2][0] === "global.get" && typeof n[2][1] === "string" && globalCands.get(n[2][1])) {
+        const g = globalCands.get(n[2][1]);
+        const m = cands.get(n[1]) || /* @__PURE__ */ new Map();
+        for (const [hex, c] of g) m.set(hex, c);
+        cands.set(n[1], m);
+      } else cands.set(n[1], null);
+    });
+    walkPost2(fn, (n, parent) => {
+      if (!Array.isArray(n) || n[0] !== "call_indirect") return;
+      if (parent && parent[0] === "else") return;
+      const typeUse = Array.isArray(n[1]) && n[1][0] === "type" ? n[1] : null;
+      if (!typeUse) return;
+      const sig = typeDefs.get(typeUse[1]);
+      const callSig = Array.isArray(sig) ? tokSig(sig.slice(1)) : null;
+      if (callSig == null) return;
+      const results = [];
+      for (const s of sig.slice(1)) if (Array.isArray(s) && s[0] === "result") results.push(...s.slice(1));
+      const args = n.slice(2, -1);
+      const idx = n[n.length - 1];
+      const sigOk = (name2) => {
+        const target = funcsByName.get(name2);
+        if (!target) return false;
+        const tu = target.find((p) => Array.isArray(p) && p[0] === "type");
+        if (tu) return tu[1] === typeUse[1] || typeDefs.get(tu[1]) && tokSig(typeDefs.get(tu[1]).slice(1)) === callSig;
+        return tokSig(target.slice(2)) === callSig;
+      };
+      if (Array.isArray(idx) && idx[0] === "i32.const") {
+        const name2 = slots.get(Number(idx[1]));
+        return name2 && sigOk(name2) ? ["call", name2, ...args] : void 0;
+      }
+      const f = matchSlotOfLocal(idx);
+      if (!f) return;
+      const m = f.local != null ? cands.get(f.local) : globalCands.get(f.global);
+      if (!m || m.size === 0 || m.size > 4) return;
+      const arms = [];
+      for (const cNode of m.values()) {
+        const name2 = slots.get(_i64HiU(_i64Canon(cNode[1])) & 32767);
+        if (!name2 || !sigOk(name2)) return;
+        arms.push([cNode, name2]);
+      }
+      const readBack = f.local != null ? ["local.get", f.local] : ["global.get", f.global];
+      let out = n;
+      for (let i = arms.length - 1; i >= 0; i--) {
+        const [cNode, name2] = arms[i];
+        out = [
+          "if",
+          ...results.length ? [["result", ...results]] : [],
+          ["i64.eq", ["i64.reinterpret_f64", clone2(readBack)], clone2(cNode)],
+          ["then", ["call", name2, ...args.map(clone2)]],
+          ["else", out]
+        ];
+      }
+      return out;
+    });
+  }
+  return ast;
+};
+var SIMD_PROTECTED = /* @__PURE__ */ new Set(["$math.sin_core", "$math.cos_core", "$math.sin", "$math.cos", "$math.pow", "$math.atan2", "$math.hypot", "$math.log"]);
+var inlineOnce = (ast) => {
+  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
+  const bodyStart = inlBodyStart, callsSelf = inlCallsSelf, unsafe = inlUnsafe, isBranch = inlIsBranch;
+  const zeroFor = inlZeroFor, needsReset = inlNeedsReset;
+  for (let round = 0; round < MAX_INLINE_ROUNDS; round++) {
     const funcs = ast.filter((n) => Array.isArray(n) && n[0] === "func");
     const funcByName = /* @__PURE__ */ new Map();
     for (const n of funcs) if (typeof n[1] === "string") funcByName.set(n[1], n);
@@ -4118,12 +4807,12 @@ var inlineOnce = (ast) => {
       for (let i = 1; i < n.length; i++) countRefs(n[i]);
     };
     countRefs(ast);
-    const pinned = /* @__PURE__ */ new Set();
-    for (const n of ast) if (!Array.isArray(n) || n[0] !== "func") collectPinned(n, pinned);
+    const pinned = inlBuildPinned(ast);
     let calleeName = null;
     for (const [name2, fn] of funcByName) {
       if (pinned.has(name2) || otherRef.has(name2)) continue;
       if (callRefs.get(name2) !== 1) continue;
+      if (SIMD_PROTECTED.has(name2)) continue;
       if (callsSelf(fn, name2)) continue;
       let ok = true, nResult = 0;
       for (let i = 2; i < fn.length; i++) {
@@ -4179,11 +4868,10 @@ var inlineOnce = (ast) => {
     const rename = /* @__PURE__ */ new Map();
     for (const p of params) rename.set(p.name, `$__inl${uid2}_${p.name.slice(1)}`);
     for (const l of locals) rename.set(l.name, `$__inl${uid2}_${l.name.slice(1)}`);
-    const isBlockLabel = (op) => op === "block" || op === "loop" || op === "if";
     const labelRename = /* @__PURE__ */ new Map();
     const collectLabels = (n) => {
       if (!Array.isArray(n)) return;
-      if (isBlockLabel(n[0]) && typeof n[1] === "string" && n[1][0] === "$" && !labelRename.has(n[1]))
+      if (isBranchScope(n[0]) && typeof n[1] === "string" && n[1][0] === "$" && !labelRename.has(n[1]))
         labelRename.set(n[1], `$__inl${uid2}L_${n[1].slice(1)}`);
       for (let i = 1; i < n.length; i++) collectLabels(n[i]);
     };
@@ -4194,7 +4882,7 @@ var inlineOnce = (ast) => {
       if ((op === "local.get" || op === "local.set" || op === "local.tee") && typeof n[1] === "string" && rename.has(n[1]))
         return [op, rename.get(n[1]), ...n.slice(2).map(sub)];
       if (op === "return") return ["br", exit, ...n.slice(1).map(sub)];
-      if (isBlockLabel(op) && typeof n[1] === "string" && labelRename.has(n[1]))
+      if (isBranchScope(op) && typeof n[1] === "string" && labelRename.has(n[1]))
         return [op, labelRename.get(n[1]), ...n.slice(2).map(sub)];
       if (isBranch(op)) return [op, ...n.slice(1).map((c) => typeof c === "string" && labelRename.has(c) ? labelRename.get(c) : sub(c))];
       return n.map((c, i) => i === 0 ? c : sub(c));
@@ -4204,7 +4892,7 @@ var inlineOnce = (ast) => {
       if (fn === callee || done) continue;
       const start = bodyStart(fn);
       for (let i = start; i < fn.length; i++) {
-        const replaced = walkPost(fn[i], (n) => {
+        const replaced = walkPost2(fn[i], (n) => {
           if (done || !Array.isArray(n) || n[0] !== "call" || n[1] !== calleeName) return;
           const args = n.slice(2);
           if (args.length !== params.length) return;
@@ -4269,7 +4957,7 @@ var targetsLabel = (body, label) => {
   return found;
 };
 var mergeBlocks = (ast) => {
-  walkPost(ast, (node) => {
+  walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "block") return;
     let bi = 1, label = null;
     if (typeof node[1] === "string" && node[1][0] === "$") {
@@ -4298,7 +4986,7 @@ var mergeBlocks = (ast) => {
     node.length = 0;
     for (const tok of only) node.push(tok);
   });
-  walk(ast, (node) => {
+  walk2(ast, (node) => {
     if (!isScopeNode(node)) return;
     let i = 1;
     while (i < node.length) {
@@ -4372,7 +5060,7 @@ var mergeBlocks = (ast) => {
   return ast;
 };
 var coalesceLocals = (ast) => {
-  walk(ast, (funcNode) => {
+  walk2(ast, (funcNode) => {
     if (!Array.isArray(funcNode) || funcNode[0] !== "func") return;
     const decls = /* @__PURE__ */ new Map();
     for (const sub of funcNode) {
@@ -4444,7 +5132,7 @@ var coalesceLocals = (ast) => {
       } else slots.push({ primary: name2, type, end: range.end });
     }
     if (rename.size === 0) return;
-    walk(funcNode, (n) => {
+    walk2(funcNode, (n) => {
       if (Array.isArray(n) && (n[0] === "local.get" || n[0] === "local.set" || n[0] === "local.tee") && rename.has(n[1])) {
         n[1] = rename.get(n[1]);
       }
@@ -4453,14 +5141,17 @@ var coalesceLocals = (ast) => {
   return ast;
 };
 var vacuum = (ast) => {
-  return walkPost(ast, (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const op = node[0];
     if (op === "nop") return ["nop"];
-    if (op === "drop" && node.length === 2 && isPure(node[1])) {
-      return ["nop"];
+    if (op === "drop" && node.length === 2) {
+      const eff = dropEffects(node[1]);
+      if (eff.length === 0) return ["nop"];
+      if (eff.length === 1) return eff[0];
+      return ["block", ...eff];
     }
-    if (op === "select" && node.length >= 4 && equal(node[1], node[2])) return node[1];
+    if (op === "select" && node.length >= 4 && equal(node[1], node[2]) && isPure(node[3])) return node[1];
     if (op === "if") {
       const { cond, thenBranch, elseBranch } = parseIf(node);
       const thenEmpty = !thenBranch || thenBranch.length <= 1;
@@ -4470,14 +5161,19 @@ var vacuum = (ast) => {
         return node.filter((c) => c !== elseBranch);
       }
     }
-    if (op === "func" || op === "block" || op === "loop" || op === "then" || op === "else") {
+    if (isScopeNode(node)) {
       const cleaned = [op];
       for (let i = 1; i < node.length; i++) {
         const child = node[i];
         if (child === "nop" || Array.isArray(child) && child[0] === "nop") continue;
         const next = node[i + 1];
         const isDrop = next === "drop" || Array.isArray(next) && next[0] === "drop" && next.length === 1;
-        if (Array.isArray(child) && isPure(child) && isDrop) {
+        if (Array.isArray(child) && isDrop && isPure(child)) {
+          i++;
+          continue;
+        }
+        if (Array.isArray(child) && isDrop && child[0] === "local.tee" && child.length === 3) {
+          cleaned.push(["local.set", child[1], child[2]]);
           i++;
           continue;
         }
@@ -4487,72 +5183,73 @@ var vacuum = (ast) => {
     }
   });
 };
+var selfFold = (val) => (a, b) => equal(a, b) && isPure(a) ? val : null;
 var PEEPHOLE = {
-  // Self-cancelling / tautological binary ops
-  "i32.sub": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
-  "i64.sub": (a, b) => equal(a, b) ? ["i64.const", 0n] : null,
-  "i32.xor": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
-  "i64.xor": (a, b) => equal(a, b) ? ["i64.const", 0n] : null,
-  "i32.eq": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
-  "i64.eq": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
-  "i32.ne": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
-  "i64.ne": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
-  "i32.lt_s": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
-  "i32.lt_u": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
-  "i32.gt_s": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
-  "i32.gt_u": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
-  "i32.le_s": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
-  "i32.le_u": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
-  "i32.ge_s": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
-  "i32.ge_u": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
-  "i64.lt_s": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
-  "i64.lt_u": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
-  "i64.gt_s": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
-  "i64.gt_u": (a, b) => equal(a, b) ? ["i32.const", 0] : null,
-  "i64.le_s": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
-  "i64.le_u": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
-  "i64.ge_s": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
-  "i64.ge_u": (a, b) => equal(a, b) ? ["i32.const", 1] : null,
-  // Zero/all-bits absorption
+  // Self-cancelling / tautological binary ops — drop both (equal) operands.
+  "i32.sub": selfFold(["i32.const", 0]),
+  "i64.sub": selfFold(["i64.const", 0]),
+  "i32.xor": selfFold(["i32.const", 0]),
+  "i64.xor": selfFold(["i64.const", 0]),
+  "i32.eq": selfFold(["i32.const", 1]),
+  "i64.eq": selfFold(["i32.const", 1]),
+  "i32.ne": selfFold(["i32.const", 0]),
+  "i64.ne": selfFold(["i32.const", 0]),
+  "i32.lt_s": selfFold(["i32.const", 0]),
+  "i32.lt_u": selfFold(["i32.const", 0]),
+  "i32.gt_s": selfFold(["i32.const", 0]),
+  "i32.gt_u": selfFold(["i32.const", 0]),
+  "i32.le_s": selfFold(["i32.const", 1]),
+  "i32.le_u": selfFold(["i32.const", 1]),
+  "i32.ge_s": selfFold(["i32.const", 1]),
+  "i32.ge_u": selfFold(["i32.const", 1]),
+  "i64.lt_s": selfFold(["i32.const", 0]),
+  "i64.lt_u": selfFold(["i32.const", 0]),
+  "i64.gt_s": selfFold(["i32.const", 0]),
+  "i64.gt_u": selfFold(["i32.const", 0]),
+  "i64.le_s": selfFold(["i32.const", 1]),
+  "i64.le_u": selfFold(["i32.const", 1]),
+  "i64.ge_s": selfFold(["i32.const", 1]),
+  "i64.ge_u": selfFold(["i32.const", 1]),
+  // Zero/all-bits absorption — drops the NON-const operand, so guard its purity.
   "i32.mul": (a, b) => {
-    const ca = getConst(a), cb = getConst(b);
-    if (ca?.value === 0 || cb?.value === 0) return ["i32.const", 0];
+    if (getConst(b)?.value === 0 && isPure(a)) return ["i32.const", 0];
+    if (getConst(a)?.value === 0 && isPure(b)) return ["i32.const", 0];
     return null;
   },
   "i64.mul": (a, b) => {
-    const ca = getConst(a), cb = getConst(b);
-    if (ca?.value === 0n || cb?.value === 0n) return ["i64.const", 0n];
+    if (getConst(b)?.value === ZERO64 && isPure(a)) return ["i64.const", 0];
+    if (getConst(a)?.value === ZERO64 && isPure(b)) return ["i64.const", 0];
     return null;
   },
   "i32.and": (a, b) => {
-    if (equal(a, b)) return a;
-    const ca = getConst(a), cb = getConst(b);
-    if (ca?.value === 0 || cb?.value === 0) return ["i32.const", 0];
+    if (equal(a, b) && isPure(b)) return a;
+    if (getConst(b)?.value === 0 && isPure(a)) return ["i32.const", 0];
+    if (getConst(a)?.value === 0 && isPure(b)) return ["i32.const", 0];
     return null;
   },
   "i64.and": (a, b) => {
-    if (equal(a, b)) return a;
-    const ca = getConst(a), cb = getConst(b);
-    if (ca?.value === 0n || cb?.value === 0n) return ["i64.const", 0n];
+    if (equal(a, b) && isPure(b)) return a;
+    if (getConst(b)?.value === ZERO64 && isPure(a)) return ["i64.const", 0];
+    if (getConst(a)?.value === ZERO64 && isPure(b)) return ["i64.const", 0];
     return null;
   },
   "i32.or": (a, b) => {
-    if (equal(a, b)) return a;
-    const ca = getConst(a), cb = getConst(b);
-    if (ca?.value === -1 || cb?.value === -1) return ["i32.const", -1];
+    if (equal(a, b) && isPure(b)) return a;
+    if (getConst(b)?.value === -1 && isPure(a)) return ["i32.const", -1];
+    if (getConst(a)?.value === -1 && isPure(b)) return ["i32.const", -1];
     return null;
   },
   "i64.or": (a, b) => {
-    if (equal(a, b)) return a;
-    const ca = getConst(a), cb = getConst(b);
-    if (ca?.value === -1n || cb?.value === -1n) return ["i64.const", -1n];
+    if (equal(a, b) && isPure(b)) return a;
+    if (getConst(b)?.value === NEG164 && isPure(a)) return ["i64.const", -1];
+    if (getConst(a)?.value === NEG164 && isPure(b)) return ["i64.const", -1];
     return null;
   },
   // (local.set $x (local.get $x)) → nop
   "local.set": (a, b) => Array.isArray(b) && b[0] === "local.get" && b[1] === a ? ["nop"] : null
 };
 var peephole = (ast) => {
-  return walkPost(ast, (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node.length !== 3) return;
     const fn = PEEPHOLE[node[0]];
     if (!fn) return;
@@ -4561,7 +5258,8 @@ var peephole = (ast) => {
   });
 };
 var slebSize = (v) => {
-  let x = typeof v === "bigint" ? v : BigInt(Math.trunc(Number(v) || 0));
+  let x = typeof v === "bigint" ? v : typeof v === "string" ? BigInt(v.replaceAll("_", "")) : BigInt(Math.trunc(Number(v) || 0));
+  if (x > 0x7fffffffffffffffn) x = x - 0x8000000000000000n - 0x8000000000000000n;
   let n = 1;
   while (true) {
     const b = x & 0x7fn;
@@ -4609,7 +5307,7 @@ var globals = (ast) => {
   }
   if (constGlobals.size === 0) return ast;
   const reads = /* @__PURE__ */ new Map();
-  walk(ast, (n) => {
+  walk2(ast, (n) => {
     if (!Array.isArray(n)) return;
     const ref = n[1];
     if (typeof ref !== "string" || ref[0] !== "$") return;
@@ -4627,9 +5325,9 @@ var globals = (ast) => {
     if (after <= before) propagate2.add(name2);
   }
   if (propagate2.size === 0) return ast;
-  walkPost(ast, (node) => {
+  walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "global.get" || node.length !== 2) return;
-    if (propagate2.has(node[1])) return clone(constGlobals.get(node[1]));
+    if (propagate2.has(node[1])) return clone2(constGlobals.get(node[1]));
   });
   for (let i = ast.length - 1; i >= 1; i--) {
     const n = ast[i];
@@ -4638,7 +5336,7 @@ var globals = (ast) => {
   return ast;
 };
 var offset = (ast) => {
-  return walkPost(ast, (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const op = node[0];
     if (typeof op !== "string" || !op.endsWith("load") && !op.endsWith("store")) return;
@@ -4689,7 +5387,7 @@ var offset = (ast) => {
   });
 };
 var unbranch = (ast) => {
-  walk(ast, (node) => {
+  walk2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const op = node[0];
     if (op !== "block") return;
@@ -4721,7 +5419,7 @@ var unbranch = (ast) => {
   return ast;
 };
 var loopify = (ast) => {
-  walk(ast, (node) => {
+  walk2(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "block") return;
     let bi = 1, label = null;
     if (typeof node[1] === "string" && node[1][0] === "$") {
@@ -4780,10 +5478,10 @@ var loopify = (ast) => {
 var stripmut = (ast) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
   const written = /* @__PURE__ */ new Set();
-  walk(ast, (n) => {
+  walk2(ast, (n) => {
     if (Array.isArray(n) && n[0] === "global.set" && typeof n[1] === "string") written.add(n[1]);
   });
-  return walkPost(ast, (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "global") return;
     const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
     if (!name2 || written.has(name2)) return;
@@ -4797,7 +5495,7 @@ var stripmut = (ast) => {
   });
 };
 var brif = (ast) => {
-  return walkPost(ast, (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "if") return;
     const { cond, thenBranch, elseBranch } = parseIf(node);
     const thenEmpty = !thenBranch || thenBranch.length <= 1;
@@ -4813,7 +5511,7 @@ var brif = (ast) => {
   });
 };
 var foldarms = (ast) => {
-  return walkPost(ast, (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "if") return;
     const { thenBranch, elseBranch } = parseIf(node);
     if (!thenBranch || !elseBranch) return;
@@ -4886,10 +5584,10 @@ var dedupe = (ast) => {
     if (!name2) continue;
     const localNames = /* @__PURE__ */ new Set();
     if (typeof node[1] === "string" && node[1][0] === "$") localNames.add(node[1]);
-    walk(node, (n) => {
+    walk2(node, (n) => {
       if (!Array.isArray(n) || typeof n[1] !== "string" || n[1][0] !== "$") return;
       const op = n[0];
-      if (op === "param" || op === "local" || op === "block" || op === "loop" || op === "if") {
+      if (op === "param" || op === "local" || isBranchScope(op)) {
         localNames.add(n[1]);
       }
     });
@@ -4901,7 +5599,7 @@ var dedupe = (ast) => {
     }
   }
   if (redirects.size === 0) return ast;
-  walkPost(ast, (node) => {
+  walkPost2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const op = node[0];
     if ((op === "call" || op === "return_call") && redirects.has(node[1])) {
@@ -4948,7 +5646,7 @@ var dedupTypes = (ast) => {
       if (name2 && redirects.has(name2)) ast.splice(i, 1);
     }
   }
-  walkPost(ast, (node) => {
+  walkPost2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const op = node[0];
     if (op === "func") {
@@ -4984,39 +5682,39 @@ var dedupTypes = (ast) => {
   return ast;
 };
 var parseDataString = (str2) => {
-  if (typeof str2 !== "string" || str2.length < 2 || str2[0] !== '"') return new Uint8Array();
-  const inner = str2.slice(1, -1);
+  if (typeof str2 !== "string" || str2.length < 2 || str2[0] !== '"') return [];
   const bytes = [];
-  for (let i = 0; i < inner.length; i++) {
-    if (inner[i] === "\\") {
-      const next = inner[++i];
-      if (next === "x" || next === "X") {
-        bytes.push(parseInt(inner.slice(i + 1, i + 3), 16));
-        i += 2;
-      } else if (/[0-9a-fA-F]/.test(next) && /[0-9a-fA-F]/.test(inner[i + 1])) {
-        bytes.push(parseInt(inner.slice(i, i + 2), 16));
-        i++;
-      } else if (next === "n") bytes.push(10);
-      else if (next === "t") bytes.push(9);
-      else if (next === "r") bytes.push(13);
-      else if (next === "\\") bytes.push(92);
-      else if (next === '"') bytes.push(34);
-      else bytes.push(next.charCodeAt(0));
+  const hexv = (c) => c >= 48 && c <= 57 ? c - 48 : c >= 97 && c <= 102 ? c - 87 : c >= 65 && c <= 70 ? c - 55 : -1;
+  const end = str2.length - 1;
+  for (let i = 1; i < end; i++) {
+    const c = str2.charCodeAt(i);
+    if (c !== 92) {
+      bytes.push(c);
+      continue;
+    }
+    const n = str2.charCodeAt(++i);
+    if (n === 120 || n === 88) {
+      bytes.push(hexv(str2.charCodeAt(i + 1)) << 4 | hexv(str2.charCodeAt(i + 2)));
+      i += 2;
     } else {
-      bytes.push(inner.charCodeAt(i));
+      const h1 = hexv(n), h2 = i + 1 < end ? hexv(str2.charCodeAt(i + 1)) : -1;
+      if (h1 >= 0 && h2 >= 0) {
+        bytes.push(h1 << 4 | h2);
+        i++;
+      } else if (n === 110) bytes.push(10);
+      else if (n === 116) bytes.push(9);
+      else if (n === 114) bytes.push(13);
+      else bytes.push(n);
     }
   }
-  return new Uint8Array(bytes);
+  return bytes;
 };
-var encodeDataString = (bytes) => {
+var encodeDataString = (bytes, end) => {
   let str2 = '"';
-  for (let i = 0; i < bytes.length; i++) {
+  for (let i = 0; i < end; i++) {
     const b = bytes[i];
-    if (b >= 32 && b < 127 && b !== 34 && b !== 92) {
-      str2 += String.fromCharCode(b);
-    } else {
-      str2 += "\\" + b.toString(16).padStart(2, "0");
-    }
+    if (b >= 32 && b < 127 && b !== 34 && b !== 92) str2 += String.fromCharCode(b);
+    else str2 += "\\" + b.toString(16).padStart(2, "0");
   }
   return str2 + '"';
 };
@@ -5024,7 +5722,8 @@ var trimTrailingZeros = (items) => {
   const bytes = [];
   for (const item of items) {
     if (typeof item === "string") {
-      bytes.push(...parseDataString(item));
+      const chunk = parseDataString(item);
+      for (let i = 0; i < chunk.length; i++) bytes.push(chunk[i]);
     } else if (Array.isArray(item) && item[0] === "i8") {
       for (let i = 1; i < item.length; i++) bytes.push(Number(item[i]) & 255);
     } else {
@@ -5035,7 +5734,7 @@ var trimTrailingZeros = (items) => {
   while (end > 0 && bytes[end - 1] === 0) end--;
   if (end === bytes.length) return items;
   if (end === 0) return [];
-  return [encodeDataString(new Uint8Array(bytes.slice(0, end)))];
+  return [encodeDataString(bytes, end)];
 };
 var getDataOffset = (node) => {
   let idx = 1;
@@ -5083,11 +5782,9 @@ var mergeDataSegments = (a, b) => {
   if (aContent.length === 1 && bContent.length === 1 && typeof aContent[0] === "string" && typeof bContent[0] === "string") {
     const aBytes = parseDataString(aContent[0]);
     const bBytes = parseDataString(bContent[0]);
-    const merged = new Uint8Array(aBytes.length + bBytes.length);
-    merged.set(aBytes);
-    merged.set(bBytes, aBytes.length);
+    for (let i = 0; i < bBytes.length; i++) aBytes.push(bBytes[i]);
     a.length = aIdx;
-    a.push(encodeDataString(merged));
+    a.push(encodeDataString(aBytes, aBytes.length));
     return true;
   }
   a.length = aIdx;
@@ -5175,7 +5872,7 @@ var minifyImports = (ast) => {
 };
 var reorderSafe = (ast) => {
   let safe = true;
-  walk(ast, (n) => {
+  walk2(ast, (n) => {
     if (!safe || !Array.isArray(n)) return;
     const op = n[0];
     if (op === "func" && (typeof n[1] !== "string" || n[1][0] !== "$")) safe = false;
@@ -5200,7 +5897,7 @@ var reorder = (ast) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
   if (!reorderSafe(ast)) return ast;
   const callCounts = /* @__PURE__ */ new Map();
-  walk(ast, (n) => {
+  walk2(ast, (n) => {
     if (!Array.isArray(n)) return;
     if (n[0] === "call" || n[0] === "return_call") {
       callCounts.set(n[1], (callCounts.get(n[1]) || 0) + 1);
@@ -5222,12 +5919,14 @@ var reorder = (ast) => {
 var PASSES = [
   ["stripmut", stripmut, true, "strip mut from never-written globals"],
   ["globals", globals, true, "propagate immutable global constants"],
+  ["guardRefine", guardRefine, false, "fold NaN-box tag reads under dominating tag guards (jz NaN-box-specific; opt-in)"],
   ["fold", fold, true, "constant folding"],
   ["identity", identity, true, "remove identity ops (x + 0 \u2192 x)"],
   ["peephole", peephole, true, "x-x\u21920, x&0\u21920, etc."],
   ["strength", strength, true, "strength reduction (x * 2 \u2192 x << 1)"],
   ["branch", branch, true, "simplify constant branches"],
   ["propagate", propagate, true, "forward-propagate single-use locals & tiny consts (never inflates)"],
+  ["devirt", devirt, false, "call_indirect with a constant or known closure-const index \u2192 direct/guarded calls \u2014 grows bytes for speed"],
   ["inlineOnce", inlineOnce, true, "inline single-call functions into their lone caller (never duplicates)"],
   ["inline", inline, false, "inline tiny functions \u2014 can duplicate bodies"],
   ["offset", offset, true, "fold add+const into load/store offset"],
@@ -5260,6 +5959,42 @@ var normalize3 = (opts) => {
   for (const p of PASSES) m[p[0]] = set ? set.has("all") || set.has(p[0]) : p[2];
   return m;
 };
+var mayInline = (ast) => {
+  if (!Array.isArray(ast)) return false;
+  const callRefs = /* @__PURE__ */ new Map(), pinned = /* @__PURE__ */ new Set(), other = /* @__PURE__ */ new Set();
+  const scan = (n) => {
+    if (!Array.isArray(n)) return;
+    const op = n[0];
+    if (op === "call" && typeof n[1] === "string") callRefs.set(n[1], (callRefs.get(n[1]) || 0) + 1);
+    else if (op === "return_call" && typeof n[1] === "string") other.add(n[1]);
+    else if (op === "ref.func" && typeof n[1] === "string") pinned.add(n[1]);
+    else if (op === "export" && Array.isArray(n[2]) && n[2][0] === "func" && typeof n[2][1] === "string") pinned.add(n[2][1]);
+    else if (op === "start" && typeof n[1] === "string") pinned.add(n[1]);
+    else if (op === "elem") {
+      for (const c of n) if (typeof c === "string" && c[0] === "$") pinned.add(c);
+    }
+    for (let i = 1; i < n.length; i++) scan(n[i]);
+  };
+  scan(ast);
+  for (const n of ast) {
+    if (!Array.isArray(n) || n[0] !== "func" || typeof n[1] !== "string") continue;
+    const name2 = n[1];
+    if (callRefs.get(name2) !== 1 || pinned.has(name2) || other.has(name2)) continue;
+    if (n.some((c) => Array.isArray(c) && c[0] === "export")) continue;
+    return true;
+  }
+  return false;
+};
+var START_HEAD = /* @__PURE__ */ new Set(["export", "type", "param", "result", "local"]);
+function pruneEmptyStart(ast) {
+  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
+  const fn = ast.find((n) => Array.isArray(n) && n[0] === "func" && n[1] === "$__start");
+  if (!fn) return ast;
+  let b = 2;
+  while (b < fn.length && Array.isArray(fn[b]) && START_HEAD.has(fn[b][0])) b++;
+  if (b < fn.length) return ast;
+  return ast.filter((n) => !(Array.isArray(n) && (n[0] === "func" && n[1] === "$__start" || n[0] === "start" && n[1] === "$__start")));
+}
 function optimize(ast, opts = true) {
   if (typeof ast === "string") ast = parse_default(ast);
   const strictGuard = opts === true;
@@ -5267,19 +6002,39 @@ function optimize(ast, opts = true) {
   const log = opts.log ? (msg, delta) => opts.log(msg, delta) : () => {
   };
   const verbose = opts.verbose || opts.log;
-  ast = clone(ast);
+  ast = clone2(ast);
+  const runInline = (a) => {
+    if (!opts.inline) return a;
+    a = inline(a, { simdOnly: opts.inline === "simd" });
+    if (opts.propagate) a = propagate(a);
+    if (opts.mergeBlocks) a = mergeBlocks(a);
+    if (opts.vacuum) a = vacuum(a);
+    if (opts.coalesceLocals) a = coalesceLocals(a);
+    return a;
+  };
+  const finish = (a) => {
+    a = runInline(a);
+    return pruneEmptyStart(opts.devirt ? devirt(a) : a);
+  };
+  if (!((opts.inlineOnce || opts.inline) && mayInline(ast))) {
+    for (let round = 0; round < 3; round++) {
+      const beforeRound2 = clone2(ast);
+      for (const [key, fn] of PASSES) if (opts[key] && key !== "inlineOnce" && key !== "inline" && key !== "devirt") ast = fn(ast);
+      if (equal(beforeRound2, ast)) break;
+      if (verbose) log(`  round ${round + 1} applied`);
+    }
+    return finish(ast);
+  }
   let beforeRound = null;
   let sizeBefore = binarySize(ast);
   for (let round = 0; round < 3; round++) {
-    beforeRound = clone(ast);
-    for (const [key, fn] of PASSES) if (opts[key]) ast = fn(ast);
+    beforeRound = clone2(ast);
+    for (const [key, fn] of PASSES) if (opts[key] && key !== "devirt" && key !== "inline") ast = fn(ast);
     if (opts.propagate && (opts.inlineOnce || opts.inline)) ast = propagate(ast);
     if (equal(beforeRound, ast)) break;
     const sizeAfter = binarySize(ast);
     const delta = sizeAfter - sizeBefore;
-    if (verbose || delta !== 0) {
-      log(`  round ${round + 1}: ${delta > 0 ? "+" : ""}${delta} bytes`, delta);
-    }
+    if (verbose || delta !== 0) log(`  round ${round + 1}: ${delta > 0 ? "+" : ""}${delta} bytes`, delta);
     const tolerance = strictGuard ? 0 : 16;
     if (delta > tolerance) {
       if (verbose) log(`  \u26A0 round ${round + 1} inflated by ${delta} bytes, reverting`, delta);
@@ -5288,7 +6043,7 @@ function optimize(ast, opts = true) {
     }
     sizeBefore = sizeAfter;
   }
-  return ast;
+  return finish(ast);
 }
 
 // src/template.js
@@ -5305,11 +6060,11 @@ var exprType = (node, ctx = {}) => {
   if (op === "call" && ctx.funcs?.[args[0]]) return ctx.funcs[args[0]].result?.[0];
   return null;
 };
-function walk2(node, fn) {
+function walk3(node, fn) {
   node = fn(node);
   if (Array.isArray(node)) {
     for (let i = 0; i < node.length; i++) {
-      let child = walk2(node[i], fn);
+      let child = walk3(node[i], fn);
       if (child?._splice) node.splice(i, 1, ...child), i += child.length - 1;
       else node[i] = child;
     }
@@ -5319,7 +6074,7 @@ function walk2(node, fn) {
 function inferImports(ast, funcs) {
   const imports = [];
   const importMap = /* @__PURE__ */ new Map();
-  walk2(ast, (node) => {
+  walk3(ast, (node) => {
     if (!Array.isArray(node)) return node;
     if (node[0] === "call" && typeof node[1] === "function") {
       const fn = node[1];
@@ -5360,7 +6115,7 @@ function compile2(backend2, source, values) {
     let ast = parse(src);
     const funcsToImport = [];
     let idx = 0;
-    ast = walk2(ast, (node) => {
+    ast = walk3(ast, (node) => {
       if (node === PUA) {
         const value = values[idx++];
         if (typeof value === "function") {