@tsvm/transforms 0.1.0

package/dist/index.js

@@ -0,0 +1,2854 @@
+// src/passes/preserve-type-illusions.ts
+import { OpCode, IRType, OperandKind as OperandKind2, ConstantKind } from "@tsvm/shared";
+
+// src/utils.ts
+import { OperandKind } from "@tsvm/shared";
+function getMaxRegister(func) {
+  let maxReg = -1;
+  const consider = (value) => {
+    if (!value) return;
+    const m = /^r(\d+)$/.exec(value);
+    if (m) {
+      maxReg = Math.max(maxReg, Number.parseInt(m[1], 10));
+    }
+  };
+  for (const param of func.params) consider(param.register);
+  for (const local of func.locals) consider(local.register);
+  for (const block of func.blocks) {
+    for (const phi of block.phiNodes ?? []) {
+      consider(phi.result);
+      for (const incoming of phi.incoming) consider(incoming.register);
+    }
+    for (const inst of block.instructions) {
+      consider(inst.result);
+      for (const op of inst.operands) {
+        if (op.kind === OperandKind.Register) consider(op.value);
+      }
+    }
+    consider(block.terminator.condition);
+    consider(block.terminator.returnValue);
+  }
+  return maxReg + 1;
+}
+
+// src/passes/preserve-type-illusions.ts
+var PreserveTypeIllusionsPass = class {
+  name = "PreserveTypeIllusionsPass";
+  priority = 10;
+  execute(ctx) {
+    let nodesTransformed = 0;
+    const newCP = [...ctx.module.constantPool];
+    const newFunctions = ctx.module.functions.map((func) => {
+      if (!func.isVirtualized) return func;
+      if (func.params.length === 0) return func;
+      if (!func.blocks || func.blocks.length === 0) return func;
+      if (ctx.rng.nextFloat() >= 0.3) {
+        return func;
+      }
+      nodesTransformed++;
+      const nextReg = getMaxRegister(func);
+      const tempReg1 = `r${nextReg}`;
+      const tempReg2 = `r${nextReg + 1}`;
+      const tempReg3 = `r${nextReg + 2}`;
+      let functionConstIdx = newCP.findIndex((cp) => cp.kind === ConstantKind.String && cp.value === "function");
+      if (functionConstIdx === -1) {
+        functionConstIdx = newCP.length;
+        newCP.push({ index: functionConstIdx, kind: ConstantKind.String, value: "function" });
+      }
+      const paramReg = func.params[0].register;
+      const newInsts = [
+        {
+          opcode: OpCode.TypeOf,
+          operands: [{ kind: OperandKind2.Register, value: paramReg }],
+          result: tempReg1
+        },
+        {
+          opcode: OpCode.LoadConst,
+          operands: [{ kind: OperandKind2.ConstantIndex, value: functionConstIdx }],
+          result: tempReg2
+        },
+        {
+          opcode: OpCode.Eq,
+          operands: [
+            { kind: OperandKind2.Register, value: tempReg1 },
+            { kind: OperandKind2.Register, value: tempReg2 }
+          ],
+          result: tempReg3
+        }
+      ];
+      const newBlocks = func.blocks.map((block, idx) => {
+        if (idx === 0) {
+          return {
+            ...block,
+            instructions: [...newInsts, ...block.instructions]
+          };
+        }
+        return block;
+      });
+      const addedLocals = [
+        {
+          name: `type_illusion_temp_${tempReg1}`,
+          register: tempReg1,
+          type: IRType.String,
+          isCaptured: false
+        },
+        {
+          name: `type_illusion_temp_${tempReg2}`,
+          register: tempReg2,
+          type: IRType.String,
+          isCaptured: false
+        },
+        {
+          name: `type_illusion_temp_${tempReg3}`,
+          register: tempReg3,
+          type: IRType.Boolean,
+          isCaptured: false
+        }
+      ];
+      return {
+        ...func,
+        locals: [...func.locals, ...addedLocals],
+        blocks: newBlocks
+      };
+    });
+    return {
+      module: { ...ctx.module, functions: newFunctions, constantPool: newCP },
+      symbolsRenamed: 0,
+      nodesTransformed,
+      diagnostics: []
+    };
+  }
+};
+
+// src/passes/generic-confusion.ts
+import { OpCode as OpCode2, OperandKind as OperandKind3, IRType as IRType2 } from "@tsvm/shared";
+var GenericConfusionPass = class {
+  name = "GenericConfusionPass";
+  priority = 20;
+  execute(ctx) {
+    let nodesTransformed = 0;
+    const newFunctions = ctx.module.functions.map((func) => {
+      let changed = false;
+      const nextReg = getMaxRegister(func);
+      let tempIndex = 0;
+      const addedLocals = [];
+      const newBlocks = func.blocks.map((block) => {
+        const newInstructions = [];
+        for (const inst of block.instructions) {
+          if (inst.opcode === OpCode2.Call || inst.opcode === OpCode2.CallMethod) {
+            if (ctx.rng.nextFloat() < 0.1) {
+              changed = true;
+              nodesTransformed++;
+              const tempReg1 = `r${nextReg + tempIndex++}`;
+              const tempReg2 = `r${nextReg + tempIndex++}`;
+              const tempReg3 = `r${nextReg + tempIndex++}`;
+              addedLocals.push(
+                { name: `generic_conf_temp_${tempReg1}`, register: tempReg1, type: IRType2.Any, isCaptured: false },
+                { name: `generic_conf_temp_${tempReg2}`, register: tempReg2, type: IRType2.String, isCaptured: false },
+                { name: `generic_conf_temp_${tempReg3}`, register: tempReg3, type: IRType2.Boolean, isCaptured: false }
+              );
+              newInstructions.push({
+                opcode: OpCode2.Move,
+                operands: [inst.operands[0], { kind: OperandKind3.Register, value: tempReg1 }],
+                metadata: { genericConfusion: true }
+              });
+              newInstructions.push({
+                opcode: OpCode2.TypeOf,
+                operands: [
+                  { kind: OperandKind3.Register, value: tempReg1 },
+                  { kind: OperandKind3.Register, value: tempReg2 }
+                ]
+              });
+              newInstructions.push({
+                opcode: OpCode2.Eq,
+                operands: [
+                  { kind: OperandKind3.Register, value: tempReg1 },
+                  { kind: OperandKind3.Register, value: tempReg2 }
+                ],
+                result: tempReg3
+              });
+              newInstructions.push(inst);
+            } else {
+              newInstructions.push(inst);
+            }
+          } else {
+            newInstructions.push(inst);
+          }
+        }
+        return changed ? { ...block, instructions: newInstructions } : block;
+      });
+      return changed ? {
+        ...func,
+        locals: [...func.locals, ...addedLocals],
+        blocks: newBlocks
+      } : func;
+    });
+    const newModule = {
+      ...ctx.module,
+      functions: newFunctions
+    };
+    return {
+      module: newModule,
+      symbolsRenamed: 0,
+      nodesTransformed,
+      diagnostics: []
+    };
+  }
+};
+
+// src/passes/decorator-aware-lowering.ts
+import { OpCode as OpCode3, OperandKind as OperandKind4, IRType as IRType3 } from "@tsvm/shared";
+var DecoratorAwareLoweringPass = class {
+  name = "DecoratorAwareLoweringPass";
+  priority = 30;
+  execute(ctx) {
+    let nodesTransformed = 0;
+    const newFunctions = ctx.module.functions.map((func) => {
+      if (!func.isVirtualized) return func;
+      const nextReg = getMaxRegister(func);
+      let tempIndex = 0;
+      const addedLocals = [];
+      const newBlocks = func.blocks.map((block) => {
+        const newInsts = block.instructions.flatMap((inst) => {
+          if ((inst.opcode === OpCode3.Call || inst.opcode === OpCode3.CallMethod) && inst.operands.length > 0) {
+            const firstOp = inst.operands[0];
+            if (firstOp.kind === OperandKind4.Register && ctx.rng.nextFloat() < 0.15) {
+              const tempReg = `r${nextReg + tempIndex}`;
+              tempIndex++;
+              nodesTransformed++;
+              addedLocals.push({
+                name: `decorator_temp_${tempReg}`,
+                register: tempReg,
+                type: IRType3.Any,
+                isCaptured: false
+              });
+              const moveInst = {
+                opcode: OpCode3.Move,
+                operands: [
+                  { kind: OperandKind4.Register, value: firstOp.value },
+                  { kind: OperandKind4.Register, value: tempReg }
+                ]
+              };
+              const updatedInst = {
+                ...inst,
+                operands: [{ kind: OperandKind4.Register, value: tempReg }, ...inst.operands.slice(1)]
+              };
+              return [moveInst, updatedInst];
+            }
+          }
+          return [inst];
+        });
+        return {
+          ...block,
+          instructions: newInsts
+        };
+      });
+      return {
+        ...func,
+        locals: [...func.locals, ...addedLocals],
+        blocks: newBlocks
+      };
+    });
+    return {
+      module: { ...ctx.module, functions: newFunctions },
+      symbolsRenamed: 0,
+      nodesTransformed,
+      diagnostics: []
+    };
+  }
+};
+
+// src/passes/namespace-virtualization.ts
+import { OpCode as OpCode4, ConstantKind as ConstantKind3, OperandKind as OperandKind5, IRType as IRType4, FunctionAttribute } from "@tsvm/shared";
+var NamespaceVirtualizationPass = class {
+  name = "NamespaceVirtualizationPass";
+  priority = 40;
+  execute(ctx) {
+    let nodesTransformed = 0;
+    const constantPool = [...ctx.module.constantPool];
+    function isThisRegister(func, reg) {
+      for (const block of func.blocks) {
+        for (const inst of block.instructions) {
+          if (inst.result === reg && inst.opcode === OpCode4.LoadThis) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    function getPropertyNameOfRegister(func, reg, cp) {
+      for (const block of func.blocks) {
+        for (const inst of block.instructions) {
+          if (inst.result === reg && inst.opcode === OpCode4.LoadConst) {
+            const op = inst.operands[0];
+            if (op && op.kind === OperandKind5.ConstantIndex) {
+              const entry = cp[op.value];
+              if (entry && entry.kind === ConstantKind3.String) {
+                return entry.value;
+              }
+            }
+          }
+        }
+      }
+      return void 0;
+    }
+    const standardBuiltins = /* @__PURE__ */ new Set([
+      "prototype",
+      "constructor",
+      "length",
+      "name",
+      // Array & Object methods
+      "push",
+      "pop",
+      "shift",
+      "unshift",
+      "splice",
+      "slice",
+      "concat",
+      "join",
+      "forEach",
+      "map",
+      "filter",
+      "reduce",
+      "indexOf",
+      "includes",
+      "find",
+      "findIndex",
+      "keys",
+      "values",
+      "entries",
+      "toString",
+      "valueOf",
+      "toLocaleString",
+      "hasOwnProperty",
+      "isPrototypeOf",
+      "propertyIsEnumerable",
+      "apply",
+      "call",
+      "bind",
+      // Promise & Async / Iterator
+      "then",
+      "catch",
+      "finally",
+      "resolve",
+      "reject",
+      "next",
+      "throw",
+      "return",
+      "value",
+      "done",
+      // Error standard properties
+      "message",
+      "stack",
+      "cause",
+      // Console & System
+      "log",
+      "error",
+      "warn",
+      "info",
+      "dir",
+      "clear",
+      // NodeJS/Browser standard & VM
+      "exports",
+      "module",
+      "require",
+      "global",
+      "window",
+      "document",
+      "process",
+      "readFileSync",
+      "writeFileSync",
+      "readdirSync",
+      "statSync",
+      "mtime",
+      "getTime",
+      "exec",
+      "test",
+      "match",
+      "replace",
+      "split",
+      "trim",
+      "toLowerCase",
+      "toUpperCase",
+      // Symbol properties or other standard ones
+      "Symbol",
+      "iterator",
+      "asyncIterator",
+      "toStringTag",
+      // Reflect and Object proxy trap builtins
+      "setPrototypeOf",
+      "getPrototypeOf",
+      "defineProperty",
+      "defineProperties",
+      "getOwnPropertyDescriptor",
+      "getOwnPropertyNames",
+      "getOwnPropertySymbols",
+      "create",
+      "assign",
+      "freeze",
+      "seal",
+      "preventExtensions",
+      "isExtensible",
+      "isFrozen",
+      "isSealed",
+      "construct",
+      "has",
+      "get",
+      "set",
+      "deleteProperty",
+      "ownKeys"
+    ]);
+    function hashString(str, seed) {
+      let hash = (seed ^ 2166136261) >>> 0;
+      const prime = 16777619;
+      for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = Math.imul(hash, prime) >>> 0;
+      }
+      const folded = hash >>> 16 ^ hash & 65535 ^ seed >>> 8 & 65535;
+      return folded.toString(16).padStart(4, "0") + ((hash ^ seed) >>> 0).toString(16);
+    }
+    const newFunctions = ctx.module.functions.map((func) => {
+      let changed = false;
+      const nextReg = getMaxRegister(func);
+      let tempIndex = 0;
+      const addedLocals = [];
+      const paramRegs = /* @__PURE__ */ new Set();
+      const paramLocals = /* @__PURE__ */ new Set();
+      for (const p of func.params) {
+        paramRegs.add(p.register);
+      }
+      let sizeChanged = true;
+      while (sizeChanged) {
+        const oldRegSize = paramRegs.size;
+        const oldLocalSize = paramLocals.size;
+        for (const block of func.blocks) {
+          for (const inst of block.instructions) {
+            if (inst.opcode === OpCode4.Move) {
+              const srcOp = inst.operands[0];
+              const destOp = inst.operands[1];
+              if (srcOp && srcOp.kind === OperandKind5.Register && typeof srcOp.value === "string" && paramRegs.has(srcOp.value)) {
+                if (destOp && destOp.kind === OperandKind5.Register && typeof destOp.value === "string") {
+                  paramRegs.add(destOp.value);
+                }
+              }
+            } else if (inst.opcode === OpCode4.StoreLocal) {
+              const localOp = inst.operands[0];
+              const srcOp = inst.operands[1];
+              if (srcOp && srcOp.kind === OperandKind5.Register && typeof srcOp.value === "string" && paramRegs.has(srcOp.value)) {
+                if (localOp && localOp.kind === OperandKind5.Register && typeof localOp.value === "string") {
+                  paramLocals.add(localOp.value);
+                }
+              }
+            } else if (inst.opcode === OpCode4.LoadLocal && inst.result) {
+              const localOp = inst.operands[0];
+              if (localOp && localOp.kind === OperandKind5.Register && typeof localOp.value === "string") {
+                if (paramLocals.has(localOp.value) || paramRegs.has(localOp.value)) {
+                  paramRegs.add(inst.result);
+                }
+              }
+            } else if (inst.result) {
+              const srcOp = inst.operands[0];
+              const isSrcReg = srcOp && srcOp.kind === OperandKind5.Register && typeof srcOp.value === "string";
+              if ((inst.opcode === OpCode4.PropGet || inst.opcode === OpCode4.ComputedGet) && isSrcReg && paramRegs.has(srcOp.value)) {
+                paramRegs.add(inst.result);
+              } else if (inst.opcode === OpCode4.Call || inst.opcode === OpCode4.CallMethod || inst.opcode === OpCode4.CallWithArray || inst.opcode === OpCode4.CallMethodWithArray) {
+                paramRegs.add(inst.result);
+              } else if (inst.opcode === OpCode4.RestArgs) {
+                paramRegs.add(inst.result);
+              }
+            }
+          }
+        }
+        sizeChanged = paramRegs.size !== oldRegSize || paramLocals.size !== oldLocalSize;
+      }
+      const lexicalThisRegs = /* @__PURE__ */ new Set();
+      const lexicalThisLocals = /* @__PURE__ */ new Set();
+      for (const block of func.blocks) {
+        for (const inst of block.instructions) {
+          if (inst.opcode === OpCode4.EnvGet && inst.result) {
+            const op = inst.operands[0];
+            if (op && op.kind === OperandKind5.Immediate && typeof op.value === "number") {
+              const capVar = func.capturedVariables[op.value];
+              if (capVar === "$$vm_lexical_this") {
+                lexicalThisRegs.add(inst.result);
+              }
+            }
+          }
+        }
+      }
+      let lexicalSizeChanged = true;
+      while (lexicalSizeChanged) {
+        const oldRegSize = lexicalThisRegs.size;
+        const oldLocalSize = lexicalThisLocals.size;
+        for (const block of func.blocks) {
+          for (const inst of block.instructions) {
+            if (inst.opcode === OpCode4.Move) {
+              const srcOp = inst.operands[0];
+              const destOp = inst.operands[1];
+              if (srcOp && srcOp.kind === OperandKind5.Register && typeof srcOp.value === "string" && lexicalThisRegs.has(srcOp.value)) {
+                if (destOp && destOp.kind === OperandKind5.Register && typeof destOp.value === "string") {
+                  lexicalThisRegs.add(destOp.value);
+                }
+              }
+            } else if (inst.opcode === OpCode4.StoreLocal) {
+              const localOp = inst.operands[0];
+              const srcOp = inst.operands[1];
+              if (srcOp && srcOp.kind === OperandKind5.Register && typeof srcOp.value === "string" && lexicalThisRegs.has(srcOp.value)) {
+                if (localOp && localOp.kind === OperandKind5.Register && typeof localOp.value === "string") {
+                  lexicalThisLocals.add(localOp.value);
+                }
+              }
+            } else if (inst.opcode === OpCode4.LoadLocal && inst.result) {
+              const localOp = inst.operands[0];
+              if (localOp && localOp.kind === OperandKind5.Register && typeof localOp.value === "string") {
+                if (lexicalThisLocals.has(localOp.value) || lexicalThisRegs.has(localOp.value)) {
+                  lexicalThisRegs.add(inst.result);
+                }
+              }
+            } else if (inst.result) {
+              if (inst.opcode === OpCode4.CellGet || inst.opcode === OpCode4.CellNew) {
+                const srcOp = inst.operands[0];
+                if (srcOp && srcOp.kind === OperandKind5.Register && typeof srcOp.value === "string" && lexicalThisRegs.has(srcOp.value)) {
+                  lexicalThisRegs.add(inst.result);
+                }
+              }
+            }
+          }
+        }
+        lexicalSizeChanged = lexicalThisRegs.size !== oldRegSize || lexicalThisLocals.size !== oldLocalSize;
+      }
+      const localObjects = /* @__PURE__ */ new Set();
+      const localObjectLocals = /* @__PURE__ */ new Set();
+      let localObjSizeChanged = true;
+      while (localObjSizeChanged) {
+        const oldRegSize = localObjects.size;
+        const oldLocalSize = localObjectLocals.size;
+        for (const block of func.blocks) {
+          for (const inst of block.instructions) {
+            if (inst.opcode === OpCode4.ObjectNew && inst.result) {
+              localObjects.add(inst.result);
+            } else if (inst.opcode === OpCode4.Move) {
+              const srcOp = inst.operands[0];
+              const destOp = inst.operands[1];
+              if (srcOp && srcOp.kind === OperandKind5.Register && typeof srcOp.value === "string" && localObjects.has(srcOp.value)) {
+                if (destOp && destOp.kind === OperandKind5.Register && typeof destOp.value === "string") {
+                  localObjects.add(destOp.value);
+                }
+              }
+            } else if (inst.opcode === OpCode4.StoreLocal) {
+              const localOp = inst.operands[0];
+              const srcOp = inst.operands[1];
+              if (srcOp && srcOp.kind === OperandKind5.Register && typeof srcOp.value === "string" && localObjects.has(srcOp.value)) {
+                if (localOp && localOp.kind === OperandKind5.Register && typeof localOp.value === "string") {
+                  localObjectLocals.add(localOp.value);
+                }
+              }
+            } else if (inst.opcode === OpCode4.LoadLocal && inst.result) {
+              const localOp = inst.operands[0];
+              if (localOp && localOp.kind === OperandKind5.Register && typeof localOp.value === "string") {
+                if (localObjectLocals.has(localOp.value) || localObjects.has(localOp.value)) {
+                  localObjects.add(inst.result);
+                }
+              }
+            }
+          }
+        }
+        localObjSizeChanged = localObjects.size !== oldRegSize || localObjectLocals.size !== oldLocalSize;
+      }
+      const newBlocks = func.blocks.map((block) => {
+        const newInstructions = [];
+        for (const inst of block.instructions) {
+          if (inst.opcode === OpCode4.PropGet || inst.opcode === OpCode4.PropSet) {
+            const objOp = inst.operands[0];
+            const keyOp = inst.operands[1];
+            const isStaticContext = func.attributes && func.attributes.indexOf(FunctionAttribute.Static) >= 0;
+            const isObjThis = !isStaticContext && objOp && objOp.kind === OperandKind5.Register && typeof objOp.value === "string" && (isThisRegister(func, objOp.value) || lexicalThisRegs.has(objOp.value));
+            const isObjParam = objOp && objOp.kind === OperandKind5.Register && typeof objOp.value === "string" && paramRegs.has(objOp.value);
+            const isLocalObj = objOp && objOp.kind === OperandKind5.Register && typeof objOp.value === "string" && localObjects.has(objOp.value);
+            const propName = keyOp && keyOp.kind === OperandKind5.Register && typeof keyOp.value === "string" ? getPropertyNameOfRegister(func, keyOp.value, constantPool) : void 0;
+            const isBuiltin = propName && (standardBuiltins.has(propName) || ctx.module.exports.some((e) => e.exportedName === propName || e.localName === propName) || ctx.module.imports.some((i) => i.localName === propName || i.importedName === propName));
+            if (!isObjThis && !isObjParam && !isLocalObj && propName && !isBuiltin) {
+              changed = true;
+              nodesTransformed++;
+              const propHash = hashString(propName, ctx.profile.seed);
+              const hashedName = `hash_${propHash}`;
+              let cpIndex = constantPool.findIndex((c) => c.kind === ConstantKind3.String && c.value === hashedName);
+              if (cpIndex === -1) {
+                cpIndex = constantPool.length;
+                constantPool.push({
+                  index: cpIndex,
+                  kind: ConstantKind3.String,
+                  value: hashedName
+                });
+              }
+              const tempReg = `r${nextReg + tempIndex++}`;
+              addedLocals.push({
+                name: `ns_virt_temp_${tempReg}`,
+                register: tempReg,
+                type: IRType4.String,
+                isCaptured: false
+              });
+              newInstructions.push({
+                opcode: OpCode4.LoadConst,
+                operands: [{ kind: OperandKind5.ConstantIndex, value: cpIndex }],
+                result: tempReg,
+                sourceLocation: inst.sourceLocation
+              });
+              const ops = [...inst.operands];
+              if (ops.length >= 2) {
+                ops[1] = { kind: OperandKind5.Register, value: tempReg };
+              }
+              newInstructions.push({
+                ...inst,
+                opcode: inst.opcode === OpCode4.PropGet ? OpCode4.ComputedGet : OpCode4.ComputedSet,
+                operands: ops,
+                metadata: { namespaceVirtualization: true }
+              });
+            } else {
+              newInstructions.push(inst);
+            }
+          } else {
+            newInstructions.push(inst);
+          }
+        }
+        return changed ? { ...block, instructions: newInstructions } : block;
+      });
+      return changed ? {
+        ...func,
+        locals: [...func.locals, ...addedLocals],
+        blocks: newBlocks
+      } : func;
+    });
+    const newModule = {
+      ...ctx.module,
+      functions: newFunctions,
+      constantPool
+    };
+    return {
+      module: newModule,
+      symbolsRenamed: 0,
+      nodesTransformed,
+      diagnostics: []
+    };
+  }
+};
+
+// src/passes/type-level-fake-path.ts
+import { OpCode as OpCode5, ConstantKind as ConstantKind4, OperandKind as OperandKind6, IRType as IRType5 } from "@tsvm/shared";
+var TypeLevelFakePathPass = class {
+  name = "TypeLevelFakePathPass";
+  priority = 30;
+  execute(ctx) {
+    let nodesTransformed = 0;
+    const newCP = [...ctx.module.constantPool];
+    function collectDecoyInstructions(func, junkRegs, rng) {
+      const realBlocks = func.blocks.filter((b) => !b.id.startsWith("__fake_path_") && b.instructions.length >= 2);
+      if (realBlocks.length === 0) return [];
+      const sourceBlock = rng.pick(realBlocks);
+      const count = Math.min(rng.nextRange(2, 3), sourceBlock.instructions.length);
+      const startIdx = rng.nextRange(0, Math.max(0, sourceBlock.instructions.length - count));
+      const decoys = [];
+      for (let d = 0; d < count; d++) {
+        const origInst = sourceBlock.instructions[startIdx + d];
+        if (!origInst) break;
+        if (origInst.opcode === OpCode5.Jmp || origInst.opcode === OpCode5.JmpIf || origInst.opcode === OpCode5.JmpIfNot || origInst.opcode === OpCode5.Return || origInst.opcode === OpCode5.ReturnVoid || origInst.opcode === OpCode5.Throw || origInst.opcode === OpCode5.Trap || origInst.opcode === OpCode5.Halt || origInst.opcode === OpCode5.Call || origInst.opcode === OpCode5.CallMethod || origInst.opcode === OpCode5.New) {
+          continue;
+        }
+        const junkReg = junkRegs[d % junkRegs.length];
+        decoys.push({
+          ...origInst,
+          result: origInst.result ? junkReg : origInst.result,
+          sourceLocation: void 0,
+          // Strip source location from decoys
+          metadata: void 0
+        });
+      }
+      return decoys;
+    }
+    function buildFakeBlockEnding(rng, junkTemp1, junkTemp2, regX, fortyTwoIdx, undefinedIdx) {
+      const endingType = rng.nextRange(0, 2);
+      if (endingType === 0) {
+        return {
+          instructions: [{ opcode: OpCode5.Trap, operands: [] }],
+          terminatorKind: "unreachable"
+        };
+      }
+      if (endingType === 1) {
+        return {
+          instructions: [
+            {
+              opcode: OpCode5.LoadConst,
+              operands: [{ kind: OperandKind6.ConstantIndex, value: undefinedIdx }],
+              result: junkTemp1
+            }
+          ],
+          terminatorKind: "return"
+        };
+      }
+      return {
+        instructions: [
+          {
+            opcode: OpCode5.LoadConst,
+            operands: [{ kind: OperandKind6.ConstantIndex, value: fortyTwoIdx }],
+            result: junkTemp1
+          },
+          {
+            opcode: OpCode5.Add,
+            operands: [
+              { kind: OperandKind6.Register, value: junkTemp1 },
+              { kind: OperandKind6.Register, value: regX }
+            ],
+            result: junkTemp2
+          },
+          {
+            opcode: OpCode5.Move,
+            operands: [
+              { kind: OperandKind6.Register, value: junkTemp2 },
+              { kind: OperandKind6.Register, value: junkTemp1 }
+            ]
+          }
+        ],
+        terminatorKind: "return"
+      };
+    }
+    const newFunctions = ctx.module.functions.map((func) => {
+      if (!func.isVirtualized) return func;
+      if (func.blocks.length < 3) return func;
+      const isParanoid = ctx.profile.vm?.runtimeHardening === "paranoid";
+      if (!isParanoid && ctx.rng.nextFloat() >= 0.25) {
+        return func;
+      }
+      let eligibleBlocks = func.blocks.filter((b) => b.terminator.kind === "jump");
+      if (eligibleBlocks.length === 0) {
+        return func;
+      }
+      const numFakes = isParanoid ? ctx.rng.nextRange(1, 3) : 1;
+      let currentFunc = { ...func };
+      for (let f = 0; f < numFakes; f++) {
+        eligibleBlocks = currentFunc.blocks.filter((b) => b.terminator.kind === "jump" && !b.id.startsWith("__fake_path_"));
+        if (eligibleBlocks.length === 0) break;
+        const blockToModify = ctx.rng.pick(eligibleBlocks);
+        if (!blockToModify.terminator.targets || blockToModify.terminator.targets.length === 0) {
+          continue;
+        }
+        nodesTransformed++;
+        const nextReg = getMaxRegister(currentFunc);
+        const tempA = `r${nextReg}`;
+        const tempB = `r${nextReg + 1}`;
+        const tempC = `r${nextReg + 2}`;
+        const tempD = `r${nextReg + 3}`;
+        const tempE = `r${nextReg + 4}`;
+        const tempF = `r${nextReg + 5}`;
+        const tempG = `r${nextReg + 6}`;
+        const tempP = `r${nextReg + 7}`;
+        const tempQ = `r${nextReg + 8}`;
+        const junkTemp1 = `r${nextReg + 9}`;
+        const junkTemp2 = `r${nextReg + 10}`;
+        const junkTemp3 = `r${nextReg + 11}`;
+        const regX = currentFunc.params.length > 0 ? currentFunc.params[0].register : "r0";
+        let zeroIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 0);
+        if (zeroIdx === -1) {
+          zeroIdx = newCP.length;
+          newCP.push({ index: zeroIdx, kind: ConstantKind4.Number, value: 0 });
+        }
+        let threeIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 3);
+        if (threeIdx === -1) {
+          threeIdx = newCP.length;
+          newCP.push({ index: threeIdx, kind: ConstantKind4.Number, value: 3 });
+        }
+        let fiveIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 5);
+        if (fiveIdx === -1) {
+          fiveIdx = newCP.length;
+          newCP.push({ index: fiveIdx, kind: ConstantKind4.Number, value: 5 });
+        }
+        let sevenIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 7);
+        if (sevenIdx === -1) {
+          sevenIdx = newCP.length;
+          newCP.push({ index: sevenIdx, kind: ConstantKind4.Number, value: 7 });
+        }
+        let fourIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 4);
+        if (fourIdx === -1) {
+          fourIdx = newCP.length;
+          newCP.push({ index: fourIdx, kind: ConstantKind4.Number, value: 4 });
+        }
+        let fortyTwoIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 42);
+        if (fortyTwoIdx === -1) {
+          fortyTwoIdx = newCP.length;
+          newCP.push({ index: fortyTwoIdx, kind: ConstantKind4.Number, value: 42 });
+        }
+        let undefinedIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Undefined);
+        if (undefinedIdx === -1) {
+          undefinedIdx = newCP.length;
+          newCP.push({ index: undefinedIdx, kind: ConstantKind4.Undefined, value: null });
+        }
+        let processIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.String && cp.value === "process");
+        if (processIdx === -1) {
+          processIdx = newCP.length;
+          newCP.push({ index: processIdx, kind: ConstantKind4.String, value: "process" });
+        }
+        let windowIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.String && cp.value === "window");
+        if (windowIdx === -1) {
+          windowIdx = newCP.length;
+          newCP.push({ index: windowIdx, kind: ConstantKind4.String, value: "window" });
+        }
+        let lengthIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.String && cp.value === "length");
+        if (lengthIdx === -1) {
+          lengthIdx = newCP.length;
+          newCP.push({ index: lengthIdx, kind: ConstantKind4.String, value: "length" });
+        }
+        let thirtyOneIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 31);
+        if (thirtyOneIdx === -1) {
+          thirtyOneIdx = newCP.length;
+          newCP.push({ index: thirtyOneIdx, kind: ConstantKind4.Number, value: 31 });
+        }
+        let fifteenIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 15);
+        if (fifteenIdx === -1) {
+          fifteenIdx = newCP.length;
+          newCP.push({ index: fifteenIdx, kind: ConstantKind4.Number, value: 15 });
+        }
+        let eightIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 8);
+        if (eightIdx === -1) {
+          eightIdx = newCP.length;
+          newCP.push({ index: eightIdx, kind: ConstantKind4.Number, value: 8 });
+        }
+        let errorIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.String && cp.value === "Error");
+        if (errorIdx === -1) {
+          errorIdx = newCP.length;
+          newCP.push({ index: errorIdx, kind: ConstantKind4.String, value: "Error" });
+        }
+        let stackIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.String && cp.value === "stack");
+        if (stackIdx === -1) {
+          stackIdx = newCP.length;
+          newCP.push({ index: stackIdx, kind: ConstantKind4.String, value: "stack" });
+        }
+        let stringIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.String && cp.value === "string");
+        if (stringIdx === -1) {
+          stringIdx = newCP.length;
+          newCP.push({ index: stringIdx, kind: ConstantKind4.String, value: "string" });
+        }
+        const templateId = isParanoid ? ctx.rng.nextRange(0, 4) : 0;
+        let opaqueInsts = [];
+        if (templateId === 0) {
+          opaqueInsts = [
+            // 1. typeof process length
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: processIdx }], result: tempA },
+            { opcode: OpCode5.LoadGlobal, operands: [{ kind: OperandKind6.Register, value: tempA }], result: tempA },
+            { opcode: OpCode5.TypeOf, operands: [{ kind: OperandKind6.Register, value: tempA }], result: tempB },
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: lengthIdx }], result: tempC },
+            {
+              opcode: OpCode5.PropGet,
+              operands: [
+                { kind: OperandKind6.Register, value: tempB },
+                { kind: OperandKind6.Register, value: tempC }
+              ],
+              result: tempD
+            },
+            // len1
+            // 2. typeof window length
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: windowIdx }], result: tempA },
+            { opcode: OpCode5.LoadGlobal, operands: [{ kind: OperandKind6.Register, value: tempA }], result: tempA },
+            { opcode: OpCode5.TypeOf, operands: [{ kind: OperandKind6.Register, value: tempA }], result: tempE },
+            {
+              opcode: OpCode5.PropGet,
+              operands: [
+                { kind: OperandKind6.Register, value: tempE },
+                { kind: OperandKind6.Register, value: tempC }
+              ],
+              result: tempF
+            },
+            // len2
+            // 3. hash = (len1 * 31 + len2) & 0xF
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: thirtyOneIdx }], result: tempA },
+            {
+              opcode: OpCode5.Mul,
+              operands: [
+                { kind: OperandKind6.Register, value: tempD },
+                { kind: OperandKind6.Register, value: tempA }
+              ],
+              result: tempG
+            },
+            // len1 * 31
+            {
+              opcode: OpCode5.Add,
+              operands: [
+                { kind: OperandKind6.Register, value: tempG },
+                { kind: OperandKind6.Register, value: tempF }
+              ],
+              result: tempG
+            },
+            // len1 * 31 + len2
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: fifteenIdx }], result: tempA },
+            {
+              opcode: OpCode5.BitAnd,
+              operands: [
+                { kind: OperandKind6.Register, value: tempG },
+                { kind: OperandKind6.Register, value: tempA }
+              ],
+              result: tempG
+            },
+            // hash = tempG & 15
+            // 4. (hash * hash + 5) % 8 !== 0
+            {
+              opcode: OpCode5.Mul,
+              operands: [
+                { kind: OperandKind6.Register, value: tempG },
+                { kind: OperandKind6.Register, value: tempG }
+              ],
+              result: tempE
+            },
+            // hash * hash
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: fiveIdx }], result: tempA },
+            {
+              opcode: OpCode5.Add,
+              operands: [
+                { kind: OperandKind6.Register, value: tempE },
+                { kind: OperandKind6.Register, value: tempA }
+              ],
+              result: tempE
+            },
+            // hash * hash + 5
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: eightIdx }], result: tempA },
+            {
+              opcode: OpCode5.Mod,
+              operands: [
+                { kind: OperandKind6.Register, value: tempE },
+                { kind: OperandKind6.Register, value: tempA }
+              ],
+              result: tempE
+            },
+            // (hash*hash+5) % 8
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: zeroIdx }], result: tempA },
+            {
+              opcode: OpCode5.StrictEq,
+              operands: [
+                { kind: OperandKind6.Register, value: tempE },
+                { kind: OperandKind6.Register, value: tempA }
+              ],
+              result: tempE
+            },
+            // hashMod === 0
+            { opcode: OpCode5.Not, operands: [{ kind: OperandKind6.Register, value: tempE }], result: tempP },
+            // envOpaque = !hashModEqualsZero
+            // 5. stack = new Error().stack, typeof stack === 'string'
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: errorIdx }], result: tempA },
+            { opcode: OpCode5.LoadGlobal, operands: [{ kind: OperandKind6.Register, value: tempA }], result: tempA },
+            { opcode: OpCode5.New, operands: [{ kind: OperandKind6.Register, value: tempA }], result: tempB },
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: stackIdx }], result: tempC },
+            {
+              opcode: OpCode5.PropGet,
+              operands: [
+                { kind: OperandKind6.Register, value: tempB },
+                { kind: OperandKind6.Register, value: tempC }
+              ],
+              result: tempD
+            },
+            // stack
+            { opcode: OpCode5.TypeOf, operands: [{ kind: OperandKind6.Register, value: tempD }], result: tempE },
+            // typeof stack
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: stringIdx }], result: tempA },
+            {
+              opcode: OpCode5.StrictEq,
+              operands: [
+                { kind: OperandKind6.Register, value: tempE },
+                { kind: OperandKind6.Register, value: tempA }
+              ],
+              result: tempF
+            },
+            // typeof stack === 'string'
+            // 6. envPredicate = (rEnvOpaque === rIsString)
+            {
+              opcode: OpCode5.StrictEq,
+              operands: [
+                { kind: OperandKind6.Register, value: tempP },
+                { kind: OperandKind6.Register, value: tempF }
+              ],
+              result: tempQ
+            }
+            // tempQ is envPredicate (always true)
+          ];
+        } else if (templateId === 1) {
+          opaqueInsts = [
+            { opcode: OpCode5.GetEntropy, operands: [], result: tempA },
+            // tempA = x
+            {
+              opcode: OpCode5.Mul,
+              operands: [
+                { kind: OperandKind6.Register, value: tempA },
+                { kind: OperandKind6.Register, value: tempA }
+              ],
+              result: tempB
+            },
+            // tempB = x^2
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: threeIdx }], result: tempC },
+            // tempC = 3
+            {
+              opcode: OpCode5.BitAnd,
+              operands: [
+                { kind: OperandKind6.Register, value: tempB },
+                { kind: OperandKind6.Register, value: tempC }
+              ],
+              result: tempD
+            },
+            // tempD = x^2 & 3
+            {
+              opcode: OpCode5.StrictEq,
+              operands: [
+                { kind: OperandKind6.Register, value: tempD },
+                { kind: OperandKind6.Register, value: tempC }
+              ],
+              result: tempP
+            },
+            // tempP = (x^2 & 3 === 3), always false
+            { opcode: OpCode5.Not, operands: [{ kind: OperandKind6.Register, value: tempP }], result: tempQ }
+            // tempQ = true
+          ];
+        } else if (templateId === 2) {
+          let thirtyOneIdx2 = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 31);
+          if (thirtyOneIdx2 === -1) {
+            thirtyOneIdx2 = newCP.length;
+            newCP.push({ index: thirtyOneIdx2, kind: ConstantKind4.Number, value: 31 });
+          }
+          let twoIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 2);
+          if (twoIdx === -1) {
+            twoIdx = newCP.length;
+            newCP.push({ index: twoIdx, kind: ConstantKind4.Number, value: 2 });
+          }
+          opaqueInsts = [
+            { opcode: OpCode5.GetEntropy, operands: [], result: tempA },
+            // tempA = x
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: thirtyOneIdx2 }], result: tempC },
+            // tempC = 31
+            {
+              opcode: OpCode5.Mul,
+              operands: [
+                { kind: OperandKind6.Register, value: tempC },
+                { kind: OperandKind6.Register, value: tempA }
+              ],
+              result: tempB
+            },
+            // tempB = 31*x
+            {
+              opcode: OpCode5.Mul,
+              operands: [
+                { kind: OperandKind6.Register, value: tempB },
+                { kind: OperandKind6.Register, value: tempB }
+              ],
+              result: tempD
+            },
+            // tempD = (31*x)^2
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: threeIdx }], result: tempC },
+            // tempC = 3
+            {
+              opcode: OpCode5.Mod,
+              operands: [
+                { kind: OperandKind6.Register, value: tempD },
+                { kind: OperandKind6.Register, value: tempC }
+              ],
+              result: tempE
+            },
+            // tempE = (31*x)^2 % 3
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: twoIdx }], result: tempC },
+            // tempC = 2
+            {
+              opcode: OpCode5.StrictEq,
+              operands: [
+                { kind: OperandKind6.Register, value: tempE },
+                { kind: OperandKind6.Register, value: tempC }
+              ],
+              result: tempP
+            },
+            // tempP = false always
+            { opcode: OpCode5.Not, operands: [{ kind: OperandKind6.Register, value: tempP }], result: tempQ }
+            // tempQ = true
+          ];
+        } else if (templateId === 3) {
+          let twoIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 2);
+          if (twoIdx === -1) {
+            twoIdx = newCP.length;
+            newCP.push({ index: twoIdx, kind: ConstantKind4.Number, value: 2 });
+          }
+          opaqueInsts = [
+            { opcode: OpCode5.GetEntropy, operands: [], result: tempA },
+            // tempA = x
+            {
+              opcode: OpCode5.Mul,
+              operands: [
+                { kind: OperandKind6.Register, value: tempA },
+                { kind: OperandKind6.Register, value: tempA }
+              ],
+              result: tempB
+            },
+            // tempB = x^2
+            {
+              opcode: OpCode5.Add,
+              operands: [
+                { kind: OperandKind6.Register, value: tempB },
+                { kind: OperandKind6.Register, value: tempA }
+              ],
+              result: tempC
+            },
+            // tempC = x^2 + x
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: twoIdx }], result: tempD },
+            // tempD = 2
+            {
+              opcode: OpCode5.Mod,
+              operands: [
+                { kind: OperandKind6.Register, value: tempC },
+                { kind: OperandKind6.Register, value: tempD }
+              ],
+              result: tempE
+            },
+            // tempE = (x^2+x) % 2
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: zeroIdx }], result: tempD },
+            // tempD = 0
+            {
+              opcode: OpCode5.StrictEq,
+              operands: [
+                { kind: OperandKind6.Register, value: tempE },
+                { kind: OperandKind6.Register, value: tempD }
+              ],
+              result: tempP
+            },
+            // always true
+            { opcode: OpCode5.Move, operands: [{ kind: OperandKind6.Register, value: tempP }], result: tempQ }
+          ];
+        } else {
+          let twoIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 2);
+          if (twoIdx === -1) {
+            twoIdx = newCP.length;
+            newCP.push({ index: twoIdx, kind: ConstantKind4.Number, value: 2 });
+          }
+          let oneIdx = newCP.findIndex((cp) => cp.kind === ConstantKind4.Number && cp.value === 1);
+          if (oneIdx === -1) {
+            oneIdx = newCP.length;
+            newCP.push({ index: oneIdx, kind: ConstantKind4.Number, value: 1 });
+          }
+          opaqueInsts = [
+            { opcode: OpCode5.GetEntropy, operands: [], result: tempA },
+            // tempA = x
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: oneIdx }], result: tempC },
+            // tempC = 1
+            {
+              opcode: OpCode5.Add,
+              operands: [
+                { kind: OperandKind6.Register, value: tempA },
+                { kind: OperandKind6.Register, value: tempC }
+              ],
+              result: tempB
+            },
+            // tempB = x+1
+            {
+              opcode: OpCode5.Mul,
+              operands: [
+                { kind: OperandKind6.Register, value: tempA },
+                { kind: OperandKind6.Register, value: tempB }
+              ],
+              result: tempD
+            },
+            // tempD = x*(x+1)
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: twoIdx }], result: tempC },
+            // tempC = 2
+            {
+              opcode: OpCode5.Mod,
+              operands: [
+                { kind: OperandKind6.Register, value: tempD },
+                { kind: OperandKind6.Register, value: tempC }
+              ],
+              result: tempE
+            },
+            // tempE = x*(x+1) % 2
+            { opcode: OpCode5.LoadConst, operands: [{ kind: OperandKind6.ConstantIndex, value: zeroIdx }], result: tempC },
+            // tempC = 0
+            {
+              opcode: OpCode5.StrictEq,
+              operands: [
+                { kind: OperandKind6.Register, value: tempE },
+                { kind: OperandKind6.Register, value: tempC }
+              ],
+              result: tempP
+            },
+            // always true
+            { opcode: OpCode5.Move, operands: [{ kind: OperandKind6.Register, value: tempP }], result: tempQ }
+          ];
+        }
+        const fakeBlockId = `__fake_path_${ctx.rng.identifier(6)}`;
+        const decoyInsts = collectDecoyInstructions(currentFunc, [junkTemp1, junkTemp2, junkTemp3], ctx.rng);
+        const ending = buildFakeBlockEnding(ctx.rng, junkTemp1, junkTemp2, regX, fortyTwoIdx, undefinedIdx);
+        const fakeBlock = {
+          id: fakeBlockId,
+          label: "fake_path",
+          instructions: [...decoyInsts, ...ending.instructions],
+          terminator: {
+            kind: ending.terminatorKind,
+            targets: []
+          },
+          predecessors: [blockToModify.id],
+          successors: [],
+          phiNodes: []
+        };
+        const originalTarget = blockToModify.terminator.targets[0];
+        const newBlocks = currentFunc.blocks.flatMap((block) => {
+          if (block.id === blockToModify.id) {
+            const updatedBlock = {
+              ...block,
+              instructions: [...block.instructions, ...opaqueInsts],
+              terminator: {
+                kind: "branch",
+                targets: [originalTarget, fakeBlock.id],
+                condition: tempQ
+              },
+              successors: [originalTarget, fakeBlock.id]
+            };
+            return [updatedBlock, fakeBlock];
+          }
+          return [block];
+        });
+        const addedLocals = [
+          { name: `fake_path_entropy_${tempA}`, register: tempA, type: IRType5.Number, isCaptured: false },
+          { name: `fake_path_temp_${tempB}`, register: tempB, type: IRType5.Number, isCaptured: false },
+          { name: `fake_path_temp_${tempC}`, register: tempC, type: IRType5.Number, isCaptured: false },
+          { name: `fake_path_temp_${tempD}`, register: tempD, type: IRType5.Number, isCaptured: false },
+          { name: `fake_path_temp_${tempE}`, register: tempE, type: IRType5.Number, isCaptured: false },
+          { name: `fake_path_temp_${tempF}`, register: tempF, type: IRType5.Number, isCaptured: false },
+          { name: `fake_path_temp_${tempG}`, register: tempG, type: IRType5.Number, isCaptured: false },
+          { name: `fake_path_pred_${tempP}`, register: tempP, type: IRType5.Boolean, isCaptured: false },
+          { name: `fake_path_cond_${tempQ}`, register: tempQ, type: IRType5.Boolean, isCaptured: false },
+          { name: `fake_path_junk_${junkTemp1}`, register: junkTemp1, type: IRType5.Number, isCaptured: false },
+          { name: `fake_path_junk_${junkTemp2}`, register: junkTemp2, type: IRType5.Number, isCaptured: false },
+          { name: `fake_path_junk_${junkTemp3}`, register: junkTemp3, type: IRType5.Any, isCaptured: false }
+        ];
+        currentFunc = {
+          ...currentFunc,
+          locals: [...currentFunc.locals, ...addedLocals],
+          blocks: newBlocks
+        };
+      }
+      return currentFunc;
+    });
+    return {
+      module: { ...ctx.module, functions: newFunctions, constantPool: newCP },
+      symbolsRenamed: 0,
+      nodesTransformed,
+      diagnostics: []
+    };
+  }
+};
+
+// src/passes/symbol-indirection.ts
+var SymbolIndirectionPass = class {
+  name = "SymbolIndirectionPass";
+  priority = 50;
+  execute(ctx) {
+    let symbolsRenamed = 0;
+    const newFunctions = ctx.module.functions.map((func) => {
+      if (func.isExported) {
+        return func;
+      }
+      if (ctx.profile.reactSafe && func.name.startsWith("use")) {
+        return func;
+      }
+      const newName = `fn_${ctx.rng.identifier(8)}`;
+      symbolsRenamed++;
+      const newLocals = func.locals.map((local) => {
+        symbolsRenamed++;
+        return {
+          ...local,
+          name: `v_${ctx.rng.identifier(6)}`
+        };
+      });
+      return {
+        ...func,
+        name: newName,
+        locals: newLocals
+      };
+    });
+    const newGlobals = ctx.module.globals.map((g) => {
+      if (g.isExported && ctx.profile.preserveExports) return g;
+      symbolsRenamed++;
+      return {
+        ...g,
+        name: `g_${ctx.rng.identifier(8)}`
+      };
+    });
+    const newModule = {
+      ...ctx.module,
+      functions: newFunctions,
+      globals: newGlobals
+    };
+    return {
+      module: newModule,
+      symbolsRenamed,
+      nodesTransformed: 0,
+      diagnostics: []
+    };
+  }
+};
+
+// src/passes/string-pool-encoding.ts
+import { OpCode as OpCode6, ConstantKind as ConstantKind5, OperandKind as OperandKind7, IRType as IRType6 } from "@tsvm/shared";
+var StringPoolEncodingPass = class {
+  name = "StringPoolEncodingPass";
+  priority = 70;
+  execute(ctx) {
+    const config = ctx.profile.transforms.find((t) => t.name === this.name);
+    const fragmentStrings = config?.options?.["fragmentStrings"] ?? true;
+    const minLength = config?.options?.["minLength"] ?? 3;
+    if (!fragmentStrings) {
+      return {
+        module: ctx.module,
+        symbolsRenamed: 0,
+        nodesTransformed: 0,
+        diagnostics: []
+      };
+    }
+    let nextConstantIndex = ctx.module.constantPool.length;
+    const newConstantPool = [...ctx.module.constantPool];
+    const getOrAddStringConstant = (val) => {
+      const existing = newConstantPool.find((c) => c.kind === ConstantKind5.String && c.value === val);
+      if (existing) {
+        return existing.index;
+      }
+      const newIdx = nextConstantIndex++;
+      newConstantPool.push({
+        index: newIdx,
+        kind: ConstantKind5.String,
+        value: val
+      });
+      return newIdx;
+    };
+    const getOrAddNumberConstant = (val) => {
+      const existing = newConstantPool.find((c) => c.kind === ConstantKind5.Number && c.value === val);
+      if (existing) {
+        return existing.index;
+      }
+      const newIdx = nextConstantIndex++;
+      newConstantPool.push({
+        index: newIdx,
+        kind: ConstantKind5.Number,
+        value: val
+      });
+      return newIdx;
+    };
+    let nodesTransformed = 0;
+    const newFunctions = ctx.module.functions.map((fn) => {
+      let nextTempRegId = getMaxRegister(fn);
+      const addedLocals = [];
+      const newBlocks = fn.blocks.map((block) => {
+        const newInstructions = [];
+        block.instructions.forEach((inst) => {
+          if (inst.opcode === OpCode6.LoadConst && inst.operands.length > 0 && inst.result) {
+            const op = inst.operands[0];
+            if (op.kind === OperandKind7.ConstantIndex) {
+              const constIndex = op.value;
+              const constant = ctx.module.constantPool[constIndex];
+              if (constant && constant.kind === ConstantKind5.String && typeof constant.value === "string" && constant.value.length >= minLength) {
+                const fullStr = constant.value;
+                const baseKey = ctx.rng.nextRange(1, 255);
+                const r_arr = `r${nextTempRegId++}`;
+                const r_val = `r${nextTempRegId++}`;
+                const r_key = `r${nextTempRegId++}`;
+                const r_dec = `r${nextTempRegId++}`;
+                const r_idx = `r${nextTempRegId++}`;
+                const r_string_str = `r${nextTempRegId++}`;
+                const r_string = `r${nextTempRegId++}`;
+                const r_from_char_code_str = `r${nextTempRegId++}`;
+                const r_from_char_code = `r${nextTempRegId++}`;
+                addedLocals.push(
+                  { name: `str_pool_temp_${r_arr}`, register: r_arr, type: IRType6.Any, isCaptured: false },
+                  { name: `str_pool_temp_${r_val}`, register: r_val, type: IRType6.Number, isCaptured: false },
+                  { name: `str_pool_temp_${r_key}`, register: r_key, type: IRType6.Number, isCaptured: false },
+                  { name: `str_pool_temp_${r_dec}`, register: r_dec, type: IRType6.Number, isCaptured: false },
+                  { name: `str_pool_temp_${r_idx}`, register: r_idx, type: IRType6.Number, isCaptured: false },
+                  { name: `str_pool_temp_${r_string_str}`, register: r_string_str, type: IRType6.String, isCaptured: false },
+                  { name: `str_pool_temp_${r_string}`, register: r_string, type: IRType6.Any, isCaptured: false },
+                  { name: `str_pool_temp_${r_from_char_code_str}`, register: r_from_char_code_str, type: IRType6.String, isCaptured: false },
+                  { name: `str_pool_temp_${r_from_char_code}`, register: r_from_char_code, type: IRType6.Any, isCaptured: false }
+                );
+                const stringNameIdx = getOrAddStringConstant("String");
+                const fromCharCodeIdx = getOrAddStringConstant("fromCharCode");
+                const stringPoolInsts = [
+                  {
+                    opcode: OpCode6.ArrayNew,
+                    operands: [],
+                    result: r_arr,
+                    sourceLocation: inst.sourceLocation
+                  }
+                ];
+                let prevEncoded = baseKey;
+                for (let i = 0; i < fullStr.length; i++) {
+                  const charKey = (baseKey * (i + 1) ^ prevEncoded ^ i * 37) & 255;
+                  const effectiveKey = charKey === 0 ? 1 : charKey;
+                  const encoded = fullStr.charCodeAt(i) ^ effectiveKey;
+                  prevEncoded = encoded & 255;
+                  const valIdx = getOrAddNumberConstant(encoded);
+                  const keyIdx = getOrAddNumberConstant(effectiveKey);
+                  const idxIdx = getOrAddNumberConstant(i);
+                  stringPoolInsts.push(
+                    {
+                      opcode: OpCode6.LoadConst,
+                      operands: [{ kind: OperandKind7.ConstantIndex, value: valIdx }],
+                      result: r_val,
+                      sourceLocation: inst.sourceLocation
+                    },
+                    {
+                      opcode: OpCode6.LoadConst,
+                      operands: [{ kind: OperandKind7.ConstantIndex, value: keyIdx }],
+                      result: r_key,
+                      sourceLocation: inst.sourceLocation
+                    },
+                    {
+                      opcode: OpCode6.BitXor,
+                      operands: [
+                        { kind: OperandKind7.Register, value: r_val },
+                        { kind: OperandKind7.Register, value: r_key }
+                      ],
+                      result: r_dec,
+                      sourceLocation: inst.sourceLocation
+                    },
+                    {
+                      opcode: OpCode6.LoadConst,
+                      operands: [{ kind: OperandKind7.ConstantIndex, value: idxIdx }],
+                      result: r_idx,
+                      sourceLocation: inst.sourceLocation
+                    },
+                    {
+                      opcode: OpCode6.ComputedSet,
+                      operands: [
+                        { kind: OperandKind7.Register, value: r_arr },
+                        { kind: OperandKind7.Register, value: r_idx },
+                        { kind: OperandKind7.Register, value: r_dec }
+                      ],
+                      sourceLocation: inst.sourceLocation
+                    }
+                  );
+                }
+                stringPoolInsts.push(
+                  {
+                    opcode: OpCode6.LoadConst,
+                    operands: [{ kind: OperandKind7.ConstantIndex, value: stringNameIdx }],
+                    result: r_string_str,
+                    sourceLocation: inst.sourceLocation
+                  },
+                  {
+                    opcode: OpCode6.LoadGlobal,
+                    operands: [{ kind: OperandKind7.Register, value: r_string_str }],
+                    result: r_string,
+                    sourceLocation: inst.sourceLocation
+                  },
+                  {
+                    opcode: OpCode6.LoadConst,
+                    operands: [{ kind: OperandKind7.ConstantIndex, value: fromCharCodeIdx }],
+                    result: r_from_char_code_str,
+                    sourceLocation: inst.sourceLocation
+                  },
+                  {
+                    opcode: OpCode6.PropGet,
+                    operands: [
+                      { kind: OperandKind7.Register, value: r_string },
+                      { kind: OperandKind7.Register, value: r_from_char_code_str }
+                    ],
+                    result: r_from_char_code,
+                    sourceLocation: inst.sourceLocation
+                  },
+                  {
+                    opcode: OpCode6.CallWithArray,
+                    operands: [
+                      { kind: OperandKind7.Register, value: r_from_char_code },
+                      { kind: OperandKind7.Register, value: r_arr }
+                    ],
+                    result: inst.result,
+                    sourceLocation: inst.sourceLocation
+                  }
+                );
+                newInstructions.push(...stringPoolInsts);
+                nodesTransformed++;
+                return;
+              }
+            }
+          }
+          newInstructions.push(inst);
+        });
+        return {
+          ...block,
+          instructions: newInstructions
+        };
+      });
+      return {
+        ...fn,
+        locals: [...fn.locals, ...addedLocals],
+        blocks: newBlocks
+      };
+    });
+    const newModule = {
+      ...ctx.module,
+      constantPool: newConstantPool,
+      functions: newFunctions
+    };
+    return {
+      module: newModule,
+      symbolsRenamed: 0,
+      nodesTransformed,
+      diagnostics: []
+    };
+  }
+};
+
+// src/passes/function-virtualization.ts
+import { FunctionAttribute as FunctionAttribute2 } from "@tsvm/shared";
+var FunctionVirtualizationPass = class {
+  name = "FunctionVirtualizationPass";
+  priority = 80;
+  execute(ctx) {
+    const newModule = {
+      ...ctx.module,
+      functions: ctx.module.functions.map((fn) => {
+        if (fn.attributes.includes(FunctionAttribute2.ReactComponent)) {
+          return { ...fn, isVirtualized: false };
+        }
+        return fn;
+      })
+    };
+    return {
+      module: newModule,
+      symbolsRenamed: 0,
+      nodesTransformed: 0,
+      diagnostics: []
+    };
+  }
+};
+
+// src/passes/dead-code-injection.ts
+import { OpCode as OpCode7, OperandKind as OperandKind8, ConstantKind as ConstantKind6 } from "@tsvm/shared";
+var DeadCodeInjectionPass = class {
+  name = "DeadCodeInjectionPass";
+  priority = 25;
+  execute(ctx) {
+    let nodesTransformed = 0;
+    const newCP = [...ctx.module.constantPool];
+    const newFunctions = ctx.module.functions.map((func) => {
+      if (!func.isVirtualized) return func;
+      let changed = false;
+      const newBlocks = [];
+      const maxReg = getMaxRegister(func) - 1;
+      for (const block of func.blocks) {
+        let currentBlockId = block.id;
+        let currentLabel = block.label;
+        let currentInstructions = [];
+        let currentPredecessors = [...block.predecessors];
+        let isFirstSubBlock = true;
+        for (const inst of block.instructions) {
+          if (ctx.rng.nextFloat() < 0.2) {
+            changed = true;
+            nodesTransformed++;
+            const rStart = maxReg + 5;
+            const junkReg1 = `r${ctx.rng.nextRange(rStart, rStart + 3)}`;
+            const junkReg2 = `r${ctx.rng.nextRange(rStart + 4, rStart + 7)}`;
+            const junkReg3 = `r${ctx.rng.nextRange(rStart + 8, rStart + 11)}`;
+            if (newCP.length === 0) {
+              newCP.push({ index: 0, kind: ConstantKind6.Number, value: 0 });
+            }
+            const cpMax = newCP.length - 1;
+            const randCpIdx = ctx.rng.nextRange(0, cpMax);
+            const patternChoice = ctx.rng.nextRange(0, 3);
+            const deadCodeInsts = [];
+            if (patternChoice === 0) {
+              deadCodeInsts.push({
+                opcode: OpCode7.LoadConst,
+                operands: [{ kind: OperandKind8.ConstantIndex, value: randCpIdx }],
+                result: junkReg1
+              });
+              deadCodeInsts.push({
+                opcode: OpCode7.Move,
+                operands: [
+                  { kind: OperandKind8.Register, value: junkReg1 },
+                  { kind: OperandKind8.Register, value: junkReg2 }
+                ]
+              });
+            } else if (patternChoice === 1) {
+              deadCodeInsts.push({
+                opcode: OpCode7.LoadConst,
+                operands: [{ kind: OperandKind8.ConstantIndex, value: randCpIdx }],
+                result: junkReg1
+              });
+              deadCodeInsts.push({
+                opcode: OpCode7.LoadConst,
+                operands: [{ kind: OperandKind8.ConstantIndex, value: ctx.rng.nextRange(0, cpMax) }],
+                result: junkReg2
+              });
+              const mathOps = [OpCode7.Add, OpCode7.Sub, OpCode7.Mul, OpCode7.BitXor, OpCode7.BitAnd];
+              const randomOp = mathOps[ctx.rng.nextRange(0, mathOps.length - 1)];
+              deadCodeInsts.push({
+                opcode: randomOp,
+                operands: [
+                  { kind: OperandKind8.Register, value: junkReg1 },
+                  { kind: OperandKind8.Register, value: junkReg2 }
+                ],
+                result: junkReg3
+              });
+            } else if (patternChoice === 2) {
+              deadCodeInsts.push({
+                opcode: OpCode7.LoadConst,
+                operands: [{ kind: OperandKind8.ConstantIndex, value: randCpIdx }],
+                result: junkReg1
+              });
+              deadCodeInsts.push({
+                opcode: OpCode7.Move,
+                operands: [
+                  { kind: OperandKind8.Register, value: junkReg1 },
+                  { kind: OperandKind8.Register, value: junkReg2 }
+                ]
+              });
+              deadCodeInsts.push({
+                opcode: OpCode7.TypeOf,
+                operands: [{ kind: OperandKind8.Register, value: junkReg2 }],
+                result: junkReg3
+              });
+              deadCodeInsts.push({
+                opcode: OpCode7.Move,
+                operands: [
+                  { kind: OperandKind8.Register, value: junkReg3 },
+                  { kind: OperandKind8.Register, value: junkReg1 }
+                ]
+              });
+            } else {
+              deadCodeInsts.push({
+                opcode: OpCode7.LoadConst,
+                operands: [{ kind: OperandKind8.ConstantIndex, value: randCpIdx }],
+                result: junkReg1
+              });
+              deadCodeInsts.push({
+                opcode: OpCode7.LoadConst,
+                operands: [{ kind: OperandKind8.ConstantIndex, value: ctx.rng.nextRange(0, cpMax) }],
+                result: junkReg2
+              });
+              const compOps = [OpCode7.Lt, OpCode7.Gt, OpCode7.Eq, OpCode7.StrictEq, OpCode7.LtEq, OpCode7.GtEq];
+              const compOp = compOps[ctx.rng.nextRange(0, compOps.length - 1)];
+              deadCodeInsts.push({
+                opcode: compOp,
+                operands: [
+                  { kind: OperandKind8.Register, value: junkReg1 },
+                  { kind: OperandKind8.Register, value: junkReg2 }
+                ],
+                result: junkReg3
+              });
+            }
+            if (ctx.rng.nextFloat() < 0.1) {
+              let zeroIdx = newCP.findIndex((cp) => cp.kind === ConstantKind6.Number && cp.value === 0);
+              if (zeroIdx === -1) {
+                zeroIdx = newCP.length;
+                newCP.push({ index: zeroIdx, kind: ConstantKind6.Number, value: 0 });
+              }
+              const randIdx = ctx.rng.nextRange(0, cpMax);
+              const condReg = `r${maxReg + 12}`;
+              currentInstructions.push({
+                opcode: OpCode7.LoadConst,
+                operands: [{ kind: OperandKind8.ConstantIndex, value: randIdx }],
+                result: junkReg1
+              });
+              currentInstructions.push({
+                opcode: OpCode7.Mul,
+                operands: [
+                  { kind: OperandKind8.Register, value: junkReg1 },
+                  { kind: OperandKind8.Register, value: junkReg1 }
+                ],
+                result: junkReg2
+              });
+              currentInstructions.push({
+                opcode: OpCode7.LoadConst,
+                operands: [{ kind: OperandKind8.ConstantIndex, value: zeroIdx }],
+                result: junkReg3
+              });
+              currentInstructions.push({
+                opcode: OpCode7.Lt,
+                operands: [
+                  { kind: OperandKind8.Register, value: junkReg2 },
+                  { kind: OperandKind8.Register, value: junkReg3 }
+                ],
+                result: condReg
+              });
+              const deadBlockId = `__dci_opaque_dead_${ctx.rng.identifier(6)}`;
+              const nextBlockId = `__dci_opaque_next_${ctx.rng.identifier(6)}`;
+              newBlocks.push({
+                id: currentBlockId,
+                label: currentLabel,
+                instructions: currentInstructions,
+                terminator: {
+                  kind: "branch",
+                  targets: [deadBlockId, nextBlockId],
+                  condition: condReg
+                },
+                predecessors: currentPredecessors,
+                successors: [deadBlockId, nextBlockId],
+                phiNodes: isFirstSubBlock ? block.phiNodes : []
+              });
+              isFirstSubBlock = false;
+              newBlocks.push({
+                id: deadBlockId,
+                label: "opaque_dead",
+                instructions: deadCodeInsts,
+                terminator: { kind: "jump", targets: [nextBlockId] },
+                predecessors: [currentBlockId],
+                successors: [nextBlockId],
+                phiNodes: []
+              });
+              const origBlockId = currentBlockId;
+              currentBlockId = nextBlockId;
+              currentLabel = `${currentLabel}_opaque`;
+              currentInstructions = [];
+              currentPredecessors = [origBlockId, deadBlockId];
+            } else {
+              currentInstructions.push(...deadCodeInsts);
+            }
+          }
+          currentInstructions.push(inst);
+        }
+        newBlocks.push({
+          id: currentBlockId,
+          label: currentLabel,
+          instructions: currentInstructions,
+          terminator: block.terminator,
+          predecessors: currentPredecessors,
+          successors: block.successors,
+          phiNodes: isFirstSubBlock ? block.phiNodes : []
+        });
+      }
+      return changed ? { ...func, blocks: newBlocks } : func;
+    });
+    return {
+      module: { ...ctx.module, functions: newFunctions, constantPool: newCP },
+      symbolsRenamed: 0,
+      nodesTransformed,
+      diagnostics: []
+    };
+  }
+};
+
+// src/passes/control-flow-flattening.ts
+import { OpCode as OpCode8, OperandKind as OperandKind9, ConstantKind as ConstantKind7 } from "@tsvm/shared";
+var ControlFlowFlatteningPass = class {
+  name = "ControlFlowFlatteningPass";
+  priority = 26;
+  execute(ctx) {
+    let nodesTransformed = 0;
+    const constantPool = [...ctx.module.constantPool];
+    const newFunctions = ctx.module.functions.map((func) => {
+      if (!func.isVirtualized || func.blocks.length < 3) return func;
+      const hasTryCatch = func.blocks.some(
+        (block) => block.instructions.some((inst) => inst.opcode === OpCode8.TryCatchBegin || inst.opcode === OpCode8.TryCatchEnd)
+      );
+      if (hasTryCatch) return func;
+      if (ctx.rng.nextFloat() < 0.4) return func;
+      nodesTransformed++;
+      const stateMap = /* @__PURE__ */ new Map();
+      const blockOrder = ctx.rng.shuffle([...func.blocks]);
+      for (const block of func.blocks) {
+        stateMap.set(block.id, ctx.rng.nextRange(1e3, 2147483647));
+      }
+      const maxReg = getMaxRegister(func) - 1;
+      const stateReg = `r${maxReg + 1}`;
+      const tempReg = `r${maxReg + 2}`;
+      const tableReg = `r${maxReg + 3}`;
+      const primeReg = `r${maxReg + 4}`;
+      const sizeReg = `r${maxReg + 5}`;
+      const mulReg = `r${maxReg + 6}`;
+      const idxReg = `r${maxReg + 7}`;
+      const targetReg = `r${maxReg + 8}`;
+      const constIdxReg = `r${maxReg + 9}`;
+      const constLblReg = `r${maxReg + 10}`;
+      const stateConstants = /* @__PURE__ */ new Map();
+      for (const [blockId, stateId] of stateMap) {
+        const cpIdx = constantPool.length;
+        constantPool.push({ index: cpIdx, kind: ConstantKind7.Number, value: stateId });
+        stateConstants.set(stateId, cpIdx);
+      }
+      const getOrAddNumberConstant = (val) => {
+        let idx = constantPool.findIndex((c) => c.kind === ConstantKind7.Number && c.value === val);
+        if (idx === -1) {
+          idx = constantPool.length;
+          constantPool.push({ index: idx, kind: ConstantKind7.Number, value: val });
+        }
+        return idx;
+      };
+      const dispatcherId = `__cff_dispatch_${ctx.rng.identifier(6)}`;
+      const exitId = `__cff_exit_${ctx.rng.identifier(4)}`;
+      const entryStateId = stateMap.get(func.blocks[0].id);
+      const caseBlocks = [];
+      for (const block of blockOrder) {
+        const stateId = stateMap.get(block.id);
+        const caseLabelId = `__cff_case_${block.id}_${ctx.rng.identifier(4)}`;
+        const caseInstructions = [...block.instructions];
+        let caseTerminator;
+        if (block.terminator.kind === "return" || block.terminator.kind === "throw") {
+          caseTerminator = block.terminator;
+        } else if (block.terminator.kind === "jump") {
+          const targetState = stateMap.get(block.terminator.targets[0]);
+          caseInstructions.push({
+            opcode: OpCode8.LoadConst,
+            operands: [{ kind: OperandKind9.ConstantIndex, value: stateConstants.get(targetState) }],
+            result: stateReg
+          });
+          caseTerminator = { kind: "jump", targets: [dispatcherId] };
+        } else if (block.terminator.kind === "branch") {
+          const trueState = stateMap.get(block.terminator.targets[0]);
+          const falseState = stateMap.get(block.terminator.targets[1]);
+          const trueBlockId = `__cff_br_t_${ctx.rng.identifier(4)}`;
+          const falseBlockId = `__cff_br_f_${ctx.rng.identifier(4)}`;
+          caseBlocks.push({
+            id: trueBlockId,
+            label: "cff_br_true",
+            instructions: [
+              {
+                opcode: OpCode8.LoadConst,
+                operands: [{ kind: OperandKind9.ConstantIndex, value: stateConstants.get(trueState) }],
+                result: stateReg
+              }
+            ],
+            terminator: { kind: "jump", targets: [dispatcherId] },
+            predecessors: [caseLabelId],
+            successors: [dispatcherId],
+            phiNodes: []
+          });
+          caseBlocks.push({
+            id: falseBlockId,
+            label: "cff_br_false",
+            instructions: [
+              {
+                opcode: OpCode8.LoadConst,
+                operands: [{ kind: OperandKind9.ConstantIndex, value: stateConstants.get(falseState) }],
+                result: stateReg
+              }
+            ],
+            terminator: { kind: "jump", targets: [dispatcherId] },
+            predecessors: [caseLabelId],
+            successors: [dispatcherId],
+            phiNodes: []
+          });
+          caseTerminator = {
+            kind: "branch",
+            targets: [trueBlockId, falseBlockId],
+            condition: block.terminator.condition
+          };
+        } else {
+          caseTerminator = block.terminator;
+        }
+        caseBlocks.push({
+          id: caseLabelId,
+          label: `cff_case_${block.id}`,
+          instructions: caseInstructions,
+          terminator: caseTerminator,
+          predecessors: [dispatcherId],
+          successors: caseTerminator.targets || [],
+          phiNodes: block.phiNodes || []
+        });
+      }
+      const orderedCases = [...caseBlocks.filter((b) => b.label?.startsWith("cff_case_"))];
+      let tableSize = 1;
+      while (tableSize < orderedCases.length) {
+        tableSize *= 2;
+      }
+      const primes = [
+        31,
+        37,
+        41,
+        43,
+        47,
+        53,
+        59,
+        61,
+        67,
+        71,
+        73,
+        79,
+        83,
+        89,
+        97,
+        101,
+        103,
+        107,
+        109,
+        113,
+        127,
+        131,
+        137,
+        139,
+        149,
+        151,
+        157,
+        163,
+        167,
+        173,
+        179,
+        181,
+        191,
+        193,
+        197,
+        199,
+        211,
+        223,
+        227,
+        229,
+        233,
+        239,
+        241,
+        251,
+        257,
+        263,
+        269,
+        271,
+        277,
+        281,
+        283,
+        293,
+        307,
+        311,
+        313,
+        317,
+        331,
+        337,
+        347,
+        349,
+        353,
+        359,
+        367,
+        373,
+        379,
+        383,
+        389,
+        397
+      ];
+      let selectedPrime = 31;
+      let collisionFree = false;
+      while (!collisionFree) {
+        for (const prime of primes) {
+          const seen = /* @__PURE__ */ new Set();
+          let collision = false;
+          for (const block of orderedCases) {
+            const stateId = stateMap.get(block.label.replace("cff_case_", ""));
+            const idx = stateId * prime % tableSize;
+            if (seen.has(idx)) {
+              collision = true;
+              break;
+            }
+            seen.add(idx);
+          }
+          if (!collision) {
+            selectedPrime = prime;
+            collisionFree = true;
+            break;
+          }
+        }
+        if (!collisionFree) {
+          tableSize *= 2;
+        }
+      }
+      const tableSlots = /* @__PURE__ */ new Map();
+      for (const caseBlock of orderedCases) {
+        const stateId = stateMap.get(caseBlock.label.replace("cff_case_", ""));
+        const slotIdx = stateId * selectedPrime % tableSize;
+        tableSlots.set(slotIdx, caseBlock.id);
+      }
+      const entryBlockId = `__cff_entry_${ctx.rng.identifier(4)}`;
+      const entryBlockInstructions = [
+        {
+          opcode: OpCode8.LoadConst,
+          operands: [{ kind: OperandKind9.ConstantIndex, value: stateConstants.get(entryStateId) }],
+          result: stateReg
+        },
+        // Initialize jump table array
+        {
+          opcode: OpCode8.ArrayNew,
+          operands: [],
+          result: tableReg
+        }
+      ];
+      for (let i = 0; i < tableSize; i++) {
+        const targetBlockId = tableSlots.get(i) || exitId;
+        const valIdx = getOrAddNumberConstant(i);
+        entryBlockInstructions.push(
+          {
+            opcode: OpCode8.LoadConst,
+            operands: [{ kind: OperandKind9.BlockLabel, value: targetBlockId }],
+            result: constLblReg
+          },
+          {
+            opcode: OpCode8.LoadConst,
+            operands: [{ kind: OperandKind9.ConstantIndex, value: valIdx }],
+            result: constIdxReg
+          },
+          {
+            opcode: OpCode8.ComputedSet,
+            operands: [
+              { kind: OperandKind9.Register, value: tableReg },
+              { kind: OperandKind9.Register, value: constIdxReg },
+              { kind: OperandKind9.Register, value: constLblReg }
+            ]
+          }
+        );
+      }
+      const entryBlock = {
+        id: entryBlockId,
+        label: "cff_entry",
+        instructions: entryBlockInstructions,
+        terminator: { kind: "jump", targets: [dispatcherId] },
+        predecessors: [],
+        successors: [dispatcherId],
+        phiNodes: []
+      };
+      const dispatcherBlock = {
+        id: dispatcherId,
+        label: "cff_dispatcher",
+        instructions: [
+          // 1. Load prime
+          {
+            opcode: OpCode8.LoadConst,
+            operands: [{ kind: OperandKind9.ConstantIndex, value: getOrAddNumberConstant(selectedPrime) }],
+            result: primeReg
+          },
+          // 2. Mul: stateReg * primeReg
+          {
+            opcode: OpCode8.Mul,
+            operands: [
+              { kind: OperandKind9.Register, value: stateReg },
+              { kind: OperandKind9.Register, value: primeReg }
+            ],
+            result: mulReg
+          },
+          // 3. Load table size
+          {
+            opcode: OpCode8.LoadConst,
+            operands: [{ kind: OperandKind9.ConstantIndex, value: getOrAddNumberConstant(tableSize) }],
+            result: sizeReg
+          },
+          // 4. Mod: mulReg % sizeReg
+          {
+            opcode: OpCode8.Mod,
+            operands: [
+              { kind: OperandKind9.Register, value: mulReg },
+              { kind: OperandKind9.Register, value: sizeReg }
+            ],
+            result: idxReg
+          },
+          // 5. ComputedGet: tableReg[idxReg] -> targetReg
+          {
+            opcode: OpCode8.ComputedGet,
+            operands: [
+              { kind: OperandKind9.Register, value: tableReg },
+              { kind: OperandKind9.Register, value: idxReg }
+            ],
+            result: targetReg
+          },
+          // 6. Jmp targetReg
+          {
+            opcode: OpCode8.Jmp,
+            operands: [{ kind: OperandKind9.Register, value: targetReg }]
+          }
+        ],
+        terminator: { kind: "dynamic_jmp", targets: [] },
+        predecessors: [entryBlockId, ...caseBlocks.map((b) => b.id)],
+        successors: [],
+        phiNodes: []
+      };
+      const decoyBlocks = [];
+      for (let i = 0; i < 2; i++) {
+        const decoyCmpBlockId = `__cff_decoy_cmp_${i}_${ctx.rng.identifier(4)}`;
+        const decoyCaseBlockId = `__cff_decoy_case_${i}_${ctx.rng.identifier(4)}`;
+        const decoyNextBlockId = i === 0 ? `__cff_decoy_cmp_1_${ctx.rng.identifier(4)}` : exitId;
+        const decoyStateId = ctx.rng.nextRange(1e3, 2147483647);
+        const decoyStateIdx = getOrAddNumberConstant(decoyStateId);
+        decoyBlocks.push(
+          {
+            id: decoyCmpBlockId,
+            label: `cff_decoy_cmp_${i}`,
+            instructions: [
+              {
+                opcode: OpCode8.LoadConst,
+                operands: [{ kind: OperandKind9.ConstantIndex, value: decoyStateIdx }],
+                result: tempReg
+              },
+              {
+                opcode: OpCode8.Eq,
+                operands: [
+                  { kind: OperandKind9.Register, value: stateReg },
+                  { kind: OperandKind9.Register, value: tempReg }
+                ],
+                result: tempReg
+              }
+            ],
+            terminator: {
+              kind: "branch",
+              targets: [decoyCaseBlockId, decoyNextBlockId],
+              condition: tempReg
+            },
+            predecessors: [],
+            successors: [decoyCaseBlockId, decoyNextBlockId],
+            phiNodes: []
+          },
+          {
+            id: decoyCaseBlockId,
+            label: `cff_decoy_case_${i}`,
+            instructions: [
+              {
+                opcode: OpCode8.LoadConst,
+                operands: [{ kind: OperandKind9.ConstantIndex, value: decoyStateIdx }],
+                result: stateReg
+              }
+            ],
+            terminator: {
+              kind: "jump",
+              targets: [dispatcherId]
+            },
+            predecessors: [decoyCmpBlockId],
+            successors: [dispatcherId],
+            phiNodes: []
+          }
+        );
+      }
+      const exitBlock = {
+        id: exitId,
+        label: "cff_exit",
+        instructions: [],
+        terminator: { kind: "return", targets: [] },
+        predecessors: [],
+        successors: [],
+        phiNodes: []
+      };
+      const allBlocks = ctx.rng.shuffle([entryBlock, dispatcherBlock, ...decoyBlocks, ...caseBlocks, exitBlock]);
+      const entryIdx = allBlocks.findIndex((b) => b.id === entryBlockId);
+      if (entryIdx > 0) {
+        [allBlocks[0], allBlocks[entryIdx]] = [allBlocks[entryIdx], allBlocks[0]];
+      }
+      return { ...func, blocks: allBlocks };
+    });
+    return {
+      module: { ...ctx.module, functions: newFunctions, constantPool },
+      symbolsRenamed: 0,
+      nodesTransformed,
+      diagnostics: []
+    };
+  }
+};
+
+// src/passes/strip-debug.ts
+import { OpCode as OpCode9, ConstantKind as ConstantKind8 } from "@tsvm/shared";
+var StripDebugPass = class {
+  name = "StripDebugPass";
+  priority = 5;
+  // Run very early
+  execute(ctx) {
+    let nodesTransformed = 0;
+    const newFunctions = ctx.module.functions.map((func) => {
+      if (!func.isVirtualized) return func;
+      let changed = false;
+      const newBlocks = func.blocks.map((block) => {
+        const stringRegs = /* @__PURE__ */ new Map();
+        const globalRegs = /* @__PURE__ */ new Map();
+        const newInstructions = [];
+        for (const inst of block.instructions) {
+          if (inst.opcode === OpCode9.LoadConst) {
+            const cpIdx = inst.operands[0].value;
+            const cpEntry = ctx.module.constantPool.find((c) => c.index === cpIdx);
+            if (cpEntry && cpEntry.kind === ConstantKind8.String) {
+              stringRegs.set(inst.result, cpEntry.value);
+            }
+          } else if (inst.opcode === OpCode9.LoadGlobal) {
+            const propReg = inst.operands[0].value;
+            const propName = stringRegs.get(propReg);
+            if (propName) {
+              globalRegs.set(inst.result, propName);
+            }
+          } else if (inst.opcode === OpCode9.CallMethod) {
+            const objReg = inst.operands[0].value;
+            if (globalRegs.get(objReg) === "console") {
+              changed = true;
+              nodesTransformed++;
+              if (inst.result) {
+                newInstructions.push({
+                  ...inst,
+                  opcode: OpCode9.Nop,
+                  operands: [],
+                  result: void 0
+                  // drop result
+                });
+              } else {
+                newInstructions.push({ ...inst, opcode: OpCode9.Nop, operands: [] });
+              }
+              continue;
+            }
+          }
+          newInstructions.push(inst);
+        }
+        return changed ? { ...block, instructions: newInstructions } : block;
+      });
+      return changed ? { ...func, blocks: newBlocks } : func;
+    });
+    return {
+      module: { ...ctx.module, functions: newFunctions },
+      symbolsRenamed: 0,
+      nodesTransformed,
+      diagnostics: []
+    };
+  }
+};
+
+// src/passes/ir-validation.ts
+import { DiagnosticSeverity, OperandKind as OperandKind10 } from "@tsvm/shared";
+function registerValue(val) {
+  if (typeof val === "string" && /^r\d+$/.test(val)) return val;
+  return void 0;
+}
+var IRValidationPass = class {
+  name = "IRValidationPass";
+  priority = 999;
+  execute(ctx) {
+    const diagnostics = [];
+    let nodesTransformed = 0;
+    for (const func of ctx.module.functions) {
+      if (func.isVirtualized) {
+        const fnDiagnostics = this.validateFunction(func, ctx.module);
+        diagnostics.push(...fnDiagnostics);
+        nodesTransformed += fnDiagnostics.length;
+      }
+    }
+    return {
+      module: ctx.module,
+      symbolsRenamed: 0,
+      nodesTransformed,
+      diagnostics
+    };
+  }
+  validateFunction(func, module) {
+    const diagnostics = [];
+    const blockIds = new Set(func.blocks.map((b) => b.id));
+    const blockMap = new Map(func.blocks.map((b) => [b.id, b]));
+    const maxReg = getMaxRegister(func);
+    for (const block of func.blocks) {
+      for (const pred of block.predecessors) {
+        if (!blockIds.has(pred)) {
+          diagnostics.push({
+            severity: DiagnosticSeverity.Warning,
+            code: "IR_INVALID_PREDECESSOR",
+            message: `Block "${block.id}" has non-existent predecessor "${pred}"`
+          });
+        }
+      }
+      for (const succ of block.successors) {
+        if (!blockIds.has(succ)) {
+          diagnostics.push({
+            severity: DiagnosticSeverity.Warning,
+            code: "IR_INVALID_SUCCESSOR",
+            message: `Block "${block.id}" has non-existent successor "${succ}"`
+          });
+        }
+      }
+      for (const target of block.terminator.targets) {
+        if (!blockIds.has(target)) {
+          diagnostics.push({
+            severity: DiagnosticSeverity.Warning,
+            code: "IR_INVALID_TARGET",
+            message: `Block "${block.id}" references non-existent target block "${target}"`
+          });
+        }
+      }
+      for (const phi of block.phiNodes ?? []) {
+        const regPhi = registerValue(phi.result);
+        if (regPhi) {
+          const idx = Number.parseInt(regPhi.substring(1), 10);
+          if (idx >= maxReg) {
+            diagnostics.push({
+              severity: DiagnosticSeverity.Warning,
+              code: "IR_PHI_REGISTER_BOUNDS",
+              message: `Phi node result "${phi.result}" exceeds max register ${maxReg - 1} in function "${func.name}"`
+            });
+          }
+        }
+        for (const inc of phi.incoming) {
+          if (!blockIds.has(inc.blockId)) {
+            diagnostics.push({
+              severity: DiagnosticSeverity.Warning,
+              code: "IR_INVALID_PHI_BLOCK",
+              message: `Phi node in "${block.id}" references non-existent incoming block "${inc.blockId}"`
+            });
+          }
+          const regInc = registerValue(inc.register);
+          if (regInc) {
+            const idx = Number.parseInt(regInc.substring(1), 10);
+            if (idx >= maxReg) {
+              diagnostics.push({
+                severity: DiagnosticSeverity.Warning,
+                code: "IR_PHI_REGISTER_BOUNDS",
+                message: `Phi node incoming register "${inc.register}" exceeds max register ${maxReg - 1} in function "${func.name}"`
+              });
+            }
+          }
+        }
+      }
+      for (const inst of block.instructions) {
+        const regResult = registerValue(inst.result);
+        if (regResult) {
+          const idx = Number.parseInt(regResult.substring(1), 10);
+          if (idx >= maxReg) {
+            diagnostics.push({
+              severity: DiagnosticSeverity.Warning,
+              code: "IR_INSTRUCTION_REGISTER_BOUNDS",
+              message: `Instruction result "${inst.result}" exceeds max register ${maxReg - 1} in function "${func.name}"`
+            });
+          }
+        }
+        for (const op of inst.operands) {
+          if (op.kind === OperandKind10.Register) {
+            const regVal = registerValue(op.value);
+            if (regVal) {
+              const idx = Number.parseInt(regVal.substring(1), 10);
+              if (idx >= maxReg) {
+                diagnostics.push({
+                  severity: DiagnosticSeverity.Warning,
+                  code: "IR_OPERAND_REGISTER_BOUNDS",
+                  message: `Operand "${op.value}" exceeds max register ${maxReg - 1} in function "${func.name}"`
+                });
+              }
+            }
+          }
+        }
+      }
+      const regCond = registerValue(block.terminator.condition);
+      if (regCond) {
+        const idx = Number.parseInt(regCond.substring(1), 10);
+        if (idx >= maxReg) {
+          diagnostics.push({
+            severity: DiagnosticSeverity.Warning,
+            code: "IR_TERMINATOR_REGISTER_BOUNDS",
+            message: `Terminator condition "${block.terminator.condition}" exceeds max register ${maxReg - 1} in function "${func.name}"`
+          });
+        }
+      }
+      const regRet = registerValue(block.terminator.returnValue);
+      if (regRet) {
+        const idx = Number.parseInt(regRet.substring(1), 10);
+        if (idx >= maxReg) {
+          diagnostics.push({
+            severity: DiagnosticSeverity.Warning,
+            code: "IR_TERMINATOR_REGISTER_BOUNDS",
+            message: `Terminator returnValue "${block.terminator.returnValue}" exceeds max register ${maxReg - 1} in function "${func.name}"`
+          });
+        }
+      }
+    }
+    for (const block of func.blocks) {
+      for (const succ of block.successors) {
+        const succBlock = blockMap.get(succ);
+        if (succBlock && !succBlock.predecessors.includes(block.id)) {
+          diagnostics.push({
+            severity: DiagnosticSeverity.Warning,
+            code: "IR_INCONSISTENT_EDGE",
+            message: `Block "${block.id}" lists "${succ}" as successor but "${succ}" does not list it as predecessor`
+          });
+        }
+      }
+      for (const pred of block.predecessors) {
+        const predBlock = blockMap.get(pred);
+        if (predBlock && !predBlock.successors.includes(block.id)) {
+          diagnostics.push({
+            severity: DiagnosticSeverity.Warning,
+            code: "IR_INCONSISTENT_EDGE",
+            message: `Block "${block.id}" lists "${pred}" as predecessor but "${pred}" does not list it as successor`
+          });
+        }
+      }
+    }
+    return diagnostics;
+  }
+};
+
+// src/passes/register-compacting.ts
+import { OperandKind as OperandKind11 } from "@tsvm/shared";
+function collectUsedRegisters(func) {
+  const regs = /* @__PURE__ */ new Set();
+  const add = (val) => {
+    if (!val) return;
+    const m = /^r(\d+)$/.exec(val);
+    if (m) regs.add(Number.parseInt(m[1], 10));
+  };
+  for (const param of func.params) add(param.register);
+  for (const local of func.locals) add(local.register);
+  for (const block of func.blocks) {
+    for (const phi of block.phiNodes ?? []) {
+      add(phi.result);
+      for (const inc of phi.incoming) add(inc.register);
+    }
+    for (const inst of block.instructions) {
+      add(inst.result);
+      for (const op of inst.operands) {
+        if (op.kind === OperandKind11.Register) add(op.value);
+      }
+    }
+    add(block.terminator.condition);
+    add(block.terminator.returnValue);
+  }
+  return regs;
+}
+function buildCompactMap(usedRegs) {
+  const sorted = Array.from(usedRegs).sort((a, b) => a - b);
+  let hasGap = false;
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < sorted.length; i++) {
+    const oldReg = sorted[i];
+    if (oldReg !== i) hasGap = true;
+    map.set(`r${oldReg}`, `r${i}`);
+  }
+  return hasGap ? map : null;
+}
+function mapReg(val, map) {
+  if (!val) return void 0;
+  return map.get(val) ?? val;
+}
+function mapOperandValue(val, map) {
+  if (typeof val === "string") return map.get(val) ?? val;
+  return val;
+}
+var RegisterCompactingPass = class {
+  name = "RegisterCompactingPass";
+  priority = 90;
+  execute(ctx) {
+    const newFunctions = ctx.module.functions.map((func) => {
+      if (!func.isVirtualized) return func;
+      const usedRegs = collectUsedRegisters(func);
+      const compactMap = buildCompactMap(usedRegs);
+      if (!compactMap) return func;
+      return this.rewriteRegisters(func, compactMap);
+    });
+    return {
+      module: { ...ctx.module, functions: newFunctions },
+      symbolsRenamed: 0,
+      nodesTransformed: newFunctions.filter((f, i) => f !== ctx.module.functions[i]).length,
+      diagnostics: []
+    };
+  }
+  rewriteRegisters(func, map) {
+    return {
+      ...func,
+      params: func.params.map((p) => ({
+        ...p,
+        register: mapReg(p.register, map)
+      })),
+      locals: func.locals.map((l) => ({
+        ...l,
+        register: mapReg(l.register, map)
+      })),
+      blocks: func.blocks.map((block) => ({
+        ...block,
+        phiNodes: (block.phiNodes ?? []).map((phi) => ({
+          ...phi,
+          result: mapReg(phi.result, map),
+          incoming: phi.incoming.map((inc) => ({
+            ...inc,
+            register: mapReg(inc.register, map)
+          }))
+        })),
+        instructions: block.instructions.map((inst) => ({
+          ...inst,
+          result: mapReg(inst.result, map),
+          operands: inst.operands.map((op) => ({
+            ...op,
+            value: op.kind === OperandKind11.Register ? mapOperandValue(op.value, map) : op.value
+          }))
+        })),
+        terminator: {
+          ...block.terminator,
+          condition: mapReg(block.terminator.condition, map),
+          returnValue: mapReg(block.terminator.returnValue, map)
+        }
+      }))
+    };
+  }
+};
+
+// src/passes/instruction-substitution.ts
+import { OpCode as OpCode10, OperandKind as OperandKind12, ConstantKind as ConstantKind9, IRType as IRType7 } from "@tsvm/shared";
+function inferRegisterTypes(blocks, params, locals, constantPool) {
+  const types = /* @__PURE__ */ new Map();
+  for (const param of params) {
+    types.set(param.register, param.type);
+  }
+  for (const local of locals) {
+    types.set(local.register, local.type);
+  }
+  const getConstantType = (idx) => {
+    const entry = constantPool[idx];
+    if (!entry) return IRType7.Any;
+    switch (entry.kind) {
+      case ConstantKind9.Number:
+        return IRType7.Number;
+      case ConstantKind9.String:
+      case ConstantKind9.Template:
+        return IRType7.String;
+      case ConstantKind9.Boolean:
+        return IRType7.Boolean;
+      case ConstantKind9.Null:
+        return IRType7.Null;
+      case ConstantKind9.Undefined:
+        return IRType7.Undefined;
+      case ConstantKind9.BigInt:
+        return IRType7.BigInt;
+      default:
+        return IRType7.Any;
+    }
+  };
+  const getOperandType = (op) => {
+    if (op.kind === OperandKind12.Register) {
+      return types.get(op.value) ?? IRType7.Any;
+    }
+    if (op.kind === OperandKind12.ConstantIndex) {
+      return getConstantType(op.value);
+    }
+    return IRType7.Any;
+  };
+  let changed = true;
+  let iterations = 0;
+  while (changed && iterations < 5) {
+    changed = false;
+    for (const block of blocks) {
+      for (const inst of block.instructions) {
+        if (!inst.result) continue;
+        let newType = IRType7.Any;
+        switch (inst.opcode) {
+          case OpCode10.LoadConst: {
+            const op = inst.operands[0];
+            if (op && op.kind === OperandKind12.ConstantIndex) {
+              newType = getConstantType(op.value);
+            }
+            break;
+          }
+          case OpCode10.Move: {
+            const op = inst.operands[0];
+            if (op) {
+              newType = getOperandType(op);
+            }
+            break;
+          }
+          case OpCode10.Add: {
+            const opA = inst.operands[0];
+            const opB = inst.operands[1];
+            if (opA && opB) {
+              const typeA = getOperandType(opA);
+              const typeB = getOperandType(opB);
+              if (typeA === IRType7.Number && typeB === IRType7.Number) {
+                newType = IRType7.Number;
+              } else if (typeA === IRType7.String || typeB === IRType7.String) {
+                newType = IRType7.String;
+              } else {
+                newType = IRType7.Any;
+              }
+            }
+            break;
+          }
+          case OpCode10.Sub:
+          case OpCode10.Mul:
+          case OpCode10.Div:
+          case OpCode10.Mod:
+          case OpCode10.BitAnd:
+          case OpCode10.BitOr:
+          case OpCode10.BitXor:
+          case OpCode10.Shl:
+          case OpCode10.Shr:
+          case OpCode10.UShr:
+          case OpCode10.Neg: {
+            newType = IRType7.Number;
+            break;
+          }
+          case OpCode10.Lt:
+          case OpCode10.Gt:
+          case OpCode10.LtEq:
+          case OpCode10.GtEq:
+          case OpCode10.Eq:
+          case OpCode10.StrictEq:
+          case OpCode10.In:
+          case OpCode10.InstanceOf:
+          case OpCode10.Not: {
+            newType = IRType7.Boolean;
+            break;
+          }
+          case OpCode10.LoadLocal: {
+            const op = inst.operands[0];
+            if (op && op.kind === OperandKind12.Register) {
+              newType = types.get(op.value) ?? IRType7.Any;
+            }
+            break;
+          }
+          default:
+            newType = IRType7.Any;
+            break;
+        }
+        const oldType = types.get(inst.result);
+        if (oldType !== newType) {
+          types.set(inst.result, newType);
+          changed = true;
+        }
+      }
+    }
+    iterations++;
+  }
+  return types;
+}
+var InstructionSubstitutionPass = class {
+  name = "InstructionSubstitutionPass";
+  priority = 20;
+  execute(ctx) {
+    let nodesTransformed = 0;
+    const constantPool = [...ctx.module.constantPool];
+    const getOrAddNumberConstant = (val) => {
+      let idx = constantPool.findIndex((c) => c.kind === ConstantKind9.Number && c.value === val);
+      if (idx === -1) {
+        idx = constantPool.length;
+        constantPool.push({ index: idx, kind: ConstantKind9.Number, value: val });
+      }
+      return idx;
+    };
+    const newFunctions = ctx.module.functions.map((func) => {
+      if (!func.isVirtualized) return func;
+      const regTypes = inferRegisterTypes(func.blocks, func.params, func.locals, constantPool);
+      let nextReg = getMaxRegister(func);
+      let changed = false;
+      const newBlocks = func.blocks.map((block) => {
+        const newInstructions = [];
+        for (const inst of block.instructions) {
+          if (ctx.rng.nextFloat() >= 0.4) {
+            newInstructions.push(inst);
+            continue;
+          }
+          const getOperandType = (op) => {
+            if (op.kind === OperandKind12.Register) {
+              return regTypes.get(op.value) ?? IRType7.Any;
+            }
+            if (op.kind === OperandKind12.ConstantIndex) {
+              const entry = constantPool[op.value];
+              if (entry) {
+                if (entry.kind === ConstantKind9.Number) return IRType7.Number;
+                if (entry.kind === ConstantKind9.String || entry.kind === ConstantKind9.Template) return IRType7.String;
+              }
+            }
+            return IRType7.Any;
+          };
+          if (inst.opcode === OpCode10.Add && inst.operands.length === 2 && inst.result) {
+            const opA = inst.operands[0];
+            const opB = inst.operands[1];
+            const typeA = getOperandType(opA);
+            const typeB = getOperandType(opB);
+            if (typeA === IRType7.Number && typeB === IRType7.Number) {
+              const temp1 = `r${nextReg++}`;
+              const temp2 = `r${nextReg++}`;
+              const tempConst2 = `r${nextReg++}`;
+              const temp3 = `r${nextReg++}`;
+              newInstructions.push(
+                { opcode: OpCode10.BitXor, operands: [opA, opB], result: temp1 },
+                { opcode: OpCode10.BitAnd, operands: [opA, opB], result: temp2 },
+                {
+                  opcode: OpCode10.LoadConst,
+                  operands: [{ kind: OperandKind12.ConstantIndex, value: getOrAddNumberConstant(2) }],
+                  result: tempConst2
+                },
+                {
+                  opcode: OpCode10.Mul,
+                  operands: [
+                    { kind: OperandKind12.Register, value: temp2 },
+                    { kind: OperandKind12.Register, value: tempConst2 }
+                  ],
+                  result: temp3
+                },
+                {
+                  opcode: OpCode10.Add,
+                  operands: [
+                    { kind: OperandKind12.Register, value: temp1 },
+                    { kind: OperandKind12.Register, value: temp3 }
+                  ],
+                  result: inst.result
+                }
+              );
+              nodesTransformed++;
+              changed = true;
+            } else {
+              newInstructions.push(inst);
+            }
+          } else if (inst.opcode === OpCode10.BitAnd && inst.operands.length === 2 && inst.result) {
+            const opA = inst.operands[0];
+            const opB = inst.operands[1];
+            const typeA = getOperandType(opA);
+            const typeB = getOperandType(opB);
+            if (typeA === IRType7.Number && typeB === IRType7.Number) {
+              const temp1 = `r${nextReg++}`;
+              const temp2 = `r${nextReg++}`;
+              newInstructions.push(
+                { opcode: OpCode10.BitOr, operands: [opA, opB], result: temp1 },
+                { opcode: OpCode10.BitXor, operands: [opA, opB], result: temp2 },
+                {
+                  opcode: OpCode10.Sub,
+                  operands: [
+                    { kind: OperandKind12.Register, value: temp1 },
+                    { kind: OperandKind12.Register, value: temp2 }
+                  ],
+                  result: inst.result
+                }
+              );
+              nodesTransformed++;
+              changed = true;
+            } else {
+              newInstructions.push(inst);
+            }
+          } else if (inst.opcode === OpCode10.BitOr && inst.operands.length === 2 && inst.result) {
+            const opA = inst.operands[0];
+            const opB = inst.operands[1];
+            const typeA = getOperandType(opA);
+            const typeB = getOperandType(opB);
+            if (typeA === IRType7.Number && typeB === IRType7.Number) {
+              const temp1 = `r${nextReg++}`;
+              const temp2 = `r${nextReg++}`;
+              newInstructions.push(
+                { opcode: OpCode10.BitAnd, operands: [opA, opB], result: temp1 },
+                { opcode: OpCode10.BitXor, operands: [opA, opB], result: temp2 },
+                {
+                  opcode: OpCode10.Add,
+                  operands: [
+                    { kind: OperandKind12.Register, value: temp1 },
+                    { kind: OperandKind12.Register, value: temp2 }
+                  ],
+                  result: inst.result
+                }
+              );
+              nodesTransformed++;
+              changed = true;
+            } else {
+              newInstructions.push(inst);
+            }
+          } else if (inst.opcode === OpCode10.BitXor && inst.operands.length === 2 && inst.result) {
+            const opA = inst.operands[0];
+            const opB = inst.operands[1];
+            const typeA = getOperandType(opA);
+            const typeB = getOperandType(opB);
+            if (typeA === IRType7.Number && typeB === IRType7.Number) {
+              const temp1 = `r${nextReg++}`;
+              const temp2 = `r${nextReg++}`;
+              newInstructions.push(
+                { opcode: OpCode10.BitOr, operands: [opA, opB], result: temp1 },
+                { opcode: OpCode10.BitAnd, operands: [opA, opB], result: temp2 },
+                {
+                  opcode: OpCode10.Sub,
+                  operands: [
+                    { kind: OperandKind12.Register, value: temp1 },
+                    { kind: OperandKind12.Register, value: temp2 }
+                  ],
+                  result: inst.result
+                }
+              );
+              nodesTransformed++;
+              changed = true;
+            } else {
+              newInstructions.push(inst);
+            }
+          } else if (inst.opcode === OpCode10.Neg && inst.operands.length === 1 && inst.result) {
+            const opA = inst.operands[0];
+            const typeA = getOperandType(opA);
+            if (typeA === IRType7.Number) {
+              const tempConstNeg1 = `r${nextReg++}`;
+              newInstructions.push(
+                {
+                  opcode: OpCode10.LoadConst,
+                  operands: [{ kind: OperandKind12.ConstantIndex, value: getOrAddNumberConstant(-1) }],
+                  result: tempConstNeg1
+                },
+                {
+                  opcode: OpCode10.Mul,
+                  operands: [opA, { kind: OperandKind12.Register, value: tempConstNeg1 }],
+                  result: inst.result
+                }
+              );
+              nodesTransformed++;
+              changed = true;
+            } else {
+              newInstructions.push(inst);
+            }
+          } else {
+            newInstructions.push(inst);
+          }
+        }
+        return { ...block, instructions: newInstructions };
+      });
+      if (!changed) return func;
+      const newLocals = [...func.locals];
+      const maxOriginalReg = getMaxRegister(func);
+      for (let reg = maxOriginalReg; reg < nextReg; reg++) {
+        newLocals.push({
+          name: `isub_temp_r${reg}`,
+          register: `r${reg}`,
+          type: IRType7.Any,
+          isCaptured: false
+        });
+      }
+      return { ...func, blocks: newBlocks, locals: newLocals };
+    });
+    return {
+      module: { ...ctx.module, functions: newFunctions, constantPool },
+      symbolsRenamed: 0,
+      nodesTransformed,
+      diagnostics: []
+    };
+  }
+};
+
+// src/registry.ts
+var TransformRegistry = class {
+  passes = /* @__PURE__ */ new Map();
+  constructor(profile) {
+    const availablePasses = {
+      PreserveTypeIllusionsPass,
+      GenericConfusionPass,
+      DecoratorAwareLoweringPass,
+      NamespaceVirtualizationPass,
+      TypeLevelFakePathPass,
+      SymbolIndirectionPass,
+      StringPoolEncodingPass,
+      FunctionVirtualizationPass,
+      DeadCodeInjectionPass,
+      ControlFlowFlatteningPass,
+      StripDebugPass,
+      IRValidationPass,
+      RegisterCompactingPass,
+      InstructionSubstitutionPass
+    };
+    for (const passConfig of profile.transforms) {
+      if (passConfig.enabled && availablePasses[passConfig.name]) {
+        this.addPass(new availablePasses[passConfig.name]());
+      }
+    }
+  }
+  addPass(pass) {
+    this.passes.set(pass.name, pass);
+  }
+  removePass(name) {
+    this.passes.delete(name);
+  }
+  getPass(name) {
+    return this.passes.get(name);
+  }
+  getOrderedPasses() {
+    return Array.from(this.passes.values()).sort((a, b) => a.priority - b.priority);
+  }
+};
+function createTransformRegistry(profile) {
+  return new TransformRegistry(profile);
+}
+export {
+  ControlFlowFlatteningPass,
+  DeadCodeInjectionPass,
+  DecoratorAwareLoweringPass,
+  FunctionVirtualizationPass,
+  GenericConfusionPass,
+  InstructionSubstitutionPass,
+  NamespaceVirtualizationPass,
+  PreserveTypeIllusionsPass,
+  StringPoolEncodingPass,
+  StripDebugPass,
+  SymbolIndirectionPass,
+  TransformRegistry,
+  TypeLevelFakePathPass,
+  createTransformRegistry
+};