🥮 mooncakes.io

wasm_component

Portable WebAssembly Component Model syntax and validation

wasm
webassembly
component-model
wit
Download zip
Author
Version
0.14.0
License
Apache-2.0
Repository
Last updated
17 hours ago
Downloads
3

Dependencies

#wasm_component

Portable syntax, binary decoding, canonical ABI modeling, validation, and text tooling for the WebAssembly Component Model.

The module is independent of Wasmoon runtime objects, JIT execution, WASI, and native host bindings. Product runtimes consume its validated component model through their own adapters.

Milky2018/wasmoon/component is the Wasmoon runtime facade, and Milky2018/wasmoon/wit_binding adapts a resolved portable WIT world to a live Wasmoon component instance.

#Packages

  • Milky2018/wasm_component: component types, binary decoding, and canonical ABI helpers.
  • Milky2018/wasm_component/validator: component validation and immutable validation evidence.
  • Milky2018/wasm_component/text: Component Model text parsing and encoding.
  • Milky2018/wasm_component/wit: WIT parsing, resolution, formatting, and Component Model encoding and decoding.

ComponentParseError

source
pub suberror ComponentParseError {
  InvalidMagic
  UnexpectedEndOfInput
  Leb128TooLarge
  NotAComponent
  UnsupportedComponentPreamble(Int, Int)
  InvalidTypeSection
  InvalidInstanceSection
  InvalidAliasSection
  InvalidCanonSection
  InvalidStartSection
  UnsupportedCanonOpcode(Int)
  InvalidUtf8
  UnsupportedTypeOpcode(Int)
}

ComponentParseError::output

source
fn ComponentParseError::output(self : ComponentParseError, logger : &Logger) -> Unit

ComponentParseError::to_string

source
fn ComponentParseError::to_string(self : ComponentParseError) -> String

Alias

source
pub(all) struct Alias {
  sort : Sort
  target : AliasTarget
} derive(Eq, 
Debug)

impl Show for Alias

Alias::equal

source
fn Alias::equal(Alias, Alias) -> Bool

Alias::not_equal

source
fn Alias::not_equal(x : Alias, y : Alias) -> Bool

Alias::output

source
fn Alias::output(self : Alias, logger : &Logger) -> Unit

Alias::to_repr

source

Alias::to_string

source
fn Alias::to_string(self : Alias) -> String

AliasTarget

source
pub(all) enum AliasTarget {
  Export(Int, String)
  CoreExport(Int, String)
  Outer(Int, Int)
} derive(Eq, 
Debug)

AliasTarget::equal

source
fn AliasTarget::equal(AliasTarget, AliasTarget) -> Bool

AliasTarget::not_equal

source
fn AliasTarget::not_equal(x : AliasTarget, y : AliasTarget) -> Bool

AliasTarget::to_repr

source

BinaryKind

source
pub(all) enum BinaryKind {
  CoreModule
  Component
  UnknownPreamble(Int, Int)
} derive(Eq, 
Debug)

impl Show for BinaryKind

BinaryKind::equal

source
fn BinaryKind::equal(BinaryKind, BinaryKind) -> Bool

BinaryKind::not_equal

source
fn BinaryKind::not_equal(x : BinaryKind, y : BinaryKind) -> Bool

BinaryKind::output

source
fn BinaryKind::output(self : BinaryKind, logger : &Logger) -> Unit

BinaryKind::to_repr

source

BinaryKind::to_string

source
fn BinaryKind::to_string(self : BinaryKind) -> String

Canon

