using @Milky2018/wasmoon_jit/artifact/loader { type ArtifactCompatibility }

using @Milky2018/wasmoon_jit/artifact/loader { type ArtifactIncompatible }

using @Milky2018/wasmoon_jit/artifact/loader { type ArtifactLoadError }

using @Milky2018/wasmoon_runtime/native/bridge { type CHeap }

using @Milky2018/wasmoon_runtime/native/bridge { type CHeapError }

using @Milky2018/wasmoon_runtime/native/layout { type ContextLayout }

using @Milky2018/wasmoon_runtime/native/layout { type ContextShape }

using @Milky2018/wasmoon_runtime/native/ffi { type GCHeapHandle }

using @Milky2018/wasmoon_runtime/native/bridge { type GcSlot }

using @Milky2018/wasmoon_jit/artifact/installer { type InstalledCode }

using @Milky2018/wasmoon_jit/artifact/installer { type InstalledFunction }

using @Milky2018/wasmoon_jit/artifact/installer { type InstalledImport }

using @Milky2018/wasmoon_jit/artifact/installer { type InstalledTrampoline }

using @Milky2018/wasmoon_runtime/control { type InvocationControl }

using @Milky2018/wasmoon_runtime/native/bridge { type JITTable }

using @Milky2018/wasmoon_runtime/native/bridge { type JITTableOwner }

using @Milky2018/wasmoon_jit/artifact/installer { type JitCodeInstaller }

using @Milky2018/wasmoon_jit/artifact/installer { type JitInstallError }

using @Milky2018/wasmoon_runtime/native/ffi { type MemoryDescriptor }

using @Milky2018/wasmoon_runtime/native/bridge { type MemoryInfo }

using @Milky2018/wasmoon_runtime/native/bridge { type NativeAtomicWait }

using @Milky2018/wasmoon_runtime/native/callable { type NativeCallableRegistry }

using @Milky2018/wasmoon_runtime/native/ffi { type NativeContinuationArena }

using @Milky2018/wasmoon_runtime/native/ffi { type NativeExceptionArena }

using @Milky2018/wasmoon_runtime/native/execution { type NativeExecutionState }

using @Milky2018/wasmoon_runtime/native/execution { type NativeExecutionStateError }

using @Milky2018/wasmoon_runtime/native/execution { type NativeInvocationHandle }

using @Milky2018/wasmoon_runtime/native/execution { type NativeInvocationPhase }

using @Milky2018/wasmoon_runtime/native/ffi { type NativeTableHandle }

pub(all) suberror GCSetupError {
  MissingJITContext
  InvalidMetadata
  InvalidFuncCount(num_funcs~ : Int)
  FuncTypeIndicesLengthMismatch(func_type_indices_len~ : Int, num_funcs~ : Int)
  MissingFunctionTableContext(num_funcs~ : Int)
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub suberror HostcallImportTrampolineError {
  UnsupportedHostcallImportTrampoline(message~ : String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub suberror JitPipelineError {
  NativeLoweringFailed(cause~ : 
@Milky2018/milkir/native.NativeLowerError
NativeLowerError)
  AArch64AbiInvalid(cause~ : 
@Milky2018/aarch64_target.InternalAbiError
InternalAbiError)
  X64AbiInvalid(cause~ : 
@Milky2018/x64_target.InternalAbiError
InternalAbiError)
  AArch64LoweringFailed(cause~ : 
@Milky2018/aarch64_target.AArch64LowerError
AArch64LowerError)
  X64LoweringFailed(cause~ : 
@Milky2018/x64_target.X64LowerError
X64LowerError)
  AArch64CompilationFailed(cause~ : 
@Milky2018/aarch64_target.AArch64CompileError
AArch64CompileError)
  X64CompilationFailed(cause~ : 
@Milky2018/x64_target.X64CompileError
X64CompileError)
  AArch64LinkPreparationFailed(cause~ : 
@Milky2018/aarch64_target.AArch64LinkError
AArch64LinkError)
  X64LinkPreparationFailed(cause~ : 
@Milky2018/x64_target.X64LinkError
X64LinkError)
  InvalidJitRelocation(target~ : NativeTarget, index~ : Int, message~ : String)
  UnsupportedEntrySignature(message~ : String)
  UnsupportedHostArchitecture(tag~ : Int)
  UnsupportedHostOsAbi(tag~ : Int)
  InvalidFunctionIndex(index~ : Int)
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub suberror NativeFiberError {
  StackAllocationFailed(Int64)
  WrongThread
  InvalidTransition(NativeFiberPhase)
  InvalidState(Int)
  UnexpectedYield(Int64)
  NativeFailure(Int)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) suberror NativeSetupError {
  SegmentAllocationFailed
  RootFrameAllocationFailed
  ExceptionPayloadAllocationFailed
  DebugRegistrationFailed
  MemoryBindingAllocationFailed
  TableBindingAllocationFailed
  InvalidBinding(String)
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub struct BacktraceFrame {
  pc : Int64
  name : String
  offset : Int64
  func_idx : Int
}

pub(all) struct CallCounter {
  counts : Map[Int, Int]
  total_calls : Int
}

pub type DWARFBuilder

pub struct FunctionInfo {
  name : String
  func_idx : Int
  offset : Int64
}

pub(all) enum FunctionTemperature {
  Cold
  Warm
  Hot
}

pub struct GcSafepoint {
  code_offset : Int
  live_refs : Array[Int]
  metadata : Int64
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct HostcallImportTrampolineCode {
  code : Array[Int]
}

pub(all) struct HostcallImportTrampolineLayout {
  arg_slots : Int
  result_slots : Int
  values_vec_bytes : Int
  int_overflow_count : Int
  float_overflow_types : Array[
@Milky2018/wasm_core/types.ValueType
ValueType]
}

pub(all) struct HotThreshold {
  warm_threshold : Int
  hot_threshold : Int
}

pub(all) enum ImportFunctionResolution {
  DirectImportFunction(Int64)
  HostImportFunctionAddr(Int)
  UnsupportedImportFunction
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct JITDebugDB {
  entries : Map[Int, JITFunctionDebug]
}

pub struct JITFunctionDebug {
  ir : String
  target_vcode : String
  allocated_vcode : String
  machine_code : String
}

pub struct JitCodeObject {
  // private fields
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct JitIntegrationPlan {
  entry_symbol : String
  target : NativeTarget
  object : JitCodeObject
}

pub struct JitPipelineDiagnostics {
  target_vcode : String
  allocated_vcode : String
  code_object : String
  machine_code : String
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub struct LoadedArtifact {
  // private fields
}

pub(all) struct MemoryDescriptorLayout {
  base_offset : Int
  current_length_offset : Int
}

pub struct NativeCallable {
  context : NativeJITContext
  entry : 
@Milky2018/wasmoon_jit/artifact/installer.InstalledTrampoline
InstalledTrampoline
}

pub struct NativeCompiler {
  // private fields
}

type NativeFiber

pub(all) enum NativeFiberEvent {
  Yielded(Int64)
  Finished(Int64)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum NativeFiberPhase {
  Ready
  Running
  Suspended
  Returned
  Cancelled
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)