preprocess-wasm-bytes 0.1.5 → 0.1.7

package/dist/preprocess_wasm_bytes.js

@@ -1,738 +1,711 @@
-// Copyright (c) 2025 justing2k5. All rights reserved.
-// src/preprocess_wasm_bytes.ts
+// preprocessWasmBytes.ts
 //
-// What changed vs your last version:
-// - We now *directly parse the WASM binary* to find all function indices referenced by the **element section**
-//   (covers active/passive/declarative + elem expressions). This avoids any @webassemblyjs AST-shape quirks.
-// - We also parse the binary export section to learn existing export names/indices (so we never collide).
-// - We export **all tables** (0..totalTables-1) unconditionally.
-// - Debug logging is OFF by default. Toggle it via:
-//     globalThis.__WASM_PREPROCESS_DEBUG__ = true/false
-const DEFAULT_DEBUG = false;
-function debugEnabled() {
-    const v = globalThis.__WASM_PREPROCESS_DEBUG__;
-    return typeof v === "boolean" ? v : DEFAULT_DEBUG;
-}
-function dbg(...args) {
-    if (debugEnabled())
-        console.log("[wasm-preprocess]", ...args);
-}
-function uniqueName(base, used, fallback) {
-    const cleanBase = base && typeof base === "string" ? base : fallback;
-    if (!used.has(cleanBase)) {
-        used.add(cleanBase);
-        return cleanBase;
+// Goal: replicate the Rust/walrus “preprocess_wasm_bytes” in TypeScript, with a
+// performance-first approach:
+// - Parse only the sections we need.
+// - Scan function bodies for the `ref.func` opcode (0xd2) without building a full AST.
+// - Patch/insert the Export section (id=7) by copying existing bytes and appending new exports.
+//
+// Notes / assumptions (matching typical Rust-produced wasm):
+// - Element/global const-exprs are expected to be “simple” (i32.const/global.get/ref.func/ref.null/...)
+//   If an unsupported opcode appears inside a const-expr, this implementation bails out and returns empty bytes.
+// - Handles funcref tables encoded as `funcref` (0x70) and also typed refs `(ref ... func)` / `(ref null ... func)`
+//   encoded as 0x64/0x63 + heaptype = -16 (func) or -13 (nofunc).
+const td = new TextDecoder("utf-8");
+const te = new TextEncoder();
+// Section ids
+const SECTION_CUSTOM = 0;
+const SECTION_IMPORT = 2;
+const SECTION_FUNCTION = 3;
+const SECTION_TABLE = 4;
+const SECTION_MEMORY = 5;
+const SECTION_GLOBAL = 6;
+const SECTION_EXPORT = 7;
+const SECTION_ELEMENT = 9;
+const SECTION_CODE = 10;
+// Export kinds (ExternalKind)
+const EXTERNAL_KIND_FUNCTION = 0;
+const EXTERNAL_KIND_TABLE = 1;
+const EXTERNAL_KIND_MEMORY = 2;
+const EXTERNAL_KIND_GLOBAL = 3;
+// Opcode we care about inside function bodies / const-exprs.
+const OPCODE_REF_FUNC = 0xd2;
+// Type encodings (commonly used)
+const VALTYPE_FUNCREF = 0x70; // funcref
+const VALTYPE_REF_NULL = 0x63; // (ref null ht) - in GC encoding, followed by heaptype
+const VALTYPE_REF = 0x64; // (ref ht) - in GC encoding, followed by heaptype
+// Heaptype signed LEB values for abstract heap types (GC encoding).
+// `func` is -16, `nofunc` is -13. These are widely used encodings (e.g. V8 constants).
+const HEAPTYPE_FUNC = -16;
+const HEAPTYPE_NOFUNC = -13;
+class Reader {
+    bytes;
+    pos;
+    constructor(bytes, pos = 0) {
+        this.bytes = bytes;
+        this.pos = pos;
+    }
+    ensure(n) {
+        if (this.pos + n > this.bytes.length) {
+            throw new Error("Unexpected EOF");
+        }
+    }
+    u8() {
+        this.ensure(1);
+        return this.bytes[this.pos++];
+    }
+    skip(n) {
+        this.ensure(n);
+        this.pos += n;
+    }
+    // Unsigned LEB128 (u32)
+    varU32() {
+        let result = 0;
+        let mul = 1;
+        while (true) {
+            const b = this.u8();
+            result += (b & 0x7f) * mul;
+            if ((b & 0x80) === 0)
+                return result >>> 0;
+            mul *= 128;
+            // varuint32 max 5 bytes; this is just a safety net
+            if (mul > 128 ** 6)
+                throw new Error("varU32 too large");
+        }
+    }
+    // Signed LEB128, up to ~33 bits (s33), used by heaptype in GC encoding.
+    varS33() {
+        let result = 0;
+        let mul = 1;
+        let b = 0;
+        while (true) {
+            b = this.u8();
+            result += (b & 0x7f) * mul;
+            mul *= 128;
+            if ((b & 0x80) === 0)
+                break;
+            if (mul > 128 ** 7)
+                throw new Error("varS33 too large");
+        }
+        // sign-extend based on 0x40 of final byte
+        if (b & 0x40)
+            result -= mul;
+        return result;
+    }
+    // Signed LEB128 (s32), used by i32.const
+    varS32() {
+        let result = 0;
+        let mul = 1;
+        let b = 0;
+        while (true) {
+            b = this.u8();
+            result += (b & 0x7f) * mul;
+            mul *= 128;
+            if ((b & 0x80) === 0)
+                break;
+            if (mul > 128 ** 6)
+                throw new Error("varS32 too large");
+        }
+        if (b & 0x40)
+            result -= mul;
+        return result | 0;
+    }
+    // Skip a signed LEB128 of arbitrary length (used for i64.const, etc.)
+    skipVarInt() {
+        while (true) {
+            const b = this.u8();
+            if ((b & 0x80) === 0)
+                return;
+        }
+    }
+    readBytes(n) {
+        this.ensure(n);
+        const sub = this.bytes.subarray(this.pos, this.pos + n);
+        this.pos += n;
+        return sub;
+    }
+    skipString() {
+        const len = this.varU32();
+        this.skip(len);
+    }
+    readString() {
+        const len = this.varU32();
+        const start = this.pos;
+        this.skip(len);
+        return td.decode(this.bytes.subarray(start, start + len));
     }
-    let i = 1;
-    while (used.has(`${cleanBase}__${i}`))
-        i++;
-    const out = `${cleanBase}__${i}`;
-    used.add(out);
-    return out;
 }
-const utf8enc = new TextEncoder();
-function writeU32LebTo(out, value) {
+class Writer {
+    buf;
+    len = 0;
+    constructor(initialCapacity = 1024) {
+        this.buf = new Uint8Array(initialCapacity);
+    }
+    ensure(n) {
+        const needed = this.len + n;
+        if (needed <= this.buf.length)
+            return;
+        let cap = this.buf.length;
+        while (cap < needed)
+            cap = cap * 2;
+        const next = new Uint8Array(cap);
+        next.set(this.buf, 0);
+        this.buf = next;
+    }
+    u8(v) {
+        this.ensure(1);
+        this.buf[this.len++] = v & 0xff;
+    }
+    bytes(arr) {
+        this.ensure(arr.length);
+        this.buf.set(arr, this.len);
+        this.len += arr.length;
+    }
     // u32 LEB128
-    let v = value >>> 0;
-    do {
-        let byte = v & 0x7f;
-        v >>>= 7;
-        if (v !== 0)
-            byte |= 0x80;
-        out.push(byte);
-    } while (v !== 0);
-}
-function writeNameTo(out, s) {
-    const bytes = utf8enc.encode(s);
-    writeU32LebTo(out, bytes.length);
-    for (let i = 0; i < bytes.length; i++)
-        out.push(bytes[i]);
-}
-function buildExportSectionBytes(entries) {
-    // section payload
-    const body = [];
-    writeU32LebTo(body, entries.length);
-    for (const e of entries) {
-        writeNameTo(body, e.name);
-        body.push(e.kind);
-        writeU32LebTo(body, e.index >>> 0);
+    varU32(v) {
+        let x = v >>> 0;
+        while (true) {
+            const byte = x & 0x7f;
+            x >>>= 7;
+            if (x === 0) {
+                this.u8(byte);
+                return;
+            }
+            else {
+                this.u8(byte | 0x80);
+            }
+        }
+    }
+    string(s) {
+        const data = te.encode(s);
+        this.varU32(data.length);
+        this.bytes(data);
+    }
+    finish() {
+        return this.buf.subarray(0, this.len);
     }
-    // section header: id=7 + size
-    const out = [];
-    out.push(0x07);
-    writeU32LebTo(out, body.length);
-    for (let i = 0; i < body.length; i++)
-        out.push(body[i]);
-    return new Uint8Array(out);
 }
-function concatChunks(chunks) {
+function concat(chunks) {
     let total = 0;
     for (const c of chunks)
-        total += c.byteLength;
+        total += c.length;
     const out = new Uint8Array(total);
     let off = 0;
     for (const c of chunks) {
         out.set(c, off);
-        off += c.byteLength;
+        off += c.length;
     }
     return out;
 }
-function rewriteWasmWithExportSection(original, newExportSection) {
-    const bytes = original;
-    const endAll = bytes.length;
-    if (endAll < 8)
-        throw new Error("[wasm-preprocess] WASM too small");
-    const chunks = [];
-    // Copy magic + version
-    chunks.push(bytes.subarray(0, 8));
-    let pos = 8;
-    let inserted = false;
-    let replaced = false;
-    // Insert before first *known* section with id > 7 (custom sections (0) can appear anywhere)
-    while (pos < endAll) {
-        const sectionStart = pos;
-        const id = bytes[pos++];
-        const rSize = readU32Leb(bytes, pos, endAll);
-        const size = rSize.value;
-        pos = rSize.pos;
-        const payloadStart = pos;
-        const payloadEnd = payloadStart + size;
-        if (payloadEnd > endAll)
-            throw new Error("[wasm-preprocess] section size out of bounds");
-        // If export section is missing, insert it before the first known section > 7
-        if (!inserted && !replaced && id !== 0 && id > 7) {
-            chunks.push(newExportSection);
-            inserted = true;
-        }
-        if (id === 7) {
-            // Replace existing export section
-            if (!replaced) {
-                chunks.push(newExportSection);
-                replaced = true;
-                inserted = true;
-            }
-            // Skip the old export section bytes
-        }
-        else {
-            // Copy original section unchanged
-            chunks.push(bytes.subarray(sectionStart, payloadEnd));
-        }
-        pos = payloadEnd;
-    }
-    // If we never inserted/replaced (no export section and no later section to trigger insertion), append it.
-    if (!inserted && !replaced) {
-        chunks.push(newExportSection);
-    }
-    return concatChunks(chunks);
+function isWasm(bytes) {
+    return (bytes.length >= 8 &&
+        bytes[0] === 0x00 &&
+        bytes[1] === 0x61 &&
+        bytes[2] === 0x73 &&
+        bytes[3] === 0x6d &&
+        // version (usually 1)
+        bytes[4] === 0x01 &&
+        bytes[5] === 0x00 &&
+        bytes[6] === 0x00 &&
+        bytes[7] === 0x00);
 }
-/* =======================================================================================
- *  Minimal WASM binary reader (just enough for exports/imports/tables/mems/globals/elems)
- * ======================================================================================= */
-const utf8 = new TextDecoder("utf-8");
-function fail(msg) {
-    throw new Error(`[wasm-preprocess] ${msg}`);
+function encodeSection(id, payload) {
+    const w = new Writer(1 + 5 + payload.length);
+    w.u8(id);
+    w.varU32(payload.length);
+    w.bytes(payload);
+    return w.finish();
 }
-function readU32Leb(bytes, pos, end) {
-    let result = 0;
-    let shift = 0;
-    for (let i = 0; i < 5; i++) {
-        if (pos >= end)
-            fail("unexpected EOF while reading u32 leb");
-        const b = bytes[pos++];
-        result |= (b & 0x7f) << shift;
-        if ((b & 0x80) === 0)
-            return { value: result >>> 0, pos };
-        shift += 7;
-    }
-    fail("u32 leb too long");
+function skipLimits(r) {
+    const flags = r.u8();
+    r.varU32(); // min
+    if (flags & 0x01)
+        r.varU32(); // max
+    // Other flags (shared/memory64) exist; we don't need them here.
 }
-function tryReadU32Leb(bytes, pos, end) {
-    let result = 0;
-    let shift = 0;
-    for (let i = 0; i < 5; i++) {
-        if (pos >= end)
-            return null;
-        const b = bytes[pos++];
-        result |= (b & 0x7f) << shift;
-        if ((b & 0x80) === 0)
-            return { value: result >>> 0, pos };
-        shift += 7;
+// Reads a `reftype`/`valtype` byte and any trailing heaptype if it is ref/refnull (0x64/0x63).
+function readRefType(r) {
+    const code = r.u8();
+    if (code === VALTYPE_REF || code === VALTYPE_REF_NULL) {
+        const heapType = r.varS33();
+        return { code, heapType };
     }
-    return null;
+    return { code };
 }
-function skipLeb(bytes, pos, end, maxBytes) {
-    for (let i = 0; i < maxBytes; i++) {
-        if (pos >= end)
-            fail("unexpected EOF while skipping leb");
-        const b = bytes[pos++];
-        if ((b & 0x80) === 0)
-            return pos;
-    }
-    fail("leb too long");
+function skipValType(r) {
+    // valtype is the same grammar as reftype for our purposes here.
+    readRefType(r);
 }
-function readName(bytes, pos, end) {
-    const r = readU32Leb(bytes, pos, end);
-    const len = r.value;
-    pos = r.pos;
-    const next = pos + len;
-    if (next > end)
-        fail("unexpected EOF while reading name");
-    const s = utf8.decode(bytes.subarray(pos, next));
-    return { value: s, pos: next };
+function isFuncRefTableType(rt) {
+    if (rt.code === VALTYPE_FUNCREF)
+        return true;
+    if ((rt.code === VALTYPE_REF || rt.code === VALTYPE_REF_NULL) && rt.heapType != null) {
+        return rt.heapType === HEAPTYPE_FUNC || rt.heapType === HEAPTYPE_NOFUNC;
+    }
+    return false;
 }
-/**
- * Parse a const expr and collect any ref.func immediates.
- * NOTE: For our purposes we only fully support the common const-expr opcodes.
- * For unknown opcodes we fail fast (with a useful error).
- */
-function parseConstExprCollectRefFuncs(bytes, pos, end, outFuncs, ctx) {
+// Skip a const expr, optionally collecting ref.func indices.
+// This only supports a conservative subset of opcodes typical in wasm init/offset exprs.
+// If you hit an unsupported opcode, we throw (caller returns empty output, like the Rust code).
+function skipConstExpr(r, onRefFunc) {
     while (true) {
-        if (pos >= end)
-            fail(`unexpected EOF in const expr (${ctx})`);
-        const op = bytes[pos++];
+        const op = r.u8();
+        if (op === 0x0b)
+            return; // end
         switch (op) {
-            case 0x0b: // end
-                return pos;
-            case 0xd2: {
-                // ref.func <funcidx:u32>
-                const r = readU32Leb(bytes, pos, end);
-                outFuncs.add(r.value);
-                pos = r.pos;
-                break;
-            }
-            case 0xd0:
-                // ref.null <reftype>
-                if (pos >= end)
-                    fail(`unexpected EOF after ref.null (${ctx})`);
-                pos += 1;
-                break;
-            case 0x23:
-                // global.get <globalidx:u32>
-                pos = skipLeb(bytes, pos, end, 5);
-                break;
-            case 0x41:
-                // i32.const <varint32>
-                pos = skipLeb(bytes, pos, end, 5);
-                break;
-            case 0x42:
-                // i64.const <varint64>
-                pos = skipLeb(bytes, pos, end, 10);
-                break;
-            case 0x43:
-                // f32.const <4 bytes>
-                if (pos + 4 > end)
-                    fail(`unexpected EOF after f32.const (${ctx})`);
-                pos += 4;
+            case 0x41: // i32.const
+                r.varS32();
                 break;
-            case 0x44:
-                // f64.const <8 bytes>
-                if (pos + 8 > end)
-                    fail(`unexpected EOF after f64.const (${ctx})`);
-                pos += 8;
-                break;
-            // Accept a few ref ops that have no immediates (rare in const exprs, but safe to skip)
-            case 0xd1: // ref.is_null
-            case 0xd3: // ref.eq
-            case 0xd4: // ref.as_non_null
-                break;
-            default:
-                fail(`unsupported opcode 0x${op.toString(16)} in const expr (${ctx}). ` +
-                    `If your modules use extended-const-exprs, we can add more opcode support.`);
-        }
-    }
-}
-function parseLimitsU32(bytes, pos, end, ctx) {
-    if (pos >= end)
-        fail(`unexpected EOF in limits (${ctx})`);
-    const flags = bytes[pos++];
-    // Core variants:
-    // 0x00: min
-    // 0x01: min, max
-    // Additional variants exist in newer proposals (shared/memory64), but we just skip in a tolerant way.
-    if (flags === 0x00) {
-        pos = skipLeb(bytes, pos, end, 5);
-        return pos;
-    }
-    if (flags === 0x01 || flags === 0x03) {
-        // treat 0x03 (shared) same shape for skipping: min + max
-        pos = skipLeb(bytes, pos, end, 5);
-        pos = skipLeb(bytes, pos, end, 5);
-        return pos;
-    }
-    // Some proposals introduce more flags; best-effort: read min + max.
-    dbg(`limits(${ctx}) uses uncommon flags 0x${flags.toString(16)}; best-effort skipping min+max`);
-    pos = skipLeb(bytes, pos, end, 5);
-    pos = skipLeb(bytes, pos, end, 5);
-    return pos;
-}
-function parseTableType(bytes, pos, end) {
-    if (pos >= end)
-        fail("unexpected EOF in tabletype");
-    // reftype byte
-    pos += 1;
-    pos = parseLimitsU32(bytes, pos, end, "tabletype.limits");
-    return pos;
-}
-function parseMemType(bytes, pos, end) {
-    // memtype is limits
-    pos = parseLimitsU32(bytes, pos, end, "memtype.limits");
-    return pos;
-}
-function parseGlobalType(bytes, pos, end) {
-    if (pos + 2 > end)
-        fail("unexpected EOF in globaltype");
-    // valtype byte
-    pos += 1;
-    // mutability byte: 0 const, 1 var
-    const mut = bytes[pos++];
-    return { pos, mutable: mut === 1 };
-}
-/**
- * Element section parsing based on the spec forms 0..7:
- * https://webassembly.github.io/spec/core/binary/modules.html#element-section
- */
-function parseElementSectionCollectFuncIdxs(bytes, start, end, outFuncs) {
-    let pos = start;
-    const rCount = readU32Leb(bytes, pos, end);
-    const count = rCount.value;
-    pos = rCount.pos;
-    dbg(`element section: ${count} segment(s)`);
-    for (let i = 0; i < count; i++) {
-        const rForm = readU32Leb(bytes, pos, end);
-        const form = rForm.value;
-        pos = rForm.pos;
-        const segCollected = [];
-        const addFunc = (idx) => {
-            outFuncs.add(idx);
-            segCollected.push(idx);
-        };
-        const readFuncIdxVec = () => {
-            const rN = readU32Leb(bytes, pos, end);
-            const n = rN.value;
-            pos = rN.pos;
-            for (let k = 0; k < n; k++) {
-                const rF = readU32Leb(bytes, pos, end);
-                pos = rF.pos;
-                addFunc(rF.value);
-            }
-        };
-        const readExprVec = (ctx) => {
-            const rN = readU32Leb(bytes, pos, end);
-            const n = rN.value;
-            pos = rN.pos;
-            for (let k = 0; k < n; k++) {
-                pos = parseConstExprCollectRefFuncs(bytes, pos, end, outFuncs, ctx);
-            }
-        };
-        switch (form) {
-            case 0: {
-                // 0: u32, offset expr, vec(funcidx)  (active, table 0, funcref implicit)
-                pos = parseConstExprCollectRefFuncs(bytes, pos, end, outFuncs, `elem[${i}].offset(form0)`);
-                readFuncIdxVec();
-                break;
-            }
-            case 1: {
-                // 1: u32, elemkind, vec(funcidx)  (passive)
-                if (pos >= end)
-                    fail("unexpected EOF reading elemkind (form1)");
-                pos += 1; // elemkind
-                readFuncIdxVec();
-                break;
-            }
-            case 2: {
-                // 2: u32, tableidx, offset expr, elemkind, vec(funcidx) (active, explicit table)
-                pos = readU32Leb(bytes, pos, end).pos; // tableidx
-                pos = parseConstExprCollectRefFuncs(bytes, pos, end, outFuncs, `elem[${i}].offset(form2)`);
-                if (pos >= end)
-                    fail("unexpected EOF reading elemkind (form2)");
-                pos += 1; // elemkind
-                readFuncIdxVec();
+            case 0x42: // i64.const
+                r.skipVarInt();
                 break;
-            }
-            case 3: {
-                // 3: u32, elemkind, vec(funcidx) (declarative)
-                if (pos >= end)
-                    fail("unexpected EOF reading elemkind (form3)");
-                pos += 1; // elemkind
-                readFuncIdxVec();
+            case 0x43: // f32.const
+                r.skip(4);
                 break;
-            }
-            case 4: {
-                // 4: u32, offset expr, vec(expr) (active, table 0, funcref implicit)
-                pos = parseConstExprCollectRefFuncs(bytes, pos, end, outFuncs, `elem[${i}].offset(form4)`);
-                readExprVec(`elem[${i}].init(form4)`);
+            case 0x44: // f64.const
+                r.skip(8);
                 break;
-            }
-            case 5: {
-                // 5: u32, reftype, vec(expr) (passive)
-                if (pos >= end)
-                    fail("unexpected EOF reading reftype (form5)");
-                pos += 1; // reftype
-                readExprVec(`elem[${i}].init(form5)`);
+            case 0x23: // global.get
+                r.varU32();
                 break;
-            }
-            case 6: {
-                // 6:u32 x:tableidx e:expr et:reftype el*:vec(expr)
-                pos = readU32Leb(bytes, pos, end).pos; // tableidx
-                pos = parseConstExprCollectRefFuncs(bytes, pos, end, outFuncs, `elem[${i}].offset(form6)`);
-                if (pos >= end)
-                    fail("unexpected EOF reading reftype (form6)");
-                pos += 1; // reftype
-                readExprVec(`elem[${i}].init(form6)`);
+            case 0xd0: // ref.null (ref types / GC): immediate is heaptype (signed LEB)
+                r.varS33();
                 break;
-            }
-            case 7: {
-                // 7: u32, reftype, vec(expr) (declarative)
-                if (pos >= end)
-                    fail("unexpected EOF reading reftype (form7)");
-                pos += 1; // reftype
-                readExprVec(`elem[${i}].init(form7)`);
+            case 0xd2: {
+                // ref.func
+                const idx = r.varU32();
+                onRefFunc?.(idx);
                 break;
             }
+            // Many const-safe ops have no immediates (e.g. i32.add). If you want to be more permissive,
+            // you can add them here as "no-op" (no immediate to skip).
             default:
-                fail(`unknown element segment form ${form} (expected 0..7)`);
-        }
-        if (debugEnabled()) {
-            const uniq = Array.from(new Set(segCollected)).sort((a, b) => a - b);
-            dbg(`  elem[${i}] form=${form} collected funcidx:`, uniq);
-        }
-    }
-    if (pos !== end) {
-        // Not necessarily fatal, but useful signal.
-        dbg(`element section: parsed ${pos - start} bytes, expected ${end - start} bytes (diff=${end - pos})`);
-    }
-}
-function parseExportSection(bytes, start, end, exportNames, alreadyExported, exportEntries) {
-    let pos = start;
-    const rCount = readU32Leb(bytes, pos, end);
-    const count = rCount.value;
-    pos = rCount.pos;
-    for (let i = 0; i < count; i++) {
-        const nm = readName(bytes, pos, end);
-        const name = nm.value;
-        pos = nm.pos;
-        if (pos >= end)
-            fail("unexpected EOF in export entry kind");
-        const kind = bytes[pos++];
-        const rIdx = readU32Leb(bytes, pos, end);
-        const idx = rIdx.value;
-        pos = rIdx.pos;
-        exportNames.add(name);
-        // keep exact original entries so we can rebuild export section without webassemblyjs
-        if (kind === 0 || kind === 1 || kind === 2 || kind === 3) {
-            exportEntries.push({ name, kind: kind, index: idx >>> 0 });
-        }
-        switch (kind) {
-            case 0: // func
-                alreadyExported.Func.add(idx);
-                break;
-            case 1: // table
-                alreadyExported.Table.add(idx);
-                break;
-            case 2: // mem
-                alreadyExported.Memory.add(idx);
-                break;
-            case 3: // global
-                alreadyExported.Global.add(idx);
-                break;
-            default:
-                // ignore unknown kinds (future-proof)
-                break;
+                throw new Error(`Unsupported opcode in const-expr: 0x${op.toString(16)}`);
         }
     }
-    dbg("existing export names:", Array.from(exportNames).sort());
-    dbg("existing exported indices:", {
-        Func: Array.from(alreadyExported.Func).sort((a, b) => a - b),
-        Table: Array.from(alreadyExported.Table).sort((a, b) => a - b),
-        Memory: Array.from(alreadyExported.Memory).sort((a, b) => a - b),
-        Global: Array.from(alreadyExported.Global).sort((a, b) => a - b),
-    });
 }
-function scanWasmBinary(wasmBytes) {
-    const bytes = wasmBytes;
-    const endAll = bytes.length;
-    if (endAll < 8)
-        fail("WASM too small");
-    if (bytes[0] !== 0x00 || bytes[1] !== 0x61 || bytes[2] !== 0x73 || bytes[3] !== 0x6d) {
-        fail("bad WASM magic");
-    }
-    // version bytes[4..8) (ignored)
-    let pos = 8;
-    const exportNames = new Set();
-    const alreadyExported = {
-        Func: new Set(),
-        Table: new Set(),
-        Memory: new Set(),
-        Global: new Set(),
-    };
-    const exportEntries = [];
-    const funcsToExport = new Set();
-    let importFunctions = 0;
-    let localFunctions = 0;
-    let importTables = 0, localTables = 0;
-    let importMemories = 0, localMemories = 0;
-    let importGlobals = 0, localGlobals = 0;
-    const mutableGlobalsToExport = new Set();
-    const noteSection = (id) => {
-        switch (id) {
-            case 2:
-                return "import";
-            case 4:
-                return "table";
-            case 5:
-                return "memory";
-            case 6:
-                return "global";
-            case 7:
-                return "export";
-            case 9:
-                return "element";
-            default:
-                return `section(${id})`;
+export function preprocess_wasm_bytes(wasmBytes, opts = {}) {
+    try {
+        if (!isWasm(wasmBytes)) {
+            if (opts.debug)
+                console.warn("Not a wasm binary (bad header).");
+            return new Uint8Array(0);
         }
-    };
-    while (pos < endAll) {
-        const id = bytes[pos++];
-        const rSize = readU32Leb(bytes, pos, endAll);
-        const size = rSize.value;
-        pos = rSize.pos;
-        const start = pos;
-        const end = start + size;
-        if (end > endAll)
-            fail(`section ${id} size out of bounds`);
-        try {
-            if (id === 2) {
-                // import section
-                let p = start;
-                const rCount = readU32Leb(bytes, p, end);
-                const n = rCount.value;
-                p = rCount.pos;
-                for (let i = 0; i < n; i++) {
-                    // module/name
-                    p = readName(bytes, p, end).pos;
-                    p = readName(bytes, p, end).pos;
-                    if (p >= end)
-                        fail("unexpected EOF in import kind");
-                    const kind = bytes[p++];
-                    switch (kind) {
-                        case 0: // func
-                            p = readU32Leb(bytes, p, end).pos; // typeidx
-                            importFunctions++;
-                            break;
-                        case 1: // table
-                            p = parseTableType(bytes, p, end);
-                            importTables++;
-                            break;
-                        case 2: // mem
-                            p = parseMemType(bytes, p, end);
-                            importMemories++;
-                            break;
-                        case 3: {
-                            // global
-                            const gt = parseGlobalType(bytes, p, end);
-                            p = gt.pos;
-                            if (gt.mutable)
-                                mutableGlobalsToExport.add(importGlobals);
-                            importGlobals++;
-                            break;
+        const sections = [];
+        // Imports + definitions summary
+        let importedFuncCount = 0;
+        let importedTableCount = 0;
+        let importedMemCount = 0;
+        let importedGlobalCount = 0;
+        const importedTableTypes = [];
+        const importedGlobalMutable = [];
+        let localFuncCount = 0;
+        const localTableTypes = [];
+        let localMemCount = 0;
+        const localGlobalMutable = [];
+        // Name section maps (optional)
+        const funcNameByIndex = new Map();
+        const globalNameByIndex = new Map();
+        // Existing exports
+        let exportSectionStart = -1;
+        let exportSectionEnd = -1;
+        let exportCount = 0;
+        let exportEntriesBytes = null;
+        const usedExportNames = new Set();
+        const exportedFuncs = new Set();
+        const exportedGlobals = new Set();
+        const exportedMems = new Set();
+        const exportedTables = new Set();
+        // Things we will export (collected)
+        const funcsToExport = new Set();
+        const markFunc = (idx) => {
+            const total = importedFuncCount + localFuncCount;
+            if (idx >>> 0 >= total >>> 0)
+                return; // bounds check (helps avoid false positives)
+            funcsToExport.add(idx >>> 0);
+        };
+        // Parse the module sections
+        const r = new Reader(wasmBytes, 8);
+        while (r.pos < wasmBytes.length) {
+            const start = r.pos;
+            const id = r.u8();
+            const size = r.varU32();
+            const payloadStart = r.pos;
+            const payloadEnd = payloadStart + size;
+            if (payloadEnd > wasmBytes.length) {
+                throw new Error("Section extends past end of file");
+            }
+            sections.push({ id, start, end: payloadEnd, payloadStart, payloadEnd });
+            // Slice reader to payload while parsing.
+            const savedPos = r.pos;
+            r.pos = payloadStart;
+            switch (id) {
+                case SECTION_CUSTOM: {
+                    // custom section: name + bytes
+                    const name = r.readString();
+                    if (name === "name") {
+                        // name subsection parsing
+                        while (r.pos < payloadEnd) {
+                            const subId = r.u8();
+                            const subSize = r.varU32();
+                            const subEnd = r.pos + subSize;
+                            if (subEnd > payloadEnd)
+                                throw new Error("Name subsection out of bounds");
+                            const subReader = new Reader(wasmBytes.subarray(r.pos, subEnd), 0);
+                            if (subId === 1) {
+                                // function names
+                                const count = subReader.varU32();
+                                for (let i = 0; i < count; i++) {
+                                    const idx = subReader.varU32();
+                                    const nm = subReader.readString();
+                                    funcNameByIndex.set(idx, nm);
+                                }
+                            }
+                            else if (subId === 7) {
+                                // global names
+                                const count = subReader.varU32();
+                                for (let i = 0; i < count; i++) {
+                                    const idx = subReader.varU32();
+                                    const nm = subReader.readString();
+                                    globalNameByIndex.set(idx, nm);
+                                }
+                            }
+                            r.pos = subEnd;
                         }
-                        case 4: // tag (future-proof)
-                            p = readU32Leb(bytes, p, end).pos;
-                            break;
-                        default:
-                            dbg(`unknown import kind ${kind}; cannot safely skip (bailing import parse)`);
-                            // safest: bail parsing this section
-                            i = n;
-                            break;
                     }
+                    else {
+                        // skip rest
+                        r.pos = payloadEnd;
+                    }
+                    break;
                 }
-                dbg("imports:", { importTables, importMemories, importGlobals });
-            }
-            else if (id === 3) {
-                // function section: vec(typeidx) for defined (non-imported) functions
-                let p = start;
-                const rCount = readU32Leb(bytes, p, end);
-                const n = rCount.value;
-                p = rCount.pos;
-                localFunctions = n;
-                // Skip typeidx entries
-                for (let i = 0; i < n; i++) {
-                    p = skipLeb(bytes, p, end, 5);
+                case SECTION_IMPORT: {
+                    const count = r.varU32();
+                    for (let i = 0; i < count; i++) {
+                        r.skipString(); // module
+                        r.skipString(); // name
+                        const kind = r.u8();
+                        switch (kind) {
+                            case EXTERNAL_KIND_FUNCTION:
+                                importedFuncCount++;
+                                r.varU32(); // type idx
+                                break;
+                            case EXTERNAL_KIND_TABLE: {
+                                importedTableCount++;
+                                const rt = readRefType(r);
+                                importedTableTypes.push(rt);
+                                skipLimits(r);
+                                break;
+                            }
+                            case EXTERNAL_KIND_MEMORY:
+                                importedMemCount++;
+                                skipLimits(r);
+                                break;
+                            case EXTERNAL_KIND_GLOBAL: {
+                                importedGlobalCount++;
+                                skipValType(r);
+                                const mut = r.u8();
+                                importedGlobalMutable.push(mut !== 0);
+                                break;
+                            }
+                            default:
+                                throw new Error(`Unknown import kind: ${kind}`);
+                        }
+                    }
+                    break;
                 }
-                dbg("functions:", { importFunctions, localFunctions, totalFunctions: importFunctions + localFunctions });
-            }
-            else if (id === 4) {
-                // table section
-                let p = start;
-                const rCount = readU32Leb(bytes, p, end);
-                const n = rCount.value;
-                p = rCount.pos;
-                for (let i = 0; i < n; i++)
-                    p = parseTableType(bytes, p, end);
-                localTables += n;
-                dbg("tables:", { localTables, totalTables: importTables + localTables });
-            }
-            else if (id === 5) {
-                // memory section
-                let p = start;
-                const rCount = readU32Leb(bytes, p, end);
-                const n = rCount.value;
-                p = rCount.pos;
-                for (let i = 0; i < n; i++)
-                    p = parseMemType(bytes, p, end);
-                localMemories += n;
-                dbg("memories:", { localMemories, totalMemories: importMemories + localMemories });
-            }
-            else if (id === 6) {
-                // global section
-                let p = start;
-                const rCount = readU32Leb(bytes, p, end);
-                const n = rCount.value;
-                p = rCount.pos;
-                let globalIndex = importGlobals;
-                for (let i = 0; i < n; i++) {
-                    const gt = parseGlobalType(bytes, p, end);
-                    p = gt.pos;
-                    if (gt.mutable)
-                        mutableGlobalsToExport.add(globalIndex);
-                    // init expr (also collect ref.func if present)
-                    p = parseConstExprCollectRefFuncs(bytes, p, end, funcsToExport, `global[${globalIndex}].init`);
-                    globalIndex++;
+                case SECTION_FUNCTION: {
+                    const count = r.varU32();
+                    localFuncCount = count;
+                    // skip type indices
+                    for (let i = 0; i < count; i++)
+                        r.varU32();
+                    break;
                 }
-                localGlobals += n;
-                dbg("globals:", {
-                    localGlobals,
-                    totalGlobals: importGlobals + localGlobals,
-                    mutableGlobals: Array.from(mutableGlobalsToExport).sort((a, b) => a - b),
-                });
-            }
-            else if (id === 7) {
-                // export section
-                parseExportSection(bytes, start, end, exportNames, alreadyExported, exportEntries);
-            }
-            else if (id === 9) {
-                // element section (the big one we care about for function refs)
-                parseElementSectionCollectFuncIdxs(bytes, start, end, funcsToExport);
-            }
-            else if (id === 10) {
-                // code section: vec(code)
-                // We scan for opcode 0xD2 (ref.func) and record its immediate funcidx.
-                const totalFunctions = importFunctions + localFunctions;
-                let p = start;
-                const rCount = readU32Leb(bytes, p, end);
-                const nBodies = rCount.value;
-                p = rCount.pos;
-                dbg("code section bodies:", nBodies);
-                for (let bi = 0; bi < nBodies; bi++) {
-                    const rBodySize = readU32Leb(bytes, p, end);
-                    const bodySize = rBodySize.value;
-                    p = rBodySize.pos;
-                    const bodyStart = p;
-                    const bodyEnd = bodyStart + bodySize;
-                    if (bodyEnd > end)
-                        fail("code body size out of bounds");
-                    // Parse locals vec to find instruction start
-                    let q = bodyStart;
-                    const rLocalCount = readU32Leb(bytes, q, bodyEnd);
-                    const localCount = rLocalCount.value;
-                    q = rLocalCount.pos;
-                    for (let li = 0; li < localCount; li++) {
-                        // locals entry: count:u32, valtype:byte
-                        const rN = readU32Leb(bytes, q, bodyEnd);
-                        q = rN.pos;
-                        if (q >= bodyEnd)
-                            fail("unexpected EOF in locals");
-                        q += 1; // valtype
+                case SECTION_TABLE: {
+                    const count = r.varU32();
+                    for (let i = 0; i < count; i++) {
+                        const rt = readRefType(r);
+                        localTableTypes.push(rt);
+                        skipLimits(r);
                     }
-                    // Now q is at instruction bytes. We do a simple linear scan.
-                    // IMPORTANT: do NOT "jump" past immediates; false-positives are okay,
-                    // but skipping could cause us to miss real 0xD2 later.
-                    for (let i = q; i < bodyEnd; i++) {
-                        if (bytes[i] !== 0xd2)
-                            continue; // ref.func
-                        const rIdx = tryReadU32Leb(bytes, i + 1, bodyEnd);
-                        if (!rIdx)
-                            continue;
-                        if (rIdx.value < totalFunctions) {
-                            funcsToExport.add(rIdx.value);
+                    break;
+                }
+                case SECTION_MEMORY: {
+                    const count = r.varU32();
+                    localMemCount = count;
+                    for (let i = 0; i < count; i++)
+                        skipLimits(r);
+                    break;
+                }
+                case SECTION_GLOBAL: {
+                    const count = r.varU32();
+                    for (let i = 0; i < count; i++) {
+                        skipValType(r);
+                        const mut = r.u8();
+                        localGlobalMutable.push(mut !== 0);
+                        // init expr: collect ref.func
+                        skipConstExpr(r, (f) => markFunc(f));
+                    }
+                    break;
+                }
+                case SECTION_EXPORT: {
+                    exportSectionStart = start;
+                    exportSectionEnd = payloadEnd;
+                    exportCount = r.varU32();
+                    const entriesStart = r.pos;
+                    for (let i = 0; i < exportCount; i++) {
+                        const nm = r.readString();
+                        usedExportNames.add(nm);
+                        const kind = r.u8();
+                        const idx = r.varU32();
+                        switch (kind) {
+                            case EXTERNAL_KIND_FUNCTION:
+                                exportedFuncs.add(idx);
+                                break;
+                            case EXTERNAL_KIND_TABLE:
+                                exportedTables.add(idx);
+                                break;
+                            case EXTERNAL_KIND_MEMORY:
+                                exportedMems.add(idx);
+                                break;
+                            case EXTERNAL_KIND_GLOBAL:
+                                exportedGlobals.add(idx);
+                                break;
+                            default:
+                                // ignore unknown kinds
+                                break;
                         }
                     }
-                    p = bodyEnd;
+                    exportEntriesBytes = wasmBytes.subarray(entriesStart, payloadEnd);
+                    break;
                 }
-                dbg("funcsToExport after code scan:", Array.from(funcsToExport).sort((a, b) => a - b));
+                case SECTION_ELEMENT: {
+                    const segCount = r.varU32();
+                    for (let s = 0; s < segCount; s++) {
+                        const flags = r.varU32();
+                        const isExpr = (flags & 0x04) !== 0;
+                        const kind = flags & 0x03;
+                        // kind: 0 active (table 0), 1 passive, 2 active (explicit table), 3 declarative
+                        if (kind === 2) {
+                            // table index
+                            r.varU32();
+                        }
+                        if (kind === 0 || kind === 2) {
+                            // active segment has offset expr
+                            skipConstExpr(r);
+                        }
+                        if (!isExpr) {
+                            // function indices encoding
+                            if (kind === 1 || kind === 3) {
+                                // elemkind byte
+                                r.u8();
+                            }
+                            const n = r.varU32();
+                            for (let i = 0; i < n; i++) {
+                                const f = r.varU32();
+                                markFunc(f);
+                            }
+                        }
+                        else {
+                            // expression encoding: has elemtype/reftype
+                            readRefType(r);
+                            const n = r.varU32();
+                            for (let i = 0; i < n; i++) {
+                                // each element is a const expr (e.g. ref.func ...)
+                                skipConstExpr(r, (f) => markFunc(f));
+                            }
+                        }
+                    }
+                    break;
+                }
+                case SECTION_CODE: {
+                    const bodyCount = r.varU32();
+                    for (let i = 0; i < bodyCount; i++) {
+                        const bodySize = r.varU32();
+                        const bodyStart = r.pos;
+                        const bodyEnd = bodyStart + bodySize;
+                        if (bodyEnd > payloadEnd)
+                            throw new Error("Function body out of bounds");
+                        // locals
+                        const localDecls = r.varU32();
+                        for (let d = 0; d < localDecls; d++) {
+                            r.varU32(); // count
+                            skipValType(r); // type
+                        }
+                        // Scan the remaining bytes of the body (instructions) for opcode 0xd2.
+                        // This is a fast, conservative scan (may over-approximate, but bounded by total func count).
+                        const instrBytes = wasmBytes.subarray(r.pos, bodyEnd);
+                        let searchFrom = 0;
+                        while (true) {
+                            const hit = instrBytes.indexOf(OPCODE_REF_FUNC, searchFrom);
+                            if (hit === -1)
+                                break;
+                            // Decode following u32 LEB safely, within bounds.
+                            const abs = r.pos + hit + 1;
+                            if (abs < bodyEnd) {
+                                const rr = new Reader(wasmBytes, abs);
+                                try {
+                                    const idx = rr.varU32();
+                                    // only accept if rr.pos didn't run past end of body
+                                    if (rr.pos <= bodyEnd)
+                                        markFunc(idx);
+                                }
+                                catch {
+                                    // ignore malformed occurrences (likely false positive)
+                                }
+                            }
+                            searchFrom = hit + 1;
+                        }
+                        // Jump to end of body
+                        r.pos = bodyEnd;
+                    }
+                    break;
+                }
+                default:
+                    // ignore
+                    break;
             }
+            // restore pos to end of section payload
+            r.pos = payloadEnd;
+            // safeguard: should match payloadEnd
+            if (r.pos !== payloadEnd)
+                r.pos = payloadEnd;
+            // restore savedPos is not needed; we control r.pos explicitly.
+            void savedPos;
         }
-        catch (e) {
-            dbg(`parse error in ${noteSection(id)}:`, e);
-            // keep going; we'll still try to add exports using whatever we found
+        // Build lists to export based on parsed info
+        // 3) mutable globals (imports + locals) => export them
+        const globalsToExport = [];
+        const allGlobalsMutable = importedGlobalMutable.concat(localGlobalMutable);
+        for (let i = 0; i < allGlobalsMutable.length; i++) {
+            if (allGlobalsMutable[i])
+                globalsToExport.push(i);
+        }
+        // 4) all memories (imports + locals)
+        const memoryCount = importedMemCount + localMemCount;
+        const memoriesToExport = [];
+        for (let i = 0; i < memoryCount; i++)
+            memoriesToExport.push(i);
+        // 5) any table of funcrefs (imports + locals)
+        const tablesToExport = [];
+        const allTableTypes = importedTableTypes.concat(localTableTypes);
+        for (let i = 0; i < allTableTypes.length; i++) {
+            if (isFuncRefTableType(allTableTypes[i]))
+                tablesToExport.push(i);
+        }
+        // Prepare new exports
+        const newExports = [];
+        const makeUniqueName = (base, fallbackSuffix) => {
+            if (!usedExportNames.has(base)) {
+                usedExportNames.add(base);
+                return base;
+            }
+            const alt = `${base}${fallbackSuffix}`;
+            if (!usedExportNames.has(alt)) {
+                usedExportNames.add(alt);
+                return alt;
+            }
+            // deterministic collision resolver
+            let n = 2;
+            while (true) {
+                const cand = `${alt}_${n++}`;
+                if (!usedExportNames.has(cand)) {
+                    usedExportNames.add(cand);
+                    return cand;
+                }
+            }
+        };
+        // Functions
+        const funcIdxs = Array.from(funcsToExport);
+        funcIdxs.sort((a, b) => a - b); // deterministic
+        for (const funcIdx of funcIdxs) {
+            if (exportedFuncs.has(funcIdx))
+                continue;
+            const debugName = funcNameByIndex.get(funcIdx);
+            const base = debugName ?? `__f${funcIdx}`;
+            const name = makeUniqueName(base, `__f${funcIdx}`);
+            newExports.push({ name, kind: EXTERNAL_KIND_FUNCTION, index: funcIdx });
+        }
+        // Globals (mutable)
+        for (const g of globalsToExport) {
+            if (exportedGlobals.has(g))
+                continue;
+            const debugName = globalNameByIndex.get(g);
+            const base = debugName ?? `__global_${g}`;
+            const name = makeUniqueName(base, `__global_${g}`);
+            newExports.push({ name, kind: EXTERNAL_KIND_GLOBAL, index: g });
+        }
+        // Memories (all)
+        for (const m of memoriesToExport) {
+            if (exportedMems.has(m))
+                continue;
+            const base = `__memory_${m}`;
+            const name = makeUniqueName(base, `__memory_${m}`);
+            newExports.push({ name, kind: EXTERNAL_KIND_MEMORY, index: m });
+        }
+        // Tables (funcref-ish)
+        for (const t of tablesToExport) {
+            if (exportedTables.has(t))
+                continue;
+            const base = `__table_${t}`;
+            const name = makeUniqueName(base, `__table_${t}`);
+            newExports.push({ name, kind: EXTERNAL_KIND_TABLE, index: t });
+        }
+        if (newExports.length === 0) {
+            // Nothing to change
+            return wasmBytes;
+        }
+        // Encode appended export entries
+        const newEntriesW = new Writer(Math.max(256, newExports.length * 20));
+        for (const e of newExports) {
+            newEntriesW.string(e.name);
+            newEntriesW.u8(e.kind);
+            newEntriesW.varU32(e.index);
+        }
+        const newEntriesBytes = newEntriesW.finish();
+        // Build new export section payload
+        let newExportPayload;
+        if (exportEntriesBytes) {
+            const w = new Writer(10 + exportEntriesBytes.length + newEntriesBytes.length);
+            w.varU32(exportCount + newExports.length);
+            w.bytes(exportEntriesBytes);
+            w.bytes(newEntriesBytes);
+            newExportPayload = w.finish();
+        }
+        else {
+            const w = new Writer(10 + newEntriesBytes.length);
+            w.varU32(newExports.length);
+            w.bytes(newEntriesBytes);
+            newExportPayload = w.finish();
+        }
+        const newExportSectionBytes = encodeSection(SECTION_EXPORT, newExportPayload);
+        // Splice into original module bytes
+        if (exportSectionStart >= 0 && exportSectionEnd >= 0) {
+            // Replace existing export section
+            const before = wasmBytes.subarray(0, exportSectionStart);
+            const after = wasmBytes.subarray(exportSectionEnd);
+            return concat([before, newExportSectionBytes, after]);
+        }
+        else {
+            // Insert export section before first non-custom section with id > 7 (Start/Element/Code/etc),
+            // otherwise append at end.
+            let insertAt = wasmBytes.length;
+            for (const s of sections) {
+                if (s.id !== SECTION_CUSTOM && s.id > SECTION_EXPORT) {
+                    insertAt = s.start;
+                    break;
+                }
+            }
+            const before = wasmBytes.subarray(0, insertAt);
+            const after = wasmBytes.subarray(insertAt);
+            return concat([before, newExportSectionBytes, after]);
         }
-        pos = end;
-    }
-    const totalTables = importTables + localTables;
-    const totalMemories = importMemories + localMemories;
-    dbg("binary scan summary:", {
-        funcsToExport: Array.from(funcsToExport).sort((a, b) => a - b),
-        mutableGlobalsToExport: Array.from(mutableGlobalsToExport).sort((a, b) => a - b),
-        totalTables,
-        totalMemories,
-    });
-    return {
-        exportNames,
-        alreadyExported,
-        exportEntries,
-        funcsToExport,
-        mutableGlobalsToExport,
-        totalMemories,
-        totalTables,
-    };
-}
-/* =======================================================================================
- *  Main entry
- * ======================================================================================= */
-export async function preprocess_wasm_bytes(wasmBytes) {
-    // Scan is authoritative for what we need to export
-    const { exportNames, alreadyExported, exportEntries, funcsToExport, mutableGlobalsToExport, totalMemories, totalTables, } = scanWasmBinary(wasmBytes);
-    const added = [];
-    // 1) Functions referenced by element segments / ref.func
-    const funcList = Array.from(funcsToExport).sort((a, b) => a - b);
-    for (const idx of funcList) {
-        if (alreadyExported.Func.has(idx))
-            continue;
-        const name = uniqueName(`__f${idx}`, exportNames, `__f${idx}`);
-        added.push({ name, kind: 0, index: idx >>> 0 });
-        alreadyExported.Func.add(idx);
-    }
-    // 2) Mutable globals
-    const globList = Array.from(mutableGlobalsToExport).sort((a, b) => a - b);
-    for (const idx of globList) {
-        if (alreadyExported.Global.has(idx))
-            continue;
-        const name = uniqueName(`__global_${idx}`, exportNames, `__global_${idx}`);
-        added.push({ name, kind: 3, index: idx >>> 0 });
-        alreadyExported.Global.add(idx);
-    }
-    // 3) All memories
-    for (let idx = 0; idx < totalMemories; idx++) {
-        if (alreadyExported.Memory.has(idx))
-            continue;
-        const name = uniqueName(`__memory_${idx}`, exportNames, `__memory_${idx}`);
-        added.push({ name, kind: 2, index: idx >>> 0 });
-        alreadyExported.Memory.add(idx);
     }
-    // 4) All tables
-    for (let idx = 0; idx < totalTables; idx++) {
-        if (alreadyExported.Table.has(idx))
-            continue;
-        const name = uniqueName(`__table_${idx}`, exportNames, `__table_${idx}`);
-        added.push({ name, kind: 1, index: idx >>> 0 });
-        alreadyExported.Table.add(idx);
+    catch (e) {
+        if (opts.debug)
+            console.warn("preprocessWasmBytes failed:", e);
+        return new Uint8Array(0);
     }
-    if (added.length === 0)
-        return wasmBytes;
-    // Rebuild export section = existing entries + added entries
-    const allExports = exportEntries.concat(added);
-    const newExportSection = buildExportSectionBytes(allExports);
-    // Replace (or insert) export section in the original binary
-    return rewriteWasmWithExportSection(wasmBytes, newExportSection);
 }
 //# sourceMappingURL=preprocess_wasm_bytes.js.map