js-confuser-vm 0.0.2 → 0.0.3

package/dist/compiler.js

@@ -1,22 +1,19 @@
-import parser from "@babel/parser";
+import { parse } from "@babel/parser";
 import traverseImport from "@babel/traverse";
 import { generate } from "@babel/generator";
-import { readFileSync } from "fs";
-import { join } from "path";
 import { stripTypeScriptTypes } from "module";
 import JSON5 from "json5";
-import { choice, getRandomInt } from "./random.js";
 import { ok } from "assert";
 import { obfuscateRuntime } from "./runtimeObf.js";
-const traverse = traverseImport.default;
-const readVMRuntimeFile = () => {
-  try {
-    return readFileSync(join(import.meta.dirname, "./runtime.ts"), "utf-8");
-  } catch (e) {
-    return readFileSync(join(import.meta.dirname, "./runtime.js"), "utf-8");
-  }
-};
-const VM_RUNTIME = stripTypeScriptTypes(readVMRuntimeFile().split("@START")[1]);
+import { DEFAULT_OPTIONS } from "./options.js";
+import { resolveLabels } from "./transforms/resolveLabels.js";
+import { resolveConstants } from "./transforms/resolveContants.js";
+import { selfModifying } from "./transforms/selfModifying.js";
+import * as b from "./types.js";
+const traverse = traverseImport.default || traverseImport;
+const readVMRuntimeFile = () => "import { OP_ORIGINAL as OP } from \"./compiler.ts\";\nconst BYTECODE = [];\nconst MAIN_START_PC = 0;\nconst CONSTANTS = [];\nconst ENCODE_BYTECODE = false;\nconst TIMING_CHECKS = false;\n// The text above is not included in the compiled output - for type intellisense only\n// @START\n\nfunction decodeBytecode(s) {\n  if (!ENCODE_BYTECODE) return s;\n\n  var b =\n    typeof Buffer !== \"undefined\"\n      ? Buffer.from(s, \"base64\")\n      : Uint8Array.from(atob(s), function (c) {\n          return c.charCodeAt(0);\n        });\n  var r = new Int32Array(b.length / 4);\n  for (var i = 0; i < r.length; i++)\n    r[i] =\n      b[i * 4] |\n      (b[i * 4 + 1] << 8) |\n      (b[i * 4 + 2] << 16) |\n      (b[i * 4 + 3] << 24);\n  return r;\n}\n\n// Closure symbol\n// Used to tag shell functions so the VM can fast-path back to the\n// inner Closure instead of going through a sub-VM on internal calls.\nvar CLOSURE_SYM = Symbol(); // Nameless for obfuscation\n\n// Upvalue\n// While the outer frame is alive: reads/writes go to frame.locals[slot].\n// After the outer frame returns (closed): reads/writes hit this.value.\nfunction Upvalue(frame, slot) {\n  this._frame = frame;\n  this._slot = slot;\n  this._closed = false;\n  this._value = undefined;\n}\nUpvalue.prototype._read = function () {\n  return this._closed ? this._value : this._frame.locals[this._slot];\n};\nUpvalue.prototype._write = function (v) {\n  if (this._closed) this._value = v;\n  else this._frame.locals[this._slot] = v;\n};\nUpvalue.prototype._close = function () {\n  this._value = this._frame.locals[this._slot];\n  this._closed = true;\n};\n\n// Closure & Frame\nfunction Closure(fn) {\n  this.fn = fn;\n  this.upvalues = [];\n  this.prototype = {}; // <- default prototype object for \\`new\\`\n}\n\nfunction Frame(closure, returnPc, parent, thisVal ) {\n  this.closure = closure;\n  this.locals = new Array(closure.fn.localCount).fill(undefined);\n  this._pc = closure.fn.startPc; // <- initialize from fn descriptor\n  this._returnPc = returnPc; // pc to resume in parent frame after RETURN\n  this._parent = parent;\n  this.thisVal = thisVal !== undefined ? thisVal : undefined;\n  this._newObj = null; // <- set by NEW so RETURN can see it\n  this._handlerStack = []; // <- exception handlers pushed by TRY_SETUP\n}\n\n// VM\nfunction VM(bytecode, mainStartPc, constants, globals) {\n  this.bytecode = bytecode;\n  this.constants = constants;\n  this.globals = globals;\n  this._stack = [];\n  this._frameStack = [];\n  this._openUpvalues = []; // all currently open Upvalue objects across all frames\n\n  var mainFn = {\n    paramCount: 0,\n    localCount: 0,\n    startPc: mainStartPc, // <- where main begins\n  };\n  this._currentFrame = new Frame(new Closure(mainFn), null, null);\n}\n\nVM.prototype._push = function (v) {\n  this._stack.push(v);\n};\nVM.prototype._pop = function () {\n  return this._stack.pop();\n};\nVM.prototype.peek = function () {\n  return this._stack[this._stack.length - 1];\n};\n\n// Read one instruction word from this.bytecode at `pc`, unwrapping the\n// encoding so callers always get a plain { op, operand } pair regardless\n// of whether ENCODE_BYTECODE is active.\nVM.prototype.readWord = function (pc) {\n  var word = this.bytecode[pc];\n  if (ENCODE_BYTECODE) {\n    return { op: word & 0xff, operand: word >>> 8 };\n  } else {\n    return { op: word[0], operand: word[1] };\n  }\n};\n\nVM.prototype.captureUpvalue = function (frame, slot) {\n  // Reuse existing open upvalue for this frame+slot if one exists.\n  // This is what makes two closures share the same mutable cell.\n  for (var i = 0; i < this._openUpvalues.length; i++) {\n    var uv = this._openUpvalues[i];\n    if (uv._frame === frame && uv._slot === slot) return uv;\n  }\n  var uv = new Upvalue(frame, slot);\n  this._openUpvalues.push(uv);\n  return uv;\n};\n\nVM.prototype._closeUpvaluesFor = function (frame) {\n  // Called on RETURN - close every upvalue that was pointing into this frame.\n  // After this, closures that captured from the frame read from upvalue.value.\n  this._openUpvalues = this._openUpvalues.filter(function (uv) {\n    if (uv._frame === frame) {\n      uv._close();\n      return false;\n    }\n    return true;\n  });\n};\n\nVM.prototype.run = function () {\n  var now = () => {\n    return performance.now();\n  };\n\n  var t = now();\n\n  while (true) {\n    var frame = this._currentFrame;\n    var bc = this.bytecode;\n    if (frame._pc >= bc.length) break;\n\n    var op, operand;\n    var word = this.readWord(frame._pc++);\n\n    op = word.op;\n    operand = word.operand;\n\n    // console.log(frame._pc - 1, op, operand);\n\n    // Debugging protection\n    if (TIMING_CHECKS) {\n      var t2 = now();\n      var isTamper = t2 - t > 1000;\n      t = t2;\n      if (isTamper) {\n        op = OP.POP;\n      }\n    }\n\n    try {\n      /* @SWITCH */\n      switch (op) {\n        case OP.LOAD_CONST:\n          this._push(this.constants[operand]);\n          break;\n\n        case OP.LOAD_INT:\n          this._push(operand);\n          break;\n\n        case OP.LOAD_LOCAL:\n          this._push(frame.locals[operand]);\n          break;\n\n        case OP.STORE_LOCAL:\n          frame.locals[operand] = this._pop();\n          break;\n\n        case OP.LOAD_GLOBAL:\n          this._push(this.globals[this.constants[operand]]);\n          break;\n\n        case OP.STORE_GLOBAL:\n          this.globals[this.constants[operand]] = this._pop();\n          break;\n\n        case OP.GET_PROP: {\n          // Stack: [..., obj, key] -> [..., obj, obj[key]]\n          // obj is PEEKED (not popped) - CALL_METHOD needs it as receiver\n          var key = this._pop();\n          var obj = this.peek();\n          this._push(obj[key]);\n          break;\n        }\n\n        case OP.ADD: {\n          var b = this._pop();\n          this._push(this._pop() + b);\n          break;\n        }\n        case OP.SUB: {\n          var b = this._pop();\n          this._push(this._pop() - b);\n          break;\n        }\n        case OP.MUL: {\n          var b = this._pop();\n          this._push(this._pop() * b);\n          break;\n        }\n        case OP.DIV: {\n          var b = this._pop();\n          this._push(this._pop() / b);\n          break;\n        }\n        case OP.MOD: {\n          var b = this._pop();\n          this._push(this._pop() % b);\n          break;\n        }\n        case OP.BAND: {\n          var b = this._pop();\n          this._push(this._pop() & b);\n          break;\n        }\n        case OP.BOR: {\n          var b = this._pop();\n          this._push(this._pop() | b);\n          break;\n        }\n        case OP.BXOR: {\n          var b = this._pop();\n          this._push(this._pop() ^ b);\n          break;\n        }\n        case OP.SHL: {\n          var b = this._pop();\n          this._push(this._pop() << b);\n          break;\n        }\n        case OP.SHR: {\n          var b = this._pop();\n          this._push(this._pop() >> b);\n          break;\n        }\n        case OP.USHR: {\n          var b = this._pop();\n          this._push(this._pop() >>> b);\n          break;\n        }\n\n        case OP.LT: {\n          var b = this._pop();\n          this._push(this._pop() < b);\n          break;\n        }\n        case OP.GT: {\n          var b = this._pop();\n          this._push(this._pop() > b);\n          break;\n        }\n        case OP.EQ: {\n          var b = this._pop();\n          this._push(this._pop() === b);\n          break;\n        }\n\n        case OP.LTE: {\n          var b = this._pop();\n          this._push(this._pop() <= b);\n          break;\n        }\n        case OP.GTE: {\n          var b = this._pop();\n          this._push(this._pop() >= b);\n          break;\n        }\n        case OP.NEQ: {\n          var b = this._pop();\n          this._push(this._pop() !== b);\n          break;\n        }\n        case OP.LOOSE_EQ: {\n          var b = this._pop();\n          this._push(this._pop() == b);\n          break;\n        }\n        case OP.LOOSE_NEQ: {\n          var b = this._pop();\n          this._push(this._pop() != b);\n          break;\n        }\n\n        case OP.IN: {\n          var b = this._pop();\n          this._push(this._pop() in b);\n          break;\n        }\n\n        case OP.INSTANCEOF: {\n          var ctor = this._pop();\n          var obj = this._pop();\n          if (typeof ctor === \"function\") {\n            // Native constructor (e.g. Array, Date) - native instanceof is fine\n            this._push(obj instanceof ctor);\n          } else {\n            // VM Closure - ctor.prototype was set by MAKE_CLOSURE / user assignment.\n            // Walk obj's prototype chain looking for identity with ctor.prototype.\n            var proto = ctor.prototype; // the .prototype property on the Closure\n            var target = Object.getPrototypeOf(obj);\n            var result = false;\n            while (target !== null) {\n              if (target === proto) {\n                result = true;\n                break;\n              }\n              target = Object.getPrototypeOf(target);\n            }\n            this._push(result);\n          }\n          break;\n        }\n\n        case OP.UNARY_NEG:\n          this._push(-this._pop());\n          break;\n        case OP.UNARY_POS:\n          this._push(this._pop());\n          break;\n        case OP.UNARY_NOT:\n          this._push(!this._pop());\n          break;\n        case OP.UNARY_BITNOT:\n          this._push(~this._pop());\n          break;\n        case OP.TYPEOF:\n          this._push(typeof this._pop());\n          break;\n        case OP.VOID:\n          this._pop();\n          this._push(undefined);\n          break;\n\n        case OP.TYPEOF_SAFE: {\n          // operand is a const index holding the variable name string.\n          // Mimics JS semantics: typeof undeclaredVar === \"undefined\" (no throw).\n          var name = this._pop(); // LOAD_CONST pushed the name - consume it\n          var val = Object.prototype.hasOwnProperty.call(this.globals, name)\n            ? this.globals[name]\n            : undefined;\n          this._push(typeof val);\n          break;\n        }\n\n        case OP.JUMP:\n          frame._pc = operand;\n          break;\n\n        case OP.JUMP_IF_FALSE:\n          if (!this._pop()) frame._pc = operand;\n          break;\n\n        case OP.JUMP_IF_TRUE_OR_POP:\n          // || semantics: if truthy, we're done - leave value, jump over RHS.\n          // If falsy, discard it and fall through to evaluate RHS.\n          if (this.peek()) {\n            frame._pc = operand;\n          } else {\n            this._pop();\n          }\n          break;\n\n        case OP.JUMP_IF_FALSE_OR_POP:\n          // && semantics: if falsy, we're done - leave value, jump over RHS.\n          // If truthy, discard it and fall through to evaluate RHS.\n          if (!this.peek()) {\n            frame._pc = operand;\n          } else {\n            this._pop();\n          }\n          break;\n\n        case OP.MAKE_CLOSURE: {\n          // operand = startPc: absolute index of the function body's first instruction.\n          // Metadata is read from the value stack (pushed by _emitClosureMetadata).\n          // Stack layout when we arrive here (top is rightmost):\n          //   [isLocal_0, idx_0, ..., isLocal_N-1, idx_N-1, uvCount, localCount, paramCount]\n          var startPc = operand;\n          var paramCount = this._pop();\n          var localCount = this._pop();\n          var uvCount = this._pop();\n\n          // Upvalues were pushed in order 0..N-1 so we pop them in reverse.\n          var uvDescs = new Array(uvCount);\n          for (var i = uvCount - 1; i >= 0; i--) {\n            var uvIndex = this._pop();\n            var isLocalRaw = this._pop();\n            uvDescs[i] = { isLocal: isLocalRaw, _index: uvIndex };\n          }\n\n          var fn = {\n            paramCount: paramCount,\n            localCount: localCount,\n            startPc: startPc,\n            upvalueDescriptors: uvDescs,\n          };\n\n          var closure = new Closure(fn);\n          for (var i = 0; i < uvDescs.length; i++) {\n            var uvd = uvDescs[i];\n            if (uvd.isLocal) {\n              // Capture directly from current frame's local slot\n              closure.upvalues.push(this.captureUpvalue(frame, uvd._index));\n            } else {\n              // Relay - take upvalue from the enclosing closure's list\n              closure.upvalues.push(frame.closure.upvalues[uvd._index]);\n            }\n          }\n          // Wrap in a native callable shell so host code (array methods,\n          // test assertions, setTimeout, etc.) can invoke VM closures.\n          // CLOSURE_SYM lets VM-internal CALL/NEW bypass the sub-VM entirely.\n          var self = this;\n          var shell = (function (c) {\n            return function () {\n              var args = Array.prototype.slice.call(arguments);\n              var sub = new VM(self.bytecode, 0, self.constants, self.globals);\n              // Sloppy-mode: null/undefined thisArg \u2192 global object\n              var f = new Frame(\n                c,\n                null,\n                null,\n                this == null ? self.globals : this,\n              );\n              for (var i = 0; i < args.length; i++) f.locals[i] = args[i];\n              f.locals[c.fn.paramCount] = args;\n              sub._currentFrame = f;\n              return sub.run();\n            };\n          })(closure);\n          shell[CLOSURE_SYM] = closure;\n          shell.prototype = closure.prototype; // unified prototype for new/instanceof\n          this._push(shell);\n          break;\n        }\n\n        case OP.DATA:\n          // Should never appear in compiled output (reserved opcode slot).\n          throw new Error(\"DATA opcode executed at pc \" + (frame._pc - 1));\n\n        case OP.LOAD_UPVALUE:\n          this._push(frame.closure.upvalues[operand]._read());\n          break;\n\n        case OP.STORE_UPVALUE:\n          frame.closure.upvalues[operand]._write(this._pop());\n          break;\n\n        case OP.BUILD_ARRAY: {\n          // Pop \\`operand\\` values off the stack in reverse, assemble array.\n          var elems = this._stack.splice(this._stack.length - operand);\n          this._push(elems);\n          break;\n        }\n\n        case OP.BUILD_OBJECT: {\n          // Stack has: key0, val0, key1, val1 ... keyN, valN  (pushed left->right)\n          // Pop all pairs and build the object.\n          var pairs = this._stack.splice(this._stack.length - operand * 2);\n          var o = {};\n          for (var i = 0; i < pairs.length; i += 2) {\n            o[pairs[i]] = pairs[i + 1]; // key at even index, val at odd\n          }\n          this._push(o);\n          break;\n        }\n        case OP.SET_PROP: {\n          // Stack: [..., obj, key, val]\n          // Leaves val on stack - assignment is an expression in JS.\n          var val = this._pop();\n          var key = this._pop();\n          var obj = this._pop();\n          // Reflect.set performs [[Set]] without throwing on failure,\n          // correctly simulating sloppy-mode assignment from a strict-mode host\n          // (output.js is an ES module). This also properly invokes inherited\n          // or prototype-chain setter functions.\n          Reflect.set(obj, key, val);\n          this._push(val); // assignment expression evaluates to the assigned value\n          break;\n        }\n        case OP.GET_PROP_COMPUTED: {\n          // Stack: [..., obj, key]  - key is a runtime value (nums[i])\n          // Mirrors GET_PROP but pops the key that was pushed dynamically.\n          var key = this._pop();\n          var obj = this._pop();\n          this._push(obj[key]);\n          break;\n        }\n        case OP.DELETE_PROP: {\n          var key = this._pop();\n          var obj = this._pop();\n          this._push(delete obj[key]);\n          break;\n        }\n\n        case OP.CALL: {\n          var args = this._stack.splice(this._stack.length - operand);\n          var callee = this._pop();\n          if (callee && callee[CLOSURE_SYM]) {\n            // VM closure - run directly in this VM, no sub-VM overhead\n            var c = callee[CLOSURE_SYM];\n            // Sloppy-mode: plain function call \u2192 global object as this\n            var f = new Frame(c, frame._pc, frame, this.globals);\n            for (var i = 0; i < args.length; i++) f.locals[i] = args[i];\n            f.locals[c.fn.paramCount] = args;\n            this._frameStack.push(this._currentFrame);\n            this._currentFrame = f;\n          } else {\n            // Native function\n            this._push(callee.apply(null, args));\n          }\n          break;\n        }\n\n        case OP.CALL_METHOD: {\n          var args = this._stack.splice(this._stack.length - operand);\n          var callee = this._pop();\n          var receiver = this._pop(); // left on stack by GET_PROP\n          if (callee && callee[CLOSURE_SYM]) {\n            // VM closure - run directly in this VM with receiver as this\n            var c = callee[CLOSURE_SYM];\n            var f = new Frame(c, frame._pc, frame, receiver);\n            for (var i = 0; i < args.length; i++) f.locals[i] = args[i];\n            f.locals[c.fn.paramCount] = args;\n            this._frameStack.push(this._currentFrame);\n            this._currentFrame = f;\n          } else {\n            // Native method\n            this._push(callee.apply(receiver, args));\n          }\n          break;\n        }\n\n        case OP.LOAD_THIS:\n          this._push(frame.thisVal);\n          break;\n\n        case OP.NEW: {\n          var args = this._stack.splice(this._stack.length - operand);\n          var callee = this._pop();\n          if (callee && callee[CLOSURE_SYM]) {\n            // VM closure constructor - prototype is unified via shell.prototype = closure.prototype\n            var c = callee[CLOSURE_SYM];\n            var newObj = Object.create(c.prototype || null);\n            var f = new Frame(c, frame._pc, frame, newObj);\n            f._newObj = newObj;\n            for (var i = 0; i < args.length; i++) f.locals[i] = args[i];\n            f.locals[c.fn.paramCount] = args;\n            this._frameStack.push(this._currentFrame);\n            this._currentFrame = f;\n          } else {\n            // Native constructor (e.g. new Error(), new Date()).\n            // Reflect.construct is required - Object.create+apply does NOT set\n            // internal slots ([[NumberData]], [[StringData]], etc.) for built-ins.\n            this._push(Reflect.construct(callee, args));\n          }\n          break;\n        }\n\n        case OP.RETURN: {\n          var retVal = this._pop();\n          this._closeUpvaluesFor(frame); // must happen before frame is abandoned\n          if (this._frameStack.length === 0) return retVal;\n\n          // new-call rule: primitive return -> discard, use the constructed object instead\n          if (frame._newObj !== null) {\n            if (typeof retVal !== \"object\" || retVal === null)\n              retVal = frame._newObj;\n          }\n\n          this._currentFrame = this._frameStack.pop();\n          this._push(retVal);\n          break;\n        }\n\n        case OP.POP:\n          this._pop();\n          break;\n\n        case OP.DUP:\n          this._push(this.peek());\n          break;\n\n        case OP.THROW:\n          throw this._pop();\n\n        case OP.FOR_IN_SETUP: {\n          // Pop the object; build an ordered list of all enumerable own+inherited\n          // string keys by walking the prototype chain manually.\n          // Uses getOwnPropertyNames (includes non-enumerable) + descriptor check,\n          // so we never rely on Object.keys() and we handle inheritance correctly.\n          var obj = this._pop();\n          var keys = [];\n          if (obj !== null && obj !== undefined) {\n            var seen = Object.create(null);\n            var cur = Object(obj); // box primitives\n            while (cur !== null) {\n              var ownNames = Object.getOwnPropertyNames(cur);\n              for (var i = 0; i < ownNames.length; i++) {\n                var k = ownNames[i];\n                if (!(k in seen)) {\n                  seen[k] = true;\n                  var propDesc = Object.getOwnPropertyDescriptor(cur, k);\n                  if (propDesc && propDesc.enumerable) {\n                    keys.push(k);\n                  }\n                }\n              }\n              cur = Object.getPrototypeOf(cur);\n            }\n          }\n          this._push({ _keys: keys, i: 0 });\n          break;\n        }\n\n        case OP.FOR_IN_NEXT: {\n          // operand = jump target for the done case.\n          // Pop the iterator; if exhausted jump to exit, otherwise push next key.\n          var iter = this._pop();\n          if (iter.i >= iter._keys.length) {\n            frame._pc = operand;\n          } else {\n            this._push(iter._keys[iter.i++]);\n          }\n          break;\n        }\n\n        case OP.PATCH: {\n          // Writes at operand the bytecode[arg1:arg2]\n          var destPc = operand;\n          var instructions = this.bytecode.slice(this._pop(), this._pop());\n\n          for (var i = 0; i < instructions.length; i++) {\n            this.bytecode[destPc + i] = instructions[i];\n          }\n\n          break;\n        }\n\n        case OP.TRY_SETUP: {\n          // Push an exception handler record onto the current frame.\n          // Saves: catch PC (operand), current stack depth, current frame-stack depth.\n          // If an exception is thrown before TRY_END fires, the VM jumps here.\n          frame._handlerStack.push({\n            handlerPc: operand,\n            stackDepth: this._stack.length,\n            frameStackDepth: this._frameStack.length,\n          });\n          break;\n        }\n\n        case OP.TRY_END: {\n          // Normal exit from a try block \u2014 disarm the exception handler.\n          frame._handlerStack.pop();\n          break;\n        }\n\n        case OP.DEFINE_GETTER: {\n          // Stack: [..., obj, key, getterFn]\n          // Pops all three; defines an enumerable, configurable getter on obj.\n          // If a setter was already defined for this key, it is preserved.\n          var getterFn = this._pop();\n          var key = this._pop();\n          var obj = this._pop();\n          var existingDesc = Object.getOwnPropertyDescriptor(obj, key);\n          var getDesc                     = {\n            get: getterFn,\n            configurable: true,\n            enumerable: true,\n          };\n          if (existingDesc && typeof existingDesc.set === \"function\") {\n            getDesc.set = existingDesc.set;\n          }\n          Object.defineProperty(obj, key, getDesc);\n          break;\n        }\n\n        case OP.DEFINE_SETTER: {\n          // Stack: [..., obj, key, setterFn]\n          // Pops all three; defines an enumerable, configurable setter on obj.\n          // If a getter was already defined for this key, it is preserved.\n          var setterFn = this._pop();\n          var key = this._pop();\n          var obj = this._pop();\n          var existingDesc = Object.getOwnPropertyDescriptor(obj, key);\n          var setDesc                     = {\n            set: setterFn,\n            configurable: true,\n            enumerable: true,\n          };\n          if (existingDesc && typeof existingDesc.get === \"function\") {\n            setDesc.get = existingDesc.get;\n          }\n          Object.defineProperty(obj, key, setDesc);\n          break;\n        }\n\n        case OP.DEBUGGER: {\n          debugger;\n          break;\n        }\n\n        default:\n          throw new Error(\n            \"Unknown opcode: \" + op + \" at pc \" + (frame._pc - 1),\n          );\n      }\n    } catch (err) {\n      // Exception handler unwinding (CPython-style frame walk, Lua-style upvalue close).\n      // Walk from the current frame upward until we find a frame that has an open\n      // exception handler (TRY_SETUP without a matching TRY_END).\n      // For every frame we abandon along the way, close its captured upvalues.\n      var handledFrame = null;\n      var searchFrame = this._currentFrame;\n      while (true) {\n        if (searchFrame._handlerStack.length > 0) {\n          handledFrame = searchFrame;\n          break;\n        }\n        // No handler in this frame \u2014 abandon it and walk up.\n        this._closeUpvaluesFor(searchFrame);\n        if (this._frameStack.length === 0) break;\n        searchFrame = this._frameStack.pop();\n        this._currentFrame = searchFrame;\n      }\n\n      if (!handledFrame) throw err; // no handler anywhere \u2014 propagate to host\n\n      var h = handledFrame._handlerStack.pop();\n      // Restore the VM value stack to the depth recorded at TRY_SETUP time,\n      // then push the caught exception so the catch binding can store it.\n      this._stack.length = h.stackDepth;\n      this._push(err);\n      // Discard any call-frames that were pushed inside the try body\n      // (functions called from within the try block that are still live).\n      this._frameStack.length = h.frameStackDepth;\n      // Jump to the catch block.\n      handledFrame._pc = h.handlerPc;\n      this._currentFrame = handledFrame;\n    }\n  }\n};\n\n// Boot\nvar globals      = {}; // global object for globals\n\n// Always pull built-ins from globalThis so eval() scoping can't shadow them\n// with a local `window` variable (e.g. the test harness fake window).\nfor (var k of Object.getOwnPropertyNames(globalThis)) {\n  globals[k] = globalThis[k];\n}\n// If a window object is in scope (browser or test harness), capture it\n// explicitly so VM code can read/write window.TEST_OUTPUT etc.\nif (typeof window !== \"undefined\") {\n  globals[\"window\"] = window;\n}\n\n// Transfer common primitives\nglobals.undefined = undefined;\nglobals.Infinity = Infinity;\nglobals.NaN = NaN;\n\nvar vm = new VM(decodeBytecode(BYTECODE), MAIN_START_PC, CONSTANTS, globals);\nvm.run();\n";
+const VM_RUNTIME = readVMRuntimeFile().split("@START")[1];
+export const SOURCE_NODE_SYM = Symbol("SOURCE_NODE"); // Attach source node location to pseudo bytecode instructions
 
 // Opcodes
 export const OP_ORIGINAL = {
@@ -132,33 +129,33 @@ export const OP_ORIGINAL = {
   // operand=exit_pc; pop iter; if done->jump; else push next key
 
   // Self-modifying bytecode
-  PATCH: 56 // pop destPc; constants[operand]=word[]; write words into bytecode[destPc..]
+  PATCH: 56,
+  // pop destPc; constants[operand]=word[]; write words into bytecode[destPc..]
+
+  // Try-Catch
+  TRY_SETUP: 57,
+  // operand = catch_pc; push exception handler onto frame._handlerStack
+  TRY_END: 58,
+  // pop exception handler (normal exit from try body)
+
+  // Getter / Setter (ES5 object literal accessor syntax)
+  DEFINE_GETTER: 59,
+  // pop fn, pop key, pop obj -> Object.defineProperty(obj, key, {get: fn})
+  DEFINE_SETTER: 60,
+  // pop fn, pop key, pop obj -> Object.defineProperty(obj, key, {set: fn})
+
+  DEBUGGER: 61,
+  // for dev/testing -- emits a "debugger" statement with a comment of the original source location
+
+  // Push the raw integer operand directly onto the stack (no constant pool lookup).
+  // Identical pipeline to JUMP ops: {type:"label"} pseudo-operands resolve to a
+  // raw PC number that becomes the operand, which is pushed as-is at runtime.
+  LOAD_INT: 62,
+  // Reserved / unused opcode slot (formerly the inline DATA header word).
+  // Kept to avoid renumbering; should never appear in compiled output.
+  DATA: 63
 };
 
-// Constant Pool
-// Primitives (string/number/bool) are interned (deduped).
-// Object entries (fn descriptors) are always appended - no dedup.
-class ConstantPool {
-  constructor() {
-    this.items = []; // ordered pool entries
-    this._index = new Map(); // primitive dedup map
-  }
-  intern(val) {
-    // Only intern primitives -- objects must use addObject()
-    const key = `${typeof val}:${val}`;
-    if (this._index.has(key)) return this._index.get(key);
-    const idx = this.items.length;
-    this.items.push(val);
-    this._index.set(key, idx);
-    return idx;
-  }
-  addObject(obj) {
-    const idx = this.items.length;
-    this.items.push(obj);
-    return idx;
-  }
-}
-
 // Scope
 // Each function call gets its own Scope. Locals are resolved to
 // numeric slots at compile time -- zero name lookups at runtime.
@@ -222,17 +219,25 @@ class FnContext {
 }
 
 // Compiler
-class Compiler {
-  constructor(options) {
+export class Compiler {
+  emit(bc, instr, node) {
+    bc.push(instr);
+    instr[SOURCE_NODE_SYM] = node;
+  }
+
+  // DO NOT USE THIS KEY UNLESS YOU ARE "RESOLVE CONSTANTS"
+  // CONSTANTS DURING COMPILATION MUST BE USED BY REFERENCE WITH b.constantOperand("myConstantHere")
+
+  constructor(options = DEFAULT_OPTIONS) {
     this.options = options;
-    this.constants = new ConstantPool();
     this.fnDescriptors = []; // populated in pass 1
     this.bytecode = [];
     this.mainStartPc = 0;
     this._currentCtx = null; // FnContext of the function being compiled, null at top-level
-    this._loopStack = []; // { breakJumps: number[], continueJumps: number[] } per active loop
+    this._loopStack = []; // per active loop/switch/block/try
     this._pendingLabel = null;
     this._forInCount = 0; // counter for synthetic for-in iterator global names
+    this._labelCount = 0; // monotonically increasing counter for unique label names
 
     this.serializer = new Serializer(this);
     this.OP = {};
@@ -253,7 +258,14 @@ class Compiler {
 
     // Reverse map for comment generation
     this.OP_NAME = Object.fromEntries(Object.entries(this.OP).map(([k, v]) => [v, k]));
-    this.JUMP_OPS = new Set([this.OP.JUMP, this.OP.JUMP_IF_FALSE, this.OP.JUMP_IF_TRUE_OR_POP, this.OP.JUMP_IF_FALSE_OR_POP, this.OP.FOR_IN_NEXT]);
+    this.JUMP_OPS = new Set([this.OP.JUMP, this.OP.JUMP_IF_FALSE, this.OP.JUMP_IF_TRUE_OR_POP, this.OP.JUMP_IF_FALSE_OR_POP, this.OP.FOR_IN_NEXT, this.OP.TRY_SETUP // catch_pc operand needs offset adjustment like jump targets
+    ]);
+  }
+
+  // Generate a globally unique label string with an optional hint for readability.
+  _makeLabel(hint = "") {
+    var id = this._labelCount++;
+    return `${hint || "L"}_${id}`;
   }
 
   // Variable resolution
@@ -297,7 +309,7 @@ class Compiler {
 
   // Entry point
   compile(source) {
-    const ast = parser.parse(source, {
+    const ast = parse(source, {
       sourceType: "script"
     });
     return this.compileAST(ast);
@@ -317,21 +329,32 @@ class Compiler {
 
     // Pass 2 -- compile top-level statements into BYTECODE.
     this._compileMain(ast.program.body);
-    return {
-      bytecode: this.bytecode,
-      mainStartPc: this.mainStartPc
-    };
+    return this.bytecode;
   }
 
   // Function Declaration
 
   _compileFunctionDecl(node) {
+    // Reserve a slot in fnDescriptors NOW, before compiling the body, so that
+    // any nested _compileFunctionDecl calls see the correct .length and get a
+    // distinct _fnIdx.  The placeholder object is mutated in-place below once
+    // the body and header are ready.
+    var fnIdx = this.fnDescriptors.length;
+    const entryLabel = this._makeLabel(`fn_${fnIdx}`);
+    var desc = {}; // placeholder — filled in after compilation
+    this.fnDescriptors.push(desc);
+
     // Create a context whose parent is whatever we're currently compiling.
     // This is what lets _resolve cross function boundaries correctly.
     const ctx = new FnContext(this, this._currentCtx);
     const savedCtx = this._currentCtx;
     this._currentCtx = ctx;
 
+    // Isolate the loop stack so that try/loop entries from the outer scope
+    // don't cause spurious TRY_END / extra jumps inside this function body.
+    const savedLoopStack = this._loopStack;
+    this._loopStack = [];
+
     // Params occupy the first N local slots (args are copied in on CALL)
     for (const param of node.params) {
       let identifier = param.type === "AssignmentPattern" ? param.left : param;
@@ -346,55 +369,70 @@ class Compiler {
     // Pass 2: emit default-value guards at top of fn body
     // Mirrors what JS engines do: if the caller passed undefined (or
     // nothing), evaluate the default expression and overwrite the slot.
-    // Default expressions are full expressions, so f(x = a + b) and
-    // f(x = foo()) both work correctly.
     for (const param of node.params) {
       if (param.type !== "AssignmentPattern") continue;
       const slot = ctx.scope._locals.get(param.left.name);
+      const skipLabel = this._makeLabel("param_skip");
 
       // if (param === undefined) param = <default expr>
-      ctx.bc.push([this.OP.LOAD_LOCAL, slot]);
-      ctx.bc.push([this.OP.LOAD_CONST, this.constants.intern(undefined)]);
-      ctx.bc.push([this.OP.EQ]);
-      ctx.bc.push([this.OP.JUMP_IF_FALSE, 0]);
-      const skipIdx = ctx.bc.length - 1;
+      this.emit(ctx.bc, [this.OP.LOAD_LOCAL, slot], param);
+      this.emit(ctx.bc, [this.OP.LOAD_CONST, b.constantOperand(undefined)], param);
+      this.emit(ctx.bc, [this.OP.EQ], param);
+      this.emit(ctx.bc, [this.OP.JUMP_IF_FALSE, {
+        type: "label",
+        label: skipLabel
+      }], param);
       this._compileExpr(param.right, ctx.scope, ctx.bc); // eval default
-      ctx.bc.push([this.OP.STORE_LOCAL, slot]);
-      ctx.bc[skipIdx][1] = ctx.bc.length; // patch skip jump
+      this.emit(ctx.bc, [this.OP.STORE_LOCAL, slot], param);
+      this.emit(ctx.bc, [null, {
+        type: "defineLabel",
+        label: skipLabel
+      }], param);
     }
     for (const stmt of node.body.body) {
       this._compileStatement(stmt, ctx.scope, ctx.bc);
     }
 
     // If we fall off the end of the function, implicitly return undefined.
-    ctx.bc.push([this.OP.LOAD_CONST, this.constants.intern(undefined)]);
-    ctx.bc.push([this.OP.RETURN]);
+    this.emit(ctx.bc, [this.OP.LOAD_CONST, b.constantOperand(undefined)], node);
+    this.emit(ctx.bc, [this.OP.RETURN], node);
     this._currentCtx = savedCtx; // restore before touching fnDescriptors
-
-    var fnIdx = this.fnDescriptors.length;
-    node._fnIdx = fnIdx; // for error messages
-
-    const desc = {
-      name: node.id?.name || "<anonymous>",
-      paramCount: node.params.length,
-      localCount: ctx.scope.localCount,
-      upvalueDescriptors: ctx.upvalues.map(u => ({
-        isLocal: u.isLocal,
-        _index: u.index
-      })),
-      bytecode: ctx.bc,
-      // Indices assigned after pushing into the pool
-      _fnIdx: this.fnDescriptors.length,
-      _constIdx: null
-    };
-    this.fnDescriptors.push(desc);
-    desc._constIdx = this.constants.addObject(desc); // object entry, no dedup
+    this._loopStack = savedLoopStack;
+    node._fnIdx = fnIdx;
+
+    // Fill the placeholder that was reserved at the top of this function.
+    // Metadata (paramCount, localCount, upvalues) is stored on desc and emitted
+    // as LOAD_INT instructions onto the value stack at each MAKE_CLOSURE call
+    // site — the runtime reads them from the stack, not from DATA words.
+    desc.name = node.id?.name || "<anonymous>";
+    desc.entryLabel = entryLabel;
+    desc.bytecode = ctx.bc;
+    desc._fnIdx = fnIdx;
+    desc.paramCount = node.params.length;
+    desc.localCount = ctx.scope.localCount;
+    desc.upvalues = ctx.upvalues.slice();
     return desc;
   }
 
+  // Emit LOAD_INT instructions that push closure metadata onto the value stack
+  // immediately before a MAKE_CLOSURE instruction.  The runtime pops these
+  // values in MAKE_CLOSURE instead of reading DATA words from bytecode.
+  //
+  // Stack layout when MAKE_CLOSURE executes (top is rightmost):
+  //   [isLocal_0, idx_0, ..., isLocal_N-1, idx_N-1, uvCount, localCount, paramCount]
+  _emitClosureMetadata(desc, node, bc) {
+    // Push each upvalue descriptor in order; runtime pops them in reverse.
+    for (const uv of desc.upvalues) {
+      this.emit(bc, [this.OP.LOAD_INT, uv.isLocal ? 1 : 0], node);
+      this.emit(bc, [this.OP.LOAD_INT, uv.index], node);
+    }
+    this.emit(bc, [this.OP.LOAD_INT, desc.upvalues.length], node);
+    this.emit(bc, [this.OP.LOAD_INT, desc.localCount], node);
+    this.emit(bc, [this.OP.LOAD_INT, desc.paramCount], node);
+  }
+
   // Main (top-level)
   _compileMain(body) {
-    this.mainStartPc = 0; // ← record main's entry point
     const bc = this.bytecode;
 
     // Hoist all FunctionDeclarations: MAKE_CLOSURE -> STORE_GLOBAL
@@ -402,9 +440,13 @@ class Compiler {
     for (const node of body) {
       if (node.type !== "FunctionDeclaration") continue;
       const desc = this.fnDescriptors.find(d => d._fnIdx === node._fnIdx);
-      const nameIdx = this.constants.intern(node.id.name);
-      bc.push([this.OP.MAKE_CLOSURE, desc._constIdx]);
-      bc.push([this.OP.STORE_GLOBAL, nameIdx]);
+      const nameRef = b.constantOperand(node.id.name);
+      this._emitClosureMetadata(desc, node, bc);
+      this.emit(bc, [this.OP.MAKE_CLOSURE, {
+        type: "label",
+        label: desc.entryLabel
+      }], node);
+      this.emit(bc, [this.OP.STORE_GLOBAL, nameRef], node);
     }
 
     // Compile everything else in order
@@ -412,49 +454,26 @@ class Compiler {
       if (node.type === "FunctionDeclaration") continue;
       this._compileStatement(node, null, bc); // null scope -> global context
     }
-    bc.push([this.OP.RETURN]); // end program
+    this.emit(bc, [this.OP.RETURN], null); // end program
 
-    // Now that main is compiled, we can append all the function bodies at the end of the bytecode.
+    // Append all function bodies. Each function's entryLabel (already generated
+    // in _compileFunctionDecl) points directly to the first body instruction;
+    // metadata is pushed onto the stack at each call site, not stored inline.
     for (const descriptor of this.fnDescriptors) {
-      descriptor.startPc = this.bytecode.length;
-      descriptor.bytecode.push([this.OP.RETURN]); // ensure every function ends with RETURN
-
-      if (this.options.selfModifying) {
-        // Preamble is 2 instructions: LOAD_CONST(destPc) + PATCH(bodyConst)
-        // Real body starts immediately after the preamble.
-        const bodyPc = descriptor.startPc + 2;
-
-        // Build real body with jump targets resolved from bodyPc as the base.
-        const realBodyInstrs = descriptor.bytecode.map(instr => this._offsetJump(instr, bodyPc));
-
-        // Pack each instruction into a 32-bit word and store as a constant.
-        // The PATCH handler will write these words directly into this.bytecode.
-        const realBodyWords = this.serializer._serializeBytecode(realBodyInstrs);
-        const bodyConstIdx = this.constants.addObject(realBodyWords);
-
-        // Emit preamble: push destination PC, then PATCH.
-        const destPcConstIdx = this.constants.intern(bodyPc);
-        this.bytecode.push([this.OP.LOAD_CONST, destPcConstIdx]);
-        this.bytecode.push([this.OP.PATCH, bodyConstIdx]);
-
-        // Garbage fill -- same length as real body, never executed (PATCH fires first).
-        for (let i = 0; i < realBodyInstrs.length; i++) {
-          this.bytecode.push([choice(Object.values(this.OP)), getRandomInt(0, 255)]);
-        }
-      } else {
-        for (const instr of descriptor.bytecode) {
-          this.bytecode.push(this._offsetJump(instr, descriptor.startPc));
-        }
+      this.bytecode.push([null, {
+        type: "defineLabel",
+        label: descriptor.entryLabel
+      }]);
+      for (const instr of descriptor.bytecode) {
+        this.bytecode.push(instr);
       }
     }
     if (this.bytecode.length > 0xffffff) throw new Error(`Program too large: ${this.bytecode.length} instructions, max 16,777,215`);
-    if (this.constants.items.length > 0xffffff) throw new Error(`Constant pool too large: ${this.constants.items.length} entries, max 16,777,215`);
-  }
-  _offsetJump(instr, offset) {
-    if (this.JUMP_OPS.has(instr[0]) && instr[1] !== undefined) {
-      return [instr[0], instr[1] + offset];
-    }
-    return instr;
+
+    // if (this.constants.items.length > 0xffffff)
+    //   throw new Error(
+    //     `Constant pool too large: ${this.constants.items.length} entries, max 16,777,215`,
+    //   );
   }
 
   // Statements
@@ -465,6 +484,9 @@ class Compiler {
           // nothing to emit -- bare semicolon is a no-op
           break;
         }
+      case "DebuggerStatement":
+        this.emit(bc, [this.OP.DEBUGGER], node);
+        break;
       case "BlockStatement":
         {
           for (const stmt of node.body) {
@@ -478,19 +500,23 @@ class Compiler {
           // MAKE_CLOSURE so it's captured as a live closure at runtime.
           // (_compileFunctionDecl pushes/pops _currentCtx internally)
           const desc = this._compileFunctionDecl(node);
-          bc.push([this.OP.MAKE_CLOSURE, desc._constIdx]);
+          this._emitClosureMetadata(desc, node, bc);
+          this.emit(bc, [this.OP.MAKE_CLOSURE, {
+            type: "label",
+            label: desc.entryLabel
+          }], node);
           if (scope) {
             const slot = scope.define(node.id.name);
-            bc.push([this.OP.STORE_LOCAL, slot]);
+            this.emit(bc, [this.OP.STORE_LOCAL, slot], node);
           } else {
-            bc.push([this.OP.STORE_GLOBAL, this.constants.intern(node.id.name)]);
+            this.emit(bc, [this.OP.STORE_GLOBAL, b.constantOperand(node.id.name)], node);
           }
           break;
         }
       case "ThrowStatement":
         {
           this._compileExpr(node.argument, scope, bc);
-          bc.push([this.OP.THROW]);
+          this.emit(bc, [this.OP.THROW], node);
           break;
         }
       case "ReturnStatement":
@@ -498,15 +524,23 @@ class Compiler {
           if (node.argument) {
             this._compileExpr(node.argument, scope, bc);
           } else {
-            bc.push([this.OP.LOAD_CONST, this.constants.intern(undefined)]);
+            this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(undefined)], node);
+          }
+          // Disarm any open try handlers before leaving the function.
+          // TRY_END only touches frame._handlerStack, not the value stack,
+          // so the return value sitting on top is safe.
+          for (let _ri = this._loopStack.length - 1; _ri >= 0; _ri--) {
+            if (this._loopStack[_ri].type === "try") {
+              this.emit(bc, [this.OP.TRY_END], node);
+            }
           }
-          bc.push([this.OP.RETURN]);
+          this.emit(bc, [this.OP.RETURN], node);
           break;
         }
       case "ExpressionStatement":
         {
           this._compileExpr(node.expression, scope, bc);
-          bc.push([this.OP.POP]); // discard return value of statement-level expressions
+          this.emit(bc, [this.OP.POP], node); // discard return value of statement-level expressions
           break;
         }
       case "VariableDeclaration":
@@ -516,49 +550,63 @@ class Compiler {
             if (decl.init) {
               this._compileExpr(decl.init, scope, bc);
             } else {
-              bc.push([this.OP.LOAD_CONST, this.constants.intern(undefined)]);
+              this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(undefined)], node);
             }
             ok(decl.id.type === "Identifier", "Only simple identifiers can be declared");
 
             // Store: local slot if inside a function, global name otherwise
             if (scope) {
               const slot = scope.define(decl.id.name);
-              bc.push([this.OP.STORE_LOCAL, slot]);
+              this.emit(bc, [this.OP.STORE_LOCAL, slot], node);
             } else {
-              bc.push([this.OP.STORE_GLOBAL, this.constants.intern(decl.id.name)]);
+              this.emit(bc, [this.OP.STORE_GLOBAL, b.constantOperand(decl.id.name)], node);
             }
           }
           break;
         }
       case "IfStatement":
         {
+          const elseOrEndLabel = this._makeLabel("if_else");
           // 1. Compile the test expression -> leaves a value on the stack
           this._compileExpr(node.test, scope, bc);
-          // 2. Emit JUMP_IF_FALSE with placeholder target
-          bc.push([this.OP.JUMP_IF_FALSE, 0]);
-          const jumpIfFalseIdx = bc.length - 1;
+          // 2. Emit JUMP_IF_FALSE to the else branch (or end if no else)
+          this.emit(bc, [this.OP.JUMP_IF_FALSE, {
+            type: "label",
+            label: elseOrEndLabel
+          }], node);
           // 3. Compile the consequent block (the "then" branch)
-          // Consequent may be a BlockStatement or a bare statement (no braces)
           const consequentBody = node.consequent.type === "BlockStatement" ? node.consequent.body : [node.consequent];
           for (const stmt of consequentBody) {
             this._compileStatement(stmt, scope, bc);
           }
           if (node.alternate) {
             // 4a. Consequent needs to jump OVER the else block when done
-            bc.push([this.OP.JUMP, 0]);
-            const jumpOverElseIdx = bc.length - 1;
-            // Patch JUMP_IF_FALSE to land here (start of else)
-            bc[jumpIfFalseIdx][1] = bc.length;
+            const endLabel = this._makeLabel("if_end");
+            this.emit(bc, [this.OP.JUMP, {
+              type: "label",
+              label: endLabel
+            }], node);
+            // Mark start of else
+            this.emit(bc, [null, {
+              type: "defineLabel",
+              label: elseOrEndLabel
+            }], node);
             // 5. Compile the alternate (else) block
             const altBody = node.alternate.type === "BlockStatement" ? node.alternate.body : [node.alternate]; // handles `else if` -- it's just a nested IfStatement
             for (const stmt of altBody) {
               this._compileStatement(stmt, scope, bc);
             }
-            // Patch the JUMP to land after the else block
-            bc[jumpOverElseIdx][1] = bc.length;
+            // Mark end (consequent's jump lands here)
+            this.emit(bc, [null, {
+              type: "defineLabel",
+              label: endLabel
+            }], node);
           } else {
-            // 4b. No else -- patch JUMP_IF_FALSE to land right after the then block
-            bc[jumpIfFalseIdx][1] = bc.length;
+            // 4b. No else -- label lands right after the then block
+            this.emit(bc, [null, {
+              type: "defineLabel",
+              label: elseOrEndLabel
+            }], node);
           }
           break;
         }
@@ -566,28 +614,35 @@ class Compiler {
         {
           const _wLabel = this._pendingLabel;
           this._pendingLabel = null;
+          const loopTopLabel = this._makeLabel("while_top");
+          const exitLabel = this._makeLabel("while_exit");
           this._loopStack.push({
             type: "loop",
             label: _wLabel,
-            breakJumps: [],
-            continueJumps: []
+            breakLabel: exitLabel,
+            continueLabel: loopTopLabel // continue re-evaluates the test
           });
-          const loopCtxW = this._loopStack[this._loopStack.length - 1];
-          const loopTop = bc.length;
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: loopTopLabel
+          }], node);
           this._compileExpr(node.test, scope, bc);
-          bc.push([this.OP.JUMP_IF_FALSE, 0]);
-          const exitJumpIdx = bc.length - 1;
+          this.emit(bc, [this.OP.JUMP_IF_FALSE, {
+            type: "label",
+            label: exitLabel
+          }], node);
           const whileBody = node.body.type === "BlockStatement" ? node.body.body : [node.body];
           for (const stmt of whileBody) {
             this._compileStatement(stmt, scope, bc);
           }
-
-          // continue -> re-evaluate the test
-          for (const idx of loopCtxW.continueJumps) bc[idx][1] = loopTop;
-          bc.push([this.OP.JUMP, loopTop]);
-          const exitTargetW = bc.length;
-          bc[exitJumpIdx][1] = exitTargetW;
-          for (const idx of loopCtxW.breakJumps) bc[idx][1] = exitTargetW;
+          this.emit(bc, [this.OP.JUMP, {
+            type: "label",
+            label: loopTopLabel
+          }], node);
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: exitLabel
+          }], node);
           this._loopStack.pop();
           break;
         }
@@ -595,29 +650,42 @@ class Compiler {
         {
           const _dwLabel = this._pendingLabel;
           this._pendingLabel = null;
+          const loopTopLabel = this._makeLabel("dowhile_top");
+          const continueLabel = this._makeLabel("dowhile_cont");
+          const exitLabel = this._makeLabel("dowhile_exit");
           this._loopStack.push({
             type: "loop",
             label: _dwLabel,
-            breakJumps: [],
-            continueJumps: []
+            breakLabel: exitLabel,
+            continueLabel: continueLabel // continue falls to the test
           });
-          const loopCtxDW = this._loopStack[this._loopStack.length - 1];
-          const loopTopDW = bc.length;
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: loopTopLabel
+          }], node);
           const doWhileBody = node.body.type === "BlockStatement" ? node.body.body : [node.body];
           for (const stmt of doWhileBody) {
             this._compileStatement(stmt, scope, bc);
           }
 
           // continue -> skip rest of body, fall through to test
-          const continueTargetDW = bc.length;
-          for (const idx of loopCtxDW.continueJumps) bc[idx][1] = continueTargetDW;
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: continueLabel
+          }], node);
           this._compileExpr(node.test, scope, bc);
-          bc.push([this.OP.JUMP_IF_FALSE, 0]);
-          const exitJumpIdxDW = bc.length - 1;
-          bc.push([this.OP.JUMP, loopTopDW]);
-          const exitTargetDW = bc.length;
-          bc[exitJumpIdxDW][1] = exitTargetDW;
-          for (const idx of loopCtxDW.breakJumps) bc[idx][1] = exitTargetDW;
+          this.emit(bc, [this.OP.JUMP_IF_FALSE, {
+            type: "label",
+            label: exitLabel
+          }], node);
+          this.emit(bc, [this.OP.JUMP, {
+            type: "label",
+            label: loopTopLabel
+          }], node);
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: exitLabel
+          }], node);
           this._loopStack.pop();
           break;
         }
