js-confuser-vm 0.0.9 → 0.1.1

package/dist/compiler.js

@@ -5,20 +5,24 @@ import traverseImport from "@babel/traverse";
 import { generate } from "@babel/generator";
 import { stripTypeScriptTypes } from "module";
 import { ok } from "assert";
-import { obfuscateRuntime } from "./build-runtime.js";
+import { buildRuntime } from "./build-runtime.js";
 import { DEFAULT_OPTIONS } from "./options.js";
 import { resolveLabels } from "./transforms/bytecode/resolveLabels.js";
-import { resolveConstants } from "./transforms/bytecode/resolveContants.js";
+import { resolveRegisters } from "./transforms/bytecode/resolveRegisters.js";
+import { resolveConstants } from "./transforms/bytecode/resolveConstants.js";
 import { selfModifying } from "./transforms/bytecode/selfModifying.js";
 import { macroOpcodes } from "./transforms/bytecode/macroOpcodes.js";
-import { microOpcodes } from "./transforms/bytecode/microOpcodes.js";
 import { specializedOpcodes } from "./transforms/bytecode/specializedOpcodes.js";
 import { aliasedOpcodes } from "./transforms/bytecode/aliasedOpcodes.js";
 import { getRandomInt } from "./utils/random-utils.js";
 import { U16_MAX } from "./utils/op-utils.js";
 import { concealConstants } from "./transforms/bytecode/concealConstants.js";
+import { dispatcher } from "./transforms/bytecode/dispatcher.js";
+import { controlFlowFlattening } from "./transforms/bytecode/controlFlowFlattening.js";
+import { stringConcealing } from "./transforms/bytecode/stringConcealing.js";
+import { now } from "./utils/profile-utils.js";
 const traverse = traverseImport.default || traverseImport;
