watr 4.5.1 → 4.6.0

package/dist/watr.js

@@ -140,16 +140,29 @@ var _f64 = new Float64Array(_buf);
 var _i64 = new BigInt64Array(_buf);
 i64.parse = (n) => {
   n = cleanInt(n);
-  n = n[0] === "-" ? -BigInt(n.slice(1)) : BigInt(n);
-  if (n < -0x8000000000000000n || n > 0xffffffffffffffffn) err(`i64 constant out of range`);
-  _i64[0] = n;
+  const neg = n[0] === "-";
+  const body = neg ? n.slice(1) : n;
+  let max;
+  if (body[0] === "0" && (body[1] === "x" || body[1] === "X")) {
+    const hex = body.slice(2).replace(/^0+/, "") || "0";
+    max = neg ? "8000000000000000" : "ffffffffffffffff";
+    if (hex.length > 16 || hex.length === 16 && hex.toLowerCase() > max) err(`i64 constant out of range`);
+  } else {
+    const dec = body.replace(/^0+/, "") || "0";
+    max = neg ? "9223372036854775808" : "18446744073709551615";
+    if (dec.length > max.length || dec.length === max.length && dec > max) err(`i64 constant out of range`);
+  }
+  let bi = BigInt(body);
+  if (neg) bi = 0n - bi;
+  _i64[0] = bi;
   return _i64[0];
 };
 var F32_SIGN = 2147483648;
 var F32_NAN = 2139095040;