@@ -625,27 +693,35 @@ class Compiler {
         {
           const _fLabel = this._pendingLabel;
           this._pendingLabel = null;
+          const loopTopLabel = this._makeLabel("for_top");
+          const exitLabel = this._makeLabel("for_exit");
+          // continue jumps to the update clause if present, else straight to test
+          const updateLabel = node.update ? this._makeLabel("for_update") : loopTopLabel;
           this._loopStack.push({
             type: "loop",
             label: _fLabel,
-            breakJumps: [],
-            continueJumps: []
+            breakLabel: exitLabel,
+            continueLabel: updateLabel
           });
-          const loopCtxF = this._loopStack[this._loopStack.length - 1];
           if (node.init) {
             if (node.init.type === "VariableDeclaration") {
               this._compileStatement(node.init, scope, bc);
             } else {
               this._compileExpr(node.init, scope, bc);
-              bc.push([this.OP.POP]);
+              this.emit(bc, [this.OP.POP], node);
             }
           }
-          const loopTopF = bc.length;
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: loopTopLabel
+          }], node);
           if (node.test) {
             this._compileExpr(node.test, scope, bc);
-            bc.push([this.OP.JUMP_IF_FALSE, 0]);
+            this.emit(bc, [this.OP.JUMP_IF_FALSE, {
+              type: "label",
+              label: exitLabel
+            }], node);
           }
