js-confuser-vm 0.0.6 → 0.0.7

package/dist/transforms/runtime/microOpcodes.js

@@ -0,0 +1,76 @@
+import * as t from "@babel/types";
+import traverseImport from "@babel/traverse";
+import { ok } from "assert";
+import { applyInternalVariablesToSwitchCase } from "./internalVariables.js";
+const traverse = traverseImport.default || traverseImport;
+
+// Extract the real statement list from a SwitchCase consequent.
+function extractCaseBody(switchCase) {
+  let stmts;
+  if (switchCase.consequent.length === 1 && t.isBlockStatement(switchCase.consequent[0])) {
+    stmts = switchCase.consequent[0].body;
+  } else {
+    stmts = switchCase.consequent;
+  }
+  return stmts.filter(s => !t.isBreakStatement(s) && !t.isEmptyStatement(s));
+}
+
+// Append a generated switch case for every entry in compiler.MICRO_OPS.
+// applyInteralVariablesToRuntime must run before this so that the source
+// case bodies are already using this._internals[index] instead of local vars.
+// Must be called BEFORE applyShuffleOpcodes so the new cases get shuffled.
+export function applyMicroOpcodes(ast, compiler) {
+  if (!compiler.MICRO_OPS || Object.keys(compiler.MICRO_OPS).length === 0) {
+    return;
+  }
+  let switchStatement = null;
+  traverse(ast, {
+    SwitchStatement(path) {
+      if (path.node.leadingComments?.some(c => c.value.includes("@SWITCH"))) {
+        switchStatement = path.node;
+        path.stop();
+      }
+    }
+  });
+  ok(switchStatement, "Could not find @SWITCH statement for micro opcodes");
+
+  // Build  opName → SwitchCase  from existing cases.
+  const nameToCaseMap = new Map();
+  for (const sc of switchStatement.cases) {
+    const test = sc.test;
+    if (test && t.isMemberExpression(test) && t.isIdentifier(test.object, {
+      name: "OP"
+    }) && t.isIdentifier(test.property)) {
+      nameToCaseMap.set(test.property.name, sc);
+    }
+  }
+  for (const [microOpStr, info] of Object.entries(compiler.MICRO_OPS)) {
+    const microOpCode = Number(microOpStr);
+    const {
+      originalOp,
+      stmtIndex
+    } = info;
+    const originalName = compiler.OP_NAME[originalOp];
+    if (!originalName) continue;
+    const originalCase = nameToCaseMap.get(originalName);
+    if (!originalCase) continue;
+
+    // Extract and clone all non-break statements from the original case body.
+    const allStmts = extractCaseBody(originalCase);
+    if (stmtIndex >= allStmts.length) continue;
+    const rawStmt = t.cloneNode(allStmts[stmtIndex], true);
+    const newCase = t.switchCase(t.numericLiteral(microOpCode), [t.blockStatement([rawStmt, t.breakStatement()])]);
+
+    // Apply internal-variable substitution — this may replace rawStmt in the
+    // block body (var decl → assignment), so add the comment afterwards on
+    // whatever the first statement of the block actually is.
+    applyInternalVariablesToSwitchCase(newCase, compiler, microOpCode);
+    const blockBody = newCase.consequent[0].body;
+    const firstStmt = blockBody[0];
+    if (firstStmt) {
+      const microName = compiler.OP_NAME[microOpCode] ?? `MICRO_${microOpCode}`;
+      t.addComment(firstStmt, "leading", ` ${microName}`, true);
+    }
+    switchStatement.cases.push(newCase);
+  }
+}

package/dist/transforms/runtime/specializedOpcodes.js

@@ -1,6 +1,7 @@
 import * as t from "@babel/types";
 import traverseImport from "@babel/traverse";
 import { ok } from "assert";
+import { getOpcodeToCaseMap } from "./macroOpcodes.js";
 const traverse = traverseImport.default || traverseImport;
 
 // Extract the real statement list from a SwitchCase consequent (identical to the
