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 TradeStrike.Pipeline.Bars and TradeStrike.Pipeline.Series.

Bar

TradeStrike.Pipeline.Bars · a readonly record struct (64 bytes, passed by value through pipeline callbacks). For non-time bars there is no fixed period — EndUtc is the timestamp of the closing tick.

Bar.cspublic readonly record struct Bar(
    DateTime StartUtc,
    DateTime EndUtc,
    double Open,
    double High,
    double Low,
    double Close,
    long Volume,
    long TickCount);

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. Adding a bar type is one new record plus one builder; no core changes.

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 abstract string DisplayName { get; }

    public virtual BarSpecification WithInstrumentId(string newInstrumentId) => this;
    public BarSpecification WithContinuous(string? continuousRoot, BarAdjustmentMode adjustment);
    public BarSpecification WithTradingHours(string? templateName, bool resetOnNewTradingDay = true);
}

Concrete bar specs

All sealed record in TradeStrike.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.KeepAtomic) : 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(InstrumentId);
public sealed record PointAndFigureBarSpec(string InstrumentId, int BoxTicks, int Reversal) : BarSpecification(InstrumentId);
public sealed record LineBreakBarSpec(string InstrumentId, int LineCount) : BarSpecification(InstrumentId);
public sealed record HeikinAshiBarSpec(string InstrumentId, BarSpecification Underlying) : 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, N ≥ 2 on a gap).

IBarBuilder.cspublic interface ITickBarBuilder : IBarBuilder
{
    int OnTick(in Tick tick, Span<Bar> closedBars);

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

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

IDerivedBarBuilder

Builders whose input is another series' closed-bar stream (e.g. Heikin Ashi).

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

IBarBuilderFactory

Resolves a spec to a freshly-constructed builder. Plugins register a custom spec + builder via the host's DefaultBarBuilderFactory.Register<TSpec>, or supply their own factory.

IBarBuilderFactory.cspublic interface IBarBuilderFactory
{
    IBarBuilder Create(BarSpecification spec);
    bool Supports(BarSpecification spec);
}

Seeding capabilities

Opt-in interfaces the historical→live handoff probes so the first live tick continues the series seamlessly. 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;
}

InMemoryInstrumentMetadata.Register(instrumentId, tickSize, pointValue?, quantityUnit?, lotSize?, quantityStep?, minQuantity?, quoteCurrency?, adjustmentVersion?, category?) populates the registry; 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" — there is deliberately no Unknown.

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

IBarSeries

TradeStrike.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();
}