-          const exitJumpIdxF = node.test ? bc.length - 1 : null;
           const forBody = node.body.type === "BlockStatement" ? node.body.body : [node.body];
           for (const stmt of forBody) {
             this._compileStatement(stmt, scope, bc);
@@ -653,147 +729,162 @@ class Compiler {
 
           // continue -> run update (if any) then back to test
           if (node.update) {
-            const continueTargetF = bc.length;
-            for (const idx of loopCtxF.continueJumps) bc[idx][1] = continueTargetF;
+            this.emit(bc, [null, {
+              type: "defineLabel",
+              label: updateLabel
+            }], node);
             this._compileExpr(node.update, scope, bc);
-            bc.push([this.OP.POP]);
-          } else {
-            // No update -- continue goes straight to the test
-            for (const idx of loopCtxF.continueJumps) bc[idx][1] = loopTopF;
+            this.emit(bc, [this.OP.POP], node);
           }
-          bc.push([this.OP.JUMP, loopTopF]);
-          const exitTargetF = bc.length;
-          if (exitJumpIdxF !== null) bc[exitJumpIdxF][1] = exitTargetF;
-          for (const idx of loopCtxF.breakJumps) bc[idx][1] = exitTargetF;
+          this.emit(bc, [this.OP.JUMP, {
+            type: "label",
+            label: loopTopLabel
+          }], node);
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: exitLabel
+          }], node);
           this._loopStack.pop();
           break;
         }
       case "BreakStatement":
         {
-          bc.push([this.OP.JUMP, 0]);
-          const _bJumpIdx = bc.length - 1;
+          // Find the jump target in the loop stack.
+          let _bTargetIdx = -1;
           if (node.label) {
             const _bLabelName = node.label.name;
-            let _bFound = -1;
             for (let _bi = this._loopStack.length - 1; _bi >= 0; _bi--) {
               if (this._loopStack[_bi].label === _bLabelName) {
-                _bFound = _bi;
+                _bTargetIdx = _bi;
                 break;
               }
             }
-            if (_bFound === -1) throw new Error(`Label '${_bLabelName}' not found`);
-            this._loopStack[_bFound].breakJumps.push(_bJumpIdx);
+            if (_bTargetIdx === -1) throw new Error(`Label '${node.label.name}' not found`);
           } else {
-            if (this._loopStack.length === 0) throw new Error("break outside loop");
-            this._loopStack[this._loopStack.length - 1].breakJumps.push(_bJumpIdx);
+            // Find innermost loop/switch/block (skip "try" entries)
+            for (let _bi = this._loopStack.length - 1; _bi >= 0; _bi--) {
+              if (this._loopStack[_bi].type !== "try") {
+                _bTargetIdx = _bi;
+                break;
+              }
+            }
+            if (_bTargetIdx === -1) throw new Error("break outside loop");
+          }
+          // Emit TRY_END for every open try block between here and the target.
+          for (let _bi = this._loopStack.length - 1; _bi > _bTargetIdx; _bi--) {
+            if (this._loopStack[_bi].type === "try") {
+              this.emit(bc, [this.OP.TRY_END], node);
+            }
           }
+          this.emit(bc, [this.OP.JUMP, {
+            type: "label",
+            label: this._loopStack[_bTargetIdx].breakLabel
+          }], node);
           break;
         }
       case "ContinueStatement":
         {
-          bc.push([this.OP.JUMP, 0]);
-          const _cJumpIdx = bc.length - 1;
+          // Find the target loop in the loop stack.
+          let _cTargetIdx = -1;
           if (node.label) {
             const _cLabelName = node.label.name;
-            let _cFound = -1;
             for (let _ci = this._loopStack.length - 1; _ci >= 0; _ci--) {
               if (this._loopStack[_ci].label === _cLabelName && this._loopStack[_ci].type === "loop") {
-                _cFound = _ci;
+                _cTargetIdx = _ci;
                 break;
               }
             }
-            if (_cFound === -1) throw new Error(`Label '${_cLabelName}' not found for continue`);
-            this._loopStack[_cFound].continueJumps.push(_cJumpIdx);
+            if (_cTargetIdx === -1) throw new Error(`Label '${node.label.name}' not found for continue`);
           } else {
-            if (this._loopStack.length === 0) throw new Error("continue outside loop");
-            // Find the innermost loop (skip switch and block contexts)
-            let loopIdx = -1;
-            for (let i = this._loopStack.length - 1; i >= 0; i--) {
-              if (this._loopStack[i].type === "loop") {
-                loopIdx = i;
+            // Find the innermost loop (skip switch, block, and try contexts)
+            for (let _ci = this._loopStack.length - 1; _ci >= 0; _ci--) {
+              if (this._loopStack[_ci].type === "loop") {
+                _cTargetIdx = _ci;
                 break;
               }
             }
-            if (loopIdx === -1) throw new Error("continue outside loop");
-            this._loopStack[loopIdx].continueJumps.push(_cJumpIdx);
+            if (_cTargetIdx === -1) throw new Error("continue outside loop");
+          }
+          // Emit TRY_END for every open try block between here and the target loop.
+          for (let _ci = this._loopStack.length - 1; _ci > _cTargetIdx; _ci--) {
+            if (this._loopStack[_ci].type === "try") {
+              this.emit(bc, [this.OP.TRY_END], node);
+            }
           }
+          this.emit(bc, [this.OP.JUMP, {
+            type: "label",
+            label: this._loopStack[_cTargetIdx].continueLabel
+          }], node);
           break;
         }
       case "SwitchStatement":
         {
           const _swLabel = this._pendingLabel;
           this._pendingLabel = null;
+          const switchBreakLabel = this._makeLabel("sw_break");
           this._loopStack.push({
             type: "switch",
             label: _swLabel,
-            breakJumps: [],
-            continueJumps: []
+            breakLabel: switchBreakLabel,
+            continueLabel: switchBreakLabel // not used for switch
           });
-          const switchCtx = this._loopStack[this._loopStack.length - 1];
 
           // Compile the discriminant and leave it on the stack
           this._compileExpr(node.discriminant, scope, bc);
           const cases = node.cases;
           const defaultIdx = cases.findIndex(c => c.test === null);
 
-          // Dispatch section: emit case checks
-          const bodyJumps = []; // { cas, jumpIdx }
+          // Pre-allocate a label for each case body so dispatch can reference them
+          const caseLabels = cases.map((_, i) => this._makeLabel(`sw_case_${i}`));
 
-          for (const cas of cases) {
-            if (cas.test === null) continue; // Skip default in dispatch
+          // Dispatch section: for each non-default case, check and jump to its body
+          for (let i = 0; i < cases.length; i++) {
+            const cas = cases[i];
+            if (cas.test === null) continue; // skip default in dispatch
 
-            // Check this case: DUP; LOAD_CONST; EQ; JUMP_IF_FALSE
-            bc.push([this.OP.DUP]);
+            const nextCheckLabel = this._makeLabel("sw_next");
+            this.emit(bc, [this.OP.DUP], node);
             this._compileExpr(cas.test, scope, bc);
-            bc.push([this.OP.EQ]);
-            bc.push([this.OP.JUMP_IF_FALSE, 0]); // Jump to next check (patched later)
-            const skipIdx = bc.length - 1;
-
-            // If matched, jump to this case's body
-            bc.push([this.OP.JUMP, 0]); // Jump to body (patched later)
-            bodyJumps.push({
-              cas,
-              jumpIdx: bc.length - 1
-            });
-
-            // Patch the JUMP_IF_FALSE to the next check
-            bc[skipIdx][1] = bc.length;
+            this.emit(bc, [this.OP.EQ], node);
+            // If not matched, fall through to the next check
+            this.emit(bc, [this.OP.JUMP_IF_FALSE, {
+              type: "label",
+              label: nextCheckLabel
+            }], node);
+            // If matched, jump directly to this case's body
+            this.emit(bc, [this.OP.JUMP, {
+              type: "label",
+              label: caseLabels[i]
+            }], node);
+            this.emit(bc, [null, {
+              type: "defineLabel",
+              label: nextCheckLabel
+            }], node);
           }
 
-          // No match found: jump to default (or exit if no default)
-          bc.push([this.OP.JUMP, 0]);
-          const noMatchJumpIdx = bc.length - 1;
-
-          // Body section: compile all case bodies in source order
-          const bodyStart = new Map();
-          for (const cas of cases) {
-            bodyStart.set(cas, bc.length);
-            for (const stmt of cas.consequent) {
+          // No case matched: jump to default body or exit (which pops discriminant)
+          this.emit(bc, [this.OP.JUMP, {
+            type: "label",
+            label: defaultIdx !== -1 ? caseLabels[defaultIdx] : switchBreakLabel
+          }], node);
+
+          // Body section: compile all case bodies in source order (fallthrough intact)
+          for (let i = 0; i < cases.length; i++) {
+            this.emit(bc, [null, {
+              type: "defineLabel",
+              label: caseLabels[i]
+            }], node);
+            for (const stmt of cases[i].consequent) {
               this._compileStatement(stmt, scope, bc);
             }
           }
 
-          // Patch the no-match jump to default or exit
-          const exitTarget = bc.length;
-          if (defaultIdx !== -1) {
-            bc[noMatchJumpIdx][1] = bodyStart.get(cases[defaultIdx]);
-          } else {
-            bc[noMatchJumpIdx][1] = exitTarget;
-          }
-
-          // Patch all body jumps
-          for (const {
-            cas,
-            jumpIdx
-          } of bodyJumps) {
-            bc[jumpIdx][1] = bodyStart.get(cas);
-          }
-
-          // Exit: pop the discriminant and patch break jumps
-          bc.push([this.OP.POP]);
-          for (const idx of switchCtx.breakJumps) {
-            bc[idx][1] = bc.length - 1; // Point to the POP instruction
-          }
+          // break label lands here; pop the discriminant and continue after switch
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: switchBreakLabel
+          }], node);
+          this.emit(bc, [this.OP.POP], node);
           this._loopStack.pop();
           break;
         }
@@ -810,16 +901,19 @@ class Compiler {
             this._pendingLabel = null; // safety clear if handler didn't consume it
           } else {
             // Non-loop labeled statement (e.g. labeled block) -- only break is valid
+            const blockBreakLabel = this._makeLabel("block_break");
             this._loopStack.push({
               type: "block",
               label: _lName,
-              breakJumps: [],
-              continueJumps: []
+              breakLabel: blockBreakLabel,
+              continueLabel: blockBreakLabel // unused
             });
             this._compileStatement(_lBody, scope, bc);
-            const _lEntry = this._loopStack.pop();
-            const _lExit = bc.length;
-            for (const _lIdx of _lEntry.breakJumps) bc[_lIdx][1] = _lExit;
+            this._loopStack.pop();
+            this.emit(bc, [null, {
+              type: "defineLabel",
+              label: blockBreakLabel
+            }], node);
           }
           break;
         }
@@ -831,7 +925,7 @@ class Compiler {
           // Evaluate the object expression -> on stack
           this._compileExpr(node.right, scope, bc);
           // FOR_IN_SETUP: pops obj, pushes iterator {keys, i}
-          bc.push([this.OP.FOR_IN_SETUP]);
+          this.emit(bc, [this.OP.FOR_IN_SETUP], node);
 
           // Store iterator in a hidden slot so break/continue need no cleanup
           let emitLoadIter;
@@ -839,28 +933,34 @@ class Compiler {
           if (scope) {
             // Reserve a hidden local slot (no name mapping needed)
             const iterSlot = scope._next++;
-            emitLoadIter = () => bc.push([this.OP.LOAD_LOCAL, iterSlot]);
-            emitStoreIter = () => bc.push([this.OP.STORE_LOCAL, iterSlot]);
+            emitLoadIter = () => this.emit(bc, [this.OP.LOAD_LOCAL, iterSlot], node);
+            emitStoreIter = () => this.emit(bc, [this.OP.STORE_LOCAL, iterSlot], node);
           } else {
             // Top level -- use a synthetic global that won't collide with user code
-            const iterNameIdx = this.constants.intern("__fi" + this._forInCount++);
-            emitLoadIter = () => bc.push([this.OP.LOAD_GLOBAL, iterNameIdx]);
-            emitStoreIter = () => bc.push([this.OP.STORE_GLOBAL, iterNameIdx]);
+            const iterNameIdx = b.constantOperand("__fi" + this._forInCount++);
+            emitLoadIter = () => this.emit(bc, [this.OP.LOAD_GLOBAL, iterNameIdx], node);
+            emitStoreIter = () => this.emit(bc, [this.OP.STORE_GLOBAL, iterNameIdx], node);
           }
           emitStoreIter();
+          const loopTopLabel = this._makeLabel("forin_top");
+          const exitLabel = this._makeLabel("forin_exit");
           this._loopStack.push({
             type: "loop",
             label: _fiLabel,
-            breakJumps: [],
-            continueJumps: []
+            breakLabel: exitLabel,
+            continueLabel: loopTopLabel // continue re-checks the iterator
           });
-          const loopCtxFI = this._loopStack[this._loopStack.length - 1];
-          const loopTopFI = bc.length;
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: loopTopLabel
+          }], node);
 
           // Load iterator, attempt to get next key
           emitLoadIter();
