feat(data-layer): TickAggregator (tick-to-candle) in all 10 languages (#309)

* feat(data-layer): TickAggregator in Node, WASM, Python + C ABI hub

First data-layer feature (F2): roll trade ticks up into fixed-timeframe OHLCV
candles, exposed natively and over the C ABI.

- wickra-data wired as a binding dependency (workspace dep; its wickra-core dep
  is default-features=false so it never forces rayon into the rayon-free WASM
  build — native bindings re-enable parallel through their own dependency).
- Node `TickAggregator(bucket, gapFill?)` -> `push(price, size, ts): Candle[]`;
  WASM the same (array of objects); Python `push(...) -> list[tuple]`.
- C ABI: `WickraCandle` struct + `wickra_tick_aggregator_new/push/free` (push
  writes candles into a caller buffer and returns the count), generated via the
  capi generator's new DATA_LAYER section; cbindgen now parses wickra-data so
  `TickAggregator` is a forward-declared opaque; header vendored to bindings/go.

Verified bit-identical across Node/WASM/Python/C/C++ (o=100 h=101 l=100 c=101
v=3 ts=0 for the shared 3-tick probe). WIP: Go/C#/Java/R generated bindings and
the cross-language golden are still pending.

* feat(data-layer): TickAggregator in Go, C#, Java, R (lossless push/drain)

Complete F2 across all 10 languages: the C-ABI tick aggregator now uses a
two-step push/drain so gap-fill candles are never lost, and the four generated
bindings expose it idiomatically.

- C ABI redesigned: opaque TickAggregator handle (inner aggregator + pending
  buffer); push consumes a tick and returns the closed-candle count, drain copies
  them into a count-sized caller buffer.
- Go: NewTickAggregator + Push(price,size,ts) []Candle; C#: TickAggregator +
  Candle[] Push(...); Java: TickAggregator + Candle[] push(...); R: TickAggregator
  constructor + push() S3 generic returning an (n x 6) numeric matrix.
- Candle output record generated per language from WickraCandle.

Verified bit-identical to the native bindings (o=100 h=101 l=100 c=101 v=3 ts=0)
in Go, C#, Java, and R at runtime; R passes R CMD check (pre-existing doc
warnings only). WIP: cross-language data-layer golden + CHANGELOG still pending.

* test(data-layer): cross-language golden for the tick aggregator + CHANGELOG

gen_golden emits a deterministic tick stream (testdata/golden/data_ticks.csv) and
the reference candle streams with and without gap filling (data_candles.csv,
data_candles_gap.csv). Every binding replays the shared ticks through its
TickAggregator and checks the candles bit-for-bit (fp tolerance) against the Rust
reference:

- Node / WASM / Python / Go / C# / Java / R: a dedicated parity test each.
- C / C++: data_layer_test.c (compiled as both, run as ctest).

The gap-fill fixture closes several candles from a single push, exercising the
lossless push/drain path. Records the feature under CHANGELOG [Unreleased].

* fix(examples): rename the CSV-loader candle to WickraBar

The example CSV helper (wickra_csv.h) defined its own struct WickraCandle, which
now collides with the public C ABI WickraCandle (the tick aggregator output) in
any example that includes both headers (backtest, multi_timeframe, the strategy
examples). The public type owns the name; rename the example loader's bar to
WickraBar. The generated golden_test.c is untouched (its only match was the
unrelated WickraCandleVolumeOutput).

bindings/node/Cargo.toml

@@ -25,6 +25,7 @@ workspace = true
 
 [dependencies]
 wickra-core = { workspace = true }
+wickra-data = { workspace = true }
 napi = { version = "2.16", features = ["napi8"] }
 napi-derive = "2.16"
 

bindings/node/__tests__/data_layer.test.js

@@ -0,0 +1,53 @@
+// Cross-language data-layer parity for the Node binding: replay the shared
+// golden tick stream through the TickAggregator and check the candles bit-for-bit
+// (within fp tolerance) against the Rust-generated fixtures, with and without
+// gap filling. Fixtures are produced by `cargo run -p wickra-examples --bin
+// gen_golden`.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { TickAggregator } = require('..');
+
+const GOLDEN = path.resolve(__dirname, '..', '..', '..', 'testdata', 'golden');
+
+function readCsv(name) {
+  const lines = fs.readFileSync(path.join(GOLDEN, `${name}.csv`), 'utf8').split(/\r?\n/);
+  lines.shift();
+  return lines.filter((l) => l.length > 0).map((l) => l.split(',').map(Number));
+}
+
+const TICKS = readCsv('data_ticks');
+
+function run(gapFill) {
+  const agg = new TickAggregator(1000, gapFill);
+  const out = [];
+  for (const [price, size, ts] of TICKS) {
+    for (const c of agg.push(price, size, ts)) {
+      out.push([c.open, c.high, c.low, c.close, c.volume, c.timestamp]);
+    }
+  }
+  return out;
+}
+
+function assertCandles(got, want, label) {
+  assert.equal(got.length, want.length, `${label}: candle count ${got.length} vs ${want.length}`);
+  for (let i = 0; i < got.length; i++) {
+    for (let j = 0; j < 6; j++) {
+      const tol = 1e-9 * Math.max(1, Math.abs(want[i][j]));
+      assert.ok(
+        Math.abs(got[i][j] - want[i][j]) <= tol,
+        `${label} row ${i} col ${j}: ${got[i][j]} vs ${want[i][j]}`,
+      );
+    }
+  }
+}
+
+test('tick aggregator matches the golden candles', () => {
+  assertCandles(run(false), readCsv('data_candles'), 'no-gap');
+});
+
+test('tick aggregator gap-fill matches the golden candles', () => {
+  assertCandles(run(true), readCsv('data_candles_gap'), 'gap');
+});

