pub struct CodeBody {
  locals : Array[ValueType]
  instruction_span : Span
  byte_length : Int
}

pub struct Cursor {
  bytes : Array[Int]
  position : Int
  limit : Int
}

pub enum DataMode {
  ActiveData(Int, Span)
  PassiveData
}

pub struct DataSegment {
  mode : DataMode
  bytes : Span
}

pub enum DecodeError {
  UnexpectedEof(Int)
  InvalidLeb128(Int, String)
  InvalidHeader(String)
  InvalidSection(Int, Int, String)
  UnsupportedFeature(String, Int)
  InvalidUtf8(Int)
  ValidationError(Int, String)
}

pub struct DecodedModule {
  binary : Module
  types : Array[FunctionType]
  imports : Array[Import]
  function_types : Array[Int]
  tables : Array[TableInfo]
  memories : Array[MemoryInfo]
  globals : Array[GlobalInfo]
  exports : Array[Export]
  start_function : Int?
  code_bodies : Array[CodeBody]
  element_segments : Array[ElementSegment]
  data_segments : Array[DataSegment]
  data_count : Int?
  tags : Array[TagInfo]
  warnings : Array[String]
}

pub enum ElementMode {
  ActiveElement(Int, Span)
  PassiveElement
  DeclarativeElement
}

pub struct ElementSegment {
  mode : ElementMode
  functions : Array[Int]
}

pub struct Export {
  name : String
  kind : ExternalKind
  index : Int
}

pub enum ExternalKind {
  FunctionExternal
  TableExternal
  MemoryExternal
  GlobalExternal
  TagExternal
} derive(Eq)

pub struct FunctionCallSummary {
  function_index : Int
  callees : Array[Int]
}

pub struct FunctionName {
  index : Int
  name : String
}

pub struct FunctionType {
  params : Array[ValueType]
  results : Array[ValueType]
}

pub struct GlobalInfo {
  value_type : ValueType
  mutable : Bool
  init_span : Span
}

pub struct Import {
  module_name : String
  name : String
  kind : ExternalKind
  type_index : Int?
}

pub struct InstructionStats {
  instruction_count : Int
  control_depth : Int
  control_block_count : Int
  branch_count : Int
  call_count : Int
  called_functions : Array[Int]
  memory_access_count : Int
  local_access_count : Int
  constant_count : Int
  bulk_memory_instruction_count : Int
  simd_instruction_count : Int
}

pub enum IssueLevel {
  ErrorIssue
  WarningIssue
} derive(Eq)

pub struct Limits {
  minimum : Int
  maximum : Int?
  shared : Bool
  memory64 : Bool
}

pub struct MemoryInfo {
  limits : Limits
}

pub struct Module {
  bytes : Array[Int]
  sections : Array[Section]
  version : Int
}

pub struct ModuleStats {
  byte_length : Int
  section_count : Int
  custom_section_count : Int
  payload_bytes : Int
}

pub struct NameSection {
  module_name : String?
  function_names : Array[FunctionName]
  unknown_subsection_ids : Array[Int]
}

pub struct Section {
  id : Int
  kind : SectionKind
  payload : Span
  full : Span
  custom_name : String?
}

pub struct SectionDifference {
  label : String
  left_size : Int?
  right_size : Int?
}

pub enum SectionKind {
  Custom
  Type
  Import
  Function
  Table
  Memory
  Global
  Export
  Start
  Element
  Code
  Data
  DataCount
  Tag
} derive(Eq)

pub struct Span {
  start : Int
  end : Int
}

pub struct TableInfo {
  element_type : ValueType
  limits : Limits
}

pub struct TagInfo {
  type_index : Int
}

pub struct ValidationIssue {
  level : IssueLevel
  rule : String
  message : String
}

pub struct ValidationReport {
  issues : Array[ValidationIssue]
}

pub enum ValueType {
  I32
  I64
  F32
  F64
  V128
  FuncRef
  ExternRef
}

pub enum WasmFeature {
  MultiMemory
  Memory64
  Threads
  BulkMemory
  ReferenceTypes
  ExceptionHandling
  Simd
}

fn build_call_graph(decoded : DecodedModule) -> Result[Array[FunctionCallSummary], DecodeError]

fn data_segment_bytes(binary : Module, segment : DataSegment) -> Array[Int]

fn decode_data_segments(binary : Module) -> Result[Array[DataSegment], DecodeError]

fn decode_element_segments(binary : Module) -> Result[Array[ElementSegment], DecodeError]

fn decode_module(binary : Module) -> Result[DecodedModule, DecodeError]

fn decode_name_section(binary : Module) -> Result[NameSection?, DecodeError]

fn detect_features(decoded : DecodedModule) -> Array[WasmFeature]

fn diff_structure(left : Module, right : Module) -> Array[SectionDifference]

fn parse_module(bytes : Array[Int]) -> Result[Module, DecodeError]

fn render_data_segments(segments : Array[DataSegment]) -> String

fn render_decoded(decoded : DecodedModule) -> String

fn render_element_segments(segments : Array[ElementSegment]) -> String

fn render_features(features : Array[WasmFeature]) -> String

fn render_structure(binary : Module) -> String

fn render_structure_diff(left : Module, right : Module) -> String

fn render_structure_json(binary : Module) -> String

fn render_validation_json(report : ValidationReport) -> String

fn scan_code_body(binary : Module, body : CodeBody) -> Result[InstructionStats, DecodeError]

fn scan_instructions(bytes : Array[Int], span : Span) -> Result[InstructionStats, DecodeError]

fn section_kind_from_id(id : Int) -> SectionKind?

fn validate(decoded : DecodedModule) -> ValidationReport