@tsvm/bytecode 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { OpcodeMapping, IRModule, VMBuildConfig, BytecodeModule, Instruction, SeededRandom, ConstantPoolEntry, ConstantEncodingScheme, EncodedConstant } from '@tsvm/shared';
+
+declare function generateRemappedOpcodes(seed: number): OpcodeMapping;
+
+declare function compileToBytecode(irModule: IRModule, config: VMBuildConfig): BytecodeModule;
+
+declare function encodeBytecode(instructions: Instruction[], mapping: OpcodeMapping, config: VMBuildConfig, rng?: SeededRandom): Uint8Array;
+declare function encodeConstantPool(constants: readonly ConstantPoolEntry[], scheme: ConstantEncodingScheme, seed: number): EncodedConstant[];
+
+declare function decodeBytecode(bytes: Uint8Array, mapping: OpcodeMapping, config: VMBuildConfig): Instruction[];
+declare function decodeConstantPool(encoded: EncodedConstant[], scheme: ConstantEncodingScheme, seed: number): ConstantPoolEntry[];
+declare function disassemble(module: BytecodeModule): string;
+
+export { compileToBytecode, decodeBytecode, decodeConstantPool, disassemble, encodeBytecode, encodeConstantPool, generateRemappedOpcodes };

package/dist/index.js