-const readVMRuntimeFile = () => "import { OP_ORIGINAL as OP } from \"./compiler.ts\";\nconst BYTECODE = [];\nconst MAIN_START_PC = 0;\nconst MAIN_REG_COUNT = 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  // Each slot is a u16 stored as 2 little-endian bytes.\n  var r = new Uint16Array(b.length / 2);\n  for (var i = 0; i < r.length; i++) r[i] = b[i * 2] | (b[i * 2 + 1] << 8);\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.regs[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.regs[this._slot];\n};\nUpvalue.prototype._write = function (v) {\n  if (this._closed) this._value = v;\n  else this._frame.regs[this._slot] = v;\n};\nUpvalue.prototype._close = function () {\n  this._value = this._frame.regs[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, retDstReg) {\n  this.closure = closure;\n  this.regs = new Array(closure.fn.regCount).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._retDstReg = retDstReg !== undefined ? retDstReg : 0; // register in parent to write return value\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, mainRegCount, constants, globals) {\n  this.bytecode = bytecode;\n  this.constants = constants;\n  this.globals = globals;\n  this._frameStack = [];\n  this._openUpvalues = []; // all currently open Upvalue objects across all frames\n\n  var mainFn = {\n    paramCount: 0,\n    regCount: mainRegCount,\n    startPc: mainStartPc, // <- where main begins\n  };\n  this._currentFrame = new Frame(new Closure(mainFn), null, null, undefined, 0);\n  this._internals = {};\n}\n\n// Consume the next slot from the flat bytecode stream and advance the PC.\n// Called by opcode handlers to read each of their operands in order.\nVM.prototype._operand = function () {\n  return this.bytecode[this._currentFrame._pc++];\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\n// Reads and decodes a constant from the pool.\n// idx  \u2014 pool index (first operand of the constant pair emitted by resolveConstants).\n// key  \u2014 conceal key (second operand). 0 means no concealment.\n//\n// For integers:  stored value is (original ^ key); XOR again to recover.\n// For strings:   stored value is a base64 string containing u16 LE byte pairs.\n//                Mirrors decodeBytecode: base64 \u2192 bytes \u2192 u16 LE \u2192 XOR with\n//                (key + i) & 0xFFFF to recover the original char codes.\n// idxIn, keyIn are passed in from specializedOpcodes when the operands are determined at compile time.\nVM.prototype._constant = function (idxIn, keyIn) {\n  var idx = idxIn ?? this._operand();\n  var key = keyIn ?? this._operand();\n\n  var v = this.constants[idx];\n  if (!key) return v;\n  if (typeof v === \"number\") return v ^ key;\n  // String: base64-decode to u16 LE byte pairs, then XOR each code with (key+i).\n  var b =\n    typeof Buffer !== \"undefined\"\n      ? Buffer.from(v, \"base64\")\n      : Uint8Array.from(atob(v), function (c) {\n          return c.charCodeAt(0);\n        });\n  var out = \"\";\n  for (var i = 0; i < b.length / 2; i++) {\n    var code = b[i * 2] | (b[i * 2 + 1] << 8); // u16 LE\n    out += String.fromCharCode(code ^ ((key + i) & 0xffff));\n  }\n  return out;\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 lastTime = 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 pc = frame._pc++;\n    var op = this.bytecode[pc];\n    var opcode = this.bytecode[pc];\n    // console.log(\n    //   \"pc=\" + pc,\n    //   \"opcode=\" + opcode,\n    //   Object.keys(OP).find((key) => OP[key] === opcode),\n    // );\n\n    // Debugging protection: Detects debugger by checking for >1s pauses which can only happen from debugger; or extremely slow sync tasks\n    if (TIMING_CHECKS) {\n      var currentTime = now();\n      var isTamper = currentTime - lastTime > 1000;\n      lastTime = currentTime;\n      if (isTamper) {\n        // Poison the bytecode\n        for (var i = 0; i < this.bytecode.length; i++) this.bytecode[i] = 0;\n        // Break the current state\n        frame.regs.fill(undefined);\n        op = OP.JUMP;\n        frame._pc = this.bytecode.length; // jump past end to halt\n      }\n    }\n\n    try {\n      /* @SWITCH */\n      switch (op) {\n        case OP.LOAD_CONST: {\n          var dst = this._operand();\n          frame.regs[dst] = this._constant();\n          break;\n        }\n\n        case OP.LOAD_INT: {\n          var dst = this._operand();\n          frame.regs[dst] = this._operand();\n          break;\n        }\n\n        case OP.LOAD_GLOBAL: {\n          var dst = this._operand();\n          var globalName = this._constant();\n\n          if (!(globalName in this.globals)) {\n            throw new ReferenceError(`${globalName} is not defined`);\n          }\n\n          frame.regs[dst] = this.globals[globalName];\n          break;\n        }\n\n        case OP.LOAD_UPVALUE: {\n          var dst = this._operand();\n          frame.regs[dst] = frame.closure.upvalues[this._operand()]._read();\n          break;\n        }\n\n        case OP.LOAD_THIS: {\n          var dst = this._operand();\n          frame.regs[dst] = frame.thisVal;\n          break;\n        }\n\n        case OP.MOVE: {\n          var dst = this._operand();\n          frame.regs[dst] = frame.regs[this._operand()];\n          break;\n        }\n\n        case OP.STORE_GLOBAL: {\n          // nameIdx and key are consumed inline so the concealConstants runtime\n          // transform can rewrite this._constant() consistently.\n          this.globals[this._constant()] = frame.regs[this._operand()];\n          break;\n        }\n\n        case OP.STORE_UPVALUE: {\n          var uvIdx = this._operand();\n          frame.closure.upvalues[uvIdx]._write(frame.regs[this._operand()]);\n          break;\n        }\n\n        case OP.GET_PROP: {\n          // dst = regs[obj][regs[key]]\n          var dst = this._operand();\n          var obj = frame.regs[this._operand()];\n          var key = frame.regs[this._operand()];\n          frame.regs[dst] = obj[key];\n          break;\n        }\n\n        case OP.SET_PROP: {\n          // regs[obj][regs[key]] = regs[val]\n          var obj = frame.regs[this._operand()];\n          var key = frame.regs[this._operand()];\n          var val = frame.regs[this._operand()];\n          // Reflect.set performs [[Set]] without throwing on failure,\n          // correctly simulating sloppy-mode assignment from a strict-mode host.\n          Reflect.set(obj, key, val);\n          break;\n        }\n\n        case OP.DELETE_PROP: {\n          var dst = this._operand();\n          var obj = frame.regs[this._operand()];\n          var key = frame.regs[this._operand()];\n          frame.regs[dst] = delete obj[key];\n          break;\n        }\n\n        // \u2500\u2500 Arithmetic  (dst, src1, src2) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.ADD: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a + frame.regs[this._operand()];\n          break;\n        }\n        case OP.SUB: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a - frame.regs[this._operand()];\n          break;\n        }\n        case OP.MUL: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a * frame.regs[this._operand()];\n          break;\n        }\n        case OP.DIV: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a / frame.regs[this._operand()];\n          break;\n        }\n        case OP.MOD: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a % frame.regs[this._operand()];\n          break;\n        }\n        case OP.BAND: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a & frame.regs[this._operand()];\n          break;\n        }\n        case OP.BOR: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a | frame.regs[this._operand()];\n          break;\n        }\n        case OP.BXOR: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a ^ frame.regs[this._operand()];\n          break;\n        }\n        case OP.SHL: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a << frame.regs[this._operand()];\n          break;\n        }\n        case OP.SHR: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a >> frame.regs[this._operand()];\n          break;\n        }\n        case OP.USHR: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a >>> frame.regs[this._operand()];\n          break;\n        }\n\n        // \u2500\u2500 Comparison  (dst, src1, src2) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.LT: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a < frame.regs[this._operand()];\n          break;\n        }\n        case OP.GT: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a > frame.regs[this._operand()];\n          break;\n        }\n        case OP.LTE: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a <= frame.regs[this._operand()];\n          break;\n        }\n        case OP.GTE: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a >= frame.regs[this._operand()];\n          break;\n        }\n        case OP.EQ: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a === frame.regs[this._operand()];\n          break;\n        }\n        case OP.NEQ: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a !== frame.regs[this._operand()];\n          break;\n        }\n        case OP.LOOSE_EQ: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a == frame.regs[this._operand()];\n          break;\n        }\n        case OP.LOOSE_NEQ: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a != frame.regs[this._operand()];\n          break;\n        }\n        case OP.IN: {\n          var dst = this._operand();\n          var a = frame.regs[this._operand()];\n          frame.regs[dst] = a in frame.regs[this._operand()];\n          break;\n        }\n        case OP.INSTANCEOF: {\n          var dst = this._operand();\n          var obj = frame.regs[this._operand()];\n          var ctor = frame.regs[this._operand()];\n          if (typeof ctor === \"function\") {\n            frame.regs[dst] = obj instanceof ctor;\n          } else {\n            // VM Closure - walk prototype chain for identity with ctor.prototype.\n            var proto = ctor.prototype;\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            frame.regs[dst] = result;\n          }\n          break;\n        }\n\n        // \u2500\u2500 Unary  (dst, src) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.UNARY_NEG: {\n          var dst = this._operand();\n          frame.regs[dst] = -frame.regs[this._operand()];\n          break;\n        }\n        case OP.UNARY_POS: {\n          var dst = this._operand();\n          frame.regs[dst] = +frame.regs[this._operand()];\n          break;\n        }\n        case OP.UNARY_NOT: {\n          var dst = this._operand();\n          frame.regs[dst] = !frame.regs[this._operand()];\n          break;\n        }\n        case OP.UNARY_BITNOT: {\n          var dst = this._operand();\n          frame.regs[dst] = ~frame.regs[this._operand()];\n          break;\n        }\n        case OP.TYPEOF: {\n          var dst = this._operand();\n          frame.regs[dst] = typeof frame.regs[this._operand()];\n          break;\n        }\n        case OP.VOID: {\n          var dst = this._operand();\n          this._operand(); // consume src \u2014 evaluated for side-effects by compiler\n          frame.regs[dst] = undefined;\n          break;\n        }\n        case OP.TYPEOF_SAFE: {\n          // dst, nameConstIdx \u2014 safe typeof for potentially-undeclared globals.\n          var dst = this._operand();\n          var name = this._constant();\n          var val = Object.prototype.hasOwnProperty.call(this.globals, name)\n            ? this.globals[name]\n            : undefined;\n          frame.regs[dst] = typeof val;\n          break;\n        }\n\n        // \u2500\u2500 Control flow \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.JUMP:\n          frame._pc = this._operand();\n          break;\n\n        case OP.JUMP_IF_FALSE: {\n          var src = this._operand();\n          var target = this._operand();\n          if (!frame.regs[src]) frame._pc = target;\n          break;\n        }\n\n        case OP.JUMP_IF_TRUE: {\n          // || short-circuit: if truthy, jump over RHS.\n          var src = this._operand();\n          var target = this._operand();\n          if (frame.regs[src]) frame._pc = target;\n          break;\n        }\n\n        // \u2500\u2500 Calls \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.CALL: {\n          // dst, calleeReg, argc, [argReg...]\n          var dst = this._operand();\n          var callee = frame.regs[this._operand()];\n          var argc = this._operand();\n          var args = new Array(argc);\n          for (var i = 0; i < argc; i++) args[i] = frame.regs[this._operand()];\n\n          if (callee && callee[CLOSURE_SYM]) {\n            var c = callee[CLOSURE_SYM];\n            var f = new Frame(c, frame._pc, frame, this.globals, dst);\n            for (var i = 0; i < args.length; i++) f.regs[i] = args[i];\n            f.regs[c.fn.paramCount] = args;\n            this._frameStack.push(this._currentFrame);\n            this._currentFrame = f;\n          } else {\n            frame.regs[dst] = callee.apply(null, args);\n          }\n          break;\n        }\n\n        case OP.CALL_METHOD: {\n          // dst, receiverReg, calleeReg, argc, [argReg...]\n          var dst = this._operand();\n          var receiver = frame.regs[this._operand()];\n          var callee = frame.regs[this._operand()];\n          var argc = this._operand();\n          var args = new Array(argc);\n          for (var i = 0; i < argc; i++) args[i] = frame.regs[this._operand()];\n\n          if (callee && callee[CLOSURE_SYM]) {\n            var c = callee[CLOSURE_SYM];\n            var f = new Frame(c, frame._pc, frame, receiver, dst);\n            for (var i = 0; i < args.length; i++) f.regs[i] = args[i];\n            f.regs[c.fn.paramCount] = args;\n            this._frameStack.push(this._currentFrame);\n            this._currentFrame = f;\n          } else {\n            frame.regs[dst] = callee.apply(receiver, args);\n          }\n          break;\n        }\n\n        case OP.NEW: {\n          // dst, calleeReg, argc, [argReg...]\n          var dst = this._operand();\n          var callee = frame.regs[this._operand()];\n          var argc = this._operand();\n          var args = new Array(argc);\n          for (var i = 0; i < argc; i++) args[i] = frame.regs[this._operand()];\n\n          if (callee && callee[CLOSURE_SYM]) {\n            var c = callee[CLOSURE_SYM];\n            var newObj = Object.create(c.prototype || null);\n            var f = new Frame(c, frame._pc, frame, newObj, dst);\n            f._newObj = newObj;\n            for (var i = 0; i < args.length; i++) f.regs[i] = args[i];\n            f.regs[c.fn.paramCount] = args;\n            this._frameStack.push(this._currentFrame);\n            this._currentFrame = f;\n          } else {\n            // Reflect.construct is required - Object.create+apply does NOT set\n            // internal slots ([[NumberData]], [[StringData]], etc.) for built-ins.\n            frame.regs[dst] = Reflect.construct(callee, args);\n          }\n          break;\n        }\n\n        case OP.RETURN: {\n          var retVal = frame.regs[this._operand()];\n          this._closeUpvaluesFor(frame); // must happen before frame is abandoned\n\n          if (this._frameStack.length === 0) return retVal; // main script returning\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          var parentFrame = this._frameStack.pop();\n          parentFrame.regs[frame._retDstReg] = retVal;\n          this._currentFrame = parentFrame;\n          break;\n        }\n\n        case OP.THROW:\n          throw frame.regs[this._operand()];\n\n        // \u2500\u2500 Closures \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.MAKE_CLOSURE: {\n          // dst, startPc, paramCount, regCount, uvCount, [isLocal, idx, ...]\n          var dst = this._operand();\n          var startPc = this._operand();\n          var paramCount = this._operand();\n          var regCount = this._operand();\n          var uvCount = this._operand();\n\n          var uvDescs = new Array(uvCount);\n          for (var i = 0; i < uvCount; i++) {\n            var isLocalRaw = this._operand();\n            var uvIndex = this._operand();\n            uvDescs[i] = { isLocal: isLocalRaw, _index: uvIndex };\n          }\n\n          var fn = {\n            paramCount: paramCount,\n            regCount: regCount,\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              closure.upvalues.push(this.captureUpvalue(frame, uvd._index));\n            } else {\n              closure.upvalues.push(frame.closure.upvalues[uvd._index]);\n            }\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(\n                self.bytecode,\n                0,\n                c.fn.regCount,\n                self.constants,\n                self.globals,\n              );\n              var f = new Frame(\n                c,\n                null,\n                null,\n                this == null ? self.globals : this,\n                0,\n              );\n              for (var i = 0; i < args.length; i++) f.regs[i] = args[i];\n              f.regs[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          frame.regs[dst] = shell;\n          break;\n        }\n\n        // \u2500\u2500 Collections \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.BUILD_ARRAY: {\n          // dst, count, [elemReg...]\n          var dst = this._operand();\n          var count = this._operand();\n          var elems = new Array(count);\n          for (var i = 0; i < count; i++)\n            elems[i] = frame.regs[this._operand()];\n          frame.regs[dst] = elems;\n          break;\n        }\n\n        case OP.BUILD_OBJECT: {\n          // dst, pairCount, [keyReg, valReg, ...]\n          var dst = this._operand();\n          var pairCount = this._operand();\n          var o = {};\n          for (var i = 0; i < pairCount; i++) {\n            var key = frame.regs[this._operand()];\n            var val = frame.regs[this._operand()];\n            o[key] = val;\n          }\n          frame.regs[dst] = o;\n          break;\n        }\n\n        // \u2500\u2500 Property definitions (getters / setters) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.DEFINE_GETTER: {\n          // obj, key, fn\n          var obj = frame.regs[this._operand()];\n          var key = frame.regs[this._operand()];\n          var getterFn = frame.regs[this._operand()];\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          // obj, key, fn\n          var obj = frame.regs[this._operand()];\n          var key = frame.regs[this._operand()];\n          var setterFn = frame.regs[this._operand()];\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        // \u2500\u2500 For-in iteration \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.FOR_IN_SETUP: {\n          // dst, src \u2014 build iterator object from enumerable keys of regs[src]\n          var dst = this._operand();\n          var obj = frame.regs[this._operand()];\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          frame.regs[dst] = { _keys: keys, i: 0 };\n          break;\n        }\n\n        case OP.FOR_IN_NEXT: {\n          // dst, iterReg, exitTarget\n          // Advances iterator; writes next key to dst, or jumps to exitTarget when done.\n          var dst = this._operand();\n          var iter = frame.regs[this._operand()];\n          var exitTarget = this._operand();\n          if (iter.i >= iter._keys.length) {\n            frame._pc = exitTarget;\n          } else {\n            frame.regs[dst] = iter._keys[iter.i++];\n          }\n          break;\n        }\n\n        // \u2500\u2500 Exception handling \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.TRY_SETUP: {\n          // handlerPc, exceptionReg \u2014 push exception handler record onto current frame.\n          frame._handlerStack.push({\n            handlerPc: this._operand(),\n            exceptionReg: this._operand(),\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        // \u2500\u2500 Self-modifying bytecode \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.PATCH: {\n          // destPc, sliceStart, sliceEnd\n          var destPc = this._operand();\n          var sliceStart = this._operand();\n          var sliceEnd = this._operand();\n          for (var pi = sliceStart; pi < sliceEnd; pi++) {\n            this.bytecode[destPc + (pi - sliceStart)] = this.bytecode[pi];\n          }\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      // Discard any call-frames that were pushed inside the try body.\n      this._frameStack.length = h.frameStackDepth;\n      // Write the caught exception directly into the designated register.\n      handledFrame.regs[h.exceptionReg] = err;\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  for (var k of Object.getOwnPropertyNames(window)) {\n    globals[k] = window[k];\n  }\n}\n\n// Transfer common primitives\nglobals.undefined = undefined;\nglobals.Infinity = Infinity;\nglobals.NaN = NaN;\n\nvar vm = new VM(\n  decodeBytecode(BYTECODE),\n  MAIN_START_PC,\n  MAIN_REG_COUNT,\n  CONSTANTS,\n  globals,\n);\nvm.run();\n";
+const readVMRuntimeFile = () => "import { OP_ORIGINAL as OP } from \"./compiler.ts\";\nconst BYTECODE = [];\nconst MAIN_START_PC = 0;\nconst MAIN_REG_COUNT = 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 base64ToBytes(s) {\n  return typeof Buffer !== \"undefined\"\n    ? Buffer.from(s, \"base64\")\n    : Uint8Array.from(atob(s), function (c) {\n        return c.charCodeAt(0);\n      });\n}\n\nfunction decodeBytecode(s) {\n  if (!ENCODE_BYTECODE) return s;\n\n  var b = base64ToBytes(s);\n  // Each slot is a u32 stored as 4 little-endian bytes.\n  var r = new Uint32Array(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      0;\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 \u2014 Lua/CPython style.\n// While the outer frame is alive: reads/writes go to vm._regs[_absSlot].\n// After the outer frame returns (closed): reads/writes hit this._value.\n// _absSlot is the absolute index in VM._regs (frame._base + local slot).\nfunction Upvalue(regs, absSlot) {\n  this._regs = regs; // shared reference to VM._regs flat array\n  this._absSlot = absSlot; // absolute index; stable as long as frame is alive\n  this._closed = false;\n  this._value = undefined;\n}\nUpvalue.prototype._read = function () {\n  return this._closed ? this._value : this._regs[this._absSlot];\n};\nUpvalue.prototype._write = function (v) {\n  if (this._closed) this._value = v;\n  else this._regs[this._absSlot] = v;\n};\nUpvalue.prototype._close = function () {\n  this._value = this._regs[this._absSlot];\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\n// Frame \u2014 analogous to Lua CallInfo / CPython PyFrameObject.\n// Does NOT own a register array; registers live in VM._regs[_base .. _base+regCount).\nfunction Frame(closure, returnPc, parent, thisVal, retDstReg, base) {\n  this.closure = closure;\n  this._base = base; // absolute offset into VM._regs for this frame's r0\n  this._pc = closure.fn.startPc;\n  this._returnPc = returnPc;\n  this._parent = parent;\n  this.thisVal = thisVal !== undefined ? thisVal : undefined;\n  this._retDstReg = retDstReg !== undefined ? retDstReg : 0;\n  this._newObj = null;\n  this._handlerStack = [];\n}\n\n// VM\nfunction VM(bytecode, mainStartPc, mainRegCount, constants, globals) {\n  this.bytecode = bytecode;\n  this.constants = constants;\n  this.globals = globals;\n  this._frameStack = [];\n  this._openUpvalues = [];\n\n  // \u2500\u2500 Flat register file (Lua-style) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  // All frames share a single array.  Each Frame records its _base offset.\n  // _regsTop is the next free slot (= base of the hypothetical next frame).\n  // On CALL:   newBase = _regsTop; _regsTop += fn.regCount\n  // On RETURN: _regsTop = frame._base   (pop the frame's register window)\n  this._regs = new Array(mainRegCount).fill(undefined);\n  this._regsTop = mainRegCount; // main frame occupies [0, mainRegCount)\n\n  var mainFn = {\n    paramCount: 0,\n    regCount: mainRegCount,\n    startPc: mainStartPc,\n  };\n  this._currentFrame = new Frame(\n    new Closure(mainFn),\n    null,\n    null,\n    undefined,\n    0,\n    0,\n  );\n}\n\n// Consume the next slot from the flat bytecode stream and advance the PC.\n// Called by opcode handlers to read each of their operands in order.\nVM.prototype._operand = function () {\n  return this.bytecode[this._currentFrame._pc++];\n};\n\nVM.prototype.captureUpvalue = function (frame, slot) {\n  // Dedup by absolute slot \u2014 two closures capturing the same local share one Upvalue.\n  var absSlot = frame._base + slot;\n  for (var i = 0; i < this._openUpvalues.length; i++) {\n    var uv = this._openUpvalues[i];\n    if (!uv._closed && uv._absSlot === absSlot) return uv;\n  }\n  var uv = new Upvalue(this._regs, absSlot);\n  this._openUpvalues.push(uv);\n  return uv;\n};\n\n// Reads and decodes a constant from the pool.\n// idx  \u2014 pool index (first operand of the constant pair emitted by resolveConstants).\n// key  \u2014 conceal key (second operand). 0 means no concealment.\n//\n// For integers:  stored value is (original ^ key); XOR again to recover.\n// For strings:   stored value is a base64 string containing u16 LE byte pairs.\n//                Mirrors decodeBytecode: base64 \u2192 bytes \u2192 u16 LE \u2192 XOR with\n//                (key + i) & 0xFFFF to recover the original char codes.\n// idxIn, keyIn are passed in from specializedOpcodes when the operands are determined at compile time.\nVM.prototype._constant = function (idxIn, keyIn) {\n  var idx = idxIn ?? this._operand();\n  var key = keyIn ?? this._operand();\n\n  var v = this.constants[idx];\n  if (!key) return v;\n  if (typeof v === \"number\") return v ^ key;\n  // String: base64-decode to u16 LE byte pairs, then XOR each code with (key+i).\n  var b = base64ToBytes(v);\n  var out = \"\";\n  for (var i = 0; i < b.length / 2; i++) {\n    var code = b[i * 2] | (b[i * 2 + 1] << 8); // u16 LE\n    out += String.fromCharCode(code ^ ((key + i) & 0xffff));\n  }\n  return out;\n};\n\nVM.prototype._closeUpvaluesFor = function (frame) {\n  // Called on RETURN \u2014 close every upvalue whose absolute slot falls within\n  // this frame's register window [_base, _base + regCount).\n  var lo = frame._base;\n  var hi = frame._base + frame.closure.fn.regCount;\n  this._openUpvalues = this._openUpvalues.filter(function (uv) {\n    if (!uv._closed && uv._absSlot >= lo && uv._absSlot < hi) {\n      uv._close();\n      return false;\n    }\n    return true;\n  });\n};\n\nVM.prototype._ensureRegisterWindow = function (base, regCount) {\n  var end = base + regCount;\n  while (this._regs.length < end) this._regs.push(undefined);\n  for (var i = base; i < end; i++) this._regs[i] = undefined;\n};\n\nVM.prototype.run = function () {\n  var now = () => {\n    return performance.now();\n  };\n\n  var lastTime = 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 pc = frame._pc++;\n    var op = this.bytecode[pc];\n    var opcode = this.bytecode[pc];\n    // console.log(\n    //   \"pc=\" + pc,\n    //   \"opcode=\" + opcode,\n    //   Object.keys(OP).find((key) => OP[key] === opcode),\n    // );\n\n    // Debugging protection: Detects debugger by checking for >1s pauses which can only happen from debugger; or extremely slow sync tasks\n    if (TIMING_CHECKS) {\n      var currentTime = now();\n      var isTamper = currentTime - lastTime > 1000;\n      lastTime = currentTime;\n      if (isTamper) {\n        // Poison the bytecode\n        for (var i = 0; i < this.bytecode.length; i++) this.bytecode[i] = 0;\n        // Break the current state\n        for (var i2 = frame._base; i2 < this._regsTop; i2++)\n          this._regs[i2] = undefined;\n        op = OP.JUMP;\n        frame._pc = this.bytecode.length; // jump past end to halt\n      }\n    }\n\n    try {\n      var regs = this._regs;\n      var base = frame._base;\n\n      /* @SWITCH */\n      switch (op) {\n        case OP.LOAD_CONST: {\n          var dst = this._operand();\n          regs[base + dst] = this._constant();\n          break;\n        }\n\n        case OP.LOAD_INT: {\n          var dst = this._operand();\n          regs[base + dst] = this._operand();\n          break;\n        }\n\n        case OP.LOAD_GLOBAL: {\n          var dst = this._operand();\n          var globalName = this._constant();\n\n          if (!(globalName in this.globals)) {\n            throw new ReferenceError(`${globalName} is not defined`);\n          }\n\n          regs[base + dst] = this.globals[globalName];\n          break;\n        }\n\n        case OP.LOAD_UPVALUE: {\n          var dst = this._operand();\n          regs[base + dst] = frame.closure.upvalues[this._operand()]._read();\n          break;\n        }\n\n        case OP.LOAD_THIS: {\n          var dst = this._operand();\n          regs[base + dst] = frame.thisVal;\n          break;\n        }\n\n        case OP.MOVE: {\n          var dst = this._operand();\n          regs[base + dst] = regs[base + this._operand()];\n          break;\n        }\n\n        case OP.STORE_GLOBAL: {\n          // globals[globalName] = regs[src]\n          this.globals[this._constant()] = regs[base + this._operand()];\n          break;\n        }\n\n        case OP.STORE_UPVALUE: {\n          var uvIdx = this._operand();\n          frame.closure.upvalues[uvIdx]._write(regs[base + this._operand()]);\n          break;\n        }\n\n        case OP.GET_PROP: {\n          // dst = regs[obj][regs[key]]\n          var dst = this._operand();\n          var obj = regs[base + this._operand()];\n          var key = regs[base + this._operand()];\n          regs[base + dst] = obj[key];\n          break;\n        }\n\n        case OP.SET_PROP: {\n          // regs[obj][regs[key]] = regs[val]\n          var obj = regs[base + this._operand()];\n          var key = regs[base + this._operand()];\n          var val = regs[base + this._operand()];\n          // Reflect.set performs [[Set]] without throwing on failure (non-strict mode behavior)\n          Reflect.set(obj, key, val);\n          break;\n        }\n\n        case OP.DELETE_PROP: {\n          // regs[dst] = delete regs[obj][regs[key]]\n          // The delete operator returns true if successful which is most cases\n          var dst = this._operand();\n          var obj = regs[base + this._operand()];\n          var key = regs[base + this._operand()];\n          regs[base + dst] = delete obj[key];\n          break;\n        }\n\n        // Arithmetic  (dst, src1, src2)\n        case OP.ADD: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a + regs[base + this._operand()];\n          break;\n        }\n        case OP.SUB: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a - regs[base + this._operand()];\n          break;\n        }\n        case OP.MUL: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a * regs[base + this._operand()];\n          break;\n        }\n        case OP.DIV: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a / regs[base + this._operand()];\n          break;\n        }\n        case OP.MOD: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a % regs[base + this._operand()];\n          break;\n        }\n        case OP.BAND: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a & regs[base + this._operand()];\n          break;\n        }\n        case OP.BOR: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a | regs[base + this._operand()];\n          break;\n        }\n        case OP.BXOR: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a ^ regs[base + this._operand()];\n          break;\n        }\n        case OP.SHL: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a << regs[base + this._operand()];\n          break;\n        }\n        case OP.SHR: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a >> regs[base + this._operand()];\n          break;\n        }\n        case OP.USHR: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a >>> regs[base + this._operand()];\n          break;\n        }\n\n        // Comparison  (dst, src1, src2)\n        case OP.LT: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a < regs[base + this._operand()];\n          break;\n        }\n        case OP.GT: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a > regs[base + this._operand()];\n          break;\n        }\n        case OP.LTE: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a <= regs[base + this._operand()];\n          break;\n        }\n        case OP.GTE: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a >= regs[base + this._operand()];\n          break;\n        }\n        case OP.EQ: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a === regs[base + this._operand()];\n          break;\n        }\n        case OP.NEQ: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a !== regs[base + this._operand()];\n          break;\n        }\n        case OP.LOOSE_EQ: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a == regs[base + this._operand()];\n          break;\n        }\n        case OP.LOOSE_NEQ: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a != regs[base + this._operand()];\n          break;\n        }\n        case OP.IN: {\n          var dst = this._operand();\n          var a = regs[base + this._operand()];\n          regs[base + dst] = a in regs[base + this._operand()];\n          break;\n        }\n        case OP.INSTANCEOF: {\n          // regs[dst] = regs[obj] instanceof regs[ctor]\n          var dst = this._operand();\n          var obj = regs[base + this._operand()];\n          var ctor = regs[base + this._operand()];\n          if (typeof ctor === \"function\") {\n            regs[base + dst] = obj instanceof ctor;\n          } else {\n            // TODO: Why is this needed?\n            var proto = ctor.prototype;\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            regs[base + dst] = result;\n          }\n          break;\n        }\n\n        // Unary  (dst, src)\n        case OP.UNARY_NEG: {\n          var dst = this._operand();\n          regs[base + dst] = -regs[base + this._operand()];\n          break;\n        }\n        case OP.UNARY_POS: {\n          var dst = this._operand();\n          regs[base + dst] = +regs[base + this._operand()];\n          break;\n        }\n        case OP.UNARY_NOT: {\n          var dst = this._operand();\n          regs[base + dst] = !regs[base + this._operand()];\n          break;\n        }\n        case OP.UNARY_BITNOT: {\n          var dst = this._operand();\n          regs[base + dst] = ~regs[base + this._operand()];\n          break;\n        }\n        case OP.TYPEOF: {\n          var dst = this._operand();\n          regs[base + dst] = typeof regs[base + this._operand()];\n          break;\n        }\n        case OP.VOID: {\n          var dst = this._operand();\n          this._operand(); // consumes argument (intended)\n          regs[base + dst] = undefined;\n          break;\n        }\n        case OP.TYPEOF_SAFE: {\n          // regs[dst] = typeof window[name]\n          // Never throws ReferenceError, instead returns undefined for undeclared variables\n          var dst = this._operand();\n          var name = this._constant();\n          var val = Object.prototype.hasOwnProperty.call(this.globals, name)\n            ? this.globals[name]\n            : undefined;\n          regs[base + dst] = typeof val;\n          break;\n        }\n\n        // Control flow\n        case OP.JUMP:\n          frame._pc = this._operand();\n          break;\n\n        case OP.JUMP_IF_FALSE: {\n          var src = this._operand();\n          var target = this._operand();\n          if (!regs[base + src]) frame._pc = target;\n          break;\n        }\n\n        case OP.JUMP_IF_TRUE: {\n          // || short-circuit: if truthy, jump over RHS.\n          var src = this._operand();\n          var target = this._operand();\n          if (regs[base + src]) frame._pc = target;\n          break;\n        }\n\n        // Calls\n        case OP.CALL: {\n          // dst, calleeReg, argc, [argReg...]\n          var dst = this._operand();\n          var callee = regs[base + this._operand()];\n          var argc = this._operand();\n          var args = new Array(argc);\n          for (var i = 0; i < argc; i++) args[i] = regs[base + this._operand()];\n\n          if (callee && callee[CLOSURE_SYM]) {\n            var closure = callee[CLOSURE_SYM];\n            var newBase = this._regsTop;\n            this._ensureRegisterWindow(newBase, closure.fn.regCount);\n            this._regsTop = newBase + closure.fn.regCount;\n            var f = new Frame(\n              closure,\n              frame._pc,\n              frame,\n              this.globals,\n              dst,\n              newBase,\n            );\n            if (closure.fn.hasRest) {\n              var restSlot = closure.fn.paramCount - 1;\n              for (var i = 0; i < restSlot; i++)\n                this._regs[newBase + i] = i < args.length ? args[i] : undefined;\n              this._regs[newBase + restSlot] = args.slice(restSlot);\n            } else {\n              for (var i = 0; i < args.length && i < closure.fn.regCount; i++)\n                this._regs[newBase + i] = args[i];\n            }\n            if (closure.fn.paramCount < closure.fn.regCount) {\n              this._regs[newBase + closure.fn.paramCount] = args;\n            }\n            this._frameStack.push(this._currentFrame);\n            this._currentFrame = f;\n          } else {\n            regs[base + dst] = callee.apply(null, args);\n          }\n          break;\n        }\n\n        case OP.CALL_METHOD: {\n          // dst, receiverReg, calleeReg, argc, [argReg...]\n          var dst = this._operand();\n          var receiver = regs[base + this._operand()];\n          var callee = regs[base + this._operand()];\n          var argc = this._operand();\n          var args = new Array(argc);\n          for (var i = 0; i < argc; i++) args[i] = regs[base + this._operand()];\n\n          if (callee && callee[CLOSURE_SYM]) {\n            var closure = callee[CLOSURE_SYM];\n            var newBase = this._regsTop;\n            this._ensureRegisterWindow(newBase, closure.fn.regCount);\n            this._regsTop = newBase + closure.fn.regCount;\n            var f = new Frame(\n              closure,\n              frame._pc,\n              frame,\n              receiver,\n              dst,\n              newBase,\n            );\n            if (closure.fn.hasRest) {\n              var restSlot = closure.fn.paramCount - 1;\n              for (var i = 0; i < restSlot; i++)\n                this._regs[newBase + i] = i < args.length ? args[i] : undefined;\n              this._regs[newBase + restSlot] = args.slice(restSlot);\n            } else {\n              for (var i = 0; i < args.length && i < closure.fn.regCount; i++)\n                this._regs[newBase + i] = args[i];\n            }\n            if (closure.fn.paramCount < closure.fn.regCount) {\n              this._regs[newBase + closure.fn.paramCount] = args;\n            }\n            this._frameStack.push(this._currentFrame);\n            this._currentFrame = f;\n          } else {\n            regs[base + dst] = callee.apply(receiver, args);\n          }\n          break;\n        }\n\n        case OP.NEW: {\n          // dst, calleeReg, argc, [argReg...]\n          var dst = this._operand();\n          var callee = regs[base + this._operand()];\n          var argc = this._operand();\n          var args = new Array(argc);\n          for (var i = 0; i < argc; i++) args[i] = regs[base + this._operand()];\n\n          if (callee && callee[CLOSURE_SYM]) {\n            var closure = callee[CLOSURE_SYM];\n            var newObj = Object.create(closure.prototype || null);\n            var newBase = this._regsTop;\n            this._ensureRegisterWindow(newBase, closure.fn.regCount);\n            this._regsTop = newBase + closure.fn.regCount;\n            var f = new Frame(closure, frame._pc, frame, newObj, dst, newBase);\n            if (closure.fn.hasRest) {\n              var restSlot = closure.fn.paramCount - 1;\n              for (var i = 0; i < restSlot; i++)\n                this._regs[newBase + i] = i < args.length ? args[i] : undefined;\n              this._regs[newBase + restSlot] = args.slice(restSlot);\n            } else {\n              for (var i = 0; i < args.length && i < closure.fn.regCount; i++)\n                this._regs[newBase + i] = args[i];\n            }\n            if (closure.fn.paramCount < closure.fn.regCount) {\n              this._regs[newBase + closure.fn.paramCount] = args;\n            }\n            f._newObj = newObj;\n            this._frameStack.push(this._currentFrame);\n            this._currentFrame = f;\n          } else {\n            // Reflect.construct is required - Object.create+apply does NOT set\n            // internal slots ([[NumberData]], [[StringData]], etc.) for built-ins.\n            regs[base + dst] = Reflect.construct(callee, args);\n          }\n          break;\n        }\n\n        case OP.RETURN: {\n          var retVal = regs[base + this._operand()];\n          this._closeUpvaluesFor(frame); // must happen before frame is abandoned\n\n          // Zero out callee's register window to limit exposing runtime values\n          var hi = frame._base + frame.closure.fn.regCount;\n          for (var i = frame._base          ; i < hi; i++)\n            this._regs[i] = undefined;\n          this._regsTop = frame._base;\n\n          if (this._frameStack.length === 0) return retVal; // main script returning\n\n          // NewExpression: When invoking from the 'new' keyword, the newly constructed object is returned instead (if the original function doesn't return an object)\n          if (frame._newObj !== null) {\n            if (typeof retVal !== \"object\" || retVal === null)\n              retVal = frame._newObj;\n          }\n\n          var parentFrame = this._frameStack.pop();\n          this._regs[parentFrame._base + frame._retDstReg] = retVal;\n          this._currentFrame = parentFrame;\n          break;\n        }\n\n        case OP.THROW:\n          throw regs[base + this._operand()];\n\n        // Closures\n        case OP.MAKE_CLOSURE: {\n          // dst, startPc, paramCount, regCount, uvCount, hasRest, [isLocal, idx, ...]\n          var dst = this._operand();\n          var startPc = this._operand();\n          var paramCount = this._operand();\n          var regCount = this._operand();\n          var uvCount = this._operand();\n          var hasRest = this._operand(); // 1 if last param is a rest element\n\n          var uvDescs = new Array(uvCount);\n          for (var i = 0; i < uvCount; i++) {\n            var isLocalRaw = this._operand();\n            var uvIndex = this._operand();\n            uvDescs[i] = { isLocal: isLocalRaw, _index: uvIndex };\n          }\n\n          var fn = {\n            paramCount: paramCount,\n            regCount: regCount,\n            startPc: startPc,\n            upvalueDescriptors: uvDescs,\n            hasRest: hasRest,\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              closure.upvalues.push(this.captureUpvalue(frame, uvd._index));\n            } else {\n              closure.upvalues.push(frame.closure.upvalues[uvd._index]);\n            }\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(\n                self.bytecode,\n                0,\n                c.fn.regCount,\n                self.constants,\n                self.globals,\n              );\n              var f = new Frame(\n                c,\n                null,\n                null,\n                this == null ? self.globals : this,\n                0,\n                0,\n              );\n              sub._currentFrame = f;\n              if (c.fn.hasRest) {\n                var restSlot = c.fn.paramCount - 1;\n                for (var i = 0; i < restSlot; i++)\n                  sub._regs[i] = i < args.length ? args[i] : undefined;\n                sub._regs[restSlot] = args.slice(restSlot);\n              } else {\n                for (var i = 0; i < args.length && i < c.fn.regCount; i++)\n                  sub._regs[i] = args[i];\n              }\n              if (c.fn.paramCount < c.fn.regCount) {\n                sub._regs[c.fn.paramCount] = args;\n              }\n              return sub.run();\n            };\n          })(closure);\n          shell[CLOSURE_SYM] = closure;\n          shell.prototype = closure.prototype; // unified prototype for new/instanceof\n          regs[base + dst] = shell;\n          break;\n        }\n\n        // Collections\n        case OP.BUILD_ARRAY: {\n          // dst, count, [elemReg...]\n          var dst = this._operand();\n          var count = this._operand();\n          var elems = new Array(count);\n          for (var i = 0; i < count; i++)\n            elems[i] = regs[base + this._operand()];\n          regs[base + dst] = elems;\n          break;\n        }\n\n        case OP.BUILD_OBJECT: {\n          // dst, pairCount, [keyReg, valReg, ...]\n          var dst = this._operand();\n          var pairCount = this._operand();\n          var o = {};\n          for (var i = 0; i < pairCount; i++) {\n            var key = regs[base + this._operand()];\n            var val = regs[base + this._operand()];\n            o[key] = val;\n          }\n          regs[base + dst] = o;\n          break;\n        }\n\n        // Object methods (getters / setters)\n        case OP.DEFINE_GETTER: {\n          // obj, key, fn\n          var obj = regs[base + this._operand()];\n          var key = regs[base + this._operand()];\n          var getterFn = regs[base + this._operand()];\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          // obj, key, fn\n          var obj = regs[base + this._operand()];\n          var key = regs[base + this._operand()];\n          var setterFn = regs[base + this._operand()];\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        // \u2500\u2500 For-in iteration \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.FOR_IN_SETUP: {\n          // dst, src \u2014 build iterator object from enumerable keys of regs[src]\n          var dst = this._operand();\n          var obj = regs[base + this._operand()];\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          regs[base + dst] = { _keys: keys, i: 0 };\n          break;\n        }\n\n        case OP.FOR_IN_NEXT: {\n          // dst, iterReg, exitTarget\n          // Advances iterator; writes next key to dst, or jumps to exitTarget when done.\n          var dst = this._operand();\n          var iter = regs[base + this._operand()];\n          var exitTarget = this._operand();\n          if (iter.i >= iter._keys.length) {\n            frame._pc = exitTarget;\n          } else {\n            regs[base + dst] = iter._keys[iter.i++];\n          }\n          break;\n        }\n\n        // \u2500\u2500 Exception handling \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        case OP.TRY_SETUP: {\n          // handlerPc, exceptionReg \u2014 push exception handler record onto current frame.\n          frame._handlerStack.push({\n            handlerPc: this._operand(),\n            exceptionReg: this._operand(),\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        // Self-modifying bytecode\n        case OP.PATCH: {\n          // destPc, sliceStart, sliceEnd\n          var destPc = this._operand();\n          var sliceStart = this._operand();\n          var sliceEnd = this._operand();\n          for (var pi = sliceStart; pi < sliceEnd; pi++) {\n            this.bytecode[destPc + (pi - sliceStart)] = this.bytecode[pi];\n          }\n          break;\n        }\n\n        case OP.JUMP_REG: {\n          // Indirect jump: allows VM to jump based on runtime values.\n          frame._pc = regs[base + this._operand()];\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\n      // Walk from the current frame upward until we find a frame that has an open 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        this._regsTop = searchFrame._base;\n        if (this._frameStack.length === 0) break;\n        searchFrame = this._frameStack.pop();\n        this._currentFrame = searchFrame;\n      }\n\n      if (!handledFrame) throw err; // if there's no handler, propagate back to host\n\n      var h = handledFrame._handlerStack.pop();\n      // Discard any call-frames that were pushed inside the try body.\n      this._frameStack.length = h.frameStackDepth;\n      // Write the caught exception directly into the designated register.\n      this._regs[handledFrame._base + h.exceptionReg] = err;\n      // Jump to the catch block.\n      handledFrame._pc = h.handlerPc;\n      this._regsTop = handledFrame._base + handledFrame.closure.fn.regCount;\n      this._currentFrame = handledFrame;\n    }\n  }\n};\n\n/* @BOOT */ // <- This comment can't be removed!\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  for (var k of Object.getOwnPropertyNames(window)) {\n    globals[k] = window[k];\n  }\n}\n\n// Transfer common primitives\nglobals.undefined = undefined;\nglobals.Infinity = Infinity;\nglobals.NaN = NaN;\n\nvar vm = new VM(\n  decodeBytecode(BYTECODE),\n  MAIN_START_PC,\n  MAIN_REG_COUNT,\n  CONSTANTS,\n  globals,\n);\nvm.run();\n";
 export const VM_RUNTIME = readVMRuntimeFile().split("@START")[1];
 export const SOURCE_NODE_SYM = Symbol("SOURCE_NODE");
 
