🥮 mooncakes.io
    Sign in

    moonbit-genbank

    MoonBit GenBank/INSDC annotation parser with feature queries, CDS validation, JSON export, and CI

    Download zip
    Version
    0.2.3
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    25

    No dependencies

    #moonbit-genbank

    MoonBit GenBank/INSDC flat-file parser for small bioinformatics tools, teaching examples, and data-conversion pipelines.

    The library focuses on annotated sequence records rather than broad bioinformatics algorithms. It parses LOCUS metadata, FEATURES entries, ORIGIN sequence text, common feature locations, qualifiers, CDS translation checks, and compact JSON export.

    #Why this project

    MoonBit already has early bioinformatics ecosystem work, but GenBank flat-file annotation parsing is still a useful standalone building block. Keeping this package focused makes it suitable for:

    • validating small submitted sequence records
    • querying genes and CDS annotations in teaching examples
    • converting GenBank snippets to JSON for web or CLI tools
    • extending toward INSDC feature-table edge cases over time

    This repository is an original MoonBit project for the August 2026 MoonBit Hackathon. No source code is copied from existing GenBank parsers.

    #Features

    • LOCUS parsing: record name, length, molecule type, topology, division, date
    • FEATURES parsing: feature key, location expression, slash qualifiers
    • Location support: point/range, nested join(...) and order(...), nested complement(...), partial markers, between-base positions, one-of(...), and remote accessions
    • ORIGIN cleanup: sequence lines are normalized to uppercase bases
    • Queries: feature key filtering, qualifier lookup, span overlap checks
    • CDS validation: extracts feature sequence, handles complement strands, and compares computed translation with /translation
    • Sequence statistics: base counts and GC percentage for ORIGIN
    • Sequence analytics: FASTA parsing, windows, k-mers, motif search, IUPAC expansion, composition entropy, consensus, homopolymers, and identity
    • Translation toolkit: selectable standard/vertebrate-mitochondrial tables, codon usage, reading frames, and bounded ORF discovery
    • Workflow utilities: strict FASTA validation, IUPAC motif scanning on both strands, global sequence alignment, contig overlap assembly, and windowed quality profiles
    • Interoperability exports: feature tables, BED/GFF3 projections, FASTA conversion, codon reports, and batch translation audits
    • Coordinate analytics: interval union/intersection, coverage masks, and feature-key coverage reports
    • Location analysis: biological coordinate order, span/length/containment, fuzzy/remote flags, and deterministic annotation summaries
    • Record audit: sequence length, source feature, bounds, remote locations, between-base locations, and CDS translation findings
    • JSON export: compact stable representation for downstream tooling
    • Runnable demo CLI: summary output by default and JSON output with --json

    #Quick Start

    moon check --deny-warn
moon test --deny-warn
moon run cmd/main
moon run cmd/main -- --json

    #Library Example

    ///|
    test "parse a minimal record" {
      let text =
        #|LOCUS       DEMO0001        12 bp    DNA     linear   SYN 28-JUL-2026
        #|DEFINITION  Minimal MoonBit GenBank demo record.
        #|ACCESSION   DEMO0001
        #|FEATURES             Location/Qualifiers
        #|     source          1..12
        #|                     /organism="synthetic construct"
        #|     CDS             1..12
        #|                     /gene="demo"
        #|                     /translation="MAIV"
        #|ORIGIN
        #|        1 atggccattgta
        #|//
      let record = parse_record(text)
      inspect(record.accession, content="DEMO0001")
      inspect(record.features_by_key("CDS").length(), content="1")
      inspect(record.check_cds_translations()[0].ok, content="true")
    }

    #API Surface

    The main package exposes:

    • parse_record(text) -> Record raise GenBankError
    • parse_records(text) -> Array[Record] raise GenBankError
    • parse_locus(line) -> Locus raise GenBankError
    • parse_location(text) -> Location raise GenBankError
    • GenBankError::message
    • Record::features_by_key
    • Record::features_with_qualifier
    • Feature::qualifier
    • Feature::overlaps
    • Record::sequence_for
    • Record::check_cds_translations
    • Record::sequence_stats
    • Record::validate
    • Record::to_json_string
    • Record::to_genbank_string
    • record_to_bed and record_to_gff3
    • scan_iupac_both_strands
    • global_align
    • batch_quality
    • translation_audit
    • ValidationIssue::is_error
    • ValidationIssue::to_json_string
    • translate_dna
    • reverse_complement

    Generated public interfaces are committed in pkg.generated.mbti.

    #Scope

    Implemented:

    • single-record GenBank flat files
    • multi-record streams separated by //
    • common feature-table qualifiers
    • multi-line qualifier values
    • nested range, join, order, and complement locations
    • fuzzy, between-base, and remote location segments
    • standard genetic code translation
    • IUPAC ambiguity bases in ORIGIN and reverse-complement operations

    Remaining extension points:

    • richer feature-table normalization and structured metadata fields
    • remote sequence resolution and full fuzzy-location alternatives
    • streaming/file-reading CLI once the async filesystem API is stabilized for all supported MoonBit targets

    #Real benchmarks

    examples/u49845.gb and examples/af165912.gb are fixed NCBI GenBank snapshots covering partial locations, reverse-strand features, multiline qualifiers, and multiline join expressions. Their source URLs and checksums are documented in BENCHMARKS.md.

    The regression suite runs against the checked-in demo.gb, U49845, and AF165912 fixtures without network access.

    #Validation

    The CI workflow installs the latest MoonBit toolchain and runs on Linux, macOS, and Windows:

    • moon fmt followed by git diff --exit-code
    • moon info followed by git diff --exit-code
    • moon check --target all --deny-warn
    • moon test --target all --deny-warn

    Locally, this repository was checked with:

    moon check --deny-warn
moon test --deny-warn
moon info

    For native coverage, run:

    moon test --target native --deny-warn --enable-coverage
