js-confuser-vm 0.0.6 → 0.0.7

package/dist/transforms/bytecode/microOpcodes.js

@@ -0,0 +1,236 @@
+import { parse } from "@babel/parser";
+import traverseImport from "@babel/traverse";
+import * as t from "@babel/types";
+import { ok } from "assert";
+import { VM_RUNTIME, SOURCE_NODE_SYM } from "../../compiler.js";
+import { nextFreeSlot } from "../../utils/op-utils.js";
+import { nSizedOps } from "./specializedOpcodes.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));
+}
+
+// Count how many IR-level operands a single statement consumes.
+// Returns null if the statement is ineligible (contains a loop, or has
+// _operand()/_constant() calls inside a conditional branch).
+function countStatementOperands(stmt) {
+  let count = 0;
+  let ineligible = false;
+  const file = t.file(t.program([t.cloneNode(stmt, true)]));
+  traverse(file, {
+    enter(path) {
+      if (ineligible) {
+        path.stop();
+        return;
+      }
+      const nodeType = path.node.type;
+
+      // Don't traverse into nested functions
+      if (nodeType === "FunctionDeclaration" || nodeType === "FunctionExpression" || nodeType === "ArrowFunctionExpression") {
+        path.skip();
+        return;
+      }
+
+      // Count _operand() and _constant() calls
+      if (nodeType === "CallExpression") {
+        const call = path.node;
+        const callee = call.callee;
+        if (t.isMemberExpression(callee) && t.isThisExpression(callee.object) && t.isIdentifier(callee.property)) {
+          const name = callee.property.name;
+          const operandsConsumed = name === "_operand" ? 1 : name === "_constant" ? 2 : null;
+          if (operandsConsumed) {
+            // You are not allowed to use _operand() in loops or branches
+            const ancestors = path.getAncestry();
+            if (ancestors.find(t => t.isLoop() || t.isIfStatement() || t.isSwitchStatement() || t.isConditionalExpression() || t.isLogicalExpression())) {
+              ineligible = true;
+              path.stop();
+              return;
+            }
+            count += operandsConsumed;
+          }
+        }
+      }
+    }
+  });
+  return ineligible ? null : count;
+}
+
+// Analyse the VM runtime's @SWITCH statement to build a per-opcode map of
+// { stmtIndex → irOperandCount } for every case that can be split.
+// Returns a map: opValue → array of per-statement operand counts (null if ineligible).
+function analyzeRuntimeCases(compiler) {
+  // Parse the runtime source
+  const ast = parse(VM_RUNTIME, {
+    sourceType: "unambiguous"
+  });
+
+  // Build reverse name→opValue map from original OPs only
+  const nameToOp = new Map();
+  for (const [name, val] of Object.entries(compiler.OP)) {
+    if (val !== undefined) nameToOp.set(name, val);
+  }
+  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");
+  const result = 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)) {
+      continue;
+    }
+    const opName = test.property.name;
+    const opVal = nameToOp.get(opName);
+    if (opVal === undefined) continue;
+    const stmts = extractCaseBody(sc);
+    if (stmts.length < 2) continue; // need at least 2 statements to split
+
+    const counts = [];
+    let allEligible = true;
+
+    // Banned patterns:
+    // Return statements (Control flow isn't remembered)
+    traverse(t.file(t.program(stmts)), {
+      ReturnStatement(path) {
+        path.stop();
+        allEligible = false;
+      }
+    });
+    for (const stmt of stmts) {
+      const c = countStatementOperands(stmt);
+      if (c === null) {
+        allEligible = false;
+        break;
+      }
+      if (t.isDebuggerStatement(stmt) || t.isThrowStatement(stmt)) {
+        allEligible = false;
+        break;
+      }
+      counts.push(c);
+    }
+    if (!allEligible) continue;
+
+    // Verify that the total operand count matches the instruction size expectation
+    // (just store for now; bytecode pass validates operands match)
+    result.set(opVal, counts);
+  }
+  return result;
+}
+
+// Main bytecode transform: split frequently-used opcodes into per-statement
+// micro-opcodes so each sub-instruction is as small as possible.
+export function microOpcodes(bc, compiler) {
+  // ── Step 1: analyse runtime to discover splittable opcodes ──────────────────
+  const opAnalysis = analyzeRuntimeCases(compiler);
+  if (opAnalysis.size === 0) return {
+    bytecode: bc
+  };
+
+  // ── Step 2: count opcode frequency in bytecode ────────────────────────────
+  const disallowedOps = new Set(nSizedOps.map(name => compiler.OP[name]));
+  disallowedOps.add(compiler.OP.RETURN);
+  const freqMap = new Map();
+  for (const instr of bc) {
+    const op = instr[0];
+    if (op === null || !opAnalysis.has(op) || disallowedOps.has(op)) continue;
+    freqMap.set(op, (freqMap.get(op) ?? 0) + 1);
+  }
+
+  // ── Step 3: sort by frequency, keep opcodes that actually appear ─────────
+  const candidates = Array.from(freqMap.entries()).filter(([, count]) => count >= 1).sort(([, a], [, b]) => b - a).map(([op]) => op);
+  if (candidates.length === 0) return {
+    bytecode: bc
+  };
+
+  // ── Step 4: assign free opcode slots for each sub-statement ─────────────
+  // Build: originalOp → [{ microOp, irOperandCount }, ...]
+  const originalToSubOps = new Map();
+  for (const origOp of candidates) {
+    const stmtCounts = opAnalysis.get(origOp);
+
+    // Pre-allocate all needed slots; if any slot is unavailable, skip this op.
+    const slots = [];
+    for (let si = 0; si < stmtCounts.length; si++) {
+      const slot = nextFreeSlot(compiler);
+      if (slot === -1) break;
+      compiler.OP_NAME[slot] = `MICRO_${origOp}_${si}`;
+      slots.push(slot);
+    }
+    if (slots.length !== stmtCounts.length) continue;
+    const subOps = [];
+    const origName = compiler.OP_NAME[origOp] ?? `OP_${origOp}`;
+    for (let si = 0; si < stmtCounts.length; si++) {
+      const microOp = slots[si];
+      const irOperandCount = stmtCounts[si];
+      subOps.push({
+        microOp,
+        irOperandCount
+      });
+      compiler.OP_NAME[microOp] = `MICRO_${origName}_${si}`;
+      compiler.MICRO_OPS[microOp] = {
+        originalOp: origOp,
+        stmtIndex: si,
+        irOperandCount
+      };
+    }
+    originalToSubOps.set(origOp, subOps);
+  }
+  if (originalToSubOps.size === 0) return {
+    bytecode: bc
+  };
+
+  // ── Step 5: replace each matched instruction with sub-instructions ────────
+  const result = [];
+  for (const instr of bc) {
+    const op = instr[0];
+    if (op === null || !originalToSubOps.has(op)) {
+      result.push(instr);
+      continue;
+    }
+    const subOps = originalToSubOps.get(op);
+    const operands = instr.slice(1); // all operands of the original instruction
+
+    // Verify total operand count matches sum of sub-op IR operand counts
+    const expectedTotal = subOps.reduce((s, {
+      irOperandCount
+    }) => s + irOperandCount, 0);
+    if (operands.length !== expectedTotal) {
+      throw new Error(`Operand count mismatch for opcode ${compiler.OP_NAME[op]}`);
+    }
+
+    // Split operands among sub-instructions
+    let offset = 0;
+    for (const {
+      microOp,
+      irOperandCount
+    } of subOps) {
+      const subOperands = operands.slice(offset, offset + irOperandCount);
+      offset += irOperandCount;
+      const newInstr = [microOp, ...subOperands];
+      // Carry source-node info on the first sub-instruction
+      if (offset === irOperandCount) {
+        newInstr[SOURCE_NODE_SYM] = instr[SOURCE_NODE_SYM];
+      }
+      result.push(newInstr);
+    }
+  }
+  return {
+    bytecode: result
+  };
+}