bindings/node/index.d.ts

@@ -594,6 +594,15 @@ export interface VolumeWeightedMacdValue {
   signal: number
   histogram: number
 }
+/** One aggregated OHLCV candle emitted by [`TickAggregatorNode`]. */
+export interface CandleValue {
+  open: number
+  high: number
+  low: number
+  close: number
+  volume: number
+  timestamp: number
+}
 export type SmaNode = SMA
 export declare class SMA {
   constructor(period: number)
@@ -5930,3 +5939,21 @@ export declare class VolumeWeightedMacd {
   isReady(): boolean
   warmupPeriod(): number
 }
+export type TickAggregatorNode = TickAggregator
+/** Roll trade ticks up into fixed-timeframe OHLCV candles. */
+export declare class TickAggregator {
+  /**
+   * Construct an aggregator with the given bucket size (in the same unit as
+   * the tick timestamps). Pass `gapFill = true` to emit a flat placeholder
+   * candle for every skipped bucket.
+   */
+  constructor(bucket: number, gapFill?: boolean | undefined | null)
+  /**
+   * Push one trade tick; returns every candle that closed as a result (none
+   * while the open bar keeps growing, one on a bucket boundary, plus one flat
+   * candle per skipped bucket when gap filling is enabled).
+   */
+  push(price: number, size: number, timestamp: number): Array<CandleValue>
+  /** Whether gap filling is enabled. */
+  fillsGaps(): boolean
+}

bindings/node/src/lib.rs

@@ -21865,3 +21865,75 @@ impl VolumeWeightedMacdNode {
         self.inner.warmup_period() as u32
     }
 }
+
+// ===== Data layer: tick-to-candle aggregation =====
+
+/// Convert a `wickra-data` error into a JS error.
+fn map_data_err(e: wickra_data::Error) -> NapiError {
+    NapiError::new(Status::InvalidArg, e.to_string())
+}
+
+/// One aggregated OHLCV candle emitted by [`TickAggregatorNode`].
+#[napi(object)]
+pub struct CandleValue {
+    pub open: f64,
+    pub high: f64,
+    pub low: f64,
+    pub close: f64,
+    pub volume: f64,
+    pub timestamp: f64,
+}
+
+/// Roll trade ticks up into fixed-timeframe OHLCV candles.
+#[napi(js_name = "TickAggregator")]
+pub struct TickAggregatorNode {
+    inner: wickra_data::aggregator::TickAggregator,
+}
+
+#[napi]
+impl TickAggregatorNode {
+    /// Construct an aggregator with the given bucket size (in the same unit as
+    /// the tick timestamps). Pass `gapFill = true` to emit a flat placeholder
+    /// candle for every skipped bucket.
+    #[napi(constructor)]
+    pub fn new(bucket: f64, gap_fill: Option<bool>) -> napi::Result<Self> {
+        let timeframe =
+            wickra_data::aggregator::Timeframe::new(bucket as i64).map_err(map_data_err)?;
+        let mut inner = wickra_data::aggregator::TickAggregator::new(timeframe);
+        if gap_fill.unwrap_or(false) {
+            inner = inner.with_gap_fill(true);
+        }
+        Ok(Self { inner })
+    }
+
+    /// Push one trade tick; returns every candle that closed as a result (none
+    /// while the open bar keeps growing, one on a bucket boundary, plus one flat
+    /// candle per skipped bucket when gap filling is enabled).
+    #[napi]
+    pub fn push(
+        &mut self,
+        price: f64,
+        size: f64,
+        timestamp: f64,
+    ) -> napi::Result<Vec<CandleValue>> {
+        let tick = wc::Tick::new(price, size, timestamp as i64).map_err(map_err)?;
+        let candles = self.inner.push(tick).map_err(map_data_err)?;
+        Ok(candles
+            .into_iter()
+            .map(|c| CandleValue {
+                open: c.open,
+                high: c.high,
+                low: c.low,
+                close: c.close,
+                volume: c.volume,
+                timestamp: c.timestamp as f64,
+            })
+            .collect())
+    }
+
+    /// Whether gap filling is enabled.
+    #[napi(js_name = "fillsGaps")]
+    pub fn fills_gaps(&self) -> bool {
+        self.inner.fills_gaps()
+    }
+}