-          bc.push([this.OP.FOR_IN_NEXT, 0]); // exit target patched below
-          const forInNextPatch = bc.length - 1;
+          this.emit(bc, [this.OP.FOR_IN_NEXT, {
+            type: "label",
+            label: exitLabel
+          }], node);
 
           // Assign the key (now on top of stack) to the loop variable
           if (node.left.type === "VariableDeclaration") {
@@ -869,18 +969,18 @@ class Compiler {
             const name = identifier.name;
             if (scope) {
               const slot = scope.define(name);
-              bc.push([this.OP.STORE_LOCAL, slot]);
+              this.emit(bc, [this.OP.STORE_LOCAL, slot], node);
             } else {
-              bc.push([this.OP.STORE_GLOBAL, this.constants.intern(name)]);
+              this.emit(bc, [this.OP.STORE_GLOBAL, b.constantOperand(name)], node);
             }
           } else if (node.left.type === "Identifier") {
             const res = this._resolve(node.left.name, this._currentCtx);
             if (res.kind === "local") {
-              bc.push([this.OP.STORE_LOCAL, res.slot]);
+              this.emit(bc, [this.OP.STORE_LOCAL, res.slot], node);
             } else if (res.kind === "upvalue") {
-              bc.push([this.OP.STORE_UPVALUE, res.index]);
+              this.emit(bc, [this.OP.STORE_UPVALUE, res.index], node);
             } else {
-              bc.push([this.OP.STORE_GLOBAL, this.constants.intern(node.left.name)]);
+              this.emit(bc, [this.OP.STORE_GLOBAL, b.constantOperand(node.left.name)], node);
             }
           } else {
             const src = generate(node.left).code;
@@ -892,14 +992,93 @@ class Compiler {
           for (const stmt of fiBody) {
             this._compileStatement(stmt, scope, bc);
           }
+          this.emit(bc, [this.OP.JUMP, {
+            type: "label",
+            label: loopTopLabel
+          }], node);
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: exitLabel
+          }], node);
+          this._loopStack.pop();
+          break;
+        }
+      case "TryStatement":
+        {
+          if (node.finalizer) {
+            throw new Error("try..finally is not supported. Use a helper function instead");
+          }
+          if (!node.handler) {
+            // try without catch requires finally — not supported
+            throw new Error("try without catch is not supported (requires finally).");
+          }
+          const catchLabel = this._makeLabel("catch");
+          const afterCatchLabel = this._makeLabel("after_catch");
+
+          // Emit TRY_SETUP with the catch block's label as the handler PC.
+          // At runtime: saves stack depth + frame stack depth, pushes handler.
+          this.emit(bc, [this.OP.TRY_SETUP, {
+            type: "label",
+            label: catchLabel
+          }], node);
+
+          // Track the open try block so that break/continue/return inside the
+          // try body can emit the matching TRY_END before their jump.
+          this._loopStack.push({
+            type: "try",
+            label: null,
+            breakLabel: "",
+            // unused
+            continueLabel: "" // unused
+          });
+
+          // Compile try body
+          for (const stmt of node.block.body) {
+            this._compileStatement(stmt, scope, bc);
+          }
 
-          // continue -> re-load iterator and check next key
-          for (const idx of loopCtxFI.continueJumps) bc[idx][1] = loopTopFI;
-          bc.push([this.OP.JUMP, loopTopFI]);
-          const exitTargetFI = bc.length;
-          bc[forInNextPatch][1] = exitTargetFI;
-          for (const idx of loopCtxFI.breakJumps) bc[idx][1] = exitTargetFI;
+          // Done compiling the try body — pop the tracking entry.
           this._loopStack.pop();
+
+          // Normal exit: disarm the exception handler.
+          this.emit(bc, [this.OP.TRY_END], node);
+
+          // Jump over the catch block on normal path.
+          this.emit(bc, [this.OP.JUMP, {
+            type: "label",
+            label: afterCatchLabel
+          }], node);
+
+          // Catch block: exception is on top of the stack (pushed by the VM).
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: catchLabel
+          }], node);
+          const handler = node.handler;
+          if (handler.param) {
+            // Bind the exception value to the catch variable.
+            const name = handler.param.name;
+            if (scope) {
+              const slot = scope.define(name);
+              this.emit(bc, [this.OP.STORE_LOCAL, slot], node);
+            } else {
+              this.emit(bc, [this.OP.STORE_GLOBAL, b.constantOperand(name)], node);
+            }
+          } else {
+            // Optional catch binding (catch without a variable — ES2019+)
+            this.emit(bc, [this.OP.POP], node);
+          }
+
+          // Compile catch body
+          for (const stmt of handler.body.body) {
+            this._compileStatement(stmt, scope, bc);
+          }
+
+          // Normal-path jump lands here (after the catch block).
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: afterCatchLabel
+          }], node);
           break;
         }
       default:
