The contracts a footprint / volume-profile / DOM plugin consumes: the per-bar orderflow model in SabrTrader.Pipeline.OrderFlow, and the live Level-2 / Level-3 market-depth surface in SabrTrader.Pipeline.MarketDepth.

Orderflow: SabrTrader.Pipeline.OrderFlow

The per-bar orderflow model footprint-class indicators read, plus the volume-profile-window seam a drawing tool requests. Add using SabrTrader.Pipeline.OrderFlow; to reach these types.

OrderFlowBar

A readonly record struct: the OHLCV Bar plus parallel per-price-level bid/ask volume and trade-print counts. Prices are discretized to integer ticks; level i sits at (LowTicks + i) × TickSize + PriceOffset. Designed for allocation-free reads in tight render loops.

Constructors. Three overloads:

OrderFlowBar.cs// Full-fidelity: bid/ask/trade-count arrays + running-delta extremes (validated).
public OrderFlowBar(Bar bar, long lowTicks, double tickSize,
    long[] bidVolumes, long[] askVolumes, long[] tradeCounts,
    long localDeltaHigh, long localDeltaLow,
    long[]? bidTradeCounts = null, long[]? askTradeCounts = null,
    OrderFlowBarStats? stats = null, double priceOffset = 0,
    OrderFlowProvenance provenance = OrderFlowProvenance.Exact);

// Defaults the running-delta extremes to 0 (empty / no-tick bars).
public OrderFlowBar(Bar bar, long lowTicks, double tickSize,
    long[] bidVolumes, long[] askVolumes, long[] tradeCounts);

// Volume-only: every level's TradeCount = 0 (seeding, fixtures).
public OrderFlowBar(Bar bar, long lowTicks, double tickSize,
    long[] bidVolumes, long[] askVolumes);

OrderFlowLevel: one price row, a readonly record struct returned by GetLevel / TryGetLevelAtPrice:

OrderFlowBarStats

A readonly record struct of per-bar quantities that can only be computed during tick aggregation (they depend on tick order). Carried by OrderFlowBar.Stats; null when no tick aggregator ran.

OrderFlowBarStats.cspublic readonly record struct OrderFlowBarStats(
    long RunningDeltaMax,
    long RunningDeltaMin,
    long AskVolumeSinceHigh,
    long BidVolumeSinceHigh,
    long AskVolumeSinceLow,
    long BidVolumeSinceLow,
    double VolumePerSecond,
    bool? LastTickIsBid = null,
    long FirstTickVolume = 0,
    System.TimeSpan? TradeSpan = null,
    long UpTickVolume = 0,
    long DownTickVolume = 0,
    double? LastTradePrice = null,
    int LastTickRuleDirection = 0,
    bool? DeltaHighSetAfterLow = null,
    DateTime? FirstTradeUtc = null,
    DateTime? LastTradeUtc = null);

Stats is filled on tick-built bars and on profiled 1-minute ladders a venue builds by replaying an aggressor-flagged tape. A venue whose profiled ladder carries per-price volume without print order leaves it null.

OrderFlowAggressorClassifier & AggressorSplit

The platform's tick-rule classifier, for when you build a ladder yourself from a tape whose prints carry no aggressor side. Feed it trades in order; it credits each to bid or ask and remembers the direction so an unchanged price inherits the previous one, which is why it is stateful.

classifying a printusing SabrTrader.Pipeline.OrderFlow;

var classifier = new OrderFlowAggressorClassifier();

AggressorSplit split = classifier.Classify(price, size, tick.Flags);
// split.BidVolume / AskVolume / BidPrints / AskPrints, plus Delta and HitBid.
// split.ByTickRule is true when the SIDE was inferred rather than venue-stamped;
// split.HadPriorTrade is false for the first print, where no direction exists yet.

classifier.Reset();                                   // new session
classifier.Restore(previousPrice, direction);         // resume where a recorded run left off

Direction and PreviousPrice expose the state so it can be persisted and restored, and OrderFlowProvenance.TickRuleClassified is what a bar built this way should carry (see OrderFlowBar).

