Match a journey across named state windows.

These views can be used together. A completed incident sequence says the three states occurred in order; it does not say two providers agreed on their exact ranges, or combine those windows into one occurrence.

Rust lane identity uses exact string equality for key, source, and partition. In C#, the first step family's configured history key comparer anchors key equality for every later step; source and partition use exact object equality. This is a real native-model difference, so normalize key conventions before expecting cross-runtime agreement.

using Spanfold.Sequences;

var result = history
    .MatchSequence("incident journey")
    .Step("Warning")
    .Then("Offline")
    .Then("Recovered")
    .WithMaximumGap(5)
    .Run();

foreach (var match in result.Matches)
{
    Console.WriteLine(
        $"{match.Key}: {match.StartPosition}..{match.EndPosition} " +
        $"gap={match.TotalGapPositionMagnitude} {match.Finality}");

    foreach (var record in match.Evidence)
    {
        Console.WriteLine($"  {record.Window.WindowName} {record.Window.Id}");
    }
}

let matches = history
    .match_sequence("incident journey")
    .step("Warning")
    .then("Offline")
    .then("Recovered")
    .with_maximum_gap(5)
    .run()?;

for sequence_match in &matches {
    println!(
        "{}: {}..{} gap={} {:?}",
        sequence_match.key(),
        sequence_match.start().magnitude(),
        sequence_match.end().magnitude(),
        sequence_match.total_gap(),
        sequence_match.finality(),
    );

    for record in sequence_match.evidence() {
        println!("  {} {}", record.window.window_name(), record.window.id());
    }
}

Builder validation follows each host language: C# rejects invalid calls as the fluent plan is built or run; Rust returns WindowSequenceError from execution.

The native semantics intentionally correspond, but package versioning, result wrapping, key identity, and error handling remain runtime-specific. No portable document currently turns the sequence surface into a cross-runtime compatibility contract.