The OHLCV bar value type, the bar-specification records that identify a series, the builder interfaces that construct bars from ticks, per-instrument metadata, and the barsAgo-indexed series you read in OnBarUpdate. Namespaces SabrTrader.Pipeline.Bars and SabrTrader.Pipeline.Series.

Bar

SabrTrader.Pipeline.Bars · a readonly record struct passed by value through pipeline callbacks. For non-time bars there is no fixed period: EndUtc is the timestamp of the closing tick. Disk and memory caches persist only the UTC instants; display fields are chart-boundary and must not be written to cache.

Bar.cspublic readonly record struct Bar(
    DateTime StartUtc,
    DateTime EndUtc,
    double Open,
    double High,
    double Low,
    double Close,
    long Volume,
    long TickCount,
    DateTime StartDisplay = default,
    DateTime EndDisplay = default)
{
    public DateTime Start => StartDisplay == default ? StartUtc : StartDisplay;
    public DateTime End   => EndDisplay   == default ? EndUtc   : EndDisplay;

    public Bar WithChartDisplay(TimeZoneInfo tz);
    public Bar WithoutChartDisplay();
}

ChartDisplayTime

SabrTrader.Pipeline.Time · converts true UTC ↔ display-as-Utc-kind. The host uses this to stamp bars; indicators use it to overlay an external UTC instant (news, prints, OrderFlowBarStats.FirstTradeUtc) onto the chart timeline.

ChartDisplayTime.cspublic static class ChartDisplayTime
{
    // True UTC → display-zone wall-clock tagged DateTimeKind.Utc. Identity when tz is UTC.
    public static DateTime FromUtc(DateTime utc, TimeZoneInfo tz);

    // Inverse: display-as-Utc-kind → true UTC.
    public static DateTime ToUtc(DateTime displayAsUtcKind, TimeZoneInfo tz);
}

Never write FromUtc's result into a field named *Utc. IIndicatorContext.DisplayTimeZone is the zone to pass; treat null as "already on the bar timeline / no shift".

BarSpecification

An abstract record that is the identity of a series: comparable by value, hashable, serialisable. Two consumers asking for the same spec share one builder and one output series. A new bar type is one record plus one builder.

BarSpecification.cspublic abstract record BarSpecification(string InstrumentId)
{
    public string? ContinuousRoot { get; init; }
    public BarAdjustmentMode ContinuousAdjustment { get; init; } = BarAdjustmentMode.BackAdjusted;
    public string? TradingHoursTemplateName { get; init; }
    public bool ResetOnNewTradingDay { get; init; } = true;
    public string? Exchange { get; init; }
    public BarBuildSource BuildSource { get; init; }   // Native (default) or Ticks
    public string RollStableInstrumentId { get; }   // ContinuousRoot ?? InstrumentId

    public abstract string DisplayName { get; }
    public virtual bool EndsOnTimeGrid => false;
    public virtual bool OffersBuildSourceChoice => false;   // true for Tick, Volume, Range

    public virtual BarSpecification WithInstrumentId(string newInstrumentId) => this;
    public BarSpecification WithContinuous(string? continuousRoot, BarAdjustmentMode adjustment);
    public BarSpecification WithTradingHours(string? templateName);
    public BarSpecification WithTradingHours(string? templateName, bool resetOnNewTradingDay);
    public BarSpecification WithExchange(string? exchange);
    public BarSpecification WithBuildSource(BarBuildSource buildSource);
}

BarConstruction

Static helpers that say how a spec's bars are cut. Use them instead of type-switching on specs when a calculation depends on what a bar's timestamps mean.

BarConstruction.cspublic static class BarConstruction
{
    public static bool IsBuiltFromTrades(BarSpecification spec);
    public static bool IsCutOnTrades(BarSpecification spec);
}

Both throw ArgumentNullException for a null spec. Any spec not named above, including a plugin spec, answers true to both.

Pair them with EndsOnTimeGrid when you match trades to bars yourself:

Matching a trade to a barusing SabrTrader.Pipeline.Bars;