source
pub(all) enum Canon {
  Lift(Int, Array[CanonOpt], Int)
  Lower(Int, Array[CanonOpt])
  BackpressureInc
  BackpressureDec
  ContextGet(
ValueType, Int)
  ContextSet(
ValueType, Int)
  TaskReturn(ValType?, Array[CanonOpt])
  TaskCancel
  ThreadIndex
  ThreadYield(Bool)
  ThreadSuspendThenResume(Bool)
  ThreadYieldThenResume(Bool)
  ThreadSuspendThenPromote(Bool)
  ThreadYieldThenPromote(Bool)
  ThreadResumeLater
  ThreadSuspend(Bool)
  ThreadNewIndirect(Int, Int)
  WaitableSetNew
  WaitableSetWait(Bool, Int)
  WaitableSetPoll(Bool, Int)
  WaitableSetDrop
  WaitableJoin
  SubtaskCancel(Bool)
  SubtaskDrop
  StreamNew(Int)
  StreamRead(Int, Array[CanonOpt])
  StreamWrite(Int, Array[CanonOpt])
  StreamCancelRead(Int, Bool)
  StreamCancelWrite(Int, Bool)
  StreamDropReadable(Int)
  StreamDropWritable(Int)
  FutureNew(Int)
  FutureRead(Int, Array[CanonOpt])
  FutureWrite(Int, Array[CanonOpt])
  FutureCancelRead(Int, Bool)
  FutureCancelWrite(Int, Bool)
  FutureDropReadable(Int)
  FutureDropWritable(Int)
  ErrorContextNew(Array[CanonOpt])
  ErrorContextDebugMessage(Array[CanonOpt])
  ErrorContextDrop
  ResourceNew(Int)
  ResourceDrop(Int)
  ResourceRep(Int)
} derive(Eq, 
Debug)

impl Show for Canon

Canon::equal

source
fn Canon::equal(Canon, Canon) -> Bool

Canon::not_equal

source
fn Canon::not_equal(x : Canon, y : Canon) -> Bool

Canon::output

source
fn Canon::output(self : Canon, logger : &Logger) -> Unit

Canon::to_repr

source

Canon::to_string

source
fn Canon::to_string(self : Canon) -> String

CanonOpt

source
pub(all) enum CanonOpt {
  StringEncoding(StringEncoding)
  Memory(Int)
  Realloc(Int)
  PostReturn(Int)
  CoreType(Int)
  Gc
  Async
  Callback(Int)
} derive(Eq, 
Debug)

CanonOpt::equal

source
fn CanonOpt::equal(CanonOpt, CanonOpt) -> Bool

CanonOpt::not_equal

source
fn CanonOpt::not_equal(x : CanonOpt, y : CanonOpt) -> Bool

CanonOpt::to_repr

source

Component

source
pub(all) struct Component {
  binary : ComponentBinary
  core_modules : Array[Bytes]
  core_instances : Array[Bytes]
  core_types : Array[Bytes]
  types : Array[TypeDef]
  imports : Array[Import]
  exports : Array[Export]
  instances : Array[Instance]
  aliases : Array[Alias]
  canons : Array[Canon]
  start : Start?
  components : Array[Component]
} derive(Eq, 
Debug)

impl Show for Component

Component::equal

source
fn Component::equal(Component, Component) -> Bool

Component::isolated_copy

source
fn Component::isolated_copy(self : Component) -> Component raise ComponentParseError

Rebuild a component that shares no mutable state with self.

Component::not_equal

source
fn Component::not_equal(x : Component, y : Component) -> Bool

Component::output

source
fn Component::output(self : Component, logger : &Logger) -> Unit

Component::snapshot_bytes

source
fn Component::snapshot_bytes(self : Component) -> Bytes

Encode the component's immutable binary snapshot.

Bytes is immutable, so validation evidence can retain and expose this value without granting mutation access to the parsed component graph.

Component::to_repr

source

Component::to_string

source
fn Component::to_string(self : Component) -> String

ComponentBinary

source
pub struct ComponentBinary {
  version : Int
  layer : Int
  sections : Array[Section]
} derive(Eq, 
Debug)

ComponentBinary::equal

source

ComponentBinary::not_equal

source
fn ComponentBinary::not_equal(x : ComponentBinary, y : ComponentBinary) -> Bool

ComponentBinary::to_repr

source

ComponentDecl