@@ -918,17 +1097,17 @@ class Compiler {
       case "NumericLiteral":
       case "StringLiteral":
         {
-          bc.push([this.OP.LOAD_CONST, this.constants.intern(node.value)]);
+          this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(node.value)], node);
           break;
         }
       case "BooleanLiteral":
         {
-          bc.push([this.OP.LOAD_CONST, this.constants.intern(node.value)]);
+          this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(node.value)], node);
           break;
         }
       case "NullLiteral":
         {
-          bc.push([this.OP.LOAD_CONST, this.constants.intern(null)]);
+          this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(null)], node);
           break;
         }
       case "Identifier":
@@ -936,17 +1115,17 @@ class Compiler {
           // scope=null means we're at the top-level -> always global
           const res = this._resolve(node.name, this._currentCtx);
           if (res.kind === "local") {
-            bc.push([this.OP.LOAD_LOCAL, res.slot]);
+            this.emit(bc, [this.OP.LOAD_LOCAL, res.slot], node);
           } else if (res.kind === "upvalue") {
-            bc.push([this.OP.LOAD_UPVALUE, res.index]);
+            this.emit(bc, [this.OP.LOAD_UPVALUE, res.index], node);
           } else {
-            bc.push([this.OP.LOAD_GLOBAL, this.constants.intern(node.name)]);
+            this.emit(bc, [this.OP.LOAD_GLOBAL, b.constantOperand(node.name)], node);
           }
           break;
         }
       case "ThisExpression":
         {
-          bc.push([this.OP.LOAD_THIS]);
+          this.emit(bc, [this.OP.LOAD_THIS], node);
           break;
         }
       case "NewExpression":
