watr 5.0.0 → 5.1.1

package/src/compile.js

@@ -1,8 +1,8 @@
 import * as encode from './encode.js'
 import { uleb, i32, i64 } from './encode.js'
-import { SECTION, TYPE, KIND, INSTR, DEFTYPE } from './const.js'
+import { SECTION, TYPE, KIND, OPCODE, IMM, DEFTYPE } from './const.js'
 import parse from './parse.js'
-import { err, unescape, str } from './util.js'
+import { err, unescape, str, setErrLoc, setErrSrc, getErrLoc, getErrSrc } from './util.js'
 
 
 /**
@@ -17,8 +17,16 @@ import { err, unescape, str } from './util.js'
 // load past parse — strip them. Predicate stays separate from `cleanup` so
 // neither has to invent a "drop me" sentinel and risk colliding with a
 // legitimate `null`/`undefined` immediate in the AST.
+// A block-comment token is `(;…` (parse.js: `buf = '(' + ';'`) — checking n[1]===';'
+// ALONE (without also requiring n[0]==='(') also matches an ordinary quoted STRING
+// whose CONTENT happens to start with ';' (a string token always starts with n[0]==='"',
+// so n[1] is its first content byte). A data-segment string is exactly this shape once
+// packData splits a segment at a zero run and the surviving byte run starts with ';'
+// (e.g. a WAT-text stdlib template's own comment, interned as static data) — cleanup()
+// then silently drops that segment's whole content as if it were a comment. Mirrors the
+// already-correct guard in optimize.js's own comment-strip (`c[0]==='(' && c[1]===';'`).
 const isDroppable = (n) =>
-  (typeof n === 'string' && (n[0] === ';' || n[1] === ';')) ||
+  (typeof n === 'string' && (n[0] === ';' || (n[0] === '(' && n[1] === ';'))) ||
   (Array.isArray(n) && n[0]?.[0] === '@' && n[0] !== '@custom' && !n[0]?.startsWith?.('@metadata.code.'))
 
 const cleanup = (node, result) => {
@@ -42,9 +50,9 @@ const cleanup = (node, result) => {
 // reason to exist (the optimizer's size-revert guard can't afford to build bytes it discards).
 function assemble(nodes, sizeOnly) {
   // normalize to (module ...) form
-  if (typeof nodes === 'string') err.src = nodes, nodes = parse(nodes) || []
-  else err.src = '' // clear source if AST passed directly
-  err.loc = 0
+  if (typeof nodes === 'string') setErrSrc(nodes), nodes = parse(nodes) || []
+  else setErrSrc('') // clear source if AST passed directly
+  setErrLoc(0)
 
   nodes = isDroppable(nodes) ? [] : (cleanup(nodes) ?? [])
 
@@ -84,7 +92,7 @@ function assemble(nodes, sizeOnly) {
   nodes.slice(idx).filter((n) => {
     if (!Array.isArray(n)) {
       // find token as standalone word (not substring of another token)
-      let pos = err.loc, src = err.src, c
+      let pos = getErrLoc(), src = getErrSrc(), c
       while ((pos = src.indexOf(n, pos)) >= 0) {
         c = src.charCodeAt(pos - 1)
         // check not preceded by word char or $
@@ -94,11 +102,11 @@ function assemble(nodes, sizeOnly) {
         if (c > 47 && c < 58 || c > 64 && c < 91 || c > 96 && c < 123 || c === 95) { pos++; continue }
         break
       }
-      if (pos >= 0) err.loc = pos
+      if (pos >= 0) setErrLoc(pos)
       err(`Unexpected token ${n}`)
     }
     let [kind, ...node] = n
-    err.loc = n.loc // track position for errors
+    setErrLoc(n.loc) // track position for errors
     // (@custom "name" placement? data) - custom section support
     if (kind === '@custom') {
       ctx.custom.push(node)
@@ -141,7 +149,7 @@ function assemble(nodes, sizeOnly) {
     // prepare/normalize nodes
     .forEach((n) => {
       let [kind, ...node] = n
-      err.loc = n.loc // track position for errors
+      setErrLoc(n.loc) // track position for errors
       let imported // if node needs to be imported
 
       // import abbr
@@ -257,7 +265,15 @@ function assemble(nodes, sizeOnly) {
   // inline bin(code) so the per-function item bytes survive — with ctx.codeSizePrefix
   // they let us lift code-metadata positions to absolute binary offsets below
   const codeItems = ctx.code.filter(Boolean).map(item => build[SECTION.code](item, ctx)).filter(Boolean)
-  const codeSection = codeItems.length ? [SECTION.code, ...vec(vec(codeItems))] : []
+  // fused vec(vec(items)): count + items appended once, then the section frame —
+  // the generic path copies the multi-MB stream twice more
+  let codeSection = []
+  if (codeItems.length) {
+    const inner = uleb(codeItems.length)
+    for (const it of codeItems) for (let i = 0; i < it.length; i++) inner.push(it[i])
+    codeSection = [SECTION.code, ...uleb(inner.length)]
+    for (let i = 0; i < inner.length; i++) codeSection.push(inner[i])
+  }
   const metaSection = binMeta()
   const dataSection = bin(SECTION.data)
   const stringsSection = ctx.strings.length ? [SECTION.strings, ...vec([0x00, ...vec(ctx.strings.map(s => vec(s)))])] : []
@@ -282,12 +298,14 @@ function assemble(nodes, sizeOnly) {
     dataSection
   ]
 
-  // build final binary
-  const wasm = Uint8Array.from([
-    0x00, 0x61, 0x73, 0x6d, // magic
-    0x01, 0x00, 0x00, 0x00, // version
-    ...sections.flat()
-  ])
+  // build final binary — sections are flat byte arrays; copy them into place
+  // instead of flattening a multi-MB nested array through Uint8Array.from
+  let total = 8
+  for (const sec of sections) total += sec.length
+  const wasm = new Uint8Array(total)
+  wasm.set([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00])
+  let off = 8
+  for (const sec of sections) { if (sec.length) { wasm.set(sec, off); off += sec.length } }
 
   // Lift any (@metadata.code.*) annotations to absolute binary offsets and hang
   // them off the result, so a source-map emitter can correlate wasm back to
@@ -360,42 +378,65 @@ const isMemParam = n => n?.[0] === 'a' || n?.[0] === 'o'
  * @param {Object} ctx - Compilation context with type info
  * @returns {Array} Flattened instruction sequence
  */
