querysub 0.356.0 → 0.357.0

package/src/wat/watCompiler.ts

@@ -0,0 +1,1716 @@
+// WAT Compiler - Compiles WebAssembly Text Format to binary
+
+import * as peggy from "peggy";
+import * as fs from "fs";
+import * as path from "path";
+
+type ASTNode = {
+    type: "module" | "sexpr" | "instruction" | "identifier" | "index" | "number" | "string" | "attribute";
+    keyword?: string;
+    items?: ASTNode[];
+    attributes?: ASTNode[];
+    operands?: ASTNode[];
+    name?: string;
+    value?: string | number;
+};
+
+// Instruction forms represent the basic patterns instructions follow
+type InstructionForm =
+    | "nullary"       // No operands (e.g., nop, return)
+    | "unary"         // One operand (e.g., drop, local.get)
+    | "binary"        // Two operands (e.g., i32.store)
+    | "block"         // Block structure (e.g., block, loop, if)
+    | "control"       // Control flow (e.g., br, br_if)
+    | "call"          // Function calls
+    | "memory"        // Memory operations
+    | "const";        // Constants (e.g., i32.const)
+
+// Instruction metadata
+type InstructionMeta = {
+    form: InstructionForm;
+    opcode: number;
+    immediates?: ("varuint32" | "varint32" | "varint64" | "float32" | "float64" | "blocktype" | "byte")[];
+};
+
+// Instruction lookup table - maps instruction names to their forms and opcodes
+export const INSTRUCTION_MAP: Record<string, InstructionMeta> = {
+    // Parametric instructions
+    "unreachable": { form: "nullary", opcode: 0x00 },
+    "nop": { form: "nullary", opcode: 0x01 },
+    "drop": { form: "nullary", opcode: 0x1a },
+    "select": { form: "nullary", opcode: 0x1b },
+
+    // Control instructions
+    "block": { form: "block", opcode: 0x02, immediates: ["blocktype"] },
+    "loop": { form: "block", opcode: 0x03, immediates: ["blocktype"] },
+    "if": { form: "block", opcode: 0x04, immediates: ["blocktype"] },
+    "else": { form: "nullary", opcode: 0x05 },
+    "end": { form: "nullary", opcode: 0x0b },
+    "br": { form: "control", opcode: 0x0c, immediates: ["varuint32"] },
+    "br_if": { form: "control", opcode: 0x0d, immediates: ["varuint32"] },
+    "return": { form: "nullary", opcode: 0x0f },
+    "call": { form: "call", opcode: 0x10, immediates: ["varuint32"] },
+    "call_indirect": { form: "call", opcode: 0x11, immediates: ["varuint32", "varuint32"] },
+
+    // Variable instructions
+    "local.get": { form: "unary", opcode: 0x20, immediates: ["varuint32"] },
+    "local.set": { form: "unary", opcode: 0x21, immediates: ["varuint32"] },
+    "local.tee": { form: "unary", opcode: 0x22, immediates: ["varuint32"] },
+    "global.get": { form: "unary", opcode: 0x23, immediates: ["varuint32"] },
+    "global.set": { form: "unary", opcode: 0x24, immediates: ["varuint32"] },
+
+    // Table instructions
+    "table.get": { form: "unary", opcode: 0x25, immediates: ["varuint32"] },
+    "table.set": { form: "unary", opcode: 0x26, immediates: ["varuint32"] },
+
+    // Memory instructions
+    "i32.load": { form: "memory", opcode: 0x28 },
+    "i64.load": { form: "memory", opcode: 0x29 },
+    "f32.load": { form: "memory", opcode: 0x2a },
+    "f64.load": { form: "memory", opcode: 0x2b },
+    "i32.load8_s": { form: "memory", opcode: 0x2c },
+    "i32.load8_u": { form: "memory", opcode: 0x2d },
+    "i32.load16_s": { form: "memory", opcode: 0x2e },
+    "i32.load16_u": { form: "memory", opcode: 0x2f },
+    "i64.load8_s": { form: "memory", opcode: 0x30 },
+    "i64.load8_u": { form: "memory", opcode: 0x31 },
+    "i64.load16_s": { form: "memory", opcode: 0x32 },
+    "i64.load16_u": { form: "memory", opcode: 0x33 },
+    "i64.load32_s": { form: "memory", opcode: 0x34 },
+    "i64.load32_u": { form: "memory", opcode: 0x35 },
+    "i32.store": { form: "memory", opcode: 0x36 },
+    "i64.store": { form: "memory", opcode: 0x37 },
+    "f32.store": { form: "memory", opcode: 0x38 },
+    "f64.store": { form: "memory", opcode: 0x39 },
+    "i32.store8": { form: "memory", opcode: 0x3a },
+    "i32.store16": { form: "memory", opcode: 0x3b },
+    "i64.store8": { form: "memory", opcode: 0x3c },
+    "i64.store16": { form: "memory", opcode: 0x3d },
+    "i64.store32": { form: "memory", opcode: 0x3e },
+    "memory.size": { form: "unary", opcode: 0x3f, immediates: ["varuint32"] },
+    "memory.grow": { form: "unary", opcode: 0x40, immediates: ["varuint32"] },
+
+    // Numeric instructions - constants
+    "i32.const": { form: "const", opcode: 0x41, immediates: ["varint32"] },
+    "i64.const": { form: "const", opcode: 0x42, immediates: ["varint64"] },
+    "f32.const": { form: "const", opcode: 0x43, immediates: ["float32"] },
+    "f64.const": { form: "const", opcode: 0x44, immediates: ["float64"] },
+
+    // i32 comparison and test operations
+    "i32.eqz": { form: "nullary", opcode: 0x45 },
+    "i32.eq": { form: "nullary", opcode: 0x46 },
+    "i32.ne": { form: "nullary", opcode: 0x47 },
+    "i32.lt_s": { form: "nullary", opcode: 0x48 },
+    "i32.lt_u": { form: "nullary", opcode: 0x49 },
+    "i32.gt_s": { form: "nullary", opcode: 0x4a },
+    "i32.gt_u": { form: "nullary", opcode: 0x4b },
+    "i32.le_s": { form: "nullary", opcode: 0x4c },
+    "i32.le_u": { form: "nullary", opcode: 0x4d },
+    "i32.ge_s": { form: "nullary", opcode: 0x4e },
+    "i32.ge_u": { form: "nullary", opcode: 0x4f },
+
+    // i64 comparison and test operations
+    "i64.eqz": { form: "nullary", opcode: 0x50 },
+    "i64.eq": { form: "nullary", opcode: 0x51 },
+    "i64.ne": { form: "nullary", opcode: 0x52 },
+    "i64.lt_s": { form: "nullary", opcode: 0x53 },
+    "i64.lt_u": { form: "nullary", opcode: 0x54 },
+    "i64.gt_s": { form: "nullary", opcode: 0x55 },
+    "i64.gt_u": { form: "nullary", opcode: 0x56 },
+    "i64.le_s": { form: "nullary", opcode: 0x57 },
+    "i64.le_u": { form: "nullary", opcode: 0x58 },
+    "i64.ge_s": { form: "nullary", opcode: 0x59 },
+    "i64.ge_u": { form: "nullary", opcode: 0x5a },
+
+    // f32 comparison operations
+    "f32.eq": { form: "nullary", opcode: 0x5b },
+    "f32.ne": { form: "nullary", opcode: 0x5c },
+    "f32.lt": { form: "nullary", opcode: 0x5d },
+    "f32.gt": { form: "nullary", opcode: 0x5e },
+    "f32.le": { form: "nullary", opcode: 0x5f },
+    "f32.ge": { form: "nullary", opcode: 0x60 },
+
+    // f64 comparison operations
+    "f64.eq": { form: "nullary", opcode: 0x61 },
+    "f64.ne": { form: "nullary", opcode: 0x62 },
+    "f64.lt": { form: "nullary", opcode: 0x63 },
+    "f64.gt": { form: "nullary", opcode: 0x64 },
+    "f64.le": { form: "nullary", opcode: 0x65 },
+    "f64.ge": { form: "nullary", opcode: 0x66 },
+
+    // i32 arithmetic and bitwise operations
+    "i32.clz": { form: "nullary", opcode: 0x67 },
+    "i32.ctz": { form: "nullary", opcode: 0x68 },
+    "i32.popcnt": { form: "nullary", opcode: 0x69 },
+    "i32.add": { form: "nullary", opcode: 0x6a },
+    "i32.sub": { form: "nullary", opcode: 0x6b },
+    "i32.mul": { form: "nullary", opcode: 0x6c },
+    "i32.div_s": { form: "nullary", opcode: 0x6d },
+    "i32.div_u": { form: "nullary", opcode: 0x6e },
+    "i32.rem_s": { form: "nullary", opcode: 0x6f },
+    "i32.rem_u": { form: "nullary", opcode: 0x70 },
+    "i32.and": { form: "nullary", opcode: 0x71 },
+    "i32.or": { form: "nullary", opcode: 0x72 },
+    "i32.xor": { form: "nullary", opcode: 0x73 },
+    "i32.shl": { form: "nullary", opcode: 0x74 },
+    "i32.shr_s": { form: "nullary", opcode: 0x75 },
+    "i32.shr_u": { form: "nullary", opcode: 0x76 },
+    "i32.rotl": { form: "nullary", opcode: 0x77 },
+    "i32.rotr": { form: "nullary", opcode: 0x78 },
+
+    // i64 arithmetic and bitwise operations
+    "i64.clz": { form: "nullary", opcode: 0x79 },
+    "i64.ctz": { form: "nullary", opcode: 0x7a },
+    "i64.popcnt": { form: "nullary", opcode: 0x7b },
+    "i64.add": { form: "nullary", opcode: 0x7c },
+    "i64.sub": { form: "nullary", opcode: 0x7d },
+    "i64.mul": { form: "nullary", opcode: 0x7e },
+    "i64.div_s": { form: "nullary", opcode: 0x7f },
+    "i64.div_u": { form: "nullary", opcode: 0x80 },
+    "i64.rem_s": { form: "nullary", opcode: 0x81 },
+    "i64.rem_u": { form: "nullary", opcode: 0x82 },
+    "i64.and": { form: "nullary", opcode: 0x83 },
+    "i64.or": { form: "nullary", opcode: 0x84 },
+    "i64.xor": { form: "nullary", opcode: 0x85 },
+    "i64.shl": { form: "nullary", opcode: 0x86 },
+    "i64.shr_s": { form: "nullary", opcode: 0x87 },
+    "i64.shr_u": { form: "nullary", opcode: 0x88 },
+    "i64.rotl": { form: "nullary", opcode: 0x89 },
+    "i64.rotr": { form: "nullary", opcode: 0x8a },
+
+    // f32 arithmetic operations
+    "f32.abs": { form: "nullary", opcode: 0x8b },
+    "f32.neg": { form: "nullary", opcode: 0x8c },
+    "f32.ceil": { form: "nullary", opcode: 0x8d },
+    "f32.floor": { form: "nullary", opcode: 0x8e },
+    "f32.trunc": { form: "nullary", opcode: 0x8f },
+    "f32.nearest": { form: "nullary", opcode: 0x90 },
+    "f32.sqrt": { form: "nullary", opcode: 0x91 },
+    "f32.add": { form: "nullary", opcode: 0x92 },
+    "f32.sub": { form: "nullary", opcode: 0x93 },
+    "f32.mul": { form: "nullary", opcode: 0x94 },
+    "f32.div": { form: "nullary", opcode: 0x95 },
+    "f32.min": { form: "nullary", opcode: 0x96 },
+    "f32.max": { form: "nullary", opcode: 0x97 },
+    "f32.copysign": { form: "nullary", opcode: 0x98 },
+
+    // f64 arithmetic operations
+    "f64.abs": { form: "nullary", opcode: 0x99 },
+    "f64.neg": { form: "nullary", opcode: 0x9a },
+    "f64.ceil": { form: "nullary", opcode: 0x9b },
+    "f64.floor": { form: "nullary", opcode: 0x9c },
+    "f64.trunc": { form: "nullary", opcode: 0x9d },
+    "f64.nearest": { form: "nullary", opcode: 0x9e },
+    "f64.sqrt": { form: "nullary", opcode: 0x9f },
+    "f64.add": { form: "nullary", opcode: 0xa0 },
+    "f64.sub": { form: "nullary", opcode: 0xa1 },
+    "f64.mul": { form: "nullary", opcode: 0xa2 },
+    "f64.div": { form: "nullary", opcode: 0xa3 },
+    "f64.min": { form: "nullary", opcode: 0xa4 },
+    "f64.max": { form: "nullary", opcode: 0xa5 },
+    "f64.copysign": { form: "nullary", opcode: 0xa6 },
+
+    // Conversion operations
+    "i32.wrap_i64": { form: "nullary", opcode: 0xa7 },
+    "i32.trunc_s_f32": { form: "nullary", opcode: 0xa8 },
+    "i32.trunc_u_f32": { form: "nullary", opcode: 0xa9 },
+    "i32.trunc_s_f64": { form: "nullary", opcode: 0xaa },
+    "i32.trunc_u_f64": { form: "nullary", opcode: 0xab },
+    "i64.extend_i32_s": { form: "nullary", opcode: 0xac },
+    "i64.extend_i32_u": { form: "nullary", opcode: 0xad },
+    "i64.trunc_s_f32": { form: "nullary", opcode: 0xae },
+    "i64.trunc_u_f32": { form: "nullary", opcode: 0xaf },
+    "i64.trunc_s_f64": { form: "nullary", opcode: 0xb0 },
+    "i64.trunc_u_f64": { form: "nullary", opcode: 0xb1 },
+    "f32.convert_s_i32": { form: "nullary", opcode: 0xb2 },
+    "f32.convert_u_i32": { form: "nullary", opcode: 0xb3 },
+    "f32.convert_s_i64": { form: "nullary", opcode: 0xb4 },
+    "f32.convert_u_i64": { form: "nullary", opcode: 0xb5 },
+    "f32.demote_f64": { form: "nullary", opcode: 0xb6 },
+    "f64.convert_s_i32": { form: "nullary", opcode: 0xb7 },
+    "f64.convert_u_i32": { form: "nullary", opcode: 0xb8 },
+    "f64.convert_s_i64": { form: "nullary", opcode: 0xb9 },
+    "f64.convert_u_i64": { form: "nullary", opcode: 0xba },
+    "f64.promote_f32": { form: "nullary", opcode: 0xbb },
+    "i32.reinterpret_f32": { form: "nullary", opcode: 0xbc },
+    "i64.reinterpret_f64": { form: "nullary", opcode: 0xbd },
+    "f32.reinterpret_i32": { form: "nullary", opcode: 0xbe },
+    "f64.reinterpret_i64": { form: "nullary", opcode: 0xbf },
+
+    // Sign extension operations
+    "i32.extend8_s": { form: "nullary", opcode: 0xc0 },
+    "i32.extend16_s": { form: "nullary", opcode: 0xc1 },
+    "i64.extend8_s": { form: "nullary", opcode: 0xc2 },
+    "i64.extend16_s": { form: "nullary", opcode: 0xc3 },
+    "i64.extend32_s": { form: "nullary", opcode: 0xc4 },
+
+    // Reference instructions
+    "ref.is_null": { form: "nullary", opcode: 0xd1 },
+    "ref.eq": { form: "nullary", opcode: 0xd3 },
+    "ref.as_non_null": { form: "nullary", opcode: 0xd4 },
+
+    // SIMD Vector instructions (0xFD prefix + sub-opcode)
+    "v128.load": { form: "memory", opcode: 0xfd00 },
+    "v128.store": { form: "memory", opcode: 0xfd0b },
+    "i8x16.shuffle": { form: "unary", opcode: 0xfd0d, immediates: ["byte", "byte", "byte", "byte", "byte", "byte", "byte", "byte", "byte", "byte", "byte", "byte", "byte", "byte", "byte", "byte"] },
+    "i32x4.splat": { form: "nullary", opcode: 0xfd11 },
+    "i32x4.extract_lane": { form: "unary", opcode: 0xfd1b, immediates: ["varuint32"] },
+    "i32x4.replace_lane": { form: "unary", opcode: 0xfd1c, immediates: ["varuint32"] },
+    "i32x4.mul": { form: "nullary", opcode: 0xfdb5 },
+    "i32x4.shr_u": { form: "nullary", opcode: 0xfdad },
+    "i32x4.and": { form: "nullary", opcode: 0xfd4e },
+    "i32x4.sub": { form: "nullary", opcode: 0xfdb1 },
+    "i32x4.max_u": { form: "nullary", opcode: 0xfdb9 },
+    "i32x4.min_u": { form: "nullary", opcode: 0xfdb7 },
+};
+
+// Type definitions for compilation
+type FuncType = {
+    params: string[];
+    results: string[];
+};
+
+type FuncDef = {
+    typeIdx: number;
+    locals: string[];
+    localNames: string[]; // Names for params and locals (empty string if unnamed)
+    body: ASTNode[];
+    exportName?: string;
+};
+
+type ExportDef = {
+    name: string;
+    kind: "func" | "table" | "memory" | "global";
+    index: number;
+};
+
+// Compiler context
+class CompilerContext {
+    buffer: number[] = [];
+    labelStack: string[] = [];
+    localMap: Map<string, number> = new Map();
+    functionMap: Map<string, number> = new Map();
+
+    // Module-level data
+    types: FuncType[] = [];
+    imports: { module: string; name: string; kind: string; type?: any }[] = [];
+    functions: FuncDef[] = [];
+    globals: { type: string; mutable: boolean; init: ASTNode[] }[] = [];
+    exports: ExportDef[] = [];
+    memoryPages?: { min: number; max?: number };
+    hasImportedMemory: boolean = false;
+
+    emit(byte: number) {
+        this.buffer.push(byte & 0xff);
+    }
+
+    emitVarint32(value: number) {
+        // LEB128 signed 32-bit encoding
+        let more = true;
+        while (more) {
+            let byte = value & 0x7f;
+            value >>= 7;
+            if ((value === 0 && (byte & 0x40) === 0) || (value === -1 && (byte & 0x40) !== 0)) {
+                more = false;
+            } else {
+                byte |= 0x80;
+            }
+            this.emit(byte);
+        }
+    }
+
+    emitVaruint32(value: number) {
+        // LEB128 unsigned 32-bit encoding
+        do {
+            let byte = value & 0x7f;
+            value >>>= 7;
+            if (value !== 0) {
+                byte |= 0x80;
+            }
+            this.emit(byte);
+        } while (value !== 0);
+    }
+
+    emitFloat32(value: number) {
+        const buffer = new ArrayBuffer(4);
+        new DataView(buffer).setFloat32(0, value, true);
+        const bytes = new Uint8Array(buffer);
+        for (const byte of bytes) {
+            this.emit(byte);
+        }
+    }
+
+    emitFloat64(value: number) {
+        const buffer = new ArrayBuffer(8);
+        new DataView(buffer).setFloat64(0, value, true);
+        const bytes = new Uint8Array(buffer);
+        for (const byte of bytes) {
+            this.emit(byte);
+        }
+    }
+
+    emitString(str: string) {
+        const bytes = new TextEncoder().encode(str);
+        this.emitVaruint32(bytes.length);
+        for (const byte of bytes) {
+            this.emit(byte);
+        }
+    }
+
+    emitSection(sectionId: number, contents: number[]) {
+        this.emit(sectionId);
+        this.emitVaruint32(contents.length);
+        for (const byte of contents) {
+            this.emit(byte);
+        }
+    }
+
+    emitOpcode(opcode: number) {
+        // SIMD vector instructions use 0xFD prefix
+        if (opcode >= 0xfd00 && opcode <= 0xfdff) {
+            this.emit(0xfd);
+            this.emitVaruint32(opcode & 0xff);
+        } else {
+            this.emit(opcode);
+        }
+    }
+}
+
+// Instruction form handlers
+const FORM_HANDLERS = {
+    nullary: (ctx: CompilerContext, meta: InstructionMeta, node: ASTNode) => {
+        ctx.emitOpcode(meta.opcode);
+    },
+
+    unary: (ctx: CompilerContext, meta: InstructionMeta, node: ASTNode) => {
+        ctx.emitOpcode(meta.opcode);
+        if (!node.operands) return;
+
+        // Handle multiple immediates (e.g., i8x16.shuffle has 16 byte immediates)
+        if (meta.immediates && meta.immediates.length > 1) {
+            for (let i = 0; i < meta.immediates.length && i < node.operands.length; i++) {
+                const immType = meta.immediates[i];
+                const operand = node.operands[i];
+                if (operand && operand.type === "number") {
+                    const value = typeof operand.value === "number" ? operand.value : parseInt(operand.value as string, 10);
+                    if (immType === "byte") {
+                        ctx.emit(value & 0xff);
+                    } else if (immType === "varuint32") {
+                        ctx.emitVaruint32(value);
+                    } else if (immType === "varint32") {
+                        ctx.emitVarint32(value);
+                    }
+                }
+            }
+            return;
+        }
+
+        // Handle single immediate (original behavior)
+        const operand = node.operands[0];
+        if (operand && operand.type === "number") {
+            const value = typeof operand.value === "number" ? operand.value : parseInt(operand.value as string, 10);
+            ctx.emitVaruint32(value);
+        } else if (operand && operand.type === "identifier") {
+            if (!operand.name) return;
+            const numericIndex = parseInt(operand.name, 10);
+            if (!isNaN(numericIndex)) {
+                ctx.emitVaruint32(numericIndex);
+                return;
+            }
+            const index = ctx.localMap.get(operand.name);
+            if (index === undefined) {
+                throw new Error(`Unknown local: ${operand.name}`);
+            }
+            ctx.emitVaruint32(index);
+        } else if (operand && operand.type === "index") {
+            if (operand.value === undefined) return;
+            ctx.emitVaruint32(operand.value as number);
+        }
+    },
+
+    const: (ctx: CompilerContext, meta: InstructionMeta, node: ASTNode) => {
+        ctx.emitOpcode(meta.opcode);
+        if (!node.operands) return;
+        const operand = node.operands[0];
+        if (operand && operand.type === "number") {
+            if (operand.value === undefined) return;
+            const value = typeof operand.value === "number" ? operand.value : parseFloat(operand.value);
+            if (meta.immediates && meta.immediates[0] === "varint32") {
+                ctx.emitVarint32(value);
+            } else if (meta.immediates && meta.immediates[0] === "varint64") {
+                // TODO: Handle 64-bit integers properly
+                ctx.emitVarint32(value);
+            } else if (meta.immediates && meta.immediates[0] === "float32") {
+                ctx.emitFloat32(value);
+            } else if (meta.immediates && meta.immediates[0] === "float64") {
+                ctx.emitFloat64(value);
+            }
+        }
+    },
+
+    block: (ctx: CompilerContext, meta: InstructionMeta, node: ASTNode) => {
+        ctx.emitOpcode(meta.opcode);
+        // Block type (0x40 = empty/void)
+        ctx.emit(0x40);
+        // Note: Block body compilation is handled specially in compileInstruction
+    },
+
+    control: (ctx: CompilerContext, meta: InstructionMeta, node: ASTNode) => {
+        ctx.emitOpcode(meta.opcode);
+        if (!node.operands) return;
+        const operand = node.operands[0];
+        if (operand && operand.type === "identifier") {
+            // Find label depth in the stack
+            if (!operand.name) return;
+            const labelName = operand.name;
+            let depth = -1;
+            for (let i = ctx.labelStack.length - 1; i >= 0; i--) {
+                depth++;
+                if (ctx.labelStack[i] === labelName) {
+                    ctx.emitVaruint32(depth);
+                    return;
+                }
+            }
+            throw new Error(`Unknown label: ${labelName}`);
+        } else if (operand && operand.type === "index") {
+            if (operand.value === undefined) return;
+            ctx.emitVaruint32(operand.value as number);
+        } else if (operand && operand.type === "number") {
+            // Direct numeric depth
+            const value = typeof operand.value === "number" ? operand.value : parseInt(operand.value as string, 10);
+            ctx.emitVaruint32(value);
+        }
+    },
+
+    call: (ctx: CompilerContext, meta: InstructionMeta, node: ASTNode) => {
+        ctx.emitOpcode(meta.opcode);
+        if (!node.operands) return;
+        const operand = node.operands[0];
+        if (operand && operand.type === "identifier") {
+            if (!operand.name) return;
+            const index = ctx.functionMap.get(operand.name);
+            if (index === undefined) {
+                throw new Error(`Unknown function: ${operand.name}`);
+            }
+            ctx.emitVaruint32(index);
+        } else if (operand && operand.type === "index") {
+            if (operand.value === undefined) return;
+            ctx.emitVaruint32(operand.value as number);
+        }
+    },
+
+    binary: (ctx: CompilerContext, meta: InstructionMeta, node: ASTNode) => {
+        ctx.emitOpcode(meta.opcode);
+        // Handle two operands
+        // TODO: Implement based on specific instruction needs
+    },
+
+    memory: (ctx: CompilerContext, meta: InstructionMeta, node: ASTNode) => {
+        ctx.emitOpcode(meta.opcode);
+        // Emit alignment and offset for memory operations
+        // Alignment: log2 of natural alignment (e.g., 2 for i32/f32, 3 for i64/f64)
+        // Offset: byte offset from the calculated address
+
+        // Extract align and offset from attributes if present
+        let alignment: number | undefined = undefined;
+        let offset = 0;
+
+        if (node.attributes) {
+            for (const attr of node.attributes) {
+                if (attr.type === "attribute" && attr.name === "align") {
+                    alignment = typeof attr.value === "number" ? attr.value : parseInt(attr.value as string, 10);
+                } else if (attr.type === "attribute" && attr.name === "offset") {
+                    offset = typeof attr.value === "number" ? attr.value : parseInt(attr.value as string, 10);
+                }
+            }
+        }
+
+        // If no explicit alignment, use default based on instruction
+        if (alignment === undefined) {
+            // Default alignment based on instruction type
+            // i32/f32 loads/stores: 2 (4-byte alignment)
+            // i64/f64 loads/stores: 3 (8-byte alignment)
+            // i8 loads/stores: 0 (byte alignment)
+            // i16 loads/stores: 1 (2-byte alignment)
+            if (meta.opcode >= 0x28 && meta.opcode <= 0x2b || meta.opcode >= 0x36 && meta.opcode <= 0x39) {
+                alignment = 2; // i32/f32
+            } else if (meta.opcode >= 0x2c && meta.opcode <= 0x2d || meta.opcode === 0x3a) {
+                alignment = 0; // i8
+            } else if (meta.opcode >= 0x2e && meta.opcode <= 0x2f || meta.opcode === 0x3b) {
+                alignment = 1; // i16
+            } else {
+                alignment = 0; // Default to byte alignment for safety
+            }
+        }
+
+        ctx.emitVaruint32(alignment);
+        ctx.emitVaruint32(offset);
+    },
+};
+
+export class WATCompiler {
+    private ctx: CompilerContext;
+
+    constructor() {
+        this.ctx = new CompilerContext();
+    }
+
+    compile(ast: ASTNode): Uint8Array {
+        // Two-pass compilation
+        // Pass 1: Collect types, functions, exports
+        this.collectModuleInfo(ast);
+
+        // Pass 2: Generate binary
+        this.generateBinary();
+
+        return new Uint8Array(this.ctx.buffer);
+    }
+
+    private collectModuleInfo(node: ASTNode) {
+        if (node.type === "module") {
+            if (node.items) {
+                for (const item of node.items) {
+                    this.collectModuleInfo(item);
+                }
+            }
+        } else if (node.type === "sexpr") {
+            this.collectSExpr(node);
+        }
+    }
+
+    private collectSExpr(node: ASTNode) {
+        if (!node.keyword) return;
+
+        const keyword = node.keyword;
+
+        if (keyword === "module") {
+            if (node.items) {
+                for (const item of node.items) {
+                    this.collectModuleInfo(item);
+                }
+            }
+        } else if (keyword === "func") {
+            this.collectFunction(node);
+        } else if (keyword === "memory") {
+            this.collectMemory(node);
+        } else if (keyword === "export") {
+            this.collectExport(node);
+        } else if (keyword === "import") {
+            this.collectImport(node);
+        } else if (keyword === "global") {
+            this.collectGlobal(node);
+        }
+    }
+
+    private generateBinary() {
+        // WebAssembly binary magic number
+        this.ctx.emit(0x00);
+        this.ctx.emit(0x61);
+        this.ctx.emit(0x73);
+        this.ctx.emit(0x6d);
+
+        // Version 1
+        this.ctx.emit(0x01);
+        this.ctx.emit(0x00);
+        this.ctx.emit(0x00);
+        this.ctx.emit(0x00);
+
+        // Generate sections (order matters!)
+        this.generateTypeSection();
+        this.generateImportSection();
+        this.generateFunctionSection();
+        this.generateMemorySection();
+        this.generateGlobalSection();
+        this.generateExportSection();
+        this.generateCodeSection();
+    }
+
+    private collectFunction(node: ASTNode) {
+        if (!node.items) return;
+
+        const params: string[] = [];
+        const results: string[] = [];
+        const locals: string[] = [];
+        const body: ASTNode[] = [];
+        let exportName: string | undefined = undefined;
+        let funcName: string | undefined = undefined;
+
+        const paramNames: string[] = [];
+
+        // Check if first item is a function name (e.g., $hashUnitToIndex)
+        if (node.items[0] && node.items[0].type === "identifier" && node.items[0].name && node.items[0].name.startsWith("$")) {
+            funcName = node.items[0].name;
+        }
+
+        for (const item of node.items) {
+            if (item.type === "sexpr" && item.keyword === "param") {
+                if (item.items) {
+                    // Check if this is a named parameter: (param $name type)
+                    if (item.items.length === 2 &&
+                        item.items[0].type === "identifier" &&
+                        item.items[0].name &&
+                        item.items[0].name.startsWith("$")) {
+                        // Named parameter
+                        paramNames.push(item.items[0].name);
+                        if (item.items[1].type === "identifier" && item.items[1].name) {
+                            params.push(item.items[1].name);
+                        }
+                    } else {
+                        // Unnamed parameters: (param type1 type2 ...)
+                        for (const paramItem of item.items) {
+                            if (paramItem.type === "identifier" && paramItem.name) {
+                                params.push(paramItem.name);
+                                paramNames.push(""); // No name for this param
+                            }
+                        }
+                    }
+                }
+            } else if (item.type === "sexpr" && item.keyword === "result") {
+                if (item.items) {
+                    for (const resultItem of item.items) {
+                        if (resultItem.type === "identifier" && resultItem.name) {
+                            results.push(resultItem.name);
+                        }
+                    }
+                }
+            } else if (item.type === "sexpr" && item.keyword === "local") {
+                if (item.items) {
+                    // Check if this is a named local: (local $name type)
+                    if (item.items.length === 2 &&
+                        item.items[0].type === "identifier" &&
+                        item.items[0].name &&
+                        item.items[0].name.startsWith("$")) {
+                        // Named local
+                        paramNames.push(item.items[0].name);
+                        if (item.items[1].type === "identifier" && item.items[1].name) {
+                            locals.push(item.items[1].name);
+                        }
+                    } else {
+                        // Unnamed locals: (local type1 type2 ...)
+                        for (const localItem of item.items) {
+                            if (localItem.type === "identifier" && localItem.name) {
+                                locals.push(localItem.name);
+                                paramNames.push(""); // No name for this local
+                            }
+                        }
+                    }
+                }
+            } else if (item.type === "sexpr" && item.keyword === "export") {
+                if (item.items && item.items[0] && item.items[0].type === "string") {
+                    exportName = item.items[0].value as string;
+                }
+            } else if (item.type === "sexpr") {
+                body.push(item);
+            }
+        }
+
+        // Find or create type
+        const funcType: FuncType = { params, results };
+        let typeIdx = this.ctx.types.findIndex(t =>
+            JSON.stringify(t) === JSON.stringify(funcType)
+        );
+        if (typeIdx === -1) {
+            typeIdx = this.ctx.types.length;
+            this.ctx.types.push(funcType);
+        }
+
+        const funcIdx = this.ctx.functions.length;
+        this.ctx.functions.push({ typeIdx, locals, localNames: paramNames, body, exportName });
+
+        // Register function name for internal calls
+        if (funcName) {
+            this.ctx.functionMap.set(funcName, funcIdx);
+        }
+
+        if (exportName) {
+            this.ctx.exports.push({
+                name: exportName,
+                kind: "func",
+                index: funcIdx
+            });
+        }
+    }
+
+    private collectMemory(node: ASTNode) {
+        if (!node.items) return;
+
+        let min = 1;
+        let max: number | undefined = undefined;
+
+        if (node.items[0] && node.items[0].type === "number") {
+            min = parseInt(node.items[0].value as string, 10);
+        }
+        if (node.items[1] && node.items[1].type === "number") {
+            max = parseInt(node.items[1].value as string, 10);
+        }
+
+        this.ctx.memoryPages = { min, max };
+    }
+
+    private collectImport(node: ASTNode) {
+        if (!node.items || node.items.length < 3) return;
+
+        // (import "module" "name" (kind ...))
+        const moduleItem = node.items[0];
+        const nameItem = node.items[1];
+        const descItem = node.items[2];
+
+        if (moduleItem.type !== "string" || nameItem.type !== "string") return;
+        if (descItem.type !== "sexpr" || !descItem.keyword) return;
+
+        const module = moduleItem.value as string;
+        const name = nameItem.value as string;
+        const kind = descItem.keyword;
+
+        if (kind === "memory") {
+            this.ctx.hasImportedMemory = true;
+            // Memory imports: (import "env" "memory" (memory i64 1))
+            // For now, just mark that we have an imported memory
+        }
+
+        this.ctx.imports.push({ module, name, kind, type: descItem });
+    }
+
+    private collectGlobal(node: ASTNode) {
+        if (!node.items) return;
+
+        // Check if this is an exported global: (global (export "name") type (init))
+        let exportName: string | undefined = undefined;
+        let type = "i32";
+        const mutable = false;
+        const init: ASTNode[] = [];
+
+        for (const item of node.items) {
+            if (item.type === "sexpr" && item.keyword === "export") {
+                if (item.items && item.items[0] && item.items[0].type === "string") {
+                    exportName = item.items[0].value as string;
+                }
+            } else if (item.type === "identifier" && item.name) {
+                // Type like i32, i64, etc
+                type = item.name;
+            } else if (item.type === "sexpr") {
+                // Initialization expression
+                init.push(item);
+            }
+        }
+
+        const globalIdx = this.ctx.globals.length;
+        this.ctx.globals.push({ type, mutable, init });
+
+        if (exportName) {
+            this.ctx.exports.push({
+                name: exportName,
+                kind: "global",
+                index: globalIdx
+            });
+        }
+    }
+
+    private collectExport(node: ASTNode) {
+        // Exports are collected inline with functions for now
+    }
+
+    private generateTypeSection() {
+        if (this.ctx.types.length === 0) return;
+
+        const section: number[] = [];
+        const tempCtx = new CompilerContext();
+
+        tempCtx.emitVaruint32(this.ctx.types.length);
+
+        for (const funcType of this.ctx.types) {
+            tempCtx.emit(0x60); // func type
+            tempCtx.emitVaruint32(funcType.params.length);
+            for (const param of funcType.params) {
+                tempCtx.emit(this.getTypeCode(param));
+            }
+            tempCtx.emitVaruint32(funcType.results.length);
+            for (const result of funcType.results) {
+                tempCtx.emit(this.getTypeCode(result));
+            }
+        }
+
+        this.ctx.emitSection(1, tempCtx.buffer);
+    }
+
+    private generateFunctionSection() {
+        if (this.ctx.functions.length === 0) return;
+
+        const tempCtx = new CompilerContext();
+        tempCtx.emitVaruint32(this.ctx.functions.length);
+
+        for (const func of this.ctx.functions) {
+            tempCtx.emitVaruint32(func.typeIdx);
+        }
+
+        this.ctx.emitSection(3, tempCtx.buffer);
+    }
+
+    private generateImportSection() {
+        if (this.ctx.imports.length === 0) return;
+
+        const tempCtx = new CompilerContext();
+        tempCtx.emitVaruint32(this.ctx.imports.length);
+
+        for (const imp of this.ctx.imports) {
+            // Module name
+            tempCtx.emitString(imp.module);
+            // Field name
+            tempCtx.emitString(imp.name);
+
+            // Import kind and type
+            if (imp.kind === "memory") {
+                tempCtx.emit(0x02); // memory import kind
+
+                // Parse memory descriptor: (memory [i64|i32] min [max])
+                // For now, ignore i64/i32 and just parse limits
+                let is64 = false;
+                let min = 1;
+                let max: number | undefined = undefined;
+
+                if (imp.type && imp.type.items) {
+                    let numbersSeen = 0;
+                    for (let i = 0; i < imp.type.items.length; i++) {
+                        const item = imp.type.items[i];
+                        if (item.type === "identifier" && item.name === "i64") {
+                            is64 = true;
+                        } else if (item.type === "identifier" && item.name === "i32") {
+                            is64 = false;
+                        } else if (item.type === "number") {
+                            if (numbersSeen === 0) {
+                                min = parseInt(item.value as string, 10);
+                            } else if (numbersSeen === 1) {
+                                max = parseInt(item.value as string, 10);
+                            }
+                            numbersSeen++;
+                        }
+                    }
+                }
+
+                // Emit memory limits with correct flags
+                // Flags: bit 0 = has_max, bit 2 = is_64 (memory64)
+                let flags = 0;
+                if (max !== undefined) flags |= 0x01; // has max
+                if (is64) flags |= 0x04; // memory64
+
+                tempCtx.emit(flags);
+                tempCtx.emitVaruint32(min);
+                if (max !== undefined) {
+                    tempCtx.emitVaruint32(max);
+                }
+            }
+            // TODO: Handle other import kinds (func, table, global)
+        }
+
+        this.ctx.emitSection(2, tempCtx.buffer);
+    }
+
+    private generateGlobalSection() {
+        if (this.ctx.globals.length === 0) return;
+
+        const tempCtx = new CompilerContext();
+        tempCtx.emitVaruint32(this.ctx.globals.length);
+
+        for (const global of this.ctx.globals) {
+            // Global type
+            tempCtx.emit(this.getTypeCode(global.type));
+            // Mutability
+            tempCtx.emit(global.mutable ? 0x01 : 0x00);
+
+            // Init expression
+            for (const initExpr of global.init) {
+                this.compileInstruction(tempCtx, initExpr);
+            }
+            tempCtx.emit(0x0b); // end of init expression
+        }
+
+        this.ctx.emitSection(6, tempCtx.buffer);
+    }
+
+    private generateMemorySection() {
+        if (!this.ctx.memoryPages || this.ctx.hasImportedMemory) return;
+
+        const tempCtx = new CompilerContext();
+        tempCtx.emitVaruint32(1); // number of memories
+
+        if (this.ctx.memoryPages.max !== undefined) {
+            tempCtx.emit(0x01); // has max
+            tempCtx.emitVaruint32(this.ctx.memoryPages.min);
+            tempCtx.emitVaruint32(this.ctx.memoryPages.max);
+        } else {
+            tempCtx.emit(0x00); // no max
+            tempCtx.emitVaruint32(this.ctx.memoryPages.min);
+        }
+
+        this.ctx.emitSection(5, tempCtx.buffer);
+    }
+
+    private generateExportSection() {
+        if (this.ctx.exports.length === 0) return;
+
+        const tempCtx = new CompilerContext();
+        tempCtx.emitVaruint32(this.ctx.exports.length);
+
+        for (const exp of this.ctx.exports) {
+            tempCtx.emitString(exp.name);
+            const kindCode = exp.kind === "func" ? 0x00 :
+                exp.kind === "table" ? 0x01 :
+                    exp.kind === "memory" ? 0x02 : 0x03;
+            tempCtx.emit(kindCode);
+            tempCtx.emitVaruint32(exp.index);
+        }
+
+        this.ctx.emitSection(7, tempCtx.buffer);
+    }
+
+    private generateCodeSection() {
+        if (this.ctx.functions.length === 0) return;
+
+        const tempCtx = new CompilerContext();
+        tempCtx.emitVaruint32(this.ctx.functions.length);
+
+        for (const func of this.ctx.functions) {
+            const funcBody = this.compileFunctionBody(func);
+            tempCtx.emitVaruint32(funcBody.length);
+            for (const byte of funcBody) {
+                tempCtx.emit(byte);
+            }
+        }
+
+        this.ctx.emitSection(10, tempCtx.buffer);
+    }
+
+    private compileFunctionBody(func: FuncDef): number[] {
+        const bodyCtx = new CompilerContext();
+
+        // Copy function map from module context for internal calls
+        bodyCtx.functionMap = this.ctx.functionMap;
+
+        // Build local map (params first, then locals)
+        const funcType = this.ctx.types[func.typeIdx];
+        let localIdx = 0;
+
+        // Map parameter names and indices
+        for (let i = 0; i < funcType.params.length; i++) {
+            if (func.localNames[i] && func.localNames[i] !== "") {
+                bodyCtx.localMap.set(func.localNames[i], localIdx);
+            }
+            // Also allow numeric access
+            bodyCtx.localMap.set(`${i}`, localIdx);
+            localIdx++;
+        }
+
+        // Group locals by type (required by WASM format)
+        const localGroups: Map<string, number> = new Map();
+        for (const local of func.locals) {
+            const count = localGroups.get(local) || 0;
+            localGroups.set(local, count + 1);
+        }
+
+        // Map local variable names based on GROUPED order
+        for (const [type, count] of localGroups) {
+            for (let i = 0; i < func.locals.length; i++) {
+                if (func.locals[i] === type) {
+                    const nameIdx = funcType.params.length + i;
+                    if (func.localNames[nameIdx] && func.localNames[nameIdx] !== "") {
+                        bodyCtx.localMap.set(func.localNames[nameIdx], localIdx);
+                    }
+                    localIdx++;
+                }
+            }
+        }
+
+        // Emit locals count (grouped by type)
+        bodyCtx.emitVaruint32(localGroups.size);
+        for (const [type, count] of localGroups) {
+            bodyCtx.emitVaruint32(count);
+            bodyCtx.emit(this.getTypeCode(type));
+        }
+
+        // Compile function body
+        for (const instr of func.body) {
+            this.compileInstruction(bodyCtx, instr);
+        }
+
+        // Emit end opcode
+        bodyCtx.emit(0x0b);
+
+        return bodyCtx.buffer;
+    }
+
+    private compileInstruction(ctx: CompilerContext, node: ASTNode) {
+        if (!node.keyword) return;
+
+        // Special handling for block/loop/if structures
+        if (node.keyword === "block" || node.keyword === "loop") {
+            // Emit opcode
+            ctx.emit(node.keyword === "block" ? 0x02 : 0x03);
+            // Emit blocktype (0x40 = void)
+            ctx.emit(0x40);
+
+            // Find and push label onto stack
+            let label = "";
+            if (node.items && node.items[0] && node.items[0].type === "identifier" && node.items[0].name) {
+                label = node.items[0].name;
+            }
+            ctx.labelStack.push(label);
+
+            // Compile body (skip first item if it's a label like $break or $continue)
+            if (node.items) {
+                for (const item of node.items) {
+                    // Skip identifiers (labels)
+                    if (item.type === "identifier") continue;
+                    if (item.type === "sexpr" && item.keyword) {
+                        this.compileInstruction(ctx, item);
+                    }
+                }
+            }
+
+            ctx.labelStack.pop(); // Pop label
+            ctx.emit(0x0b); // end opcode
+            return;
+        }
+
+        if (node.keyword === "if") {
+            if (node.items) {
+                let thenIdx = -1;
+                let elseIdx = -1;
+                let resultType: string | undefined = undefined;
+
+                // Find then, else, and result clauses
+                for (let i = 0; i < node.items.length; i++) {
+                    const item = node.items[i];
+                    if (item.type === "sexpr" && item.keyword === "then") {
+                        thenIdx = i;
+                    } else if (item.type === "sexpr" && item.keyword === "else") {
+                        elseIdx = i;
+                    } else if (item.type === "sexpr" && item.keyword === "result") {
+                        // Extract result type from (result i32)
+                        if (item.items && item.items.length > 0) {
+                            const typeItem = item.items[0];
+                            if (typeItem.type === "identifier" && typeof typeItem.value === "string") {
+                                resultType = typeItem.value;
+                            }
+                        }
+                    }
+                }
+
+                // Compile condition BEFORE emitting if opcode (instructions before then)
+                for (let i = 0; i < (thenIdx >= 0 ? thenIdx : node.items.length); i++) {
+                    const item = node.items[i];
+                    if (item.type === "sexpr" && item.keyword && item.keyword !== "then" && item.keyword !== "else" && item.keyword !== "result") {
+                        this.compileInstruction(ctx, item);
+                    }
+                }
+
+                // Now emit if opcode
+                ctx.emit(0x04); // if opcode
+                // Emit blocktype: 0x40 for void, or type code for result type
+                if (resultType) {
+                    ctx.emit(this.getTypeCode(resultType));
+                } else {
+                    ctx.emit(0x40); // blocktype (void)
+                }
+                ctx.labelStack.push(""); // if blocks have no label
+
+                // Compile then clause
+                if (thenIdx >= 0) {
+                    const thenClause = node.items[thenIdx];
+                    if (thenClause && thenClause.items) {
+                        for (const item of thenClause.items) {
+                            if (item.type === "sexpr") {
+                                if (item.keyword) {
+                                    this.compileInstruction(ctx, item);
+                                }
+                            } else if (item.type === "instruction") {
+                                this.compileInstruction(ctx, item);
+                            }
+                        }
+                    }
+                }
+
+                // Compile else clause if present
+                if (elseIdx >= 0) {
+                    ctx.emit(0x05); // else opcode
+                    const elseClause = node.items[elseIdx];
+                    if (elseClause && elseClause.items) {
+                        for (const item of elseClause.items) {
+                            if (item.type === "sexpr") {
+                                if (item.keyword) {
+                                    this.compileInstruction(ctx, item);
+                                }
+                            } else if (item.type === "instruction") {
+                                this.compileInstruction(ctx, item);
+                            }
+                        }
+                    }
+                }
+
+                ctx.labelStack.pop(); // Pop if label
+                ctx.emit(0x0b); // end opcode
+            }
+            return;
+        }
+
+        const meta = INSTRUCTION_MAP[node.keyword];
+        if (!meta) {
+            throw new Error(`Unknown instruction: ${node.keyword}`);
+        }
+
+        const handler = FORM_HANDLERS[meta.form];
+        if (!handler) {
+            throw new Error(`No handler for form: ${meta.form}`);
+        }
+
+        // Compile nested S-expressions BEFORE emitting the parent instruction (depth-first)
+        // This is correct for stack machine semantics
+        // Skip for block/loop which handle their own bodies
+        if (node.keyword !== "block" && node.keyword !== "loop" && node.items) {
+            for (const item of node.items) {
+                if (item.type === "sexpr" && item.keyword) {
+                    this.compileInstruction(ctx, item);
+                }
+            }
+        }
+
+        const instructionNode = {
+            ...node,
+            operands: node.items || [],
+            attributes: node.attributes || []
+        };
+
+        handler(ctx, meta, instructionNode);
+    }
+
+    private getTypeCode(typeName: string): number {
+        switch (typeName) {
+            case "i32": return 0x7f;
+            case "i64": return 0x7e;
+            case "f32": return 0x7d;
+            case "f64": return 0x7c;
+            case "v128": return 0x7b;
+            default: throw new Error(`Unknown type: ${typeName}`);
+        }
+    }
+}
+
+// Cache the parser so we don't regenerate it every time
+let cachedParser: { parse: (input: string) => ASTNode } | undefined = undefined;
+
+function getParser(): { parse: (input: string) => ASTNode } {
+    if (cachedParser === undefined) {
+        const grammarPath = path.join(__dirname, "watGrammar.pegjs");
+        const grammarSource = fs.readFileSync(grammarPath, "utf-8");
+        cachedParser = peggy.generate(grammarSource) as { parse: (input: string) => ASTNode };
+    }
+    return cachedParser;
+}
+
+export function parseWAT(source: string): ASTNode {
+    const parser = getParser();
+    try {
+        return parser.parse(source);
+    } catch (e: unknown) {
+        if (e && typeof e === "object" && "location" in e) {
+            const error = e as { location: { start: { line: number; column: number } }; message: string };
+            const loc = error.location.start;
+            throw new Error(`Parse error at line ${loc.line}, column ${loc.column}: ${error.message}`);
+        }
+        throw e;
+    }
+}
+
+export function compileWAT(source: string): Uint8Array {
+    const ast = parseWAT(source);
+    const compiler = new WATCompiler();
+    return compiler.compile(ast);
+}
+
+// Test function to verify the WAT compiler works
+export async function testWATCompiler() {
+    console.log("Testing WAT compiler...\n");
+
+    // Test 1: Simple arithmetic function
+    const simpleWAT = `
+        (module
+            (func (export "add") (param i32 i32) (result i32)
+                (local.get 0)
+                (local.get 1)
+                (i32.add)
+            )
+        )
+    `;
+
+    try {
+        const wasmBytes = compileWAT(simpleWAT);
+        console.log(`✓ Compiled ${wasmBytes.length} bytes`);
+
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const wasmInstance = new WebAssembly.Instance(wasmModule);
+
+        const add = wasmInstance.exports.add as (a: number, b: number) => number;
+        const result = add(5, 7);
+
+        if (result === 12) {
+            console.log("✓ Test 1 passed: add(5, 7) = 12");
+        } else {
+            console.error(`✗ Test 1 failed: add(5, 7) = ${result}, expected 12`);
+        }
+    } catch (e) {
+        console.error("✗ Test 1 failed with error:", e);
+    }
+
+    // Test 2: Conditional logic with select
+    const conditionalWAT = `
+        (module
+            (func (export "max") (param i32 i32) (result i32)
+                (local.get 0)
+                (local.get 1)
+                (local.get 0)
+                (local.get 1)
+                (i32.gt_s)
+                (select)
+            )
+        )
+    `;
+
+    try {
+        const wasmBytes = compileWAT(conditionalWAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const wasmInstance = new WebAssembly.Instance(wasmModule);
+
+        const max = wasmInstance.exports.max as (a: number, b: number) => number;
+        const result1 = max(10, 5);
+        const result2 = max(3, 8);
+
+        if (result1 === 10 && result2 === 8) {
+            console.log("✓ Test 2 passed: max(10, 5) = 10, max(3, 8) = 8");
+        } else {
+            console.error(`✗ Test 2 failed: max(10, 5) = ${result1}, max(3, 8) = ${result2}`);
+        }
+    } catch (e) {
+        console.error("✗ Test 2 failed with error:", e);
+    }
+
+    // Test 3: Multiple operations
+    const multiOpWAT = `
+        (module
+            (func (export "compute") (param i32) (result i32)
+                (local.get 0)
+                (i32.const 10)
+                (i32.mul)
+                (i32.const 5)
+                (i32.add)
+            )
+        )
+    `;
+
+    try {
+        const wasmBytes = compileWAT(multiOpWAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const wasmInstance = new WebAssembly.Instance(wasmModule);
+
+        const compute = wasmInstance.exports.compute as (a: number) => number;
+        const result = compute(3);
+
+        if (result === 35) {
+            console.log("✓ Test 3 passed: compute(3) = 35 (3 * 10 + 5)");
+        } else {
+            console.error(`✗ Test 3 failed: compute(3) = ${result}, expected 35`);
+        }
+    } catch (e) {
+        console.error("✗ Test 3 failed with error:", e);
+    }
+
+    // Test 4: Subtraction and division
+    const mathWAT = `
+        (module
+            (func (export "calculate") (param i32 i32) (result i32)
+                (local.get 0)
+                (local.get 1)
+                (i32.sub)
+                (i32.const 2)
+                (i32.div_s)
+            )
+        )
+    `;
+
+    try {
+        const wasmBytes = compileWAT(mathWAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const wasmInstance = new WebAssembly.Instance(wasmModule);
+
+        const calculate = wasmInstance.exports.calculate as (a: number, b: number) => number;
+        const result = calculate(20, 10);
+
+        if (result === 5) {
+            console.log("✓ Test 4 passed: calculate(20, 10) = 5 ((20 - 10) / 2)");
+        } else {
+            console.error(`✗ Test 4 failed: calculate(20, 10) = ${result}, expected 5`);
+        }
+    } catch (e) {
+        console.error("✗ Test 4 failed with error:", e);
+    }
+
+    // Test 5: Local.set with named parameters
+    const localSetWAT = `
+        (module
+            (func (export "test") (param $a i32) (result i32)
+                (local $b i32)
+                (local.set $b (i32.add (local.get $a) (i32.const 5)))
+                (local.get $b)
+            )
+        )
+    `;
+
+    try {
+        const wasmBytes = compileWAT(localSetWAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const wasmInstance = new WebAssembly.Instance(wasmModule);
+
+        const test = wasmInstance.exports.test as (a: number) => number;
+        const result = test(10);
+
+        if (result === 15) {
+            console.log("✓ Test 5 passed: test(10) = 15 (10 + 5)");
+        } else {
+            console.error(`✗ Test 5 failed: test(10) = ${result}, expected 15`);
+        }
+    } catch (e) {
+        console.error("✗ Test 5 failed with error:", e);
+    }
+
+    // Test 6: Block with local.set
+    const blockWAT = `
+        (module
+            (func (export "test") (param $a i32) (result i32)
+                (local $b i32)
+                (local.set $b (i32.const 0))
+                (block $myblock
+                    (local.set $b (i32.add (local.get $a) (i32.const 10)))
+                )
+                (local.get $b)
+            )
+        )
+    `;
+
+    try {
+        const wasmBytes = compileWAT(blockWAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const wasmInstance = new WebAssembly.Instance(wasmModule);
+
+        const test = wasmInstance.exports.test as (a: number) => number;
+        const result = test(5);
+
+        if (result === 15) {
+            console.log("✓ Test 6 passed: test(5) = 15 (block with local.set)");
+        } else {
+            console.error(`✗ Test 6 failed: test(5) = ${result}, expected 15`);
+        }
+    } catch (e) {
+        console.error("✗ Test 6 failed with error:", e);
+    }
+
+    // Test 7: Many parameters and locals
+    const manyLocalsWAT = `
+        (module
+            (func (export "test")
+                (param $a i32) (param $b i32) (param $c i32) (param $d i32)
+                (local $e i32) (local $f i32) (local $g i32)
+                (local.set $e (i32.const 1))
+                (local.set $f (i32.const 2))
+                (local.set $g (i32.add (local.get $e) (local.get $f)))
+            )
+        )
+    `;
+
+    try {
+        const wasmBytes = compileWAT(manyLocalsWAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        console.log("✓ Test 7 passed: many parameters and locals compiled");
+    } catch (e) {
+        console.error("✗ Test 7 failed with error:", e);
+    }
+
+    // Test 8: BufferIndex excerpt
+    const bufferIndexExcerpt = `(module
+  (func (export "phase1_count_deduplicate")
+    (param $unitRefsPtr i32)
+    (param $totalUnits i32)
+    (param $hashTablePtr i32)
+    (param $hashTableCapacity i32)
+    (param $uniqueUnitListPtr i32)
+    (param $maxUniqueCount i32)
+    (result i32)
+    
+    (local $i i32)
+    (local $hashTableSize i32)
+    
+    (local.set $hashTableSize
+      (i32.mul (local.get $hashTableCapacity) (i32.const 16)))
+    
+    (local.set $i (i32.const 0))
+    
+    (local.get $i)
+  )
+)`;
+
+    try {
+        const wasmBytes = compileWAT(bufferIndexExcerpt);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const wasmInstance = new WebAssembly.Instance(wasmModule);
+        const fn = wasmInstance.exports.phase1_count_deduplicate as (...args: number[]) => number;
+        const result = fn(0, 0, 0, 16, 0, 0);
+        console.log(`✓ Test 8 passed: BufferIndex excerpt compiled, result = ${result}`);
+    } catch (e) {
+        console.error("✗ Test 8 failed with error:", e);
+    }
+
+    // Test 9: Memory operations (i32.store)
+    const memoryWAT = `(module
+  (memory 1)
+  (func (export "test") (result i32)
+    (local $addr i32)
+    (local.set $addr (i32.const 0))
+    (i32.store (local.get $addr) (i32.const 42))
+    (i32.load (local.get $addr))
+  )
+)`;
+
+    try {
+        const wasmBytes = compileWAT(memoryWAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const wasmInstance = new WebAssembly.Instance(wasmModule);
+        const fn = wasmInstance.exports.test as () => number;
+        const result = fn();
+        if (result === 42) {
+            console.log("✓ Test 9 passed: memory operations work");
+        } else {
+            console.error(`✗ Test 9 failed: expected 42, got ${result}`);
+        }
+    } catch (e) {
+        console.error("✗ Test 9 failed with error:", e);
+    }
+
+    // Test 10: Loop with if/then
+    const loopIfWAT = `(module
+  (func (export "test") (param $max i32) (result i32)
+    (local $i i32)
+    (local $sum i32)
+    (local.set $i (i32.const 0))
+    (local.set $sum (i32.const 0))
+    (block $break
+      (loop $continue
+        (br_if $break (i32.ge_u (local.get $i) (local.get $max)))
+        (if (i32.eq (i32.rem_u (local.get $i) (i32.const 2)) (i32.const 0))
+          (then
+            (local.set $sum (i32.add (local.get $sum) (local.get $i)))
+          )
+        )
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (br $continue)
+      )
+    )
+    (local.get $sum)
+  )
+)`;
+
+    try {
+        const wasmBytes = compileWAT(loopIfWAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const wasmInstance = new WebAssembly.Instance(wasmModule);
+        const fn = wasmInstance.exports.test as (max: number) => number;
+        const result = fn(10);
+        // Sum of even numbers 0,2,4,6,8 = 20
+        if (result === 20) {
+            console.log("✓ Test 10 passed: loop with if/then works");
+        } else {
+            console.error(`✗ Test 10 failed: expected 20, got ${result}`);
+        }
+    } catch (e) {
+        console.error("✗ Test 10 failed with error:", e);
+    }
+
+    // Test 11: Nested multi-line expression in memory operation
+    const nestedLoadWAT = `(module
+  (memory 1)
+  (func (export "test") (param $ptr i32) (param $i i32) (result i32)
+    (local $unit i32)
+    (local.set $unit
+      (i32.load (i32.add (local.get $ptr) 
+                        (i32.mul (local.get $i) (i32.const 12)))))
+    (local.get $unit)
+  )
+)`;
+
+    try {
+        const wasmBytes = compileWAT(nestedLoadWAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        console.log("✓ Test 11 passed: nested multi-line expression compiled");
+    } catch (e) {
+        console.error("✗ Test 11 failed with error:", e);
+    }
+
+    // Test 12: Memory64 with i64 pointers
+    const memory64WAT = `(module
+  (import "env" "memory" (memory i64 1))
+  (func (export "write_read") (param $ptr i64) (param $value i32) (result i32)
+    (i32.store (local.get $ptr) (local.get $value))
+    (i32.load (local.get $ptr))
+  )
+)`;
+
+    try {
+        const wasmBytes = compileWAT(memory64WAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const memory = new WebAssembly.Memory({ initial: BigInt(1), address: "i64" } as any);
+        const wasmInstance = new WebAssembly.Instance(wasmModule, { env: { memory } });
+        const fn = wasmInstance.exports.write_read as (ptr: bigint, value: number) => number;
+        const result = fn(BigInt(0), 42);
+        if (result === 42) {
+            console.log("✓ Test 12 passed: memory64 write/read with i64 pointers");
+        } else {
+            console.error(`✗ Test 12 failed: expected 42, got ${result}`);
+        }
+    } catch (e) {
+        console.error("✗ Test 12 failed with error:", e);
+    }
+
+    // Test 13: Memory64 with i64 address arithmetic
+    const memory64ArithmeticWAT = `(module
+  (import "env" "memory" (memory i64 1))
+  (func (export "store_at_offset") (param $base i64) (param $offset i32) (param $value i32)
+    (i32.store 
+      (i64.add (local.get $base) (i64.extend_i32_u (local.get $offset)))
+      (local.get $value))
+  )
+  (func (export "load_from_offset") (param $base i64) (param $offset i32) (result i32)
+    (i32.load 
+      (i64.add (local.get $base) (i64.extend_i32_u (local.get $offset))))
+  )
+)`;
+
+    try {
+        const wasmBytes = compileWAT(memory64ArithmeticWAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const memory = new WebAssembly.Memory({ initial: BigInt(1), address: "i64" } as any);
+        const wasmInstance = new WebAssembly.Instance(wasmModule, { env: { memory } });
+        const store = wasmInstance.exports.store_at_offset as (base: bigint, offset: number, value: number) => void;
+        const load = wasmInstance.exports.load_from_offset as (base: bigint, offset: number) => number;
+
+        store(BigInt(100), 8, 123);
+        const result = load(BigInt(100), 8);
+        if (result === 123) {
+            console.log("✓ Test 13 passed: memory64 with i64 address arithmetic");
+        } else {
+            console.error(`✗ Test 13 failed: expected 123, got ${result}`);
+        }
+    } catch (e) {
+        console.error("✗ Test 13 failed with error:", e);
+    }
+
+    // Test 14: Memory64 with array-like access pattern
+    const memory64ArrayWAT = `(module
+  (import "env" "memory" (memory i64 1))
+  (func (export "write_array") (param $basePtr i64) (param $index i32) (param $value i32)
+    (i32.store 
+      (i64.add (local.get $basePtr) 
+               (i64.extend_i32_u (i32.mul (local.get $index) (i32.const 4))))
+      (local.get $value))
+  )
+  (func (export "read_array") (param $basePtr i64) (param $index i32) (result i32)
+    (i32.load 
+      (i64.add (local.get $basePtr) 
+               (i64.extend_i32_u (i32.mul (local.get $index) (i32.const 4)))))
+  )
+  (func (export "sum_array") (param $basePtr i64) (param $count i32) (result i32)
+    (local $i i32)
+    (local $sum i32)
+    (local.set $i (i32.const 0))
+    (local.set $sum (i32.const 0))
+    (block $break
+      (loop $continue
+        (br_if $break (i32.ge_u (local.get $i) (local.get $count)))
+        (local.set $sum 
+          (i32.add (local.get $sum)
+            (i32.load 
+              (i64.add (local.get $basePtr) 
+                       (i64.extend_i32_u (i32.mul (local.get $i) (i32.const 4)))))))
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (br $continue)
+      )
+    )
+    (local.get $sum)
+  )
+)`;
+
+    try {
+        const wasmBytes = compileWAT(memory64ArrayWAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const memory = new WebAssembly.Memory({ initial: BigInt(1), address: "i64" } as any);
+        const wasmInstance = new WebAssembly.Instance(wasmModule, { env: { memory } });
+        const writeArray = wasmInstance.exports.write_array as (basePtr: bigint, index: number, value: number) => void;
+        const readArray = wasmInstance.exports.read_array as (basePtr: bigint, index: number) => number;
+        const sumArray = wasmInstance.exports.sum_array as (basePtr: bigint, count: number) => number;
+
+        // Write values [10, 20, 30, 40, 50]
+        writeArray(BigInt(1000), 0, 10);
+        writeArray(BigInt(1000), 1, 20);
+        writeArray(BigInt(1000), 2, 30);
+        writeArray(BigInt(1000), 3, 40);
+        writeArray(BigInt(1000), 4, 50);
+
+        // Verify reads
+        const val0 = readArray(BigInt(1000), 0);
+        const val2 = readArray(BigInt(1000), 2);
+        const val4 = readArray(BigInt(1000), 4);
+
+        // Sum array
+        const sum = sumArray(BigInt(1000), 5);
+
+        if (val0 === 10 && val2 === 30 && val4 === 50 && sum === 150) {
+            console.log("✓ Test 14 passed: memory64 array operations (sum = 150)");
+        } else {
+            console.error(`✗ Test 14 failed: val0=${val0}, val2=${val2}, val4=${val4}, sum=${sum}`);
+        }
+    } catch (e) {
+        console.error("✗ Test 14 failed with error:", e);
+    }
+
+    // Test 15: Memory64 large offset (beyond 4GB-like address)
+    const memory64LargeOffsetWAT = `(module
+  (import "env" "memory" (memory i64 1))
+  (func (export "test_large_ptr") (param $ptr i64) (param $value i32) (result i32)
+    (i32.store (local.get $ptr) (local.get $value))
+    (i32.load (local.get $ptr))
+  )
+)`;
+
+    try {
+        const wasmBytes = compileWAT(memory64LargeOffsetWAT);
+        const wasmModule = new WebAssembly.Module(wasmBytes);
+        const memory = new WebAssembly.Memory({ initial: BigInt(1), address: "i64" } as any);
+        const wasmInstance = new WebAssembly.Instance(wasmModule, { env: { memory } });
+        const fn = wasmInstance.exports.test_large_ptr as (ptr: bigint, value: number) => number;
+
+        // Test with a large address within first page (< 64KB)
+        const largeAddr = BigInt(60000);
+        const result = fn(largeAddr, 999);
+        if (result === 999) {
+            console.log("✓ Test 15 passed: memory64 with large address (60000)");
+        } else {
+            console.error(`✗ Test 15 failed: expected 999, got ${result}`);
+        }
+    } catch (e) {
+        console.error("✗ Test 15 failed with error:", e);
+    }
+
+    // Test 16: Instruction count
+    const totalInstructions = Object.keys(INSTRUCTION_MAP).length;
+    console.log(`\n✓ Total WebAssembly instructions loaded: ${totalInstructions}`);
+
+    console.log("\nWAT compiler tests complete!");
+}
+
+// Run tests
+//testWATCompiler().catch(console.error);