🥮 mooncakes.io
    Sign in

    #wasmoon_jit/artifact

    Target-portable ordinary data for Wasmoon Cwasm files and persistent JIT cache entries.

    The package defines the compatibility manifest, stable import and function identities, logical signatures, and the complete unlinked code-object payload. Relocations remain symbolic. Artifacts never contain process addresses, executable-memory addresses, linked images, MilkIR, MachV, Target VCode, allocation results, or frame-planning objects.

    Decoding and encoding belong to this package. Compatibility checks, target code-object verification, symbol resolution, executable-memory allocation, and installation belong to the native Milky2018/wasmoon_jit facade.

    decode treats every input as untrusted. DecodeLimits bounds the file, function and import counts, strings, signatures, code, relocations, metadata, and safepoint roots before allocation. Malformed input, incompatible versions, invalid UTF-8, unknown tags, truncation, and limit violations are reported as structured ArtifactDecodeError values.

    ArtifactDecodeError

    source
    pub suberror ArtifactDecodeError {
      ArtifactTooLarge(size~ : Int, limit~ : Int)
      BadMagic
      UnsupportedVersion(version~ : Int)
      Truncated(field~ : String, offset~ : Int, needed~ : Int, remaining~ : Int)
      InvalidTag(field~ : String, tag~ : Int)
      InvalidValue(field~ : String, message~ : String)
      InvalidUtf8(field~ : String)
      LimitExceeded(field~ : String, count~ : Int, limit~ : Int)
      TrailingBytes(count~ : Int)
    } derive(Eq, 
    Debug    )

    ArtifactEncodeError

    source
    pub suberror ArtifactEncodeError {
      InvalidArtifactField(field~ : String, message~ : String)
    } derive(Eq, 
    Debug    )

    Artifact

    source
    pub(all) struct Artifact {
      manifest : CompatibilityManifest
      imports : Array[ImportIdentity]
      functions : Array[FunctionCode]
    } derive(Eq, 
    Debug    )

    Target-portable ordinary data contained in one Cwasm file or cache entry.

    CallBinding

    source
    pub(all) enum CallBinding {
      StableEntry
      DirectBody
    } derive(Eq, 
    Debug    )

    Binding policy for internal direct and tail calls.

    CodeModel

    source
    pub(all) enum CodeModel {
      Small
      Large
    } derive(Eq, 
    Debug    )

    Addressing range selected by target emission.

    CompatibilityManifest

    source
    pub(all) struct CompatibilityManifest {
      format_version : Int
      target : TargetSpec
      required_cpu_features : Array[CpuFeature]
      jit_abi_version : Int
      codegen_revision : String
      module_identity : ModuleIdentity
      policy : CompilationPolicy
    } derive(Eq, 
    Debug    )

    Complete compatibility contract checked before code-object verification.

    Every field matches exactly except required_cpu_features, for which the installing host may provide a strict superset.

    CompilationPolicy

    source
    pub(all) struct CompilationPolicy {
      optimization_level : OptimizationLevel
      code_model : CodeModel
      call_binding : CallBinding
      cancellation_safepoints : Bool
      debug_info : Bool
    } derive(Eq, 
    Debug    )

    Compilation choices that change generated code or its runtime contract.

    CpuFeature

    source
    pub(all) struct CpuFeature {
      name : String
    } derive(Eq, 
    Debug    )

    A target CPU feature required by every function in the artifact.

    Names are stable wire identities. Compatibility validation rejects names that are not known for TargetSpec::architecture; it never guesses a fallback feature.

    DecodeLimits

    source
    pub(all) struct DecodeLimits {
      max_artifact_bytes : Int
      max_imports : Int
      max_functions : Int
      max_cpu_features : Int
      max_string_bytes : Int
      max_signature_values : Int
      max_code_bytes_per_function : Int
      max_total_code_bytes : Int
      max_relocations_per_function : Int
      max_sources_per_function : Int
      max_traps_per_function : Int
      max_safepoints_per_function : Int
      max_unwind_directives_per_function : Int
      max_roots_per_safepoint : Int
    } derive(Eq, 
    Debug    )

    Resource limits applied before allocating variable-length artifact data.

    DecodeLimits::default

    source
    fn DecodeLimits::default() -> DecodeLimits

    Digest

    source
    pub(all) struct Digest {
      bytes : Bytes
    } derive(Eq)

    Content digest used for source-module and semantic-feature identity.

    The Cwasm codec accepts exactly 32 bytes and interprets them as SHA-256.
    impl Debug for Digest

    FunctionCode

    source

    Serializable ordinary-data form of one unlinked target code object.

    This record deliberately contains symbolic relocations and no resolved process or executable-memory address. The Wasmoon JIT root reconstructs and verifies UnlinkedCodeObject values from these fields before installation.

    FunctionIdentity

    source
    pub(all) struct FunctionIdentity {
      function_index : Int
      symbol : 
    CodeSymbol
      signature : 
    Signature
    } derive(Eq, 
    Debug    )

    Stable identity and logical signature for a defined function.

    ImportIdentity

    source
    pub(all) struct ImportIdentity {
      function_index : Int
      module_name : String
      function_name : String
      symbol : 
    ExternalSymbol
      signature : 
    Signature
    } derive(Eq, 
    Debug    )

    Stable identity and logical signature for an imported function.

    ModuleIdentity

    source
    pub(all) struct ModuleIdentity {
      name : String
      source_digest : Digest
      semantic_features_digest : Digest
    } derive(Eq, 
    Debug    )

    Identity of the validated WebAssembly module that produced this artifact.

    OperatingSystemAbi

    source
    pub(all) enum OperatingSystemAbi {
      MacOS
      LinuxGnu
      LinuxMusl
      WindowsMsvc
    } derive(Eq, 
    Debug    )

    Operating-system ABI assumed by generated code and unwind metadata.

    OptimizationLevel

    source
    pub(all) enum OptimizationLevel {
      O0
      O1
      O2
      O3
    } derive(Eq, 
    Debug    )

    MilkIR optimization level used before target lowering.

    PointerWidth

    source
    pub(all) enum PointerWidth {
      Bits64
    } derive(Eq, 
    Debug    )

    Pointer width assumed by the Wasmoon JIT ABI.

    TargetSpec

    source
    pub(all) struct TargetSpec {
      architecture : 
    Architecture
      operating_system_abi : OperatingSystemAbi
      endianness : 
    Endianness
      pointer_width : PointerWidth
    } derive(Eq, 
    Debug    )

    Exact target and platform contract for the persisted machine code.

    FORMAT_VERSION

    source
    let FORMAT_VERSION : Int

    The first breaking Cwasm format after the legacy v8 representation.

    decode

    source
    fn decode(data : Bytes, limits? : DecodeLimits) -> Artifact raise ArtifactDecodeError

    Decode untrusted v9 Cwasm bytes into ordinary artifact data.

    This function performs bounded structural decoding only. The native wasmoon_jit facade performs compatibility and code-object verification before installation.

    encode

    source
    fn encode(artifact : Artifact) -> Bytes raise ArtifactEncodeError

    Encode one v9 Cwasm artifact without resolving symbolic relocations.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io