@@ -954,16 +1133,15 @@ class Compiler {
           // Push callee, then args -- identical layout to CALL but uses NEW opcode
           this._compileExpr(node.callee, scope, bc);
           for (const arg of node.arguments) this._compileExpr(arg, scope, bc);
-          bc.push([this.OP.NEW, node.arguments.length]);
+          this.emit(bc, [this.OP.NEW, node.arguments.length], node);
           break;
         }
       case "SequenceExpression":
         {
           // (a, b, c)  ->  eval a -> POP, eval b -> POP, eval c -> leave on stack
-          // Matches CPython's BINARY_OP / POP_TOP pattern for comma expressions.
           for (let i = 0; i < node.expressions.length - 1; i++) {
             this._compileExpr(node.expressions[i], scope, bc);
-            bc.push([this.OP.POP]); // discard intermediate result
+            this.emit(bc, [this.OP.POP], node); // discard intermediate result
           }
           // Last expression -- its value is the result of the whole sequence
           this._compileExpr(node.expressions[node.expressions.length - 1], scope, bc);
@@ -972,16 +1150,27 @@ class Compiler {
       case "ConditionalExpression":
         {
           // test ? consequent : alternate
-          // Identical to IfStatement codegen, just lives in expression context.
+          const elseLabel = this._makeLabel("ternary_else");
+          const endLabel = this._makeLabel("ternary_end");
           this._compileExpr(node.test, scope, bc);
-          bc.push([this.OP.JUMP_IF_FALSE, 0]);
-          const jumpToElse = bc.length - 1;
+          this.emit(bc, [this.OP.JUMP_IF_FALSE, {
+            type: "label",
+            label: elseLabel
+          }], node);
           this._compileExpr(node.consequent, scope, bc);
-          bc.push([this.OP.JUMP, 0]);
-          const jumpToEnd = bc.length - 1;
-          bc[jumpToElse][1] = bc.length; // patch: false -> alternate
+          this.emit(bc, [this.OP.JUMP, {
+            type: "label",
+            label: endLabel
+          }], node);
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: elseLabel
+          }], node);
           this._compileExpr(node.alternate, scope, bc);
-          bc[jumpToEnd][1] = bc.length; // patch: after consequent -> end
+          this.emit(bc, [null, {
+            type: "defineLabel",
+            label: endLabel
+          }], node);
           break;
         }
       case "LogicalExpression":