source
pub(all) enum ComponentDecl {
  CoreType(Bytes)
  Type(TypeDef)
  AliasOuter(Int, Int, Int)
  AliasInstanceExport(Int, Int, String)
  Import(String, Array[NameAttribute], ExternDesc)
  Export(String, Array[NameAttribute], ExternDesc)
} derive(Eq, 
Debug)

A subset of component type declarations (enough for WIT-encoded components).

ComponentDecl::equal

source

ComponentDecl::not_equal

source
fn ComponentDecl::not_equal(x : ComponentDecl, y : ComponentDecl) -> Bool

ComponentDecl::to_repr

source

CoreInlineExport

source
pub(all) struct CoreInlineExport {
  name : String
  sortidx : SortIdx
} derive(Eq, 
Debug)

CoreInlineExport::equal

source

CoreInlineExport::not_equal

source
fn CoreInlineExport::not_equal(x : CoreInlineExport, y : CoreInlineExport) -> Bool

CoreInlineExport::to_repr

source

CoreInstanceDecl

source
pub(all) struct CoreInstanceDecl {
  expr : CoreInstanceExpr
} derive(Eq, 
Debug)

CoreInstanceDecl::equal

source

CoreInstanceDecl::not_equal

source
fn CoreInstanceDecl::not_equal(x : CoreInstanceDecl, y : CoreInstanceDecl) -> Bool

CoreInstanceDecl::to_repr

source

CoreInstanceExpr

source
pub(all) enum CoreInstanceExpr {
  Instantiate(Int, Array[CoreInstantiateArg])
  InlineExports(Array[CoreInlineExport])
} derive(Eq, 
Debug)

CoreInstanceExpr::equal

source

CoreInstanceExpr::not_equal

source
fn CoreInstanceExpr::not_equal(x : CoreInstanceExpr, y : CoreInstanceExpr) -> Bool

CoreInstanceExpr::to_repr

source

CoreInstantiateArg

source
pub(all) struct CoreInstantiateArg {
  name : String
  sortidx : SortIdx
} derive(Eq, 
Debug)

CoreInstantiateArg::equal

source

CoreInstantiateArg::not_equal

source

CoreInstantiateArg::to_repr

source

Export

source
pub(all) struct Export {
  name : ExportName
  attributes : Array[NameAttribute]
  sortidx : SortIdx
  desc : ExternDesc?
} derive(Eq, 
Debug)

Export::equal

source
fn Export::equal(Export, Export) -> Bool

Export::not_equal

source
fn Export::not_equal(x : Export, y : Export) -> Bool

Export::to_repr

source

ExportName

source
pub(all) enum ExportName {
  Plain(Bytes)
  WithVersion(Bytes, Bytes)
} derive(Eq, 
Debug)

ExportName::equal

source
fn ExportName::equal(ExportName, ExportName) -> Bool

ExportName::not_equal

source
fn ExportName::not_equal(x : ExportName, y : ExportName) -> Bool

ExportName::to_repr

source

ExternDesc

source
pub(all) enum ExternDesc {
  CoreModuleType(Int)
  FuncType(Int)
  Value(ValueBound)
  Type(TypeBound)
  ComponentType(Int)
  InstanceType(Int)
} derive(Eq, 
Debug)

impl Show for ExternDesc

ExternDesc::equal

source
fn ExternDesc::equal(ExternDesc, ExternDesc) -> Bool

ExternDesc::not_equal

source
fn ExternDesc::not_equal(x : ExternDesc, y : ExternDesc) -> Bool

ExternDesc::output

source
fn ExternDesc::output(self : ExternDesc, logger : &Logger) -> Unit

ExternDesc::to_repr

source

ExternDesc::to_string

source
fn ExternDesc::to_string(self : ExternDesc) -> String

FuncType

source
pub(all) struct FuncType {
  is_async : Bool
  params : Array[Param]
  result : ValType?
} derive(Eq, 
Debug)

FuncType::equal

source
fn FuncType::equal(FuncType, FuncType) -> Bool

FuncType::not_equal

source
fn FuncType::not_equal(x : FuncType, y : FuncType) -> Bool