OrderFlowTapeStatsAccumulator is the matching mutable struct for the per-bar statistics: call OnTrade(DateTime utc, long size, long delta, bool lastTickIsBid, double price) for each trade folded into the bar, then Build() for its OrderFlowBarStats. Start a new accumulator per bar.

OrderFlowResolution

Backfill granularity an orderflow consumer requests. Coarser = far less data = faster backfill, at the cost of aggressor fidelity. Settings persist the value by name.

OrderFlowWindowRequest

An immutable readonly record struct describing the volume-at-price profile a tool wants for a time window. Value equality makes it the host's cache key: the same window and parameters resolve to the same cached profile, and dragging an anchor produces a new key and a fresh build.

OrderFlowWindowRequest.cspublic readonly record struct OrderFlowWindowRequest(
    DateTime FromUtc,
    DateTime ToUtcExclusive,
    OrderFlowResolution Resolution,
    int TickAggregation,
    double ValueAreaPercentage,
    bool EnableSmoothing,
    int SmoothingPeriod,
    int HighVolumeNodeCount,
    int LowVolumeNodeCount,
    int HighVolumeRegionSize,
    int LowVolumeRegionSize);

bool HasWindow: true only when ToUtcExclusive > FromUtc.

VolumeProfileWindow

A finished volume-at-price profile for one window, a plain sealed record free of engine types so a contracts-only drawing tool can render it. Produced host-side and handed back via IOrderFlowWindowSource.

VolumeProfileWindow.cspublic sealed record VolumeProfileWindow(
    IReadOnlyList<VolumeProfileBin> Bins,
    double BucketStep,
    double MaxVolume,
    double MaxAbsDelta,
    double TotalVolume,
    double Poc,
    double ValueAreaHigh,
    double ValueAreaLow,
    double HighPrice,
    double LowPrice,
    IReadOnlyList<double> HighVolumeNodePrices,
    IReadOnlyList<double> LowVolumeNodePrices,
    DateTime FromUtc,
    DateTime ToUtcExclusive);

bool IsEmpty: true when the window enclosed no traded volume. Each row is a VolumeProfileBin (readonly record struct):

IOrderFlowWindowSource

Host-provided seam that resolves an OrderFlowWindowRequest to a VolumeProfileWindow. Surfaced to drawing tools through IDrawingToolRenderContext.OrderFlowWindows.

IOrderFlowWindowSource.cspublic interface IOrderFlowWindowSource
{
    // Returns the cached profile when ready, or null while a build is in flight.
    // On a cache miss, kicks an async build and repaints when done. Never blocks.
    VolumeProfileWindow? GetOrRequest(in OrderFlowWindowRequest request);
}

Call it from the synchronous render loop: it returns immediately, so a tool paints a "calculating" placeholder on null and the real profile on the next frame after the async build completes.

Market depth: SabrTrader.Pipeline.MarketDepth

The live order-book surface. A venue may offer aggregated Level-2 (IMarketDepthFeed), per-order Level-3 / MBO (IMarketByOrderFeed), or both; the OrderBook unifies whichever arrives. Add using SabrTrader.Pipeline.MarketDepth;.

IMarketDepthFeed

Live aggregated Level-2 depth feed. Emits DepthUpdate per price-level change. Events may arrive on any thread; the feed reference-counts per instrument so subscribers share one upstream connection.

IMarketDepthFeed.cspublic interface IMarketDepthFeed : IDisposable
{
    IDisposable Subscribe(string instrumentId, Action<DepthUpdate> onUpdate);
    // Also hear about updates the feed dropped before the next one it delivers.
    // Default forwards to the two-argument form: a synchronous fan-out never drops.
    IDisposable Subscribe(string instrumentId, Action<DepthUpdate> onUpdate, Action<long> onLoss);
    event Action? SubscriptionReset;   // drop state; default no-op
}

SubscriptionReset fires when consumers must drop all depth state (typically a connection loss). Disposing the token from Subscribe unsubscribes; the upstream sub is torn down when the last subscriber drops.

IMarketByOrderFeed

Live Market-By-Order (Level-3) feed. Emits MboEvent per resting-order lifecycle event (Add / Modify / Cancel). MboEvent.OrderId must be the venue's exchange-supplied id, stable across Modify (including a price move).