@@ -149,21 +153,26 @@ export const OP_ORIGINAL = {
   // destPc, sliceStart, sliceEnd
 
   // ── Debug ─────────────────────────────────────────────────────────────────
-  DEBUGGER: 57
+  DEBUGGER: 57,
+  // ── Indirect jump (register-addressed) ───────────────────────────────────
+  // Used by Dispatcher pass. The target PC is read from a register
+  // rather than encoded as a bytecode immediate, so static analysis cannot
+  // determine the destination without tracking register values at runtime.
+  JUMP_REG: 58 // src — frame._pc = regs[src]
 };
 
 // ── Scope ─────────────────────────────────────────────────────────────────────
-// Maps variable names to register indices (slot numbers).
-// Locals are allocated at compile time; zero name lookups at runtime.
+// Maps variable names to virtual RegisterOperands.
+// Locals are allocated at compile time via ctx._newReg(); zero name lookups at runtime.
+// resolveRegisters() assigns concrete slot indices before serialization.
 class Scope {
   constructor(parent = null) {
     this.parent = parent;
     this._locals = new Map();
-    this._next = 0;
   }
-  define(name) {
+  define(name, ctx) {
     if (!this._locals.has(name)) {
-      this._locals.set(name, this._next++);
+      this._locals.set(name, ctx._newReg());
     }
     return this._locals.get(name);
   }
@@ -171,7 +180,7 @@ class Scope {
     if (this._locals.has(name)) {
       return {
         kind: "local",
-        slot: this._locals.get(name)
+        reg: this._locals.get(name)
       };
     }
     if (this.parent) return this.parent.resolve(name);
@@ -179,38 +188,68 @@ class Scope {
       kind: "global"
     };
   }
-  get localCount() {
-    return this._next;
-  }
 }
 
 // ── FnContext ─────────────────────────────────────────────────────────────────
 // Compiler-side state for the function currently being compiled.
 // Distinct from the runtime Frame — this is compile-time only.
+//
+// Virtual-register model (Lua/LLVM style):
+//   Every allocReg() / _newReg() call returns a fresh RegisterOperand with a
+//   unique (fnId, id) pair.  IDs are never reused — resolveRegisters() does
+//   liveness-aware slot assignment and sets desc.regCount at the end of the
+//   pipeline, just like resolveLabels() fills in jump targets.
 class FnContext {
-  // Register allocator.  Locals occupy regs[0..scope.localCount-1];
-  // temps are allocated above that and freed at statement boundaries.
-  regTop = 0;
-  maxRegTop = 0;
-  constructor(compiler, parentCtx = null) {
+  // index: RegisterOperand if isLocal (register in parent frame), number if upvalue chain
+
+  // Unique ID for this function — matches the index in compiler.fnDescriptors.
+
+  // Monotonically increasing counter; each call to _newReg() bumps it.
+  _nextId = 0;
+  constructor(compiler, parentCtx = null, fnId = 0) {
     this.compiler = compiler;
     this.parentCtx = parentCtx;
     this.scope = new Scope();
     this.bc = [];
     this.upvalues = [];
+    this._fnId = fnId;
   }
 
-  /** Allocate the next free temp register and return its index. */
+  /** Create a new virtual register owned by this function. */
+  _newReg() {
+    return b.registerOperand(this._nextId++, this._fnId);
+  }
+
+  /**
+   * Allocate a short-lived temporary register (pool "temp::").
+   * resolveRegisters() will reuse its concrete slot once its live range ends.
+   * Do NOT use for named locals or upvalue-captured variables — use _newReg()
+   * via scope.define() for those, so they stay in the stable "local::" pool.
+   */
   allocReg() {
-    const r = this.regTop++;
-    if (this.regTop > this.maxRegTop) this.maxRegTop = this.regTop;
-    return r;
+    return b.registerOperand(this._nextId++, this._fnId, {
+      kind: "temp"
+    });
   }
 
-  /** Release all temps above the local region. Called at each statement boundary. */
-  resetTemps() {
-    this.regTop = this.scope.localCount;
+  /**
+   * Emit a freeReg pseudo-instruction to explicitly end a temporary's live range.
+   *
+   * NOTE: This is extraneous for any programmatically generated IR.
+   * resolveRegisters() already computes lastUse as the last instruction index
+   * where the register appears as a real operand — which is always the tightest
+   * correct bound when you stop emitting a register after its last logical use.
+   * freeReg is only needed in the rare case where a register has a late syntactic
+   * appearance that does NOT represent its true logical death (e.g. a dummy read
+   * emitted for side-effects long after the value is logically dead). No current
+   * pass in this codebase uses it; it is kept as an extension point only.
+   */
+  freeReg(bc, reg) {
+    bc.push([null, b.freeRegOperand(reg)]);
   }
+
+  /** No-op kept for call-site compatibility; liveness is handled by resolveRegisters. */
+  resetTemps() {}
   addUpvalue(name, isLocal, index) {
     const existing = this.upvalues.findIndex(u => u.name === name);
     if (existing !== -1) return existing;
@@ -225,11 +264,20 @@ class FnContext {
 }
 // ── Compiler ──────────────────────────────────────────────────────────────────
 export class Compiler {
-  /** Internal variable slot registry.
-   *  globally: shared name→index pool (written on first sight; reused by non-random mode or by 50% chance in random mode).
-   *  opcodes:  per-opcode source-of-truth — all assignment lookups are read/written here. */
-
+  log(...messages) {
+    if (this.options.verbose) {
+      console.log(...messages);
+    }
+  }
+  _cloneRegisterOperand(operand) {
+    if (!operand || typeof operand !== "object") return operand;
+    if (operand.type !== "register") return operand;
+    return JSON.parse(JSON.stringify(operand));
+  }
   emit(bc, instr, node) {
+    for (let i = 1; i < instr.length; i++) {
+      instr[i] = this._cloneRegisterOperand(instr[i]);
+    }
     bc.push(instr);
     instr[SOURCE_NODE_SYM] = node;
   }
@@ -249,10 +297,6 @@ export class Compiler {
     this.MICRO_OPS = {};
     this.SPECIALIZED_OPS = {};
     this.ALIASED_OPS = {};
-    this._internals = {
-      globally: new Map(),
-      opcodes: new Map()
-    };
     this.OP = {
       ...OP_ORIGINAL
     };
@@ -280,7 +324,7 @@ export class Compiler {
     if (ctx.scope._locals.has(name)) {
       return {
         kind: "local",
-        slot: ctx.scope._locals.get(name)
+        reg: ctx.scope._locals.get(name)
       };
     }
     if (!ctx.parentCtx) return {
@@ -291,7 +335,7 @@ export class Compiler {
       kind: "global"
     };
     const isLocal = parentResult.kind === "local";
-    const index = isLocal ? parentResult.slot : parentResult.index;
+    const index = isLocal ? parentResult.reg : parentResult.index;
     const uvIdx = ctx.addUpvalue(name, isLocal ? 1 : 0, index);
     return {
       kind: "upvalue",
@@ -300,31 +344,30 @@ export class Compiler {
   }
 
   // ── Variable hoisting ──────────────────────────────────────────────────────
-  // Pre-scan a statement list and reserve scope slots for every var declaration,
-  // function declaration, for-in iterator, and try-catch binding.
-  // Must be called before compilation begins so that ctx.regTop can be set
-  // safely above ALL locals (including those declared late in the body).
-  _hoistVars(stmts, scope) {
+  // Pre-scan a statement list and reserve virtual registers for every var
+  // declaration, function declaration, for-in iterator, and try-catch binding.
+  // Must be called before any emit so that locals are allocated before temps.
+  _hoistVars(stmts, scope, ctx) {
     for (const stmt of stmts) {
       switch (stmt.type) {
         case "VariableDeclaration":
           for (const decl of stmt.declarations) {
-            if (decl.id.type === "Identifier") scope.define(decl.id.name);
+            if (decl.id.type === "Identifier") scope.define(decl.id.name, ctx);
           }
           break;
         case "FunctionDeclaration":
-          if (stmt.id) scope.define(stmt.id.name);
+          if (stmt.id) scope.define(stmt.id.name, ctx);
           break;
         case "BlockStatement":
-          this._hoistVars(stmt.body, scope);
+          this._hoistVars(stmt.body, scope, ctx);
           break;
         case "IfStatement":
           {
             const cons = stmt.consequent.type === "BlockStatement" ? stmt.consequent.body : [stmt.consequent];
-            this._hoistVars(cons, scope);
+            this._hoistVars(cons, scope, ctx);
             if (stmt.alternate) {
               const alt = stmt.alternate.type === "BlockStatement" ? stmt.alternate.body : [stmt.alternate];
-              this._hoistVars(alt, scope);
+              this._hoistVars(alt, scope, ctx);
             }
             break;
           }
@@ -332,65 +375,73 @@ export class Compiler {
         case "DoWhileStatement":
           {
             const body = stmt.body.type === "BlockStatement" ? stmt.body.body : [stmt.body];
-            this._hoistVars(body, scope);
+            this._hoistVars(body, scope, ctx);
             break;
           }
         case "ForStatement":
           {
             if (stmt.init?.type === "VariableDeclaration") {
               for (const decl of stmt.init.declarations) {
-                if (decl.id.type === "Identifier") scope.define(decl.id.name);
+                if (decl.id.type === "Identifier") scope.define(decl.id.name, ctx);
               }
             }
             const body = stmt.body.type === "BlockStatement" ? stmt.body.body : [stmt.body];
-            this._hoistVars(body, scope);
+            this._hoistVars(body, scope, ctx);
             break;
           }
         case "ForInStatement":
           {
-            // Reserve a hidden register for the iterator object.
-            stmt._iterSlot = scope._next++;
+            // Reserve a hidden virtual register for the iterator object.
+            stmt._iterSlot = ctx._newReg();
             if (stmt.left.type === "VariableDeclaration") {
               for (const decl of stmt.left.declarations) {
-                if (decl.id.type === "Identifier") scope.define(decl.id.name);
+                if (decl.id.type === "Identifier") scope.define(decl.id.name, ctx);
               }
             }
             const body = stmt.body.type === "BlockStatement" ? stmt.body.body : [stmt.body];
-            this._hoistVars(body, scope);
+            this._hoistVars(body, scope, ctx);
             break;
           }
         case "SwitchStatement":
-          for (const c of stmt.cases) this._hoistVars(c.consequent, scope);
+          for (const c of stmt.cases) this._hoistVars(c.consequent, scope, ctx);
           break;
         case "TryStatement":
-          this._hoistVars(stmt.block.body, scope);
+          this._hoistVars(stmt.block.body, scope, ctx);
           if (stmt.handler) {
             if (stmt.handler.param?.type === "Identifier") {
               // Catch parameter IS the exception register.
-              scope.define(stmt.handler.param.name);
+              scope.define(stmt.handler.param.name, ctx);
             } else {
-              // No catch binding – reserve a dummy slot for the exception value.
-              stmt._exceptionSlot = scope._next++;
+              // No catch binding – reserve a dummy virtual register for the exception value.
+              stmt._exceptionSlot = ctx._newReg();
             }
-            this._hoistVars(stmt.handler.body.body, scope);
+            this._hoistVars(stmt.handler.body.body, scope, ctx);
           }
           break;
         case "LabeledStatement":
-          this._hoistVars([stmt.body], scope);
+          this._hoistVars([stmt.body], scope, ctx);
           break;
       }
     }
   }
+  profileData = {
+    transforms: {}
+  };
 
   // ── Entry point ───────────────────────────────────────────────────────────
   compile(source) {
+    let startedAt = now();
     const ast = parse(source, {
-      sourceType: "script"
+      sourceType: "script",
+      allowReturnOutsideFunction: true
     });
+    this.profileData.parseTime = now() - startedAt;
     return this.compileAST(ast);
   }
   compileAST(ast) {
+    let startedAt = now();
     this._compileMain(ast.program.body);
+    this.profileData.compileTime = now() - startedAt;
     return this.bytecode;
   }
 
@@ -402,28 +453,31 @@ export class Compiler {
     const entryLabel = this._makeLabel(`fn_${fnIdx}`);
     var desc = {};
     this.fnDescriptors.push(desc);
-    const ctx = new FnContext(this, this._currentCtx);
+    const ctx = new FnContext(this, this._currentCtx, fnIdx);
     const savedCtx = this._currentCtx;
     this._currentCtx = ctx;
     const savedLoopStack = this._loopStack;
     this._loopStack = [];
 
-    // 1. Define parameters (occupy regs 0..paramCount-1).
+    // 1. Define parameters as virtual registers (occupy the first IDs in order).
+    let hasRest = false;
     for (const param of node.params) {
-      let identifier = param.type === "AssignmentPattern" ? param.left : param;
-      ok(identifier.type === "Identifier", "Only simple identifiers allowed as parameters");
-      ctx.scope.define(identifier.name);
+      if (param.type === "RestElement") {
+        ok(param.argument.type === "Identifier", "Rest element must be a simple identifier");
+        hasRest = true;
+        ctx.scope.define(param.argument.name, ctx);
+      } else {
+        let identifier = param.type === "AssignmentPattern" ? param.left : param;
+        ok(identifier.type === "Identifier", "Only simple identifiers allowed as parameters");
+        ctx.scope.define(identifier.name, ctx);
+      }
     }
 
-    // 2. Reserve the `arguments` slot (reg index = paramCount).
-    ctx.scope.define("arguments");
+    // 2. Reserve the `arguments` virtual register (immediately after params).
+    ctx.scope.define("arguments", ctx);
 
-    // 3. Hoist all var declarations so temps start above every local.
-    this._hoistVars(node.body.body, ctx.scope);
-
-    // 4. Temps now start above all locals.
-    ctx.regTop = ctx.scope.localCount;
-    ctx.maxRegTop = ctx.regTop;
+    // 3. Hoist all var declarations so locals are allocated before any temps.
+    this._hoistVars(node.body.body, ctx.scope, ctx);
 
     // 5. Emit default-value guards.
     for (const param of node.params) {
@@ -469,25 +523,32 @@ export class Compiler {
     desc.bytecode = ctx.bc;
     desc._fnIdx = fnIdx;
     desc.paramCount = node.params.length;
-    desc.regCount = ctx.maxRegTop; // total registers needed at runtime
+    desc.hasRest = hasRest;
+    // regCount is NOT set here — resolveRegisters() fills it after liveness analysis.
     desc.upvalues = ctx.upvalues.slice();
+    desc.ctx = ctx;
     return desc;
   }
 
   // Emit MAKE_CLOSURE with all metadata as inline operands.
   // Layout: dst, startPc, paramCount, regCount, uvCount, [isLocal, idx, …]
+  // regCount is emitted as a fnRegCount IR operand; resolveRegisters() fills it.
   _emitMakeClosure(desc, node, bc) {
     const ctx = this._currentCtx;
     const dst = ctx.allocReg();
     const uvOperands = [];
     for (const uv of desc.upvalues) {
       uvOperands.push(uv.isLocal ? 1 : 0);
-      uvOperands.push(uv.index);
+      uvOperands.push(uv.index); // RegisterOperand if isLocal, number if upvalue chain
     }
     this.emit(bc, [this.OP.MAKE_CLOSURE, dst, {
       type: "label",
       label: desc.entryLabel
-    }, desc.paramCount, desc.regCount, desc.upvalues.length, ...uvOperands], node);
+    }, desc.paramCount, b.fnRegCountOperand(desc._fnIdx),
+    // resolved by resolveRegisters()
+    desc.upvalues.length, desc.hasRest ? 1 : 0,
+    // 1 = last param is a rest element
+    ...uvOperands], node);
     return dst;
   }
 
@@ -501,7 +562,7 @@ export class Compiler {
       async: false,
       generator: false,
       params: [],
-      id: null,
+      id: t.identifier("main"),
       body: t.blockStatement([...body])
     });
     for (const descriptor of this.fnDescriptors) {
@@ -513,7 +574,8 @@ export class Compiler {
         this.bytecode.push(instr);
       }
     }
-    this.mainRegCount = mainCtx.maxRegTop;
+
+    // mainRegCount is set by resolveRegisters() after the pipeline runs.
     this.mainFn = desc;
     this._currentCtx = savedCtx;
   }
@@ -592,14 +654,8 @@ export class Compiler {
                   this.emit(bc, [this.OP.MOVE, slot, srcReg], node);
                 }
               } else {
-                this.emit(bc, [this.OP.MOVE, slot, ctx.allocReg()], node);
-                // Load undefined into the just-allocated temp, then move.
-                // Actually: just emit LOAD_CONST directly into slot.
-                // Undo the allocReg – instead emit directly:
-                ctx.regTop--; // undo the allocReg above
-                const tmp = ctx.allocReg();
-                this.emit(bc, [this.OP.LOAD_CONST, tmp, b.constantOperand(undefined)], node);
-                if (tmp !== slot) this.emit(bc, [this.OP.MOVE, slot, tmp], node);
+                // No initializer: var x; → load undefined directly into the local's register.
+                this.emit(bc, [this.OP.LOAD_CONST, slot, b.constantOperand(undefined)], node);
               }
             } else {
               if (decl.init) {
@@ -617,14 +673,11 @@ export class Compiler {
       case "IfStatement":
         {
           const elseOrEndLabel = this._makeLabel("if_else");
-          const savedTop = ctx.regTop;
           const testReg = this._compileExpr(node.test, scope, bc);
           this.emit(bc, [this.OP.JUMP_IF_FALSE, testReg, {
             type: "label",
             label: elseOrEndLabel
           }], node);
-          ctx.regTop = savedTop; // free test temps
-
           const consequentBody = node.consequent.type === "BlockStatement" ? node.consequent.body : [node.consequent];
           for (const stmt of consequentBody) {
             this._compileStatement(stmt, scope, bc);
@@ -671,13 +724,11 @@ export class Compiler {
             type: "defineLabel",
             label: loopTopLabel
           }], node);
-          const savedTop = ctx.regTop;
           const testReg = this._compileExpr(node.test, scope, bc);
           this.emit(bc, [this.OP.JUMP_IF_FALSE, testReg, {
             type: "label",
             label: exitLabel
           }], node);
-          ctx.regTop = savedTop;
           const whileBody = node.body.type === "BlockStatement" ? node.body.body : [node.body];
           for (const stmt of whileBody) {
             this._compileStatement(stmt, scope, bc);
@@ -718,13 +769,11 @@ export class Compiler {
             type: "defineLabel",
             label: continueLabel
           }], node);
-          const savedTop = ctx.regTop;
           const testReg = this._compileExpr(node.test, scope, bc);
           this.emit(bc, [this.OP.JUMP_IF_FALSE, testReg, {
             type: "label",
             label: exitLabel
           }], node);
-          ctx.regTop = savedTop;
           this.emit(bc, [this.OP.JUMP, {
             type: "label",
             label: loopTopLabel
@@ -762,13 +811,11 @@ export class Compiler {
             label: loopTopLabel
           }], node);
           if (node.test) {
-            const savedTop = ctx.regTop;
             const testReg = this._compileExpr(node.test, scope, bc);
             this.emit(bc, [this.OP.JUMP_IF_FALSE, testReg, {
               type: "label",
               label: exitLabel
             }], node);
-            ctx.regTop = savedTop;
           }
           const forBody = node.body.type === "BlockStatement" ? node.body.body : [node.body];
           for (const stmt of forBody) {
@@ -880,7 +927,6 @@ export class Compiler {
             const cas = cases[i];
             if (cas.test === null) continue;
             const nextCheckLabel = this._makeLabel("sw_next");
-            const savedTop = ctx.regTop;
             const caseValReg = this._compileExpr(cas.test, scope, bc);
             const cmpReg = ctx.allocReg();
             this.emit(bc, [this.OP.EQ, cmpReg, discReg, caseValReg], node);
@@ -888,7 +934,6 @@ export class Compiler {
               type: "label",
               label: nextCheckLabel
             }], node);
-            ctx.regTop = savedTop;
             this.emit(bc, [this.OP.JUMP, {
               type: "label",
               label: caseLabels[i]
@@ -992,7 +1037,7 @@ export class Compiler {
           } else if (node.left.type === "Identifier") {
             const res = this._resolve(node.left.name, this._currentCtx);
             if (res.kind === "local") {
-              if (keyReg !== res.slot) this.emit(bc, [this.OP.MOVE, res.slot, keyReg], node);
+              if (keyReg !== res.reg) this.emit(bc, [this.OP.MOVE, res.reg, keyReg], node);
             } else if (res.kind === "upvalue") {
               this.emit(bc, [this.OP.STORE_UPVALUE, res.index, keyReg], node);
             } else {
@@ -1076,12 +1121,38 @@ export class Compiler {
   }
 
   // ── Expressions ───────────────────────────────────────────────────────────
-  // Returns the register index that holds the result.
-  // For local variables: returns their slot directly (no instruction emitted).
-  // For all others: allocates a fresh temp register, emits the instruction(s),
+  // Returns the virtual RegisterOperand that holds the result.
+  // For local variables: returns their RegisterOperand directly (no instruction emitted).
+  // For all others: allocates a fresh virtual register, emits the instruction(s),
   // and returns the allocated register.
   _compileExpr(node, scope, bc) {
     const ctx = this._currentCtx;
+
+    // Intrinsic for emitting raw bytecode, useful for emitting register address
+    if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "_VM_") {
+      const argJSONStrng = node.arguments[0].value;
+      console.log("Emitting raw bytecode from _VM_ call:", argJSONStrng);
+      const arg = JSON.parse(argJSONStrng);
+      console.log("Parsed bytecode:", arg);
+      const dst = ctx.allocReg();
+      let operand = arg[0];
+      this.emit(bc, [this.OP.MOVE, dst, operand], node); // emit a breakpoint for easy inspection
+
+      return dst;
+    }
+
+    // _VM_JUMP_("labelName") — emits JUMP with a label operand.
+    // Used by bytecode transforms (e.g. CFF) via Template to express jumps
+    // to labels that exist in the parent compiler's bytecode stream.
+    if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "_VM_JUMP_") {
+      const label = node.arguments[0].value;
+      bc.push([this.OP.JUMP, {
+        type: "label",
+        label
+      }]);
+      // Return a dummy register — caller (ExpressionStatement) discards it.
+      return ctx.allocReg();
+    }
     switch (node.type) {
       case "NumericLiteral":
       case "StringLiteral":
@@ -1100,7 +1171,7 @@ export class Compiler {
       case "Identifier":
         {
           const res = this._resolve(node.name, this._currentCtx);
-          if (res.kind === "local") return res.slot; // register IS the local
+          if (res.kind === "local") return res.reg; // register IS the local
           if (res.kind === "upvalue") {
             const dst = ctx.allocReg();
             this.emit(bc, [this.OP.LOAD_UPVALUE, dst, res.index], node);
@@ -1129,9 +1200,7 @@ export class Compiler {
         {
           const exprs = node.expressions;
           for (let i = 0; i < exprs.length - 1; i++) {
-            const savedTop = ctx.regTop;
-            this._compileExpr(exprs[i], scope, bc);
-            ctx.regTop = savedTop; // discard intermediate result
+            this._compileExpr(exprs[i], scope, bc); // result discarded; virtual reg is unused
           }
           return this._compileExpr(exprs[exprs.length - 1], scope, bc);
         }
@@ -1140,17 +1209,13 @@ export class Compiler {
           const n = node;
           const elseLabel = this._makeLabel("ternary_else");
           const endLabel = this._makeLabel("ternary_end");
-
-          // Compile test; free its temps after the jump is emitted.
-          const baseTop = ctx.regTop;
           const testReg = this._compileExpr(n.test, scope, bc);
           this.emit(bc, [this.OP.JUMP_IF_FALSE, testReg, {
             type: "label",
             label: elseLabel
           }], node);
-          ctx.regTop = baseTop; // free test temps
 
-          // Reserve reg_result at the base of the temp space.
+          // reg_result is a stable virtual register both branches write into.
           const reg_result = ctx.allocReg();
 
           // Consequent branch.
@@ -1161,22 +1226,18 @@ export class Compiler {
             label: endLabel
           }], node);
 
-          // Alternate branch: reset to baseTop then re-reserve reg_result.
+          // Alternate branch — each allocReg() gets a unique virtual ID so no
+          // slot collision is possible; no need to "re-occupy" reg_result.
           this.emit(bc, [null, {
             type: "defineLabel",
             label: elseLabel
           }], node);
-          ctx.regTop = baseTop;
-          ctx.allocReg(); // re-occupy reg_result slot
           const altReg = this._compileExpr(n.alternate, scope, bc);
           if (altReg !== reg_result) this.emit(bc, [this.OP.MOVE, reg_result, altReg], node);
           this.emit(bc, [null, {
             type: "defineLabel",
             label: endLabel
           }], node);
-
-          // Leave reg_result allocated above baseTop.
-          ctx.regTop = baseTop + 1;
           return reg_result;
         }
       case "LogicalExpression":
@@ -1185,9 +1246,7 @@ export class Compiler {
           const endLabel = this._makeLabel("logical_end");
           const isOr = n.operator === "||";
           if (!isOr && n.operator !== "&&") throw new Error(`Unsupported logical operator: ${n.operator}`);
-          const baseTop = ctx.regTop;
           const lhsReg = this._compileExpr(n.left, scope, bc);
-          ctx.regTop = baseTop;
           const reg_result = ctx.allocReg();
           if (lhsReg !== reg_result) this.emit(bc, [this.OP.MOVE, reg_result, lhsReg], node);
 
@@ -1199,15 +1258,12 @@ export class Compiler {
           }], node);
 
           // Compile RHS into reg_result.
-          ctx.regTop = baseTop;
-          ctx.allocReg(); // re-occupy reg_result
           const rhsReg = this._compileExpr(n.right, scope, bc);
           if (rhsReg !== reg_result) this.emit(bc, [this.OP.MOVE, reg_result, rhsReg], node);
           this.emit(bc, [null, {
             type: "defineLabel",
             label: endLabel
           }], node);
-          ctx.regTop = baseTop + 1;
           return reg_result;
         }
       case "TemplateLiteral":
@@ -1269,7 +1325,8 @@ export class Compiler {
 
           // Shared: compute curReg +/- 1 into newReg, return [postfixResult, newReg]
           const applyBump = curReg => {
-            const postfixReg = n.prefix ? -1 : (() => {
+            const postfixReg = n.prefix ? curReg // prefix: postfix copy unused; caller returns newReg instead
+            : (() => {
               const r = ctx.allocReg();
               this.emit(bc, [this.OP.MOVE, r, curReg], node);
               return r;
@@ -1301,7 +1358,7 @@ export class Compiler {
           const res = this._resolve(name, this._currentCtx);
           let curReg;
           if (res.kind === "local") {
-            curReg = res.slot;
+            curReg = res.reg;
           } else if (res.kind === "upvalue") {
             curReg = ctx.allocReg();
             this.emit(bc, [this.OP.LOAD_UPVALUE, curReg, res.index], node);
@@ -1311,7 +1368,7 @@ export class Compiler {
           }
           const [postfixReg, newReg] = applyBump(curReg);
           if (res.kind === "local") {
-            this.emit(bc, [this.OP.MOVE, res.slot, newReg], node);
+            this.emit(bc, [this.OP.MOVE, res.reg, newReg], node);
           } else if (res.kind === "upvalue") {
             this.emit(bc, [this.OP.STORE_UPVALUE, res.index, newReg], node);
           } else {
@@ -1369,7 +1426,7 @@ export class Compiler {
             // Load current value of the variable.
             let curReg;
             if (res.kind === "local") {
-              curReg = res.slot;
+              curReg = res.reg;
             } else if (res.kind === "upvalue") {
               curReg = ctx.allocReg();
               this.emit(bc, [this.OP.LOAD_UPVALUE, curReg, res.index], node);
@@ -1386,8 +1443,8 @@ export class Compiler {
 
           // Store result and return it.
           if (res.kind === "local") {
-            if (rhsReg !== res.slot) this.emit(bc, [this.OP.MOVE, res.slot, rhsReg], node);
-            return res.slot;
+            if (rhsReg !== res.reg) this.emit(bc, [this.OP.MOVE, res.reg, rhsReg], node);
+            return res.reg;
           } else if (res.kind === "upvalue") {
             this.emit(bc, [this.OP.STORE_UPVALUE, res.index, rhsReg], node);
             return rhsReg;
@@ -1608,6 +1665,7 @@ class Serializer {
     const v = constants[idx];
     if (!key) return v;
     if (typeof v === "number") return v ^ key;
+    if (typeof v !== "string") return v;
     // String: base64 → u16 LE byte pairs → XOR with (key + i) (mirrors _readConstant)
     const bytes = Buffer.from(v, "base64");
     let out = "";
@@ -1617,16 +1675,25 @@ class Serializer {
     }
     return out;
   }
-  _serializeInstr(instr) {
+  _generateComment(instr) {
     const op = instr[0];
     const operands = instr.slice(1);
-    const constants = this.compiler.constants;
-    const resolvedOperands = operands.filter(operand => operand?.placeholder !== true).map(o => o?.resolvedValue ?? o);
-    for (const o of resolvedOperands) {
-      ok(typeof o === "number", "Unresolved operand: " + JSON.stringify(o));
-      ok(o >= 0 && o <= 0xffff, `Operand overflow (max 0xFFFF u16): ${o}`);
+    if (op === null && operands[0]?.type === "defineLabel") {
+      const label = operands[0].label;
+      return `${label}:`;
     }
-    ok(op >= 0 && op <= 0xffff, `Opcode overflow (max 0xFFFF u16): ${op}`);
+    const constants = this.compiler.constants;
+    const emittedOperands = operands.filter(operand => operand?.placeholder !== true);
+    const resolvedOperands = emittedOperands.map(o => o?.resolvedValue ?? o);
+    const displayOperands = operands.map((o, i) => {
+      const resolvedValue = resolvedOperands[i];
+      const label = o?.label;
+      let displayOperand = resolvedValue;
+      if (label) {
+        return label;
+      }
+      return displayOperand;
+    });
     let name = this.OP_NAME[op];
     if (!name || name.includes("{")) {
       name = `OP_${op}`;
@@ -1637,73 +1704,79 @@ class Serializer {
     }
     const sourceNode = instr[SOURCE_NODE_SYM];
     const sourceLocation = sourceNode?.loc ? [formatLoc(sourceNode.loc.start), formatLoc(sourceNode.loc.end)].filter(Boolean).join("-") : "";
-    if (resolvedOperands.length > 0) {
+    if (displayOperands.length > 0) {
       // Operand[0] is always `dst` for instruction types that produce a value.
-      const dst = resolvedOperands[0];
+      const dst = displayOperands[0];
       switch (op) {
         case this.OP.LOAD_CONST:
           {
             // resolvedOperands: [dst, constIdx, concealKey]
-            const val = this._decryptConst(constants, resolvedOperands[1], resolvedOperands[2]);
+            const val = this._decryptConst(constants, displayOperands[1], displayOperands[2]);
             comment += `  reg[${dst}] = ${this._serializeConst(val)}`;
             break;
           }
+        case this.OP.LOAD_INT:
+          {
+            // resolvedOperands: [dst, intValue]
+            comment += `  reg[${dst}] = ${displayOperands[1]}`;
+            break;
+          }
         case this.OP.LOAD_GLOBAL:
           // resolvedOperands: [dst, constIdx, concealKey]
-          comment += `  reg[${dst}] = ${this._decryptConst(constants, resolvedOperands[1], resolvedOperands[2])}`;
+          comment += `  reg[${dst}] = ${this._decryptConst(constants, displayOperands[1], displayOperands[2])}`;
           break;
         case this.OP.STORE_GLOBAL:
           // resolvedOperands: [constIdx, concealKey, srcReg]
-          comment += `  ${this._decryptConst(constants, resolvedOperands[0], resolvedOperands[1])} = reg[${resolvedOperands[2]}]`;
+          comment += `  ${this._decryptConst(constants, displayOperands[0], displayOperands[1])} = reg[${displayOperands[2]}]`;
           break;
         case this.OP.LOAD_UPVALUE:
-          comment += `  reg[${dst}] = upvalue[${resolvedOperands[1]}]`;
+          comment += `  reg[${dst}] = upvalue[${displayOperands[1]}]`;
           break;
         case this.OP.STORE_UPVALUE:
-          comment += `  upvalue[${resolvedOperands[0]}] = reg[${resolvedOperands[1]}]`;
+          comment += `  upvalue[${displayOperands[0]}] = reg[${displayOperands[1]}]`;
           break;
         case this.OP.MOVE:
-          comment += `  reg[${dst}] = reg[${resolvedOperands[1]}]`;
+          comment += `  reg[${dst}] = reg[${displayOperands[1]}]`;
           break;
         case this.OP.MAKE_CLOSURE:
-          comment += `  reg[${dst}] PC=${resolvedOperands[1]} (params=${resolvedOperands[2]} regs=${resolvedOperands[3]} upvalues=${resolvedOperands[4]})`;
+          comment += `  reg[${dst}] PC=${displayOperands[1]} (params=${displayOperands[2]} regs=${displayOperands[3]} upvalues=${displayOperands[4]})`;
           break;
         case this.OP.CALL:
-          comment += `  reg[${dst}] = reg[${resolvedOperands[1]}](${resolvedOperands[2]} args)`;
+          comment += `  reg[${dst}] = reg[${displayOperands[1]}](${displayOperands.slice(3).map(v => `reg[${v}]`).join(", ")})`;
           break;
         case this.OP.CALL_METHOD:
-          comment += `  reg[${dst}] = reg[${resolvedOperands[2]}](recv=reg[${resolvedOperands[1]}], ${resolvedOperands[3]} args)`;
+          comment += `  reg[${dst}] = reg[${displayOperands[2]}](recv=reg[${displayOperands[1]}], ${displayOperands[3]} args)`;
           break;
         case this.OP.NEW:
-          comment += `  reg[${dst}] = new reg[${resolvedOperands[1]}](${resolvedOperands[2]} args)`;
+          comment += `  reg[${dst}] = new reg[${displayOperands[1]}](${displayOperands[2]} args)`;
           break;
         case this.OP.RETURN:
-          comment += `  reg[${resolvedOperands[0]}]`;
+          comment += `  reg[${displayOperands[0]}]`;
           break;
         case this.OP.BUILD_ARRAY:
-          comment += `  reg[${dst}] = [${resolvedOperands[2]} elems]`;
+          comment += `  reg[${dst}] = [${displayOperands[2]} elems]`;
           break;
         case this.OP.BUILD_OBJECT:
-          comment += `  reg[${dst}] = {${resolvedOperands[1]} pairs}`;
+          comment += `  reg[${dst}] = {${displayOperands[1]} pairs}`;
           break;
         case this.OP.GET_PROP:
-          comment += `  reg[${dst}] = reg[${resolvedOperands[1]}][reg[${resolvedOperands[2]}]]`;
+          comment += `  reg[${dst}] = reg[${displayOperands[1]}][reg[${displayOperands[2]}]]`;
           break;
         case this.OP.SET_PROP:
-          comment += `  reg[${resolvedOperands[0]}][reg[${resolvedOperands[1]}]] = reg[${resolvedOperands[2]}]`;
+          comment += `  reg[${displayOperands[0]}][reg[${displayOperands[1]}]] = reg[${displayOperands[2]}]`;
+          break;
+        case this.OP.JUMP_REG:
+          comment += `  PC = reg[${displayOperands[0]}]`;
           break;
         default:
-          comment += resolvedOperands.length === 1 ? `  ${resolvedOperands[0]}` : `  [${resolvedOperands.join(", ")}]`;
+          comment += displayOperands.length === 1 ? `  ${displayOperands[0]}` : `  [${displayOperands.join(", ")}]`;
       }
     }
     comment = comment.padEnd(50) + sourceLocation;
     const values = [op, ...resolvedOperands];
     const instrText = `[${values.join(", ")}]`;
     const text = `${(instrText + ",").padEnd(20)} ${comment}`;
-    return {
-      text,
-      values
-    };
+    return text;
   }
   _serializeConstants(constants) {
     const lines = ["var CONSTANTS = ["];
@@ -1716,14 +1789,23 @@ class Serializer {
   _serializeBytecode(bytecode, compiler) {
     const serialized = [];
     for (const instr of bytecode) {
-      if (instr[0] === null) continue;
+      const op = instr[0];
+      const operands = instr.slice(1);
+      if (instr[0] === null) continue; // null opcodes are not emitted
+
+      const resolvedValues = operands.map(o => o?.resolvedValue ?? o);
       const specializedOpInfo = compiler.SPECIALIZED_OPS[instr[0]];
       if (specializedOpInfo) {
-        const operands = instr.slice(1);
-        const resolvedValues = operands.map(o => o?.resolvedValue ?? o);
         const originalName = compiler.OP_NAME[specializedOpInfo.originalOp];
         compiler.OP_NAME[instr[0]] = `${originalName}_${resolvedValues.join("_")}`;
       }
+
+      // Validate no opcode or operand exceeds u16 limit
+      for (const o of resolvedValues) {
+        ok(typeof o === "number", "Unresolved operand: " + JSON.stringify(o));
+        ok(o >= 0 && o <= 0xffffffff, `Operand overflow (max 0xFFFFFFFF u32): ${o}`);
+      }
+      ok(op >= 0 && op <= 0xffffffff, `Opcode overflow (max 0xFFFFFFFF u32): ${op}`);
       serialized.push(instr);
     }
     return {
@@ -1731,10 +1813,12 @@ class Serializer {
     };
   }
   _encodeBytecode(flat) {
-    const buf = new Uint8Array(flat.length * 2);
+    const buf = new Uint8Array(flat.length * 4);
     flat.forEach((w, i) => {
-      buf[i * 2] = w & 0xff;
-      buf[i * 2 + 1] = w >>> 8 & 0xff;
+      buf[i * 4] = w & 0xff;
+      buf[i * 4 + 1] = w >>> 8 & 0xff;
+      buf[i * 4 + 2] = w >>> 16 & 0xff;
+      buf[i * 4 + 3] = w >>> 24 & 0xff;
     });
     return Buffer.from(buf).toString("base64");
   }
@@ -1767,58 +1851,121 @@ class Serializer {
   }
 }
 export async function compileAndSerialize(sourceCode, options) {
+  let obfuscationStartedAt = now();
   const compiler = new Compiler(options);
   let bytecode = compiler.compile(sourceCode);
   const passes = [];
-  passes.push(concealConstants);
-  if (options.specializedOpcodes) {
-    passes.push(specializedOpcodes);
+  if (options.stringConcealing) {
+    passes.push({
+      pass: stringConcealing,
+      name: "stringConcealing"
+    });
   }
-  if (options.microOpcodes) {
-    passes.push(microOpcodes);
+
+  // CFF and Dispatcher both run before resolveRegisters and resolveLabels
+  if (options.controlFlowFlattening) {
+    passes.push({
+      pass: controlFlowFlattening,
+      name: "controlFlowFlattening"
+    });
   }
-  if (options.macroOpcodes) {
-    passes.push(macroOpcodes);
+  if (options.dispatcher) {
+    passes.push({
+      pass: dispatcher,
+      name: "dispatcher"
+    });
   }
-  if (options.selfModifying) {
-    passes.push(selfModifying);
+  passes.push({
+    pass: concealConstants,
+    name: "concealConstants"
+  });
+  if (options.specializedOpcodes) {
+    passes.push({
+      pass: specializedOpcodes,
+      name: "specializedOpcodes"
+    });
+  }
+  if (options.macroOpcodes) {
+    passes.push({
+      pass: macroOpcodes,
+      name: "macroOpcodes"
+    });
   }
   if (options.aliasedOpcodes) {
-    passes.push(aliasedOpcodes);
+    passes.push({
+      pass: aliasedOpcodes,
+      name: "aliasedOpcodes"
+    });
   }
-  for (const pass of passes) {
+  const timings = {};
+  function runAndTime(pass, name) {
+    const startedAt = now();
+    compiler.log(`Running bytecode pass ${name}...`);
     const passResult = pass(bytecode, compiler);
     bytecode = passResult.bytecode;
+    const endedAt = now();
+    const elapsedMs = endedAt - startedAt;
+    timings[name] = elapsedMs;
+    compiler.profileData.transforms[name] = {
+      transformTime: elapsedMs,
+      bytecodeSize: bytecode.length
+    };
+    compiler.log(`Bytecode pass ${name} completed in ${Math.floor(elapsedMs)}ms`);
+    return passResult;
+  }
+  for (const pass of passes) {
+    runAndTime(pass.pass, pass.name);
+  }
+
+  // Resolve virtual registers to concrete slot indices and set regCount per fn.
+  // Must run BEFORE selfModifying: that pass moves body instructions to the end
+  // of the bytecode while leaving RETURN in place, splitting a function's code
+  // into two non-contiguous regions. Linear-scan liveness then sees incorrect
+  // firstUse/lastUse for registers that span the gap, causing slot collisions.
+  const regsResult = runAndTime(resolveRegisters, "resolveRegisters");
+  bytecode = regsResult.bytecode;
+
+  // selfModifying runs after register resolution so concrete slot indices are
+  // already in place; only label operands remain unresolved at this stage.
+  if (options.selfModifying) {
+    const smResult = runAndTime(selfModifying, "selfModifying");
+    bytecode = smResult.bytecode;
   }
 
   // Resolve label references to flat bytecode indices.
-  const labelsResult = resolveLabels(bytecode, compiler);
+  const labelsResult = runAndTime(resolveLabels, "resolveLabels");
   bytecode = labelsResult.bytecode;
 
   // Set mainStartPc from the first function descriptor (or 0 for top-level start).
   compiler.mainStartPc = compiler.mainFn.startPc;
 
   // Resolve constant references to pool indices (+ conceal key operand).
-  const constResult = resolveConstants(bytecode, compiler);
+  const constResult = runAndTime(resolveConstants, "resolveConstants");
   bytecode = constResult.bytecode;
   compiler.constants = constResult.constants;
 
   // Build and obfuscate the runtime.
   const runtimeSource = compiler.serializer.serialize(bytecode, constResult.constants, compiler);
 
-  // This part was purposefully pulled out Serializer as OP_NAME's get resolved during obfuscateRuntime
+  // for (const key of Object.keys(timings)) {
+  //   console.log(`  ${key}: ${timings[key]}ms`);
+  // }
+
+  // This part was purposefully pulled out Serializer as OP_NAME's get resolved during buildRuntime
   // So for the most useful comments, it's ran absolutely last
   // Tests also rely on correct comments so it's required
   const generateBytecodeComment = () => {
     var lines = [];
     for (const instr of bytecode) {
-      const serialized = compiler.serializer._serializeInstr(instr);
-      lines.push("// " + serialized.text);
+      const comment = compiler.serializer._generateComment(instr);
+      lines.push("// " + comment);
     }
     return lines.join("\n");
   };
-  const code = await obfuscateRuntime(runtimeSource, bytecode, options, compiler, generateBytecodeComment);
+  const code = await buildRuntime(runtimeSource, bytecode, options, compiler, generateBytecodeComment);
+  compiler.profileData.obfuscationTime = now() - obfuscationStartedAt;
   return {
-    code
+    code,
+    profileData: compiler.profileData
   };
 }