@@ -0,0 +1,1021 @@
+// src/opcodes.ts
+import { OpCode, SeededRandom } from "@tsvm/shared";
+function generateRemappedOpcodes(seed) {
+  const forward = /* @__PURE__ */ new Map();
+  const reverse = /* @__PURE__ */ new Map();
+  const rng = new SeededRandom(seed);
+  const opcodes = [];
+  for (const key in OpCode) {
+    if (!Number.isNaN(Number(key))) {
+      opcodes.push(Number(key));
+    }
+  }
+  const availableSlots = [];
+  for (let i = 0; i < 256; i++) {
+    availableSlots.push(i);
+  }
+  rng.shuffle(availableSlots);
+  for (let i = 0; i < opcodes.length; i++) {
+    const canonical = opcodes[i];
+    const slot = availableSlots.pop();
+    const mapped = [slot];
+    reverse.set(slot, canonical);
+    forward.set(canonical, mapped);
+  }
+  while (availableSlots.length > 0) {
+    const slot = availableSlots.pop();
+    const randomOpcode = opcodes[rng.nextRange(0, opcodes.length - 1)];
+    const mapped = forward.get(randomOpcode);
+    mapped.push(slot);
+    reverse.set(slot, randomOpcode);
+  }
+  return { seed, forward, reverse };
+}
+
+// src/compiler.ts
+import { FunctionAttribute, OpCode as OpCode3, OperandKind as OperandKind2, SeededRandom as SeededRandom2 } from "@tsvm/shared";
+
+// src/encoder.ts
+import { ImmediateEncodingScheme, ConstantEncodingScheme, OperandKind, OpCode as OpCode2 } from "@tsvm/shared";
+function isVariableLengthOpcode(opcode) {
+  return opcode === OpCode2.Call || opcode === OpCode2.CallMethod || opcode === OpCode2.New || opcode === OpCode2.ArrayNew || opcode === OpCode2.ObjectNew || opcode === OpCode2.Spread || opcode === OpCode2.SpreadIntoArray || opcode === OpCode2.SuperCall || opcode === OpCode2.SuperInstruction;
+}
+function isTerminator(opcode) {
+  return opcode === OpCode2.Jmp || opcode === OpCode2.JmpIf || opcode === OpCode2.JmpIfNot || opcode === OpCode2.Return || opcode === OpCode2.ReturnVoid || opcode === OpCode2.Throw || opcode === OpCode2.Yield || opcode === OpCode2.YieldStar || opcode === OpCode2.Await || opcode === OpCode2.Halt || opcode === OpCode2.Trap;
+}
+function encodeBytecode(instructions, mapping, config, rng) {
+  const bytes = [];
+  let currentHandlerIdx = 0;
+  for (const inst of instructions) {
+    let mappedOp = inst.mappedOp ?? inst.opcode;
+    if (inst.mappedOp === void 0) {
+      const forward = mapping.forward.get(inst.opcode);
+      if (Array.isArray(forward)) {
+        if (!rng) throw new Error("SeededRandom required when opcodeMap is provided");
+        mappedOp = forward[Math.floor(rng.next() * forward.length)];
+      } else if (forward !== void 0) {
+        mappedOp = forward;
+      }
+    }
+    if (config.stealthDispatch) {
+      const delta = mappedOp - currentHandlerIdx + 256 & 255;
+      bytes.push(delta);
+      currentHandlerIdx = isTerminator(inst.opcode) ? 0 : mappedOp;
+    } else {
+      bytes.push(mappedOp);
+    }
+    if (config.junkInsertion) {
+      const numJunk = (inst.opcode * 7 + config.seed) % 4;
+      for (let j = 0; j < numJunk; j++) {
+        if (!rng) throw new Error("SeededRandom required for junk byte injection");
+        const junk = Math.floor(rng.next() * 256);
+        bytes.push(junk);
+      }
+    }
+    const ops = [...inst.operands || []];
+    if (inst.result) {
+      ops.push({ kind: OperandKind.Register, value: inst.result });
+    }
+    const isVarLength = isVariableLengthOpcode(inst.opcode);
+    if (isVarLength) {
+      bytes.push(ops.length);
+    }
+    for (const op of ops) {
+      const kindNum = operandKindToNum(op.kind);
+      bytes.push(kindNum);
+      let val = 0;
+      if (typeof op.value === "string" && op.value.startsWith("r")) {
+        val = Number.parseInt(op.value.substring(1), 10);
+      } else if (typeof op.value === "number") {
+        val = op.value;
+      }
+      if (config.immediateEncoding === ImmediateEncodingScheme.VariableLength) {
+        let v = val;
+        do {
+          let byte = v & 127;
+          v >>>= 7;
+          if (v !== 0) byte |= 128;
+          bytes.push(byte);
+        } while (v !== 0);
+      } else {
+        const b0 = val & 255;
+        const b1 = val >> 8 & 255;
+        const b2 = val >> 16 & 255;
+        const b3 = val >> 24 & 255;
+        bytes.push(b0, b1, b2, b3);
+      }
+    }
+  }
+  const resultBytes = new Uint8Array(bytes);
+  if (config.rollingKeys) {
+    for (let pc = 0; pc < resultBytes.length; pc++) {
+      const rawVal = resultBytes[pc];
+      const offsetVal = rawVal + pc & 255;
+      const rollingKey = (config.seed ^ pc * 2654435769) >>> 8 & 255;
+      resultBytes[pc] = offsetVal ^ rollingKey;
+    }
+  }
+  return resultBytes;
+}
+function operandKindToNum(kind) {
+  if (typeof kind === "number") return kind;
+  switch (kind) {
+    case OperandKind.Register:
+    case "register":
+      return 0;
+    case OperandKind.Immediate:
+    case "immediate":
+      return 1;
+    case OperandKind.ConstantIndex:
+    case "constant_index":
+      return 2;
+    case OperandKind.BlockLabel:
+    case "block_label":
+      return 3;
+    case OperandKind.FunctionRef:
+    case "function_ref":
+      return 4;
+    default:
+      throw new Error(`Unrecognized operand kind: ${kind}`);
+  }
+}
+function encodeConstantPool(constants, scheme, seed) {
+  return constants.map((c, index) => {
+    if (scheme === ConstantEncodingScheme.XorRotate && typeof c.value === "string") {
+      let stringSeed = (seed ^ index * 2654435769) & 4294967295;
+      if (c.expectedPathHash !== void 0) {
+        stringSeed = (stringSeed ^ c.expectedPathHash) & 4294967295;
+      }
+      const keyBytes = new Uint8Array(16);
+      let s = stringSeed;
+      for (let i = 0; i < 16; i++) {
+        s = Math.imul(s, 1664525) + 1013904223;
+        keyBytes[i] = s >>> 16 & 255;
+      }
+      const S = new Uint8Array(256);
+      for (let i = 0; i < 256; i++) S[i] = i;
+      let j = 0;
+      for (let i = 0; i < 256; i++) {
+        j = j + S[i] + keyBytes[i % 16] & 255;
+        const temp = S[i];
+        S[i] = S[j];
+        S[j] = temp;
+      }
+      let ri = 0;
+      j = 0;
+      for (let skip = 0; skip < 256; skip++) {
+        ri = ri + 1 & 255;
+        j = j + S[ri] & 255;
+        const temp = S[ri];
+        S[ri] = S[j];
+        S[j] = temp;
+      }
+      let encoded = "";
+      for (let i = 0; i < c.value.length; i++) {
+        ri = ri + 1 & 255;
+        j = j + S[ri] & 255;
+        const temp = S[ri];
+        S[ri] = S[j];
+        S[j] = temp;
+        const keystreamByte = S[S[ri] + S[j] & 255];
+        encoded += String.fromCharCode(c.value.charCodeAt(i) ^ keystreamByte);
+      }
+      return { index, kind: c.kind, value: encoded, encodedBytes: new Uint8Array(), decodingKey: 0 };
+    }
+    return { index, kind: c.kind, value: c.value, encodedBytes: new Uint8Array(), decodingKey: 0 };
+  });
+}
+
+// src/compiler.ts
+function collectMaxRegisterIndex(irFn) {
+  let maxRegister = -1;
+  const consider = (value) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    const match = /^r(\d+)$/.exec(value);
+    if (!match) {
+      return;
+    }
+    maxRegister = Math.max(maxRegister, Number.parseInt(match[1], 10));
+  };
+  for (const param of irFn.params) {
+    consider(param.register);
+  }
+  for (const local of irFn.locals) {
+    consider(local.register);
+  }
+  for (const block of irFn.blocks) {
+    if (block.phiNodes) {
+      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 operand of inst.operands) {
+        if (operand.kind === OperandKind2.Register) {
+          consider(operand.value);
+        }
+      }
+    }
+    consider(block.terminator.condition);
+    consider(block.terminator.returnValue);
+  }
+  return maxRegister + 1;
+}
+function computeSourceHash(irModule) {
+  let hash = 2166136261;
+  const update = (val) => {
+    hash ^= val & 255;
+    hash = Math.imul(hash, 16777619);
+  };
+  for (const fn of irModule.functions) {
+    for (const block of fn.blocks) {
+      for (const inst of block.instructions) {
+        update(inst.opcode);
+        for (const op of inst.operands) {
+          if (typeof op.kind === "number") update(op.kind);
+          if (typeof op.value === "number") {
+            update(op.value & 255);
+            update(op.value >> 8 & 255);
+            update(op.value >> 16 & 255);
+            update(op.value >> 24 & 255);
+          }
+        }
+      }
+    }
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function isVariableLengthOpcode2(opcode) {
+  return opcode === 64 || // OpCode.Call
+  opcode === 65 || // OpCode.CallMethod
+  opcode === 66 || // OpCode.New
+  opcode === 84 || // OpCode.ArrayNew
+  opcode === 85 || // OpCode.ObjectNew
+  opcode === 86 || // OpCode.Spread
+  opcode === 87 || // OpCode.SpreadIntoArray
+  opcode === 94 || // OpCode.SuperCall
+  opcode === 254;
+}
+function isTerminator2(opcode) {
+  return opcode === OpCode3.Jmp || opcode === OpCode3.JmpIf || opcode === OpCode3.JmpIfNot || opcode === OpCode3.Return || opcode === OpCode3.ReturnVoid || opcode === OpCode3.Throw || opcode === OpCode3.Yield || opcode === OpCode3.YieldStar || opcode === OpCode3.Await || opcode === OpCode3.Halt || opcode === OpCode3.Trap;
+}
+function fuseInstructions(insts, config) {
+  if (!config.superInstructions) return insts;
+  const rng = new SeededRandom2(config.seed);
+  const ids = rng.shuffle([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  const loadConstMulId = ids[0];
+  const getEntropyMulId = ids[1];
+  const loadConstAddId = ids[2];
+  const fused = [];
+  let i = 0;
+  while (i < insts.length) {
+    const inst1 = insts[i];
+    const inst2 = insts[i + 1];
+    if (inst2) {
+      if (inst1.opcode === OpCode3.LoadConst && inst2.opcode === OpCode3.Mul && inst1.operands[0]?.kind === OperandKind2.ConstantIndex && inst1.result && inst2.result) {
+        let matched = false;
+        let regX;
+        if (inst2.operands[0]?.kind === OperandKind2.Register && inst2.operands[0].value === inst1.result) {
+          regX = inst2.operands[1];
+          matched = true;
+        } else if (inst2.operands[1]?.kind === OperandKind2.Register && inst2.operands[1].value === inst1.result) {
+          regX = inst2.operands[0];
+          matched = true;
+        }
+        if (matched && regX) {
+          fused.push({
+            opcode: OpCode3.SuperInstruction,
+            operands: [
+              { kind: OperandKind2.Immediate, value: loadConstMulId },
+              inst1.operands[0],
+              // constIdx
+              { kind: OperandKind2.Register, value: inst1.result },
+              // regT
+              regX,
+              // regX
+              { kind: OperandKind2.Register, value: inst2.result }
+              // regR
+            ]
+          });
+          i += 2;
+          continue;
+        }
+      }
+      if (inst1.opcode === OpCode3.GetEntropy && inst2.opcode === OpCode3.Mul && inst1.result && inst2.operands[0]?.kind === OperandKind2.Register && inst2.operands[0].value === inst1.result && inst2.operands[1]?.kind === OperandKind2.Register && inst2.operands[1].value === inst1.result && inst2.result) {
+        fused.push({
+          opcode: OpCode3.SuperInstruction,
+          operands: [
+            { kind: OperandKind2.Immediate, value: getEntropyMulId },
+            { kind: OperandKind2.Register, value: inst1.result },
+            // regT
+            { kind: OperandKind2.Register, value: inst2.result }
+            // regR
+          ]
+        });
+        i += 2;
+        continue;
+      }
+      if (inst1.opcode === OpCode3.LoadConst && inst2.opcode === OpCode3.Add && inst1.operands[0]?.kind === OperandKind2.ConstantIndex && inst1.result && inst2.operands[0]?.kind === OperandKind2.Register && inst2.operands[0].value === inst1.result && inst2.operands[1]?.kind === OperandKind2.Register && inst2.result) {
+        fused.push({
+          opcode: OpCode3.SuperInstruction,
+          operands: [
+            { kind: OperandKind2.Immediate, value: loadConstAddId },
+            inst1.operands[0],
+            // constIdx
+            { kind: OperandKind2.Register, value: inst1.result },
+            // regT
+            inst2.operands[1],
+            // regX (second operand)
+            { kind: OperandKind2.Register, value: inst2.result }
+            // regR
+          ]
+        });
+        i += 2;
+        continue;
+      }
+    }
+    fused.push(inst1);
+    i++;
+  }
+  return fused;
+}
+function compileToBytecode(irModule, config) {
+  const mapping = generateRemappedOpcodes(config.seed);
+  const functions = [];
+  const rng = new SeededRandom2(config.seed);
+  const duplicatedCP = [];
+  const tempFunctions = [];
+  for (const irFn of irModule.functions) {
+    if (irFn.isVirtualized) {
+      const paramCount = irFn.params.length;
+      const maxRegs = Math.max(collectMaxRegisterIndex(irFn), paramCount);
+      const regIds = Array.from({ length: maxRegs - paramCount }, (_, i) => i + paramCount);
+      const shuffledRegIds = rng.shuffle([...regIds]);
+      const originalToShuffledReg = /* @__PURE__ */ new Map();
+      regIds.forEach((origId, shuffledIdx) => {
+        originalToShuffledReg.set(origId, shuffledRegIds[shuffledIdx]);
+      });
+      const mapReg = (regStr) => {
+        if (typeof regStr !== "string") return regStr;
+        const match = /^r(\d+)$/.exec(regStr);
+        if (match) {
+          const origId = Number.parseInt(match[1], 10);
+          if (origId < paramCount) {
+            return regStr;
+          }
+          const newId = originalToShuffledReg.get(origId) ?? origId;
+          return `r${newId}`;
+        }
+        return regStr;
+      };
+      const blockInstIndices = /* @__PURE__ */ new Map();
+      const flatInsts = [];
+      for (const block of irFn.blocks) {
+        blockInstIndices.set(block.id, flatInsts.length);
+        const mappedInstructions = block.instructions.map((inst) => {
+          const mappedOperands = inst.operands.map((op) => {
+            if (op.kind === OperandKind2.Register) {
+              return { ...op, value: mapReg(op.value) };
+            }
+            if (op.kind === OperandKind2.ConstantIndex) {
+              return { ...op };
+            }
+            return op;
+          });
+          return {
+            ...inst,
+            result: inst.result ? mapReg(inst.result) : void 0,
+            operands: mappedOperands
+          };
+        });
+        const fusedInstructions = fuseInstructions(mappedInstructions, config);
+        flatInsts.push(...fusedInstructions);
+        if (block.terminator) {
+          if (block.terminator.kind === "jump") {
+            flatInsts.push({
+              opcode: OpCode3.Jmp,
+              operands: [{ kind: OperandKind2.BlockLabel, value: block.terminator.targets[0] }]
+            });
+          } else if (block.terminator.kind === "branch") {
+            flatInsts.push({
+              opcode: OpCode3.JmpIf,
+              operands: [
+                { kind: OperandKind2.Register, value: mapReg(block.terminator.condition) },
+                { kind: OperandKind2.BlockLabel, value: block.terminator.targets[0] },
+                { kind: OperandKind2.BlockLabel, value: block.terminator.targets[1] }
+              ]
+            });
+          } else if (block.terminator.kind === "return") {
+            const ops = block.terminator.returnValue ? [{ kind: OperandKind2.Register, value: mapReg(block.terminator.returnValue) }] : [];
+            flatInsts.push({
+              opcode: OpCode3.Return,
+              operands: ops
+            });
+          } else if (block.terminator.kind === "throw") {
+            const ops = block.terminator.returnValue ? [{ kind: OperandKind2.Register, value: mapReg(block.terminator.returnValue) }] : [];
+            flatInsts.push({
+              opcode: OpCode3.Throw,
+              operands: ops
+            });
+          }
+        }
+      }
+      for (const inst of flatInsts) {
+        let mappedOp = inst.opcode;
+        const forward = mapping.forward.get(inst.opcode);
+        if (Array.isArray(forward)) {
+          mappedOp = forward[Math.floor(rng.next() * forward.length)];
+        } else if (forward !== void 0) {
+          mappedOp = forward;
+        }
+        inst.mappedOp = mappedOp;
+      }
+      let expectedPathHash = 0;
+      for (const inst of flatInsts) {
+        expectedPathHash = Math.imul(expectedPathHash, 31) + inst.mappedOp & 4294967295;
+        for (const op of inst.operands) {
+          if (op.kind === OperandKind2.ConstantIndex) {
+            const origIdx = op.value;
+            const origEntry = irModule.constantPool[origIdx];
+            const newIdx = duplicatedCP.length;
+            duplicatedCP.push({
+              ...origEntry,
+              index: newIdx,
+              expectedPathHash: config.rollingKeys ? expectedPathHash : void 0
+            });
+            op.value = newIdx;
+          }
+        }
+        if (isTerminator2(inst.opcode)) {
+          expectedPathHash = 0;
+        }
+      }
+      tempFunctions.push({
+        irFn,
+        flatInsts,
+        blockInstIndices,
+        maxRegs
+      });
+    }
+  }
+  const cpLength = duplicatedCP.length;
+  const originalIndices = Array.from({ length: cpLength }, (_, i) => i);
+  const shuffledIndices = rng.shuffle([...originalIndices]);
+  const duplicatedToShuffled = /* @__PURE__ */ new Map();
+  shuffledIndices.forEach((origIdx, shuffledIdx) => {
+    duplicatedToShuffled.set(origIdx, shuffledIdx);
+  });
+  const shuffledCP = new Array(cpLength);
+  shuffledIndices.forEach((origIdx, shuffledIdx) => {
+    shuffledCP[shuffledIdx] = {
+      ...duplicatedCP[origIdx],
+      index: shuffledIdx
+    };
+  });
+  for (const temp of tempFunctions) {
+    const { irFn, flatInsts, blockInstIndices, maxRegs } = temp;
+    for (const inst of flatInsts) {
+      for (const op of inst.operands) {
+        if (op.kind === OperandKind2.ConstantIndex) {
+          const dupIdx = op.value;
+          op.value = duplicatedToShuffled.get(dupIdx) ?? dupIdx;
+        }
+      }
+    }
+    const instByteOffset = new Array(flatInsts.length).fill(0);
+    let changed = true;
+    while (changed) {
+      changed = false;
+      let currentOffset = 0;
+      for (let i = 0; i < flatInsts.length; i++) {
+        if (instByteOffset[i] !== currentOffset) {
+          instByteOffset[i] = currentOffset;
+          changed = true;
+        }
+        const inst = flatInsts[i];
+        let mappedOp = inst.mappedOp !== void 0 ? inst.mappedOp : inst.opcode;
+        const forward = mapping.forward.get(inst.opcode);
+        if (inst.mappedOp === void 0) {
+          if (Array.isArray(forward)) mappedOp = forward[0];
+          else if (forward !== void 0) mappedOp = forward;
+        }
+        let size = 1;
+        if (config.junkInsertion) {
+          const numJunk = (inst.opcode * 7 + config.seed) % 4;
+          size += numJunk;
+        }
+        const ops = [...inst.operands || []];
+        if (inst.result) {
+          ops.push({ kind: OperandKind2.Register, value: inst.result });
+        }
+        const isVarLength = isVariableLengthOpcode2(inst.opcode);
+        if (isVarLength) {
+          size += 1;
+        }
+        for (let opIdx = 0; opIdx < ops.length; opIdx++) {
+          const op = ops[opIdx];
+          size += 1;
+          let val = 0;
+          if (op.kind === OperandKind2.BlockLabel) {
+            const targetIdx = blockInstIndices.get(op.value);
+            val = instByteOffset[targetIdx] || 0;
+          } else if (typeof op.value === "string" && op.value.startsWith("r")) {
+            val = Number.parseInt(op.value.substring(1), 10);
+          } else if (typeof op.value === "number") {
+            val = op.value;
+          }
+          if (config.immediateEncoding === 1) {
+            let v = val;
+            do {
+              v >>>= 7;
+              size++;
+            } while (v !== 0);
+          } else {
+            size += 4;
+          }
+        }
+        currentOffset += size;
+      }
+    }
+    for (const inst of flatInsts) {
+      if (inst.opcode === OpCode3.Jmp || inst.opcode === OpCode3.JmpIf || inst.opcode === OpCode3.JmpIfNot) {
+        const ops = inst.operands;
+        if (inst.opcode === OpCode3.Jmp) {
+          if (ops[0].kind === OperandKind2.BlockLabel || typeof ops[0].value === "string" && blockInstIndices.has(ops[0].value)) {
+            const targetIdx = blockInstIndices.get(ops[0].value);
+            ops[0].value = instByteOffset[targetIdx];
+            ops[0].kind = OperandKind2.Immediate;
+          }
+        } else if (inst.opcode === OpCode3.JmpIf || inst.opcode === OpCode3.JmpIfNot) {
+          const targetTrueIdx = blockInstIndices.get(ops[1].value);
+          const targetFalseIdx = blockInstIndices.get(ops[2].value);
+          ops[1].value = instByteOffset[targetTrueIdx];
+          ops[1].kind = OperandKind2.Immediate;
+          ops[2].value = instByteOffset[targetFalseIdx];
+          ops[2].kind = OperandKind2.Immediate;
+        }
+      } else {
+        for (const op of inst.operands) {
+          if (op.kind === OperandKind2.BlockLabel) {
+            const targetIdx = blockInstIndices.get(op.value);
+            op.value = instByteOffset[targetIdx];
+            op.kind = OperandKind2.Immediate;
+          }
+        }
+      }
+    }
+    const bytecode = encodeBytecode(flatInsts, mapping, config, rng);
+    functions.push({
+      id: irFn.id,
+      name: irFn.name,
+      bytecode,
+      paramCount: irFn.params.length,
+      localCount: irFn.locals.length,
+      maxRegisters: maxRegs,
+      attributes: irFn.attributes,
+      isEntryPoint: !irFn.attributes.includes(FunctionAttribute.Nested) && (irFn.isVirtualized || irFn.isExported)
+    });
+  }
+  const shuffledFunctions = rng.shuffle([...functions]);
+  const constantPool = encodeConstantPool(shuffledCP, config.constantPoolEncoding, config.seed);
+  const sourceFileName = irModule.sourceFile.split(/[\\/]/).pop()?.replace(/[^a-zA-Z0-9]/g, "_") ?? "unknown";
+  return {
+    magic: 1414745922,
+    version: 1,
+    buildId: `build_${config.seed}_${sourceFileName}`,
+    functions: shuffledFunctions,
+    constantPool,
+    opcodeMapping: mapping,
+    entryPointIndex: shuffledFunctions.findIndex((f) => f.isEntryPoint),
+    metadata: {
+      buildTimestamp: Date.now(),
+      buildId: `build_${config.seed}`,
+      sourceHash: computeSourceHash(irModule),
+      profile: config.profile ?? "generic",
+      deterministicSeed: config.seed
+    }
+  };
+}
+
+// src/decoder.ts
+import { ImmediateEncodingScheme as ImmediateEncodingScheme2, ConstantEncodingScheme as ConstantEncodingScheme2, OperandKind as OperandKind3, OpCode as OpCode4, ConstantKind } from "@tsvm/shared";
+function numToOperandKind(kind) {
+  switch (kind) {
+    case 0:
+      return OperandKind3.Register;
+    case 1:
+      return OperandKind3.Immediate;
+    case 2:
+      return OperandKind3.ConstantIndex;
+    case 3:
+      return OperandKind3.BlockLabel;
+    case 4:
+      return OperandKind3.FunctionRef;
+    default:
+      throw new Error(`Unknown operand kind: ${kind}`);
+  }
+}
+function isVariableLengthOpcode3(opcode) {
+  return opcode === OpCode4.Call || opcode === OpCode4.CallMethod || opcode === OpCode4.New || opcode === OpCode4.ArrayNew || opcode === OpCode4.ObjectNew || opcode === OpCode4.Spread || opcode === OpCode4.SpreadIntoArray || opcode === OpCode4.SuperCall || opcode === OpCode4.SuperInstruction;
+}
+function isTerminator3(opcode) {
+  return opcode === OpCode4.Jmp || opcode === OpCode4.JmpIf || opcode === OpCode4.JmpIfNot || opcode === OpCode4.Return || opcode === OpCode4.ReturnVoid || opcode === OpCode4.Throw || opcode === OpCode4.Yield || opcode === OpCode4.YieldStar || opcode === OpCode4.Await || opcode === OpCode4.Halt || opcode === OpCode4.Trap;
+}
+function unrollKeys(bytes, seed) {
+  const result = new Uint8Array(bytes.length);
+  for (let pc = 0; pc < bytes.length; pc++) {
+    const encoded = bytes[pc];
+    const rollingKey = (seed ^ pc * 2654435769) >>> 8 & 255;
+    const offsetVal = encoded ^ rollingKey;
+    result[pc] = offsetVal - pc & 255;
+  }
+  return result;
+}
+function readLEB128(bytes, offset) {
+  let val = 0;
+  let shift = 0;
+  let b = 0;
+  do {
+    b = bytes[offset.pos++];
+    val |= (b & 127) << shift;
+    shift += 7;
+  } while (b & 128);
+  return val;
+}
+function readFixed32(bytes, offset) {
+  const b0 = bytes[offset.pos++];
+  const b1 = bytes[offset.pos++];
+  const b2 = bytes[offset.pos++];
+  const b3 = bytes[offset.pos++];
+  return b3 << 24 | b2 << 16 | b1 << 8 | b0;
+}
+var OPCODE_DEFAULT_LAYOUT = { inputCount: 0, hasResult: false };
+var opcodeLayout = {
+  [OpCode4.Nop]: { inputCount: 0, hasResult: false },
+  [OpCode4.Halt]: { inputCount: 0, hasResult: false },
+  [OpCode4.Trap]: { inputCount: 0, hasResult: false },
+  [OpCode4.LoadConst]: { inputCount: 1, hasResult: true },
+  [OpCode4.LoadLocal]: { inputCount: 1, hasResult: true },
+  [OpCode4.StoreLocal]: { inputCount: 2, hasResult: false },
+  [OpCode4.Move]: { inputCount: 2, hasResult: false },
+  [OpCode4.LoadGlobal]: { inputCount: 1, hasResult: true },
+  [OpCode4.StoreGlobal]: { inputCount: 2, hasResult: false },
+  [OpCode4.LoadThis]: { inputCount: 0, hasResult: true },
+  [OpCode4.LoadNewTarget]: { inputCount: 0, hasResult: true },
+  [OpCode4.Add]: { inputCount: 2, hasResult: true },
+  [OpCode4.Sub]: { inputCount: 2, hasResult: true },
+  [OpCode4.Mul]: { inputCount: 2, hasResult: true },
+  [OpCode4.Div]: { inputCount: 2, hasResult: true },
+  [OpCode4.Mod]: { inputCount: 2, hasResult: true },
+  [OpCode4.Neg]: { inputCount: 1, hasResult: true },
+  [OpCode4.BitAnd]: { inputCount: 2, hasResult: true },
+  [OpCode4.BitOr]: { inputCount: 2, hasResult: true },
+  [OpCode4.BitXor]: { inputCount: 2, hasResult: true },
+  [OpCode4.Shl]: { inputCount: 2, hasResult: true },
+  [OpCode4.Shr]: { inputCount: 2, hasResult: true },
+  [OpCode4.UShr]: { inputCount: 2, hasResult: true },
+  [OpCode4.Eq]: { inputCount: 2, hasResult: true },
+  [OpCode4.StrictEq]: { inputCount: 2, hasResult: true },
+  [OpCode4.Lt]: { inputCount: 2, hasResult: true },
+  [OpCode4.LtEq]: { inputCount: 2, hasResult: true },
+  [OpCode4.Gt]: { inputCount: 2, hasResult: true },
+  [OpCode4.GtEq]: { inputCount: 2, hasResult: true },
+  [OpCode4.Not]: { inputCount: 1, hasResult: true },
+  [OpCode4.TypeOf]: { inputCount: 1, hasResult: true },
+  [OpCode4.InstanceOf]: { inputCount: 2, hasResult: true },
+  [OpCode4.In]: { inputCount: 2, hasResult: true },
+  [OpCode4.Jmp]: { inputCount: 1, hasResult: false },
+  [OpCode4.JmpIf]: { inputCount: 3, hasResult: false },
+  [OpCode4.JmpIfNot]: { inputCount: 3, hasResult: false },
+  [OpCode4.Call]: { inputCount: 1, hasResult: true },
+  [OpCode4.CallMethod]: { inputCount: 2, hasResult: true },
+  [OpCode4.New]: { inputCount: 1, hasResult: true },
+  [OpCode4.Return]: { inputCount: 1, hasResult: false },
+  [OpCode4.ReturnVoid]: { inputCount: 0, hasResult: false },
+  [OpCode4.ClosureNew]: { inputCount: 1, hasResult: true },
+  [OpCode4.CellNew]: { inputCount: 0, hasResult: true },
+  [OpCode4.CellGet]: { inputCount: 1, hasResult: true },
+  [OpCode4.CellSet]: { inputCount: 2, hasResult: false },
+  [OpCode4.EnvGet]: { inputCount: 1, hasResult: true },
+  [OpCode4.CallWithArray]: { inputCount: 1, hasResult: true },
+  [OpCode4.CallMethodWithArray]: { inputCount: 2, hasResult: true },
+  [OpCode4.NewWithArray]: { inputCount: 1, hasResult: true },
+  [OpCode4.RestArgs]: { inputCount: 0, hasResult: true },
+  [OpCode4.PropGet]: { inputCount: 2, hasResult: true },
+  [OpCode4.PropSet]: { inputCount: 3, hasResult: false },
+  [OpCode4.ComputedGet]: { inputCount: 2, hasResult: true },
+  [OpCode4.ComputedSet]: { inputCount: 3, hasResult: false },
+  [OpCode4.ArrayNew]: { inputCount: 1, hasResult: true },
+  [OpCode4.ObjectNew]: { inputCount: 0, hasResult: true },
+  [OpCode4.Spread]: { inputCount: 1, hasResult: true },
+  [OpCode4.SpreadIntoArray]: { inputCount: 1, hasResult: true },
+  [OpCode4.Delete]: { inputCount: 1, hasResult: true },
+  [OpCode4.PrivateGet]: { inputCount: 1, hasResult: true },
+  [OpCode4.PrivateSet]: { inputCount: 2, hasResult: false },
+  [OpCode4.PrivateIn]: { inputCount: 1, hasResult: true },
+  [OpCode4.SuperPropGet]: { inputCount: 2, hasResult: true },
+  [OpCode4.SuperPropSet]: { inputCount: 3, hasResult: false },
+  [OpCode4.SuperCall]: { inputCount: 1, hasResult: true },
+  [OpCode4.SuperCallWithArray]: { inputCount: 1, hasResult: true },
+  [OpCode4.Throw]: { inputCount: 1, hasResult: false },
+  [OpCode4.TryCatchBegin]: { inputCount: 0, hasResult: false },
+  [OpCode4.TryCatchEnd]: { inputCount: 0, hasResult: false },
+  [OpCode4.Yield]: { inputCount: 0, hasResult: true },
+  [OpCode4.Await]: { inputCount: 0, hasResult: true },
+  [OpCode4.YieldStar]: { inputCount: 0, hasResult: true },
+  [OpCode4.GetEntropy]: { inputCount: 0, hasResult: true },
+  [OpCode4.SuperInstruction]: { inputCount: 1, hasResult: true }
+};
+function decodeBytecode(bytes, mapping, config) {
+  const raw = config.rollingKeys ? unrollKeys(bytes, config.seed) : bytes;
+  const instructions = [];
+  const offset = { pos: 0 };
+  let currentHandlerIdx = 0;
+  while (offset.pos < raw.length) {
+    const opcodeStart = offset.pos;
+    let mappedOp;
+    if (config.stealthDispatch) {
+      const delta = raw[offset.pos++];
+      mappedOp = delta + currentHandlerIdx & 255;
+    } else {
+      mappedOp = raw[offset.pos++];
+    }
+    const canonicalOp = mapping.reverse.get(mappedOp);
+    const opcode = canonicalOp ?? mappedOp;
+    const numJunk = config.junkInsertion ? (opcode * 7 + config.seed) % 4 : 0;
+    offset.pos += numJunk;
+    const layout = opcodeLayout[opcode] ?? OPCODE_DEFAULT_LAYOUT;
+    const isVarLength = isVariableLengthOpcode3(opcode);
+    let totalOps;
+    if (isVarLength) {
+      totalOps = raw[offset.pos++];
+    } else {
+      totalOps = layout.inputCount + (layout.hasResult ? 1 : 0);
+    }
+    const allOperands = [];
+    for (let opsRead = 0; opsRead < totalOps; opsRead++) {
+      const kindNum = raw[offset.pos++];
+      let val;
+      if (config.immediateEncoding === ImmediateEncodingScheme2.VariableLength) {
+        val = readLEB128(raw, offset);
+      } else {
+        val = readFixed32(raw, offset);
+      }
+      const kind = numToOperandKind(kindNum);
+      if (kind === OperandKind3.Register) {
+        allOperands.push({ kind, value: `r${val}` });
+      } else if (kind === OperandKind3.BlockLabel) {
+        allOperands.push({ kind, value: val });
+      } else {
+        allOperands.push({ kind, value: val });
+      }
+    }
+    let result;
+    const operands = [];
+    if (layout.hasResult && allOperands.length > layout.inputCount) {
+      const lastOp = allOperands[allOperands.length - 1];
+      result = lastOp.value;
+      for (let i = 0; i < allOperands.length - 1; i++) {
+        operands.push(allOperands[i]);
+      }
+    } else {
+      operands.push(...allOperands);
+    }
+    if (isTerminator3(opcode)) {
+      currentHandlerIdx = 0;
+    } else {
+      currentHandlerIdx = mappedOp;
+    }
+    instructions.push({
+      opcode,
+      result,
+      mappedOp,
+      operands
+    });
+  }
+  return instructions;
+}
+function decodeConstantPool(encoded, scheme, seed) {
+  return encoded.map((entry, index) => {
+    if (scheme === ConstantEncodingScheme2.XorRotate && entry.kind === ConstantKind.String && typeof entry.value === "string") {
+      let stringSeed = (seed ^ index * 2654435769) & 4294967295;
+      if (entry.decodingKey !== 0) {
+        stringSeed = (stringSeed ^ entry.decodingKey) & 4294967295;
+      }
+      const keyBytes = new Uint8Array(16);
+      let s = stringSeed;
+      for (let i = 0; i < 16; i++) {
+        s = Math.imul(s, 1664525) + 1013904223;
+        keyBytes[i] = s >>> 16 & 255;
+      }
+      const S = new Uint8Array(256);
+      for (let i = 0; i < 256; i++) S[i] = i;
+      let j = 0;
+      for (let i = 0; i < 256; i++) {
+        j = j + S[i] + keyBytes[i % 16] & 255;
+        const temp = S[i];
+        S[i] = S[j];
+        S[j] = temp;
+      }
+      let ri = 0;
+      j = 0;
+      for (let skip = 0; skip < 256; skip++) {
+        ri = ri + 1 & 255;
+        j = j + S[ri] & 255;
+        const temp = S[ri];
+        S[ri] = S[j];
+        S[j] = temp;
+      }
+      let decoded = "";
+      for (let i = 0; i < entry.value.length; i++) {
+        ri = ri + 1 & 255;
+        j = j + S[ri] & 255;
+        const temp = S[ri];
+        S[ri] = S[j];
+        S[j] = temp;
+        const keystreamByte = S[S[ri] + S[j] & 255];
+        decoded += String.fromCharCode(entry.value.charCodeAt(i) ^ keystreamByte);
+      }
+      return { index, kind: entry.kind, value: decoded };
+    }
+    return { index, kind: entry.kind, value: entry.value };
+  });
+}
+var opcodeNames = {
+  [OpCode4.LoadConst]: "LoadConst",
+  [OpCode4.LoadLocal]: "LoadLocal",
+  [OpCode4.StoreLocal]: "StoreLocal",
+  [OpCode4.Move]: "Move",
+  [OpCode4.LoadGlobal]: "LoadGlobal",
+  [OpCode4.StoreGlobal]: "StoreGlobal",
+  [OpCode4.LoadThis]: "LoadThis",
+  [OpCode4.LoadNewTarget]: "LoadNewTarget",
+  [OpCode4.Add]: "Add",
+  [OpCode4.Sub]: "Sub",
+  [OpCode4.Mul]: "Mul",
+  [OpCode4.Div]: "Div",
+  [OpCode4.Mod]: "Mod",
+  [OpCode4.Neg]: "Neg",
+  [OpCode4.BitAnd]: "BitAnd",
+  [OpCode4.BitOr]: "BitOr",
+  [OpCode4.BitXor]: "BitXor",
+  [OpCode4.Shl]: "Shl",
+  [OpCode4.Shr]: "Shr",
+  [OpCode4.UShr]: "UShr",
+  [OpCode4.Eq]: "Eq",
+  [OpCode4.StrictEq]: "StrictEq",
+  [OpCode4.Lt]: "Lt",
+  [OpCode4.LtEq]: "LtEq",
+  [OpCode4.Gt]: "Gt",
+  [OpCode4.GtEq]: "GtEq",
+  [OpCode4.Not]: "Not",
+  [OpCode4.TypeOf]: "TypeOf",
+  [OpCode4.InstanceOf]: "InstanceOf",
+  [OpCode4.In]: "In",
+  [OpCode4.Jmp]: "Jmp",
+  [OpCode4.JmpIf]: "JmpIf",
+  [OpCode4.JmpIfNot]: "JmpIfNot",
+  [OpCode4.Call]: "Call",
+  [OpCode4.CallMethod]: "CallMethod",
+  [OpCode4.New]: "New",
+  [OpCode4.Return]: "Return",
+  [OpCode4.ReturnVoid]: "ReturnVoid",
+  [OpCode4.ClosureNew]: "ClosureNew",
+  [OpCode4.CellNew]: "CellNew",
+  [OpCode4.CellGet]: "CellGet",
+  [OpCode4.CellSet]: "CellSet",
+  [OpCode4.EnvGet]: "EnvGet",
+  [OpCode4.CallWithArray]: "CallWithArray",
+  [OpCode4.CallMethodWithArray]: "CallMethodWithArray",
+  [OpCode4.NewWithArray]: "NewWithArray",
+  [OpCode4.RestArgs]: "RestArgs",
+  [OpCode4.PropGet]: "PropGet",
+  [OpCode4.PropSet]: "PropSet",
+  [OpCode4.ComputedGet]: "ComputedGet",
+  [OpCode4.ComputedSet]: "ComputedSet",
+  [OpCode4.ArrayNew]: "ArrayNew",
+  [OpCode4.ObjectNew]: "ObjectNew",
+  [OpCode4.Spread]: "Spread",
+  [OpCode4.SpreadIntoArray]: "SpreadIntoArray",
+  [OpCode4.Delete]: "Delete",
+  [OpCode4.PrivateGet]: "PrivateGet",
+  [OpCode4.PrivateSet]: "PrivateSet",
+  [OpCode4.PrivateIn]: "PrivateIn",
+  [OpCode4.SuperPropGet]: "SuperPropGet",
+  [OpCode4.SuperPropSet]: "SuperPropSet",
+  [OpCode4.SuperCall]: "SuperCall",
+  [OpCode4.SuperCallWithArray]: "SuperCallWithArray",
+  [OpCode4.Throw]: "Throw",
+  [OpCode4.TryCatchBegin]: "TryCatchBegin",
+  [OpCode4.TryCatchEnd]: "TryCatchEnd",
+  [OpCode4.Yield]: "Yield",
+  [OpCode4.Await]: "Await",
+  [OpCode4.YieldStar]: "YieldStar",
+  [OpCode4.Nop]: "Nop",
+  [OpCode4.Halt]: "Halt",
+  [OpCode4.Trap]: "Trap",
+  [OpCode4.GetEntropy]: "GetEntropy",
+  [OpCode4.SuperInstruction]: "SuperInstruction"
+};
+function disassemble(module) {
+  const config = {
+    opcodeRemapping: true,
+    immediateEncoding: ImmediateEncodingScheme2.XorMasked,
+    superInstructions: true,
+    handlerLayoutRandom: true,
+    constantPoolEncoding: ConstantEncodingScheme2.XorRotate,
+    traceMode: false,
+    deterministicReplay: false,
+    seed: module.metadata.deterministicSeed ?? 0,
+    profile: module.metadata.profile,
+    threadedDispatch: true,
+    tamperDetection: true,
+    antiDebug: true,
+    opcodeAliasing: true,
+    junkInsertion: true,
+    rollingKeys: true,
+    stealthDispatch: true
+  };
+  const lines = [];
+  lines.push(`; Bytecode Module: ${module.buildId}`);
+  lines.push(`; Version: ${module.version}, Functions: ${module.functions.length}`);
+  lines.push(`; Profile: ${module.metadata.profile}, Seed: ${module.metadata.deterministicSeed}`);
+  lines.push("");
+  for (const fn of module.functions) {
+    lines.push(`; --- Function: ${fn.name} (id: ${fn.id}) ---`);
+    lines.push(`;   paramCount: ${fn.paramCount}, localCount: ${fn.localCount}, maxRegisters: ${fn.maxRegisters}`);
+    lines.push(`;   bytecodeSize: ${fn.bytecode.length} bytes, entryPoint: ${fn.isEntryPoint}`);
+    lines.push("");
+    try {
+      const instructions = decodeBytecode(fn.bytecode, module.opcodeMapping, config);
+      let byteOffset = 0;
+      for (let i = 0; i < instructions.length; i++) {
+        const inst = instructions[i];
+        const opName = opcodeNames[inst.opcode] ?? `OP_${inst.opcode.toString(16).toUpperCase().padStart(2, "0")}`;
+        const mappedStr = inst.mappedOp !== void 0 && inst.mappedOp !== inst.opcode ? ` (mapped: 0x${inst.mappedOp.toString(16).toUpperCase().padStart(2, "0")})` : "";
+        const opsStr = inst.operands.map((op) => {
+          const kindStr = op.kind === OperandKind3.Register ? "r" + op.value : op.kind === OperandKind3.Immediate ? "#" + op.value : op.kind === OperandKind3.ConstantIndex ? "@" + op.value : op.kind === OperandKind3.BlockLabel ? "L" + op.value : op.kind === OperandKind3.FunctionRef ? "fn" + op.value : String(op.value);
+          return kindStr;
+        }).join(", ");
+        lines.push(`  ${byteOffset.toString(10).padStart(4, " ")}: ${opName}${mappedStr} ${opsStr}`);
+        byteOffset += estimateInstructionSize(inst, config, module.metadata.deterministicSeed ?? 0);
+      }
+    } catch (e) {
+      const err = e;
+      lines.push(`  ; DECODE ERROR: ${err.message}`);
+    }
+    lines.push("");
+  }
+  lines.push(`; Constant Pool (${module.constantPool.length} entries):`);
+  for (const entry of module.constantPool) {
+    const valStr = typeof entry.value === "string" ? JSON.stringify(entry.value.substring(0, 40)) : String(entry.value);
+    lines.push(`;   [${entry.index}] ${entry.kind}: ${valStr}`);
+  }
+  return lines.join("\n");
+}
+function estimateInstructionSize(inst, config, seed) {
+  let size = 1;
+  const mappedOp = inst.mappedOp ?? inst.opcode;
+  if (config.junkInsertion) {
+    size += (inst.opcode * 7 + seed) % 4;
+  }
+  const ops = [...inst.operands || []];
+  const isVarLength = isVariableLengthOpcode3(inst.opcode);
+  if (isVarLength) {
+    size += 1;
+  }
+  for (const op of ops) {
+    size += 1;
+    let val = 0;
+    if (typeof op.value === "string" && op.value.startsWith("r")) {
+      val = Number.parseInt(op.value.substring(1), 10);
+    } else if (typeof op.value === "number") {
+      val = op.value;
+    }
+    if (config.immediateEncoding === ImmediateEncodingScheme2.VariableLength) {
+      let v = val;
+      do {
+        v >>>= 7;
+        size++;
+      } while (v !== 0);
+    } else {
+      size += 4;
+    }
+  }
+  return size;
+}
+export {
+  compileToBytecode,
+  decodeBytecode,
+  decodeConstantPool,
+  disassemble,
+  encodeBytecode,
+  encodeConstantPool,
+  generateRemappedOpcodes
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@tsvm/bytecode",
+  "version": "0.1.0",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup ./src/index.ts --format esm --dts --clean",
+    "test": "pnpm --dir ../.. exec vitest run packages/bytecode/tests/**/*.test.ts --config vitest.config.mjs",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@tsvm/shared": "workspace:*"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.0"
+  }
+}