IMarketByOrderFeed.cspublic interface IMarketByOrderFeed : IDisposable
{
    IDisposable Subscribe(string instrumentId, Action<MboEvent> onEvent);
    // Also hear about events the feed dropped before the next one it delivers: the
    // count arrives before that event. Default forwards to the two-argument form
    // (a synchronous fan-out never drops); the hosted feed's per-instrument drain
    // pump overrides it, and the recorder subscribes this way.
    IDisposable Subscribe(string instrumentId, Action<MboEvent> onEvent, Action<long> onLoss);
    event Action? SubscriptionReset;   // clear book on connection loss; default no-op
    // One instrument's book was reset, re-imaged (RebuildStarted / RebuildCompleted)
    // or changed authority. Args: instrumentId, transition. Default no-op.
    event Action<string, OrderBookLifecycleEvent>? BookLifecycleChanged;
}

IDepthFeedRouting

Optional capability of a data provider that fronts several underlying feeds: one venue login with several datasets behind a single IDataProvider, where Depth and Mbo route each instrument to the dataset that carries it. The routing surface itself keeps no order books, so when the host needs the shared book for an instrument (a chart's order book, a DOM) it asks this capability which underlying feed serves that instrument and reads the books from that feed. Several datasets of one login may share one set of books. The host probes it with AsCapability<IDepthFeedRouting>(); a provider with one depth feed per session leaves it out, and the host reads Depth / Mbo directly.

IDepthFeedRouting.cspublic interface IDepthFeedRouting
{
    // The MBO feed that serves instrumentId, or null when none does.
    IMarketByOrderFeed? MboFeedFor(string instrumentId);

    // The aggregated depth feed that serves instrumentId, or null when none does.
    IMarketDepthFeed? DepthFeedFor(string instrumentId);
}

Return the same feed object your routed Mbo / Depth would hand that instrument's subscription to. Null means no feed keeps books for it, and the consumer builds a local book from its own subscription; it never borrows another venue's book.

MyRoutedProvider.Depth.csusing SabrTrader.Pipeline.MarketDepth;
using SabrTrader.Pipeline.Providers;

// The other half of this partial class implements IDataProvider. Its Depth and Mbo
// forward each subscription to the dataset that lists the instrument.
public sealed partial class MyRoutedProvider : IDepthFeedRouting
{
    private readonly IReadOnlyDictionary<string, IDataProvider> _datasetByInstrument;

    public IMarketByOrderFeed? MboFeedFor(string instrumentId)
        => _datasetByInstrument.TryGetValue(instrumentId, out var dataset) ? dataset.Mbo : null;

    public IMarketDepthFeed? DepthFeedFor(string instrumentId)
        => _datasetByInstrument.TryGetValue(instrumentId, out var dataset) ? dataset.Depth : null;
}

IOrderBook

Read-only view onto a live OrderBook, the surface exposed via IIndicatorContext.OrderBook. The mutation API stays on the concrete OrderBook; indicator code only reads. Read it inside IIndicatorContext.ReadOrderBook (or TryReadOrderBook), which holds the host's book lock; callers that need a frozen copy use OrderBookSnapshot.Capture there.

OrderBook

The concrete sealed class OrderBook : IOrderBook for one instrument. Accepts both aggregated L2 and per-order MBO events into a unified per-level surface. Not internally synchronised: the feed code that owns it holds the lock. Construct your own for offline work such as replaying a recorded tape.

OrderBookSnapshot

Immutable, render-safe copy of a book at one moment: flat Bids / Asks arrays (index 0 = top of book) so iteration is allocation-free and rows match visual ladder order. Per-order detail is dropped; each row is aggregated only.

PriceLevel

One price level inside an OrderBook (a sealed class). Carries the aggregated Size and, when MBO-fed, an ordered per-order queue. A level constructed only from L2 reports OrderCount == 0.

OrderBookEntry

One resting order in an MBO-mode book (a sealed class; identity is OrderId).

DepthUpdate

One aggregated Level-2 depth event, a readonly record struct passed by value. Venues pass SequenceNumber = 0; the host's sequencer stamps it during fan-out.

DepthUpdate.cspublic readonly record struct DepthUpdate(
    long SequenceNumber,
    DateTime ExchangeTimestampUtc,
    string InstrumentId,
    Side Side,
    DepthAction Action,
    double Price,
    long Size);

DepthAction

Kind of update a DepthUpdate carries (an enum : byte).

MboEvent

One Market-By-Order event, a readonly record struct passed by value. Carries the individual resting order's identity, price, size and queue priority. On a price-move Modify, PrevPrice holds the old price (double.NaN when unchanged).

MboEvent.cspublic readonly record struct MboEvent(
    long SequenceNumber,        // platform delivery stamp: venues leave it 0
    DateTime ExchangeTimestampUtc,
    string InstrumentId,
    string OrderId,
    Side Side,
    MboAction Action,
    double Price,
    long Size,
    ulong QueuePriority,
    double PrevPrice,
    ulong VenueSequence);       // the venue's own wire counter, 0 when it has none

// Ten-argument constructor: VenueSequence = 0.
public MboEvent(long SequenceNumber, DateTime ExchangeTimestampUtc, string InstrumentId,
    string OrderId, Side Side, MboAction Action, double Price, long Size,
    ulong QueuePriority, double PrevPrice);

MboAction

Lifecycle of an MBO event (an enum : byte): the exchange's new / change / delete order messages.

Side

Side of the book a depth or order event applies to (an enum : byte). Two-valued: every depth event is sided at the source (aggressor classification on a trade is separate, via TickFlags).

OrderBookDepthMode

Which feed currently authors an IOrderBook (an enum : byte, read through IOrderBook.DepthMode). A venue that grants both streams starts per-order and falls back to aggregated when its market-by-order book cannot be recovered; the change is announced as OrderBookLifecycleEvent.DepthModeChanged.

OrderBookLifecycleEvent

A transition of the shared book that invalidates state a consumer derived from earlier depth or MBO callbacks (an enum : byte). Delivered through IIndicator.OnOrderBookLifecycle; each value names what has already happened to the book when the callback runs.

Depth-hub diagnostics

Recorded tapes: SabrTrader.Pipeline.Storage

The platform's recorder writes an instrument's L2 / MBO stream to disk together with the control markers a reader needs to rebuild the book. Live indicator callbacks are sampled; the tape is the complete record. The user starts recording from the platform's recording window. Add using SabrTrader.Pipeline.Storage;.

Tape items and the catalog ambient

IRecordedDepthCatalog

Read seam over the recorded tapes, reached from an indicator through IIndicatorContext.RecordedDepth (null when the host records none). Tapes are keyed by DepthStoreKey (venue provider key + instrument); a null cursor means the store has no coverage of the window. Reads run beside the live feed without blocking it. DepthStoreKeyInfo is (Key, ItemCount, FirstUtc, LastUtc, ApproxByteSize).

IRecordedDepthCatalog.cspublic interface IRecordedDepthCatalog
{
    IMboCursor? OpenMbo(DepthStoreKey key, DateTime fromUtc, DateTime toUtcExclusive);
    IDepthCursor? OpenDepth(DepthStoreKey key, DateTime fromUtc, DateTime toUtcExclusive);
    IHeatmapSidecarCursor? OpenHeatmap(DepthStoreKey key, DateTime fromUtc, DateTime toUtcExclusive);

    ITickTapeCursor? OpenTicks(DepthStoreKey key, DateTime fromUtc, DateTime toUtcExclusive);

    IReadOnlyList<DepthStoreKey> EnumerateMboKeys();     // every key with an MBO tape
    IReadOnlyList<DepthStoreKey> EnumerateDepthKeys();   // every key with an L2 tape
    IReadOnlyList<DepthStoreKey> EnumerateTickKeys();    // every key with a tick tape
    DepthStoreKeyInfo? DescribeMbo(DepthStoreKey key);       // coverage, or null
    DepthStoreKeyInfo? DescribeDepth(DepthStoreKey key);
    DepthStoreKeyInfo? DescribeTicks(DepthStoreKey key);

    // Which parts of a window are actually on disk - ask before you plan a read.
    IReadOnlyList<DateRange> GetRecordedMboRanges(DepthStoreKey key, DateTime fromUtc, DateTime toUtcExclusive);
    IReadOnlyList<DateRange> GetRecordedDepthRanges(DepthStoreKey key, DateTime fromUtc, DateTime toUtcExclusive);
    IReadOnlyList<DateRange> GetRecordedTickRanges(DepthStoreKey key, DateTime fromUtc, DateTime toUtcExclusive);
}

public readonly struct DepthStoreKey : IEquatable<DepthStoreKey>
{
    public DepthStoreKey(string providerKey, string instrumentId);
    public string ProviderKey { get; }
    public string InstrumentId { get; }
}

public interface IMboCursor : IDisposable
{
    bool MoveNext();          // false when the window is exhausted
    MboTapeItem Current { get; }
}

public readonly record struct MboTapeItem(
    DepthTapeMarker Marker,
    DateTime ExchangeTimestampUtc,   // the marker time when Marker is not Event
    MboEvent Event);                 // default when Marker is not Event

DepthTapeMarker

Control records on a tape (an enum : byte). Events are the payload; the rest bracket reconnects, venue images, capture loss and recording sessions, so a reader knows which stretches of book are trustworthy.

Example: reading the book from an indicator

DepthImbalance.csusing System;
using SabrTrader.Pipeline.Indicators;
using SabrTrader.Pipeline.MarketDepth;

// Inside an IndicatorBase subclass whose constructor sets ProcessesMarketDepth = true.
private double _imbalance;              // top-of-book imbalance in [-1, 1]: positive = bid-heavy
private OrderBookSnapshot? _snapshot;   // frozen copy for a render thread

public override void OnMarketDepth(in DepthUpdate update, IIndicatorContext ctx)
{
    // ReadOrderBook runs the reader under the host's book lock.
    ctx.ReadOrderBook(book =>
    {
        double bid = book.BestBidPrice, ask = book.BestAskPrice;
        if (double.IsNaN(bid) || double.IsNaN(ask)) return;   // one side empty

        long bidSize = book.GetLevel(Side.Bid, bid)?.Size ?? 0;
        long askSize = book.GetLevel(Side.Ask, ask)?.Size ?? 0;
        long total = bidSize + askSize;
        _imbalance = total == 0 ? 0 : (double)(bidSize - askSize) / total;

        // Capture inside the reader so the copy is consistent.
        _snapshot = OrderBookSnapshot.Capture(book, DateTime.UtcNow, maxLevelsPerSide: 20);
    });
}

Example: rebuilding order lifecycles from the tape

QueueAudit.csusing System;
using SabrTrader.Pipeline.Indicators;
using SabrTrader.Pipeline.MarketDepth;
using SabrTrader.Pipeline.Storage;

// Off the hot path (a toolbar action, a background task): replay one hour of an
// instrument's MBO tape into a private book and measure how long orders rested.
static void Audit(IIndicatorContext ctx, string instrumentId, DateTime fromUtc)
{
    IRecordedDepthCatalog? tapes = ctx.RecordedDepth;
    if (tapes is null) return;                        // this host records nothing

    DepthStoreKey? found = null;
    foreach (var k in tapes.EnumerateMboKeys())
        if (k.InstrumentId == instrumentId) { found = k; break; }
    if (found is not { } key) return;                 // never recorded

    using IMboCursor? cursor = tapes.OpenMbo(key, fromUtc, fromUtc.AddHours(1));
    if (cursor is null) return;                       // no coverage of that window

    var book = new OrderBook(key.InstrumentId);
    book.OrderRemoved += (entry, removedAtUtc) =>
    {
        TimeSpan rested = removedAtUtc - entry.FirstSeenUtc;
        // record `rested` for entry.Side / entry.Price ...
    };

    bool complete = true;                             // false once a Gap sits inside the window
    while (cursor.MoveNext())
    {
        MboTapeItem item = cursor.Current;
        switch (item.Marker)
        {
            case DepthTapeMarker.Event:
                MboEvent evt = item.Event;
                book.ApplyMbo(in evt);
                break;
            case DepthTapeMarker.Reset:
            case DepthTapeMarker.ReimageBegin:
                book.Clear();                         // everything before is superseded
                break;
            case DepthTapeMarker.Gap:
                complete = false;                     // lifecycles across this point are unknowable
                break;
        }
    }
    // complete == true: every order that appeared in the window has a certain fate.
}