Write a custom replay viewer module in C#

using System.Buffers;
using System.Buffers.Binary;
using System.Numerics;
using OneScope.Sdk;
 
// CNTR + a little-endian int32 step count; each step increments the counter.
byte[] bytes = [67, 78, 84, 82, 10, 0, 0, 0];
File.WriteAllBytes("counter.replay", bytes);
var source = new CounterModule().Open(bytes, "counter.replay");
var history = new History(source);
history.Seek(7);
Console.WriteLine($"Step: {history.CurrentStep}");
Console.WriteLine($"Hash: {history.StateHash:x16}");
history.Seek(2);
history.Seek(7);
Console.WriteLine($"After rewind: {history.StateHash:x16}");
var saved = new ArrayBufferWriter<byte>();
source.WriteReplay(saved);
Console.WriteLine($"Replay round trip: {bytes.AsSpan().SequenceEqual(saved.WrittenSpan)}");
 
public sealed class CounterModule : IScopeModule
{
    public string Id => "counter";
    public string Name => "Counter";
    public IScopeSource Open(ReadOnlyMemory<byte> data, string name)
    {
        if (data.Length != 8 || !data.Span[..4].SequenceEqual("CNTR"u8))
            throw new ScopeFormatException(name, "Expected CNTR and an int32 step count (8 bytes).");
        int steps = BinaryPrimitives.ReadInt32LittleEndian(data.Span[4..]);
        if (steps < 0 || steps > 10000)
            throw new ScopeFormatException(name, "Expected 0..10000 steps at offset 4.");
        var inputs = new ReadOnlyMemory<byte>[steps];
        return new CounterSource(name, Recording.Create(ReadOnlyMemory<byte>.Empty, inputs));
    }
}
 
public sealed class CounterSource(string name, Recording recording) : IScopeSource
{
    public SourceInfo Info { get; } = new()
    {
        ModuleId = "counter", Name = name, Dimensions = 2,
        Unit = LengthUnit.Metre,
        Axes = [new AxisInfo(AxisIds.Time, "Time", 0)],
        EntityKinds = [new EntityKindInfo("counter", "Counter")],
        Overlays = [new OverlayInfo(0, "Counter", true)]
    };
    public Recording Recording { get; } = recording;
    public IScopeWorld CreateWorld() => new CounterWorld();
    public IScopeSource WithRecording(Recording other) => new CounterSource(name, other);
    public void WriteReplay(IBufferWriter<byte> writer)
    {
        Span<byte> bytes = writer.GetSpan(8)[..8];
        "CNTR"u8.CopyTo(bytes);
        BinaryPrimitives.WriteInt32LittleEndian(bytes[4..], checked((int)Recording.StepCount));
        writer.Advance(8);
    }
}
 
public sealed class CounterWorld : IScopeWorld
{
    public long Step { get; private set; }
    public ulong Hash() => (ulong)Step; // This toy's entire state is its counter.
    public void Advance(ReadOnlySpan<byte> input, TimelineSink sink)
    {
        if (!input.IsEmpty) throw new ScopeFormatException("counter", "Expected empty step input.");
        Step = checked(Step + 1);
    }
    public void AdvanceAxis(string axis, int position, ReadOnlySpan<byte> input) =>
        throw new ArgumentException("No secondary axes.", nameof(axis));
    public void WriteSnapshot(IBufferWriter<byte> writer)
    {
        BinaryPrimitives.WriteInt64LittleEndian(writer.GetSpan(8), Step);
        writer.Advance(8);
    }
    public void Restore(ReadOnlySpan<byte> snapshot)
    {
        if (snapshot.Length != 8 || BinaryPrimitives.ReadInt64LittleEndian(snapshot) < 0)
            throw new ScopeFormatException("counter", "Expected a nonnegative int64 snapshot.");
        Step = BinaryPrimitives.ReadInt64LittleEndian(snapshot);
    }
    public void CollectEntities(List<EntityInfo> into)
    {
        into.Clear();
        into.Add(new(new EntityId(1), default, "counter", "Counter"));
    }
    public bool Inspect(EntityId entity, PropertyList into)
    {
        into.Clear();
        if (entity.Value != 1) return false;
        into.Add("State", "Value", ScopeValue.OfInteger(Step));
        return true;
    }
    public void Draw(DrawList into, in DrawRequest request) =>
        into.Point(new Vector3(Step, 0, 0), 8, new DrawStyle(Color32.White, Entity: new EntityId(1)));
    public void EncodePoke(in PokeCall call, IBufferWriter<byte> into) =>
        throw new ArgumentException("This counter declares no pokes.");
    public Difference? FirstDifference(IScopeWorld other)
    {
        if (other is not CounterWorld counter) throw new ArgumentException("Expected a counter.");
        return Step == counter.Step ? null : new Difference(new EntityId(1), "value",
            Step.ToString(System.Globalization.CultureInfo.InvariantCulture),
            counter.Step.ToString(System.Globalization.CultureInfo.InvariantCulture));
    }
}

Step: 7
Hash: 0000000000000007
After rewind: 0000000000000007
Replay round trip: True

{"source":0,"step":7,"entity":1,"kind":"counter","name":"Counter","properties":[{"group":"State","name":"Value","kind":"integer","value":7}]}