🥮 mooncakes.io
    Sign in

    moongrammata

    Structure-aware feedback-guided fuzzing toolkit for MoonBit

    fuzzing
    grammar
    testing
    structured-input
    quality-assurance
    Download zip
    Version
    0.1.1
    License
    Apache-2.0
    Repository
    Last updated
    22 days ago
    Downloads
    56

    No dependencies

    #MoonGrammata

    Structure-aware, feedback-guided fuzzing for MoonBit.

    ///|
    let builder = @grammata.GrammarBuilder::new()

    ///|
    let digit = builder.ascii_range('0', '9')

    ///|
    let document = builder.repeat(digit, minimum=1, maximum=16)

    ///|
    let grammar = builder.set_start(document).build().unwrap()

    ///|
    let tree = grammar.generate(seed=42L).unwrap()

    The core provides bounded grammar generation, derivation-tree mutation and crossover, novelty corpus scheduling, failure-preserving reduction, differential/metamorphic oracles, deterministic replay, and evidence reports. See the repository README for the full contract and runnable examples.

    AdmissionDecision

    source
    pub(all) enum AdmissionDecision {
      Admitted(Int, AdmissionReason)
      Rejected(RejectionReason)
    } derive(Eq, 
    Debug    )

    AdmissionReason

    source
    pub(all) enum AdmissionReason {
      FirstInput
      NovelFeature(Int)
      NovelSignature
      NewFailure(FailureFingerprint)
    } derive(Eq, 
    Debug    )

    Alternative

    source
    pub(all) struct Alternative {
      rule : RuleId
      weight : Int
      label : String
    } derive(Eq, 
    Debug    )

    AnalysisError

    source
    pub(all) enum AnalysisError {
      UnproductiveStartRule(Int)
      UnproductiveRule(Int)
      NoTerminatingAlternative(Int)
      MinimumCostOverflow(Int)
    } derive(Eq, 
    Debug    )

    CampaignConfig

    source
    pub(all) struct CampaignConfig {
      seed : Int64
      executions : Int
      initial_inputs : Int
      crossover_percent : Int
      generation_budget : GenerationBudget
      mutation_config : MutationConfig
      crossover_config : CrossoverConfig
      corpus_limits : CorpusLimits
      max_events : Int
    } derive(Eq, 
    Debug    )

    CampaignConfig::default

    source
    fn CampaignConfig::default(seed? : Int64) -> CampaignConfig

    CampaignError

    source
    pub(all) enum CampaignError {
      InvalidCampaignConfig(String)
      InitialGenerationFailed(GenerationError)
      CorpusCouldNotBeSeeded
    } derive(Eq, 
    Debug    )

    CampaignEvent

    source
    pub(all) struct CampaignEvent {
      execution : Int
      input_bytes : Int
      corpus_entries : Int
      kind : CampaignEventKind
    } derive(Eq, 
    Debug    )

    CampaignEventKind

    source
    pub(all) enum CampaignEventKind {
      Generated
      Mutated(MutationStrategy)
      Crossed
      Admitted(AdmissionReason)
      RejectedInput(RejectionReason)
      FailureFound(FailureFingerprint)
      MutationSkipped
    } derive(Eq, 
    Debug    )

    CampaignResult

    source
    pub(all) struct CampaignResult {
      statistics : CampaignStatistics
      corpus : Array[CorpusEntry]
      failures : Array[ReplayRecord]
      events : Array[CampaignEvent]
    } derive(Eq, 
    Debug    )

    CampaignResult::json_report

    source
    fn CampaignResult::json_report(self : CampaignResult) -> String

    CampaignResult::markdown_report

    source
    fn CampaignResult::markdown_report(self : CampaignResult, title? : String) -> String

    CampaignResult::strategy_evidence

    source
    fn CampaignResult::strategy_evidence(self : CampaignResult, name : String) -> StrategyEvidence

    CampaignStatistics

    source
    pub(all) struct CampaignStatistics {
      requested_executions : Int
      completed_executions : Int
      generated_inputs : Int
      mutated_inputs : Int
      crossed_inputs : Int
      admitted_inputs : Int
      rejected_inputs : Int
      unique_failures : Int
      mutation_failures : Int
      final_corpus : CorpusStatistics
    } derive(Eq, 
    Debug    )

    Corpus

    source
    pub struct Corpus {
      entries : Array[CorpusEntry]
      limits : CorpusLimits
      registry : FeatureRegistry
      input_ids : 
    HashMap    [String, Int]
      failure_ids : 
    HashMap    [FailureFingerprint, Int]
      total_bytes : Int
      failure_count : Int
    }

    Corpus::consider

    source
    fn Corpus::consider(self : Corpus, tree : DerivationTree, observation : TargetObservation, origin : CorpusOrigin) -> AdmissionDecision

    Corpus::entries

    source
    fn Corpus::entries(self : Corpus) -> Array[CorpusEntry]

    Corpus::entry

    source
    fn Corpus::entry(self : Corpus, id : Int) -> CorpusEntry?

    Corpus::failure_entry

    source
    fn Corpus::failure_entry(self : Corpus, fingerprint : FailureFingerprint) -> CorpusEntry?

    Corpus::feature_frequency

    source
    fn Corpus::feature_frequency(self : Corpus, value : Feature) -> Int

    Corpus::find_input

    source
    fn Corpus::find_input(self : Corpus, input : Bytes) -> CorpusEntry?

    Corpus::is_empty

    source
    fn Corpus::is_empty(self : Corpus) -> Bool

    Corpus::length

    source
    fn Corpus::length(self : Corpus) -> Int

    Corpus::new

    source
    fn Corpus::new(limits? : CorpusLimits) -> Corpus

    Corpus::signature_frequency

    source
    fn Corpus::signature_frequency(self : Corpus, value : FeedbackSignature) -> Int

    Corpus::smallest_failure

    source
    fn Corpus::smallest_failure(self : Corpus, fingerprint : FailureFingerprint) -> CorpusEntry?

    Corpus::statistics

    source
    fn Corpus::statistics(self : Corpus) -> CorpusStatistics

    CorpusEntry

    source
    pub(all) struct CorpusEntry {
      id : Int
      tree : DerivationTree
      observation : TargetObservation
      signature : FeedbackSignature
      failure : FailureFingerprint?
      origin : CorpusOrigin
      input_key : String
      executions : Int
      selections : Int
      discoveries : Int
      energy : Int
    } derive(Eq, 
    Debug    )

    CorpusEntry::is_failure

    source
    fn CorpusEntry::is_failure(self : CorpusEntry) -> Bool

    CorpusEntry::observation

    source
    fn CorpusEntry::observation(self : CorpusEntry) -> TargetObservation

    CorpusEntry::record_discovery

    source
    fn CorpusEntry::record_discovery(self : CorpusEntry) -> Unit

    CorpusEntry::record_execution

    source
    fn CorpusEntry::record_execution(self : CorpusEntry) -> Unit

    CorpusEntry::record_selection

    source
    fn CorpusEntry::record_selection(self : CorpusEntry) -> Unit

    CorpusEntry::set_energy

    source
    fn CorpusEntry::set_energy(self : CorpusEntry, value : Int) -> Unit

    CorpusEntry::tree

    source

    CorpusLimits

    source
    pub(all) struct CorpusLimits {
      max_entries : Int
      max_total_bytes : Int
      max_failures : Int
      max_input_bytes : Int
    } derive(Eq, 
    Debug    )

    CorpusLimits::default

    source
    fn CorpusLimits::default() -> CorpusLimits

    CorpusOrigin

    source
    pub(all) enum CorpusOrigin {
      Seeded(Int64)
      Generated(Int64)
      Mutated(Int, String)
      Crossed(Int, Int)
      Reduced(Int)
      Replayed
    } derive(Eq, 
    Debug    )

    CorpusStatistics

    source
    pub(all) struct CorpusStatistics {
      entries : Int
      failures : Int
      total_bytes : Int
      unique_inputs : Int
      unique_features : Int
      unique_signatures : Int
      unique_failures : Int
    } derive(Eq, 
    Debug    )

    CrossoverConfig

    source
    pub(all) struct CrossoverConfig {
      maximum_output_bytes : Int
      maximum_nodes : Int
      maximum_depth : Int
      attempts : Int
    } derive(Eq, 
    Debug    )

    CrossoverConfig::default

    source

    CrossoverError

    source
    pub(all) enum CrossoverError {
      NoCompatibleSubtree
      CrossoverBudgetExceeded(String, Int)
      NoEffectiveCrossover
    } derive(Eq, 
    Debug    )

    CrossoverResult

    source
    pub(all) struct CrossoverResult {
      tree : DerivationTree
      recipient_node : Int
      donor_node : Int
      rule : RuleId
    } derive(Eq, 
    Debug    )

    DerivationKind

    source
    pub(all) enum DerivationKind {
      LiteralLeaf
      ByteLeaf
      IntegerLeaf(Int)
      DictionaryLeaf(Int)
      SequenceNode
      ChoiceNode(Int, String)
      RepeatNode(Int)
      OptionalNode(Bool)
      ReferenceNode(String)
    } derive(Eq, 
    Debug    )

    DerivationTree

    source
    pub(all) struct DerivationTree {
      node_id : Int
      rule : RuleId
      kind : DerivationKind
      payload : Array[Byte]
      children : Array[DerivationTree]
    } derive(Eq, 
    Debug    )

    DerivationTree::branch

    source
    fn DerivationTree::branch(node_id : Int, rule : RuleId, kind : DerivationKind, children : Array[DerivationTree]) -> DerivationTree

    DerivationTree::byte_length

    source
    fn DerivationTree::byte_length(self : DerivationTree) -> Int

    DerivationTree::children

    source

    DerivationTree::depth

    source
    fn DerivationTree::depth(self : DerivationTree) -> Int

    DerivationTree::descendants

    source

    DerivationTree::find

    source
    fn DerivationTree::find(self : DerivationTree, node_id : Int) -> DerivationTree?

    DerivationTree::kind

    source

    DerivationTree::leaf

    source
    fn DerivationTree::leaf(node_id : Int, rule : RuleId, kind : DerivationKind, payload : Array[Byte]) -> DerivationTree

    DerivationTree::node_count

    source
    fn DerivationTree::node_count(self : DerivationTree) -> Int

    DerivationTree::node_id

    source
    fn DerivationTree::node_id(self : DerivationTree) -> Int

    DerivationTree::nodes_for_rule

    source
    fn DerivationTree::nodes_for_rule(self : DerivationTree, rule : RuleId) -> Array[DerivationTree]

    DerivationTree::payload

    source
    fn DerivationTree::payload(self : DerivationTree) -> Array[Byte]

    DerivationTree::render

    source
    fn DerivationTree::render(self : DerivationTree) -> Bytes

    DerivationTree::render_text

    source
    fn DerivationTree::render_text(self : DerivationTree) -> Result[String, String]

    DerivationTree::renumber

    source

    DerivationTree::replace

    source
    fn DerivationTree::replace(self : DerivationTree, node_id : Int, replacement : DerivationTree) -> DerivationTree

    DerivationTree::rule

    source

    DerivationTree::structural_summary

    source
    fn DerivationTree::structural_summary(self : DerivationTree) -> String

    DerivationTree::without_child

    source
    fn DerivationTree::without_child(self : DerivationTree, child_index : Int) -> DerivationTree?

    DifferentialPolicy

    source
    pub(all) enum DifferentialPolicy {
      CompareDisposition
      CompareResultDigest
      CompareDispositionAndDigest
    } derive(Eq, 
    Debug    )

    EnergyScheduler

    source
    pub struct EnergyScheduler {
      config : ScheduleConfig
      random : Random
      rounds : Int
    }

    EnergyScheduler::energy_for

    source
    fn EnergyScheduler::energy_for(self : EnergyScheduler, corpus : Corpus, entry : CorpusEntry) -> Int

    EnergyScheduler::new

    source
    fn EnergyScheduler::new(seed : Int64, config? : ScheduleConfig) -> EnergyScheduler

    EnergyScheduler::rank

    source

    EnergyScheduler::refresh

    source
    fn EnergyScheduler::refresh(self : EnergyScheduler, corpus : Corpus) -> Array[Int]

    EnergyScheduler::rounds

    source
    fn EnergyScheduler::rounds(self : EnergyScheduler) -> Int

    EnergyScheduler::seed

    source
    fn EnergyScheduler::seed(self : EnergyScheduler) -> Int64

    EnergyScheduler::select

    source
    fn EnergyScheduler::select(self : EnergyScheduler, corpus : Corpus) -> ScheduleDecision?

    ExecutionDisposition

    source
    pub(all) enum ExecutionDisposition {
      Accepted
      Rejected(String)
      Failed(String, String)
    } derive(Eq, 
    Debug    )

    FailureFingerprint

    source
    pub(all) struct FailureFingerprint(String) derive(Eq, Hash, 
    Debug    )

    FailureFingerprint::value

    source
    fn FailureFingerprint::value(self : FailureFingerprint) -> String

    Feature

    source
    pub(all) struct Feature {
      domain : String
      value : String
    } derive(Eq, Hash, 
    Debug    )

    Feature::canonical

    source
    fn Feature::canonical(self : Feature) -> String

    FeatureDelta

    source
    pub(all) struct FeatureDelta {
      signature : FeedbackSignature
      novel_features : Array[Feature]
      all_features : Array[Feature]
    } derive(Eq, 
    Debug    )

    FeatureRegistry

    source
    pub struct FeatureRegistry {
      seen : 
    HashMap    [Feature, Int]
      signatures : 
    HashMap    [FeedbackSignature, Int]
      observations : Int
    }

    FeatureRegistry::feature_frequency

    source
    fn FeatureRegistry::feature_frequency(self : FeatureRegistry, value : Feature) -> Int

    FeatureRegistry::new

    source

    FeatureRegistry::observation_count

    source
    fn FeatureRegistry::observation_count(self : FeatureRegistry) -> Int

    FeatureRegistry::observe

    source
    fn FeatureRegistry::observe(self : FeatureRegistry, observation : TargetObservation) -> FeatureDelta

    FeatureRegistry::signature_frequency

    source
    fn FeatureRegistry::signature_frequency(self : FeatureRegistry, value : FeedbackSignature) -> Int

    FeatureRegistry::unique_feature_count

    source
    fn FeatureRegistry::unique_feature_count(self : FeatureRegistry) -> Int

    FeatureRegistry::unique_signature_count

    source
    fn FeatureRegistry::unique_signature_count(self : FeatureRegistry) -> Int

    FeedbackSignature

    source
    pub(all) struct FeedbackSignature(String) derive(Eq, Hash, 
    Debug    )

    FeedbackSignature::value

    source
    fn FeedbackSignature::value(self : FeedbackSignature) -> String

    GenerationBudget

    source
    pub(all) struct GenerationBudget {
      max_depth : Int
      max_nodes : Int
      max_bytes : Int
      max_repeat : Int
    } derive(Eq, 
    Debug    )

    GenerationBudget::default

    source

    GenerationBudget::new

    source
    fn GenerationBudget::new(max_depth? : Int, max_nodes? : Int, max_bytes? : Int, max_repeat? : Int) -> GenerationBudget

    GenerationError

    source
    pub(all) enum GenerationError {
      InvalidBudget(String)
      UnproductiveGrammar(AnalysisError)
      DepthBudgetExceeded(Int)
      NodeBudgetExceeded(Int)
      ByteBudgetExceeded(Int)
      NoViableAlternative(Int)
      InvalidGeneratedInteger(Int, Int)
    } derive(Eq, 
    Debug    )

    Grammar

    source
    pub struct Grammar {
      rules : Array[RuleDefinition]
      start : RuleId
      names : 
    HashMap    [String, RuleId]
    }

    Grammar::analyze

    source
    fn Grammar::analyze(self : Grammar) -> GrammarAnalysis

    Grammar::generate

    source
    fn Grammar::generate(self : Grammar, seed~ : Int64, budget? : GenerationBudget) -> Result[DerivationTree, GenerationError]

    Grammar::generate_from

    source
    fn Grammar::generate_from(self : Grammar, rule : RuleId, seed~ : Int64, budget? : GenerationBudget) -> Result[DerivationTree, GenerationError]

    Generate a standalone subtree for an existing grammar rule. This is the primitive used by structure-preserving mutation and crossover repair.

    Grammar::mutate

    source
    fn Grammar::mutate(self : Grammar, tree : DerivationTree, seed~ : Int64, config? : MutationConfig) -> Result[MutationResult, MutationError]

    Grammar::mutate_with

    source
    fn Grammar::mutate_with(self : Grammar, tree : DerivationTree, strategy : MutationStrategy, seed~ : Int64, config? : MutationConfig) -> Result[MutationResult, MutationError]

    Grammar::name_of

    source
    fn Grammar::name_of(self : Grammar, id : RuleId) -> String?

    Grammar::reduce_failure

    source
    fn Grammar::reduce_failure(self : Grammar, tree : DerivationTree, target : Target, fingerprint? : FailureFingerprint, seed? : Int64, config? : ReductionConfig) -> Result[ReductionResult, ReductionError]

    Grammar::resolve

    source
    fn Grammar::resolve(self : Grammar, name : String) -> RuleId?

    Grammar::rule

    source
    fn Grammar::rule(self : Grammar, id : RuleId) -> RuleDefinition?

    Grammar::rule_count

    source
    fn Grammar::rule_count(self : Grammar) -> Int

    Grammar::rules

    source
    fn Grammar::rules(self : Grammar) -> Array[RuleDefinition]

    Grammar::start

    source
    fn Grammar::start(self : Grammar) -> RuleId

    Grammar::validate_productivity

    source
    fn Grammar::validate_productivity(self : Grammar) -> Result[GrammarAnalysis, AnalysisError]

    GrammarAnalysis

    source
    pub(all) struct GrammarAnalysis {
      rules : Array[RuleProperties]
      reachable_count : Int
      unreachable_count : Int
      recursive_count : Int
      nullable_count : Int
      productive_count : Int
    } derive(Eq, 
    Debug    )

    GrammarAnalysis::properties

    source
    fn GrammarAnalysis::properties(self : GrammarAnalysis, id : RuleId) -> RuleProperties?

    GrammarAnalysis::rules

    source

    GrammarBuilder

    source
    pub struct GrammarBuilder {
      rules : Array[RuleDefinition]
      start_rule : RuleId?
    }

    GrammarBuilder::ascii_range

    source
    fn GrammarBuilder::ascii_range(self : GrammarBuilder, first : Char, last : Char, name? : String) -> RuleId

    GrammarBuilder::build

    source
    fn GrammarBuilder::build(self : GrammarBuilder) -> Result[Grammar, GrammarError]

    GrammarBuilder::bytes

    source
    fn GrammarBuilder::bytes(self : GrammarBuilder, values : Array[Int], name? : String) -> RuleId

    GrammarBuilder::choice

    source
    fn GrammarBuilder::choice(self : GrammarBuilder, alternatives : Array[Alternative], name? : String) -> RuleId

    GrammarBuilder::dictionary

    source
    fn GrammarBuilder::dictionary(self : GrammarBuilder, values : Array[String], name? : String) -> RuleId

    GrammarBuilder::integer

    source
    fn GrammarBuilder::integer(self : GrammarBuilder, minimum : Int, maximum : Int, name? : String) -> RuleId

    GrammarBuilder::literal

    source
    fn GrammarBuilder::literal(self : GrammarBuilder, value : String, name? : String) -> RuleId

    GrammarBuilder::new

    source

    GrammarBuilder::optional

    source
    fn GrammarBuilder::optional(self : GrammarBuilder, child : RuleId, present_weight? : Int, name? : String) -> RuleId

    GrammarBuilder::reference

    source
    fn GrammarBuilder::reference(self : GrammarBuilder, target_name : String, name? : String) -> RuleId

    GrammarBuilder::repeat

    source
    fn GrammarBuilder::repeat(self : GrammarBuilder, child : RuleId, minimum? : Int, maximum? : Int, name? : String) -> RuleId

    GrammarBuilder::sequence

    source
    fn GrammarBuilder::sequence(self : GrammarBuilder, children : Array[RuleId], name? : String) -> RuleId

    GrammarBuilder::set_start

    source
    fn GrammarBuilder::set_start(self : GrammarBuilder, start : RuleId) -> GrammarBuilder

    GrammarError

    source
    pub(all) enum GrammarError {
      EmptyGrammar
      InvalidStartRule(Int)
      InvalidRuleReference(Int, Int)
      MissingNamedRule(String)
      DuplicateRuleName(String)
      EmptyByteSet(Int)
      InvalidByteValue(Int, Int)
      EmptyDictionary(Int)
      EmptyChoice(Int)
      NonPositiveWeight(Int, Int)
      InvalidRepeatBounds(Int, Int, Int)
      InvalidIntegerBounds(Int, Int, Int)
      InvalidOptionalWeight(Int, Int)
    } derive(Eq, 
    Debug    )

    MetamorphicTransform

    source
    pub struct MetamorphicTransform {
      name : String
      apply : (Bytes) -> Bytes
      relation : (TargetObservation, TargetObservation) -> Bool
    }

    MetamorphicTransform::name

    source
    fn MetamorphicTransform::name(self : MetamorphicTransform) -> String

    MetamorphicTransform::new

    source
    fn MetamorphicTransform::new(name : String, apply : (Bytes) -> Bytes, relation : (TargetObservation, TargetObservation) -> Bool) -> MetamorphicTransform

    MutationConfig

    source
    pub(all) struct MutationConfig {
      budget : GenerationBudget
      attempts : Int
      maximum_output_bytes : Int
    } derive(Eq, 
    Debug    )

    MutationConfig::default

    source

    MutationError

    source
    pub(all) enum MutationError {
      EmptyTree
      NoApplicableMutation
      GenerationFailed(GenerationError)
      OutputBudgetExceeded(Int)
    } derive(Eq, 
    Debug    )

    MutationResult

    source
    pub(all) struct MutationResult {
      tree : DerivationTree
      strategy : MutationStrategy
      changed_node : Int
      detail : String
    } derive(Eq, 
    Debug    )

    MutationStrategy

    source
    pub(all) enum MutationStrategy {
      RegenerateSubtree
      DeleteRepeatedChild
      ToggleOptional
      ReplaceIntegerBoundary
      ReplaceDictionaryEntry
      DuplicateRepeatedChild
    } derive(Eq, 
    Debug    )

    Random

    source
    pub(all) struct Random {
      state : Int64
      initial_seed : Int64
      draws : Int
    }

    Stable pseudo-random generator used by every generative operation. The Park-Miller recurrence is intentionally small and reproducible on all MoonBit targets; it is not a cryptographic generator.

    Random::advance

    source
    fn Random::advance(self : Random, count : Int) -> Unit

    Random::below

    source
    fn Random::below(self : Random, exclusive : Int) -> Int

    Random::between

    source
    fn Random::between(self : Random, minimum : Int, maximum : Int) -> Int

    Random::chance

    source
    fn Random::chance(self : Random, numerator : Int, denominator : Int) -> Bool

    Random::choose_index

    source
    fn Random::choose_index(self : Random, length : Int) -> Int?

    Random::draw_count

    source
    fn Random::draw_count(self : Random) -> Int

    Random::fork

    source
    fn Random::fork(self : Random, stream : Int) -> Random

    Random::new

    source
    fn Random::new(seed : Int64) -> Random

    Random::next_raw

    source
    fn Random::next_raw(self : Random) -> Int

    Random::restore

    source
    fn Random::restore(snapshot : RandomSnapshot) -> Random

    Random::sample_without_replacement

    source
    fn Random::sample_without_replacement(self : Random, population : Int, requested : Int) -> Array[Int]

    Random::seed

    source
    fn Random::seed(self : Random) -> Int64

    Random::shuffle

    source
    fn[T] Random::shuffle(self : Random, input : Array[T]) -> Array[T]

    Random::snapshot

    source
    fn Random::snapshot(self : Random) -> RandomSnapshot

    Random::weighted_index

    source
    fn Random::weighted_index(self : Random, weights : Array[Int]) -> Int?

    RandomSnapshot

    source
    pub(all) struct RandomSnapshot {
      seed : Int64
      state : Int64
      draws : Int
    } derive(Eq, 
    Debug    )

    ReductionConfig

    source
    pub(all) struct ReductionConfig {
      max_attempts : Int
      generation_trials : Int
      generation_budget : GenerationBudget
    } derive(Eq, 
    Debug    )

    ReductionConfig::default

    source

    ReductionError

    source
    pub(all) enum ReductionError {
      InputDoesNotFail
      FingerprintMismatch(FailureFingerprint, FailureFingerprint)
      NoReductionPossible
    } derive(Eq, 
    Debug    )

    ReductionKind

    source
    pub(all) enum ReductionKind {
      RemoveRepeatedChild
      RemoveOptionalChild
      ReplaceWithSmallerSubtree
      SimplifyInteger
      SimplifyDictionary
    } derive(Eq, 
    Debug    )

    ReductionResult

    source
    pub(all) struct ReductionResult {
      original : DerivationTree
      reduced : DerivationTree
      fingerprint : FailureFingerprint
      attempts : Int
      accepted_steps : Array[ReductionStep]
    } derive(Eq, 
    Debug    )

    ReductionResult::bytes_removed

    source
    fn ReductionResult::bytes_removed(self : ReductionResult) -> Int

    ReductionResult::nodes_removed

    source
    fn ReductionResult::nodes_removed(self : ReductionResult) -> Int

    ReductionStep

    source
    pub(all) struct ReductionStep {
      kind : ReductionKind
      node_id : Int
      before_bytes : Int
      after_bytes : Int
      before_nodes : Int
      after_nodes : Int
    } derive(Eq, 
    Debug    )

    RejectionReason

    source
    pub(all) enum RejectionReason {
      DuplicateInput
      NoNovelty
      EntryCapacity
      ByteCapacity
      FailureCapacity
      InputTooLarge(Int)
    } derive(Eq, 
    Debug    )

    ReplayError

    source
    pub(all) enum ReplayError {
      InvalidJson
      MissingField(String)
      InvalidField(String)
      UnsupportedReplayVersion(Int)
      ArtifactLimitExceeded(Int)
      InputLimitExceeded(Int)
      InvalidHexInput(Int)
      TargetNameMismatch(String, String)
    } derive(Eq, 
    Debug    )

    ReplayOutcome

    source
    pub(all) struct ReplayOutcome {
      observation : TargetObservation
      feedback_matches : Bool
      failure_matches : Bool
      result_matches : Bool
    } derive(Eq, 
    Debug    )

    ReplayOutcome::matches

    source
    fn ReplayOutcome::matches(self : ReplayOutcome) -> Bool

    ReplayRecord

    source
    pub(all) struct ReplayRecord {
      schema_version : Int
      target_name : String
      seed : Int64
      input : Bytes
      feedback_signature : FeedbackSignature
      failure_fingerprint : FailureFingerprint?
      result_digest : String?
      generation_budget : GenerationBudget
    } derive(Eq, 
    Debug    )

    ReplayRecord::decode_json

    source
    fn ReplayRecord::decode_json(text : String, max_input_bytes? : Int, max_artifact_bytes? : Int) -> Result[ReplayRecord, ReplayError]

    ReplayRecord::encode_json

    source
    fn ReplayRecord::encode_json(self : ReplayRecord) -> String

    ReplayRecord::new

    source
    fn ReplayRecord::new(target_name~ : String, seed~ : Int64, input~ : Bytes, observation~ : TargetObservation, generation_budget? : GenerationBudget) -> ReplayRecord

    RuleDefinition

    source
    pub(all) struct RuleDefinition {
      id : RuleId
      name : String?
      kind : RuleKind
    } derive(Eq, 
    Debug    )

    RuleId

    source
    pub(all) struct RuleId(Int) derive(Eq, Hash, 
    Debug    )

    Stable integer identity of one grammar rule.

    RuleId::value

    source
    fn RuleId::value(self : RuleId) -> Int

    RuleKind

    source
    pub(all) enum RuleKind {
      Literal(String)
      Bytes(Array[Int])
      Integer(Int, Int)
      Dictionary(Array[String])
      Sequence(Array[RuleId])
      Choice(Array[Alternative])
      Repeat(RuleId, Int, Int)
      Optional(RuleId, Int)
      Reference(String)
    } derive(Eq, 
    Debug    )

    Composable rule kinds. References are resolved by name when the grammar is sealed, which allows explicit recursion without mutable placeholder nodes.

    RuleProperties

    source
    pub(all) struct RuleProperties {
      rule : RuleId
      reachable : Bool
      nullable : Bool
      productive : Bool
      recursive : Bool
      minimum_bytes : Int?
      minimum_nodes : Int?
    } derive(Eq, 
    Debug    )

    ScheduleConfig

    source
    pub(all) struct ScheduleConfig {
      base_energy : Int
      maximum_energy : Int
      novelty_bonus : Int
      discovery_bonus : Int
      failure_bonus : Int
      cost_penalty : Int
      selection_penalty : Int
    } derive(Eq, 
    Debug    )

    ScheduleConfig::default

    source

    ScheduleDecision

    source
    pub(all) struct ScheduleDecision {
      entry_id : Int
      energy : Int
      reason : String
    } derive(Eq, 
    Debug    )

    StrategyEvidence

    source
    pub(all) struct StrategyEvidence {
      name : String
      executions : Int
      unique_features : Int
      unique_signatures : Int
      unique_failures : Int
      corpus_entries : Int
    } derive(Eq, 
    Debug    )

    Target

    source
    pub struct Target {
      name : String
      evaluate : (Bytes) -> TargetObservation
    }

    Target::name

    source
    fn Target::name(self : Target) -> String

    Target::new

    source
    fn Target::new(name : String, evaluate : (Bytes) -> TargetObservation) -> Target

    Target::replay

    source
    fn Target::replay(self : Target, record : ReplayRecord) -> Result[ReplayOutcome, ReplayError]

    Target::run

    source
    fn Target::run(self : Target, input : Bytes) -> TargetObservation

    TargetObservation

    source
    pub(all) struct TargetObservation {
      disposition : ExecutionDisposition
      features : Array[Feature]
      result_digest : String?
      cost_class : Int
    } derive(Eq, 
    Debug    )

    TargetObservation::canonical_features

    source
    fn TargetObservation::canonical_features(self : TargetObservation) -> Array[Feature]

    TargetObservation::failure_fingerprint

    source
    fn TargetObservation::failure_fingerprint(self : TargetObservation) -> FailureFingerprint?

    TargetObservation::feature_count

    source
    fn TargetObservation::feature_count(self : TargetObservation) -> Int

    TargetObservation::is_failure

    source
    fn TargetObservation::is_failure(self : TargetObservation) -> Bool

    TargetObservation::signature

    source

    accepted

    source
    fn accepted(features? : Array[Feature], result_digest? : String, cost_class? : Int) -> TargetObservation

    agreement_target

    source
    fn agreement_target(name : String, targets : Array[Target], minimum_agreement? : Int) -> Target

    alternative

    source
    fn alternative(rule : RuleId, weight? : Int, label? : String) -> Alternative

    compare_strategies

    source
    fn compare_strategies(values : Array[StrategyEvidence]) -> String

    crossover

    source
    fn crossover(recipient : DerivationTree, donor : DerivationTree, seed~ : Int64, config? : CrossoverConfig) -> Result[CrossoverResult, CrossoverError]

    crossover_compatible_rule_count

    source
    fn crossover_compatible_rule_count(left : DerivationTree, right : DerivationTree) -> Int

    deterministic_permutation

    source
    fn deterministic_permutation(seed : Int64, size : Int) -> Array[Int]

    differential_target

    source
    fn differential_target(name : String, left : Target, right : Target, policy? : DifferentialPolicy) -> Target

    failed

    source
    fn failed(kind : String, detail : String, features? : Array[Feature]) -> TargetObservation

    feature

    source
    fn feature(domain : String, value : String) -> Feature

    feedback_signature

    source
    fn feedback_signature(features : Array[Feature]) -> FeedbackSignature

    metamorphic_target

    source
    fn metamorphic_target(name : String, base : Target, transforms : Array[MetamorphicTransform]) -> Target

    observation

    source
    fn observation(disposition : ExecutionDisposition, features? : Array[Feature], result_digest? : String, cost_class? : Int) -> TargetObservation

    rejected

    source
    fn rejected(reason : String, features? : Array[Feature]) -> TargetObservation

    replay_schema_version

    source
    let replay_schema_version : Int

    run_campaign

    source
    fn run_campaign(grammar : Grammar, target : Target, config : CampaignConfig) -> Result[CampaignResult, CampaignError]

    same_digest_transform

    source
    fn same_digest_transform(name : String, apply : (Bytes) -> Bytes) -> MetamorphicTransform

    same_disposition_transform

    source
    fn same_disposition_transform(name : String, apply : (Bytes) -> Bytes) -> MetamorphicTransform

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io