// Does a trade stamped t belong to this closed bar?
static bool Holds(BarSpecification spec, in Bar bar, DateTime t)
    => spec.EndsOnTimeGrid
        ? t >= bar.StartUtc && t < bar.EndUtc    // grid end is exclusive: t == EndUtc is the next bar
        : t >= bar.StartUtc && t <= bar.EndUtc;  // the bar ends on its own last trade

// Trade-built bars can share a timestamp, so never key them by time alone.
static bool TimestampsAreUnique(BarSpecification spec)
    => !BarConstruction.IsBuiltFromTrades(spec);

Concrete bar specs

All sealed record in SabrTrader.Pipeline.Bars. Each overrides DisplayName and WithInstrumentId.

BarSpecification.cspublic sealed record TimeBarSpec(string InstrumentId, TimeSpan Period) : BarSpecification(InstrumentId);
public sealed record TickBarSpec(string InstrumentId, int Ticks) : BarSpecification(InstrumentId);
public sealed record VolumeBarSpec(string InstrumentId, long Volume,
    OversizedTradePolicy OversizedTrades = OversizedTradePolicy.SplitAcrossBars) : BarSpecification(InstrumentId);
public sealed record RangeBarSpec(string InstrumentId, int RangeTicks) : BarSpecification(InstrumentId);
public sealed record RenkoBarSpec(string InstrumentId, int BrickTicks, bool WithWicks = false) : BarSpecification(InstrumentId);
public sealed record MedianRenkoBarSpec(string InstrumentId, int BrickTicks, int TrendThresholdTicks) : BarSpecification(InstrumentId);
public sealed record KagiBarSpec(string InstrumentId, int ReversalTicks,
    BarSpecification? Underlying = null, KagiReversalType ReversalType = KagiReversalType.Tick) : BarSpecification(InstrumentId);
public sealed record PointAndFigureBarSpec(string InstrumentId, int BoxTicks, int Reversal,
    BarSpecification? Underlying = null, PointAndFigurePriceType PriceType = PointAndFigurePriceType.Close) : BarSpecification(InstrumentId);
public sealed record LineBreakBarSpec(string InstrumentId, int LineCount,
    BarSpecification? Underlying = null) : BarSpecification(InstrumentId);

public enum KagiReversalType        { Tick, Percent }
public enum PointAndFigurePriceType { Close, HighLow }

// Distance units a price gap can be expressed in (PriceDistanceFormatter converts between them).
public enum DistanceUnit { Price, Tick, Point, Pip }
public sealed record HeikinAshiBarSpec(string InstrumentId, BarSpecification Underlying) : BarSpecification(InstrumentId);
public sealed record UniRenkoBarSpec(string InstrumentId, int BrickTicks, int TrendThresholdTicks, int ReversalTicks)
    : BarSpecification(InstrumentId);

BarAdjustmentMode · OversizedTradePolicy

BarAdjustmentMode.cspublic enum BarAdjustmentMode { None, BackAdjusted, RatioAdjusted }
public enum OversizedTradePolicy { KeepAtomic, SplitAcrossBars }

IBarBuilder

Shared metadata every builder exposes. HasCurrentBar is false until the first bar starts; reading CurrentBar while false throws.

IBarBuilder.cspublic interface IBarBuilder
{
    BarSpecification Spec { get; }
    bool HasCurrentBar { get; }
    Bar CurrentBar { get; }
}

ITickBarBuilder

Tick-driven builders (Time, Tick, Volume, Range, Renko, …). They consume only TickFlags.Trade ticks. OnTick writes newly-closed bars into a caller-supplied span and returns the count (0 mid-bar, 1 typical, 2 or more on a gap).

