feat(data-layer): Resampler (candle resampling) in all 10 languages (#310)

* feat(data-layer): Resampler (candle resampling) in all 10 languages

Second data-layer feature (F3): resample candles into a higher timeframe.

- Native (Node.js/WASM): new Resampler(timeframe) -> update(o,h,l,c,v,ts):
  Candle|null + flush(): Candle|null. Python the same -> tuple|None.
- C ABI: wickra_resampler_new/update/flush/free (update has the multi-output
  shape so the generators auto-emit it; flush is bespoke). Go Update -> (Candle,
  bool) + Flush; C# Candle? Update/Flush; Java Candle update/flush; R update()
  generic + a flush() S3 method (extends base::flush); C/C++ direct.
- Cross-language golden (testdata/golden/data_resampled.csv): the shared input
  candles resampled into 5-unit buckets, the final partial bucket via flush,
  pinned bit-for-bit across every binding.

Verified locally in all 10 (3 candles for the 5-unit smoke; 16 for the golden).
The WickraCandle output record is shared with the tick aggregator (deduped).

* test(node): exclude data-layer types from the indicator completeness contract

The Resampler exposes update(), so the completeness test flagged it as an
indicator and required batch/reset/isReady/warmupPeriod, which a data-layer type
does not have. Exclude TickAggregator and Resampler like the bar builders.

CHANGELOG.md

@@ -8,6 +8,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- **Candle resampling in all 10 languages (data layer).** The `Resampler`
+  aggregates candles into a higher timeframe (e.g. 1m → 5m): `update(open, high,
+  low, close, volume, timestamp)` returns the completed higher-timeframe candle on
+  a bucket boundary (else `null`/`None`/`NA`), and `flush()` emits the final,
+  still-open candle. Exposed natively (Node.js / WASM / Python) and over the C ABI
+  (Go / C# / Java return `(Candle, bool)` / `Candle?` / `Candle`; R via `update()`
+  and a `flush()` S3 method; C / C++ directly). A cross-language golden
+  (`testdata/golden/data_resampled.csv`) pins the resampled stream identically.
 - **Tick-to-candle aggregation in all 10 languages (data layer).** The
   `TickAggregator` — roll trade ticks up into fixed-timeframe OHLCV candles, with
   optional gap filling — is now exposed natively (Node.js / WASM `push(price,

bindings/c/include/wickra.h

@@ -678,6 +678,8 @@ typedef struct RenkoBars RenkoBars;
 
 typedef struct RenkoTrailingStop RenkoTrailingStop;
 
+typedef struct Resampler Resampler;
+
 typedef struct RickshawMan RickshawMan;
 
 typedef struct RisingThreeMethods RisingThreeMethods;
@@ -13719,6 +13721,21 @@ intptr_t wickra_tick_aggregator_drain(struct TickAggregator *handle,
 
 void wickra_tick_aggregator_free(struct TickAggregator *handle);
 
+struct Resampler *wickra_resampler_new(int64_t timeframe);
+
+bool wickra_resampler_update(struct Resampler *handle,
+                             double open,
+                             double high,
+                             double low,
+                             double close,
+                             double volume,
+                             int64_t timestamp,
+                             struct WickraCandle *out);
+
+bool wickra_resampler_flush(struct Resampler *handle, struct WickraCandle *out);
+
+void wickra_resampler_free(struct Resampler *handle);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus

bindings/c/src/lib.rs

@@ -116,6 +116,8 @@ use wickra_core::{
 
 use wickra_data::aggregator::{TickAggregator as DataTickAggregator, Timeframe};
 
+use wickra_data::resample::Resampler;
+
 // ===== Scalar indicators (f64 -> f64) =====
 
 /// Create a `AdaptiveCycle` indicator.
@@ -68188,6 +68190,102 @@ pub unsafe extern "C" fn wickra_tick_aggregator_free(handle: *mut TickAggregator
     }
 }
 
+/// Convert a core candle into the C-ABI view.
+fn candle_to_c(candle: Candle) -> WickraCandle {
+    WickraCandle {
+        open: candle.open,
+        high: candle.high,
+        low: candle.low,
+        close: candle.close,
+        volume: candle.volume,
+        timestamp: candle.timestamp,
+    }
+}
+
+/// Create a resampler aggregating input candles into `timeframe`-sized candles
+/// (the same unit as the candle timestamps). Returns `NULL` on a non-positive
+/// timeframe; release with `wickra_resampler_free`.
+#[no_mangle]
+pub extern "C" fn wickra_resampler_new(timeframe: i64) -> *mut Resampler {
+    match Timeframe::new(timeframe) {
+        Ok(tf) => Box::into_raw(Box::new(Resampler::new(tf))),
+        Err(_) => ptr::null_mut(),
+    }
+}
+
+/// Push one candle. On `true` the completed higher-timeframe candle is written to
+/// `*out`; `false` means none closed yet (still aggregating), a `NULL` handle /
+/// `out`, or an invalid input candle.
+///
+/// # Safety
+/// `handle` (from `wickra_resampler_new`, not freed) and `out` must be valid or `NULL`.
+#[no_mangle]
+pub unsafe extern "C" fn wickra_resampler_update(
+    handle: *mut Resampler,
+    open: f64,
+    high: f64,
+    low: f64,
+    close: f64,
+    volume: f64,
+    timestamp: i64,
+    out: *mut WickraCandle,
+) -> bool {
+    let Some(resampler) = handle.as_mut() else {
+        return false;
+    };
+    if out.is_null() {
+        return false;
+    }
+    let Ok(candle) = Candle::new(open, high, low, close, volume, timestamp) else {
+        return false;
+    };
+    match resampler.push(candle) {
+        Ok(Some(emitted)) => {
+            *out = candle_to_c(emitted);
+            true
+        }
+        _ => false,
+    }
+}
+
+/// Flush the final, still-open candle. On `true` it is written to `*out`; `false`
+/// means nothing was pending or `handle` / `out` is `NULL`.
+///
+/// # Safety
+/// `handle` (from `wickra_resampler_new`, not freed) and `out` must be valid or `NULL`.
+#[no_mangle]
+pub unsafe extern "C" fn wickra_resampler_flush(
+    handle: *mut Resampler,
+    out: *mut WickraCandle,
+) -> bool {
+    let Some(resampler) = handle.as_mut() else {
+        return false;
+    };
+    if out.is_null() {
+        return false;
+    }
+    match resampler.flush() {
+        Ok(Some(emitted)) => {
+            *out = candle_to_c(emitted);
+            true
+        }
+        _ => false,
+    }
+}
+
+/// Destroy a resampler created by `wickra_resampler_new`. No-op if `handle` is
+/// `NULL`.
+///
+/// # Safety
+/// `handle` must have been returned by `wickra_resampler_new` and not previously
+/// freed, or `NULL`.
+#[no_mangle]
+pub unsafe extern "C" fn wickra_resampler_free(handle: *mut Resampler) {
+    if !handle.is_null() {
+        drop(Box::from_raw(handle));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

bindings/csharp/Wickra.Tests/DataLayerTests.cs

@@ -28,6 +28,37 @@ public class DataLayerTests
         return rows.ToArray();
     }
 
+    [Fact]
+    public void ResamplerMatchesGolden()
+    {
+        var input = Read("input"); // open,high,low,close,volume (timestamp = row index)
+        using var r = new Resampler(5);
+        var got = new List<double[]>();
+        for (var i = 0; i < input.Length; i++)
+        {
+            var c = r.Update(input[i][0], input[i][1], input[i][2], input[i][3], input[i][4], i);
+            if (c.HasValue)
+            {
+                got.Add(new[] { c.Value.Open, c.Value.High, c.Value.Low, c.Value.Close, c.Value.Volume, (double)c.Value.Timestamp });
+            }
+        }
+        var f = r.Flush();
+        if (f.HasValue)
+        {
+            got.Add(new[] { f.Value.Open, f.Value.High, f.Value.Low, f.Value.Close, f.Value.Volume, (double)f.Value.Timestamp });
+        }
+        var want = Read("data_resampled");
+        Assert.Equal(want.Length, got.Count);
+        for (var i = 0; i < got.Count; i++)
+        {
+            for (var j = 0; j < 6; j++)
+            {
+                var tol = 1e-9 * Math.Max(1, Math.Abs(want[i][j]));
+                Assert.True(Math.Abs(got[i][j] - want[i][j]) <= tol, $"resample row {i} col {j}: {got[i][j]} vs {want[i][j]}");
+            }
+        }
+    }
+
     [Theory]
     [InlineData(false, "data_candles")]
     [InlineData(true, "data_candles_gap")]

bindings/csharp/Wickra/Generated/Indicators.g.cs

@@ -26580,6 +26580,50 @@ public sealed class RenkoTrailingStop : IDisposable
     public void Dispose() => _handle.Dispose();
 }
 
+public sealed class Resampler : IDisposable
+{
+    private readonly WickraHandle _handle;
+
+    public Resampler(long timeframe)
+    {
+        var ptr = NativeMethods.wickra_resampler_new(timeframe);
+        if (ptr == nint.Zero)
+        {
+            throw new ArgumentException("invalid Resampler parameters");
+        }
+
+        _handle = new WickraHandle(ptr, NativeMethods.wickra_resampler_free);
+    }
+
+    public Candle? Update(double open, double high, double low, double close, double volume, long timestamp)
+    {
+        WickraCandle native;
+        bool ok;
+        unsafe
+        {
+            ok = NativeMethods.wickra_resampler_update(_handle.DangerousGetHandle(), open, high, low, close, volume, timestamp, &native);
+        }
+
+        GC.KeepAlive(_handle);
+        return ok ? new Candle(native.open, native.high, native.low, native.close, native.volume, native.timestamp) : null;
+    }
+
+    /// <summary>Emit the final, still-open candle (null if none is pending).</summary>
+    public Candle? Flush()
+    {
+        WickraCandle native;
+        bool ok;
+        unsafe
+        {
+            ok = NativeMethods.wickra_resampler_flush(_handle.DangerousGetHandle(), &native);
+        }
+        GC.KeepAlive(_handle);
+        return ok ? new Candle(native.open, native.high, native.low, native.close, native.volume, native.timestamp) : null;
+    }
+
+    public void Dispose() => _handle.Dispose();
+}
+
 public sealed class RickshawMan : IDisposable
 {
     private readonly WickraHandle _handle;

bindings/csharp/Wickra/Generated/NativeMethods.g.cs

@@ -12416,6 +12416,20 @@ internal static partial class NativeMethods
     [LibraryImport(WickraNative.LibraryName)]
     internal static partial void wickra_tick_aggregator_free(nint handle);
 
+    [LibraryImport(WickraNative.LibraryName)]
+    internal static partial nint wickra_resampler_new(long timeframe);
+
+    [LibraryImport(WickraNative.LibraryName)]
+    [return: MarshalAs(UnmanagedType.U1)]
+    internal static unsafe partial bool wickra_resampler_update(nint handle, double open, double high, double low, double close, double volume, long timestamp, WickraCandle* @out);
+
+    [LibraryImport(WickraNative.LibraryName)]
+    [return: MarshalAs(UnmanagedType.U1)]
+    internal static unsafe partial bool wickra_resampler_flush(nint handle, WickraCandle* @out);
+
+    [LibraryImport(WickraNative.LibraryName)]
+    internal static partial void wickra_resampler_free(nint handle);
+
 }
 
     [StructLayout(LayoutKind.Sequential)]

bindings/go/data_layer_test.go

@@ -20,6 +20,37 @@ func dataParseF(t *testing.T, s string) float64 {
 	return v
 }
 
+func TestResamplerGolden(t *testing.T) {
+	input := readGolden(t, "input") // open,high,low,close,volume (timestamp = row index)
+	r, err := NewResampler(5)
+	if err != nil {
+		t.Fatalf("new: %v", err)
+	}
+	var got [][6]float64
+	for i, row := range input {
+		o, h, l, c, v := dataParseF(t, row[0]), dataParseF(t, row[1]), dataParseF(t, row[2]), dataParseF(t, row[3]), dataParseF(t, row[4])
+		if k, ok := r.Update(o, h, l, c, v, int64(i)); ok {
+			got = append(got, [6]float64{k.Open, k.High, k.Low, k.Close, k.Volume, float64(k.Timestamp)})
+		}
+	}
+	if k, ok := r.Flush(); ok {
+		got = append(got, [6]float64{k.Open, k.High, k.Low, k.Close, k.Volume, float64(k.Timestamp)})
+	}
+	r.Close()
+	want := readGolden(t, "data_resampled")
+	if len(got) != len(want) {
+		t.Fatalf("resample: %d candles vs %d", len(got), len(want))
+	}
+	for i := range got {
+		for j := 0; j < 6; j++ {
+			w := dataParseF(t, want[i][j])
+			if math.Abs(got[i][j]-w) > 1e-9*math.Max(1, math.Abs(w)) {
+				t.Errorf("resample row %d col %d: %v vs %v", i, j, got[i][j], w)
+			}
+		}
+	}
+}
+
 func TestTickAggregatorGolden(t *testing.T) {
 	ticks := readGolden(t, "data_ticks")
 	cases := []struct {

bindings/go/include/wickra.h

@@ -678,6 +678,8 @@ typedef struct RenkoBars RenkoBars;
 
 typedef struct RenkoTrailingStop RenkoTrailingStop;
 
+typedef struct Resampler Resampler;
+
 typedef struct RickshawMan RickshawMan;
 
 typedef struct RisingThreeMethods RisingThreeMethods;
@@ -13719,6 +13721,21 @@ intptr_t wickra_tick_aggregator_drain(struct TickAggregator *handle,
 
 void wickra_tick_aggregator_free(struct TickAggregator *handle);
 
+struct Resampler *wickra_resampler_new(int64_t timeframe);
+
+bool wickra_resampler_update(struct Resampler *handle,
+                             double open,
+                             double high,
+                             double low,
+                             double close,
+                             double volume,
+                             int64_t timestamp,
+                             struct WickraCandle *out);
+
+bool wickra_resampler_flush(struct Resampler *handle, struct WickraCandle *out);
+
+void wickra_resampler_free(struct Resampler *handle);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus

bindings/go/indicators_gen.go

@@ -28057,6 +28057,56 @@ func (ind *RenkoTrailingStop) Close() {
 	}
 }
 
+// Resampler wraps the Resampler indicator over the Wickra C ABI.
+type Resampler struct {
+	handle *C.struct_Resampler
+}
+
+// NewResampler constructs a Resampler. It returns ErrInvalidParams when the
+// native constructor rejects the arguments.
+func NewResampler(timeframe int64) (*Resampler, error) {
+	ptr := C.wickra_resampler_new(C.int64_t(timeframe))
+	if ptr == nil {
+		return nil, ErrInvalidParams
+	}
+	obj := &Resampler{handle: ptr}
+	runtime.SetFinalizer(obj, (*Resampler).Close)
+	return obj, nil
+}
+
+// Update feeds one observation. The bool reports whether a value is
+// available yet (false during warmup).
+func (ind *Resampler) Update(open float64, high float64, low float64, close float64, volume float64, timestamp int64) (Candle, bool) {
+	var out C.struct_WickraCandle
+	ok := bool(C.wickra_resampler_update(ind.handle, C.double(open), C.double(high), C.double(low), C.double(close), C.double(volume), C.int64_t(timestamp), &out))
+	runtime.KeepAlive(ind)
+	if !ok {
+		return Candle{}, false
+	}
+	return Candle{float64(out.open), float64(out.high), float64(out.low), float64(out.close), float64(out.volume), int64(out.timestamp)}, true
+}
+
+// Flush emits the final, still-open candle (ok is false if none is pending).
+func (ind *Resampler) Flush() (Candle, bool) {
+	var out C.struct_WickraCandle
+	ok := bool(C.wickra_resampler_flush(ind.handle, &out))
+	runtime.KeepAlive(ind)
+	if !ok {
+		return Candle{}, false
+	}
+	return Candle{float64(out.open), float64(out.high), float64(out.low), float64(out.close), float64(out.volume), int64(out.timestamp)}, true
+}
+
+// Close frees the native handle. It is idempotent and safe to call
+// alongside the finalizer.
+func (ind *Resampler) Close() {
+	if ind.handle != nil {
+		C.wickra_resampler_free(ind.handle)
+		ind.handle = nil
+		runtime.SetFinalizer(ind, nil)
+	}
+}
+
 // RickshawMan wraps the RickshawMan indicator over the Wickra C ABI.
 type RickshawMan struct {
 	handle *C.struct_RickshawMan

bindings/java/src/main/java/org/wickra/Resampler.java

@@ -0,0 +1,73 @@
+// Generated from bindings/c/include/wickra.h. Do not edit by hand.
+package org.wickra;
+
+import org.wickra.internal.NativeMethods;
+import org.wickra.internal.WickraNative;
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.ref.Cleaner;
+import static java.lang.foreign.ValueLayout.*;
+
+/** Streaming Resampler indicator over the Wickra C ABI. Not thread-safe; close when done. */
+public final class Resampler implements AutoCloseable {
+    private final MemorySegment handle;
+    private final Cleaner.Cleanable cleanable;
+
+    public Resampler(long timeframe) {
+        MemorySegment h;
+        try {
+            h = (MemorySegment) NativeMethods.WICKRA_RESAMPLER_NEW.invokeExact(timeframe);
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+        if (h.address() == 0L) {
+            throw new IllegalArgumentException("invalid Resampler parameters");
+        }
+        this.handle = h;
+        this.cleanable = WickraNative.register(this, h, NativeMethods.WICKRA_RESAMPLER_FREE);
+    }
+
+    /** Push one observation; returns the result, or null during warmup. */
+    public Candle update(double open, double high, double low, double close, double volume, long timestamp) {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(48L);
+            byte ok = (byte) NativeMethods.WICKRA_RESAMPLER_UPDATE.invokeExact(handle, open, high, low, close, volume, timestamp, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new Candle(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L),
+                out.get(JAVA_DOUBLE, 16L),
+                out.get(JAVA_DOUBLE, 24L),
+                out.get(JAVA_DOUBLE, 32L),
+                (double) out.get(JAVA_LONG, 40L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    /** Emit the final, still-open candle (null if none is pending). */
+    public Candle flush() {
+        try (Arena a = Arena.ofConfined()) {
+            MemorySegment out = a.allocate(48L);
+            byte ok = (byte) NativeMethods.WICKRA_RESAMPLER_FLUSH.invokeExact(handle, out);
+            if (ok == 0) {
+                return null;
+            }
+            return new Candle(
+                out.get(JAVA_DOUBLE, 0L),
+                out.get(JAVA_DOUBLE, 8L),
+                out.get(JAVA_DOUBLE, 16L),
+                out.get(JAVA_DOUBLE, 24L),
+                out.get(JAVA_DOUBLE, 32L),
+                (double) out.get(JAVA_LONG, 40L));
+        } catch (Throwable t) {
+            throw WickraNative.rethrow(t);
+        }
+    }
+
+    @Override public void close() {
+        cleanable.clean();
+    }
+}

bindings/java/src/main/java/org/wickra/internal/NativeMethods.java

@@ -3951,6 +3951,10 @@ public final class NativeMethods {
     public static MethodHandle WICKRA_TICK_AGGREGATOR_PUSH;
     public static MethodHandle WICKRA_TICK_AGGREGATOR_DRAIN;
     public static MethodHandle WICKRA_TICK_AGGREGATOR_FREE;
+    public static MethodHandle WICKRA_RESAMPLER_NEW;
+    public static MethodHandle WICKRA_RESAMPLER_UPDATE;
+    public static MethodHandle WICKRA_RESAMPLER_FLUSH;
+    public static MethodHandle WICKRA_RESAMPLER_FREE;
 
     static {
         init0();
@@ -8023,6 +8027,10 @@ public final class NativeMethods {
         WICKRA_TICK_AGGREGATOR_PUSH = h("wickra_tick_aggregator_push", FunctionDescriptor.of(JAVA_LONG, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG));
         WICKRA_TICK_AGGREGATOR_DRAIN = h("wickra_tick_aggregator_drain", FunctionDescriptor.of(JAVA_LONG, ADDRESS, ADDRESS, JAVA_LONG));
         WICKRA_TICK_AGGREGATOR_FREE = h("wickra_tick_aggregator_free", FunctionDescriptor.ofVoid(ADDRESS));
+        WICKRA_RESAMPLER_NEW = h("wickra_resampler_new", FunctionDescriptor.of(ADDRESS, JAVA_LONG));
+        WICKRA_RESAMPLER_UPDATE = h("wickra_resampler_update", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_LONG, ADDRESS));
+        WICKRA_RESAMPLER_FLUSH = h("wickra_resampler_flush", FunctionDescriptor.of(JAVA_BYTE, ADDRESS, ADDRESS));
+        WICKRA_RESAMPLER_FREE = h("wickra_resampler_free", FunctionDescriptor.ofVoid(ADDRESS));
     }
 
 }

bindings/java/src/test/java/org/wickra/DataLayerTest.java

@@ -46,6 +46,33 @@ class DataLayerTest {
         return rows.toArray(new double[0][]);
     }
 
+    @Test
+    void resamplerMatchesGolden() throws IOException {
+        double[][] input = read("input"); // open,high,low,close,volume (timestamp = row index)
+        try (Resampler r = new Resampler(5)) {
+            List<double[]> got = new ArrayList<>();
+            for (int i = 0; i < input.length; i++) {
+                Candle c = r.update(input[i][0], input[i][1], input[i][2], input[i][3], input[i][4], i);
+                if (c != null) {
+                    got.add(new double[]{c.open(), c.high(), c.low(), c.close(), c.volume(), (double) c.timestamp()});
+                }
+            }
+            Candle f = r.flush();
+            if (f != null) {
+                got.add(new double[]{f.open(), f.high(), f.low(), f.close(), f.volume(), (double) f.timestamp()});
+            }
+            double[][] want = read("data_resampled");
+            assertEquals(want.length, got.size(), "resample candle count");
+            for (int i = 0; i < got.size(); i++) {
+                for (int j = 0; j < 6; j++) {
+                    double w = want[i][j];
+                    assertTrue(Math.abs(got.get(i)[j] - w) <= 1e-9 * Math.max(1, Math.abs(w)),
+                        "resample row " + i + " col " + j + ": " + got.get(i)[j] + " vs " + w);
+                }
+            }
+        }
+    }
+
     @Test
     void tickAggregatorMatchesGolden() throws IOException {
         double[][] ticks = read("data_ticks");

bindings/node/__tests__/completeness.test.js

@@ -27,9 +27,14 @@ const BAR_BUILDERS = new Set([
   'ThreeLineBreakBars',
 ]);
 
+// Data-layer types (tick aggregator, resampler) are not `Indicator`s: they
+// transform raw market data into candles and have their own update/flush shape,
+// so they are excluded from the streaming-indicator completeness contract.
+const DATA_LAYER = new Set(['TickAggregator', 'Resampler']);
+
 // An "indicator class" is an exported constructor whose prototype carries the
 // streaming `update` method. This excludes `version` (a plain function), the bar
-// builders, and any non-indicator export.
+// builders, the data-layer types, and any non-indicator export.
 function indicatorClasses() {
   return Object.keys(wickra).filter((name) => {
     const value = wickra[name];
@@ -37,7 +42,8 @@ function indicatorClasses() {
       typeof value === 'function' &&
       value.prototype &&
       typeof value.prototype.update === 'function' &&
-      !BAR_BUILDERS.has(name)
+      !BAR_BUILDERS.has(name) &&
+      !DATA_LAYER.has(name)
     );
   });
 }

bindings/node/__tests__/data_layer.test.js

@@ -8,7 +8,7 @@ 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 { TickAggregator, Resampler } = require('..');
 
 const GOLDEN = path.resolve(__dirname, '..', '..', '..', 'testdata', 'golden');
 
@@ -51,3 +51,25 @@ test('tick aggregator matches the golden candles', () => {
 test('tick aggregator gap-fill matches the golden candles', () => {
   assertCandles(run(true), readCsv('data_candles_gap'), 'gap');
 });
+
+const INPUT = readCsv('input'); // open,high,low,close,volume (timestamp = row index)
+
+function runResample() {
+  const r = new Resampler(5);
+  const out = [];
+  INPUT.forEach(([o, h, l, c, v], i) => {
+    const candle = r.update(o, h, l, c, v, i);
+    if (candle) {
+      out.push([candle.open, candle.high, candle.low, candle.close, candle.volume, candle.timestamp]);
+    }
+  });
+  const f = r.flush();
+  if (f) {
+    out.push([f.open, f.high, f.low, f.close, f.volume, f.timestamp]);
+  }
+  return out;
+}
+
+test('resampler matches the golden candles', () => {
+  assertCandles(runResample(), readCsv('data_resampled'), 'resample');
+});

bindings/node/index.d.ts

@@ -5957,3 +5957,19 @@ export declare class TickAggregator {
   /** Whether gap filling is enabled. */
   fillsGaps(): boolean
 }
+export type ResamplerNode = Resampler
+/** Resample candles into a higher timeframe (e.g. 1m -> 5m). */
+export declare class Resampler {
+  /**
+   * Construct a resampler that aggregates inputs into `timeframe`-sized
+   * candles (same unit as the candle timestamps).
+   */
+  constructor(timeframe: number)
+  /**
+   * Push one candle; returns the completed higher-timeframe candle when a
+   * bucket boundary is crossed, otherwise `null`.
+   */
+  update(open: number, high: number, low: number, close: number, volume: number, timestamp: number): CandleValue | null
+  /** Emit the final, still-open candle (or `null` if none is pending). */
+  flush(): CandleValue | null
+}

bindings/node/src/lib.rs

@@ -21937,3 +21937,66 @@ impl TickAggregatorNode {
         self.inner.fills_gaps()
     }
 }
+
+// ===== Data layer: resampling (candle -> higher-timeframe candle) =====
+
+fn candle_to_value(c: wc::Candle) -> CandleValue {
+    CandleValue {
+        open: c.open,
+        high: c.high,
+        low: c.low,
+        close: c.close,
+        volume: c.volume,
+        timestamp: c.timestamp as f64,
+    }
+}
+
+/// Resample candles into a higher timeframe (e.g. 1m -> 5m).
+#[napi(js_name = "Resampler")]
+pub struct ResamplerNode {
+    inner: wickra_data::resample::Resampler,
+}
+
+#[napi]
+impl ResamplerNode {
+    /// Construct a resampler that aggregates inputs into `timeframe`-sized
+    /// candles (same unit as the candle timestamps).
+    #[napi(constructor)]
+    pub fn new(timeframe: f64) -> napi::Result<Self> {
+        let tf = wickra_data::aggregator::Timeframe::new(timeframe as i64).map_err(map_data_err)?;
+        Ok(Self {
+            inner: wickra_data::resample::Resampler::new(tf),
+        })
+    }
+
+    /// Push one candle; returns the completed higher-timeframe candle when a
+    /// bucket boundary is crossed, otherwise `null`.
+    #[napi]
+    pub fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+        timestamp: f64,
+    ) -> napi::Result<Option<CandleValue>> {
+        let candle =
+            wc::Candle::new(open, high, low, close, volume, timestamp as i64).map_err(map_err)?;
+        Ok(self
+            .inner
+            .push(candle)
+            .map_err(map_data_err)?
+            .map(candle_to_value))
+    }
+
+    /// Emit the final, still-open candle (or `null` if none is pending).
+    #[napi]
+    pub fn flush(&mut self) -> napi::Result<Option<CandleValue>> {
+        Ok(self
+            .inner
+            .flush()
+            .map_err(map_data_err)?
+            .map(candle_to_value))
+    }
+}

bindings/python/python/wickra/__init__.py

@@ -360,6 +360,7 @@ from ._wickra import (
     CandleVolume,
     # Data layer
     TickAggregator,
+    Resampler,
     # Market Profile
     CompositeProfile,
     HighLowVolumeNodes,
@@ -906,6 +907,7 @@ __all__ = [
     "CandleVolume",
     # Data layer
     "TickAggregator",
+    "Resampler",
     # Market Profile
     "CompositeProfile",
     "HighLowVolumeNodes",

bindings/python/src/lib.rs

@@ -28287,6 +28287,7 @@ fn _wickra(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyCompositeProfile>()?;
     // Data layer.
     m.add_class::<PyTickAggregator>()?;
+    m.add_class::<PyResampler>()?;
     // Candlestick patterns.
     m.add_class::<PyDoji>()?;
     m.add_class::<PyHammer>()?;
@@ -28616,3 +28617,52 @@ impl PyTickAggregator {
         format!("TickAggregator(fills_gaps={})", self.inner.fills_gaps())
     }
 }
+
+// ===== Data layer: resampling (candle -> higher-timeframe candle) =====
+
+/// Resample candles into a higher timeframe (e.g. 1m -> 5m).
+#[pyclass(name = "Resampler", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PyResampler {
+    inner: wickra_data::resample::Resampler,
+}
+
+#[pymethods]
+impl PyResampler {
+    #[new]
+    fn new(timeframe: i64) -> PyResult<Self> {
+        let tf = wickra_data::aggregator::Timeframe::new(timeframe).map_err(map_data_err)?;
+        Ok(Self {
+            inner: wickra_data::resample::Resampler::new(tf),
+        })
+    }
+
+    /// Push one candle; returns the completed higher-timeframe candle as
+    /// `(open, high, low, close, volume, timestamp)` on a bucket boundary, else
+    /// `None`.
+    fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+        timestamp: i64,
+    ) -> PyResult<Option<CandleTuple>> {
+        let candle = wc::Candle::new(open, high, low, close, volume, timestamp).map_err(map_err)?;
+        Ok(self
+            .inner
+            .push(candle)
+            .map_err(map_data_err)?
+            .map(|c| (c.open, c.high, c.low, c.close, c.volume, c.timestamp)))
+    }
+
+    /// Emit the final, still-open candle (or `None` if none is pending).
+    fn flush(&mut self) -> PyResult<Option<CandleTuple>> {
+        Ok(self
+            .inner
+            .flush()
+            .map_err(map_data_err)?
+            .map(|c| (c.open, c.high, c.low, c.close, c.volume, c.timestamp)))
+    }
+}

bindings/python/tests/test_data_layer.py

@@ -42,3 +42,24 @@ def test_tick_aggregator_matches_golden(gap_fill, fixture):
         for j in range(6):
             tol = 1e-9 * max(1.0, abs(w[j]))
             assert abs(g[j] - w[j]) <= tol, f"row {i} col {j}: {g[j]} vs {w[j]}"
+
+
+INPUT = _read("input")  # open,high,low,close,volume (timestamp = row index)
+
+
+def test_resampler_matches_golden():
+    r = ta.Resampler(5)
+    got = []
+    for i, (o, h, l, c, v) in enumerate(INPUT):
+        candle = r.update(o, h, l, c, v, i)
+        if candle is not None:
+            got.append(candle)
+    f = r.flush()
+    if f is not None:
+        got.append(f)
+    want = _read("data_resampled")
+    assert len(got) == len(want)
+    for i, (g, w) in enumerate(zip(got, want)):
+        for j in range(6):
+            tol = 1e-9 * max(1.0, abs(w[j]))
+            assert abs(g[j] - w[j]) <= tol, f"row {i} col {j}: {g[j]} vs {w[j]}"

bindings/r/NAMESPACE

@@ -1,6 +1,7 @@
 # Generated by roxygen2: do not edit by hand
 
 S3method(batch,wickra_indicator)
+S3method(flush,wickra_indicator)
 S3method(is_ready,wickra_indicator)
 S3method(name,wickra_indicator)
 S3method(push,wickra_indicator)
@@ -341,6 +342,7 @@ export(RegimeLabel)
 export(RelativeStrengthAB)
 export(RenkoBars)
 export(RenkoTrailingStop)
+export(Resampler)
 export(RickshawMan)
 export(RisingThreeMethods)
 export(Rmi)

bindings/r/R/indicators.R

@@ -2679,6 +2679,14 @@ RenkoTrailingStop <- function(block_size) {
   .wk_obj("renko_trailing_stop", ptr, "RenkoTrailingStop")
 }
 
+#' Resampler indicator
+#' @keywords internal
+#' @export
+Resampler <- function(timeframe) {
+  ptr <- .Call("wk_resampler_new", timeframe, PACKAGE = "wickra")
+  .wk_obj("resampler", ptr, "Resampler")
+}
+
 #' RickshawMan indicator
 #' @keywords internal
 #' @export

bindings/r/R/methods.R

@@ -170,3 +170,22 @@ push.wickra_indicator <- function(object, price, size, timestamp) {
   colnames(out) <- c("open", "high", "low", "close", "volume", "timestamp")
   out
 }
+
+#' Flush a resampler's final candle
+#'
+#' Emit the final, still-open candle a [Resampler()] is aggregating (the partial
+#' higher-timeframe bar that no later input has closed yet). Extends the base
+#' generic [base::flush()].
+#'
+#' @param con A `wickra_indicator` created by [Resampler()].
+#' @return A named numeric vector (`open`, `high`, `low`, `close`, `volume`,
+#'   `timestamp`), or `NULL` if nothing is pending.
+#' @examples
+#' r <- Resampler(5)
+#' for (t in 0:6) update(r, 100 + t, 101 + t, 99 + t, 100 + t, 10, t)
+#' flush(r)
+#' @exportS3Method base::flush
+flush.wickra_indicator <- function(con) {
+  out <- .Call(paste0("wk_", con$prefix, "_flush"), con$ptr, PACKAGE = "wickra")
+  out
+}

bindings/r/src/wickra.c

@@ -14606,6 +14606,64 @@ SEXP wk_renko_trailing_stop_reset(SEXP e) {
   return R_NilValue;
 }
 
+static void resampler_fin(SEXP e) {
+  struct Resampler *h = (struct Resampler *)R_ExternalPtrAddr(e);
+  if (h) wickra_resampler_free(h);
+  R_ClearExternalPtr(e);
+}
+SEXP wk_resampler_new(SEXP a0) {
+  struct Resampler *h = wickra_resampler_new((int64_t)Rf_asReal(a0));
+  if (!h) Rf_error("invalid Resampler parameters");
+  SEXP e = PROTECT(R_MakeExternalPtr(h, R_NilValue, R_NilValue));
+  R_RegisterCFinalizerEx(e, resampler_fin, TRUE);
+  UNPROTECT(1);
+  return e;
+}
+SEXP wk_resampler_update(SEXP e, SEXP a0, SEXP a1, SEXP a2, SEXP a3, SEXP a4, SEXP a5) {
+  struct Resampler *h = (struct Resampler *)R_ExternalPtrAddr(e);
+  struct WickraCandle out;
+  int ok = wickra_resampler_update(h, Rf_asReal(a0), Rf_asReal(a1), Rf_asReal(a2), Rf_asReal(a3), Rf_asReal(a4), (int64_t)Rf_asReal(a5), &out);
+  SEXP r = PROTECT(Rf_allocVector(REALSXP, 6));
+  REAL(r)[0] = ok ? (double)out.open : NA_REAL;
+  REAL(r)[1] = ok ? (double)out.high : NA_REAL;
+  REAL(r)[2] = ok ? (double)out.low : NA_REAL;
+  REAL(r)[3] = ok ? (double)out.close : NA_REAL;
+  REAL(r)[4] = ok ? (double)out.volume : NA_REAL;
+  REAL(r)[5] = ok ? (double)out.timestamp : NA_REAL;
+  SEXP nm = PROTECT(Rf_allocVector(STRSXP, 6));
+  SET_STRING_ELT(nm, 0, Rf_mkChar("open"));
+  SET_STRING_ELT(nm, 1, Rf_mkChar("high"));
+  SET_STRING_ELT(nm, 2, Rf_mkChar("low"));
+  SET_STRING_ELT(nm, 3, Rf_mkChar("close"));
+  SET_STRING_ELT(nm, 4, Rf_mkChar("volume"));
+  SET_STRING_ELT(nm, 5, Rf_mkChar("timestamp"));
+  Rf_setAttrib(r, R_NamesSymbol, nm);
+  UNPROTECT(2);
+  return r;
+}
+SEXP wk_resampler_flush(SEXP e) {
+  struct Resampler *h = (struct Resampler *)R_ExternalPtrAddr(e);
+  struct WickraCandle out;
+  if (!wickra_resampler_flush(h, &out)) return R_NilValue;
+  SEXP r = PROTECT(Rf_allocVector(REALSXP, 6));
+  REAL(r)[0] = out.open;
+  REAL(r)[1] = out.high;
+  REAL(r)[2] = out.low;
+  REAL(r)[3] = out.close;
+  REAL(r)[4] = out.volume;
+  REAL(r)[5] = (double)out.timestamp;
+  SEXP nm = PROTECT(Rf_allocVector(STRSXP, 6));
+  SET_STRING_ELT(nm, 0, Rf_mkChar("open"));
+  SET_STRING_ELT(nm, 1, Rf_mkChar("high"));
+  SET_STRING_ELT(nm, 2, Rf_mkChar("low"));
+  SET_STRING_ELT(nm, 3, Rf_mkChar("close"));
+  SET_STRING_ELT(nm, 4, Rf_mkChar("volume"));
+  SET_STRING_ELT(nm, 5, Rf_mkChar("timestamp"));
+  Rf_setAttrib(r, R_NamesSymbol, nm);
+  UNPROTECT(2);
+  return r;
+}
+
 static void rickshaw_man_fin(SEXP e) {
   struct RickshawMan *h = (struct RickshawMan *)R_ExternalPtrAddr(e);
   if (h) wickra_rickshaw_man_free(h);
@@ -24781,6 +24839,9 @@ static const R_CallMethodDef CallEntries[] = {
   {"wk_renko_trailing_stop_is_ready", (DL_FUNC)&wk_renko_trailing_stop_is_ready, 1},
   {"wk_renko_trailing_stop_name", (DL_FUNC)&wk_renko_trailing_stop_name, 1},
   {"wk_renko_trailing_stop_reset", (DL_FUNC)&wk_renko_trailing_stop_reset, 1},
+  {"wk_resampler_new", (DL_FUNC)&wk_resampler_new, 1},
+  {"wk_resampler_update", (DL_FUNC)&wk_resampler_update, 7},
+  {"wk_resampler_flush", (DL_FUNC)&wk_resampler_flush, 1},
   {"wk_rickshaw_man_new", (DL_FUNC)&wk_rickshaw_man_new, 0},
   {"wk_rickshaw_man_update", (DL_FUNC)&wk_rickshaw_man_update, 7},
   {"wk_rickshaw_man_batch", (DL_FUNC)&wk_rickshaw_man_batch, 7},

bindings/r/tests/testthat/test-data-layer.R

@@ -50,3 +50,31 @@ test_that("tick aggregator matches the golden candles", {
     expect_equal(got, want, tolerance = 1e-9, info = spec$fixture)
   }
 })
+
+test_that("resampler matches the golden candles", {
+  gdir <- find_data_golden_dir()
+  skip_if(is.null(gdir), "golden fixtures not bundled with the package")
+
+  read_mat <- function(name) {
+    lines <- readLines(file.path(gdir, paste0(name, ".csv")))[-1]
+    lines <- lines[nzchar(lines)]
+    do.call(rbind, lapply(lines, function(l) as.numeric(strsplit(l, ",")[[1]])))
+  }
+
+  input <- read_mat("input") # open,high,low,close,volume (timestamp = row index)
+  r <- Resampler(5)
+  got <- matrix(numeric(0), 0, 6)
+  for (i in seq_len(nrow(input))) {
+    c <- update(r, input[i, 1], input[i, 2], input[i, 3], input[i, 4], input[i, 5], i - 1)
+    if (!is.na(c[1])) {
+      got <- rbind(got, unname(c))
+    }
+  }
+  f <- flush(r)
+  if (!is.null(f)) {
+    got <- rbind(got, unname(f))
+  }
+  want <- unname(read_mat("data_resampled"))
+  expect_equal(nrow(got), nrow(want))
+  expect_equal(got, want, tolerance = 1e-9)
+})

bindings/wasm/src/lib.rs

@@ -16043,3 +16043,61 @@ impl WasmTickAggregator {
         self.inner.fills_gaps()
     }
 }
+
+// ===== Data layer: resampling (candle -> higher-timeframe candle) =====
+
+fn candle_object(c: wc::Candle) -> Object {
+    let obj = Object::new();
+    Reflect::set(&obj, &"open".into(), &c.open.into()).ok();
+    Reflect::set(&obj, &"high".into(), &c.high.into()).ok();
+    Reflect::set(&obj, &"low".into(), &c.low.into()).ok();
+    Reflect::set(&obj, &"close".into(), &c.close.into()).ok();
+    Reflect::set(&obj, &"volume".into(), &c.volume.into()).ok();
+    Reflect::set(&obj, &"timestamp".into(), &(c.timestamp as f64).into()).ok();
+    obj
+}
+
+/// Resample candles into a higher timeframe (e.g. 1m -> 5m).
+#[wasm_bindgen(js_name = Resampler)]
+pub struct WasmResampler {
+    inner: wickra_data::resample::Resampler,
+}
+
+#[wasm_bindgen(js_class = Resampler)]
+impl WasmResampler {
+    /// Construct a resampler aggregating inputs into `timeframe`-sized candles.
+    #[wasm_bindgen(constructor)]
+    pub fn new(timeframe: f64) -> Result<WasmResampler, JsError> {
+        let tf = wickra_data::aggregator::Timeframe::new(timeframe as i64).map_err(map_data_err)?;
+        Ok(Self {
+            inner: wickra_data::resample::Resampler::new(tf),
+        })
+    }
+
+    /// Push one candle; returns a `{ open, high, low, close, volume, timestamp }`
+    /// object on a bucket boundary, otherwise `null`.
+    pub fn update(
+        &mut self,
+        open: f64,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+        timestamp: f64,
+    ) -> Result<JsValue, JsError> {
+        let candle =
+            wc::Candle::new(open, high, low, close, volume, timestamp as i64).map_err(map_err)?;
+        match self.inner.push(candle).map_err(map_data_err)? {
+            Some(c) => Ok(candle_object(c).into()),
+            None => Ok(JsValue::NULL),
+        }
+    }
+
+    /// Emit the final, still-open candle (or `null` if none is pending).
+    pub fn flush(&mut self) -> Result<JsValue, JsError> {
+        match self.inner.flush().map_err(map_data_err)? {
+            Some(c) => Ok(candle_object(c).into()),
+            None => Ok(JsValue::NULL),
+        }
+    }
+}

bindings/wasm/tests/data_layer.test.js

@@ -49,3 +49,25 @@ test('wasm tick aggregator matches the golden candles', () => {
 test('wasm tick aggregator gap-fill matches the golden candles', () => {
   assertCandles(run(true), readCsv('data_candles_gap'), 'gap');
 });
+
+const INPUT = readCsv('input'); // open,high,low,close,volume (timestamp = row index)
+
+function runResample() {
+  const r = new W.Resampler(5);
+  const out = [];
+  INPUT.forEach(([o, h, l, c, v], i) => {
+    const candle = r.update(o, h, l, c, v, i);
+    if (candle) {
+      out.push([candle.open, candle.high, candle.low, candle.close, candle.volume, candle.timestamp]);
+    }
+  });
+  const f = r.flush();
+  if (f) {
+    out.push([f.open, f.high, f.low, f.close, f.volume, f.timestamp]);
+  }
+  return out;
+}
+
+test('wasm resampler matches the golden candles', () => {
+  assertCandles(runResample(), readCsv('data_resampled'), 'resample');
+});

examples/c/data_layer_test.c

@@ -94,12 +94,66 @@ static int check(const char *fixture, bool gap, const double *ticks, int nt) {
     return fails;
 }
 
+static int check_resample(void) {
+    double input[MAXROWS * 5];
+    int ni = read_csv("input", input, 5);
+    double want[MAXROWS * 6];
+    int nw = read_csv("data_resampled", want, 6);
+    struct Resampler *r = wickra_resampler_new(5);
+    if (!r) {
+        printf("FAIL resample: new returned NULL\n");
+        return 1;
+    }
+    double got[MAXROWS * 6];
+    int ng = 0;
+    struct WickraCandle out;
+    for (int i = 0; i < ni; i++) {
+        if (wickra_resampler_update(r, input[i * 5 + 0], input[i * 5 + 1], input[i * 5 + 2],
+                                    input[i * 5 + 3], input[i * 5 + 4], (int64_t)i, &out)) {
+            got[ng * 6 + 0] = out.open;
+            got[ng * 6 + 1] = out.high;
+            got[ng * 6 + 2] = out.low;
+            got[ng * 6 + 3] = out.close;
+            got[ng * 6 + 4] = out.volume;
+            got[ng * 6 + 5] = (double)out.timestamp;
+            ng++;
+        }
+    }
+    if (wickra_resampler_flush(r, &out)) {
+        got[ng * 6 + 0] = out.open;
+        got[ng * 6 + 1] = out.high;
+        got[ng * 6 + 2] = out.low;
+        got[ng * 6 + 3] = out.close;
+        got[ng * 6 + 4] = out.volume;
+        got[ng * 6 + 5] = (double)out.timestamp;
+        ng++;
+    }
+    wickra_resampler_free(r);
+    if (ng != nw) {
+        printf("FAIL resample: %d candles vs %d\n", ng, nw);
+        return 1;
+    }
+    int fails = 0;
+    for (int i = 0; i < ng; i++) {
+        for (int j = 0; j < 6; j++) {
+            double w = want[i * 6 + j];
+            double tol = 1e-9 * fmax(1.0, fabs(w));
+            if (fabs(got[i * 6 + j] - w) > tol) {
+                printf("FAIL resample row %d col %d: %g vs %g\n", i, j, got[i * 6 + j], w);
+                fails++;
+            }
+        }
+    }
+    return fails;
+}
+
 int main(int argc, char **argv) {
     GDIR = (argc > 1) ? argv[1] : "testdata/golden";
     double ticks[MAXROWS * 3];
     int nt = read_csv("data_ticks", ticks, 3);
     int fails = check("data_candles", false, ticks, nt);
     fails += check("data_candles_gap", true, ticks, nt);
+    fails += check_resample();
     if (fails == 0) {
         printf("C/C++ data layer: OK (%d ticks)\n", nt);
     }

examples/rust/src/bin/gen_golden.rs

@@ -20,6 +20,7 @@ use wickra::{
     Indicator, IntradayIntensity, MacdIndicator, Rsi, Sma, Tick,
 };
 use wickra_data::aggregator::{TickAggregator, Timeframe};
+use wickra_data::resample::Resampler;
 
 const N: usize = 80;
 
@@ -185,9 +186,37 @@ fn main() {
     emit_profiles(dir, &candles);
     emit_bars(dir, &candles);
     emit_data_layer(dir);
+    emit_resampler(dir, &candles);
     println!("golden fixtures written to {}", dir.display());
 }
 
+/// Data layer: the resampler. Resamples the shared input candles (timestamp =
+/// row index) into 5-unit buckets; the final partial bucket comes out of flush.
+fn emit_resampler(dir: &Path, candles: &[Candle]) {
+    let mut resampler = Resampler::new(Timeframe::new(5).unwrap());
+    let mut rows = Vec::new();
+    for &candle in candles {
+        if let Some(out) = resampler.push(candle).expect("valid resample push") {
+            rows.push(format!(
+                "{},{},{},{},{},{}",
+                out.open, out.high, out.low, out.close, out.volume, out.timestamp
+            ));
+        }
+    }
+    if let Some(out) = resampler.flush().expect("valid resample flush") {
+        rows.push(format!(
+            "{},{},{},{},{},{}",
+            out.open, out.high, out.low, out.close, out.volume, out.timestamp
+        ));
+    }
+    write_csv(
+        dir,
+        "data_resampled",
+        "open,high,low,close,volume,timestamp",
+        &rows,
+    );
+}
+
 /// Deterministic trade tick `i`: price on the shared varied path, a small
 /// repeating size, and a timestamp that places roughly three ticks per
 /// 1000-unit bucket. A deliberate jump at `i == 36` opens a multi-bucket gap so

testdata/golden/data_resampled.csv

@@ -0,0 +1,17 @@
+open,high,low,close,volume,timestamp
+99,112.90403177129735,98,111.32039085967226,5187.008623739826,0
+113.27609348158748,115.1642566915892,107.76539185209613,108.7737988023383,5473.238103468329,5
+106.12753789513545,107.73969337995807,96.34710045689485,98.28424227586412,5324.374653317379,10
+97.378063505514,106.32510161131832,95.93821562552817,103.99314457402363,5150.941358775185,15
+108.04491654708718,121.38046215528227,105.7105413401633,119.93667863849153,5456.9835954080345,20
+120.88220148856881,124.2878498649492,119.39438848583472,121.12969230082183,5371.101223522536,25
+119.8808727652764,121.29920058454442,108.51535390119264,110.00125312406458,5128.47088205189,30
+108.48360243707184,113.29382811110736,106.26786689008574,111.88016416080967,5431.582557578566,35
+114.22618875818226,130.20955349568973,113.09073586402833,127.92073514707224,5410.400200215731,40
+131.41114890560974,135.065460892756,129.49585703767033,132.95746831142935,5120.058973527027,45
+130.5116755897077,132.71696973631924,121.2254215875191,122.27578013601534,5397.543391924787,50
+121.09703354508844,122.45602084147426,117.25536324735009,120.37417550208815,5441.485014111252,55
+122.33587608239566,136.79793765689536,120.87761530843784,135.43314928819893,5132.5539248008245,60
+138.08766685694894,146.57143212166807,136.58837142074304,144.11152724502116,5355.547392578692,65
+144.27024859045207,145.7471249168318,132.66155074344638,134.9266357939324,5463.733502447633,70
+131.6480122345848,134.02210748888697,127.39947545719488,129.59514479102842,5163.946538828373,75