🥮 mooncakes.io

    moonbit-vcd

    Streaming-friendly VCD waveform parser and digital signal analysis toolkit for MoonBit

    vcd
    waveform
    fpga
    digital-circuit
    Download zip
    Version
    0.3.1
    License
    MIT
    Repository
    Last updated
    2 months ago
    Downloads
    44

    No dependencies

    #moonbit-vcd

    moonbit-vcd is a MoonBit toolkit for reading Value Change Dump (VCD) waveforms and turning them into reusable verification data. It targets FPGA, RTL simulation, embedded signal capture, and regression-analysis workflows where deterministic parsing and four-state logic matter.

    #Project positioning

    The library keeps VCD identifier codes, declaration widths, real-valued samples, and hierarchical scope paths intact. It provides a small core model and layered analysis APIs so applications can choose between a direct parser, an indexed query path, bounded sampling, streaming digests, or report exports.

    #Core capabilities

    • VCD headers, scopes, scalar/vector/real declarations, $dumpvars blocks, timestamps, and four-state values (0, 1, x, z).
    • Structural diagnostics for missing definitions, duplicate identifiers, scope underflow, invalid widths, unknown identifiers, and malformed values.
    • Signal lookup, hierarchical glob matching, indexed time queries, snapshots, windows, resampling, change coalescing, and trace transformations.
    • Rising/falling edges, intervals, duty cycle, frequency, jitter, glitches, state transitions, latency correlation, activity, and change density.
    • Four-state bitwise arithmetic, vector shifts and rotates, value encoding, deterministic JSON/CSV/VCD export, trace diffing, and compatibility reports.
    • Chunked parsing and online digests for applications that need bounded memory while retaining counts, checksums, and signal-level activity.
    • Protocol-level decoders for UART, SPI, I²C, APB, clocks, valid/ready, request/response, pulse and level channels, with transaction health monitors and deterministic replay.
    • Window planning, coverage bins, temporal assertions, derived signals, waveform repair, schema inference, packet fields, dependency graphs, regression comparison, trace alignment, checkpoints, caches, and workflow orchestration for repeatable verification jobs.

    #Quick start

    moon run cmd/vcd-report
moon check --deny-warn
moon test --deny-warn

    Library use starts with a string containing VCD text:

    match @vcd.parse(source) {
      Ok(trace) => {
        println(trace.summary())
        println(@vcd.markdown_report(trace, @vcd.markdown_report_options()))
      }
      Err(error) => println(@vcd.parse_error_message(error))
    }

    For a package import, use lqhy1234567/moonbit-vcd. Published package documentation is available on Mooncakes.

    #CLI

    The example command runs a small built-in waveform and exercises the same reporting layer used by library clients:

    moon run cmd/vcd-report -- --help