moon coverage report -f summary

    The current local Windows environment has no system C compiler, so native --target all execution is delegated to CI, where gcc is installed explicitly.

    #License

    Apache-2.0.

    GenBankError

    source
    pub(all) suberror GenBankError {
      MissingSection(String)
      InvalidLocus(String)
      InvalidLocation(String)
      InvalidNumber(String)
    } derive(Eq, 
    Debug    )

    GenBankError::message

    source
    fn GenBankError::message(self : GenBankError) -> String

    Human-readable parse error message for CLIs and logs.

    AlignmentSummary

    source
    pub struct AlignmentSummary {
      left_length : Int
      right_length : Int
      matches : Int
      mismatches : Int
      gaps : Int
      identity : Double
      edit_distance : Int
    } derive(Eq, 
    Debug    )

    AlignmentSummary::to_json_string

    source
    fn AlignmentSummary::to_json_string(self : AlignmentSummary) -> String

    AnnotationSummary

    source
    pub struct AnnotationSummary {
      feature_count : Int
      cds_count : Int
      gene_count : Int
      source_count : Int
      base_count : Int
      gc_percent : Double
      feature_keys : Array[String]
      qualifier_names : Array[String]
    } derive(Eq, 
    Debug    )

    A compact, deterministic annotation summary for dashboards and reports.

    AnnotationSummary::to_json_string

    source
    fn AnnotationSummary::to_json_string(self : AnnotationSummary) -> String

    AssemblyResult

    source
    pub struct AssemblyResult {
      sequence : String
      contig_count : Int
      merged_count : Int
      overlaps : Array[ContigOverlap]
      unresolved : Array[String]
    } derive(Eq, 
    Debug    )

    Result of a deterministic greedy contig merge.

    AssemblyResult::to_json_string

    source
    fn AssemblyResult::to_json_string(self : AssemblyResult) -> String

    Export assembly diagnostics as JSON for pipeline artifacts.

    BatchQualityReport

    source
    pub struct BatchQualityReport {
      record_count : Int
      valid_count : Int
      invalid_count : Int
      total_bases : Int
      mean_length : Double
      mean_gc : Double
      duplicate_accessions : Array[String]
      records_with_remote_locations : Int
      records_with_fuzzy_locations : Int
      records_with_translation_errors : Int
    } derive(Eq, 
    Debug    )

    Quality summary for a collection of parsed GenBank records.

    BatchQualityReport::to_json_string

    source
    fn BatchQualityReport::to_json_string(self : BatchQualityReport) -> String

    BatchQualityReport::to_text

    source
    fn BatchQualityReport::to_text(self : BatchQualityReport) -> String

    Return a stable report line useful for a CLI summary.

    BatchSummary

    source
    pub struct BatchSummary {
      record_count : Int
      total_bases : Int
      total_features : Int
      total_cds : Int
      total_genes : Int
      valid_records : Int
      invalid_records : Int
      accessions : Array[String]
    } derive(Eq, 
    Debug    )

    Summary statistics for a batch of GenBank records.

    BatchSummary::to_json_string

    source
    fn BatchSummary::to_json_string(self : BatchSummary) -> String

    BatchSummary::to_text

    source
    fn BatchSummary::to_text(self : BatchSummary) -> String

    CdsTranslationResult

    source
    pub struct CdsTranslationResult {
      feature_index : Int
      location : String
      nucleotide : String
      protein : String
      expected : String?
      matches_expected : Bool
      start_codon : String
      terminal_codon : String
      codon_count : Int
    } derive(Eq, 
    Debug    )

    Detailed CDS translation result with source coordinates.

    CdsTranslationResult::to_json_string

    source
    fn CdsTranslationResult::to_json_string(self : CdsTranslationResult) -> String

    CodingSequenceReport

    source
    pub struct CodingSequenceReport {
      nucleotide_length : Int
      complete_codons : Int
      trailing_bases : Int
      start_codons : Int
      stop_codons : Int
      ambiguous_codons : Int
      gc_first : Double
      gc_second : Double
      gc_third : Double
      usage : Array[CodonUsage]
    } derive(Eq, 
    Debug    )

    Aggregate coding-sequence statistics for reporting and QC.

    CodingSequenceReport::to_json_string

    source
    fn CodingSequenceReport::to_json_string(self : CodingSequenceReport) -> String

    CodingSequenceReport::to_tsv

    source
    fn CodingSequenceReport::to_tsv(self : CodingSequenceReport) -> String

    Emit a stable tabular codon report for downstream scripts.

    CodonTable

    source
    pub enum CodonTable {
      Standard
      VertebrateMitochondrial
    } derive(Eq, 
    Debug    )

    Genetic-code presets supported by the translation helpers.

    CodonUsage

    source
    pub struct CodonUsage {
      codon : String
      amino : String
      count : Int
    } derive(Eq, 
    Debug    )

    CodonUsage::to_json_string

    source
    fn CodonUsage::to_json_string(self : CodonUsage) -> String

    CompositionReport

    source
    pub struct CompositionReport {
      length : Int
      a : Int
      c : Int
      g : Int
      t : Int
      ambiguous : Int
      gc_percent : Double
      entropy : Double
    } derive(Eq, 
    Debug    )

    Composition and diversity statistics for a nucleotide sequence.

    CompositionReport::to_json_string

    source
    fn CompositionReport::to_json_string(self : CompositionReport) -> String

    ContigOverlap

    source
    pub struct ContigOverlap {
      left_index : Int
      right_index : Int
      overlap : Int
      merged_length : Int
    } derive(Eq, 
    Debug    )

    An overlap between the suffix of one contig and the prefix of another.

    CoordinateInterval

    source
    pub struct CoordinateInterval {
      start : Int
      end : Int
    } derive(Eq, 
    Debug    )

    A normalized half-open interval used by coordinate set operations.

    CoordinateInterval::to_json_string

    source
    fn CoordinateInterval::to_json_string(self : CoordinateInterval) -> String

    FastaIssue

    source
    pub struct FastaIssue {
      id : String
      code : String
      message : String
      position : Int
    } derive(Eq, 
    Debug    )

    A validation finding tied to a FASTA record identifier.

    FastaIssue::to_text

    source
    fn FastaIssue::to_text(self : FastaIssue) -> String

    FastaRecord

    source
    pub struct FastaRecord {
      id : String
      description : String
      sequence : String
    } derive(Eq, 
    Debug    )

    A FASTA sequence with its identifier and optional description.

    FastaRecord::to_fasta

    source
    fn FastaRecord::to_fasta(self : FastaRecord, line_width : Int) -> String

    FastaValidationReport

    source
    pub struct FastaValidationReport {
      record_count : Int
      total_bases : Int
      duplicate_ids : Array[String]
      issues : Array[FastaIssue]
      valid : Bool
    } derive(Eq, 
    Debug    )

    A strict batch validation result for FASTA input.

    FastaValidationReport::to_json_string

    source
    fn FastaValidationReport::to_json_string(self : FastaValidationReport) -> String

    Emit a compact validation report for logs and CI artifacts.

    Feature

    source
    pub struct Feature {
      key : String
      location : Location
      qualifiers : Array[Qualifier]
    } derive(Eq, 
    Debug    )

    A feature-table entry such as source, gene, or CDS.

    Feature::overlaps

    source
    fn Feature::overlaps(self : Feature, start : Int, end : Int) -> Bool

    True when any parsed range overlaps a 1-based inclusive query span.

    Feature::qualifier

    source
    fn Feature::qualifier(self : Feature, name : String) -> String?

    Look up the first qualifier value by name.

    Feature::to_genbank_head

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

    Feature::to_json_string

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

    FeatureExtraction

    source
    pub struct FeatureExtraction {
      index : Int
      key : String
      location : String
      sequence : String
      sequence_length : Int
      translation : String
    } derive(Eq, 
    Debug    )

    A compact result for a feature extraction workflow.

    FeatureExtraction::to_json_string

    source
    fn FeatureExtraction::to_json_string(self : FeatureExtraction) -> String

    Return an extraction as JSON without requiring a JSON dependency.

    FeatureIndex

    source
    pub struct FeatureIndex {
      record : Record
      entries : Array[FeatureIndexEntry]
    } derive(Eq, 
    Debug    )

    An immutable-style feature index built for repeated annotation queries.

    FeatureIndex::all

    source

    FeatureIndex::at

    source
    fn FeatureIndex::at(self : FeatureIndex, position : Int) -> Array[Feature]

    FeatureIndex::by_key

    source
    fn FeatureIndex::by_key(self : FeatureIndex, key : String) -> Array[Feature]

    FeatureIndex::by_keys

    source
    fn FeatureIndex::by_keys(self : FeatureIndex, keys : Array[String]) -> Array[Feature]

    FeatureIndex::by_qualifier

    source
    fn FeatureIndex::by_qualifier(self : FeatureIndex, name : String, value : String) -> Array[Feature]

    FeatureIndex::contained_in

    source
    fn FeatureIndex::contained_in(self : FeatureIndex, start : Int, end : Int) -> Array[Feature]

    FeatureIndex::count

    source
    fn FeatureIndex::count(self : FeatureIndex) -> Int

    FeatureIndex::keys

    source
    fn FeatureIndex::keys(self : FeatureIndex) -> Array[String]

    FeatureIndex::overlapping

    source
    fn FeatureIndex::overlapping(self : FeatureIndex, start : Int, end : Int) -> Array[Feature]

    FeatureIndex::positions

    source
    fn FeatureIndex::positions(self : FeatureIndex, key : String) -> Array[Int]

    FeatureIndex::qualifier_names

    source
    fn FeatureIndex::qualifier_names(self : FeatureIndex) -> Array[String]

    FeatureIndex::summary_json

    source
    fn FeatureIndex::summary_json(self : FeatureIndex) -> String

    FeatureIndex::with_qualifier

    source
    fn FeatureIndex::with_qualifier(self : FeatureIndex, name : String) -> Array[Feature]

    FeatureIndexEntry

    source
    type FeatureIndexEntry derive(Eq, 
    Debug    )

    FeatureKeySummary

    source
    pub struct FeatureKeySummary {
      key : String
      count : Int
      total_bases : Int
      remote_count : Int
      fuzzy_count : Int
      qualifier_count : Int
    } derive(Eq, 
    Debug    )

    A key-level annotation summary used by dashboards and batch reports.

    FeatureKeySummary::to_json_string

    source
    fn FeatureKeySummary::to_json_string(self : FeatureKeySummary) -> String

    FeatureProjection

    source
    pub struct FeatureProjection {
      accession : String
      key : String
      start : Int
      end : Int
      strand : String
      name : String
      attributes : String
    } derive(Eq, 
    Debug    )

    A feature projection in BED/GFF-compatible coordinate conventions.

    FeatureProjection::to_json_string

    source
    fn FeatureProjection::to_json_string(self : FeatureProjection) -> String

    Serialize a projection for APIs that do not need the full record model.

    FeatureTableRow

    source
    pub struct FeatureTableRow {
      index : Int
      key : String
      start : Int
      end : Int
      length : Int
      strand : String
      remote : Bool
      fuzzy : Bool
      qualifier_count : Int
      label : String
    } derive(Eq, 
    Debug    )

    A flat row suitable for TSV export, spreadsheets, and lightweight UIs.

    FeatureTableRow::to_json_string

    source
    fn FeatureTableRow::to_json_string(self : FeatureTableRow) -> String

    GlobalAlignment

    source
    pub struct GlobalAlignment {
      left : String
      right : String
      score : Int
      matches : Int
      mismatches : Int
      gaps : Int
      identity : Double
    } derive(Eq, 
    Debug    )

    A global alignment with an explicit traceback, not only a distance score.

    GlobalAlignment::to_json_string

    source
    fn GlobalAlignment::to_json_string(self : GlobalAlignment) -> String

    Export alignment metrics and strings for a JSON consumer.

    IntervalCoverage

    source
    pub struct IntervalCoverage {
      intervals : Array[CoordinateInterval]
      covered_bases : Int
      minimum : Int
      maximum : Int
      gaps : Int
    } derive(Eq, 
    Debug    )

    Summary of interval union/intersection calculations.

    IntervalCoverage::to_json_string

    source
    fn IntervalCoverage::to_json_string(self : IntervalCoverage) -> String

    KmerCount

    source
    pub struct KmerCount {
      kmer : String
      count : Int
    } derive(Eq, 
    Debug    )

    One k-mer and its number of occurrences.

    Location

    source
    pub struct Location {
      raw : String
      ranges : Array[Range]
      complement : Bool
      joined : Bool
      ordered : Bool
      segments : Array[LocationSegment]
    } derive(Eq, 
    Debug    )

    Location text is preserved exactly enough for round-trip inspection and exposes common numeric spans for simple queries.

    Location::to_json_string

    source
    fn Location::to_json_string(self : Location) -> String

    LocationSegment

    source
    pub struct LocationSegment {
      range : Range
      reverse : Bool
      remote : String?
    } derive(Eq, 
    Debug    )

    One ordered segment in a feature location expression.

    LocationSummary

    source
    pub struct LocationSummary {
      raw : String
      minimum : Int
      maximum : Int
      length : Int
      segment_count : Int
      reverse_segments : Int
      remote_segments : Int
      fuzzy : Bool
      between : Bool
    } derive(Eq, 
    Debug    )

    A biological span with optional remote accession metadata.

    LocationSummary::to_json_string

    source
    fn LocationSummary::to_json_string(self : LocationSummary) -> String

    Locus

    source
    pub struct Locus {
      name : String
      length : Int
      molecule_type : String
      topology : String
      division : String
      date : String
    } derive(Eq, 
    Debug    )

    Information extracted from the LOCUS line.

    Locus::to_genbank_line

    source
    fn Locus::to_genbank_line(self : Locus) -> String

    Locus::to_json_string

    source
    fn Locus::to_json_string(self : Locus) -> String

    MotifHit

    source
    pub struct MotifHit {
      motif : String
      start : Int
      end : Int
      strand : String
      matched : String
    } derive(Eq, 
    Debug    )

    An occurrence of an IUPAC motif in a nucleotide sequence.

    MotifHit::to_json_string

    source
    fn MotifHit::to_json_string(self : MotifHit) -> String

    MotifScanReport

    source
    pub struct MotifScanReport {
      motif : String
      sequence_length : Int
      forward_hits : Int
      reverse_hits : Int
      hits : Array[MotifHit]
    } derive(Eq, 
    Debug    )

    Summary of a forward and reverse-complement motif scan.

    MotifScanReport::to_json_string

    source
    fn MotifScanReport::to_json_string(self : MotifScanReport) -> String

    OpenReadingFrame

    source
    pub struct OpenReadingFrame {
      start : Int
      end : Int
      frame : Int
      protein : String
      nucleotide_length : Int
    } derive(Eq, 
    Debug    )

    OpenReadingFrame::to_json_string

    source
    fn OpenReadingFrame::to_json_string(self : OpenReadingFrame) -> String

    Qualifier

    source
    pub struct Qualifier {
      name : String
      value : String?
    } derive(Eq, 
    Debug    )

    A slash-prefixed feature qualifier such as /gene="lacZ".

    Qualifier::to_genbank_lines

    source
    fn Qualifier::to_genbank_lines(self : Qualifier, line_width? : Int) -> Array[String]

    QualifierMatch

    source
    pub struct QualifierMatch {
      feature_key : String
      qualifier_name : String
      value : String
      feature_start : Int
      feature_end : Int
    } derive(Eq, 
    Debug    )

    A normalized qualifier lookup result.

    QualifierMatch::to_json_string

    source
    fn QualifierMatch::to_json_string(self : QualifierMatch) -> String

    Range

    source
    pub struct Range {
      start : Int
      end : Int
      partial_start : Bool
      partial_end : Bool
      between : Bool
    } derive(Eq, 
    Debug    )

    A 1-based inclusive interval from a GenBank feature location.

    Record

    source
    pub struct Record {
      accession : String
      version : String
      locus : Locus
      definition : String
      keywords : String
      source : String
      features : Array[Feature]
      origin : String
    } derive(Eq, 
    Debug    )

    Parsed representation of a GenBank or INSDC flat-file record.

    Record::check_cds_translations

    source
    fn Record::check_cds_translations(self : Record) -> Array[TranslationCheck]

    Validate every CDS feature that provides a /translation qualifier.

    Record::features_by_key

    source
    fn Record::features_by_key(self : Record, key : String) -> Array[Feature]

    Find all features with a matching key.

    Record::features_with_qualifier

    source
    fn Record::features_with_qualifier(self : Record, name : String) -> Array[Feature]

    Return all features that carry a named qualifier.

    Record::sequence_for

    source
    fn Record::sequence_for(self : Record, feature : Feature) -> String

    Extract and orient feature sequence from the parsed ORIGIN.

    Record::sequence_stats

    source
    fn Record::sequence_stats(self : Record) -> SequenceStats

    Count normalized bases in the ORIGIN sequence.

    Record::to_genbank_string

    source
    fn Record::to_genbank_string(self : Record, line_width? : Int) -> String

    Render a record as a canonical GenBank flat-file document.

    Record::to_json_string

    source
    fn Record::to_json_string(self : Record) -> String

    Export a parsed record as compact JSON.

    Record::validate

    source
    fn Record::validate(self : Record) -> Array[ValidationIssue]

    Audit structural invariants that can be checked without network access.

    RecordCollection

    source
    pub struct RecordCollection {
      records : Array[Record]
      source_name : String
    } derive(Eq, 
    Debug    )

    A reusable collection wrapper for multi-record workflows.

    RecordCollection::accessions

    source
    fn RecordCollection::accessions(self : RecordCollection) -> Array[String]

    RecordCollection::all_feature_keys

    source
    fn RecordCollection::all_feature_keys(self : RecordCollection) -> Array[String]

    RecordCollection::at

    source
    fn RecordCollection::at(self : RecordCollection, index : Int) -> Record?

    RecordCollection::between_locations

    source
    fn RecordCollection::between_locations(self : RecordCollection) -> Int

    RecordCollection::count

    source
    fn RecordCollection::count(self : RecordCollection) -> Int

    RecordCollection::definitions

    source
    fn RecordCollection::definitions(self : RecordCollection) -> Array[String]

    RecordCollection::feature_density

    source
    fn RecordCollection::feature_density(self : RecordCollection) -> Double

    RecordCollection::filter_accession

    source
    fn RecordCollection::filter_accession(self : RecordCollection, prefix : String) -> RecordCollection

    RecordCollection::filter_definition

    source
    fn RecordCollection::filter_definition(self : RecordCollection, text : String) -> RecordCollection

    RecordCollection::filter_valid

    source

    RecordCollection::fuzzy_locations

    source
    fn RecordCollection::fuzzy_locations(self : RecordCollection) -> Int

    RecordCollection::gc

    source
    fn RecordCollection::gc(self : RecordCollection) -> Double

    RecordCollection::invalid_count

    source
    fn RecordCollection::invalid_count(self : RecordCollection) -> Int

    RecordCollection::map_normalized

    source
    fn RecordCollection::map_normalized(self : RecordCollection) -> RecordCollection

    RecordCollection::records

    source

    RecordCollection::records_with_feature

    source
    fn RecordCollection::records_with_feature(self : RecordCollection, key : String) -> RecordCollection

    RecordCollection::remote_locations

    source
    fn RecordCollection::remote_locations(self : RecordCollection) -> Int

    RecordCollection::reports

    source
    fn RecordCollection::reports(self : RecordCollection) -> Array[String]

    RecordCollection::sequence_signatures

    source
    fn RecordCollection::sequence_signatures(self : RecordCollection) -> Array[String]

    RecordCollection::source_name

    source
    fn RecordCollection::source_name(self : RecordCollection) -> String

    RecordCollection::summary

    source

    RecordCollection::to_fasta_string

    source
    fn RecordCollection::to_fasta_string(self : RecordCollection) -> String

    RecordCollection::to_genbank_string

    source
    fn RecordCollection::to_genbank_string(self : RecordCollection) -> String

    RecordCollection::total_bases

    source
    fn RecordCollection::total_bases(self : RecordCollection) -> Int

    RecordCollection::total_cds

    source
    fn RecordCollection::total_cds(self : RecordCollection) -> Int

    RecordCollection::total_features

    source
    fn RecordCollection::total_features(self : RecordCollection) -> Int

    RecordCollection::total_genes

    source
    fn RecordCollection::total_genes(self : RecordCollection) -> Int

    RecordCollection::valid_count

    source
    fn RecordCollection::valid_count(self : RecordCollection) -> Int

    RecordCollection::validation_reports

    source
    fn RecordCollection::validation_reports(self : RecordCollection) -> Array[ValidationReport]

    RecordDiff

    source
    pub struct RecordDiff {
      accession_changed : Bool
      definition_changed : Bool
      sequence_changed : Bool
      length_delta : Int
      feature_count_left : Int
      feature_count_right : Int
      added_features : Int
      removed_features : Int
      changed_features : Int
      qualifier_changes : Int
      identical : Bool
    } derive(Eq, 
    Debug    )

    A deterministic comparison between two parsed records.

    RecordDiff::to_json_string

    source
    fn RecordDiff::to_json_string(self : RecordDiff) -> String

    RecordDiff::to_text

    source
    fn RecordDiff::to_text(self : RecordDiff) -> String

    Produce an actionable human-readable comparison.

    RecordMetrics

    source
    pub struct RecordMetrics {
      accession : String
      length : Int
      gc_percent : Double
      entropy : Double
      feature_count : Int
      feature_coverage : Int
      feature_coverage_percent : Double
      cds_count : Int
      gene_count : Int
      translation_count : Int
      remote_locations : Int
      fuzzy_locations : Int
      between_locations : Int
      validation_errors : Int
      validation_warnings : Int
    } derive(Eq, 
    Debug    )

    A compact metrics snapshot used by CLI and batch reporting.

    RecordMetrics::to_json_string

    source
    fn RecordMetrics::to_json_string(self : RecordMetrics) -> String

    RecordMetrics::to_text

    source
    fn RecordMetrics::to_text(self : RecordMetrics) -> String

    SequenceAnalysis

    source
    pub struct SequenceAnalysis {
      sequence : String
      length : Int
      windows : Array[SequenceWindow]
      composition : CompositionReport
      gc_skew : Int
      longest_run : Int
      motifs : Array[String]
    } derive(Eq, 
    Debug    )

    A complete sequence analysis result suitable for a report or dashboard.

    SequenceAnalysis::to_json_string

    source
    fn SequenceAnalysis::to_json_string(self : SequenceAnalysis) -> String

    SequenceInterval

    source
    pub struct SequenceInterval {
      start : Int
      end : Int
      sequence : String
    } derive(Eq, 
    Debug    )

    A normalized interval used by trimming and masking workflows.

    SequenceProfile

    source
    pub struct SequenceProfile {
      start : Int
      end : Int
      length : Int
      gc_percent : Double
      ambiguous : Int
      entropy : Double
      motif_hits : Int
    } derive(Eq, 
    Debug    )

    Composition metrics for one coordinate window.

    SequenceProfile::to_json_string

    source
    fn SequenceProfile::to_json_string(self : SequenceProfile) -> String

    SequenceQualityReport

    source
    pub struct SequenceQualityReport {
      sequence_length : Int
      canonical_bases : Int
      ambiguous_bases : Int
      invalid_bases : Int
      gc_percent : Double
      longest_run : Int
      run_count : Int
      has_internal_gap : Bool
      valid : Bool
    } derive(Eq, 
    Debug    )

    Quality and composition findings for a sequence supplied by a caller.

    SequenceQualityReport::to_json_string

    source
    fn SequenceQualityReport::to_json_string(self : SequenceQualityReport) -> String

    Render a compact machine-readable quality report.

    SequenceRun

    source
    pub struct SequenceRun {
      base : Char
      start : Int
      end : Int
      length : Int
    } derive(Eq, 
    Debug    )

    SequenceRun::to_text

    source
    fn SequenceRun::to_text(self : SequenceRun) -> String

    SequenceStats

    source
    pub struct SequenceStats {
      length : Int
      a : Int
      c : Int
      g : Int
      t : Int
      n : Int
      gc_percent : Double
    } derive(Eq, 
    Debug    )

    SequenceStats::to_json_string

    source
    fn SequenceStats::to_json_string(self : SequenceStats) -> String

    SequenceWindow

    source
    pub struct SequenceWindow {
      start : Int
      end : Int
      sequence : String
      gc_percent : Double
    } derive(Eq, 
    Debug    )

    A sequence window and coordinates in the original sequence.

    TranslationAuditSummary

    source
    pub struct TranslationAuditSummary {
      accession : String
      cds_count : Int
      checked_count : Int
      passed_count : Int
      failed_count : Int
      missing_translation_count : Int
      total_nucleotide_bases : Int
    } derive(Eq, 
    Debug    )

    Aggregate result for CDS translation validation in a single record.

    TranslationAuditSummary::to_json_string

    source
    fn TranslationAuditSummary::to_json_string(self : TranslationAuditSummary) -> String

    TranslationAuditSummary::to_tsv

    source

    Render one row per CDS for human review and spreadsheet import.

    TranslationCheck

    source
    pub struct TranslationCheck {
      feature_index : Int
      location : String
      expected : String
      actual : String
      ok : Bool
    } derive(Eq, 
    Debug    )

    CDS validation status for /translation qualifiers.

    TranslationReport

    source
    pub struct TranslationReport {
      protein : String
      codons : Int
      stops : Int
      ambiguous : Int
      trailing_bases : Int
    } derive(Eq, 
    Debug    )

    Translation details useful for validation reports.

    TranslationReport::to_json_string

    source
    fn TranslationReport::to_json_string(self : TranslationReport) -> String

    ValidationIssue

    source
    pub struct ValidationIssue {
      code : String
      message : String
      severity : ValidationSeverity
    } derive(Eq, 
    Debug    )

    A deterministic audit finding for a parsed record.

    ValidationIssue::is_error

    source
    fn ValidationIssue::is_error(self : ValidationIssue) -> Bool

    True when an audit finding is an error rather than an advisory warning.

    ValidationIssue::to_json_string

    source
    fn ValidationIssue::to_json_string(self : ValidationIssue) -> String

    Render an audit finding for CLI and JSON consumers.

    ValidationReport

    source
    pub struct ValidationReport {
      ok : Bool
      error_count : Int
      warning_count : Int
      issues : Array[ValidationIssue]
      accession : String
      sequence_length : Int
      feature_count : Int
    } derive(Eq, 
    Debug    )

    A validation result grouped for human and machine consumers.

    ValidationReport::to_json_string

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

    ValidationReport::to_text

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

    ValidationSeverity

    source
    pub enum ValidationSeverity {
      Error
      Warning
    } derive(Eq, 
    Debug    )

    Severity of a structural record audit finding.

    align_sequences

    source
    fn align_sequences(left : String, right : String) -> GlobalAlignment

    Use conventional scoring for quick pairwise comparisons.

    aligned_iupac_consensus

    source
    fn aligned_iupac_consensus(sequences : Array[String]) -> String

    Derive a position-wise IUPAC consensus from aligned sequences.

    alignment_display

    source
    fn alignment_display(alignment : GlobalAlignment) -> String

    Convert an alignment to a three-line display with a match marker row.

    alignment_operations

    source
    fn alignment_operations(alignment : GlobalAlignment) -> String

    Return a CIGAR-like operation string (M, X, and -).

    ambiguous_base_positions

    source
    fn ambiguous_base_positions(sequence : String) -> Array[Int]

    Return one-based positions of IUPAC ambiguity symbols.

    ambiguous_codon_count

    source
    fn ambiguous_codon_count(sequence : String, table : CodonTable) -> Int

    analyze_sequence

    source
    fn analyze_sequence(sequence : String, window_size : Int, step : Int) -> SequenceAnalysis

    annotation_summary

    source
    fn annotation_summary(record : Record) -> AnnotationSummary

    assembly_contig_lengths

    source
    fn assembly_contig_lengths(result : AssemblyResult) -> Array[Int]

    Return a stable length vector for assembled contigs.

    assembly_to_fasta

    source
    fn assembly_to_fasta(result : AssemblyResult, id : String) -> String

    Format an assembly as a FASTA record for downstream tools.

    base_frequencies

    source
    fn base_frequencies(sequence : String) -> Array[(Char, Int)]

    base_profile

    source
    fn base_profile(sequence : String, base : Char, window_size : Int) -> Array[Int]

    batch_checked_translation_count

    source
    fn batch_checked_translation_count(records : Array[Record]) -> Int

    Count all CDS features with a supplied translation in a batch.

    batch_coding_bases

    source
    fn batch_coding_bases(records : Array[Record]) -> Int

    Return the total amount of nucleotide material represented by CDS checks.

    batch_failed_translation_count

    source
    fn batch_failed_translation_count(records : Array[Record]) -> Int

    Count all failed CDS translation checks in a batch.

    batch_metric_invalid

    source
    fn batch_metric_invalid(records : Array[Record]) -> Int

    batch_metric_max_length

    source
    fn batch_metric_max_length(records : Array[Record]) -> Int

    batch_metric_mean_gc

    source
    fn batch_metric_mean_gc(records : Array[Record]) -> Double

    batch_metric_mean_length

    source
    fn batch_metric_mean_length(records : Array[Record]) -> Double

    batch_metric_min_length

    source
    fn batch_metric_min_length(records : Array[Record]) -> Int

    batch_metric_report

    source
    fn batch_metric_report(records : Array[Record]) -> String

    batch_metric_total_cds

    source
    fn batch_metric_total_cds(records : Array[Record]) -> Int

    batch_metric_total_features

    source
    fn batch_metric_total_features(records : Array[Record]) -> Int

    batch_metric_total_genes

    source
    fn batch_metric_total_genes(records : Array[Record]) -> Int

    batch_metric_valid

    source
    fn batch_metric_valid(records : Array[Record]) -> Int

    batch_metrics

    source
    fn batch_metrics(records : Array[Record]) -> Array[RecordMetrics]

    batch_metrics_json

    source
    fn batch_metrics_json(records : Array[Record]) -> String

    batch_quality

    source
    fn batch_quality(records : Array[Record]) -> BatchQualityReport

    Build a batch report without mutating or reparsing records.

    batch_quality_from_text

    source
    fn batch_quality_from_text(text : String) -> BatchQualityReport raise GenBankError

    Parse and assess a multi-record stream in one operation.

    batch_translation_audits

    source
    fn batch_translation_audits(records : Array[Record]) -> Array[TranslationAuditSummary]

    Summarize translation checks across a multi-record batch.

    batch_translation_status

    source
    fn batch_translation_status(records : Array[Record]) -> String

    Return a compact batch status string for monitoring jobs.

    best_alignments

    source
    fn best_alignments(query : String, candidates : Array[String]) -> Array[GlobalAlignment]

    Compare a sequence against many candidates and retain their best scores.

    best_contig_overlap

    source
    fn best_contig_overlap(contigs : Array[String], minimum : Int) -> ContigOverlap?

    Compare every ordered contig pair and choose the strongest available join.

    build_feature_index

    source
    fn build_feature_index(record : Record) -> FeatureIndex

    build_validation_report

    source
    fn build_validation_report(record : Record) -> ValidationReport

    cds_complete

    source
    fn cds_complete(record : Record, feature : Feature) -> Bool

    cds_frame_length

    source
    fn cds_frame_length(record : Record, feature : Feature) -> Int

    cds_in_frame

    source
    fn cds_in_frame(record : Record, feature : Feature) -> Bool

    cds_nucleotide_lengths

    source
    fn cds_nucleotide_lengths(record : Record) -> Array[Int]

    cds_partial

    source
    fn cds_partial(record : Record, feature : Feature) -> Bool

    cds_protein_lengths

    source
    fn cds_protein_lengths(record : Record) -> Array[Int]

    cds_start_codons

    source
    fn cds_start_codons(record : Record) -> Array[String]

    cds_terminal_codons

    source
    fn cds_terminal_codons(record : Record) -> Array[String]

    cds_translation_error_count

    source
    fn cds_translation_error_count(record : Record) -> Int

    cds_translation_json

    source
    fn cds_translation_json(record : Record) -> String

    cds_translation_matches

    source
    fn cds_translation_matches(record : Record) -> Array[CdsTranslationResult]

    cds_translation_mismatches

    source
    fn cds_translation_mismatches(record : Record) -> Array[CdsTranslationResult]

    cds_translation_ok

    source
    fn cds_translation_ok(record : Record) -> Bool

    cds_translation_results

    source
    fn cds_translation_results(record : Record) -> Array[CdsTranslationResult]

    cds_translation_summary

    source
    fn cds_translation_summary(record : Record) -> String

    cds_with_start_codon

    source
    fn cds_with_start_codon(record : Record, codon : String) -> Array[Feature]

    cds_with_stop_codon

    source
    fn cds_with_stop_codon(record : Record, codon : String) -> Array[Feature]

    change_points

    source
    fn change_points(sequence : String) -> Array[Int]

    Return all positions where a sequence changes base.

    clean_records

    source
    fn clean_records(records : Array[Record]) -> Array[Record]

    Return records that pass structural validation and CDS translation checks.

    coding_sequence_report

    source
    fn coding_sequence_report(sequence : String, table : CodonTable) -> CodingSequenceReport

    Calculate codon-position GC and translation diagnostics.

    codon_amino

    source
    fn codon_amino(table : CodonTable, codon : String) -> String

    codon_frequency_by_amino

    source
    fn codon_frequency_by_amino(sequence : String, table : CodonTable) -> Array[(String, Int)]

    codon_usage

    source
    fn codon_usage(sequence : String, table : CodonTable) -> Array[CodonUsage]

    Count complete codons in first-seen order.

    codon_usage_frequencies

    source
    fn codon_usage_frequencies(sequence : String, table : CodonTable) -> Array[(String, Double)]

    Calculate the proportion of each codon among complete codons.

    codon_usage_ranked

    source
    fn codon_usage_ranked(sequence : String, table : CodonTable) -> Array[CodonUsage]

    Return codons sorted by descending usage, preserving first-seen ties.

    codon_usage_total

    source
    fn codon_usage_total(items : Array[CodonUsage]) -> Int

    collection_fasta

    source
    fn collection_fasta(text : String) -> String raise GenBankError

    collection_from_records

    source
    fn collection_from_records(records : Array[Record], source_name? : String) -> RecordCollection

    collection_json

    source
    fn collection_json(text : String) -> String raise GenBankError

    common_dna_motifs

    source
    fn common_dna_motifs(sequence : String) -> Array[String]

    compare_records

    source
    fn compare_records(left : Record, right : Record) -> RecordDiff

    Compare records using normalized sequence and feature signatures.

    composition_report

    source
    fn composition_report(sequence : String) -> CompositionReport

    Compute composition and Shannon entropy using canonical base frequencies.

    consensus_sequence

    source
    fn consensus_sequence(sequences : Array[String]) -> String

    Build a majority consensus; ties and absent positions become N.

    coordinate_coverage

    source
    fn coordinate_coverage(intervals : Array[CoordinateInterval]) -> Int

    Calculate the number of bases covered by a coordinate set.

    coordinate_mask

    source
    fn coordinate_mask(intervals : Array[CoordinateInterval], sequence_length : Int) -> Array[Bool]

    Return a boolean mask indexed by one-based sequence coordinates.

    count_base

    source
    fn count_base(sequence : String, base : Char) -> Int

    count_not_in

    source
    fn count_not_in(left : Array[String], right : Array[String]) -> Int

    Count signatures that occur in the left array but not the right array.

    distinct_codon_count

    source
    fn distinct_codon_count(sequence : String, table : CodonTable) -> Int

    Calculate the effective number of distinct codons in a sequence.

    dna_sequence

    source
    fn dna_sequence(sequence : String) -> String

    extract_cds

    source
    fn extract_cds(record : Record) -> Array[FeatureExtraction]

    Extract all CDS sequences and orient joined/complement locations correctly.

    extract_features

    source
    fn extract_features(record : Record, key : String) -> Array[FeatureExtraction]

    Extract feature sequences while retaining enough context for audit logs.

    failed_translation_checks_tsv

    source
    fn failed_translation_checks_tsv(record : Record) -> String

    Render only failed translation checks, making review output concise.

    fasta_length_histogram

    source
    fn fasta_length_histogram(records : Array[FastaRecord], bin_width : Int) -> Array[(Int, Int)]

    Compute a length histogram using inclusive bins.

    feature_at_coordinate

    source
    fn feature_at_coordinate(record : Record, coordinate : Int) -> Array[FeatureTableRow]

    Locate the first feature covering a one-based sequence coordinate.

    feature_coverage

    source
    fn feature_coverage(record : Record) -> Int

    feature_coverage_percent

    source
    fn feature_coverage_percent(record : Record) -> Double

    feature_density

    source
    fn feature_density(record : Record) -> Double

    feature_end

    source
    fn feature_end(feature : Feature) -> Int

    feature_extractions_json

    source
    fn feature_extractions_json(record : Record, key : String) -> String

    Export extracted features as a line-oriented JSON document.

    feature_gene_name

    source
    fn feature_gene_name(feature : Feature) -> String?

    feature_has_fuzzy_location

    source
    fn feature_has_fuzzy_location(feature : Feature) -> Bool

    feature_has_remote_location

    source
    fn feature_has_remote_location(feature : Feature) -> Bool

    feature_has_translation

    source
    fn feature_has_translation(feature : Feature) -> Bool

    feature_is_cds

    source
    fn feature_is_cds(feature : Feature) -> Bool

    feature_is_empty

    source
    fn feature_is_empty(feature : Feature) -> Bool

    feature_is_gene

    source
    fn feature_is_gene(feature : Feature) -> Bool

    feature_is_source

    source
    fn feature_is_source(feature : Feature) -> Bool

    feature_key_counts

    source
    fn feature_key_counts(record : Record) -> Array[(String, Int)]

    feature_key_coverage

    source
    fn feature_key_coverage(record : Record, key : String) -> Double

    Return the percentage of a record covered by features of one key.

    feature_key_summary

    source
    fn feature_key_summary(record : Record) -> Array[FeatureKeySummary]

    Summarize all features by key in first-seen order.

    feature_key_summary_tsv

    source
    fn feature_key_summary_tsv(record : Record) -> String

    Export key summaries as stable TSV for command-line data processing.

    feature_length

    source
    fn feature_length(feature : Feature) -> Int

    feature_note_values

    source
    fn feature_note_values(feature : Feature) -> Array[String]

    feature_overlaps_any

    source
    fn feature_overlaps_any(features : Array[Feature], start : Int, end : Int) -> Array[Feature]

    feature_product_name

    source
    fn feature_product_name(feature : Feature) -> String?

    feature_qualifier_count

    source
    fn feature_qualifier_count(feature : Feature) -> Int

    feature_qualifier_counts

    source
    fn feature_qualifier_counts(record : Record) -> Array[(String, Int)]

    feature_qualifier_names

    source
    fn feature_qualifier_names(feature : Feature) -> Array[String]

    feature_qualifier_values

    source
    fn feature_qualifier_values(features : Array[Feature], qualifier_name : String) -> Array[String]

    fn feature_search(record : Record, text : String) -> Array[Feature]

    feature_sequence_lengths

    source
    fn feature_sequence_lengths(record : Record) -> Array[(String, Int)]

    Return all features with their local sequence length, preserving order.

    feature_signatures

    source
    fn feature_signatures(record : Record) -> Array[String]

    Build a signature that includes key, location, and all qualifier values.

    feature_span

    source
    fn feature_span(feature : Feature) -> Int

    feature_start

    source
    fn feature_start(feature : Feature) -> Int

    feature_summary_text

    source
    fn feature_summary_text(feature : Feature) -> String

    feature_table

    source
    fn feature_table(record : Record) -> Array[FeatureTableRow]

    Build rows in source order; source order is preserved for reproducible CSV.

    feature_table_by_key

    source
    fn feature_table_by_key(record : Record, key : String) -> Array[FeatureTableRow]

    Select rows by key without rebuilding the complete feature index.

    feature_table_row

    source
    fn feature_table_row(index : Int, feature : Feature) -> FeatureTableRow

    Convert a parsed feature to a stable tabular record.

    feature_table_tsv

    source
    fn feature_table_tsv(record : Record) -> String

    Export feature rows as RFC-style tab-separated text with a header.

    features_in_length_range

    source
    fn features_in_length_range(record : Record, minimum : Int, maximum : Int) -> Array[FeatureTableRow]

    Return feature rows with a location length in the inclusive range.

    features_with_location_property

    source
    fn features_with_location_property(features : Array[Feature], include_remote : Bool, include_fuzzy : Bool) -> Array[Feature]

    features_with_qualifier_text

    source
    fn features_with_qualifier_text(record : Record, name : String, needle : String) -> Array[Feature]

    Find features whose qualifier contains a case-insensitive search term.

    features_with_strand

    source
    fn features_with_strand(features : Array[Feature], reverse : Bool) -> Array[Feature]

    find_motif_positions

    source
    fn find_motif_positions(sequence : String, motif : String) -> Array[Int]

    Find every overlapping occurrence of a motif, using zero-based positions.

    find_orfs

    source
    fn find_orfs(sequence : String, minimum_codons : Int, maximum_bases : Int, table : CodonTable) -> Array[OpenReadingFrame]

    Find start-to-stop ORFs in all three forward reading frames.

    find_qualifier_matches

    source
    fn find_qualifier_matches(record : Record, name : String) -> Array[QualifierMatch]

    find_qualifier_value_matches

    source
    fn find_qualifier_value_matches(record : Record, name : String, value : String) -> Array[QualifierMatch]

    first_feature_by_key

    source
    fn first_feature_by_key(record : Record, key : String) -> Feature?

    format_fasta_records

    source
    fn format_fasta_records(records : Array[FastaRecord], line_width : Int) -> String

    Render a FASTA batch with explicit wrapping and normalized bases.

    gap_count

    source
    fn gap_count(sequence : String) -> Int

    gc_profile

    source
    fn gc_profile(sequence : String, window_size : Int) -> Array[Double]

    gc_skew_profile

    source
    fn gc_skew_profile(sequence : String, window_size : Int) -> Array[Int]

    gc_skew_windows

    source
    fn gc_skew_windows(sequence : String, window_size : Int, step : Int) -> Array[(Int, Int, Double)]

    Produce non-overlapping windows containing GC skew (G-C)/(G+C).

    genbank_round_trip

    source
    fn genbank_round_trip(text : String) -> String raise GenBankError

    gene_summary_json

    source
    fn gene_summary_json(record : Record) -> String

    global_align

    source
    fn global_align(left : String, right : String, match_score : Int, mismatch_score : Int, gap_score : Int) -> GlobalAlignment

    Align two sequences with a deterministic Needleman-Wunsch implementation.

    greedy_assemble

    source
    fn greedy_assemble(contigs : Array[String], minimum_overlap : Int) -> AssemblyResult

    Greedily merge the strongest suffix/prefix join until no join remains.

    hamming_distance

    source
    fn hamming_distance(left : String, right : String) -> Int

    Hamming distance, or -1 when strings have different lengths.

    has_motif

    source
    fn has_motif(sequence : String, motif : String) -> Bool

    highest_gc_profile

    source
    fn highest_gc_profile(profiles : Array[SequenceProfile]) -> SequenceProfile?

    Return the window with the highest GC percentage, if one exists.

    homopolymer_runs

    source
    fn homopolymer_runs(sequence : String, minimum_length : Int) -> Array[SequenceRun]

    Find every homopolymer run of at least minimum_length.

    intersect_coordinate_intervals

    source
    fn intersect_coordinate_intervals(left : Array[CoordinateInterval], right : Array[CoordinateInterval]) -> Array[CoordinateInterval]

    Calculate the intersection of two coordinate sets.

    interval_contains

    source
    fn interval_contains(outer : CoordinateInterval, inner : CoordinateInterval) -> Bool

    Determine whether an interval is wholly contained in another interval.

    interval_coverage

    source
    fn interval_coverage(intervals : Array[CoordinateInterval]) -> IntervalCoverage

    Build a coverage report including unannotated gaps in the enclosing span.

    intervals_to_text

    source
    fn intervals_to_text(intervals : Array[CoordinateInterval]) -> String

    Render interval sets as start..end values for logs and reports.

    invalid_base_positions

    source
    fn invalid_base_positions(sequence : String) -> Array[Int]

    Return positions of symbols that are not valid IUPAC nucleotides.

    is_iupac_base

    source
    fn is_iupac_base(ch : Char) -> Bool

    Whether a character is one of the 15 standard IUPAC nucleotide symbols.

    is_palindromic_motif

    source
    fn is_palindromic_motif(motif : String) -> Bool

    is_valid_dna

    source
    fn is_valid_dna(sequence : String) -> Bool

    iupac_consensus

    source
    fn iupac_consensus(observed : Array[Char]) -> Char

    Build a consensus IUPAC symbol for a set of observed canonical bases.

    iupac_expansion

    source
    fn iupac_expansion(ch : Char) -> Array[Char]

    Expand an IUPAC code to sorted canonical bases.

    iupac_motif_count

    source
    fn iupac_motif_count(sequence : String, motif : String) -> Int

    Count overlapping IUPAC motif occurrences.

    iupac_motif_matches_at

    source
    fn iupac_motif_matches_at(sequence : String, motif : String, offset : Int) -> Bool

    Match one IUPAC motif at a zero-based sequence offset.

    iupac_motif_positions

    source
    fn iupac_motif_positions(sequence : String, motif : String) -> Array[Int]

    Return only one-based coordinates for a strand-specific scan.

    join_sequences

    source
    fn join_sequences(sequences : Array[String]) -> String

    kmer_profile

    source
    fn kmer_profile(sequence : String, k : Int) -> Array[KmerCount]

    Count k-mers in first-seen order, making reports stable across targets.

    local_features_fit_origin

    source
    fn local_features_fit_origin(record : Record) -> Bool

    Check whether every local feature lies inside the declared ORIGIN length.

    location_between_ranges

    source
    fn location_between_ranges(location : Location) -> Array[Range]

    location_contains

    source
    fn location_contains(location : Location, position : Int) -> Bool

    location_coordinates

    source
    fn location_coordinates(location : Location) -> Array[Int]

    Emit each coordinate in biological order, reversing complemented segments.

    location_distance

    source
    fn location_distance(left : Location, right : Location) -> Int?

    location_forward_coordinates

    source
    fn location_forward_coordinates(location : Location) -> Array[Int]

    location_has_overlap

    source
    fn location_has_overlap(left : Location, right : Location) -> Bool

    location_intervals

    source
    fn location_intervals(location : Location) -> Array[CoordinateInterval]

    Convert a location into sorted, valid inclusive coordinate intervals.

    location_is_complemented

    source
    fn location_is_complemented(location : Location) -> Bool

    location_is_fuzzy

    source
    fn location_is_fuzzy(location : Location) -> Bool

    location_is_joined

    source
    fn location_is_joined(location : Location) -> Bool

    location_is_ordered

    source
    fn location_is_ordered(location : Location) -> Bool

    location_is_remote

    source
    fn location_is_remote(location : Location) -> Bool

    location_is_single_range

    source
    fn location_is_single_range(location : Location) -> Bool

    location_length

    source
    fn location_length(location : Location) -> Int

    location_minimum

    source
    fn location_minimum(location : Location) -> Int

    location_overlap_length

    source
    fn location_overlap_length(left : Location, right : Location) -> Int

    Calculate the number of shared bases between two locations.

    location_partial_ranges

    source
    fn location_partial_ranges(location : Location) -> Array[Range]

    location_range_text

    source
    fn location_range_text(range : Range) -> String

    location_ranges_text

    source
    fn location_ranges_text(location : Location) -> Array[String]

    location_remote_accessions

    source
    fn location_remote_accessions(location : Location) -> Array[String]

    location_segments

    source
    fn location_segments(location : Location) -> Array[Range]

    location_span

    source
    fn location_span(location : Location) -> Int

    location_summary_text

    source
    fn location_summary_text(location : Location) -> String

    location_unique_coordinates

    source
    fn location_unique_coordinates(location : Location) -> Array[Int]

    longest_fasta_record

    source
    fn longest_fasta_record(records : Array[FastaRecord]) -> FastaRecord?

    Return the longest sequence in a FASTA batch.

    longest_homopolymer

    source
    fn longest_homopolymer(sequence : String) -> Int

    Return the length of the longest run of the same base.

    longest_sequence_run

    source
    fn longest_sequence_run(sequence : String) -> SequenceRun?

    longest_translation

    source
    fn longest_translation(record : Record) -> String?

    mask_ambiguities

    source
    fn mask_ambiguities(sequence : String) -> String

    Mask ambiguity symbols to N while retaining gaps and their coordinates.

    mask_ambiguous

    source
    fn mask_ambiguous(sequence : String) -> String

    mask_to_intervals

    source
    fn mask_to_intervals(mask : Array[Bool]) -> Array[CoordinateInterval]

    Convert a mask back into maximal inclusive intervals.

    merge_coordinate_intervals

    source
    fn merge_coordinate_intervals(intervals : Array[CoordinateInterval]) -> Array[CoordinateInterval]

    Merge touching and overlapping intervals into a minimal union.

    metric_between_count

    source
    fn metric_between_count(record : Record) -> Int

    metric_cds_count

    source
    fn metric_cds_count(record : Record) -> Int

    metric_coverage

    source
    fn metric_coverage(record : Record) -> Int

    metric_coverage_percent

    source
    fn metric_coverage_percent(record : Record) -> Double

    metric_entropy

    source
    fn metric_entropy(record : Record) -> Double

    metric_error_count

    source
    fn metric_error_count(record : Record) -> Int

    metric_feature_count

    source
    fn metric_feature_count(record : Record) -> Int

    metric_fuzzy_count

    source
    fn metric_fuzzy_count(record : Record) -> Int

    metric_gc

    source
    fn metric_gc(record : Record) -> Double

    metric_gene_count

    source
    fn metric_gene_count(record : Record) -> Int

    metric_length

    source
    fn metric_length(record : Record) -> Int

    metric_remote_count

    source
    fn metric_remote_count(record : Record) -> Int

    metric_warning_count

    source
    fn metric_warning_count(record : Record) -> Int

    most_ambiguous_profile

    source
    fn most_ambiguous_profile(profiles : Array[SequenceProfile]) -> SequenceProfile?

    Return the window with the greatest ambiguity burden.

    motif_count

    source
    fn motif_count(sequence : String, motif : String) -> Int

    motif_density

    source
    fn motif_density(sequence : String, motif : String) -> Double

    normalize_genbank_text

    source
    fn normalize_genbank_text(text : String) -> String

    Normalize line endings and ensure a final GenBank terminator.

    normalize_record

    source
    fn normalize_record(record : Record) -> Record

    normalize_sequence

    source
    fn normalize_sequence(text : String) -> String

    Remove formatting characters and normalize a sequence to uppercase.

    normalize_spaces

    source
    fn normalize_spaces(text : String) -> String

    nucleotide_length

    source
    fn nucleotide_length(sequence : String) -> Int

    pad_sequence

    source
    fn pad_sequence(sequence : String, length : Int, base : Char) -> String

    parse_fasta

    source
    fn parse_fasta(text : String) -> Array[FastaRecord] raise GenBankError

    Parse FASTA records while preserving the first-line description.

    parse_fasta_strict

    source
    fn parse_fasta_strict(text : String) -> Array[FastaRecord] raise GenBankError

    Parse FASTA and reject missing identifiers, duplicate identifiers, and symbols outside the IUPAC alphabet instead of silently dropping them.

    parse_location

    source
    fn parse_location(text : String) -> Location raise GenBankError

    Parse a GenBank location expression into ordered, strand-aware segments.

    parse_locus

    source
    fn parse_locus(line : String) -> Locus raise GenBankError

    Parse the LOCUS line into its stable fields.

    parse_record

    source
    fn parse_record(text : String) -> Record raise GenBankError

    Parse one GenBank/INSDC flat-file record.

    parse_record_collection

    source
    fn parse_record_collection(text : String, source_name? : String) -> RecordCollection raise GenBankError

    parse_records

    source
    fn parse_records(text : String) -> Array[Record] raise GenBankError

    Parse all records in a GenBank flat-file stream separated by //.

    profile_has_ambiguity

    source
    fn profile_has_ambiguity(profiles : Array[SequenceProfile]) -> Bool

    Check whether any profile contains ambiguity symbols.

    profile_mean_gc

    source
    fn profile_mean_gc(profiles : Array[SequenceProfile]) -> Double

    Calculate a length-weighted mean GC percentage across profiles.

    profile_total_motif_hits

    source
    fn profile_total_motif_hits(profiles : Array[SequenceProfile]) -> Int

    Count motif occurrences represented by a profile series.

    profile_window_count

    source
    fn profile_window_count(profiles : Array[SequenceProfile]) -> Int

    Return the number of windows in a profile series.

    project_feature

    source
    fn project_feature(record : Record, feature : Feature) -> FeatureProjection

    Convert a feature to a zero-based, half-open projection for genome tools.

    project_interval

    source
    fn project_interval(record : Record, start : Int, end : Int) -> Array[FeatureProjection]

    Return only projections overlapping a requested one-based interval.

    project_record_features

    source
    fn project_record_features(record : Record) -> Array[FeatureProjection]

    Project every local feature in source order.

    protein_has_unknowns

    source
    fn protein_has_unknowns(protein : String) -> Bool

    protein_is_empty

    source
    fn protein_is_empty(protein : String) -> Bool

    protein_length

    source
    fn protein_length(protein : String) -> Int

    protein_molecular_weight_approximation

    source
    fn protein_molecular_weight_approximation(protein : String) -> Double

    protein_stop_count

    source
    fn protein_stop_count(protein : String) -> Int

    protein_unknown_count

    source
    fn protein_unknown_count(protein : String) -> Int

    qualifier_difference

    source
    fn qualifier_difference(left : Record, right : Record) -> Int

    Count qualifier values that changed for features occupying the same slot.

    qualifier_exists

    source
    fn qualifier_exists(record : Record, name : String) -> Bool

    qualifier_histogram

    source
    fn qualifier_histogram(record : Record) -> Array[(String, Int)]

    qualifier_match_json

    source
    fn qualifier_match_json(record : Record, name : String) -> String

    qualifier_match_text

    source
    fn qualifier_match_text(item : QualifierMatch) -> String

    qualifier_name_count

    source
    fn qualifier_name_count(record : Record, name : String) -> Int

    qualifier_names_for_record

    source
    fn qualifier_names_for_record(record : Record) -> Array[String]

    fn qualifier_search(record : Record, text : String) -> Array[QualifierMatch]

    qualifier_value

    source
    fn qualifier_value(record : Record, key : String, name : String) -> Array[String]

    qualifier_value_count

    source
    fn qualifier_value_count(record : Record, name : String, value : String) -> Int

    qualifier_value_exists

    source
    fn qualifier_value_exists(record : Record, name : String, value : String) -> Bool

    qualifier_values_for_feature

    source
    fn qualifier_values_for_feature(feature : Feature, name : String) -> Array[String]

    qualifier_values_json

    source
    fn qualifier_values_json(record : Record, name : String) -> String

    record_annotation_report

    source
    fn record_annotation_report(record : Record) -> String

    record_between_location_count

    source
    fn record_between_location_count(record : Record) -> Int

    record_cds_count

    source
    fn record_cds_count(record : Record) -> Int

    record_coding_reports

    source
    fn record_coding_reports(record : Record, table : CodonTable) -> Array[CodingSequenceReport]

    Calculate codon usage for every CDS feature in one record.

    record_complete_codon_count

    source
    fn record_complete_codon_count(record : Record) -> Int

    Sum complete codons across all CDS features.

    record_error_count

    source
    fn record_error_count(record : Record) -> Int

    record_feature_labels

    source
    fn record_feature_labels(record : Record) -> Array[String]

    Produce stable feature labels in source order for list and search widgets.

    record_feature_report

    source
    fn record_feature_report(record : Record) -> String

    record_feature_span

    source
    fn record_feature_span(record : Record) -> Int

    record_fuzzy_location_count

    source
    fn record_fuzzy_location_count(record : Record) -> Int

    record_gene_count

    source
    fn record_gene_count(record : Record) -> Int

    record_gene_names

    source
    fn record_gene_names(record : Record) -> Array[String]

    record_has_terminator

    source
    fn record_has_terminator(record : Record) -> Bool

    record_has_translation_errors

    source
    fn record_has_translation_errors(record : Record) -> Bool

    record_is_normalized

    source
    fn record_is_normalized(record : Record) -> Bool

    record_is_valid

    source
    fn record_is_valid(record : Record) -> Bool

    record_key_coverage

    source
    fn record_key_coverage(record : Record, key : String) -> IntervalCoverage

    Count bases in a record covered by features of a selected key.

    record_location_json

    source
    fn record_location_json(record : Record) -> String

    record_location_summaries

    source
    fn record_location_summaries(record : Record) -> Array[LocationSummary]

    record_locus_tags

    source
    fn record_locus_tags(record : Record) -> Array[String]

    record_maximum_feature_end

    source
    fn record_maximum_feature_end(record : Record) -> Int

    record_metrics

    source
    fn record_metrics(record : Record) -> RecordMetrics

    record_metrics_json

    source
    fn record_metrics_json(record : Record) -> String

    record_metrics_text

    source
    fn record_metrics_text(record : Record) -> String

    record_minimum_feature_start

    source
    fn record_minimum_feature_start(record : Record) -> Int

    record_notes

    source
    fn record_notes(record : Record) -> Array[String]

    record_organisms

    source
    fn record_organisms(record : Record) -> Array[String]

    record_origin_chunks

    source
    fn record_origin_chunks(record : Record, chunk_size : Int) -> Array[String]

    Return the normalized ORIGIN split into fixed-size chunks for streaming UIs.

    record_products

    source
    fn record_products(record : Record) -> Array[String]

    record_qualifier_report

    source
    fn record_qualifier_report(record : Record) -> String

    record_references

    source
    fn record_references(record : Record) -> Array[String]

    record_remote_accession_count

    source
    fn record_remote_accession_count(record : Record) -> Int

    record_report

    source
    fn record_report(record : Record) -> String

    record_report_json

    source
    fn record_report_json(record : Record) -> String

    record_source_count

    source
    fn record_source_count(record : Record) -> Int

    record_span

    source
    fn record_span(record : Record) -> Int

    record_text_length

    source
    fn record_text_length(record : Record) -> Int

    record_text_lines

    source
    fn record_text_lines(record : Record) -> Array[String]

    record_to_bed

    source
    fn record_to_bed(record : Record) -> String

    Render BED6 rows; coordinates are zero-based and end-exclusive.

    record_to_fasta

    source
    fn record_to_fasta(record : Record, line_width : Int) -> String

    Render an indexed FASTA header that retains accession and definition.

    record_to_gff3

    source
    fn record_to_gff3(record : Record) -> String

    Render GFF3 rows with escaped attributes for common downstream consumers.

    record_translations

    source
    fn record_translations(record : Record) -> Array[String]

    record_warning_count

    source
    fn record_warning_count(record : Record) -> Int

    records_equivalent

    source
    fn records_equivalent(left : Record, right : Record) -> Bool

    Compare a record against itself after canonical sequence normalization.

    records_with_consistent_translations

    source
    fn records_with_consistent_translations(records : Array[Record]) -> Array[Record]

    Select records whose CDS annotations are fully self-consistent.

    remove_gaps

    source
    fn remove_gaps(sequence : String) -> String

    render_location

    source
    fn render_location(location : Location) -> String

    reverse_complement

    source
    fn reverse_complement(seq : String) -> String

    reverse_complement_frames

    source
    fn reverse_complement_frames(sequence : String, table : CodonTable) -> Array[String]

    rna_sequence

    source
    fn rna_sequence(sequence : String) -> String

    scan_iupac_both_strands

    source
    fn scan_iupac_both_strands(sequence : String, motif : String) -> MotifScanReport

    Scan both strands and retain orientation in every hit.

    scan_iupac_motif

    source
    fn scan_iupac_motif(sequence : String, motif : String) -> Array[MotifHit]

    Scan overlapping occurrences on one strand using IUPAC semantics.

    sequence_chunks

    source
    fn sequence_chunks(sequence : String, size : Int) -> Array[String]

    sequence_complexity

    source
    fn sequence_complexity(sequence : String) -> Double

    sequence_edit_distance

    source
    fn sequence_edit_distance(left : String, right : String) -> Int

    sequence_entropy_profile

    source
    fn sequence_entropy_profile(sequence : String, window_size : Int) -> Array[Double]

    sequence_gc_skew

    source
    fn sequence_gc_skew(sequence : String) -> Int

    GC skew (G-C) for a sequence.

    sequence_identity

    source
    fn sequence_identity(left : String, right : String) -> Double

    sequence_is_clean

    source
    fn sequence_is_clean(sequence : String) -> Bool

    Validate that a sequence has no invalid symbols and no internal gaps.

    sequence_is_low_complexity

    source
    fn sequence_is_low_complexity(sequence : String, threshold : Double) -> Bool

    sequence_pairwise_identity

    source
    fn sequence_pairwise_identity(left : String, right : String) -> Double

    sequence_palindrome

    source
    fn sequence_palindrome(sequence : String) -> Bool

    Check whether a sequence equals its reverse complement.

    sequence_profile

    source
    fn sequence_profile(sequence : String, window_size : Int, step : Int, motif : String) -> Array[SequenceProfile]

    Compute composition and motif metrics for overlapping windows.

    sequence_profiles_tsv

    source
    fn sequence_profiles_tsv(profiles : Array[SequenceProfile]) -> String

    Export profiles as tab-separated rows for plotting or spreadsheet review.

    sequence_quality_flags

    source
    fn sequence_quality_flags(sequence : String) -> Array[String]

    sequence_quality_ok

    source
    fn sequence_quality_ok(sequence : String) -> Bool

    sequence_quality_report

    source
    fn sequence_quality_report(sequence : String) -> SequenceQualityReport

    Analyze canonical, ambiguous, gap, and invalid symbols without silently discarding input. Coordinates in all reports are one-based and inclusive.

    sequence_runs

    source
    fn sequence_runs(sequence : String) -> Array[SequenceRun]

    sequence_signature

    source
    fn sequence_signature(sequence : String) -> String

    sequence_subsequence

    source
    fn sequence_subsequence(sequence : String, start : Int, end : Int) -> String

    Extract an inclusive one-based subsequence.

    sequence_windows

    source
    fn sequence_windows(sequence : String, window_size : Int, step : Int) -> Array[SequenceWindow]

    Return overlapping windows. Invalid window sizes produce an empty array.

    shortest_translation

    source
    fn shortest_translation(record : Record) -> String?

    sort_fasta_by_length

    source
    fn sort_fasta_by_length(records : Array[FastaRecord]) -> Array[FastaRecord]

    Sort records by descending sequence length, with source order as a tie-break.

    sorted_feature_keys

    source
    fn sorted_feature_keys(record : Record) -> Array[String]

    sorted_qualifier_names

    source
    fn sorted_qualifier_names(record : Record) -> Array[String]

    source_feature

    source
    fn source_feature(record : Record) -> Feature?

    standard_codon_table

    source
    fn standard_codon_table() -> CodonTable

    stop_codon_count

    source
    fn stop_codon_count(sequence : String, table : CodonTable) -> Int

    stop_codon_fraction

    source
    fn stop_codon_fraction(sequence : String, table : CodonTable) -> Double

    Return the fraction of a coding sequence represented by a stop codon.

    suffix_prefix_overlap

    source
    fn suffix_prefix_overlap(left : String, right : String, minimum : Int) -> Int

    Find the longest suffix/prefix overlap subject to a minimum length.

    summarize_alignment

    source
    fn summarize_alignment(left : String, right : String) -> AlignmentSummary

    summarize_location

    source
    fn summarize_location(location : Location) -> LocationSummary

    summarize_records

    source
    fn summarize_records(text : String) -> BatchSummary raise GenBankError

    synonymous_codon_count

    source
    fn synonymous_codon_count(sequence : String, table : CodonTable) -> Int

    translate_all_frames

    source
    fn translate_all_frames(sequence : String, table : CodonTable) -> Array[String]

    translate_dna

    source
    fn translate_dna(seq : String) -> String

    translate_dna_report

    source
    fn translate_dna_report(seq : String) -> TranslationReport

    Translate a nucleotide sequence and retain quality diagnostics.

    translate_feature

    source
    fn translate_feature(record : Record, feature_index : Int, table? : CodonTable) -> CdsTranslationResult?

    translate_frame

    source
    fn translate_frame(sequence : String, frame : Int, table : CodonTable) -> String

    Translate a one-based reading frame, where frame 1 starts at position 1.

    translation_audit

    source
    fn translation_audit(record : Record) -> TranslationAuditSummary

    Summarize every CDS, including entries that do not provide /translation.

    translation_checks_json

    source
    fn translation_checks_json(record : Record) -> String

    Return the checked CDS findings as stable JSON objects.

    translation_has_internal_stop

    source
    fn translation_has_internal_stop(protein : String) -> Bool

    translation_is_terminated

    source
    fn translation_is_terminated(protein : String) -> Bool

    translation_lengths

    source
    fn translation_lengths(record : Record) -> Array[Int]

    translation_pass_rate

    source
    fn translation_pass_rate(record : Record) -> Double

    Compute the proportion of supplied translations that passed validation.

    translation_without_stop

    source
    fn translation_without_stop(protein : String) -> String

    translations_are_consistent

    source
    fn translations_are_consistent(record : Record) -> Bool

    Return false when any supplied translation disagrees with extracted DNA.

    trim_sequence

    source
    fn trim_sequence(sequence : String, left : Int, right : Int) -> String

    ungapped_intervals

    source
    fn ungapped_intervals(sequence : String) -> Array[SequenceInterval]

    Split a sequence at gaps and return the biological sequence intervals.

    unresolved_feature_count

    source
    fn unresolved_feature_count(record : Record) -> Int

    Count features that cannot be materialized from the local ORIGIN.

    validate_fasta_records

    source
    fn validate_fasta_records(records : Array[FastaRecord]) -> FastaValidationReport

    Validate parsed FASTA records without changing their sequences.

    validate_fasta_text

    source
    fn validate_fasta_text(text : String) -> FastaValidationReport raise GenBankError

    Validate FASTA text using the same parser used by production workflows.

    vertebrate_mitochondrial_table

    source
    fn vertebrate_mitochondrial_table() -> CodonTable

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io