FuncType::to_repr

source

Import

source
pub(all) struct Import {
  name : ImportName
  attributes : Array[NameAttribute]
  desc : ExternDesc
} derive(Eq, 
Debug)

Import::equal

source
fn Import::equal(Import, Import) -> Bool

Import::not_equal

source
fn Import::not_equal(x : Import, y : Import) -> Bool

Import::to_repr

source

ImportName

source
pub(all) enum ImportName {
  Plain(Bytes)
  WithVersion(Bytes, Bytes)
} derive(Eq, 
Debug)

ImportName::equal

source
fn ImportName::equal(ImportName, ImportName) -> Bool

ImportName::not_equal

source
fn ImportName::not_equal(x : ImportName, y : ImportName) -> Bool

ImportName::to_repr

source

InlineExport

source
pub(all) struct InlineExport {
  name : String
  attributes : Array[NameAttribute]
  sortidx : SortIdx
} derive(Eq, 
Debug)

InlineExport::equal

source

InlineExport::not_equal

source
fn InlineExport::not_equal(x : InlineExport, y : InlineExport) -> Bool

InlineExport::to_repr

source

Instance

source
pub(all) struct Instance {
  expr : InstanceExpr
} derive(Eq, 
Debug)

Instance::equal

source
fn Instance::equal(Instance, Instance) -> Bool

Instance::not_equal

source
fn Instance::not_equal(x : Instance, y : Instance) -> Bool

Instance::to_repr

source

InstanceDecl

source
pub(all) enum InstanceDecl {
  CoreType(Bytes)
  Type(TypeDef)
  AliasOuter(Int, Int, Int)
  AliasInstanceExport(Int, Int, String)
  Export(String, Array[NameAttribute], ExternDesc)
} derive(Eq, 
Debug)

A subset of instance type declarations (enough for wasmtime/component-spec).

InstanceDecl::equal

source

InstanceDecl::not_equal

source
fn InstanceDecl::not_equal(x : InstanceDecl, y : InstanceDecl) -> Bool

InstanceDecl::to_repr

source

InstanceExpr

source
pub(all) enum InstanceExpr {
  Instantiate(Int, Array[InstantiateArg])
  InlineExports(Array[InlineExport])
} derive(Eq, 
Debug)

InstanceExpr::equal

source

InstanceExpr::not_equal

source
fn InstanceExpr::not_equal(x : InstanceExpr, y : InstanceExpr) -> Bool

InstanceExpr::output

source
fn InstanceExpr::output(self : InstanceExpr, logger : &Logger) -> Unit

InstanceExpr::to_repr

source

InstanceExpr::to_string

source
fn InstanceExpr::to_string(self : InstanceExpr) -> String

InstantiateArg

source
pub(all) struct InstantiateArg {
  name : String
  sortidx : SortIdx
} derive(Eq, 
Debug)

InstantiateArg::equal

source

InstantiateArg::not_equal

source
fn InstantiateArg::not_equal(x : InstantiateArg, y : InstantiateArg) -> Bool

InstantiateArg::to_repr

source

NameAttribute

source
pub(all) enum NameAttribute {
  Implements(Bytes)
  VersionSuffix(Bytes)
  ExternalId(Bytes)
} derive(Eq, 
Debug)

NameAttribute::equal

source

NameAttribute::not_equal

source
fn NameAttribute::not_equal(x : NameAttribute, y : NameAttribute) -> Bool

NameAttribute::to_repr

source

Param

source
pub(all) struct Param {
  label : String
  ty : ValType
} derive(Eq, 
Debug)

Param::equal

source
fn Param::equal(Param, Param) -> Bool

Param::not_equal

source
fn Param::not_equal(x : Param, y : Param) -> Bool

Param::to_repr

source

PrimValType

source
pub(all) enum PrimValType {
  Bool
  S8
  U8
  S16
  U16
  S32
  U32
  S64
  U64
  F32
  F64
  Char
  String
  ErrorContext
} derive(Eq, 
Debug)

PrimValType::equal