package/dist/transforms/bytecode/resolveContants.js

@@ -18,8 +18,7 @@ function concealString(s, key) {
   return Buffer.from(bytes).toString("base64");
 }
 
-// Resolve all {type:"constant", value} operands to a PAIR of integer operands:
-//   [constPoolIndex, concealKey]
+// Resolve all {type:"constant", value} (index) and {type:"constant", value, key: true} (key) operands
 //
 // constPoolIndex — index into the constants array (as before).
 // concealKey     — XOR key used to conceal this constant.
@@ -36,7 +35,6 @@ export function resolveConstants(bc, compiler) {
   const keyMap = new Map(); // pool index → conceal key
 
   function intern(operand) {
-    const operandAsObject = typeof operand === "object" && operand ? operand : {};
     const value = operand.value;
     let idx = constantsMap.get(value);
     let key = 0;
@@ -62,12 +60,10 @@ export function resolveConstants(bc, compiler) {
       key = keyMap.get(idx);
     }
     const idxOperand = {
-      ...operandAsObject,
       type: "number",
       resolvedValue: idx
     };
     const keyOperand = {
-      ...operandAsObject,
       type: "number",
       resolvedValue: key
     };
@@ -81,17 +77,15 @@ export function resolveConstants(bc, compiler) {
     const hasConstant = operands.some(o => o !== undefined && o !== null && typeof o === "object" && o.type === "constant");
     if (hasConstant) {
       // 1-to-2 expansion: each {type:"constant"} becomes [constIdx, concealKey].
-      const newOperands = [];
-      for (const operand of operands) {
+      const newOperands = operands.map(operand => {
         if (operand?.type === "constant") {
           const [idxOperand, key] = intern(operand);
           const newOperand = operand?.key ? key : idxOperand;
-          newOperands.push(newOperand);
-          // newOperands.push(key); // plain number — serialized as a regular u16 slot
+          return Object.assign(operand, newOperand);
         } else {
-          newOperands.push(operand);
+          return operand;
         }
-      }
+      });
       const newInstr = [op, ...newOperands];
       newInstr[SOURCE_NODE_SYM] = instr[SOURCE_NODE_SYM];
       resolved.push(newInstr);

package/dist/transforms/bytecode/resolveLabels.js

@@ -54,13 +54,15 @@ export function resolveLabels(bc, compiler) {
       if (operand !== undefined && operand !== null && typeof operand === "object" && operand.type === "label") {
         const pc = labelToPc.get(operand.label);
         if (pc === undefined) throw new Error(`Undefined label: ${operand.label}`);
-        var operandAsObject = typeof operand === "object" && operand ? operand : {};
         const newOperand = {
-          ...operandAsObject,
-          // Preverse original operand properties
           type: "number",
           resolvedValue: pc + (operand.offset ?? 0)
         };
+
+        // Mutate original object so that references are also updated
+        if (typeof operand === "object" && operand !== null) {
+          return Object.assign(operand, newOperand);
+        }
         return newOperand;
       }
       return operand;

package/dist/transforms/bytecode/specializedOpcodes.js

@@ -1,5 +1,6 @@
 import { SOURCE_NODE_SYM } from "../../compiler.js";
-import { getInstructionSize, nextFreeSlot, U16_MAX } from "../../utils/op-utils.js";
+import { getInstructionSize, nextFreeSlot } from "../../utils/op-utils.js";
+export const nSizedOps = ["MAKE_CLOSURE", "BUILD_ARRAY", "BUILD_OBJECT", "CALL", "CALL_METHOD", "NEW"];
 
 // Creates specialized opcodes for the most frequent (OPCODE + single_integer_operand) pairs.
 // Example: [OP.LOAD_CONST, 1] becomes [SPECIALIZED_LOAD_CONST_1].
@@ -7,13 +8,7 @@ import { getInstructionSize, nextFreeSlot, U16_MAX } from "../../utils/op-utils.
 // MAKE_CLOSURE and other N-sized instructions cannot be specialized
 // Runs after selfModifying but before resolveLabels (operands stay plain numbers).
 export function specializedOpcodes(bc, compiler) {
-  const disallowedOps = new Set([compiler.OP.MAKE_CLOSURE, compiler.OP.BUILD_ARRAY, compiler.OP.BUILD_OBJECT, compiler.OP.CALL, compiler.OP.CALL_METHOD, compiler.OP.NEW]);
-
-  // ── 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 {
-    bytecode: bc
-  };
+  const disallowedOps = new Set(nSizedOps.map(name => compiler.OP[name]));
 
   // ── Step 1: count frequency of eligible (op, operand) pairs ───────────────
   const freqMap = new Map();
@@ -24,7 +19,21 @@ export function specializedOpcodes(bc, compiler) {
     // Only supports between 1-6 operands
     const operandCount = getInstructionSize(instr) - 1;
     if (operandCount < 1 || operandCount > 6) continue;
-    const operands = instr.slice(1);
+
+    // Convert numbers into operand objects so they can be modified elsewhere and preserved
+    const oldOperands = instr.slice(1);
+    const operands = oldOperands.map(operand => {
+      if (typeof operand === "number") {
+        return {
+          type: "number",
+          value: operand,
+          resolvedValue: operand
+        };
+      }
+      return operand;
+    });
+    instr.length = 1;
+    instr.push(...operands);
     const operandsKey = JSON.stringify(operands);
     const key = `${op},${operandsKey}`;
     const entry = freqMap.get(key);
@@ -50,7 +59,7 @@ export function specializedOpcodes(bc, compiler) {
   const sigToSpecial = new Map();
   const specializedOps = {};
   for (let i = 0; i < candidates.length; i++) {
-    const specialOp = nextFreeSlot(usedOpcodes);
+    const specialOp = nextFreeSlot(compiler);
     if (specialOp === -1) break;
     const {
       op: originalOp,
@@ -92,14 +101,10 @@ export function specializedOpcodes(bc, compiler) {
     const newOperands = operands.map(operand => {
       const operandAsObject = typeof operand === "object" && operand ? operand : {
         type: "number",
-        value: operand,
         resolvedValue: operand
       };
-      const newOperand = {
-        ...operandAsObject,
-        placeholder: true
-      };
-      return newOperand;
+      operandAsObject.placeholder = true;
+      return operandAsObject;
     });
     const newInstr = [specialOpCode, ...newOperands];
 

package/dist/transforms/runtime/internalVariables.js

@@ -0,0 +1,202 @@
+// Goes through the switch case for defined identifiers on the statement level
+// Example:
+// case OP.LOAD_CONST: {
+//   var dst = this._operand();
+//   frame.regs[dst] = this._constant();
+//   break;
+// }
+// You find "dst" is defined in this scope.
+// You first check the compiler to see if it's already assigned an index in compiler._internals mapping varName=>index
+// If not found, use compiler._internals.globally.size as the new index (when options.randomizeOpcodes is off, when on, choose random between 0 and 65535), and add varName=>index to compiler._internals
+// Then replace the VariableDeclaration to an AssignmentExpression setting left this._internals[index] = init;
+// Then replace all identifiers of "dst" to this._internals[index] as well (Updates references)
+// Final output:
+// case OP.LOAD_CONST: {
+//   this._internals[index] = this._operand();
+//   frame.regs[this._internals[index]] = this._constant();
+//   break;
+// }
+
+import * as t from "@babel/types";
+import traverseImport from "@babel/traverse";
+import { ok } from "assert";
+import { getRandomInt } from "../../utils/random-utils.js";
+import { U16_MAX } from "../../utils/op-utils.js";
+const traverse = traverseImport.default || traverseImport;
+export function makeInternalsAccess(index) {
+  return t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier("_internals")), t.numericLiteral(index), true // computed
+  );
+}
+function collectUsedIndices(compiler) {
+  const used = new Set();
+  for (const v of compiler._internals.globally.values()) used.add(v);
+  for (const opMap of compiler._internals.opcodes.values()) {
+    for (const v of opMap.values()) used.add(v);
+  }
+  return used;
+}
+
+// Assign or look up the _internals slot index for a variable name within a
+// specific opcode handler.
+//
+// _internals.opcodes[currentOpcode] is the source of truth for this opcode.
+// _internals.globally holds the shared pool written on first sight.
+//
+// randomizeOpcodes OFF → always reuse / create in globally, mirror to opcodes.
+// randomizeOpcodes ON  → first time a name is seen: create global slot.
+//                        subsequent opcodes: 50% reuse global, 50% create an
+//                        opcode-specific random slot (NOT written to globally).
+function assignInternalsIndex(name, compiler, currentOpcode) {
+  // Ensure per-opcode map exists
+  let opcodeMap = compiler._internals.opcodes.get(currentOpcode);
+  if (!opcodeMap) {
+    opcodeMap = new Map();
+    compiler._internals.opcodes.set(currentOpcode, opcodeMap);
+  }
+
+  // Already registered for this opcode — return immediately
+  const existing = opcodeMap.get(name);
+  if (existing !== undefined) return existing;
+  const globalIndex = compiler._internals.globally.get(name);
+  let index;
+  if (!compiler.options.randomizeOpcodes) {
+    // Non-random: always share the global sequential slot
+    if (globalIndex === undefined) {
+      index = compiler._internals.globally.size;
+      compiler._internals.globally.set(name, index);
+    } else {
+      index = globalIndex;
+    }
+  } else if (globalIndex === undefined) {
+    // First opcode to declare this variable — establish the global slot
+    const used = collectUsedIndices(compiler);
+    let candidate;
+    do {
+      candidate = getRandomInt(0, U16_MAX);
+    } while (used.has(candidate));
+    index = candidate;
+    compiler._internals.globally.set(name, index);
+  } else {
+    // Already in global: 50% chance to reuse, 50% opcode-specific new slot
+    if (Math.random() < 0.5) {
+      index = globalIndex;
+    } else {
+      const used = collectUsedIndices(compiler);
+      let candidate;
+      do {
+        candidate = getRandomInt(0, U16_MAX);
+      } while (used.has(candidate));
+      index = candidate;
+      // Intentionally NOT written to globally — this slot is opcode-specific
+    }
+  }
+  opcodeMap.set(name, index);
+  return index;
+}
+export function applyInternalVariablesToSwitchCase(node, compiler, currentOpcode) {
+  // Work with the actual body array (block body or flat consequent)
+  let bodyArr;
+  if (node.consequent.length === 1 && t.isBlockStatement(node.consequent[0])) {
+    bodyArr = node.consequent[0].body;
+  } else {
+    bodyArr = node.consequent;
+  }
+
+  // Single traversal: declarations and references handled in one pass.
+  //
+  // Declaration (Identifier is VariableDeclarator.id):
+  //   → register/look-up slot, replace entire VariableDeclaration with
+  //     AssignmentExpression (bare for ForStatement.init, else ExpressionStatement).
+  //
+  // Reference (any other Identifier):
+  //   → look up opcodes[currentOpcode] (source of truth) and replace if found.
+  //     This handles cross-statement refs produced by micro-opcode splitting.
+  const syntheticFile = t.file(t.program(bodyArr));
+  const illegalNames = new Set(); // Nested closure names are skipped
+
+  traverse(syntheticFile, {
+    Identifier(path) {
+      const name = path.node.name;
+      if (illegalNames.has(name)) return;
+
+      // Skip non-computed property names: obj.name
+      if (t.isMemberExpression(path.parent) && !path.parent.computed && path.parent.property === path.node) {
+        return;
+      }
+
+      // Skip non-computed object-property keys: { name: value }
+      if (t.isObjectProperty(path.parent) && !path.parent.computed && path.parent.key === path.node) {
+        return;
+      }
+
+      // Don't descend into nested function scopes
+      if (path.find(p => p.isFunctionDeclaration() || p.isFunctionExpression() || p.isArrowFunctionExpression())) {
+        return;
+      }
+
+      // ── Declaration binding ──────────────────────────────────────────────
+      if (t.isVariableDeclarator(path.parent) && path.parent.id === path.node) {
+        // Verify it's not referenced in nested closure (illegal)
+        const binding = path.scope.getBinding(name);
+        if (binding?.referencePaths.some(rp => rp.findParent(p => p.isFunctionDeclaration() || p.isFunctionExpression() || p.isArrowFunctionExpression()))) {
+          illegalNames.add(name);
+          return;
+        }
+        const index = assignInternalsIndex(name, compiler, currentOpcode);
+        const init = path.parent.init;
+        const assignment = t.assignmentExpression("=", makeInternalsAccess(index), init ?? t.identifier("undefined"));
+
+        // Two levels up: VariableDeclarator → VariableDeclaration
+        const varDeclPath = path.parentPath.parentPath;
+        if (t.isForStatement(varDeclPath.parent) && varDeclPath.parent.init === varDeclPath.node) {
+          // ForStatement.init accepts an Expression directly
+          varDeclPath.replaceWith(assignment);
+        } else {
+          varDeclPath.replaceWith(t.expressionStatement(assignment));
+        }
+        return;
+      }
+
+      // ── Reference ───────────────────────────────────────────────────────
+      // Source of truth for this opcode is its own per-opcode map
+      const opcodeMap = compiler._internals.opcodes.get(currentOpcode);
+      const index = opcodeMap?.get(name);
+      if (index !== undefined) {
+        path.replaceWith(makeInternalsAccess(index));
+        path.skip();
+      }
+    }
+  });
+}
+
+// This takes the AST and finds the runtime switch statement via the leading
+// comment "@SWITCH" then applies the above transformation to each switch case.
+export function applyInteralVariablesToRuntime(ast, compiler) {
+  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 internal variables");
+  for (const sc of switchStatement.cases) {
+    const test = sc.test;
+    let currentOpcode = null;
+    if (test && t.isMemberExpression(test) && t.isIdentifier(test.object, {
+      name: "OP"
+    }) && t.isIdentifier(test.property)) {
+      // case OP.LOAD_CONST: → resolve via compiler.OP
+      const opName = test.property.name;
+      const val = compiler.OP[opName];
+      if (val !== undefined) currentOpcode = val;
+    } else if (test && t.isNumericLiteral(test)) {
+      // Already a numeric literal (e.g. generated micro-opcode cases)
+      currentOpcode = test.value;
+    }
+    if (currentOpcode === null) continue;
+    applyInternalVariablesToSwitchCase(sc, compiler, currentOpcode);
+  }
+}

package/dist/transforms/runtime/macroOpcodes.js

@@ -17,6 +17,29 @@ function extractCaseBody(switchCase) {
   }
   return stmts.filter(s => !t.isBreakStatement(s) && !t.isEmptyStatement(s));
 }
+export function getOpcodeToCaseMap(switchStatement, compiler) {
+  // Build a map  opName → SwitchCase  from the existing OP.xxx case tests.
+  const opcodeToCaseMap = new Map();
+  for (const sc of switchStatement.cases) {
+    const test = sc.test;
+    if (!test) continue;
+    let opcode;
+    let opName;
+    if (t.isMemberExpression(test) && t.isIdentifier(test.object, {
+      name: "OP"
+    }) && t.isIdentifier(test.property)) {
+      opName = test.property.name;
+      opcode = +Object.keys(compiler.OP_NAME).find(key => compiler.OP_NAME[key] == opName);
+    } else if (t.isNumericLiteral(test)) {
+      opcode = test.value;
+    }
+    ok(typeof opcode === "number" && !Number.isNaN(opcode), `Failed to parse ${opcode} from ${opName}`);
+    if (opcode !== undefined) {
+      opcodeToCaseMap.set(opcode, sc);
+    }
+  }
+  return opcodeToCaseMap;
+}
 
 // Append a generated switch case for every entry in compiler.MACRO_OPS.
 // Each case inlines the constituent case bodies directly — no operand stack,
@@ -35,17 +58,7 @@ export function applyMacroOpcodes(ast, compiler) {
     }
   });
   ok(switchStatement, "Could not find @SWITCH statement for macro 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);
   for (const [macroOpStr, constituentOps] of Object.entries(compiler.MACRO_OPS)) {
     const macroOpCode = Number(macroOpStr);
     const N = constituentOps.length;
@@ -54,20 +67,19 @@ export function applyMacroOpcodes(ast, compiler) {
     const constituentCases = [];
     let allFound = true;
     for (const opVal of constituentOps) {
-      const opName = compiler.OP_NAME[opVal];
-      if (!opName) {
-        allFound = false;
-        break;
-      }
-      const found = nameToCaseMap.get(opName);
+      const found = opcodeToCaseMap.get(opVal);
       if (!found) {
         allFound = false;
         break;
       }
       constituentCases.push(found);
     }
-    if (!allFound) continue;
+    if (!allFound) {
+      throw new Error(`Could not find all constituent ops for macro op ${macroOpCode}`);
+    }
     const opNames = constituentOps.map(v => compiler.OP_NAME[v] ?? `OP_${v}`);
+    let newName = opNames.join(",");
+    compiler.OP_NAME[macroOpCode] = newName;
 
     // ── Build the macro case body ──────────────────────────────────────────
     // Clone and inline each sub-instruction's case body directly.