watr 4.7.1 → 5.0.0

package/dist/watr.js

@@ -56,17 +56,6 @@ var str = (s) => {
   return bytes;
 };
 var unescape = (s) => tdec.decode(new Uint8Array(str(s)));
-var clone = (node) => Array.isArray(node) ? node.map(clone) : node;
-var walk = (node, fn, parent, idx) => {
-  fn(node, parent, idx);
-  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) walk(node[i], fn, node, i);
-};
-var walkPost = (node, fn, parent, idx) => {
-  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) walkPost(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;
-};
 
 // src/encode.js
 var uleb = (n, buffer = []) => {
@@ -1381,7 +1370,7 @@ var cleanup = (node, result) => {
   result.loc = node.loc;
   return result.length === 1 && result[0]?.[0] === "module" ? result[0] : result;
 };
-function compile(nodes) {
+function assemble(nodes, sizeOnly) {
   if (typeof nodes === "string") err.src = nodes, nodes = parse_default(nodes) || [];
   else err.src = "";
   err.loc = 0;
@@ -1389,8 +1378,11 @@ function compile(nodes) {
   let idx = 0;
   if (nodes[0] === "module") idx++, isId(nodes[idx]) && idx++;
   else if (typeof nodes[0] === "string") nodes = [nodes];
-  if (nodes[idx] === "binary") return Uint8Array.from(nodes.slice(++idx).flat());
-  if (nodes[idx] === "quote") return compile(nodes.slice(++idx).map((v) => v.valueOf().slice(1, -1)).flat().join(""));
+  if (nodes[idx] === "binary") {
+    const b = Uint8Array.from(nodes.slice(++idx).flat());
+    return sizeOnly ? b.length : b;
+  }
+  if (nodes[idx] === "quote") return assemble(nodes.slice(++idx).map((v) => v.valueOf().slice(1, -1)).flat().join(""), sizeOnly);
   nodes = nodes.flatMap((n, i) => {
     if (i < idx || !Array.isArray(n) || n[0] !== "import") return [n];
     const [, mod, ...rest] = n;
@@ -1503,6 +1495,32 @@ function compile(nodes) {
   };
   const globalSection = bin(SECTION.global);
   const elemSection = bin(SECTION.elem);
+  if (sizeOnly) {
+    const codeSizes = ctx.code.filter(Boolean).map((item) => codeItemSize(item, ctx));
+    const innerLen = codeSizes.length ? ulebSize(codeSizes.length) + codeSizes.reduce((a, b) => a + b, 0) : 0;
+    const codeSecLen = codeSizes.length ? 1 + ulebSize(innerLen) + innerLen : 0;
+    const metaSection2 = binMeta();
+    const dataSection2 = bin(SECTION.data);
+    const stringsSection2 = ctx.strings.length ? [SECTION.strings, ...vec([0, ...vec(ctx.strings.map((s) => vec(s)))])] : [];
+    const others = [
+      bin(SECTION.custom),
+      bin(SECTION.type),
+      bin(SECTION.import),
+      bin(SECTION.func),
+      bin(SECTION.table),
+      bin(SECTION.memory),
+      bin(SECTION.tag),
+      stringsSection2,
+      globalSection,
+      bin(SECTION.export),
+      bin(SECTION.start, false),
+      elemSection,
+      bin(SECTION.datacount, false),
+      metaSection2,
+      dataSection2
+    ];
+    return 8 + codeSecLen + others.reduce((s, sec) => s + sec.length, 0);
+  }
   const codeItems = ctx.code.filter(Boolean).map((item) => build[SECTION.code](item, ctx)).filter(Boolean);
   const codeSection = codeItems.length ? [SECTION.code, ...vec(vec(codeItems))] : [];
   const metaSection = binMeta();
@@ -1566,6 +1584,9 @@ function compile(nodes) {
     return out;
   }
 }
+function compile(nodes) {
+  return assemble(nodes);
+}
 var isIdx = (n) => n?.[0] === "$" || !isNaN(n);
 var isId = (n) => n?.[0] === "$";
 var isMemParam = (n) => n?.[0] === "a" || n?.[0] === "o";
@@ -1775,7 +1796,7 @@ var build = [
   // (elem (table idx)? (offset expr)|(expr) elem*) - active
   // ref: https://webassembly.github.io/spec/core/binary/modules.html#element-section
   (parts, ctx) => {
-    let passive = 0, declare = 0, elexpr = 0, nofunc = 0, tabidx, offset2, rt;
+    let passive = 0, declare = 0, elexpr = 0, nofunc = 0, tabidx, offset, rt;
     if (parts[0] === "declare") parts.shift(), declare = 1;
     if (parts[0]?.[0] === "table") {
       [, tabidx] = parts.shift();
@@ -1784,9 +1805,9 @@ var build = [
       tabidx = id(parts.shift(), ctx.table);
     }
     if (parts[0]?.[0] === "offset" || Array.isArray(parts[0]) && parts[0][0] !== "item" && !parts[0][0].startsWith("ref")) {
-      offset2 = parts.shift();
-      if (offset2[0] === "offset") [, offset2] = offset2;
-      offset2 = expr(offset2, ctx);
+      offset = parts.shift();
+      if (offset[0] === "offset") [, offset] = offset;
+      offset = expr(offset, ctx);
     } else if (!declare) passive = 1;
     if (TYPE[parts[0]] || parts[0]?.[0] === "ref") rt = reftype(parts.shift(), ctx);
     else if (parts[0] === "func") rt = [TYPE[parts.shift()]];
@@ -1802,19 +1823,19 @@ var build = [
     return [
       mode,
       ...// 0b000 e:expr y*:vec(funcidx)                     | type=(ref func), init ((ref.func y)end)*, active (table=0,offset=e)
-      mode === 0 ? offset2 : (
+      mode === 0 ? offset : (
         // 0b001 et:elkind y*:vec(funcidx)                  | type=0x00, init ((ref.func y)end)*, passive
         mode === 1 ? [0] : (
           // 0b010 x:tabidx e:expr et:elkind y*:vec(funcidx)  | type=0x00, init ((ref.func y)end)*, active (table=x,offset=e)
-          mode === 2 ? [...uleb(tabidx || 0), ...offset2, 0] : (
+          mode === 2 ? [...uleb(tabidx || 0), ...offset, 0] : (
             // 0b011 et:elkind y*:vec(funcidx)                  | type=0x00, init ((ref.func y)end)*, passive declare
             mode === 3 ? [0] : (
               // 0b100 e:expr el*:vec(expr)                       | type=(ref null func), init el*, active (table=0, offset=e)
-              mode === 4 ? offset2 : (
+              mode === 4 ? offset : (
                 // 0b101 et:reftype el*:vec(expr)                   | type=et, init el*, passive
                 mode === 5 ? rt : (
                   // 0b110 x:tabidx e:expr et:reftype el*:vec(expr)   | type=et, init el*, active (table=x, offset=e)
-                  mode === 6 ? [...uleb(tabidx || 0), ...offset2, ...rt] : (
+                  mode === 6 ? [...uleb(tabidx || 0), ...offset, ...rt] : (
                     // 0b111 et:reftype el*:vec(expr)                   | type=et, init el*, passive declare
                     rt
                   )
@@ -1875,7 +1896,7 @@ var build = [
   // (data (global.get $x) "\aa" "\bb"?)
   // (data (i8 1 2 3) ...) numeric values (WAT numeric values, Phase 2)
   (inits, ctx) => {
-    let offset2, memidx = 0;
+    let offset, memidx = 0;
     if (inits[0]?.[0] === "memory") {
       [, memidx] = inits.shift();
       memidx = id(memidx, ctx.memory);
@@ -1883,15 +1904,15 @@ var build = [
       memidx = id(inits.shift(), ctx.memory);
     }
     if (Array.isArray(inits[0]) && typeof inits[0]?.[0] === "string") {
-      offset2 = inits.shift();
-      if (offset2[0] === "offset") [, offset2] = offset2;
-      offset2 ?? err("Bad offset", offset2);
+      offset = inits.shift();
+      if (offset[0] === "offset") [, offset] = offset;
+      offset ?? err("Bad offset", offset);
     }
     return [
       ...// active: 2, x=memidx, e=expr
-      memidx ? [2, ...uleb(memidx), ...expr(offset2, ctx)] : (
+      memidx ? [2, ...uleb(memidx), ...expr(offset, ctx)] : (
         // active: 0, e=expr
-        offset2 ? [0, ...expr(offset2, ctx)] : (
+        offset ? [0, ...expr(offset, ctx)] : (
           // passive: 1
           [1]
         )
@@ -2105,16 +2126,72 @@ var instr = (nodes, ctx) => {
   }
   return out.push(11), out;
 };
+var ulebSize = (n) => uleb(n).length;
+var instrSize = (nodes, ctx) => {
+  let size = 0, meta = [];
+  while (nodes?.length) {
+    let op = nodes.shift();
+    if (op?.[0] === "@metadata") {
+      meta.push(op.slice(1));
+      continue;
+    }
+    if (Array.isArray(op)) {
+      op.loc != null && (err.loc = op.loc);
+      err(`Unknown instruction ${op[0]}`);
+    }
+    const opc = INSTR[op] || err(`Unknown instruction ${op}`);
+    let n = opc.length;
+    if (HANDLER[op]) n += HANDLER[op](nodes, ctx, op).length;
+    if (meta.length) {
+      for (const [type, data] of meta) (ctx.meta[type] ??= []).push([size, data]);
+      meta = [];
+    }
+    size += n;
+  }
+  return size + 1;
+};
+var codeItemSize = (body, ctx) => {
+  let [typeidx, param] = body.shift();
+  if (!param) [, [param]] = ctx.type[id(typeidx, ctx.type)];
+  ctx.local = Object.create(param);
+  ctx.block = [];
+  ctx.local.name = "local";
+  ctx.block.name = "block";
+  if (ctx._codeIdx === void 0) ctx._codeIdx = 0;
+  let codeIdx = ctx._codeIdx++;
+  while (body[0]?.[0] === "local") {
+    let [, ...types] = body.shift();
+    if (isId(types[0])) {
+      let nm = types.shift();
+      if (nm in ctx.local) err(`Duplicate local ${nm}`);
+      else ctx.local[nm] = ctx.local.length;
+    }
+    ctx.local.push(...types);
+  }
+  ctx.meta = {};
+  const bytesLen = instrSize(body, ctx);
+  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;
+  const bodyLen = locals.length + bytesLen;
+  (ctx.codeSizePrefix ??= [])[codeIdx] = ulebSize(bodyLen);
+  return ulebSize(bodyLen) + bodyLen;
+};
 var expr = (node, ctx) => instr(normalize([node], ctx), ctx);
 var id = (nm, list, n) => (n = isId(nm) ? list[nm] : +nm, n in list ? n : err(`Unknown ${list.name} ${nm}`));
 var blockid = (nm, block, i) => (i = isId(nm) ? block.length - block[nm] : +nm, isNaN(i) || i > block.length ? err(`Bad label ${nm}`) : i);
 var memarg = (args) => {
-  let align2, offset2, k, v;
-  while (isMemParam(args[0])) [k, v] = args.shift().split("="), k === "offset" ? offset2 = +v : k === "align" ? align2 = +v : err(`Unknown param ${k}=${v}`);
-  if (offset2 < 0 || offset2 > 4294967295) err(`Bad offset ${offset2}`);
+  let align2, offset, k, v;
+  while (isMemParam(args[0])) [k, v] = args.shift().split("="), k === "offset" ? offset = +v : k === "align" ? align2 = +v : err(`Unknown param ${k}=${v}`);
+  if (offset < 0 || offset > 4294967295) err(`Bad offset ${offset}`);
   if (align2 <= 0 || align2 > 4294967295) err(`Bad align ${align2}`);
   if (align2) (align2 = Math.log2(align2)) % 1 && err(`Bad align ${align2}`);
-  return [align2, offset2];
+  return [align2, offset];
 };
 var memargEnc = (nodes, op, memIdx = 0) => {
   const [a, o] = memarg(nodes), alignVal = (a ?? align(op)) | (memIdx && 64);
@@ -2235,3846 +2312,40 @@ function print(tree, options = {}) {
   }
 }
 
-// src/polyfill.js
-var findNodes = (ast, kind) => {
-  const nodes = [];
-  const start = ast[0] === "module" ? 1 : 0;
-  for (let i = start; i < ast.length; i++) {
-    if (Array.isArray(ast[i]) && ast[i][0] === kind) nodes.push({ node: ast[i], idx: i });
-  }
-  return nodes;
-};
-var insert = (ast, idx, node) => ast.splice(idx, 0, node);
-var uid = 0;
-var genId = (prefix) => `$__${prefix}${uid++}`;
-var funcref = (ast, ctx) => {
-  const refs = /* @__PURE__ */ new Set();
-  walk(ast, (node) => {
-    if (Array.isArray(node) && node[0] === "ref.func") refs.add(node[1]);
-  });
-  if (!refs.size) return ast;
-  const tableId = genId("fntbl");
-  const refList = [...refs];
-  const refIdx = Object.fromEntries(refList.map((r, i) => [r, i]));
-  const funcs = findNodes(ast, "func");
-  const insertPos = funcs.length ? funcs[0].idx : ast[0] === "module" ? 1 : 0;
-  insert(ast, insertPos, ["table", tableId, "funcref", ["elem", ...refList]]);
-  const funcSigs = {};
-  walk(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "func") return;
-    const id2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
-    if (!id2) return;
-    const params = [], results = [];
-    for (const part of node) {
-      if (Array.isArray(part) && part[0] === "param") {
-        for (let i = 1; i < part.length; i++) if (part[i][0] !== "$") params.push(part[i]);
-      }
-      if (Array.isArray(part) && part[0] === "result") {
-        for (let i = 1; i < part.length; i++) results.push(part[i]);
-      }
-    }
-    funcSigs[id2] = { params, results };
-  });
-  walkPost(ast, (node, parent, idx) => {
-    if (!Array.isArray(node) || !parent) return;
-    if (node[0] === "ref.func" && refIdx[node[1]] !== void 0) {
-      parent[idx] = ["i32.const", refIdx[node[1]]];
-    }
-    if (node[0] === "call_ref") {
-      const typeRef = node[1];
-      const args = node.slice(2);
-      parent[idx] = ["call_indirect", tableId, ["type", typeRef], ...args];
-    }
-    if (node[0] === "return_call_ref") {
-      const typeRef = node[1];
-      const args = node.slice(2);
-      parent[idx] = ["return_call_indirect", tableId, ["type", typeRef], ...args];
-    }
-  });
-  return ast;
-};
-var SIGN_EXT_SHIFTS = {
-  "i32.extend8_s": ["i32", 24],
-  "i32.extend16_s": ["i32", 16],
-  "i64.extend8_s": ["i64", 56n],
-  "i64.extend16_s": ["i64", 48n],
-  "i64.extend32_s": ["i64", 32n]
-};
-var sign_ext = (ast, ctx) => {
-  walkPost(ast, (node, parent, idx) => {
-    if (!Array.isArray(node) || !parent) return;
-    const info = SIGN_EXT_SHIFTS[node[0]];
-    if (!info) return;
-    const [type, shift] = info;
-    const arg = node.slice(1);
-    parent[idx] = [
-      `${type}.shr_s`,
-      [`${type}.shl`, ...arg, [`${type}.const`, shift]],
-      [`${type}.const`, shift]
-    ];
-  });
-  return ast;
-};
-var TRUNC_SAT_INFO = {
-  "i32.trunc_sat_f32_s": { itype: "i32", ftype: "f32", signed: true, min: -2147483648, max: 2147483647 },
-  "i32.trunc_sat_f32_u": { itype: "i32", ftype: "f32", signed: false, min: 0, max: 4294967295 },
-  "i32.trunc_sat_f64_s": { itype: "i32", ftype: "f64", signed: true, min: -2147483648, max: 2147483647 },
-  "i32.trunc_sat_f64_u": { itype: "i32", ftype: "f64", signed: false, min: 0, max: 4294967295 },
-  "i64.trunc_sat_f32_s": { itype: "i64", ftype: "f32", signed: true, min: -9223372036854775808n, max: 9223372036854775807n },
-  "i64.trunc_sat_f32_u": { itype: "i64", ftype: "f32", signed: false, min: 0n, max: 18446744073709551615n },
-  "i64.trunc_sat_f64_s": { itype: "i64", ftype: "f64", signed: true, min: -9223372036854775808n, max: 9223372036854775807n },
-  "i64.trunc_sat_f64_u": { itype: "i64", ftype: "f64", signed: false, min: 0n, max: 18446744073709551615n }
-};
-var nontrapping = (ast, ctx) => {
-  const used = /* @__PURE__ */ new Set();
-  walk(ast, (node) => {
-    if (Array.isArray(node) && TRUNC_SAT_INFO[node[0]]) used.add(node[0]);
-  });
-  if (!used.size) return ast;
-  const helpers = {};
-  for (const op of used) {
-    const { itype, ftype, signed, min, max } = TRUNC_SAT_INFO[op];
-    const id2 = genId(`trunc_${itype}_${ftype}_${signed ? "s" : "u"}`);
-    helpers[op] = id2;
-    const truncOp = `${itype}.trunc_${ftype}_${signed ? "s" : "u"}`;
-    const zero = itype === "i64" ? 0n : 0;
-    const helper = [
-      "func",
-      id2,
-      ["param", "$v", ftype],
-      ["result", itype],
-      // NaN check: if v != v return 0
-      [
-        "if",
-        ["result", itype],
-        [`${ftype}.ne`, ["local.get", "$v"], ["local.get", "$v"]],
-        ["then", [`${itype}.const`, zero]],
-        [
-          "else",
-          // Below min check
-          [
-            "if",
-            ["result", itype],
-            [`${ftype}.lt`, ["local.get", "$v"], [`${ftype}.const`, typeof min === "bigint" ? Number(min) : min]],
-            ["then", [`${itype}.const`, min]],
-            [
-              "else",
-              // Above max check
-              [
-                "if",
-                ["result", itype],
-                [`${ftype}.gt`, ["local.get", "$v"], [`${ftype}.const`, typeof max === "bigint" ? Number(max) : max]],
-                ["then", [`${itype}.const`, max]],
-                ["else", [truncOp, ["local.get", "$v"]]]
-              ]
-            ]
-          ]
-        ]
-      ]
-    ];
-    ast.push(helper);
-  }
-  walkPost(ast, (node, parent, idx) => {
-    if (!Array.isArray(node) || !parent) return;
-    if (helpers[node[0]]) {
-      parent[idx] = ["call", helpers[node[0]], ...node.slice(1)];
-    }
-  });
-  return ast;
-};
-var bulk_memory = (ast, ctx) => {
-  const needsCopy = /* @__PURE__ */ new Set(), needsFill = /* @__PURE__ */ new Set();
-  walk(ast, (node) => {
-    if (!Array.isArray(node)) return;
-    if (node[0] === "memory.copy") {
-      const m1 = typeof node[1] === "number" ? node[1] : 0;
-      const m2 = typeof node[2] === "number" ? node[2] : 0;
-      needsCopy.add(`${m1}_${m2}`);
-    }
-    if (node[0] === "memory.fill") {
-      const m = typeof node[1] === "number" ? node[1] : 0;
-      needsFill.add(m);
-    }
-  });
-  const copyHelpers = {}, fillHelpers = {};
-  for (const key of needsCopy) {
-    const [m1, m2] = key.split("_").map(Number);
-    const id2 = genId(`memcpy${key === "0_0" ? "" : "_" + key}`);
-    copyHelpers[key] = id2;
-    const store = m1 ? ["i32.store8", m1] : ["i32.store8"];
-    const load = m2 ? ["i32.load8_u", m2] : ["i32.load8_u"];
-    ast.push([
-      "func",
-      id2,
-      ["param", "$dst", "i32"],
-      ["param", "$src", "i32"],
-      ["param", "$len", "i32"],
-      ["local", "$i", "i32"],
-      [
-        "block",
-        "$done",
-        [
-          "loop",
-          "$loop",
-          ["br_if", "$done", ["i32.ge_u", ["local.get", "$i"], ["local.get", "$len"]]],
-          [
-            ...store,
-            ["i32.add", ["local.get", "$dst"], ["local.get", "$i"]],
-            [...load, ["i32.add", ["local.get", "$src"], ["local.get", "$i"]]]
-          ],
-          ["local.set", "$i", ["i32.add", ["local.get", "$i"], ["i32.const", 1]]],
-          ["br", "$loop"]
-        ]
-      ]
-    ]);
-  }
-  for (const m of needsFill) {
-    const id2 = genId(`memset${m === 0 ? "" : "_" + m}`);
-    fillHelpers[m] = id2;
-    const store = m ? ["i32.store8", m] : ["i32.store8"];
-    ast.push([
-      "func",
-      id2,
-      ["param", "$dst", "i32"],
-      ["param", "$val", "i32"],
-      ["param", "$len", "i32"],
-      ["local", "$i", "i32"],
-      [
-        "block",
-        "$done",
-        [
-          "loop",
-          "$loop",
-          ["br_if", "$done", ["i32.ge_u", ["local.get", "$i"], ["local.get", "$len"]]],
-          [
-            ...store,
-            ["i32.add", ["local.get", "$dst"], ["local.get", "$i"]],
-            ["local.get", "$val"]
-          ],
-          ["local.set", "$i", ["i32.add", ["local.get", "$i"], ["i32.const", 1]]],
-          ["br", "$loop"]
-        ]
-      ]
-    ]);
+// src/template.js
+var PUA = "\uE000";
+function applyTransform(fn, name2, ast, opt) {
+  if (typeof fn !== "function")
+    throw Error(`watr: '${name2}' is not bundled in this entry \u2014 import it from 'watr/${name2}' and compose: compile(${name2}(src))`);
+  return fn(ast, opt);
+}
+var exprType = (node, ctx = {}) => {
+  if (!Array.isArray(node)) {
+    if (typeof node === "string" && node[0] === "$" && ctx.locals?.[node]) return ctx.locals[node];
+    return null;
   }
-  walkPost(ast, (node, parent, idx) => {
-    if (!Array.isArray(node) || !parent) return;
-    if (node[0] === "memory.copy") {
-      const m1 = typeof node[1] === "number" ? node[1] : 0;
-      const m2 = typeof node[2] === "number" ? node[2] : 0;
-      const args = node.filter((n) => Array.isArray(n) || typeof n === "string" && n[0] === "$");
-      parent[idx] = ["call", copyHelpers[`${m1}_${m2}`], ...args];
-    }
-    if (node[0] === "memory.fill") {
-      const m = typeof node[1] === "number" ? node[1] : 0;
-      const args = node.filter((n) => Array.isArray(n) || typeof n === "string" && n[0] === "$");
-      parent[idx] = ["call", fillHelpers[m], ...args];
-    }
-  });
-  return ast;
-};
-var return_call_transform = (ast, ctx) => {
-  let hasAnyTailCall = false;
-  walk(ast, (node) => {
-    if (Array.isArray(node) && (node[0] === "return_call" || node[0] === "return_call_indirect")) {
-      hasAnyTailCall = true;
-    }
-  });
-  if (!hasAnyTailCall) return ast;
-  walkPost(ast, (node, parent, idx) => {
-    if (!Array.isArray(node) || !parent) return;
-    if (node[0] === "return_call") {
-      parent[idx] = ["return", ["call", ...node.slice(1)]];
-    }
-    if (node[0] === "return_call_indirect") {
-      parent[idx] = ["return", ["call_indirect", ...node.slice(1)]];
-    }
-  });
-  return ast;
-};
-var i31ref = (ast, ctx) => {
-  walkPost(ast, (node, parent, idx) => {
-    if (!Array.isArray(node) || !parent) return;
-    if (node[0] === "ref.i31") {
-      parent[idx] = ["i32.and", ...node.slice(1), ["i32.const", 2147483647]];
-    }
-    if (node[0] === "i31.get_u") {
-      parent[idx] = node.length > 1 ? node[1] : ["drop"];
-    }
-    if (node[0] === "i31.get_s") {
-      const arg = node.slice(1);
-      parent[idx] = ["i32.shr_s", ["i32.shl", ...arg, ["i32.const", 1]], ["i32.const", 1]];
-    }
-  });
-  return ast;
-};
-var extended_const = (ast, ctx) => {
-  const globals2 = {};
-  walk(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "global") return;
-    const id2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
-    if (!id2) return;
-    for (let i = node.length - 1; i >= 0; i--) {
-      const init = node[i];
-      if (!Array.isArray(init)) continue;
-      if (init[0] === "i32.const" || init[0] === "i64.const" || init[0] === "f32.const" || init[0] === "f64.const") {
-        globals2[id2] = { type: init[0].split(".")[0], value: init[1] };
-        break;
-      }
-    }
-  });
-  const evalConst = (node) => {
-    if (!Array.isArray(node)) return node;
-    const op = node[0];
-    if (op === "global.get" && globals2[node[1]]) {
-      const g = globals2[node[1]];
-      return [`${g.type}.const`, g.value];
-    }
-    if (op === "i32.add" || op === "i64.add") {
-      const a = evalConst(node[1]), b = evalConst(node[2]);
-      if (a && b && a[0]?.endsWith(".const") && b[0]?.endsWith(".const")) {
-        const type = op.split(".")[0];
-        const va = type === "i64" ? BigInt(a[1]) : Number(a[1]);
-        const vb = type === "i64" ? BigInt(b[1]) : Number(b[1]);
-        return [`${type}.const`, va + vb];
-      }
-    }
-    if (op === "i32.sub" || op === "i64.sub") {
-      const a = evalConst(node[1]), b = evalConst(node[2]);
-      if (a && b && a[0]?.endsWith(".const") && b[0]?.endsWith(".const")) {
-        const type = op.split(".")[0];
-        const va = type === "i64" ? BigInt(a[1]) : Number(a[1]);
-        const vb = type === "i64" ? BigInt(b[1]) : Number(b[1]);
-        return [`${type}.const`, va - vb];
-      }
-    }
-    if (op === "i32.mul" || op === "i64.mul") {
-      const a = evalConst(node[1]), b = evalConst(node[2]);
-      if (a && b && a[0]?.endsWith(".const") && b[0]?.endsWith(".const")) {
-        const type = op.split(".")[0];
-        const va = type === "i64" ? BigInt(a[1]) : Number(a[1]);
-        const vb = type === "i64" ? BigInt(b[1]) : Number(b[1]);
-        return [`${type}.const`, va * vb];
-      }
-    }
-    return node;
-  };
-  walkPost(ast, (node, parent, idx) => {
-    if (!Array.isArray(node) || node[0] !== "global" || !parent) return;
-    for (let i = 2; i < node.length; i++) {
-      if (Array.isArray(node[i])) {
-        const evaluated = evalConst(node[i]);
-        if (evaluated !== node[i]) node[i] = evaluated;
-      }
-    }
-  });
-  return ast;
+  const [op, ...args] = node;
+  const rt = resultType(op);
+  if (rt) return rt;
+  if (op === "local.get" && ctx.locals?.[args[0]]) return ctx.locals[args[0]];
+  if (op === "call" && ctx.funcs?.[args[0]]) return ctx.funcs[args[0]].result?.[0];
+  return null;
 };
-var multi_value = (ast, ctx) => {
-  const multiResultFuncs = /* @__PURE__ */ new Map();
-  const returnGlobals = [];
-  walk(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "func") return;
-    const id2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
-    const results = [];
-    for (const part of node) {
-      if (Array.isArray(part) && part[0] === "result") {
-        for (let i = 1; i < part.length; i++) results.push(part[i]);
-      }
-    }
-    if (results.length > 1 && id2) {
-      multiResultFuncs.set(id2, results);
-    }
-  });
-  if (!multiResultFuncs.size) return ast;
-  const maxReturns = Math.max(...[...multiResultFuncs.values()].map((r) => r.length));
-  const globalsByType = {};
-  for (const [id2, results] of multiResultFuncs) {
-    for (let i = 1; i < results.length; i++) {
-      const type = results[i];
-      if (!globalsByType[type]) globalsByType[type] = [];
-      if (globalsByType[type].length < i) {
-        const gid = genId(`ret_${type}_${globalsByType[type].length}`);
-        globalsByType[type].push(gid);
-        returnGlobals.push(["global", gid, ["mut", type], [`${type}.const`, type === "i64" ? 0n : 0]]);
-      }
-    }
-  }
-  const insertPos = ast[0] === "module" ? 1 : 0;
-  for (const g of returnGlobals.reverse()) {
-    insert(ast, insertPos, g);
-  }
-  walkPost(ast, (node, parent, idx) => {
-    if (!Array.isArray(node) || node[0] !== "func") return;
-    const id2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
-    if (!id2 || !multiResultFuncs.has(id2)) return;
-    const results = multiResultFuncs.get(id2);
+function walk(node, fn) {
+  node = fn(node);
+  if (Array.isArray(node)) {
     for (let i = 0; i < node.length; i++) {
-      if (Array.isArray(node[i]) && node[i][0] === "result") {
-        node[i] = ["result", results[0]];
-        break;
-      }
-    }
-  });
-  return ast;
-};
-var TYPE_SIZES = { i32: 4, i64: 8, f32: 4, f64: 8 };
-var gc = (ast, ctx) => {
-  const types = /* @__PURE__ */ new Map();
-  const typeIndices = /* @__PURE__ */ new Map();
-  let typeIdx = 1;
-  walk(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "type") return;
-    const id2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
-    if (!id2) return;
-    for (const def of node) {
-      if (!Array.isArray(def)) continue;
-      if (def[0] === "struct") {
-        const fields = [];
-        for (const f of def) {
-          if (Array.isArray(f) && f[0] === "field") {
-            const fname = typeof f[1] === "string" && f[1][0] === "$" ? f[1] : null;
-            const ftype = fname ? f[2] : f[1];
-            const actualType = Array.isArray(ftype) && ftype[0] === "mut" ? ftype[1] : ftype;
-            fields.push({ name: fname, type: actualType });
-          }
-        }
-        types.set(id2, { kind: "struct", fields });
-        typeIndices.set(id2, typeIdx++);
-      }
-      if (def[0] === "array") {
-        const elemDef = def[1];
-        const elemType = Array.isArray(elemDef) && elemDef[0] === "mut" ? elemDef[1] : elemDef;
-        types.set(id2, { kind: "array", elemType });
-        typeIndices.set(id2, typeIdx++);
-      }
-    }
-  });
-  if (!types.size) return ast;
-  const hasMemory = findNodes(ast, "memory").length > 0;
-  const allocId = genId("alloc");
-  const heapPtrId = genId("heap_ptr");
-  const insertPos = ast[0] === "module" ? 1 : 0;
-  if (!hasMemory) {
-    insert(ast, insertPos, ["memory", 1]);
-  }
-  insert(ast, insertPos + 1, ["global", heapPtrId, ["mut", "i32"], ["i32.const", 1024]]);
-  const allocFunc = [
-    "func",
-    allocId,
-    ["param", "$size", "i32"],
-    ["result", "i32"],
-    ["local", "$ptr", "i32"],
-    ["local.set", "$ptr", ["global.get", heapPtrId]],
-    ["global.set", heapPtrId, ["i32.add", ["global.get", heapPtrId], ["local.get", "$size"]]],
-    ["local.get", "$ptr"]
-  ];
-  ast.push(allocFunc);
-  const structSize = (typeDef) => {
-    let size = 4;
-    for (const f of typeDef.fields) {
-      size += TYPE_SIZES[f.type] || 4;
-    }
-    return size;
-  };
-  const fieldOffset = (typeDef, fieldIdx) => {
-    let offset2 = 4;
-    for (let i = 0; i < fieldIdx; i++) {
-      offset2 += TYPE_SIZES[typeDef.fields[i].type] || 4;
-    }
-    return offset2;
-  };
-  const findFieldIdx = (typeDef, fieldName) => {
-    for (let i = 0; i < typeDef.fields.length; i++) {
-      if (typeDef.fields[i].name === fieldName) return i;
-    }
-    return -1;
-  };
-  let localCounter = 0;
-  const genLocal = () => `$__gc_tmp${localCounter++}`;
-  walk(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "func") return;
-    let needsStructPtr = false;
-    let needsArrayPtr = false;
-    let needsArrayLen = false;
-    let needsArrayIdx = false;
-    walk(node, (n) => {
-      if (!Array.isArray(n)) return;
-      if (n[0] === "struct.new" || n[0] === "struct.new_default") needsStructPtr = true;
-      if (n[0] === "array.new" || n[0] === "array.new_default") {
-        needsArrayPtr = true;
-        needsArrayLen = true;
-        needsArrayIdx = true;
-      }
-    });
-    if (!needsStructPtr && !needsArrayPtr) return;
-    let insertIdx = 1;
-    for (let i = 1; i < node.length; i++) {
-      const item = node[i];
-      if (Array.isArray(item) && (item[0] === "param" || item[0] === "result" || item[0] === "local" || item[0] === "export" || item[0] === "type")) {
-        insertIdx = i + 1;
-      } else if (typeof item === "string" && item[0] === "$") {
-        insertIdx = i + 1;
-      } else if (!Array.isArray(item)) {
-        insertIdx = i + 1;
-      } else {
-        break;
-      }
-    }
-    if (needsStructPtr) node.splice(insertIdx++, 0, ["local", "$__gc_ptr", "i32"]);
-    if (needsArrayPtr) node.splice(insertIdx++, 0, ["local", "$__gc_aptr", "i32"]);
-    if (needsArrayLen) node.splice(insertIdx++, 0, ["local", "$__gc_alen", "i32"]);
-    if (needsArrayIdx) node.splice(insertIdx++, 0, ["local", "$__gc_aidx", "i32"]);
-  });
-  walkPost(ast, (node, parent, idx) => {
-    if (!Array.isArray(node) || !parent) return;
-    if (node[0] === "struct.new" || node[0] === "struct.new_default") {
-      const typeId = node[1];
-      const typeDef = types.get(typeId);
-      if (!typeDef || typeDef.kind !== "struct") return;
-      const size = structSize(typeDef);
-      const typeTag = typeIndices.get(typeId);
-      const args = node.slice(2);
-      const ptrLocal = "$__gc_ptr";
-      const stores = [
-        ["local.set", ptrLocal, ["call", allocId, ["i32.const", size]]],
-        ["i32.store", ["local.get", ptrLocal], ["i32.const", typeTag]]
-        // store type tag
-      ];
-      if (node[0] === "struct.new") {
-        for (let i = 0; i < typeDef.fields.length; i++) {
-          const f = typeDef.fields[i];
-          const offset2 = fieldOffset(typeDef, i);
-          const storeOp = f.type === "i64" ? "i64.store" : f.type === "f32" ? "f32.store" : f.type === "f64" ? "f64.store" : "i32.store";
-          stores.push([storeOp, ["i32.add", ["local.get", ptrLocal], ["i32.const", offset2]], args[i] || [`${f.type}.const`, 0]]);
-        }
-      } else {
-        for (let i = 0; i < typeDef.fields.length; i++) {
-          const f = typeDef.fields[i];
-          const offset2 = fieldOffset(typeDef, i);
-          const storeOp = f.type === "i64" ? "i64.store" : f.type === "f32" ? "f32.store" : f.type === "f64" ? "f64.store" : "i32.store";
-          const zero = f.type === "i64" ? ["i64.const", 0n] : f.type === "f32" ? ["f32.const", 0] : f.type === "f64" ? ["f64.const", 0] : ["i32.const", 0];
-          stores.push([storeOp, ["i32.add", ["local.get", ptrLocal], ["i32.const", offset2]], zero]);
-        }
-      }
-      stores.push(["local.get", ptrLocal]);
-      parent[idx] = ["block", ["result", "i32"], ...stores];
-    }
-    if (node[0] === "struct.get") {
-      const typeId = node[1];
-      const fieldId = node[2];
-      const ref = node[3];
-      const typeDef = types.get(typeId);
-      if (!typeDef || typeDef.kind !== "struct") return;
-      const fieldIdx = typeof fieldId === "string" && fieldId[0] === "$" ? findFieldIdx(typeDef, fieldId) : parseInt(fieldId);
-      if (fieldIdx < 0) return;
-      const f = typeDef.fields[fieldIdx];
-      const offset2 = fieldOffset(typeDef, fieldIdx);
-      const loadOp = f.type === "i64" ? "i64.load" : f.type === "f32" ? "f32.load" : f.type === "f64" ? "f64.load" : "i32.load";
-      parent[idx] = [loadOp, ["i32.add", ref, ["i32.const", offset2]]];
-    }
-    if (node[0] === "struct.set") {
-      const typeId = node[1];
-      const fieldId = node[2];
-      const ref = node[3];
-      const val = node[4];
-      const typeDef = types.get(typeId);
-      if (!typeDef || typeDef.kind !== "struct") return;
-      const fieldIdx = typeof fieldId === "string" && fieldId[0] === "$" ? findFieldIdx(typeDef, fieldId) : parseInt(fieldId);
-      if (fieldIdx < 0) return;
-      const f = typeDef.fields[fieldIdx];
-      const offset2 = fieldOffset(typeDef, fieldIdx);
-      const storeOp = f.type === "i64" ? "i64.store" : f.type === "f32" ? "f32.store" : f.type === "f64" ? "f64.store" : "i32.store";
-      parent[idx] = [storeOp, ["i32.add", ref, ["i32.const", offset2]], val];
-    }
-    if (node[0] === "array.new" || node[0] === "array.new_default") {
-      const typeId = node[1];
-      const typeDef = types.get(typeId);
-      if (!typeDef || typeDef.kind !== "array") return;
-      const typeTag = typeIndices.get(typeId);
-      const elemSize = TYPE_SIZES[typeDef.elemType] || 4;
-      const val = node[0] === "array.new" ? node[2] : null;
-      const len = node[0] === "array.new" ? node[3] : node[2];
-      const ptrLocal = "$__gc_aptr";
-      const lenLocal = "$__gc_alen";
-      const iLocal = "$__gc_aidx";
-      const storeOp = typeDef.elemType === "i64" ? "i64.store" : typeDef.elemType === "f32" ? "f32.store" : typeDef.elemType === "f64" ? "f64.store" : "i32.store";
-      const ops = [
-        ["local.set", lenLocal, len],
-        ["local.set", ptrLocal, ["call", allocId, ["i32.add", ["i32.const", 8], ["i32.mul", ["local.get", lenLocal], ["i32.const", elemSize]]]]],
-        ["i32.store", ["local.get", ptrLocal], ["i32.const", typeTag]],
-        ["i32.store", ["i32.add", ["local.get", ptrLocal], ["i32.const", 4]], ["local.get", lenLocal]]
-      ];
-      if (val) {
-        ops.push(
-          ["local.set", iLocal, ["i32.const", 0]],
-          [
-            "block",
-            "$done",
-            [
-              "loop",
-              "$loop",
-              ["br_if", "$done", ["i32.ge_u", ["local.get", iLocal], ["local.get", lenLocal]]],
-              [
-                storeOp,
-                [
-                  "i32.add",
-                  ["i32.add", ["local.get", ptrLocal], ["i32.const", 8]],
-                  ["i32.mul", ["local.get", iLocal], ["i32.const", elemSize]]
-                ],
-                val
-              ],
-              ["local.set", iLocal, ["i32.add", ["local.get", iLocal], ["i32.const", 1]]],
-              ["br", "$loop"]
-            ]
-          ]
-        );
-      }
-      ops.push(["local.get", ptrLocal]);
-      parent[idx] = ["block", ["result", "i32"], ...ops];
-    }
-    if (node[0] === "array.get") {
-      const typeId = node[1];
-      const ref = node[2];
-      const idx_val = node[3];
-      const typeDef = types.get(typeId);
-      if (!typeDef || typeDef.kind !== "array") return;
-      const elemSize = TYPE_SIZES[typeDef.elemType] || 4;
-      const loadOp = typeDef.elemType === "i64" ? "i64.load" : typeDef.elemType === "f32" ? "f32.load" : typeDef.elemType === "f64" ? "f64.load" : "i32.load";
-      parent[idx] = [loadOp, ["i32.add", ["i32.add", ref, ["i32.const", 8]], ["i32.mul", idx_val, ["i32.const", elemSize]]]];
-    }
-    if (node[0] === "array.set") {
-      const typeId = node[1];
-      const ref = node[2];
-      const idx_val = node[3];
-      const val = node[4];
-      const typeDef = types.get(typeId);
-      if (!typeDef || typeDef.kind !== "array") return;
-      const elemSize = TYPE_SIZES[typeDef.elemType] || 4;
-      const storeOp = typeDef.elemType === "i64" ? "i64.store" : typeDef.elemType === "f32" ? "f32.store" : typeDef.elemType === "f64" ? "f64.store" : "i32.store";
-      parent[idx] = [storeOp, ["i32.add", ["i32.add", ref, ["i32.const", 8]], ["i32.mul", idx_val, ["i32.const", elemSize]]], val];
-    }
-    if (node[0] === "array.len") {
-      const ref = node[1];
-      parent[idx] = ["i32.load", ["i32.add", ref, ["i32.const", 4]]];
-    }
-  });
-  return ast;
-};
-var ref_cast = (ast, ctx) => {
-  const typeIndices = /* @__PURE__ */ new Map();
-  let typeIdx = 1;
-  walk(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "type") return;
-    const id2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
-    if (!id2) return;
-    for (const def of node) {
-      if (Array.isArray(def) && (def[0] === "struct" || def[0] === "array")) {
-        typeIndices.set(id2, typeIdx++);
-      }
-    }
-  });
-  if (!typeIndices.size) return ast;
-  walkPost(ast, (node, parent, idx) => {
-    if (!Array.isArray(node) || !parent) return;
-    if (node[0] === "ref.test") {
-      const reftype2 = node[1];
-      let typeId = null;
-      if (Array.isArray(reftype2) && reftype2[0] === "ref") {
-        typeId = reftype2[1] === "null" ? reftype2[2] : reftype2[1];
-      }
-      const val = node[2];
-      const typeTag = typeIndices.get(typeId);
-      if (typeTag !== void 0) {
-        parent[idx] = [
-          "if",
-          ["result", "i32"],
-          ["i32.eqz", val],
-          ["then", ["i32.const", 0]],
-          // null fails test
-          ["else", ["i32.eq", ["i32.load", val], ["i32.const", typeTag]]]
-        ];
-      }
-    }
-    if (node[0] === "ref.cast") {
-      const reftype2 = node[1];
-      let typeId = null;
-      let allowNull = false;
-      if (Array.isArray(reftype2) && reftype2[0] === "ref") {
-        if (reftype2[1] === "null") {
-          allowNull = true;
-          typeId = reftype2[2];
-        } else {
-          typeId = reftype2[1];
-        }
-      }
-      const val = node[2];
-      const typeTag = typeIndices.get(typeId);
-      if (typeTag !== void 0) {
-        const checkLocal = genId("cast");
-        if (allowNull) {
-          parent[idx] = [
-            "block",
-            ["result", "i32"],
-            ["local", checkLocal, "i32"],
-            ["local.set", checkLocal, val],
-            [
-              "if",
-              [
-                "i32.and",
-                ["i32.ne", ["local.get", checkLocal], ["i32.const", 0]],
-                ["i32.ne", ["i32.load", ["local.get", checkLocal]], ["i32.const", typeTag]]
-              ],
-              ["then", ["unreachable"]]
-            ],
-            ["local.get", checkLocal]
-          ];
-        } else {
-          parent[idx] = [
-            "block",
-            ["result", "i32"],
-            ["local", checkLocal, "i32"],
-            ["local.set", checkLocal, val],
-            [
-              "if",
-              [
-                "i32.or",
-                ["i32.eqz", ["local.get", checkLocal]],
-                ["i32.ne", ["i32.load", ["local.get", checkLocal]], ["i32.const", typeTag]]
-              ],
-              ["then", ["unreachable"]]
-            ],
-            ["local.get", checkLocal]
-          ];
-        }
-      }
-    }
-    if (node[0] === "br_on_cast") {
-      const label = node[1];
-      const fromType = node[2];
-      const toType = node[3];
-      const val = node[4];
-      let typeId = null;
-      if (Array.isArray(toType) && toType[0] === "ref") {
-        typeId = toType[1] === "null" ? toType[2] : toType[1];
-      }
-      const typeTag = typeIndices.get(typeId);
-      if (typeTag !== void 0) {
-        const checkLocal = genId("brcast");
-        parent[idx] = [
-          "block",
-          ["result", "i32"],
-          ["local", checkLocal, "i32"],
-          ["local.set", checkLocal, val],
-          ["br_if", label, [
-            "i32.and",
-            ["i32.ne", ["local.get", checkLocal], ["i32.const", 0]],
-            ["i32.eq", ["i32.load", ["local.get", checkLocal]], ["i32.const", typeTag]]
-          ]],
-          ["local.get", checkLocal]
-        ];
-      }
-    }
-    if (node[0] === "br_on_cast_fail") {
-      const label = node[1];
-      const fromType = node[2];
-      const toType = node[3];
-      const val = node[4];
-      let typeId = null;
-      if (Array.isArray(toType) && toType[0] === "ref") {
-        typeId = toType[1] === "null" ? toType[2] : toType[1];
-      }
-      const typeTag = typeIndices.get(typeId);
-      if (typeTag !== void 0) {
-        const checkLocal = genId("brfail");
-        parent[idx] = [
-          "block",
-          ["result", "i32"],
-          ["local", checkLocal, "i32"],
-          ["local.set", checkLocal, val],
-          ["br_if", label, [
-            "i32.or",
-            ["i32.eqz", ["local.get", checkLocal]],
-            ["i32.ne", ["i32.load", ["local.get", checkLocal]], ["i32.const", typeTag]]
-          ]],
-          ["local.get", checkLocal]
-        ];
-      }
-    }
-  });
-  return ast;
-};
-var POLYFILLS = [
-  ["funcref", ["ref.func", "call_ref", "return_call_ref"], funcref],
-  ["sign_ext", ["i32.extend8_s", "i32.extend16_s", "i64.extend8_s", "i64.extend16_s", "i64.extend32_s"], sign_ext],
-  ["nontrapping", [
-    "i32.trunc_sat_f32_s",
-    "i32.trunc_sat_f32_u",
-    "i32.trunc_sat_f64_s",
-    "i32.trunc_sat_f64_u",
-    "i64.trunc_sat_f32_s",
-    "i64.trunc_sat_f32_u",
-    "i64.trunc_sat_f64_s",
-    "i64.trunc_sat_f64_u"
-  ], nontrapping],
-  ["bulk_memory", ["memory.copy", "memory.fill"], bulk_memory],
-  ["return_call", ["return_call", "return_call_indirect"], return_call_transform],
-  ["i31ref", ["ref.i31", "i31.get_s", "i31.get_u"], i31ref],
-  ["extended_const", ["global.get"], extended_const],
-  // global.get in a const initializer — also detected specially
-  ["multi_value", [], multi_value],
-  // functions with >1 result — detected by result count
-  ["gc", [
-    "struct.new",
-    "struct.get",
-    "struct.set",
-    "array.new",
-    "array.get",
-    "array.set",
-    "array.len",
-    "struct.new_default",
-    "array.new_default",
-    "array.new_fixed",
-    "array.copy"
-  ], gc],
-  ["ref_cast", ["ref.test", "ref.cast", "br_on_cast", "br_on_cast_fail"], ref_cast]
-];
-var FEATURES = Object.fromEntries(POLYFILLS.map((p) => [p[0], p[1]]));
-var normalize2 = (opts) => {
-  if (opts === false) return {};
-  if (opts !== true && typeof opts !== "string") return { ...opts };
-  const set = typeof opts === "string" ? new Set(opts.split(/\s+/).filter(Boolean)) : null;
-  const m = {};
-  for (const p of POLYFILLS) m[p[0]] = set ? set.has("all") || set.has(p[0]) : true;
-  return m;
-};
-var detect = (ast) => {
-  const used = /* @__PURE__ */ new Set();
-  walk(ast, (node) => {
-    if (typeof node !== "string") return;
-    for (const p of POLYFILLS) {
-      const ops = p[1];
-      if (ops.some((op) => node === op || node.startsWith(op + " "))) used.add(p[0]);
-    }
-  });
-  walk(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "global") return;
-    for (const init of node) {
-      if (!Array.isArray(init)) continue;
-      if (init[0] === "i32.add" || init[0] === "i32.sub" || init[0] === "i32.mul" || init[0] === "i64.add" || init[0] === "i64.sub" || init[0] === "i64.mul") {
-        walk(init, (inner) => {
-          if (Array.isArray(inner) && inner[0] === "global.get") used.add("extended_const");
-        });
-      }
-    }
-  });
-  walk(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "func") return;
-    let resultCount = 0;
-    for (const part of node) {
-      if (Array.isArray(part) && part[0] === "result") resultCount += part.length - 1;
+      let child = walk(node[i], fn);
+      if (child?._splice) node.splice(i, 1, ...child), i += child.length - 1;
+      else node[i] = child;
     }
-    if (resultCount > 1) used.add("multi_value");
-  });
-  return used;
-};
-function polyfill(ast, opts = true) {
-  if (typeof ast === "string") ast = parse_default(ast);
-  ast = clone(ast);
-  opts = normalize2(opts);
-  const used = detect(ast);
-  const ctx = { uid: 0 };
-  for (const p of POLYFILLS) {
-    const fn = p[2];
-    if (used.has(p[0]) && opts[p[0]] !== false) ast = fn(ast, ctx);
   }
-  return ast;
-}
-
-// 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;
-  } catch {
-    return Infinity;
-  }
-};
-var equal = (a, b) => {
-  if (a === b) return true;
-  if (typeof a !== typeof b) return false;
-  if (typeof a === "bigint") return a === b;
-  if (!Array.isArray(a) || !Array.isArray(b)) return false;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) if (!equal(a[i], b[i])) return false;
-  return true;
-};
-var parseIf = (node) => {
-  let condIdx = 1;
-  while (condIdx < node.length) {
-    const c = node[condIdx];
-    if (Array.isArray(c) && (c[0] === "then" || c[0] === "else" || c[0] === "result" || c[0] === "param")) {
-      condIdx++;
-      continue;
-    }
-    break;
-  }
-  let thenBranch = null, elseBranch = null;
-  for (let i = condIdx + 1; i < node.length; i++) {
-    const c = node[i];
-    if (!Array.isArray(c)) continue;
-    if (c[0] === "then") thenBranch = c;
-    else if (c[0] === "else") elseBranch = c;
-  }
-  return { condIdx, cond: node[condIdx], thenBranch, elseBranch };
-};
-var treeshake = (ast) => {
-  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const funcs = /* @__PURE__ */ new Map(), globals2 = /* @__PURE__ */ new Map(), types = /* @__PURE__ */ new Map();
-  const tables = /* @__PURE__ */ new Map(), memories = /* @__PURE__ */ new Map();
-  const nodeMap = /* @__PURE__ */ new Map();
-  const register = (map, node, idx, isImport = false) => {
-    const named = typeof node[1] === "string" && node[1][0] === "$";
-    const name2 = named ? node[1] : idx;
-    const inlineExported = !isImport && node.some((s) => Array.isArray(s) && s[0] === "export");
-    const entry = { node, idx, used: inlineExported, isImport };
-    map.set(name2, entry);
-    if (named) map.set(idx, entry);
-    nodeMap.set(node, entry);
-    return entry;
-  };
-  let funcIdx = 0, globalIdx = 0, typeIdx = 0, tableIdx = 0, memIdx = 0;
-  const elems = [], data = [], exports = [], starts = [];
-  for (const node of ast.slice(1)) {
-    if (!Array.isArray(node)) continue;
-    const kind = node[0];
-    if (kind === "type") register(types, node, typeIdx++);
-    else if (kind === "func") register(funcs, node, funcIdx++);
-    else if (kind === "global") register(globals2, node, globalIdx++);
-    else if (kind === "table") register(tables, node, tableIdx++);
-    else if (kind === "memory") register(memories, node, memIdx++);
-    else if (kind === "import") {
-      for (const sub of node) {
-        if (!Array.isArray(sub)) continue;
-        if (sub[0] === "func") register(funcs, sub, funcIdx++, true);
-        else if (sub[0] === "global") register(globals2, sub, globalIdx++, true);
-        else if (sub[0] === "table") register(tables, sub, tableIdx++, true);
-        else if (sub[0] === "memory") register(memories, sub, memIdx++, true);
-      }
-    } else if (kind === "export") exports.push(node);
-    else if (kind === "start") starts.push(node);
-    else if (kind === "elem") elems.push(node);
-    else if (kind === "data") data.push(node);
-  }
-  const work = [];
-  const enqueue = (entry) => {
-    if (entry && !entry.scanned) work.push(entry);
-  };
-  const markFunc = (ref) => {
-    const e = funcs.get(ref);
-    if (!e) return;
-    if (!e.used) e.used = true;
-    enqueue(e);
-  };
-  const markGlobal = (ref) => {
-    const e = globals2.get(ref);
-    if (e) e.used = true;
-  };
-  const markTable = (ref) => {
-    const e = tables.get(ref);
-    if (e) e.used = true;
-  };
-  const markMemory = (ref) => {
-    if (typeof ref === "string" && ref[0] !== "$") ref = +ref;
-    const e = memories.get(ref);
-    if (e) e.used = true;
-  };
-  const markType = (ref) => {
-    const e = types.get(ref);
-    if (e) e.used = true;
-  };
-  for (const exp of exports) {
-    for (const sub of exp) {
-      if (!Array.isArray(sub)) continue;
-      const [kind, ref] = sub;
-      if (kind === "func") markFunc(ref);
-      else if (kind === "global") markGlobal(ref);
-      else if (kind === "table") markTable(ref);
-      else if (kind === "memory") markMemory(ref);
-    }
-  }
-  for (const start of starts) {
-    let ref = start[1];
-    if (typeof ref === "string" && ref[0] !== "$") ref = +ref;
-    markFunc(ref);
-  }
-  for (const elem of elems) {
-    walk2(elem, (n) => {
-      if (Array.isArray(n) && n[0] === "ref.func") markFunc(n[1]);
-      else if (typeof n === "string" && n[0] === "$") markFunc(n);
-    });
-  }
-  for (const d of data) {
-    const first = d[1];
-    if (Array.isArray(first) && first[0] === "memory") markMemory(first[1]);
-    else if (typeof first === "string" && first[0] === "$") markMemory(first);
-    else if (Array.isArray(first)) markMemory(0);
-  }
-  for (const m of [funcs, globals2, tables, memories]) for (const e of m.values()) if (e.used) enqueue(e);
-  const hasAnchor = exports.length > 0 || starts.length > 0 || elems.length > 0 || work.length > 0;
-  if (!hasAnchor) {
-    for (const m of [funcs, globals2, tables, memories]) for (const e of m.values()) e.used = true;
-    return ast;
-  }
-  while (work.length) {
-    const entry = work.pop();
-    if (entry.scanned) continue;
-    entry.scanned = true;
-    if (entry.isImport) continue;
-    walk2(entry.node, (n) => {
-      if (!Array.isArray(n)) {
-        if (typeof n === "string" && n[0] === "$") markFunc(n);
-        return;
-      }
-      const [op, ref] = n;
-      if (op === "call" || op === "return_call" || op === "ref.func") markFunc(ref);
-      else if (op === "global.get" || op === "global.set") markGlobal(ref);
-      else if (op === "type") markType(ref);
-      else if (op === "call_indirect" || op === "return_call_indirect") {
-        for (const sub of n) if (typeof sub === "string" && sub[0] === "$") markTable(sub);
-      }
-      if (typeof op === "string" && (op.startsWith("memory.") || op.includes(".load") || op.includes(".store"))) {
-        markMemory(0);
-      }
-    });
-  }
-  const result = ["module"];
-  for (const node of ast.slice(1)) {
-    if (!Array.isArray(node)) {
-      result.push(node);
-      continue;
-    }
-    const kind = node[0];
-    if (kind === "func" || kind === "global" || kind === "type") {
-      if (nodeMap.get(node)?.used) result.push(node);
-    } else if (kind === "import") {
-      let used = false;
-      for (const sub of node) {
-        if (!Array.isArray(sub)) continue;
-        const e = nodeMap.get(sub);
-        if (e?.used) {
-          used = true;
-          break;
-        }
-      }
-      if (used) result.push(node);
-    } else {
-      result.push(node);
-    }
-  }
-  return result;
-};
-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 _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 "0x" + _hex8(_ru32[1]) + _hex8(_ru32[0]);
-};
-var f64FromI64 = (h) => {
-  _ru32[1] = parseInt(h.slice(2, 10), 16);
-  _ru32[0] = parseInt(h.slice(10), 16);
-  return _rf64[0];
-};
-var i32FromF32 = (x) => {
-  _rf32[0] = x;
-  return _ri32[0];
-};
-var f32FromI32 = (x) => {
-  _ri32[0] = x | 0;
-  return _rf32[0];
-};
-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(_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,
-  "i32.sub": (a, b) => a - b | 0,
-  "i32.mul": (a, b) => Math.imul(a, b),
-  "i32.div_s": (a, b) => b !== 0 ? a / b | 0 : null,
-  "i32.div_u": (a, b) => b !== 0 ? (a >>> 0) / (b >>> 0) | 0 : null,
-  "i32.rem_s": (a, b) => b !== 0 ? a % b | 0 : null,
-  "i32.rem_u": (a, b) => b !== 0 ? (a >>> 0) % (b >>> 0) | 0 : null,
-  "i32.and": (a, b) => a & b,
-  "i32.or": (a, b) => a | b,
-  "i32.xor": (a, b) => a ^ b,
-  "i32.shl": (a, b) => a << (b & 31),
-  "i32.shr_s": (a, b) => a >> (b & 31),
-  "i32.shr_u": (a, b) => a >>> (b & 31),
-  "i32.rotl": (a, b) => {
-    b &= 31;
-    return a << b | a >>> 32 - b | 0;
-  },
-  "i32.rotr": (a, b) => {
-    b &= 31;
-    return a >>> b | a << 32 - b | 0;
-  },
-  "i32.eq": i32c((a, b) => a === b),
-  "i32.ne": i32c((a, b) => a !== b),
-  "i32.lt_s": i32c((a, b) => a < b),
-  "i32.lt_u": u32c((a, b) => a < b),
-  "i32.gt_s": i32c((a, b) => a > b),
-  "i32.gt_u": u32c((a, b) => a > b),
-  "i32.le_s": i32c((a, b) => a <= b),
-  "i32.le_u": u32c((a, b) => a <= b),
-  "i32.ge_s": i32c((a, b) => a >= b),
-  "i32.ge_u": u32c((a, b) => a >= b),
-  "i32.eqz": (a) => a === 0 ? 1 : 0,
-  "i32.clz": (a) => Math.clz32(a),
-  "i32.ctz": (a) => a === 0 ? 32 : 31 - Math.clz32(a & -a),
-  "i32.popcnt": (a) => {
-    let c = 0;
-    while (a) {
-      c += a & 1;
-      a >>>= 1;
-    }
-    return c;
-  },
-  "i32.wrap_i64": (a) => _i64Lo(a),
-  "i32.extend8_s": (a) => a << 24 >> 24,
-  "i32.extend16_s": (a) => a << 16 >> 16,
-  // 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),
-  "i64.gt_u": u64c((a, b) => a > b),
-  "i64.le_s": i64c((a, b) => a <= b),
-  "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 === 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),
-  "f32.mul": (a, b) => Math.fround(a * b),
-  "f32.div": (a, b) => Math.fround(a / b),
-  "f32.neg": (a) => Math.fround(-a),
-  "f32.abs": (a) => Math.fround(Math.abs(a)),
-  "f32.sqrt": (a) => Math.fround(Math.sqrt(a)),
-  "f32.ceil": (a) => Math.fround(Math.ceil(a)),
-  "f32.floor": (a) => Math.fround(Math.floor(a)),
-  "f32.trunc": (a) => Math.fround(Math.trunc(a)),
-  "f32.nearest": (a) => Math.fround(roundEven(a)),
-  "f64.add": (a, b) => a + b,
-  "f64.sub": (a, b) => a - b,
-  "f64.mul": (a, b) => a * b,
-  "f64.div": (a, b) => a / b,
-  "f64.neg": (a) => -a,
-  "f64.abs": Math.abs,
-  "f64.sqrt": Math.sqrt,
-  "f64.ceil": Math.ceil,
-  "f64.floor": Math.floor,
-  "f64.trunc": Math.trunc,
-  "f64.nearest": roundEven,
-  // Bit-exact reinterprets (preserve NaN payloads)
-  "i32.reinterpret_f32": i32FromF32,
-  "f32.reinterpret_i32": f32FromI32,
-  "i64.reinterpret_f64": i64FromF64,
-  "f64.reinterpret_i64": f64FromI64,
-  // Numeric conversions (value-preserving where representable)
-  "f32.convert_i32_s": (a) => Math.fround(a | 0),
-  "f32.convert_i32_u": (a) => Math.fround(a >>> 0),
-  // (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) => (_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;
-  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")) => {
-  if (i < 0 || i == null) return null;
-  let tail = s.slice(i + 4).replaceAll("_", ""), bits = s[i + 3] === ":" && tail !== "canonical" && tail !== "arithmetic" ? parseInt(tail) : 4194304;
-  _ri32[0] = bits | 2139095040 | (s[0] === "-" ? 2147483648 : 0) | 0;
-  return _rf32[0];
-};
-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" ? 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);
-    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", 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 walkPost2(ast, (node) => {
-    if (!Array.isArray(node)) return;
-    const fn = FOLDABLE[node[0]];
-    if (!fn) return;
-    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 || r === void 0) return;
-      return makeConst(resultType2(node[0]), r);
-    }
-    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 || r === void 0) return;
-      return makeConst(resultType2(node[0]), r);
-    }
-  });
-};
-var commutativeIdentity = (neutral) => (a, b) => {
-  const ca = getConst(a), cb = getConst(b);
-  if (ca?.value === neutral) return b;
-  if (cb?.value === neutral) return a;
-  return null;
-};
-var rightIdentity = (neutral) => (a, b) => getConst(b)?.value === neutral ? a : null;
-var IDENTITIES = {
-  // x + 0 → x, 0 + x → x
-  "i32.add": commutativeIdentity(0),
-  "i64.add": commutativeIdentity(ZERO64),
-  // x - 0 → x
-  "i32.sub": rightIdentity(0),
-  "i64.sub": rightIdentity(ZERO64),
-  // x * 1 → x, 1 * x → x
-  "i32.mul": commutativeIdentity(1),
-  "i64.mul": commutativeIdentity(ONE64),
-  // x / 1 → x
-  "i32.div_s": rightIdentity(1),
-  "i32.div_u": rightIdentity(1),
-  "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(NEG164),
-  // x | 0 → x, 0 | x → x
-  "i32.or": commutativeIdentity(0),
-  "i64.or": commutativeIdentity(ZERO64),
-  // x ^ 0 → x, 0 ^ x → x
-  "i32.xor": commutativeIdentity(0),
-  "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(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 walkPost2(ast, (node) => {
-    if (!Array.isArray(node) || node.length !== 3) return;
-    const fn = IDENTITIES[node[0]];
-    if (!fn) return;
-    const result = fn(node[1], node[2]);
-    if (result === null) return;
-    return result;
-  });
-};
-var strength = (ast) => {
-  return walkPost2(ast, (node) => {
-    if (!Array.isArray(node) || node.length !== 3) return;
-    const [op, a, b] = node;
-    if (op === "i32.mul") {
-      const cb = getConst(b);
-      if (cb && cb.value > 0 && (cb.value & cb.value - 1) === 0) {
-        const shift = Math.log2(cb.value);
-        if (Number.isInteger(shift)) return ["i32.shl", a, ["i32.const", shift]];
-      }
-      const ca = getConst(a);
-      if (ca && ca.value > 0 && (ca.value & ca.value - 1) === 0) {
-        const shift = Math.log2(ca.value);
-        if (Number.isInteger(shift)) return ["i32.shl", b, ["i32.const", shift]];
-      }
-    }
-    if (op === "i64.mul") {
-      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);
-      if (cb && cb.value > 0 && (cb.value & cb.value - 1) === 0) {
-        const shift = Math.log2(cb.value);
-        if (Number.isInteger(shift)) return ["i32.shr_u", a, ["i32.const", shift]];
-      }
-    }
-    if (op === "i64.div_u") {
-      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);
-      if (cb && cb.value > 0 && (cb.value & cb.value - 1) === 0) {
-        return ["i32.and", a, ["i32.const", cb.value - 1]];
-      }
-    }
-    if (op === "i64.rem_u") {
-      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 walkPost2(ast, (node) => {
-    if (!Array.isArray(node)) return;
-    const op = node[0];
-    if (op === "if") {
-      const { condIdx, cond, thenBranch, elseBranch } = parseIf(node);
-      const c = getConst(cond);
-      if (!c) return;
-      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"];
-    }
-    if (op === "br_if" && node.length >= 3) {
-      const cond = node[node.length - 1];
-      const c = getConst(cond);
-      if (!c) return;
-      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 === 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) => {
-  walk2(ast, (node) => {
-    if (!Array.isArray(node)) return;
-    const kind = node[0];
-    if (kind === "func" || kind === "block" || kind === "loop") {
-      eliminateDeadInBlock(node);
-    }
-    if (kind === "if") {
-      for (let i = 1; i < node.length; i++) {
-        if (Array.isArray(node[i]) && (node[i][0] === "then" || node[i][0] === "else")) {
-          eliminateDeadInBlock(node[i]);
-        }
-      }
-    }
-  });
-  return ast;
-};
-var eliminateDeadInBlock = (block) => {
-  let terminated = false;
-  let firstTerminator = -1;
-  for (let i = 1; i < block.length; i++) {
-    const node = block[i];
-    if (Array.isArray(node)) {
-      const op = node[0];
-      if (op === "param" || op === "result" || op === "local" || op === "type" || op === "export") continue;
-      if (terminated) {
-        if (firstTerminator === -1) firstTerminator = i;
-      }
-      if (TERMINATORS.has(op)) {
-        terminated = true;
-        firstTerminator = i + 1;
-      }
-    } else if (typeof node === "string") {
-      if (terminated) {
-        if (firstTerminator === -1) firstTerminator = i;
-      }
-      if (TERMINATORS.has(node)) {
-        terminated = true;
-        firstTerminator = i + 1;
-      }
-    }
-  }
-  if (firstTerminator > 0 && firstTerminator < block.length) {
-    block.splice(firstTerminator);
-  }
-};
-var localReuse = (ast) => {
-  walk2(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "func") return;
-    const localDecls = [];
-    const localTypes = /* @__PURE__ */ new Map();
-    const usedLocals = /* @__PURE__ */ new Set();
-    for (let i = 1; i < node.length; i++) {
-      const sub = node[i];
-      if (!Array.isArray(sub)) continue;
-      if (sub[0] === "local") {
-        localDecls.push({ node: sub, idx: i });
-        if (typeof sub[1] === "string" && sub[1][0] === "$") {
-          localTypes.set(sub[1], sub[2]);
-        }
-      }
-      if (sub[0] === "param") {
-        if (typeof sub[1] === "string" && sub[1][0] === "$") {
-          localTypes.set(sub[1], sub[2]);
-          usedLocals.add(sub[1]);
-        }
-      }
-    }
-    walk2(node, (n) => {
-      if (!Array.isArray(n)) return;
-      const op = n[0];
-      if (op === "local.get" || op === "local.set" || op === "local.tee") {
-        const ref = n[1];
-        if (typeof ref === "string") usedLocals.add(ref);
-      }
-    });
-    for (let i = localDecls.length - 1; i >= 0; i--) {
-      const { idx, node: decl } = localDecls[i];
-      const name2 = typeof decl[1] === "string" && decl[1][0] === "$" ? decl[1] : null;
-      if (name2 && !usedLocals.has(name2)) {
-        node.splice(idx, 1);
-      }
-    }
-  });
-  return ast;
-};
-var IMPURE_OPS = /* @__PURE__ */ new Set([
-  "call",
-  "call_indirect",
-  "return_call",
-  "return_call_indirect",
-  "table.set",
-  "table.grow",
-  "table.fill",
-  "table.copy",
-  "table.init",
-  "struct.set",
-  "struct.new",
-  "array.set",
-  "array.new",
-  "array.new_fixed",
-  "array.new_data",
-  "array.new_elem",
-  "array.init_data",
-  "array.init_elem",
-  "ref.i31",
-  "global.set",
-  "local.set",
-  "local.tee",
-  "unreachable",
-  "return",
-  "br",
-  "br_if",
-  "br_table",
-  "br_on_null",
-  "br_on_non_null",
-  "br_on_cast",
-  "br_on_cast_fail",
-  "throw",
-  "rethrow",
-  "throw_ref",
-  "try_table",
-  "data.drop",
-  "elem.drop"
-]);
-var IMPURE_SUBSTRINGS = [".store", "memory.", ".atomic."];
-var isPure = (node) => {
-  if (!Array.isArray(node)) return true;
-  const op = node[0];
-  if (typeof op !== "string") return false;
-  if (IMPURE_OPS.has(op)) return false;
-  for (const sub of IMPURE_SUBSTRINGS) if (op.includes(sub)) return false;
-  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);
-  };
-  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++;
-    else if (n[0] === "local.tee") ensure(n[1]).tees++;
-  });
-  return counts;
-};
-var isTinyConst = (node) => {
-  const c = getConst(node);
-  if (!c) return false;
-  if (c.type === "i32") {
-    const v = c.value | 0;
-    return v >= -64 && v <= 63;
-  }
-  if (c.type === "i64") {
-    const v = BigInt(c.value);
-    return v <= 63n || v >= 0xffffffffffffffc0n;
-  }
-  return false;
-};
-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;
-    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];
-  if (typeof op === "string") {
-    if (op.includes(".load") || op === "memory.copy" || op === "memory.size") return true;
-  }
-  for (let i = 1; i < node.length; i++) if (readsMemory(node[i])) return true;
-  return false;
-};
-var readsCallableState = (node) => {
-  if (!Array.isArray(node)) return false;
-  const op = node[0];
-  if (typeof op === "string") {
-    if (op === "global.get" || op === "table.get" || op === "table.size") return true;
-    if (op === "call" || op === "call_indirect" || op === "return_call" || op === "return_call_indirect") return true;
-    if (op.includes(".load") || op === "memory.copy" || op === "memory.size") return true;
-  }
-  for (let i = 1; i < node.length; i++) if (readsCallableState(node[i])) return true;
-  return false;
-};
-var writesMemory = (node) => {
-  if (!Array.isArray(node)) return false;
-  const op = node[0];
-  if (typeof op === "string") {
-    if (op.endsWith(".store") || op === "memory.copy" || op === "memory.fill" || op === "memory.init") return true;
-    if (op.includes(".atomic.") && !op.endsWith(".load")) return true;
-  }
-  for (let i = 1; i < node.length; i++) if (writesMemory(node[i])) return true;
-  return false;
-};
-var substGets = (node, known) => {
-  if (!Array.isArray(node)) return node;
-  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 clone2(k.val);
-    return node;
-  }
-  let inner = known;
-  if (isBranchScope(op)) {
-    let cloned = null;
-    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);
-        cloned.delete(n[1]);
-      }
-    });
-    if (cloned) inner = cloned;
-  }
-  for (let i = 1; i < node.length; i++) {
-    const r = substGets(node[i], inner);
-    if (r !== node[i]) node[i] = r;
-    if (i + 1 < node.length && Array.isArray(node[i])) {
-      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]);
-        }
-      });
-    }
-  }
-  return node;
-};
-var forwardPropagate = (funcNode, params, useCounts) => {
-  let changed = false;
-  const getUseCount = (name2) => useCounts.get(name2) || { gets: 0, sets: 0, tees: 0 };
-  const known = /* @__PURE__ */ new Map();
-  for (let i = 1; i < funcNode.length; i++) {
-    const instr2 = funcNode[i];
-    if (!Array.isArray(instr2)) continue;
-    const op = instr2[0];
-    if (op === "param" || op === "result" || op === "local" || op === "type" || op === "export") continue;
-    if ((op === "local.set" || op === "local.tee") && instr2.length === 3 && typeof instr2[1] === "string") {
-      const sr = substGets(instr2[2], known);
-      if (sr !== instr2[2]) {
-        instr2[2] = sr;
-        changed = true;
-      }
-      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]);
-      if (writesMemory(instr2[2])) {
-        for (const [key, tracked] of known) if (tracked.readsMem) known.delete(key);
-      }
-      known.set(instr2[1], {
-        val: instr2[2],
-        pure: isPure(instr2[2]),
-        readsMem: readsMemory(instr2[2]),
-        singleUse: uses.gets <= 1 && uses.sets <= 1 && uses.tees === 0,
-        copy: isLocalCopy(instr2[2], instr2[1])
-      });
-      continue;
-    }
-    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 = clone2(tracked.val);
-        instr2.length = 0;
-        instr2.push(...Array.isArray(replacement) ? replacement : [replacement]);
-        changed = true;
-        continue;
-      }
-    }
-    if (op !== "block" && op !== "loop" && op !== "if") {
-      const prev = clone2(instr2);
-      substGets(instr2, known);
-      if (!equal(prev, instr2)) changed = true;
-      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);
-      }
-    }
-  }
-  return changed;
-};
-var eliminateSetGetPairs = (funcNode, params, useCounts) => {
-  let changed = false;
-  for (let i = 1; i < funcNode.length - 1; i++) {
-    const setNode = funcNode[i];
-    const getNode = funcNode[i + 1];
-    if (!Array.isArray(setNode) || setNode[0] !== "local.set" || setNode.length !== 3) continue;
-    if (!Array.isArray(getNode) || getNode[0] !== "local.get" || getNode.length !== 2) continue;
-    const name2 = setNode[1];
-    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 = clone2(setNode[2]);
-    funcNode.splice(i, 2, ...Array.isArray(expr2) ? [expr2] : [expr2]);
-    changed = true;
-    i--;
-  }
-  return changed;
-};
-var createLocalTees = (funcNode, params, useCounts) => {
-  let changed = false;
-  for (let i = 1; i < funcNode.length - 1; i++) {
-    const setNode = funcNode[i];
-    const getNode = funcNode[i + 1];
-    if (!Array.isArray(setNode) || setNode[0] !== "local.set" || setNode.length !== 3) continue;
-    if (!Array.isArray(getNode) || getNode[0] !== "local.get" || getNode.length !== 2) continue;
-    const name2 = setNode[1];
-    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, clone2(setNode[2])]);
-    changed = true;
-  }
-  return changed;
-};
-var eliminateDeadStores = (funcNode, params, useCounts) => {
-  let changed = false;
-  const getPostUseCount = (name2) => useCounts.get(name2) || { gets: 0, sets: 0, tees: 0 };
-  for (let i = funcNode.length - 1; i >= 1; i--) {
-    const sub = funcNode[i];
-    if (!Array.isArray(sub)) continue;
-    const name2 = typeof sub[1] === "string" ? sub[1] : null;
-    if (!name2 || params.has(name2)) continue;
-    const uses = getPostUseCount(name2);
-    if (sub[0] === "local.set" && uses.gets === 0 && uses.tees === 0) {
-      if (sub.length === 3) {
-        if (isPure(sub[2])) {
-          funcNode.splice(i, 1);
-          changed = true;
-        }
-      } else if (sub.length === 2) {
-        funcNode[i] = ["drop"];
-        changed = true;
-      }
-    } else if (sub[0] === "local" && name2[0] === "$" && uses.gets === 0 && uses.sets === 0 && uses.tees === 0) {
-      funcNode.splice(i, 1);
-      changed = true;
-    }
-  }
-  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) => {
-  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 = [];
-    walkPost2(funcNode, (n) => {
-      if (isScopeNode(n)) scopes.push(n);
-    });
-    for (let round = 0; round < MAX_PROP_ROUNDS; round++) {
-      const useCounts = countLocalUses(funcNode);
-      let progressed = false;
-      for (const scope of scopes) {
-        if (forwardPropagate(scope, params, useCounts)) progressed = true;
-        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 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, pin = EMPTY_SET } = {}) => {
-  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  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) || pin.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 (!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);
-  }
-  return ast;
-};
-var devirt = (ast) => {
-  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  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);
-    }
-  }
-  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 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 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);
-      }
-      if (poisoned) {
-        resolved.set(g, null);
-        changed = true;
-        continue;
-      }
-      if (!resolved.has(g) || m.size !== before) {
-        resolved.set(g, m);
-        changed = true;
-      }
-    }
-  }
-  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 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 (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 inlineOnce = (ast, { pin = EMPTY_SET } = {}) => {
-  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);
-    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 = 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 (pin.has(name2)) continue;
-      if (callsSelf(fn, name2)) continue;
-      let 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" || c[0] === "local") {
-          if (typeof c[1] !== "string" || c[1][0] !== "$") {
-            ok = false;
-            break;
-          }
-          if (c[0] === "local" && !zeroFor(c[2])) {
-            ok = false;
-            break;
-          }
-        } else if (c[0] === "result") nResult += c.length - 1;
-        else if (c[0] === "export") {
-          ok = false;
-          break;
-        } else if (c[0] === "type") continue;
-        else break;
-      }
-      if (!ok || nResult > 1) continue;
-      let bad = false;
-      for (let i = bodyStart(fn); i < fn.length; i++) if (unsafe(fn[i])) {
-        bad = true;
-        break;
-      }
-      if (bad) continue;
-      calleeName = name2;
-      break;
-    }
-    if (!calleeName) break;
-    const callee = funcByName.get(calleeName);
-    const params = [], locals = [];
-    let inlResult = null;
-    for (let i = 2; i < callee.length; i++) {
-      const c = callee[i];
-      if (typeof c === "string" || !Array.isArray(c)) continue;
-      if (c[0] === "param") params.push({ name: c[1], type: c[2] });
-      else if (c[0] === "result") {
-        if (c.length > 1) inlResult = c[1];
-      } else if (c[0] === "local") locals.push({ name: c[1], type: c[2] });
-      else if (c[0] === "export" || c[0] === "type") continue;
-      else break;
-    }
-    const cBody = callee.slice(bodyStart(callee));
-    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 (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));
-    };
-    let done = false;
-    for (const fn of funcs) {
-      if (fn === callee || done) continue;
-      const start = bodyStart(fn);
-      for (let i = start; i < fn.length; i++) {
-        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;
-          const setup = params.map((p, k) => ["local.set", rename.get(p.name), args[k]]);
-          const resets = locals.filter((l) => needsReset(cBody, l.name)).map((l) => ["local.set", rename.get(l.name), zeroFor(l.type)]);
-          const inner = cBody.map(sub);
-          done = true;
-          return inlResult ? ["block", exit, ["result", inlResult], ...setup, ...resets, ...inner] : ["block", exit, ...setup, ...resets, ...inner];
-        });
-        if (replaced !== fn[i]) fn[i] = replaced;
-        if (done) {
-          const decls = [...params, ...locals].map((p) => ["local", rename.get(p.name), p.type]);
-          if (decls.length) fn.splice(bodyStart(fn), 0, ...decls);
-          break;
-        }
-      }
-      if (done) break;
-    }
-    if (!done) break;
-    const idx = ast.indexOf(callee);
-    if (idx >= 0) ast.splice(idx, 1);
-  }
-  return ast;
-};
-var targetsLabel = (body, label) => {
-  let found = false;
-  const search = (n, shadowed) => {
-    if (found || !Array.isArray(n)) return;
-    const op = n[0];
-    let inner = shadowed;
-    if ((op === "block" || op === "loop") && typeof n[1] === "string" && n[1] === label) inner = true;
-    if (!shadowed) {
-      if (op === "br" || op === "br_if" || op === "br_on_null" || op === "br_on_non_null" || op === "br_on_cast" || op === "br_on_cast_fail") {
-        if (n[1] === label) {
-          found = true;
-          return;
-        }
-      } else if (op === "br_table") {
-        for (let j = 1; j < n.length; j++) {
-          if (typeof n[j] === "string") {
-            if (n[j] === label) {
-              found = true;
-              return;
-            }
-          } else break;
-        }
-      } else if (op === "catch" || op === "catch_ref") {
-        if (n[2] === label) {
-          found = true;
-          return;
-        }
-      } else if (op === "catch_all" || op === "catch_all_ref") {
-        if (n[1] === label) {
-          found = true;
-          return;
-        }
-      }
-    }
-    for (let i = 1; i < n.length; i++) search(n[i], inner);
-  };
-  for (const node of body) search(node, false);
-  return found;
-};
-var mergeBlocks = (ast) => {
-  walkPost2(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "block") return;
-    let bi = 1, label = null;
-    if (typeof node[1] === "string" && node[1][0] === "$") {
-      label = node[1];
-      bi = 2;
-    }
-    let hasResult = false;
-    while (bi < node.length) {
-      const c = node[bi];
-      if (Array.isArray(c) && (c[0] === "param" || c[0] === "type")) {
-        bi++;
-        continue;
-      }
-      if (Array.isArray(c) && c[0] === "result") {
-        hasResult = true;
-        bi++;
-        continue;
-      }
-      break;
-    }
-    const body = node.slice(bi);
-    if (!hasResult || body.length !== 1) return;
-    const only = body[0];
-    if (!Array.isArray(only)) return;
-    if (label && targetsLabel(body, label)) return;
-    node.length = 0;
-    for (const tok of only) node.push(tok);
-  });
-  walk2(ast, (node) => {
-    if (!isScopeNode(node)) return;
-    let i = 1;
-    while (i < node.length) {
-      const child = node[i];
-      if (!Array.isArray(child)) {
-        i++;
-        continue;
-      }
-      {
-        const cop = child[0];
-        const oi = cop === "local.set" || cop === "global.set" ? 2 : cop === "drop" ? 1 : -1;
-        if (oi >= 0 && child.length === oi + 1) {
-          const operand = child[oi];
-          if (Array.isArray(operand) && operand[0] === "block") {
-            let bi2 = 1, label2 = null;
-            if (typeof operand[1] === "string" && operand[1][0] === "$") {
-              label2 = operand[1];
-              bi2 = 2;
-            }
-            let hasResult = false;
-            while (bi2 < operand.length) {
-              const c = operand[bi2];
-              if (Array.isArray(c) && (c[0] === "param" || c[0] === "type")) {
-                bi2++;
-                continue;
-              }
-              if (Array.isArray(c) && c[0] === "result") {
-                hasResult = true;
-                bi2++;
-                continue;
-              }
-              break;
-            }
-            const body2 = hasResult ? operand.slice(bi2) : null;
-            if (body2 && body2.length >= 2 && !(label2 && targetsLabel(body2, label2))) {
-              const expr2 = body2[body2.length - 1];
-              const setup = body2.slice(0, -1);
-              child[oi] = expr2;
-              node.splice(i, 1, ...setup, child);
-              continue;
-            }
-          }
-        }
-      }
-      if (child[0] !== "block") {
-        i++;
-        continue;
-      }
-      let bi = 1, label = null;
-      if (typeof child[1] === "string" && child[1][0] === "$") {
-        label = child[1];
-        bi = 2;
-      }
-      while (bi < child.length) {
-        const c = child[bi];
-        if (Array.isArray(c) && (c[0] === "param" || c[0] === "result" || c[0] === "type")) {
-          bi++;
-          continue;
-        }
-        break;
-      }
-      const body = child.slice(bi);
-      if (label && targetsLabel(body, label)) {
-        i++;
-        continue;
-      }
-      node.splice(i, 1, ...body);
-      i += body.length;
-    }
-  });
-  return ast;
-};
-var coalesceLocals = (ast) => {
-  walk2(ast, (funcNode) => {
-    if (!Array.isArray(funcNode) || funcNode[0] !== "func") return;
-    const decls = /* @__PURE__ */ new Map();
-    for (const sub of funcNode) {
-      if (Array.isArray(sub) && sub[0] === "local" && typeof sub[1] === "string" && sub[1][0] === "$" && typeof sub[2] === "string") {
-        decls.set(sub[1], sub[2]);
-      }
-    }
-    if (decls.size < 2) return;
-    const uses = /* @__PURE__ */ new Map();
-    const loopStack = [];
-    let pos = 0, abort = false, condDepth = 0;
-    const visit = (n) => {
-      if (abort || !Array.isArray(n)) return;
-      const op = n[0];
-      const isLoop = op === "loop";
-      if (isLoop) loopStack.push({ start: pos, end: pos });
-      const isSet = op === "local.set" || op === "local.tee";
-      if (isSet || op === "local.get") {
-        const name2 = n[1];
-        if (typeof name2 !== "string" || name2[0] !== "$") {
-          abort = true;
-          return;
-        }
-        if (isSet) for (let i = 2; i < n.length; i++) visit(n[i]);
-        const here = pos++;
-        if (decls.has(name2)) {
-          let u = uses.get(name2);
-          if (!u) {
-            u = { start: here, end: here, firstOp: op, firstCond: condDepth > 0, loops: /* @__PURE__ */ new Set() };
-            uses.set(name2, u);
-          }
-          if (here > u.end) u.end = here;
-          for (const ls of loopStack) u.loops.add(ls);
-        }
-      } else {
-        pos++;
-        const isIf = op === "if";
-        for (let i = 1; i < n.length; i++) {
-          const c = n[i];
-          const cond = isIf && Array.isArray(c) && (c[0] === "then" || c[0] === "else");
-          if (cond) condDepth++;
-          visit(c);
-          if (cond) condDepth--;
-        }
-      }
-      if (isLoop) {
-        const ls = loopStack.pop();
-        ls.end = pos;
-      }
-    };
-    visit(funcNode);
-    if (abort) return;
-    for (const u of uses.values()) {
-      for (const ls of u.loops) {
-        if (ls.start < u.start) u.start = ls.start;
-        if (ls.end > u.end) u.end = ls.end;
-      }
-    }
-    const ordered = [...uses.entries()].sort((a, b) => a[1].start - b[1].start);
-    const rename = /* @__PURE__ */ new Map();
-    const slots = [];
-    for (const [name2, range] of ordered) {
-      const readsZero = range.firstOp === "local.get" || range.firstCond;
-      const type = decls.get(name2);
-      const slot = readsZero ? null : slots.find((s) => s.type === type && s.end < range.start);
-      if (slot) {
-        rename.set(name2, slot.primary);
-        if (range.end > slot.end) slot.end = range.end;
-      } else slots.push({ primary: name2, type, end: range.end });
-    }
-    if (rename.size === 0) return;
-    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]);
-      }
-    });
-  });
-  return ast;
-};
-var vacuum = (ast) => {
-  return walkPost2(ast, (node) => {
-    if (!Array.isArray(node)) return;
-    const op = node[0];
-    if (op === "nop") 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]) && isPure(node[3])) return node[1];
-    if (op === "if") {
-      const { cond, thenBranch, elseBranch } = parseIf(node);
-      const thenEmpty = !thenBranch || thenBranch.length <= 1;
-      const elseEmpty = !elseBranch || elseBranch.length <= 1;
-      if (thenEmpty && elseEmpty) return isPure(cond) ? ["nop"] : ["drop", cond];
-      if (elseBranch && elseEmpty && !thenEmpty) {
-        return node.filter((c) => c !== elseBranch);
-      }
-    }
-    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) && 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;
-        }
-        cleaned.push(child);
-      }
-      if (cleaned.length !== node.length) return cleaned;
-    }
-  });
-};
-var selfFold = (val) => (a, b) => equal(a, b) && isPure(a) ? val : null;
-var PEEPHOLE = {
-  // 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) => {
-    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) => {
-    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) && 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) && 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) && 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) && 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 walkPost2(ast, (node) => {
-    if (!Array.isArray(node) || node.length !== 3) return;
-    const fn = PEEPHOLE[node[0]];
-    if (!fn) return;
-    const result = fn(node[1], node[2]);
-    if (result !== null) return result;
-  });
-};
-var slebSize = (v) => {
-  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;
-    x >>= 7n;
-    if (x === 0n && (b & 0x40n) === 0n || x === -1n && (b & 0x40n) !== 0n) return n;
-    n++;
-  }
-};
-var constInstrSize = (node) => {
-  if (!Array.isArray(node)) return 4;
-  switch (node[0]) {
-    case "i32.const":
-    case "i64.const":
-      return 1 + slebSize(node[1]);
-    case "f32.const":
-      return 5;
-    case "f64.const":
-      return 9;
-    case "v128.const":
-      return 18;
-    default:
-      return 4;
-  }
-};
-var GLOBAL_GET_SIZE = 2;
-var globals = (ast) => {
-  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const constGlobals = /* @__PURE__ */ new Map();
-  const exported = /* @__PURE__ */ new Set();
-  for (const node of ast.slice(1)) {
-    if (!Array.isArray(node)) continue;
-    if (node[0] === "export" && Array.isArray(node[2]) && node[2][0] === "global" && typeof node[2][1] === "string") {
-      exported.add(node[2][1]);
-      continue;
-    }
-    if (node[0] !== "global") continue;
-    const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
-    if (!name2) continue;
-    if (node.some((c) => Array.isArray(c) && c[0] === "export")) exported.add(name2);
-    const typeSlot = node[2];
-    if (Array.isArray(typeSlot) && typeSlot[0] === "mut") continue;
-    if (Array.isArray(typeSlot) && typeSlot[0] === "import") continue;
-    const init = node[3];
-    if (getConst(init)) constGlobals.set(name2, init);
-  }
-  if (constGlobals.size === 0) return ast;
-  const reads = /* @__PURE__ */ new Map();
-  walk2(ast, (n) => {
-    if (!Array.isArray(n)) return;
-    const ref = n[1];
-    if (typeof ref !== "string" || ref[0] !== "$") return;
-    if (n[0] === "global.set") constGlobals.delete(ref);
-    else if (n[0] === "global.get") reads.set(ref, (reads.get(ref) || 0) + 1);
-  });
-  const propagate2 = /* @__PURE__ */ new Set();
-  for (const [name2, init] of constGlobals) {
-    const r = reads.get(name2) || 0;
-    if (r === 0) continue;
-    const cs = constInstrSize(init);
-    const declSize = cs + 2;
-    const before = r * GLOBAL_GET_SIZE + declSize;
-    const after = r * cs + (exported.has(name2) ? declSize : 0);
-    if (after <= before) propagate2.add(name2);
-  }
-  if (propagate2.size === 0) return ast;
-  walkPost2(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "global.get" || node.length !== 2) return;
-    if (propagate2.has(node[1])) return clone2(constGlobals.get(node[1]));
-  });
-  for (let i = ast.length - 1; i >= 1; i--) {
-    const n = ast[i];
-    if (Array.isArray(n) && n[0] === "global" && typeof n[1] === "string" && propagate2.has(n[1]) && !exported.has(n[1])) ast.splice(i, 1);
-  }
-  return ast;
-};
-var offset = (ast) => {
-  return walkPost2(ast, (node) => {
-    if (!Array.isArray(node)) return;
-    const op = node[0];
-    if (typeof op !== "string" || !op.endsWith("load") && !op.endsWith("store")) return;
-    const isStore = op.endsWith("store");
-    let currentOffset = 0;
-    let memIdx = null;
-    let argStart = 1;
-    if (typeof node[1] === "string" && (node[1][0] === "$" || !isNaN(node[1]))) {
-      memIdx = node[1];
-      argStart = 2;
-    }
-    while (argStart < node.length && typeof node[argStart] === "string" && (node[argStart].startsWith("offset=") || node[argStart].startsWith("align="))) {
-      if (node[argStart].startsWith("offset=")) {
-        currentOffset = +node[argStart].slice(7);
-      }
-      argStart++;
-    }
-    const ptrIdx = isStore ? node.length - 2 : node.length - 1;
-    const valIdx = isStore ? node.length - 1 : -1;
-    if (ptrIdx < argStart) return;
-    const ptr = node[ptrIdx];
-    if (!Array.isArray(ptr) || ptr[0] !== "i32.add" || ptr.length !== 3) return;
-    const a = ptr[1], b = ptr[2];
-    const ca = getConst(a), cb = getConst(b);
-    let base = null, addend = null;
-    if (ca && ca.type === "i32") {
-      addend = ca.value;
-      base = b;
-    } else if (cb && cb.type === "i32") {
-      addend = cb.value;
-      base = a;
-    }
-    if (base === null || addend === null) return;
-    const newOffset = currentOffset + addend;
-    const newNode = [op];
-    if (memIdx !== null) newNode.push(memIdx);
-    newNode.push(`offset=${newOffset}`);
-    let alignParam = null;
-    for (let i = argStart; i < ptrIdx; i++) {
-      if (typeof node[i] === "string" && node[i].startsWith("align=")) {
-        alignParam = node[i];
-      }
-    }
-    if (alignParam) newNode.push(alignParam);
-    newNode.push(base);
-    if (isStore) newNode.push(node[valIdx]);
-    return newNode;
-  });
-};
-var unbranch = (ast) => {
-  walk2(ast, (node) => {
-    if (!Array.isArray(node)) return;
-    const op = node[0];
-    if (op !== "block") return;
-    let labelIdx = 1;
-    let label = null;
-    if (typeof node[1] === "string" && node[1][0] === "$") {
-      label = node[1];
-      labelIdx = 2;
-    }
-    if (!label) return;
-    let lastIdx = -1;
-    for (let i = node.length - 1; i >= labelIdx; i--) {
-      const child = node[i];
-      if (!Array.isArray(child)) {
-        if (child !== "nop" && child !== "end") lastIdx = i;
-        continue;
-      }
-      const cop = child[0];
-      if (cop === "param" || cop === "result" || cop === "local" || cop === "type" || cop === "export") continue;
-      lastIdx = i;
-      break;
-    }
-    if (lastIdx < 0) return;
-    const last = node[lastIdx];
-    if (Array.isArray(last) && last[0] === "br" && last[1] === label) {
-      node.splice(lastIdx, 1, ...last.slice(2));
-    }
-  });
-  return ast;
-};
-var loopify = (ast) => {
-  walk2(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "block") return;
-    let bi = 1, label = null;
-    if (typeof node[1] === "string" && node[1][0] === "$") {
-      label = node[1];
-      bi = 2;
-    }
-    if (!label) return;
-    while (bi < node.length) {
-      const c = node[bi];
-      if (Array.isArray(c) && c[0] === "type") {
-        bi++;
-        continue;
-      }
-      if (Array.isArray(c) && (c[0] === "param" || c[0] === "result")) return;
-      break;
-    }
-    if (node.length - bi !== 1) return;
-    const loop = node[bi];
-    if (!Array.isArray(loop) || loop[0] !== "loop") return;
-    let li = 1, loopLabel = null;
-    if (typeof loop[1] === "string" && loop[1][0] === "$") {
-      loopLabel = loop[1];
-      li = 2;
-    }
-    const loopHeader = [];
-    while (li < loop.length) {
-      const c = loop[li];
-      if (Array.isArray(c) && c[0] === "type") {
-        loopHeader.push(c);
-        li++;
-        continue;
-      }
-      if (Array.isArray(c) && (c[0] === "param" || c[0] === "result")) return;
-      break;
-    }
-    const body = loop.slice(li);
-    if (body.length < 2) return;
-    const head = body[0];
-    const tail = body[body.length - 1];
-    if (!Array.isArray(head) || head[0] !== "br_if" || head[1] !== label || head.length !== 3) return;
-    if (!Array.isArray(tail) || tail[0] !== "br" || tail[1] !== loopLabel || tail.length !== 2) return;
-    const inner = body.slice(1, -1);
-    if (targetsLabel(inner, label)) return;
-    let cond = head[2];
-    if (Array.isArray(cond) && cond[0] === "i32.eqz" && cond.length === 2) cond = cond[1];
-    else cond = ["i32.eqz", cond];
-    const newLoop = ["loop"];
-    if (loopLabel) newLoop.push(loopLabel);
-    for (const h of loopHeader) newLoop.push(h);
-    newLoop.push(["if", cond, ["then", ...inner, tail]]);
-    node.length = 0;
-    for (const tok of newLoop) node.push(tok);
-  });
-  return ast;
-};
-var stripmut = (ast) => {
-  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const written = /* @__PURE__ */ new Set();
-  walk2(ast, (n) => {
-    if (Array.isArray(n) && n[0] === "global.set" && typeof n[1] === "string") written.add(n[1]);
-  });
-  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;
-    const hasName = typeof node[1] === "string" && node[1][0] === "$";
-    const typeSlot = hasName ? node[2] : node[1];
-    if (Array.isArray(typeSlot) && typeSlot[0] === "mut") {
-      const newNode = [...node];
-      newNode[hasName ? 2 : 1] = typeSlot[1];
-      return newNode;
-    }
-  });
-};
-var brif = (ast) => {
-  return walkPost2(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "if") return;
-    const { cond, thenBranch, elseBranch } = parseIf(node);
-    const thenEmpty = !thenBranch || thenBranch.length <= 1;
-    const elseEmpty = !elseBranch || elseBranch.length <= 1;
-    if (!thenEmpty && elseEmpty && thenBranch.length === 2) {
-      const t = thenBranch[1];
-      if (Array.isArray(t) && t[0] === "br" && t.length === 2) return ["br_if", t[1], cond];
-    }
-    if (thenEmpty && !elseEmpty && elseBranch.length === 2) {
-      const e = elseBranch[1];
-      if (Array.isArray(e) && e[0] === "br" && e.length === 2) return ["br_if", e[1], ["i32.eqz", cond]];
-    }
-  });
-};
-var foldarms = (ast) => {
-  return walkPost2(ast, (node) => {
-    if (!Array.isArray(node) || node[0] !== "if") return;
-    const { thenBranch, elseBranch } = parseIf(node);
-    if (!thenBranch || !elseBranch) return;
-    if (thenBranch.length <= 1 || elseBranch.length <= 1) return;
-    const hasResult = node.some((c) => Array.isArray(c) && c[0] === "result");
-    if (!hasResult) return;
-    let common = 0;
-    const minLen = Math.min(thenBranch.length, elseBranch.length);
-    for (let i = 1; i < minLen; i++) {
-      if (!equal(thenBranch[thenBranch.length - i], elseBranch[elseBranch.length - i])) break;
-      common++;
-    }
-    if (common === 0) return;
-    const hoisted = thenBranch.slice(thenBranch.length - common);
-    const newThen = thenBranch.slice(0, thenBranch.length - common);
-    const newElse = elseBranch.slice(0, elseBranch.length - common);
-    const block = ["block"];
-    for (let i = 1; i < node.length; i++) {
-      const c = node[i];
-      if (Array.isArray(c) && (c[0] === "then" || c[0] === "else")) break;
-      if (Array.isArray(c) && (c[0] === "result" || c[0] === "type")) block.push(c);
-    }
-    const newIf = ["if"];
-    for (let i = 1; i < node.length; i++) {
-      const c = node[i];
-      if (Array.isArray(c) && (c[0] === "then" || c[0] === "else")) break;
-      if (Array.isArray(c) && (c[0] === "result" || c[0] === "type")) continue;
-      newIf.push(c);
-    }
-    newIf.push(newThen.length > 1 ? newThen : ["then"]);
-    newIf.push(newElse.length > 1 ? newElse : ["else"]);
-    block.push(newIf, ...hoisted);
-    return block;
-  });
-};
-var hashFunc = (node, localNames) => {
-  const parts = [];
-  const stack = [node];
-  while (stack.length) {
-    const v = stack.pop();
-    if (Array.isArray(v)) {
-      stack.push("|");
-      for (let i = v.length - 1; i >= 0; i--) stack.push(v[i]);
-      stack.push("[");
-    } else if (typeof v === "string") {
-      parts.push(localNames.has(v) ? "$__L" : v);
-    } else if (typeof v === "bigint") {
-      parts.push(v.toString() + "n");
-    } else if (typeof v === "number") {
-      parts.push(v.toString());
-    } else if (v === null) {
-      parts.push("null");
-    } else if (v === true) {
-      parts.push("t");
-    } else if (v === false) {
-      parts.push("f");
-    } else {
-      parts.push(String(v));
-    }
-  }
-  return parts.join(",");
-};
-var dedupe = (ast) => {
-  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const signatures = /* @__PURE__ */ new Map();
-  const redirects = /* @__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;
-    const localNames = /* @__PURE__ */ new Set();
-    if (typeof node[1] === "string" && node[1][0] === "$") localNames.add(node[1]);
-    walk2(node, (n) => {
-      if (!Array.isArray(n) || typeof n[1] !== "string" || n[1][0] !== "$") return;
-      const op = n[0];
-      if (op === "param" || op === "local" || isBranchScope(op)) {
-        localNames.add(n[1]);
-      }
-    });
-    const hash = hashFunc(node, localNames);
-    if (signatures.has(hash)) {
-      redirects.set(name2, signatures.get(hash));
-    } else {
-      signatures.set(hash, name2);
-    }
-  }
-  if (redirects.size === 0) return ast;
-  walkPost2(ast, (node) => {
-    if (!Array.isArray(node)) return;
-    const op = node[0];
-    if ((op === "call" || op === "return_call") && redirects.has(node[1])) {
-      return [op, redirects.get(node[1]), ...node.slice(2)];
-    }
-    if (op === "ref.func" && redirects.has(node[1])) {
-      return ["ref.func", redirects.get(node[1])];
-    }
-    if (op === "elem") {
-      const funcs = node[node.length - 1];
-      if (Array.isArray(funcs)) {
-        return [...node.slice(0, -1), funcs.map((f) => redirects.get(f) || f)];
-      }
-    }
-    if (op === "call_indirect" && node.length >= 3) {
-      const typeRef = node[1];
-      if (typeof typeRef === "string" && redirects.has(typeRef)) {
-        return ["call_indirect", redirects.get(typeRef), ...node.slice(2)];
-      }
-    }
-  });
-  return ast;
-};
-var dedupTypes = (ast) => {
-  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const signatures = /* @__PURE__ */ new Map();
-  const redirects = /* @__PURE__ */ new Map();
-  for (const node of ast.slice(1)) {
-    if (!Array.isArray(node) || node[0] !== "type") continue;
-    const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
-    if (!name2) continue;
-    const hash = hashFunc(node, /* @__PURE__ */ new Set([name2]));
-    if (signatures.has(hash)) {
-      redirects.set(name2, signatures.get(hash));
-    } else {
-      signatures.set(hash, name2);
-    }
-  }
-  if (redirects.size === 0) return ast;
-  for (let i = ast.length - 1; i >= 0; i--) {
-    const node = ast[i];
-    if (Array.isArray(node) && node[0] === "type") {
-      const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
-      if (name2 && redirects.has(name2)) ast.splice(i, 1);
-    }
-  }
-  walkPost2(ast, (node) => {
-    if (!Array.isArray(node)) return;
-    const op = node[0];
-    if (op === "func") {
-      for (let i = 1; i < node.length; i++) {
-        const sub = node[i];
-        if (Array.isArray(sub) && sub[0] === "type" && typeof sub[1] === "string" && redirects.has(sub[1])) {
-          node[i] = ["type", redirects.get(sub[1])];
-        }
-      }
-    }
-    if (op === "import") {
-      for (let i = 1; i < node.length; i++) {
-        const sub = node[i];
-        if (Array.isArray(sub)) {
-          for (let j = 1; j < sub.length; j++) {
-            const inner = sub[j];
-            if (Array.isArray(inner) && inner[0] === "type" && typeof inner[1] === "string" && redirects.has(inner[1])) {
-              sub[j] = ["type", redirects.get(inner[1])];
-            }
-          }
-        }
-      }
-    }
-    if (op === "call_indirect" || op === "return_call_indirect") {
-      if (typeof node[1] === "string" && redirects.has(node[1])) {
-        return [op, redirects.get(node[1]), ...node.slice(2)];
-      }
-      if (Array.isArray(node[1]) && node[1][0] === "type" && typeof node[1][1] === "string" && redirects.has(node[1][1])) {
-        return [op, ["type", redirects.get(node[1][1])], ...node.slice(2)];
-      }
-    }
-  });
-  return ast;
-};
-var parseDataString = (str2) => {
-  if (typeof str2 !== "string" || str2.length < 2 || str2[0] !== '"') return [];
-  const bytes = [];
-  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 {
-      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 bytes;
-};
-var encodeDataString = (bytes, end) => {
-  let str2 = '"';
-  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");
-  }
-  return str2 + '"';
-};
-var trimTrailingZeros = (items) => {
-  const bytes = [];
-  for (const item of items) {
-    if (typeof item === "string") {
-      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 {
-      return items;
-    }
-  }
-  let end = bytes.length;
-  while (end > 0 && bytes[end - 1] === 0) end--;
-  if (end === bytes.length) return items;
-  if (end === 0) return [];
-  return [encodeDataString(bytes, end)];
-};
-var getDataOffset = (node) => {
-  let idx = 1;
-  if (typeof node[idx] === "string" && node[idx][0] === "$") idx++;
-  if (Array.isArray(node[idx]) && node[idx][0] === "memory") {
-    const mem = node[idx][1];
-    idx++;
-    const off2 = node[idx];
-    if (Array.isArray(off2) && (off2[0] === "i32.const" || off2[0] === "i64.const")) {
-      return { memidx: mem, offset: Number(off2[1]) };
-    }
-    return null;
-  }
-  const off = node[idx];
-  if (Array.isArray(off) && (off[0] === "i32.const" || off[0] === "i64.const")) {
-    return { memidx: 0, offset: Number(off[1]) };
-  }
-  return null;
-};
-var getDataLength = (node) => {
-  let idx = 1;
-  if (typeof node[idx] === "string" && node[idx][0] === "$") idx++;
-  if (Array.isArray(node[idx]) && node[idx][0] === "memory") idx++;
-  if (Array.isArray(node[idx]) && typeof node[idx][0] === "string" && !node[idx][0].startsWith('"')) idx++;
-  let len = 0;
-  for (let i = idx; i < node.length; i++) {
-    const item = node[i];
-    if (typeof item === "string") len += parseDataString(item).length;
-    else if (Array.isArray(item) && item[0] === "i8") len += item.length - 1;
-    else return null;
-  }
-  return len;
-};
-var mergeDataSegments = (a, b) => {
-  let aIdx = 1;
-  if (typeof a[aIdx] === "string" && a[aIdx][0] === "$") aIdx++;
-  if (Array.isArray(a[aIdx]) && a[aIdx][0] === "memory") aIdx++;
-  if (Array.isArray(a[aIdx]) && typeof a[aIdx][0] === "string" && !a[aIdx][0].startsWith('"')) aIdx++;
-  let bIdx = 1;
-  if (typeof b[bIdx] === "string" && b[bIdx][0] === "$") bIdx++;
-  if (Array.isArray(b[bIdx]) && b[bIdx][0] === "memory") bIdx++;
-  if (Array.isArray(b[bIdx]) && typeof b[bIdx][0] === "string" && !b[bIdx][0].startsWith('"')) bIdx++;
-  const aContent = a.slice(aIdx);
-  const bContent = b.slice(bIdx);
-  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]);
-    for (let i = 0; i < bBytes.length; i++) aBytes.push(bBytes[i]);
-    a.length = aIdx;
-    a.push(encodeDataString(aBytes, aBytes.length));
-    return true;
-  }
-  a.length = aIdx;
-  a.push(...aContent, ...bContent);
-  return true;
-};
-var packData = (ast) => {
-  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  for (const node of ast) {
-    if (!Array.isArray(node) || node[0] !== "data") continue;
-    let contentStart = 1;
-    if (typeof node[1] === "string" && node[1][0] === "$") contentStart = 2;
-    if (contentStart < node.length && Array.isArray(node[contentStart]) && typeof node[contentStart][0] === "string" && !node[contentStart][0].startsWith('"')) {
-      contentStart++;
-    }
-    const content = node.slice(contentStart);
-    if (content.length === 0) continue;
-    const trimmed = trimTrailingZeros(content);
-    if (trimmed.length !== content.length || trimmed.length > 0 && trimmed[0] !== content[0]) {
-      node.length = contentStart;
-      node.push(...trimmed);
-    }
-  }
-  const dataNodes = [];
-  for (let i = 0; i < ast.length; i++) {
-    const node = ast[i];
-    if (Array.isArray(node) && node[0] === "data") {
-      const info = getDataOffset(node);
-      if (info) {
-        const len = getDataLength(node);
-        if (len !== null) dataNodes.push({ ...info, node, index: i, len });
-      }
-    }
-  }
-  dataNodes.sort((a, b) => {
-    const ma = String(a.memidx), mb = String(b.memidx);
-    if (ma !== mb) return ma.localeCompare(mb);
-    return a.offset - b.offset;
-  });
-  const toRemove = /* @__PURE__ */ new Set();
-  for (let i = 0; i < dataNodes.length - 1; i++) {
-    const a = dataNodes[i];
-    const b = dataNodes[i + 1];
-    if (toRemove.has(a.index) || String(a.memidx) !== String(b.memidx)) continue;
-    if (a.offset + a.len !== b.offset) continue;
-    if (mergeDataSegments(a.node, b.node)) {
-      toRemove.add(b.index);
-      a.len = getDataLength(a.node);
-    }
-  }
-  if (toRemove.size > 0) {
-    ast = ast.filter((_, i) => !toRemove.has(i));
-  }
-  return ast;
-};
-var makeShortener = () => {
-  const map = /* @__PURE__ */ new Map();
-  let n = 0;
-  return (name2) => {
-    if (!map.has(name2)) {
-      let id2 = "", x = n++;
-      do {
-        id2 = String.fromCharCode(97 + x % 26) + id2;
-        x = Math.floor(x / 26) - 1;
-      } while (x >= 0);
-      map.set(name2, id2 || "a");
-    }
-    return map.get(name2);
-  };
-};
-var minifyImports = (ast) => {
-  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const shortMod = makeShortener();
-  const shortField = makeShortener();
-  for (const node of ast) {
-    if (!Array.isArray(node) || node[0] !== "import") continue;
-    if (typeof node[1] === "string" && node[1][0] === '"') {
-      node[1] = '"' + shortMod(node[1].slice(1, -1)) + '"';
-    }
-    if (typeof node[2] === "string" && node[2][0] === '"') {
-      node[2] = '"' + shortField(node[2].slice(1, -1)) + '"';
-    }
-  }
-  return ast;
-};
-var reorderSafe = (ast) => {
-  let safe = true;
-  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;
-    else if ((op === "call" || op === "return_call" || op === "ref.func") && (typeof n[1] !== "string" || n[1][0] !== "$")) safe = false;
-    else if (op === "start" && (typeof n[1] !== "string" || n[1][0] !== "$")) safe = false;
-    else if (op === "elem") {
-      for (const sub of n) {
-        if (typeof sub === "string" && sub[0] !== "$" && /^\d/.test(sub)) {
-          safe = false;
-          break;
-        }
-        if (Array.isArray(sub) && sub[0] === "ref.func" && (typeof sub[1] !== "string" || sub[1][0] !== "$")) {
-          safe = false;
-          break;
-        }
-      }
-    }
-  });
-  return safe;
-};
-var reorder = (ast) => {
-  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  if (!reorderSafe(ast)) return ast;
-  const callCounts = /* @__PURE__ */ new Map();
-  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);
-    }
-  });
-  const imports = [], funcs = [], others = [];
-  for (const node of ast.slice(1)) {
-    if (!Array.isArray(node)) {
-      others.push(node);
-      continue;
-    }
-    if (node[0] === "import") imports.push(node);
-    else if (node[0] === "func") funcs.push(node);
-    else others.push(node);
-  }
-  funcs.sort((a, b) => (callCounts.get(b[1]) || 0) - (callCounts.get(a[1]) || 0));
-  return ["module", ...imports, ...funcs, ...others];
-};
-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"],
-  ["unbranch", unbranch, true, "remove redundant br at end of own block"],
-  ["loopify", loopify, true, "collapse block+loop+brif while-idiom into loop+if"],
-  ["brif", brif, true, "if-then-br \u2192 br_if"],
-  ["foldarms", foldarms, false, "merge identical trailing if arms \u2014 can add block wrapper"],
-  ["deadcode", deadcode, true, "eliminate dead code after unreachable/br/return"],
-  ["vacuum", vacuum, true, "remove nops, drop-of-pure, empty branches"],
-  ["mergeBlocks", mergeBlocks, true, "unwrap `(block $L \u2026)` whose label is never targeted"],
-  ["coalesce", coalesceLocals, true, "share local slots between same-type non-overlapping locals"],
-  ["locals", localReuse, true, "remove unused locals"],
-  ["dedupe", dedupe, true, "eliminate duplicate functions"],
-  ["dedupTypes", dedupTypes, true, "merge identical type definitions"],
-  ["packData", packData, true, "trim trailing zeros, merge adjacent data segments"],
-  ["reorder", reorder, false, "put hot functions first \u2014 no AST reduction"],
-  ["treeshake", treeshake, true, "remove unused funcs/globals/types/tables"],
-  ["minifyImports", minifyImports, false, "shorten import names \u2014 enable only when you control the host"]
-];
-var OPTS = Object.fromEntries(PASSES.map((p) => [p[0], p[2]]));
-var normalize3 = (opts) => {
-  if (opts === false) return {};
-  if (opts !== true && typeof opts !== "string") {
-    const m2 = { ...opts };
-    for (const p of PASSES) if (m2[p[0]] === void 0) m2[p[0]] = p[2];
-    return m2;
-  }
-  const set = typeof opts === "string" ? new Set(opts.split(/\s+/).filter(Boolean)) : null;
-  const m = {};
-  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;
-  opts = normalize3(opts);
-  opts.pin = opts.pin instanceof Set ? opts.pin : new Set(opts.pin || []);
-  const log = opts.log ? (msg, delta) => opts.log(msg, delta) : () => {
-  };
-  const verbose = opts.verbose || opts.log;
-  ast = clone2(ast);
-  const runInline = (a) => {
-    if (!opts.inline) return a;
-    a = inline(a, { simdOnly: opts.inline === "simd", pin: opts.pin });
-    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, opts);
-      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 = clone2(ast);
-    for (const [key, fn] of PASSES) if (opts[key] && key !== "devirt" && key !== "inline") ast = fn(ast, opts);
-    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);
-    const tolerance = strictGuard ? 0 : 16;
-    if (delta > tolerance) {
-      if (verbose) log(`  \u26A0 round ${round + 1} inflated by ${delta} bytes, reverting`, delta);
-      ast = beforeRound;
-      break;
-    }
-    sizeBefore = sizeAfter;
-  }
-  return finish(ast);
-}
-
-// src/template.js
-var PUA = "\uE000";
-var exprType = (node, ctx = {}) => {
-  if (!Array.isArray(node)) {
-    if (typeof node === "string" && node[0] === "$" && ctx.locals?.[node]) return ctx.locals[node];
-    return null;
-  }
-  const [op, ...args] = node;
-  const rt = resultType(op);
-  if (rt) return rt;
-  if (op === "local.get" && ctx.locals?.[args[0]]) return ctx.locals[args[0]];
-  if (op === "call" && ctx.funcs?.[args[0]]) return ctx.funcs[args[0]].result?.[0];
-  return null;
-};
-function walk3(node, fn) {
-  node = fn(node);
-  if (Array.isArray(node)) {
-    for (let i = 0; i < node.length; i++) {
-      let child = walk3(node[i], fn);
-      if (child?._splice) node.splice(i, 1, ...child), i += child.length - 1;
-      else node[i] = child;
-    }
-  }
-  return node;
+  return node;
 }
 function inferImports(ast, funcs) {
   const imports = [];
   const importMap = /* @__PURE__ */ new Map();
-  walk3(ast, (node) => {
+  walk(ast, (node) => {
     if (!Array.isArray(node)) return node;
     if (node[0] === "call" && typeof node[1] === "function") {
       const fn = node[1];
@@ -6102,7 +2373,7 @@ function genImports(imports) {
   );
 }
 function compile2(backend2, source, values) {
-  const { parse, compile: emit, optimize: optimize2, polyfill: polyfill2 } = backend2;
+  const { parse, compile: emit, optimize, polyfill } = backend2;
   let opts = {};
   if (!Array.isArray(source) && values.length && typeof values[values.length - 1] === "object" && values[values.length - 1] !== null && !values[values.length - 1].byteLength) {
     opts = values.pop();
@@ -6115,7 +2386,7 @@ function compile2(backend2, source, values) {
     let ast = parse(src);
     const funcsToImport = [];
     let idx = 0;
-    ast = walk3(ast, (node) => {
+    ast = walk(ast, (node) => {
       if (node === PUA) {
         const value = values[idx++];
         if (typeof value === "function") {
@@ -6153,16 +2424,16 @@ function compile2(backend2, source, values) {
         }
       }
     }
-    if (opts.polyfill) ast = polyfill2(ast, opts.polyfill);
-    if (opts.optimize) ast = optimize2(ast, opts.optimize);
+    if (opts.polyfill) ast = applyTransform(polyfill, "polyfill", ast, opts.polyfill);
+    if (opts.optimize) ast = applyTransform(optimize, "optimize", ast, opts.optimize);
     const binary = emit(ast);
     if (importObjs) binary._imports = importObjs;
     return binary;
   }
   if (opts.polyfill || opts.optimize) {
     let ast = typeof source === "string" ? parse(source) : source;
-    if (opts.polyfill) ast = polyfill2(ast, opts.polyfill);
-    if (opts.optimize) ast = optimize2(ast, opts.optimize);
+    if (opts.polyfill) ast = applyTransform(polyfill, "polyfill", ast, opts.polyfill);
+    if (opts.optimize) ast = applyTransform(optimize, "optimize", ast, opts.optimize);
     return emit(ast);
   }
   return emit(source);
@@ -6175,7 +2446,7 @@ function watr(backend2, source, values) {
 }
 
 // watr.js
-var backend = { parse: parse_default, compile, optimize, polyfill };
+var backend = { parse: parse_default, compile };
 function compile3(source, ...values) {
   return compile2(backend, source, values);
 }
@@ -6186,9 +2457,7 @@ var watr_default = watr2;
 export {
   compile3 as compile,
   watr_default as default,
-  optimize,
   parse_default as parse,
-  polyfill,
   print,
   watr2 as watr
 };