source
fn PrimValType::equal(PrimValType, PrimValType) -> Bool

PrimValType::not_equal

source
fn PrimValType::not_equal(x : PrimValType, y : PrimValType) -> Bool

PrimValType::to_repr

source

RecordField

source
pub(all) struct RecordField {
  label : String
  ty : ValType
} derive(Eq, 
Debug)

RecordField::equal

source
fn RecordField::equal(RecordField, RecordField) -> Bool

RecordField::not_equal

source
fn RecordField::not_equal(x : RecordField, y : RecordField) -> Bool

RecordField::to_repr

source

ResourceKind

source
pub(all) enum ResourceKind {
  GuestDefined
  HostDefined
} derive(Eq, 
Debug)

ResourceKind::equal

source

ResourceKind::not_equal

source
fn ResourceKind::not_equal(x : ResourceKind, y : ResourceKind) -> Bool

ResourceKind::to_repr

source

Section

source
pub struct Section {
  id : Int
  payload : Bytes
} derive(Eq, 
Debug)

Section::equal

source
fn Section::equal(Section, Section) -> Bool

Section::not_equal

source
fn Section::not_equal(x : Section, y : Section) -> Bool

Section::to_repr

source

Sort

source
pub(all) enum Sort {
  Core(Int)
  Func
  Value
  Type
  Component
  Instance
} derive(Eq, 
Debug)

Sort::equal

source
fn Sort::equal(Sort, Sort) -> Bool

Sort::not_equal

source
fn Sort::not_equal(x : Sort, y : Sort) -> Bool

Sort::to_repr

source

SortIdx

source
pub(all) struct SortIdx {
  sort : Sort
  idx : Int
} derive(Eq, 
Debug)

impl Show for SortIdx

SortIdx::equal

source
fn SortIdx::equal(SortIdx, SortIdx) -> Bool

SortIdx::not_equal

source
fn SortIdx::not_equal(x : SortIdx, y : SortIdx) -> Bool

SortIdx::output

source
fn SortIdx::output(self : SortIdx, logger : &Logger) -> Unit

SortIdx::to_repr

source

SortIdx::to_string

source
fn SortIdx::to_string(self : SortIdx) -> String

Start

source
pub(all) struct Start {
  func_idx : Int
  args : Array[Int]
  results : Int
} derive(Eq, 
Debug)

impl Show for Start

Start::equal

source
fn Start::equal(Start, Start) -> Bool

Start::not_equal

source
fn Start::not_equal(x : Start, y : Start) -> Bool

Start::output

source
fn Start::output(self : Start, logger : &Logger) -> Unit

Start::to_repr

source

Start::to_string

source
fn Start::to_string(self : Start) -> String

StringEncoding

source
pub(all) enum StringEncoding {
  Utf8
  Utf16
  Latin1Utf16
} derive(Eq, 
Debug)

StringEncoding::equal

source

StringEncoding::not_equal

source
fn StringEncoding::not_equal(x : StringEncoding, y : StringEncoding) -> Bool

StringEncoding::to_repr

source

TypeBound

source
pub(all) enum TypeBound {
  Eq(Int)
  SubResource
} derive(Eq, 
Debug)

TypeBound::equal

source
fn TypeBound::equal(TypeBound, TypeBound) -> Bool

TypeBound::not_equal

source
fn TypeBound::not_equal(x : TypeBound, y : TypeBound) -> Bool

TypeBound::to_repr

source

TypeDef

source
pub(all) enum TypeDef {
  DefValType(PrimValType)
  FuncType(FuncType)
  List(ValType)
  FixedList(ValType, Int)
  MapType(ValType, ValType)
  Record(Array[RecordField])
  Variant(Array[VariantCase])
  Tuple(Array[ValType])
  Flags(Array[String])
  Enum(Array[String])
  Option(ValType)
  Result(ValType?, ValType?)
  Own(Int)
  Borrow(Int)
  Stream(ValType?)
  Future(ValType?)
  ResourceType(Int, Int, Int?, ResourceKind)
  ComponentType(Array[ComponentDecl])
  InstanceTypeEmpty
  InstanceType(Array[InstanceDecl])
} derive(Eq, 
Debug)