@@ -23,6 +24,11 @@ function inlineFixedOperands(bodyStmts, resolvedValues) {
   // Wrap the statements in a temporary BlockStatement so traverse has a root.
   // The replacement mutates the original statement objects in place.
   var replaced = 0;
+  function consumeOperand() {
+    const resolvedValue = resolvedValues[replaced++];
+    ok(typeof resolvedValue === "number", `Expected a numeric operand value, got ${resolvedValue}`);
+    return t.numericLiteral(resolvedValue);
+  }
   traverse(t.blockStatement(bodyStmts), {
     noScope: true,
     CallExpression(path) {
@@ -33,10 +39,10 @@ function inlineFixedOperands(bodyStmts, resolvedValues) {
         }) && path.node.arguments.length === 0;
       };
       if (isMethodCall("_operand")) {
-        path.replaceWith(t.numericLiteral(resolvedValues[replaced++]));
+        path.replaceWith(consumeOperand());
       }
       if (isMethodCall("_constant")) {
-        path.node.arguments = [t.numericLiteral(resolvedValues[replaced++]), t.numericLiteral(resolvedValues[replaced++])];
+        path.node.arguments = [consumeOperand(), consumeOperand()];
       }
     }
   });
@@ -48,7 +54,7 @@ function inlineFixedOperands(bodyStmts, resolvedValues) {
 // replaced by the constant integer that was captured at compile time.
 // Must be called AFTER applyMacroOpcodes (so the original cases exist) but
 // BEFORE applyShuffleOpcodes so the new specialized cases also get shuffled.
-export function applySpecializedOpcodes(ast, bytecode, compiler) {
+export function applySpecializedOpcodes(ast, compiler) {
   let switchStatement = null;
   traverse(ast, {
     SwitchStatement(path) {
@@ -61,15 +67,7 @@ export function applySpecializedOpcodes(ast, bytecode, compiler) {
   ok(switchStatement, "Could not find @SWITCH statement for specialized opcodes");
 
   // Build a map  opName → SwitchCase  from the existing OP.xxx case tests.
-  const nameToCaseMap = new Map();
-  for (const sc of switchStatement.cases) {
-    const test = sc.test;
-    if (test && t.isMemberExpression(test) && t.isIdentifier(test.object, {
-      name: "OP"
-    }) && t.isIdentifier(test.property)) {
-      nameToCaseMap.set(test.property.name, sc);
-    }
-  }
+  const opcodeToCaseMap = getOpcodeToCaseMap(switchStatement, compiler);
   if (!compiler.SPECIALIZED_OPS) return;
   for (const [specialOpStr, info] of Object.entries(compiler.SPECIALIZED_OPS)) {
     const specialOpCode = Number(specialOpStr);
@@ -77,20 +75,24 @@ export function applySpecializedOpcodes(ast, bytecode, compiler) {
       originalOp,
       operands
     } = info;
-    const newName = compiler.OP_NAME[specialOpCode];
+    let newName = compiler.OP_NAME[specialOpCode];
     const originalName = compiler.OP_NAME[originalOp];
-    if (!originalName) continue;
-    const originalCase = nameToCaseMap.get(originalName);
-    if (!originalCase) continue;
+    const originalCase = opcodeToCaseMap.get(originalOp);
+    ok(originalCase, `Could not find original case for opcode ${originalName} (${originalOp})`);
 
     // Clone the original handler body
     const bodyStmts = extractCaseBody(originalCase).map(s => t.cloneNode(s, true));
-    const placedOperands = info.resolvedOperands;
+    const placedOperands = info.operands;
     ok(placedOperands, `Could not find operand for original opcode ${newName}`);
     const resolvedValues = placedOperands.map(placedOperand => {
       return placedOperand?.resolvedValue ?? placedOperand;
     });
-    ok(!resolvedValues.find(v => typeof v !== "number"), "Expected a numeric operand value");
+    if (resolvedValues.find(v => typeof v !== "number")) {
+      console.error(info);
+      throw new Error("Expected all resolved operand values to be numbers");
+    }
+    newName = `${originalName}_${resolvedValues.join("_")}`;
+    compiler.OP_NAME[specialOpCode] = newName;
 
     // Replace this._operand() with the baked-in constant
     inlineFixedOperands(bodyStmts, resolvedValues);

package/dist/utils/op-utils.js

@@ -2,18 +2,25 @@ import { getRandomInt } from "./random-utils.js";
 export const U16_MAX = 0xffff; // bytecode operands are u16
 
 /** Returns the next free opcode slot, or -1 when the space is exhausted. */
-export function nextFreeSlot(usedOpcodes) {
+export function nextFreeSlot(compiler) {
+  // ── Collect used opcodes exactly as specified ─────────────────────────────
+  const usedOpcodes = new Set(Object.keys(compiler.OP_NAME).map(k => parseInt(k, 10)).filter(v => !isNaN(v)));
   if (usedOpcodes.size > U16_MAX) return -1;
-  let attempts = 0;
-  while (attempts++ < 512) {
-    const candidate = getRandomInt(0, U16_MAX);
-    if (!usedOpcodes.has(candidate)) {
-      usedOpcodes.add(candidate);
-      return candidate;
+
+  // Random opcode
+  if (compiler.options.randomizeOpcodes) {
+    let attempts = 0;
+    while (attempts++ < 512) {
+      const candidate = getRandomInt(0, U16_MAX);
+      if (!usedOpcodes.has(candidate)) {
+        usedOpcodes.add(candidate);
+        return candidate;
+      }
     }
   }
+
   // Fallback: linear scan from a random start
-  const start = getRandomInt(0, U16_MAX);
+  const start = Object.keys(compiler.OP_NAME).length;
   for (let i = 0; i <= U16_MAX; i++) {
     const v = start + i & U16_MAX;
     if (!usedOpcodes.has(v)) {

package/index.ts

@@ -11,14 +11,15 @@ async function main() {
     target: "browser", // or "node"
     randomizeOpcodes: true, // randomize the opcode numbers?
     shuffleOpcodes: true, // shuffle order of opcode handlers in the runtime?
-    encodeBytecode: true, // encode bytecode? when off, comments for instructions are added
+    encodeBytecode: true, // encode the bytecode array?
+    concealConstants: true, // conceal strings and integers in the constant pool?
     selfModifying: true, // do self-modifying bytecode for function bodies?
     macroOpcodes: true, // create combined opcodes for repeated instruction sequences?
+    microOpcodes: true, // break opcodes into sub-opcodes?
     specializedOpcodes: true, // create specialized opcodes for commonly used opcode+operand pairs?
     aliasedOpcodes: true, // create duplicate opcodes for commonly used opcodes?
     timingChecks: true, // add timing checks to detect debuggers?
     minify: true, // pass final output through Google Closure Compiler? (Renames VM class properties)
-    concealConstants: true,
   });
 
   writeFileSync("output.original.js", orginalOutput, "utf-8");

package/jest.config.js

@@ -6,6 +6,7 @@ const OPTIONS_MATRIX = [
   { displayName: "selfModifying", VM_OPTIONS: { selfModifying: true } },
   { displayName: "timingChecks", VM_OPTIONS: { timingChecks: true } },
   { displayName: "macroOpcodes", VM_OPTIONS: { macroOpcodes: true } },
+  { displayName: "microOpcodes", VM_OPTIONS: { microOpcodes: true } },
   {
     displayName: "specializedOpcodes",
     VM_OPTIONS: { specializedOpcodes: true },
@@ -27,6 +28,7 @@ const OPTIONS_MATRIX = [
       selfModifying: true,
       timingChecks: true,
       macroOpcodes: true,
+      microOpcodes: true,
       specializedOpcodes: true,
       aliasedOpcodes: true,
       concealConstants: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-confuser-vm",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "main": "dist/index.js",
   "scripts": {
     "build": "babel src --out-dir dist --extensions \".ts,.js\"",

package/src/build-runtime.ts

@@ -1,8 +1,10 @@
 import { generate } from "@babel/generator";
-import { parse, type ParseResult } from "@babel/parser";
+import { parse } from "@babel/parser";
 import type * as t from "@babel/types";
 import type { Options } from "./options.ts";
 import { applyMacroOpcodes } from "./transforms/runtime/macroOpcodes.ts";
+import { applyMicroOpcodes } from "./transforms/runtime/microOpcodes.ts";
+import { applyInteralVariablesToRuntime } from "./transforms/runtime/internalVariables.ts";
 import { applyShuffleOpcodes } from "./transforms/runtime/shuffleOpcodes.ts";
 import { applyMinify } from "./transforms/runtime/minify.ts";
 import { Compiler } from "./compiler.ts";
@@ -14,7 +16,8 @@ export async function obfuscateRuntime(
   runtime: string,
   bytecode: b.Bytecode,
   options: Options,
-  compiler?: Compiler,
+  compiler: Compiler,
+  generateBytecodeComment,
 ) {
   let ast: t.File;
   try {
@@ -25,7 +28,16 @@ export async function obfuscateRuntime(
 
   // Specialized opcode cases must be applied BEFORE shuffleOpcodes
   if (options.specializedOpcodes) {
-    applySpecializedOpcodes(ast, bytecode, compiler);
+    applySpecializedOpcodes(ast, compiler);
+  }
+
+  if (options.microOpcodes) {
+    applyInteralVariablesToRuntime(ast, compiler);
+  }
+
+  // Micro opcode cases must be applied BEFORE shuffleOpcodes
+  if (options.microOpcodes && Object.keys(compiler.MICRO_OPS).length > 0) {
+    applyMicroOpcodes(ast, compiler);
   }
 
   // Macro opcode cases must be applied BEFORE shuffleOpcodes
@@ -50,6 +62,9 @@ export async function obfuscateRuntime(
     throw new Error("VM-Runtime final generation failed", { cause: error });
   }
 
+  // Add comment here for more accurate opcode names
+  generated = generateBytecodeComment() + "\n" + generated;
+
   // Minify code?
   if (options.minify) {
     try {

package/src/compiler.ts

@@ -1,11 +1,11 @@
+import * as t from "@babel/types";
+import * as b from "./types.ts";
 import { parse } from "@babel/parser";
 import traverseImport from "@babel/traverse";
 import { generate } from "@babel/generator";
-
-import { readFileSync } from "fs";
 import { join } from "path";
+import { readFileSync } from "fs";
 import { stripTypeScriptTypes } from "module";
-import * as t from "@babel/types";
 import { ok } from "assert";
 import { obfuscateRuntime } from "./build-runtime.ts";
 import { DEFAULT_OPTIONS, type Options } from "./options.ts";
@@ -13,7 +13,7 @@ import { resolveLabels } from "./transforms/bytecode/resolveLabels.ts";
 import { resolveConstants } from "./transforms/bytecode/resolveContants.ts";
 import { selfModifying } from "./transforms/bytecode/selfModifying.ts";
 import { macroOpcodes } from "./transforms/bytecode/macroOpcodes.ts";
-import * as b from "./types.ts";
+import { microOpcodes } from "./transforms/bytecode/microOpcodes.ts";
 import { specializedOpcodes } from "./transforms/bytecode/specializedOpcodes.ts";
 import { aliasedOpcodes } from "./transforms/bytecode/aliasedOpcodes.ts";
 import { getRandomInt } from "./utils/random-utils.ts";
@@ -264,10 +264,21 @@ export class Compiler {
     {
       originalOp: number;
       operands: b.InstrOperand[];
-      resolvedOperands?: b.InstrOperand[];
     }
   >;
   ALIASED_OPS: Record<number, { originalOp: number; order: number[] }>;
+  MICRO_OPS: Record<
+    number,
+    { originalOp: number; stmtIndex: number; irOperandCount: number }
+  >;
+
+  /** 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. */
+  _internals: {
+    globally: Map<string, number>;
+    opcodes: Map<number, Map<string, number>>;
+  };
 
   OP_NAME: Record<number, string>;
   JUMP_OPS: Set<number>;
@@ -293,8 +304,10 @@ export class Compiler {
 
     this.serializer = new Serializer(this);
     this.MACRO_OPS = {};
+    this.MICRO_OPS = {};
     this.SPECIALIZED_OPS = {};
     this.ALIASED_OPS = {};
+    this._internals = { globally: new Map(), opcodes: new Map() };
 
     this.OP = { ...OP_ORIGINAL };
 
@@ -455,14 +468,6 @@ export class Compiler {
   }
 
   compileAST(ast: t.File) {
-    traverse(ast, {
-      FunctionDeclaration: (path) => {
-        if (path.parent.type !== "Program") return;
-        this._compileFunctionDecl(path.node);
-        path.skip();
-      },
-    });
-
     this._compileMain(ast.program.body);
     return this.bytecode;
   }
@@ -1291,14 +1296,10 @@ export class Compiler {
 
       case "TryStatement": {
         if (node.finalizer) {
-          throw new Error(
-            "try..finally is not supported. Use a helper function instead",
-          );
+          throw new Error("try..finally is not supported");
         }
         if (!node.handler) {
-          throw new Error(
-            "try without catch is not supported (requires finally).",
-          );
+          throw new Error("try without catch is not supported");
         }
 
         const catchLabel = this._makeLabel("catch");
@@ -1538,6 +1539,45 @@ export class Compiler {
         return reg_result;
       }
 
+      case "TemplateLiteral": {
+        const n = node as t.TemplateLiteral;
+        // Fold: quasi[0] + expr[0] + quasi[1] + ... + quasi[last]
+        let acc = ctx.allocReg();
+        this.emit(
+          bc,
+          [
+            this.OP.LOAD_CONST,
+            acc,
+            b.constantOperand(n.quasis[0].value.cooked ?? ""),
+          ],
+          node,
+        );
+        for (let i = 0; i < n.expressions.length; i++) {
+          const exprReg = this._compileExpr(
+            n.expressions[i] as t.Expression,
+            scope,
+            bc,
+          );
+          const t1 = ctx.allocReg();
+          this.emit(bc, [this.OP.ADD, t1, acc, exprReg], node);
+          acc = t1;
+          const quasiReg = ctx.allocReg();
+          this.emit(
+            bc,
+            [
+              this.OP.LOAD_CONST,
+              quasiReg,
+              b.constantOperand(n.quasis[i + 1].value.cooked ?? ""),
+            ],
+            node,
+          );
+          const t2 = ctx.allocReg();
+          this.emit(bc, [this.OP.ADD, t2, acc, quasiReg], node);
+          acc = t2;
+        }
+        return acc;
+      }
+
       case "BinaryExpression": {
         const n = node as t.BinaryExpression;
         const lhsReg = this._compileExpr(n.left as t.Expression, scope, bc);
@@ -1579,15 +1619,68 @@ export class Compiler {
 
       case "UpdateExpression": {
         const n = node as t.UpdateExpression;
+        const bumpOp = n.operator === "++" ? this.OP.ADD : this.OP.SUB;
+
+        // Shared: compute curReg +/- 1 into newReg, return [postfixResult, newReg]
+        const applyBump = (curReg: number): [number, number] => {
+          const postfixReg = n.prefix
+            ? -1
+            : (() => {
+                const r = ctx.allocReg();
+                this.emit(bc, [this.OP.MOVE, r, curReg], node as t.Node);
+                return r;
+              })();
+          const oneReg = ctx.allocReg();
+          this.emit(
+            bc,
+            [this.OP.LOAD_CONST, oneReg, b.constantOperand(1)],
+            node as t.Node,
+          );
+          const newReg = ctx.allocReg();
+          this.emit(bc, [bumpOp, newReg, curReg, oneReg], node as t.Node);
+          return [postfixReg, newReg];
+        };
+
+        if (n.argument.type === "MemberExpression") {
+          const mem = n.argument as t.MemberExpression;
+          const objReg = this._compileExpr(mem.object, scope, bc);
+          let keyReg: number;
+          if (mem.computed) {
+            keyReg = this._compileExpr(mem.property as t.Expression, scope, bc);
+          } else {
+            keyReg = ctx.allocReg();
+            this.emit(
+              bc,
+              [
+                this.OP.LOAD_CONST,
+                keyReg,
+                b.constantOperand((mem.property as t.Identifier).name),
+              ],
+              node as t.Node,
+            );
+          }
+          const curReg = ctx.allocReg();
+          this.emit(
+            bc,
+            [this.OP.GET_PROP, curReg, objReg, keyReg],
+            node as t.Node,
+          );
+          const [postfixReg, newReg] = applyBump(curReg);
+          this.emit(
+            bc,
+            [this.OP.SET_PROP, objReg, keyReg, newReg],
+            node as t.Node,
+          );
+          return n.prefix ? newReg : postfixReg;
+        }
+
         ok(
           n.argument.type === "Identifier",
-          "UpdateExpression requires identifier",
+          "UpdateExpression requires identifier or member expression",
         );
         const name = (n.argument as t.Identifier).name;
         const res = this._resolve(name, this._currentCtx);
-        const bumpOp = n.operator === "++" ? this.OP.ADD : this.OP.SUB;
 
-        // Load current value into a register (locals are already in place)
         let curReg: number;
         if (res.kind === "local") {
           curReg = res.slot;
@@ -1607,27 +1700,8 @@ export class Compiler {
           );
         }
 
-        // For postfix we need to preserve the *old* value as the result
-        let resultReg: number;
-        if (!n.prefix) {
-          resultReg = ctx.allocReg();
-          this.emit(bc, [this.OP.MOVE, resultReg, curReg], node as t.Node);
-        } else {
-          resultReg = -1; // placeholder – will become newReg below
-        }
-
-        const oneReg = ctx.allocReg();
-        this.emit(
-          bc,
-          [this.OP.LOAD_CONST, oneReg, b.constantOperand(1)],
-          node as t.Node,
-        );
-
-        // Compute new value (always into a fresh register)
-        const newReg = ctx.allocReg();
-        this.emit(bc, [bumpOp, newReg, curReg, oneReg], node as t.Node);
+        const [postfixReg, newReg] = applyBump(curReg);
 
-        // Write the new value back (local = MOVE, others = STORE_xxx)
         if (res.kind === "local") {
           this.emit(bc, [this.OP.MOVE, res.slot, newReg], node as t.Node);
         } else if (res.kind === "upvalue") {
@@ -1644,12 +1718,7 @@ export class Compiler {
           );
         }
 
-        // Prefix returns the *new* value (we already have it in newReg – no reload needed)
-        if (n.prefix) {
-          resultReg = newReg;
-        }
-
-        return resultReg;
+        return n.prefix ? newReg : postfixReg;
       }
 
       case "AssignmentExpression": {
@@ -2138,13 +2207,12 @@ class Serializer {
     return out;
   }
 
-  _serializeInstr(
-    instr: b.Instruction,
-    constants: any[],
-  ): { text: string; values: number[] } {
+  _serializeInstr(instr: b.Instruction): { text: string; values: number[] } {
     const op = instr[0] as number;
     const operands = instr.slice(1) as number[];
 
+    const constants = this.compiler.constants;
+
     const resolvedOperands = operands
       .filter((operand) => (operand as any)?.placeholder !== true)
       .map((o) => (o as any)?.resolvedValue ?? o);
@@ -2155,7 +2223,11 @@ class Serializer {
     }
     ok(op >= 0 && op <= 0xffff, `Opcode overflow (max 0xFFFF u16): ${op}`);
 
-    const name = this.OP_NAME[op] || `OP_${op}`;
+    let name = this.OP_NAME[op];
+    if (!name || name.includes("{")) {
+      name = `OP_${op}`;
+    }
+
     let comment = name;
 
     function formatLoc(loc: t.Node["loc"]["start"]) {
@@ -2205,10 +2277,10 @@ class Serializer {
           comment += `  reg[${dst}] PC=${resolvedOperands[1]} (params=${resolvedOperands[2]} regs=${resolvedOperands[3]} upvalues=${resolvedOperands[4]})`;
           break;
         case this.OP.CALL:
-          comment += `  reg[${dst}] = call(reg[${resolvedOperands[1]}], ${resolvedOperands[2]} args)`;
+          comment += `  reg[${dst}] = reg[${resolvedOperands[1]}](${resolvedOperands[2]} args)`;
           break;
         case this.OP.CALL_METHOD:
-          comment += `  reg[${dst}] = method(recv=reg[${resolvedOperands[1]}], fn=reg[${resolvedOperands[2]}], ${resolvedOperands[3]} args)`;
+          comment += `  reg[${dst}] = reg[${resolvedOperands[2]}](recv=reg[${resolvedOperands[1]}], ${resolvedOperands[3]} args)`;
           break;
         case this.OP.NEW:
           comment += `  reg[${dst}] = new reg[${resolvedOperands[1]}](${resolvedOperands[2]} args)`;
@@ -2222,6 +2294,13 @@ class Serializer {
         case this.OP.BUILD_OBJECT:
           comment += `  reg[${dst}] = {${resolvedOperands[1]} pairs}`;
           break;
+        case this.OP.GET_PROP:
+          comment += `  reg[${dst}] = reg[${resolvedOperands[1]}][reg[${resolvedOperands[2]}]]`;
+          break;
+        case this.OP.SET_PROP:
+          comment += `  reg[${resolvedOperands[0]}][reg[${resolvedOperands[1]}]] = reg[${resolvedOperands[2]}]`;
+          break;
+
         default:
           comment +=
             resolvedOperands.length === 1
@@ -2266,7 +2345,6 @@ class Serializer {
         const originalName = compiler.OP_NAME[specializedOpInfo.originalOp];
         compiler.OP_NAME[instr[0]] =
           `${originalName}_${resolvedValues.join("_")}`;
-        specializedOpInfo.resolvedOperands = operands;
       }
 
       serialized.push(instr);
@@ -2288,18 +2366,9 @@ class Serializer {
     const mainRegCount = compiler.mainRegCount;
     let sections = [];
 
-    var textForm = [];
     var initBody = [];
-
     var bytecodeResult = this._serializeBytecode(bytecode, compiler);
 
-    for (const instr of bytecodeResult.bytecode) {
-      const serialized = this._serializeInstr(instr, constants);
-      textForm.push(serialized.text);
-    }
-
-    initBody.push(textForm.map((line) => `// ${line}`).join("\n"));
-
     const flat = bytecodeResult.bytecode.flatMap((instr) => {
       let filtered = instr.filter((x) => (x as any)?.placeholder !== true);
       let resolved = filtered.map((x) => (x as any)?.resolvedValue ?? x);
@@ -2348,6 +2417,10 @@ export async function compileAndSerialize(
     passes.push(specializedOpcodes);
   }
 
+  if (options.microOpcodes) {
+    passes.push(microOpcodes);
+  }
+
   if (options.macroOpcodes) {
     passes.push(macroOpcodes);
   }
@@ -2384,11 +2457,25 @@ export async function compileAndSerialize(
     compiler,
   );
 
+  // This part was purposefully pulled out Serializer as OP_NAME's get resolved during obfuscateRuntime
+  // 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);
+    }
+
+    return lines.join("\n");
+  };
+
   const code = await obfuscateRuntime(
     runtimeSource,
     bytecode,
     options,
     compiler,
+    generateBytecodeComment,
   );
 
   return { code };

package/src/options.ts

@@ -6,6 +6,7 @@ export interface Options {
   encodeBytecode?: boolean; // encode bytecode? when off, comments for instructions are added
   selfModifying?: boolean; // do self-modifying bytecode for function bodies?
   macroOpcodes?: boolean; // create combined opcodes for repeated instruction sequences?
+  microOpcodes?: boolean; // break opcodes into sub-opcodes?
   specializedOpcodes?: boolean; // create specialized opcodes for commonly used opcode+operand pairs?
   aliasedOpcodes?: boolean; // create duplicate opcodes for commonly used opcodes?
   timingChecks?: boolean; // add timing checks to detect debuggers?