🥮 mooncakes.io

    moonbit-counterpoint

    Explainable counterpoint rule engine for MoonBit

    music
    counterpoint
    rule-engine
    education
    composition
    Download zip
    Version
    0.3.2
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    44

    No dependencies

    #moonbit-counterpoint

    An explainable counterpoint analysis toolkit for MoonBit. It turns species counterpoint rules into typed findings that can be shown to a learner, consumed by a composition assistant, or exported by a command-line workflow.

    #Project positioning

    The library focuses on the analysis layer between a note sequence and a music editor. It does not attempt to replace MIDI playback or notation rendering. Its boundary is deliberately small: represent notes, validate timelines, analyze counterpoint, summarize findings, and produce machine-readable or human-readable reports.

    #Core capabilities

    • First through fifth species rhythm-shape checks.
    • Parallel and hidden perfect consonance checks.
    • Voice crossing and dissonance placement diagnostics.
    • Melodic span, leap, recovery, cadence, and suspension guidance.
    • Classroom, strict, Renaissance, and custom rule profiles.
    • Timeline validation for empty, overlapping, duplicate, non-monotonic, and excessively gapped input.
    • Pitch-class, register, voice-range, histogram, and transposition helpers.
    • Stable summaries with pass/review/fail grades and deterministic scores.
    • CSV and Markdown reports suitable for CLI output or editor integrations.
    • End-to-end pipeline output with quality gates, scorecards, practice plans, profile comparison, history tracking, and batch variant reports.
    • Dependency-free interchange helpers for note rows, TSV, manifests, and stable sequence fingerprints.

    #Quick start

    Install MoonBit stable, clone the repository, and run:

    moon check --target all
moon test --target all
moon run cmd/main

    Minimal library usage:

    ///|
    test {
      let cantus = [
        Note::new(midi=60, onset=0, duration=2, label="C"),
        Note::new(midi=62, onset=2, duration=2, label="D"),
        Note::new(midi=64, onset=4, duration=2, label="E"),
        Note::new(midi=65, onset=6, duration=2, label="F"),
        Note::new(midi=67, onset=8, duration=2, label="G"),
      ]
      let counter = [
        Note::new(midi=67, onset=0, duration=2, label="G"),
        Note::new(midi=65, onset=2, duration=2, label="F"),
        Note::new(midi=72, onset=4, duration=2, label="C"),
        Note::new(midi=81, onset=6, duration=2, label="A"),
        Note::new(midi=79, onset=8, duration=2, label="G"),
      ]
      let result = validate_pair(cantus, counter, RuleProfileConfig::classroom())
      inspect(result.passed(), content="true")
    }

    #CLI

    The example executable in cmd/main analyzes a small first-species exercise and prints the structured findings. It is intentionally dependency-free so it can serve as a smoke test for a fresh MoonBit installation.

    The library APIs can be composed into an application-specific CLI:

    • analyze_counterpoint returns the full typed report.
    • summarize returns counts, score, grade, and rule-family totals.
    • analysis_csv and analysis_markdown export reports.
    • sequence_report validates note timing before analysis.
    • validate_pair combines input validation, analysis, and profile metadata.

    #Architecture

    ModuleResponsibility
    types.mbtPublic note, rule, finding, species, and option types
    intervals.mbtMelodic/harmonic interval and motion primitives
    melody.mbtRange, leap, and recovery diagnostics
    harmony.mbtVertical sonority, parallels, hidden perfects, and cadence
    species.mbtSpecies rhythm and suspension-shape rules
    profiles.mbtReusable rule policy presets and classification helpers
    timeline.mbtSequence validation and note-time utilities
    pitch.mbt / voices.mbtPitch classes, registers, voice ranges, and alignment
    metrics.mbt / reports.mbtScores, summaries, CSV, and Markdown output
    workflow.mbtEnd-to-end pair validation facade
    rhythm.mbt / contour.mbt / statistics.mbtMeter, contour, distribution, and motion statistics
    candidates.mbt / phrase_planner.mbtBounded candidate generation and phrase planning
    phrase_windows.mbt / candidate_evidence.mbtLocal phrase partitioning and explainable candidate constraints
    analysis_triage.mbt / repair_suggestions.mbtRepair prioritization and bounded single-event edits
    harmony_tools.mbt / voice_leading.mbtSonority profiles and motion constraints
    rule_catalog.mbt / exercise_catalog.mbt / teaching.mbtExplainable rule and practice content
    pipeline.mbt / quality_gate.mbt / scorecards.mbtProduction analysis orchestration and quality gates
    interchange.mbt / report_sections.mbt / analysis_exports.mbtInterchange and composable report artifacts

    All public domain types are owned by the root package. The implementation is pure and deterministic, which keeps it suitable for teaching tools, snapshot tests, and future MIDI/MusicXML adapters.

    #Benchmarks

    The repository includes a reproducible benchmark record in benchmarks/RESULTS.md. It reports the measured MoonBit commands and a 1,000-note analysis workload. Re-run the commands from the repository root when comparing toolchain versions.

    #Testing

    The test suite contains rule examples, report checks, production API checks, and a boundary matrix. It exercises malformed timelines, extreme registers, zero and varied durations, duplicate onsets, transposition, scaling, pitch histograms, and voice-range calculations.

    moon fmt --check