IBarBuilder.cspublic interface ITickBarBuilder : IBarBuilder
{
    int OnTick(in Tick tick, Span<Bar> closedBars);
    bool HasPendingClosedBars => false;
    int DrainPendingClosedBars(Span<Bar> closedBars) => 0;

    bool ClosingTickBelongsToNextBar => false;
    bool ResetsOnSessionBoundary => true;
    bool ExposesFormingBar => true;

    int ForceCloseCurrentBar(Span<Bar> closedBars) => 0;
    int ForceCloseAtSessionEnd(DateTime sessionEnd, Span<Bar> closedBars) => ForceCloseCurrentBar(closedBars);
    void BeginSession(DateTime sessionBegin) { }
}

IDerivedBarBuilder

Builders whose input is another series' closed-bar stream (the host's Heikin-Ashi, Kagi, Point & Figure and Line Break). Plugin discovery binds ITickBarBuilder only; see A derived bar.

IBarBuilder.cspublic interface IDerivedBarBuilder : IBarBuilder
{
    int OnSourceBarClosed(in Bar sourceBar, Span<Bar> closedBars);
    void PreviewSourceBar(in Bar developingSourceBar);
}

Derived-builder capabilities

Opt-in interfaces an IDerivedBarBuilder may also implement. Neither is required; a builder without them rebuilds from its source series.

Seeding capabilities

Opt-in interfaces the history-to-live handoff probes so the first live tick continues the series. A builder implements whichever applies.

ISeedableBarBuilder.cspublic readonly record struct BarSeedResult(bool Seeded, DateTime Cutoff, bool LastSeriesBarIsInProgress)
{
    public static readonly BarSeedResult NotSeeded;
}

public interface ISeedableBarBuilder
{
    BarSeedResult SeedFromLastBar(in Bar lastBar, DateTime nowUtc);
}

public interface ISeedableDerivedBarBuilder
{
    void SeedFromLastDerivedBar(in Bar lastDerivedBar);
}

public interface IHistorySeedableBarBuilder
{
    BarSeedResult SeedFromHistory(IBarSeries series, DateTime nowUtc);
}

IInstrumentMetadata

Per-instrument static metadata the runtime needs, most importantly GetTickSize, used by range / Renko builders. InMemoryInstrumentMetadata is the public thread-safe fixture/registry.

IInstrumentMetadata.cspublic interface IInstrumentMetadata
{
    double GetTickSize(string instrumentId);
    bool IsRegistered(string instrumentId);

    double? TryGetPointValue(string instrumentId) => null;
    QuantityUnit GetQuantityUnit(string instrumentId) => QuantityUnit.Contract;
    double? TryGetLotSize(string instrumentId) => null;
    double? TryGetQuantityStep(string instrumentId) => null;
    double? TryGetMinQuantity(string instrumentId) => null;
    string? TryGetQuoteCurrency(string instrumentId) => null;
    string? TryGetAdjustmentVersion(string instrumentId) => null;
    InstrumentCategory? TryGetCategory(string instrumentId) => null;

    // Multi-asset facets: forex/crypto sizing and contract shape.
    double? TryGetPipSize(string instrumentId) => null;
    double? TryGetContractSize(string instrumentId) => null;
    double? TryGetMaxLeverage(string instrumentId) => null;
    double? TryGetSizeMultiplier(string instrumentId) => null;
    bool? TryGetIsInverse(string instrumentId) => null;
    int? TryGetPriceSignificantFigures(string instrumentId) => null;
}

InMemoryInstrumentMetadata.Register(instrumentId, tickSize, pointValue?, quantityUnit?, lotSize?, quantityStep?, minQuantity?, quoteCurrency?, adjustmentVersion?, category?, pipSize?, contractSize?, maxLeverage?, isInverse?, sizeMultiplier?, priceSignificantFigures?) populates the registry and returns it for chaining; only tickSize is required.

QuantityUnit

QuantityUnit.cspublic enum QuantityUnit { Contract = 0, Share, Lot, Unit, Coin }

InstrumentCategory

A venue's explicit asset-class signal, used when QuantityUnit alone is ambiguous (a forex pair and a metal/index CFD are both Lot/Unit). Carried nullable everywhere; null is the single canonical "no category reported", so the enum has no Unknown value.