@@ -995,16 +1184,28 @@ class Compiler {
           this._compileExpr(node.left, scope, bc);
           if (node.operator === "||") {
             // Short-circuit if LHS is TRUTHY -- keep it, skip RHS
-            bc.push([this.OP.JUMP_IF_TRUE_OR_POP, 0]);
-            const jumpIdx = bc.length - 1;
+            const endLabel = this._makeLabel("or_end");
+            this.emit(bc, [this.OP.JUMP_IF_TRUE_OR_POP, {
+              type: "label",
+              label: endLabel
+            }], node);
             this._compileExpr(node.right, scope, bc);
-            bc[jumpIdx][1] = bc.length; // patch target to after RHS
+            this.emit(bc, [null, {
+              type: "defineLabel",
+              label: endLabel
+            }], node);
           } else if (node.operator === "&&") {
             // Short-circuit if LHS is FALSY -- keep it, skip RHS
-            bc.push([this.OP.JUMP_IF_FALSE_OR_POP, 0]);
-            const jumpIdx = bc.length - 1;
+            const endLabel = this._makeLabel("and_end");
+            this.emit(bc, [this.OP.JUMP_IF_FALSE_OR_POP, {
+              type: "label",
+              label: endLabel
+            }], node);
             this._compileExpr(node.right, scope, bc);
-            bc[jumpIdx][1] = bc.length; // patch target to after RHS
+            this.emit(bc, [null, {
+              type: "defineLabel",
+              label: endLabel
+            }], node);
           } else {
             throw new Error(`Unsupported logical operator: ${node.operator}`);
           }
@@ -1042,26 +1243,26 @@ class Compiler {
           }[node.operator];
           const resolvedOp = arithOp ?? cmpOp;
           if (resolvedOp === undefined) throw new Error(`Unsupported operator: ${node.operator}`);
-          bc.push([resolvedOp]);
+          this.emit(bc, [resolvedOp], node);
           break;
         }
       case "UpdateExpression":
         {
           const res = this._resolve(node.argument.name, this._currentCtx);
           const bumpOp = node.operator === "++" ? this.OP.ADD : this.OP.SUB;
-          const one = this.constants.intern(1);
+          const one = b.constantOperand(1);
 
           // Helper closures: emit load / store for whichever resolution kind we have
           const emitLoad = () => {
-            if (res.kind === "local") bc.push([this.OP.LOAD_LOCAL, res.slot]);else if (res.kind === "upvalue") bc.push([this.OP.LOAD_UPVALUE, res.index]);else bc.push([this.OP.LOAD_GLOBAL, this.constants.intern(node.argument.name)]);
+            if (res.kind === "local") this.emit(bc, [this.OP.LOAD_LOCAL, res.slot], node);else if (res.kind === "upvalue") this.emit(bc, [this.OP.LOAD_UPVALUE, res.index], node);else this.emit(bc, [this.OP.LOAD_GLOBAL, b.constantOperand(node.argument.name)], node);
           };
           const emitStore = () => {
-            if (res.kind === "local") bc.push([this.OP.STORE_LOCAL, res.slot]);else if (res.kind === "upvalue") bc.push([this.OP.STORE_UPVALUE, res.index]);else bc.push([this.OP.STORE_GLOBAL, this.constants.intern(node.argument.name)]);
+            if (res.kind === "local") this.emit(bc, [this.OP.STORE_LOCAL, res.slot], node);else if (res.kind === "upvalue") this.emit(bc, [this.OP.STORE_UPVALUE, res.index], node);else this.emit(bc, [this.OP.STORE_GLOBAL, b.constantOperand(node.argument.name)], node);
           };
           emitLoad();
-          if (!node.prefix) bc.push([this.OP.DUP]); // post: save old value before mutating
-          bc.push([this.OP.LOAD_CONST, one]);
-          bc.push([bumpOp]);
+          if (!node.prefix) this.emit(bc, [this.OP.DUP], node); // post: save old value before mutating
+          this.emit(bc, [this.OP.LOAD_CONST, one], node);
+          this.emit(bc, [bumpOp], node);
           emitStore();
           if (node.prefix) emitLoad(); // pre: reload new value as result
 
@@ -1094,7 +1295,7 @@ class Compiler {
             if (node.left.computed) {
               this._compileExpr(node.left.property, scope, bc); // push key (runtime)
             } else {
-              bc.push([this.OP.LOAD_CONST, this.constants.intern(node.left.property.name)]);
+              this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(node.left.property.name)], node);
             }
             if (isCompound) {
               // Duplicate obj+key on the stack so we can read before we write.
@@ -1106,15 +1307,15 @@ class Compiler {
               if (node.left.computed) {
                 this._compileExpr(node.left.property, scope, bc);
               } else {
-                bc.push([this.OP.LOAD_CONST, this.constants.intern(node.left.property.name)]);
+                this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(node.left.property.name)], node);
               }
-              bc.push([this.OP.GET_PROP_COMPUTED]); // [..., obj, key, currentVal]
+              this.emit(bc, [this.OP.GET_PROP_COMPUTED], node); // [..., obj, key, currentVal]
               this._compileExpr(node.right, scope, bc); // [..., obj, key, currentVal, rhs]
-              bc.push([compoundOp]); // [..., obj, key, newVal]
+              this.emit(bc, [compoundOp], node); // [..., obj, key, newVal]
             } else {
               this._compileExpr(node.right, scope, bc); // [..., obj, key, val]
             }
-            bc.push([this.OP.SET_PROP]); // obj[key] = val, leaves val on stack
+            this.emit(bc, [this.OP.SET_PROP], node); // obj[key] = val, leaves val on stack
             break;
           }
 
@@ -1123,30 +1324,30 @@ class Compiler {
           if (isCompound) {
             // Load the current value of the target first
             if (res.kind === "local") {
-              bc.push([this.OP.LOAD_LOCAL, res.slot]);
+              this.emit(bc, [this.OP.LOAD_LOCAL, res.slot], node);
             } else if (res.kind === "upvalue") {
-              bc.push([this.OP.LOAD_UPVALUE, res.index]);
+              this.emit(bc, [this.OP.LOAD_UPVALUE, res.index], node);
             } else {
-              bc.push([this.OP.LOAD_GLOBAL, this.constants.intern(node.left.name)]);
+              this.emit(bc, [this.OP.LOAD_GLOBAL, b.constantOperand(node.left.name)], node);
             }
           }
           this._compileExpr(node.right, scope, bc); // push RHS
 
           if (isCompound) {
-            bc.push([compoundOp]); // apply binary op -> leaves newVal on stack
+            this.emit(bc, [compoundOp], node); // apply binary op -> leaves newVal on stack
           }
 
           // Store & leave value on stack (assignment is an expression)
           if (res.kind === "local") {
-            bc.push([this.OP.STORE_LOCAL, res.slot]);
-            bc.push([this.OP.LOAD_LOCAL, res.slot]);
+            this.emit(bc, [this.OP.STORE_LOCAL, res.slot], node);
+            this.emit(bc, [this.OP.LOAD_LOCAL, res.slot], node);
           } else if (res.kind === "upvalue") {
-            bc.push([this.OP.STORE_UPVALUE, res.index]);
-            bc.push([this.OP.LOAD_UPVALUE, res.index]);
+            this.emit(bc, [this.OP.STORE_UPVALUE, res.index], node);
+            this.emit(bc, [this.OP.LOAD_UPVALUE, res.index], node);
           } else {
-            const nameIdx = this.constants.intern(node.left.name);
-            bc.push([this.OP.STORE_GLOBAL, nameIdx]);
-            bc.push([this.OP.LOAD_GLOBAL, nameIdx]);
+            const nameIdx = b.constantOperand(node.left.name);
+            this.emit(bc, [this.OP.STORE_GLOBAL, nameIdx], node);
+            this.emit(bc, [this.OP.LOAD_GLOBAL, nameIdx], node);
           }
           break;
         }
@@ -1157,16 +1358,16 @@ class Compiler {
             // Push receiver first (GET_PROP leaves it; CALL_METHOD pops it as `this`)
             this._compileExpr(node.callee.object, scope, bc);
             const prop = node.callee.property.name;
-            const propIdx = this.constants.intern(prop);
-            bc.push([this.OP.LOAD_CONST, propIdx]);
-            bc.push([this.OP.GET_PROP]);
+            const propIdx = b.constantOperand(prop);
+            this.emit(bc, [this.OP.LOAD_CONST, propIdx], node);
+            this.emit(bc, [this.OP.GET_PROP], node);
             for (const arg of node.arguments) this._compileExpr(arg, scope, bc);
-            bc.push([this.OP.CALL_METHOD, node.arguments.length]);
+            this.emit(bc, [this.OP.CALL_METHOD, node.arguments.length], node);
           } else {
             // ── Plain call: add(5, 10)
             this._compileExpr(node.callee, scope, bc);
             for (const arg of node.arguments) this._compileExpr(arg, scope, bc);
-            bc.push([this.OP.CALL, node.arguments.length]);
+            this.emit(bc, [this.OP.CALL, node.arguments.length], node);
           }
           break;
         }
@@ -1179,16 +1380,14 @@ class Compiler {
             const res = this._resolve(node.argument.name, this._currentCtx);
             if (res.kind === "global") {
               // Potentially undeclared -- let VM guard it
-              bc.push([this.OP.LOAD_CONST, this.constants.intern(node.argument.name)]);
-              bc.push([this.OP.TYPEOF_SAFE]);
+              this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(node.argument.name)], node);
+              this.emit(bc, [this.OP.TYPEOF_SAFE], node);
               break;
             }
             // Known local or upvalue -- safe to load first, then typeof
           }
 
           // Special case: delete -- argument must NOT be pre-evaluated.
-          // The generic path below compiles the argument first, which would leave
-          // a stale value on the stack before the delete result, corrupting it.
           if (node.operator === "delete") {
             const arg = node.argument;
             if (arg.type === "MemberExpression") {
@@ -1196,12 +1395,12 @@ class Compiler {
               if (arg.computed) {
                 this._compileExpr(arg.property, scope, bc);
               } else {
-                bc.push([this.OP.LOAD_CONST, this.constants.intern(arg.property.name)]);
+                this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(arg.property.name)], node);
               }
-              bc.push([this.OP.DELETE_PROP]);
+              this.emit(bc, [this.OP.DELETE_PROP], node);
             } else {
               // delete x, delete 0, etc. -- always true in non-strict, just push true
-              bc.push([this.OP.LOAD_CONST, this.constants.intern(true)]);
+              this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(true)], node);
             }
             break;
           }
@@ -1210,22 +1409,22 @@ class Compiler {
           this._compileExpr(node.argument, scope, bc);
           switch (node.operator) {
             case "-":
-              bc.push([this.OP.UNARY_NEG]);
+              this.emit(bc, [this.OP.UNARY_NEG], node);
               break;
             case "+":
-              bc.push([this.OP.UNARY_POS]);
+              this.emit(bc, [this.OP.UNARY_POS], node);
               break;
             case "!":
-              bc.push([this.OP.UNARY_NOT]);
+              this.emit(bc, [this.OP.UNARY_NOT], node);
               break;
             case "~":
-              bc.push([this.OP.UNARY_BITNOT]);
+              this.emit(bc, [this.OP.UNARY_BITNOT], node);
               break;
             case "typeof":
-              bc.push([this.OP.TYPEOF]);
+              this.emit(bc, [this.OP.TYPEOF], node);
               break;
             case "void":
-              bc.push([this.OP.VOID]);
+              this.emit(bc, [this.OP.VOID], node);
               break;
             default:
               throw new Error(`Unsupported unary operator: ${node.operator}`);
@@ -1236,10 +1435,10 @@ class Compiler {
         {
           // Emit: new RegExp(pattern, flags)
           // Fresh object per evaluation -- correct for stateful g/y flags.
-          bc.push([this.OP.LOAD_GLOBAL, this.constants.intern("RegExp")]);
-          bc.push([this.OP.LOAD_CONST, this.constants.intern(node.pattern)]);
-          bc.push([this.OP.LOAD_CONST, this.constants.intern(node.flags)]);
-          bc.push([this.OP.NEW, 2]);
+          this.emit(bc, [this.OP.LOAD_GLOBAL, b.constantOperand("RegExp")], node);
+          this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(node.pattern)], node);
+          this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(node.flags)], node);
+          this.emit(bc, [this.OP.NEW, 2], node);
           break;
         }
       case "FunctionExpression":
@@ -1248,7 +1447,11 @@ class Compiler {
           // but leave the resulting closure ON THE STACK -- no store.
           // The surrounding expression (assignment, call arg, return) consumes it.
           const desc = this._compileFunctionDecl(node);
-          bc.push([this.OP.MAKE_CLOSURE, desc._constIdx]);
+          this._emitClosureMetadata(desc, node, bc);
+          this.emit(bc, [this.OP.MAKE_CLOSURE, {
+            type: "label",
+            label: desc.entryLabel
+          }], node);
           break;
         }
       case "MemberExpression":
@@ -1259,13 +1462,13 @@ class Compiler {
             this._compileExpr(node.property, scope, bc);
           } else {
             // point.x -- push key as string, same opcode handles both
-            bc.push([this.OP.LOAD_CONST, this.constants.intern(node.property.name)]);
+            this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(node.property.name)], node);
           }
 
           // GET_PROP_COMPUTED pops the object -- correct for value access.
           // GET_PROP (peek) is only used in CallExpression's method call path
           // where the receiver must survive on the stack for CALL_METHOD.
-          bc.push([this.OP.GET_PROP_COMPUTED]);
+          this.emit(bc, [this.OP.GET_PROP_COMPUTED], node);
           break;
         }
       case "ArrayExpression":