moon check --target all
moon test --target all
moon coverage report -f summary
moon coverage analyze

    #CI

    GitHub Actions runs on Ubuntu, macOS, and Windows. It installs the current MoonBit stable toolchain, enforces the supported compiler floor, checks all targets, runs all tests, verifies formatting and generated interfaces, and publishes only through an explicit manual workflow.

    #License

    Apache-2.0. See LICENSE.

    Analysis

    source
    pub(all) struct Analysis {
      species : Species
      findings : Array[Finding]
    } derive(Eq, ToJson, 
    Debug    )

    Analysis::is_clean

    source
    fn Analysis::is_clean(self : Analysis) -> Bool

    AnalysisExport

    source
    pub(all) struct AnalysisExport {
      title : String
      profile : String
      summary : AnalysisSummary
      findings : Array[String]
      recommendations : Array[String]
      fingerprint : String
    } derive(Eq, ToJson, 
    Debug    )

    AnalysisHistory

    source
    pub(all) struct AnalysisHistory {
      snapshots : Array[AnalysisSnapshot]
      best_score : Int
      latest_score : Int
      improvement : Int
    } derive(Eq, ToJson, 
    Debug    )

    AnalysisOptions

    source
    pub(all) struct AnalysisOptions {
      species : Species
      strict_cadence : Bool
      max_melody_span : Int
      max_leap : Int
    } derive(Eq, ToJson, 
    Debug    )

    AnalysisOptions::default

    source
    fn AnalysisOptions::default(species~ : Species) -> AnalysisOptions

    AnalysisSnapshot

    source
    pub(all) struct AnalysisSnapshot {
      label : String
      score : Int
      errors : Int
      warnings : Int
      notes : Int
      profile : String
    } derive(Eq, ToJson, 
    Debug    )

    AnalysisSummary

    source
    pub(all) struct AnalysisSummary {
      total : Int
      errors : Int
      warnings : Int
      infos : Int
      structural : Int
      harmonic : Int
      score : Int
    } derive(Eq, ToJson, 
    Debug    )

    AnalysisSummary::grade

    source
    fn AnalysisSummary::grade(self : AnalysisSummary) -> String

    AnalysisSummary::passed

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

    AnalysisSummary::severity_total

    source
    fn AnalysisSummary::severity_total(self : AnalysisSummary) -> Int

    AnalysisTriage

    source
    pub(all) struct AnalysisTriage {
      band : TriageBand
      items : Array[TriageItem]
      total_findings : Int
      repair_score : Int
    } derive(Eq, ToJson, 
    Debug    )

    BatchReport

    source
    pub(all) struct BatchReport {
      labels : Array[String]
      summaries : Array[AnalysisSummary]
      best_index : Int
      best_score : Int
    } derive(Eq, ToJson, 
    Debug    )

    BeatPoint

    source
    pub(all) struct BeatPoint {
      index : Int
      time : Int
      measure : Int
      beat : Int
      strength : BeatStrength
    } derive(Eq, ToJson, 
    Debug    )

    BeatStrength

    source
    pub(all) enum BeatStrength {
      Downbeat
      Strong
      Weak
      Offbeat
    } derive(Eq, ToJson, 
    Debug    )

    CadencePlan

    source
    pub(all) struct CadencePlan {
      penultimate : Int
      final_pitch : Int
      final_interval : Int
      approach : Direction
      valid : Bool
      message : String
    } derive(Eq, ToJson, 
    Debug    )

    CandidateBatch

    source
    pub(all) struct CandidateBatch {
      source : Note
      candidates : Array[PitchCandidate]
      accepted : Int
      rejected : Int
    } derive(Eq, ToJson, 
    Debug    )

    CandidateConstraint

    source
    pub(all) enum CandidateConstraint {
      Range
      Consonance
      Leap
      Motion
    } derive(Eq, ToJson, 
    Debug    )

    CandidateEvaluation

    source
    pub(all) struct CandidateEvaluation {
      candidate : PitchCandidate
      constraints : Array[ConstraintEvidence]
      score : Int
      accepted : Bool
    } derive(Eq, ToJson, 
    Debug    )

    CandidatePolicy

    source
    pub(all) struct CandidatePolicy {
      low : Int
      high : Int
      max_leap : Int
      require_consonance : Bool
      prefer_contrary : Bool
      avoid_repetition : Bool
    } derive(Eq, ToJson, 
    Debug    )

    CandidatePolicy::default

    source

    CandidatePolicy::is_valid

    source
    fn CandidatePolicy::is_valid(self : CandidatePolicy) -> Bool

    CandidatePolicy::strict

    source

    ConsonanceClass

    source
    pub(all) enum ConsonanceClass {
      Perfect
      Imperfect
      Dissonant
    } derive(Eq, ToJson, 
    Debug    )

    ConstraintEvidence

    source
    pub(all) struct ConstraintEvidence {
      constraint : CandidateConstraint
      passed : Bool
      score : Int
      detail : String
    } derive(Eq, ToJson, 
    Debug    )

    ContourStep

    source
    pub(all) enum ContourStep {
      Rising
      Falling
      Repeated
      LeapUp
      LeapDown
    } derive(Eq, ToJson, 
    Debug    )

    ContourSummary

    source
    pub(all) struct ContourSummary {
      notes : Int
      rising : Int
      falling : Int
      repeated : Int
      leaps : Int
      turning_points : Int
      first_pitch : Int
      last_pitch : Int
      range : Int
    } derive(Eq, ToJson, 
    Debug    )

    Direction

    source
    pub(all) enum Direction {
      Up
      Down
      Same
    } derive(Eq, ToJson, 
    Debug    )

    ExerciseSpec

    source
    pub(all) struct ExerciseSpec {
      id : String
      rule : RuleKind
      species : Species
      title : String
      objective : String
      prompt : String
      target : String
      level : String
      notes : Int
    } derive(Eq, ToJson, 
    Debug    )

    Finding

    source
    pub(all) struct Finding {
      rule : RuleKind
      severity : Severity
      index : Int
      message : String
    } derive(Eq, ToJson, 
    Debug    )

    Finding::error

    source
    fn Finding::error(rule~ : RuleKind, index~ : Int, message~ : String) -> Finding

    Finding::warning

    source
    fn Finding::warning(rule~ : RuleKind, index~ : Int, message~ : String) -> Finding

    GateStatus

    source
    pub(all) enum GateStatus {
      Pass
      Review
      Fail
    } derive(Eq, ToJson, 
    Debug    )

    HarmonySummary

    source
    pub(all) struct HarmonySummary {
      events : Int
      perfect : Int
      imperfect : Int
      dissonant : Int
      crossings : Int
      highest : Int
      lowest : Int
    } derive(Eq, ToJson, 
    Debug    )

    IntervalSize

    source
    pub(all) enum IntervalSize {
      Unison
      Step
      Third
      Fourth
      Fifth
      Sixth
      Seventh
      Octave
      Compound
    } derive(Eq, ToJson, 
    Debug    )

    IntervalStatistics

    source
    pub(all) struct IntervalStatistics {
      count : Int
      minimum : Int
      maximum : Int
      mean : Int
      steps : Int
      leaps : Int
      repeated : Int
    } derive(Eq, ToJson, 
    Debug    )

    LessonStage

    source
    pub(all) enum LessonStage {
      Listen
      Identify
      Repair
      Compose
      Reflect
    } derive(Eq, ToJson, 
    Debug    )

    LessonStep

    source
    pub(all) struct LessonStep {
      index : Int
      stage : LessonStage
      title : String
      prompt : String
      expected_rule : RuleKind?
    } derive(Eq, ToJson, 
    Debug    )

    Meter

    source
    pub(all) struct Meter {
      numerator : Int
      denominator : Int
      subdivision : Int
    } derive(Eq, ToJson, 
    Debug    )

    Meter::beat_length

    source
    fn Meter::beat_length(self : Meter) -> Int

    Meter::beats_per_measure

    source
    fn Meter::beats_per_measure(self : Meter) -> Int

    Meter::is_valid

    source
    fn Meter::is_valid(self : Meter) -> Bool

    Meter::measure_length

    source
    fn Meter::measure_length(self : Meter) -> Int

    Meter::new

    source
    fn Meter::new(numerator~ : Int, denominator~ : Int, subdivision? : Int) -> Meter

    MotionConstraint

    source
    pub(all) struct MotionConstraint {
      name : String
      allow_parallel : Bool
      allow_similar : Bool
      allow_contrary : Bool
      allow_oblique : Bool
      max_leap : Int
    } derive(Eq, ToJson, 
    Debug    )

    MotionConstraint::allows

    source
    fn MotionConstraint::allows(self : MotionConstraint, motion_value : MotionKind) -> Bool

    MotionConstraint::classroom

    source

    MotionConstraint::strict

    source

    MotionKind

    source
    pub(all) enum MotionKind {
      Parallel
      Similar
      Contrary
      Oblique
      Static
    } derive(Eq, ToJson, 
    Debug    )

    MotionResult

    source
    pub(all) struct MotionResult {
      motion : MotionKind
      accepted : Bool
      cost : Int
      message : String
    } derive(Eq, ToJson, 
    Debug    )

    Note

    source
    pub(all) struct Note {
      midi : Int
      onset : Int
      duration : Int
      tied_from_previous : Bool
      label : String
    } derive(Eq, ToJson, 
    Debug    )

    Note::new

    source
    fn Note::new(midi~ : Int, onset~ : Int, duration~ : Int, tied_from_previous? : Bool, label? : String) -> Note

    NoteRow

    source
    pub(all) struct NoteRow {
      midi : Int
      onset : Int
      duration : Int
      tied : Bool
      label : String
    } derive(Eq, ToJson, 
    Debug    )

    NoteRow::from_note

    source
    fn NoteRow::from_note(note : Note) -> NoteRow

    NoteRow::to_note

    source
    fn NoteRow::to_note(self : NoteRow) -> Note

    PairStatistics

    source
    pub(all) struct PairStatistics {
      aligned : Int
      contrary : Int
      parallel : Int
      similar : Int
      oblique : Int
      static_motion : Int
      average_vertical : Int
    } derive(Eq, ToJson, 
    Debug    )

    PairValidation

    source
    pub(all) struct PairValidation {
      cantus : SequenceReport
      counterpoint : SequenceReport
      analysis : Analysis
      summary : AnalysisSummary
      profile : String
    } derive(Eq, ToJson, 
    Debug    )

    PairValidation::markdown

    source
    fn PairValidation::markdown(self : PairValidation) -> String

    PairValidation::passed

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

    PairValidation::quality_score

    source
    fn PairValidation::quality_score(self : PairValidation) -> Int

    PhrasePartition

    source
    pub(all) struct PhrasePartition {
      windows : Array[PhraseWindow]
      total_notes : Int
      total_duration : Int
      window_duration : Int
    } derive(Eq, ToJson, 
    Debug    )

    PhrasePlan

    source
    pub(all) struct PhrasePlan {
      segments : Array[PhraseSegment]
      cadence : CadencePlan
      total_notes : Int
      balanced : Bool
    } derive(Eq, ToJson, 
    Debug    )

    PhraseRole

    source
    pub(all) enum PhraseRole {
      Opening
      Continuation
      Preparation
      Cadence
      Extension
    } derive(Eq, ToJson, 
    Debug    )

    PhraseRole::label

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

    PhraseSegment

    source
    pub(all) struct PhraseSegment {
      start : Int
      end : Int
      role : PhraseRole
      notes : Int
      pitch_range : Int
      density : Int
    } derive(Eq, ToJson, 
    Debug    )

    PhraseWindow

    source
    pub(all) struct PhraseWindow {
      index : Int
      start_index : Int
      end_index : Int
      start_time : Int
      end_time : Int
      note_count : Int
      pitch_range : Int
      density : Int
      anchor_beat : String
    } derive(Eq, ToJson, 
    Debug    )

    PipelineInput

    source
    pub(all) struct PipelineInput {
      cantus : Array[Note]
      counterpoint : Array[Note]
      meter : Meter
      profile : RuleProfileConfig
    } derive(Eq, ToJson, 
    Debug    )

    PipelineInput::new

    source
    fn PipelineInput::new(cantus~ : Array[Note], counterpoint~ : Array[Note], meter~ : Meter, profile~ : RuleProfileConfig) -> PipelineInput

    PipelineOutput

    source
    pub(all) struct PipelineOutput {
      validation : PairValidation
      rhythm : RhythmSummary
      contour : ContourSummary
      harmony : HarmonySummary
      motion : VoiceLeadingSummary
      report : ReportDocument
      recommendations : Array[Recommendation]
    } derive(Eq, ToJson, 
    Debug    )

    PitchCandidate

    source
    pub(all) struct PitchCandidate {
      note : Note
      vertical_interval : Int
      melodic_interval : Int
      consonant : Bool
      motion : MotionKind
      score : Int
    } derive(Eq, ToJson, 
    Debug    )

    PitchClass

    source
    pub(all) enum PitchClass {
      C
      Cs
      D
      Ds
      E
      F
      Fs
      G
      Gs
      A
      As
      B
    } derive(Eq, ToJson, 
    Debug    )

    PitchStatistics

    source
    pub(all) struct PitchStatistics {
      count : Int
      minimum : Int
      maximum : Int
      mean : Int
      median : Int
      range : Int
      distinct : Int
    } derive(Eq, ToJson, 
    Debug    )

    PracticePlan

    source
    pub(all) struct PracticePlan {
      title : String
      objective : String
      steps : Array[LessonStep]
      estimated_minutes : Int
      difficulty : String
    } derive(Eq, ToJson, 
    Debug    )

    PracticeResult

    source
    pub(all) struct PracticeResult {
      completed : Int
      total : Int
      score : Int
      next_stage : LessonStage
      feedback : String
    } derive(Eq, ToJson, 
    Debug    )

    ProfileResult

    source
    pub(all) struct ProfileResult {
      profile : String
      score : Int
      grade : String
      findings : Int
      passed : Bool
    } derive(Eq, ToJson, 
    Debug    )

    QualityGate

    source
    pub(all) struct QualityGate {
      name : String
      status : GateStatus
      score : Int
      evidence : String
      action : String
    } derive(Eq, ToJson, 
    Debug    )

    QualityGateReport

    source
    pub(all) struct QualityGateReport {
      status : GateStatus
      gates : Array[QualityGate]
      score : Int
    } derive(Eq, ToJson, 
    Debug    )

    Recommendation

    source
    pub(all) struct Recommendation {
      code : String
      priority : Int
      title : String
      action : String
      evidence : String
    } derive(Eq, ToJson, 
    Debug    )

    RegisterBand

    source
    pub(all) struct RegisterBand {
      low : Int
      high : Int
      count : Int
      percentage : Int
    } derive(Eq, ToJson, 
    Debug    )

    RepairKind

    source
    pub(all) enum RepairKind {
      StepUp
      StepDown
      ReduceLeap
      MoveIntoRange
      PreserveCadence
    } derive(Eq, ToJson, 
    Debug    )

    RepairSuggestion

    source
    pub(all) struct RepairSuggestion {
      index : Int
      kind : RepairKind
      replacement_midi : Int
      score : Int
      rationale : String
    } derive(Eq, ToJson, 
    Debug    )

    ReportDocument

    source
    pub(all) struct ReportDocument {
      title : String
      sections : Array[ReportSection]
      format : String
    } derive(Eq, ToJson, 
    Debug    )

    ReportSection

    source
    pub(all) struct ReportSection {
      id : String
      title : String
      body : String
      priority : Int
    } derive(Eq, ToJson, 
    Debug    )

    ReportSection::new

    source
    fn ReportSection::new(id~ : String, title~ : String, body~ : String, priority~ : Int) -> ReportSection

    RhythmSummary

    source
    pub(all) struct RhythmSummary {
      notes : Int
      measures : Int
      downbeats : Int
      offbeats : Int
      syncopations : Int
      tied_notes : Int
      total_duration : Int
    } derive(Eq, ToJson, 
    Debug    )

    RuleCard

    source
    pub(all) struct RuleCard {
      code : String
      rule : RuleKind
      topic : String
      level : String
      title : String
      rationale : String
      remedy : String
      example : String
    } derive(Eq, ToJson, 
    Debug    )

    RuleKind

    source
    pub(all) enum RuleKind {
      ParallelPerfect
      HiddenPerfect
      VoiceCrossing
      DissonancePlacement
      MelodyRange
      LargeLeap
      LeapRecovery
      SpeciesRhythm
      CadenceShape
    } derive(Eq, ToJson, 
    Debug    )

    RuleProfile

    source
    pub(all) enum RuleProfile {
      Classroom
      Strict
      Renaissance
      Custom
    } derive(Eq, ToJson, 
    Debug    )

    RuleProfileConfig

    source
    pub(all) struct RuleProfileConfig {
      profile : RuleProfile
      allow_hidden_perfect : Bool
      allow_weak_beat_dissonance : Bool
      require_cadence : Bool
      max_span : Int
      max_leap : Int
      max_consecutive_perfect : Int
    } derive(Eq, ToJson, 
    Debug    )

    RuleProfileConfig::classroom

    source

    RuleProfileConfig::custom

    source
    fn RuleProfileConfig::custom(allow_hidden_perfect~ : Bool, allow_weak_beat_dissonance~ : Bool, require_cadence~ : Bool, max_span~ : Int, max_leap~ : Int, max_consecutive_perfect~ : Int) -> RuleProfileConfig

    RuleProfileConfig::is_valid

    source
    fn RuleProfileConfig::is_valid(self : RuleProfileConfig) -> Bool

    RuleProfileConfig::label

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

    RuleProfileConfig::renaissance

    source

    RuleProfileConfig::strict

    source

    RuleProfileConfig::with_profile

    source
    fn RuleProfileConfig::with_profile(self : RuleProfileConfig, profile : RuleProfile) -> RuleProfileConfig

    RuleTopic

    source
    pub(all) enum RuleTopic {
      Harmony
      Melody
      Rhythm
      Cadence
      VoiceLeading
    } derive(Eq, ToJson, 
    Debug    )

    Scorecard

    source
    pub(all) struct Scorecard {
      title : String
      technical : Int
      melodic : Int
      harmonic : Int
      rhythmic : Int
      explainability : Int
      total : Int
      grade : String
    } derive(Eq, ToJson, 
    Debug    )

    SequenceEnvelope

    source
    pub(all) struct SequenceEnvelope {
      name : String
      meter : Meter
      notes : Array[NoteRow]
      version : String
    } derive(Eq, ToJson, 
    Debug    )

    SequenceIssue

    source
    pub(all) enum SequenceIssue {
      EmptySequence
      NegativePitch(index~ : Int)
      InvalidDuration(index~ : Int)
      NonMonotonicOnset(index~ : Int)
      Overlap(index~ : Int)
      DuplicateOnset(index~ : Int)
      ExcessiveGap(index~ : Int)
    } derive(Eq, ToJson, 
    Debug    )

    SequenceReport

    source
    pub(all) struct SequenceReport {
      note_count : Int
      duration : Int
      issues : Array[SequenceIssue]
    } derive(Eq, ToJson, 
    Debug    )

    SequenceReport::error_count

    source
    fn SequenceReport::error_count(self : SequenceReport) -> Int

    SequenceReport::is_valid

    source
    fn SequenceReport::is_valid(self : SequenceReport) -> Bool

    Severity

    source
    pub(all) enum Severity {
      Error
      Warning
      Info
    } derive(Eq, ToJson, 
    Debug    )

    Species

    source
    pub(all) enum Species {
      First
      Second
      Third
      Fourth
      Fifth
    } derive(Eq, ToJson, 
    Debug    )

    TeachingLevel

    source
    pub(all) enum TeachingLevel {
      Foundation
      Intermediate
      Advanced
    } derive(Eq, ToJson, 
    Debug    )

    Transformation

    source
    pub(all) struct Transformation {
      kind : TransformationKind
      amount : Int
      description : String
    } derive(Eq, ToJson, 
    Debug    )

    TransformationKind

    source
    pub(all) enum TransformationKind {
      Transpose
      Invert
      Retrograde
      Stretch
      Compress
      Rotate
    } derive(Eq, ToJson, 
    Debug    )

    TriageBand

    source
    pub(all) enum TriageBand {
      Critical
      Attention
      Healthy
    } derive(Eq, ToJson, 
    Debug    )

    TriageItem

    source
    pub(all) struct TriageItem {
      rule : RuleKind
      count : Int
      errors : Int
      warnings : Int
      infos : Int
      priority : Int
      band : TriageBand
      action : String
    } derive(Eq, ToJson, 
    Debug    )

    TurningPoint

    source
    pub(all) struct TurningPoint {
      index : Int
      pitch : Int
      before : Direction
      after : Direction
    } derive(Eq, ToJson, 
    Debug    )

    VerticalEvent

    source
    pub(all) struct VerticalEvent {
      index : Int
      lower : Int
      upper : Int
      semitones : Int
      interval_class : Int
      class : ConsonanceClass
      inversion : Bool
    } derive(Eq, ToJson, 
    Debug    )

    VoiceAssessment

    source
    pub(all) struct VoiceAssessment {
      role : VoiceRole
      range : VoiceRange
      notes : Int
      violations : Int
      lowest : Int
      highest : Int
    } derive(Eq, ToJson, 
    Debug    )

    VoiceAssessment::passed

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

    VoiceAssessment::span

    source
    fn VoiceAssessment::span(self : VoiceAssessment) -> Int

    VoiceLeadingSummary

    source
    pub(all) struct VoiceLeadingSummary {
      transitions : Int
      accepted : Int
      rejected : Int
      contrary : Int
      parallel : Int
      similar : Int
      oblique : Int
      total_cost : Int
    } derive(Eq, ToJson, 
    Debug    )

    VoiceRange

    source
    pub(all) enum VoiceRange {
      Soprano
      Alto
      Tenor
      Bass
      CustomRange(low~ : Int, high~ : Int)
    } derive(Eq, ToJson, 
    Debug    )

    VoiceRange::contains

    source
    fn VoiceRange::contains(self : VoiceRange, midi : Int) -> Bool

    VoiceRange::high

    source
    fn VoiceRange::high(self : VoiceRange) -> Int

    VoiceRange::low

    source
    fn VoiceRange::low(self : VoiceRange) -> Int

    VoiceRange::width

    source
    fn VoiceRange::width(self : VoiceRange) -> Int

    VoiceRole

    source
    pub(all) enum VoiceRole {
      Cantus
      Counterpoint
      Upper
      Lower
    } derive(Eq, ToJson, 
    Debug    )

    absolute_melodic_interval

    source
    fn absolute_melodic_interval(a : Note, b : Note) -> Int

    active_at

    source
    fn active_at(notes : Array[Note], time : Int) -> Array[Note]

    add_snapshot

    source
    fn add_snapshot(history : AnalysisHistory, value : AnalysisSnapshot) -> AnalysisHistory

    aligned_pairs

    source
    fn aligned_pairs(lower : Array[Note], upper : Array[Note]) -> Int

    analysis_csv

    source
    fn analysis_csv(analysis : Analysis) -> String

    analysis_fingerprint

    source
    fn analysis_fingerprint(analysis : Analysis) -> String

    analysis_has_rule

    source
    fn analysis_has_rule(analysis : Analysis, rule : RuleKind) -> Bool

    analysis_indices

    source
    fn analysis_indices(analysis : Analysis) -> Array[Int]

    analysis_is_empty

    source
    fn analysis_is_empty(analysis : Analysis) -> Bool

    analysis_manifest

    source
    fn analysis_manifest(analysis : Analysis) -> Array[String]

    analysis_manifest_text

    source
    fn analysis_manifest_text(analysis : Analysis) -> String

    analysis_markdown

    source
    fn analysis_markdown(analysis : Analysis) -> String

    analysis_title

    source
    fn analysis_title(analysis : Analysis) -> String

    analyze_batch

    source
    fn analyze_batch(cantus : Array[Note], variants : Array[Array[Note]], profile : RuleProfileConfig) -> Array[AnalysisSummary]

    analyze_counterpoint

    source
    fn analyze_counterpoint(cantus : Array[Note], counter : Array[Note], options? : AnalysisOptions) -> Analysis

    analyze_harmony

    source
    fn analyze_harmony(cantus : Array[Note], counter : Array[Note], options : AnalysisOptions) -> Array[Finding]

    analyze_melody

    source
    fn analyze_melody(notes : Array[Note], options : AnalysisOptions) -> Array[Finding]

    analyze_species_shape

    source
    fn analyze_species_shape(cantus : Array[Note], counter : Array[Note], options : AnalysisOptions) -> Array[Finding]

    analyze_with_profile

    source
    fn analyze_with_profile(cantus : Array[Note], counter : Array[Note], profile : RuleProfileConfig) -> Analysis

    api_health

    source
    fn api_health(notes : Array[Note], meter : Meter) -> Bool

    api_health_message

    source
    fn api_health_message(notes : Array[Note], meter : Meter) -> String

    append_report_section

    source
    fn append_report_section(document : ReportDocument, section : ReportSection) -> ReportDocument

    apply_repair_suggestion

    source
    fn apply_repair_suggestion(notes : Array[Note], suggestion : RepairSuggestion) -> Array[Note]

    apply_transformation

    source
    fn apply_transformation(notes : Array[Note], transformation : Transformation) -> Array[Note]

    assess_voice

    source
    fn assess_voice(notes : Array[Note], role : VoiceRole, range : VoiceRange) -> VoiceAssessment

    average_interval

    source
    fn average_interval(notes : Array[Note]) -> Int

    average_pitch

    source
    fn average_pitch(notes : Array[Note]) -> Int

    batch_average

    source
    fn batch_average(report : BatchReport) -> Int

    batch_best_label

    source
    fn batch_best_label(report : BatchReport) -> String?

    batch_count

    source
    fn batch_count(report : BatchReport) -> Int

    batch_csv

    source
    fn batch_csv(report : BatchReport) -> String

    batch_failure_count

    source
    fn batch_failure_count(report : BatchReport) -> Int

    batch_improvement

    source
    fn batch_improvement(report : BatchReport) -> Int

    batch_is_better_than

    source
    fn batch_is_better_than(report : BatchReport, baseline : Int) -> Bool

    batch_manifest

    source
    fn batch_manifest(report : BatchReport) -> Array[String]

    batch_markdown

    source
    fn batch_markdown(report : BatchReport) -> String

    batch_pass_count

    source
    fn batch_pass_count(report : BatchReport) -> Int

    batch_quality

    source
    fn batch_quality(report : BatchReport) -> String

    batch_report

    source
    fn batch_report(cantus : Array[Note], variants : Array[Array[Note]], labels : Array[String], profile : RuleProfileConfig) -> BatchReport

    batch_scores

    source
    fn batch_scores(report : BatchReport) -> Array[Int]

    beat_label

    source
    fn beat_label(point : BeatPoint) -> String

    beat_of

    source
    fn beat_of(meter : Meter, time : Int) -> Int

    beat_point

    source
    fn beat_point(meter : Meter, time : Int, index : Int) -> BeatPoint

    beat_points

    source
    fn beat_points(meter : Meter, notes : Array[Note]) -> Array[BeatPoint]

    beat_strength

    source
    fn beat_strength(meter : Meter, beat : Int) -> BeatStrength

    best_candidate

    source
    fn best_candidate(candidates : Array[PitchCandidate]) -> PitchCandidate?

    best_candidates

    source
    fn best_candidates(candidates : Array[PitchCandidate], limit : Int) -> Array[PitchCandidate]

    best_evaluation

    source
    fn best_evaluation(evaluations : Array[CandidateEvaluation]) -> CandidateEvaluation?

    best_pipeline

    source
    fn best_pipeline(input : PipelineInput) -> PipelineOutput

    best_profile_result

    source
    fn best_profile_result(results : Array[ProfileResult]) -> ProfileResult?

    best_repair_suggestion

    source
    fn best_repair_suggestion(suggestions : Array[RepairSuggestion]) -> RepairSuggestion?

    best_variant

    source
    fn best_variant(cantus : Array[Note], variants : Array[Array[Note]], profile : RuleProfileConfig) -> Array[Note]?

    cadence_candidates

    source
    fn cadence_candidates(cantus : Note, final_pitch : Int, policy : CandidatePolicy) -> Array[PitchCandidate]

    cadence_distance

    source
    fn cadence_distance(notes : Array[Note], target : Int) -> Int

    cadence_message

    source
    fn cadence_message(plan : PhrasePlan) -> String

    cadence_plan

    source
    fn cadence_plan(cantus : Array[Note], counter : Array[Note]) -> CadencePlan

    candidate_constraint_name

    source
    fn candidate_constraint_name(constraint : CandidateConstraint) -> String

    candidate_count_in_range

    source
    fn candidate_count_in_range(candidates : Array[PitchCandidate], low : Int, high : Int) -> Int

    candidate_evaluation_count

    source
    fn candidate_evaluation_count(evaluation : CandidateEvaluation) -> Int

    candidate_evaluation_failed

    source
    fn candidate_evaluation_failed(evaluation : CandidateEvaluation) -> Array[CandidateConstraint]

    candidate_evaluation_has

    source
    fn candidate_evaluation_has(evaluation : CandidateEvaluation, constraint : CandidateConstraint) -> Bool

    candidate_evaluation_markdown

    source
    fn candidate_evaluation_markdown(evaluation : CandidateEvaluation) -> String

    candidate_evaluation_passes

    source
    fn candidate_evaluation_passes(evaluation : CandidateEvaluation, constraint : CandidateConstraint) -> Bool

    candidate_evaluation_summary

    source
    fn candidate_evaluation_summary(evaluation : CandidateEvaluation) -> String

    candidate_has_rule

    source
    fn candidate_has_rule(candidate : PitchCandidate, rule : RuleKind) -> Bool

    candidate_is_allowed

    source
    fn candidate_is_allowed(cantus : Note, previous : Note?, candidate : Note, policy : CandidatePolicy) -> Bool

    candidate_motion

    source
    fn candidate_motion(cantus_before : Note, cantus_after : Note, counter_before : Note, counter_after : Note) -> MotionKind

    candidate_motion_name

    source
    fn candidate_motion_name(motion_value : MotionKind) -> String

    candidate_note

    source
    fn candidate_note(source : Note, midi : Int) -> Note

    candidate_range

    source
    fn candidate_range(candidates : Array[PitchCandidate]) -> Int

    candidate_score

    source
    fn candidate_score(vertical : Int, melodic : Int, motion_value : MotionKind, policy : CandidatePolicy) -> Int

    candidate_scores

    source
    fn candidate_scores(candidates : Array[PitchCandidate]) -> Array[Int]

    cap_quality

    source
    fn cap_quality(value : Int) -> Int

    cards_for_level

    source
    fn cards_for_level(level : String) -> Array[RuleCard]

    cards_for_rule

    source
    fn cards_for_rule(rule : RuleKind) -> Array[RuleCard]

    cards_for_topic

    source
    fn cards_for_topic(topic : String) -> Array[RuleCard]

    catalog_levels

    source
    fn catalog_levels() -> Array[String]

    catalog_topics

    source
    fn catalog_topics() -> Array[String]

    compact_report

    source
    fn compact_report(analysis : Analysis) -> String

    compact_report_document

    source
    fn compact_report_document(document : ReportDocument) -> String

    compare_contours

    source
    fn compare_contours(left : Array[Note], right : Array[Note]) -> Int

    compare_pitch_statistics

    source
    fn compare_pitch_statistics(left : Array[Note], right : Array[Note]) -> Int

    compare_profiles

    source
    fn compare_profiles(cantus : Array[Note], counter : Array[Note]) -> Array[AnalysisSummary]

    compare_scores

    source
    fn compare_scores(left : Analysis, right : Analysis, profile : RuleProfileConfig) -> Int

    compress_sequence

    source
    fn compress_sequence(notes : Array[Note], factor : Int) -> Array[Note]

    consecutive_perfects

    source
    fn consecutive_perfects(lower : Array[Note], upper : Array[Note]) -> Array[Int]

    consonance_class

    source
    fn consonance_class(semitones : Int) -> ConsonanceClass

    consonance_class_name

    source
    fn consonance_class_name(value : ConsonanceClass) -> String

    constrained_quality

    source
    fn constrained_quality(lower : Array[Note], upper : Array[Note], constraint : MotionConstraint) -> Int

    contour_balance

    source
    fn contour_balance(notes : Array[Note]) -> Int

    contour_label

    source
    fn contour_label(step : ContourStep) -> String

    contour_preserved_after_transpose

    source
    fn contour_preserved_after_transpose(notes : Array[Note], semitones : Int) -> Bool

    contour_range

    source
    fn contour_range(notes : Array[Note]) -> Int

    contour_section

    source
    fn contour_section(notes : Array[Note]) -> ReportSection

    contour_step

    source
    fn contour_step(left : Note, right : Note) -> ContourStep

    contour_steps

    source
    fn contour_steps(notes : Array[Note]) -> Array[ContourStep]

    contour_summary

    source
    fn contour_summary(notes : Array[Note]) -> ContourSummary

    contrary_motion_count

    source
    fn contrary_motion_count(cantus : Array[Note], counter : Array[Note]) -> Int

    contrary_motion_ratio

    source
    fn contrary_motion_ratio(lower : Array[Note], upper : Array[Note]) -> Int

    count_contour

    source
    fn count_contour(notes : Array[Note], step : ContourStep) -> Int

    count_direction

    source
    fn count_direction(notes : Array[Note], direction_value : Direction) -> Int

    count_duration

    source
    fn count_duration(notes : Array[Note], duration : Int) -> Int

    crossing_count

    source
    fn crossing_count(lower : Array[Note], upper : Array[Note]) -> Int

    default_practice_plan

    source
    fn default_practice_plan(rule : RuleKind) -> PracticePlan

    density_by_measure

    source
    fn density_by_measure(meter : Meter, notes : Array[Note]) -> Array[Int]

    direction

    source
    fn direction(a : Note, b : Note) -> Direction

    direction_name

    source
    fn direction_name(value : Direction) -> String

    dissonance_ratio

    source
    fn dissonance_ratio(lower : Array[Note], upper : Array[Note]) -> Int

    duration_between

    source
    fn duration_between(notes : Array[Note], start : Int, end : Int) -> Int

    duration_histogram

    source
    fn duration_histogram(notes : Array[Note]) -> Array[Int]

    duration_ratio

    source
    fn duration_ratio(notes : Array[Note], duration : Int) -> Int

    edit_distance

    source
    fn edit_distance(left : Array[Note], right : Array[Note]) -> Int

    empty_history

    source
    fn empty_history() -> AnalysisHistory

    envelope

    source
    fn envelope(name : String, meter : Meter, notes : Array[Note]) -> SequenceEnvelope

    envelope_notes

    source
    fn envelope_notes(value : SequenceEnvelope) -> Array[Note]

    envelope_summary

    source
    fn envelope_summary(value : SequenceEnvelope) -> String

    evaluate_candidate

    source
    fn evaluate_candidate(cantus_before : Note, cantus_after : Note, counter_before : Note, counter_after : Note, candidate : Note, policy : CandidatePolicy) -> CandidateEvaluation

    Evaluate a candidate as transparent constraint evidence instead of one opaque score.

    evaluate_candidates

    source
    fn evaluate_candidates(cantus_before : Note, cantus_after : Note, counter_before : Note, counter_after : Note, candidates : Array[Note], policy : CandidatePolicy) -> Array[CandidateEvaluation]

    evaluate_motion

    source
    fn evaluate_motion(lower_before : Note, lower_after : Note, upper_before : Note, upper_after : Note, constraint : MotionConstraint) -> MotionResult

    evaluate_practice

    source
    fn evaluate_practice(plan : PracticePlan, completed : Int, score : Int) -> PracticeResult

    evaluate_voice_leading

    source
    fn evaluate_voice_leading(lower : Array[Note], upper : Array[Note], constraint : MotionConstraint) -> Array[MotionResult]

    event_count_between

    source
    fn event_count_between(notes : Array[Note], start : Int, end : Int) -> Int

    exercise

    source
    fn exercise(id : String) -> ExerciseSpec?

    exercise_catalog

    source
    fn exercise_catalog() -> Array[ExerciseSpec]

    The curriculum is intentionally small and curated: each item names a distinct musical task.

    exercise_catalog_markdown

    source
    fn exercise_catalog_markdown(rule : RuleKind) -> String

    exercise_count

    source
    fn exercise_count() -> Int

    exercise_minutes

    source
    fn exercise_minutes(item : ExerciseSpec) -> Int

    exercise_objective

    source
    fn exercise_objective(item : ExerciseSpec) -> String

    exercise_prompt

    source
    fn exercise_prompt(item : ExerciseSpec) -> String

    exercise_summary

    source
    fn exercise_summary(item : ExerciseSpec) -> String

    exercise_target

    source
    fn exercise_target(item : ExerciseSpec) -> String

    exercises_for_level

    source
    fn exercises_for_level(level : String) -> Array[ExerciseSpec]

    exercises_for_rule

    source
    fn exercises_for_rule(rule : RuleKind) -> Array[ExerciseSpec]

    exercises_for_species

    source
    fn exercises_for_species(species : Species) -> Array[ExerciseSpec]

    export_csv

    source
    fn export_csv(value : AnalysisExport) -> String

    export_findings_count

    source
    fn export_findings_count(value : AnalysisExport) -> Int

    export_findings_for

    source
    fn export_findings_for(value : AnalysisExport, rule : RuleKind) -> Array[String]

    export_grade

    source
    fn export_grade(value : AnalysisExport) -> String

    export_has_fingerprint

    source
    fn export_has_fingerprint(value : AnalysisExport, fingerprint : String) -> Bool

    export_is_clean

    source
    fn export_is_clean(value : AnalysisExport) -> Bool

    export_line_count

    source
    fn export_line_count(value : AnalysisExport) -> Int

    export_markdown

    source
    fn export_markdown(value : AnalysisExport) -> String

    export_profile

    source
    fn export_profile(value : AnalysisExport) -> String

    export_recommendation_count

    source
    fn export_recommendation_count(value : AnalysisExport) -> Int

    export_score

    source
    fn export_score(value : AnalysisExport) -> Int

    export_summary_line

    source
    fn export_summary_line(value : AnalysisExport) -> String

    export_to_sections

    source
    fn export_to_sections(value : AnalysisExport) -> Array[ReportSection]

    feature_count

    source
    fn feature_count() -> Int

    filter_by_beat

    source
    fn filter_by_beat(meter : Meter, notes : Array[Note], strength : BeatStrength) -> Array[Note]

    filter_by_duration

    source
    fn filter_by_duration(notes : Array[Note], duration : Int) -> Array[Note]

    filter_by_range

    source
    fn filter_by_range(notes : Array[Note], low : Int, high : Int) -> Array[Note]

    final_sonority_is_valid

    source
    fn final_sonority_is_valid(lower : Array[Note], upper : Array[Note]) -> Bool

    finding_count

    source
    fn finding_count(analysis : Analysis, rule : RuleKind) -> Int

    finding_csv

    source
    fn finding_csv(finding : Finding) -> String

    findings_for

    source
    fn findings_for(analysis : Analysis, severity : Severity) -> Array[Finding]

    findings_for_rule

    source
    fn findings_for_rule(analysis : Analysis, rule : RuleKind) -> Array[Finding]

    findings_section

    source
    fn findings_section(analysis : Analysis) -> ReportSection

    first_dissonance

    source
    fn first_dissonance(lower : Array[Note], upper : Array[Note]) -> Int?

    first_pitch

    source
    fn first_pitch(notes : Array[Note]) -> Int?

    format_analysis

    source
    fn format_analysis(analysis : Analysis) -> String

    format_finding

    source
    fn format_finding(finding : Finding) -> String

    format_note_row

    source
    fn format_note_row(row : NoteRow) -> String

    format_sequence

    source
    fn format_sequence(notes : Array[Note]) -> String

    gap_count

    source
    fn gap_count(notes : Array[Note]) -> Int

    gate_count

    source
    fn gate_count(report : QualityGateReport, status : GateStatus) -> Int

    gate_for_motion

    source
    fn gate_for_motion(summary : VoiceLeadingSummary) -> QualityGate

    gate_for_sequence

    source
    fn gate_for_sequence(report : SequenceReport, name : String) -> QualityGate

    gate_for_summary

    source
    fn gate_for_summary(summary : AnalysisSummary) -> QualityGate

    gate_status_name

    source
    fn gate_status_name(status : GateStatus) -> String

    generate_candidates

    source
    fn generate_candidates(cantus : Note, previous : Note?, policy : CandidatePolicy) -> Array[PitchCandidate]

    generate_voice_candidates

    source
    fn generate_voice_candidates(cantus_before : Note, cantus_after : Note, counter_before : Note?, policy : CandidatePolicy) -> CandidateBatch

    harmonic_interval

    source
    fn harmonic_interval(lower : Note, upper : Note) -> Int

    harmonic_motion_count

    source
    fn harmonic_motion_count(lower : Array[Note], upper : Array[Note], label : String) -> Int

    harmonic_motion_labels

    source
    fn harmonic_motion_labels(lower : Array[Note], upper : Array[Note]) -> Array[String]

    harmonic_signature

    source
    fn harmonic_signature(lower : Array[Note], upper : Array[Note]) -> String

    harmony_section

    source
    fn harmony_section(lower : Array[Note], upper : Array[Note]) -> ReportSection

    harmony_summary

    source
    fn harmony_summary(lower : Array[Note], upper : Array[Note]) -> HarmonySummary

    has_feature

    source
    fn has_feature(name : String) -> Bool

    health_summary

    source
    fn health_summary() -> String

    hidden_perfect_indices

    source
    fn hidden_perfect_indices(lower : Array[Note], upper : Array[Note]) -> Array[Int]

    highest_severity

    source
    fn highest_severity(analysis : Analysis) -> Severity?

    history_average

    source
    fn history_average(history : AnalysisHistory) -> Int

    history_best

    source
    fn history_best(history : AnalysisHistory) -> AnalysisSnapshot?

    history_delta

    source
    fn history_delta(history : AnalysisHistory, first : Int, second : Int) -> Int?

    history_errors

    source
    fn history_errors(history : AnalysisHistory) -> Int

    history_fingerprint

    source
    fn history_fingerprint(history : AnalysisHistory) -> String

    history_from_validations

    source
    fn history_from_validations(labels : Array[String], validations : Array[PairValidation]) -> AnalysisHistory

    history_is_improving

    source
    fn history_is_improving(history : AnalysisHistory) -> Bool

    history_latest

    source
    fn history_latest(history : AnalysisHistory) -> AnalysisSnapshot?

    history_markdown

    source
    fn history_markdown(history : AnalysisHistory) -> String

    history_scores

    source
    fn history_scores(history : AnalysisHistory) -> Array[Int]

    history_warnings

    source
    fn history_warnings(history : AnalysisHistory) -> Int

    interval_class

    source
    fn interval_class(semitones : Int) -> Int

    interval_class_name

    source
    fn interval_class_name(value : Int) -> String

    interval_is_stable

    source
    fn interval_is_stable(value : Int) -> Bool

    interval_profile

    source
    fn interval_profile(notes : Array[Note]) -> Array[Int]

    interval_size

    source
    fn interval_size(semitones : Int) -> IntervalSize

    interval_size_name

    source
    fn interval_size_name(value : IntervalSize) -> String

    interval_statistics

    source
    fn interval_statistics(notes : Array[Note]) -> IntervalStatistics

    interval_tension

    source
    fn interval_tension(value : Int) -> Int

    invert_sequence

    source
    fn invert_sequence(notes : Array[Note], axis : Int) -> Array[Note]

    is_accented

    source
    fn is_accented(point : BeatPoint) -> Bool

    is_arch_shape

    source
    fn is_arch_shape(notes : Array[Note]) -> Bool

    is_black_key

    source
    fn is_black_key(midi : Int) -> Bool

    is_consonance

    source
    fn is_consonance(semitones : Int) -> Bool

    is_dissonance

    source
    fn is_dissonance(semitones : Int) -> Bool

    is_extreme_register

    source
    fn is_extreme_register(midi : Int) -> Bool

    is_imperfect_consonance

    source
    fn is_imperfect_consonance(semitones : Int) -> Bool

    is_leap

    source
    fn is_leap(semitones : Int) -> Bool

    is_measure_boundary

    source
    fn is_measure_boundary(meter : Meter, time : Int) -> Bool

    is_perfect_consonance

    source
    fn is_perfect_consonance(semitones : Int) -> Bool

    is_step

    source
    fn is_step(semitones : Int) -> Bool

    is_valley_shape

    source
    fn is_valley_shape(notes : Array[Note]) -> Bool

    is_weak

    source
    fn is_weak(point : BeatPoint) -> Bool

    labels_text

    source
    fn labels_text(notes : Array[Note]) -> String

    largest_repeated_run

    source
    fn largest_repeated_run(notes : Array[Note]) -> Int

    last_dissonance

    source
    fn last_dissonance(lower : Array[Note], upper : Array[Note]) -> Int?

    last_pitch

    source
    fn last_pitch(notes : Array[Note]) -> Int?

    learning_objective

    source
    fn learning_objective(rule : RuleKind) -> String

    lesson_prompts

    source
    fn lesson_prompts(stage : LessonStage) -> Array[String]

    lesson_stage_index

    source
    fn lesson_stage_index(stage : LessonStage) -> Int

    lesson_stage_name

    source
    fn lesson_stage_name(stage : LessonStage) -> String

    lesson_stage_order

    source
    fn lesson_stage_order() -> Array[LessonStage]

    lesson_step

    source
    fn lesson_step(index : Int, stage : LessonStage, title : String, prompt : String, rule : RuleKind?) -> LessonStep

    library_name

    source
    fn library_name() -> String

    library_version

    source
    fn library_version() -> String

    make_analysis_export

    source
    fn make_analysis_export(title : String, profile : RuleProfileConfig, analysis : Analysis) -> AnalysisExport

    make_scorecard

    source
    fn make_scorecard(output : PipelineOutput) -> Scorecard

    make_segment

    source
    fn make_segment(notes : Array[Note], start : Int, end : Int, role : PhraseRole) -> PhraseSegment

    manifest

    source
    fn manifest(profile : RuleProfileConfig, meter : Meter) -> Array[String]

    manifest_text

    source
    fn manifest_text(profile : RuleProfileConfig, meter : Meter) -> String

    maximum_density

    source
    fn maximum_density(meter : Meter, notes : Array[Note]) -> Int

    measure_of

    source
    fn measure_of(meter : Meter, time : Int) -> Int

    melodic_interval

    source
    fn melodic_interval(a : Note, b : Note) -> Int

    melodic_interval_histogram

    source
    fn melodic_interval_histogram(notes : Array[Note]) -> Array[Int]

    merge_sequences

    source
    fn merge_sequences(left : Array[Note], right : Array[Note]) -> Array[Note]

    motion

    source
    fn motion(cantus_a : Note, cantus_b : Note, counter_a : Note, counter_b : Note) -> MotionKind

    motion_acceptance_rate

    source
    fn motion_acceptance_rate(summary : VoiceLeadingSummary) -> Int

    motion_cost

    source
    fn motion_cost(value : MotionKind) -> Int

    motion_rejection_indices

    source
    fn motion_rejection_indices(lower : Array[Note], upper : Array[Note], constraint : MotionConstraint) -> Array[Int]

    next_exercise

    source
    fn next_exercise(rule : RuleKind, completed : Array[String]) -> ExerciseSpec?

    next_lesson_stage

    source
    fn next_lesson_stage(stage : LessonStage) -> LessonStage

    normalize_onsets

    source
    fn normalize_onsets(notes : Array[Note]) -> Array[Note]

    normalize_phrase

    source
    fn normalize_phrase(notes : Array[Note], low : Int, high : Int) -> Array[Note]

    normalize_pitch

    source
    fn normalize_pitch(midi : Int, low : Int, high : Int) -> Int

    note_at_index

    source
    fn note_at_index(notes : Array[Note], index : Int) -> Note?

    note_end

    source
    fn note_end(note : Note) -> Int

    note_indices

    source
    fn note_indices(notes : Array[Note]) -> Array[Int]

    note_name

    source
    fn note_name(note : Note) -> String

    note_row_header

    source
    fn note_row_header() -> String

    note_row_to_line

    source
    fn note_row_to_line(row : NoteRow) -> String

    note_with_pitch

    source
    fn note_with_pitch(note : Note, midi : Int) -> Note

    notes_at

    source
    fn notes_at(notes : Array[Note], onset : Int) -> Array[Note]

    notes_from_pitches

    source
    fn notes_from_pitches(pitches_value : Array[Int], duration : Int) -> Array[Note]

    notes_from_rows

    source
    fn notes_from_rows(rows : Array[NoteRow]) -> Array[Note]

    notes_to_lines

    source
    fn notes_to_lines(notes : Array[Note]) -> Array[String]

    notes_to_pitches

    source
    fn notes_to_pitches(notes : Array[Note]) -> Array[Int]

    notes_to_tsv

    source
    fn notes_to_tsv(notes : Array[Note]) -> String

    notes_with_labels

    source
    fn notes_with_labels(notes : Array[Note]) -> Array[String]

    octave_number

    source
    fn octave_number(midi : Int) -> Int

    onset_histogram

    source
    fn onset_histogram(notes : Array[Note], period : Int) -> Array[Int]

    onset_span

    source
    fn onset_span(notes : Array[Note]) -> Int

    package_ready

    source
    fn package_ready() -> Bool

    pair_statistics

    source
    fn pair_statistics(cantus : Array[Note], counter : Array[Note]) -> PairStatistics

    parallel_perfect_indices

    source
    fn parallel_perfect_indices(lower : Array[Note], upper : Array[Note]) -> Array[Int]

    partition_phrases

    source
    fn partition_phrases(notes : Array[Note], meter : Meter, measures_per_window : Int) -> PhrasePartition

    Divide a sequence into deterministic measure-sized windows for local analysis.

    perfect_ratio

    source
    fn perfect_ratio(lower : Array[Note], upper : Array[Note]) -> Int

    phrase_is_cadential

    source
    fn phrase_is_cadential(plan : PhrasePlan) -> Bool

    phrase_length

    source
    fn phrase_length(plan : PhrasePlan) -> Int

    phrase_partition_boundaries

    source
    fn phrase_partition_boundaries(partition : PhrasePartition) -> Array[Int]

    phrase_partition_for_meter

    source
    fn phrase_partition_for_meter(notes : Array[Note], meter : Meter) -> PhrasePartition

    phrase_partition_markdown

    source
    fn phrase_partition_markdown(partition : PhrasePartition) -> String

    phrase_partition_summary

    source
    fn phrase_partition_summary(partition : PhrasePartition) -> String

    phrase_role_counts

    source
    fn phrase_role_counts(plan : PhrasePlan) -> Array[Int]

    phrase_window

    source
    fn phrase_window(partition : PhrasePartition, index : Int) -> PhraseWindow?

    phrase_window_contains

    source
    fn phrase_window_contains(window : PhraseWindow, note_index : Int) -> Bool

    phrase_window_count

    source
    fn phrase_window_count(partition : PhrasePartition) -> Int

    phrase_window_duration

    source
    fn phrase_window_duration(window : PhraseWindow) -> Int

    phrase_window_is_dense

    source
    fn phrase_window_is_dense(window : PhraseWindow, threshold : Int) -> Bool

    phrase_window_summary

    source
    fn phrase_window_summary(window : PhraseWindow) -> String

    pipeline_compare

    source
    fn pipeline_compare(left : PipelineOutput, right : PipelineOutput) -> Int

    pipeline_grade

    source
    fn pipeline_grade(output : PipelineOutput) -> String

    pipeline_has_quality_flag

    source
    fn pipeline_has_quality_flag(output : PipelineOutput, flag : String) -> Bool

    pipeline_has_rule

    source
    fn pipeline_has_rule(output : PipelineOutput, rule : RuleKind) -> Bool

    pipeline_is_explainable

    source
    fn pipeline_is_explainable(output : PipelineOutput) -> Bool

    pipeline_manifest

    source
    fn pipeline_manifest(output : PipelineOutput) -> Array[String]

    pipeline_manifest_text

    source
    fn pipeline_manifest_text(output : PipelineOutput) -> String

    pipeline_markdown

    source
    fn pipeline_markdown(output : PipelineOutput) -> String

    pipeline_passed

    source
    fn pipeline_passed(output : PipelineOutput) -> Bool

    pipeline_profile

    source
    fn pipeline_profile(output : PipelineOutput) -> String

    pipeline_profiles

    source
    fn pipeline_profiles(input : PipelineInput) -> Array[PipelineOutput]

    pipeline_quality_flags

    source
    fn pipeline_quality_flags(output : PipelineOutput) -> Array[String]

    pipeline_recommendation_count

    source
    fn pipeline_recommendation_count(output : PipelineOutput) -> Int

    pipeline_report_section_count

    source
    fn pipeline_report_section_count(output : PipelineOutput) -> Int

    pipeline_rule_count

    source
    fn pipeline_rule_count(output : PipelineOutput, rule : RuleKind) -> Int

    pipeline_score

    source
    fn pipeline_score(output : PipelineOutput) -> Int

    pipeline_summary

    source
    fn pipeline_summary(output : PipelineOutput) -> String

    pipeline_with_profile

    source
    fn pipeline_with_profile(input : PipelineInput, profile : RuleProfileConfig) -> PipelineOutput

    pitch_class

    source
    fn pitch_class(midi : Int) -> PitchClass

    pitch_class_name

    source
    fn pitch_class_name(pitch : PitchClass) -> String

    pitch_edit_distance

    source
    fn pitch_edit_distance(left : Array[Note], right : Array[Note]) -> Int

    pitch_histogram

    source
    fn pitch_histogram(notes : Array[Note]) -> Array[Int]

    pitch_label

    source
    fn pitch_label(midi : Int) -> String

    pitch_rows

    source
    fn pitch_rows(low : Int, high : Int, onset : Int, duration : Int) -> Array[NoteRow]

    pitch_statistics

    source
    fn pitch_statistics(notes : Array[Note]) -> PitchStatistics

    pitch_variance_proxy

    source
    fn pitch_variance_proxy(notes : Array[Note]) -> Int

    pitches

    source
    fn pitches(notes : Array[Note]) -> Array[Int]

    plan_for_analysis

    source
    fn plan_for_analysis(analysis : Analysis) -> PracticePlan

    plan_is_complete

    source
    fn plan_is_complete(result : PracticeResult) -> Bool

    plan_markdown

    source
    fn plan_markdown(plan : PracticePlan) -> String

    plan_phrase

    source
    fn plan_phrase(cantus : Array[Note], counter : Array[Note], segment_size : Int) -> PhrasePlan

    plan_progress

    source
    fn plan_progress(result : PracticeResult) -> Int

    plan_step

    source
    fn plan_step(plan : PracticePlan, index : Int) -> LessonStep?

    practice_section

    source
    fn practice_section(analysis : Analysis) -> ReportSection

    production_features

    source
    fn production_features() -> Array[String]

    profile_config

    source
    fn profile_config(profile : RuleProfile) -> RuleProfileConfig

    profile_improvement

    source
    fn profile_improvement(results : Array[ProfileResult]) -> Int

    profile_labels

    source
    fn profile_labels() -> Array[String]

    profile_result

    source
    fn profile_result(profile : RuleProfileConfig, analysis : Analysis) -> ProfileResult

    profile_result_markdown

    source
    fn profile_result_markdown(results : Array[ProfileResult]) -> String

    profile_result_table

    source
    fn profile_result_table(results : Array[ProfileResult]) -> String

    profile_results

    source
    fn profile_results(cantus : Array[Note], counter : Array[Note]) -> Array[ProfileResult]

    quality_gate_actions

    source
    fn quality_gate_actions(report : QualityGateReport) -> Array[String]

    quality_gate_markdown

    source
    fn quality_gate_markdown(report : QualityGateReport) -> String

    quality_gate_passed

    source
    fn quality_gate_passed(report : QualityGateReport) -> Bool

    quality_gate_report

    source
    fn quality_gate_report(validation : PairValidation, motion : VoiceLeadingSummary) -> QualityGateReport

    quality_gate_score

    source
    fn quality_gate_score(report : QualityGateReport) -> Int

    quantize_note

    source
    fn quantize_note(note : Note, grid : Int) -> Note

    quantize_sequence

    source
    fn quantize_sequence(notes : Array[Note], grid : Int) -> Array[Note]

    quantize_time

    source
    fn quantize_time(time : Int, grid : Int) -> Int

    ready_message

    source
    fn ready_message() -> String

    recommendation_count_for_rule

    source
    fn recommendation_count_for_rule(analysis : Analysis, rule : RuleKind) -> Int

    recommendation_for_finding

    source
    fn recommendation_for_finding(finding : Finding) -> Recommendation

    recommendation_markdown

    source
    fn recommendation_markdown(recommendation : Recommendation) -> String

    recommendation_section

    source
    fn recommendation_section(analysis : Analysis) -> ReportSection

    recommendations

    source
    fn recommendations(analysis : Analysis) -> Array[Recommendation]

    recommendations_markdown

    source
    fn recommendations_markdown(analysis : Analysis) -> String

    register_bands

    source
    fn register_bands(notes : Array[Note], width : Int) -> Array[RegisterBand]

    register_distance

    source
    fn register_distance(notes : Array[Note], target : Int) -> Int

    render_document

    source
    fn render_document(document : ReportDocument) -> String

    render_section

    source
    fn render_section(section : ReportSection) -> String

    repair_kind_name

    source
    fn repair_kind_name(kind : RepairKind) -> String

    repair_suggestion_all_in_range

    source
    fn repair_suggestion_all_in_range(suggestions : Array[RepairSuggestion], low : Int, high : Int) -> Bool

    repair_suggestion_average_score

    source
    fn repair_suggestion_average_score(suggestions : Array[RepairSuggestion]) -> Int

    repair_suggestion_count

    source
    fn repair_suggestion_count(suggestions : Array[RepairSuggestion]) -> Int

    repair_suggestion_for_index

    source
    fn repair_suggestion_for_index(suggestions : Array[RepairSuggestion], index : Int) -> Array[RepairSuggestion]

    repair_suggestion_kinds

    source
    fn repair_suggestion_kinds(suggestions : Array[RepairSuggestion]) -> Array[String]

    repair_suggestion_markdown

    source
    fn repair_suggestion_markdown(suggestions : Array[RepairSuggestion]) -> String

    repair_suggestion_summary

    source
    fn repair_suggestion_summary(suggestion : RepairSuggestion) -> String

    repair_suggestions

    source
    fn repair_suggestions(finding : Finding, notes : Array[Note], max_leap : Int, low : Int, high : Int) -> Array[RepairSuggestion]

    Produce bounded single-event edits that can be reviewed before applying them.

    repeated_run_lengths

    source
    fn repeated_run_lengths(notes : Array[Note]) -> Array[Int]

    replace_note

    source
    fn replace_note(notes : Array[Note], index : Int, replacement : Note) -> Array[Note]

    replace_pitch

    source
    fn replace_pitch(notes : Array[Note], index : Int, midi : Int) -> Array[Note]

    report_contains

    source
    fn report_contains(document : ReportDocument, id : String) -> Bool

    report_document

    source
    fn report_document(title : String, analysis : Analysis, meter : Meter, cantus : Array[Note], counter : Array[Note]) -> ReportDocument

    report_line_count

    source
    fn report_line_count(analysis : Analysis) -> Int

    report_quality_score

    source
    fn report_quality_score(document : ReportDocument, analysis : Analysis) -> Int

    report_section_count

    source
    fn report_section_count(document : ReportDocument) -> Int

    report_section_ids

    source
    fn report_section_ids(document : ReportDocument) -> Array[String]

    report_with_manifest

    source
    fn report_with_manifest(document : ReportDocument, profile : RuleProfileConfig, meter : Meter) -> ReportDocument

    report_word_count

    source
    fn report_word_count(document : ReportDocument) -> Int

    retrograde_sequence

    source
    fn retrograde_sequence(notes : Array[Note]) -> Array[Note]

    rhythm_density

    source
    fn rhythm_density(meter : Meter, notes : Array[Note]) -> Int

    rhythm_section

    source
    fn rhythm_section(meter : Meter, notes : Array[Note]) -> ReportSection

    role_for_segment

    source
    fn role_for_segment(index : Int, total : Int) -> PhraseRole

    rotate_sequence

    source
    fn rotate_sequence(notes : Array[Note], amount : Int) -> Array[Note]

    rows_from_notes

    source
    fn rows_from_notes(notes : Array[Note]) -> Array[NoteRow]

    rule_card

    source
    fn rule_card(rule : RuleKind, index : Int) -> RuleCard?

    rule_card_count

    source
    fn rule_card_count() -> Int

    rule_cards

    source
    fn rule_cards() -> Array[RuleCard]

    Each card documents one analyzer rule with an actionable domain-specific repair.

    rule_explanation

    source
    fn rule_explanation(rule : RuleKind) -> String

    rule_family

    source
    fn rule_family(rule : RuleKind) -> String

    rule_is_harmonic

    source
    fn rule_is_harmonic(rule : RuleKind) -> Bool

    rule_is_structural

    source
    fn rule_is_structural(rule : RuleKind) -> Bool

    rule_learning_level

    source
    fn rule_learning_level(rule : RuleKind) -> String

    rule_remedy

    source
    fn rule_remedy(rule : RuleKind) -> String

    rule_topic_name

    source
    fn rule_topic_name(topic : RuleTopic) -> String

    run_pipeline

    source
    fn run_pipeline(input : PipelineInput) -> PipelineOutput

    safe_transformations

    source
    fn safe_transformations() -> Array[Transformation]

    same_interval_profile

    source
    fn same_interval_profile(left : Array[Note], right : Array[Note]) -> Bool

    same_sequence

    source
    fn same_sequence(left : Array[Note], right : Array[Note]) -> Bool

    scale_time

    source
    fn scale_time(notes : Array[Note], factor : Int) -> Array[Note]

    score_for

    source
    fn score_for(analysis : Analysis, profile : RuleProfileConfig) -> Int

    scorecard_action

    source
    fn scorecard_action(scorecard : Scorecard) -> String

    scorecard_compare

    source
    fn scorecard_compare(left : Scorecard, right : Scorecard) -> Int

    scorecard_csv

    source
    fn scorecard_csv(scorecard : Scorecard) -> String

    scorecard_dimensions

    source
    fn scorecard_dimensions(scorecard : Scorecard) -> Array[Int]

    scorecard_grade

    source
    fn scorecard_grade(scorecard : Scorecard) -> String

    scorecard_markdown

    source
    fn scorecard_markdown(scorecard : Scorecard) -> String

    scorecard_passed

    source
    fn scorecard_passed(scorecard : Scorecard) -> Bool

    section_by_id

    source
    fn section_by_id(document : ReportDocument, id : String) -> ReportSection?

    sections_by_priority

    source
    fn sections_by_priority(document : ReportDocument, minimum : Int) -> Array[ReportSection]

    sections_for_analysis

    source
    fn sections_for_analysis(analysis : Analysis, meter : Meter, cantus : Array[Note], counter : Array[Note]) -> Array[ReportSection]

    segment_phrase

    source
    fn segment_phrase(notes : Array[Note], target : Int) -> Array[PhraseSegment]

    semitone_distance

    source
    fn semitone_distance(left : PitchClass, right : PitchClass) -> Int

    sequence_end

    source
    fn sequence_end(notes : Array[Note]) -> Int

    sequence_fingerprint

    source
    fn sequence_fingerprint(notes : Array[Note]) -> String

    sequence_markdown

    source
    fn sequence_markdown(report : SequenceReport) -> String

    sequence_report

    source
    fn sequence_report(notes : Array[Note]) -> SequenceReport

    severity_rank

    source
    fn severity_rank(severity : Severity) -> Int

    shift_onsets

    source
    fn shift_onsets(notes : Array[Note], delta : Int) -> Array[Note]

    snapshot

    source
    fn snapshot(label : String, validation : PairValidation) -> AnalysisSnapshot

    species_count

    source
    fn species_count() -> Int

    split_points

    source
    fn split_points(notes : Array[Note], target : Int) -> Array[Int]

    stable_event_indices

    source
    fn stable_event_indices(lower : Array[Note], upper : Array[Note]) -> Array[Int]

    stretch_sequence

    source
    fn stretch_sequence(notes : Array[Note], factor : Int) -> Array[Note]

    summarize

    source
    fn summarize(analysis : Analysis) -> AnalysisSummary

    summarize_rhythm

    source
    fn summarize_rhythm(meter : Meter, notes : Array[Note]) -> RhythmSummary

    summarize_voice_leading

    source
    fn summarize_voice_leading(lower : Array[Note], upper : Array[Note], constraint : MotionConstraint) -> VoiceLeadingSummary

    summary_csv

    source
    fn summary_csv(summary : AnalysisSummary) -> String

    summary_section

    source
    fn summary_section(analysis : Analysis) -> ReportSection

    supported_profile_count

    source
    fn supported_profile_count() -> Int

    supported_rule_count

    source
    fn supported_rule_count() -> Int

    supported_species

    source
    fn supported_species() -> Array[Species]

    syncopation_count

    source
    fn syncopation_count(meter : Meter, notes : Array[Note]) -> Int

    teaching_level_name

    source
    fn teaching_level_name(level : TeachingLevel) -> String

    tension_profile

    source
    fn tension_profile(lower : Array[Note], upper : Array[Note]) -> Array[Int]

    tied_count

    source
    fn tied_count(notes : Array[Note]) -> Int

    top_recommendations

    source
    fn top_recommendations(analysis : Analysis, limit : Int) -> Array[Recommendation]

    total_sounding_duration

    source
    fn total_sounding_duration(notes : Array[Note]) -> Int

    total_tension

    source
    fn total_tension(lower : Array[Note], upper : Array[Note]) -> Int

    transformation_catalog

    source
    fn transformation_catalog() -> Array[Transformation]

    transformation_count

    source
    fn transformation_count() -> Int

    transformation_description

    source
    fn transformation_description(value : Transformation) -> String

    transformation_examples

    source
    fn transformation_examples(notes : Array[Note]) -> Array[String]

    transformation_is_safe

    source
    fn transformation_is_safe(transformation : Transformation) -> Bool

    transformation_name

    source
    fn transformation_name(kind : TransformationKind) -> String

    transformation_round_trip

    source
    fn transformation_round_trip(notes : Array[Note], semitones : Int) -> Bool

    transpose

    source
    fn transpose(notes : Array[Note], semitones : Int) -> Array[Note]

    transpose_pitch_class

    source
    fn transpose_pitch_class(pitch : PitchClass, semitones : Int) -> PitchClass

    transpose_sequence

    source
    fn transpose_sequence(notes : Array[Note], semitones : Int) -> Array[Note]

    triage_actions

    source
    fn triage_actions(triage : AnalysisTriage) -> Array[String]

    triage_analysis

    source
    fn triage_analysis(analysis : Analysis) -> AnalysisTriage

    Convert raw findings into a stable repair queue for editors and teaching tools.

    triage_band

    source
    fn triage_band(analysis : Analysis) -> TriageBand

    triage_band_name

    source
    fn triage_band_name(band : TriageBand) -> String

    triage_compare

    source
    fn triage_compare(left : AnalysisTriage, right : AnalysisTriage) -> Int

    triage_csv

    source
    fn triage_csv(triage : AnalysisTriage) -> String

    triage_is_actionable

    source
    fn triage_is_actionable(triage : AnalysisTriage) -> Bool

    triage_item

    source
    fn triage_item(triage : AnalysisTriage, index : Int) -> TriageItem?

    triage_item_count

    source
    fn triage_item_count(triage : AnalysisTriage) -> Int

    triage_item_summary

    source
    fn triage_item_summary(item : TriageItem) -> String

    triage_markdown

    source
    fn triage_markdown(triage : AnalysisTriage) -> String

    triage_priority_for_rule

    source
    fn triage_priority_for_rule(triage : AnalysisTriage, rule : RuleKind) -> Int

    triage_rule_count

    source
    fn triage_rule_count(triage : AnalysisTriage, rule : RuleKind) -> Int

    triage_rule_order

    source
    fn triage_rule_order(triage : AnalysisTriage) -> Array[RuleKind]

    triage_summary

    source
    fn triage_summary(triage : AnalysisTriage) -> String

    trim_after

    source
    fn trim_after(notes : Array[Note], time : Int) -> Array[Note]

    trim_before

    source
    fn trim_before(notes : Array[Note], time : Int) -> Array[Note]

    turning_points

    source
    fn turning_points(notes : Array[Note]) -> Array[TurningPoint]

    unescape_field

    source
    fn unescape_field(value : String) -> String

    unstable_event_indices

    source
    fn unstable_event_indices(lower : Array[Note], upper : Array[Note]) -> Array[Int]

    valid_profiles

    source
    fn valid_profiles() -> Array[RuleProfileConfig]

    validate_pair

    source
    fn validate_pair(cantus : Array[Note], counter : Array[Note], profile : RuleProfileConfig) -> PairValidation

    vertical_event

    source
    fn vertical_event(lower : Note, upper : Note, index : Int) -> VerticalEvent

    vertical_events

    source
    fn vertical_events(lower : Array[Note], upper : Array[Note]) -> Array[VerticalEvent]

    voice_assessment_is_extreme

    source
    fn voice_assessment_is_extreme(assessment : VoiceAssessment) -> Bool

    voice_assessment_markdown

    source
    fn voice_assessment_markdown(assessment : VoiceAssessment) -> String

    voice_assessment_pitch_center

    source
    fn voice_assessment_pitch_center(assessment : VoiceAssessment) -> Int

    voice_assessment_repair_distance

    source
    fn voice_assessment_repair_distance(assessment : VoiceAssessment) -> Int

    voice_assessment_status

    source
    fn voice_assessment_status(assessment : VoiceAssessment) -> String

    voice_assessment_summary

    source
    fn voice_assessment_summary(assessment : VoiceAssessment) -> String

    voice_assessment_violation_rate

    source
    fn voice_assessment_violation_rate(assessment : VoiceAssessment) -> Int

    voice_crossing_at

    source
    fn voice_crossing_at(lower : Note, upper : Note) -> Bool

    voice_leading_quality

    source
    fn voice_leading_quality(lower : Array[Note], upper : Array[Note]) -> Int

    voice_order_is_stable

    source
    fn voice_order_is_stable(lower : Array[Note], upper : Array[Note]) -> Bool

    voice_range_name

    source
    fn voice_range_name(range : VoiceRange) -> String

    voice_role_name

    source
    fn voice_role_name(role : VoiceRole) -> String

    voices_fit

    source
    fn voices_fit(lower : Array[Note], upper : Array[Note], lower_range : VoiceRange, upper_range : VoiceRange) -> Bool

    weakest_dimension

    source
    fn weakest_dimension(scorecard : Scorecard) -> String

    weighted_pitch_center

    source
    fn weighted_pitch_center(notes : Array[Note]) -> Int

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io