InstrumentCategory.cspublic enum InstrumentCategory { Forex, Equity, Crypto, Index, Commodity, Metal, Bond, Future }

Metadata & formatting helpers

Small statics in SabrTrader.Pipeline.Bars that exist so every surface formats and resolves the same way. None of them is required to build a bar type; they are here because a plugin that renders a distance or a quantity should not invent its own rounding.

IBarSeries

SabrTrader.Pipeline.Series · read-only bar series with NinjaTrader-style barsAgo indexing: this[0] is the current bar, this[1] the one before. Backed by a power-of-2 ring (struct-of-arrays); Count is monotonic, the largest legal barsAgo is Math.Min(Count, Capacity) - 1.

ISeries.cspublic interface IBarSeries
{
    BarSpecification Spec { get; }
    int SeriesIndex { get; }
    int Count { get; }
    int Capacity { get; }

    Bar this[int barsAgo] { get; }
    bool TryGet(int barsAgo, out Bar bar);

    bool TryReadCloseSpan (int fromBarsAgo, int count, out ReadOnlySpan<double> firstSlice, out ReadOnlySpan<double> secondSlice);
    bool TryReadOpenSpan  (int fromBarsAgo, int count, out ReadOnlySpan<double> firstSlice, out ReadOnlySpan<double> secondSlice);
    bool TryReadHighSpan  (int fromBarsAgo, int count, out ReadOnlySpan<double> firstSlice, out ReadOnlySpan<double> secondSlice);
    bool TryReadLowSpan   (int fromBarsAgo, int count, out ReadOnlySpan<double> firstSlice, out ReadOnlySpan<double> secondSlice);
    bool TryReadVolumeSpan(int fromBarsAgo, int count, out ReadOnlySpan<long>   firstSlice, out ReadOnlySpan<long>   secondSlice);

    ISeries<double> Close { get; }
    ISeries<double> High { get; }
    ISeries<double> Low { get; }
    ISeries<double> Open { get; }
    ISeries<double> Volume { get; }
    ISeries<double> Typical { get; }   // (H+L+C)/3
    ISeries<double> Median { get; }    // (H+L)/2
    ISeries<double> Weighted { get; }  // (H+L+2C)/4
    ISeries<double> OHLC4 { get; }     // (O+H+L+C)/4
}

ISeries<T>

Read-only generic series: the shape indicator output plots expose. Warmup positions hold double.NaN for double-typed series.

ISeries.cspublic interface ISeries<T> where T : struct
{
    int Count { get; }
    int Capacity { get; }
    T this[int barsAgo] { get; }
    bool TryGet(int barsAgo, out T value);
}

IBarSourcedSeries

Marker on an ISeries<double> that knows the IBarSeries it was derived from. The indicator framework uses it to resolve a child's primary bars in indicator-of-indicator chains.

IBarSourcedSeries.cspublic interface IBarSourcedSeries
{
    IBarSeries SourceBars { get; }
}

ChunkedSeries<T>

The public writable backing for indicator output. ISeries<T> + IClearableSeries; grows without bound (4096-slot chunks), single-writer / multi-reader, NaN-aware for warmup. this[0] is the newest value.

ChunkedSeries.cspublic sealed class ChunkedSeries<T> : ISeries<T>, IClearableSeries where T : struct
{
    public int Count { get; }
    public int Capacity { get; }            // int.MaxValue (unbounded)
    public T this[int barsAgo] { get; }
    public bool TryGet(int barsAgo, out T value);

    public void Append(T value);            // becomes the new this[0]
    public void UpdateLast(T value);        // rewrite the newest value (intra-bar)
    public void Set(int barsAgo, T value);  // rewrite at an arbitrary offset (swing/pivot backfill)
    public void Clear();                    // drop all values, Count -> 0
}

IClearableSeries

Opt-in: a mutable series that can be reset to empty in place. The recalc path clears values without reallocating, so the chart's IPlot.Values references never dangle.

IClearableSeries.cspublic interface IClearableSeries
{
    void Clear();
}