superinstance-flux-runtime 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ea9ba7c8b41057f91a8ff10c2d6cb643dffd8ce9bc269678cd23ee725381f588
+  data.tar.gz: 8b1c353e2a4b3e021f568972240888c87679b087074f39d94f803caad7e5e9e1
+SHA512:
+  metadata.gz: ad2712c1004e3c47645cb40911a5bfc5a3d285fc618517b7a983984a23ed2c485b3e7863a6630df8c36e585418102ea5f6f3b0733cbd8799747f996f97996878
+  data.tar.gz: b123e8b9b9a7e356b2ff7a76b5aa09d2a8fb280fb09926f9e7a29be6f1f5f2824374c7ad451b763f5fe6f7ab8e4dcd923d16d09e458d1e199c521de088f37756

data/lib/superinstance/flux-runtime/assembler.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+require_relative 'flux_vm'
+
+module Flux
+  # Text assembly to bytecode
+  class Assembler
+    REGISTER_ALIASES = {
+      'RV' => 8, 'R8' => 8,
+      'A0' => 9, 'R9' => 9,
+      'A1' => 10, 'R10' => 10,
+      'SP' => 11, 'R11' => 11,
+      'FP' => 12, 'R12' => 12,
+      'FL' => 13, 'R13' => 13,
+      'TP' => 14, 'R14' => 14,
+      'LR' => 15, 'R15' => 15
+    }.freeze
+
+    OPCODE_MAP = {
+      # Control Flow
+      'HALT' => 0x00, 'NOP' => 0x01, 'RET' => 0x02,
+      'JUMP' => 0x03, 'JUMPIF' => 0x04, 'JUMPIFNOT' => 0x05,
+      'CALL' => 0x06, 'CALLINDIRECT' => 0x07,
+      'YIELD' => 0x08, 'PANIC' => 0x09, 'UNREACHABLE' => 0x0A,
+
+      # Stack Operations
+      'PUSH' => 0x10, 'POP' => 0x11, 'DUP' => 0x12, 'SWAP' => 0x13,
+
+      # Integer Arithmetic
+      'IMOV' => 0x20, 'IADD' => 0x21, 'ISUB' => 0x22,
+      'IMUL' => 0x23, 'IDIV' => 0x24, 'IMOD' => 0x25,
+      'INEG' => 0x26, 'IABS' => 0x27,
+      'IINC' => 0x28, 'IDEC' => 0x29,
+      'IMIN' => 0x2A, 'IMAX' => 0x2B,
+      'IAND' => 0x2C, 'IOR' => 0x2D, 'IXOR' => 0x2E,
+      'ISHL' => 0x2F, 'ISHR' => 0x30, 'INOT' => 0x31,
+      'ICMPEQ' => 0x32, 'ICMPNE' => 0x33,
+      'ICMPLT' => 0x34, 'ICMPLE' => 0x35,
+      'ICMPGT' => 0x36, 'ICMPGE' => 0x37,
+
+      # Float Arithmetic
+      'FMOV' => 0x40, 'FADD' => 0x41, 'FSUB' => 0x42,
+      'FMUL' => 0x43, 'FDIV' => 0x44, 'FMOD' => 0x45,
+      'FNEG' => 0x46, 'FABS' => 0x47, 'FSQRT' => 0x48,
+      'FFLOOR' => 0x49, 'FCEIL' => 0x4A, 'FROUND' => 0x4B,
+      'FMIN' => 0x4C, 'FMAX' => 0x4D,
+      'FSIN' => 0x4E, 'FCOS' => 0x4F,
+      'FEXP' => 0x50, 'FLOG' => 0x51,
+      'FCLAMP' => 0x52, 'FLERP' => 0x53,
+      'FCMPEQ' => 0x54, 'FCMPNE' => 0x55,
+      'FCMPLT' => 0x56, 'FCMPLE' => 0x57,
+      'FCMPGT' => 0x58, 'FCMPGE' => 0x59,
+
+      # Conversions
+      'ITOF' => 0x60, 'FTOI' => 0x61, 'BTOI' => 0x62, 'ITOB' => 0x63,
+
+      # Memory Operations
+      'LOAD8' => 0x70, 'LOAD16' => 0x71, 'LOAD32' => 0x72, 'LOAD64' => 0x73,
+      'STORE8' => 0x74, 'STORE16' => 0x75, 'STORE32' => 0x76, 'STORE64' => 0x77,
+      'LOADADDR' => 0x78, 'STACKALLOC' => 0x79,
+
+      # A2A Communication
+      'ASEND' => 0x80, 'ARECV' => 0x81, 'AASK' => 0x82,
+      'ATELL' => 0x83, 'ADELEGATE' => 0x84, 'ABROADCAST' => 0x85,
+      'ASUBSCRIBE' => 0x86, 'AWAIT' => 0x87, 'ATRUST' => 0x88, 'AVERIFY' => 0x89,
+
+      # Type/Meta
+      'CAST' => 0x90, 'SIZEOF' => 0x91, 'TYPEOF' => 0x92,
+
+      # Bitwise
+      'BAND' => 0xA0, 'BOR' => 0xA1, 'BXOR' => 0xA2,
+      'BSHL' => 0xA3, 'BSHR' => 0xA4, 'BNOT' => 0xA5,
+
+      # Vector
+      'VLOAD' => 0xB0, 'VSTORE' => 0xB1, 'VADD' => 0xB2,
+      'VMUL' => 0xB3, 'VDOT' => 0xB4
+    }.freeze
+
+    def initialize
+      @labels = {}
+    end
+
+    def assemble(source_code)
+      output = []
+      lines = source_code.lines.map(&:chomp)
+
+      # Single pass: collect labels and build bytecode
+      @labels = {}
+      pc = 0
+
+      # First pass: find labels
+      lines.each do |line|
+        line = strip_comment(line)
+        next if line.empty?
+
+        if line.end_with?(':')
+          label_name = line.chomp(':').upcase
+          @labels[label_name] = pc
+        else
+          pc += estimate_size(line)
+        end
+      end
+
+      # Second pass: generate bytecode
+      pc = 0
+      lines.each do |line|
+        line = strip_comment(line)
+        next if line.empty?
+        next if line.end_with?(':')
+
+        bytes = encode_instruction(line, pc)
+        output.concat(bytes)
+        pc += bytes.length
+      end
+
+      output.pack('C*')
+    end
+
+    private
+
+    def strip_comment(line)
+      line.split(/\/\/|#/).first.to_s.strip
+    end
+
+    def estimate_size(line)
+      parts = line.upcase.split(/\s+/)
+      op = parts[0]
+      opcode = OPCODE_MAP[op]
+      return 1 unless opcode
+
+      case opcode
+      when 0x00, 0x01, 0x02, 0x08, 0x09, 0x0A then 1
+      when 0x10, 0x11, 0x12, 0x13, 0x20, 0x40 then 3
+      when 0x21..0x37, 0x41..0x59, 0x60..0x63, 0x90..0x92, 0xA0..0xA5, 0xB2..0xB4 then 4
+      when 0x28, 0x29, 0x79 then 4
+      when 0x70..0x78, 0xB0, 0xB1 then 5
+      when 0x03, 0x04, 0x05 then 4
+      when 0x06 then 4
+      when 0x07 then 3
+      when 0x80..0x89 then 4
+      else 4
+      end
+    end
+
+    def encode_instruction(line, pc)
+      parts = line.upcase.split(/\s+/)
+      op = parts[0]
+
+      # Join remaining parts with space and parse comma-separated operands
+      raw_args = parts[1..].join(' ')
+      args = raw_args.split(',').map(&:strip).reject(&:empty?)
+
+      opcode = OPCODE_MAP[op]
+      raise ArgumentError, "Unknown opcode: #{op}" unless opcode
+
+      bytes = [opcode]
+
+      case opcode
+      # Format A: no operands
+      when 0x00, 0x01, 0x02, 0x08, 0x09, 0x0A
+        bytes
+
+      # Format B: Rd, Rs
+      when 0x10, 0x11, 0x12, 0x20, 0x40
+        bytes << parse_register(args[0]) << parse_register(args[1] || 'R0')
+
+      when 0x13  # Swap: Ra, Rb
+        bytes << parse_register(args[0]) << parse_register(args[1] || 'R0')
+
+      # Format C: Rd, Ra, Rb
+      when 0x21..0x37, 0x41..0x59, 0x60..0x63, 0x90..0x92, 0xA0..0xA5, 0xB2..0xB4
+        bytes << parse_register(args[0]) << parse_register(args[1] || 'R0') << parse_register(args[2] || 'R0')
+
+      # Format D: Rd, imm16
+      when 0x28, 0x29
+        bytes << parse_register(args[0]) << encode_imm16(args[1] || '0')
+
+      when 0x79  # StackAlloc
+        bytes << parse_register(args[0] || 'R0') << encode_imm16(args[1] || '0')
+
+      # Format E: Rd, Rb, off16
+      when 0x70..0x78, 0xB0, 0xB1
+        bytes << parse_register(args[0]) << parse_register(args[1] || 'R0') << encode_imm16(args[2] || '0')
+
+      # Format G: variable
+      when 0x03  # Jump
+        offset = resolve_label(args[0], pc, 4) || 0
+        bytes << 4 << encode_imm16(offset.to_s)
+
+      when 0x04, 0x05  # JumpIf, JumpIfNot
+        rd = parse_register(args[0] || 'R0')
+        offset = resolve_label(args[1], pc, 5) || 0
+        bytes << 5 << rd << encode_imm16(offset.to_s)
+
+      when 0x06  # Call
+        func_idx = resolve_func_idx(args[0] || '0')
+        bytes << 4 << encode_imm16(func_idx.to_s)
+
+      when 0x07  # CallIndirect
+        reg = parse_register(args[0] || 'R0')
+        bytes << 3 << reg
+
+      when 0x80  # ASend
+        agent_id = parse_immediate(args[0] || '0')
+        reg = parse_register(args[1] || 'R0')
+        bytes << 4 << agent_id << reg
+
+      when 0x81  # ARecv
+        agent_id = parse_immediate(args[0] || '0')
+        reg = parse_register(args[1] || 'R0')
+        bytes << 4 << agent_id << reg
+
+      when 0x82  # AAsk
+        agent_id = parse_immediate(args[0] || '0')
+        reg = parse_register(args[1] || 'R0')
+        bytes << 4 << agent_id << reg
+
+      when 0x83  # ATell
+        agent_id = parse_immediate(args[0] || '0')
+        reg = parse_register(args[1] || 'R0')
+        bytes << 4 << agent_id << reg
+
+      when 0x84  # ADelegate
+        agent_id = parse_immediate(args[0] || '0')
+        bc_start = resolve_func_idx(args[1] || '0')
+        bytes << 4 << agent_id << encode_imm16(bc_start.to_s)
+
+      when 0x85  # ABroadcast
+        reg = parse_register(args[0] || 'R0')
+        bytes << 3 << reg
+
+      when 0x86  # ASubscribe
+        channel_id = parse_immediate(args[0] || '0')
+        bytes << 3 << channel_id
+
+      when 0x87  # AWait
+        cond_reg = parse_register(args[0] || 'R0')
+        bytes << 3 << cond_reg
+
+      when 0x88  # ATrust
+        agent_id = parse_immediate(args[0] || '0')
+        level = parse_immediate(args[1] || '0')
+        bytes << 4 << agent_id << level
+
+      when 0x89  # AVerify
+        agent_id = parse_immediate(args[0] || '0')
+        result_reg = parse_register(args[1] || 'R0')
+        bytes << 4 << agent_id << result_reg
+
+      else
+        bytes
+      end
+    end
+
+    def parse_register(name)
+      return 0 unless name
+
+      name = name.to_s.strip.upcase
+      return REGISTER_ALIASES[name] if REGISTER_ALIASES[name]
+
+      if name.start_with?('R')
+        num = name[1..].to_i
+        return num if num >= 0 && num < 16
+      end
+
+      raise ArgumentError, "Invalid register: #{name}"
+    end
+
+    def parse_immediate(value)
+      value = value.to_s.strip
+      if value.start_with?('0x', '0X')
+        value[2..].to_i(16)
+      else
+        value.to_i
+      end
+    end
+
+    def encode_imm16(value)
+      val = parse_immediate(value)
+      [val & 0xFF, (val >> 8) & 0xFF]
+    end
+
+    def resolve_func_idx(value)
+      value = value.to_s.strip
+      if @labels[value.upcase]
+        @labels[value.upcase]
+      elsif @labels["FUNC_#{value.upcase}"]
+        @labels["FUNC_#{value.upcase}"]
+      else
+        value.to_i
+      end
+    end
+
+    def resolve_label(name, current_pc, instruction_size)
+      return nil unless name
+
+      name = name.to_s.strip.upcase
+      if @labels[name]
+        @labels[name] - current_pc - instruction_size
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/superinstance/flux-runtime/cli.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative 'flux_vm'
+require_relative 'assembler'
+require_relative 'disassembler'
+require_relative 'loader'
+
+module Flux
+  # Command-line interface for FLUX VM
+  class CLI
+    def self.run(args)
+      new.run(args)
+    end
+
+    def run(args)
+      command = args[0]
+      path = args[1]
+
+      case command
+      when 'run'
+        run_bytecode(path)
+      when 'asm'
+        assemble_file(path)
+      when 'dis'
+        disassemble_file(path)
+      when 'repl'
+        start_repl
+      when 'help', nil
+        print_help
+      else
+        $stderr.puts "Unknown command: #{command}"
+        print_help
+        exit 1
+      end
+    end
+
+    private
+
+    def run_bytecode(path)
+      unless path
+        $stderr.puts 'Error: No file specified'
+        exit 1
+      end
+
+      loader = Loader.new
+      bytecode = loader.load_file(path)
+
+      vm = FluxVM.new
+      vm.load(bytecode)
+
+      trap('INT') do
+        $stderr.puts "\nInterrupted"
+        exit 1
+      end
+
+      vm.run
+
+      puts "VM state: #{vm.state}"
+      puts "Cycles: #{vm.stats[:cycles]}"
+      puts "Instructions: #{vm.stats[:instruction_count]}"
+      puts "Registers: #{vm.regs}"
+    end
+
+    def assemble_file(path)
+      unless path
+        $stderr.puts 'Error: No file specified'
+        exit 1
+      end
+
+      source = File.read(path)
+      asm = Assembler.new
+      bytecode = asm.assemble(source)
+
+      output_path = path.sub(/\.asm$/, '.flux')
+      output_path = "#{path}.flux" unless path.include?('.')
+
+      File.binwrite(output_path, bytecode)
+      puts "Assembled: #{path} -> #{output_path} (#{bytecode.bytesize} bytes)"
+    end
+
+    def disassemble_file(path)
+      unless path
+        $stderr.puts 'Error: No file specified'
+        exit 1
+      end
+
+      loader = Loader.new
+      bytecode = loader.load_file(path)
+
+      dis = Disassembler.new
+      puts dis.disassemble(bytecode)
+    end
+
+    def start_repl
+      puts 'FLUX REPL v1.0.0'
+      puts 'Type "help" for commands, "quit" to exit'
+      puts
+
+      vm = FluxVM.new
+      loader = Loader.new
+      asm = Assembler.new
+
+      loop do
+        print 'flux> '
+        line = gets
+        break unless line
+
+        line = line.strip
+        next if line.empty?
+
+        case line
+        when 'quit', 'exit', 'q'
+          break
+        when 'help', '?'
+          puts 'Commands:'
+          puts '  run          - Run loaded bytecode'
+          puts '  step         - Step one instruction'
+          puts '  regs         - Show registers'
+          puts '  state        - Show VM state'
+          puts '  reset        - Reset VM'
+          puts '  load <file>  - Load bytecode file'
+          puts '  asm <code>   - Assemble and load'
+          puts '  dis          - Disassemble loaded bytecode'
+          puts '  quit         - Exit REPL'
+        when 'run'
+          vm.run
+          puts "State: #{vm.state}"
+        when 'step'
+          vm.step
+          puts "State: #{vm.state}"
+        when 'regs'
+          puts vm.regs.inspect
+        when 'state'
+          puts "State: #{vm.state}"
+          puts "PC: #{vm.pc}"
+          puts "SP: #{vm.sp}"
+        when 'reset'
+          vm.reset
+          puts 'VM reset'
+        when /^load\s+(.+)$/
+          path = $1
+          bytecode = loader.load_file(path)
+          vm.load(bytecode)
+          puts "Loaded #{bytecode.bytesize} bytes"
+        when /^asm\s+(.+)$/
+          code = $1
+          begin
+            bytecode = asm.assemble(code)
+            vm.load(bytecode)
+            puts "Assembled #{bytecode.bytesize} bytes"
+          rescue => e
+            puts "Error: #{e.message}"
+          end
+        when 'dis'
+          dis = Disassembler.new
+          # Disassemble what's in memory
+          puts dis.disassemble(vm.instance_variable_get(:memory).pack('C*'))
+        else
+          puts "Unknown command: #{line}"
+        end
+      end
+    end
+
+    def print_help
+      puts <<~HELP
+        FLUX Runtime v1.0.0
+        Pure Ruby FLUX ISA v3.0 Virtual Machine
+
+        Usage: flux <command> [options]
+
+        Commands:
+          run <file>    Run a FLUX bytecode file
+          asm <file>    Assemble .asm file to .flux
+          dis <file>    Disassemble .flux to .asm
+          repl          Start interactive REPL
+          help          Show this help
+
+        Examples:
+          flux run program.flux
+          flux asm source.asm
+          flux dis program.flux
+      HELP
+    end
+  end
+end
+
+# Run CLI if executed directly
+if $PROGRAM_NAME == __FILE__ || File.basename($PROGRAM_NAME) == 'flux'
+  Flux::CLI.run(ARGV)
+end

data/lib/superinstance/flux-runtime/disassembler.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require_relative 'opcode'
+
+module Flux
+  # Bytecode to text disassembly
+  class Disassembler
+    include OpcodeRegistry
+
+    MNEMONIC_MAP = OPCODE_CLASSES.transform_keys(&:to_i).freeze
+
+    def disassemble(bytecode_string)
+      bytecode = bytecode_string.dup.force_encoding('BINARY')
+      output = []
+      pc = 0
+
+      while pc < bytecode.bytesize
+        offset = pc
+        opcode = bytecode.getbyte(pc)
+        pc += 1
+
+        mnemonic = OPCODE_NAMES[opcode] || "Unknown_0x#{opcode.to_s(16).upcase}"
+        line = "#{mnemonic}"
+
+        case opcode
+        # Format A: 1 byte
+        when 0x00, 0x01, 0x02, 0x08, 0x09, 0x0A
+          # No operands
+
+        # Format B: +Rd +Rs (2 bytes)
+        when 0x10, 0x11, 0x12, 0x20, 0x40
+          rd = bytecode.getbyte(pc)
+          rs = bytecode.getbyte(pc + 1)
+          line = "#{mnemonic} R#{rd}, R#{rs}"
+          pc += 2
+
+        when 0x13  # Swap: Ra, Rb
+          ra = bytecode.getbyte(pc)
+          rb = bytecode.getbyte(pc + 1)
+          line = "#{mnemonic} R#{ra}, R#{rb}"
+          pc += 2
+
+        # Format C: +Rd +Ra +Rb (3 bytes)
+        when 0x21..0x37, 0x41..0x59, 0x60..0x63, 0x90..0x92, 0xA0..0xA5, 0xB2..0xB4
+          rd = bytecode.getbyte(pc)
+          ra = bytecode.getbyte(pc + 1)
+          rb = bytecode.getbyte(pc + 2)
+          line = "#{mnemonic} R#{rd}, R#{ra}, R#{rb}"
+          pc += 3
+
+        # Format D: +Rd +imm16 (3 bytes)
+        when 0x28, 0x29, 0x79
+          rd = bytecode.getbyte(pc)
+          imm_lo = bytecode.getbyte(pc + 1)
+          imm_hi = bytecode.getbyte(pc + 2)
+          imm = imm_lo | (imm_hi << 8)
+          # Sign extend
+          imm = (imm << 16) >> 16
+          line = "#{mnemonic} R#{rd}, #{imm}"
+          pc += 3
+
+        # Format E: +Rd +Rb +off16 (4 bytes)
+        when 0x70..0x78
+          rd = bytecode.getbyte(pc)
+          rb = bytecode.getbyte(pc + 1)
+          off_lo = bytecode.getbyte(pc + 2)
+          off_hi = bytecode.getbyte(pc + 3)
+          off = off_lo | (off_hi << 8)
+          line = "#{mnemonic} R#{rd}, R#{rb}, #{off}"
+          pc += 4
+
+        when 0xB0, 0xB1  # VLoad, VStore
+          rd = bytecode.getbyte(pc)
+          rb = bytecode.getbyte(pc + 1)
+          off_lo = bytecode.getbyte(pc + 2)
+          off_hi = bytecode.getbyte(pc + 3)
+          off = off_lo | (off_hi << 8)
+          line = "#{mnemonic} R#{rd}, R#{rb}, #{off}"
+          pc += 4
+
+        # Format G: variable
+        when 0x03, 0x04, 0x05  # Jump, JumpIf, JumpIfNot
+          length = bytecode.getbyte(pc)
+          pc += 1
+          off_lo = bytecode.getbyte(pc)
+          off_hi = bytecode.getbyte(pc + 1)
+          off = off_lo | (off_hi << 8)
+          off = (off << 16) >> 16  # Sign extend
+          line = "#{mnemonic} #{off}"
+          pc += 2
+
+        when 0x06  # Call
+          length = bytecode.getbyte(pc)
+          pc += 1
+          func_lo = bytecode.getbyte(pc)
+          func_hi = bytecode.getbyte(pc + 1)
+          func_idx = func_lo | (func_hi << 8)
+          line = "#{mnemonic} #{func_idx}"
+          pc += 2
+
+        when 0x07  # CallIndirect
+          length = bytecode.getbyte(pc)
+          pc += 1
+          reg = bytecode.getbyte(pc)
+          line = "#{mnemonic} R#{reg}"
+          pc += 1
+
+        when 0x80  # ASend
+          length = bytecode.getbyte(pc)
+          pc += 1
+          agent_id = bytecode.getbyte(pc)
+          reg = bytecode.getbyte(pc + 1)
+          line = "#{mnemonic} #{agent_id}, R#{reg}"
+          pc += 2
+
+        when 0x81  # ARecv
+          length = bytecode.getbyte(pc)
+          pc += 1
+          agent_id = bytecode.getbyte(pc)
+          reg = bytecode.getbyte(pc + 1)
+          line = "#{mnemonic} #{agent_id}, R#{reg}"
+          pc += 2
+
+        when 0x82  # AAsk
+          length = bytecode.getbyte(pc)
+          pc += 1
+          agent_id = bytecode.getbyte(pc)
+          reg = bytecode.getbyte(pc + 1)
+          line = "#{mnemonic} #{agent_id}, R#{reg}"
+          pc += 2
+
+        when 0x83  # ATell
+          length = bytecode.getbyte(pc)
+          pc += 1
+          agent_id = bytecode.getbyte(pc)
+          reg = bytecode.getbyte(pc + 1)
+          line = "#{mnemonic} #{agent_id}, R#{reg}"
+          pc += 2
+
+        when 0x84  # ADelegate
+          length = bytecode.getbyte(pc)
+          pc += 1
+          agent_id = bytecode.getbyte(pc)
+          bc_lo = bytecode.getbyte(pc + 1)
+          bc_hi = bytecode.getbyte(pc + 2)
+          bc_start = bc_lo | (bc_hi << 8)
+          line = "#{mnemonic} #{agent_id}, #{bc_start}"
+          pc += 3
+
+        when 0x85  # ABroadcast
+          length = bytecode.getbyte(pc)
+          pc += 1
+          reg = bytecode.getbyte(pc)
+          line = "#{mnemonic} R#{reg}"
+          pc += 1
+
+        when 0x86  # ASubscribe
+          length = bytecode.getbyte(pc)
+          pc += 1
+          channel_id = bytecode.getbyte(pc)
+          line = "#{mnemonic} #{channel_id}"
+          pc += 1
+
+        when 0x87  # AWait
+          length = bytecode.getbyte(pc)
+          pc += 1
+          cond_reg = bytecode.getbyte(pc)
+          line = "#{mnemonic} R#{cond_reg}"
+          pc += 1
+
+        when 0x88  # ATrust
+          length = bytecode.getbyte(pc)
+          pc += 1
+          agent_id = bytecode.getbyte(pc)
+          level = bytecode.getbyte(pc + 1)
+          line = "#{mnemonic} #{agent_id}, #{level}"
+          pc += 2
+
+        when 0x89  # AVerify
+          length = bytecode.getbyte(pc)
+          pc += 1
+          agent_id = bytecode.getbyte(pc)
+          result_reg = bytecode.getbyte(pc + 1)
+          line = "#{mnemonic} #{agent_id}, R#{result_reg}"
+          pc += 2
+
+        else
+          pc += 3  # Skip unknown bytes
+        end
+
+        output << "    #{offset.to_s(16).rjust(8, '0')}: #{line}"
+      end
+
+      output.join("\n")
+    end
+  end
+end