watr 4.5.3 → 4.6.0

package/dist/watr.js

@@ -1459,10 +1459,10 @@ function compile(nodes) {
     if (imported) ctx.import.push([...imported, [kind, ...node]]), node = null;
     items.push(node);
   });
-  const bin = (kind, count2 = true) => {
+  const bin = (kind, count = true) => {
     const items = ctx[kind].filter(Boolean).map((item) => build[kind](item, ctx)).filter(Boolean);
     if (kind === SECTION.custom) return items.flatMap((content) => [kind, ...vec(content)]);
-    return !items.length ? [] : [kind, ...vec(count2 ? vec(items) : items.flat())];
+    return !items.length ? [] : [kind, ...vec(count ? vec(items) : items.flat())];
   };
   const binMeta = () => {
     const sections = [];
@@ -1869,16 +1869,16 @@ var IMM = {
     isId(n[0]) && (c.block[n.shift()] = c.block.length + 1);
     let blocktype2 = n.shift();
     let result = !blocktype2 ? [TYPE.void] : blocktype2[0] === "result" ? reftype(blocktype2[1], c) : uleb(id(blocktype2[1], c.type));
-    let catches = [], count2 = 0;
+    let catches = [], count = 0;
     while (n[0]?.[0] === "catch" || n[0]?.[0] === "catch_ref" || n[0]?.[0] === "catch_all" || n[0]?.[0] === "catch_all_ref") {
       let clause = n.shift();
       let kind = clause[0] === "catch" ? 0 : clause[0] === "catch_ref" ? 1 : clause[0] === "catch_all" ? 2 : 3;
       if (kind <= 1) catches.push(kind, ...uleb(id(clause[1], c.tag)), ...uleb(blockid(clause[2], c.block)));
       else catches.push(kind, ...uleb(blockid(clause[1], c.block)));
-      count2++;
+      count++;
     }
     c.block.push(1);
-    return [...result, ...uleb(count2), ...catches];
+    return [...result, ...uleb(count), ...catches];
   },
   end: (_n, c) => (c.block.pop(), []),
   call_indirect: (n, c) => {
@@ -1886,9 +1886,9 @@ var IMM = {
     return [...uleb(id(idx, c.type)), ...uleb(id(t, c.table))];
   },
   br_table: (n, c) => {
-    let labels = [], count2 = 0;
-    while (n[0] && (!isNaN(n[0]) || isId(n[0]))) labels.push(...uleb(blockid(n.shift(), c.block))), count2++;
-    return [...uleb(count2 - 1), ...labels];
+    let labels = [], count = 0;
+    while (n[0] && (!isNaN(n[0]) || isId(n[0]))) labels.push(...uleb(blockid(n.shift(), c.block))), count++;
+    return [...uleb(count - 1), ...labels];
   },
   select: (n, c) => {
     let r = n.shift() || [];
@@ -3064,12 +3064,18 @@ var OPTS = {
   // strength reduction (x * 2 → x << 1)
   branch: true,
   // simplify constant branches
-  propagate: false,
-  // constant propagation — can duplicate expressions
+  propagate: true,
+  // 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,
@@ -3096,11 +3102,12 @@ var OPTS = {
   // shorten import names — enable only when you control the host
 };
 var ALL2 = Object.keys(OPTS);
-var count = (node) => {
-  if (!Array.isArray(node)) return 1;
-  let n = 1;
-  for (let i = 0; i < node.length; i++) n += count(node[i]);
-  return n;
+var binarySize = (ast) => {
+  try {
+    return compile(ast).length;
+  } catch {
+    return Infinity;
+  }
 };
 var equal = (a, b) => {
   if (a === b) return true;
@@ -3736,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]);
@@ -3754,6 +3783,7 @@ var forwardPropagate = (funcNode, params, useCounts) => {
     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]),
@@ -3780,8 +3810,10 @@ var forwardPropagate = (funcNode, params, useCounts) => {
       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")
+        if (Array.isArray(n) && (n[0] === "local.set" || n[0] === "local.tee") && typeof n[1] === "string") {
           known.delete(n[1]);
+          purgeRefs(known, n[1]);
+        }
       });
     }
   }
@@ -3840,19 +3872,27 @@ 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) => {
   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 ast;
@@ -3927,6 +3967,311 @@ var inline = (ast) => {
   });
   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(ast, (node) => {
     if (!Array.isArray(node)) return;
@@ -4035,33 +4380,82 @@ 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 constGlobals = /* @__PURE__ */ new Map();
-  const mutableGlobals = /* @__PURE__ */ new Set();
+  const exported = /* @__PURE__ */ new Set();
   for (const node of ast.slice(1)) {
-    if (!Array.isArray(node) || node[0] !== "global") continue;
+    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);
   }
+  if (constGlobals.size === 0) return ast;
+  const reads = /* @__PURE__ */ new Map();
   walk2(ast, (n) => {
-    if (!Array.isArray(n) || n[0] !== "global.set") return;
+    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 ast;
-  return walkPost2(ast, (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(ast, (node) => {
@@ -4141,7 +4535,7 @@ 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 ast;
@@ -4599,7 +4993,7 @@ function optimize(ast, opts = true) {
   let beforeRound = null;
   for (let round = 0; round < 3; round++) {
     beforeRound = clone2(ast);
-    const sizeBefore = count(ast);
+    const sizeBefore = binarySize(ast);
     if (opts.stripmut) ast = stripmut(ast);
     if (opts.globals) ast = globals(ast);
     if (opts.fold) ast = fold(ast);
@@ -4608,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);
@@ -4615,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);
@@ -4622,14 +5019,15 @@ function optimize(ast, opts = true) {
     if (opts.reorder) ast = reorder(ast);
     if (opts.treeshake) ast = treeshake(ast);
     if (opts.minifyImports) ast = minifyImports(ast);
-    const sizeAfter = count(ast);
+    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} nodes`, delta);
+      log(`  round ${round + 1}: ${delta > 0 ? "+" : ""}${delta} bytes`, delta);
     }
-    const tolerance = strictGuard ? 0 : 5;
+    const tolerance = strictGuard ? 0 : 16;
     if (delta > tolerance) {
-      if (verbose) log(`  \u26A0 round ${round + 1} inflated by ${delta}, reverting`, delta);
+      if (verbose) log(`  \u26A0 round ${round + 1} inflated by ${delta} bytes, reverting`, delta);
       ast = beforeRound;
       break;
     }