🥮 mooncakes.io

    zlhahaha/moonsim/core does not have a README file

    Backoff

    source
    pub(all) struct Backoff {
      initial : Int
      factor : Int
      max_delay : Int
      jitter : Int
      current : Int
    }

    Backoff::new

    source
    fn Backoff::new(initial? : Int, factor? : Int, max_delay? : Int, jitter? : Int) -> Backoff

    Backoff::next_delay

    source
    fn Backoff::next_delay(self : Backoff, rng : Rng) -> Int

    Backoff::reset

    source
    fn Backoff::reset(self : Backoff) -> Unit

    CounterSample

    source
    pub(all) struct CounterSample {
      name : String
      value : Int
    }

    Duration

    source
    pub(all) struct Duration {
      value : Int
    } derive(Eq, 
    Debug    )

    Virtual simulation duration.

    Duration::is_zero

    source
    fn Duration::is_zero(self : Duration) -> Bool

    Duration::scale

    source
    fn Duration::scale(self : Duration, factor : Int) -> Duration

    Duration::to_int

    source
    fn Duration::to_int(self : Duration) -> Int

    EventFailureCase

    source
    pub(all) struct EventFailureCase {
      seed : UInt64
      rule : String
      digest : UInt64
      events : Array[EventRecord]
      policy : EventMutationPolicy
      source_events : Array[EventRecord]
    }

    EventFailureCase::replay

    source

    EventId

    source
    pub(all) struct EventId {
      value : Int
    } derive(Eq, 
    Debug    )

    Stable simulation event identifier.

    EventId::to_int

    source
    fn EventId::to_int(self : EventId) -> Int

    EventKind

    source
    pub enum EventKind {
      Message
      Task
      Timer
      StateTransition
      ExternalCall
    }

    Built-in event categories for deterministic model traces.

    EventKind::label

    source
    fn EventKind::label(self : EventKind) -> String

    EventMutationPolicy

    source
    pub(all) struct EventMutationPolicy {
      seed : UInt64
      max_delay : Int
      delay_percent : Int
      drop_percent : Int
      duplicate_percent : Int
      reorder_same_tick : Bool
      failure_percent : Int
    }

    EventRecord

    source
    pub(all) struct EventRecord {
      id : Int
      kind : EventKind
      tick : Int
      priority : Int
      correlation_id : String
      source : String
      target : String
      label : String
      parent_id : Int
      payload : String
      dropped : Bool
      failed : Bool
    }

    EventReplayResult

    source
    pub(all) struct EventReplayResult {
      seed : UInt64
      digest : UInt64
      events : Array[EventRecord]
      scheduled : Int
      dropped : Int
      duplicated : Int
      failed : Int
    }

    EventReplayResult::invariants

    source

    EventReplayResult::matches_digest

    source
    fn EventReplayResult::matches_digest(self : EventReplayResult, other : EventReplayResult) -> Bool

    EventStream

    source
    pub(all) struct EventStream {
      next_id : Int
      events : Array[EventRecord]
    }

    EventStream::append

    source
    fn EventStream::append(self : EventStream, event : EventRecord) -> EventRecord

    EventStream::digest

    source
    fn EventStream::digest(self : EventStream) -> UInt64

    EventStream::events

    source
    fn EventStream::events(self : EventStream) -> Array[EventRecord]

    EventStream::invariants

    source
    fn EventStream::invariants(self : EventStream) -> InvariantReport

    EventStream::new

    source

    EventStream::ordered

    source
    fn EventStream::ordered(self : EventStream) -> Array[EventRecord]

    EventStream::record

    source
    fn EventStream::record(self : EventStream, kind : EventKind, tick : Int, label : String, correlation_id? : String, source? : String, target? : String, parent_id? : Int, payload? : String, priority? : Int, dropped? : Bool, failed? : Bool) -> EventRecord

    EventStream::replay

    source

    EventStream::restore

    source
    fn EventStream::restore(self : EventStream, snapshot : EventStreamSnapshot) -> Unit

    EventStream::snapshot

    source

    EventStreamSnapshot

    source
    pub(all) struct EventStreamSnapshot {
      next_id : Int
      events : Array[EventRecord]
    }

    EventView

    source
    pub(all) struct EventView {
      id : Int
      tick : Int
      priority : Int
      name : String
      status : String
    }

    ForkComparison

    source
    pub(all) struct ForkComparison {
      left_name : String
      right_name : String
      left_digest : UInt64
      right_digest : UInt64
      same_digest : Bool
      left_events : Int
      right_events : Int
    }

    ForkComparison::summary

    source
    fn ForkComparison::summary(self : ForkComparison) -> String

    IntRange

    source
    pub(all) struct IntRange {
      min : Int
      max : Int
    }

    InvariantCheck

    source
    pub(all) struct InvariantCheck {
      name : String
      passed : Bool
      detail : String
    }

    InvariantReport

    source
    pub(all) struct InvariantReport {
      subject : String
      checks : Array[InvariantCheck]
    }

    InvariantReport::add

    source

    InvariantReport::check_count

    source
    fn InvariantReport::check_count(self : InvariantReport) -> Int

    InvariantReport::failed_count

    source
    fn InvariantReport::failed_count(self : InvariantReport) -> Int

    InvariantReport::has_check

    source
    fn InvariantReport::has_check(self : InvariantReport, name : String) -> Bool

    InvariantReport::is_empty

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

    InvariantReport::merge

    source

    InvariantReport::new

    source
    fn InvariantReport::new(subject : String) -> InvariantReport

    InvariantReport::only_failures

    source
    fn InvariantReport::only_failures(self : InvariantReport) -> InvariantReport

    InvariantReport::passed

    source
    fn InvariantReport::passed(self : InvariantReport) -> Bool

    InvariantReport::passed_count

    source
    fn InvariantReport::passed_count(self : InvariantReport) -> Int

    InvariantReport::render

    source
    fn InvariantReport::render(self : InvariantReport) -> String

    InvariantReport::summary

    source
    fn InvariantReport::summary(self : InvariantReport) -> String

    Message

    source
    pub(all) struct Message {
      id : Int
      from : String
      to : String
      body : String
      send_tick : Int
      deliver_tick : Int
      dropped : Bool
    }

    MessageBus

    source
    pub(all) struct MessageBus {
      next_message_id : Int
      messages : Array[Message]
    }

    MessageBus::deliver_due

    source
    fn MessageBus::deliver_due(self : MessageBus, sim : Sim) -> Int

    MessageBus::drop

    source
    fn MessageBus::drop(self : MessageBus, sim : Sim, id : Int) -> Bool

    MessageBus::event_stream

    source
    fn MessageBus::event_stream(self : MessageBus) -> EventStream

    Projects message send and delivery facts into the generic event stream.

    MessageBus::messages

    source
    fn MessageBus::messages(self : MessageBus) -> Array[Message]

    MessageBus::new

    source
    fn MessageBus::new() -> MessageBus

    MessageBus::pending

    source
    fn MessageBus::pending(self : MessageBus, sim : Sim) -> Int

    MessageBus::send

    source
    fn MessageBus::send(self : MessageBus, sim : Sim, from : String, to : String, body : String, delay? : Int) -> Int

    MetricDelta

    source
    pub(all) struct MetricDelta {
      name : String
      before : Int
      after : Int
      delta : Int
    }

    MetricDiff

    source
    pub(all) struct MetricDiff {
      counters : Array[MetricDelta]
      gauges : Array[MetricDelta]
      sample_delta : Int
    }

    MetricDiff::summary

    source
    fn MetricDiff::summary(self : MetricDiff) -> String

    MetricSnapshot

    source
    pub(all) struct MetricSnapshot {
      counters : Array[CounterSample]
      gauges : Array[CounterSample]
      samples : Array[CounterSample]
    }

    Metrics

    source
    pub(all) struct Metrics {
      counters : Array[CounterSample]
      gauges : Array[CounterSample]
      samples : Array[CounterSample]
    }

    Metrics::counter

    source
    fn Metrics::counter(self : Metrics, name : String) -> Int

    Metrics::diff_from

    source
    fn Metrics::diff_from(self : Metrics, before : MetricSnapshot) -> MetricDiff

    Metrics::distribution

    source
    fn Metrics::distribution(self : Metrics, name : String) -> SampleDistribution

    Metrics::gauge

    source
    fn Metrics::gauge(self : Metrics, name : String) -> Int

    Metrics::gauge_snapshot

    source
    fn Metrics::gauge_snapshot(self : Metrics) -> Array[CounterSample]

    Metrics::inc

    source
    fn Metrics::inc(self : Metrics, name : String, delta? : Int) -> Unit

    Metrics::metric_snapshot

    source
    fn Metrics::metric_snapshot(self : Metrics) -> MetricSnapshot

    Metrics::new

    source
    fn Metrics::new() -> Metrics

    Metrics::sample

    source
    fn Metrics::sample(self : Metrics, name : String, value : Int) -> Unit

    Metrics::sample_count

    source
    fn Metrics::sample_count(self : Metrics, name : String) -> Int

    Metrics::sample_snapshot

    source
    fn Metrics::sample_snapshot(self : Metrics) -> Array[CounterSample]

    Metrics::sample_values

    source
    fn Metrics::sample_values(self : Metrics, name : String) -> Array[Int]

    Metrics::set_gauge

    source
    fn Metrics::set_gauge(self : Metrics, name : String, value : Int) -> Unit

    Metrics::snapshot

    source
    fn Metrics::snapshot(self : Metrics) -> Array[CounterSample]

    Metrics::summary

    source
    fn Metrics::summary(self : Metrics, name : String) -> SampleSummary

    QueueStats

    source
    pub(all) struct QueueStats {
      pending : Int
      cancelled : Int
      earliest_tick : Int
      latest_tick : Int
    }

    ReplayBaseline

    source
    pub(all) struct ReplayBaseline {
      name : String
      digest : UInt64
      entries : Array[TraceEntry]
      counters : Array[CounterSample]
      gauges : Array[CounterSample]
    }

    ReplayComparison

    source
    pub(all) struct ReplayComparison {
      name : String
      matched : Bool
      trace : TraceComparison
      counter_mismatches : Int
      gauge_mismatches : Int
    }

    ReplayComparison::summary

    source
    fn ReplayComparison::summary(self : ReplayComparison) -> String

    Rng

    source
    pub(all) struct Rng {
      state : UInt64
    }

    Deterministic pseudo-random generator for reproducible simulations.

    This generator is not cryptographic. It is intentionally small and portable so simulations behave the same across MoonBit targets.

    Rng::choose

    source
    fn[T] Rng::choose(self : Rng, items : Array[T]) -> T?

    Rng::choose_weighted

    source
    fn Rng::choose_weighted(self : Rng, choices : Array[WeightedChoice]) -> String?

    Rng::new

    source
    fn Rng::new(seed : UInt64) -> Rng

    Rng::next_bool

    source
    fn Rng::next_bool(self : Rng) -> Bool

    Rng::next_int

    source
    fn Rng::next_int(self : Rng, bound : Int) -> Int

    Rng::next_range

    source
    fn Rng::next_range(self : Rng, low : Int, high : Int) -> Int

    Rng::next_u64

    source
    fn Rng::next_u64(self : Rng) -> UInt64

    Rng::shuffle

    source
    fn[T] Rng::shuffle(self : Rng, items : Array[T]) -> Array[T]

    Rng::state

    source
    fn Rng::state(self : Rng) -> UInt64

    RunReport

    source
    pub(all) struct RunReport {
      steps : Int
      final_tick : Int
      pending : Int
      reason : RunStopReason
    }

    RunStep

    source
    pub(all) enum RunStep {
      Executed(ScheduledEvent)
      Idle
    }

    RunStopReason

    source
    pub(all) enum RunStopReason {
      Idle
      StepLimit
      TickLimit
    }

    SampleDistribution

    source
    pub(all) struct SampleDistribution {
      name : String
      count : Int
      min : Int
      max : Int
      median : Int
      p90 : Int
    }

    SampleSummary

    source
    pub(all) struct SampleSummary {
      name : String
      count : Int
      min : Int
      max : Int
      sum : Int
    }

    SampleSummary::average

    source
    fn SampleSummary::average(self : SampleSummary) -> Double

    Scenario

    source
    pub(all) struct Scenario {
      name : String
      seed : UInt64
      max_steps : Int
      expectations : Array[ScenarioExpectation]
    }

    Scenario::create_sim

    source
    fn Scenario::create_sim(self : Scenario) -> Sim

    Scenario::expect_counter

    source
    fn Scenario::expect_counter(self : Scenario, name : String, value : Int) -> Scenario

    Scenario::expect_counter_range

    source
    fn Scenario::expect_counter_range(self : Scenario, name : String, min : Int, max : Int) -> Scenario

    Scenario::expect_digest

    source
    fn Scenario::expect_digest(self : Scenario, value : UInt64) -> Scenario

    Scenario::expect_final_tick

    source
    fn Scenario::expect_final_tick(self : Scenario, value : Int) -> Scenario

    Scenario::expect_final_tick_range

    source
    fn Scenario::expect_final_tick_range(self : Scenario, min : Int, max : Int) -> Scenario

    Scenario::expect_gauge

    source
    fn Scenario::expect_gauge(self : Scenario, name : String, value : Int) -> Scenario

    Scenario::expect_no_validation_issues

    source
    fn Scenario::expect_no_validation_issues(self : Scenario) -> Scenario

    Scenario::expect_pending

    source
    fn Scenario::expect_pending(self : Scenario, value : Int) -> Scenario

    Scenario::expect_sample_count

    source
    fn Scenario::expect_sample_count(self : Scenario, name : String, value : Int) -> Scenario

    Scenario::expect_summary_average_range

    source
    fn Scenario::expect_summary_average_range(self : Scenario, name : String, min : Int, max : Int) -> Scenario

    Scenario::expect_summary_max

    source
    fn Scenario::expect_summary_max(self : Scenario, name : String, value : Int) -> Scenario

    Scenario::expect_summary_min

    source
    fn Scenario::expect_summary_min(self : Scenario, name : String, value : Int) -> Scenario

    Scenario::expect_trace_contains

    source
    fn Scenario::expect_trace_contains(self : Scenario, text : String) -> Scenario

    Scenario::expect_trace_kind_count

    source
    fn Scenario::expect_trace_kind_count(self : Scenario, kind : String, count : Int) -> Scenario

    Scenario::new

    source
    fn Scenario::new(name : String, seed? : UInt64, max_steps? : Int) -> Scenario

    Scenario::verify

    source
    fn Scenario::verify(self : Scenario, sim : Sim) -> ScenarioReport

    ScenarioCase

    source
    pub(all) struct ScenarioCase {
      scenario : Scenario
      sim : Sim
    }

    ScenarioExpectation

    source
    pub(all) struct ScenarioExpectation {
      kind : String
      name : String
      expected : String
    }

    ScenarioFailure

    source
    pub(all) struct ScenarioFailure {
      kind : String
      name : String
      expected : String
      actual : String
    }

    ScenarioReport

    source
    pub(all) struct ScenarioReport {
      name : String
      passed : Bool
      steps : Int
      final_tick : Int
      digest : UInt64
      failures : Array[ScenarioFailure]
    }

    ScenarioReport::detailed_text

    source
    fn ScenarioReport::detailed_text(self : ScenarioReport) -> String

    ScenarioReport::failure_count

    source
    fn ScenarioReport::failure_count(self : ScenarioReport) -> Int

    ScenarioReport::failure_text

    source
    fn ScenarioReport::failure_text(self : ScenarioReport) -> String

    ScenarioReport::summary

    source
    fn ScenarioReport::summary(self : ScenarioReport) -> String

    ScenarioSuite

    source
    pub(all) struct ScenarioSuite {
      name : String
      cases : Array[ScenarioCase]
    }

    ScenarioSuite::add

    source
    fn ScenarioSuite::add(self : ScenarioSuite, scenario : Scenario, sim : Sim) -> ScenarioSuite

    ScenarioSuite::new

    source
    fn ScenarioSuite::new(name : String) -> ScenarioSuite

    ScenarioSuite::run

    source

    ScenarioSuiteReport

    source
    pub(all) struct ScenarioSuiteReport {
      name : String
      reports : Array[ScenarioReport]
    }

    ScenarioSuiteReport::failed_count

    source
    fn ScenarioSuiteReport::failed_count(self : ScenarioSuiteReport) -> Int

    ScenarioSuiteReport::passed

    source
    fn ScenarioSuiteReport::passed(self : ScenarioSuiteReport) -> Bool

    ScenarioSuiteReport::passed_count

    source
    fn ScenarioSuiteReport::passed_count(self : ScenarioSuiteReport) -> Int

    ScenarioSuiteReport::render

    source
    fn ScenarioSuiteReport::render(self : ScenarioSuiteReport) -> String

    ScenarioSuiteReport::summary

    source
    fn ScenarioSuiteReport::summary(self : ScenarioSuiteReport) -> String

    ScheduledEvent

    source
    pub(all) struct ScheduledEvent {
      id : Int
      tick : Int
      priority : Int
      name : String
      cancelled : Bool
      repeat_every : Int
      remaining_runs : Int
    }

    A scheduled simulation event.

    Events are ordered by tick, priority, then id. The id tie-breaker makes same-tick execution stable and replayable.

    ScheduledEvent::cancel

    source
    fn ScheduledEvent::cancel(self : ScheduledEvent) -> Unit

    ScheduledEvent::is_cancelled

    source
    fn ScheduledEvent::is_cancelled(self : ScheduledEvent) -> Bool

    ScheduledEvent::is_repeating

    source
    fn ScheduledEvent::is_repeating(self : ScheduledEvent) -> Bool

    ScheduledEvent::new

    source
    fn ScheduledEvent::new(id : Int, tick : Int, name : String, priority? : Int) -> ScheduledEvent

    ScheduledEvent::next_repeat

    source
    fn ScheduledEvent::next_repeat(self : ScheduledEvent) -> ScheduledEvent

    ScheduledEvent::repeating

    source
    fn ScheduledEvent::repeating(id : Int, tick : Int, name : String, every : Int, times : Int, priority? : Int) -> ScheduledEvent

    Sim

    source
    pub(all) struct Sim {
      now : Int
      next_id : Int
      events : Array[ScheduledEvent]
      trace_entries : Array[TraceEntry]
      rng : Rng
      metrics : Metrics
    }

    Deterministic simulation state.

    Sim::cancel

    source
    fn Sim::cancel(self : Sim, event_id : Int) -> Bool

    Sim::choose

    source
    fn[T] Sim::choose(self : Sim, label : String, items : Array[T]) -> T?

    Sim::choose_weighted

    source
    fn Sim::choose_weighted(self : Sim, label : String, choices : Array[WeightedChoice]) -> String?

    Sim::digest

    source
    fn Sim::digest(self : Sim) -> UInt64

    Sim::event_views

    source
    fn Sim::event_views(self : Sim) -> Array[EventView]

    Sim::inc_counter

    source
    fn Sim::inc_counter(self : Sim, name : String, delta? : Int) -> Unit

    Sim::install_timer

    source
    fn Sim::install_timer(self : Sim, plan : TimerPlan) -> Int

    Sim::metrics

    source
    fn Sim::metrics(self : Sim) -> Metrics

    Sim::new

    source
    fn Sim::new(seed? : UInt64) -> Sim

    Sim::next_int

    source
    fn Sim::next_int(self : Sim, bound : Int) -> Int

    Sim::next_range

    source
    fn Sim::next_range(self : Sim, low : Int, high : Int) -> Int

    Sim::pending_count

    source
    fn Sim::pending_count(self : Sim) -> Int

    Sim::queue_stats

    source
    fn Sim::queue_stats(self : Sim) -> QueueStats

    Sim::record

    source
    fn Sim::record(self : Sim, event_id : Int, kind : String, detail : String) -> Unit

    Sim::record_transition

    source
    fn Sim::record_transition(self : Sim, machine : StateMachine, result : TransitionResult) -> Unit

    Sim::restore

    source
    fn Sim::restore(snapshot : SimSnapshot) -> Sim

    Sim::run_next

    source
    fn Sim::run_next(self : Sim) -> ScheduledEvent?

    Sim::run_report_until_idle

    source
    fn Sim::run_report_until_idle(self : Sim, max_steps? : Int) -> RunReport

    Sim::run_until_idle

    source
    fn Sim::run_until_idle(self : Sim, max_steps? : Int) -> Int

    Sim::run_until_tick

    source
    fn Sim::run_until_tick(self : Sim, tick_limit : Int, max_steps? : Int) -> RunReport

    Sim::sample

    source
    fn Sim::sample(self : Sim, name : String, value : Int) -> Unit

    Sim::schedule_after

    source
    fn Sim::schedule_after(self : Sim, delay : Int, name : String, priority? : Int) -> Int

    Sim::schedule_after_duration

    source
    fn Sim::schedule_after_duration(self : Sim, delay : Duration, name : String, priority? : Int) -> EventId

    Sim::schedule_at

    source
    fn Sim::schedule_at(self : Sim, tick : Int, name : String, priority? : Int) -> Int

    Sim::schedule_at_tick

    source
    fn Sim::schedule_at_tick(self : Sim, at : Tick, name : String, priority? : Int) -> EventId

    Sim::schedule_backoff

    source
    fn Sim::schedule_backoff(self : Sim, backoff : Backoff, name : String) -> Int

    Sim::schedule_repeating

    source
    fn Sim::schedule_repeating(self : Sim, start_after : Int, every : Int, times : Int, name : String, priority? : Int) -> Int

    Sim::schedule_timeout

    source
    fn Sim::schedule_timeout(self : Sim, after : Int, name : String) -> Int

    Sim::set_gauge

    source
    fn Sim::set_gauge(self : Sim, name : String, value : Int) -> Unit

    Sim::shuffle

    source
    fn[T] Sim::shuffle(self : Sim, label : String, items : Array[T]) -> Array[T]

    Sim::snapshot

    source
    fn Sim::snapshot(self : Sim, name? : String) -> SimSnapshot

    Sim::step

    source
    fn Sim::step(self : Sim) -> RunStep

    Sim::tick

    source
    fn Sim::tick(self : Sim) -> Tick

    Sim::time

    source
    fn Sim::time(self : Sim) -> Int

    Sim::timeline

    source
    fn Sim::timeline(self : Sim, bucket_size? : Int) -> TimelineView

    Sim::timeline_text

    source
    fn Sim::timeline_text(self : Sim) -> String

    Sim::trace

    source
    fn Sim::trace(self : Sim) -> Array[TraceEntry]

    Sim::trace_stats

    source
    fn Sim::trace_stats(self : Sim) -> TraceStats

    Sim::trace_text

    source
    fn Sim::trace_text(self : Sim) -> String

    Sim::validate

    source
    fn Sim::validate(self : Sim) -> ValidationReport

    SimSnapshot

    source
    pub(all) struct SimSnapshot {
      name : String
      time : Int
      next_id : Int
      rng_state : UInt64
      digest : UInt64
      events : Array[ScheduledEvent]
      counters : Array[CounterSample]
      gauges : Array[CounterSample]
      samples : Array[CounterSample]
    }

    SimSnapshot::fork

    source
    fn SimSnapshot::fork(self : SimSnapshot, name : String) -> Sim

    StateMachine

    source
    pub(all) struct StateMachine {
      name : String
      state : String
      transitions : Array[Transition]
      history : Array[TransitionResult]
    }

    StateMachine::add

    source
    fn StateMachine::add(self : StateMachine, transition : Transition) -> StateMachine

    StateMachine::event_stream

    source
    fn StateMachine::event_stream(self : StateMachine) -> EventStream

    Projects accepted and rejected transitions into a causally linked event stream.

    StateMachine::history

    source

    StateMachine::new

    source
    fn StateMachine::new(name : String, initial : String) -> StateMachine

    StateMachine::send

    source
    fn StateMachine::send(self : StateMachine, event : String) -> TransitionResult

    StateMachine::state

    source
    fn StateMachine::state(self : StateMachine) -> String

    Tick

    source
    pub(all) struct Tick {
      value : Int
    } derive(Eq, 
    Debug    )

    Virtual simulation tick.

    Tick::compare

    source
    fn Tick::compare(self : Tick, other : Tick) -> Int

    Tick::diff

    source
    fn Tick::diff(self : Tick, earlier : Tick) -> Duration

    Tick::plus

    source
    fn Tick::plus(self : Tick, delta : Duration) -> Tick

    Tick::to_int

    source
    fn Tick::to_int(self : Tick) -> Int

    TimelineBucket

    source
    pub(all) struct TimelineBucket {
      start_tick : Int
      end_tick : Int
      events : Int
      executions : Int
      metrics : Int
      messages : Int
    }

    TimelineBucket::line

    source
    fn TimelineBucket::line(self : TimelineBucket) -> String

    TimelineView

    source
    pub(all) struct TimelineView {
      bucket_size : Int
      buckets : Array[TimelineBucket]
    }

    TimelineView::bucket_count

    source
    fn TimelineView::bucket_count(self : TimelineView) -> Int

    TimelineView::peak_bucket

    source
    fn TimelineView::peak_bucket(self : TimelineView) -> TimelineBucket

    TimelineView::render

    source
    fn TimelineView::render(self : TimelineView) -> String

    TimelineView::total_events

    source
    fn TimelineView::total_events(self : TimelineView) -> Int

    TimerPlan

    source
    pub(all) struct TimerPlan {
      name : String
      start_after : Int
      interval : Int
      times : Int
      priority : Int
    }

    TimerPlan::event_stream

    source
    fn TimerPlan::event_stream(self : TimerPlan) -> EventStream

    Projects a timer plan into the common deterministic event representation.

    TraceComparison

    source
    pub(all) struct TraceComparison {
      matched : Bool
      checked : Int
      left_digest : UInt64
      right_digest : UInt64
      mismatch : TraceMismatch?
    }

    TraceComparison::summary

    source
    fn TraceComparison::summary(self : TraceComparison) -> String

    TraceEntry

    source
    pub(all) struct TraceEntry {
      tick : Int
      event_id : Int
      kind : String
      detail : String
    }

    A deterministic record of an action observed during a simulation run.

    TraceEntry::format

    source
    fn TraceEntry::format(self : TraceEntry) -> String

    TraceEntry::to_line

    source
    fn TraceEntry::to_line(self : TraceEntry) -> String

    TraceExpectation

    source
    pub(all) struct TraceExpectation {
      passed : Bool
      label : String
      expected : String
      actual : String
    }

    TraceKindCount

    source
    pub(all) struct TraceKindCount {
      kind : String
      count : Int
    }

    TraceMismatch

    source
    pub(all) struct TraceMismatch {
      index : Int
      left : String
      right : String
      reason : String
    }

    TraceQuery

    source
    pub(all) struct TraceQuery {
      kind : String
      detail : String
      min_tick : Int
      max_tick : Int
    }

    TraceQuery::matches

    source
    fn TraceQuery::matches(self : TraceQuery, entry : TraceEntry) -> Bool

    TraceQueryResult

    source
    pub(all) struct TraceQueryResult {
      entries : Array[TraceEntry]
      first_tick : Int
      last_tick : Int
      kind_counts : Array[TraceKindCount]
    }

    TraceQueryResult::kind_count

    source
    fn TraceQueryResult::kind_count(self : TraceQueryResult, kind : String) -> Int

    TraceQueryResult::summary

    source
    fn TraceQueryResult::summary(self : TraceQueryResult) -> String

    TraceStats

    source
    pub(all) struct TraceStats {
      entries : Int
      schedules : Int
      executions : Int
      cancellations : Int
      rng_draws : Int
      metrics : Int
      messages : Int
    }

    TraceStats::summary

    source
    fn TraceStats::summary(self : TraceStats) -> String

    Transition

    source
    pub(all) struct Transition {
      from : String
      event : String
      to : String
      action : String
    }

    TransitionResult

    source
    pub(all) struct TransitionResult {
      accepted : Bool
      from : String
      event : String
      to : String
      action : String
      reason : String
    }

    ValidationIssue

    source
    pub(all) struct ValidationIssue {
      code : String
      message : String
      severity : String
    }

    ValidationReport

    source
    pub(all) struct ValidationReport {
      subject : String
      issues : Array[ValidationIssue]
    }

    ValidationReport::passed

    source
    fn ValidationReport::passed(self : ValidationReport) -> Bool

    ValidationReport::summary

    source
    fn ValidationReport::summary(self : ValidationReport) -> String

    ValidationReport::text

    source
    fn ValidationReport::text(self : ValidationReport) -> String

    WeightedChoice

    source
    pub(all) struct WeightedChoice {
      label : String
      weight : Int
    }

    build_timeline

    source
    fn build_timeline(entries : Array[TraceEntry], bucket_size? : Int) -> TimelineView

    check_counter_at_least

    source
    fn check_counter_at_least(sim : Sim, name : String, minimum : Int) -> InvariantCheck

    check_no_pending

    source
    fn check_no_pending(sim : Sim) -> InvariantCheck

    check_sim_invariants

    source
    fn check_sim_invariants(sim : Sim) -> InvariantReport

    compare_event

    source
    fn compare_event(a : ScheduledEvent, b : ScheduledEvent) -> Int

    compare_forks

    source
    fn compare_forks(left_name : String, left : Sim, right_name : String, right : Sim) -> ForkComparison

    compare_replay

    source
    fn compare_replay(baseline : ReplayBaseline, sim : Sim) -> ReplayComparison

    compare_traces

    source
    fn compare_traces(left : Array[TraceEntry], right : Array[TraceEntry]) -> TraceComparison

    diff_metrics

    source
    fn diff_metrics(before : MetricSnapshot, after : MetricSnapshot) -> MetricDiff

    duration

    source
    fn duration(value : Int) -> Duration

    event_failure_case

    source
    fn event_failure_case(rule : String, source : EventStream, policy : EventMutationPolicy) -> EventFailureCase

    event_id

    source
    fn event_id(value : Int) -> EventId

    event_mutation_policy

    source
    fn event_mutation_policy(seed? : UInt64, max_delay? : Int, delay_percent? : Int, drop_percent? : Int, duplicate_percent? : Int, reorder_same_tick? : Bool, failure_percent? : Int) -> EventMutationPolicy

    event_record

    source
    fn event_record(kind : EventKind, tick : Int, label : String, correlation_id? : String, source? : String, target? : String, parent_id? : Int, payload? : String, priority? : Int, dropped? : Bool, failed? : Bool) -> EventRecord

    expect_trace_contains_detail

    source
    fn expect_trace_contains_detail(entries : Array[TraceEntry], detail : String) -> TraceExpectation

    expect_trace_contains_kind

    source
    fn expect_trace_contains_kind(entries : Array[TraceEntry], kind : String) -> TraceExpectation

    expect_trace_digest

    source
    fn expect_trace_digest(entries : Array[TraceEntry], digest : UInt64) -> TraceExpectation

    expect_trace_kind_count

    source
    fn expect_trace_kind_count(entries : Array[TraceEntry], kind : String, expected : Int) -> TraceExpectation

    expect_trace_monotonic_ticks

    source
    fn expect_trace_monotonic_ticks(entries : Array[TraceEntry]) -> TraceExpectation

    expect_trace_order

    source
    fn expect_trace_order(entries : Array[TraceEntry], before_detail : String, after_detail : String) -> TraceExpectation

    external_call_event_kind

    source
    fn external_call_event_kind() -> EventKind

    invariant_check

    source
    fn invariant_check(name : String, passed : Bool, detail? : String) -> InvariantCheck

    message_event_kind

    source
    fn message_event_kind() -> EventKind

    metrics_counter_delta

    source
    fn metrics_counter_delta(left : Metrics, right : Metrics, name : String) -> Int

    query_trace

    source
    fn query_trace(entries : Array[TraceEntry], query : TraceQuery) -> TraceQueryResult

    replay_baseline

    source
    fn replay_baseline(name : String, sim : Sim) -> ReplayBaseline

    state_transition_event_kind

    source
    fn state_transition_event_kind() -> EventKind

    task_event_kind

    source
    fn task_event_kind() -> EventKind

    tick

    source
    fn tick(value : Int) -> Tick

    timer_event_kind

    source
    fn timer_event_kind() -> EventKind

    timer_plan

    source
    fn timer_plan(name : String, start_after? : Int, interval? : Int, times? : Int, priority? : Int) -> TimerPlan

    trace_digest

    source
    fn trace_digest(entries : Array[TraceEntry]) -> UInt64

    trace_entry

    source
    fn trace_entry(tick : Int, event_id : Int, kind : String, detail : String) -> TraceEntry

    trace_filter_detail

    source
    fn trace_filter_detail(entries : Array[TraceEntry], detail : String) -> Array[TraceEntry]

    trace_filter_kind

    source
    fn trace_filter_kind(entries : Array[TraceEntry], kind : String) -> Array[TraceEntry]

    trace_filter_tick_range

    source
    fn trace_filter_tick_range(entries : Array[TraceEntry], min_tick : Int, max_tick : Int) -> Array[TraceEntry]

    trace_query

    source
    fn trace_query(kind? : String, detail? : String, min_tick? : Int, max_tick? : Int) -> TraceQuery

    trace_query_result

    source
    fn trace_query_result(entries : Array[TraceEntry]) -> TraceQueryResult

    trace_stats

    source
    fn trace_stats(entries : Array[TraceEntry]) -> TraceStats

    trace_to_text

    source
    fn trace_to_text(entries : Array[TraceEntry]) -> String

    transition

    source
    fn transition(from : String, event : String, to : String, action? : String) -> Transition

    validate_metrics

    source
    fn validate_metrics(metrics : Metrics) -> ValidationReport

    validate_sim

    source
    fn validate_sim(sim : Sim) -> ValidationReport

    validate_trace

    source
    fn validate_trace(entries : Array[TraceEntry]) -> ValidationReport

    validation_issue

    source
    fn validation_issue(code : String, message : String, severity? : String) -> ValidationIssue

    version

    source
    fn version() -> String

    weighted_choice

    source
    fn weighted_choice(label : String, weight : Int) -> WeightedChoice

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io