@@ -1275,43 +1478,84 @@ class Compiler {
           for (const el of node.elements) {
             if (el === null) {
               // hole: e.g. [1,,3]
-              bc.push([this.OP.LOAD_CONST, this.constants.intern(undefined)]);
+              this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(undefined)], node);
             } else {
               this._compileExpr(el, scope, bc);
             }
           }
-          bc.push([this.OP.BUILD_ARRAY, node.elements.length]);
+          this.emit(bc, [this.OP.BUILD_ARRAY, node.elements.length], node);
           break;
         }
       case "ObjectExpression":
         {
-          // For each property: push key (always as string), push value.
-          // BUILD_OBJECT pops pairs right->left and assembles the object.
+          // Separate regular data properties from ES5 accessor methods (get/set).
+          const regularProps = [];
+          const accessorProps = [];
           for (const prop of node.properties) {
             if (prop.type === "SpreadElement") {
               throw new Error("Object spread not supported");
             }
-            // Key -- identifier shorthand (`{x:1}`) or string/number literal
+            if (prop.type === "ObjectMethod") {
+              if (prop.kind === "get" || prop.kind === "set") {
+                if (prop.computed) {
+                  throw new Error("Computed getter/setter keys are not supported");
+                }
+                accessorProps.push(prop);
+              } else {
+                throw new Error(`Shorthand method syntax is not supported`);
+              }
+            } else {
+              regularProps.push(prop);
+            }
+          }
+
+          // Build the base object from data properties.
+          for (const prop of regularProps) {
             const key = prop.key;
             let keyStr;
             if (key.type === "Identifier") {
-              keyStr = key.name; // {x: 1} -> key is "x"
+              keyStr = key.name;
             } else if (key.type === "StringLiteral" || key.type === "NumericLiteral") {
-              keyStr = String(key.value); // {"x": 1} or {0: 1}
+              keyStr = String(key.value);
             } else {
               throw new Error(`Unsupported object key type: ${key.type}`);
             }
-            bc.push([this.OP.LOAD_CONST, this.constants.intern(keyStr)]);
-            // Value -- any expression, including FunctionExpression
+            this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(keyStr)], node);
             this._compileExpr(prop.value, scope, bc);
           }
-          bc.push([this.OP.BUILD_OBJECT, node.properties.length]);
+          this.emit(bc, [this.OP.BUILD_OBJECT, regularProps.length], node);
+
+          // Define each accessor on the object that is now on top of the stack.
+          // Stack after BUILD_OBJECT: [..., obj]
+          // For each accessor: DUP obj, push key, compile fn, DEFINE_GETTER/DEFINE_SETTER
+          // DEFINE_GETTER/DEFINE_SETTER pops fn+key+obj, leaving the original obj.
+          for (const prop of accessorProps) {
+            const key = prop.key;
+            let keyStr;
+            if (key.type === "Identifier") {
+              keyStr = key.name;
+            } else if (key.type === "StringLiteral" || key.type === "NumericLiteral") {
+              keyStr = String(key.value);
+            } else {
+              throw new Error(`Unsupported object key type: ${key.type}`);
+            }
+            this.emit(bc, [this.OP.DUP], node); // dup so the original obj stays after the define
+            this.emit(bc, [this.OP.LOAD_CONST, b.constantOperand(keyStr)], node);
+
+            // Compile the accessor body as an anonymous function descriptor.
+            const desc = this._compileFunctionDecl(prop);
+            this._emitClosureMetadata(desc, prop, bc);
+            this.emit(bc, [this.OP.MAKE_CLOSURE, {
+              type: "label",
+              label: desc.entryLabel
+            }], node);
+            this.emit(bc, [prop.kind === "get" ? this.OP.DEFINE_GETTER : this.OP.DEFINE_SETTER], node);
+          }
           break;
         }
       default:
         {
-          const src = generate(node).code;
-          throw new Error(`Unsupported expression: ${node.type}\n  -> ${src}`);
+          throw new Error(`Unsupported expression: ${node.type}`);
         }
     }
   }
@@ -1319,6 +1563,8 @@ class Compiler {
 
 // Serializer
 // Turns the compiled output into a commented JS source string.
+// Expects fully-resolved bytecode (all label refs and constant refs already
+// converted to plain integers by resolveLabels + resolveConstants passes).
 class Serializer {
   constructor(compiler) {
     this.compiler = compiler;
@@ -1335,42 +1581,44 @@ class Serializer {
   get JUMP_OPS() {
     return this.compiler.JUMP_OPS;
   }
-  get constants() {
-    return this.compiler.constants.items;
-  }
-  get fnDescriptors() {
-    return this.compiler.fnDescriptors;
-  }
 
   // Produce a JS literal for a constant pool entry
   _serializeConst(val) {
     if (val === null) return "null";
     if (val === undefined) return "undefined";
-    if (typeof val === "object" && val._fnIdx !== undefined) {
-      return `FN[${val._fnIdx}]`; // fn descriptor -> reference by FN index
-    }
     return JSON.stringify(val); // number / string / bool
   }
 
   // One instruction -> "[op, operand]  // MNEMONIC description"
-  _serializeInstr(instr) {
-    const constants = this.constants;
-    const [op, operand] = instr;
+  // Expects a fully-resolved instruction: operand is a plain number or undefined.
+  _serializeInstr(instr, constants) {
+    const [op, rawOperand] = instr;
+    ok(rawOperand === undefined || typeof rawOperand === "number", "Unresolved operand: " + JSON.stringify(rawOperand));
+    const operand = rawOperand;
     const name = this.OP_NAME[op] || `OP_${op}`;
     let comment = name;
+    const sourceNode = instr[SOURCE_NODE_SYM];
+    const sourceLocation = sourceNode ? sourceNode.loc.start?.line + ":" + sourceNode.loc.start?.column + "-" + (sourceNode.loc.end?.line + ":" + sourceNode.loc.end?.column) : "";
 
     // Annotate operand with its meaning
     if (operand !== undefined) {
       switch (op) {
         case this.OP.LOAD_CONST:
-        case this.OP.MAKE_CLOSURE:
           {
             const val = constants[operand];
-            if (val && typeof val === "object" && val.name) {
-              comment += `  FN[${val._fnIdx}] -> fn:${val.name}`;
-            } else {
-              comment += `  ${JSON.stringify(val)}`;
-            }
+            comment += `  ${this._serializeConst(val)}`;
+            break;
+          }
+        case this.OP.MAKE_CLOSURE:
+          {
+            // operand is the absolute PC of the function body's first instruction
+            comment += `  PC ${operand}`;
+            break;
+          }
+        case this.OP.DATA:
+          {
+            // Inline function header word — value is a raw integer
+            comment += `  ${operand}`;
             break;
           }
         case this.OP.LOAD_LOCAL:
@@ -1402,14 +1650,16 @@ class Serializer {
           comment += `  ${operand}`;
       }
     }
+    comment = comment.padEnd(40) + sourceLocation;
 
     // Pack a [op, operand?] instruction pair into a single 32-bit word.
     // Shared between the Serializer and the obfuscation path in _compileMain.
 
+    const instrText = operand !== undefined ? `[${op}, ${operand}]` : `[${op}]`;
+    const text = `${(instrText + ",").padEnd(12)} ${comment}`;
     if (!this.options.encodeBytecode) {
-      const instrText = operand !== undefined ? `[${op}, ${operand}]` : `[${op}]`;
       return {
-        text: `      ${instrText.padEnd(12)}, // ${comment}`,
+        text: text,
         value: operand !== undefined ? [op, operand] : [op]
       };
     }
@@ -1421,35 +1671,34 @@ class Serializer {
       return operand !== undefined ? operand << 8 | op : op;
     }
     return {
-      text: "",
+      text: text,
       value: packInstr(instr)
     };
   }
 
-  // Serialize one fn descriptor into its FN[n] block
-  _serializeFn(desc) {
-    const lines = [`  {                       // FN[${desc._fnIdx}] -- ${desc.name}`, `    paramCount: ${desc.paramCount},`, `    localCount: ${desc.localCount},`, `    upvalueDescriptors: ${JSON5.stringify(desc.upvalueDescriptors)},`, `    startPc: ${desc.startPc},`, `  },`];
-    return lines.join("\n");
-  }
-
-  // Serialize the CONSTANTS array, showing FN[n] references
-  _serializeConstants() {
+  // Serialize the CONSTANTS array
+  _serializeConstants(constants) {
     const lines = ["var CONSTANTS = ["];
-    this.constants.forEach((val, idx) => {
+    constants.forEach((val, idx) => {
       lines.push(`  /* ${idx} */  ${this._serializeConst(val)},`);
     });
     lines.push("];");
     return lines.join("\n");
   }
+
+  // Filter out any remaining null-opcode pseudo-instructions.
+  // (defineLabel pseudo-ops are already stripped by resolveLabels.)
   _serializeBytecode(bytecode) {
-    if (!this.options.encodeBytecode) {
-      return bytecode.map(instr => this._serializeInstr(instr).value);
-    }
+    return {
+      bytecode: bytecode.filter(instr => instr[0] !== null)
+    };
+  }
+  __serializeBytecode(bytecode, constants) {
     let words = [];
 
     // BYTECODE
     for (const instr of bytecode) {
-      words.push(this._serializeInstr(instr).value);
+      words.push(this._serializeInstr(instr, constants).value);
     }
 
     // Convert packed words -> raw 4-byte little-endian binary -> base64
@@ -1460,26 +1709,23 @@ class Serializer {
       buf[i * 4 + 2] = w >>> 16 & 0xff;
       buf[i * 4 + 3] = w >>> 24 & 0xff;
     });
-    const b64 = Buffer.from(buf).toString("base64");
-    return b64;
+    return Buffer.from(buf).toString("base64");
   }
-  serialize(bytecode, mainStartPc) {
-    const sections = [];
-
-    // ── FN array
-    const fnLines = ["var FN = ["];
-    for (const desc of this.fnDescriptors) {
-      fnLines.push(this._serializeFn(desc));
+  serialize(bytecode, constants, compiler) {
+    const mainStartPc = compiler.mainStartPc;
+    let sections = [];
+    var textForm = [];
+    var initBody = [];
+    var bytecodeResult = this._serializeBytecode(bytecode);
+    for (const instr of bytecodeResult.bytecode) {
+      const serialized = this._serializeInstr(instr, constants);
+      textForm.push(serialized.text);
     }
-    fnLines.push("];");
-    sections.push(fnLines.join("\n"));
-
-    // ── CONSTANTS
-    sections.push(this._serializeConstants());
+    initBody.push(textForm.map(line => `// ${line}`).join("\n"));
     if (this.options.encodeBytecode) {
-      sections.push(`var BYTECODE = "${this._serializeBytecode(bytecode)}";`);
+      sections.push(`var BYTECODE = "${this.__serializeBytecode(bytecodeResult.bytecode, constants)}";`);
     } else {
-      sections.push(`var BYTECODE = [\n  ${bytecode.map(instr => this._serializeInstr(instr).text).join(",\n  ")}\n];`);
+      sections.push(`var BYTECODE = [${bytecodeResult.bytecode.map(v => "[" + v[0] + ", " + v[1] + "]").join(",")}]`);
     }
 
     // MAIN_START_PC
@@ -1489,6 +1735,10 @@ class Serializer {
     // Opcodes
     sections.push(`var OP = ${JSON5.stringify(this.OP)};`);
 
+    // Constants must be defined before the bytecode
+    initBody.push(this._serializeConstants(constants));
+    sections = [...initBody, ...sections];
+
     // VM runtime
     sections.push(VM_RUNTIME);
     return sections.join("\n\n");
@@ -1496,8 +1746,24 @@ class Serializer {
 }
 export async function compileAndSerialize(sourceCode, options) {
   const compiler = new Compiler(options);
-  const result = compiler.compile(sourceCode);
-  const output = compiler.serializer.serialize(result.bytecode, result.mainStartPc);
+  let bytecode = compiler.compile(sourceCode);
+
+  // User transform passes (operate on unresolved IR with label/constant refs)
+  const passes = [...(options.selfModifying ? [selfModifying] : [])];
+  for (const pass of passes) {
+    const passResult = pass(bytecode, compiler);
+    bytecode = passResult.bytecode;
+  }
+
+  // Assembler phases: resolve IR operands to plain integers before printing
+  const {
+    bytecode: labelResolved
+  } = resolveLabels(bytecode, compiler);
+  const {
+    bytecode: finalBytecode,
+    constants
+  } = resolveConstants(labelResolved);
+  const output = compiler.serializer.serialize(finalBytecode, constants, compiler);
   const finalOutput = await obfuscateRuntime(output, options);
   return {
     code: finalOutput