+var F32_QUIET = 4194304;
 function f32(input, value, idx) {
-  if (typeof input === "string" && ~(idx = input.indexOf("nan:"))) {
-    value = i32.parse(input.slice(idx + 4));
+  if (typeof input === "string" && (idx = input.indexOf("nan")) >= 0) {
+    value = input[idx + 3] === ":" ? i32.parse(input.slice(idx + 4)) : F32_QUIET;
     value |= F32_NAN;
     if (input[0] === "-") value |= F32_SIGN;
     _i32[0] = value;
@@ -161,9 +174,10 @@ function f32(input, value, idx) {
 }
 var F64_SIGN = 0x8000000000000000n;
 var F64_NAN = 0x7ff0000000000000n;
+var F64_QUIET = 0x8000000000000n;
 function f64(input, value, idx) {
-  if (typeof input === "string" && ~(idx = input.indexOf("nan:"))) {
-    value = i64.parse(input.slice(idx + 4));
+  if (typeof input === "string" && (idx = input.indexOf("nan")) >= 0) {
+    value = input[idx + 3] === ":" ? i64.parse(input.slice(idx + 4)) : F64_QUIET;
     value |= F64_NAN;
     if (input[0] === "-") value |= F64_SIGN;
     _i64[0] = value;
@@ -182,8 +196,11 @@ f64.parse = (input, max = Number.MAX_VALUE) => {
     let [sig, exp = "0"] = input.split(/p/i);
     let [int, fract = ""] = sig.split(".");
     let flen = fract.length ?? 0;
-    let intVal = parseInt(int);
-    isNaN(intVal) && err();
+    let intVal = 0;
+    for (let i = int.length - 1; i >= 2; i--) {
+      let digit = parseInt(int[i], 16);
+      intVal += digit * 16 ** (int.length - 1 - i);
+    }
     let fractVal = fract ? parseInt("0x" + fract) / 16 ** flen : 0;
     exp = parseInt(exp, 10);
     let value = sign * (intVal + fractVal) * 2 ** exp;
@@ -497,9 +514,9 @@ var INSTR = [
     "array.init_data typeidx_dataidx",
     "array.init_elem typeidx_elemidx",
     "ref.test reftype",
-    "",
+    "ref.test_null reftype",
     "ref.cast reftype",
-    "",
+    "ref.cast_null reftype",
     "br_on_cast reftype2",
     "br_on_cast_fail reftype2",
     "any.convert_extern",
@@ -1244,6 +1261,7 @@ var TYPE = {
   i31: 108,
   struct: 107,
   array: 106,
+  data: 107,
   cont: 104,
   nocont: 117,
   // stack switching (Phase 3)
@@ -1522,7 +1540,7 @@ function normalize(nodes, ctx) {
         ctx.datacount && (ctx.datacount[0] = true);
       } else if ((node.startsWith("memory.") || node.endsWith("load") || node.endsWith("store")) && isIdx(nodes[0])) out.push(nodes.shift());
     } else if (Array.isArray(node)) {
-      const op = node[0];
+      let op = node[0];
       node.loc != null && (err.loc = node.loc);
       if (op?.startsWith?.("@metadata.code.")) {
         let type = op.slice(15);
@@ -1556,6 +1574,12 @@ function normalize(nodes, ctx) {
           out.push(parts.shift());
         }
         out.push(...normalize(parts, ctx), "end");
+      } else if (op === "ref.test" || op === "ref.cast") {
+        const type = parts[0];
+        const isNullable = !Array.isArray(type) || type[1] === "null" || type[0] !== "ref";
+        if (isNullable) op += "_null";
+        out.push(...normalize(parts.slice(1), ctx), op, type);
+        nodes.unshift(...out.splice(out.length - 2));
       } else {
         const imm = [];
         while (parts.length && (!Array.isArray(parts[0]) || parts[0].valueOf !== Array.prototype.valueOf || "type,param,result,ref,exact,on".includes(parts[0][0]))) imm.push(parts.shift());
@@ -2006,7 +2030,7 @@ var instr = (nodes, ctx) => {
     let [...bytes] = INSTR[op] || err(`Unknown instruction ${op}`);
     if (HANDLER[op]) {
       if (op === "select" && nodes[0]?.length) bytes[0]++;
-      else if (HANDLER[op] === IMM.reftype && (nodes[0][1] === "null" || nodes[0][0] !== "ref")) {
+      else if (HANDLER[op] === IMM.reftype && !op.endsWith("_null") && (nodes[0][1] === "null" || nodes[0][0] !== "ref")) {
         bytes[bytes.length - 1]++;
       }
       bytes.push(...HANDLER[op](nodes, ctx, op));
@@ -3041,11 +3065,17 @@ var OPTS = {
   branch: true,
   // simplify constant branches
   propagate: true,
-  // constant propagation through locals
-  inline: true,
-  // inline tiny functions
+  // forward-propagate single-use locals & tiny consts (never inflates)
+  inline: false,
+  // inline tiny functions — can duplicate bodies
+  inlineOnce: true,
+  // inline single-call functions into their lone caller (never duplicates)
   vacuum: true,
   // remove nops, drop-of-pure, empty branches
+  mergeBlocks: true,
+  // unwrap `(block $L …)` whose label is never targeted
+  coalesce: true,
+  // share local slots between same-type non-overlapping locals
   peephole: true,
   // x-x→0, x&0→0, etc.
   globals: true,
@@ -3058,14 +3088,12 @@ var OPTS = {
   // strip mut from never-written globals
   brif: true,
   // if-then-br → br_if
-  foldarms: true,
-  // merge identical trailing if arms
-  // minify: true,    // NOTE: disabled — renaming $ids has no binary-size effect
-  // without a names section, and risks local-name collisions.
+  foldarms: false,
+  // merge identical trailing if arms — can add block wrapper
   dedupe: true,
   // eliminate duplicate functions
-  reorder: true,
-  // put hot functions first for smaller LEBs
+  reorder: false,
+  // put hot functions first — no AST reduction
   dedupTypes: true,
   // merge identical type definitions
   packData: true,
@@ -3074,6 +3102,13 @@ var OPTS = {
   // shorten import names — enable only when you control the host
 };
 var ALL2 = Object.keys(OPTS);
+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;
@@ -3088,10 +3123,8 @@ var normalize3 = (opts) => {
   if (opts === false) return {};
   if (typeof opts === "string") {
     const set = new Set(opts.split(/\s+/).filter(Boolean));
-    if (set.size === 1 && ALL2.includes([...set][0])) {
-      return Object.fromEntries(ALL2.map((f) => [f, set.has(f)]));
-    }
-    return Object.fromEntries(ALL2.map((f) => [f, set.has(f) || set.has("all")]));
+    if (set.has("all")) return Object.fromEntries(ALL2.map((f) => [f, true]));
+    return Object.fromEntries(ALL2.map((f) => [f, set.has(f)]));
   }
   return { ...OPTS, ...opts };
 };
@@ -3401,7 +3434,7 @@ var makeConst = (type, value) => {
   return null;
 };
 var fold = (ast) => {
-  return walkPost2(clone2(ast), (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const entry = FOLDABLE[node[0]];
     if (!entry) return;
@@ -3464,7 +3497,7 @@ var IDENTITIES = {
   // f * 1 → x (careful with NaN, skip for floats)
 };
 var identity = (ast) => {
-  return walkPost2(clone2(ast), (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node.length !== 3) return;
     const fn = IDENTITIES[node[0]];
     if (!fn) return;
@@ -3474,7 +3507,7 @@ var identity = (ast) => {
   });
 };
 var strength = (ast) => {
-  return walkPost2(clone2(ast), (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node.length !== 3) return;
     const [op, a, b] = node;
     if (op === "i32.mul") {
@@ -3530,7 +3563,7 @@ var strength = (ast) => {
   });
 };
 var branch = (ast) => {
-  return walkPost2(clone2(ast), (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const op = node[0];
     if (op === "if") {
@@ -3562,8 +3595,7 @@ var branch = (ast) => {
 };
 var TERMINATORS = /* @__PURE__ */ new Set(["unreachable", "return", "br", "br_table"]);
 var deadcode = (ast) => {
-  const result = clone2(ast);
-  walk2(result, (node) => {
+  walk2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const kind = node[0];
     if (kind === "func" || kind === "block" || kind === "loop") {
@@ -3577,7 +3609,7 @@ var deadcode = (ast) => {
       }
     }
   });
-  return result;
+  return ast;
 };
 var eliminateDeadInBlock = (block) => {
   let terminated = false;
@@ -3609,8 +3641,7 @@ var eliminateDeadInBlock = (block) => {
   }
 };
 var localReuse = (ast) => {
-  const result = clone2(ast);
-  walk2(result, (node) => {
+  walk2(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "func") return;
     const localDecls = [];
     const localTypes = /* @__PURE__ */ new Map();
@@ -3647,7 +3678,7 @@ var localReuse = (ast) => {
       }
     }
   });
-  return result;
+  return ast;
 };
 var IMPURE_OPS = /* @__PURE__ */ new Set([
   "call",
@@ -3712,7 +3743,29 @@ var countLocalUses = (node) => {
   });
   return counts;
 };
-var canSubst = (k) => getConst(k.val) || k.pure && k.singleUse;
+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 = typeof c.value === "bigint" ? c.value : BigInt(c.value);
+    return v >= -64n && v <= 63n;
+  }
+  return false;
+};
+var canSubst = (k) => k.pure && k.singleUse || isTinyConst(k.val);
+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 substGets = (node, known) => walkPost2(node, (n) => {
   if (!Array.isArray(n) || n[0] !== "local.get" || n.length !== 2) return;
   const k = typeof n[1] === "string" && known.get(n[1]);
@@ -3727,9 +3780,10 @@ var forwardPropagate = (funcNode, params, useCounts) => {
     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" && instr2.length === 3 && typeof instr2[1] === "string") {
+    if ((op === "local.set" || op === "local.tee") && instr2.length === 3 && typeof instr2[1] === "string") {
       substGets(instr2[2], known);
       const uses = getUseCount(instr2[1]);
+      purgeRefs(known, instr2[1]);
       known.set(instr2[1], {
         val: instr2[2],
         pure: isPure(instr2[2]),
@@ -3755,6 +3809,12 @@ var forwardPropagate = (funcNode, params, useCounts) => {
       const prev = clone2(instr2);
       substGets(instr2, known);
       if (!equal(prev, instr2)) changed = true;
+      walk2(instr2, (n) => {
+        if (Array.isArray(n) && (n[0] === "local.set" || n[0] === "local.tee") && typeof n[1] === "string") {
+          known.delete(n[1]);
+          purgeRefs(known, n[1]);
+        }
+      });
     }
   }
   return changed;
@@ -3812,29 +3872,35 @@ var eliminateDeadStores = (funcNode, params, useCounts) => {
   }
   return changed;
 };
+var isScopeNode = (n) => Array.isArray(n) && (n[0] === "func" || n[0] === "block" || n[0] === "loop" || n[0] === "then" || n[0] === "else");
 var propagate = (ast) => {
-  const result = clone2(ast);
-  walk2(result, (funcNode) => {
+  walk2(ast, (funcNode) => {
     if (!Array.isArray(funcNode) || funcNode[0] !== "func") return;
     const params = /* @__PURE__ */ new Set();
     for (const sub of funcNode)
       if (Array.isArray(sub) && sub[0] === "param" && typeof sub[1] === "string") params.add(sub[1]);
-    for (let pass = 0; pass < 4; pass++) {
-      let changed = false;
-      if (forwardPropagate(funcNode, params, countLocalUses(funcNode))) changed = true;
-      if (eliminateSetGetPairs(funcNode, params, countLocalUses(funcNode))) changed = true;
-      if (createLocalTees(funcNode, params, countLocalUses(funcNode))) changed = true;
-      if (eliminateDeadStores(funcNode, params, countLocalUses(funcNode))) changed = true;
-      if (!changed) break;
+    const scopes = [];
+    walkPost2(funcNode, (n) => {
+      if (isScopeNode(n)) scopes.push(n);
+    });
+    for (let round = 0; round < 6; 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 (!progressed) break;
     }
   });
-  return result;
+  return ast;
 };
 var inline = (ast) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const result = clone2(ast);
   const inlinable = /* @__PURE__ */ new Map();
-  for (const node of result.slice(1)) {
+  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;
@@ -3878,8 +3944,8 @@ var inline = (ast) => {
       }
     }
   }
-  if (inlinable.size === 0) return result;
-  walkPost2(result, (node) => {
+  if (inlinable.size === 0) return ast;
+  walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "call") return;
     const fname = node[1];
     if (!inlinable.has(fname)) return;
@@ -3899,10 +3965,315 @@ var inline = (ast) => {
     });
     return substituted;
   });
-  return result;
+  return ast;
+};
+var inlineUid = 0;
+var inlineOnce = (ast) => {
+  if (!Array.isArray(ast) || ast[0] !== "module") return ast;
+  const HEAD = /* @__PURE__ */ new Set(["export", "type", "param", "result", "local"]);
+  const bodyStart = (fn) => {
+    let i = 2;
+    while (i < fn.length && (typeof fn[i] === "string" || Array.isArray(fn[i]) && HEAD.has(fn[i][0]))) i++;
+    return i;
+  };
+  const isBranch = (op) => op === "br" || op === "br_if" || op === "br_table";
+  const unsafe = (n) => {
+    if (!Array.isArray(n)) return false;
+    const op = n[0];
+    if (op === "return_call" || op === "return_call_indirect" || op === "return_call_ref") return true;
+    if (op === "try" || op === "try_table" || op === "delegate" || op === "rethrow") return true;
+    if (isBranch(op)) {
+      for (let i = 1; i < n.length; i++) if (typeof n[i] === "number" || typeof n[i] === "string" && /^\d+$/.test(n[i])) return true;
+    }
+    for (let i = 1; i < n.length; i++) if (unsafe(n[i])) return true;
+    return false;
+  };
+  const callsSelf = (n, name2) => {
+    if (!Array.isArray(n)) return false;
+    if ((n[0] === "call" || n[0] === "return_call") && n[1] === name2) return true;
+    for (let i = 1; i < n.length; i++) if (callsSelf(n[i], name2)) return true;
+    return false;
+  };
+  const collectPinned = (n, pinned) => {
+    if (!Array.isArray(n)) return;
+    const op = n[0];
+    if (op === "export" && Array.isArray(n[2]) && n[2][0] === "func" && typeof n[2][1] === "string") pinned.add(n[2][1]);
+    else if (op === "start" && typeof n[1] === "string") pinned.add(n[1]);
+    else if (op === "ref.func" && typeof n[1] === "string") pinned.add(n[1]);
+    else if (op === "elem") {
+      for (const c of n) if (typeof c === "string" && c[0] === "$") pinned.add(c);
+    }
+    for (const c of n) collectPinned(c, pinned);
+  };
+  for (let round = 0; round < 16; 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") collectPinned(n, pinned);
+    let calleeName = null;
+    for (const [name2, fn] of funcByName) {
+      if (pinned.has(name2) || otherRef.has(name2)) continue;
+      if (callRefs.get(name2) !== 1) 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;
+          }
+        } 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 resultType = 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) resultType = 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 isBlockLabel = (op) => op === "block" || op === "loop" || op === "if";
+    const labelRename = /* @__PURE__ */ new Map();
+    const collectLabels = (n) => {
+      if (!Array.isArray(n)) return;
+      if (isBlockLabel(n[0]) && typeof n[1] === "string" && n[1][0] === "$" && !labelRename.has(n[1]))
+        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 (isBlockLabel(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 inner = cBody.map(sub);
+          done = true;
+          return resultType ? ["block", exit, ["result", resultType], ...setup, ...inner] : ["block", exit, ...setup, ...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;
+        }
+      }
+    }
+    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) => {
+  walk2(ast, (node) => {
+    if (!isScopeNode(node)) return;
+    let i = 1;
+    while (i < node.length) {
+      const child = node[i];
+      if (!Array.isArray(child) || child[0] !== "block") {
+        i++;
+        continue;
+      }
+      let bi = 1, label = null;
+      if (typeof child[1] === "string" && child[1][0] === "$") {
+        label = child[1];
+        bi = 2;
+      }
+      let typed = false;
+      for (let j = bi; j < child.length; j++) {
+        const c = child[j];
+        if (Array.isArray(c) && (c[0] === "param" || c[0] === "result" || c[0] === "type")) {
+          typed = true;
+          break;
+        }
+      }
+      if (typed) {
+        i++;
+        continue;
+      }
+      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(clone2(ast), (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const op = node[0];
     if (op === "nop") return ["nop"];
@@ -4001,7 +4372,7 @@ var PEEPHOLE = {
   "local.set": (a, b) => Array.isArray(b) && b[0] === "local.get" && b[1] === a ? ["nop"] : null
 };
 var peephole = (ast) => {
-  return walkPost2(clone2(ast), (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node.length !== 3) return;
     const fn = PEEPHOLE[node[0]];
     if (!fn) return;
@@ -4009,37 +4380,85 @@ var peephole = (ast) => {
     if (result !== null) return result;
   });
 };
+var slebSize = (v) => {
+  let x = typeof v === "bigint" ? v : BigInt(Math.trunc(Number(v) || 0));
+  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 result = clone2(ast);
   const constGlobals = /* @__PURE__ */ new Map();
-  const mutableGlobals = /* @__PURE__ */ new Set();
-  for (const node of result.slice(1)) {
-    if (!Array.isArray(node) || node[0] !== "global") continue;
+  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;
-    const hasName = typeof node[1] === "string" && node[1][0] === "$";
-    const initIdx = hasName ? 3 : 2;
-    const typeSlot = hasName ? node[2] : node[1];
+    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;
-    const init = node[initIdx];
+    if (Array.isArray(typeSlot) && typeSlot[0] === "import") continue;
+    const init = node[3];
     if (getConst(init)) constGlobals.set(name2, init);
   }
-  walk2(result, (n) => {
-    if (!Array.isArray(n) || n[0] !== "global.set") return;
+  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] === "$") mutableGlobals.add(ref);
+    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);
   });
-  for (const name2 of mutableGlobals) constGlobals.delete(name2);
-  if (constGlobals.size === 0) return result;
-  return walkPost2(result, (node) => {
+  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;
-    const ref = node[1];
-    if (constGlobals.has(ref)) return clone2(constGlobals.get(ref));
+    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(clone2(ast), (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const op = node[0];
     if (typeof op !== "string" || !op.endsWith("load") && !op.endsWith("store")) return;
@@ -4090,8 +4509,7 @@ var offset = (ast) => {
   });
 };
 var unbranch = (ast) => {
-  const result = clone2(ast);
-  walk2(result, (node) => {
+  walk2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const op = node[0];
     if (op !== "block") return;
@@ -4117,19 +4535,18 @@ var unbranch = (ast) => {
     if (lastIdx < 0) return;
     const last = node[lastIdx];
     if (Array.isArray(last) && last[0] === "br" && last[1] === label) {
-      node.splice(lastIdx, 1);
+      node.splice(lastIdx, 1, ...last.slice(2));
     }
   });
-  return result;
+  return ast;
 };
 var stripmut = (ast) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const result = clone2(ast);
   const written = /* @__PURE__ */ new Set();
-  walk2(result, (n) => {
+  walk2(ast, (n) => {
     if (Array.isArray(n) && n[0] === "global.set" && typeof n[1] === "string") written.add(n[1]);
   });
-  return walkPost2(result, (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "global") return;
     const name2 = typeof node[1] === "string" && node[1][0] === "$" ? node[1] : null;
     if (!name2 || written.has(name2)) return;
@@ -4143,7 +4560,7 @@ var stripmut = (ast) => {
   });
 };
 var brif = (ast) => {
-  return walkPost2(clone2(ast), (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "if") return;
     const { cond, thenBranch, elseBranch } = parseIf(node);
     const thenEmpty = !thenBranch || thenBranch.length <= 1;
@@ -4159,7 +4576,7 @@ var brif = (ast) => {
   });
 };
 var foldarms = (ast) => {
-  return walkPost2(clone2(ast), (node) => {
+  return walkPost2(ast, (node) => {
     if (!Array.isArray(node) || node[0] !== "if") return;
     const { thenBranch, elseBranch } = parseIf(node);
     if (!thenBranch || !elseBranch) return;
@@ -4224,10 +4641,9 @@ var hashFunc = (node, localNames) => {
 };
 var dedupe = (ast) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const result = clone2(ast);
   const signatures = /* @__PURE__ */ new Map();
   const redirects = /* @__PURE__ */ new Map();
-  for (const node of result.slice(1)) {
+  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;
@@ -4247,8 +4663,8 @@ var dedupe = (ast) => {
       signatures.set(hash, name2);
     }
   }
-  if (redirects.size === 0) return result;
-  walkPost2(result, (node) => {
+  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])) {
@@ -4270,14 +4686,13 @@ var dedupe = (ast) => {
       }
     }
   });
-  return result;
+  return ast;
 };
 var dedupTypes = (ast) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const result = clone2(ast);
   const signatures = /* @__PURE__ */ new Map();
   const redirects = /* @__PURE__ */ new Map();
-  for (const node of result.slice(1)) {
+  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;
@@ -4288,15 +4703,15 @@ var dedupTypes = (ast) => {
       signatures.set(hash, name2);
     }
   }
-  if (redirects.size === 0) return result;
-  for (let i = result.length - 1; i >= 0; i--) {
-    const node = result[i];
+  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)) result.splice(i, 1);
+      if (name2 && redirects.has(name2)) ast.splice(i, 1);
     }
   }
-  walkPost2(result, (node) => {
+  walkPost2(ast, (node) => {
     if (!Array.isArray(node)) return;
     const op = node[0];
     if (op === "func") {
@@ -4329,7 +4744,7 @@ var dedupTypes = (ast) => {
       }
     }
   });
-  return result;
+  return ast;
 };
 var parseDataString = (str2) => {
   if (typeof str2 !== "string" || str2.length < 2 || str2[0] !== '"') return new Uint8Array();
@@ -4444,8 +4859,7 @@ var mergeDataSegments = (a, b) => {
 };
 var packData = (ast) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  let result = clone2(ast);
-  for (const node of result) {
+  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;
@@ -4461,8 +4875,8 @@ var packData = (ast) => {
     }
   }
   const dataNodes = [];
-  for (let i = 0; i < result.length; i++) {
-    const node = result[i];
+  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) {
@@ -4488,9 +4902,9 @@ var packData = (ast) => {
     }
   }
   if (toRemove.size > 0) {
-    result = result.filter((_, i) => !toRemove.has(i));
+    ast = ast.filter((_, i) => !toRemove.has(i));
   }
-  return result;
+  return ast;
 };
 var makeShortener = () => {
   const map = /* @__PURE__ */ new Map();
@@ -4509,10 +4923,9 @@ var makeShortener = () => {
 };
 var minifyImports = (ast) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
-  const result = clone2(ast);
   const shortMod = makeShortener();
   const shortField = makeShortener();
-  for (const node of result) {
+  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)) + '"';
@@ -4521,7 +4934,7 @@ var minifyImports = (ast) => {
       node[2] = '"' + shortField(node[2].slice(1, -1)) + '"';
     }
   }
-  return result;
+  return ast;
 };
 var reorderSafe = (ast) => {
   let safe = true;
@@ -4549,16 +4962,15 @@ var reorderSafe = (ast) => {
 var reorder = (ast) => {
   if (!Array.isArray(ast) || ast[0] !== "module") return ast;
   if (!reorderSafe(ast)) return ast;
-  const result = clone2(ast);
   const callCounts = /* @__PURE__ */ new Map();
-  walk2(result, (n) => {
+  walk2(ast, (n) => {
     if (!Array.isArray(n)) return;
     if (n[0] === "call" || n[0] === "return_call") {
       callCounts.set(n[1], (callCounts.get(n[1]) || 0) + 1);
     }
   });
   const imports = [], funcs = [], others = [];
-  for (const node of result.slice(1)) {
+  for (const node of ast.slice(1)) {
     if (!Array.isArray(node)) {
       others.push(node);
       continue;
@@ -4572,10 +4984,16 @@ var reorder = (ast) => {
 };
 function optimize(ast, opts = true) {
   if (typeof ast === "string") ast = parse_default(ast);
-  ast = clone2(ast);
+  const strictGuard = opts === true;
   opts = normalize3(opts);
-  for (let round = 0; round < 6; round++) {
-    const before = ast;
+  const log = opts.log ? (msg, delta) => opts.log(msg, delta) : () => {
+  };
+  const verbose = opts.verbose || opts.log;
+  ast = clone2(ast);
+  let beforeRound = null;
+  for (let round = 0; round < 3; round++) {
+    beforeRound = clone2(ast);
+    const sizeBefore = binarySize(ast);
     if (opts.stripmut) ast = stripmut(ast);
     if (opts.globals) ast = globals(ast);
     if (opts.fold) ast = fold(ast);
@@ -4584,6 +5002,7 @@ function optimize(ast, opts = true) {
     if (opts.strength) ast = strength(ast);
     if (opts.branch) ast = branch(ast);
     if (opts.propagate) ast = propagate(ast);
+    if (opts.inlineOnce) ast = inlineOnce(ast);
     if (opts.inline) ast = inline(ast);
     if (opts.offset) ast = offset(ast);
     if (opts.unbranch) ast = unbranch(ast);
@@ -4591,6 +5010,8 @@ function optimize(ast, opts = true) {
     if (opts.foldarms) ast = foldarms(ast);
     if (opts.deadcode) ast = deadcode(ast);
     if (opts.vacuum) ast = vacuum(ast);
+    if (opts.mergeBlocks) ast = mergeBlocks(ast);
+    if (opts.coalesce) ast = coalesceLocals(ast);
     if (opts.locals) ast = localReuse(ast);
     if (opts.dedupe) ast = dedupe(ast);
     if (opts.dedupTypes) ast = dedupTypes(ast);
@@ -4598,7 +5019,19 @@ function optimize(ast, opts = true) {
     if (opts.reorder) ast = reorder(ast);
     if (opts.treeshake) ast = treeshake(ast);
     if (opts.minifyImports) ast = minifyImports(ast);
-    if (equal(before, ast)) break;
+    if (opts.propagate && (opts.inlineOnce || opts.inline)) ast = propagate(ast);
+    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;
+    }
+    if (equal(beforeRound, ast)) break;
   }
   return ast;
 }