@tsvm/vm-runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,2185 @@
+// src/polymorphic-builder.ts
+import { OpCode, ConstantEncodingScheme, ImmediateEncodingScheme, SeededRandom } from "@tsvm/shared";
+function createOpaqueNameFactory(seed) {
+  const rng = new SeededRandom(seed ^ 5369200);
+  const alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const used = /* @__PURE__ */ new Set();
+  return () => {
+    let value = "_";
+    do {
+      value = "_";
+      const len = rng.nextRange(5, 9);
+      for (let i = 0; i < len; i++) {
+        value += alphabet[rng.nextRange(0, alphabet.length - 1)];
+      }
+    } while (used.has(value));
+    used.add(value);
+    return value;
+  };
+}
+function materializeConstant(value, seed) {
+  const rng = new SeededRandom(seed ^ value ^ 2068122);
+  const offset = rng.nextRange(1e3, 99999);
+  const choice = rng.nextRange(0, 3);
+  switch (choice) {
+    case 0:
+      return `(((${value - offset}) + ${offset}) | 0)`;
+    case 1:
+      return `(((${value ^ offset}) ^ ${offset}) | 0)`;
+    default:
+      return `(((${value + offset}) - ${offset}) | 0)`;
+  }
+}
+function mutateArithmeticExpression(op, a, b, seed) {
+  const rng = new SeededRandom(seed ^ 9679525);
+  const choice = rng.nextRange(0, 9);
+  let expr = "";
+  if (op === "add") {
+    switch (choice) {
+      case 0:
+        expr = `(((${a}) ^ (${b})) + 2 * ((${a}) & (${b})))`;
+        break;
+      // a+b = (a^b) + 2*(a&b)
+      case 1:
+        expr = `(((${a}) | (${b})) + ((${a}) & (${b})))`;
+        break;
+      // a+b = (a|b) + (a&b)
+      case 2:
+        expr = `(2 * ((${a}) | (${b})) - ((${a}) ^ (${b})))`;
+        break;
+      // a+b = 2*(a|b) - (a^b)
+      case 3:
+        expr = `(((${a}) ^ ~(${b})) + 2 * ((${a}) | (${b})) + 1)`;
+        break;
+      // a+b = (a^~b) + 2*(a|b) + 1
+      case 4:
+        expr = `(((${a}) - (-(${b}))))`;
+        break;
+      // a+b = a - (-b)
+      case 5:
+        expr = `(((${a}) - ~(${b})) - 1)`;
+        break;
+      // a+b = a - ~b - 1, since ~b = -(b+1)
+      case 6:
+        expr = `(~(~(${a}) - (${b})))`;
+        break;
+      // a+b = ~(~a - b), since ~(~a-b) = a+b
+      case 7:
+        expr = `((((${a}) + (${b})) | 0))`;
+        break;
+      // a+b with int coercion
+      case 8:
+        expr = `((${a}) * 2 - (${a}) + (${b}))`;
+        break;
+      // 2a - a + b = a + b
+      default:
+        expr = `((${a}) + (${b}))`;
+        break;
+    }
+  } else if (op === "sub") {
+    switch (choice) {
+      case 0:
+        expr = `(((${a}) ^ ~(${b})) + 2 * ((${a}) & ~(${b})) + 1)`;
+        break;
+      // a-b via complement add
+      case 1:
+        expr = `(((${a}) & ~(${b})) - (~(${a}) & (${b})))`;
+        break;
+      // a-b = (a&~b) - (~a&b)
+      case 2:
+        expr = `(((${a}) | ~(${b})) - (~(${a}) | (${b})))`;
+        break;
+      // a-b via complement or
+      case 3:
+        expr = `(((${a}) ^ (${b})) - 2 * (~(${a}) & (${b})))`;
+        break;
+      // a-b = (a^b) - 2*(~a&b)
+      case 4:
+        expr = `((${a}) + (-(${b})))`;
+        break;
+      // a-b = a + (-b)
+      case 5:
+        expr = `(~((${b}) - (${a}) - 1))`;
+        break;
+      // a-b = ~(b-a-1), since ~x = -(x+1)
+      case 6:
+        expr = `((${a}) + (~(${b})) + 1)`;
+        break;
+      // a-b = a + ~b + 1 (two's complement)
+      case 7:
+        expr = `(((${a}) | 0) - ((${b}) | 0))`;
+        break;
+      // a-b with int coercion
+      case 8:
+        expr = `(~(~(${a}) + (${b})))`;
+        break;
+      // a-b = ~(~a+b), since ~(~a+b) = -(~a+b+1) = a-b
+      default:
+        expr = `((${a}) - (${b}))`;
+        break;
+    }
+  } else if (op === "and") {
+    switch (choice) {
+      case 0:
+        expr = `(((${a}) | (${b})) - ((${a}) ^ (${b})))`;
+        break;
+      // a&b = (a|b) - (a^b)
+      case 1:
+        expr = `((((${a}) + (${b})) - ((${a}) ^ (${b}))) >> 1)`;
+        break;
+      // a&b = ((a+b) - (a^b)) / 2
+      case 2:
+        expr = `(~(~(${a}) | ~(${b})))`;
+        break;
+      // De Morgan: a&b = ~(~a|~b)
+      case 3:
+        expr = `((${a}) & (${b}))`;
+        break;
+      // identity
+      case 4:
+        expr = `(((${a}) | (${b})) & ~((${a}) ^ (${b})))`;
+        break;
+      // a&b = (a|b) & ~(a^b)
+      case 5:
+        expr = `(((${a}) + (${b}) - ((${a}) | (${b}))))`;
+        break;
+      // a&b = a+b - (a|b)
+      case 6:
+        expr = `((${a}) - ((${a}) & ~(${b})))`;
+        break;
+      // a&b = a - (a&~b)
+      case 7:
+        expr = `((${b}) - (~(${a}) & (${b})))`;
+        break;
+      // a&b = b - (~a&b)
+      case 8:
+        expr = `((${a}) ^ ((${a}) ^ ((${a}) & (${b}))))`;
+        break;
+      // a ^ a ^ (a&b) = a&b
+      default:
+        expr = `((${a}) & (${b}))`;
+        break;
+    }
+  } else if (op === "or") {
+    switch (choice) {
+      case 0:
+        expr = `(((${a}) & (${b})) + ((${a}) ^ (${b})))`;
+        break;
+      // a|b = (a&b) + (a^b)
+      case 1:
+        expr = `(((${a}) ^ (${b})) | ((${a}) & (${b})))`;
+        break;
+      // a|b = (a^b) | (a&b) (disjoint)
+      case 2:
+        expr = `(~(~(${a}) & ~(${b})))`;
+        break;
+      // De Morgan: a|b = ~(~a&~b)
+      case 3:
+        expr = `((${a}) | (${b}))`;
+        break;
+      // identity
+      case 4:
+        expr = `(((${a}) + (${b})) - ((${a}) & (${b})))`;
+        break;
+      // a|b = a+b - (a&b)
+      case 5:
+        expr = `(((${a}) ^ (${b})) + ((${a}) & (${b})))`;
+        break;
+      // a|b = (a^b) + (a&b) (same as case 0)
+      case 6:
+        expr = `((${a}) + ((${b}) & ~(${a})))`;
+        break;
+      // a|b = a + (b&~a)
+      case 7:
+        expr = `((${b}) + ((${a}) & ~(${b})))`;
+        break;
+      // a|b = b + (a&~b)
+      case 8:
+        expr = `((${a}) ^ ((${a}) ^ ((${a}) | (${b}))))`;
+        break;
+      // a ^ a ^ (a|b) = a|b
+      default:
+        expr = `((${a}) | (${b}))`;
+        break;
+    }
+  } else {
+    switch (choice) {
+      case 0:
+        expr = `(((${a}) | (${b})) - ((${a}) & (${b})))`;
+        break;
+      // a^b = (a|b) - (a&b)
+      case 1:
+        expr = `(((${a}) + (${b})) - 2 * ((${a}) & (${b})))`;
+        break;
+      // a^b = a+b - 2*(a&b)
+      case 2:
+        expr = `(~(((${a}) | ~(${b})) & (~(${a}) | (${b}))))`;
+        break;
+      // FIX: ~XNOR = XOR
+      case 3:
+        expr = `((${a}) ^ (${b}))`;
+        break;
+      // identity
+      case 4:
+        expr = `(~(${a}) ^ ~(${b}))`;
+        break;
+      // ~a ^ ~b = a ^ b
+      case 5:
+        expr = `(2 * ((${a}) | (${b})) - (${a}) - (${b}))`;
+        break;
+      // 2*(a|b) - a - b = a^b
+      case 6:
+        expr = `(((${a}) | (${b})) ^ ((${a}) & (${b})))`;
+        break;
+      // (a|b) ^ (a&b) = a^b
+      case 7:
+        expr = `((~(${a}) & (${b})) | ((${a}) & ~(${b})))`;
+        break;
+      // textbook XOR definition
+      case 8:
+        expr = `((${a}) - (${b}) + 2 * (~(${a}) & (${b})))`;
+        break;
+      // a^b = (a-b) + 2*(~a&b)
+      default:
+        expr = `((${a}) ^ (${b}))`;
+        break;
+    }
+  }
+  if (op === "and" || op === "or" || op === "xor") {
+    return `((${expr}) | 0)`;
+  }
+  return expr;
+}
+function generateOpaquePredicate(seed, varIdx) {
+  const rng = new SeededRandom(seed ^ varIdx ^ 57005);
+  const choice = rng.nextRange(0, 7);
+  const pVar = `_op${rng.nextRange(100, 999)}`;
+  const runtimeVal = "ctx.pc";
+  switch (choice) {
+    case 0:
+      return { expr: `(function(){ var ${pVar} = ${runtimeVal}; return (${pVar} * ${pVar} + ${pVar}) % 2 === 0; })()`, alwaysTrue: true };
+    case 1:
+      return { expr: `(function(){ var ${pVar} = ${runtimeVal}; return (${pVar} * ${pVar}) % 4 !== 2; })()`, alwaysTrue: true };
+    case 2:
+      return {
+        expr: `(function(){ var ${pVar} = ${runtimeVal} | 0; return (${pVar} | (${pVar} - 1)) >= (${pVar} - 1); })()`,
+        alwaysTrue: true
+      };
+    case 3:
+      return { expr: `(function(){ var ${pVar} = ${runtimeVal}; return (${pVar} * ${pVar}) >= 0; })()`, alwaysTrue: true };
+    case 4:
+      return {
+        expr: `(function(){ var ${pVar} = ${runtimeVal}; return ((${pVar} & 1) + ((${pVar} >> 1) & 1)) < 3; })()`,
+        alwaysTrue: true
+      };
+    case 5:
+      return { expr: `(function(){ var ${pVar} = (${runtimeVal} & 255); return (${pVar} * ${pVar} & 3) !== 3; })()`, alwaysTrue: true };
+    case 6:
+      return {
+        expr: `(function(){ var ${pVar} = (${runtimeVal} & 255) * 31; return (${pVar} * ${pVar}) % 3 !== 2; })()`,
+        alwaysTrue: true
+      };
+    default:
+      return { expr: `(function(){ var ${pVar} = ${runtimeVal} | 0; return (${pVar} | 0) === ${pVar}; })()`, alwaysTrue: true };
+  }
+}
+function generateOpaqueDeadCode(seed, varIdx, regAlias, ctx) {
+  const rng = new SeededRandom(seed ^ varIdx ^ 51966);
+  const numBlocks = rng.nextRange(1, 2);
+  let code = "";
+  for (let i = 0; i < numBlocks; i++) {
+    const pred = generateOpaquePredicate(seed ^ i, varIdx);
+    const fakeReg1 = rng.nextRange(0, 15);
+    const fakeReg2 = rng.nextRange(0, 15);
+    const fakeConst = rng.nextRange(1, 255);
+    const trapVar = `_dt${rng.nextRange(100, 999)}`;
+    code += `  if (!${pred.expr}) {
+`;
+    code += `    var ${trapVar} = ${regAlias}[${fakeReg1}];
+`;
+    code += `    ${regAlias}[${fakeReg2}] = ${trapVar} ^ ${fakeConst};
+`;
+    code += `    ctx.${ctx.rollingState} = (ctx.${ctx.rollingState} ^ ${trapVar}) | 0;
+`;
+    code += "  }\n";
+  }
+  return code;
+}
+function generateSignaturePollution(seed, varIdx) {
+  const rng = new SeededRandom(seed ^ varIdx ^ 45232);
+  const numDecls = rng.nextRange(2, 4);
+  let code = "";
+  for (let i = 0; i < numDecls; i++) {
+    const varName = `_sp${rng.nextRange(100, 999)}_${i}`;
+    const choice = rng.nextRange(0, 3);
+    switch (choice) {
+      case 0:
+        code += `  var ${varName} = (${rng.nextRange(1, 65535)} ^ ctx.pc) | 0;
+`;
+        break;
+      case 1:
+        code += `  var ${varName} = (ctx.pc * ${rng.nextRange(2, 7)} + ${rng.nextRange(1, 100)}) & 0xFF;
+`;
+        break;
+      case 2:
+        code += `  var ${varName} = ~(ctx.pc ^ ${rng.nextRange(1, 65535)}) >>> 0;
+`;
+        break;
+      default:
+        code += `  var ${varName} = ((ctx.pc >> ${rng.nextRange(1, 4)}) + ${rng.nextRange(1, 50)}) | 0;
+`;
+        break;
+    }
+  }
+  return code;
+}
+function generateJunkStatements(seed, id, names, mulConst = "1664525", addConst = "1013904223") {
+  const rng = new SeededRandom(seed ^ id ^ 8137233);
+  const numJunk = rng.nextRange(1, 3);
+  let junk = "";
+  const ctx = names.ctx;
+  for (let i = 0; i < numJunk; i++) {
+    const choice = rng.nextRange(0, 3);
+    const varName = `_j${id}_${i}`;
+    switch (choice) {
+      case 0:
+        junk += `  var ${varName} = (${seed} ^ ${rng.nextRange(10, 100)}) | 0;
+`;
+        junk += `  ctx.${ctx.rollingState} = (Math.imul(ctx.${ctx.rollingState} ^ ${varName}, ${mulConst}) + ${addConst}) | 0;
+`;
+        break;
+      case 1:
+        junk += `  var ${varName} = Math.sin(${rng.nextRange(1, 10)}) * ${rng.nextRange(2, 5)};
+`;
+        junk += `  ctx.${ctx.rollingState} = (ctx.${ctx.rollingState} + (${varName} | 0)) & 0xFFFFFFFF;
+`;
+        break;
+      default:
+        junk += `  var ${varName} = (${seed} % ${rng.nextRange(3, 9)}) | 0;
+`;
+        junk += `  ctx.${ctx.rollingState} = (ctx.${ctx.rollingState} ^ (${varName} * ${varName})) | 0;
+`;
+        break;
+    }
+  }
+  return junk;
+}
+function createRuntimeNames(config) {
+  const stealth = !!config.stealthDispatch;
+  if (!stealth) {
+    return {
+      stealth,
+      nextHandlerName: (canonical) => `h_${canonical}`,
+      top: {
+        seed: "seed",
+        rawCP: "rawCP",
+        cpCache: "cpCache",
+        getCP: "getCP",
+        runtimeStrings: "runtimeStrings",
+        runtimeStringCache: "runtimeStringCache",
+        getRuntimeString: "getRuntimeString",
+        weakMapCtor: "VMWeakMap",
+        weakMapGet: "VMWeakMapGet",
+        weakMapSet: "VMWeakMapSet",
+        reflectObj: "VMReflect",
+        objectObj: "VMObject",
+        nativeToString: "VMNativeToString",
+        nativeMathSin: "VMNativeMathSin",
+        nativeDefineProperty: "VMDefineProperty",
+        nativeGetOwnPropertyDescriptor: "VMGetOwnPropertyDescriptor",
+        nativeApply: "VMNativeApply",
+        nativeCall: "VMNativeCall",
+        performanceNow: "VMPerformanceNow",
+        mathRandom: "VMMathRandom",
+        arraySlice: "sliceArgs",
+        promiseResolve: "resolvePromise",
+        iteratorSymbol: "iteratorSymbol",
+        asyncIteratorSymbol: "asyncIteratorSymbol",
+        functionArena: "functionArena",
+        functionBytecodes: "functionBytecodes",
+        executorCache: "executorCache",
+        getExecutorById: "getExecutorById",
+        createExecutor: "createExecutor",
+        handlers: "handlers",
+        result: "result",
+        vmFunctions: "vmFunctions",
+        privateData: "privateData",
+        opaquePredicate: "opaquePredicate",
+        junkSink: "junkSink",
+        readByte: "readByte"
+      },
+      ctx: {
+        pc: "pc",
+        bytecode: "bytecode",
+        regs: "regs",
+        fnArgs: "fnArgs",
+        env: "env",
+        globalScope: "globalScope",
+        thisArg: "thisArg",
+        newTarget: "newTarget",
+        resumeMode: "resumeMode",
+        resumeValue: "resumeValue",
+        resumeReg: "resumeReg",
+        awaitPromise: "awaitPromise",
+        running: "running",
+        returnValue: "returnValue",
+        tryFrames: "tryStack",
+        rollingState: "rollingKey",
+        xorLog: "xorLog",
+        executionNonce: "executionNonce",
+        currentOpcode: "currentOpcode",
+        currentHandlerIdx: "currentHandlerIdx",
+        pathHash: "pathHash"
+      },
+      frame: {
+        catchPc: "catchPc",
+        endPc: "endPc",
+        exceptionReg: "exceptionReg"
+      },
+      locals: {
+        opByte: "op",
+        dispatchBank: "handlers",
+        dispatchRoute: "dispatchRoute"
+      }
+    };
+  }
+  const next = createOpaqueNameFactory(config.seed);
+  return {
+    stealth,
+    nextHandlerName: () => next(),
+    top: {
+      seed: next(),
+      rawCP: next(),
+      cpCache: next(),
+      getCP: next(),
+      runtimeStrings: next(),
+      runtimeStringCache: next(),
+      getRuntimeString: next(),
+      weakMapCtor: next(),
+      weakMapGet: next(),
+      weakMapSet: next(),
+      reflectObj: next(),
+      objectObj: next(),
+      nativeToString: next(),
+      nativeMathSin: next(),
+      nativeDefineProperty: next(),
+      nativeGetOwnPropertyDescriptor: next(),
+      nativeApply: next(),
+      nativeCall: next(),
+      performanceNow: next(),
+      mathRandom: next(),
+      arraySlice: next(),
+      promiseResolve: next(),
+      iteratorSymbol: next(),
+      asyncIteratorSymbol: next(),
+      functionArena: next(),
+      functionBytecodes: next(),
+      executorCache: next(),
+      getExecutorById: next(),
+      createExecutor: next(),
+      handlers: next(),
+      result: next(),
+      vmFunctions: next(),
+      privateData: next(),
+      opaquePredicate: next(),
+      junkSink: next(),
+      readByte: next()
+    },
+    ctx: {
+      pc: "pc",
+      bytecode: "bytecode",
+      regs: "regs",
+      fnArgs: "fnArgs",
+      env: "env",
+      globalScope: "globalScope",
+      thisArg: next(),
+      newTarget: next(),
+      resumeMode: next(),
+      resumeValue: next(),
+      resumeReg: next(),
+      awaitPromise: next(),
+      running: "running",
+      returnValue: "returnValue",
+      tryFrames: next(),
+      rollingState: next(),
+      xorLog: next(),
+      executionNonce: "executionNonce",
+      currentOpcode: "currentOpcode",
+      currentHandlerIdx: next(),
+      pathHash: next()
+    },
+    frame: {
+      catchPc: next(),
+      endPc: next(),
+      exceptionReg: next()
+    },
+    locals: {
+      opByte: next(),
+      dispatchBank: next(),
+      dispatchRoute: next()
+    }
+  };
+}
+function buildVMRuntime(module, config) {
+  const names = createRuntimeNames(config);
+  const buildRng = new SeededRandom(config.seed ^ 765210);
+  const ctx = names.ctx;
+  const top = names.top;
+  const frame = names.frame;
+  const locals = names.locals;
+  const mulConst = materializeConstant(1664525, config.seed);
+  const addConst = materializeConstant(1013904223, config.seed ^ 1616702);
+  const seedConst = materializeConstant(config.seed, config.seed ^ 4069292);
+  const regRef = (idx) => `ctx.${ctx.regs}[${idx}]`;
+  const ctxRef = (key) => `ctx.${ctx[key]}`;
+  const frameRef = (target, key) => `${target}.${frame[key]}`;
+  const opToMapped = /* @__PURE__ */ new Map();
+  for (const [canonical, mapped] of module.opcodeMapping.forward.entries()) {
+    opToMapped.set(canonical, Array.isArray(mapped) ? [...mapped] : [mapped]);
+  }
+  const cp = JSON.stringify(module.constantPool);
+  const targetFnIndex = module.entryPointIndex >= 0 ? module.entryPointIndex : 0;
+  const targetFn = module.functions[targetFnIndex];
+  if (!targetFn) {
+    throw new Error(`No target function found at index ${targetFnIndex}`);
+  }
+  const exportedFunctions = module.functions.filter((f) => f.isEntryPoint);
+  const concealRuntimeStrings = !!config.stealthDispatch || !!config.tamperDetection || !!config.junkInsertion;
+  const stringRng = new SeededRandom(config.seed ^ 4030233);
+  const keyBytes = [];
+  for (let i = 0; i < 16; i++) {
+    keyBytes.push(stringRng.nextRange(1, 255));
+  }
+  const runtimeStringEntries = [
+    "VM Integrity Violation at PC ",
+    ", raw op: ",
+    "Unknown VM function id: ",
+    "Cannot read private member",
+    "@@iterator"
+  ];
+  const runtimeStringIndex = new Map(runtimeStringEntries.map((value, index) => [value, index]));
+  const encodedRuntimeStrings = runtimeStringEntries.map((value) => {
+    let encoded = "";
+    for (let i = 0; i < value.length; i++) {
+      const keyByte = keyBytes[i % 16];
+      const nextKeyByte = keyBytes[(i + 1) % 16];
+      encoded += String.fromCharCode(value.charCodeAt(i) ^ keyByte ^ nextKeyByte);
+    }
+    return encoded;
+  });
+  const runtimeStringRef = (value) => {
+    if (!concealRuntimeStrings) {
+      return JSON.stringify(value);
+    }
+    const index = runtimeStringIndex.get(value);
+    if (index === void 0) {
+      throw new Error(`Missing runtime string entry: ${value}`);
+    }
+    return `${top.getRuntimeString}(${index})`;
+  };
+  const runtimeStringBootstrap = concealRuntimeStrings ? `
+  const ${top.runtimeStrings} = ${JSON.stringify(encodedRuntimeStrings)};
+  const ${top.runtimeStringCache} = Object.create(null);
+  const _strKey = ${JSON.stringify(keyBytes)};
+  function ${top.getRuntimeString}(index) {
+    if (${top.runtimeStringCache}[index] !== undefined) return ${top.runtimeStringCache}[index];
+    var encoded = ${top.runtimeStrings}[index];
+    var decoded = '';
+    for (var i = 0; i < encoded.length; i++) {
+      var keyByte = _strKey[i % 16];
+      var nextKeyByte = _strKey[(i + 1) % 16];
+      decoded += String.fromCharCode(encoded.charCodeAt(i) ^ keyByte ^ nextKeyByte);
+    }
+    return ${top.runtimeStringCache}[index] = decoded;
+  }
+  function ${top.opaquePredicate}(value) {
+    value = (value ^ 0x51ed) | 0;
+    var steps = 0;
+    var n = value;
+    if (n < 0) n = -n;
+    while (n > 1 && steps < 12) {
+      if ((n & 1) === 0) {
+        n = (n >>> 1) | 0;
+      } else {
+        n = (Math.imul(n, 3) + 1) | 0;
+      }
+      steps++;
+    }
+    return (n | 0) !== -9999;
+  }
+  function ${top.junkSink}(value) {
+    var acc = value ^ ${config.seed};
+    for (var i = 0; i < 3; i++) acc = ((acc << 5) - acc + i) | 0;
+    return acc;
+  }
+  if (!${top.opaquePredicate}(${top.seed})) {
+    ${top.junkSink}(${top.seed});
+  }
+  ` : "";
+  function isVariableLengthOpcode(opcode) {
+    return opcode === 64 || // OpCode.Call
+    opcode === 65 || // OpCode.CallMethod
+    opcode === 66 || // OpCode.New
+    opcode === 84 || // OpCode.ArrayNew
+    opcode === 85 || // OpCode.ObjectNew
+    opcode === 86 || // OpCode.Spread
+    opcode === 87 || // OpCode.SpreadIntoArray
+    opcode === 94 || // OpCode.SuperCall
+    opcode === 254;
+  }
+  function isTerminator(opcode) {
+    return opcode === OpCode.Jmp || opcode === OpCode.JmpIf || opcode === OpCode.JmpIfNot || opcode === OpCode.Switch || opcode === OpCode.Return || opcode === OpCode.ReturnVoid || opcode === OpCode.TailCall || opcode === OpCode.Throw || opcode === OpCode.Yield || opcode === OpCode.YieldStar || opcode === OpCode.Await || opcode === OpCode.Halt || opcode === OpCode.Trap;
+  }
+  const handlerDeclarations = [];
+  const handlerNames = /* @__PURE__ */ new Map();
+  const declaredOpcodes = [];
+  const allHandlerVariants = /* @__PURE__ */ new Map();
+  const declareHandler = (canonical, body) => {
+    const isParanoid = config.runtimeHardening === "paranoid" && canonical !== OpCode.Trap;
+    const numVariants = isParanoid ? 4 : 1;
+    const fnNames = [];
+    for (let vIdx = 0; vIdx < numVariants; vIdx++) {
+      const fnName = isParanoid ? `${names.nextHandlerName(canonical)}_${vIdx}` : names.nextHandlerName(canonical);
+      fnNames.push(fnName);
+      const mySeed = config.seed ^ canonical ^ vIdx;
+      const myRng = new SeededRandom(mySeed);
+      let junkSkip = "";
+      if (config.junkInsertion) {
+        const numJunk = (canonical * 7 + config.seed) % 4;
+        for (let i = 0; i < numJunk; i++) {
+          junkSkip += config.rollingKeys ? `  let __junk_${vIdx}_${i} = ${top.readByte}(ctx);
+` : "  ctx.pc++;\n";
+        }
+      }
+      const isVarLength = isVariableLengthOpcode(canonical);
+      let myReadArgs = "";
+      const argsVar = isParanoid ? `_args_${vIdx}` : "args";
+      const valVar = isParanoid ? `_val_${vIdx}` : "val";
+      const kindNumVar = isParanoid ? `_kind_${vIdx}` : "kindNum";
+      const myAdvanceArg = config.rollingKeys ? `
+        let ${kindNumVar} = ${top.readByte}(ctx);
+        let ${valVar} = 0;
+        ${config.immediateEncoding === ImmediateEncodingScheme.VariableLength ? `
+          let shift = 0;
+          let b;
+          do {
+            b = ${top.readByte}(ctx);
+            ${valVar} |= (b & 0x7F) << shift;
+            shift += 7;
+          } while (b & 0x80);
+        ` : `
+          let b0 = ${top.readByte}(ctx);
+          let b1 = ${top.readByte}(ctx);
+          let b2 = ${top.readByte}(ctx);
+          let b3 = ${top.readByte}(ctx);
+          ${valVar} = b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
+        `}
+      ` : `
+        let ${kindNumVar} = ctx.bytecode[ctx.pc++];
+        let ${valVar} = 0;
+        ${config.immediateEncoding === ImmediateEncodingScheme.VariableLength ? `
+          let shift = 0;
+          let b;
+          do {
+            b = ctx.bytecode[ctx.pc++];
+            ${valVar} |= (b & 0x7F) << shift;
+            shift += 7;
+          } while (b & 0x80);
+        ` : `
+          let b0 = ctx.bytecode[ctx.pc];
+          let b1 = ctx.bytecode[ctx.pc + 1];
+          let b2 = ctx.bytecode[ctx.pc + 2];
+          let b3 = ctx.bytecode[ctx.pc + 3];
+          ctx.pc += 4;
+          ${valVar} = b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
+        `}
+      `;
+      if (isVarLength) {
+        myReadArgs = `
+          let argCount = ${config.rollingKeys ? `${top.readByte}(ctx)` : "ctx.bytecode[ctx.pc++]"};
+          const ${argsVar} = [];
+          const kinds = [];
+          for (let i = 0; i < argCount; i++) {
+            ${myAdvanceArg}
+            ${argsVar}.push(${valVar});
+            kinds.push(${kindNumVar});
+          }
+        `;
+      } else {
+        const matches = body.match(/args\[(\d+)\]/g);
+        let operandCount = 0;
+        if (matches) {
+          for (const m of matches) {
+            const idx = Number.parseInt(m.match(/\d+/)[0], 10);
+            if (idx + 1 > operandCount) {
+              operandCount = idx + 1;
+            }
+          }
+        }
+        myReadArgs = `
+          const ${argsVar} = [];
+          const kinds = [];
+          for (let i = 0; i < ${operandCount}; i++) {
+            ${myAdvanceArg}
+            ${argsVar}.push(${valVar});
+            kinds.push(${kindNumVar});
+          }
+        `;
+      }
+      const junkLogic = config.stealthDispatch ? generateJunkStatements(mySeed, canonical, names, mulConst, addConst) : "";
+      let nextOpLogic = "";
+      if (canonical !== OpCode.Halt && canonical !== OpCode.Return && canonical !== OpCode.ReturnVoid && canonical !== OpCode.Throw && canonical !== OpCode.Trap && canonical !== OpCode.Await && canonical !== OpCode.Yield && canonical !== OpCode.YieldStar) {
+        if (config.runtimeHardening === "paranoid") {
+          nextOpLogic = `
+            if (${ctxRef("pc")} >= ${ctxRef("bytecode")}.length) return null;
+            let nextOp = ${top.readByte}(ctx);
+            ${config.stealthDispatch ? `
+              nextOp = (ctx.${ctx.currentHandlerIdx} + nextOp) % 256;
+              ctx.${ctx.currentHandlerIdx} = nextOp;
+            ` : ""}
+            ${config.rollingKeys ? `
+              ctx.${ctx.pathHash} = (Math.imul(ctx.${ctx.pathHash}, 31) + nextOp) & 0xFFFFFFFF;
+            ` : ""}
+            return makeRouteToken(ctx, nextOp);
+          `;
+        } else {
+          nextOpLogic = `
+            if (${ctxRef("pc")} >= ${ctxRef("bytecode")}.length) return null;
+            let nextOp = ${top.readByte}(ctx);
+            ${config.stealthDispatch ? `
+              nextOp = (ctx.${ctx.currentHandlerIdx} + nextOp) % 256;
+              ctx.${ctx.currentHandlerIdx} = nextOp;
+            ` : ""}
+            ${config.rollingKeys ? `
+              ctx.${ctx.pathHash} = (Math.imul(ctx.${ctx.pathHash}, 31) + nextOp) & 0xFFFFFFFF;
+            ` : ""}
+            return ${locals.dispatchBank}[nextOp];
+          `;
+        }
+      } else {
+        nextOpLogic = "return null;";
+      }
+      let variantBody = body.replace(/\${readArgs}/g, () => myReadArgs);
+      variantBody = variantBody.replace(/__ADD_EXPR__/g, () => {
+        return mutateArithmeticExpression("add", "ctx.regs[args[0]]", "ctx.regs[args[1]]", mySeed);
+      });
+      variantBody = variantBody.replace(/__SUB_EXPR__/g, () => {
+        return mutateArithmeticExpression("sub", "ctx.regs[args[0]]", "ctx.regs[args[1]]", mySeed);
+      });
+      variantBody = variantBody.replace(/__AND_EXPR__/g, () => {
+        return mutateArithmeticExpression("and", "ctx.regs[args[0]]", "ctx.regs[args[1]]", mySeed);
+      });
+      variantBody = variantBody.replace(/__OR_EXPR__/g, () => {
+        return mutateArithmeticExpression("or", "ctx.regs[args[0]]", "ctx.regs[args[1]]", mySeed);
+      });
+      variantBody = variantBody.replace(/__XOR_EXPR__/g, () => {
+        return mutateArithmeticExpression("xor", "ctx.regs[args[0]]", "ctx.regs[args[1]]", mySeed);
+      });
+      if (isParanoid) {
+        variantBody = variantBody.replace(/\bargs\b/g, argsVar);
+        variantBody = variantBody.replace(/args\[/g, `${argsVar}[`);
+      }
+      const regAlias = isParanoid ? `_r${myRng.nextRange(1e3, 9999)}` : `ctx.${ctx.regs}`;
+      const regSetup = isParanoid ? `  var ${regAlias} = ctx.${ctx.regs};
+` : "";
+      if (isParanoid) {
+        variantBody = variantBody.replace(/\bctx\.regs\[/g, `${regAlias}[`);
+        variantBody = variantBody.replace(/\bctx\.regs\b/g, regAlias);
+      }
+      if (config.stealthDispatch && isTerminator(canonical)) {
+        variantBody += `
+ctx.${ctx.currentHandlerIdx} = 0;
+`;
+      }
+      let currentOpcodeTracker = "";
+      if (config.runtimeHardening === "paranoid") {
+        currentOpcodeTracker = `ctx.currentOpcode = ${canonical};
+`;
+      }
+      let opaqueDeadCode = "";
+      let sigPollution = "";
+      if (isParanoid) {
+        opaqueDeadCode = generateOpaqueDeadCode(mySeed, vIdx, regAlias, ctx);
+        sigPollution = generateSignaturePollution(mySeed, vIdx);
+      }
+      handlerDeclarations.push(
+        `function ${fnName}(ctx) {
+${currentOpcodeTracker}${junkSkip}
+${regSetup}${sigPollution}${junkLogic}
+${opaqueDeadCode}${variantBody}
+${nextOpLogic}
+}`
+      );
+    }
+    declaredOpcodes.push(canonical);
+    handlerNames.set(canonical, fnNames[0]);
+    allHandlerVariants.set(canonical, fnNames);
+  };
+  const readArgs = "${readArgs}";
+  declareHandler(
+    OpCode.Trap,
+    `
+    ctx.regs = [];
+    ctx.pc = 999999;
+    ctx.running = false;
+    debugger;
+    throw new Error(${runtimeStringRef("VM Integrity Violation at PC ")} + (${ctxRef("pc")} - 1));
+  `
+  );
+  declareHandler(
+    OpCode.LoadConst,
+    `
+    ${readArgs}
+    ${regRef("args[1]")} = (kinds[0] === 2) ? ${top.getCP}(ctx, args[0]) : args[0];
+  `
+  );
+  declareHandler(OpCode.LoadLocal, `${readArgs} ctx.regs[args[1]] = ctx.regs[args[0]];`);
+  declareHandler(OpCode.StoreLocal, `${readArgs} ctx.regs[args[0]] = ctx.regs[args[1]];`);
+  declareHandler(OpCode.Move, `${readArgs} ctx.regs[args[1]] = ctx.regs[args[0]];`);
+  declareHandler(
+    OpCode.LoadGlobal,
+    `
+    ${readArgs}
+    var propName = ctx.regs[args[0]];
+    var globalVal = ${ctxRef("globalScope")}[propName];
+    ${regRef("args[1]")} = (typeof ${top.result} !== 'undefined' && ${top.result}[propName] !== undefined)
+      ? ${top.result}[propName]
+      : globalVal;
+  `
+  );
+  declareHandler(
+    OpCode.StoreGlobal,
+    `
+    ${readArgs}
+    var propName = ctx.regs[args[0]];
+    ${ctxRef("globalScope")}[propName] = ${regRef("args[1]")};
+  `
+  );
+  declareHandler(OpCode.LoadThis, `${readArgs} ${regRef("args[0]")} = ${ctxRef("thisArg")};`);
+  declareHandler(OpCode.LoadNewTarget, `${readArgs} ${regRef("args[0]")} = ${ctxRef("newTarget")};`);
+  declareHandler(
+    OpCode.Add,
+    `${readArgs} ctx.regs[args[2]] = (typeof ctx.regs[args[0]] === 'string' || typeof ctx.regs[args[1]] === 'string') ? (ctx.regs[args[0]] + ctx.regs[args[1]]) : (ctx.regs[args[0]] + ctx.regs[args[1]]);`
+  );
+  declareHandler(
+    OpCode.Sub,
+    `${readArgs} ctx.regs[args[2]] = (typeof ctx.regs[args[0]] === 'number' && typeof ctx.regs[args[1]] === 'number') ? __SUB_EXPR__ : (ctx.regs[args[0]] - ctx.regs[args[1]]);`
+  );
+  declareHandler(OpCode.Mul, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] * ctx.regs[args[1]];`);
+  declareHandler(OpCode.Div, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] / ctx.regs[args[1]];`);
+  declareHandler(OpCode.Mod, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] % ctx.regs[args[1]];`);
+  declareHandler(OpCode.Neg, `${readArgs} ctx.regs[args[1]] = -ctx.regs[args[0]];`);
+  declareHandler(OpCode.BitAnd, `${readArgs} ctx.regs[args[2]] = (ctx.regs[args[0]] & ctx.regs[args[1]]);`);
+  declareHandler(OpCode.BitOr, `${readArgs} ctx.regs[args[2]] = (ctx.regs[args[0]] | ctx.regs[args[1]]);`);
+  declareHandler(OpCode.BitXor, `${readArgs} ctx.regs[args[2]] = (ctx.regs[args[0]] ^ ctx.regs[args[1]]);`);
+  declareHandler(OpCode.Shl, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] << ctx.regs[args[1]];`);
+  declareHandler(OpCode.Shr, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] >> ctx.regs[args[1]];`);
+  declareHandler(OpCode.UShr, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] >>> ctx.regs[args[1]];`);
+  declareHandler(OpCode.Not, `${readArgs} ctx.regs[args[1]] = !ctx.regs[args[0]];`);
+  declareHandler(OpCode.Eq, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] == ctx.regs[args[1]];`);
+  declareHandler(OpCode.StrictEq, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] === ctx.regs[args[1]];`);
+  declareHandler(OpCode.Lt, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] < ctx.regs[args[1]];`);
+  declareHandler(OpCode.LtEq, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] <= ctx.regs[args[1]];`);
+  declareHandler(OpCode.Gt, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] > ctx.regs[args[1]];`);
+  declareHandler(OpCode.GtEq, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] >= ctx.regs[args[1]];`);
+  declareHandler(OpCode.TypeOf, `${readArgs} ctx.regs[args[1]] = typeof ctx.regs[args[0]];`);
+  declareHandler(OpCode.InstanceOf, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] instanceof ctx.regs[args[1]];`);
+  declareHandler(OpCode.In, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]] in ctx.regs[args[1]];`);
+  declareHandler(OpCode.PropGet, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]][ctx.regs[args[1]]];`);
+  declareHandler(OpCode.PropSet, `${readArgs} ctx.regs[args[0]][ctx.regs[args[1]]] = ctx.regs[args[2]];`);
+  declareHandler(OpCode.ComputedGet, `${readArgs} ctx.regs[args[2]] = ctx.regs[args[0]][ctx.regs[args[1]]];`);
+  declareHandler(OpCode.ComputedSet, `${readArgs} ctx.regs[args[0]][ctx.regs[args[1]]] = ctx.regs[args[2]];`);
+  declareHandler(OpCode.ArrayNew, `${readArgs} ctx.regs[args[0]] = [];`);
+  declareHandler(OpCode.ObjectNew, `${readArgs} ctx.regs[args[0]] = {};`);
+  declareHandler(OpCode.Delete, `${readArgs} delete ctx.regs[args[0]][ctx.regs[args[1]]];`);
+  declareHandler(OpCode.CellNew, `${readArgs} ctx.regs[args[1]] = { v: ctx.regs[args[0]] };`);
+  declareHandler(OpCode.CellGet, `${readArgs} ctx.regs[args[1]] = ctx.regs[args[0]].v;`);
+  declareHandler(OpCode.CellSet, `${readArgs} ctx.regs[args[0]].v = ctx.regs[args[1]];`);
+  declareHandler(OpCode.EnvGet, `${readArgs} ${regRef("args[1]")} = ${ctxRef("env")}[args[0]];`);
+  declareHandler(OpCode.RestArgs, `${readArgs} ${regRef("args[1]")} = ${ctxRef("fnArgs")}.slice(${regRef("args[0]")});`);
+  declareHandler(
+    OpCode.ClosureNew,
+    `
+    ${readArgs}
+    ${regRef("args[2]")} = ${top.getExecutorById}(${top.getCP}(ctx, args[0]), ${regRef("args[1]")});
+  `
+  );
+  declareHandler(
+    OpCode.Spread,
+    `
+    ${readArgs}
+    var spreadTarget = ${regRef("args[0]")};
+    var spreadSource = ${regRef("args[1]")};
+    if (Array.isArray(spreadTarget)) {
+      if (spreadSource == null || typeof spreadSource[Symbol.iterator] !== 'function') {
+        throw new TypeError('VM spread source is not iterable');
+      }
+      var spreadIterator = spreadSource[Symbol.iterator]();
+      var spreadStep;
+      while (!(spreadStep = spreadIterator.next()).done) {
+        spreadTarget.push(spreadStep.value);
+      }
+    } else if (spreadSource != null) {
+      var spreadKeys = Object.keys(spreadSource);
+      for (var ski = 0; ski < spreadKeys.length; ski++) {
+        var spreadKey = spreadKeys[ski];
+        spreadTarget[spreadKey] = spreadSource[spreadKey];
+      }
+    }
+  `
+  );
+  declareHandler(
+    OpCode.SpreadIntoArray,
+    `
+    ${readArgs}
+    var indexedSpreadTarget = ${regRef("args[0]")};
+    var indexedSpreadSource = ${regRef("args[1]")};
+    var indexedSpreadStart = ${regRef("args[2]")};
+    if (indexedSpreadSource == null || typeof indexedSpreadSource[Symbol.iterator] !== 'function') {
+      throw new TypeError('VM spread source is not iterable');
+    }
+    var indexedSpreadIterator = indexedSpreadSource[Symbol.iterator]();
+    var indexedSpreadStep;
+    var indexedSpreadCount = 0;
+    while (!(indexedSpreadStep = indexedSpreadIterator.next()).done) {
+      indexedSpreadTarget[indexedSpreadStart + indexedSpreadCount] = indexedSpreadStep.value;
+      indexedSpreadCount++;
+    }
+    ${regRef("args[3]")} = indexedSpreadCount;
+  `
+  );
+  declareHandler(
+    OpCode.CallMethod,
+    `
+    ${readArgs}
+    var obj = ${regRef("args[0]")};
+    var method = obj[ctx.regs[args[1]]];
+    var aa = [];
+    for (var ci = 2; ci < args.length - 1; ci++) {
+      aa.push(${regRef("args[ci]")});
+    }
+    ${regRef("args[args.length - 1]")} = ${top.nativeApply}.call(method, obj, aa);
+  `
+  );
+  declareHandler(
+    OpCode.Call,
+    `
+    ${readArgs}
+    var fn = ${regRef("args[0]")};
+    if (typeof fn === 'undefined' || fn === null) {
+      throw new TypeError('VM Call target is undefined or null');
+    }
+    var ab = [];
+    for (var ci2 = 1; ci2 < args.length - 1; ci2++) {
+      ab.push(${regRef("args[ci2]")});
+    }
+    ${regRef("args[args.length - 1]")} = ${top.nativeApply}.call(fn, null, ab);
+  `
+  );
+  declareHandler(
+    OpCode.CallWithArray,
+    `
+    ${readArgs}
+    var fnArray = ctx.regs[args[0]];
+    ctx.regs[args[2]] = ${top.nativeApply}.call(fnArray, null, ctx.regs[args[1]]);
+  `
+  );
+  declareHandler(
+    OpCode.CallMethodWithArray,
+    `
+    ${readArgs}
+    var methodObj = ctx.regs[args[0]];
+    var methodFn = methodObj[ctx.regs[args[1]]];
+    ctx.regs[args[3]] = ${top.nativeApply}.call(methodFn, methodObj, ctx.regs[args[2]]);
+  `
+  );
+  declareHandler(
+    OpCode.New,
+    `
+    ${readArgs}
+    var ctor = ctx.regs[args[0]];
+    var ctorArgs = [];
+    for (var ni = 1; ni < args.length - 1; ni++) {
+      ctorArgs.push(ctx.regs[args[ni]]);
+    }
+    ctx.regs[args[args.length - 1]] = typeof Reflect !== 'undefined' && Reflect.construct
+      ? Reflect.construct(ctor, ctorArgs)
+      : new (${top.nativeApply}.call((cleanIntrinsics.Function || Function).prototype.bind, ctor, [null].concat(ctorArgs)))();
+  `
+  );
+  declareHandler(
+    OpCode.NewWithArray,
+    `
+    ${readArgs}
+    var ctorArray = ctx.regs[args[0]];
+    var ctorArrayArgs = ctx.regs[args[1]];
+    ctx.regs[args[2]] = typeof Reflect !== 'undefined' && Reflect.construct
+      ? Reflect.construct(ctorArray, ctorArrayArgs)
+      : new (${top.nativeApply}.call((cleanIntrinsics.Function || Function).prototype.bind, ctorArray, [null].concat(ctorArrayArgs)))();
+  `
+  );
+  declareHandler(
+    OpCode.Jmp,
+    `${readArgs} ${ctxRef("pc")} = (kinds[0] === 0) ? ctx.regs[args[0]] : args[0];${config.rollingKeys ? ` ctx.${ctx.pathHash} = 0;` : ""}`
+  );
+  declareHandler(
+    OpCode.JmpIf,
+    `${readArgs} ${ctxRef("pc")} = ${regRef("args[0]")} ? args[1] : args[2];${config.rollingKeys ? ` ctx.${ctx.pathHash} = 0;` : ""}`
+  );
+  declareHandler(
+    OpCode.JmpIfNot,
+    `${readArgs} ${ctxRef("pc")} = !${regRef("args[0]")} ? args[1] : args[2];${config.rollingKeys ? ` ctx.${ctx.pathHash} = 0;` : ""}`
+  );
+  declareHandler(
+    OpCode.Return,
+    `${readArgs} ${ctxRef("returnValue")} = args.length > 0 ? ${regRef("args[0]")} : undefined; ${ctxRef("running")} = false;`
+  );
+  declareHandler(OpCode.ReturnVoid, `${readArgs} ${ctxRef("returnValue")} = undefined; ${ctxRef("running")} = false;`);
+  declareHandler(OpCode.Throw, `${readArgs} throw (args.length > 0 ? ${regRef("args[0]")} : undefined);`);
+  declareHandler(
+    OpCode.TryCatchBegin,
+    `
+    ${readArgs}
+    ${ctxRef("tryFrames")}.push({
+      ${frame.catchPc}: args[0],
+      ${frame.endPc}: args[1],
+      ${frame.exceptionReg}: args[2],
+    });
+  `
+  );
+  declareHandler(OpCode.TryCatchEnd, `${readArgs} if (${ctxRef("tryFrames")}.length > 0) { ${ctxRef("tryFrames")}.pop(); }`);
+  declareHandler(
+    OpCode.Await,
+    `
+    ${readArgs}
+    ${ctxRef("awaitPromise")} = Promise.resolve(${regRef("args[0]")});
+    ${ctxRef("resumeReg")} = args[1];
+    ${ctxRef("resumeMode")} = 'await';
+    ${ctxRef("running")} = false;
+    ${config.rollingKeys ? `ctx.${ctx.pathHash} = 0;` : ""}
+  `
+  );
+  declareHandler(OpCode.Nop, `${readArgs} /* Junk */`);
+  declareHandler(OpCode.Halt, `${ctxRef("running")} = false;`);
+  declareHandler(
+    OpCode.PrivateGet,
+    `
+    ${readArgs}
+    var obj = ctx.regs[args[0]];
+    var key = ctx.regs[args[1]];
+    var p = ${top.weakMapGet}.call(${top.privateData}, obj);
+    if (!p || !(key in p)) throw new TypeError(${runtimeStringRef("Cannot read private member")});
+    ctx.regs[args[2]] = p[key];
+  `
+  );
+  declareHandler(
+    OpCode.PrivateSet,
+    `
+    ${readArgs}
+    var obj = ctx.regs[args[0]];
+    var key = ctx.regs[args[1]];
+    var p = ${top.weakMapGet}.call(${top.privateData}, obj);
+    if (!p) { p = {}; ${top.weakMapSet}.call(${top.privateData}, obj, p); }
+    p[key] = ctx.regs[args[2]];
+  `
+  );
+  declareHandler(
+    OpCode.PrivateIn,
+    `
+    ${readArgs}
+    var obj = ctx.regs[args[0]];
+    var key = ctx.regs[args[1]];
+    var p = ${top.weakMapGet}.call(${top.privateData}, obj);
+    ctx.regs[args[2]] = p ? (key in p) : false;
+  `
+  );
+  declareHandler(
+    OpCode.SuperPropGet,
+    `
+    ${readArgs}
+    var isStatic = typeof ${ctxRef("thisArg")} === 'function';
+    var superProto = isStatic 
+      ? ${top.objectObj}.getPrototypeOf(${ctxRef("thisArg")})
+      : ${top.objectObj}.getPrototypeOf(${top.objectObj}.getPrototypeOf(${ctxRef("thisArg")}));
+    ctx.regs[args[1]] = superProto[ctx.regs[args[0]]];
+  `
+  );
+  declareHandler(
+    OpCode.SuperPropSet,
+    `
+    ${readArgs}
+    var isStatic = typeof ${ctxRef("thisArg")} === 'function';
+    var superProto = isStatic 
+      ? ${top.objectObj}.getPrototypeOf(${ctxRef("thisArg")})
+      : ${top.objectObj}.getPrototypeOf(${top.objectObj}.getPrototypeOf(${ctxRef("thisArg")}));
+    superProto[ctx.regs[args[0]]] = ctx.regs[args[1]];
+  `
+  );
+  declareHandler(
+    OpCode.SuperCall,
+    `
+    ${readArgs}
+    if (!${top.reflectObj} || !${top.reflectObj}.construct) {
+      throw new TypeError('Reflect.construct is required for super()');
+    }
+    var superCtor = ${top.objectObj}.getPrototypeOf(${ctxRef("newTarget")});
+    var aa = [];
+    for (var ci = 0; ci < args.length - 1; ci++) {
+      aa.push(ctx.regs[args[ci]]);
+    }
+    ${ctxRef("thisArg")} = ${top.reflectObj}.construct(superCtor, aa, ${ctxRef("newTarget")});
+    ctx.regs[args[args.length - 1]] = ${ctxRef("thisArg")};
+  `
+  );
+  declareHandler(
+    OpCode.SuperCallWithArray,
+    `
+    ${readArgs}
+    if (!${top.reflectObj} || !${top.reflectObj}.construct) {
+      throw new TypeError('Reflect.construct is required for super()');
+    }
+    var superCtor = ${top.objectObj}.getPrototypeOf(${ctxRef("newTarget")});
+    ${ctxRef("thisArg")} = ${top.reflectObj}.construct(superCtor, ctx.regs[args[0]], ${ctxRef("newTarget")});
+    ctx.regs[args[1]] = ${ctxRef("thisArg")};
+  `
+  );
+  declareHandler(
+    OpCode.Yield,
+    `
+    ${readArgs}
+    ${ctxRef("resumeReg")} = args[1];
+    ${ctxRef("resumeMode")} = 'yield';
+    ${ctxRef("resumeValue")} = ctx.regs[args[0]];
+    ${ctxRef("running")} = false;
+    ${config.rollingKeys ? `ctx.${ctx.pathHash} = 0;` : ""}
+  `
+  );
+  declareHandler(
+    OpCode.YieldStar,
+    `
+    ${readArgs}
+    ${ctxRef("resumeReg")} = args[1];
+    ${ctxRef("resumeMode")} = 'yieldStar';
+    ${ctxRef("resumeValue")} = ctx.regs[args[0]];
+    ${ctxRef("running")} = false;
+    ${config.rollingKeys ? `ctx.${ctx.pathHash} = 0;` : ""}
+  `
+  );
+  declareHandler(
+    OpCode.GetEntropy,
+    `
+    ${readArgs}
+    var t = 0;
+    try {
+      if (${top.performanceNow}) {
+        t = ${top.performanceNow}();
+      } else if (typeof Date !== 'undefined' && typeof Date.now === 'function') {
+        t = Date.now();
+      }
+    } catch(e) {}
+    var r = 0;
+    try {
+      r = ${top.mathRandom}() * 1000;
+    } catch(e) {}
+    var tBits = (t * 1000) & 0xFFFFFFFF;
+    var rBits = r & 0xFFFFFFFF;
+    var entropy = (ctx.${ctx.rollingState} ^ (${ctxRef("pc")} * 2654435761) ^ tBits ^ rBits) >>> 0;
+    entropy = (entropy ^ (entropy >>> 16)) & 0xFF;
+    ctx.regs[args[0]] = entropy;
+  `
+  );
+  const superRng = new SeededRandom(config.seed);
+  const superIds = superRng.shuffle([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  const loadConstMulId = superIds[0];
+  const getEntropyMulId = superIds[1];
+  const loadConstAddId = superIds[2];
+  declareHandler(
+    OpCode.SuperInstruction,
+    `
+    ${readArgs}
+    var patternId = args[0];
+    if (patternId === ${loadConstMulId}) {
+      var val = (kinds[1] === 2) ? ${top.getCP}(ctx, args[1]) : args[1];
+      ctx.regs[args[2]] = val;
+      ctx.regs[args[4]] = val * ctx.regs[args[3]];
+    } else if (patternId === ${getEntropyMulId}) {
+      var entropy = (ctx.${ctx.rollingState} ^ (${ctxRef("pc")} * 2654435761)) >>> 0;
+      entropy = (entropy ^ (entropy >>> 16)) & 0xFF;
+      ctx.regs[args[1]] = entropy;
+      ctx.regs[args[2]] = entropy * entropy;
+    } else if (patternId === ${loadConstAddId}) {
+      var val = (kinds[1] === 2) ? ${top.getCP}(ctx, args[1]) : args[1];
+      ctx.regs[args[2]] = val;
+      ctx.regs[args[4]] = val + ctx.regs[args[3]];
+    } else {
+      throw new Error('Invalid Super-Instruction Pattern: ' + patternId);
+    }
+  `
+  );
+  const antiDebugLogic = config.antiDebug ? `
+    // Anti-Debug DevTools & Trace Protection (Self-Destruct Trap)
+    // \u26A0\uFE0F WARNING: Contains literal \`debugger;\` statement. This will trigger
+    // breakpoints in DevTools. Remove this entire block if distributing to production.
+    var _dbg_start = typeof performance !== 'undefined' ? performance.now() : Date.now();
+    debugger;
+       selfDestruct(ctx);
+    }
+    // Opaque getter trap to detect automated inspect / DevTools formatting
+    var _rTrap = /./;
+    ${top.nativeDefineProperty}(_rTrap, 'source', {
+      get: function() {
+        selfDestruct(ctx);
+        return 'trap';
+      }
+    });
+  ` : "";
+  const tamperDetectionLogic = config.tamperDetection ? `
+    // Multi-layer native intrinsics verification (hardened against toString spoofing)
+    var _isNative = function(fn) {
+      try { 
+        if (typeof fn !== 'function') return false;
+        var s = ${top.nativeCall}.call(${top.nativeToString}, fn);
+        var regexPass = ${top.nativeCall}.call(RegExp.prototype.test, /^\\s*function\\s*[a-zA-Z0-9_$]*\\s*\\(\\s*\\)\\s*\\{\\s*\\[native code\\]\\s*\\}\\s*$/, s) || 
+               (${top.nativeCall}.call(String.prototype.indexOf, s, '[native code]') !== -1 && ${top.nativeCall}.call(String.prototype.indexOf, s, 'function') !== -1);
+        if (!regexPass) return false;
+        // Cross-check: verify our cached toString reference itself reports native
+        var selfCheck = ${top.nativeCall}.call(${top.nativeToString}, ${top.nativeToString});
+        if (${top.nativeCall}.call(String.prototype.indexOf, selfCheck, '[native code]') === -1) return false;
+        // Prototype identity: native functions have non-configurable prototype
+        var protoDesc = ${top.nativeGetOwnPropertyDescriptor}(fn, 'prototype');
+        // Most builtins lack own 'prototype' (WeakMap.prototype.get, etc.)
+        // If present, it should not be configurable on native constructors
+        if (protoDesc && protoDesc.configurable && fn.length === 0) return false;
+        // Name consistency: native function name should not be writable
+        var nameDesc = ${top.nativeGetOwnPropertyDescriptor}(fn, 'name');
+        if (nameDesc && nameDesc.writable) return false;
+        return true;
+      }
+      catch (_) { return false; }
+    };
+    var fnStr = ${top.nativeCall}.call(${top.nativeToString}, __runVm);
+    var hasDbg = 0;
+    for (var i = 0; i < fnStr.length - 7; i++) {
+       if (fnStr.charCodeAt(i) === 100 && fnStr.charCodeAt(i+1) === 101 && fnStr.charCodeAt(i+2) === 98 && fnStr.charCodeAt(i+3) === 117) {
+           hasDbg = 1; break;
+       }
+    }
+    
+    // Intrinsic verification for descriptor descriptors and identity
+    var verifyIntrinsic = function(obj, prop, expectedNative) {
+      if (!obj || !prop) return false;
+      var desc = ${top.nativeGetOwnPropertyDescriptor}(obj, prop);
+      if (!desc) return false;
+      if (expectedNative && !_isNative(desc.value || desc.get)) return false;
+      return true;
+    };
+
+    // Active hook probes: call native methods on controlled inputs and verify expected behavior
+    var probeActive = function() {
+      try {
+        var map = new ${top.weakMapCtor}();
+        var key = {};
+        ${top.nativeCall}.call(${top.weakMapSet}, map, key, 42);
+        if (${top.nativeCall}.call(${top.weakMapGet}, map, key) !== 42) return false;
+        var sliceRes = ${top.nativeCall}.call(${top.arraySlice}, [1, 2], 1);
+        if (!sliceRes || sliceRes[0] !== 2 || sliceRes.length !== 1) return false;
+        return true;
+      } catch (_) { return false; }
+    };
+
+    if (
+      (!hasDbg && ${config.antiDebug}) || 
+      fnStr.length < 50 || 
+      !_isNative(${top.nativeMathSin}) ||
+      !_isNative(${top.weakMapGet}) ||
+      !_isNative(${top.weakMapSet}) ||
+      !_isNative(${top.nativeToString}) ||
+      !verifyIntrinsic((cleanIntrinsics.Function || Function).prototype, 'toString', true) ||
+      !verifyIntrinsic((cleanIntrinsics.Array || Array).prototype, 'slice', true) ||
+      !verifyIntrinsic(${top.objectObj}, 'defineProperty', true) ||
+      !verifyIntrinsic(cleanIntrinsics.Promise || Promise, 'resolve', true) ||
+      !verifyIntrinsic(${top.reflectObj}, 'construct', true) ||
+      !probeActive()
+    ) {
+      selfDestruct(ctx);
+    }
+  ` : "";
+  const runtimeDispatch = (() => {
+    const vOpToHandlerName = new Array(256);
+    const vOpToVariants = new Array(256);
+    const trapFnName = handlerNames.get(OpCode.Trap);
+    vOpToHandlerName.fill(trapFnName);
+    vOpToVariants.fill(`[${trapFnName}]`);
+    for (const [canonical, mapped] of opToMapped.entries()) {
+      const fnNames = allHandlerVariants.get(canonical);
+      if (!fnNames) continue;
+      for (const vOp of mapped) {
+        if (vOp >= 0 && vOp < 256) {
+          const varIdx = (vOp ^ config.seed) % fnNames.length;
+          vOpToHandlerName[vOp] = fnNames[varIdx];
+          vOpToVariants[vOp] = `[${fnNames.join(", ")}]`;
+        }
+      }
+    }
+    if (config.runtimeHardening === "paranoid") {
+      const dispatchArch = config.seed % 5;
+      if (dispatchArch === 0) {
+        let casesStr = "";
+        for (let b = 0; b < 16; b++) {
+          let subCases = "";
+          for (let offset = 0; offset < 16; offset++) {
+            const vOp = b << 4 | offset;
+            const variants = vOpToVariants[vOp];
+            subCases += `        case ${offset}: var va = ${variants}; return va[(((ctx.${ctx.rollingState} >>> 16) ^ (ctx.${ctx.rollingState} & 0xFFFF)) & 0x7FFF) % va.length];
+`;
+          }
+          casesStr += `      case ${b}:
+        switch (nextOp & 0xF) {
+${subCases}        }
+        break;
+`;
+        }
+        return {
+          declarations: `
+  function resolveRoute(ctx, token) {
+    if (token === null) return null;
+    var nextOp = (token ^ ctx.${ctx.rollingState}) & 0xFF;
+    var bucket = (nextOp >> 4) & 0xF;
+    switch (bucket) {
+${casesStr}
+    }
+    return ${trapFnName};
+  }
+          `,
+          invoke: `resolveRoute(ctx, makeRouteToken(ctx, ${locals.opByte}));`
+        };
+      }
+      if (dispatchArch === 1) {
+        const saltByte = (config.seed ^ 42483) & 255;
+        const saltByte2 = (config.seed >>> 8 ^ 49841) & 255;
+        const permTable = new Array(256).fill(`[${trapFnName}]`);
+        for (let vOp = 0; vOp < 256; vOp++) {
+          const nibSwap = (vOp >> 4 | (vOp & 15) << 4) & 255;
+          const permuted = (nibSwap ^ saltByte ^ saltByte2) & 255;
+          permTable[permuted] = vOpToVariants[vOp];
+        }
+        return {
+          declarations: `
+  var _hcVT = [
+    ${permTable.join(",\n    ")}
+  ];
+  function resolveRoute(ctx, token) {
+    if (token === null) return null;
+    var nextOp = (token ^ ctx.${ctx.rollingState}) & 0xFF;
+    var nibSwap = ((nextOp >> 4) | ((nextOp & 0xF) << 4)) & 0xFF;
+    var h = (nibSwap ^ ${saltByte} ^ ${saltByte2}) & 0xFF;
+    var variants = _hcVT[h];
+    if (!variants || !variants.length) return ${trapFnName};
+    return variants[(((ctx.${ctx.rollingState} >>> 16) ^ (ctx.${ctx.rollingState} & 0xFFFF)) & 0x7FFF) % variants.length];
+  }
+          `,
+          invoke: `resolveRoute(ctx, makeRouteToken(ctx, ${locals.opByte}));`
+        };
+      }
+      if (dispatchArch === 2) {
+        const xorScramble = (config.seed ^ 2117967660) & 255;
+        const scrambledTable = new Array(256).fill(`[${trapFnName}]`);
+        for (let vOp = 0; vOp < 256; vOp++) {
+          const idx = (vOp ^ xorScramble) & 255;
+          scrambledTable[idx] = vOpToVariants[vOp];
+        }
+        return {
+          declarations: `
+  var _tfVT = [
+    ${scrambledTable.join(",\n    ")}
+  ];
+  function resolveRoute(ctx, token) {
+    if (token === null) return null;
+    var nextOp = (token ^ ctx.${ctx.rollingState}) & 0xFF;
+    var scrambled = (nextOp ^ ${xorScramble}) & 0xFF;
+    var variants = _tfVT[scrambled];
+    if (!variants || !variants.length) return ${trapFnName};
+    return variants[(((ctx.${ctx.rollingState} >>> 16) ^ (ctx.${ctx.rollingState} & 0xFFFF)) & 0x7FFF) % variants.length];
+  }
+          `,
+          invoke: `resolveRoute(ctx, makeRouteToken(ctx, ${locals.opByte}));`
+        };
+      }
+      if (dispatchArch === 3) {
+        const bitRevSalt = (config.seed ^ 19325) & 255;
+        const bitRevTable = new Array(256).fill(`[${trapFnName}]`);
+        for (let vOp = 0; vOp < 256; vOp++) {
+          let rev = 0;
+          for (let bit = 0; bit < 8; bit++) {
+            if (vOp & 1 << bit) rev |= 1 << 7 - bit;
+          }
+          const idx = (rev ^ bitRevSalt) & 255;
+          bitRevTable[idx] = vOpToVariants[vOp];
+        }
+        return {
+          declarations: `
+  var _brVT = [
+    ${bitRevTable.join(",\n    ")}
+  ];
+  function _rev8(x) {
+    x = ((x & 0xF0) >> 4) | ((x & 0x0F) << 4);
+    x = ((x & 0xCC) >> 2) | ((x & 0x33) << 2);
+    x = ((x & 0xAA) >> 1) | ((x & 0x55) << 1);
+    return x & 0xFF;
+  }
+  function resolveRoute(ctx, token) {
+    if (token === null) return null;
+    var nextOp = (token ^ ctx.${ctx.rollingState}) & 0xFF;
+    var h = (_rev8(nextOp) ^ ${bitRevSalt}) & 0xFF;
+    var variants = _brVT[h];
+    if (!variants || !variants.length) return ${trapFnName};
+    return variants[(((ctx.${ctx.rollingState} >>> 16) ^ (ctx.${ctx.rollingState} & 0xFFFF)) & 0x7FFF) % variants.length];
+  }
+          `,
+          invoke: `resolveRoute(ctx, makeRouteToken(ctx, ${locals.opByte}));`
+        };
+      }
+      const oddMul = config.seed & 127 | 1 | 2;
+      const addConst4 = config.seed >>> 16 & 255;
+      const affineTable = new Array(256).fill(`[${trapFnName}]`);
+      for (let vOp = 0; vOp < 256; vOp++) {
+        const idx = vOp * oddMul + addConst4 & 255;
+        affineTable[idx] = vOpToVariants[vOp];
+      }
+      return {
+        declarations: `
+  var _afVT = [
+    ${affineTable.join(",\n    ")}
+  ];
+  function resolveRoute(ctx, token) {
+    if (token === null) return null;
+    var nextOp = (token ^ ctx.${ctx.rollingState}) & 0xFF;
+    var h = ((nextOp * ${oddMul}) + ${addConst4}) & 0xFF;
+    var variants = _afVT[h];
+    if (!variants || !variants.length) return ${trapFnName};
+    return variants[(((ctx.${ctx.rollingState} >>> 16) ^ (ctx.${ctx.rollingState} & 0xFFFF)) & 0x7FFF) % variants.length];
+  }
+          `,
+        invoke: `resolveRoute(ctx, makeRouteToken(ctx, ${locals.opByte}));`
+      };
+    }
+    return {
+      declarations: `
+  const ${locals.dispatchBank} = [
+    ${vOpToHandlerName.join(",\n    ")}
+  ];
+  function resolveRoute(ctx, token) {
+    if (token === null) return null;
+    var nextOp = (token ^ ctx.${ctx.rollingState}) & 0xFF;
+    return ${locals.dispatchBank}[nextOp];
+  }
+        `,
+      invoke: `${locals.dispatchBank}[${locals.opByte}](ctx);`
+    };
+  })();
+  const allBytecodes = [];
+  const functionTable = {};
+  let currentOffset = 0;
+  for (const fn of module.functions) {
+    const fnSalt = buildRng.nextRange(1, 4294967295);
+    functionTable[fn.id] = {
+      o: currentOffset,
+      l: fn.bytecode.length,
+      a: fn.attributes ? [...fn.attributes] : [],
+      r: fn.maxRegisters,
+      s: fnSalt
+    };
+    for (let i = 0; i < fn.bytecode.length; i++) {
+      allBytecodes.push(fn.bytecode[i]);
+    }
+    currentOffset += fn.bytecode.length;
+  }
+  const arenaArray = allBytecodes.join(",");
+  const fnTableStr = Object.entries(functionTable).map(([id, info]) => {
+    return `${JSON.stringify(id)}: { o: ${info.o}, l: ${info.l}, a: ${JSON.stringify(info.a)}, r: ${info.r}, s: ${info.s} }`;
+  }).join(",\n    ");
+  const handlerVariantsEntries = Array.from(allHandlerVariants.entries()).map(([canonical, names2]) => {
+    return `[${canonical}]: [${names2.join(", ")}]`;
+  }).join(",\n    ");
+  const handlerVariantsStr = `const handlerVariants = {
+    ${handlerVariantsEntries}
+  };`;
+  if (config.runtimeHardening === "paranoid") {
+    handlerDeclarations.push(`function _fakeHandler_A(ctx) {
+    var _r192 = ctx.regs;
+    var a = _r192[0] ^ 0x3d2;
+    var b = (a * 9172) | 0;
+    _r192[1] = b ^ 0xdead;
+    return (ctx.${ctx.rollingState} ^ 0xab) & 0xffff;
+  }
+  function _fakeHandler_B(ctx) {
+    var _r928 = ctx.regs;
+    var a = _r928[1] & 0xff;
+    var b = Math.sin(a) * 4;
+    _r928[2] = b | 0;
+    return (ctx.${ctx.rollingState} ^ 0x3e) & 0xffff;
+  }`);
+  }
+  const sourceCode = `
+// Polymorphic Threaded VM Engine - Build: ${module.buildId}
+const ${top.vmFunctions} = (function() {
+  "use strict";
+  const ${top.seed} = ${config.seed};
+  const ${top.rawCP} = ${cp};
+
+  // Grab clean intrinsics from a secure isolated context.
+  // Uses iframe (browser) ONLY \u2014 require('vm') is deliberately excluded
+  // due to known sandbox escape vulnerabilities (CVE-2023-37903, etc.).
+  // For Node.js environments, pre-sealed intrinsics should be provided via config.
+  var cleanIntrinsics = (function() {
+    var win;
+    try {
+      if (typeof document !== 'undefined' && typeof document.createElement === 'function') {
+        var iframe = document.createElement('iframe');
+        iframe.style.display = 'none';
+        document.documentElement.appendChild(iframe);
+        win = iframe.contentWindow;
+        try {
+          if (iframe && iframe.parentNode) iframe.parentNode.removeChild(iframe);
+        } catch(e) {}
+      }
+    } catch (e) {}
+    return win || {};
+  })();
+
+  const ${top.weakMapCtor} = cleanIntrinsics.WeakMap || WeakMap;
+  const ${top.weakMapGet} = ${top.weakMapCtor}.prototype.get;
+  const ${top.weakMapSet} = ${top.weakMapCtor}.prototype.set;
+  const ${top.reflectObj} = cleanIntrinsics.Reflect || (typeof Reflect !== 'undefined' ? Reflect : undefined);
+  const ${top.objectObj} = cleanIntrinsics.Object || Object;
+  const ${top.nativeToString} = (cleanIntrinsics.Function || Function).prototype.toString;
+  const ${top.nativeMathSin} = (cleanIntrinsics.Math || Math).sin;
+  const ${top.arraySlice} = (cleanIntrinsics.Array || Array).prototype.slice;
+  const ${top.promiseResolve} = (cleanIntrinsics.Promise || Promise).resolve.bind(cleanIntrinsics.Promise || Promise);
+  const ${top.iteratorSymbol} = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';
+  const ${top.asyncIteratorSymbol} = typeof Symbol !== 'undefined' && Symbol.asyncIterator ? Symbol.asyncIterator : null;
+  const ${top.privateData} = new ${top.weakMapCtor}();
+
+  // Secure local caches of essential operations
+  const ${top.nativeDefineProperty} = ${top.objectObj}.defineProperty;
+  const ${top.nativeGetOwnPropertyDescriptor} = ${top.objectObj}.getOwnPropertyDescriptor;
+  const ${top.nativeApply} = (cleanIntrinsics.Function || Function).prototype.apply;
+  const ${top.nativeCall} = (cleanIntrinsics.Function || Function).prototype.call;
+  const ${top.performanceNow} = (cleanIntrinsics.performance && cleanIntrinsics.performance.now) ? cleanIntrinsics.performance.now.bind(cleanIntrinsics.performance) : (typeof performance !== 'undefined' && performance.now) ? performance.now.bind(performance) : null;
+  const ${top.mathRandom} = (cleanIntrinsics.Math || Math).random;
+  let executionCounter = 0;
+
+  function selfDestruct(ctx) {
+    if (!ctx) return;
+    ctx.poisoned = true;
+    ctx.${ctx.running} = false;
+    ctx.${ctx.pc} = 999999;
+    if (ctx.${ctx.bytecode}) {
+      for (var i = 0; i < ctx.${ctx.bytecode}.length; i++) {
+        ctx.${ctx.bytecode}[i] = 0;
+      }
+    }
+    if (ctx.${ctx.xorLog}) {
+      for (var i = 0; i < ctx.${ctx.xorLog}.length; i++) {
+        ctx.${ctx.xorLog}[i] = 0;
+      }
+    }
+    try {
+      for (var i = 0; i < ctx.regCount; i++) {
+        ctx.${ctx.regs}[i] = 0;
+      }
+    } catch(e) {}
+    ctx.${ctx.env} = [];
+    ctx.${ctx.tryFrames} = [];
+    ctx.${ctx.returnValue} = undefined;
+    ctx.${ctx.globalScope} = {};
+  }
+
+  ${runtimeStringBootstrap}
+  
+  // Lazy Decryption
+  function ${top.getCP}(ctx, index) {
+    var c = ${top.rawCP}[index];
+    if (!c) return undefined;
+    if (c.kind === 'string' && ${config.constantPoolEncoding === ConstantEncodingScheme.XorRotate}) {
+      var val = c.value;
+      var decoded = '';
+      var stringSeed = (${top.seed} ^ (index * 0x9E3779B9)) | 0;
+      if (ctx && ctx.${ctx.pathHash} !== undefined) {
+        stringSeed = (stringSeed ^ ctx.${ctx.pathHash}) | 0;
+      }
+      
+      // Deriving 16-byte key using LCG
+      var keyBytes = [];
+      var s = stringSeed;
+      for (var i = 0; i < 16; i++) {
+        s = (Math.imul(s, ${mulConst}) + ${addConst}) | 0;
+        keyBytes.push((s >>> 16) & 0xff);
+      }
+      
+      // KSA
+      var S = [];
+      for (var i = 0; i < 256; i++) S.push(i);
+      var j = 0;
+      for (var i = 0; i < 256; i++) {
+        j = (j + S[i] + keyBytes[i % 16]) & 0xff;
+        var temp = S[i];
+        S[i] = S[j];
+        S[j] = temp;
+      }
+      
+      // PRGA with drop-256
+      var ri = 0;
+      j = 0;
+      for (var skip = 0; skip < 256; skip++) {
+        ri = (ri + 1) & 0xff;
+        j = (j + S[ri]) & 0xff;
+        var temp = S[ri];
+        S[ri] = S[j];
+        S[j] = temp;
+      }
+      
+      for (var i = 0; i < val.length; i++) {
+        ri = (ri + 1) & 0xff;
+        j = (j + S[ri]) & 0xff;
+        var temp = S[ri];
+        S[ri] = S[j];
+        S[j] = temp;
+        var keystreamByte = S[(S[ri] + S[j]) & 0xff];
+        decoded += String.fromCharCode(val.charCodeAt(i) ^ keystreamByte);
+      }
+      
+      return decoded;
+    }
+    return c.kind === 'undefined' ? undefined : c.value;
+  }
+
+  function mixRollingState(ctx, pos, decoded) {
+    var salt = ctx.salt || 0;
+    var nonce = ctx.executionNonce || 0;
+    var op = ctx.currentOpcode || 0;
+    var mixed = (pos ^ decoded ^ op ^ salt ^ nonce) & 0xFF;
+    // MurmurHash3-inspired non-linear mixing (replaces reversible LCG)
+    var s = ctx.${ctx.rollingState} ^ mixed;
+    s = Math.imul(s, 0xcc9e2d51);
+    s = ((s << 15) | (s >>> 17));
+    s = Math.imul(s, 0x1b873593);
+    s ^= (s >>> 13);
+    s = Math.imul(s, 0xc2b2ae35);
+    s ^= (s >>> 16);
+    ctx.${ctx.rollingState} = s;
+  }
+
+  function corruptByteNear(ctx, at, mask) {
+    if (at >= 0 && at < ctx.bytecode.length) {
+      // Asymmetric masking: xorLog gets bit-reversed mask (linear over XOR, prevents cancellation)
+      var rev = ((mask & 0xF0) >>> 4) | ((mask & 0x0F) << 4);
+      rev = ((rev & 0xCC) >>> 2) | ((rev & 0x33) << 2);
+      rev = ((rev & 0xAA) >>> 1) | ((rev & 0x55) << 1);
+      ctx.bytecode[at] ^= mask;
+      ctx.${ctx.xorLog}[at] ^= rev;
+    }
+  }
+
+  function makeRouteToken(ctx, nextOp) {
+    return (nextOp ^ ctx.${ctx.rollingState}) & 0xFFFF;
+  }
+
+
+
+  function ${top.readByte}(ctx) {
+    var pos = ${ctxRef("pc")}++;
+    if (pos >= ${ctxRef("bytecode")}.length) return 0;
+    var byte = ${ctxRef("bytecode")}[pos];
+    ${config.rollingKeys ? `
+      var xorVal = ${ctxRef("xorLog")}[pos];
+      var rev = ((xorVal & 0xF0) >>> 4) | ((xorVal & 0x0F) << 4);
+      rev = ((rev & 0xCC) >>> 2) | ((rev & 0x33) << 2);
+      rev = ((rev & 0xAA) >>> 1) | ((rev & 0x55) << 1);
+      byte ^= rev;
+      var rawDecoded = byte ^ (((${top.seed} ^ (pos * 0x9E3779B9)) >>> 8) & 0xFF);
+      var decoded = (rawDecoded - pos) & 0xFF;
+      if (${config.runtimeHardening === "paranoid" ? "true" : "false"}) {
+        mixRollingState(ctx, pos, decoded);
+      } else {
+        // Non-linear state advancement (replaces reversible LCG)
+        var s_nr = ctx.${ctx.rollingState} ^ pos;
+        s_nr = Math.imul(s_nr, 0xcc9e2d51);
+        s_nr = ((s_nr << 15) | (s_nr >>> 17));
+        s_nr = Math.imul(s_nr, 0x1b873593);
+        s_nr ^= (s_nr >>> 13);
+        ctx.${ctx.rollingState} = s_nr;
+      }
+      var mask = ((ctx.${ctx.rollingState} >>> 16) & 0xFF) | 1;
+      if (${config.runtimeHardening === "paranoid" ? "true" : "false"}) {
+        corruptByteNear(ctx, pos, mask);
+        corruptByteNear(ctx, pos - 1, (mask * 3) & 0xFF);
+        corruptByteNear(ctx, pos + 1, (mask * 7) & 0xFF);
+        var stride = ((ctx.${ctx.rollingState} >>> 8) & 3) + 2;
+        corruptByteNear(ctx, pos + stride, (mask * 13) & 0xFF);
+      } else {
+         var revMask = ((mask & 0xF0) >>> 4) | ((mask & 0x0F) << 4);
+         revMask = ((revMask & 0xCC) >>> 2) | ((revMask & 0x33) << 2);
+         revMask = ((revMask & 0xAA) >>> 1) | ((revMask & 0x55) << 1);
+         ctx.${ctx.bytecode}[pos] ^= mask;
+         ctx.${ctx.xorLog}[pos] ^= revMask;
+      }
+      return decoded;
+    ` : `
+      return byte;
+    `}
+  }
+
+  ${handlerDeclarations.join("\n\n")}
+
+  ${handlerVariantsStr}
+
+  ${runtimeDispatch.declarations}
+
+  const ${top.functionArena} = new Uint8Array([${arenaArray}]);
+  const ${top.functionBytecodes} = {
+    ${fnTableStr}
+  };
+  const ${top.executorCache} = Object.create(null);
+
+  function ${top.getExecutorById}(functionId, env) {
+    if ((!env || env.length === 0) && ${top.executorCache}[functionId]) {
+      return ${top.executorCache}[functionId];
+    }
+    const functionMeta = ${top.functionBytecodes}[functionId];
+    if (!functionMeta) {
+      throw new Error(${runtimeStringRef("Unknown VM function id: ")} + functionId);
+    }
+    const bytecodeSegment = ${top.functionArena}.subarray(functionMeta.o, functionMeta.o + functionMeta.l);
+    const executor = ${top.createExecutor}(bytecodeSegment, env || [], functionMeta.a || [], functionMeta.r || 0, functionMeta.s || 0);
+    if (!env || env.length === 0) {
+      ${top.executorCache}[functionId] = executor;
+    }
+    return executor;
+  }
+
+  function __createVmContext(bytecodeArr, envArr, thisArg, newTarget, argsArr, registerCount, salt) {
+    var rawRegs = new Array(registerCount > 0 ? registerCount : argsArr.length + 8).fill(undefined);
+    var regCount = rawRegs.length;
+    var ctx;
+    var regsProxy = new Proxy(rawRegs, {
+      get: function(target, prop) {
+        if (typeof prop === 'string') {
+          var idx = +prop;
+          if (idx === idx) {
+            if (idx < 0 || idx >= regCount) {
+              throw new Error('Register out of bounds (get): ' + idx + ', regCount: ' + regCount);
+            }
+          }
+        }
+        return target[prop];
+      },
+      set: function(target, prop, val) {
+        if (typeof prop === 'string') {
+          var idx = +prop;
+          if (idx === idx) {
+            if (idx < 0 || idx >= regCount) {
+              throw new Error('Register out of bounds (set): ' + idx + ', regCount: ' + regCount + ', val: ' + val);
+            }
+          }
+        }
+        target[prop] = val;
+        return true;
+      }
+    });
+    ctx = {
+      ${ctx.pc}: 0,
+      ${ctx.bytecode}: ${config.rollingKeys ? "Uint8Array.from(bytecodeArr)" : "bytecodeArr"},
+      ${ctx.regs}: regsProxy,
+      ${ctx.fnArgs}: argsArr,
+      ${ctx.env}: envArr || [],
+      ${ctx.globalScope}: typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : global,
+      ${ctx.thisArg}: thisArg,
+      ${ctx.newTarget}: newTarget,
+      ${ctx.resumeMode}: 'normal',
+      ${ctx.resumeValue}: undefined,
+      ${ctx.resumeReg}: -1,
+      ${ctx.awaitPromise}: null,
+      ${ctx.running}: true,
+      ${ctx.returnValue}: undefined,
+      ${ctx.tryFrames}: [],
+      ${ctx.rollingState}: ${config.rollingKeys ? `${top.seed} & 0xFF` : "0"},
+      ${ctx.xorLog}: ${config.rollingKeys ? "new Uint8Array(bytecodeArr.length)" : "null"},
+      ${ctx.executionNonce}: ${config.rollingKeys ? "(++executionCounter)" : "0"},
+      salt: ${config.rollingKeys ? "salt" : "0"},
+      currentOpcode: 0,
+      poisoned: false,
+      regCount: regCount,
+      ${ctx.currentHandlerIdx}: 0,
+      ${ctx.pathHash}: 0,
+      shred: function() {
+        // Zero per-execution register backing array
+        if (rawRegs) {
+          for (var i = 0; i < rawRegs.length; i++) rawRegs[i] = 0;
+        }
+        ${config.rollingKeys ? `
+        if (ctx.${ctx.bytecode} && ctx.${ctx.bytecode}.fill) {
+          try { ctx.${ctx.bytecode}.fill(0); } catch(e) {}
+        }
+        ` : ""}
+        ctx.${ctx.bytecode} = new Uint8Array(0);
+        // Detach env reference without destroying shared envArr
+        ctx.${ctx.env} = [];
+        // Zero per-execution args (these are cloned per call via arraySlice)
+        if (argsArr) {
+          for (var i = 0; i < argsArr.length; i++) argsArr[i] = 0;
+        }
+        if (ctx.${ctx.tryFrames}) {
+          ctx.${ctx.tryFrames} = [];
+        }
+        ctx.${ctx.xorLog} = null;
+        ctx.${ctx.returnValue} = undefined;
+        ctx.${ctx.globalScope} = {};
+        ctx.${ctx.running} = false;
+      }
+    };
+    for (let i = 0; i < argsArr.length; i++) {
+      ${regRef("i")} = argsArr[i];
+    }
+    return ctx;
+  }
+
+  function __runVm(ctx) {
+    ${antiDebugLogic}
+    ${tamperDetectionLogic}
+    if (${ctxRef("pc")} >= ${ctxRef("bytecode")}.length) return { kind: 'return', value: ${ctxRef("returnValue")} };
+    let ${locals.opByte} = ${top.readByte}(ctx);
+    ${config.stealthDispatch ? `
+      ${locals.opByte} = (ctx.${ctx.currentHandlerIdx} + ${locals.opByte}) % 256;
+      ctx.${ctx.currentHandlerIdx} = ${locals.opByte};
+    ` : ""}
+    ${config.rollingKeys ? `
+      ctx.${ctx.pathHash} = (Math.imul(ctx.${ctx.pathHash}, 31) + ${locals.opByte}) & 0xFFFFFFFF;
+    ` : ""}
+    let handler = ${config.runtimeHardening === "paranoid" ? `resolveRoute(ctx, makeRouteToken(ctx, ${locals.opByte}))` : `${locals.dispatchBank}[${locals.opByte}]`};
+    
+    while(handler && ${ctxRef("running")} && !ctx.poisoned) {
+      // Timing Jitter Injection to mitigate Timing Side-Channels
+      var jitterLimit = (ctx.${ctx.rollingState} ^ ${ctxRef("pc")}) & 0x3;
+      var jitterVal = 0;
+      for (var j = 0; j < jitterLimit; j++) {
+        jitterVal = (Math.imul(jitterVal + j, 31) + ctx.${ctx.rollingState}) | 0;
+      }
+      if (jitterVal === 0xdeadbeef) {
+        ctx._j = jitterVal;
+      }
+      if (${ctxRef("tryFrames")}.length > 0) {
+        while (${ctxRef("tryFrames")}.length > 0 && ${ctxRef("pc")} >= ${ctxRef("tryFrames")}[${ctxRef("tryFrames")}.length - 1].${frame.endPc}) {
+          ${ctxRef("tryFrames")}.pop();
+        }
+        if (${ctxRef("tryFrames")}.length === 0) {
+          continue;
+        }
+        try {
+          if (${ctxRef("resumeMode")} === 'store') {
+            ctx.${ctx.regs}[ctx.${ctx.resumeReg}] = ctx.${ctx.resumeValue};
+            ${ctxRef("resumeMode")} = 'normal';
+            ${ctxRef("resumeValue")} = undefined;
+            ${ctxRef("resumeReg")} = -1;
+          } else if (${ctxRef("resumeMode")} === 'throw') {
+            const pendingError = ctx.${ctx.resumeValue};
+            ${ctxRef("resumeMode")} = 'normal';
+            ${ctxRef("resumeValue")} = undefined;
+            throw pendingError;
+          }
+          if (${config.runtimeHardening === "paranoid" ? "true" : "false"}) {
+            handler = resolveRoute(ctx, handler(ctx));
+          } else {
+            handler = handler(ctx);
+          }
+        } catch (error) {
+          const handlerFrame = ${ctxRef("tryFrames")}.pop();
+          ${regRef(frameRef("handlerFrame", "exceptionReg"))} = error;
+          ${ctxRef("running")} = true;
+          ${ctxRef("pc")} = ${frameRef("handlerFrame", "catchPc")};
+          ${config.stealthDispatch ? `ctx.${ctx.currentHandlerIdx} = 0;` : ""}
+          ${config.rollingKeys ? `ctx.${ctx.pathHash} = 0;` : ""}
+          if (${ctxRef("pc")} >= ${ctxRef("bytecode")}.length) {
+            handler = null;
+          } else {
+            let nextOp = ${top.readByte}(ctx);
+            ${config.stealthDispatch ? `
+              nextOp = (ctx.${ctx.currentHandlerIdx} + nextOp) % 256;
+              ctx.${ctx.currentHandlerIdx} = nextOp;
+            ` : ""}
+            ${config.rollingKeys ? `
+              ctx.${ctx.pathHash} = (Math.imul(ctx.${ctx.pathHash}, 31) + nextOp) & 0xFFFFFFFF;
+            ` : ""}
+            if (${config.runtimeHardening === "paranoid" ? "true" : "false"}) {
+              handler = resolveRoute(ctx, makeRouteToken(ctx, nextOp));
+            } else {
+              handler = ${locals.dispatchBank}[nextOp];
+            }
+          }
+        }
+      } else {
+        if (${ctxRef("resumeMode")} === 'store') {
+          ctx.${ctx.regs}[ctx.${ctx.resumeReg}] = ctx.${ctx.resumeValue};
+          ${ctxRef("resumeMode")} = 'normal';
+          ${ctxRef("resumeValue")} = undefined;
+          ${ctxRef("resumeReg")} = -1;
+        } else if (${ctxRef("resumeMode")} === 'throw') {
+          const pendingError = ctx.${ctx.resumeValue};
+          ${ctxRef("resumeMode")} = 'normal';
+          ${ctxRef("resumeValue")} = undefined;
+          throw pendingError;
+        }
+        if (${config.runtimeHardening === "paranoid" ? "true" : "false"}) {
+          handler = resolveRoute(ctx, handler(ctx));
+        } else {
+          handler = handler(ctx);
+        }
+      }
+    }
+    if (${ctxRef("resumeMode")} === 'await') {
+      ${ctxRef("resumeMode")} = 'normal';
+      return { kind: 'await', promise: ${ctxRef("awaitPromise")} };
+    }
+    if (${ctxRef("resumeMode")} === 'yield' || ${ctxRef("resumeMode")} === 'yieldStar') {
+      return { kind: ${ctxRef("resumeMode")}, value: ${ctxRef("resumeValue")} };
+    }
+    return { kind: 'return', value: ${ctxRef("returnValue")} };
+  }
+
+  function ${top.createExecutor}(bytecodeArr, envArr, attributes, registerCount, salt) {
+    const isAsync = attributes && attributes.indexOf('async') >= 0;
+    const isGenerator = attributes && attributes.indexOf('generator') >= 0;
+    if (isAsync && isGenerator) {
+      return function execute() {
+        const ${ctx.fnArgs} = ${top.nativeCall}.call(${top.arraySlice}, arguments);
+        const ctx = __createVmContext(bytecodeArr, envArr, this, new.target, ${ctx.fnArgs}, registerCount, salt);
+        let delegateIterator = null;
+        let delegateIsAsync = false;
+        let finished = false;
+        const resumeAwait = async (promise, mode) => {
+          try {
+            ctx.${ctx.resumeMode} = 'store';
+            ctx.${ctx.resumeValue} = await ${top.promiseResolve}(promise);
+            ctx.${ctx.running} = true;
+          } catch (error) {
+            ctx.${ctx.resumeMode} = 'throw';
+            ctx.${ctx.resumeValue} = error;
+            ctx.${ctx.running} = true;
+          }
+          return mode;
+        };
+        return {
+          [${top.asyncIteratorSymbol} || ${top.iteratorSymbol}]: function() { return this; },
+          next: async function(v) {
+            if (finished) return { value: undefined, done: true };
+            try {
+              while (true) {
+                if (delegateIterator) {
+                  const step = delegateIsAsync ? await delegateIterator.next(v) : delegateIterator.next(v);
+                  if (step.done) {
+                    v = step.value;
+                    delegateIterator = null;
+                    delegateIsAsync = false;
+                  } else {
+                    return step;
+                  }
+                }
+                if (ctx.${ctx.resumeMode} === 'yield' || ctx.${ctx.resumeMode} === 'yieldStar') {
+                  ctx.${ctx.resumeMode} = 'normal';
+                  ctx.${ctx.regs}[ctx.${ctx.resumeReg}] = v;
+                  ctx.${ctx.resumeReg} = -1;
+                  ctx.${ctx.running} = true;
+                }
+                const outcome = __runVm(ctx);
+                if (outcome.kind === 'await') {
+                  await resumeAwait(outcome.promise, 'await');
+                  v = undefined;
+                  continue;
+                }
+                if (outcome.kind === 'return') {
+                  finished = true;
+                  ctx.shred();
+                  return { value: outcome.value, done: true };
+                }
+                if (outcome.kind === 'yield') {
+                  return { value: outcome.value, done: false };
+                }
+                if (outcome.kind === 'yieldStar') {
+                  if (${top.asyncIteratorSymbol} && outcome.value[${top.asyncIteratorSymbol}]) {
+                    delegateIterator = outcome.value[${top.asyncIteratorSymbol}]();
+                    delegateIsAsync = true;
+                  } else {
+                    delegateIterator = outcome.value[${top.iteratorSymbol}]();
+                    delegateIsAsync = false;
+                  }
+                  v = undefined;
+                }
+              }
+            } catch(e) {
+              finished = true;
+              ctx.shred();
+              throw e;
+            }
+          },
+          return: async function(v) {
+            finished = true;
+            ctx.${ctx.running} = false;
+            ctx.shred();
+            return { value: v, done: true };
+          },
+          throw: async function(e) {
+            ctx.${ctx.resumeMode} = 'throw';
+            ctx.${ctx.resumeValue} = e;
+            ctx.${ctx.running} = true;
+            try {
+              return await this.next();
+            } catch(err) {
+              ctx.shred();
+              throw err;
+            }
+          }
+        };
+      };
+    }
+    if (isAsync) {
+      return async function execute() {
+        const ${ctx.fnArgs} = ${top.nativeCall}.call(${top.arraySlice}, arguments);
+        const ctx = __createVmContext(bytecodeArr, envArr, this, new.target, ${ctx.fnArgs}, registerCount, salt);
+        try {
+          while (true) {
+            const outcome = __runVm(ctx);
+            if (outcome.kind === 'return') {
+              return outcome.value;
+            }
+            try {
+              ctx.${ctx.resumeMode} = 'store';
+              ctx.${ctx.resumeValue} = await ${top.promiseResolve}(outcome.promise);
+              ctx.${ctx.running} = true;
+            } catch (error) {
+              ctx.${ctx.resumeMode} = 'throw';
+              ctx.${ctx.resumeValue} = error;
+              ctx.${ctx.running} = true;
+            }
+          }
+        } finally {
+          ctx.shred();
+        }
+      };
+    }
+    if (isGenerator) {
+      return function execute() {
+        const ${ctx.fnArgs} = ${top.nativeCall}.call(${top.arraySlice}, arguments);
+        const ctx = __createVmContext(bytecodeArr, envArr, this, new.target, ${ctx.fnArgs}, registerCount, salt);
+        let delegateIterator = null;
+        let finished = false;
+        return {
+          [${top.iteratorSymbol}]: function() { return this; },
+          next: function(v) {
+            if (finished) return { value: undefined, done: true };
+            try {
+              while(true) {
+                if (delegateIterator) {
+                  let step = delegateIterator.next(v);
+                  if (step.done) {
+                    v = step.value;
+                    delegateIterator = null;
+                  } else {
+                    return step;
+                  }
+                }
+                if (ctx.${ctx.resumeMode} === 'yield' || ctx.${ctx.resumeMode} === 'yieldStar') {
+                  ctx.${ctx.resumeMode} = 'normal';
+                  ctx.${ctx.regs}[ctx.${ctx.resumeReg}] = v;
+                  ctx.${ctx.resumeReg} = -1;
+                  ctx.${ctx.running} = true;
+                }
+                const outcome = __runVm(ctx);
+                if (outcome.kind === 'await') {
+                  throw new Error('VM await suspension reached sync generator');
+                }
+                if (outcome.kind === 'return') {
+                  finished = true;
+                  ctx.shred();
+                  return { value: outcome.value, done: true };
+                }
+                if (outcome.kind === 'yield') {
+                  return { value: outcome.value, done: false };
+                }
+                if (outcome.kind === 'yieldStar') {
+                  delegateIterator = outcome.value[${top.iteratorSymbol}]();
+                  v = undefined;
+                  continue;
+                }
+              }
+            } catch(e) {
+              finished = true;
+              ctx.shred();
+              throw e;
+            }
+          },
+          return: function(v) {
+             finished = true;
+             ctx.${ctx.running} = false;
+             ctx.shred();
+             return { value: v, done: true };
+          },
+          throw: function(e) {
+             ctx.${ctx.resumeMode} = 'throw';
+             ctx.${ctx.resumeValue} = e;
+             ctx.${ctx.running} = true;
+             try {
+               return this.next();
+             } catch(err) {
+               ctx.shred();
+               throw err;
+             }
+          }
+        };
+      };
+    }
+    return function execute() {
+      const ${ctx.fnArgs} = ${top.nativeCall}.call(${top.arraySlice}, arguments);
+      const ctx = __createVmContext(bytecodeArr, envArr, this, new.target, ${ctx.fnArgs}, registerCount, salt);
+      try {
+        const outcome = __runVm(ctx);
+        if (outcome.kind === 'await') {
+          throw new Error('VM await suspension reached sync executor');
+        }
+        var retVal = outcome.value;
+        if (new.target) {
+          if (retVal === undefined || (typeof retVal !== 'object' && typeof retVal !== 'function')) {
+            return ctx.${ctx.thisArg};
+          }
+        }
+        return retVal;
+      } finally {
+        ctx.shred();
+      }
+    };
+  }
+
+  var ${top.result} = {};
+${exportedFunctions.map((fn) => `  ${top.result}[${JSON.stringify(fn.name)}] = ${top.getExecutorById}(${JSON.stringify(fn.id)});`).join("\n")}
+  if (typeof Object.freeze === 'function') {
+    Object.freeze(${top.result});
+  }
+  return ${top.result};
+})();
+
+if (typeof module !== 'undefined' && module.exports) {
+${exportedFunctions.map((fn) => `  module.exports[${JSON.stringify(fn.name)}] = ${top.vmFunctions}[${JSON.stringify(fn.name)}];`).join("\n")}
+}
+  `.trim();
+  return {
+    buildId: module.buildId,
+    dispatchLoop: "function dispatch() {}",
+    handlers: [],
+    constantDecoder: "function decode() {}",
+    bytecodePayload: targetFn.bytecode,
+    entryBootstrap: "function boot() {}",
+    fullSource: sourceCode
+  };
+}
+export {
+  buildVMRuntime
+};