-function normalize(nodes, ctx) {
-  const out = []
-  nodes = [...nodes]
+// bare-token classification — one lookup replaces a six-way string-scan chain
+// (built lazily over OPCODE's key set; unknown tokens fall through untouched)
+let NCLS = null
+const nclsOf = (op) => {
+  if (!NCLS) {
+    NCLS = Object.create(null)
+    for (const k in OPCODE) {
+      if (k === 'block' || k === 'if' || k === 'loop') NCLS[k] = 1
+      else if (k === 'else' || k === 'end') NCLS[k] = 2
+      else if (k === 'select') NCLS[k] = 3
+      else if (k.endsWith('call_indirect')) NCLS[k] = 4
+      else if (k === 'table.init') NCLS[k] = 5
+      else if (k === 'table.copy' || k === 'memory.copy') NCLS[k] = 6
+      else if (k.startsWith('table.')) NCLS[k] = 7
+      else if (k === 'memory.init') NCLS[k] = 8
+      else if (k === 'data.drop' || k === 'array.new_data' || k === 'array.init_data') NCLS[k] = 9
+      else if (k.startsWith('memory.') || k.endsWith('load') || k.endsWith('store')) NCLS[k] = 10
+    }
+  }
+  return NCLS[op]
+}
+
+function normalize(nodes, ctx, out = [], owned = false) {
+  if (!owned) nodes = [...nodes]
   while (nodes.length) {
     let node = nodes.shift()
     if (typeof node === 'string') {
       out.push(node)
-      if (node === 'block' || node === 'if' || node === 'loop') {
+      const cls = nclsOf(node)
+      if (cls === undefined) continue
+      if (cls === 1) {
         if (isId(nodes[0])) out.push(nodes.shift())
         out.push(blocktype(nodes, ctx))
       }
-      else if (node === 'else' || node === 'end') {
+      else if (cls === 2) {
         if (isId(nodes[0])) nodes.shift()
       }
-      else if (node === 'select') out.push(paramres(nodes)[1])
-      else if (node.endsWith('call_indirect')) {
+      else if (cls === 3) out.push(paramres(nodes)[1])
+      else if (cls === 4) {
         let tableidx = isIdx(nodes[0]) ? nodes.shift() : 0, [idx, param, result] = typeuse(nodes, ctx)
         out.push(tableidx, ['type', idx ?? regtype(param, result, ctx)])
       }
-      else if (node === 'table.init') out.push(isIdx(nodes[1]) ? nodes.shift() : 0, nodes.shift())
-      else if (node === 'table.copy' || node === 'memory.copy') out.push(isIdx(nodes[0]) ? nodes.shift() : 0, isIdx(nodes[0]) ? nodes.shift() : 0)
-      else if (node.startsWith('table.')) out.push(isIdx(nodes[0]) ? nodes.shift() : 0)
-      else if (node === 'memory.init') {
+      else if (cls === 5) out.push(isIdx(nodes[1]) ? nodes.shift() : 0, nodes.shift())
+      else if (cls === 6) out.push(isIdx(nodes[0]) ? nodes.shift() : 0, isIdx(nodes[0]) ? nodes.shift() : 0)
+      else if (cls === 7) out.push(isIdx(nodes[0]) ? nodes.shift() : 0)
+      else if (cls === 8) {
         out.push(...(isIdx(nodes[1]) ? [nodes.shift(), nodes.shift()].reverse() : [nodes.shift(), 0]))
         ctx.datacount && (ctx.datacount[0] = true)
       }
-      else if (node === 'data.drop' || node === 'array.new_data' || node === 'array.init_data') {
+      else if (cls === 9) {
         node === 'data.drop' && out.push(nodes.shift())
         ctx.datacount && (ctx.datacount[0] = true)
       }
       // memory.* instructions and load/store with optional memory index
-      else if ((node.startsWith('memory.') || node.endsWith('load') || node.endsWith('store')) && isIdx(nodes[0])) out.push(nodes.shift())
+      else if (isIdx(nodes[0])) out.push(nodes.shift())
     }
     else if (Array.isArray(node)) {
       let op = node[0]
-      node.loc != null && (err.loc = node.loc) // track position for errors
+      node.loc != null && setErrLoc(node.loc) // track position for errors
 
       // code metadata annotations - pass through as marker with metadata type and data
       // (@metadata.code.<type> data:str)
@@ -405,23 +446,29 @@ function normalize(nodes, ctx) {
         continue
       }
 
-      // Check if node is a valid instruction (string with opcode in INSTR)
-      if (typeof op !== 'string' || !Array.isArray(INSTR[op])) { out.push(node); continue }
+      // Check if node is a valid instruction (string with a known opcode)
+      if (typeof op !== 'string' || typeof OPCODE[op] !== 'number') { out.push(node); continue }
       const parts = node.slice(1)
       if (op === 'block' || op === 'loop') {
         out.push(op)
         if (isId(parts[0])) out.push(parts.shift())
-        out.push(blocktype(parts, ctx), ...normalize(parts, ctx), 'end')
+        out.push(blocktype(parts, ctx))
+        normalize(parts, ctx, out, true)
+        out.push('end')
       }
       else if (op === 'if') {
+        // then/else normalize BEFORE the condition but EMIT after it — the temp
+        // arrays preserve the original type-registration order exactly
         let then = [], els = []
-        if (parts.at(-1)?.[0] === 'else') els = normalize(parts.pop().slice(1), ctx)
-        if (parts.at(-1)?.[0] === 'then') then = normalize(parts.pop().slice(1), ctx)
+        if (parts.at(-1)?.[0] === 'else') els = normalize(parts.pop().slice(1), ctx, [], true)
+        if (parts.at(-1)?.[0] === 'then') then = normalize(parts.pop().slice(1), ctx, [], true)
         let immed = [op]
         if (isId(parts[0])) immed.push(parts.shift())
         immed.push(blocktype(parts, ctx))
-        out.push(...normalize(parts, ctx), ...immed, ...then)
-        els.length && out.push('else', ...els)
+        normalize(parts, ctx, out, true)
+        for (let i = 0; i < immed.length; i++) out.push(immed[i])
+        for (let i = 0; i < then.length; i++) out.push(then[i])
+        if (els.length) { out.push('else'); for (let i = 0; i < els.length; i++) out.push(els[i]) }
         out.push('end')
       }
       else if (op === 'try_table') {
@@ -432,20 +479,23 @@ function normalize(nodes, ctx) {
         while (parts[0]?.[0] === 'catch' || parts[0]?.[0] === 'catch_ref' || parts[0]?.[0] === 'catch_all' || parts[0]?.[0] === 'catch_all_ref') {
           out.push(parts.shift())
         }
-        out.push(...normalize(parts, ctx), 'end')
+        normalize(parts, ctx, out, true)
+        out.push('end')
       }
       else if (op === 'ref.test' || op === 'ref.cast') {
         const type = parts[0]
         const isNullable = !Array.isArray(type) || type[1] === 'null' || type[0] !== 'ref'
         if (isNullable) op += '_null'
-        out.push(...normalize(parts.slice(1), ctx), op, type)
+        normalize(parts.slice(1), ctx, out, true)
+        out.push(op, type)
         nodes.unshift(...out.splice(out.length - 2))
       }
       else {
         const imm = []
         // Collect immediate operands (non-arrays or special forms like type/param/result/ref)
         while (parts.length && (!Array.isArray(parts[0]) || parts[0].valueOf !== Array.prototype.valueOf || 'type,param,result,ref,exact,on'.includes(parts[0][0]))) imm.push(parts.shift())
-        out.push(...normalize(parts, ctx), op, ...imm)
+        normalize(parts, ctx, out, true)
+        out.push(op, ...imm)
         nodes.unshift(...out.splice(out.length - 1 - imm.length))
       }
     } else out.push(node)
@@ -819,10 +869,10 @@ const build = [
     ctx.local = ctx.block = ctx.meta = null
 
     // https://webassembly.github.io/spec/core/binary/modules.html#code-section
-    const item = vec([...locals, ...bytes])
-    // size-prefix length (item minus its body) lets the now function-body-relative
-    // metadata positions be lifted to absolute binary offsets
-    ;(ctx.codeSizePrefix ??= [])[codeIdx] = item.length - locals.length - bytes.length
+    const item = uleb(locals.length + bytes.length)
+    ;(ctx.codeSizePrefix ??= [])[codeIdx] = item.length // = vec prefix width
+    for (let i = 0; i < locals.length; i++) item.push(locals[i])
+    for (let i = 0; i < bytes.length; i++) item.push(bytes[i])
     return item
   },
 
@@ -894,15 +944,19 @@ const fieldtype = (t, ctx, mut = t[0] === 'mut' ? 1 : 0) => [...reftype(mut ? t[
 
 
 
-// Pre-defined instruction handlers
-const IMM = {
-  null: () => [],
+// Immediate encoders, keyed by immediate type (IMM in const.js maps op name → immediate type)
+// leb into `out` (returning undefined — the write-mode sentinel) or a fresh array
+const wleb = (v, out) => { if (out) { uleb(v, out); return } return uleb(v) }
+
+const HANDLER = {
   reversed: (n, c) => { let t = n.shift(), e = n.shift(); return [...uleb(id(e, c.elem)), ...uleb(id(t, c.table))] },
-  block: (n, c) => {
+  block: (n, c, op, out) => {
     c.block.push(1)
     isId(n[0]) && (c.block[n.shift()] = c.block.length)
     let t = n.shift()
-    return !t ? [TYPE.void] : t[0] === 'result' ? reftype(t[1], c) : uleb(id(t[1], c.type))
+    const b = !t ? [TYPE.void] : t[0] === 'result' ? reftype(t[1], c) : uleb(id(t[1], c.type))
+    if (out) { for (let i = 0; i < b.length; i++) out.push(b[i]); return }
+    return b
   },
   try_table: (n, c) => {
     isId(n[0]) && (c.block[n.shift()] = c.block.length + 1)
@@ -921,7 +975,11 @@ const IMM = {
     return [...result, ...uleb(count), ...catches]
   },
   end: (_n, c) => (c.block.pop(), []),
-  call_indirect: (n, c) => { let t = n.shift(), [, idx] = n.shift(); return [...uleb(id(idx, c.type)), ...uleb(id(t, c.table))] },
+  call_indirect: (n, c, op, out) => {
+    let t = n.shift(), [, idx] = n.shift()
+    if (out) { uleb(id(idx, c.type), out); uleb(id(t, c.table), out); return }
+    return [...uleb(id(idx, c.type)), ...uleb(id(t, c.table))]
+  },
   br_table: (n, c) => {
     let labels = [], count = 0
     while (n[0] && (!isNaN(n[0]) || isId(n[0]))) (labels.push(...uleb(blockid(n.shift(), c.block))), count++)
@@ -929,8 +987,8 @@ const IMM = {
   },
   select: (n, c) => { let r = n.shift() || []; return r.length ? vec(r.map(t => reftype(t, c))) : [] },
   ref_null: (n, c) => { let t = n.shift(); return Array.isArray(t) && t[0] === 'exact' ? [0x62, ...uleb(id(t[1], c.type))] : TYPE[t] ? [TYPE[t]] : uleb(id(t, c.type)) },
-  memarg: (n, c, op) => memargEnc(n, op, isIdx(n[0]) && !isMemParam(n[0]) ? id(n.shift(), c.memory) : 0),
-  opt_memory: (n, c) => uleb(id(isIdx(n[0]) ? n.shift() : 0, c.memory)),
+  memarg: (n, c, op, out) => memargEnc(n, op, isIdx(n[0]) && !isMemParam(n[0]) ? id(n.shift(), c.memory) : 0, out),
+  opt_memory: (n, c, op, out) => wleb(id(isIdx(n[0]) ? n.shift() : 0, c.memory), out),
   reftype: (n, c) => { let ht = reftype(n.shift(), c); return ht.length > 1 ? ht.slice(1) : ht },
   reftype2: (n, c) => { let b = blockid(n.shift(), c.block), h1 = reftype(n.shift(), c), h2 = reftype(n.shift(), c), ht = h => h.length > 1 ? h.slice(1) : h; return [((h2[0] !== TYPE.ref) << 1) | (h1[0] !== TYPE.ref), ...uleb(b), ...ht(h1), ...ht(h2)] },
   v128const: (n) => {
@@ -955,28 +1013,28 @@ const IMM = {
     const memIdx = isId(n[0]) || (isIdx(n[0]) && (isMemParam(n[1]) || isIdx(n[1]))) ? id(n.shift(), c.memory) : 0
     return [...memargEnc(n, op, memIdx), ...uleb(parseUint(n.shift()))]
   },
-  '*': (n) => uleb(n.shift()),
-
-  // *idx types
-  labelidx: (n, c) => uleb(blockid(n.shift(), c.block)),
-  laneidx: (n) => [parseUint(n.shift(), 0xff)],
-  funcidx: (n, c) => uleb(id(n.shift(), c.func)),
-  typeidx: (n, c) => uleb(id(n.shift(), c.type)),
-  tableidx: (n, c) => uleb(id(n.shift(), c.table)),
-  memoryidx: (n, c) => uleb(id(n.shift(), c.memory)),
-  globalidx: (n, c) => uleb(id(n.shift(), c.global)),
-  localidx: (n, c) => uleb(id(n.shift(), c.local)),
-  dataidx: (n, c) => uleb(id(n.shift(), c.data)),
-  elemidx: (n, c) => uleb(id(n.shift(), c.elem)),
-  tagidx: (n, c) => uleb(id(n.shift(), c.tag)),
-  'memoryidx?': (n, c) => uleb(id(isIdx(n[0]) ? n.shift() : 0, c.memory)),
-  stringidx: (n, c) => { let s = n.shift(), key = s.valueOf(), idx = c.strings.findIndex(x => x.valueOf() === key); if (idx < 0) idx = c.strings.push(s) - 1; return uleb(idx) },
+  // *idx types — write-mode (out present) pushes in place and returns undefined;
+  // return-mode hands back a fresh array. The sentinel is EXPLICIT: a boxed-
+  // pointer identity compare (`returned !== out`) misfires under the jz kernel.
+  labelidx: (n, c, op, out) => wleb(blockid(n.shift(), c.block), out),
+  laneidx: (n, c, op, out) => { const v = parseUint(n.shift(), 0xff); if (out) { out.push(v); return } return [v] },
+  funcidx: (n, c, op, out) => wleb(id(n.shift(), c.func), out),
+  typeidx: (n, c, op, out) => wleb(id(n.shift(), c.type), out),
+  tableidx: (n, c, op, out) => wleb(id(n.shift(), c.table), out),
+  memoryidx: (n, c, op, out) => wleb(id(n.shift(), c.memory), out),
+  globalidx: (n, c, op, out) => wleb(id(n.shift(), c.global), out),
+  localidx: (n, c, op, out) => wleb(id(n.shift(), c.local), out),
+  dataidx: (n, c, op, out) => wleb(id(n.shift(), c.data), out),
+  elemidx: (n, c, op, out) => wleb(id(n.shift(), c.elem), out),
+  tagidx: (n, c, op, out) => wleb(id(n.shift(), c.tag), out),
+  'memoryidx?': (n, c, op, out) => wleb(id(isIdx(n[0]) ? n.shift() : 0, c.memory), out),
+  stringidx: (n, c, op, out) => { let s = n.shift(), key = s.valueOf(), idx = c.strings.findIndex(x => x.valueOf() === key); if (idx < 0) idx = c.strings.push(s) - 1; return wleb(idx, out) },
 
   // Value type
-  i32: (n) => encode.i32(n.shift()),
-  i64: (n) => encode.i64(n.shift()),
-  f32: (n) => encode.f32(n.shift()),
-  f64: (n) => encode.f64(n.shift()),
+  i32: (n, c, op, out) => { if (out) { encode.i32(n.shift(), out); return } return encode.i32(n.shift()) },
+  i64: (n, c, op, out) => { if (out) { encode.i64(n.shift(), out); return } return encode.i64(n.shift()) },
+  f32: (n, c, op, out) => encode.f32(n.shift(), out),
+  f64: (n, c, op, out) => encode.f64(n.shift(), out),
   v128: (n) => encode.v128(n.shift()),
 
   // Combinations
@@ -1028,21 +1086,9 @@ const IMM = {
   }
 };
 
-// per-op imm handlers
-const HANDLER = {};
-
-
-// Populate INSTR and IMM
-(function populate(items, pre) {
-  for (let op = 0, item, nm, imm; op < items.length; op++) if (item = items[op]) {
-    // Nested array (0xfb, 0xfc, 0xfd opcodes)
-    if (Array.isArray(item)) populate(item, op)
-    else [nm, imm] = item.split(' '), INSTR[nm] = pre ? [pre, ...uleb(op)] : [op], imm && (HANDLER[nm] = IMM[imm])
-  }
-})(INSTR);
-
 
-// instruction encoder
+// instruction encoder — bytes land DIRECTLY in the output stream (write-mode
+// handlers push immediates themselves; cold handlers still return small arrays)
 const instr = (nodes, ctx) => {
   let out = [], meta = []
 
@@ -1058,22 +1104,12 @@ const instr = (nodes, ctx) => {
 
     // Array = unknown instruction passed through from normalize
     if (Array.isArray(op)) {
-      op.loc != null && (err.loc = op.loc)
+      op.loc != null && setErrLoc(op.loc)
       err(`Unknown instruction ${op[0]}`)
     }
 
-    let [...bytes] = INSTR[op] || err(`Unknown instruction ${op}`)
-
-    // special op handlers
-    if (HANDLER[op]) {
-      // select: becomes typed select (opcode+1) if next node is an array with result types
-      if (op === 'select' && nodes[0]?.length) bytes[0]++
-      // ref.type|cast: opcode+1 if type is nullable: (ref null $t) or (funcref, anyref, etc.)
-      else if (HANDLER[op] === IMM.reftype && !op.endsWith('_null') && (nodes[0][1] === 'null' || nodes[0][0] !== 'ref')) {
-        bytes[bytes.length - 1]++
-      }
-      bytes.push(...HANDLER[op](nodes, ctx, op))
-    }
+    const code = OPCODE[op]
+    if (typeof code !== 'number') err(`Unknown instruction ${op}`)
 
     // Attach any pending annotations to this instruction's byte position, then
     // clear — a (@metadata.code.*) annotation applies to the next instruction only
@@ -1082,14 +1118,95 @@ const instr = (nodes, ctx) => {
       meta = []
     }
 
-    out.push(...bytes)
+    const at = out.length
+    // unpack: top byte is the page prefix (0xfb-0xfe), low bits the uleb-encoded subopcode
+    if (code > 0xffff) { out.push(code >>> 16); uleb(code & 0xffff, out) }
+    else out.push(code)
+
+    // immediate encoding
+    const imm = IMM[op]
+    if (imm) {
+      // select: becomes typed select (opcode+1) if next node is an array with result types
+      if (op === 'select' && nodes[0]?.length) out[at]++
+      // ref.type|cast: opcode+1 if type is nullable: (ref null $t) or (funcref, anyref, etc.)
+      else if (imm === 'reftype' && !op.endsWith('_null') && (nodes[0][1] === 'null' || nodes[0][0] !== 'ref')) {
+        out[out.length - 1]++
+      }
+      const b = HANDLER[imm](nodes, ctx, op, out)
+      if (b) for (let i = 0; i < b.length; i++) out.push(b[i])
+    }
   }
 
   return out.push(0x0b), out
 }
 
-// LEB128 byte-width of an unsigned integer (exact, reuses uleb so it can never drift).
-const ulebSize = (n) => uleb(n).length
+// LEB128 byte-width of a non-negative number (7 bits per byte). Non-number
+// input (BigInt, numeric string) falls back to the real encoder's length.
+const ulebSize = (n) => {
+  if (typeof n !== 'number' || n < 0) return uleb(n).length
+  let k = 1; n >>>= 7
+  while (n) k++, n >>>= 7
+  return k
+}
+
+// Signed-LEB byte-width of an i32 immediate (mirrors encode.i32's loop).
+const slebSize32 = (n) => {
+  if (typeof n === 'string') n = i32.parse(n)
+  let k = 1
+  while (true) {
+    const byte = n & 0x7F
+    n >>= 7
+    if ((n === 0 && (byte & 0x40) === 0) || (n === -1 && (byte & 0x40) !== 0)) return k
+    k++
+  }
+}
+
+// Width of a memarg (align + optional memidx + offset) without building it.
+const memargSize = (nodes, op, memIdx = 0) => {
+  const [a, o] = memarg(nodes), alignVal = (a ?? align(op)) | (memIdx && 0x40)
+  return memIdx ? ulebSize(alignVal) + ulebSize(memIdx) + ulebSize(o ?? 0) : ulebSize(alignVal) + ulebSize(o ?? 0)
+}
+
+// Width-only twins of the HOT immediate handlers: identical token consumption
+// and ctx side effects (block stack, string interning), integer widths instead
+// of materialized byte arrays — immediate allocation dominates instrSize on
+// multi-MB modules. Cold immtypes fall back to the real handler's .length, so
+// the tables cannot drift; equality with compile().length is invariant-tested.
+const SIZE_HANDLER = {}
+for (const k in HANDLER) SIZE_HANDLER[k] = (n, c, op) => HANDLER[k](n, c, op).length
+Object.assign(SIZE_HANDLER, {
+  i32: (n) => slebSize32(n.shift()),
+  f32: (n) => (n.shift(), 4),
+  f64: (n) => (n.shift(), 8),
+  localidx: (n, c) => ulebSize(id(n.shift(), c.local)),
+  funcidx: (n, c) => ulebSize(id(n.shift(), c.func)),
+  typeidx: (n, c) => ulebSize(id(n.shift(), c.type)),
+  tableidx: (n, c) => ulebSize(id(n.shift(), c.table)),
+  memoryidx: (n, c) => ulebSize(id(n.shift(), c.memory)),
+  globalidx: (n, c) => ulebSize(id(n.shift(), c.global)),
+  dataidx: (n, c) => ulebSize(id(n.shift(), c.data)),
+  elemidx: (n, c) => ulebSize(id(n.shift(), c.elem)),
+  tagidx: (n, c) => ulebSize(id(n.shift(), c.tag)),
+  labelidx: (n, c) => ulebSize(blockid(n.shift(), c.block)),
+  laneidx: (n) => (parseUint(n.shift(), 0xff), 1),
+  memarg: (n, c, op) => memargSize(n, op, isIdx(n[0]) && !isMemParam(n[0]) ? id(n.shift(), c.memory) : 0),
+  opt_memory: (n, c) => ulebSize(id(isIdx(n[0]) ? n.shift() : 0, c.memory)),
+  'memoryidx?': (n, c) => ulebSize(id(isIdx(n[0]) ? n.shift() : 0, c.memory)),
+  call_indirect: (n, c) => { const t = n.shift(), [, ti] = n.shift(); return ulebSize(id(ti, c.type)) + ulebSize(id(t, c.table)) },
+  block: (n, c) => {
+    c.block.push(1)
+    isId(n[0]) && (c.block[n.shift()] = c.block.length)
+    const t = n.shift()
+    return !t ? 1 : t[0] === 'result' ? reftype(t[1], c).length : ulebSize(id(t[1], c.type))
+  },
+  end: (_n, c) => (c.block.pop(), 0),
+  stringidx: (n, c) => {
+    const str = n.shift(), key = str.valueOf()
+    let idx = c.strings.findIndex(x => x.valueOf() === key)
+    if (idx < 0) idx = c.strings.push(str) - 1
+    return ulebSize(idx)
+  },
+})
 
 // Size-only twin of instr(): the byte LENGTH of the encoded instruction stream,
 // WITHOUT building the (multi-MB) byte array. Reuses every HANDLER for exact
@@ -1103,10 +1220,11 @@ const instrSize = (nodes, ctx) => {
   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 (Array.isArray(op)) { op.loc != null && setErrLoc(op.loc); err(`Unknown instruction ${op[0]}`) }
+    const code = OPCODE[op]
+    if (typeof code !== 'number') err(`Unknown instruction ${op}`)
+    let n = code > 0xffff ? 1 + ulebSize(code & 0xffff) : 1
+    if (IMM[op]) n += SIZE_HANDLER[IMM[op]](nodes, ctx, op)
     if (meta.length) { for (const [type, data] of meta) ((ctx.meta[type] ??= []).push([size, data])); meta = [] }
     size += n
   }
@@ -1145,7 +1263,9 @@ const codeItemSize = (body, ctx) => {
 const expr = (node, ctx) => instr(normalize([node], ctx), ctx)
 
 // deref id node to numeric idx
-const id = (nm, list, n) => (n = isId(nm) ? list[nm] : +nm, n in list ? n : err(`Unknown ${list.name} ${nm}`))
+// dense index spaces: a resolved name or an in-range number needs no second
+// dictionary hit — `n in list` only arbitrates the miss path
+const id = (nm, list, n) => (n = isId(nm) ? list[nm] : +nm, n >= 0 && n < list.length ? n : n in list ? n : err(`Unknown ${list.name} ${nm}`))
 
 // block id - same as id but for block
 // index indicates how many block items to pop
@@ -1167,8 +1287,14 @@ const memarg = (args) => {
 
 // Encode memarg (align + offset) with default values based on instruction
 // If memIdx is non-zero, set bit 6 in alignment flags and insert memIdx after align
-const memargEnc = (nodes, op, memIdx = 0) => {
+const memargEnc = (nodes, op, memIdx = 0, out) => {
   const [a, o] = memarg(nodes), alignVal = (a ?? align(op)) | (memIdx && 0x40)
+  if (out) {
+    uleb(alignVal, out)
+    if (memIdx) uleb(memIdx, out)
+    uleb(o ?? 0, out)
+    return
+  }
   return memIdx ? [...uleb(alignVal), ...uleb(memIdx), ...uleb(o ?? 0)] : [...uleb(alignVal), ...uleb(o ?? 0)]
 }
 
@@ -1194,7 +1320,7 @@ const align = (op) => {
 }
 
 // Convert WAT numeric data (i8/i16/i32/i64/f32/f64 lists) to bytes (Phase 2: WAT numeric values)
-const numdata = (item) => {
+export const numdata = (item) => {
   if (!Array.isArray(item)) return null
   const [t, ...vs] = item
   if (t !== 'i8' && t !== 'i16' && t !== 'i32' && t !== 'i64' && t !== 'f32' && t !== 'f64') return null