impl Show for TypeDef

TypeDef::equal

source
fn TypeDef::equal(TypeDef, TypeDef) -> Bool

TypeDef::not_equal

source
fn TypeDef::not_equal(x : TypeDef, y : TypeDef) -> Bool

TypeDef::output

source
fn TypeDef::output(self : TypeDef, logger : &Logger) -> Unit

TypeDef::to_repr

source

TypeDef::to_string

source
fn TypeDef::to_string(self : TypeDef) -> String

ValType

source
pub(all) enum ValType {
  TypeIdx(Int)
  Prim(PrimValType)
} derive(Eq, 
Debug)

ValType::equal

source
fn ValType::equal(ValType, ValType) -> Bool

ValType::not_equal

source
fn ValType::not_equal(x : ValType, y : ValType) -> Bool

ValType::to_repr

source

ValueBound

source
pub(all) enum ValueBound {
  Eq(Int)
  Type(ValType)
} derive(Eq, 
Debug)

ValueBound::equal

source
fn ValueBound::equal(ValueBound, ValueBound) -> Bool

ValueBound::not_equal

source
fn ValueBound::not_equal(x : ValueBound, y : ValueBound) -> Bool

ValueBound::to_repr

source

VariantCase

source
pub(all) struct VariantCase {
  label : String
  ty : ValType?
  refines : Int?
} derive(Eq, 
Debug)

VariantCase::equal

source
fn VariantCase::equal(VariantCase, VariantCase) -> Bool

VariantCase::not_equal

source
fn VariantCase::not_equal(x : VariantCase, y : VariantCase) -> Bool

VariantCase::to_repr

source

canonical_flat_types

source

Return the Canonical ABI flat core value types for one component value.

pointer_type must be I32 or I64 and represents the selected canonical memory. None means the type index is invalid, recursive, or does not name a value type.

canonical_lift_core_func_type

source
fn canonical_lift_core_func_type(func_type : FuncType, types : Array[TypeDef?], pointer_type : 
ValueType) -> 
FuncType?

Return the Canonical ABI core signature consumed by canon lift.

More than sixteen flat parameters use one indirect pointer. A result with more than one flat value is returned as a pointer to the result area.

canonical_lower_core_func_type

source
fn canonical_lower_core_func_type(func_type : FuncType, types : Array[TypeDef?], pointer_type : 
ValueType) -> 
FuncType?

Return the Canonical ABI core signature produced by canon lower.

More than sixteen flat parameters use one indirect pointer. A result with more than one flat value appends an indirect result pointer to the core parameters.

parse_alias_section

source
fn parse_alias_section(payload : Bytes) -> Array[Alias] raise ComponentParseError

parse_canon_section

source
fn parse_canon_section(payload : Bytes) -> Array[Canon] raise ComponentParseError

parse_component

source
fn parse_component(bytes : Bytes) -> Component raise ComponentParseError

parse_component_binary

source
fn parse_component_binary(bytes : Bytes) -> ComponentBinary raise ComponentParseError

parse_core_instance_section

source
fn parse_core_instance_section(payload : Bytes) -> Array[CoreInstanceDecl] raise ComponentParseError

parse_export_section

source
fn parse_export_section(payload : Bytes) -> Array[Export] raise ComponentParseError

parse_import_section

source
fn parse_import_section(payload : Bytes) -> Array[Import] raise ComponentParseError

parse_instance_section

source
fn parse_instance_section(payload : Bytes) -> Array[Instance] raise ComponentParseError

parse_start_section

source
fn parse_start_section(payload : Bytes) -> Start raise ComponentParseError

parse_type_section

source
fn parse_type_section(payload : Bytes) -> Array[TypeDef] raise ComponentParseError

sniff_binary_kind

source
fn sniff_binary_kind(bytes : Bytes) -> BinaryKind?

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io