moon run cmd/vcd-report -- --json
moon run cmd/vcd-report -- --markdown
moon run cmd/vcd-report -- --csv
moon run cmd/vcd-report -- --benchmark

    The parser accepts application-provided text through parse(String). File system and simulator-specific input adapters can therefore remain outside the core package.

    #Architecture

    LayerResponsibility
    Model and parserVCD declarations, values, timestamps, and errors
    Value and scope toolsFour-state logic, widths, paths, and glob queries
    Index and querySignal-local lookup, windows, snapshots, and timelines
    AnalysisEdges, intervals, states, frequency, jitter, glitches, latency
    Transform and compareFiltering, clipping, merging, decimation, and diffs
    Protocol and verificationUART, SPI, I²C, APB, clock quality, coverage, assertions, replay
    OperationsRepair, schema, dependency graph, cache, checkpoints, package artifacts
    Streaming and pipelineChunked decode, online digest, validation, and stage reports
    Export and CLIJSON, CSV, VCD, Markdown, text, and benchmark output

    #Benchmarks

    The built-in benchmark is deterministic and reports operation counters rather than unverifiable synthetic claims. On the checked-in local run:

    FixtureOperationIterationsInput charsParsedChangesChecksum
    synthetic-8x128parse206476202304012880
    synthetic-8x128indexed-queries200123040240
    synthetic-8x128analysis200120320101600

    Reproduce it with:

    moon run cmd/vcd-report -- --benchmark

    The benchmark implementation is in benchmarks.mbt; its checksum makes regressions in parsed records and analysis work visible in CI.

    Measured warm-cache wall-clock samples and the exact run context are recorded in BENCHMARKS.md.

    #Tests and quality gates

    The test suite covers parser failures, control blocks, four-state values, hierarchy round trips, chunk boundaries, vector arithmetic, indexed queries, edge/latency analysis, exports, fixtures, benchmarks, protocol decoders, window boundaries, empty inputs, repair policies, schema checks, workflow orchestration, checkpoints, and the end-to-end pipeline. The current native run is 22/22 passing.

    #CI

    GitHub Actions checks the project on Ubuntu, macOS, and Windows. The workflow installs the current stable MoonBit toolchain, checks formatting, regenerates package interfaces, runs all-target checks and tests, and performs native coverage on Linux.

    #License

    MIT. See LICENSE.

    ActivitySegment

    source
    pub struct ActivitySegment {
      start : Int64
      end : Int64
      changes : Int
      active : Bool
      density : Double
    } derive(
    Debug    )

    A burst or idle segment derived from aggregate activity.

    ActivitySegmentOptions

    source
    pub struct ActivitySegmentOptions {
      bucket_width : Int64
      active_threshold : Int
      include_empty : Bool
    } derive(
    Debug    )

    Options controlling activity segmentation.

    ActivitySegmentOptions::with_empty

    source
    fn ActivitySegmentOptions::with_empty(self : ActivitySegmentOptions, include_empty : Bool) -> ActivitySegmentOptions

    Include or omit zero-change buckets.

    ActivitySegmentOptions::with_threshold

    source
    fn ActivitySegmentOptions::with_threshold(self : ActivitySegmentOptions, threshold : Int) -> ActivitySegmentOptions

    Set the minimum changes required for an active bucket.

    AlignmentEstimate

    source
    pub struct AlignmentEstimate {
      mode : AlignmentMode
      left_marker : String?
      right_marker : String?
      left_time : Int64?
      right_time : Int64?
      offset : Int64
      confidence : Double
    } derive(
    Debug    )

    A measured time offset between two traces.

    AlignmentEstimate::to_text

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

    Render an alignment estimate.

    AlignmentMode

    source
    pub enum AlignmentMode {
      FirstEdge
      RisingEdgeMedian
      MarkerChange
      StartAtZero
    } derive(Eq, 
    Debug    )

    Policy for aligning traces from independent capture sessions.

    AlignmentResult

    source
    pub struct AlignmentResult {
      left : Trace
      right : Trace
      estimate : AlignmentEstimate
      overlap_start : Int64
      overlap_end : Int64
      comparable : Bool
    } derive(
    Debug    )

    A pair of aligned traces and their estimate.

    AlignmentResult::has_overlap

    source
    fn AlignmentResult::has_overlap(self : AlignmentResult) -> Bool

    Return whether two traces have a non-empty aligned overlap.

    AlignmentResult::overlap

    source
    fn AlignmentResult::overlap(self : AlignmentResult) -> (Int64, Int64)

    Return an inclusive overlap window.

    AlignmentResult::to_json

    source
    fn AlignmentResult::to_json(self : AlignmentResult) -> String

    Render alignment metadata as JSON.

    AnalysisDocument

    source
    pub struct AnalysisDocument {
      title : String
      version : String
      verdict : DocumentSeverity
      sections : Array[DocumentSection]
      generated_by : String
    } derive(
    Debug    )

    A portable analysis document that can be rendered in several formats.

    AnalysisDocument::add_line

    source
    fn AnalysisDocument::add_line(self : AnalysisDocument, kind : DocumentSectionKind, line : String) -> AnalysisDocument

    Add an explanatory line to a section.

    AnalysisDocument::add_metric

    source

    Add a metric to a section, creating the section when necessary.

    AnalysisDocument::add_section

    source

    Add a section, replacing an existing section of the same kind.

    AnalysisDocument::metric_count

    source
    fn AnalysisDocument::metric_count(self : AnalysisDocument) -> Int

    Return the number of report metrics.

    AnalysisDocument::risk_metrics

    source

    Return all metrics with warning or failure status.

    AnalysisDocument::to_html

    source
    fn AnalysisDocument::to_html(self : AnalysisDocument) -> String

    Render a simple HTML document for web artifacts.

    AnalysisDocument::to_junit

    source
    fn AnalysisDocument::to_junit(self : AnalysisDocument) -> String

    Render report sections as JUnit XML test cases.

    AnalysisDocument::to_markdown

    source
    fn AnalysisDocument::to_markdown(self : AnalysisDocument) -> String

    Render a readable Markdown report.

    AnalysisDocument::verdict_line

    source
    fn AnalysisDocument::verdict_line(self : AnalysisDocument) -> String

    Render a compact one-line verdict.

    AnalysisDocument::with_verdict

    source
    fn AnalysisDocument::with_verdict(self : AnalysisDocument, version : String, verdict : DocumentSeverity) -> AnalysisDocument

    Set the document version and top-level verdict.

    AnalysisMetric

    source
    pub struct AnalysisMetric {
      name : String
      signal_id : String?
      value : Double
      count : Int
    } derive(Eq, 
    Debug    )

    Named scalar metrics exposed to dashboards and CI summaries.

    AnalysisOptions

    source
    pub struct AnalysisOptions {
      start : Int64?
      end : Int64?
      step : Int64
      include_initial : Bool
      include_unknown : Bool
    } derive(Eq, 
    Debug    )

    Configuration for bounded sampling and report generation.

    AnalysisOptions::normalized

    source
    fn AnalysisOptions::normalized(self : AnalysisOptions, trace : Trace) -> AnalysisOptions

    Return a normalized copy of analysis options.

    AnalysisWorkflow

    source
    pub struct AnalysisWorkflow {
      trace : Trace
      options : WorkflowOptions
      stages : Array[WorkflowStageResult]
      index : TraceIndex?
      windows : Array[TraceWindow]
      coverage : CoverageReport?
      assertions : AssertionSummary?
      protocol_stats : Array[ProtocolStats]
      passed : Bool
    } derive(
    Debug    )

    Complete workflow output, retaining reusable intermediate products.

    AnalysisWorkflow::is_success

    source
    fn AnalysisWorkflow::is_success(self : AnalysisWorkflow) -> Bool

    Return whether every required workflow stage passed.

    AnalysisWorkflow::passed_stage_count

    source
    fn AnalysisWorkflow::passed_stage_count(self : AnalysisWorkflow) -> Int

    Return the number of passed stages.

    AnalysisWorkflow::stage

    source

    Return a stage result by kind.

    AnalysisWorkflow::to_json

    source
    fn AnalysisWorkflow::to_json(self : AnalysisWorkflow) -> String

    Render a workflow summary as JSON.

    AnalysisWorkflow::to_text

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

    Render a workflow summary for a terminal.

    ApbConfig

    source
    pub struct ApbConfig {
      pclk : String
      psel : String
      penable : String
      pwrite : String
      paddr : String
      pwdata : String?
      prdata : String?
      pready : String?
      pslverr : String?
    } derive(Eq, 
    Debug    )

    APB signal mapping for transaction extraction.

    ApbConfig::with_data

    source
    fn ApbConfig::with_data(self : ApbConfig, pwdata : String, prdata : String) -> ApbConfig

    Add data and response signals to an APB mapping.

    ApbConfig::with_response

    source
    fn ApbConfig::with_response(self : ApbConfig, pready : String, pslverr : String) -> ApbConfig

    Add optional APB response signals.

    ApbReport

    source
    pub struct ApbReport {
      transfers : Int
      completed : Int
      reads : Int
      writes : Int
      errors : Int
      maximum_wait : Int
      mean_wait : Double?
      addresses : Int
    } derive(Eq, 
    Debug    )

    APB decode summary.

    ApbReport::to_json

    source
    fn ApbReport::to_json(self : ApbReport) -> String

    Render APB summary as JSON.

    ApbReport::to_text

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

    Render APB summary as text.

    ApbTransfer

    source
    pub struct ApbTransfer {
      index : Int
      setup_time : Int64
      access_time : Int64
      complete_time : Int64
      address : Int64?
      write : Bool
      write_data : Int64?
      read_data : Int64?
      ready : Bool
      error : Bool
      wait_cycles : Int
    } derive(Eq, 
    Debug    )

    One decoded APB transfer.

    AssertionKind

    source
    pub enum AssertionKind {
      KnownValue
      StableInterval
      MinimumPulse
      MinimumGap
      UnsignedRange
      OneHot
      ResponseWithin
      NoActivity
      Monotonic
    } derive(Eq, 
    Debug    )

    Kinds of temporal and value assertions supported by the engine.

    AssertionSeverity

    source
    pub enum AssertionSeverity {
      Info
      Warning
      Error
      Fatal
    } derive(Eq, 
    Debug    )

    Severity assigned to a failed waveform assertion.

    AssertionSummary

    source
    pub struct AssertionSummary {
      total : Int
      passed : Int
      failed : Int
      fatal : Int
      violations : Array[AssertionViolation]
    } derive(
    Debug    )

    Aggregate result for a set of assertions.

    AssertionSummary::has_fatal

    source
    fn AssertionSummary::has_fatal(self : AssertionSummary) -> Bool

    Return whether the suite contains a fatal violation.

    AssertionSummary::is_success

    source
    fn AssertionSummary::is_success(self : AssertionSummary) -> Bool

    Return whether every assertion passed.

    AssertionSummary::to_csv

    source
    fn AssertionSummary::to_csv(self : AssertionSummary) -> String

    Return failures as CSV suitable for CI artifacts.

    AssertionSummary::to_json

    source
    fn AssertionSummary::to_json(self : AssertionSummary) -> String

    Return failures as JSON.

    AssertionSummary::to_text

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

    Return a deterministic text report.

    AssertionViolation

    source
    pub struct AssertionViolation {
      name : String
      kind : AssertionKind
      signal_id : String
      time : Int64
      end_time : Int64
      severity : AssertionSeverity
      observed : String
      expected : String
      message : String
    } derive(Eq, 
    Debug    )

    One assertion failure with an exact time range.

    BenchmarkResult

    source
    pub struct BenchmarkResult {
      name : String
      iterations : Int
      input_chars : Int
      parsed_traces : Int
      observed_changes : Int
      checksum : Int64
    } derive(Eq, 
    Debug    )

    Deterministic operation counters used by the benchmark CLI and CI.

    BenchmarkResult::to_text

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

    Render benchmark counters as stable text.

    BenchmarkSuite

    source
    pub struct BenchmarkSuite {
      fixture : String
      results : Array[BenchmarkResult]
    } derive(Eq, 
    Debug    )

    A collection of benchmark results for one fixture.

    BenchmarkSuite::to_csv

    source
    fn BenchmarkSuite::to_csv(self : BenchmarkSuite) -> String

    Render a suite as CSV for archival benchmark evidence.

    BitStatistics

    source
    pub struct BitStatistics {
      signal_id : String
      bits : Int
      zeros : Int
      ones : Int
      unknown : Int
      high_impedance : Int
    } derive(Eq, 
    Debug    )

    Bit-level counters for a vector signal.

    BusSnapshot

    source
    pub struct BusSnapshot {
      time : Int64
      value : Value
      signal_ids : Array[String]
    } derive(Eq, 
    Debug    )

    A decoded bus snapshot assembled from several scalar signals.

    CdcObservation

    source
    pub struct CdcObservation {
      source_id : String
      destination_id : String
      destination_time : Int64
      nearest_source_edge : Int64?
      distance : Int64?
      inside_guard_band : Bool
      source_value : Value?
      destination_value : Value?
    } derive(
    Debug    )

    A cross-clock-domain sampling relationship.

    Change

    source
    pub struct Change {
      time : Int64
      id : String
      value : Value
    } derive(
    Debug    )

    Change::at

    source
    fn Change::at(self : Change, timestamp : Int64) -> Change

    Return a copy of a change at a different timestamp.

    Change::is_real

    source
    fn Change::is_real(self : Change) -> Bool

    Return whether a change carries a real-valued sample.

    Change::is_scalar

    source
    fn Change::is_scalar(self : Change) -> Bool

    Return whether a change carries a scalar logical state.

    Change::is_vector

    source
    fn Change::is_vector(self : Change) -> Bool

    Return whether a change carries a vector value.

    Change::text

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

    Return a concise change representation for trace logs.

    CheckpointSet

    source
    pub struct CheckpointSet {
      trace_digest : Int64
      checkpoints : Array[TraceCheckpoint]
      ordered : Bool
    } derive(
    Debug    )

    A checkpoint set for replay and incremental analysis.

    CheckpointSet::at_or_before

    source
    fn CheckpointSet::at_or_before(self : CheckpointSet, time : Int64) -> TraceCheckpoint?

    Find the latest checkpoint at or before a timestamp.

    CheckpointSet::find

    source
    fn CheckpointSet::find(self : CheckpointSet, name : String) -> TraceCheckpoint?

    Find a checkpoint by name.

    CheckpointSet::to_json

    source
    fn CheckpointSet::to_json(self : CheckpointSet) -> String

    Render a checkpoint set as JSON.

    CheckpointSet::to_text

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

    Render a checkpoint set for a terminal.

    CliFormat

    source
    pub enum CliFormat {
      Text
      Markdown
      Json
      Csv
    } derive(Eq, 
    Debug    )

    Output formats supported by the command-line report adapter.

    CliOptions

    source
    pub struct CliOptions {
      input : String?
      output : String?
      signal_id : String?
      start : Int64?
      end : Int64?
      format : CliFormat
      strict : Bool
      include_unknown : Bool
      benchmark : Bool
      help : Bool
    } derive(Eq, 
    Debug    )

    Parsed command-line options for embedding the library in small tools.

    ClockConfig

    source
    pub struct ClockConfig {
      signal_id : String
      expected_period : Int64?
      tolerance : Int64
      active_rising : Bool
      minimum_edges : Int
    } derive(Eq, 
    Debug    )

    Configuration for clock-quality analysis.

    ClockConfig::with_minimum_edges

    source
    fn ClockConfig::with_minimum_edges(self : ClockConfig, edges : Int) -> ClockConfig

    Require a minimum number of measured edges.

    ClockConfig::with_period

    source
    fn ClockConfig::with_period(self : ClockConfig, period : Int64, tolerance : Int64) -> ClockConfig

    Attach an expected period and absolute tolerance.

    ClockCycle

    source
    pub struct ClockCycle {
      index : Int
      rising_time : Int64
      falling_time : Int64?
      next_rising_time : Int64?
      period : Int64?
      high_time : Int64?
      low_time : Int64?
      duty_cycle : Double?
    } derive(Eq, 
    Debug    )

    One measured clock cycle.

    ClockReport

    source
    pub struct ClockReport {
      signal_id : String
      edge_count : Int
      cycle_count : Int
      missing_falling_edges : Int
      missing_next_edges : Int
      periods : Array[Int64]
      minimum_period : Int64?
      maximum_period : Int64?
      mean_period : Double?
      period_jitter : Double?
      mean_duty_cycle : Double?
      out_of_tolerance : Int
    } derive(
    Debug    )

    Aggregate clock-quality results.

    ClockReport::to_json

    source
    fn ClockReport::to_json(self : ClockReport) -> String

    Render a clock report as JSON.

    ClockReport::to_text

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

    Render a clock report as text.

    CompareOptions

    source
    pub struct CompareOptions {
      time_tolerance : Int64
      include_equal : Bool
      ignore_unknown_case : Bool
    } derive(Eq, 
    Debug    )

    Tolerance-aware comparison settings for independently captured traces.

    ComparisonSummary

    source
    pub struct ComparisonSummary {
      signals_left : Int
      signals_right : Int
      compared_points : Int
      equal_points : Int
      different_points : Int
      missing_left : Int
      missing_right : Int
      first_difference : Int64?
    } derive(Eq, 
    Debug    )

    Aggregate result for a pairwise comparison.

    CompatibilitySummary

    source
    pub struct CompatibilitySummary {
      has_date : Bool
      has_version : Bool
      has_timescale : Bool
      has_comment : Bool
      variable_kinds : Array[(String, Int)]
      supports_dumpvars : Bool
      supports_real : Bool
    } derive(Eq, 
    Debug    )

    Header and declaration facts used for compatibility reports.

    CoverageBin

    source
    pub struct CoverageBin {
      group : String
      key : String
      label : String
      kind : CoverageKind
      hits : Int
      target : Int
      first_time : Int64?
      last_time : Int64?
    } derive(
    Debug    )

    One measurable coverage bin.

    CoverageBin::hit

    source
    fn CoverageBin::hit(self : CoverageBin, time : Int64, weight : Int) -> CoverageBin

    Return a copy with one observation applied.

    CoverageBin::is_covered

    source
    fn CoverageBin::is_covered(self : CoverageBin) -> Bool

    Return whether a bin has met its target.

    CoverageBin::progress

    source
    fn CoverageBin::progress(self : CoverageBin) -> Double

    Return a bounded progress ratio for a bin.

    CoverageKind

    source
    pub enum CoverageKind {
      Value
      Transition
      Toggle
      Width
      Activity
      Protocol
    } derive(Eq, 
    Debug    )

    Coverage dimensions supported by waveform regression analysis.

    CoveragePoint

    source
    pub struct CoveragePoint {
      group : String
      key : String
      time : Int64
      weight : Int
    } derive(Eq, 
    Debug    )

    An observed point that can be accumulated into coverage.

    CoverageReport

    source
    pub struct CoverageReport {
      name : String
      bins : Array[CoverageBin]
      observations : Int
      covered : Int
      target : Int
      score : Double
    } derive(
    Debug    )

    A complete coverage report for one trace or regression batch.

    CoverageReport::score_by_kind

    source
    fn CoverageReport::score_by_kind(self : CoverageReport) -> Array[(String, Double)]

    Return coverage grouped by dimension.

    CoverageReport::to_csv

    source
    fn CoverageReport::to_csv(self : CoverageReport) -> String

    Render a report in a stable CSV form.

    CoverageReport::to_json

    source
    fn CoverageReport::to_json(self : CoverageReport) -> String

    Render the complete report as JSON.

    CoverageReport::to_text

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

    Render report rows for CI summaries.

    CoverageReport::uncovered

    source

    Return all bins that remain uncovered.

    DependencyKind

    source
    pub enum DependencyKind {
      DataFollowsControl
      ControlPrecedesData
      SameTimestamp
      ClockDriven
      CorrelatedActivity
    } derive(Eq, 
    Debug    )

    Dependency relationships inferred from signal timing.

    DependencyReport

    source
    pub struct DependencyReport {
      dependencies : Array[SignalDependency]
      signal_count : Int
      observation_count : Int
      threshold : Int64
    } derive(
    Debug    )

    Dependency report for a trace.

    DependencyReport::from

    source
    fn DependencyReport::from(self : DependencyReport, source_id : String) -> Array[SignalDependency]

    Return dependencies originating from one signal.

    DependencyReport::strong

    source
    fn DependencyReport::strong(self : DependencyReport, minimum : Double) -> Array[SignalDependency]

    Return high-confidence dependencies only.

    DependencyReport::to

    source
    fn DependencyReport::to(self : DependencyReport, target_id : String) -> Array[SignalDependency]

    Return dependencies targeting one signal.

    DependencyReport::to_json

    source
    fn DependencyReport::to_json(self : DependencyReport) -> String

    Render a dependency report as JSON.

    DependencyReport::to_text

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

    Render a dependency report summary.

    DerivedExpr

    source
    pub enum DerivedExpr {
      SignalRef(String)
      Constant(Value)
      Not(DerivedExpr)
      And(DerivedExpr, DerivedExpr)
      Or(DerivedExpr, DerivedExpr)
      Xor(DerivedExpr, DerivedExpr)
      Add(DerivedExpr, DerivedExpr)
      Sub(DerivedExpr, DerivedExpr)
      Concat(DerivedExpr, DerivedExpr)
      ShiftLeft(DerivedExpr, Int)
      ShiftRight(DerivedExpr, Int)
      Mux(DerivedExpr, DerivedExpr, DerivedExpr)
      SampleAt(DerivedExpr, Int64)
      EdgeRise(String)
      EdgeFall(String)
    } derive(Eq, 
    Debug    )

    Expression nodes used to derive analysis signals from an existing trace.

    DerivedObservation

    source
    pub struct DerivedObservation {
      id : String
      time : Int64
      value : Value
      source_changes : Int
    } derive(Eq, 
    Debug    )

    One calculated value at a source timestamp.

    DerivedReport

    source
    pub struct DerivedReport {
      signal_id : String
      expression : String
      timestamps : Int
      changes : Int
      unknowns : Int
      source_changes : Int
    } derive(Eq, 
    Debug    )

    Summary counters for derived-signal generation.

    DerivedReport::to_json

    source
    fn DerivedReport::to_json(self : DerivedReport) -> String

    Render a generation report as JSON.

    DerivedReport::to_text

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

    Render a generation report as text.

    DerivedSignalSpec

    source
    pub struct DerivedSignalSpec {
      id : String
      name : String
      width : Int
      kind : String
      expr : DerivedExpr
    } derive(Eq, 
    Debug    )

    A declaration for a calculated signal.

    DiffOptions

    source
    pub struct DiffOptions {
      start : Int64
      end : Int64
      include_equal : Bool
      compare_unknown_case_insensitively : Bool
    } derive(Eq, 
    Debug    )

    Options used by deterministic trace comparison.

    DigestSummary

    source
    pub struct DigestSummary {
      changes : Int
      signals : Int
      first_time : Int64?
      last_time : Int64?
      unknown : Int
      checksum : Int64
    } derive(Eq, 
    Debug    )

    Immutable digest snapshot suitable for persistence.

    DigestSummary::duration

    source
    fn DigestSummary::duration(self : DigestSummary) -> Int64

    Return the duration covered by an immutable digest.

    DigestSummary::is_empty

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

    Return whether a digest describes an empty input.

    DigestSummary::to_json

    source
    fn DigestSummary::to_json(self : DigestSummary) -> String

    Return a stable JSON representation of an immutable digest.

    DigestSummary::to_text

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

    Return a stable text representation of an immutable digest.

    DocumentMetric

    source
    pub struct DocumentMetric {
      name : String
      value : String
      unit : String?
      severity : DocumentSeverity
    } derive(
    Debug    )

    A named scalar or textual report metric.

    DocumentSection

    source
    pub struct DocumentSection {
      kind : DocumentSectionKind
      title : String
      summary : String
      metrics : Array[DocumentMetric]
      lines : Array[String]
    } derive(
    Debug    )

    A report section containing metrics and explanatory lines.

    DocumentSectionKind

    source
    pub enum DocumentSectionKind {
      Overview
      Input
      Validation
      Performance
      Coverage
      Assertions
      Protocol
      Findings
      Artifacts
    } derive(Eq, 
    Debug    )

    Standard sections emitted by a verification report.

    DocumentSeverity

    source
    pub enum DocumentSeverity {
      Notice
      Success
      Warning
      Failure
    } derive(Eq, 
    Debug    )

    Severity used by a machine-readable analysis document.

    EdgeEvent

    source
    pub struct EdgeEvent {
      signal_id : String
      time : Int64
      before : Char
      after : Char
      kind : EdgeKind
    } derive(Eq, 
    Debug    )

    A timestamped scalar transition.

    EdgeKind

    source
    pub enum EdgeKind {
      Rising
      Falling
      ToUnknown
      FromUnknown
      ToHighImpedance
      FromHighImpedance
      Other
    } derive(Eq, 
    Debug    )

    A classified transition between two scalar logic states.

    EventFilter

    source
    pub struct EventFilter {
      signal_ids : Array[String]
      start : Int64
      end : Int64
      include_unknown : Bool
    } derive(Eq, 
    Debug    )

    Select events by identifier and inclusive time window.

    EventGraph

    source
    pub struct EventGraph {
      nodes : Array[GraphNode]
      edges : Array[GraphEdge]
      signal_nodes : Int
      change_nodes : Int
      temporal_edges : Int
      cross_signal_edges : Int
    } derive(
    Debug    )

    A deterministic graph built from trace changes and declarations.

    EventGraph::find_node

    source
    fn EventGraph::find_node(self : EventGraph, node_id : String) -> GraphNode?

    Find a node by its stable identifier.

    EventGraph::incoming

    source
    fn EventGraph::incoming(self : EventGraph, node_id : String) -> Array[GraphEdge]

    Return the incoming edges for one node.

    EventGraph::neighbors

    source
    fn EventGraph::neighbors(self : EventGraph, node_id : String) -> Array[String]

    Return unique graph neighbors in edge order.

    EventGraph::outgoing

    source
    fn EventGraph::outgoing(self : EventGraph, node_id : String) -> Array[GraphEdge]

    Return the outgoing edges for one node.

    EventGraph::to_dot

    source
    fn EventGraph::to_dot(self : EventGraph) -> String

    Export graph nodes and edges as Graphviz DOT.

    EventGraph::to_json

    source
    fn EventGraph::to_json(self : EventGraph) -> String

    Render graph metadata and edge data as JSON.

    EventGraph::to_text

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

    Render a compact graph summary.

    EventWindowMetric

    source
    pub struct EventWindowMetric {
      start : Int64
      end : Int64
      changes : Int
      active_signals : Int
      rising_edges : Int
      falling_edges : Int
      unknown_changes : Int
      density : Double
    } derive(Eq, 
    Debug    )

    Aggregate metrics for one fixed analysis window.

    FixtureFact

    source
    pub struct FixtureFact {
      name : String
      ok : Bool
      signals : Int
      changes : Int
      source_bytes : Int
      round_trip : Bool
    } derive(Eq, 
    Debug    )

    Parsed facts used by local smoke tests and example applications.

    FrequencyEstimate

    source
    pub struct FrequencyEstimate {
      signal_id : String
      edge_count : Int
      period_count : Int
      mean_period : Double?
      minimum_period : Int64?
      maximum_period : Int64?
      frequency : Double?
    } derive(Eq, 
    Debug    )

    A frequency estimate derived from consecutive rising edges.

    GlitchEvent

    source
    pub struct GlitchEvent {
      signal_id : String
      start : Int64
      end : Int64
      width : Int64
      value : Char
    } derive(Eq, 
    Debug    )

    A short driven pulse detected by a width threshold.

    GraphEdge

    source
    pub struct GraphEdge {
      from : String
      to : String
      kind : GraphEdgeKind
      weight : Int
      evidence : String
    } derive(
    Debug    )

    A directed relationship between two analysis nodes.

    GraphEdgeKind

    source
    pub enum GraphEdgeKind {
      Temporal
      SameSignal
      SameTimestamp
      Dependency
      Containment
    } derive(Eq, 
    Debug    )

    Relationship categories used for trace causality.

    GraphNode

    source
    pub struct GraphNode {
      id : String
      kind : GraphNodeKind
      label : String
      signal_id : String?
      time : Int64?
      weight : Int
    } derive(
    Debug    )

    A graph node that points back to a waveform object.

    GraphNodeKind

    source
    pub enum GraphNodeKind {
      SignalNode
      ChangeNode
      WindowNode
      AssertionNode
      ProtocolNode
    } derive(Eq, 
    Debug    )

    Node categories in the analysis graph.
    pub struct Header {
      date : String?
      version : String?
      timescale : String?
      comment : String?
    } derive(
    Debug    )

    Header::summary

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

    Return a compact header description.

    I2cByte

    source
    pub struct I2cByte {
      index : Int
      time : Int64
      value : Int
      text : String
      address : Bool
      read : Bool
      acknowledged : Bool?
      bit_count : Int
    } derive(
    Debug    )

    One decoded byte, including its address/data role and ACK result.

    I2cConfig

    source
    pub struct I2cConfig {
      clock : String
      data : String
      address_bits : Int
      include_ack : Bool
      address_is_seven_bit : Bool
    } derive(
    Debug    )

    I²C bus configuration.

    I2cConfig::with_ack_slots

    source
    fn I2cConfig::with_ack_slots(self : I2cConfig, include_ack : Bool) -> I2cConfig

    Include or omit ACK slots from byte grouping.

    I2cConfig::with_address_width

    source
    fn I2cConfig::with_address_width(self : I2cConfig, bits : Int) -> I2cConfig

    Select seven- or ten-bit address interpretation.

    I2cEventKind

    source
    pub enum I2cEventKind {
      Start
      RepeatedStart
      Stop
      Byte
      Acknowledge
      NotAcknowledge
      Unknown
    } derive(Eq, 
    Debug    )

    A semantic event observed on an I²C bus.

    I2cReport

    source
    pub struct I2cReport {
      config : I2cConfig
      transactions : Array[I2cTransaction]
      events : Int
      bytes : Int
      acknowledged : Int
      not_acknowledged : Int
      first_time : Int64?
      last_time : Int64?
    } derive(
    Debug    )

    Aggregate I²C decode output.

    I2cReport::all_bytes

    source
    fn I2cReport::all_bytes(self : I2cReport) -> Array[I2cByte]

    Return every byte from every transaction in wire order.

    I2cReport::byte_count

    source
    fn I2cReport::byte_count(self : I2cReport) -> Int

    Return the number of decoded bytes.

    I2cReport::to_json

    source
    fn I2cReport::to_json(self : I2cReport) -> String

    Render an I²C report as JSON.

    I2cReport::to_text

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

    Render an I²C report for a terminal.

    I2cTransaction

    source
    pub struct I2cTransaction {
      index : Int
      start_time : Int64
      end_time : Int64
      repeated_start_count : Int
      bytes : Array[I2cByte]
      address : Int?
      read : Bool?
      completed : Bool
    } derive(
    Debug    )

    A complete I²C transaction between START and STOP.

    JitterReport

    source
    pub struct JitterReport {
      signal_id : String
      edges : Int
      periods : Int
      mean_period : Double?
      minimum_period : Int64?
      maximum_period : Int64?
      mean_absolute_deviation : Double?
    } derive(Eq, 
    Debug    )

    A deterministic clock-quality summary.

    LatencyReport

    source
    pub struct LatencyReport {
      source_signal : String
      target_signal : String
      samples : Int
      matched : Int
      minimum : Int64?
      maximum : Int64?
      mean : Double?
    } derive(Eq, 
    Debug    )

    Summary of matched edge latency.

    LatencySample

    source
    pub struct LatencySample {
      source_signal : String
      target_signal : String
      source_time : Int64
      target_time : Int64?
      latency : Int64?
    } derive(Eq, 
    Debug    )

    A matched pair of source and target rising edges.

    LogicBit

    source
    pub enum LogicBit {
      Zero
      One
      Unknown
      HighImpedance
    } derive(Eq, 
    Debug    )

    The four logical states used by a digital waveform.

    LogicBit::to_char

    source
    fn LogicBit::to_char(self : LogicBit) -> Char

    Convert a classified logic state to canonical VCD spelling.

    MergeOptions

    source
    pub struct MergeOptions {
      mode : MergeTimeMode
      offset : Int64
      align_signal : String?
      include_duplicate_changes : Bool
      rename_conflicts : Bool
      sort_changes : Bool
    } derive(Eq, 
    Debug    )

    Options for a deterministic trace merge.

    MergeSelection

    source
    pub struct MergeSelection {
      ids : Array[String]
      paths : Array[String]
      include_vectors : Bool
      include_reals : Bool
    } derive(Eq, 
    Debug    )

    A signal selection used to reduce a large trace before analysis.

    MergeSelection::reals

    source
    fn MergeSelection::reals(self : MergeSelection, enabled : Bool) -> MergeSelection

    Restrict whether real declarations are selected.

    MergeSelection::vectors

    source
    fn MergeSelection::vectors(self : MergeSelection, enabled : Bool) -> MergeSelection

    Restrict whether vector declarations are selected.

    MergeTimeMode

    source
    pub enum MergeTimeMode {
      PreserveLeft
      PreserveRight
      ShiftRightToEnd
      AlignFirstChange
      AlignNamedSignal
    } derive(Eq, 
    Debug    )

    Policies for combining traces recorded by separate simulators or runs.

    MonitorFinding

    source
    pub struct MonitorFinding {
      channel : String
      rule : MonitorRule
      severity : MonitorSeverity
      transaction_index : Int?
      time : Int64
      observed : String
      expected : String
      message : String
    } derive(
    Debug    )

    One transaction monitor finding.

    MonitorOptions

    source
    pub struct MonitorOptions {
      require_completed : Bool
      maximum_latency : Int64?
      minimum_gap : Int64?
      require_payload : Bool
      require_acceptance : Bool
      minimum_throughput : Double?
    } derive(
    Debug    )

    Monitor policy for a protocol channel.

    MonitorOptions::with_gap

    source
    fn MonitorOptions::with_gap(self : MonitorOptions, gap : Int64?) -> MonitorOptions

    Require a minimum gap between completed transactions.

    MonitorOptions::with_max_latency

    source
    fn MonitorOptions::with_max_latency(self : MonitorOptions, limit : Int64?) -> MonitorOptions

    Require a maximum transaction latency.

    MonitorOptions::with_payloads

    source
    fn MonitorOptions::with_payloads(self : MonitorOptions, required : Bool) -> MonitorOptions

    Require non-empty payloads for accepted transfers.

    MonitorReport

    source
    pub struct MonitorReport {
      channel : String
      transactions : Array[ProtocolTransaction]
      findings : Array[MonitorFinding]
      passed : Bool
      score : Int
    } derive(
    Debug    )

    Protocol monitor output.

    MonitorReport::findings_by_severity

    source
    fn MonitorReport::findings_by_severity(self : MonitorReport, severity : MonitorSeverity) -> Array[MonitorFinding]

    Return error and warning findings in stable order.

    MonitorReport::is_success

    source
    fn MonitorReport::is_success(self : MonitorReport) -> Bool

    Return whether the monitor passed without error findings.

    MonitorReport::to_json

    source
    fn MonitorReport::to_json(self : MonitorReport) -> String

    Render a protocol monitor summary as JSON.

    MonitorReport::to_text

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

    Render a protocol monitor summary.

    MonitorRule

    source
    pub enum MonitorRule {
      CompletionRequired
      MaximumLatency
      MinimumGap
      PayloadRequired
      AcceptanceRequired
      ThroughputMinimum
    } derive(Eq, 
    Debug    )

    Health rules applied to protocol transactions.

    MonitorSeverity

    source
    pub enum MonitorSeverity {
      MonitorInfo
      MonitorWarning
      MonitorError
    } derive(Eq, 
    Debug    )

    Severity of a protocol monitor finding.

    OnlineMetrics

    source
    pub struct OnlineMetrics {
      changes : Int
      scalar_changes : Int
      vector_changes : Int
      real_changes : Int
      unknown_changes : Int
      first_time : Int64?
      last_time : Int64?
      checksum : Int64
    } derive(Eq, 
    Debug    )

    Mutable online counters for a stream of changes.

    OnlineMetrics::mean_interval

    source
    fn OnlineMetrics::mean_interval(self : OnlineMetrics) -> Double?

    Return the average time between online changes.

    OnlineMetrics::merge

    source

    Merge two online metric accumulators.

    OnlineMetrics::push

    source
    fn OnlineMetrics::push(self : OnlineMetrics, change : Change) -> Unit

    Add one change to an online accumulator.

    OnlineMetrics::to_json_string

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

    Render online metrics as JSON.

    PacketField

    source
    pub struct PacketField {
      name : String
      lsb : Int
      width : Int
      signed : Bool
      display : String
    } derive(
    Debug    )

    A bit field in a decoded packet or bus payload.

    PacketFieldValue

    source
    pub struct PacketFieldValue {
      name : String
      raw : Int64?
      text : String
      valid : Bool
    } derive(
    Debug    )

    A decoded packet field value.

    PacketLayout

    source
    pub struct PacketLayout {
      name : String
      total_bits : Int
      fields : Array[PacketField]
      byte_order : String
    } derive(
    Debug    )

    A packet layout used by protocol and register analysis.

    PacketLayout::to_json

    source
    fn PacketLayout::to_json(self : PacketLayout) -> String

    Render a layout as JSON.

    PacketLayout::with_byte_order

    source
    fn PacketLayout::with_byte_order(self : PacketLayout, byte_order : String) -> PacketLayout

    Set byte order.

    PacketLayout::with_field

    source
    fn PacketLayout::with_field(self : PacketLayout, name : String, lsb : Int, width : Int, signed : Bool) -> PacketLayout

    Add a field, clamped to the layout width.

    PacketRecord

    source
    pub struct PacketRecord {
      index : Int
      time : Int64
      payload : Value?
      fields : Array[PacketFieldValue]
      valid : Bool
      error : String?
    } derive(
    Debug    )

    One packet captured at a protocol timestamp.

    PacketRecord::field

    source
    fn PacketRecord::field(self : PacketRecord, name : String) -> PacketFieldValue?

    Return the first field with a named identifier.

    PacketRecord::to_json

    source
    fn PacketRecord::to_json(self : PacketRecord) -> String

    Render a packet record as JSON.

    ParseError

    source
    pub enum ParseError {
      InvalidDirective(String)
      InvalidVariable(String)
      InvalidValue(String)
      InvalidTime(String)
      EmptyInput
      MissingEnddefinitions
      ScopeUnderflow
      DuplicateIdentifier(String)
      UnknownIdentifier(String)
      UnsupportedValue(String)
    } derive(Eq, 
    Debug    )

    ParseSummary

    source
    pub struct ParseSummary {
      ok : Bool
      signal_count : Int
      change_count : Int
      end_time : Int64
      error : String?
    } derive(Eq, 
    Debug    )

    A parse attempt summary that keeps errors machine-readable.

    PipelineResult

    source
    pub struct PipelineResult {
      stage : PipelineStage
      ok : Bool
      items : Int
      detail : String
    } derive(Eq, 
    Debug    )

    One stage result with deterministic counters and a status flag.

    PipelineStage

    source
    pub enum PipelineStage {
      SourceInventory
      Parse
      Validation
      Index
      Analysis
      Export
    } derive(Eq, 
    Debug    )

    Stages reported by a reusable parse-and-analyze pipeline.

    ProfileMetric

    source
    pub struct ProfileMetric {
      signal_id : String
      kind : ProfileMetricKind
      value : Double?
      count : Int?
      unit : String
      quality : Int
    } derive(
    Debug    )

    One measured profile metric.

    ProfileMetricKind

    source
    pub enum ProfileMetricKind {
      TransitionCount
      RisingCount
      FallingCount
      UnknownCount
      DutyCycle
      Frequency
      Entropy
      MeanChangeInterval
    } derive(Eq, 
    Debug    )

    Metric families included in a signal profile.

    ProtocolChannel

    source
    pub struct ProtocolChannel {
      name : String
      mode : ProtocolMode
      clock_id : String?
      valid_id : String?
      ready_id : String?
      request_id : String?
      response_id : String?
      payload_id : String?
      reset_id : String?
      active_high : Bool
      minimum_gap : Int64
    } derive(Eq, 
    Debug    )

    Signal identifiers and timing rules used by a protocol extractor.

    ProtocolChannel::with_minimum_gap

    source
    fn ProtocolChannel::with_minimum_gap(self : ProtocolChannel, gap : Int64) -> ProtocolChannel

    Attach a minimum spacing rule for burst analysis.

    ProtocolChannel::with_reset

    source
    fn ProtocolChannel::with_reset(self : ProtocolChannel, reset_id : String) -> ProtocolChannel

    Attach a reset signal to a channel without changing its mode.

    ProtocolEvent

    source
    pub struct ProtocolEvent {
      channel : String
      time : Int64
      kind : String
      payload : Value?
      accepted : Bool
      sequence : Int
    } derive(Eq, 
    Debug    )

    A protocol event observed at one simulation timestamp.

    ProtocolMode

    source
    pub enum ProtocolMode {
      ValidReady
      ValidOnly
      RequestResponse
      Pulse
      Level
    } derive(Eq, 
    Debug    )

    Common transaction interpretations for synchronous digital interfaces.

    ProtocolReplay

    source
    pub struct ProtocolReplay {
      channel : String
      steps : Array[ReplayStep]
      accepted : Int
      rejected : Int
      incomplete : Int
      final_state : String
      deterministic : Bool
    } derive(
    Debug    )

    A replayed protocol state machine result.

    ProtocolReplay::is_success

    source
    fn ProtocolReplay::is_success(self : ProtocolReplay) -> Bool

    Return whether the replay was deterministic and complete.

    ProtocolReplay::steps_with

    source
    fn ProtocolReplay::steps_with(self : ProtocolReplay, outcome : ReplayOutcome) -> Array[ReplayStep]

    Return replay steps with a particular outcome.

    ProtocolReplay::to_json

    source
    fn ProtocolReplay::to_json(self : ProtocolReplay) -> String

    Render replay metadata as JSON.

    ProtocolReplay::to_text

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

    Render replay metadata for a terminal.

    ProtocolStats

    source
    pub struct ProtocolStats {
      channel : String
      events : Int
      transactions : Int
      completed : Int
      incomplete : Int
      accepted : Int
      rejected : Int
      minimum_latency : Int64?
      maximum_latency : Int64?
      mean_latency : Double?
      throughput : Double
      backpressure_cycles : Int
    } derive(Eq, 
    Debug    )

    Aggregate protocol health metrics.

    ProtocolStats::to_json

    source
    fn ProtocolStats::to_json(self : ProtocolStats) -> String

    Render a protocol statistic record as JSON.

    ProtocolStats::to_text

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

    Render a human-readable protocol summary.

    ProtocolTransaction

    source
    pub struct ProtocolTransaction {
      channel : String
      index : Int
      start : Int64
      end : Int64
      latency : Int64
      payload : Value?
      completed : Bool
      accepted : Bool
    } derive(Eq, 
    Debug    )

    A paired request/response or accepted transfer.

    QueryPlanNode

    source
    pub struct QueryPlanNode {
      index : Int
      kind : QueryPlanNodeKind
      input_rows : Int
      output_rows : Int
      estimated_cost : Double
      detail : String
    } derive(
    Debug    )

    One node in a costed query plan.

    QueryPlanNodeKind

    source
    pub enum QueryPlanNodeKind {
      FullScan
      SignalIndex
      TimeIndex
      ValueFilter
      Projection
      Sort
      Limit
    } derive(Eq, 
    Debug    )

    Physical operations used in a query plan.

    QueryPlanV2

    source
    pub struct QueryPlanV2 {
      predicates : Array[QueryPredicate]
      signals : Array[String]
      limit : Int?
      nodes : Array[QueryPlanNode]
      estimated_rows : Int
      estimated_cost : Double
    } derive(
    Debug    )

    A complete query plan with predicates and projections.

    QueryPlanV2::optimize

    source
    fn QueryPlanV2::optimize(self : QueryPlanV2, trace : Trace) -> QueryPlanV2

    Build a costed plan against the actual trace shape.

    QueryPlanV2::take

    source
    fn QueryPlanV2::take(self : QueryPlanV2, count : Int) -> QueryPlanV2

    Limit the number of returned changes.

    QueryPlanV2::to_text

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

    Render the plan as a table suitable for performance diagnostics.

    QueryPlanV2::where_signal

    source
    fn QueryPlanV2::where_signal(self : QueryPlanV2, signal_id : String) -> QueryPlanV2

    Add an equality predicate for a signal identifier.

    QueryPlanV2::where_signal_matches

    source
    fn QueryPlanV2::where_signal_matches(self : QueryPlanV2, pattern : String) -> QueryPlanV2

    Add a signal glob/prefix predicate.

    QueryPlanV2::where_time

    source
    fn QueryPlanV2::where_time(self : QueryPlanV2, start : Int64?, end : Int64?) -> QueryPlanV2

    Restrict the query to an inclusive time range.

    QueryPlanV2::where_value_kind

    source
    fn QueryPlanV2::where_value_kind(self : QueryPlanV2, kind : String) -> QueryPlanV2

    Restrict the query to a textual value kind.

    QueryPredicate

    source
    pub struct QueryPredicate {
      kind : QueryPredicateKind
      field : String
      argument : String
      lower : Int64?
      upper : Int64?
    } derive(
    Debug    )

    One normalized query predicate.

    QueryPredicateKind

    source
    pub enum QueryPredicateKind {
      SignalEquals
      SignalMatches
      TimeAtLeast
      TimeAtMost
      ValueKindIs
      HasTransition
    } derive(Eq, 
    Debug    )

    Predicate operators available to the trace query planner.

    QueryResultV2

    source
    pub struct QueryResultV2 {
      trace : Trace
      scanned_rows : Int
      returned_rows : Int
      elapsed_units : Int64
      plan : QueryPlanV2
    } derive(
    Debug    )

    Materialized result from executing a query plan.

    QueryResultV2::first_change

    source
    fn QueryResultV2::first_change(self : QueryResultV2, signal_id : String) -> Change?

    Find the first returned change for a signal.

    QueryResultV2::to_json

    source
    fn QueryResultV2::to_json(self : QueryResultV2) -> String

    Render the query result as JSON metadata plus trace JSON.

    QueryWindow

    source
    pub struct QueryWindow {
      signal_id : String?
      start : Int64
      end : Int64
    } derive(Eq, 
    Debug    )

    A reusable signal/time query window.

    RegressionComparison

    source
    pub enum RegressionComparison {
      ExactValues
      TolerantTimes
      ShapeOnly
      ActivityOnly
    } derive(Eq, 
    Debug    )

    Comparison policy for regression waveform checks.

    RegressionFinding

    source
    pub struct RegressionFinding {
      signal_id : String
      time : Int64
      left : Value?
      right : Value?
      kind : String
      distance : Int64
    } derive(
    Debug    )

    One regression difference with a stable classification.

    RegressionReportV2

    source
    pub struct RegressionReportV2 {
      comparison : RegressionComparison
      findings : Array[RegressionFinding]
      compared_signals : Int
      compared_changes : Int
      passed : Bool
      score : Int
    } derive(
    Debug    )

    Regression comparison result.

    RegressionReportV2::for_signal

    source
    fn RegressionReportV2::for_signal(self : RegressionReportV2, signal_id : String) -> Array[RegressionFinding]

    Return the first finding for a signal.

    RegressionReportV2::is_success

    source
    fn RegressionReportV2::is_success(self : RegressionReportV2) -> Bool

    Return whether a comparison passed.

    RegressionReportV2::to_json

    source
    fn RegressionReportV2::to_json(self : RegressionReportV2) -> String

    Render regression summary as JSON.

    RegressionReportV2::to_text

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

    Render regression summary.

    RepairFinding

    source
    pub struct RepairFinding {
      rule : RepairRule
      level : RepairFindingLevel
      signal_id : String?
      time : Int64?
      message : String
    } derive(
    Debug    )

    One repair finding with source and resulting state.

    RepairFindingLevel

    source
    pub enum RepairFindingLevel {
      Informational
      Corrected
      Rejected
      Fatal
    } derive(Eq, 
    Debug    )

    Severity assigned to a repair finding.

    RepairOptions

    source
    pub struct RepairOptions {
      rules : Array[RepairRule]
      preserve_unknown_values : Bool
      end_time : Int64?
      deduplicate_changes : Bool
    } derive(
    Debug    )

    Repair policy for imported waveform data.

    RepairOptions::with_end_time

    source
    fn RepairOptions::with_end_time(self : RepairOptions, end_time : Int64?) -> RepairOptions

    Set the expected trace end time used by time clamping.

    RepairOptions::with_rule

    source
    fn RepairOptions::with_rule(self : RepairOptions, rule : RepairRule) -> RepairOptions

    Add one repair rule if it is not already present.

    RepairOptions::with_unknown_values

    source
    fn RepairOptions::with_unknown_values(self : RepairOptions, preserve : Bool) -> RepairOptions

    Set whether unknown/X/Z values are retained.

    RepairResult

    source
    pub struct RepairResult {
      trace : Trace
      findings : Array[RepairFinding]
      changed : Bool
      rejected_changes : Int
      repaired_changes : Int
    } derive(
    Debug    )

    Repaired trace and an audit trail of every material decision.

    RepairResult::findings_for

    source
    fn RepairResult::findings_for(self : RepairResult, rule : RepairRule) -> Array[RepairFinding]

    Return all findings for a particular rule.

    RepairResult::has_changes

    source
    fn RepairResult::has_changes(self : RepairResult) -> Bool

    Return whether any finding indicates a correction or rejection.

    RepairResult::to_json

    source
    fn RepairResult::to_json(self : RepairResult) -> String

    Render the repair result as JSON.

    RepairResult::to_text

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

    Render an audit report for terminal output.

    RepairRule

    source
    pub enum RepairRule {
      SortChanges
      RemoveUnknownSignals
      ClampNegativeTime
      ClampPastEnd
      RemoveDuplicateDeclarations
      NormalizeValues
      DropZeroWidthSignals
    } derive(Eq, 
    Debug    )

    A deterministic repair operation that can be audited before application.

    ReplayOutcome

    source
    pub enum ReplayOutcome {
      ReplayAccepted
      ReplayRejected
      ReplayIncomplete
      ReplayOutOfOrder
    } derive(Eq, 
    Debug    )

    Outcome assigned while replaying a protocol transaction stream.

    ReplayStep

    source
    pub struct ReplayStep {
      index : Int
      start : Int64
      end : Int64
      state_before : String
      state_after : String
      outcome : ReplayOutcome
      payload : Value?
      note : String
    } derive(
    Debug    )

    One replayed transaction with a state-machine sequence number.

    ReportFormat

    source
    pub enum ReportFormat {
      Text
      Markdown
      Json
      Csv
    } derive(Eq, 
    Debug    )

    Output format for machine and human reports.

    ReportOptions

    source
    pub struct ReportOptions {
      format : ReportFormat
      include_changes : Bool
      include_validation : Bool
      signal_pattern : String?
    } derive(Eq, 
    Debug    )

    Options controlling report content.

    RollingPoint

    source
    pub struct RollingPoint {
      time : Int64
      changes : Int
      active_signals : Int
    } derive(Eq, 
    Debug    )

    A rolling point for plotting change density and activity.

    Sample

    source
    pub struct Sample {
      signal_id : String
      time : Int64
      value : Value?
    } derive(Eq, 
    Debug    )

    A sampled value for a signal at an analysis timestamp.

    SampledTrace

    source
    pub struct SampledTrace {
      source_end : Int64
      config : SamplingConfig
      points : Array[SamplingPoint]
      sample_count : Int
      known_count : Int
    } derive(
    Debug    )

    A sampled trace preserving the source declaration shape.

    SampledTrace::at

    source
    fn SampledTrace::at(self : SampledTrace, time : Int64) -> Array[SamplingPoint]

    Return points for one timestamp across all signals.

    SampledTrace::timestamp_count

    source
    fn SampledTrace::timestamp_count(self : SampledTrace) -> Int

    Return the number of grid timestamps represented in the result.

    SampledTrace::to_json

    source
    fn SampledTrace::to_json(self : SampledTrace) -> String

    Render sampling metadata as JSON.

    SamplingConfig

    source
    pub struct SamplingConfig {
      start : Int64
      end : Int64
      step : Int64
      mode : SamplingMode
      include_unknown : Bool
    } derive(
    Debug    )

    Sampling configuration shared by signal and trace resampling.

    SamplingConfig::with_mode

    source
    fn SamplingConfig::with_mode(self : SamplingConfig, mode : SamplingMode) -> SamplingConfig

    Select a sampling mode.

    SamplingConfig::with_unknown

    source
    fn SamplingConfig::with_unknown(self : SamplingConfig, keep_unknown : Bool) -> SamplingConfig

    Keep or omit points whose value is unknown.

    SamplingMode

    source
    pub enum SamplingMode {
      HoldPrevious
      NearestChange
      ExactOnly
      LinearReal
    } derive(Eq, 
    Debug    )

    Value selection policy for resampling an asynchronous waveform.

    SamplingPoint

    source
    pub struct SamplingPoint {
      signal_id : String
      time : Int64
      value : Value?
      source_time : Int64?
      distance : Int64?
    } derive(
    Debug    )

    One sampled value with provenance metadata.

    SchemaConstraint

    source
    pub enum SchemaConstraint {
      ScalarOnly
      VectorOnly
      RealOnly
      WidthExact
      WidthAtMost
      KnownValuesOnly
      MonotonicTime
    } derive(Eq, 
    Debug    )

    Schema constraints inferred or supplied for a signal.

    SchemaFinding

    source
    pub struct SchemaFinding {
      signal_id : String
      constraint : SchemaConstraint
      valid : Bool
      observed : String
      expected : String
      message : String
    } derive(
    Debug    )

    Result of validating a trace against a schema.

    Signal

    source
    pub struct Signal {
      id : String
      name : String
      width : Int
      kind : String
      scope : Array[String]
    } derive(
    Debug    )

    Signal::full_path

    source
    fn Signal::full_path(self : Signal) -> String

    Return a fully-qualified path for a declaration.

    Signal::is_vector

    source
    fn Signal::is_vector(self : Signal) -> Bool

    Return whether the declaration represents a vector signal.

    Signal::scope_name

    source
    fn Signal::scope_name(self : Signal) -> String

    Return the innermost scope or an explicit top-level label.

    SignalActivity

    source
    pub struct SignalActivity {
      signal_id : String
      samples : Int
      known_samples : Int
      unknown_samples : Int
      active_time : Int64
      high_time : Int64
      low_time : Int64
      transition_count : Int
    } derive(Eq, 
    Debug    )

    A compact summary for a signal over a trace.

    SignalDependency

    source
    pub struct SignalDependency {
      source_id : String
      target_id : String
      kind : DependencyKind
      evidence_count : Int
      average_lag : Double
      confidence : Double
      first_time : Int64?
      last_time : Int64?
    } derive(
    Debug    )

    One weighted dependency hypothesis.

    SignalGroup

    source
    pub struct SignalGroup {
      path : String
      signals : Array[Signal]
    } derive(
    Debug    )

    A group of signals sharing one hierarchical scope.

    SignalOverview

    source
    pub struct SignalOverview {
      id : String
      path : String
      width : Int
      kind : String
      depth : Int
      changes : Int
      transitions : Int
      unknown : Int
    } derive(Eq, 
    Debug    )

    Public overview of one signal and its observable activity.

    SignalOverview::to_json_string

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

    Serialize a signal overview as a stable JSON object.

    SignalRun

    source
    pub struct SignalRun {
      signal_id : String
      start : Int64
      end : Int64
      token : String
      duration : Int64
      change_count : Int
    } derive(
    Debug    )

    A contiguous run of one waveform token.

    SignalSchema

    source
    pub struct SignalSchema {
      signal_id : String
      path : String
      declared_width : Int
      observed_width : Int
      kind : String
      constraints : Array[SchemaConstraint]
      samples : Int
      valid : Bool
    } derive(
    Debug    )

    A versioned signal schema entry.

    SignalStats

    source
    pub struct SignalStats {
      changes : Int
      first_time : Int64?
      last_time : Int64?
      rising_edges : Int
      falling_edges : Int
      unknown_values : Int
    } derive(
    Debug    )

    SliceContext

    source
    pub enum SliceContext {
      NoContext
      IncludeInitialValues
      IncludeFinalValues
      IncludeBothValues
    } derive(Eq, 
    Debug    )

    Context policy when slicing a trace around an interval.

    SourceStatistics

    source
    pub struct SourceStatistics {
      lines : Int
      nonempty_lines : Int
      bytes : Int
      directives : Int
      timestamps : Int
      assignments : Int
      comments : Int
    } derive(Eq, 
    Debug    )

    Text-level inventory collected before full VCD parsing.

    SpiBitOrder

    source
    pub enum SpiBitOrder {
      MsbFirst
      LsbFirst
    } derive(Eq, 
    Debug    )

    Bit ordering on the wire.

    SpiConfig

    source
    pub struct SpiConfig {
      clock : String
      chip_select : String
      mosi : String?
      miso : String?
      polarity : SpiPolarity
      phase : SpiPhase
      order : SpiBitOrder
      word_bits : Int
      active_low : Bool
    } derive(
    Debug    )

    Configuration for decoding one chip-select framed SPI stream.

    SpiConfig::with_active_low

    source
    fn SpiConfig::with_active_low(self : SpiConfig, active_low : Bool) -> SpiConfig

    Configure chip-select polarity.

    SpiConfig::with_data

    source
    fn SpiConfig::with_data(self : SpiConfig, mosi : String, miso : String?) -> SpiConfig

    Attach a MOSI and MISO pair to an SPI configuration.

    SpiConfig::with_mode

    source
    fn SpiConfig::with_mode(self : SpiConfig, polarity : SpiPolarity, phase : SpiPhase) -> SpiConfig

    Set clock polarity and sampling phase.

    SpiConfig::with_word_format

    source
    fn SpiConfig::with_word_format(self : SpiConfig, order : SpiBitOrder, word_bits : Int) -> SpiConfig

    Set wire order and word width, clamping width to a useful range.

    SpiPhase

    source
    pub enum SpiPhase {
      SampleLeading
      SampleTrailing
    } derive(Eq, 
    Debug    )

    SPI clock phase used when sampling and changing data.

    SpiPolarity

    source
    pub enum SpiPolarity {
      IdleLow
      IdleHigh
    } derive(Eq, 
    Debug    )

    SPI clock polarity used by a serial peripheral interface capture.

    SpiReport

    source
    pub struct SpiReport {
      config : SpiConfig
      words : Array[SpiWord]
      complete_words : Int
      incomplete_words : Int
      active_edges : Int
      total_bits : Int
      first_time : Int64?
      last_time : Int64?
    } derive(
    Debug    )

    Aggregate SPI decode statistics.

    SpiReport::incomplete_count

    source
    fn SpiReport::incomplete_count(self : SpiReport) -> Int

    Return the number of incomplete words in a report.

    SpiReport::to_json

    source
    fn SpiReport::to_json(self : SpiReport) -> String

    Render a report as deterministic JSON.

    SpiReport::to_text

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

    Render a report for command-line inspection.

    SpiReport::word_count

    source
    fn SpiReport::word_count(self : SpiReport) -> Int

    Return the number of complete words in a report.

    SpiWord

    source
    pub struct SpiWord {
      index : Int
      start_time : Int64
      end_time : Int64
      clock_edges : Int
      mosi_bits : String
      miso_bits : String
      mosi_value : Int64?
      miso_value : Int64?
      complete : Bool
      chip_select_active : Bool
    } derive(
    Debug    )

    One decoded SPI word, retaining both wire values and timing metadata.

    StateInterval

    source
    pub struct StateInterval {
      signal_id : String
      start : Int64
      end : Int64
      state : String
    } derive(Eq, 
    Debug    )

    A dwell interval labelled by its digital state.

    StateTransition

    source
    pub struct StateTransition {
      signal_id : String
      time : Int64
      from : String
      to : String
    } derive(Eq, 
    Debug    )

    A state change represented by the display form of a VCD value.

    StreamDecoder

    source
    pub struct StreamDecoder {
      pending : String
      record_buffer : String
      records : Int
      lines : Int
      finished : Bool
    } derive(Eq, 
    Debug    )

    Incremental decoder for chunked VCD input.

    StreamDecoder::feed

    source
    fn StreamDecoder::feed(self : StreamDecoder, chunk : String) -> Result[Array[Trace], ParseError]

    Feed a chunk and emit all complete VCD documents ending in //.

    StreamDecoder::finish

    source
    fn StreamDecoder::finish(self : StreamDecoder) -> Result[Array[Trace], ParseError]

    Finish a stream and parse its final record when present.

    StreamDecoder::line_count

    source
    fn StreamDecoder::line_count(self : StreamDecoder) -> Int

    Number of lines received by this decoder.

    StreamDecoder::record_count

    source
    fn StreamDecoder::record_count(self : StreamDecoder) -> Int

    Number of complete records emitted by this decoder.

    StreamingDigest

    source
    pub struct StreamingDigest {
      changes : Int
      signals : Array[(String, Int)]
      first_time : Int64?
      last_time : Int64?
      unknown : Int
      checksum : Int64
    } derive(Eq, 
    Debug    )

    Online digest for large traces that should not retain every change.

    StreamingDigest::push_change

    source
    fn StreamingDigest::push_change(self : StreamingDigest, change : Change) -> Unit

    Add one change to the digest in source order.

    StreamingDigest::signal_change_count

    source
    fn StreamingDigest::signal_change_count(self : StreamingDigest, signal_id : String) -> Int

    Return the count for one signal from a mutable digest.

    StreamingDigest::snapshot

    source

    Freeze the current online counters.

    SynthPattern

    source
    pub enum SynthPattern {
      ConstantLow
      ConstantHigh
      Toggle
      PulseTrain
      Counter
      RampReal
    } derive(Eq, 
    Debug    )

    Reusable stimulus patterns for deterministic waveform fixtures.

    SynthPlan

    source
    pub struct SynthPlan {
      end_time : Int64
      signals : Array[SynthSignal]
      timescale : String
    } derive(
    Debug    )

    A complete synthetic trace plan.

    SynthPlan::to_json

    source
    fn SynthPlan::to_json(self : SynthPlan) -> String

    Render a synthetic plan as JSON.

    SynthPlan::to_text

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

    Render a plan as a compact text description.

    SynthPlan::with_last_signal_seed

    source
    fn SynthPlan::with_last_signal_seed(self : SynthPlan, phase : Int64, seed : Int64) -> SynthPlan

    Add a phase offset and initial seed to the last signal.

    SynthPlan::with_signal

    source
    fn SynthPlan::with_signal(self : SynthPlan, id : String, name : String, width : Int, pattern : SynthPattern, period : Int64) -> SynthPlan

    Add a signal stimulus to a plan.

    SynthSignal

    source
    pub struct SynthSignal {
      id : String
      name : String
      width : Int
      pattern : SynthPattern
      period : Int64
      phase : Int64
      seed : Int64
    } derive(
    Debug    )

    A signal stimulus declaration.

    TimeBucket

    source
    pub struct TimeBucket {
      start : Int64
      end : Int64
      changes : Array[Change]
      signal_count : Int
    } derive(
    Debug    )

    A bounded time bucket containing changes from one or more signals.

    TimeScale

    source
    pub struct TimeScale {
      magnitude : Int
      unit : String
      femtoseconds_per_tick : Int64
      source : String
    } derive(Eq, 
    Debug    )

    A normalized VCD time scale.

    TimeScale::display

    source
    fn TimeScale::display(self : TimeScale) -> String

    Return a canonical compact spelling.

    TimeScale::from_femtoseconds

    source
    fn TimeScale::from_femtoseconds(self : TimeScale, duration : Int64) -> Int64

    Convert a femtosecond duration to the closest whole VCD tick.

    TimeScale::source_text

    source
    fn TimeScale::source_text(self : TimeScale) -> String

    Return the original spelling used for this scale.

    TimeScale::tick_femtoseconds

    source
    fn TimeScale::tick_femtoseconds(self : TimeScale) -> Int64

    Return the physical duration of a tick as femtoseconds.

    TimeScale::to_femtoseconds

    source
    fn TimeScale::to_femtoseconds(self : TimeScale, ticks : Int64) -> Int64

    Convert a VCD timestamp to femtoseconds.

    TimeStatistics

    source
    pub struct TimeStatistics {
      count : Int
      minimum : Int64?
      maximum : Int64?
      mean : Double?
      median : Double?
      spread : Double?
    } derive(Eq, 
    Debug    )

    A numeric summary of a timestamp sequence.

    TimelinePoint

    source
    pub struct TimelinePoint {
      time : Int64
      values : Array[(String, Value?)]
    } derive(Eq, 
    Debug    )

    A row in a signal timeline view.

    Trace

    source
    pub struct Trace {
      header : Header
      signals : Array[Signal]
      changes : Array[Change]
      end_time : Int64
    } derive(
    Debug    )

    Trace::change_count

    source
    fn Trace::change_count(self : Trace) -> Int

    Number of value changes in a trace.

    Trace::changes_at

    source
    fn Trace::changes_at(self : Trace, timestamp : Int64) -> Array[Change]

    Return values for all changes at a timestamp.

    Trace::duration

    source
    fn Trace::duration(self : Trace) -> Int64

    Return the observed duration in trace ticks.

    Trace::has_signal

    source
    fn Trace::has_signal(self : Trace, signal_id : String) -> Bool

    Return whether an identifier is declared by this trace.

    Trace::scope_change_counts

    source
    fn Trace::scope_change_counts(self : Trace) -> Array[(String, Int)]

    Return the number of changes in each declared scope.

    Trace::shape_digest

    source
    fn Trace::shape_digest(self : Trace) -> Int64

    Return a deterministic digest over declaration and change shape.

    Trace::signal_count

    source
    fn Trace::signal_count(self : Trace) -> Int

    Number of declarations in a trace.

    Trace::signal_paths

    source
    fn Trace::signal_paths(self : Trace) -> Array[String]

    Return all fully-qualified signal paths in declaration order.

    Trace::snapshot_at

    source
    fn Trace::snapshot_at(self : Trace, timestamp : Int64) -> Array[(String, Value?)]

    Return the latest snapshot for every declared signal.

    Trace::summary

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

    Return a stable summary line useful in CLI smoke tests.

    Trace::take_changes

    source
    fn Trace::take_changes(self : Trace, limit : Int) -> Array[Change]

    Return a bounded copy of changes in source order.

    Trace::time_scale

    source
    fn Trace::time_scale(self : Trace) -> TimeScale

    Parse the header timescale, falling back to one nanosecond for absent data.

    TraceArtifact

    source
    pub struct TraceArtifact {
      name : String
      kind : TraceArtifactKind
      format : String
      bytes : Int
      digest : Int64
      ready : Bool
    } derive(
    Debug    )

    A named artifact with a stable content digest.

    TraceArtifact::digest_matches

    source
    fn TraceArtifact::digest_matches(self : TraceArtifact, content : String) -> Bool

    Compare an artifact digest with independently generated content.

    TraceArtifact::is_ready

    source
    fn TraceArtifact::is_ready(self : TraceArtifact) -> Bool

    Return whether an artifact is usable.

    TraceArtifact::label

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

    Return a stable artifact label.

    TraceArtifact::to_json

    source
    fn TraceArtifact::to_json(self : TraceArtifact) -> String

    Render one artifact descriptor as JSON.

    TraceArtifact::to_text

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

    Render a compact artifact status line.

    TraceArtifactKind

    source
    pub enum TraceArtifactKind {
      Waveform
      Report
      CoverageData
      AssertionData
      ProtocolData
      Manifest
    } derive(Eq, 
    Debug    )

    An artifact produced by a trace analysis run.

    TraceCache

    source
    pub struct TraceCache {
      policy : TraceCachePolicy
      entries : Array[TraceCacheEntry]
      lookups : Int
      hits : Int
      misses : Int
      capacity : Int
    } derive(
    Debug    )

    Reusable cache for signal-at-time and snapshot queries.

    TraceCache::clear

    source
    fn TraceCache::clear(self : TraceCache) -> TraceCache

    Remove every cached entry.

    TraceCache::hit_ratio

    source
    fn TraceCache::hit_ratio(self : TraceCache) -> Double

    Return the cache hit ratio.

    TraceCache::invalidate_signal

    source
    fn TraceCache::invalidate_signal(self : TraceCache, signal_id : String) -> TraceCache

    Remove all entries for one signal.

    TraceCache::summary

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

    Return a stable cache summary.

    TraceCache::value_at

    source
    fn TraceCache::value_at(self : TraceCache, trace : Trace, signal_id : String, time : Int64) -> (TraceCache, Value?)

    Look up a signal value and remember the result.

    TraceCache::warm_signal

    source
    fn TraceCache::warm_signal(self : TraceCache, trace : Trace, signal_id : String) -> TraceCache

    Precompute a cache for every change timestamp.

    TraceCacheEntry

    source
    pub struct TraceCacheEntry {
      signal_id : String
      time : Int64
      value : Value?
      source_time : Int64?
      hits : Int
    } derive(
    Debug    )

    A cached value lookup with source provenance.

    TraceCachePolicy

    source
    pub enum TraceCachePolicy {
      NoCache
      LastValue
      SignalSnapshots
      WindowResults
    } derive(Eq, 
    Debug    )

    Cache policy for repeated waveform queries.

    TraceCatalogItem

    source
    pub struct TraceCatalogItem {
      name : String
      category : String
      description : String
      signal_count : Int
      change_count : Int
      duration : Int64
      tags : Array[String]
      quality : Int
    } derive(
    Debug    )

    A user-facing catalog entry for a waveform artifact.

    TraceCatalogV2

    source
    pub struct TraceCatalogV2 {
      items : Array[TraceCatalogItem]
      total_signals : Int
      total_changes : Int
      total_duration : Int64
    } derive(
    Debug    )

    A catalog assembled from one or more analyzed traces.

    TraceCatalogV2::add

    source

    Add an item to a catalog.

    TraceCatalogV2::best

    source

    Return the highest-quality artifact.

    TraceCatalogV2::category

    source
    fn TraceCatalogV2::category(self : TraceCatalogV2, category : String) -> Array[TraceCatalogItem]

    Find catalog items by category.

    TraceCatalogV2::tagged

    source
    fn TraceCatalogV2::tagged(self : TraceCatalogV2, tag : String) -> Array[TraceCatalogItem]

    Find catalog items containing a tag.

    TraceCatalogV2::to_json

    source
    fn TraceCatalogV2::to_json(self : TraceCatalogV2) -> String

    Render catalog metadata as JSON.

    TraceCatalogV2::to_text

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

    Render catalog totals for terminal output.

    TraceCheckpoint

    source
    pub struct TraceCheckpoint {
      name : String
      time : Int64
      digest : Int64
      samples : Array[Sample]
      change_count : Int
      signal_count : Int
    } derive(
    Debug    )

    A named analysis checkpoint at a simulation timestamp.

    TraceDiagnostic

    source
    pub struct TraceDiagnostic {
      severity : String
      code : String
      signal_id : String?
      time : Int64?
      message : String
    } derive(Eq, 
    Debug    )

    A detailed diagnostic emitted by deep waveform validation.

    TraceDifference

    source
    pub struct TraceDifference {
      signal_id : String
      time : Int64
      left : Value?
      right : Value?
      kind : String
    } derive(Eq, 
    Debug    )

    A difference between two traces with the same signal identifier.

    TraceDistribution

    source
    pub struct TraceDistribution {
      signal_id : String
      sample_count : Int
      distinct_tokens : Int
      minimum_run : Int64?
      maximum_run : Int64?
      mean_run : Double?
      median_run : Int64?
      p95_run : Int64?
      entropy : Double
      transition_rate : Double
    } derive(
    Debug    )

    Distribution statistics for one signal.

    TraceDistribution::to_text

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

    Render one distribution in a compact text line.

    TraceIndex

    source
    pub struct TraceIndex {
      signal_ids : Array[String]
      offsets : Array[Int]
      counts : Array[Int]
      change_positions : Array[Int]
    } derive(Eq, 
    Debug    )

    A reusable time index for fast signal-local queries.

    TraceIndex::between

    source
    fn TraceIndex::between(self : TraceIndex, trace : Trace, signal_id : String, start~ : Int64, end~ : Int64) -> Array[Change]

    Return indexed changes in an inclusive time window.

    TraceIndex::change_count

    source
    fn TraceIndex::change_count(self : TraceIndex, signal_id : String) -> Int

    Return the number of changes indexed for a signal.

    TraceIndex::changes

    source
    fn TraceIndex::changes(self : TraceIndex, trace : Trace, signal_id : String) -> Array[Change]

    Return indexed changes in source order.

    TraceIndex::first_time

    source
    fn TraceIndex::first_time(self : TraceIndex, trace : Trace, signal_id : String) -> Int64?

    Return the first indexed timestamp for a signal.

    TraceIndex::is_consistent

    source
    fn TraceIndex::is_consistent(self : TraceIndex, trace : Trace) -> Bool

    Verify that every indexed position points to the requested signal.

    TraceIndex::last_time

    source
    fn TraceIndex::last_time(self : TraceIndex, trace : Trace, signal_id : String) -> Int64?

    Return the last indexed timestamp for a signal.

    TraceIndex::lookup

    source
    fn TraceIndex::lookup(self : TraceIndex, signal_id : String) -> Int?

    Return the index position for a signal identifier, if present.

    TraceIndex::positions

    source
    fn TraceIndex::positions(self : TraceIndex, signal_id : String) -> Array[Int]

    Return the original change positions for a signal.

    TraceIndex::signal_count

    source
    fn TraceIndex::signal_count(self : TraceIndex) -> Int

    Return the number of indexed signal identifiers.

    TraceIndex::value_at

    source
    fn TraceIndex::value_at(self : TraceIndex, trace : Trace, signal_id : String, timestamp : Int64) -> Value?

    Return the indexed value at or before a timestamp.

    TraceManifest

    source
    pub struct TraceManifest {
      name : String
      format : String
      timescale : String?
      end_time : Int64
      signal_count : Int
      change_count : Int
      shape_digest : Int64
      content_digest : Int64
      validated : Bool
      tags : Array[String]
    } derive(
    Debug    )

    A reproducibility manifest for an imported waveform.

    TraceManifest::to_json

    source
    fn TraceManifest::to_json(self : TraceManifest) -> String

    Export a manifest as JSON.

    TraceManifest::to_text

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

    Return a stable manifest line for logs.

    TraceOverview

    source
    pub struct TraceOverview {
      signal_count : Int
      change_count : Int
      end_time : Int64
      maximum_depth : Int
      valid : Bool
      diagnostics : Int
    } derive(Eq, 
    Debug    )

    Public overview of a complete trace.

    TraceOverview::to_json_string

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

    Serialize a trace overview as a stable JSON object.

    TracePackage

    source
    pub struct TracePackage {
      descriptor : TracePackageDescriptor
      manifest : TraceManifest
      readme : String
    } derive(
    Debug    )

    A package descriptor plus its trace manifest.

    TracePackage::compatible

    source
    fn TracePackage::compatible(self : TracePackage, trace : Trace) -> Bool

    Check package compatibility with the current trace shape.

    TracePackage::supports

    source
    fn TracePackage::supports(self : TracePackage, capability : String) -> Bool

    Return whether a capability is advertised.

    TracePackage::to_json

    source
    fn TracePackage::to_json(self : TracePackage) -> String

    Render package metadata as JSON.

    TracePackage::to_text

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

    Render package metadata for terminal output.

    TracePackageDescriptor

    source
    pub struct TracePackageDescriptor {
      name : String
      version : String
      schema_version : String
      capabilities : Array[String]
      dependencies : Array[String]
      reproducible : Bool
    } derive(
    Debug    )

    A portable package descriptor for a trace analysis artifact.

    TracePatch

    source
    pub struct TracePatch {
      source : String
      offset : Int64
      start : Int64
      end : Int64
      changes : Array[Change]
      renamed_signals : Int
    } derive(
    Debug    )

    A trace patch with a source label for audit logs.

    TracePatch::contains

    source
    fn TracePatch::contains(self : TracePatch, time : Int64) -> Bool

    Return whether a patch contains a timestamp.

    TracePipeline

    source
    pub struct TracePipeline {
      source : SourceStatistics
      trace : Trace?
      results : Array[PipelineResult]
    } derive(
    Debug    )

    Complete result of the high-level processing pipeline.

    TracePipeline::failed_stages

    source
    fn TracePipeline::failed_stages(self : TracePipeline) -> Int

    Return the number of pipeline stages that failed.

    TracePipeline::is_success

    source
    fn TracePipeline::is_success(self : TracePipeline) -> Bool

    Return whether all completed pipeline stages passed.

    TracePipeline::passed_stages

    source
    fn TracePipeline::passed_stages(self : TracePipeline) -> Int

    Return the number of pipeline stages that passed.

    TracePipeline::successful_trace

    source
    fn TracePipeline::successful_trace(self : TracePipeline) -> Trace?

    Return the parsed trace when every required stage passed.

    TracePipeline::to_csv

    source
    fn TracePipeline::to_csv(self : TracePipeline) -> String

    Render pipeline stages as CSV.

    TracePipeline::to_json

    source
    fn TracePipeline::to_json(self : TracePipeline) -> String

    Render a pipeline result as JSON.

    TracePipeline::to_text

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

    Render a pipeline result as readable text.

    TraceProfile

    source
    pub struct TraceProfile {
      trace_end : Int64
      signal_count : Int
      metrics : Array[ProfileMetric]
      quality : Int
    } derive(
    Debug    )

    A complete profile for one trace.

    TraceProfile::for_signal

    source
    fn TraceProfile::for_signal(self : TraceProfile, signal_id : String) -> Array[ProfileMetric]

    Return metrics for one signal.

    TraceProfile::metric

    source
    fn TraceProfile::metric(self : TraceProfile, signal_id : String, kind : ProfileMetricKind) -> ProfileMetric?

    Return a metric by signal and kind.

    TraceProfile::to_json

    source
    fn TraceProfile::to_json(self : TraceProfile) -> String

    Render profile metrics as JSON.

    TraceProfile::to_text

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

    Render profile summary.

    TraceSchemaReport

    source
    pub struct TraceSchemaReport {
      version : String
      entries : Array[SignalSchema]
      findings : Array[SchemaFinding]
      valid : Bool
    } derive(
    Debug    )

    A schema snapshot and validation findings.

    TraceSchemaReport::find

    source
    fn TraceSchemaReport::find(self : TraceSchemaReport, signal_id : String) -> SignalSchema?

    Return a schema entry by signal identifier.

    TraceSchemaReport::to_json

    source
    fn TraceSchemaReport::to_json(self : TraceSchemaReport) -> String

    Render schema metadata as JSON.

    TraceSchemaReport::to_text

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

    Render a schema report as a compact text summary.

    TraceSchemaReport::violation_count

    source
    fn TraceSchemaReport::violation_count(self : TraceSchemaReport) -> Int

    Return the number of schema violations.

    TraceSelection

    source
    pub struct TraceSelection {
      pattern : String?
      start : Int64
      end : Int64
      include_empty_signals : Bool
    } derive(Eq, 
    Debug    )

    A signal/time selection used to derive a smaller trace.

    TraceSlice

    source
    pub struct TraceSlice {
      name : String
      trace : Trace
      source_start : Int64
      source_end : Int64
      before_count : Int
      retained_count : Int
      after_count : Int
    } derive(
    Debug    )

    A slice and its provenance metadata.

    TraceSlice::is_empty

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

    Return whether a slice retained at least one source change.

    TraceSlice::to_json

    source
    fn TraceSlice::to_json(self : TraceSlice) -> String

    Render slice metadata as JSON.

    TraceSliceRequest

    source
    pub struct TraceSliceRequest {
      name : String
      start : Int64
      end : Int64
      signal_ids : Array[String]
      context : SliceContext
      keep_empty : Bool
    } derive(
    Debug    )

    A named slice request suitable for batch analysis.

    TraceSliceRequest::with_context

    source
    fn TraceSliceRequest::with_context(self : TraceSliceRequest, context : SliceContext) -> TraceSliceRequest

    Set context policy.

    TraceSliceRequest::with_empty

    source
    fn TraceSliceRequest::with_empty(self : TraceSliceRequest, keep_empty : Bool) -> TraceSliceRequest

    Include or omit empty signal declarations.

    TraceSliceRequest::with_signals

    source
    fn TraceSliceRequest::with_signals(self : TraceSliceRequest, signal_ids : Array[String]) -> TraceSliceRequest

    Select signal identifiers for a slice.

    TraceWindow

    source
    pub struct TraceWindow {
      index : Int
      start : Int64
      end : Int64
      changes : Array[Change]
      signal_count : Int
      active_signals : Int
      transition_count : Int
    } derive(
    Debug    )

    A bounded view of a trace. The source trace remains unchanged.

    TraceWindow::change_count

    source
    fn TraceWindow::change_count(self : TraceWindow) -> Int

    Return the number of transitions in a window.

    TraceWindow::contains

    source
    fn TraceWindow::contains(self : TraceWindow, time : Int64) -> Bool

    Return whether a timestamp belongs to the inclusive window range.

    TraceWindow::copy_changes

    source
    fn TraceWindow::copy_changes(self : TraceWindow) -> Array[Change]

    Return the window's changes as a defensive copy.

    TraceWindow::duration

    source
    fn TraceWindow::duration(self : TraceWindow) -> Int64

    Return the inclusive duration represented by a window.

    TraceWindow::label

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

    Return a compact window label suitable for logs and CSV files.

    TraceWindow::signal_ids

    source
    fn TraceWindow::signal_ids(self : TraceWindow) -> Array[String]

    Return a stable list of identifiers active in a window.

    TriggerCondition

    source
    pub enum TriggerCondition {
      AnyChange
      ScalarLevel(Char)
      RisingEdge
      FallingEdge
      UnknownValue
      ExactValue(Value)
    } derive(Eq, 
    Debug    )

    A trigger condition used by waveform regression checks.

    TriggerHit

    source
    pub struct TriggerHit {
      signal_id : String
      time : Int64
      value : Value
      condition : String
    } derive(Eq, 
    Debug    )

    A timestamp at which a trigger condition matched.

    UartConfig

    source
    pub struct UartConfig {
      signal_id : String
      bit_period : Int64
      data_bits : Int
      stop_bits : Int
      parity : UartParity
      idle_high : Bool
      sample_offset : Int64
      lsb_first : Bool
    } derive(Eq, 
    Debug    )

    Sampling configuration for an asynchronous serial line.

    UartConfig::with_data_bits

    source
    fn UartConfig::with_data_bits(self : UartConfig, data_bits : Int) -> UartConfig

    Update the data width while keeping timing parameters intact.

    UartConfig::with_parity

    source
    fn UartConfig::with_parity(self : UartConfig, parity : UartParity) -> UartConfig

    Update parity handling.

    UartConfig::with_sample_offset

    source
    fn UartConfig::with_sample_offset(self : UartConfig, offset : Int64) -> UartConfig

    Update the sample offset within the first data bit.

    UartConfig::with_stop_bits

    source
    fn UartConfig::with_stop_bits(self : UartConfig, stop_bits : Int) -> UartConfig

    Update stop-bit count.

    UartFrame

    source
    pub struct UartFrame {
      index : Int
      start : Int64
      end : Int64
      value : Int64
      data_bits : String
      parity_bit : Char?
      stop_ok : Bool
      parity_ok : Bool
      framing_ok : Bool
      error : String?
    } derive(Eq, 
    Debug    )

    A decoded UART frame and its validation status.

    UartParity

    source
    pub enum UartParity {
      NoParity
      EvenParity
      OddParity
    } derive(Eq, 
    Debug    )

    UART parity modes supported by the waveform decoder.

    UartReport

    source
    pub struct UartReport {
      signal_id : String
      frames : Int
      valid_frames : Int
      invalid_frames : Int
      parity_errors : Int
      framing_errors : Int
      minimum_gap : Int64?
      maximum_gap : Int64?
      mean_gap : Double?
      bytes_per_time : Double
    } derive(Eq, 
    Debug    )

    Aggregate UART decode metrics.

    UartReport::to_json

    source
    fn UartReport::to_json(self : UartReport) -> String

    Render a UART report as JSON.

    UartReport::to_text

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

    Render a UART report as text.

    ValidationIssue

    source
    pub enum ValidationIssue {
      MissingDefinitions
      DuplicateIdentifier(String)
      UnknownIdentifier(String)
      NonMonotonicTime(Int64)
      InvalidWidth(String)
    } derive(Eq, 
    Debug    )

    ValidationSummary

    source
    pub struct ValidationSummary {
      diagnostics : Int
      errors : Int
      warnings : Int
      unknown_changes : Int
      duplicate_ids : Int
      width_mismatches : Int
      monotonic_timestamps : Bool
      score : Int
    } derive(Eq, 
    Debug    )

    Aggregate validation counters for dashboards and CI gates.

    Value

    source
    pub enum Value {
      Scalar(Char)
      Vector(String)
      Real(Double)
    } derive(Eq, 
    Debug    )

    Value::as_scalar

    source
    fn Value::as_scalar(self : Value) -> Char?

    Return the scalar character when the value is a scalar.

    Value::bits

    source
    fn Value::bits(self : Value) -> Array[LogicBit]

    Expand a value into classified bits, preserving vector order.

    Value::display

    source
    fn Value::display(self : Value) -> String

    Return a stable human-readable representation of any VCD value.

    Value::is_unknown

    source
    fn Value::is_unknown(self : Value) -> Bool

    Return whether a value contains an unknown or high-impedance bit.

    Value::kind_name

    source
    fn Value::kind_name(self : Value) -> String

    Return the semantic kind of a value for table-oriented consumers.

    Value::normalized

    source
    fn Value::normalized(self : Value) -> Value

    Return a canonical lowercase representation without changing numeric data.

    Value::text

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

    Return a stable textual value suitable for logs and CSV.

    Value::to_int

    source
    fn Value::to_int(self : Value) -> Int64?

    Convert a binary VCD value to an integer, returning None for unknown bits.

    Value::width

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

    Return the number of bits represented by a VCD value.

    ValueDistribution

    source
    pub struct ValueDistribution {
      signal_id : String
      total : Int
      scalar : Int
      vector : Int
      real : Int
      zero : Int
      one : Int
      unknown : Int
      high_impedance : Int
    } derive(Eq, 
    Debug    )

    Counts of observable value classes for one signal.

    ValueInterval

    source
    pub struct ValueInterval {
      signal_id : String
      start : Int64
      end : Int64
      value : Value
    } derive(Eq, 
    Debug    )

    A stable interval occupied by one scalar value.

    ValueKind

    source
    pub enum ValueKind {
      ScalarKind
      VectorKind
      RealKind
    } derive(Eq, 
    Debug    )

    Canonical encoding class for a VCD value.

    WaveformAssertion

    source
    pub struct WaveformAssertion {
      name : String
      kind : AssertionKind
      signal_id : String
      companion_id : String?
      start : Int64
      end : Int64
      limit : Int64
      lower : Int64
      upper : Int64
      severity : AssertionSeverity
      message : String
    } derive(Eq, 
    Debug    )

    A serializable assertion definition.

    WindowMetric

    source
    pub struct WindowMetric {
      index : Int
      start : Int64
      end : Int64
      duration : Int64
      changes : Int
      active_signals : Int
      density : Double
      first_change : Int64?
      last_change : Int64?
    } derive(Eq, 
    Debug    )

    Counters used to compare windows without serializing every change.

    WindowPlan

    source
    pub struct WindowPlan {
      source_start : Int64
      source_end : Int64
      windows : Array[TraceWindow]
      policy : WindowPolicy
      dropped_changes : Int
    } derive(
    Debug    )

    A complete segmentation plan with stable source bounds.

    WindowPlan::covers_changes

    source
    fn WindowPlan::covers_changes(self : WindowPlan, trace : Trace) -> Bool

    Return whether the windows cover every source change at least once.

    WindowPlan::empty_count

    source
    fn WindowPlan::empty_count(self : WindowPlan) -> Int

    Return the number of windows that contain no changes.

    WindowPlan::is_monotonic

    source
    fn WindowPlan::is_monotonic(self : WindowPlan) -> Bool

    Return whether window starts are monotonically increasing.

    WindowPlan::retained_changes

    source
    fn WindowPlan::retained_changes(self : WindowPlan) -> Int

    Return the total number of retained change records.

    WindowPolicy

    source
    pub enum WindowPolicy {
      FixedWidth
      FixedCount
      Overlapping
      ChangeDriven
      SignalActivity
    } derive(Eq, 
    Debug    )

    Policies used when a trace is divided into analysis windows.

    WindowSpec

    source
    pub struct WindowSpec {
      policy : WindowPolicy
      width : Int64
      count : Int
      overlap : Int64
      minimum_changes : Int
      include_empty : Bool
    } derive(Eq, 
    Debug    )

    A request for deterministic trace segmentation.

    WindowSummary

    source
    pub struct WindowSummary {
      start : Int64
      end : Int64
      changes : Int
      signals : Int
      rising_edges : Int
      falling_edges : Int
      unknown_changes : Int
    } derive(Eq, 
    Debug    )

    Summary for one inclusive analysis window.

    WorkflowOptions

    source
    pub struct WorkflowOptions {
      window_width : Int64
      coverage_signal_ids : Array[String]
      assertions : Array[WaveformAssertion]
      protocol_channels : Array[ProtocolChannel]
      stop_on_failure : Bool
    } derive(
    Debug    )

    Configuration for a repeatable analysis workflow.

    WorkflowOptions::with_assertion

    source
    fn WorkflowOptions::with_assertion(self : WorkflowOptions, assertion : WaveformAssertion) -> WorkflowOptions

    Add an assertion to the workflow.

    WorkflowOptions::with_coverage_signal

    source
    fn WorkflowOptions::with_coverage_signal(self : WorkflowOptions, signal_id : String) -> WorkflowOptions

    Add a signal to coverage analysis.

    WorkflowOptions::with_protocol

    source
    fn WorkflowOptions::with_protocol(self : WorkflowOptions, channel : ProtocolChannel) -> WorkflowOptions

    Add a protocol channel to the workflow.

    WorkflowOptions::with_window_width

    source
    fn WorkflowOptions::with_window_width(self : WorkflowOptions, width : Int64) -> WorkflowOptions

    Set analysis window width.

    WorkflowStage

    source
    pub enum WorkflowStage {
      InputValidation
      IndexBuild
      WindowSegmentation
      CoverageAnalysis
      AssertionAnalysis
      ProtocolAnalysis
      ReportAssembly
    } derive(Eq, 
    Debug    )

    Stages of the reusable waveform analysis workflow.

    WorkflowStageResult

    source
    pub struct WorkflowStageResult {
      stage : WorkflowStage
      status : WorkflowStageStatus
      duration_units : Int64
      rows : Int
      message : String
    } derive(
    Debug    )

    Result of one workflow stage.

    WorkflowStageStatus

    source
    pub enum WorkflowStageStatus {
      StagePending
      StageRunning
      StagePassed
      StageSkipped
      StageFailed
    } derive(Eq, 
    Debug    )

    Status of one workflow stage.

    active_signal_counts

    source
    fn active_signal_counts(trace : Trace) -> Array[(Int64, Int)]

    Count how many declared signals changed at each timestamp.

    active_windows

    source
    fn active_windows(trace : Trace, signal_id : String, width : Int64) -> Array[(Int64, Int64)]

    Return windows where a signal has at least one transition.

    activity

    source
    fn activity(trace : Trace, signal_id : String) -> SignalActivity

    Compute time-weighted activity for one signal.

    activity_coverage_bins

    source
    fn activity_coverage_bins(trace : Trace, bucket_width : Int64, threshold : Int) -> Array[CoverageBin]

    Build activity bins for each signal based on change density.

    activity_distance

    source
    fn activity_distance(trace : Trace, left_id : String, right_id : String) -> Int64

    Compare activity between two signals.

    activity_segment_options

    source
    fn activity_segment_options(bucket_width : Int64) -> ActivitySegmentOptions

    Create an activity segmentation policy.

    activity_segments

    source
    fn activity_segments(trace : Trace, options : ActivitySegmentOptions) -> Array[ActivitySegment]

    Divide a trace into fixed activity segments.

    activity_segments_csv

    source
    fn activity_segments_csv(segments : Array[ActivitySegment]) -> String

    Export activity segments as CSV.

    align_traces

    source
    fn align_traces(left : Trace, right : Trace, left_marker : String?, right_marker : String?, mode : AlignmentMode) -> AlignmentResult

    Shift two traces into one comparable time domain.

    alignment_mode_catalog

    source
    fn alignment_mode_catalog() -> Array[AlignmentMode]

    List alignment modes.

    alignment_mode_name

    source
    fn alignment_mode_name(value : AlignmentMode) -> String

    Name an alignment mode.

    all_activity

    source
    fn all_activity(trace : Trace) -> Array[SignalActivity]

    Compute activity summaries for all signals.

    all_edges

    source
    fn all_edges(trace : Trace) -> Array[(String, Array[EdgeEvent])]

    Extract all scalar transitions, grouped by signal identifier.

    all_merge_selection

    source
    fn all_merge_selection() -> MergeSelection

    Return a selection that includes every signal.

    all_signal_distributions

    source
    fn all_signal_distributions(trace : Trace) -> Array[TraceDistribution]

    Calculate distributions for every declared signal.

    all_stats

    source
    fn all_stats(trace : Trace) -> Array[(String, SignalStats)]

    analysis_document

    source
    fn analysis_document(title : String) -> AnalysisDocument

    Start an empty analysis document.

    analysis_metric_count

    source
    fn analysis_metric_count(metrics : Array[AnalysisMetric]) -> Int

    Return the number of metrics in a catalog.

    analysis_metrics_csv

    source
    fn analysis_metrics_csv(metrics : Array[AnalysisMetric]) -> String

    Render metrics as a stable CSV document.

    analysis_metrics_json

    source
    fn analysis_metrics_json(metrics : Array[AnalysisMetric]) -> String

    Render metrics as a compact JSON array.

    analysis_safe

    source
    fn analysis_safe(trace : Trace) -> Bool

    Return whether a trace is safe for bounded analysis.

    any_change_trigger

    source
    fn any_change_trigger() -> TriggerCondition

    Construct an any-change trigger.

    apb_config

    source
    fn apb_config(pclk : String, psel : String, penable : String, pwrite : String, paddr : String) -> ApbConfig

    Construct an APB4 mapping.

    apb_decode

    source
    fn apb_decode(trace : Trace, config : ApbConfig) -> Array[ApbTransfer]

    Decode APB transfers by observing setup, access, and completion phases.

    apb_report

    source
    fn apb_report(trace : Trace, config : ApbConfig) -> ApbReport

    Calculate APB statistics.

    apb_transfers_csv

    source
    fn apb_transfers_csv(transfers : Array[ApbTransfer]) -> String

    Render APB transfers as CSV.

    append_derived_signal

    source
    fn append_derived_signal(trace : Trace, spec : DerivedSignalSpec) -> Trace

    Build a trace with one calculated declaration and only changed values.

    append_derived_signals

    source
    fn append_derived_signals(trace : Trace, specs : Array[DerivedSignalSpec]) -> Trace

    Append multiple calculated signals in declaration order.

    apply_cli_window

    source
    fn apply_cli_window(trace : Trace, options : CliOptions) -> Trace

    Select changes according to the parsed time and signal filters.

    artifact_default_format

    source
    fn artifact_default_format(kind : TraceArtifactKind) -> String

    Return a canonical format label for an artifact kind.

    artifact_format_supported

    source
    fn artifact_format_supported(format : String) -> Bool

    Check whether an artifact uses a supported interchange format.

    artifact_kinds

    source
    fn artifact_kinds(items : Array[TraceArtifact]) -> Array[TraceArtifactKind]

    Return the artifact kinds represented by a collection.

    artifact_publication_manifest

    source
    fn artifact_publication_manifest(items : Array[TraceArtifact]) -> String

    Render a publication manifest from ready artifacts.

    artifact_uses_canonical_format

    source
    fn artifact_uses_canonical_format(item : TraceArtifact) -> Bool

    Validate the canonical format selected for an artifact kind.

    artifacts_complete

    source
    fn artifacts_complete(items : Array[TraceArtifact], required : Array[TraceArtifactKind]) -> Bool

    Return whether every required artifact is ready.

    assert_known

    source
    fn assert_known(name : String, signal_id : String, start : Int64, end : Int64, severity : AssertionSeverity) -> WaveformAssertion

    Create a known-value assertion.

    assert_minimum_gap

    source
    fn assert_minimum_gap(name : String, signal_id : String, gap : Int64, severity : AssertionSeverity) -> WaveformAssertion

    Create a minimum gap assertion between consecutive scalar transitions.

    assert_minimum_pulse

    source
    fn assert_minimum_pulse(name : String, signal_id : String, width : Int64, severity : AssertionSeverity) -> WaveformAssertion

    Create a minimum pulse-width assertion for a scalar signal.

    assert_monotonic

    source
    fn assert_monotonic(name : String, signal_id : String, severity : AssertionSeverity) -> WaveformAssertion

    Create a monotonic unsigned-value assertion.

    assert_no_activity

    source
    fn assert_no_activity(name : String, signal_id : String, start : Int64, end : Int64, severity : AssertionSeverity) -> WaveformAssertion

    Create an idle-window assertion.

    assert_one_hot

    source
    fn assert_one_hot(name : String, signal_id : String, severity : AssertionSeverity) -> WaveformAssertion

    Create a one-hot assertion for a vector signal.

    assert_response_within

    source
    fn assert_response_within(name : String, request_id : String, response_id : String, limit : Int64, severity : AssertionSeverity) -> WaveformAssertion

    Create a request/response latency assertion.

    assert_stable

    source
    fn assert_stable(name : String, signal_id : String, start : Int64, end : Int64, severity : AssertionSeverity) -> WaveformAssertion

    Create a stability assertion over an inclusive time range.

    assert_unsigned_range

    source
    fn assert_unsigned_range(name : String, signal_id : String, lower : Int64, upper : Int64, severity : AssertionSeverity) -> WaveformAssertion

    Create an unsigned integer range assertion.

    assertion_kind_catalog

    source
    fn assertion_kind_catalog() -> Array[AssertionKind]

    Return all assertion kinds for configuration UIs.

    assertion_kind_name

    source
    fn assertion_kind_name(value : AssertionKind) -> String

    Return the canonical assertion kind name.

    assertion_severity_catalog

    source
    fn assertion_severity_catalog() -> Array[AssertionSeverity]

    Return all assertion severities for report configuration.

    assertion_severity_name

    source
    fn assertion_severity_name(value : AssertionSeverity) -> String

    Return the canonical severity name.

    benchmark_analysis

    source
    fn benchmark_analysis(trace : Trace, iterations : Int) -> BenchmarkResult

    Run repeated edge and state analysis over a parsed fixture.

    benchmark_checksum

    source
    fn benchmark_checksum(suite : BenchmarkSuite) -> Int64

    Sum the stable checksums of all operations in a suite.

    benchmark_density

    source
    fn benchmark_density(result : BenchmarkResult) -> Double

    Calculate observed changes per parsed trace for a result.

    benchmark_parse

    source
    fn benchmark_parse(input : String, iterations : Int) -> BenchmarkResult

    Run repeated parser passes and count observable outputs.

    benchmark_queries

    source
    fn benchmark_queries(trace : Trace, iterations : Int) -> BenchmarkResult

    Run repeated indexed queries over a parsed fixture.

    benchmark_result_json

    source
    fn benchmark_result_json(result : BenchmarkResult) -> String

    Render one result as a machine-readable JSON object.

    benchmark_rows

    source
    fn benchmark_rows(suite : BenchmarkSuite) -> Array[String]

    Return a compact CSV row for every benchmark operation.

    benchmark_suite

    source
    fn benchmark_suite(signal_count : Int, time_count : Int, iterations : Int) -> BenchmarkSuite

    Run the complete deterministic benchmark suite.

    benchmark_suite_compatible

    source
    fn benchmark_suite_compatible(left : BenchmarkSuite, right : BenchmarkSuite) -> Bool

    Compare two benchmark runs by stable checksum and operation names.

    benchmark_suite_json

    source
    fn benchmark_suite_json(suite : BenchmarkSuite) -> String

    Render a complete benchmark suite as deterministic JSON.

    benchmark_suite_markdown

    source
    fn benchmark_suite_markdown(suite : BenchmarkSuite) -> String

    Render benchmark results as a Markdown table suitable for reports.

    benchmark_suite_text

    source
    fn benchmark_suite_text(suite : BenchmarkSuite) -> String

    Render one benchmark suite as a readable terminal report.

    benchmark_verdict

    source
    fn benchmark_verdict(suite : BenchmarkSuite) -> String

    Produce a human-readable benchmark verdict for CI logs.

    bit_statistics

    source
    fn bit_statistics(trace : Trace, signal_id : String) -> BitStatistics

    Count every observed bit in scalar and vector values.

    bit_statistics_json

    source
    fn bit_statistics_json(stats : BitStatistics) -> String

    Render bit statistics as JSON.

    bit_statistics_line

    source
    fn bit_statistics_line(stats : BitStatistics) -> String

    Render bit statistics as a stable line.

    bits_to_string

    source
    fn bits_to_string(bits : Array[LogicBit]) -> String

    Convert classified bits to a canonical vector string.

    bucket_changes

    source
    fn bucket_changes(trace : Trace, bucket_width : Int64) -> Array[TimeBucket]

    Partition events into equal-width timestamp buckets.

    bucket_first_changes

    source
    fn bucket_first_changes(trace : Trace, bucket_width : Int64) -> Array[Change]

    Return the first event in each non-empty time bucket.

    build_index

    source
    fn build_index(trace : Trace) -> TraceIndex

    Build a signal-local position index without copying waveform values.

    build_trace_profile

    source
    fn build_trace_profile(trace : Trace) -> TraceProfile

    Build signal profiles from the existing analysis primitives.

    bus_snapshot

    source
    fn bus_snapshot(trace : Trace, signal_ids : Array[String], timestamp : Int64) -> BusSnapshot

    Assemble a bus from signals ordered from most to least significant.

    bus_snapshots

    source
    fn bus_snapshots(trace : Trace, signal_ids : Array[String]) -> Array[BusSnapshot]

    Assemble bus snapshots at every trace timestamp where a member changes.

    busiest_activity_segment

    source
    fn busiest_activity_segment(segments : Array[ActivitySegment]) -> ActivitySegment?

    Return the busiest segment, if the trace contains one.

    busiest_event_window

    source
    fn busiest_event_window(metrics : Array[EventWindowMetric]) -> EventWindowMetric?

    Return the busiest window by change count.

    canonical_round_trip

    source
    fn canonical_round_trip(trace : Trace) -> Trace?

    Serialize, parse, and return the canonical trace when possible.

    canonical_value_text

    source
    fn canonical_value_text(value : Value) -> String

    Return a VCD-compatible string with lower-case state markers.

    cdc_observations

    source
    fn cdc_observations(trace : Trace, source_id : String, destination_id : String, guard_band : Int64) -> Array[CdcObservation]

    Detect destination samples that occur inside a source guard band.

    change_count_catalog

    source
    fn change_count_catalog(trace : Trace) -> Array[(String, Int)]

    Return the number of changes observed for each declared identifier.

    change_counts_by_window

    source
    fn change_counts_by_window(trace : Trace, signal_id : String, width : Int64) -> Array[(Int64, Int)]

    Count signal changes in equally sized windows.

    change_density

    source
    fn change_density(trace : Trace, bucket_width : Int64) -> Array[(Int64, Int)]

    Return the number of changes per time bucket.

    change_driven_windows

    source
    fn change_driven_windows(trace : Trace, minimum_changes : Int) -> Array[TraceWindow]

    Build windows from change density. A new window starts after enough changes.

    change_json

    source
    fn change_json(change : Change) -> String

    Encode one change as a compact JSON object.

    change_rate

    source
    fn change_rate(trace : Trace, signal_id : String) -> Double

    Count signal changes per unit of observed trace time.

    change_times

    source
    fn change_times(trace : Trace, signal_id : String) -> Array[Int64]

    Return timestamps for one signal.

    changes_after

    source
    fn changes_after(trace : Trace, signal_id : String, timestamp : Int64) -> Array[Change]

    Return changes after an exclusive timestamp.

    changes_before

    source
    fn changes_before(trace : Trace, signal_id : String, timestamp : Int64) -> Array[Change]

    Return changes before an exclusive timestamp.

    changes_between

    source
    fn changes_between(trace : Trace, signal_id : String, start~ : Int64, end~ : Int64) -> Array[Change]

    Return changes in the inclusive time window [start, end].

    changes_csv

    source
    fn changes_csv(trace : Trace, signal_id? : String) -> String

    Export signal changes as CSV for spreadsheet and plotting tools.

    changes_for_ids

    source
    fn changes_for_ids(trace : Trace, ids : Array[String]) -> Array[Change]

    Return all changes for a set of identifiers without changing trace order.

    changes_json_pretty

    source
    fn changes_json_pretty(trace : Trace, indent : String) -> String

    Render one change array as indented JSON.

    checkpoints_csv

    source
    fn checkpoints_csv(checkpoints : Array[TraceCheckpoint]) -> String

    Export checkpoints as CSV.

    checkpoints_equal

    source
    fn checkpoints_equal(left : TraceCheckpoint, right : TraceCheckpoint) -> Bool

    Return whether two checkpoints have equivalent sampled state.

    cli_options_diagnostic

    source
    fn cli_options_diagnostic(options : CliOptions) -> String

    Explain an invalid range without throwing from a command-line adapter.

    cli_options_valid

    source
    fn cli_options_valid(options : CliOptions) -> Bool

    Validate the relationship between CLI bounds before a report is run.

    cli_range

    source
    fn cli_range(options : CliOptions) -> String

    Return the selected time range in a shell-friendly representation.

    cli_report

    source
    fn cli_report(trace : Trace, options : CliOptions) -> String

    Render a trace according to CLI options.

    cli_usage

    source
    fn cli_usage() -> String

    Render concise command help for documentation and shell completion.

    clip_trace

    source
    fn clip_trace(trace : Trace, start~ : Int64, end~ : Int64) -> Trace

    Clip a trace to an inclusive time window.

    clock_config

    source
    fn clock_config(signal_id : String) -> ClockConfig

    Return a basic clock configuration.

    clock_cycles

    source
    fn clock_cycles(trace : Trace, config : ClockConfig) -> Array[ClockCycle]

    Measure cycles by matching each active edge to the next edge.

    clock_cycles_csv

    source
    fn clock_cycles_csv(cycles : Array[ClockCycle]) -> String

    Render cycle samples as CSV.

    clock_edge_times

    source
    fn clock_edge_times(trace : Trace, config : ClockConfig) -> Array[Int64]

    Extract rising-edge timestamps for a configured clock.

    clock_fixture

    source
    fn clock_fixture(period : Int, cycles : Int) -> String

    Clock fixture with stable alternating periods.

    clock_phase_offsets

    source
    fn clock_phase_offsets(trace : Trace, left_id : String, right_id : String, guard_band : Int64) -> Array[Int64]

    Compare two clocks by nearest active-edge distance.

    clock_report

    source
    fn clock_report(trace : Trace, config : ClockConfig) -> ClockReport

    Produce an aggregate clock report.

    coalesce_events

    source
    fn coalesce_events(changes : Array[Change]) -> Array[Change]

    Combine writes at the same timestamp by keeping the final write per signal.

    compact_trace

    source
    fn compact_trace(trace : Trace) -> Trace

    Remove consecutive duplicate values for each signal.

    comparable_values

    source
    fn comparable_values(left : Value?, right : Value?, ignore_unknown_case : Bool) -> Bool

    Compare two optional values while treating X and x as equivalent.

    compare_regression_v2

    source
    fn compare_regression_v2(left : Trace, right : Trace, comparison : RegressionComparison, tolerance : Int64) -> RegressionReportV2

    Compare two traces by aligned signal identifiers.

    compare_traces

    source
    fn compare_traces(left : Trace, right : Trace, options : CompareOptions) -> ComparisonSummary

    Compare all observed timestamps after nearest-sample alignment.

    comparison_passes

    source
    fn comparison_passes(summary : ComparisonSummary) -> Bool

    Return whether two traces meet the requested comparison policy.

    comparison_ratio

    source
    fn comparison_ratio(summary : ComparisonSummary) -> Double

    Return the equality ratio of two traces.

    comparison_summary_json

    source
    fn comparison_summary_json(summary : ComparisonSummary) -> String

    Render a comparison summary as JSON.

    comparison_summary_line

    source
    fn comparison_summary_line(summary : ComparisonSummary) -> String

    Render a comparison summary as a stable line.

    compatibility_label

    source
    fn compatibility_label(source : String, trace : Trace) -> String

    Return a concise compatibility label.

    compatibility_report

    source
    fn compatibility_report(source : String, trace : Trace) -> String

    Produce a stable compatibility report.

    compatibility_summary

    source
    fn compatibility_summary(source : String, trace : Trace) -> CompatibilitySummary

    Summarize syntax features found in a parsed trace and its source text.

    concatenate_traces

    source
    fn concatenate_traces(traces : Array[Trace], gap : Int64) -> Trace?

    Concatenate traces in sequence, shifting each trace after the previous end.

    correlate_rising_edges

    source
    fn correlate_rising_edges(trace : Trace, source_signal : String, target_signal : String, maximum_latency : Int64) -> Array[LatencySample]

    Match every source rising edge with the first target rising edge at or after it.

    counted_window_spec

    source
    fn counted_window_spec(count : Int) -> WindowSpec

    Build a window specification that creates exactly the requested count.

    counted_windows

    source
    fn counted_windows(trace : Trace, count : Int) -> Array[TraceWindow]

    Divide a trace into a requested number of equally sized windows.

    counter_fixture

    source
    fn counter_fixture(count : Int) -> String

    Counter-like four-bit vector fixture.

    coverage_bin

    source
    fn coverage_bin(group : String, key : String, label : String, kind : CoverageKind, target : Int) -> CoverageBin

    Create a coverage bin with a minimum target of one hit.

    coverage_kind_catalog

    source
    fn coverage_kind_catalog() -> Array[CoverageKind]

    Return every coverage dimension for report configuration UIs.

    coverage_kind_name

    source
    fn coverage_kind_name(kind : CoverageKind) -> String

    Return a stable name for a coverage dimension.

    coverage_point

    source
    fn coverage_point(group : String, key : String, time : Int64, weight : Int) -> CoveragePoint

    Construct an observation point for custom coverage adapters.

    coverage_report

    source
    fn coverage_report(name : String, trace : Trace, include_values : Bool, include_transitions : Bool, include_toggles : Bool, include_widths : Bool, include_activity : Bool) -> CoverageReport

    Assemble a report from configured coverage dimensions.

    coverage_report_from_bins

    source
    fn coverage_report_from_bins(name : String, bins : Array[CoverageBin]) -> CoverageReport

    Build a report from externally generated or merged bins.

    csv_header

    source
    fn csv_header() -> String

    Return the CSV header expected by plotting tools.

    csv_report_options

    source
    fn csv_report_options() -> ReportOptions

    Create CSV report options.

    decimate_trace

    source
    fn decimate_trace(trace : Trace, step : Int64) -> Trace

    Keep one change at every step-sized time bucket.

    declaration_compatible

    source
    fn declaration_compatible(left : Trace, right : Trace) -> Bool

    Compare only declarations and signal paths.

    declaration_manifest

    source
    fn declaration_manifest(trace : Trace) -> String

    Return all declaration paths as a newline-delimited manifest.

    decode_packet

    source
    fn decode_packet(layout : PacketLayout, time : Int64, payload : Value?) -> PacketRecord

    Decode one payload value according to a packet layout.

    decode_packets

    source
    fn decode_packets(layout : PacketLayout, payloads : Array[(Int64, Value?)]) -> Array[PacketRecord]

    Decode a sequence of packet payloads.

    decode_state

    source
    fn decode_state(value : Value, labels : Array[String]) -> String

    Decode a known integer value through an optional state label table.

    decode_value_token

    source
    fn decode_value_token(token : String, signal_id : String, time : Int64) -> Result[Change, ParseError]

    Decode a value token together with its identifier.

    decoded_states

    source
    fn decoded_states(trace : Trace, signal_id : String, labels : Array[String]) -> Array[(Int64, String)]

    Decode all observed values with a label table.

    deduplicate_trace

    source
    fn deduplicate_trace(trace : Trace) -> Trace

    Remove duplicate writes at the same signal and timestamp, keeping the last.

    deep_is_valid

    source
    fn deep_is_valid(trace : Trace) -> Bool

    Return whether deep validation reports no errors.

    deep_validate

    source
    fn deep_validate(trace : Trace) -> Array[TraceDiagnostic]

    Validate declarations, change ordering, value widths, and metadata.

    default_analysis_options

    source
    fn default_analysis_options(trace : Trace) -> AnalysisOptions

    Create deterministic analysis options for the complete trace.

    default_cli_options

    source
    fn default_cli_options() -> CliOptions

    Return conservative defaults suitable for a terminal invocation.

    default_compare_options

    source
    fn default_compare_options() -> CompareOptions

    Create strict comparison defaults.

    default_diff_options

    source
    fn default_diff_options(left : Trace, right : Trace) -> DiffOptions

    Create comparison options spanning both traces.

    default_event_filter

    source
    fn default_event_filter(trace : Trace) -> EventFilter

    Create an event filter for the complete trace.

    default_merge_options

    source
    fn default_merge_options() -> MergeOptions

    Return a default merge policy for two traces with a shared timeline.

    default_monitor_options

    source
    fn default_monitor_options() -> MonitorOptions

    Create a permissive monitor policy.

    default_repair_options

    source
    fn default_repair_options() -> RepairOptions

    Create a conservative repair policy for parser output.

    default_report_options

    source
    fn default_report_options() -> ReportOptions

    Create a complete text-report configuration.

    default_trace_package_descriptor

    source
    fn default_trace_package_descriptor() -> TracePackageDescriptor

    Create a descriptor for the built-in analysis package.

    default_window_spec

    source
    fn default_window_spec(trace : Trace) -> WindowSpec

    Return a conservative default for a trace with a useful duration.

    default_workflow_options

    source
    fn default_workflow_options() -> WorkflowOptions

    Create default options for a production trace review.

    density_report

    source
    fn density_report(trace : Trace, bucket_width : Int64) -> String

    Render a density table suitable for a CI artifact.

    dependencies_csv

    source
    fn dependencies_csv(items : Array[SignalDependency]) -> String

    Export dependencies as CSV.

    dependency_adjacency

    source
    fn dependency_adjacency(report : DependencyReport) -> Array[(String, Array[String])]

    Build an adjacency map for scheduling and visualization.

    dependency_kind_catalog

    source
    fn dependency_kind_catalog() -> Array[DependencyKind]

    List dependency categories.

    dependency_kind_name

    source
    fn dependency_kind_name(kind : DependencyKind) -> String

    Name a dependency category.

    derived_add

    source
    fn derived_add(left : DerivedExpr, right : DerivedExpr) -> DerivedExpr

    Unsigned addition expression constructor.

    derived_and

    source
    fn derived_and(left : DerivedExpr, right : DerivedExpr) -> DerivedExpr

    Bitwise AND expression constructor.

    derived_changes

    source
    fn derived_changes(trace : Trace, spec : DerivedSignalSpec) -> Array[Change]

    Return observations as a change array for a standalone pipeline stage.

    derived_concat

    source
    fn derived_concat(left : DerivedExpr, right : DerivedExpr) -> DerivedExpr

    Bus concatenation expression constructor.

    derived_edge_fall

    source
    fn derived_edge_fall(id : String) -> DerivedExpr

    derived_edge_rise

    source
    fn derived_edge_rise(id : String) -> DerivedExpr

    derived_expr_text

    source
    fn derived_expr_text(expression : DerivedExpr) -> String

    Return a textual form useful for cache keys and diagnostics.

    derived_mux

    source
    fn derived_mux(condition : DerivedExpr, when_true : DerivedExpr, when_false : DerivedExpr) -> DerivedExpr

    derived_not

    source
    fn derived_not(inner : DerivedExpr) -> DerivedExpr

    Unary expression constructor.

    derived_observations

    source
    fn derived_observations(trace : Trace, spec : DerivedSignalSpec) -> Array[DerivedObservation]

    Evaluate a derived signal at every distinct source timestamp.

    derived_operator_catalog

    source
    fn derived_operator_catalog() -> Array[String]

    Return every expression constructor used by report UIs.

    derived_or

    source
    fn derived_or(left : DerivedExpr, right : DerivedExpr) -> DerivedExpr

    Bitwise OR expression constructor.

    derived_report

    source
    fn derived_report(trace : Trace, spec : DerivedSignalSpec) -> DerivedReport

    Return a generation report for one derived signal.

    derived_sample_at

    source
    fn derived_sample_at(inner : DerivedExpr, offset : Int64) -> DerivedExpr

    derived_scalar

    source
    fn derived_scalar(value : Char) -> DerivedExpr

    Return a constant scalar expression.

    derived_shift_left

    source
    fn derived_shift_left(inner : DerivedExpr, amount : Int) -> DerivedExpr

    derived_shift_right

    source
    fn derived_shift_right(inner : DerivedExpr, amount : Int) -> DerivedExpr

    derived_signal

    source
    fn derived_signal(id : String) -> DerivedExpr

    Return a reference expression.

    derived_spec

    source
    fn derived_spec(id : String, name : String, width : Int, expr : DerivedExpr) -> DerivedSignalSpec

    Return a declarative spec for a calculated signal.

    derived_sub

    source
    fn derived_sub(left : DerivedExpr, right : DerivedExpr) -> DerivedExpr

    Unsigned subtraction expression constructor.

    derived_vector

    source
    fn derived_vector(value : String) -> DerivedExpr

    Return a constant vector expression.

    derived_xor

    source
    fn derived_xor(left : DerivedExpr, right : DerivedExpr) -> DerivedExpr

    Bitwise XOR expression constructor.

    detect_glitches

    source
    fn detect_glitches(trace : Trace, signal_id : String, maximum_width : Int64) -> Array[GlitchEvent]

    Find short known pulses, including both high and low pulses.

    diagnostic_counts

    source
    fn diagnostic_counts(items : Array[TraceDiagnostic]) -> (Int, Int)

    Return a count of diagnostics grouped by severity.

    diagnostics_report

    source
    fn diagnostics_report(items : Array[TraceDiagnostic]) -> String

    Render detailed validation diagnostics as text.

    diff_report

    source
    fn diff_report(differences : Array[TraceDifference]) -> String

    Render a compact human-readable diff.

    diff_traces

    source
    fn diff_traces(left : Trace, right : Trace, options : DiffOptions) -> Array[TraceDifference]

    Compare two traces at every timestamp where either side changes.

    digest_trace

    source
    fn digest_trace(trace : Trace) -> DigestSummary

    Consume all changes from a trace into an online digest.

    directive_inventory

    source
    fn directive_inventory(input : String) -> String

    Return a stable directive inventory line.

    directive_names

    source
    fn directive_names(input : String) -> Array[String]

    Return all directive names in source order.

    distinct_value_tokens

    source
    fn distinct_value_tokens(trace : Trace, signal_id : String) -> Array[String]

    Return the first occurrence of each distinct value token.

    distinct_values

    source
    fn distinct_values(trace : Trace, signal_id : String) -> Array[Value]

    Return distinct values in first-seen order.

    document_metric

    source
    fn document_metric(name : String, value : String, unit : String?, severity : DocumentSeverity) -> DocumentMetric

    Construct a metric.

    document_section

    source
    fn document_section(kind : DocumentSectionKind, title : String, summary : String) -> DocumentSection

    Construct a section directly.

    document_section_catalog

    source
    fn document_section_catalog() -> Array[DocumentSectionKind]

    List report section kinds.

    document_section_name

    source
    fn document_section_name(value : DocumentSectionKind) -> String

    Stable section names for headings and automation.

    document_severity_catalog

    source
    fn document_severity_catalog() -> Array[DocumentSeverity]

    List report severities.

    document_severity_name

    source
    fn document_severity_name(value : DocumentSeverity) -> String

    Stable severity names for all output formats.

    dominant_states

    source
    fn dominant_states(trace : Trace, signal_id : String) -> Array[(String, Int64)]

    Return the most frequently occupied states, ordered by first appearance.

    dominant_value_token

    source
    fn dominant_value_token(trace : Trace, signal_id : String) -> String?

    Return the most common canonical value token.

    driven_intervals

    source
    fn driven_intervals(trace : Trace, signal_id : String) -> Array[ValueInterval]

    Return intervals with a known scalar level and positive duration.

    drop_unknown_changes

    source
    fn drop_unknown_changes(trace : Trace) -> Trace

    Return a trace after dropping changes with unknown identifiers.

    duplicate_signal_ids

    source
    fn duplicate_signal_ids(trace : Trace) -> Array[String]

    Return declaration identifiers that are repeated in a malformed trace.

    duration_report

    source
    fn duration_report(trace : Trace, start : Int64, end : Int64) -> String

    Return a scale-aware duration report.

    duration_seconds

    source
    fn duration_seconds(trace : Trace, start : Int64, end : Int64) -> Double

    Return the physical duration between two timestamps.

    duty_cycle

    source
    fn duty_cycle(trace : Trace, signal_id : String) -> Double?

    dwell_time

    source
    fn dwell_time(trace : Trace, signal_id : String, value : Char) -> Int64

    Calculate the total time for a scalar value.

    edge_counts

    source
    fn edge_counts(trace : Trace, signal_id : String) -> (Int, Int, Int)

    Count rising, falling, and non-binary transitions.

    edge_fixture

    source
    fn edge_fixture() -> String

    Generate a fixture containing every supported scalar transition class.

    edge_kind

    source
    fn edge_kind(before : Char, after : Char) -> EdgeKind

    Return the canonical scalar category used by edge analysis.

    edges

    source
    fn edges(trace : Trace, signal_id : String) -> Array[EdgeEvent]

    Extract scalar transitions for one signal.

    ensure_final_newline

    source
    fn ensure_final_newline(input : String) -> String

    Add a final newline when a generated VCD is embedded in a stream.

    escape_text

    source
    fn escape_text(text : String) -> String

    Escape a string for the compact JSON helpers in this package.

    estimate_alignment

    source
    fn estimate_alignment(left : Trace, right : Trace, left_marker : String?, right_marker : String?, mode : AlignmentMode) -> AlignmentEstimate

    Estimate an offset using named marker signals.

    eval_derived_expr

    source
    fn eval_derived_expr(trace : Trace, expression : DerivedExpr, time : Int64) -> Value?

    Evaluate one expression at a timestamp.

    event_window_metrics

    source
    fn event_window_metrics(trace : Trace, width : Int64) -> Array[EventWindowMetric]

    Calculate event metrics for every fixed-width window.

    event_window_metrics_csv

    source
    fn event_window_metrics_csv(metrics : Array[EventWindowMetric]) -> String

    Render event metrics as CSV for charting.

    event_window_quality

    source
    fn event_window_quality(item : EventWindowMetric) -> Int

    Return a bounded window quality score based on unknown samples.

    event_window_report

    source
    fn event_window_report(trace : Trace, width : Int64) -> String

    Render one line for event-window verification diagnostics.

    exact_value_trigger

    source
    fn exact_value_trigger(value : Value) -> TriggerCondition

    Construct an exact-value trigger.

    execute_query

    source
    fn execute_query(trace : Trace, plan : QueryPlanV2) -> QueryResultV2

    Execute a plan by filtering and preserving source order.

    export_parseable

    source
    fn export_parseable(trace : Trace) -> Bool

    Return whether a serialized trace can be parsed again.

    export_summary

    source
    fn export_summary(trace : Trace) -> String

    Return a small export inventory for verification reports.

    extended_json_report

    source
    fn extended_json_report(trace : Trace, options : ReportOptions) -> String

    Render a report-oriented JSON object.

    extended_text_report

    source
    fn extended_text_report(trace : Trace, options : ReportOptions) -> String

    Render a text report with analysis highlights.

    falling_edge_trigger

    source
    fn falling_edge_trigger() -> TriggerCondition

    Construct a falling-edge trigger.

    filter_changes

    source
    fn filter_changes(trace : Trace, signal_id : String, predicate : (Value) -> Bool) -> Array[Change]

    Return changes whose values satisfy a caller predicate.

    filter_events

    source
    fn filter_events(trace : Trace, filter : EventFilter) -> Array[Change]

    Filter changes without changing their source order.

    filter_trace_signals

    source
    fn filter_trace_signals(trace : Trace, pattern : String) -> Trace

    Keep only declarations matching a path glob.

    find_analysis_metric

    source
    fn find_analysis_metric(metrics : Array[AnalysisMetric], signal_id : String, name : String) -> AnalysisMetric?

    Find a metric by name and signal identifier.

    find_signal

    source
    fn find_signal(trace : Trace, signal_id : String) -> Signal?

    Find a signal by its VCD identifier.

    find_signal_names

    source
    fn find_signal_names(trace : Trace, needle : String) -> Array[Signal]

    Return signal paths containing a case-insensitive substring.

    find_signal_path

    source
    fn find_signal_path(trace : Trace, path : String) -> Signal?

    Find a signal by its fully-qualified hierarchical path.

    find_signals_glob

    source
    fn find_signals_glob(trace : Trace, pattern : String) -> Array[Signal]

    Return signals whose fully-qualified path matches a small glob language.

    first_artifact_of_kind

    source
    fn first_artifact_of_kind(items : Array[TraceArtifact], kind : TraceArtifactKind) -> TraceArtifact?

    Return the first artifact with a requested kind.

    first_difference_from

    source
    fn first_difference_from(trace : Trace, signal_id : String, baseline : Value) -> Int64?

    Return the first timestamp at which a signal differs from a baseline.

    first_time_catalog

    source
    fn first_time_catalog(trace : Trace) -> Array[(String, Int64?)]

    Return the first timestamp of each declared signal.

    first_value

    source
    fn first_value(trace : Trace, signal_id : String) -> Value?

    Return the first observed value for a signal.

    fixed_window_spec

    source
    fn fixed_window_spec(width : Int64) -> WindowSpec

    Build a window specification with a fixed width.

    fixed_windows

    source
    fn fixed_windows(trace : Trace, width : Int64) -> Array[TraceWindow]

    Divide a trace into fixed-width inclusive windows.

    fixture_catalog

    source
    fn fixture_catalog() -> Array[(String, String)]

    Build a collection of independent fixtures for table-driven tests.

    fixture_expectations

    source
    fn fixture_expectations(name : String) -> (Int, Int)

    Return expected structural facts for a named generated fixture.

    fixture_fact_json

    source
    fn fixture_fact_json(fact : FixtureFact) -> String

    Render one fixture fact as JSON for smoke-test output.

    fixture_facts

    source
    fn fixture_facts() -> Array[FixtureFact]

    Parse all valid generated fixtures and retain observable facts.

    fixture_facts_csv

    source
    fn fixture_facts_csv(facts : Array[FixtureFact]) -> String

    Render fixture facts as a stable CSV table.

    fixture_facts_json

    source
    fn fixture_facts_json(facts : Array[FixtureFact]) -> String

    Render every fixture fact as a JSON array.

    fixture_names

    source
    fn fixture_names() -> Array[String]

    Return fixture names in the documented verification order.

    fixture_size

    source
    fn fixture_size(name : String) -> Int

    Return the size of a generated fixture without parsing it.

    fixture_size_report

    source
    fn fixture_size_report(signal_count : Int, time_count : Int) -> String

    Return the number of source characters in a generated fixture.

    fixture_validation_report

    source
    fn fixture_validation_report() -> String

    Render a short fixture validation report.

    fixture_workload_report

    source
    fn fixture_workload_report() -> String

    Return a workload summary for the generated benchmark corpus.

    fixtures_meet_expectations

    source
    fn fixtures_meet_expectations() -> Bool

    Return whether the built-in fixtures satisfy their minimum structural facts.

    fold_events

    source
    fn[A] fold_events(trace : Trace, filter : EventFilter, init : A, step : (A, Change) -> A) -> A

    Fold every selected change in source order.

    four_state_fixture

    source
    fn four_state_fixture() -> String

    Fixture with every scalar logical state.

    frequency_estimate

    source
    fn frequency_estimate(trace : Trace, signal_id : String) -> FrequencyEstimate

    Estimate period and frequency from rising edges.

    full_selection

    source
    fn full_selection(trace : Trace) -> TraceSelection

    Create a selection covering the complete trace.

    glitch_ratio

    source
    fn glitch_ratio(trace : Trace, signal_id : String, maximum_width : Int64) -> Double

    Estimate the fraction of driven intervals that are short pulses.

    glitch_report

    source
    fn glitch_report(glitches : Array[GlitchEvent]) -> String

    Render glitches as a stable table for CI logs.

    glob_matches

    source
    fn glob_matches(pattern : String, text : String) -> Bool

    Match * against any number of characters and ? against one character.

    graph_degrees

    source
    fn graph_degrees(graph : EventGraph) -> Array[(String, Int)]

    Calculate node degree pairs for graph ranking.

    graph_edge_kind_catalog

    source
    fn graph_edge_kind_catalog() -> Array[GraphEdgeKind]

    List graph edge categories.

    graph_edge_kind_name

    source
    fn graph_edge_kind_name(kind : GraphEdgeKind) -> String

    Name a graph edge category.

    graph_edges_csv

    source
    fn graph_edges_csv(edges : Array[GraphEdge]) -> String

    Export graph edges as CSV.

    graph_hub

    source
    fn graph_hub(graph : EventGraph) -> GraphNode?

    Return the highest-degree node, if any node exists.

    graph_node_kind_catalog

    source
    fn graph_node_kind_catalog() -> Array[GraphNodeKind]

    List graph node categories.

    graph_node_kind_name

    source
    fn graph_node_kind_name(kind : GraphNodeKind) -> String

    Name a graph node category.

    graph_path

    source
    fn graph_path(graph : EventGraph, start : String, goal : String, limit : Int) -> Array[String]

    Find a bounded breadth-first path between two nodes.

    graph_reachable

    source
    fn graph_reachable(graph : EventGraph, start : String, goal : String, limit : Int) -> Bool

    Return whether a path exists within a depth bound.

    grouped_export_preserves_shape

    source
    fn grouped_export_preserves_shape(trace : Trace) -> Bool

    Compare grouped export with the source trace's declaration shape.

    hamming_distance

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

    Return the Hamming distance between two known values.

    has_change_at

    source
    fn has_change_at(trace : Trace, signal_id : String, timestamp : Int64) -> Bool

    Return whether a signal changed exactly at a timestamp.

    has_complete_definition_block

    source
    fn has_complete_definition_block(input : String) -> Bool

    Return whether the text contains a complete definition block.

    has_dumpvars

    source
    fn has_dumpvars(source : String) -> Bool

    Return whether a source uses the standard $dumpvars block.

    hierarchy_fixture

    source
    fn hierarchy_fixture() -> String

    Generate a nested hierarchy with clocks, buses, and real values.

    hierarchy_report

    source
    fn hierarchy_report(trace : Trace) -> String

    Return one-line hierarchy summary rows.

    high_ratio

    source
    fn high_ratio(trace : Trace, signal_id : String) -> Double?

    Return the proportion of the trace spent at logical high.

    i2c_config

    source
    fn i2c_config(clock : String, data : String) -> I2cConfig

    Create the usual seven-bit address I²C configuration.

    i2c_decode

    source
    fn i2c_decode(trace : Trace, config : I2cConfig) -> Array[I2cTransaction]

    Decode all transactions in a trace.

    i2c_event_catalog

    source
    fn i2c_event_catalog() -> Array[I2cEventKind]

    List the event kinds used by the decoder.

    i2c_report

    source
    fn i2c_report(trace : Trace, config : I2cConfig) -> I2cReport

    Decode and summarize an I²C capture.

    i2c_transactions_csv

    source
    fn i2c_transactions_csv(transactions : Array[I2cTransaction]) -> String

    Export transactions as CSV.

    indexed_changes

    source
    fn indexed_changes(trace : Trace) -> Array[(String, Array[Change])]

    Return an index-backed snapshot of every signal's changes.

    infer_signal_dependencies

    source
    fn infer_signal_dependencies(trace : Trace, threshold : Int64) -> DependencyReport

    Infer dependencies between declared signals using nearby changes.

    infer_trace_schema

    source
    fn infer_trace_schema(trace : Trace) -> TraceSchemaReport

    Infer a schema from declarations and observed values.

    intervals_for_value

    source
    fn intervals_for_value(trace : Trace, signal_id : String, value : Char) -> Array[ValueInterval]

    Return the intervals occupied by a particular scalar value.

    is_clocklike

    source
    fn is_clocklike(trace : Trace, signal_id : String) -> Bool

    Return whether a signal behaves like a binary clock.

    is_known_scalar

    source
    fn is_known_scalar(value : Char) -> Bool

    Return whether a scalar character represents a known driven level.

    is_logic_char

    source
    fn is_logic_char(value : Char) -> Bool

    Return whether a character is a legal four-state VCD bit.

    is_vcd_directive

    source
    fn is_vcd_directive(line : String) -> Bool

    Return whether a line is a VCD control directive.

    is_vcd_timestamp

    source
    fn is_vcd_timestamp(line : String) -> Bool

    Return whether a line is a timestamp marker.

    jitter_report

    source
    fn jitter_report(trace : Trace, signal_id : String) -> JitterReport

    Compute period jitter from consecutive rising edges.

    json_report_options

    source
    fn json_report_options() -> ReportOptions

    Create JSON report options.

    json_size

    source
    fn json_size(trace : Trace) -> Int

    Return the compact JSON byte count for one trace.

    known_snapshot_count

    source
    fn known_snapshot_count(trace : Trace, timestamp : Int64) -> Int

    Return the number of signals that have a known value at a timestamp.

    known_value_ratio

    source
    fn known_value_ratio(trace : Trace, signal_id : String) -> Double

    Fraction of changes whose value contains no x or z state.

    last_value

    source
    fn last_value(trace : Trace, signal_id : String) -> Value?

    Return the last observed value for a signal.

    latency_report

    source
    fn latency_report(trace : Trace, source_signal : String, target_signal : String, maximum_latency : Int64) -> LatencyReport

    Summarize rising-edge latency pairs.

    logic_bit

    source
    fn logic_bit(value : Char) -> LogicBit

    Convert a VCD scalar character to its classified four-state value.

    longest_pulse

    source
    fn longest_pulse(trace : Trace, signal_id : String) -> (Char, Int64)?

    Return the longest known pulse for a signal.

    longest_value_run

    source
    fn longest_value_run(trace : Trace, signal_id : String) -> (String, Int)

    Return the longest stable run of one value token.

    looks_like_vcd

    source
    fn looks_like_vcd(input : String) -> Bool

    Return whether a string has the minimum VCD structure.

    low_ratio

    source
    fn low_ratio(trace : Trace, signal_id : String) -> Double?

    Return the proportion of the trace spent at logical low.

    make_checkpoints

    source
    fn make_checkpoints(trace : Trace, times : Array[(String, Int64)]) -> CheckpointSet

    Create checkpoints at explicit times.

    make_trace_patch

    source
    fn make_trace_patch(trace : Trace, source : String, start : Int64, end : Int64, selection : MergeSelection) -> TracePatch

    Return a patch describing the selected portion of a trace.

    make_window_plan

    source
    fn make_window_plan(trace : Trace, spec : WindowSpec) -> WindowPlan

    Build and validate a full segmentation plan.

    malformed_fixture

    source
    fn malformed_fixture() -> String

    Fixture suitable for testing malformed directive handling.

    manifests_equal

    source
    fn manifests_equal(left : TraceManifest, right : TraceManifest) -> Bool

    Return whether two manifests identify the same trace content.

    markdown_report

    source
    fn markdown_report(trace : Trace, options : ReportOptions) -> String

    Render a Markdown summary with tables for all declared signals.

    markdown_report_options

    source
    fn markdown_report_options() -> ReportOptions

    Create Markdown report options.

    matching_value_span

    source
    fn matching_value_span(trace : Trace, signal_id : String, expected : Value) -> Int64

    Return the duration between the first and last matching value.

    maximum_parallel_activity

    source
    fn maximum_parallel_activity(trace : Trace) -> (Int64, Int)

    Return the timestamp at which the most signals changed together.

    maximum_scope_depth

    source
    fn maximum_scope_depth(trace : Trace) -> Int

    Return the deepest declared scope depth.

    maximum_window_count

    source
    fn maximum_window_count(trace : Trace, signal_id : String, width : Int64) -> Int

    Return the maximum number of changes in any window.

    mean_change_interval

    source
    fn mean_change_interval(trace : Trace, signal_id : String) -> Double?

    Return the average distance between changes, if at least two exist.

    mean_event_density

    source
    fn mean_event_density(metrics : Array[EventWindowMetric]) -> Double

    Return the average event density across non-empty windows.

    merge_activity_segments

    source
    fn merge_activity_segments(segments : Array[ActivitySegment]) -> Array[ActivitySegment]

    Merge adjacent segments with the same activity state.

    merge_adjacent_windows

    source
    fn merge_adjacent_windows(windows : Array[TraceWindow], maximum_gap : Int64) -> Array[TraceWindow]

    Merge adjacent windows when their gap is below a threshold.

    merge_clip_trace

    source
    fn merge_clip_trace(trace : Trace, start : Int64, end : Int64) -> Trace

    Clip a trace to inclusive time bounds and preserve its declaration shape.

    merge_coverage_reports

    source
    fn merge_coverage_reports(left : CoverageReport, right : CoverageReport) -> CoverageReport

    Merge two reports by group and key while preserving first-seen order.

    merge_report

    source
    fn merge_report(left : Trace, right : Trace, merged : Trace) -> String

    Return a report describing a merge result.

    merge_select_trace

    source
    fn merge_select_trace(trace : Trace, selection : MergeSelection) -> Trace

    Keep only signals matched by a selection and their changes.

    merge_selection_ids

    source
    fn merge_selection_ids(ids : Array[String]) -> MergeSelection

    Return a selection by identifier.

    merge_selection_paths

    source
    fn merge_selection_paths(paths : Array[String]) -> MergeSelection

    Return a selection by hierarchical path fragments.

    merge_time_mode_catalog

    source
    fn merge_time_mode_catalog() -> Array[MergeTimeMode]

    Return every merge timing mode supported by the library.

    merge_traces

    source
    fn merge_traces(left : Trace, right : Trace) -> Trace

    Merge changes from two traces with the same declaration shape.

    merge_traces_with_options

    source
    fn merge_traces_with_options(left : Trace, right : Trace, options : MergeOptions) -> Trace

    Merge two traces under explicit timing and conflict policies.

    merged_signal_events

    source
    fn merged_signal_events(trace : Trace, signal_ids : Array[String]) -> Array[Change]

    Return all events for a group of identifiers, sorted by time.

    minimal_fixture

    source
    fn minimal_fixture() -> String

    Minimal scalar VCD fixture used in examples and boundary tests.

    mixed_fixture

    source
    fn mixed_fixture() -> String

    Fixture containing a nested scope and a real-valued signal.

    monitor_findings_csv

    source
    fn monitor_findings_csv(findings : Array[MonitorFinding]) -> String

    Render monitor findings as CSV.

    monitor_protocol

    source
    fn monitor_protocol(trace : Trace, channel : ProtocolChannel, options : MonitorOptions) -> MonitorReport

    Check one decoded protocol channel.

    monitor_rule_catalog

    source
    fn monitor_rule_catalog() -> Array[MonitorRule]

    List monitor rules.

    monitor_rule_name

    source
    fn monitor_rule_name(rule : MonitorRule) -> String

    Name a monitor rule.

    monitor_severity_catalog

    source
    fn monitor_severity_catalog() -> Array[MonitorSeverity]

    List monitor severities.

    monitor_severity_name

    source
    fn monitor_severity_name(value : MonitorSeverity) -> String

    Name a monitor severity.

    multi_signal_fixture

    source
    fn multi_signal_fixture(signal_count : Int, time_count : Int) -> String

    Generate a multi-signal fixture for parser and index benchmarks.

    nearest_value

    source
    fn nearest_value(trace : Trace, signal_id : String, timestamp : Int64, tolerance : Int64) -> Value?

    Return the nearest sample at or around a timestamp.

    new_online_metrics

    source
    fn new_online_metrics() -> OnlineMetrics

    Create an empty online metrics accumulator.

    new_stream_decoder

    source
    fn new_stream_decoder() -> StreamDecoder

    Create an empty chunk decoder.

    new_streaming_digest

    source
    fn new_streaming_digest() -> StreamingDigest

    Create an empty online digest.

    next_change

    source
    fn next_change(trace : Trace, signal_id : String, timestamp : Int64) -> Change?

    Return the next change after a timestamp.

    normalize_trace_changes

    source
    fn normalize_trace_changes(trace : Trace, include_duplicates : Bool) -> Trace

    Normalize a trace by sorting changes and optionally removing duplicates.

    normalize_vcd_text

    source
    fn normalize_vcd_text(input : String) -> String

    Normalize CRLF, CR, trailing whitespace, and repeated blank lines.

    normalized_text_equal

    source
    fn normalized_text_equal(left : String, right : String) -> Bool

    Return whether two source texts normalize to the same bytes.

    one_bit_ratio

    source
    fn one_bit_ratio(stats : BitStatistics) -> Double

    Return the fraction of observed bits that are one.

    online_metrics

    source
    fn online_metrics(trace : Trace) -> OnlineMetrics

    Add all trace changes to an accumulator.

    overlapping_window_spec

    source
    fn overlapping_window_spec(width : Int64, overlap : Int64) -> WindowSpec

    Build an overlapping fixed-width specification.

    overlapping_windows

    source
    fn overlapping_windows(trace : Trace, width : Int64, overlap : Int64) -> Array[TraceWindow]

    Divide a trace into overlapping windows while guaranteeing progress.

    overlay_traces

    source
    fn overlay_traces(reference : Trace, candidate : Trace, reference_prefix : String, candidate_prefix : String) -> Trace

    Overlay a reference trace and a candidate trace into a named pair.

    overview_json

    source
    fn overview_json(trace : Trace) -> String

    Render a complete catalog as JSON.

    overview_signal

    source
    fn overview_signal(trace : Trace, signal : Signal) -> SignalOverview

    Create one signal overview.

    package_trace

    source
    fn package_trace(trace : Trace, name : String) -> TracePackage

    Package a trace with its reproducibility manifest.

    packet_byte_order_catalog

    source
    fn packet_byte_order_catalog() -> Array[String]

    List supported packet byte orders.

    packet_layout

    source
    fn packet_layout(name : String, total_bits : Int) -> PacketLayout

    Create an empty packet layout.

    packet_records_csv

    source
    fn packet_records_csv(records : Array[PacketRecord]) -> String

    Export packet records as CSV.

    parse

    source
    fn parse(input : String) -> Result[Trace, ParseError]

    Parse a VCD document held in memory.

    parse_batch_safely

    source
    fn parse_batch_safely(input : String) -> Array[ParseSummary]

    Parse every non-empty document in a line-separated batch.

    parse_chunked

    source
    fn parse_chunked(input : String, chunk_size : Int) -> Result[Array[Trace], ParseError]

    Parse a complete stream in chunks of a fixed size.

    parse_cli_options

    source
    fn parse_cli_options(args : Array[String]) -> CliOptions

    Parse options without depending on an operating-system argument parser. Unknown switches are intentionally ignored so applications can add their own flags while reusing this package's report options.

    parse_documents

    source
    fn parse_documents(documents : Array[String]) -> Array[ParseSummary]

    Parse all records and return the first error only after complete traversal.

    parse_error_code

    source
    fn parse_error_code(error : ParseError) -> String

    Classify a parse error without exposing implementation details.

    parse_error_message

    source
    fn parse_error_message(error : ParseError) -> String

    Render a parse error with its original payload.

    parse_incremental

    source
    fn parse_incremental(input : String, chunk_size : Int) -> Result[Array[Trace], ParseError]

    Parse a document using fixed-size input chunks.

    parse_normalized

    source
    fn parse_normalized(input : String) -> Result[Trace, ParseError]

    Parse normalized text after repairing common line-ending issues.

    parse_optional

    source
    fn parse_optional(input : String) -> Trace?

    Parse a document or return None for any malformed input.

    parse_repaired

    source
    fn parse_repaired(input : String) -> Result[Trace, ParseError]

    Parse and repair a document by sorting changes and dropping invalid ids.

    parse_strict

    source
    fn parse_strict(input : String) -> Result[Trace, ParseError]

    Parse a trace and reject deep validation errors.

    parse_text_batch

    source
    fn parse_text_batch(inputs : Array[String]) -> Array[ParseSummary]

    Parse a batch and retain one diagnostic per source document.

    parse_timescale

    source
    fn parse_timescale(text : String) -> Result[TimeScale, ParseError]

    Parse a VCD timescale such as 1ns, 10 ps, or 100fs.

    parseable_count

    source
    fn parseable_count(summaries : Array[ParseSummary]) -> Int

    Return the number of parseable documents in a batch.

    parser_consistency_report

    source
    fn parser_consistency_report(source : String, trace : Trace) -> String

    Produce an explicit source/trace consistency line.

    parser_counters

    source
    fn parser_counters(input : String) -> (Int, Int, Int)

    Return common parser counters for a document.

    peak_change_density

    source
    fn peak_change_density(trace : Trace, bucket_width : Int64) -> Int

    Return the maximum number of changes in a bucket.

    peak_window_transitions

    source
    fn peak_window_transitions(trace : Trace, signal_id : String, width : Int64) -> Int

    Return the peak transition count in any window.

    period_values

    source
    fn period_values(trace : Trace, signal_id : String) -> Array[Int64]

    Return scalar pulse durations in source order.

    periods_within_tolerance

    source
    fn periods_within_tolerance(trace : Trace, signal_id : String, tolerance : Int64) -> Bool

    Return whether all periods lie inside an inclusive tolerance.

    physical_line_count

    source
    fn physical_line_count(input : String) -> Int

    Return the number of non-empty physical lines in an input.

    pipeline_batch_json

    source
    fn pipeline_batch_json(pipelines : Array[TracePipeline]) -> String

    Render a batch as a compact JSON object.

    pipeline_batch_report

    source
    fn pipeline_batch_report(pipelines : Array[TracePipeline]) -> String

    Render every pipeline verdict as newline-delimited text.

    pipeline_batch_verdict

    source
    fn pipeline_batch_verdict(pipelines : Array[TracePipeline]) -> String

    Return a batch verdict with success and failure counts.

    pipeline_detail

    source
    fn pipeline_detail(pipeline : TracePipeline, stage : PipelineStage) -> String?

    Return a stage detail, if that stage was recorded.

    pipeline_item_count

    source
    fn pipeline_item_count(pipeline : TracePipeline) -> Int

    Return the number of recorded items across successful stages.

    pipeline_shapes_valid

    source
    fn pipeline_shapes_valid(pipelines : Array[TracePipeline]) -> Bool

    Return whether every pipeline has the expected stage order.

    pipeline_source_bytes

    source
    fn pipeline_source_bytes(pipelines : Array[TracePipeline]) -> Int

    Return a stable source-size total for a batch.

    pipeline_source_lines

    source
    fn pipeline_source_lines(pipelines : Array[TracePipeline]) -> Array[String]

    Return all source inventories for a batch.

    pipeline_stage_count

    source
    fn pipeline_stage_count(pipeline : TracePipeline) -> Int

    Return the number of recorded stages.

    pipeline_stage_order

    source
    fn pipeline_stage_order() -> Array[PipelineStage]

    Return a fixed stage order for dashboards.

    pipeline_verdict

    source
    fn pipeline_verdict(pipeline : TracePipeline) -> String

    Return a one-line pipeline verdict for CI.

    previous_change

    source
    fn previous_change(trace : Trace, signal_id : String, timestamp : Int64) -> Change?

    Return the previous change at or before a timestamp.

    profile_metric_catalog

    source
    fn profile_metric_catalog() -> Array[ProfileMetricKind]

    List profile metric families.

    profile_metric_name

    source
    fn profile_metric_name(kind : ProfileMetricKind) -> String

    Name a profile metric.

    profile_metrics_csv

    source
    fn profile_metrics_csv(metrics : Array[ProfileMetric]) -> String

    Export profile metrics as CSV.

    protocol_backpressure

    source
    fn protocol_backpressure(trace : Trace, channel : ProtocolChannel) -> Int

    Count timestamps where valid is asserted but ready is not.

    protocol_events

    source
    fn protocol_events(trace : Trace, channel : ProtocolChannel) -> Array[ProtocolEvent]

    Extract all events for a configured channel.

    protocol_events_csv

    source
    fn protocol_events_csv(events : Array[ProtocolEvent]) -> String

    Return events as CSV for regression artifacts.

    protocol_mode_catalog

    source
    fn protocol_mode_catalog() -> Array[ProtocolMode]

    Return all supported protocol modes for CLI selection.

    protocol_stats

    source
    fn protocol_stats(trace : Trace, channel : ProtocolChannel) -> ProtocolStats

    Calculate deterministic health metrics for a channel.

    protocol_transactions

    source
    fn protocol_transactions(trace : Trace, channel : ProtocolChannel) -> Array[ProtocolTransaction]

    Convert protocol events into completed and incomplete transactions.

    protocol_transactions_csv

    source
    fn protocol_transactions_csv(transactions : Array[ProtocolTransaction]) -> String

    Return transactions as CSV for spreadsheet and CI consumers.

    pulse_channel

    source
    fn pulse_channel(name : String, signal_id : String) -> ProtocolChannel

    Return a one-signal pulse channel descriptor.

    pulse_widths

    source
    fn pulse_widths(trace : Trace, signal_id : String) -> Array[(Char, Int64)]

    Return pulse widths for scalar high and low levels.

    quality_line

    source
    fn quality_line(trace : Trace, signal_id : String) -> String

    Produce a short human-readable signal quality line.

    query_plan

    source
    fn query_plan(trace : Trace) -> QueryPlanV2

    Start a query plan for a trace.

    query_plan_node_catalog

    source
    fn query_plan_node_catalog() -> Array[QueryPlanNodeKind]

    List physical query plan nodes.

    query_predicate_catalog

    source
    fn query_predicate_catalog() -> Array[QueryPredicateKind]

    List query predicates.

    query_window

    source
    fn query_window(signal_id? : String, start~ : Int64, end~ : Int64) -> QueryWindow

    Create an inclusive query window.

    query_window_changes

    source
    fn query_window_changes(trace : Trace, window : QueryWindow) -> Array[Change]

    Return a signal's changes filtered by an inclusive query window.

    query_window_count

    source
    fn query_window_count(trace : Trace, window : QueryWindow) -> Int

    Return a trace-level change count for a query window.

    range_seconds

    source
    fn range_seconds(trace : Trace, range : (Int64, Int64)) -> (Double, Double)

    Convert a timestamp range to seconds while preserving order.

    ready_artifact_labels

    source
    fn ready_artifact_labels(items : Array[TraceArtifact]) -> Array[String]

    Return labels for ready artifacts.

    ready_trace_artifacts

    source
    fn ready_trace_artifacts(items : Array[TraceArtifact]) -> Array[TraceArtifact]

    Return artifacts that are ready for publication.

    regression_comparison_catalog

    source
    fn regression_comparison_catalog() -> Array[RegressionComparison]

    List comparison policies.

    regression_comparison_name

    source
    fn regression_comparison_name(value : RegressionComparison) -> String

    Name a comparison policy.

    regression_findings_csv

    source
    fn regression_findings_csv(findings : Array[RegressionFinding]) -> String

    Export regression findings as CSV.

    regular_checkpoints

    source
    fn regular_checkpoints(trace : Trace, step : Int64) -> CheckpointSet

    Create regularly spaced checkpoints.

    rename_signal

    source
    fn rename_signal(trace : Trace, old_id : String, new_id : String) -> Trace

    Rename signal identifiers while preserving all values.

    rename_trace_signal

    source
    fn rename_trace_signal(trace : Trace, old_id : String, new_id : String) -> Trace

    Rename one signal ID while preserving its display name and path.

    rename_trace_signals

    source
    fn rename_trace_signals(trace : Trace, pairs : Array[(String, String)]) -> Trace

    Rename a sequence of identifiers in declaration order.

    render_report

    source
    fn render_report(trace : Trace, options : ReportOptions) -> String

    Render a trace using the requested report format.

    repair_finding_level_catalog

    source
    fn repair_finding_level_catalog() -> Array[RepairFindingLevel]

    List every finding level.

    repair_findings_csv

    source
    fn repair_findings_csv(findings : Array[RepairFinding]) -> String

    Render repair findings as CSV.

    repair_level_name

    source
    fn repair_level_name(level : RepairFindingLevel) -> String

    Get a stable finding level name.

    repair_rule_catalog

    source
    fn repair_rule_catalog() -> Array[RepairRule]

    List every supported repair rule.

    repair_rule_name

    source
    fn repair_rule_name(rule : RepairRule) -> String

    Get a stable rule name.

    repair_trace

    source
    fn repair_trace(trace : Trace) -> Trace

    Return a trace after sorting changes and removing redundant writes.

    repair_trace_default

    source
    fn repair_trace_default(trace : Trace) -> RepairResult

    Run the default repair policy.

    repair_trace_with_options

    source
    fn repair_trace_with_options(trace : Trace, options : RepairOptions) -> RepairResult

    Execute a repair policy and return an auditable result.

    replace_unknown

    source
    fn replace_unknown(value : Value, replacement : LogicBit) -> Value

    Replace all unknown vector bits with a chosen stable value.

    replay_outcome_catalog

    source
    fn replay_outcome_catalog() -> Array[ReplayOutcome]

    List replay outcomes.

    replay_outcome_name

    source
    fn replay_outcome_name(value : ReplayOutcome) -> String

    Name a replay outcome.

    replay_protocol

    source
    fn replay_protocol(channel : ProtocolChannel, transactions : Array[ProtocolTransaction]) -> ProtocolReplay

    Replay a decoded transaction stream as a small deterministic state machine.

    replay_protocol_trace

    source
    fn replay_protocol_trace(trace : Trace, channel : ProtocolChannel) -> ProtocolReplay

    Replay a trace directly through a protocol channel.

    replay_steps_csv

    source
    fn replay_steps_csv(steps : Array[ReplayStep]) -> String

    Export replay steps as CSV.

    request_response_channel

    source
    fn request_response_channel(name : String, request_id : String, response_id : String, payload_id : String?) -> ProtocolChannel

    Return a request/response channel descriptor.

    resample_window

    source
    fn resample_window(trace : Trace, signal_id : String, start : Int64, end : Int64, step : Int64) -> Array[Sample]

    Resample a signal at evenly spaced timestamps inside a window.

    rising_edge_trigger

    source
    fn rising_edge_trigger() -> TriggerCondition

    Construct a rising-edge trigger.

    rolling_points

    source
    fn rolling_points(trace : Trace, width : Int64) -> Array[RollingPoint]

    Produce one rolling point at the beginning of every window.

    rolling_points_csv

    source
    fn rolling_points_csv(points : Array[RollingPoint]) -> String

    Render rolling points as CSV.

    round_trip_equal

    source
    fn round_trip_equal(trace : Trace) -> Bool

    Return whether serialization preserves declarations and observable changes.

    round_trip_fixture_count

    source
    fn round_trip_fixture_count(facts : Array[FixtureFact]) -> Int

    Return the number of round-trip-safe fixtures.

    run_analysis_workflow

    source
    fn run_analysis_workflow(trace : Trace, options : WorkflowOptions) -> AnalysisWorkflow

    Run all configured stages and retain their outputs.

    run_assertion

    source
    fn run_assertion(trace : Trace, assertion : WaveformAssertion) -> Array[AssertionViolation]

    Run one assertion against a trace.

    run_assertion_suite

    source
    fn run_assertion_suite(trace : Trace, assertions : Array[WaveformAssertion]) -> AssertionSummary

    Run a suite in declaration order and preserve all failures.

    run_duration_histogram

    source
    fn run_duration_histogram(trace : Trace, signal_id : String, bucket : Int64) -> Array[(Int64, Int)]

    Compute a histogram of run durations using a fixed bucket size.

    run_pipeline

    source
    fn run_pipeline(source : String) -> TracePipeline

    Run inventory, parse, validation, indexing, analysis, and export checks.

    run_pipeline_batch

    source
    fn run_pipeline_batch(inputs : Array[String]) -> Array[TracePipeline]

    Run the same pipeline over multiple independent inputs.

    same_signal_scope

    source
    fn same_signal_scope(left : Signal, right : Signal) -> Bool

    Return whether two declarations live in the same scope.

    same_signal_shape

    source
    fn same_signal_shape(left : Trace, right : Trace) -> Bool

    Return whether two traces declare identical signal paths and widths.

    sample_all

    source
    fn sample_all(trace : Trace, options : AnalysisOptions) -> Array[(String, Array[Sample])]

    Sample every declared signal using the same time grid.

    sample_signal

    source
    fn sample_signal(trace : Trace, signal_id : String, options : AnalysisOptions) -> Array[Sample]

    Sample one signal at regular timestamps.

    sample_trace

    source
    fn sample_trace(trace : Trace, config : SamplingConfig) -> SampledTrace

    Resample every declared signal at a fixed time grid.

    sample_trace_signal

    source
    fn sample_trace_signal(trace : Trace, signal_id : String, config : SamplingConfig) -> Array[SamplingPoint]

    Resample one signal only.

    sampling_config

    source
    fn sampling_config(start : Int64, end : Int64, step : Int64) -> SamplingConfig

    Create a hold-last-value sampling configuration.

    sampling_mode_catalog

    source
    fn sampling_mode_catalog() -> Array[SamplingMode]

    List sampling modes.

    sampling_points_csv

    source
    fn sampling_points_csv(points : Array[SamplingPoint]) -> String

    Export samples as CSV.

    scalar_level_trigger

    source
    fn scalar_level_trigger(value : Char) -> TriggerCondition

    Construct a scalar-level trigger.

    scalar_sequence

    source
    fn scalar_sequence(trace : Trace, signal_id : String) -> Array[Char]

    Return all scalar values in source order.

    scale_trace_time

    source
    fn scale_trace_time(trace : Trace, multiplier : Int64) -> Trace

    Scale all timestamps and the trace end time by an integer multiplier.

    schema_constraint_catalog

    source
    fn schema_constraint_catalog() -> Array[SchemaConstraint]

    List supported schema constraints.

    schema_constraint_name

    source
    fn schema_constraint_name(value : SchemaConstraint) -> String

    Name a schema constraint.

    schema_entries_csv

    source
    fn schema_entries_csv(entries : Array[SignalSchema]) -> String

    Export schema entries as CSV.

    schema_findings_csv

    source
    fn schema_findings_csv(findings : Array[SchemaFinding]) -> String

    Export schema findings as CSV.

    scope_paths

    source
    fn scope_paths(trace : Trace) -> Array[String]

    Return all unique scope paths from shallow to deep order.

    segment_trace

    source
    fn segment_trace(trace : Trace, spec : WindowSpec) -> Array[TraceWindow]

    Select the segmentation algorithm requested by a specification.

    select_trace

    source
    fn select_trace(trace : Trace, selection : TraceSelection) -> Trace

    Select signals by glob and changes by inclusive time range.

    selected_change_counts

    source
    fn selected_change_counts(trace : Trace, selection : MergeSelection) -> Array[(String, Int)]

    Return stable per-signal change counts after selection.

    setup_hold_violations

    source
    fn setup_hold_violations(trace : Trace, reference_signal : String, data_signal : String, setup : Int64, hold : Int64) -> Array[Int64]

    Check a setup/hold window around each reference rising edge.

    shift_trace

    source
    fn shift_trace(trace : Trace, offset : Int64) -> Trace

    Return a copy of a trace with all times shifted by a signed offset.

    shortest_pulse

    source
    fn shortest_pulse(trace : Trace, signal_id : String) -> (Char, Int64)?

    Return the shortest known pulse for a signal.

    signal_agreement

    source
    fn signal_agreement(trace : Trace, left_id : String, right_id : String, step : Int64) -> Double?

    Return the fraction of aligned scalar samples that agree.

    signal_analysis_metrics

    source
    fn signal_analysis_metrics(trace : Trace, signal_id : String) -> Array[AnalysisMetric]

    Calculate quality and activity metrics for one signal.

    signal_catalog

    source
    fn signal_catalog(trace : Trace) -> Array[(String, Int, String)]

    Return a stable table of path, width, and declaration kind.

    signal_changes

    source
    fn signal_changes(trace : Trace, signal_id : String) -> Array[Change]

    Return changes for one signal in source order.

    signal_depth

    source
    fn signal_depth(signal : Signal) -> Int

    Return the number of hierarchy levels used by a signal.

    signal_distribution

    source
    fn signal_distribution(trace : Trace, signal_id : String) -> TraceDistribution

    Calculate a distribution report for one signal.

    signal_groups

    source
    fn signal_groups(trace : Trace) -> Array[SignalGroup]

    Group declarations by their exact parent scope.

    signal_json

    source
    fn signal_json(signal : Signal) -> String

    Encode signal metadata as a compact JSON object.

    signal_leaf_name

    source
    fn signal_leaf_name(signal : Signal) -> String

    Return the leaf name of a signal path.

    signal_overviews

    source
    fn signal_overviews(trace : Trace) -> Array[SignalOverview]

    Create all signal overviews.

    signal_parent_path

    source
    fn signal_parent_path(signal : Signal) -> String

    Return the nearest parent scope, or an empty string for a root signal.

    signal_path

    source
    fn signal_path(signal : Signal) -> String

    signal_path_parts

    source
    fn signal_path_parts(signal : Signal) -> Array[String]

    Return path components for a signal.

    signal_runs

    source
    fn signal_runs(trace : Trace, signal_id : String) -> Array[SignalRun]

    Extract stable runs for one signal, including the final run.

    signal_time_statistics

    source
    fn signal_time_statistics(trace : Trace, signal_id : String) -> TimeStatistics

    Return a signal's change timestamp statistics.

    signals_in_scope

    source
    fn signals_in_scope(trace : Trace, scope : String) -> Array[Signal]

    Return signals declared directly in a scope.

    signals_json_pretty

    source
    fn signals_json_pretty(trace : Trace, indent : String) -> String

    Render one signal array as indented JSON.

    slice_context_catalog

    source
    fn slice_context_catalog() -> Array[SliceContext]

    List slice context policies.

    slice_request

    source
    fn slice_request(name : String, start : Int64, end : Int64) -> TraceSliceRequest

    Create a bounded slice request.

    slice_trace

    source
    fn slice_trace(trace : Trace, request : TraceSliceRequest) -> TraceSlice

    Materialize one slice with optional boundary context.

    slice_trace_batch

    source
    fn slice_trace_batch(trace : Trace, requests : Array[TraceSliceRequest]) -> Array[TraceSlice]

    Materialize a batch of slices.

    snapshot

    source
    fn snapshot(trace : Trace, timestamp : Int64) -> Array[Sample]

    Return the latest value for every declared signal at a timestamp.

    snapshot_glob

    source
    fn snapshot_glob(trace : Trace, pattern : String, timestamp : Int64) -> Array[Sample]

    Return a snapshot for only signals matching a glob.

    snapshot_manifest

    source
    fn snapshot_manifest(trace : Trace, timestamp : Int64) -> String

    Return a stable snapshot manifest at one timestamp.

    snapshot_window

    source
    fn snapshot_window(trace : Trace, time : Int64) -> Array[Sample]

    Return the last sample at or before the requested point for each signal.

    sort_trace_changes

    source
    fn sort_trace_changes(trace : Trace) -> Trace

    Return a trace with all changes ordered by timestamp and stable input order.

    source_statistics

    source
    fn source_statistics(input : String) -> SourceStatistics

    Count physical VCD constructs without allocating a Trace.

    source_statistics_line

    source
    fn source_statistics_line(stats : SourceStatistics) -> String

    Return a compact source inventory for diagnostics and benchmark labels.

    spi_bit_order_catalog

    source
    fn spi_bit_order_catalog() -> Array[SpiBitOrder]

    List every supported SPI bit order.

    spi_bit_order_name

    source
    fn spi_bit_order_name(value : SpiBitOrder) -> String

    Human-readable bit-order label.

    spi_chip_select_active

    source
    fn spi_chip_select_active(config : SpiConfig, value : Value?) -> Bool

    Return the active level for a configured chip-select.

    spi_decode

    source
    fn spi_decode(trace : Trace, config : SpiConfig) -> Array[SpiWord]

    Decode all chip-select framed words in a trace.

    spi_mode0

    source
    fn spi_mode0(clock : String, chip_select : String) -> SpiConfig

    Create a conventional mode-0, MSB-first SPI configuration.

    spi_phase_catalog

    source
    fn spi_phase_catalog() -> Array[SpiPhase]

    List every supported SPI sampling phase.

    spi_phase_name

    source
    fn spi_phase_name(value : SpiPhase) -> String

    Human-readable phase label.

    spi_polarity_catalog

    source
    fn spi_polarity_catalog() -> Array[SpiPolarity]

    List every supported SPI polarity.

    spi_polarity_name

    source
    fn spi_polarity_name(value : SpiPolarity) -> String

    Human-readable polarity label.

    spi_report

    source
    fn spi_report(trace : Trace, config : SpiConfig) -> SpiReport

    Decode and summarize SPI activity.

    spi_words_csv

    source
    fn spi_words_csv(words : Array[SpiWord]) -> String

    Produce a stable CSV table for decoded words.

    state_dwell

    source
    fn state_dwell(trace : Trace, signal_id : String) -> Array[(String, Int64)]

    Count dwell time by state label.

    state_intervals

    source
    fn state_intervals(trace : Trace, signal_id : String) -> Array[StateInterval]

    Return state intervals for a signal, preserving vector values.

    state_report

    source
    fn state_report(trace : Trace, signal_id : String) -> String

    Render a compact state transition report.

    state_sequence

    source
    fn state_sequence(trace : Trace, signal_id : String) -> Array[String]

    Return the sequence of stable state labels without adjacent duplicates.

    state_transitions

    source
    fn state_transitions(trace : Trace, signal_id : String) -> Array[StateTransition]

    Return all value transitions, including vector and real changes.

    statistics_catalog

    source
    fn statistics_catalog(trace : Trace) -> Array[(String, Int, Double, Double)]

    Summarize all declared signals as a compact table.

    statistics_catalog_csv

    source
    fn statistics_catalog_csv(trace : Trace) -> String

    Render a stable CSV catalog for plotting and spreadsheet review.

    stats

    source
    fn stats(trace : Trace, signal_id : String) -> SignalStats

    stats_csv

    source
    fn stats_csv(trace : Trace) -> String

    Render each signal's statistics as CSV.

    structural_gate

    source
    fn structural_gate(trace : Trace) -> Bool

    Return a compact structural gate result.

    structural_gate_report

    source
    fn structural_gate_report(trace : Trace) -> String

    Render a one-line gate explanation.

    successful_pipeline_count

    source
    fn successful_pipeline_count(pipelines : Array[TracePipeline]) -> Int

    Count successful pipelines in a batch.

    summarize_parse

    source
    fn summarize_parse(input : String) -> ParseSummary

    Parse text while returning a summary instead of raising or branching at call sites.

    summarize_window

    source
    fn summarize_window(trace : Trace, start : Int64, end : Int64) -> WindowSummary

    Summarize a single inclusive time window.

    summary_line

    source
    fn summary_line(trace : Trace) -> String

    Return a one-line summary intended for command-line tools.

    supported_variable_kinds

    source
    fn supported_variable_kinds(trace : Trace) -> Bool

    Return whether all declarations have supported variable kinds.

    synth_pattern_catalog

    source
    fn synth_pattern_catalog() -> Array[SynthPattern]

    List deterministic stimulus patterns.

    synth_pattern_name

    source
    fn synth_pattern_name(value : SynthPattern) -> String

    Name a synthetic pattern.

    synth_plan

    source
    fn synth_plan(end_time : Int64) -> SynthPlan

    Create an empty synthetic plan.

    synthesize_pulse_fixture

    source
    fn synthesize_pulse_fixture(end_time : Int64, period : Int64) -> Trace

    Generate a pulse fixture with clock and payload signals.

    synthesize_trace

    source
    fn synthesize_trace(plan : SynthPlan) -> Trace

    Generate a valid trace from a synthetic plan.

    synthetic_vcd

    source
    fn synthetic_vcd(signal_count : Int, time_count : Int) -> String

    Build a repeatable VCD fixture with scalar and vector signals.

    text_diagnostic

    source
    fn text_diagnostic(input : String) -> String

    Validate a text document and return a diagnostic suitable for a CLI.

    text_report

    source
    fn text_report(trace : Trace) -> String

    time_statistics

    source
    fn time_statistics(values : Array[Int64]) -> TimeStatistics

    Summarize timestamp values using deterministic sorting.

    time_windows

    source
    fn time_windows(trace : Trace, width : Int64) -> Array[(Int64, Int64)]

    Return windows of fixed width over the complete trace.

    timeline

    source
    fn timeline(trace : Trace, start : Int64, end : Int64, step : Int64) -> Array[TimelinePoint]

    Build snapshots at a fixed cadence across a bounded range.

    timeline_csv

    source
    fn timeline_csv(points : Array[TimelinePoint]) -> String

    Render a timeline as CSV with one row per signal value.

    timeline_is_monotonic

    source
    fn timeline_is_monotonic(points : Array[TimelinePoint]) -> Bool

    Return whether all requested timeline timestamps are monotonic.

    timeline_signal

    source
    fn timeline_signal(points : Array[TimelinePoint], signal_id : String) -> Array[(Int64, Value?)]

    Return only one signal's samples from a timeline.

    times_with_value

    source
    fn times_with_value(trace : Trace, signal_id : String, expected : Value) -> Array[Int64]

    Return all timestamps with a value matching a predicate-like value.

    timestamp_seconds

    source
    fn timestamp_seconds(trace : Trace, ticks : Int64) -> Double

    Convert a trace timestamp into seconds.

    timestamps_monotonic

    source
    fn timestamps_monotonic(trace : Trace) -> Bool

    Return whether timestamps are nondecreasing in source order.

    toggle_coverage_bins

    source
    fn toggle_coverage_bins(trace : Trace) -> Array[CoverageBin]

    Build toggle bins for declarations with meaningful transitions.

    trace_analysis_metrics

    source
    fn trace_analysis_metrics(trace : Trace) -> Array[AnalysisMetric]

    Calculate metrics for every declared signal in declaration order.

    trace_artifact

    source
    fn trace_artifact(name : String, kind : TraceArtifactKind, format : String, content : String) -> TraceArtifact

    Create an artifact descriptor from textual content.

    trace_artifact_catalog

    source
    fn trace_artifact_catalog() -> Array[TraceArtifactKind]

    List artifact kinds.

    trace_artifact_kind_name

    source
    fn trace_artifact_kind_name(value : TraceArtifactKind) -> String

    Name an artifact kind.

    trace_artifacts_csv

    source
    fn trace_artifacts_csv(items : Array[TraceArtifact]) -> String

    Export artifact metadata as CSV.

    trace_cache

    source
    fn trace_cache(policy : TraceCachePolicy, capacity : Int) -> TraceCache

    Create an empty bounded cache.

    trace_cache_entries_csv

    source
    fn trace_cache_entries_csv(entries : Array[TraceCacheEntry]) -> String

    Export cache entries as CSV.

    trace_cache_policy_catalog

    source
    fn trace_cache_policy_catalog() -> Array[TraceCachePolicy]

    List cache policies.

    trace_cache_policy_name

    source
    fn trace_cache_policy_name(policy : TraceCachePolicy) -> String

    Name a cache policy.

    trace_catalog

    source
    fn trace_catalog(items : Array[TraceCatalogItem]) -> TraceCatalogV2

    Create a catalog from named traces.

    trace_catalog_csv

    source
    fn trace_catalog_csv(items : Array[TraceCatalogItem]) -> String

    Export catalog entries as CSV.

    trace_catalog_item

    source
    fn trace_catalog_item(name : String, category : String, description : String, trace : Trace, tags : Array[String]) -> TraceCatalogItem

    Build a catalog entry from a trace and descriptive metadata.

    trace_distributions_csv

    source
    fn trace_distributions_csv(items : Array[TraceDistribution]) -> String

    Export distribution data as CSV.

    trace_event_graph

    source
    fn trace_event_graph(trace : Trace) -> EventGraph

    Build a signal/change graph with temporal and same-timestamp evidence.

    trace_json

    source
    fn trace_json(trace : Trace) -> String

    Export the complete trace as deterministic JSON.

    trace_json_pretty

    source
    fn trace_json_pretty(trace : Trace) -> String

    Render a human-readable JSON trace with stable indentation.

    trace_manifest

    source
    fn trace_manifest(name : String, trace : Trace, tags : Array[String]) -> TraceManifest

    Create a reproducibility manifest from a trace.

    trace_manifests_csv

    source
    fn trace_manifests_csv(items : Array[TraceManifest]) -> String

    Export manifests as CSV.

    trace_overview

    source
    fn trace_overview(trace : Trace) -> TraceOverview

    Create a trace overview for dashboards and CLI summaries.

    trace_quality_report

    source
    fn trace_quality_report(trace : Trace) -> String

    Produce a compact quality report for verification logs.

    trace_quality_score

    source
    fn trace_quality_score(trace : Trace) -> Int

    Return a bounded quality score in the range [0, 100].

    trace_signal_ids

    source
    fn trace_signal_ids(trace : Trace) -> Array[String]

    Return all declared identifiers in declaration order.

    trace_slices_csv

    source
    fn trace_slices_csv(slices : Array[TraceSlice]) -> String

    Export slice metadata as CSV.

    trace_to_vcd

    source
    fn trace_to_vcd(trace : Trace) -> String

    Render a trace back into a portable VCD document.

    trace_to_vcd_grouped

    source
    fn trace_to_vcd_grouped(trace : Trace) -> String

    Render declarations grouped by their complete scope path.

    traces_equal

    source
    fn traces_equal(left : Trace, right : Trace) -> Bool

    Return whether two traces have no observable differences.

    transform_is_valid

    source
    fn transform_is_valid(trace : Trace) -> Bool

    Return whether a transformed trace still references declared identifiers.

    transition_coverage_bins

    source
    fn transition_coverage_bins(trace : Trace) -> Array[CoverageBin]

    Build transition bins for each scalar signal.

    transition_histogram

    source
    fn transition_histogram(trace : Trace, signal_id : String, bucket : Int64) -> Array[(Int64, Int)]

    Compute an empirical transition histogram by integer bucket.

    transition_matrix

    source
    fn transition_matrix(trace : Trace, signal_id : String) -> Array[(Char, Char, Int)]

    Return every observed scalar transition and its multiplicity.

    transition_matrix_csv

    source
    fn transition_matrix_csv(trace : Trace, signal_id : String) -> String

    Render a transition matrix as stable CSV.

    transition_rate

    source
    fn transition_rate(trace : Trace, signal_id : String) -> Double?

    Return the number of transitions per trace time unit.

    transition_time_statistics

    source
    fn transition_time_statistics(trace : Trace, signal_id : String) -> TimeStatistics

    Return a signal's transition timestamp statistics.

    transition_times

    source
    fn transition_times(trace : Trace, signal_id : String) -> Array[Int64]

    Return timestamps at which a scalar signal changed logical state.

    trigger_hits

    source
    fn trigger_hits(trace : Trace, signal_id : String, condition : TriggerCondition) -> Array[TriggerHit]

    Find trigger hits for one signal.

    trigger_window

    source
    fn trigger_window(trace : Trace, signal_id : String, condition : TriggerCondition, before : Int64, after : Int64) -> Array[(Int64, Int64)]

    Return all changes within a time-triggered region.

    truncate_value

    source
    fn truncate_value(value : Value, width : Int) -> Value

    Coerce a vector to a fixed width by truncating the most significant bits.

    uart_8n1

    source
    fn uart_8n1(signal_id : String, bit_period : Int64) -> UartConfig

    Create a conventional 8-N-1 UART configuration.

    uart_decode

    source
    fn uart_decode(trace : Trace, config : UartConfig) -> Array[UartFrame]

    Decode all falling start edges that have enough samples for a frame.

    uart_frames_csv

    source
    fn uart_frames_csv(frames : Array[UartFrame]) -> String

    Render decoded frames as CSV.

    uart_parity_catalog

    source
    fn uart_parity_catalog() -> Array[UartParity]

    Return all supported parity modes.

    uart_report

    source
    fn uart_report(trace : Trace, config : UartConfig) -> UartReport

    Calculate aggregate decode metrics.

    uncertain_bit_ratio

    source
    fn uncertain_bit_ratio(stats : BitStatistics) -> Double

    Return the fraction of observed bits that are unknown or high impedance.

    union_signal_ids

    source
    fn union_signal_ids(left : Trace, right : Trace) -> Array[String]

    Return every signal identifier present in either trace.

    unknown_change_ids

    source
    fn unknown_change_ids(trace : Trace) -> Array[String]

    Return all changes whose identifiers are not declared.

    unknown_sample_count

    source
    fn unknown_sample_count(trace : Trace, signal_id : String) -> Int

    Return the number of samples with unknown or high-impedance values.

    unknown_value_ratio

    source
    fn unknown_value_ratio(trace : Trace, signal_id : String) -> Double

    Fraction of changes carrying an unknown or high-impedance state.

    unknown_value_trigger

    source
    fn unknown_value_trigger() -> TriggerCondition

    Construct an unknown-value trigger.

    unmatched_rising_edges

    source
    fn unmatched_rising_edges(trace : Trace, source_signal : String, target_signal : String, maximum_latency : Int64) -> Array[LatencySample]

    Return source edges that have no target edge within the allowed latency.

    unsigned_value

    source
    fn unsigned_value(value : Value) -> Int64?

    Return the highest known integer value represented by a binary vector.

    valid_fixture_count

    source
    fn valid_fixture_count(facts : Array[FixtureFact]) -> Int

    Return the number of valid fixtures in the built-in catalog.

    valid_packets

    source
    fn valid_packets(records : Array[PacketRecord]) -> Array[PacketRecord]

    Return all valid records.

    valid_ready_channel

    source
    fn valid_ready_channel(name : String, clock_id : String, valid_id : String, ready_id : String, payload_id : String?) -> ProtocolChannel

    Return a channel descriptor for a valid/ready transfer.

    validate

    source
    fn validate(trace : Trace) -> Array[ValidationIssue]

    Check structural invariants that are useful before running analysis.

    validate_trace_schema

    source
    fn validate_trace_schema(trace : Trace, expected : TraceSchemaReport) -> TraceSchemaReport

    Validate a trace against an expected schema report.

    validation_summary

    source
    fn validation_summary(trace : Trace) -> ValidationSummary

    Count diagnostics and structural risks in one trace.

    validation_summary_json

    source
    fn validation_summary_json(summary : ValidationSummary) -> String

    Render validation counters as JSON.

    validation_summary_line

    source
    fn validation_summary_line(summary : ValidationSummary) -> String

    Return a compact validation line suitable for CI output.

    value_add

    source
    fn value_add(left : Value, right : Value) -> Value

    Add two binary values, returning unknown for any unknown input bit.

    value_after

    source
    fn value_after(trace : Trace, signal_id : String, timestamp : Int64) -> Value?

    Return the first value strictly after a timestamp.

    value_and

    source
    fn value_and(left : Value, right : Value) -> Value

    Four-state bitwise AND.

    value_at

    source
    fn value_at(trace : Trace, signal_id : String, timestamp : Int64) -> Value?

    Return the last value observed at or before a timestamp.

    value_before

    source
    fn value_before(trace : Trace, signal_id : String, timestamp : Int64) -> Value?

    Return the value strictly before a timestamp.

    value_binary_op

    source
    fn value_binary_op(left : Value, right : Value, op : String) -> Value

    Apply a four-state binary operation to two values after width extension.

    value_binary_string

    source
    fn value_binary_string(value : Value, width : Int) -> String

    Convert a value to a fixed-width binary string.

    value_bit

    source
    fn value_bit(value : Value, index : Int) -> LogicBit?

    Return a bit at a zero-based position from the most significant side.

    value_compare_unsigned

    source
    fn value_compare_unsigned(left : Value, right : Value) -> Int?

    Compare two known binary values as unsigned integers.

    value_concat

    source
    fn value_concat(left : Value, right : Value) -> Value

    Concatenate two VCD values without losing vector width.

    value_count_ones

    source
    fn value_count_ones(value : Value) -> Int

    Count one bits in a value.

    value_count_unknown

    source
    fn value_count_unknown(value : Value) -> Int

    Count unknown and high-impedance bits in a value.

    value_coverage_bins

    source
    fn value_coverage_bins(trace : Trace) -> Array[CoverageBin]

    Build value bins for all declarations in a trace.

    value_distribution

    source
    fn value_distribution(trace : Trace, signal_id : String) -> ValueDistribution

    Count value classes without losing the distinction between x and z.

    value_distribution_json

    source
    fn value_distribution_json(item : ValueDistribution) -> String

    Encode one value distribution for dashboards.

    value_entropy

    source
    fn value_entropy(trace : Trace, signal_id : String) -> Double

    Compute Shannon-style entropy over observed values.

    value_from_int

    source
    fn value_from_int(number : Int64, width : Int) -> Value

    Construct a value from a non-negative integer and a fixed width.

    value_has_one

    source
    fn value_has_one(value : Value) -> Bool

    Return whether a vector contains at least one known one bit.

    value_hex

    source
    fn value_hex(value : Value) -> String?

    Convert a known binary value to hexadecimal text.

    value_intervals

    source
    fn value_intervals(trace : Trace, signal_id : String) -> Array[ValueInterval]

    Convert changes into stable scalar value intervals.

    value_is_zero

    source
    fn value_is_zero(value : Value) -> Bool

    Return whether every bit is logically zero.

    value_json

    source
    fn value_json(value : Value) -> String

    Encode one value as a stable JSON object fragment.

    value_kind

    source
    fn value_kind(value : Value) -> ValueKind

    Return a value's encoding class.

    value_not

    source
    fn value_not(value : Value) -> Value

    Four-state bitwise NOT.

    value_or

    source
    fn value_or(left : Value, right : Value) -> Value

    Four-state bitwise OR.

    value_reduce_and

    source
    fn value_reduce_and(value : Value) -> Value

    Reduce a vector with four-state AND semantics.

    value_reduce_or

    source
    fn value_reduce_or(value : Value) -> Value

    Reduce a vector with four-state OR semantics.

    value_reduce_xor

    source
    fn value_reduce_xor(value : Value) -> Value

    Reduce a vector with four-state XOR semantics.

    value_rotate_left

    source
    fn value_rotate_left(value : Value, amount : Int) -> Value

    Rotate a value left within its declared width.

    value_rotate_right

    source
    fn value_rotate_right(value : Value, amount : Int) -> Value

    Rotate a value right within its declared width.

    value_run_lengths

    source
    fn value_run_lengths(trace : Trace, signal_id : String) -> Array[(String, Int)]

    Return run lengths for consecutive equal values.

    value_shift_left

    source
    fn value_shift_left(value : Value, amount : Int) -> Value

    Shift a value left and fill vacated bits with zero.

    value_shift_right

    source
    fn value_shift_right(value : Value, amount : Int) -> Value

    Shift a value right and fill vacated bits with zero.

    value_sign_extend

    source
    fn value_sign_extend(value : Value, width : Int) -> Value

    Return a vector with the requested sign extension policy.

    value_slice

    source
    fn value_slice(value : Value, start : Int, end : Int) -> Value

    Return a vector slice with half-open bounds.

    value_sub

    source
    fn value_sub(left : Value, right : Value) -> Value

    Subtract two binary values with a fixed-width result.

    value_token

    source
    fn value_token(value : Value) -> String

    Encode a value exactly as a VCD assignment token, excluding the id.

    value_xor

    source
    fn value_xor(left : Value, right : Value) -> Value

    Four-state bitwise XOR.

    value_zero_extend

    source
    fn value_zero_extend(value : Value, width : Int) -> Value

    Pad a value on the left to a requested width.

    values_equal

    source
    fn values_equal(left : Value, right : Value, normalize_unknown : Bool) -> Bool

    Return whether two values are equal after VCD case normalization.

    values_fit_declarations

    source
    fn values_fit_declarations(trace : Trace) -> Bool

    Return whether all values fit their signal declarations.

    variable_kind_counts

    source
    fn variable_kind_counts(trace : Trace) -> Array[(String, Int)]

    Return counts of declared variable kinds.

    vcd_declaration

    source
    fn vcd_declaration(signal : Signal) -> String

    Render a single declaration line without surrounding scope directives.

    vcd_scope_close

    source
    fn vcd_scope_close() -> String

    Render a scope closing directive.

    vcd_scope_open

    source
    fn vcd_scope_open(scope : String) -> String

    Render a scope opening directive.

    widest_signal

    source
    fn widest_signal(trace : Trace) -> Signal?

    Return the widest declaration in a trace.

    width_coverage_bins

    source
    fn width_coverage_bins(trace : Trace, minimum : Int, maximum : Int) -> Array[CoverageBin]

    Build bins that check declaration widths against an expected range.

    width_mismatch_ids

    source
    fn width_mismatch_ids(trace : Trace) -> Array[String]

    Return all declarations with values wider than their declared width.

    window_activity_score

    source
    fn window_activity_score(window : TraceWindow) -> Int

    Return a dense activity score based on distinct change timestamps.

    window_at

    source
    fn window_at(plan : WindowPlan, time : Int64) -> TraceWindow?

    Find the first window containing a timestamp.

    window_coverage

    source
    fn window_coverage(trace : Trace, signal_id : String, start : Int64, end : Int64) -> Double

    Return the fraction of a window covered by known scalar intervals.

    window_metric

    source
    fn window_metric(window : TraceWindow) -> WindowMetric

    Return a one-line metric record for a window.

    window_metrics_csv

    source
    fn window_metrics_csv(metrics : Array[WindowMetric]) -> String

    Render metrics as deterministic CSV.

    window_metrics_json

    source
    fn window_metrics_json(metrics : Array[WindowMetric]) -> String

    Render metrics as a small JSON array without external dependencies.

    window_plan_report

    source
    fn window_plan_report(plan : WindowPlan) -> String

    Produce one line per window for operational dashboards.

    window_policy_catalog

    source
    fn window_policy_catalog() -> Array[WindowPolicy]

    Return every supported policy. Keeping the catalog public also makes it possible for CLI frontends to present the same choices as the library.

    window_summaries

    source
    fn window_summaries(trace : Trace, width : Int64) -> Array[WindowSummary]

    Summarize every fixed-width window.

    windows_between

    source
    fn windows_between(plan : WindowPlan, start : Int64, end : Int64) -> Array[TraceWindow]

    Return all windows that intersect an inclusive range.

    windows_cover_trace

    source
    fn windows_cover_trace(trace : Trace, width : Int64) -> Bool

    Return whether windows cover the complete trace without gaps.

    with_end_time

    source
    fn with_end_time(trace : Trace, end_time : Int64) -> Trace

    Return a trace with a new explicit end timestamp.

    workflow_stage_catalog

    source
    fn workflow_stage_catalog() -> Array[WorkflowStage]

    List workflow stages.

    workflow_stage_name

    source
    fn workflow_stage_name(stage : WorkflowStage) -> String

    Name a workflow stage.

    workflow_stages_csv

    source
    fn workflow_stages_csv(stages : Array[WorkflowStageResult]) -> String

    Render stage timings and statuses as CSV.

    workflow_status_catalog

    source
    fn workflow_status_catalog() -> Array[WorkflowStageStatus]

    List workflow statuses.

    workflow_status_name

    source
    fn workflow_status_name(status : WorkflowStageStatus) -> String

    Name a workflow status.

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io