release: bump 0.7.1 -> 0.7.2 (#217)

Version bump 0.7.1 -> 0.7.2 for the B17 Market Profile batch (498 indicators).

CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.2] - 2026-06-08
+- **Composite Profile** — multi-session composite volume profile exposing POC, VAH and VAL (`CompositeProfile`).
+- **High/Low Volume Nodes** — highest- and lowest-volume price nodes in the profile (`HighLowVolumeNodes`).
+- **Profile Shape** — profile shape classification (b/P/D normal) as a numeric code (`ProfileShape`).
+- **Single Prints** — count of single-print (low-activity) price levels in the profile (`SinglePrints`).
+- **Naked POC** — most recent untouched (naked) point of control level (`NakedPoc`).
+
+## [0.7.1] - 2026-06-08
+- **Open-Interest Momentum** — rate-of-change of open interest over a rolling window (`OpenInterestMomentum`).
+- **Funding-Implied APR** — annualised funding rate (per-interval funding times intervals per year) (`FundingImpliedApr`).
+- **Perpetual Premium Index** — relative premium of the mark price over the index price (`PerpetualPremiumIndex`).
+- **OI-to-Volume Ratio** — open interest divided by taker volume (position turnover proxy) (`OiToVolumeRatio`).
+- **Estimated Leverage Ratio** — open interest divided by aggregate long+short position size (leverage proxy) (`EstimatedLeverageRatio`).
+
 ## [0.7.0] - 2026-06-08
 - **Hasbrouck Information Share** — variance-ratio proxy for each venue's share of price discovery (Hasbrouck information share) (`HasbrouckInformationShare`).
 - **PIN** — probability of informed trading from rolling buy/sell imbalance (EKOP single-window estimator) (`Pin`).
@@ -1382,7 +1396,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   optional Binance live feed.
 - Bindings for Python, Node.js, and WebAssembly.
 
-[Unreleased]: https://github.com/wickra-lib/wickra/compare/v0.7.0...HEAD
+[Unreleased]: https://github.com/wickra-lib/wickra/compare/v0.7.2...HEAD
+[0.7.2]: https://github.com/wickra-lib/wickra/compare/v0.7.1...v0.7.2
+[0.7.1]: https://github.com/wickra-lib/wickra/compare/v0.7.0...v0.7.1
 [0.7.0]: https://github.com/wickra-lib/wickra/compare/v0.6.9...v0.7.0
 [0.6.9]: https://github.com/wickra-lib/wickra/compare/v0.6.8...v0.6.9
 [0.6.8]: https://github.com/wickra-lib/wickra/compare/v0.6.7...v0.6.8

Cargo.lock

@@ -1944,7 +1944,7 @@ dependencies = [
 
 [[package]]
 name = "wickra"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "approx",
  "criterion",
@@ -1955,7 +1955,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-bench"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "criterion",
  "kand",
@@ -1967,7 +1967,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-core"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "approx",
  "proptest",
@@ -1977,7 +1977,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-data"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "approx",
  "csv",
@@ -1994,7 +1994,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-examples"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "serde_json",
  "tokio",
@@ -2004,7 +2004,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-node"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "napi",
  "napi-build",
@@ -2014,7 +2014,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-python"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "numpy",
  "pyo3",
@@ -2023,7 +2023,7 @@ dependencies = [
 
 [[package]]
 name = "wickra-wasm"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

Cargo.toml

@@ -13,7 +13,7 @@ members = [
 exclude = ["fuzz"]
 
 [workspace.package]
-version = "0.7.0"
+version = "0.7.2"
 authors = ["kingchenc <support@wickra.org>"]
 edition = "2021"
 rust-version = "1.86"
@@ -25,7 +25,7 @@ keywords = ["finance", "trading", "indicators", "technical-analysis", "ta"]
 categories = ["finance", "mathematics", "science"]
 
 [workspace.dependencies]
-wickra-core = { path = "crates/wickra-core", version = "0.7.0" }
+wickra-core = { path = "crates/wickra-core", version = "0.7.2" }
 
 thiserror = "2"
 rayon = "1.10"

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=488" alt="Wickra — streaming-first technical indicators" width="100%"></a>
+  <a href="https://wickra.org"><img src="https://raw.githubusercontent.com/wickra-lib/.github/main/profile/wickra-banner.webp?v=498" alt="Wickra — streaming-first technical indicators" width="100%"></a>
 </p>
 
 [![CI](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml/badge.svg)](https://github.com/wickra-lib/wickra/actions/workflows/ci.yml)
@@ -48,7 +48,7 @@ Full documentation lives at **[docs.wickra.org](https://docs.wickra.org)**:
   [Node](https://docs.wickra.org/Quickstart-Node),
   [WASM](https://docs.wickra.org/Quickstart-WASM).
 - **Indicators** — a per-indicator deep dive (formula, parameters, warmup) for
-  every one of the 488 indicators; start at the
+  every one of the 498 indicators; start at the
   [indicators overview](https://docs.wickra.org/Indicators-Overview).
 - **Reference** — [warmup periods](https://docs.wickra.org/Warmup-Periods),
   [streaming vs batch](https://docs.wickra.org/Streaming-vs-Batch),
@@ -66,7 +66,7 @@ an afterthought — **live, tick-by-tick data** — without giving up the breadt
 a full batch library, and without making you reimplement your indicators four
 times to get there.
 
-- **The biggest streaming-native catalogue, period.** 488 indicators across 24
+- **The biggest streaming-native catalogue, period.** 498 indicators across 24
   families — candlesticks, harmonic & chart patterns, market profile, market
   breadth, Renko/Kagi/Point&Figure bars, Ehlers DSP cycles, risk/performance
   metrics — every single one updating in **O(1) per tick**. TA-Lib ships ~150 and
@@ -77,7 +77,7 @@ times to get there.
 - **Correct by construction, not by hope.** Every `update` validates its input,
   runs a real warmup, and returns an `Option` so a single bad tick can't silently
   poison state. `batch == streaming` is **bit-exact, fuzzed and 100 %-line-covered
-  for all 488 indicators**.
+  for all 498 indicators**.
 - **Orders of magnitude faster where it counts.** In streaming Wickra is **11–56×**
   faster than the only other incremental peer and **thousands of times** faster
   than recompute-on-every-tick libraries. On batch it wins several rows outright
@@ -95,7 +95,7 @@ Every other library forces one of those compromises. Wickra doesn't:
 
 | Library          | Install     | Streaming   | Languages                   | Indicators | Active |
 |------------------|-------------|-------------|-----------------------------|-----------:|--------|
-| **★&nbsp;Wickra**| **clean**   | **yes, O(1)** | **Python · Node · WASM · Rust** | **488** | **yes** |
+| **★&nbsp;Wickra**| **clean**   | **yes, O(1)** | **Python · Node · WASM · Rust** | **498** | **yes** |
 | kand             | clean       | yes         | Python · WASM · Rust        |       ~60  | yes    |
 | ta-rs            | clean       | yes         | Rust only                   |       ~30  | stale  |
 | yata             | clean       | partial     | Rust only                   |       ~35  | yes    |
@@ -128,7 +128,7 @@ Full tables (Rust + Python, streaming + batch) and how to reproduce them live in
 
 ## Indicators
 
-488 streaming-first indicators across twenty-four families. Every one passes the
+498 streaming-first indicators across twenty-four families. Every one passes the
 `batch == streaming` equivalence test, reference-value tests, and reset
 semantics tests. Each has a per-indicator deep dive (formula, parameters,
 warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview).
@@ -154,8 +154,8 @@ warmup) at [docs.wickra.org](https://docs.wickra.org/Indicators-Overview).
 | Harmonic Patterns    | AB=CD, Gartley, Butterfly, Bat, Crab, Shark, Cypher, Three Drives |
 | Fibonacci            | Fibonacci Retracement, Fibonacci Extension, Fibonacci Projection, Auto-Fibonacci, Golden Pocket, Fibonacci Confluence, Fibonacci Fan, Fibonacci Arcs, Fibonacci Channel, Fibonacci Time Zones |
 | Microstructure       | Order-Book Imbalance (Top-1 / Top-N / Full), Microprice, Quoted Spread, Depth Slope, Signed Volume, Cumulative Volume Delta, Trade Imbalance, Effective Spread, Realized Spread, Kyle's Lambda, Footprint, Order Flow Imbalance, VPIN, Amihud Illiquidity, Roll Measure, Trade-Sign Autocorrelation, Hasbrouck Information Share |
-| Derivatives          | Funding Rate, Funding Rate Mean, Funding Rate Z-Score, Funding Basis, Open-Interest Delta, OI / Price Divergence, OI-Weighted Price, Long/Short Ratio, Taker Buy/Sell Ratio, Liquidation Features, Term-Structure Basis, Calendar Spread |
-| Market Profile       | Value Area (POC / VAH / VAL), Volume Profile (histogram), TPO Profile, Initial Balance, Opening Range |
+| Derivatives          | Funding Rate, Funding Rate Mean, Funding Rate Z-Score, Funding Basis, Open-Interest Delta, OI / Price Divergence, OI-Weighted Price, Long/Short Ratio, Taker Buy/Sell Ratio, Liquidation Features, Term-Structure Basis, Calendar Spread, Estimated Leverage Ratio, OI-to-Volume Ratio, Perpetual Premium Index, Funding-Implied APR, Open-Interest Momentum |
+| Market Profile       | Value Area (POC / VAH / VAL), Volume Profile (histogram), TPO Profile, Initial Balance, Opening Range, Naked POC, Single Prints, Profile Shape, High/Low Volume Nodes, Composite Profile |
 | Market Breadth       | Advance/Decline Line, Advance/Decline Ratio, Advance/Decline Volume Line, McClellan Oscillator, McClellan Summation Index, TRIN / Arms Index, Breadth Thrust, New Highs - New Lows, High-Low Index, Percent Above Moving Average, Up/Down Volume Ratio, Bullish Percent Index, Cumulative Volume Index, Absolute Breadth Index, TICK Index |
 | Risk / Performance   | Sharpe Ratio, Sortino Ratio, Calmar Ratio, Omega Ratio, Max Drawdown, Average Drawdown, Drawdown Duration, Pain Index, Value at Risk, Conditional Value at Risk (CVaR), Profit Factor, Gain/Loss Ratio, Recovery Factor, Kelly Criterion, Treynor Ratio, Information Ratio, Alpha (Jensen) |
 | Seasonality & Session | Session VWAP, Session High/Low, Session Range, Average Daily Range, Overnight Gap, Overnight/Intraday Return, Turn-of-Month, Seasonal Z-Score, Time-of-Day Return Profile, Day-of-Week Profile, Intraday Volatility Profile, Volume-by-Time Profile |
@@ -237,7 +237,7 @@ A Python live-trading example using the public `websockets` package lives at
 ```
 wickra/
 ├── crates/
-│   ├── wickra-core/         core engine + all 488 indicators
+│   ├── wickra-core/         core engine + all 498 indicators
 │   ├── wickra/              top-level facade crate (publishes on crates.io) + benches/
 │   ├── wickra-data/         CSV reader, tick aggregator, live exchange feeds
 │   └── wickra-bench/        internal cross-library benchmark harness (not published)

bindings/node/__tests__/indicators.test.js

@@ -392,6 +392,9 @@ const candleScalar = {
   DumplingTop: { make: () => new wickra.DumplingTop(9), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   NewPriceLines: { make: () => new wickra.NewPriceLines(5), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
   FryPanBottom: { make: () => new wickra.FryPanBottom(9), step: (ind, i) => ind.update(high[i], low[i], close[i]), batch: (ind) => ind.batch(high, low, close) },
+  NakedPoc: { make: () => new wickra.NakedPoc(20, 24), step: (ind, i) => ind.update(high[i], low[i], close[i], volume[i]), batch: (ind) => ind.batch(high, low, close, volume) },
+  SinglePrints: { make: () => new wickra.SinglePrints(20, 24), step: (ind, i) => ind.update(high[i], low[i]), batch: (ind) => ind.batch(high, low) },
+  ProfileShape: { make: () => new wickra.ProfileShape(20, 24), step: (ind, i) => ind.update(high[i], low[i], volume[i]), batch: (ind) => ind.batch(high, low, volume) },
 };
 
 for (const [name, d] of Object.entries(candleScalar)) {
@@ -497,6 +500,8 @@ const multi = {
   SmoothedHeikinAshi: { make: () => new wickra.SmoothedHeikinAshi(5), fields: ['open', 'high', 'low', 'close'], step: (ind, i) => ind.update(open[i], high[i], low[i], close[i]), batch: (ind) => ind.batch(open, high, low, close) },
   Equivolume: { make: () => new wickra.Equivolume(20), fields: ['height', 'width'], step: (ind, i) => ind.update(high[i], low[i], volume[i]), batch: (ind) => ind.batch(high, low, volume) },
   CandleVolume: { make: () => new wickra.CandleVolume(20), fields: ['body', 'width'], step: (ind, i) => ind.update(open[i], close[i], volume[i]), batch: (ind) => ind.batch(open, close, volume) },
+  HighLowVolumeNodes: { make: () => new wickra.HighLowVolumeNodes(20, 24), fields: ['hvn', 'lvn'], step: (ind, i) => ind.update(high[i], low[i], volume[i]), batch: (ind) => ind.batch(high, low, volume) },
+  CompositeProfile: { make: () => new wickra.CompositeProfile(20, 24, 0.7), fields: ['poc', 'vah', 'val'], step: (ind, i) => ind.update(high[i], low[i], volume[i]), batch: (ind) => ind.batch(high, low, volume) },
 };
 
 for (const [name, d] of Object.entries(multi)) {
@@ -1443,6 +1448,56 @@ test('derivatives reject bad input', () => {
   assert.throws(() => new wickra.FundingBasis().update(100, 0));
 });
 
+test('B16 derivatives reference values', () => {
+  // Estimated leverage: oi / (long + short) = 200 / 100 = 2.
+  assert.ok(Math.abs(new wickra.EstimatedLeverageRatio().update(200, 60, 40) - 2.0) < 1e-12);
+  // OI-to-volume: oi / (buy + sell) = 100 / 50 = 2.
+  assert.ok(Math.abs(new wickra.OiToVolumeRatio().update(100, 30, 20) - 2.0) < 1e-12);
+  // Perpetual premium: (mark - index) / index = 0.5 / 100 = 0.005.
+  assert.ok(Math.abs(new wickra.PerpetualPremiumIndex().update(100.5, 100.0) - 0.005) < 1e-12);
+  // Funding-implied APR: rate * intervals = 0.0001 * 1095 = 0.1095.
+  assert.ok(Math.abs(new wickra.FundingImpliedApr(1095).update(0.0001) - 0.1095) < 1e-12);
+  // Open-interest momentum (period 2): warmup then ROC% = 100*(120 - 100)/100 = 20.
+  const oim = new wickra.OpenInterestMomentum(2);
+  assert.equal(oim.update(100), null);
+  assert.equal(oim.update(110), null);
+  assert.ok(Math.abs(oim.update(120) - 20.0) < 1e-12);
+});
+
+test('B16 derivatives streaming matches batch', () => {
+  const n = 30;
+  const oi = Array.from({ length: n }, (_, i) => 1000 + 50 * Math.sin(i * 0.3));
+  const longSz = Array.from({ length: n }, (_, i) => 600 + 20 * Math.cos(i * 0.2));
+  const shortSz = Array.from({ length: n }, (_, i) => 400 + 15 * Math.sin(i * 0.4));
+  const buy = Array.from({ length: n }, (_, i) => 300 + 10 * Math.sin(i * 0.5));
+  const sell = Array.from({ length: n }, (_, i) => 250 + 12 * Math.cos(i * 0.35));
+  const index = Array.from({ length: n }, (_, i) => 100 + Math.sin(i * 0.2));
+  const mark = Array.from({ length: n }, (_, i) => index[i] + 0.05 * Math.cos(i * 0.3));
+  const rate = Array.from({ length: n }, (_, i) => 0.0001 * Math.sin(i * 0.3));
+  const cmp = (batch, s, i) =>
+    assert.ok((s === null && Number.isNaN(batch[i])) || Math.abs(s - batch[i]) < 1e-12, `mismatch at ${i}`);
+
+  let b = new wickra.EstimatedLeverageRatio().batch(oi, longSz, shortSz);
+  let st = new wickra.EstimatedLeverageRatio();
+  for (let i = 0; i < n; i++) cmp(b, st.update(oi[i], longSz[i], shortSz[i]), i);
+
+  b = new wickra.OiToVolumeRatio().batch(oi, buy, sell);
+  st = new wickra.OiToVolumeRatio();
+  for (let i = 0; i < n; i++) cmp(b, st.update(oi[i], buy[i], sell[i]), i);
+
+  b = new wickra.PerpetualPremiumIndex().batch(mark, index);
+  st = new wickra.PerpetualPremiumIndex();
+  for (let i = 0; i < n; i++) cmp(b, st.update(mark[i], index[i]), i);
+
+  b = new wickra.FundingImpliedApr(1095).batch(rate);
+  st = new wickra.FundingImpliedApr(1095);
+  for (let i = 0; i < n; i++) cmp(b, st.update(rate[i]), i);
+
+  b = new wickra.OpenInterestMomentum(10).batch(oi);
+  st = new wickra.OpenInterestMomentum(10);
+  for (let i = 0; i < n; i++) cmp(b, st.update(oi[i]), i);
+});
+
 test('market breadth: AdvanceDecline reference values', () => {
   // A breadth tick is the universe as parallel arrays; the sign of `change`
   // classifies each symbol as advancing / declining / unchanged.

bindings/node/index.d.ts

@@ -409,6 +409,15 @@ export interface VolumeProfileValue {
   priceHigh: number
   bins: Array<number>
 }
+export interface HighLowVolumeNodesValue {
+  hvn: number
+  lvn: number
+}
+export interface CompositeProfileValue {
+  poc: number
+  vah: number
+  val: number
+}
 export interface TpoProfileValue {
   priceLow: number
   priceHigh: number
@@ -3470,6 +3479,51 @@ export declare class ValueArea {
   update(high: number, low: number, volume: number): ValueAreaValue | null
   batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
 }
+export type NakedPocNode = NakedPoc
+export declare class NakedPoc {
+  constructor(sessionLen: number, binCount: number)
+  update(high: number, low: number, close: number, volume: number): number | null
+  batch(high: Array<number>, low: Array<number>, close: Array<number>, volume: Array<number>): Array<number>
+  reset(): void
+  isReady(): boolean
+  warmupPeriod(): number
+}
+export type SinglePrintsNode = SinglePrints
+export declare class SinglePrints {
+  constructor(period: number, binCount: number)
+  update(high: number, low: number): number | null
+  batch(high: Array<number>, low: Array<number>): Array<number>
+  reset(): void
+  isReady(): boolean
+  warmupPeriod(): number
+}
+export type ProfileShapeNode = ProfileShape
+export declare class ProfileShape {
+  constructor(period: number, binCount: number)
+  update(high: number, low: number, volume: number): number | null
+  batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
+  reset(): void
+  isReady(): boolean
+  warmupPeriod(): number
+}
+export type HighLowVolumeNodesNode = HighLowVolumeNodes
+export declare class HighLowVolumeNodes {
+  constructor(period: number, binCount: number)
+  update(high: number, low: number, volume: number): HighLowVolumeNodesValue | null
+  batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
+  reset(): void
+  isReady(): boolean
+  warmupPeriod(): number
+}
+export type CompositeProfileNode = CompositeProfile
+export declare class CompositeProfile {
+  constructor(period: number, binCount: number, valueAreaPct: number)
+  update(high: number, low: number, volume: number): CompositeProfileValue | null
+  batch(high: Array<number>, low: Array<number>, volume: Array<number>): Array<number>
+  reset(): void
+  isReady(): boolean
+  warmupPeriod(): number
+}
 export type VolumeProfileNode = VolumeProfile
 export declare class VolumeProfile {
   constructor(period: number, binCount: number)
@@ -4544,6 +4598,51 @@ export declare class CalendarSpread {
   isReady(): boolean
   warmupPeriod(): number
 }
+export type EstimatedLeverageRatioNode = EstimatedLeverageRatio
+export declare class EstimatedLeverageRatio {
+  constructor()
+  update(openInterest: number, longSize: number, shortSize: number): number | null
+  batch(openInterest: Array<number>, longSize: Array<number>, shortSize: Array<number>): Array<number>
+  reset(): void
+  isReady(): boolean
+  warmupPeriod(): number
+}
+export type OiToVolumeRatioNode = OiToVolumeRatio
+export declare class OiToVolumeRatio {
+  constructor()
+  update(openInterest: number, takerBuyVolume: number, takerSellVolume: number): number | null
+  batch(openInterest: Array<number>, takerBuyVolume: Array<number>, takerSellVolume: Array<number>): Array<number>
+  reset(): void
+  isReady(): boolean
+  warmupPeriod(): number
+}
+export type PerpetualPremiumIndexNode = PerpetualPremiumIndex
+export declare class PerpetualPremiumIndex {
+  constructor()
+  update(markPrice: number, indexPrice: number): number | null
+  batch(markPrice: Array<number>, indexPrice: Array<number>): Array<number>
+  reset(): void
+  isReady(): boolean
+  warmupPeriod(): number
+}
+export type FundingImpliedAprNode = FundingImpliedApr
+export declare class FundingImpliedApr {
+  constructor(intervalsPerYear: number)
+  update(fundingRate: number): number | null
+  batch(fundingRate: Array<number>): Array<number>
+  reset(): void
+  isReady(): boolean
+  warmupPeriod(): number
+}
+export type OpenInterestMomentumNode = OpenInterestMomentum
+export declare class OpenInterestMomentum {
+  constructor(period: number)
+  update(openInterest: number): number | null
+  batch(openInterest: Array<number>): Array<number>
+  reset(): void
+  isReady(): boolean
+  warmupPeriod(): number
+}
 export type AdvanceDeclineNode = AdvanceDecline
 export declare class AdvanceDecline {
   constructor()

bindings/node/npm/darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra-darwin-arm64",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Native binding for wickra (macOS Apple Silicon). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.darwin-arm64.node",
   "files": [

bindings/node/npm/darwin-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra-darwin-x64",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Native binding for wickra (macOS Intel). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.darwin-x64.node",
   "files": [

bindings/node/npm/linux-arm64-gnu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra-linux-arm64-gnu",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Native binding for wickra (linux arm64 GNU). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.linux-arm64-gnu.node",
   "files": [

bindings/node/npm/linux-x64-gnu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra-linux-x64-gnu",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Native binding for wickra (linux x64 GNU). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.linux-x64-gnu.node",
   "files": [

bindings/node/npm/win32-arm64-msvc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra-win32-arm64-msvc",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Native binding for wickra (Windows arm64 MSVC). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.win32-arm64-msvc.node",
   "files": [

bindings/node/npm/win32-x64-msvc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra-win32-x64-msvc",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Native binding for wickra (Windows x64 MSVC). Installed automatically as an optional dependency of wickra on matching platforms.",
   "main": "wickra.win32-x64-msvc.node",
   "files": [

bindings/node/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "wickra",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "wickra",
-      "version": "0.7.0",
+      "version": "0.7.2",
       "license": "MIT OR Apache-2.0",
       "devDependencies": {
         "@napi-rs/cli": "^2.18.0"
@@ -15,12 +15,12 @@
         "node": ">= 18"
       },
       "optionalDependencies": {
-        "wickra-darwin-arm64": "0.7.0",
-        "wickra-darwin-x64": "0.7.0",
-        "wickra-linux-arm64-gnu": "0.7.0",
-        "wickra-linux-x64-gnu": "0.7.0",
-        "wickra-win32-arm64-msvc": "0.7.0",
-        "wickra-win32-x64-msvc": "0.7.0"
+        "wickra-darwin-arm64": "0.7.2",
+        "wickra-darwin-x64": "0.7.2",
+        "wickra-linux-arm64-gnu": "0.7.2",
+        "wickra-linux-x64-gnu": "0.7.2",
+        "wickra-win32-arm64-msvc": "0.7.2",
+        "wickra-win32-x64-msvc": "0.7.2"
       }
     },
     "node_modules/@napi-rs/cli": {
@@ -41,8 +41,8 @@
       }
     },
     "node_modules/wickra-darwin-arm64": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/wickra-darwin-arm64/-/wickra-darwin-arm64-0.7.0.tgz",
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/wickra-darwin-arm64/-/wickra-darwin-arm64-0.7.2.tgz",
       "integrity": "sha512-4eZiBR/yGUdr4nzhEUFy2i69XgNx64iI2ax/LPamsThgylC0KpHOZKK19QzJ2d9KbK4C8nMjME5FLuR+4GNEwQ==",
       "cpu": [
         "arm64"
@@ -57,8 +57,8 @@
       }
     },
     "node_modules/wickra-darwin-x64": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/wickra-darwin-x64/-/wickra-darwin-x64-0.7.0.tgz",
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/wickra-darwin-x64/-/wickra-darwin-x64-0.7.2.tgz",
       "integrity": "sha512-6hf8zI3QPjTFp4zCpmgUwDvNtu6jHqNUHKD5e55POo0CgA52HkpyxSPtVm8TGTIZDI7kPjlbOdBM8CJ76mmXwA==",
       "cpu": [
         "x64"
@@ -73,8 +73,8 @@
       }
     },
     "node_modules/wickra-linux-arm64-gnu": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/wickra-linux-arm64-gnu/-/wickra-linux-arm64-gnu-0.7.0.tgz",
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/wickra-linux-arm64-gnu/-/wickra-linux-arm64-gnu-0.7.2.tgz",
       "integrity": "sha512-kSe6y0xBMSiqdPLXNjwop5WZdHtvdBNKSEBCwZ4hFq33p4apW25/wrlzv9/oDuyD4kuPabJEhCCnFOplh58CUg==",
       "cpu": [
         "arm64"
@@ -89,8 +89,8 @@
       }
     },
     "node_modules/wickra-linux-x64-gnu": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/wickra-linux-x64-gnu/-/wickra-linux-x64-gnu-0.7.0.tgz",
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/wickra-linux-x64-gnu/-/wickra-linux-x64-gnu-0.7.2.tgz",
       "integrity": "sha512-tWBWS4qz7hxM4xnpFb59bhf6TaLwXq0Z3jEa/2l7r8PiHA94g8r8S53NRMiT+4yiL5hSWe/nUiC/YXdRrhEZ4g==",
       "cpu": [
         "x64"
@@ -105,8 +105,8 @@
       }
     },
     "node_modules/wickra-win32-arm64-msvc": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/wickra-win32-arm64-msvc/-/wickra-win32-arm64-msvc-0.7.0.tgz",
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/wickra-win32-arm64-msvc/-/wickra-win32-arm64-msvc-0.7.2.tgz",
       "integrity": "sha512-EXIckHxAtF75PUGDKRzXyqMe9ldP0JjSdu68WFN6iJfp+McYrGu6h40TEJlQ/oUEIoPqiZB/xhVyo/el5Lg7zw==",
       "cpu": [
         "arm64"
@@ -121,8 +121,8 @@
       }
     },
     "node_modules/wickra-win32-x64-msvc": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/wickra-win32-x64-msvc/-/wickra-win32-x64-msvc-0.7.0.tgz",
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/wickra-win32-x64-msvc/-/wickra-win32-x64-msvc-0.7.2.tgz",
       "integrity": "sha512-Yfsqq1Xwp6hdxMyLze411vNdo7BDwI6+lPSe7A9XdqyPecNDbtKwYLpsal2r8EHbNzqM+R8XnuRtUaEQS5VlUQ==",
       "cpu": [
         "x64"

bindings/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wickra",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Streaming-first technical indicators: incremental, fast, install-free. Node bindings powered by Rust.",
   "author": "kingchenc <support@wickra.org>",
   "main": "index.js",
@@ -47,12 +47,12 @@
     "node": ">= 18"
   },
   "optionalDependencies": {
-    "wickra-linux-x64-gnu": "0.7.0",
-    "wickra-linux-arm64-gnu": "0.7.0",
-    "wickra-darwin-x64": "0.7.0",
-    "wickra-darwin-arm64": "0.7.0",
-    "wickra-win32-x64-msvc": "0.7.0",
-    "wickra-win32-arm64-msvc": "0.7.0"
+    "wickra-linux-x64-gnu": "0.7.2",
+    "wickra-linux-arm64-gnu": "0.7.2",
+    "wickra-darwin-x64": "0.7.2",
+    "wickra-darwin-arm64": "0.7.2",
+    "wickra-win32-x64-msvc": "0.7.2",
+    "wickra-win32-arm64-msvc": "0.7.2"
   },
   "scripts": {
     "build": "napi build --platform --release",

bindings/node/src/lib.rs

@@ -12874,6 +12874,332 @@ pub struct VolumeProfileValue {
     pub bins: Vec<f64>,
 }
 
+// Naked POC: most recent untouched point-of-control level (Candle -> f64).
+#[napi(js_name = "NakedPoc")]
+pub struct NakedPocNode {
+    inner: wc::NakedPoc,
+}
+
+#[napi]
+impl NakedPocNode {
+    #[napi(constructor)]
+    pub fn new(session_len: u32, bin_count: u32) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::NakedPoc::new(session_len as usize, bin_count as usize).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(
+        &mut self,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+    ) -> napi::Result<Option<f64>> {
+        Ok(self.inner.update(cnd(high, low, close, volume)?))
+    }
+    #[napi]
+    pub fn batch(
+        &mut self,
+        high: Vec<f64>,
+        low: Vec<f64>,
+        close: Vec<f64>,
+        volume: Vec<f64>,
+    ) -> napi::Result<Vec<f64>> {
+        if high.len() != low.len() || low.len() != close.len() || close.len() != volume.len() {
+            return Err(NapiError::from_reason(
+                "high, low, close, volume must be equal length".to_string(),
+            ));
+        }
+        let mut out = Vec::with_capacity(close.len());
+        for i in 0..close.len() {
+            out.push(
+                self.inner
+                    .update(cnd(high[i], low[i], close[i], volume[i])?)
+                    .unwrap_or(f64::NAN),
+            );
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+// Single Prints: count of single-print price levels (Candle -> f64).
+#[napi(js_name = "SinglePrints")]
+pub struct SinglePrintsNode {
+    inner: wc::SinglePrints,
+}
+
+#[napi]
+impl SinglePrintsNode {
+    #[napi(constructor)]
+    pub fn new(period: u32, bin_count: u32) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::SinglePrints::new(period as usize, bin_count as usize).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(&mut self, high: f64, low: f64) -> napi::Result<Option<f64>> {
+        let mid = f64::midpoint(high, low);
+        Ok(self
+            .inner
+            .update(wc::Candle::new(mid, high, low, mid, 0.0, 0).map_err(map_err)?))
+    }
+    #[napi]
+    pub fn batch(&mut self, high: Vec<f64>, low: Vec<f64>) -> napi::Result<Vec<f64>> {
+        if high.len() != low.len() {
+            return Err(NapiError::from_reason(
+                "high and low must be equal length".to_string(),
+            ));
+        }
+        let mut out = Vec::with_capacity(high.len());
+        for i in 0..high.len() {
+            let mid = f64::midpoint(high[i], low[i]);
+            out.push(
+                self.inner
+                    .update(wc::Candle::new(mid, high[i], low[i], mid, 0.0, 0).map_err(map_err)?)
+                    .unwrap_or(f64::NAN),
+            );
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+// Profile Shape: b/P/D classification as a numeric code (Candle -> f64).
+#[napi(js_name = "ProfileShape")]
+pub struct ProfileShapeNode {
+    inner: wc::ProfileShape,
+}
+
+#[napi]
+impl ProfileShapeNode {
+    #[napi(constructor)]
+    pub fn new(period: u32, bin_count: u32) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::ProfileShape::new(period as usize, bin_count as usize).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(&mut self, high: f64, low: f64, volume: f64) -> napi::Result<Option<f64>> {
+        let mid = f64::midpoint(high, low);
+        Ok(self
+            .inner
+            .update(wc::Candle::new(mid, high, low, mid, volume, 0).map_err(map_err)?))
+    }
+    #[napi]
+    pub fn batch(
+        &mut self,
+        high: Vec<f64>,
+        low: Vec<f64>,
+        volume: Vec<f64>,
+    ) -> napi::Result<Vec<f64>> {
+        if high.len() != low.len() || low.len() != volume.len() {
+            return Err(NapiError::from_reason(
+                "high, low, volume must be equal length".to_string(),
+            ));
+        }
+        let mut out = Vec::with_capacity(high.len());
+        for i in 0..high.len() {
+            let mid = f64::midpoint(high[i], low[i]);
+            out.push(
+                self.inner
+                    .update(
+                        wc::Candle::new(mid, high[i], low[i], mid, volume[i], 0)
+                            .map_err(map_err)?,
+                    )
+                    .unwrap_or(f64::NAN),
+            );
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+#[napi(object)]
+pub struct HighLowVolumeNodesValue {
+    pub hvn: f64,
+    pub lvn: f64,
+}
+
+// High/Low Volume Nodes: highest- and lowest-volume price nodes (Candle -> struct).
+#[napi(js_name = "HighLowVolumeNodes")]
+pub struct HighLowVolumeNodesNode {
+    inner: wc::HighLowVolumeNodes,
+}
+
+#[napi]
+impl HighLowVolumeNodesNode {
+    #[napi(constructor)]
+    pub fn new(period: u32, bin_count: u32) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::HighLowVolumeNodes::new(period as usize, bin_count as usize)
+                .map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(
+        &mut self,
+        high: f64,
+        low: f64,
+        volume: f64,
+    ) -> napi::Result<Option<HighLowVolumeNodesValue>> {
+        let mid = f64::midpoint(high, low);
+        let candle = wc::Candle::new(mid, high, low, mid, volume, 0).map_err(map_err)?;
+        Ok(self.inner.update(candle).map(|o| HighLowVolumeNodesValue {
+            hvn: o.hvn,
+            lvn: o.lvn,
+        }))
+    }
+    #[napi]
+    pub fn batch(
+        &mut self,
+        high: Vec<f64>,
+        low: Vec<f64>,
+        volume: Vec<f64>,
+    ) -> napi::Result<Vec<f64>> {
+        if high.len() != low.len() || low.len() != volume.len() {
+            return Err(NapiError::from_reason(
+                "high, low, volume must be equal length".to_string(),
+            ));
+        }
+        let n = high.len();
+        let mut out = vec![f64::NAN; n * 2];
+        for i in 0..n {
+            let mid = f64::midpoint(high[i], low[i]);
+            let candle =
+                wc::Candle::new(mid, high[i], low[i], mid, volume[i], 0).map_err(map_err)?;
+            if let Some(o) = self.inner.update(candle) {
+                out[i * 2] = o.hvn;
+                out[i * 2 + 1] = o.lvn;
+            }
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+#[napi(object)]
+pub struct CompositeProfileValue {
+    pub poc: f64,
+    pub vah: f64,
+    pub val: f64,
+}
+
+// Composite Profile: multi-session composite volume profile (Candle -> struct).
+#[napi(js_name = "CompositeProfile")]
+pub struct CompositeProfileNode {
+    inner: wc::CompositeProfile,
+}
+
+#[napi]
+impl CompositeProfileNode {
+    #[napi(constructor)]
+    pub fn new(period: u32, bin_count: u32, value_area_pct: f64) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::CompositeProfile::new(period as usize, bin_count as usize, value_area_pct)
+                .map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(
+        &mut self,
+        high: f64,
+        low: f64,
+        volume: f64,
+    ) -> napi::Result<Option<CompositeProfileValue>> {
+        let mid = f64::midpoint(high, low);
+        let candle = wc::Candle::new(mid, high, low, mid, volume, 0).map_err(map_err)?;
+        Ok(self.inner.update(candle).map(|o| CompositeProfileValue {
+            poc: o.poc,
+            vah: o.vah,
+            val: o.val,
+        }))
+    }
+    #[napi]
+    pub fn batch(
+        &mut self,
+        high: Vec<f64>,
+        low: Vec<f64>,
+        volume: Vec<f64>,
+    ) -> napi::Result<Vec<f64>> {
+        if high.len() != low.len() || low.len() != volume.len() {
+            return Err(NapiError::from_reason(
+                "high, low, volume must be equal length".to_string(),
+            ));
+        }
+        let n = high.len();
+        let mut out = vec![f64::NAN; n * 3];
+        for i in 0..n {
+            let mid = f64::midpoint(high[i], low[i]);
+            let candle =
+                wc::Candle::new(mid, high[i], low[i], mid, volume[i], 0).map_err(map_err)?;
+            if let Some(o) = self.inner.update(candle) {
+                out[i * 3] = o.poc;
+                out[i * 3 + 1] = o.vah;
+                out[i * 3 + 2] = o.val;
+            }
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
 #[napi(js_name = "VolumeProfile")]
 pub struct VolumeProfileNode {
     inner: wc::VolumeProfile,
@@ -14450,6 +14776,50 @@ fn deriv_taker(taker_buy_volume: f64, taker_sell_volume: f64) -> napi::Result<wc
     .map_err(map_err)
 }
 
+fn deriv_oi_long_short(
+    open_interest: f64,
+    long_size: f64,
+    short_size: f64,
+) -> napi::Result<wc::DerivativesTick> {
+    wc::DerivativesTick::new(
+        0.0,
+        1.0,
+        1.0,
+        1.0,
+        open_interest,
+        long_size,
+        short_size,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+    )
+    .map_err(map_err)
+}
+
+fn deriv_oi_taker(
+    open_interest: f64,
+    taker_buy_volume: f64,
+    taker_sell_volume: f64,
+) -> napi::Result<wc::DerivativesTick> {
+    wc::DerivativesTick::new(
+        0.0,
+        1.0,
+        1.0,
+        1.0,
+        open_interest,
+        0.0,
+        0.0,
+        taker_buy_volume,
+        taker_sell_volume,
+        0.0,
+        0.0,
+        0,
+    )
+    .map_err(map_err)
+}
+
 fn deriv_liquidation(
     long_liquidation: f64,
     short_liquidation: f64,
@@ -15165,6 +15535,288 @@ impl CalendarSpreadNode {
     }
 }
 
+// Estimated leverage ratio: open interest over aggregate long+short size.
+#[napi(js_name = "EstimatedLeverageRatio")]
+pub struct EstimatedLeverageRatioNode {
+    inner: wc::EstimatedLeverageRatio,
+}
+
+impl Default for EstimatedLeverageRatioNode {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[napi]
+impl EstimatedLeverageRatioNode {
+    #[napi(constructor)]
+    pub fn new() -> Self {
+        Self {
+            inner: wc::EstimatedLeverageRatio::new(),
+        }
+    }
+    #[napi]
+    pub fn update(
+        &mut self,
+        open_interest: f64,
+        long_size: f64,
+        short_size: f64,
+    ) -> napi::Result<Option<f64>> {
+        Ok(self
+            .inner
+            .update(deriv_oi_long_short(open_interest, long_size, short_size)?))
+    }
+    #[napi]
+    pub fn batch(
+        &mut self,
+        open_interest: Vec<f64>,
+        long_size: Vec<f64>,
+        short_size: Vec<f64>,
+    ) -> napi::Result<Vec<f64>> {
+        if open_interest.len() != long_size.len() || long_size.len() != short_size.len() {
+            return Err(NapiError::from_reason(
+                "open_interest, long_size, short_size must be equal length".to_string(),
+            ));
+        }
+        let mut out = Vec::with_capacity(open_interest.len());
+        for i in 0..open_interest.len() {
+            out.push(
+                self.inner
+                    .update(deriv_oi_long_short(
+                        open_interest[i],
+                        long_size[i],
+                        short_size[i],
+                    )?)
+                    .unwrap_or(f64::NAN),
+            );
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+// OI-to-volume ratio: open interest over taker buy+sell volume.
+#[napi(js_name = "OiToVolumeRatio")]
+pub struct OiToVolumeRatioNode {
+    inner: wc::OiToVolumeRatio,
+}
+
+impl Default for OiToVolumeRatioNode {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[napi]
+impl OiToVolumeRatioNode {
+    #[napi(constructor)]
+    pub fn new() -> Self {
+        Self {
+            inner: wc::OiToVolumeRatio::new(),
+        }
+    }
+    #[napi]
+    pub fn update(
+        &mut self,
+        open_interest: f64,
+        taker_buy_volume: f64,
+        taker_sell_volume: f64,
+    ) -> napi::Result<Option<f64>> {
+        Ok(self.inner.update(deriv_oi_taker(
+            open_interest,
+            taker_buy_volume,
+            taker_sell_volume,
+        )?))
+    }
+    #[napi]
+    pub fn batch(
+        &mut self,
+        open_interest: Vec<f64>,
+        taker_buy_volume: Vec<f64>,
+        taker_sell_volume: Vec<f64>,
+    ) -> napi::Result<Vec<f64>> {
+        if open_interest.len() != taker_buy_volume.len()
+            || taker_buy_volume.len() != taker_sell_volume.len()
+        {
+            return Err(NapiError::from_reason(
+                "open_interest, taker_buy_volume, taker_sell_volume must be equal length"
+                    .to_string(),
+            ));
+        }
+        let mut out = Vec::with_capacity(open_interest.len());
+        for i in 0..open_interest.len() {
+            out.push(
+                self.inner
+                    .update(deriv_oi_taker(
+                        open_interest[i],
+                        taker_buy_volume[i],
+                        taker_sell_volume[i],
+                    )?)
+                    .unwrap_or(f64::NAN),
+            );
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+// Perpetual premium index: relative premium of mark over index price.
+#[napi(js_name = "PerpetualPremiumIndex")]
+pub struct PerpetualPremiumIndexNode {
+    inner: wc::PerpetualPremiumIndex,
+}
+
+impl Default for PerpetualPremiumIndexNode {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[napi]
+impl PerpetualPremiumIndexNode {
+    #[napi(constructor)]
+    pub fn new() -> Self {
+        Self {
+            inner: wc::PerpetualPremiumIndex::new(),
+        }
+    }
+    #[napi]
+    pub fn update(&mut self, mark_price: f64, index_price: f64) -> napi::Result<Option<f64>> {
+        Ok(self.inner.update(deriv_basis(mark_price, index_price)?))
+    }
+    #[napi]
+    pub fn batch(&mut self, mark_price: Vec<f64>, index_price: Vec<f64>) -> napi::Result<Vec<f64>> {
+        if mark_price.len() != index_price.len() {
+            return Err(NapiError::from_reason(
+                "mark_price and index_price must be equal length".to_string(),
+            ));
+        }
+        let mut out = Vec::with_capacity(mark_price.len());
+        for i in 0..mark_price.len() {
+            out.push(
+                self.inner
+                    .update(deriv_basis(mark_price[i], index_price[i])?)
+                    .unwrap_or(f64::NAN),
+            );
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+// Funding-implied APR: per-interval funding annualised.
+#[napi(js_name = "FundingImpliedApr")]
+pub struct FundingImpliedAprNode {
+    inner: wc::FundingImpliedApr,
+}
+
+#[napi]
+impl FundingImpliedAprNode {
+    #[napi(constructor)]
+    pub fn new(intervals_per_year: f64) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::FundingImpliedApr::new(intervals_per_year).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(&mut self, funding_rate: f64) -> napi::Result<Option<f64>> {
+        Ok(self.inner.update(deriv_funding(funding_rate)?))
+    }
+    #[napi]
+    pub fn batch(&mut self, funding_rate: Vec<f64>) -> napi::Result<Vec<f64>> {
+        let mut out = Vec::with_capacity(funding_rate.len());
+        for r in funding_rate {
+            out.push(self.inner.update(deriv_funding(r)?).unwrap_or(f64::NAN));
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
+// Open-interest momentum: rate-of-change of open interest over a window.
+#[napi(js_name = "OpenInterestMomentum")]
+pub struct OpenInterestMomentumNode {
+    inner: wc::OpenInterestMomentum,
+}
+
+#[napi]
+impl OpenInterestMomentumNode {
+    #[napi(constructor)]
+    pub fn new(period: u32) -> napi::Result<Self> {
+        Ok(Self {
+            inner: wc::OpenInterestMomentum::new(period as usize).map_err(map_err)?,
+        })
+    }
+    #[napi]
+    pub fn update(&mut self, open_interest: f64) -> napi::Result<Option<f64>> {
+        Ok(self.inner.update(deriv_oi(open_interest)?))
+    }
+    #[napi]
+    pub fn batch(&mut self, open_interest: Vec<f64>) -> napi::Result<Vec<f64>> {
+        let mut out = Vec::with_capacity(open_interest.len());
+        for oi in open_interest {
+            out.push(self.inner.update(deriv_oi(oi)?).unwrap_or(f64::NAN));
+        }
+        Ok(out)
+    }
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[napi(js_name = "isReady")]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[napi(js_name = "warmupPeriod")]
+    pub fn warmup_period(&self) -> u32 {
+        self.inner.warmup_period() as u32
+    }
+}
+
 // ---------- Market Breadth (CrossSection input) ----------
 //
 // A breadth tick is the per-symbol state of the whole universe, passed as four

bindings/python/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "wickra"
-version = "0.7.0"
+version = "0.7.2"
 description = "Streaming-first technical indicators: incremental, fast, install-free."
 readme = "README.md"
 license = "MIT OR Apache-2.0"

bindings/python/python/wickra/__init__.py

@@ -350,6 +350,11 @@ from ._wickra import (
     Equivolume,
     CandleVolume,
     # Market Profile
+    CompositeProfile,
+    HighLowVolumeNodes,
+    ProfileShape,
+    SinglePrints,
+    NakedPoc,
     ValueArea,
     VolumeProfile,
     TpoProfile,
@@ -480,6 +485,11 @@ from ._wickra import (
     # Microstructure: footprint
     Footprint,
     # Derivatives
+    OpenInterestMomentum,
+    FundingImpliedApr,
+    PerpetualPremiumIndex,
+    OiToVolumeRatio,
+    EstimatedLeverageRatio,
     FundingRate,
     FundingRateMean,
     FundingRateZScore,
@@ -868,6 +878,11 @@ __all__ = [
     "Equivolume",
     "CandleVolume",
     # Market Profile
+    "CompositeProfile",
+    "HighLowVolumeNodes",
+    "ProfileShape",
+    "SinglePrints",
+    "NakedPoc",
     "ValueArea",
     "VolumeProfile",
     "TpoProfile",
@@ -998,6 +1013,11 @@ __all__ = [
     # Microstructure: footprint
     "Footprint",
     # Derivatives
+    "OpenInterestMomentum",
+    "FundingImpliedApr",
+    "PerpetualPremiumIndex",
+    "OiToVolumeRatio",
+    "EstimatedLeverageRatio",
     "FundingRate",
     "FundingRateMean",
     "FundingRateZScore",

bindings/python/src/lib.rs

@@ -18140,6 +18140,349 @@ impl PyOpeningRange {
     }
 }
 
+// Naked POC: most recent untouched point-of-control level (Candle -> f64).
+#[pyclass(name = "NakedPoc", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PyNakedPoc {
+    inner: wc::NakedPoc,
+}
+
+#[pymethods]
+impl PyNakedPoc {
+    #[new]
+    #[pyo3(signature = (session_len=20, bin_count=24))]
+    fn new(session_len: usize, bin_count: usize) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::NakedPoc::new(session_len, bin_count).map_err(map_err)?,
+        })
+    }
+    fn update(&mut self, candle: &Bound<'_, PyAny>) -> PyResult<Option<f64>> {
+        let c = extract_candle(candle)?;
+        Ok(self.inner.update(c))
+    }
+    /// Batch over numpy high, low, close, volume arrays (all 1-D, equal length).
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        high: PyReadonlyArray1<'py, f64>,
+        low: PyReadonlyArray1<'py, f64>,
+        close: PyReadonlyArray1<'py, f64>,
+        volume: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        let h = high
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let l = low
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let c = close
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let v = volume
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        if h.len() != l.len() || l.len() != c.len() || c.len() != v.len() {
+            return Err(PyValueError::new_err(
+                "high, low, close, volume must be equal length",
+            ));
+        }
+        let mut out = Vec::with_capacity(c.len());
+        for i in 0..c.len() {
+            let candle = wc::Candle::new(c[i], h[i], l[i], c[i], v[i], 0).map_err(map_err)?;
+            out.push(self.inner.update(candle).unwrap_or(f64::NAN));
+        }
+        Ok(out.into_pyarray(py))
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        let (s, b) = self.inner.params();
+        format!("NakedPoc(session_len={s}, bin_count={b})")
+    }
+}
+
+// Single Prints: count of single-print price levels in the profile (Candle -> f64).
+#[pyclass(name = "SinglePrints", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PySinglePrints {
+    inner: wc::SinglePrints,
+}
+
+#[pymethods]
+impl PySinglePrints {
+    #[new]
+    #[pyo3(signature = (period=20, bin_count=24))]
+    fn new(period: usize, bin_count: usize) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::SinglePrints::new(period, bin_count).map_err(map_err)?,
+        })
+    }
+    fn update(&mut self, candle: &Bound<'_, PyAny>) -> PyResult<Option<f64>> {
+        let c = extract_candle(candle)?;
+        Ok(self.inner.update(c))
+    }
+    /// Batch over numpy high, low arrays (1-D, equal length).
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        high: PyReadonlyArray1<'py, f64>,
+        low: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        let h = high
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let l = low
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        if h.len() != l.len() {
+            return Err(PyValueError::new_err("high and low must be equal length"));
+        }
+        let mut out = Vec::with_capacity(h.len());
+        for i in 0..h.len() {
+            let mid = f64::midpoint(h[i], l[i]);
+            let candle = wc::Candle::new(mid, h[i], l[i], mid, 0.0, 0).map_err(map_err)?;
+            out.push(self.inner.update(candle).unwrap_or(f64::NAN));
+        }
+        Ok(out.into_pyarray(py))
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        let (p, b) = self.inner.params();
+        format!("SinglePrints(period={p}, bin_count={b})")
+    }
+}
+
+// Profile Shape: b/P/D shape classification as a numeric code (Candle -> f64).
+#[pyclass(name = "ProfileShape", module = "wickra._wickra", skip_from_py_object)]
+#[derive(Clone)]
+struct PyProfileShape {
+    inner: wc::ProfileShape,
+}
+
+#[pymethods]
+impl PyProfileShape {
+    #[new]
+    #[pyo3(signature = (period=20, bin_count=24))]
+    fn new(period: usize, bin_count: usize) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::ProfileShape::new(period, bin_count).map_err(map_err)?,
+        })
+    }
+    fn update(&mut self, candle: &Bound<'_, PyAny>) -> PyResult<Option<f64>> {
+        let c = extract_candle(candle)?;
+        Ok(self.inner.update(c))
+    }
+    /// Batch over numpy high, low, volume arrays (1-D, equal length).
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        high: PyReadonlyArray1<'py, f64>,
+        low: PyReadonlyArray1<'py, f64>,
+        volume: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        let h = high
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let l = low
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let v = volume
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        if h.len() != l.len() || l.len() != v.len() {
+            return Err(PyValueError::new_err(
+                "high, low, volume must be equal length",
+            ));
+        }
+        let mut out = Vec::with_capacity(h.len());
+        for i in 0..h.len() {
+            let mid = f64::midpoint(h[i], l[i]);
+            let candle = wc::Candle::new(mid, h[i], l[i], mid, v[i], 0).map_err(map_err)?;
+            out.push(self.inner.update(candle).unwrap_or(f64::NAN));
+        }
+        Ok(out.into_pyarray(py))
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        let (p, b) = self.inner.params();
+        format!("ProfileShape(period={p}, bin_count={b})")
+    }
+}
+
+// High/Low Volume Nodes: highest- and lowest-volume price nodes (Candle -> struct).
+#[pyclass(
+    name = "HighLowVolumeNodes",
+    module = "wickra._wickra",
+    skip_from_py_object
+)]
+#[derive(Clone)]
+struct PyHighLowVolumeNodes {
+    inner: wc::HighLowVolumeNodes,
+}
+
+#[pymethods]
+impl PyHighLowVolumeNodes {
+    #[new]
+    #[pyo3(signature = (period=20, bin_count=24))]
+    fn new(period: usize, bin_count: usize) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::HighLowVolumeNodes::new(period, bin_count).map_err(map_err)?,
+        })
+    }
+    fn update(&mut self, candle: &Bound<'_, PyAny>) -> PyResult<Option<(f64, f64)>> {
+        let c = extract_candle(candle)?;
+        Ok(self.inner.update(c).map(|o| (o.hvn, o.lvn)))
+    }
+    /// Batch over numpy high, low, volume. Returns shape `(n, 2)` `[hvn, lvn]`.
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        high: PyReadonlyArray1<'py, f64>,
+        low: PyReadonlyArray1<'py, f64>,
+        volume: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray2<f64>>> {
+        let h = high
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let l = low
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let v = volume
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        if h.len() != l.len() || l.len() != v.len() {
+            return Err(PyValueError::new_err(
+                "high, low, volume must be equal length",
+            ));
+        }
+        let n = h.len();
+        let mut out = vec![f64::NAN; n * 2];
+        for i in 0..n {
+            let mid = f64::midpoint(h[i], l[i]);
+            let candle = wc::Candle::new(mid, h[i], l[i], mid, v[i], 0).map_err(map_err)?;
+            if let Some(o) = self.inner.update(candle) {
+                out[i * 2] = o.hvn;
+                out[i * 2 + 1] = o.lvn;
+            }
+        }
+        Ok(numpy::ndarray::Array2::from_shape_vec((n, 2), out)
+            .expect("shape consistent")
+            .into_pyarray(py))
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        let (p, b) = self.inner.params();
+        format!("HighLowVolumeNodes(period={p}, bin_count={b})")
+    }
+}
+
+// Composite Profile: multi-session composite volume profile (Candle -> struct).
+#[pyclass(
+    name = "CompositeProfile",
+    module = "wickra._wickra",
+    skip_from_py_object
+)]
+#[derive(Clone)]
+struct PyCompositeProfile {
+    inner: wc::CompositeProfile,
+}
+
+#[pymethods]
+impl PyCompositeProfile {
+    #[new]
+    #[pyo3(signature = (period=20, bin_count=24, value_area_pct=0.70))]
+    fn new(period: usize, bin_count: usize, value_area_pct: f64) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::CompositeProfile::new(period, bin_count, value_area_pct).map_err(map_err)?,
+        })
+    }
+    fn update(&mut self, candle: &Bound<'_, PyAny>) -> PyResult<Option<(f64, f64, f64)>> {
+        let c = extract_candle(candle)?;
+        Ok(self.inner.update(c).map(|o| (o.poc, o.vah, o.val)))
+    }
+    /// Batch over numpy high, low, volume. Returns shape `(n, 3)` `[poc, vah, val]`.
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        high: PyReadonlyArray1<'py, f64>,
+        low: PyReadonlyArray1<'py, f64>,
+        volume: PyReadonlyArray1<'py, f64>,
+    ) -> PyResult<Bound<'py, PyArray2<f64>>> {
+        let h = high
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let l = low
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        let v = volume
+            .as_slice()
+            .map_err(|_| PyValueError::new_err(NON_CONTIGUOUS))?;
+        if h.len() != l.len() || l.len() != v.len() {
+            return Err(PyValueError::new_err(
+                "high, low, volume must be equal length",
+            ));
+        }
+        let n = h.len();
+        let mut out = vec![f64::NAN; n * 3];
+        for i in 0..n {
+            let mid = f64::midpoint(h[i], l[i]);
+            let candle = wc::Candle::new(mid, h[i], l[i], mid, v[i], 0).map_err(map_err)?;
+            if let Some(o) = self.inner.update(candle) {
+                out[i * 3] = o.poc;
+                out[i * 3 + 1] = o.vah;
+                out[i * 3 + 2] = o.val;
+            }
+        }
+        Ok(numpy::ndarray::Array2::from_shape_vec((n, 3), out)
+            .expect("shape consistent")
+            .into_pyarray(py))
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        let (p, b, pct) = self.inner.params();
+        format!("CompositeProfile(period={p}, bin_count={b}, value_area_pct={pct})")
+    }
+}
+
 // ============================== Candlestick Patterns ==============================
 //
 // All 15 patterns take Candles and emit a signed f64 signal per bar:
@@ -19420,6 +19763,50 @@ fn deriv_taker(taker_buy_volume: f64, taker_sell_volume: f64) -> PyResult<wc::De
     .map_err(map_err)
 }
 
+fn deriv_oi_long_short(
+    open_interest: f64,
+    long_size: f64,
+    short_size: f64,
+) -> PyResult<wc::DerivativesTick> {
+    wc::DerivativesTick::new(
+        0.0,
+        1.0,
+        1.0,
+        1.0,
+        open_interest,
+        long_size,
+        short_size,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+    )
+    .map_err(map_err)
+}
+
+fn deriv_oi_taker(
+    open_interest: f64,
+    taker_buy_volume: f64,
+    taker_sell_volume: f64,
+) -> PyResult<wc::DerivativesTick> {
+    wc::DerivativesTick::new(
+        0.0,
+        1.0,
+        1.0,
+        1.0,
+        open_interest,
+        0.0,
+        0.0,
+        taker_buy_volume,
+        taker_sell_volume,
+        0.0,
+        0.0,
+        0,
+    )
+    .map_err(map_err)
+}
+
 fn deriv_liquidation(
     long_liquidation: f64,
     short_liquidation: f64,
@@ -20140,6 +20527,302 @@ impl PyCalendarSpread {
     }
 }
 
+// Estimated leverage ratio: open interest over aggregate long+short size.
+#[pyclass(
+    name = "EstimatedLeverageRatio",
+    module = "wickra._wickra",
+    skip_from_py_object
+)]
+#[derive(Clone)]
+struct PyEstimatedLeverageRatio {
+    inner: wc::EstimatedLeverageRatio,
+}
+
+#[pymethods]
+impl PyEstimatedLeverageRatio {
+    #[new]
+    fn new() -> Self {
+        Self {
+            inner: wc::EstimatedLeverageRatio::new(),
+        }
+    }
+    fn update(
+        &mut self,
+        open_interest: f64,
+        long_size: f64,
+        short_size: f64,
+    ) -> PyResult<Option<f64>> {
+        Ok(self
+            .inner
+            .update(deriv_oi_long_short(open_interest, long_size, short_size)?))
+    }
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        open_interest: Vec<f64>,
+        long_size: Vec<f64>,
+        short_size: Vec<f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        if open_interest.len() != long_size.len() || long_size.len() != short_size.len() {
+            return Err(PyValueError::new_err(
+                "open_interest, long_size, short_size must be equal length",
+            ));
+        }
+        let mut out = Vec::with_capacity(open_interest.len());
+        for i in 0..open_interest.len() {
+            out.push(
+                self.inner
+                    .update(deriv_oi_long_short(
+                        open_interest[i],
+                        long_size[i],
+                        short_size[i],
+                    )?)
+                    .unwrap_or(f64::NAN),
+            );
+        }
+        Ok(out.into_pyarray(py))
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        "EstimatedLeverageRatio()".to_string()
+    }
+}
+
+// OI-to-volume ratio: open interest over taker buy+sell volume.
+#[pyclass(
+    name = "OiToVolumeRatio",
+    module = "wickra._wickra",
+    skip_from_py_object
+)]
+#[derive(Clone)]
+struct PyOiToVolumeRatio {
+    inner: wc::OiToVolumeRatio,
+}
+
+#[pymethods]
+impl PyOiToVolumeRatio {
+    #[new]
+    fn new() -> Self {
+        Self {
+            inner: wc::OiToVolumeRatio::new(),
+        }
+    }
+    fn update(
+        &mut self,
+        open_interest: f64,
+        taker_buy_volume: f64,
+        taker_sell_volume: f64,
+    ) -> PyResult<Option<f64>> {
+        Ok(self.inner.update(deriv_oi_taker(
+            open_interest,
+            taker_buy_volume,
+            taker_sell_volume,
+        )?))
+    }
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        open_interest: Vec<f64>,
+        taker_buy_volume: Vec<f64>,
+        taker_sell_volume: Vec<f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        if open_interest.len() != taker_buy_volume.len()
+            || taker_buy_volume.len() != taker_sell_volume.len()
+        {
+            return Err(PyValueError::new_err(
+                "open_interest, taker_buy_volume, taker_sell_volume must be equal length",
+            ));
+        }
+        let mut out = Vec::with_capacity(open_interest.len());
+        for i in 0..open_interest.len() {
+            out.push(
+                self.inner
+                    .update(deriv_oi_taker(
+                        open_interest[i],
+                        taker_buy_volume[i],
+                        taker_sell_volume[i],
+                    )?)
+                    .unwrap_or(f64::NAN),
+            );
+        }
+        Ok(out.into_pyarray(py))
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        "OiToVolumeRatio()".to_string()
+    }
+}
+
+// Perpetual premium index: relative premium of mark over index price.
+#[pyclass(
+    name = "PerpetualPremiumIndex",
+    module = "wickra._wickra",
+    skip_from_py_object
+)]
+#[derive(Clone)]
+struct PyPerpetualPremiumIndex {
+    inner: wc::PerpetualPremiumIndex,
+}
+
+#[pymethods]
+impl PyPerpetualPremiumIndex {
+    #[new]
+    fn new() -> Self {
+        Self {
+            inner: wc::PerpetualPremiumIndex::new(),
+        }
+    }
+    fn update(&mut self, mark_price: f64, index_price: f64) -> PyResult<Option<f64>> {
+        Ok(self.inner.update(deriv_basis(mark_price, index_price)?))
+    }
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        mark_price: Vec<f64>,
+        index_price: Vec<f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        if mark_price.len() != index_price.len() {
+            return Err(PyValueError::new_err(
+                "mark_price and index_price must be equal length",
+            ));
+        }
+        let mut out = Vec::with_capacity(mark_price.len());
+        for i in 0..mark_price.len() {
+            out.push(
+                self.inner
+                    .update(deriv_basis(mark_price[i], index_price[i])?)
+                    .unwrap_or(f64::NAN),
+            );
+        }
+        Ok(out.into_pyarray(py))
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        "PerpetualPremiumIndex()".to_string()
+    }
+}
+
+// Funding-implied APR: per-interval funding annualised.
+#[pyclass(
+    name = "FundingImpliedApr",
+    module = "wickra._wickra",
+    skip_from_py_object
+)]
+#[derive(Clone)]
+struct PyFundingImpliedApr {
+    inner: wc::FundingImpliedApr,
+}
+
+#[pymethods]
+impl PyFundingImpliedApr {
+    #[new]
+    fn new(intervals_per_year: f64) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::FundingImpliedApr::new(intervals_per_year).map_err(map_err)?,
+        })
+    }
+    fn update(&mut self, funding_rate: f64) -> PyResult<Option<f64>> {
+        Ok(self.inner.update(deriv_funding(funding_rate)?))
+    }
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        funding_rate: Vec<f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        let mut out = Vec::with_capacity(funding_rate.len());
+        for r in funding_rate {
+            out.push(self.inner.update(deriv_funding(r)?).unwrap_or(f64::NAN));
+        }
+        Ok(out.into_pyarray(py))
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        format!(
+            "FundingImpliedApr(intervals_per_year={})",
+            self.inner.intervals_per_year()
+        )
+    }
+}
+
+// Open-interest momentum: rate-of-change of open interest over a window.
+#[pyclass(
+    name = "OpenInterestMomentum",
+    module = "wickra._wickra",
+    skip_from_py_object
+)]
+#[derive(Clone)]
+struct PyOpenInterestMomentum {
+    inner: wc::OpenInterestMomentum,
+}
+
+#[pymethods]
+impl PyOpenInterestMomentum {
+    #[new]
+    fn new(period: usize) -> PyResult<Self> {
+        Ok(Self {
+            inner: wc::OpenInterestMomentum::new(period).map_err(map_err)?,
+        })
+    }
+    fn update(&mut self, open_interest: f64) -> PyResult<Option<f64>> {
+        Ok(self.inner.update(deriv_oi(open_interest)?))
+    }
+    fn batch<'py>(
+        &mut self,
+        py: Python<'py>,
+        open_interest: Vec<f64>,
+    ) -> PyResult<Bound<'py, PyArray1<f64>>> {
+        let mut out = Vec::with_capacity(open_interest.len());
+        for oi in open_interest {
+            out.push(self.inner.update(deriv_oi(oi)?).unwrap_or(f64::NAN));
+        }
+        Ok(out.into_pyarray(py))
+    }
+    fn reset(&mut self) {
+        self.inner.reset();
+    }
+    fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+    fn __repr__(&self) -> String {
+        format!("OpenInterestMomentum(period={})", self.inner.period())
+    }
+}
+
 // ============================== Market Breadth ==============================
 //
 // Market-breadth indicators consume a `CrossSection`: one tick carrying the
@@ -24932,6 +25615,11 @@ fn _wickra(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyPointAndFigureBars>()?;
     m.add_class::<PyInitialBalance>()?;
     m.add_class::<PyOpeningRange>()?;
+    m.add_class::<PyNakedPoc>()?;
+    m.add_class::<PySinglePrints>()?;
+    m.add_class::<PyProfileShape>()?;
+    m.add_class::<PyHighLowVolumeNodes>()?;
+    m.add_class::<PyCompositeProfile>()?;
     // Candlestick patterns.
     m.add_class::<PyDoji>()?;
     m.add_class::<PyHammer>()?;
@@ -25029,6 +25717,11 @@ fn _wickra(_py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyLiquidationFeatures>()?;
     m.add_class::<PyTermStructureBasis>()?;
     m.add_class::<PyCalendarSpread>()?;
+    m.add_class::<PyEstimatedLeverageRatio>()?;
+    m.add_class::<PyOiToVolumeRatio>()?;
+    m.add_class::<PyPerpetualPremiumIndex>()?;
+    m.add_class::<PyFundingImpliedApr>()?;
+    m.add_class::<PyOpenInterestMomentum>()?;
     m.add_class::<PyAdvanceDecline>()?;
     m.add_class::<PyAdvanceDeclineRatio>()?;
     m.add_class::<PyAdVolumeLine>()?;

bindings/python/tests/test_new_indicators.py

@@ -383,6 +383,18 @@ def test_relative_strength_streaming_matches_batch():
 # 6-tuple candle; the batch helper takes only the columns it needs.
 
 CANDLE_SCALAR = {
+    "ProfileShape": (
+        lambda: ta.ProfileShape(20, 24),
+        lambda ind, h, l, c, v: ind.batch(h, l, v),
+    ),
+    "SinglePrints": (
+        lambda: ta.SinglePrints(20, 24),
+        lambda ind, h, l, c, v: ind.batch(h, l),
+    ),
+    "NakedPoc": (
+        lambda: ta.NakedPoc(20, 24),
+        lambda ind, h, l, c, v: ind.batch(h, l, c, v),
+    ),
     "FryPanBottom": (
         lambda: ta.FryPanBottom(9),
         lambda ind, h, l, c, v: ind.batch(h, l, c),
@@ -1009,6 +1021,16 @@ def test_candle_scalar_streaming_matches_batch(name, ohlcv):
 # --- Candle-input, multi-output indicators --------------------------------
 
 MULTI = {
+    "CompositeProfile": (
+        lambda: ta.CompositeProfile(20, 24, 0.7),
+        lambda ind, h, l, c, v: ind.batch(h, l, v),
+        3,
+    ),
+    "HighLowVolumeNodes": (
+        lambda: ta.HighLowVolumeNodes(20, 24),
+        lambda ind, h, l, c, v: ind.batch(h, l, v),
+        2,
+    ),
     "CandleVolume": (
         lambda: ta.CandleVolume(20),
         lambda ind, h, l, c, v: ind.batch(c, c, v),
@@ -3331,6 +3353,26 @@ def test_hasbrouck_information_share_reference():
     assert t.update(7.0, 9.0) is None
     assert t.update(7.0, 9.0) == pytest.approx(0.5)
 
+
+def test_naked_poc_reference():
+    t = ta.NakedPoc(20, 24)
+
+
+def test_single_prints_reference():
+    t = ta.SinglePrints(20, 24)
+
+
+def test_profile_shape_reference():
+    t = ta.ProfileShape(20, 24)
+
+
+def test_high_low_volume_nodes_reference():
+    t = ta.HighLowVolumeNodes(20, 24)
+
+
+def test_composite_profile_reference():
+    t = ta.CompositeProfile(20, 24, 0.7)
+
 # --- Lifecycle ------------------------------------------------------------
 
 
@@ -4082,6 +4124,71 @@ def test_basis_indicators_streaming_equals_batch():
     assert _eq_nan(batch, streamed)
 
 
+def test_b16_derivatives_reference():
+    # Estimated leverage: oi / (long + short) = 200 / 100 = 2.
+    assert ta.EstimatedLeverageRatio().update(200.0, 60.0, 40.0) == pytest.approx(2.0)
+    # OI-to-volume: oi / (buy + sell) = 100 / 50 = 2.
+    assert ta.OiToVolumeRatio().update(100.0, 30.0, 20.0) == pytest.approx(2.0)
+    # Perpetual premium: (mark - index) / index = 0.5 / 100 = 0.005.
+    assert ta.PerpetualPremiumIndex().update(100.5, 100.0) == pytest.approx(0.005)
+    # Funding-implied APR: rate * intervals = 0.0001 * 1095 = 0.1095.
+    assert ta.FundingImpliedApr(1095.0).update(0.0001) == pytest.approx(0.1095)
+    # Open-interest momentum (period 2): warmup then ROC% = 100*(120-100)/100 = 20.
+    oim = ta.OpenInterestMomentum(2)
+    assert oim.update(100.0) is None
+    assert oim.update(110.0) is None
+    assert oim.update(120.0) == pytest.approx(20.0)
+
+
+def test_b16_derivatives_streaming_equals_batch():
+    n = 40
+    oi = np.array([1000.0 + 50.0 * math.sin(i * 0.3) for i in range(n)], dtype=np.float64)
+    long_sz = np.array([600.0 + 20.0 * math.cos(i * 0.2) for i in range(n)], dtype=np.float64)
+    short_sz = np.array([400.0 + 15.0 * math.sin(i * 0.4) for i in range(n)], dtype=np.float64)
+    buy = np.array([300.0 + 10.0 * math.sin(i * 0.5) for i in range(n)], dtype=np.float64)
+    sell = np.array([250.0 + 12.0 * math.cos(i * 0.35) for i in range(n)], dtype=np.float64)
+    index = np.array([100.0 + math.sin(i * 0.2) for i in range(n)], dtype=np.float64)
+    mark = np.array([index[i] + 0.05 * math.cos(i * 0.3) for i in range(n)], dtype=np.float64)
+    rate = np.array([0.0001 * math.sin(i * 0.3) for i in range(n)], dtype=np.float64)
+
+    # EstimatedLeverageRatio; update(open_interest, long_size, short_size).
+    batch = ta.EstimatedLeverageRatio().batch(oi, long_sz, short_sz)
+    streamer = ta.EstimatedLeverageRatio()
+    streamed = np.array(
+        [streamer.update(oi[i], long_sz[i], short_sz[i]) for i in range(n)], dtype=np.float64
+    )
+    assert batch.shape == (n,)
+    assert _eq_nan(batch, streamed)
+
+    # OiToVolumeRatio; update(open_interest, taker_buy_volume, taker_sell_volume).
+    batch = ta.OiToVolumeRatio().batch(oi, buy, sell)
+    streamer = ta.OiToVolumeRatio()
+    streamed = np.array(
+        [streamer.update(oi[i], buy[i], sell[i]) for i in range(n)], dtype=np.float64
+    )
+    assert _eq_nan(batch, streamed)
+
+    # PerpetualPremiumIndex; update(mark_price, index_price).
+    batch = ta.PerpetualPremiumIndex().batch(mark, index)
+    streamer = ta.PerpetualPremiumIndex()
+    streamed = np.array(
+        [streamer.update(mark[i], index[i]) for i in range(n)], dtype=np.float64
+    )
+    assert _eq_nan(batch, streamed)
+
+    # FundingImpliedApr; update(funding_rate).
+    batch = ta.FundingImpliedApr(1095.0).batch(rate)
+    streamer = ta.FundingImpliedApr(1095.0)
+    streamed = np.array([streamer.update(rate[i]) for i in range(n)], dtype=np.float64)
+    assert _eq_nan(batch, streamed)
+
+    # OpenInterestMomentum; update(open_interest).
+    batch = ta.OpenInterestMomentum(10).batch(oi)
+    streamer = ta.OpenInterestMomentum(10)
+    streamed = np.array([streamer.update(oi[i]) for i in range(n)], dtype=np.float64)
+    assert _eq_nan(batch, streamed)
+
+
 # --- Alt-Chart Bars ------------------------------------------------------
 
 

bindings/wasm/src/lib.rs

@@ -8526,6 +8526,298 @@ impl WasmValueArea {
     }
 }
 
+// Naked POC: most recent untouched point-of-control level (Candle -> f64).
+#[wasm_bindgen(js_name = NakedPoc)]
+pub struct WasmNakedPoc {
+    inner: wc::NakedPoc,
+}
+
+#[wasm_bindgen(js_class = NakedPoc)]
+impl WasmNakedPoc {
+    #[wasm_bindgen(constructor)]
+    pub fn new(session_len: usize, bin_count: usize) -> Result<WasmNakedPoc, JsError> {
+        Ok(Self {
+            inner: wc::NakedPoc::new(session_len, bin_count).map_err(map_err)?,
+        })
+    }
+    pub fn update(
+        &mut self,
+        high: f64,
+        low: f64,
+        close: f64,
+        volume: f64,
+    ) -> Result<Option<f64>, JsError> {
+        Ok(self.inner.update(make_candle(high, low, close, volume)?))
+    }
+    pub fn batch(
+        &mut self,
+        high: &[f64],
+        low: &[f64],
+        close: &[f64],
+        volume: &[f64],
+    ) -> Result<Float64Array, JsError> {
+        if high.len() != low.len() || low.len() != close.len() || close.len() != volume.len() {
+            return Err(JsError::new(
+                "high, low, close, volume must be equal length",
+            ));
+        }
+        let mut out = Vec::with_capacity(close.len());
+        for i in 0..close.len() {
+            out.push(
+                self.inner
+                    .update(make_candle(high[i], low[i], close[i], volume[i])?)
+                    .unwrap_or(f64::NAN),
+            );
+        }
+        Ok(Float64Array::from(out.as_slice()))
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
+// Single Prints: count of single-print price levels (Candle -> f64).
+#[wasm_bindgen(js_name = SinglePrints)]
+pub struct WasmSinglePrints {
+    inner: wc::SinglePrints,
+}
+
+#[wasm_bindgen(js_class = SinglePrints)]
+impl WasmSinglePrints {
+    #[wasm_bindgen(constructor)]
+    pub fn new(period: usize, bin_count: usize) -> Result<WasmSinglePrints, JsError> {
+        Ok(Self {
+            inner: wc::SinglePrints::new(period, bin_count).map_err(map_err)?,
+        })
+    }
+    pub fn update(&mut self, high: f64, low: f64) -> Result<Option<f64>, JsError> {
+        let mid = f64::midpoint(high, low);
+        Ok(self
+            .inner
+            .update(wc::Candle::new(mid, high, low, mid, 0.0, 0).map_err(map_err)?))
+    }
+    pub fn batch(&mut self, high: &[f64], low: &[f64]) -> Result<Float64Array, JsError> {
+        if high.len() != low.len() {
+            return Err(JsError::new("high and low must be equal length"));
+        }
+        let mut out = Vec::with_capacity(high.len());
+        for i in 0..high.len() {
+            let mid = f64::midpoint(high[i], low[i]);
+            out.push(
+                self.inner
+                    .update(wc::Candle::new(mid, high[i], low[i], mid, 0.0, 0).map_err(map_err)?)
+                    .unwrap_or(f64::NAN),
+            );
+        }
+        Ok(Float64Array::from(out.as_slice()))
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
+// Profile Shape: b/P/D classification as a numeric code (Candle -> f64).
+#[wasm_bindgen(js_name = ProfileShape)]
+pub struct WasmProfileShape {
+    inner: wc::ProfileShape,
+}
+
+#[wasm_bindgen(js_class = ProfileShape)]
+impl WasmProfileShape {
+    #[wasm_bindgen(constructor)]
+    pub fn new(period: usize, bin_count: usize) -> Result<WasmProfileShape, JsError> {
+        Ok(Self {
+            inner: wc::ProfileShape::new(period, bin_count).map_err(map_err)?,
+        })
+    }
+    pub fn update(&mut self, high: f64, low: f64, volume: f64) -> Result<Option<f64>, JsError> {
+        let mid = f64::midpoint(high, low);
+        Ok(self
+            .inner
+            .update(wc::Candle::new(mid, high, low, mid, volume, 0).map_err(map_err)?))
+    }
+    pub fn batch(
+        &mut self,
+        high: &[f64],
+        low: &[f64],
+        volume: &[f64],
+    ) -> Result<Float64Array, JsError> {
+        if high.len() != low.len() || low.len() != volume.len() {
+            return Err(JsError::new("high, low, volume must be equal length"));
+        }
+        let mut out = Vec::with_capacity(high.len());
+        for i in 0..high.len() {
+            let mid = f64::midpoint(high[i], low[i]);
+            out.push(
+                self.inner
+                    .update(
+                        wc::Candle::new(mid, high[i], low[i], mid, volume[i], 0)
+                            .map_err(map_err)?,
+                    )
+                    .unwrap_or(f64::NAN),
+            );
+        }
+        Ok(Float64Array::from(out.as_slice()))
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
+// High/Low Volume Nodes: highest- and lowest-volume price nodes (Candle -> struct).
+#[wasm_bindgen(js_name = HighLowVolumeNodes)]
+pub struct WasmHighLowVolumeNodes {
+    inner: wc::HighLowVolumeNodes,
+}
+
+#[wasm_bindgen(js_class = HighLowVolumeNodes)]
+impl WasmHighLowVolumeNodes {
+    #[wasm_bindgen(constructor)]
+    pub fn new(period: usize, bin_count: usize) -> Result<WasmHighLowVolumeNodes, JsError> {
+        Ok(Self {
+            inner: wc::HighLowVolumeNodes::new(period, bin_count).map_err(map_err)?,
+        })
+    }
+    pub fn batch(
+        &mut self,
+        high: &[f64],
+        low: &[f64],
+        volume: &[f64],
+    ) -> Result<Float64Array, JsError> {
+        if high.len() != low.len() || low.len() != volume.len() {
+            return Err(JsError::new("high, low, volume must be equal length"));
+        }
+        let n = high.len();
+        let mut out = vec![f64::NAN; n * 2];
+        for i in 0..n {
+            let mid = f64::midpoint(high[i], low[i]);
+            let c = wc::Candle::new(mid, high[i], low[i], mid, volume[i], 0).map_err(map_err)?;
+            if let Some(o) = self.inner.update(c) {
+                out[i * 2] = o.hvn;
+                out[i * 2 + 1] = o.lvn;
+            }
+        }
+        Ok(Float64Array::from(out.as_slice()))
+    }
+    /// Streaming update. Returns `{ hvn, lvn }` once warm, else `null`.
+    pub fn update(&mut self, high: f64, low: f64, volume: f64) -> Result<JsValue, JsError> {
+        let mid = f64::midpoint(high, low);
+        let c = wc::Candle::new(mid, high, low, mid, volume, 0).map_err(map_err)?;
+        Ok(match self.inner.update(c) {
+            Some(o) => {
+                let obj = Object::new();
+                Reflect::set(&obj, &"hvn".into(), &o.hvn.into()).ok();
+                Reflect::set(&obj, &"lvn".into(), &o.lvn.into()).ok();
+                obj.into()
+            }
+            None => JsValue::NULL,
+        })
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
+// Composite Profile: multi-session composite volume profile (Candle -> struct).
+#[wasm_bindgen(js_name = CompositeProfile)]
+pub struct WasmCompositeProfile {
+    inner: wc::CompositeProfile,
+}
+
+#[wasm_bindgen(js_class = CompositeProfile)]
+impl WasmCompositeProfile {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        period: usize,
+        bin_count: usize,
+        value_area_pct: f64,
+    ) -> Result<WasmCompositeProfile, JsError> {
+        Ok(Self {
+            inner: wc::CompositeProfile::new(period, bin_count, value_area_pct).map_err(map_err)?,
+        })
+    }
+    pub fn batch(
+        &mut self,
+        high: &[f64],
+        low: &[f64],
+        volume: &[f64],
+    ) -> Result<Float64Array, JsError> {
+        if high.len() != low.len() || low.len() != volume.len() {
+            return Err(JsError::new("high, low, volume must be equal length"));
+        }
+        let n = high.len();
+        let mut out = vec![f64::NAN; n * 3];
+        for i in 0..n {
+            let mid = f64::midpoint(high[i], low[i]);
+            let c = wc::Candle::new(mid, high[i], low[i], mid, volume[i], 0).map_err(map_err)?;
+            if let Some(o) = self.inner.update(c) {
+                out[i * 3] = o.poc;
+                out[i * 3 + 1] = o.vah;
+                out[i * 3 + 2] = o.val;
+            }
+        }
+        Ok(Float64Array::from(out.as_slice()))
+    }
+    /// Streaming update. Returns `{ poc, vah, val }` once warm, else `null`.
+    pub fn update(&mut self, high: f64, low: f64, volume: f64) -> Result<JsValue, JsError> {
+        let mid = f64::midpoint(high, low);
+        let c = wc::Candle::new(mid, high, low, mid, volume, 0).map_err(map_err)?;
+        Ok(match self.inner.update(c) {
+            Some(o) => {
+                let obj = Object::new();
+                Reflect::set(&obj, &"poc".into(), &o.poc.into()).ok();
+                Reflect::set(&obj, &"vah".into(), &o.vah.into()).ok();
+                Reflect::set(&obj, &"val".into(), &o.val.into()).ok();
+                obj.into()
+            }
+            None => JsValue::NULL,
+        })
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
 #[wasm_bindgen(js_name = VolumeProfile)]
 pub struct WasmVolumeProfile {
     inner: wc::VolumeProfile,
@@ -9933,6 +10225,50 @@ fn deriv_taker(
     .map_err(map_err)
 }
 
+fn deriv_oi_long_short(
+    open_interest: f64,
+    long_size: f64,
+    short_size: f64,
+) -> Result<wc::DerivativesTick, JsError> {
+    wc::DerivativesTick::new(
+        0.0,
+        1.0,
+        1.0,
+        1.0,
+        open_interest,
+        long_size,
+        short_size,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0,
+    )
+    .map_err(map_err)
+}
+
+fn deriv_oi_taker(
+    open_interest: f64,
+    taker_buy_volume: f64,
+    taker_sell_volume: f64,
+) -> Result<wc::DerivativesTick, JsError> {
+    wc::DerivativesTick::new(
+        0.0,
+        1.0,
+        1.0,
+        1.0,
+        open_interest,
+        0.0,
+        0.0,
+        taker_buy_volume,
+        taker_sell_volume,
+        0.0,
+        0.0,
+        0,
+    )
+    .map_err(map_err)
+}
+
 fn deriv_liquidation(
     long_liquidation: f64,
     short_liquidation: f64,
@@ -10256,6 +10592,195 @@ impl WasmCalendarSpread {
     }
 }
 
+// ---------- Estimated Leverage Ratio ----------
+
+#[wasm_bindgen(js_name = EstimatedLeverageRatio)]
+pub struct WasmEstimatedLeverageRatio {
+    inner: wc::EstimatedLeverageRatio,
+}
+
+impl Default for WasmEstimatedLeverageRatio {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[wasm_bindgen(js_class = EstimatedLeverageRatio)]
+impl WasmEstimatedLeverageRatio {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> WasmEstimatedLeverageRatio {
+        Self {
+            inner: wc::EstimatedLeverageRatio::new(),
+        }
+    }
+    pub fn update(
+        &mut self,
+        open_interest: f64,
+        long_size: f64,
+        short_size: f64,
+    ) -> Result<Option<f64>, JsError> {
+        Ok(self
+            .inner
+            .update(deriv_oi_long_short(open_interest, long_size, short_size)?))
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
+// ---------- OI-to-Volume Ratio ----------
+
+#[wasm_bindgen(js_name = OiToVolumeRatio)]
+pub struct WasmOiToVolumeRatio {
+    inner: wc::OiToVolumeRatio,
+}
+
+impl Default for WasmOiToVolumeRatio {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[wasm_bindgen(js_class = OiToVolumeRatio)]
+impl WasmOiToVolumeRatio {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> WasmOiToVolumeRatio {
+        Self {
+            inner: wc::OiToVolumeRatio::new(),
+        }
+    }
+    pub fn update(
+        &mut self,
+        open_interest: f64,
+        taker_buy_volume: f64,
+        taker_sell_volume: f64,
+    ) -> Result<Option<f64>, JsError> {
+        Ok(self.inner.update(deriv_oi_taker(
+            open_interest,
+            taker_buy_volume,
+            taker_sell_volume,
+        )?))
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
+// ---------- Perpetual Premium Index ----------
+
+#[wasm_bindgen(js_name = PerpetualPremiumIndex)]
+pub struct WasmPerpetualPremiumIndex {
+    inner: wc::PerpetualPremiumIndex,
+}
+
+impl Default for WasmPerpetualPremiumIndex {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[wasm_bindgen(js_class = PerpetualPremiumIndex)]
+impl WasmPerpetualPremiumIndex {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> WasmPerpetualPremiumIndex {
+        Self {
+            inner: wc::PerpetualPremiumIndex::new(),
+        }
+    }
+    pub fn update(&mut self, mark_price: f64, index_price: f64) -> Result<Option<f64>, JsError> {
+        Ok(self.inner.update(deriv_basis(mark_price, index_price)?))
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
+// ---------- Funding-Implied APR ----------
+
+#[wasm_bindgen(js_name = FundingImpliedApr)]
+pub struct WasmFundingImpliedApr {
+    inner: wc::FundingImpliedApr,
+}
+
+#[wasm_bindgen(js_class = FundingImpliedApr)]
+impl WasmFundingImpliedApr {
+    #[wasm_bindgen(constructor)]
+    pub fn new(intervals_per_year: f64) -> Result<WasmFundingImpliedApr, JsError> {
+        Ok(Self {
+            inner: wc::FundingImpliedApr::new(intervals_per_year).map_err(map_err)?,
+        })
+    }
+    pub fn update(&mut self, funding_rate: f64) -> Result<Option<f64>, JsError> {
+        Ok(self.inner.update(deriv_funding(funding_rate)?))
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
+// ---------- Open-Interest Momentum ----------
+
+#[wasm_bindgen(js_name = OpenInterestMomentum)]
+pub struct WasmOpenInterestMomentum {
+    inner: wc::OpenInterestMomentum,
+}
+
+#[wasm_bindgen(js_class = OpenInterestMomentum)]
+impl WasmOpenInterestMomentum {
+    #[wasm_bindgen(constructor)]
+    pub fn new(period: usize) -> Result<WasmOpenInterestMomentum, JsError> {
+        Ok(Self {
+            inner: wc::OpenInterestMomentum::new(period).map_err(map_err)?,
+        })
+    }
+    pub fn update(&mut self, open_interest: f64) -> Result<Option<f64>, JsError> {
+        Ok(self.inner.update(deriv_oi(open_interest)?))
+    }
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+    #[wasm_bindgen(js_name = isReady)]
+    pub fn is_ready(&self) -> bool {
+        self.inner.is_ready()
+    }
+    #[wasm_bindgen(js_name = warmupPeriod)]
+    pub fn warmup_period(&self) -> usize {
+        self.inner.warmup_period()
+    }
+}
+
 // ---------- Heikin-Ashi Oscillator ----------
 
 #[wasm_bindgen(js_name = HeikinAshiOscillator)]

crates/wickra-core/src/indicators/composite_profile.rs

@@ -0,0 +1,347 @@
+//! Composite Profile — POC and value area over a long composite window.
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Output of [`CompositeProfile`]: the point of control and the value-area bounds.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct CompositeProfileOutput {
+    /// Point of Control — the price (bin centre) with the most volume.
+    pub poc: f64,
+    /// Value-Area High — top of the band holding `value_area_pct` of volume.
+    pub vah: f64,
+    /// Value-Area Low — bottom of that band.
+    pub val: f64,
+}
+
+/// Composite Profile — a multi-session volume profile reduced to its **point of
+/// control** and **value area**, built over a long composite window.
+///
+/// ```text
+/// build a `bins`-bucket volume profile over the last `period` candles
+/// POC = bin with the most volume
+/// expand from the POC, always adding the heavier adjacent bin, until the
+///   accumulated volume reaches `value_area_pct` of the total
+/// VAH / VAL = the highest / lowest price included
+/// ```
+///
+/// A composite profile merges many sessions into one structure to reveal the
+/// dominant value area and control price across a longer horizon — the levels that
+/// matter for swing positioning rather than a single day. The point of control is
+/// the fairest price (heaviest trade); the value area (classically 70% of volume)
+/// brackets where the market spent most of its time. Price inside the value area is
+/// "in balance"; acceptance outside it signals a value migration.
+///
+/// The first value lands after `period` candles; each `update` rebuilds the
+/// profile in O(`period · bins`).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, CompositeProfile};
+///
+/// let mut indicator = CompositeProfile::new(100, 50, 0.70).unwrap();
+/// let mut last = None;
+/// for i in 0..150 {
+///     let base = 100.0 + (f64::from(i) * 0.1).sin() * 8.0;
+///     let c = Candle::new(base, base + 1.0, base - 1.0, base, 1_000.0, 0).unwrap();
+///     last = indicator.update(c);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct CompositeProfile {
+    period: usize,
+    bins: usize,
+    value_area_pct: f64,
+    window: VecDeque<Candle>,
+    last: Option<CompositeProfileOutput>,
+}
+
+impl CompositeProfile {
+    /// Construct a Composite Profile.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::PeriodZero`] if `period` or `bins` is zero, or
+    /// [`Error::InvalidParameter`] if `value_area_pct` is not in `(0, 1]`.
+    pub fn new(period: usize, bins: usize, value_area_pct: f64) -> Result<Self> {
+        if period == 0 || bins == 0 {
+            return Err(Error::PeriodZero);
+        }
+        if !value_area_pct.is_finite() || value_area_pct <= 0.0 || value_area_pct > 1.0 {
+            return Err(Error::InvalidParameter {
+                message: "value_area_pct must be in (0, 1]",
+            });
+        }
+        Ok(Self {
+            period,
+            bins,
+            value_area_pct,
+            window: VecDeque::with_capacity(period),
+            last: None,
+        })
+    }
+
+    /// Configured `(period, bins, value_area_pct)`.
+    pub const fn params(&self) -> (usize, usize, f64) {
+        (self.period, self.bins, self.value_area_pct)
+    }
+
+    /// Current value if available.
+    pub const fn value(&self) -> Option<CompositeProfileOutput> {
+        self.last
+    }
+
+    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+    fn compute(&self) -> CompositeProfileOutput {
+        let mut low = f64::INFINITY;
+        let mut high = f64::NEG_INFINITY;
+        for c in &self.window {
+            low = low.min(c.low);
+            high = high.max(c.high);
+        }
+        let span = high - low;
+        if span <= 0.0 {
+            return CompositeProfileOutput {
+                poc: low,
+                vah: low,
+                val: low,
+            };
+        }
+        let width = span / self.bins as f64;
+        let centre = |idx: usize| low + (idx as f64 + 0.5) * width;
+        let mut hist = vec![0.0; self.bins];
+        for c in &self.window {
+            if c.volume == 0.0 {
+                continue;
+            }
+            let lo_idx = (((c.low - low) / width).floor() as usize).min(self.bins - 1);
+            let hi_idx = (((c.high - low) / width).floor() as usize).min(self.bins - 1);
+            let share = c.volume / (hi_idx - lo_idx + 1) as f64;
+            for bin in hist.iter_mut().take(hi_idx + 1).skip(lo_idx) {
+                *bin += share;
+            }
+        }
+        let total: f64 = hist.iter().sum();
+        let mut poc = 0;
+        let mut poc_vol = f64::NEG_INFINITY;
+        for (idx, &vol) in hist.iter().enumerate() {
+            if vol > poc_vol {
+                poc_vol = vol;
+                poc = idx;
+            }
+        }
+        let target = total * self.value_area_pct;
+        let mut acc = hist[poc];
+        let mut top = poc;
+        let mut bottom = poc;
+        while acc < target && (top < self.bins - 1 || bottom > 0) {
+            let above = if top < self.bins - 1 {
+                hist[top + 1]
+            } else {
+                f64::NEG_INFINITY
+            };
+            let below = if bottom > 0 {
+                hist[bottom - 1]
+            } else {
+                f64::NEG_INFINITY
+            };
+            if above >= below {
+                top += 1;
+                acc += hist[top];
+            } else {
+                bottom -= 1;
+                acc += hist[bottom];
+            }
+        }
+        CompositeProfileOutput {
+            poc: centre(poc),
+            vah: centre(top),
+            val: centre(bottom),
+        }
+    }
+}
+
+impl Indicator for CompositeProfile {
+    type Input = Candle;
+    type Output = CompositeProfileOutput;
+
+    fn update(&mut self, candle: Candle) -> Option<CompositeProfileOutput> {
+        if self.window.len() == self.period {
+            self.window.pop_front();
+        }
+        self.window.push_back(candle);
+        if self.window.len() < self.period {
+            return None;
+        }
+        let out = self.compute();
+        self.last = Some(out);
+        Some(out)
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+        self.last = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.last.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "CompositeProfile"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(high: f64, low: f64, volume: f64) -> Candle {
+        Candle::new_unchecked(
+            f64::midpoint(high, low),
+            high,
+            low,
+            f64::midpoint(high, low),
+            volume,
+            0,
+        )
+    }
+
+    #[test]
+    fn rejects_invalid_params() {
+        assert!(matches!(
+            CompositeProfile::new(0, 50, 0.7),
+            Err(Error::PeriodZero)
+        ));
+        assert!(matches!(
+            CompositeProfile::new(100, 0, 0.7),
+            Err(Error::PeriodZero)
+        ));
+        assert!(matches!(
+            CompositeProfile::new(100, 50, 0.0),
+            Err(Error::InvalidParameter { .. })
+        ));
+        assert!(matches!(
+            CompositeProfile::new(100, 50, 1.5),
+            Err(Error::InvalidParameter { .. })
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let p = CompositeProfile::new(100, 50, 0.7).unwrap();
+        assert_eq!(p.params(), (100, 50, 0.7));
+        assert_eq!(p.warmup_period(), 100);
+        assert_eq!(p.name(), "CompositeProfile");
+        assert!(!p.is_ready());
+        assert_eq!(p.value(), None);
+    }
+
+    #[test]
+    fn first_emission_at_warmup_period() {
+        let mut p = CompositeProfile::new(4, 8, 0.7).unwrap();
+        let candles: Vec<Candle> = (0..6).map(|_| c(110.0, 90.0, 1_000.0)).collect();
+        let out = p.batch(&candles);
+        for v in out.iter().take(3) {
+            assert!(v.is_none());
+        }
+        assert!(out[3].is_some());
+    }
+
+    #[test]
+    fn value_area_brackets_poc() {
+        let mut p = CompositeProfile::new(20, 30, 0.7).unwrap();
+        let candles: Vec<Candle> = (0..40)
+            .map(|i| {
+                c(
+                    110.0 + (f64::from(i) * 0.3).sin() * 8.0,
+                    90.0 + (f64::from(i) * 0.3).cos() * 8.0,
+                    1_000.0,
+                )
+            })
+            .collect();
+        for o in p.batch(&candles).into_iter().flatten() {
+            assert!(o.val <= o.poc && o.poc <= o.vah);
+        }
+    }
+
+    #[test]
+    fn poc_at_heavy_cluster() {
+        // Volume clustered at ~100; thin pokes elsewhere -> POC near 100.
+        let mut p = CompositeProfile::new(6, 30, 0.7).unwrap();
+        let mut candles: Vec<Candle> = (0..5).map(|_| c(101.0, 99.0, 5_000.0)).collect();
+        candles.push(c(140.0, 60.0, 50.0));
+        let out = p.batch(&candles).into_iter().flatten().last().unwrap();
+        assert!(
+            (out.poc - 100.0).abs() < 5.0,
+            "POC should sit at the cluster, got {}",
+            out.poc
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut p = CompositeProfile::new(4, 8, 0.7).unwrap();
+        p.batch(&[c(110.0, 90.0, 1_000.0); 6]);
+        assert!(p.is_ready());
+        p.reset();
+        assert!(!p.is_ready());
+        assert_eq!(p.value(), None);
+        assert_eq!(p.update(c(110.0, 90.0, 1_000.0)), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..120)
+            .map(|i| {
+                c(
+                    110.0 + (f64::from(i) * 0.25).sin() * 9.0,
+                    90.0,
+                    1_000.0 + f64::from(i),
+                )
+            })
+            .collect();
+        let batch = CompositeProfile::new(50, 50, 0.7).unwrap().batch(&candles);
+        let mut b = CompositeProfile::new(50, 50, 0.7).unwrap();
+        let streamed: Vec<_> = candles.iter().map(|x| b.update(*x)).collect();
+        assert_eq!(batch, streamed);
+    }
+
+    #[test]
+    fn flat_window_collapses_to_price() {
+        // Zero high-low span returns the price for POC, VAH and VAL.
+        let mut cp = CompositeProfile::new(2, 4, 0.7).unwrap();
+        cp.update(c(50.0, 50.0, 10.0));
+        let out = cp.update(c(50.0, 50.0, 10.0)).unwrap();
+        assert_eq!(out.poc, out.vah);
+        assert_eq!(out.poc, out.val);
+    }
+
+    #[test]
+    fn zero_volume_window_is_handled() {
+        // Non-flat window of zero-volume candles hits the skip path.
+        let mut cp = CompositeProfile::new(2, 4, 0.7).unwrap();
+        cp.update(c(60.0, 40.0, 0.0));
+        assert!(cp.update(c(60.0, 40.0, 0.0)).is_some());
+    }
+
+    #[test]
+    fn value_area_expands_down_from_top_poc() {
+        // POC sits in the top bin; with a wide value-area target the area runs
+        // out of bins above (the ceiling branch) and keeps expanding downward.
+        let mut cp = CompositeProfile::new(2, 3, 0.9).unwrap();
+        cp.update(c(100.0, 0.0, 30.0)); // thin spread across all three bins
+        let out = cp.update(c(100.0, 67.0, 60.0)).unwrap(); // heavy in the top bin
+        assert!(out.val <= out.poc && out.poc <= out.vah);
+    }
+}

crates/wickra-core/src/indicators/estimated_leverage_ratio.rs

@@ -0,0 +1,155 @@
+//! Estimated Leverage Ratio — open interest per unit of aggregate position size.
+
+use crate::derivatives::DerivativesTick;
+use crate::traits::Indicator;
+
+/// Estimated Leverage Ratio (ELR) — open interest relative to the aggregate
+/// long+short position size, a proxy for how leveraged outstanding positions are.
+///
+/// ```text
+/// ELR = open_interest / (long_size + short_size)
+/// ```
+///
+/// The classic estimated leverage ratio compares open interest (the notional of
+/// outstanding contracts) to the capital backing it. With the size fields of a
+/// [`DerivativesTick`] standing in for the position base, the ratio rises when a
+/// given pool of positions controls more open interest — i.e. when the market is
+/// running hotter leverage. Spikes in ELR mark crowded, fragile conditions where a
+/// move can cascade into liquidations; a falling ELR marks deleveraging.
+///
+/// The ratio is non-negative; a tick with zero aggregate size reports `0` rather
+/// than dividing by zero. It is stateless — each tick yields one value (no warmup).
+/// Each `update` is O(1).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{DerivativesTick, Indicator, EstimatedLeverageRatio};
+///
+/// let mut indicator = EstimatedLeverageRatio::new();
+/// let tick = DerivativesTick::new(0.0001, 100.0, 100.0, 100.0, 1_000.0, 400.0, 600.0, 0.0, 0.0, 0.0, 0.0, 0).unwrap();
+/// let elr = indicator.update(tick).unwrap();
+/// assert!((elr - 1.0).abs() < 1e-12); // 1000 / (400 + 600)
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct EstimatedLeverageRatio {
+    ready: bool,
+}
+
+impl EstimatedLeverageRatio {
+    /// Construct a new Estimated Leverage Ratio. The indicator is parameter-free.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self { ready: false }
+    }
+}
+
+impl Indicator for EstimatedLeverageRatio {
+    type Input = DerivativesTick;
+    type Output = f64;
+
+    fn update(&mut self, tick: DerivativesTick) -> Option<f64> {
+        let base = tick.long_size + tick.short_size;
+        let elr = if base > 0.0 {
+            tick.open_interest / base
+        } else {
+            0.0
+        };
+        self.ready = true;
+        Some(elr)
+    }
+
+    fn reset(&mut self) {
+        self.ready = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.ready
+    }
+
+    fn name(&self) -> &'static str {
+        "EstimatedLeverageRatio"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn tick(oi: f64, long: f64, short: f64) -> DerivativesTick {
+        DerivativesTick::new_unchecked(
+            0.0, 100.0, 100.0, 100.0, oi, long, short, 0.0, 0.0, 0.0, 0.0, 0,
+        )
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let e = EstimatedLeverageRatio::new();
+        assert_eq!(e.warmup_period(), 1);
+        assert_eq!(e.name(), "EstimatedLeverageRatio");
+        assert!(!e.is_ready());
+    }
+
+    #[test]
+    fn ratio_reference_value() {
+        let mut e = EstimatedLeverageRatio::new();
+        // 1000 / (400 + 600) = 1.0.
+        assert_relative_eq!(
+            e.update(tick(1_000.0, 400.0, 600.0)).unwrap(),
+            1.0,
+            epsilon = 1e-12
+        );
+    }
+
+    #[test]
+    fn higher_oi_raises_ratio() {
+        let mut e = EstimatedLeverageRatio::new();
+        let low = e.update(tick(1_000.0, 500.0, 500.0)).unwrap();
+        let high = e.update(tick(3_000.0, 500.0, 500.0)).unwrap();
+        assert!(high > low);
+    }
+
+    #[test]
+    fn zero_base_is_zero() {
+        let mut e = EstimatedLeverageRatio::new();
+        assert_relative_eq!(
+            e.update(tick(1_000.0, 0.0, 0.0)).unwrap(),
+            0.0,
+            epsilon = 1e-12
+        );
+    }
+
+    #[test]
+    fn ready_after_first_update() {
+        let mut e = EstimatedLeverageRatio::new();
+        assert!(!e.is_ready());
+        e.update(tick(1_000.0, 500.0, 500.0));
+        assert!(e.is_ready());
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut e = EstimatedLeverageRatio::new();
+        e.update(tick(1_000.0, 500.0, 500.0));
+        assert!(e.is_ready());
+        e.reset();
+        assert!(!e.is_ready());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let ticks: Vec<DerivativesTick> = (0..40)
+            .map(|i| tick(1_000.0 + f64::from(i) * 10.0, 500.0, 500.0))
+            .collect();
+        let batch = EstimatedLeverageRatio::new().batch(&ticks);
+        let mut b = EstimatedLeverageRatio::new();
+        let streamed: Vec<_> = ticks.iter().map(|x| b.update(*x)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

crates/wickra-core/src/indicators/funding_implied_apr.rs

@@ -0,0 +1,164 @@
+//! Funding-Implied APR — the per-interval funding rate annualised.
+
+use crate::derivatives::DerivativesTick;
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Funding-Implied APR — the perpetual's per-interval funding rate scaled to an
+/// annualised rate.
+///
+/// ```text
+/// APR = funding_rate · intervals_per_year
+/// ```
+///
+/// Funding is paid in small per-interval amounts (commonly every 8 hours, i.e.
+/// `1095` intervals per year). Annualising it converts the headline funding number
+/// into the carry cost (or yield) of holding the position for a year, which is far
+/// easier to reason about and to compare against spot lending rates, basis trades,
+/// and other yields. A large positive APR means longs pay a steep carry to shorts
+/// (and vice versa) — the economic incentive behind cash-and-carry and
+/// funding-arbitrage strategies.
+///
+/// The output is a fraction (multiply by `100` for percent) and may be negative.
+/// It is stateless — each tick yields one value (no warmup). Each `update` is O(1).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{DerivativesTick, Indicator, FundingImpliedApr};
+///
+/// // 0.01% per 8h funding -> 0.0001 * 1095 ≈ 10.95% APR.
+/// let mut indicator = FundingImpliedApr::new(1095.0).unwrap();
+/// let tick = DerivativesTick::new(0.0001, 100.0, 100.0, 100.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0).unwrap();
+/// let apr = indicator.update(tick).unwrap();
+/// assert!((apr - 0.1095).abs() < 1e-9);
+/// ```
+#[derive(Debug, Clone)]
+pub struct FundingImpliedApr {
+    intervals_per_year: f64,
+    ready: bool,
+}
+
+impl FundingImpliedApr {
+    /// Construct a Funding-Implied APR with the number of funding intervals per
+    /// year (e.g. `1095` for 8-hour funding, `365` for daily).
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::InvalidParameter`] if `intervals_per_year` is not finite
+    /// and positive.
+    pub fn new(intervals_per_year: f64) -> Result<Self> {
+        if !intervals_per_year.is_finite() || intervals_per_year <= 0.0 {
+            return Err(Error::InvalidParameter {
+                message: "intervals_per_year must be finite and positive",
+            });
+        }
+        Ok(Self {
+            intervals_per_year,
+            ready: false,
+        })
+    }
+
+    /// Configured intervals per year.
+    pub const fn intervals_per_year(&self) -> f64 {
+        self.intervals_per_year
+    }
+}
+
+impl Indicator for FundingImpliedApr {
+    type Input = DerivativesTick;
+    type Output = f64;
+
+    fn update(&mut self, tick: DerivativesTick) -> Option<f64> {
+        self.ready = true;
+        Some(tick.funding_rate * self.intervals_per_year)
+    }
+
+    fn reset(&mut self) {
+        self.ready = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.ready
+    }
+
+    fn name(&self) -> &'static str {
+        "FundingImpliedApr"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn tick(funding: f64) -> DerivativesTick {
+        DerivativesTick::new_unchecked(
+            funding, 100.0, 100.0, 100.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0,
+        )
+    }
+
+    #[test]
+    fn rejects_invalid_intervals() {
+        assert!(matches!(
+            FundingImpliedApr::new(0.0),
+            Err(Error::InvalidParameter { .. })
+        ));
+        assert!(matches!(
+            FundingImpliedApr::new(-1.0),
+            Err(Error::InvalidParameter { .. })
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let f = FundingImpliedApr::new(1095.0).unwrap();
+        assert_relative_eq!(f.intervals_per_year(), 1095.0, epsilon = 1e-12);
+        assert_eq!(f.warmup_period(), 1);
+        assert_eq!(f.name(), "FundingImpliedApr");
+        assert!(!f.is_ready());
+    }
+
+    #[test]
+    fn apr_reference_value() {
+        let mut f = FundingImpliedApr::new(1095.0).unwrap();
+        assert_relative_eq!(f.update(tick(0.0001)).unwrap(), 0.1095, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn negative_funding_is_negative_apr() {
+        let mut f = FundingImpliedApr::new(1095.0).unwrap();
+        assert!(f.update(tick(-0.0001)).unwrap() < 0.0);
+    }
+
+    #[test]
+    fn zero_funding_is_zero() {
+        let mut f = FundingImpliedApr::new(365.0).unwrap();
+        assert_relative_eq!(f.update(tick(0.0)).unwrap(), 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut f = FundingImpliedApr::new(1095.0).unwrap();
+        f.update(tick(0.0001));
+        assert!(f.is_ready());
+        f.reset();
+        assert!(!f.is_ready());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let ticks: Vec<DerivativesTick> = (0..40)
+            .map(|i| tick(0.0001 * (f64::from(i) * 0.3).sin()))
+            .collect();
+        let batch = FundingImpliedApr::new(1095.0).unwrap().batch(&ticks);
+        let mut b = FundingImpliedApr::new(1095.0).unwrap();
+        let streamed: Vec<_> = ticks.iter().map(|x| b.update(*x)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

crates/wickra-core/src/indicators/high_low_volume_nodes.rs

@@ -0,0 +1,307 @@
+//! High/Low Volume Nodes (HVN / LVN) — the busiest and quietest price levels.
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Output of [`HighLowVolumeNodes`]: the price of the highest- and lowest-volume
+/// node in the profile.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct HighLowVolumeNodesOutput {
+    /// High Volume Node — the price level (bin centre) with the most volume.
+    pub hvn: f64,
+    /// Low Volume Node — the traded price level with the least volume.
+    pub lvn: f64,
+}
+
+/// High/Low Volume Nodes — the price levels of greatest and least acceptance in a
+/// rolling volume profile.
+///
+/// ```text
+/// build a `bins`-bucket volume profile over the last `period` candles
+/// HVN = bin centre of the bucket with the most volume
+/// LVN = bin centre of the traded bucket with the least volume
+/// ```
+///
+/// A volume profile reveals where the market spent the most effort. A **High Volume
+/// Node** (HVN) is a price the market accepted and traded heavily — it acts as a
+/// magnet and as strong support/resistance. A **Low Volume Node** (LVN) is a price
+/// the market rejected quickly — moves tend to accelerate through LVNs and they
+/// often mark the edges between balance areas. Each candle's volume is spread
+/// across the price bins its high-low range spans (as in
+/// [`VolumeProfile`](crate::VolumeProfile)).
+///
+/// The first value lands after `period` candles; each `update` rebuilds the profile
+/// in O(`period · bins`). A degenerate flat window puts both nodes at the price.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, HighLowVolumeNodes};
+///
+/// let mut indicator = HighLowVolumeNodes::new(20, 24).unwrap();
+/// let mut last = None;
+/// for i in 0..40 {
+///     let base = 100.0 + (f64::from(i) * 0.3).sin() * 5.0;
+///     let c = Candle::new(base, base + 1.0, base - 1.0, base, 1_000.0, 0).unwrap();
+///     last = indicator.update(c);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct HighLowVolumeNodes {
+    period: usize,
+    bins: usize,
+    window: VecDeque<Candle>,
+    last: Option<HighLowVolumeNodesOutput>,
+}
+
+impl HighLowVolumeNodes {
+    /// Construct a High/Low Volume Nodes indicator.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::PeriodZero`] if `period` or `bins` is zero.
+    pub fn new(period: usize, bins: usize) -> Result<Self> {
+        if period == 0 || bins == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            period,
+            bins,
+            window: VecDeque::with_capacity(period),
+            last: None,
+        })
+    }
+
+    /// Configured `(period, bins)`.
+    pub const fn params(&self) -> (usize, usize) {
+        (self.period, self.bins)
+    }
+
+    /// Current value if available.
+    pub const fn value(&self) -> Option<HighLowVolumeNodesOutput> {
+        self.last
+    }
+
+    /// Build the volume histogram; returns `(low, bin_width, bins)`.
+    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+    fn profile(&self) -> (f64, f64, Vec<f64>) {
+        let mut low = f64::INFINITY;
+        let mut high = f64::NEG_INFINITY;
+        for c in &self.window {
+            low = low.min(c.low);
+            high = high.max(c.high);
+        }
+        let mut hist = vec![0.0; self.bins];
+        let span = high - low;
+        if span <= 0.0 {
+            hist[0] = self.window.iter().map(|c| c.volume).sum();
+            return (low, 0.0, hist);
+        }
+        let width = span / self.bins as f64;
+        for c in &self.window {
+            if c.volume == 0.0 {
+                continue;
+            }
+            let lo_idx = (((c.low - low) / width).floor() as usize).min(self.bins - 1);
+            let hi_idx = (((c.high - low) / width).floor() as usize).min(self.bins - 1);
+            let touched = hi_idx - lo_idx + 1;
+            let share = c.volume / touched as f64;
+            for bin in hist.iter_mut().take(hi_idx + 1).skip(lo_idx) {
+                *bin += share;
+            }
+        }
+        (low, width, hist)
+    }
+}
+
+impl Indicator for HighLowVolumeNodes {
+    type Input = Candle;
+    type Output = HighLowVolumeNodesOutput;
+
+    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+    fn update(&mut self, candle: Candle) -> Option<HighLowVolumeNodesOutput> {
+        if self.window.len() == self.period {
+            self.window.pop_front();
+        }
+        self.window.push_back(candle);
+        if self.window.len() < self.period {
+            return None;
+        }
+        let (low, width, hist) = self.profile();
+        let centre = |idx: usize| low + (idx as f64 + 0.5) * width;
+
+        let mut hvn_idx = 0;
+        let mut hvn_vol = f64::NEG_INFINITY;
+        let mut lvn_idx = 0;
+        let mut lvn_vol = f64::INFINITY;
+        for (idx, &vol) in hist.iter().enumerate() {
+            if vol > hvn_vol {
+                hvn_vol = vol;
+                hvn_idx = idx;
+            }
+            if vol > 0.0 && vol < lvn_vol {
+                lvn_vol = vol;
+                lvn_idx = idx;
+            }
+        }
+        // If no traded bin was found (all zero volume), both default to bin 0.
+        if !lvn_vol.is_finite() {
+            lvn_idx = hvn_idx;
+        }
+        let out = HighLowVolumeNodesOutput {
+            hvn: centre(hvn_idx),
+            lvn: centre(lvn_idx),
+        };
+        self.last = Some(out);
+        Some(out)
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+        self.last = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.last.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "HighLowVolumeNodes"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(high: f64, low: f64, volume: f64) -> Candle {
+        Candle::new_unchecked(
+            f64::midpoint(high, low),
+            high,
+            low,
+            f64::midpoint(high, low),
+            volume,
+            0,
+        )
+    }
+
+    #[test]
+    fn rejects_zero_params() {
+        assert!(matches!(
+            HighLowVolumeNodes::new(0, 24),
+            Err(Error::PeriodZero)
+        ));
+        assert!(matches!(
+            HighLowVolumeNodes::new(20, 0),
+            Err(Error::PeriodZero)
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let h = HighLowVolumeNodes::new(20, 24).unwrap();
+        assert_eq!(h.params(), (20, 24));
+        assert_eq!(h.warmup_period(), 20);
+        assert_eq!(h.name(), "HighLowVolumeNodes");
+        assert!(!h.is_ready());
+        assert_eq!(h.value(), None);
+    }
+
+    #[test]
+    fn first_emission_at_warmup_period() {
+        let mut h = HighLowVolumeNodes::new(4, 8).unwrap();
+        let candles: Vec<Candle> = (0..6).map(|_| c(110.0, 90.0, 1_000.0)).collect();
+        let out = h.batch(&candles);
+        for v in out.iter().take(3) {
+            assert!(v.is_none());
+        }
+        assert!(out[3].is_some());
+    }
+
+    #[test]
+    fn hvn_at_heavy_price() {
+        // Most bars cluster at ~100 (heavy volume); one bar pokes up to 120 lightly.
+        let mut h = HighLowVolumeNodes::new(6, 24).unwrap();
+        let mut candles: Vec<Candle> = (0..5).map(|_| c(101.0, 99.0, 5_000.0)).collect();
+        candles.push(c(121.0, 119.0, 100.0));
+        let out = h.batch(&candles).into_iter().flatten().last().unwrap();
+        // HVN should sit near the heavy 100 cluster, well below the light 120 poke.
+        assert!(
+            out.hvn < 110.0,
+            "HVN should be at the heavy cluster, got {}",
+            out.hvn
+        );
+        assert!(out.lvn >= out.hvn - 1e9); // lvn is a valid level
+    }
+
+    #[test]
+    fn hvn_at_or_above_low() {
+        let mut h = HighLowVolumeNodes::new(10, 24).unwrap();
+        let candles: Vec<Candle> = (0..30)
+            .map(|i| {
+                c(
+                    110.0 + (f64::from(i) * 0.3).sin() * 5.0,
+                    90.0,
+                    1_000.0 + f64::from(i),
+                )
+            })
+            .collect();
+        for o in h.batch(&candles).into_iter().flatten() {
+            assert!(o.hvn.is_finite() && o.lvn.is_finite());
+        }
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut h = HighLowVolumeNodes::new(4, 8).unwrap();
+        h.batch(&[c(110.0, 90.0, 1_000.0); 6]);
+        assert!(h.is_ready());
+        h.reset();
+        assert!(!h.is_ready());
+        assert_eq!(h.value(), None);
+        assert_eq!(h.update(c(110.0, 90.0, 1_000.0)), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..80)
+            .map(|i| {
+                c(
+                    110.0 + (f64::from(i) * 0.25).sin() * 9.0,
+                    90.0,
+                    1_000.0 + f64::from(i),
+                )
+            })
+            .collect();
+        let batch = HighLowVolumeNodes::new(20, 24).unwrap().batch(&candles);
+        let mut b = HighLowVolumeNodes::new(20, 24).unwrap();
+        let streamed: Vec<_> = candles.iter().map(|x| b.update(*x)).collect();
+        assert_eq!(batch, streamed);
+    }
+
+    #[test]
+    fn flat_window_is_handled() {
+        // Zero high-low span dumps all volume into bin 0 and returns early.
+        let mut h = HighLowVolumeNodes::new(2, 4).unwrap();
+        h.update(c(50.0, 50.0, 10.0));
+        assert!(h.update(c(50.0, 50.0, 10.0)).is_some());
+    }
+
+    #[test]
+    fn zero_volume_window_falls_back() {
+        // All-zero volume leaves no traded bin; the LVN falls back to the HVN.
+        let mut h = HighLowVolumeNodes::new(2, 4).unwrap();
+        h.update(c(60.0, 40.0, 0.0));
+        let out = h.update(c(60.0, 40.0, 0.0)).unwrap();
+        assert_eq!(out.hvn, out.lvn);
+    }
+}

crates/wickra-core/src/indicators/mod.rs

@@ -84,6 +84,7 @@ mod cmf;
 mod cmo;
 mod coefficient_of_variation;
 mod cointegration;
+mod composite_profile;
 mod concealing_baby_swallow;
 mod conditional_value_at_risk;
 mod connors_rsi;
@@ -131,6 +132,7 @@ mod ema;
 mod empirical_mode_decomposition;
 mod engulfing;
 mod equivolume;
+mod estimated_leverage_ratio;
 mod even_better_sinewave;
 mod evening_doji_star;
 mod evwma;
@@ -156,6 +158,7 @@ mod fractal_chaos_bands;
 mod frama;
 mod fry_pan_bottom;
 mod funding_basis;
+mod funding_implied_apr;
 mod funding_rate;
 mod funding_rate_mean;
 mod funding_rate_zscore;
@@ -180,6 +183,7 @@ mod heikin_ashi;
 mod heikin_ashi_oscillator;
 mod high_low_index;
 mod high_low_range;
+mod high_low_volume_nodes;
 mod high_wave;
 mod highpass_filter;
 mod hikkake;
@@ -267,6 +271,7 @@ mod mom;
 mod morning_doji_star;
 mod morning_evening_star;
 mod murrey_math_lines;
+mod naked_poc;
 mod natr;
 mod new_highs_new_lows;
 mod new_price_lines;
@@ -278,9 +283,11 @@ mod ob_imbalance_topn;
 mod obv;
 mod oi_delta;
 mod oi_price_divergence;
+mod oi_to_volume_ratio;
 mod oi_weighted;
 mod omega_ratio;
 mod on_neck;
+mod open_interest_momentum;
 mod opening_marubozu;
 mod opening_range;
 mod order_flow_imbalance;
@@ -295,6 +302,7 @@ mod pearson_correlation;
 mod percent_above_ma;
 mod percent_b;
 mod percentage_trailing_stop;
+mod perpetual_premium_index;
 mod pgo;
 mod piercing_dark_cloud;
 mod pin;
@@ -306,6 +314,7 @@ mod point_and_figure_bars;
 mod polarized_fractal_efficiency;
 mod ppo;
 mod ppo_histogram;
+mod profile_shape;
 mod profit_factor;
 mod projection_bands;
 mod projection_oscillator;
@@ -361,6 +370,7 @@ mod short_line;
 mod signed_volume;
 mod sine_wave;
 mod sine_weighted_ma;
+mod single_prints;
 mod skewness;
 mod sma;
 mod smi;
@@ -572,6 +582,7 @@ pub use cmf::ChaikinMoneyFlow;
 pub use cmo::Cmo;
 pub use coefficient_of_variation::CoefficientOfVariation;
 pub use cointegration::{Cointegration, CointegrationOutput};
+pub use composite_profile::{CompositeProfile, CompositeProfileOutput};
 pub use concealing_baby_swallow::ConcealingBabySwallow;
 pub use conditional_value_at_risk::ConditionalValueAtRisk;
 pub use connors_rsi::ConnorsRsi;
@@ -619,6 +630,7 @@ pub use ema::Ema;
 pub use empirical_mode_decomposition::EmpiricalModeDecomposition;
 pub use engulfing::Engulfing;
 pub use equivolume::{Equivolume, EquivolumeOutput};
+pub use estimated_leverage_ratio::EstimatedLeverageRatio;
 pub use even_better_sinewave::EvenBetterSinewave;
 pub use evening_doji_star::EveningDojiStar;
 pub use evwma::Evwma;
@@ -644,6 +656,7 @@ pub use fractal_chaos_bands::{FractalChaosBands, FractalChaosBandsOutput};
 pub use frama::Frama;
 pub use fry_pan_bottom::FryPanBottom;
 pub use funding_basis::FundingBasis;
+pub use funding_implied_apr::FundingImpliedApr;
 pub use funding_rate::FundingRate;
 pub use funding_rate_mean::FundingRateMean;
 pub use funding_rate_zscore::FundingRateZScore;
@@ -668,6 +681,7 @@ pub use heikin_ashi::{HeikinAshi, HeikinAshiOutput};
 pub use heikin_ashi_oscillator::HeikinAshiOscillator;
 pub use high_low_index::HighLowIndex;
 pub use high_low_range::HighLowRange;
+pub use high_low_volume_nodes::{HighLowVolumeNodes, HighLowVolumeNodesOutput};
 pub use high_wave::HighWave;
 pub use highpass_filter::HighpassFilter;
 pub use hikkake::Hikkake;
@@ -755,6 +769,7 @@ pub use mom::Mom;
 pub use morning_doji_star::MorningDojiStar;
 pub use morning_evening_star::MorningEveningStar;
 pub use murrey_math_lines::{MurreyMathLines, MurreyMathLinesOutput};
+pub use naked_poc::NakedPoc;
 pub use natr::Natr;
 pub use new_highs_new_lows::NewHighsNewLows;
 pub use new_price_lines::NewPriceLines;
@@ -766,9 +781,11 @@ pub use ob_imbalance_topn::OrderBookImbalanceTopN;
 pub use obv::Obv;
 pub use oi_delta::OpenInterestDelta;
 pub use oi_price_divergence::OIPriceDivergence;
+pub use oi_to_volume_ratio::OiToVolumeRatio;
 pub use oi_weighted::OIWeighted;
 pub use omega_ratio::OmegaRatio;
 pub use on_neck::OnNeck;
+pub use open_interest_momentum::OpenInterestMomentum;
 pub use opening_marubozu::OpeningMarubozu;
 pub use opening_range::{OpeningRange, OpeningRangeOutput};
 pub use order_flow_imbalance::OrderFlowImbalance;
@@ -783,6 +800,7 @@ pub use pearson_correlation::PearsonCorrelation;
 pub use percent_above_ma::PercentAboveMa;
 pub use percent_b::PercentB;
 pub use percentage_trailing_stop::PercentageTrailingStop;
+pub use perpetual_premium_index::PerpetualPremiumIndex;
 pub use pgo::Pgo;
 pub use piercing_dark_cloud::PiercingDarkCloud;
 pub use pin::Pin;
@@ -794,6 +812,7 @@ pub use point_and_figure_bars::{PnfColumn, PointAndFigureBars};
 pub use polarized_fractal_efficiency::PolarizedFractalEfficiency;
 pub use ppo::Ppo;
 pub use ppo_histogram::PpoHistogram;
+pub use profile_shape::ProfileShape;
 pub use profit_factor::ProfitFactor;
 pub use projection_bands::{ProjectionBands, ProjectionBandsOutput};
 pub use projection_oscillator::ProjectionOscillator;
@@ -849,6 +868,7 @@ pub use short_line::ShortLine;
 pub use signed_volume::SignedVolume;
 pub use sine_wave::SineWave;
 pub use sine_weighted_ma::SineWeightedMa;
+pub use single_prints::SinglePrints;
 pub use skewness::Skewness;
 pub use sma::Sma;
 pub use smi::Smi;
@@ -1478,6 +1498,11 @@ pub const FAMILIES: &[(&str, &[&str])] = &[
             "LiquidationFeatures",
             "TermStructureBasis",
             "CalendarSpread",
+            "EstimatedLeverageRatio",
+            "OiToVolumeRatio",
+            "PerpetualPremiumIndex",
+            "FundingImpliedApr",
+            "OpenInterestMomentum",
         ],
     ),
     (
@@ -1488,6 +1513,11 @@ pub const FAMILIES: &[(&str, &[&str])] = &[
             "OpeningRange",
             "VolumeProfile",
             "TpoProfile",
+            "NakedPoc",
+            "SinglePrints",
+            "ProfileShape",
+            "HighLowVolumeNodes",
+            "CompositeProfile",
         ],
     ),
     (
@@ -1624,6 +1654,6 @@ mod family_tests {
         // the actual indicator count is the early-warning signal that an
         // indicator was added without being assigned a family.
         let total: usize = FAMILIES.iter().map(|(_, ns)| ns.len()).sum();
-        assert_eq!(total, 488, "FAMILIES total drifted from indicator count");
+        assert_eq!(total, 498, "FAMILIES total drifted from indicator count");
     }
 }

crates/wickra-core/src/indicators/naked_poc.rs

@@ -0,0 +1,318 @@
+//! Naked POC — the nearest prior-session point of control price has not yet revisited.
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Naked (Virgin) POC — the nearest **untested** point of control from a prior
+/// session: a heavily-traded price the market has not traded back through since.
+///
+/// ```text
+/// every `session_len` candles forms a session; its POC (heaviest-volume price) is
+///   recorded as "naked"
+/// a naked POC becomes "tested" once a later candle's high-low range covers it
+/// output = the nearest still-naked POC to the current close (or the close itself
+///   if every prior POC has been revisited)
+/// ```
+///
+/// A point of control is a magnet — price tends to return to fair value. A *naked*
+/// (or virgin) POC is one that has not yet been revisited, so it carries an
+/// outstanding "pull": untested POCs are high-probability targets and
+/// support/resistance on the approach. This indicator records each completed
+/// session's POC, marks them tested as price trades through them, and reports the
+/// closest one still outstanding.
+///
+/// The first value lands after `session_len` candles (the first session's POC).
+/// Each `update` is O(`session_len · bins` + naked-count).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, NakedPoc};
+///
+/// let mut indicator = NakedPoc::new(20, 24).unwrap();
+/// let mut last = None;
+/// for i in 0..60 {
+///     let base = 100.0 + (f64::from(i) * 0.2).sin() * 5.0;
+///     let c = Candle::new(base, base + 1.0, base - 1.0, base, 1_000.0, 0).unwrap();
+///     last = indicator.update(c);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct NakedPoc {
+    session_len: usize,
+    bins: usize,
+    session: VecDeque<Candle>,
+    naked: Vec<f64>,
+    last_close: f64,
+    ready: bool,
+    last: Option<f64>,
+}
+
+impl NakedPoc {
+    /// Construct a Naked POC tracker with the given `session_len` and profile
+    /// `bins`.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::PeriodZero`] if `session_len` or `bins` is zero.
+    pub fn new(session_len: usize, bins: usize) -> Result<Self> {
+        if session_len == 0 || bins == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            session_len,
+            bins,
+            session: VecDeque::with_capacity(session_len),
+            naked: Vec::new(),
+            last_close: 0.0,
+            ready: false,
+            last: None,
+        })
+    }
+
+    /// Configured `(session_len, bins)`.
+    pub const fn params(&self) -> (usize, usize) {
+        (self.session_len, self.bins)
+    }
+
+    /// Number of currently-naked POCs.
+    pub fn naked_count(&self) -> usize {
+        self.naked.len()
+    }
+
+    /// Current value if available.
+    pub const fn value(&self) -> Option<f64> {
+        self.last
+    }
+
+    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+    fn session_poc(&self) -> f64 {
+        let mut low = f64::INFINITY;
+        let mut high = f64::NEG_INFINITY;
+        for c in &self.session {
+            low = low.min(c.low);
+            high = high.max(c.high);
+        }
+        let span = high - low;
+        if span <= 0.0 {
+            return low;
+        }
+        let width = span / self.bins as f64;
+        let mut hist = vec![0.0; self.bins];
+        for c in &self.session {
+            if c.volume == 0.0 {
+                continue;
+            }
+            let lo_idx = (((c.low - low) / width).floor() as usize).min(self.bins - 1);
+            let hi_idx = (((c.high - low) / width).floor() as usize).min(self.bins - 1);
+            let share = c.volume / (hi_idx - lo_idx + 1) as f64;
+            for bin in hist.iter_mut().take(hi_idx + 1).skip(lo_idx) {
+                *bin += share;
+            }
+        }
+        let mut poc = 0;
+        let mut poc_vol = f64::NEG_INFINITY;
+        for (idx, &vol) in hist.iter().enumerate() {
+            if vol > poc_vol {
+                poc_vol = vol;
+                poc = idx;
+            }
+        }
+        low + (poc as f64 + 0.5) * width
+    }
+}
+
+impl Indicator for NakedPoc {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        // Test outstanding naked POCs against this candle's range.
+        self.naked
+            .retain(|&poc| !(candle.low <= poc && poc <= candle.high));
+        self.last_close = candle.close;
+
+        // Accumulate the session; finalize a POC at the boundary.
+        self.session.push_back(candle);
+        if self.session.len() == self.session_len {
+            let poc = self.session_poc();
+            self.naked.push(poc);
+            self.session.clear();
+            self.ready = true;
+        }
+
+        if !self.ready {
+            return None;
+        }
+        let nearest = self
+            .naked
+            .iter()
+            .copied()
+            .min_by(|a, b| {
+                (a - self.last_close)
+                    .abs()
+                    .total_cmp(&(b - self.last_close).abs())
+            })
+            .unwrap_or(self.last_close);
+        self.last = Some(nearest);
+        Some(nearest)
+    }
+
+    fn reset(&mut self) {
+        self.session.clear();
+        self.naked.clear();
+        self.last_close = 0.0;
+        self.ready = false;
+        self.last = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.session_len
+    }
+
+    fn is_ready(&self) -> bool {
+        self.last.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "NakedPoc"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(high: f64, low: f64, close: f64, volume: f64) -> Candle {
+        Candle::new_unchecked(f64::midpoint(high, low), high, low, close, volume, 0)
+    }
+
+    #[test]
+    fn rejects_zero_params() {
+        assert!(matches!(NakedPoc::new(0, 24), Err(Error::PeriodZero)));
+        assert!(matches!(NakedPoc::new(20, 0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let n = NakedPoc::new(20, 24).unwrap();
+        assert_eq!(n.params(), (20, 24));
+        assert_eq!(n.naked_count(), 0);
+        assert_eq!(n.warmup_period(), 20);
+        assert_eq!(n.name(), "NakedPoc");
+        assert!(!n.is_ready());
+        assert_eq!(n.value(), None);
+    }
+
+    #[test]
+    fn first_emission_at_session_end() {
+        let mut n = NakedPoc::new(4, 8).unwrap();
+        let candles: Vec<Candle> = (0..6).map(|_| c(101.0, 99.0, 100.0, 1_000.0)).collect();
+        let out = n.batch(&candles);
+        for v in out.iter().take(3) {
+            assert!(v.is_none());
+        }
+        assert!(out[3].is_some());
+    }
+
+    #[test]
+    fn records_session_poc() {
+        let mut n = NakedPoc::new(4, 16).unwrap();
+        // A session clustered around 100 -> POC near 100.
+        n.batch(&[c(101.0, 99.0, 100.0, 5_000.0); 4]);
+        assert_eq!(n.naked_count(), 1);
+        let poc = n.value().unwrap();
+        assert!(
+            (poc - 100.0).abs() < 2.0,
+            "POC should be near 100, got {poc}"
+        );
+    }
+
+    #[test]
+    fn revisit_marks_poc_tested() {
+        let mut n = NakedPoc::new(4, 16).unwrap();
+        // Session 1 around 100 -> naked POC ~100.
+        n.batch(&[c(101.0, 99.0, 100.0, 5_000.0); 4]);
+        assert_eq!(n.naked_count(), 1);
+        // Trade away at 120 (does not cover 100) -> still naked.
+        n.update(c(121.0, 119.0, 120.0, 1_000.0));
+        assert_eq!(n.naked_count(), 1);
+        // A candle whose range covers 100 -> POC tested -> removed.
+        n.update(c(121.0, 95.0, 100.0, 1_000.0));
+        assert_eq!(n.naked_count(), 0);
+    }
+
+    #[test]
+    fn empty_naked_reports_close() {
+        let mut n = NakedPoc::new(4, 16).unwrap();
+        n.batch(&[c(101.0, 99.0, 100.0, 5_000.0); 4]);
+        // Wipe the naked POC with a covering candle.
+        let out = n.update(c(121.0, 95.0, 117.0, 1_000.0)).unwrap();
+        assert_eq!(n.naked_count(), 0);
+        assert!(
+            (out - 117.0).abs() < 1e-9,
+            "with no naked POC, output is the close"
+        );
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut n = NakedPoc::new(4, 8).unwrap();
+        n.batch(&[c(101.0, 99.0, 100.0, 1_000.0); 6]);
+        assert!(n.is_ready());
+        n.reset();
+        assert!(!n.is_ready());
+        assert_eq!(n.value(), None);
+        assert_eq!(n.naked_count(), 0);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..80)
+            .map(|i| {
+                let b = 100.0 + (f64::from(i) * 0.25).sin() * 9.0;
+                c(b + 1.0, b - 1.0, b, 1_000.0 + f64::from(i))
+            })
+            .collect();
+        let batch = NakedPoc::new(20, 24).unwrap().batch(&candles);
+        let mut b = NakedPoc::new(20, 24).unwrap();
+        let streamed: Vec<_> = candles.iter().map(|x| b.update(*x)).collect();
+        assert_eq!(batch, streamed);
+    }
+
+    #[test]
+    fn flat_session_reports_price() {
+        // A session with zero high-low span returns the session price directly.
+        let mut n = NakedPoc::new(2, 4).unwrap();
+        n.update(c(50.0, 50.0, 50.0, 10.0));
+        assert_eq!(n.update(c(50.0, 50.0, 50.0, 10.0)), Some(50.0));
+    }
+
+    #[test]
+    fn zero_volume_session_is_handled() {
+        // Zero-volume candles are skipped in the histogram; a POC still emits.
+        let mut n = NakedPoc::new(2, 4).unwrap();
+        n.update(c(60.0, 40.0, 50.0, 0.0));
+        assert!(n.update(c(60.0, 40.0, 50.0, 0.0)).is_some());
+    }
+
+    #[test]
+    fn nearest_of_two_naked_pocs() {
+        // Two untouched POCs at distant prices accumulate; the one nearest the
+        // last close is reported (exercises the min-by comparison).
+        let mut n = NakedPoc::new(2, 4).unwrap();
+        n.update(c(11.0, 9.0, 10.0, 100.0));
+        n.update(c(11.0, 9.0, 10.0, 100.0)); // POC near 10
+        n.update(c(101.0, 99.0, 100.0, 100.0));
+        let v = n.update(c(101.0, 99.0, 100.0, 100.0)).unwrap(); // POC near 100
+        assert!(
+            v > 50.0,
+            "nearest to close 100 should be the upper POC, got {v}"
+        );
+    }
+}

crates/wickra-core/src/indicators/oi_to_volume_ratio.rs

@@ -0,0 +1,154 @@
+//! OI-to-Volume Ratio — open interest relative to traded volume.
+
+use crate::derivatives::DerivativesTick;
+use crate::traits::Indicator;
+
+/// OI-to-Volume Ratio — open interest divided by the tick's total taker volume, a
+/// measure of how much position is *held* versus *turned over*.
+///
+/// ```text
+/// OIVR = open_interest / (taker_buy_volume + taker_sell_volume)
+/// ```
+///
+/// A high ratio means open interest dwarfs the volume trading it — positions are
+/// being held, not churned (low participation, potential complacency or a coiling
+/// market). A low ratio means heavy volume relative to outstanding interest —
+/// active churn, often around breakouts or capitulation. Watching the ratio change
+/// distinguishes new-money trends (OI and volume both rising) from short-covering
+/// or position rolls.
+///
+/// The ratio is non-negative; a tick with zero taker volume reports `0` rather than
+/// dividing by zero. It is stateless — each tick yields one value (no warmup). Each
+/// `update` is O(1).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{DerivativesTick, Indicator, OiToVolumeRatio};
+///
+/// let mut indicator = OiToVolumeRatio::new();
+/// let tick = DerivativesTick::new(0.0, 100.0, 100.0, 100.0, 5_000.0, 0.0, 0.0, 400.0, 600.0, 0.0, 0.0, 0).unwrap();
+/// let oivr = indicator.update(tick).unwrap();
+/// assert!((oivr - 5.0).abs() < 1e-12); // 5000 / (400 + 600)
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct OiToVolumeRatio {
+    ready: bool,
+}
+
+impl OiToVolumeRatio {
+    /// Construct a new OI-to-Volume Ratio. The indicator is parameter-free.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self { ready: false }
+    }
+}
+
+impl Indicator for OiToVolumeRatio {
+    type Input = DerivativesTick;
+    type Output = f64;
+
+    fn update(&mut self, tick: DerivativesTick) -> Option<f64> {
+        let volume = tick.taker_buy_volume + tick.taker_sell_volume;
+        let ratio = if volume > 0.0 {
+            tick.open_interest / volume
+        } else {
+            0.0
+        };
+        self.ready = true;
+        Some(ratio)
+    }
+
+    fn reset(&mut self) {
+        self.ready = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.ready
+    }
+
+    fn name(&self) -> &'static str {
+        "OiToVolumeRatio"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn tick(oi: f64, buy: f64, sell: f64) -> DerivativesTick {
+        DerivativesTick::new_unchecked(
+            0.0, 100.0, 100.0, 100.0, oi, 0.0, 0.0, buy, sell, 0.0, 0.0, 0,
+        )
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let o = OiToVolumeRatio::new();
+        assert_eq!(o.warmup_period(), 1);
+        assert_eq!(o.name(), "OiToVolumeRatio");
+        assert!(!o.is_ready());
+    }
+
+    #[test]
+    fn ratio_reference_value() {
+        let mut o = OiToVolumeRatio::new();
+        assert_relative_eq!(
+            o.update(tick(5_000.0, 400.0, 600.0)).unwrap(),
+            5.0,
+            epsilon = 1e-12
+        );
+    }
+
+    #[test]
+    fn more_volume_lowers_ratio() {
+        let mut o = OiToVolumeRatio::new();
+        let held = o.update(tick(5_000.0, 100.0, 100.0)).unwrap();
+        let churned = o.update(tick(5_000.0, 1_000.0, 1_000.0)).unwrap();
+        assert!(churned < held);
+    }
+
+    #[test]
+    fn zero_volume_is_zero() {
+        let mut o = OiToVolumeRatio::new();
+        assert_relative_eq!(
+            o.update(tick(5_000.0, 0.0, 0.0)).unwrap(),
+            0.0,
+            epsilon = 1e-12
+        );
+    }
+
+    #[test]
+    fn ready_after_first_update() {
+        let mut o = OiToVolumeRatio::new();
+        assert!(!o.is_ready());
+        o.update(tick(5_000.0, 100.0, 100.0));
+        assert!(o.is_ready());
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut o = OiToVolumeRatio::new();
+        o.update(tick(5_000.0, 100.0, 100.0));
+        assert!(o.is_ready());
+        o.reset();
+        assert!(!o.is_ready());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let ticks: Vec<DerivativesTick> = (0..40)
+            .map(|i| tick(5_000.0, 100.0 + f64::from(i), 100.0))
+            .collect();
+        let batch = OiToVolumeRatio::new().batch(&ticks);
+        let mut b = OiToVolumeRatio::new();
+        let streamed: Vec<_> = ticks.iter().map(|x| b.update(*x)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

crates/wickra-core/src/indicators/open_interest_momentum.rs

@@ -0,0 +1,221 @@
+//! Open-Interest Momentum — the rate of change of open interest over a lookback.
+
+use std::collections::VecDeque;
+
+use crate::derivatives::DerivativesTick;
+use crate::error::{Error, Result};
+use crate::traits::Indicator;
+
+/// Open-Interest Momentum — the percentage rate of change of open interest over a
+/// `period`-tick lookback.
+///
+/// ```text
+/// OIM = 100 · (OI_t − OI_{t−period}) / OI_{t−period}
+/// ```
+///
+/// Where [`OIDelta`](crate::OIDelta) reports the single-tick change in open
+/// interest, OI Momentum measures the trend in positioning over a window: positive
+/// values mean open interest is expanding (new money entering — a position build
+/// that fuels the prevailing move), negative values mean it is contracting
+/// (positions being closed — deleveraging or short-covering). Read alongside price:
+/// rising OI with rising price is a strong new-long trend, while rising price with
+/// falling OI is a short-covering rally on borrowed time.
+///
+/// The output is a percentage and may be negative. A zero base open interest
+/// `period` ticks ago reports `0` rather than dividing by zero. The first value
+/// lands after `period + 1` inputs. Each `update` is O(1).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{DerivativesTick, Indicator, OpenInterestMomentum};
+///
+/// let mut indicator = OpenInterestMomentum::new(5).unwrap();
+/// let mut last = None;
+/// for i in 0..20 {
+///     let oi = 1_000.0 + f64::from(i) * 100.0;
+///     let tick = DerivativesTick::new(0.0, 100.0, 100.0, 100.0, oi, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0).unwrap();
+///     last = indicator.update(tick);
+/// }
+/// assert!(last.unwrap() > 0.0); // expanding OI
+/// ```
+#[derive(Debug, Clone)]
+pub struct OpenInterestMomentum {
+    period: usize,
+    window: VecDeque<f64>,
+    last: Option<f64>,
+}
+
+impl OpenInterestMomentum {
+    /// Construct an OI Momentum over a `period`-tick lookback.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::PeriodZero`] if `period == 0`.
+    pub fn new(period: usize) -> Result<Self> {
+        if period == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            period,
+            window: VecDeque::with_capacity(period + 1),
+            last: None,
+        })
+    }
+
+    /// Configured lookback period.
+    pub const fn period(&self) -> usize {
+        self.period
+    }
+
+    /// Current value if available.
+    pub const fn value(&self) -> Option<f64> {
+        self.last
+    }
+}
+
+impl Indicator for OpenInterestMomentum {
+    type Input = DerivativesTick;
+    type Output = f64;
+
+    fn update(&mut self, tick: DerivativesTick) -> Option<f64> {
+        if self.window.len() == self.period + 1 {
+            self.window.pop_front();
+        }
+        self.window.push_back(tick.open_interest);
+        if self.window.len() < self.period + 1 {
+            return None;
+        }
+        let base = *self.window.front().expect("non-empty");
+        let current = tick.open_interest;
+        let oim = if base > 0.0 {
+            100.0 * (current - base) / base
+        } else {
+            0.0
+        };
+        self.last = Some(oim);
+        Some(oim)
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+        self.last = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period + 1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.last.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "OpenInterestMomentum"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn tick(oi: f64) -> DerivativesTick {
+        DerivativesTick::new_unchecked(
+            0.0, 100.0, 100.0, 100.0, oi, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0,
+        )
+    }
+
+    #[test]
+    fn rejects_zero_period() {
+        assert!(matches!(
+            OpenInterestMomentum::new(0),
+            Err(Error::PeriodZero)
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let o = OpenInterestMomentum::new(5).unwrap();
+        assert_eq!(o.period(), 5);
+        assert_eq!(o.warmup_period(), 6);
+        assert_eq!(o.name(), "OpenInterestMomentum");
+        assert!(!o.is_ready());
+        assert_eq!(o.value(), None);
+    }
+
+    #[test]
+    fn first_emission_at_warmup_period() {
+        let mut o = OpenInterestMomentum::new(3).unwrap();
+        let ticks: Vec<DerivativesTick> = (0..6)
+            .map(|i| tick(1_000.0 + f64::from(i) * 100.0))
+            .collect();
+        let out = o.batch(&ticks);
+        for v in out.iter().take(3) {
+            assert!(v.is_none());
+        }
+        assert!(out[3].is_some());
+    }
+
+    #[test]
+    fn reference_value() {
+        // period 2: OI 1000 -> 1200 over the window -> +20%.
+        let mut o = OpenInterestMomentum::new(2).unwrap();
+        let out = o.batch(&[tick(1_000.0), tick(1_100.0), tick(1_200.0)]);
+        assert_relative_eq!(out[2].unwrap(), 20.0, epsilon = 1e-9);
+    }
+
+    #[test]
+    fn expanding_oi_is_positive() {
+        let mut o = OpenInterestMomentum::new(5).unwrap();
+        let ticks: Vec<DerivativesTick> = (0..20)
+            .map(|i| tick(1_000.0 + f64::from(i) * 100.0))
+            .collect();
+        let last = o.batch(&ticks).into_iter().flatten().last().unwrap();
+        assert!(last > 0.0);
+    }
+
+    #[test]
+    fn contracting_oi_is_negative() {
+        let mut o = OpenInterestMomentum::new(5).unwrap();
+        let ticks: Vec<DerivativesTick> = (0..20)
+            .map(|i| tick(3_000.0 - f64::from(i) * 100.0))
+            .collect();
+        let last = o.batch(&ticks).into_iter().flatten().last().unwrap();
+        assert!(last < 0.0);
+    }
+
+    #[test]
+    fn zero_base_is_zero() {
+        let mut o = OpenInterestMomentum::new(2).unwrap();
+        let out = o.batch(&[tick(0.0), tick(100.0), tick(200.0)]);
+        assert_relative_eq!(out[2].unwrap(), 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut o = OpenInterestMomentum::new(3).unwrap();
+        o.batch(
+            &(0..10)
+                .map(|i| tick(1_000.0 + f64::from(i) * 50.0))
+                .collect::<Vec<_>>(),
+        );
+        assert!(o.is_ready());
+        o.reset();
+        assert!(!o.is_ready());
+        assert_eq!(o.value(), None);
+        assert_eq!(o.update(tick(1_000.0)), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let ticks: Vec<DerivativesTick> = (0..80)
+            .map(|i| tick(1_000.0 + (f64::from(i) * 0.25).sin() * 300.0))
+            .collect();
+        let batch = OpenInterestMomentum::new(10).unwrap().batch(&ticks);
+        let mut b = OpenInterestMomentum::new(10).unwrap();
+        let streamed: Vec<_> = ticks.iter().map(|x| b.update(*x)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

crates/wickra-core/src/indicators/perpetual_premium_index.rs

@@ -0,0 +1,139 @@
+//! Perpetual Premium Index — the perp mark price relative to spot.
+
+use crate::derivatives::DerivativesTick;
+use crate::traits::Indicator;
+
+/// Perpetual Premium Index — the perpetual's mark price relative to the spot index
+/// it tracks, as a fraction.
+///
+/// ```text
+/// premium = (mark_price − index_price) / index_price
+/// ```
+///
+/// A perpetual swap is pegged to spot by the funding mechanism, but it can still
+/// trade at a premium (above spot) or discount (below). A positive premium signals
+/// net long demand willing to pay up to hold the perp — bullish positioning, and
+/// the proximate driver of positive funding; a negative premium signals the
+/// reverse. Sustained extremes flag crowded positioning ripe for a funding-driven
+/// mean reversion.
+///
+/// The output is centred on zero and dimensionless (a fraction; multiply by `100`
+/// for percent). `index_price` is validated strictly positive on the tick, so the
+/// division is always defined. It is stateless — each tick yields one value (no
+/// warmup). Each `update` is O(1).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{DerivativesTick, Indicator, PerpetualPremiumIndex};
+///
+/// let mut indicator = PerpetualPremiumIndex::new();
+/// // Mark 101 vs index 100 -> +1% premium.
+/// let tick = DerivativesTick::new(0.0, 101.0, 100.0, 101.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0).unwrap();
+/// let premium = indicator.update(tick).unwrap();
+/// assert!((premium - 0.01).abs() < 1e-12);
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct PerpetualPremiumIndex {
+    ready: bool,
+}
+
+impl PerpetualPremiumIndex {
+    /// Construct a new Perpetual Premium Index. The indicator is parameter-free.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self { ready: false }
+    }
+}
+
+impl Indicator for PerpetualPremiumIndex {
+    type Input = DerivativesTick;
+    type Output = f64;
+
+    fn update(&mut self, tick: DerivativesTick) -> Option<f64> {
+        let premium = (tick.mark_price - tick.index_price) / tick.index_price;
+        self.ready = true;
+        Some(premium)
+    }
+
+    fn reset(&mut self) {
+        self.ready = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.ready
+    }
+
+    fn name(&self) -> &'static str {
+        "PerpetualPremiumIndex"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn tick(mark: f64, index: f64) -> DerivativesTick {
+        DerivativesTick::new_unchecked(0.0, mark, index, mark, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0)
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let p = PerpetualPremiumIndex::new();
+        assert_eq!(p.warmup_period(), 1);
+        assert_eq!(p.name(), "PerpetualPremiumIndex");
+        assert!(!p.is_ready());
+    }
+
+    #[test]
+    fn premium_reference_value() {
+        let mut p = PerpetualPremiumIndex::new();
+        assert_relative_eq!(p.update(tick(101.0, 100.0)).unwrap(), 0.01, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn discount_is_negative() {
+        let mut p = PerpetualPremiumIndex::new();
+        assert!(p.update(tick(99.0, 100.0)).unwrap() < 0.0);
+    }
+
+    #[test]
+    fn at_par_is_zero() {
+        let mut p = PerpetualPremiumIndex::new();
+        assert_relative_eq!(p.update(tick(100.0, 100.0)).unwrap(), 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn ready_after_first_update() {
+        let mut p = PerpetualPremiumIndex::new();
+        assert!(!p.is_ready());
+        p.update(tick(100.0, 100.0));
+        assert!(p.is_ready());
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut p = PerpetualPremiumIndex::new();
+        p.update(tick(101.0, 100.0));
+        assert!(p.is_ready());
+        p.reset();
+        assert!(!p.is_ready());
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let ticks: Vec<DerivativesTick> = (0..40)
+            .map(|i| tick(100.0 + (f64::from(i) * 0.3).sin(), 100.0))
+            .collect();
+        let batch = PerpetualPremiumIndex::new().batch(&ticks);
+        let mut b = PerpetualPremiumIndex::new();
+        let streamed: Vec<_> = ticks.iter().map(|x| b.update(*x)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

crates/wickra-core/src/indicators/profile_shape.rs

@@ -0,0 +1,285 @@
+//! Profile Shape — classifies the volume profile as b-shape, P-shape, or D/normal.
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Profile Shape — classifies a rolling volume profile by where its point of
+/// control (POC) sits within the range: `b`, `P`, or `D` (normal).
+///
+/// ```text
+/// build a `bins`-bucket volume profile over the last `period` candles
+/// poc_idx = bin with the most volume
+/// +1  P-shape : POC in the upper third  (heavy top, thin tail down) — short-covering / accumulation
+/// −1  b-shape : POC in the lower third  (heavy bottom, thin tail up) — long-liquidation / distribution
+///  0  D/normal: POC in the middle third (balanced bell)
+/// ```
+///
+/// Market Profile readers classify the day's shape by the location of the heaviest
+/// trading. A **P-shape** (control high, a thin tail beneath) typically marks
+/// short-covering or the start of accumulation; a **b-shape** (control low, thin
+/// tail above) marks long liquidation or distribution; a **D-shape** is a balanced,
+/// two-sided day. Reducing the profile to this three-way code gives a compact,
+/// streaming read of market posture.
+///
+/// The output is `+1` / `0` / `−1`. The first value lands after `period` candles;
+/// each `update` rebuilds the profile in O(`period · bins`).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, ProfileShape};
+///
+/// let mut indicator = ProfileShape::new(20, 24).unwrap();
+/// let mut last = None;
+/// for i in 0..40 {
+///     let base = 100.0 + (f64::from(i) * 0.3).sin() * 5.0;
+///     let c = Candle::new(base, base + 1.0, base - 1.0, base, 1_000.0, 0).unwrap();
+///     last = indicator.update(c);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct ProfileShape {
+    period: usize,
+    bins: usize,
+    window: VecDeque<Candle>,
+    last: Option<f64>,
+}
+
+impl ProfileShape {
+    /// Construct a Profile Shape classifier.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::PeriodZero`] if `period` is zero, or
+    /// [`Error::InvalidPeriod`] if `bins < 3` (the three-way split needs three
+    /// zones).
+    pub fn new(period: usize, bins: usize) -> Result<Self> {
+        if period == 0 {
+            return Err(Error::PeriodZero);
+        }
+        if bins < 3 {
+            return Err(Error::InvalidPeriod {
+                message: "profile shape needs bins >= 3",
+            });
+        }
+        Ok(Self {
+            period,
+            bins,
+            window: VecDeque::with_capacity(period),
+            last: None,
+        })
+    }
+
+    /// Configured `(period, bins)`.
+    pub const fn params(&self) -> (usize, usize) {
+        (self.period, self.bins)
+    }
+
+    /// Current value if available.
+    pub const fn value(&self) -> Option<f64> {
+        self.last
+    }
+
+    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+    fn poc_index(&self) -> usize {
+        let mut low = f64::INFINITY;
+        let mut high = f64::NEG_INFINITY;
+        for c in &self.window {
+            low = low.min(c.low);
+            high = high.max(c.high);
+        }
+        let mut hist = vec![0.0; self.bins];
+        let span = high - low;
+        if span > 0.0 {
+            let width = span / self.bins as f64;
+            for c in &self.window {
+                if c.volume == 0.0 {
+                    continue;
+                }
+                let lo_idx = (((c.low - low) / width).floor() as usize).min(self.bins - 1);
+                let hi_idx = (((c.high - low) / width).floor() as usize).min(self.bins - 1);
+                let share = c.volume / (hi_idx - lo_idx + 1) as f64;
+                for bin in hist.iter_mut().take(hi_idx + 1).skip(lo_idx) {
+                    *bin += share;
+                }
+            }
+        }
+        let mut poc_idx = 0;
+        let mut poc_vol = f64::NEG_INFINITY;
+        for (idx, &vol) in hist.iter().enumerate() {
+            if vol > poc_vol {
+                poc_vol = vol;
+                poc_idx = idx;
+            }
+        }
+        poc_idx
+    }
+}
+
+impl Indicator for ProfileShape {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        if self.window.len() == self.period {
+            self.window.pop_front();
+        }
+        self.window.push_back(candle);
+        if self.window.len() < self.period {
+            return None;
+        }
+        let poc = self.poc_index();
+        let lower = self.bins / 3;
+        let upper = self.bins - self.bins / 3;
+        let shape = if poc >= upper {
+            1.0
+        } else if poc < lower {
+            -1.0
+        } else {
+            0.0
+        };
+        self.last = Some(shape);
+        Some(shape)
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+        self.last = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.last.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "ProfileShape"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(high: f64, low: f64, volume: f64) -> Candle {
+        Candle::new_unchecked(
+            f64::midpoint(high, low),
+            high,
+            low,
+            f64::midpoint(high, low),
+            volume,
+            0,
+        )
+    }
+
+    #[test]
+    fn rejects_invalid_params() {
+        assert!(matches!(ProfileShape::new(0, 24), Err(Error::PeriodZero)));
+        assert!(matches!(
+            ProfileShape::new(20, 2),
+            Err(Error::InvalidPeriod { .. })
+        ));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let p = ProfileShape::new(20, 24).unwrap();
+        assert_eq!(p.params(), (20, 24));
+        assert_eq!(p.warmup_period(), 20);
+        assert_eq!(p.name(), "ProfileShape");
+        assert!(!p.is_ready());
+        assert_eq!(p.value(), None);
+    }
+
+    #[test]
+    fn first_emission_at_warmup_period() {
+        let mut p = ProfileShape::new(4, 9).unwrap();
+        let candles: Vec<Candle> = (0..6).map(|_| c(110.0, 90.0, 1_000.0)).collect();
+        let out = p.batch(&candles);
+        for v in out.iter().take(3) {
+            assert!(v.is_none());
+        }
+        assert!(out[3].is_some());
+    }
+
+    #[test]
+    fn heavy_top_is_p_shape() {
+        // Volume concentrated near the top of the range -> P-shape -> +1.
+        let mut p = ProfileShape::new(6, 9).unwrap();
+        let mut candles: Vec<Candle> = (0..5).map(|_| c(119.0, 117.0, 5_000.0)).collect();
+        candles.push(c(119.0, 80.0, 50.0)); // a thin tail down to 80
+        let last = p.batch(&candles).into_iter().flatten().last().unwrap();
+        assert_eq!(last, 1.0);
+    }
+
+    #[test]
+    fn heavy_bottom_is_b_shape() {
+        let mut p = ProfileShape::new(6, 9).unwrap();
+        let mut candles: Vec<Candle> = (0..5).map(|_| c(83.0, 81.0, 5_000.0)).collect();
+        candles.push(c(120.0, 81.0, 50.0)); // a thin tail up to 120
+        let last = p.batch(&candles).into_iter().flatten().last().unwrap();
+        assert_eq!(last, -1.0);
+    }
+
+    #[test]
+    fn balanced_is_d_shape() {
+        // Volume concentrated in the middle -> D/normal -> 0.
+        let mut p = ProfileShape::new(6, 9).unwrap();
+        let mut candles: Vec<Candle> = (0..5).map(|_| c(101.0, 99.0, 5_000.0)).collect();
+        candles.push(c(120.0, 80.0, 50.0)); // thin tails both ways, POC in the middle
+        let last = p.batch(&candles).into_iter().flatten().last().unwrap();
+        assert_eq!(last, 0.0);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut p = ProfileShape::new(4, 9).unwrap();
+        p.batch(&[c(110.0, 90.0, 1_000.0); 6]);
+        assert!(p.is_ready());
+        p.reset();
+        assert!(!p.is_ready());
+        assert_eq!(p.value(), None);
+        assert_eq!(p.update(c(110.0, 90.0, 1_000.0)), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..80)
+            .map(|i| {
+                c(
+                    110.0 + (f64::from(i) * 0.25).sin() * 9.0,
+                    90.0,
+                    1_000.0 + f64::from(i),
+                )
+            })
+            .collect();
+        let batch = ProfileShape::new(20, 24).unwrap().batch(&candles);
+        let mut b = ProfileShape::new(20, 24).unwrap();
+        let streamed: Vec<_> = candles.iter().map(|x| b.update(*x)).collect();
+        assert_eq!(batch, streamed);
+    }
+
+    #[test]
+    fn flat_window_is_handled() {
+        // Zero high-low span skips the histogram pass entirely.
+        let mut p = ProfileShape::new(2, 4).unwrap();
+        p.update(c(50.0, 50.0, 10.0));
+        assert!(p.update(c(50.0, 50.0, 10.0)).is_some());
+    }
+
+    #[test]
+    fn zero_volume_window_is_handled() {
+        // Non-flat window of zero-volume candles hits the skip path.
+        let mut p = ProfileShape::new(2, 4).unwrap();
+        p.update(c(60.0, 40.0, 0.0));
+        assert!(p.update(c(60.0, 40.0, 0.0)).is_some());
+    }
+}

crates/wickra-core/src/indicators/single_prints.rs

@@ -0,0 +1,253 @@
+//! Single Prints — count of price levels touched by exactly one bar (low acceptance).
+
+use std::collections::VecDeque;
+
+use crate::error::{Error, Result};
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Single Prints — the number of price levels (bins) in the rolling profile that
+/// were touched by **exactly one** bar, marking zones of low acceptance / fast
+/// movement.
+///
+/// ```text
+/// for each of `bins` price levels over the last `period` candles:
+///   touches = number of bars whose high-low range covers that level
+/// SinglePrints = count of levels with touches == 1
+/// ```
+///
+/// In Market Profile a "single print" is a price the market traded through so
+/// quickly that only one time-period printed there — a footprint of an aggressive,
+/// one-sided move with little two-way trade. Single prints often act as support or
+/// resistance on a retest (the imbalance gets "repaired") and mark the edges of
+/// rapid moves. Counting them per profile gives a streaming gauge of how much of
+/// the recent range was traversed without acceptance: a high count means a fast,
+/// trending, low-rotation market; a low count means a balanced, well-traded range.
+///
+/// The output is a non-negative count. The first value lands after `period`
+/// candles; each `update` rebuilds the touch histogram in O(`period · bins`).
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, SinglePrints};
+///
+/// let mut indicator = SinglePrints::new(20, 24).unwrap();
+/// let mut last = None;
+/// for i in 0..40 {
+///     let base = 100.0 + f64::from(i); // a one-directional ramp -> many single prints
+///     let c = Candle::new(base, base + 0.5, base - 0.5, base, 1_000.0, 0).unwrap();
+///     last = indicator.update(c);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct SinglePrints {
+    period: usize,
+    bins: usize,
+    window: VecDeque<Candle>,
+    last: Option<f64>,
+}
+
+impl SinglePrints {
+    /// Construct a Single Prints counter.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::PeriodZero`] if `period` or `bins` is zero.
+    pub fn new(period: usize, bins: usize) -> Result<Self> {
+        if period == 0 || bins == 0 {
+            return Err(Error::PeriodZero);
+        }
+        Ok(Self {
+            period,
+            bins,
+            window: VecDeque::with_capacity(period),
+            last: None,
+        })
+    }
+
+    /// Configured `(period, bins)`.
+    pub const fn params(&self) -> (usize, usize) {
+        (self.period, self.bins)
+    }
+
+    /// Current value if available.
+    pub const fn value(&self) -> Option<f64> {
+        self.last
+    }
+
+    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+    fn count_single_prints(&self) -> usize {
+        let mut low = f64::INFINITY;
+        let mut high = f64::NEG_INFINITY;
+        for c in &self.window {
+            low = low.min(c.low);
+            high = high.max(c.high);
+        }
+        let span = high - low;
+        if span <= 0.0 {
+            return 0;
+        }
+        let width = span / self.bins as f64;
+        let mut touches = vec![0u32; self.bins];
+        for c in &self.window {
+            let lo_idx = (((c.low - low) / width).floor() as usize).min(self.bins - 1);
+            let hi_idx = (((c.high - low) / width).floor() as usize).min(self.bins - 1);
+            for t in touches.iter_mut().take(hi_idx + 1).skip(lo_idx) {
+                *t += 1;
+            }
+        }
+        touches.iter().filter(|&&t| t == 1).count()
+    }
+}
+
+impl Indicator for SinglePrints {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        if self.window.len() == self.period {
+            self.window.pop_front();
+        }
+        self.window.push_back(candle);
+        if self.window.len() < self.period {
+            return None;
+        }
+        let count = self.count_single_prints() as f64;
+        self.last = Some(count);
+        Some(count)
+    }
+
+    fn reset(&mut self) {
+        self.window.clear();
+        self.last = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.period
+    }
+
+    fn is_ready(&self) -> bool {
+        self.last.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "SinglePrints"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+
+    fn c(high: f64, low: f64) -> Candle {
+        Candle::new_unchecked(
+            f64::midpoint(high, low),
+            high,
+            low,
+            f64::midpoint(high, low),
+            1_000.0,
+            0,
+        )
+    }
+
+    #[test]
+    fn rejects_zero_params() {
+        assert!(matches!(SinglePrints::new(0, 24), Err(Error::PeriodZero)));
+        assert!(matches!(SinglePrints::new(20, 0), Err(Error::PeriodZero)));
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let s = SinglePrints::new(20, 24).unwrap();
+        assert_eq!(s.params(), (20, 24));
+        assert_eq!(s.warmup_period(), 20);
+        assert_eq!(s.name(), "SinglePrints");
+        assert!(!s.is_ready());
+        assert_eq!(s.value(), None);
+    }
+
+    #[test]
+    fn first_emission_at_warmup_period() {
+        let mut s = SinglePrints::new(4, 8).unwrap();
+        let candles: Vec<Candle> = (0..6)
+            .map(|i| c(101.0 + f64::from(i), 99.0 + f64::from(i)))
+            .collect();
+        let out = s.batch(&candles);
+        for v in out.iter().take(3) {
+            assert!(v.is_none());
+        }
+        assert!(out[3].is_some());
+    }
+
+    #[test]
+    fn flat_range_has_no_single_prints() {
+        // Every bar covers the same single price -> zero span -> 0.
+        let mut s = SinglePrints::new(4, 8).unwrap();
+        let last = s
+            .batch(&[c(100.0, 100.0); 6])
+            .into_iter()
+            .flatten()
+            .last()
+            .unwrap();
+        assert_eq!(last, 0.0);
+    }
+
+    #[test]
+    fn ramp_has_many_single_prints() {
+        // A one-directional ramp visits most levels exactly once.
+        let mut s = SinglePrints::new(10, 24).unwrap();
+        let candles: Vec<Candle> = (0..10)
+            .map(|i| c(100.5 + f64::from(i), 99.5 + f64::from(i)))
+            .collect();
+        let last = s.batch(&candles).into_iter().flatten().last().unwrap();
+        assert!(
+            last > 0.0,
+            "a ramp should produce single prints, got {last}"
+        );
+    }
+
+    #[test]
+    fn output_non_negative() {
+        let mut s = SinglePrints::new(14, 24).unwrap();
+        for v in s
+            .batch(
+                &(0..60)
+                    .map(|i| c(110.0 + (f64::from(i) * 0.3).sin() * 8.0, 90.0))
+                    .collect::<Vec<_>>(),
+            )
+            .into_iter()
+            .flatten()
+        {
+            assert!(v >= 0.0);
+        }
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut s = SinglePrints::new(4, 8).unwrap();
+        s.batch(
+            &(0..6)
+                .map(|i| c(101.0 + f64::from(i), 99.0 + f64::from(i)))
+                .collect::<Vec<_>>(),
+        );
+        assert!(s.is_ready());
+        s.reset();
+        assert!(!s.is_ready());
+        assert_eq!(s.value(), None);
+        assert_eq!(s.update(c(101.0, 99.0)), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..80)
+            .map(|i| c(110.0 + (f64::from(i) * 0.25).sin() * 9.0, 90.0))
+            .collect();
+        let batch = SinglePrints::new(20, 24).unwrap().batch(&candles);
+        let mut b = SinglePrints::new(20, 24).unwrap();
+        let streamed: Vec<_> = candles.iter().map(|x| b.update(*x)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

crates/wickra-core/src/lib.rs

@@ -72,36 +72,38 @@ pub use indicators::{
     ChaikinVolatility, ChandeKrollStop, ChandeKrollStopOutput, ChandelierExit,
     ChandelierExitOutput, ChoppinessIndex, ClassicPivots, ClassicPivotsOutput, CloseVsOpen,
     ClosingMarubozu, Cmo, CoefficientOfVariation, Cointegration, CointegrationOutput,
-    ConcealingBabySwallow, ConditionalValueAtRisk, ConnorsRsi, Coppock, CorrelationTrendIndicator,
-    Counterattack, Crab, CumulativeVolumeDelta, CumulativeVolumeIndex, CupAndHandle,
-    CyberneticCycle, Cypher, DayOfWeekProfile, DayOfWeekProfileOutput, Decycler,
-    DecyclerOscillator, Dema, DemandIndex, DemarkPivots, DemarkPivotsOutput, DepthSlope,
-    DerivativeOscillator, DetrendedStdDev, DisparityIndex, DistanceSsd, Doji, DojiStar, Donchian,
-    DonchianOutput, DonchianStop, DonchianStopOutput, DoubleBollinger, DoubleBollingerOutput,
-    DoubleTopBottom, DownsideGapThreeMethods, Dpo, DragonflyDoji, DrawdownDuration, DumplingTop,
-    Dx, DynamicMomentumIndex, EaseOfMovement, EffectiveSpread, EhlersStochastic, Ehma,
-    ElderImpulse, ElderRay, ElderRayOutput, ElderSafeZone, ElderSafeZoneOutput, Ema,
-    EmpiricalModeDecomposition, Engulfing, Equivolume, EquivolumeOutput, EvenBetterSinewave,
-    EveningDojiStar, Evwma, EwmaVolatility, Expectancy, FallingThreeMethods, Fama, FibArcs,
-    FibArcsOutput, FibChannel, FibChannelOutput, FibConfluence, FibConfluenceOutput, FibExtension,
-    FibExtensionOutput, FibFan, FibFanOutput, FibProjection, FibProjectionOutput, FibRetracement,
-    FibRetracementOutput, FibTimeZones, FibTimeZonesOutput, FibonacciPivots, FibonacciPivotsOutput,
-    FisherRsi, FisherTransform, FlagPennant, Footprint, FootprintOutput, ForceIndex,
-    FractalChaosBands, FractalChaosBandsOutput, Frama, FryPanBottom, FundingBasis, FundingRate,
-    FundingRateMean, FundingRateZScore, GainLossRatio, GapSideBySideWhite, Garch11,
-    GarmanKlassVolatility, Gartley, GatorOscillator, GatorOscillatorOutput, GeneralizedDema,
-    GeometricMa, GoldenPocket, GoldenPocketOutput, GrangerCausality, GravestoneDoji, Hammer,
-    HangingMan, Harami, HaramiCross, HasbrouckInformationShare, HeadAndShoulders, HeikinAshi,
-    HeikinAshiOscillator, HeikinAshiOutput, HiLoActivator, HighLowIndex, HighLowRange, HighWave,
-    HighpassFilter, Hikkake, HikkakeModified, HilbertDominantCycle, HistoricalVolatility, Hma,
-    HoltWinters, HomingPigeon, HtDcPhase, HtPhasor, HtPhasorOutput, HtTrendMode, HurstChannel,
-    HurstChannelOutput, HurstExponent, Ichimoku, IchimokuOutput, IdenticalThreeCrows, InNeck,
-    Inertia, InformationRatio, InitialBalance, InitialBalanceOutput, InstantaneousTrendline,
-    IntradayIntensity, IntradayMomentumIndex, IntradayVolatilityProfile,
-    IntradayVolatilityProfileOutput, InverseFisherTransform, InvertedHammer, JarqueBera, Jma,
-    JumpIndicator, KagiBars, KalmanHedgeRatio, KalmanHedgeRatioOutput, Kama, KaseDevStop,
-    KaseDevStopOutput, KasePermissionStochastic, KasePermissionStochasticOutput, KellyCriterion,
-    Keltner, KeltnerOutput, KendallTau, Kicking, KickingByLength, Kst, KstOutput, Kurtosis, Kvo,
+    CompositeProfile, CompositeProfileOutput, ConcealingBabySwallow, ConditionalValueAtRisk,
+    ConnorsRsi, Coppock, CorrelationTrendIndicator, Counterattack, Crab, CumulativeVolumeDelta,
+    CumulativeVolumeIndex, CupAndHandle, CyberneticCycle, Cypher, DayOfWeekProfile,
+    DayOfWeekProfileOutput, Decycler, DecyclerOscillator, Dema, DemandIndex, DemarkPivots,
+    DemarkPivotsOutput, DepthSlope, DerivativeOscillator, DetrendedStdDev, DisparityIndex,
+    DistanceSsd, Doji, DojiStar, Donchian, DonchianOutput, DonchianStop, DonchianStopOutput,
+    DoubleBollinger, DoubleBollingerOutput, DoubleTopBottom, DownsideGapThreeMethods, Dpo,
+    DragonflyDoji, DrawdownDuration, DumplingTop, Dx, DynamicMomentumIndex, EaseOfMovement,
+    EffectiveSpread, EhlersStochastic, Ehma, ElderImpulse, ElderRay, ElderRayOutput, ElderSafeZone,
+    ElderSafeZoneOutput, Ema, EmpiricalModeDecomposition, Engulfing, Equivolume, EquivolumeOutput,
+    EstimatedLeverageRatio, EvenBetterSinewave, EveningDojiStar, Evwma, EwmaVolatility, Expectancy,
+    FallingThreeMethods, Fama, FibArcs, FibArcsOutput, FibChannel, FibChannelOutput, FibConfluence,
+    FibConfluenceOutput, FibExtension, FibExtensionOutput, FibFan, FibFanOutput, FibProjection,
+    FibProjectionOutput, FibRetracement, FibRetracementOutput, FibTimeZones, FibTimeZonesOutput,
+    FibonacciPivots, FibonacciPivotsOutput, FisherRsi, FisherTransform, FlagPennant, Footprint,
+    FootprintOutput, ForceIndex, FractalChaosBands, FractalChaosBandsOutput, Frama, FryPanBottom,
+    FundingBasis, FundingImpliedApr, FundingRate, FundingRateMean, FundingRateZScore,
+    GainLossRatio, GapSideBySideWhite, Garch11, GarmanKlassVolatility, Gartley, GatorOscillator,
+    GatorOscillatorOutput, GeneralizedDema, GeometricMa, GoldenPocket, GoldenPocketOutput,
+    GrangerCausality, GravestoneDoji, Hammer, HangingMan, Harami, HaramiCross,
+    HasbrouckInformationShare, HeadAndShoulders, HeikinAshi, HeikinAshiOscillator,
+    HeikinAshiOutput, HiLoActivator, HighLowIndex, HighLowRange, HighLowVolumeNodes,
+    HighLowVolumeNodesOutput, HighWave, HighpassFilter, Hikkake, HikkakeModified,
+    HilbertDominantCycle, HistoricalVolatility, Hma, HoltWinters, HomingPigeon, HtDcPhase,
+    HtPhasor, HtPhasorOutput, HtTrendMode, HurstChannel, HurstChannelOutput, HurstExponent,
+    Ichimoku, IchimokuOutput, IdenticalThreeCrows, InNeck, Inertia, InformationRatio,
+    InitialBalance, InitialBalanceOutput, InstantaneousTrendline, IntradayIntensity,
+    IntradayMomentumIndex, IntradayVolatilityProfile, IntradayVolatilityProfileOutput,
+    InverseFisherTransform, InvertedHammer, JarqueBera, Jma, JumpIndicator, KagiBars,
+    KalmanHedgeRatio, KalmanHedgeRatioOutput, Kama, KaseDevStop, KaseDevStopOutput,
+    KasePermissionStochastic, KasePermissionStochasticOutput, KellyCriterion, Keltner,
+    KeltnerOutput, KendallTau, Kicking, KickingByLength, Kst, KstOutput, Kurtosis, Kvo,
     KylesLambda, LadderBottom, LaguerreRsi, LeadLagCrossCorrelation, LeadLagCrossCorrelationOutput,
     LinRegAngle, LinRegChannel, LinRegChannelOutput, LinRegIntercept, LinRegSlope,
     LinearRegression, LiquidationFeatures, LiquidationFeaturesOutput, LogReturn, LongLeggedDoji,
@@ -111,46 +113,47 @@ pub use indicators::{
     McGinleyDynamic, MedianAbsoluteDeviation, MedianChannel, MedianChannelOutput, MedianMa,
     MedianPrice, Mfi, Microprice, MidPoint, MidPrice, MinusDi, MinusDm, ModifiedMaStop,
     ModifiedMaStopOutput, Mom, MorningDojiStar, MorningEveningStar, MurreyMathLines,
-    MurreyMathLinesOutput, Natr, NewHighsNewLows, NewPriceLines, Nrtr, NrtrOutput, Nvi,
-    OIPriceDivergence, OIWeighted, Obv, OmegaRatio, OnNeck, OpenInterestDelta, OpeningMarubozu,
-    OpeningRange, OpeningRangeOutput, OrderBookImbalanceFull, OrderBookImbalanceTop1,
-    OrderBookImbalanceTopN, OrderFlowImbalance, OuHalfLife, OvernightGap, OvernightIntradayReturn,
-    OvernightIntradayReturnOutput, PainIndex, PairSpreadZScore, PairwiseBeta, ParkinsonVolatility,
-    PearsonCorrelation, PercentAboveMa, PercentB, PercentageTrailingStop, Pgo, PiercingDarkCloud,
-    Pin, PivotReversal, PlusDi, PlusDm, Pmo, PointAndFigureBars, PolarizedFractalEfficiency, Ppo,
-    PpoHistogram, ProfitFactor, ProjectionBands, ProjectionBandsOutput, ProjectionOscillator, Psar,
-    Pvi, Qqe, QqeOutput, Qstick, QuartileBands, QuartileBandsOutput, QuotedSpread, RSquared,
-    RealizedSpread, RealizedVolatility, RecoveryFactor, RectangleRange, Reflex, RegimeLabel,
-    RelativeStrengthAB, RelativeStrengthOutput, RenkoBars, RenkoTrailingStop, RickshawMan,
-    RisingThreeMethods, Rmi, Roc, Rocp, Rocr, Rocr100, RogersSatchellVolatility, RollMeasure,
-    RollingCorrelation, RollingCovariance, RollingIqr, RollingMinMaxScaler, RollingPercentileRank,
-    RollingQuantile, RollingVwap, RoofingFilter, Rsi, Rsx, Rvi, RviVolatility, Rwi, RwiOutput,
-    SampleEntropy, SarExt, SeasonalZScore, SeparatingLines, SessionHighLow, SessionHighLowOutput,
-    SessionRange, SessionRangeOutput, SessionVwap, ShannonEntropy, Shark, SharpeRatio,
-    ShootingStar, ShortLine, SignedVolume, SineWave, SineWeightedMa, Skewness, Sma, Smi, Smma,
-    SmoothedHeikinAshi, SmoothedHeikinAshiOutput, SortinoRatio, SpearmanCorrelation, SpinningTop,
-    SpreadAr1Coefficient, SpreadBollingerBands, SpreadBollingerBandsOutput, SpreadHurst,
-    StalledPattern, StandardError, StandardErrorBands, StandardErrorBandsOutput, StarcBands,
-    StarcBandsOutput, Stc, StdDev, StepTrailingStop, StickSandwich, StochRsi, Stochastic,
-    StochasticCci, StochasticOutput, SuperSmoother, SuperTrend, SuperTrendOutput,
-    TakerBuySellRatio, Takuri, TasukiGap, TdCamouflage, TdClop, TdClopwin, TdCombo, TdCountdown,
-    TdDWave, TdDeMarker, TdDifferential, TdLines, TdLinesOutput, TdMovingAverage,
-    TdMovingAverageOutput, TdOpen, TdPressure, TdPropulsion, TdRangeProjection,
-    TdRangeProjectionOutput, TdRei, TdRiskLevel, TdRiskLevelOutput, TdSequential,
-    TdSequentialOutput, TdSetup, TdTrap, Tema, TermStructureBasis, ThreeDrives, ThreeInside,
-    ThreeLineBreak, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth,
-    Thrusting, TickIndex, Tii, TimeBasedStop, TimeOfDayReturnProfile, TimeOfDayReturnProfileOutput,
-    TowerTopBottom, TpoProfile, TpoProfileOutput, TradeImbalance, TradeSignAutocorrelation,
-    TradeVolumeIndex, TrendLabel, TrendStrengthIndex, Trendflex, TreynorRatio, Triangle, Trima,
-    Trin, TripleTopBottom, Tristar, Trix, TrueRange, Tsf, TsfOscillator, Tsi, Tsv, TtmSqueeze,
-    TtmSqueezeOutput, TtmTrend, TurnOfMonth, Tweezer, TwiggsMoneyFlow, TwoCrows, TypicalPrice,
-    UlcerIndex, UltimateOscillator, UniqueThreeRiver, UniversalOscillator, UpDownVolumeRatio,
-    UpsideGapThreeMethods, UpsideGapTwoCrows, ValueArea, ValueAreaOutput, ValueAtRisk, Variance,
-    VarianceRatio, VerticalHorizontalFilter, Vidya, VolatilityCone, VolatilityConeOutput,
-    VolatilityOfVolatility, VolatilityRatio, VoltyStop, VolumeByTimeProfile,
-    VolumeByTimeProfileOutput, VolumeOscillator, VolumePriceTrend, VolumeProfile,
-    VolumeProfileOutput, VolumeRsi, VolumeWeightedMacd, VolumeWeightedMacdOutput, VolumeWeightedSr,
-    VolumeWeightedSrOutput, Vortex, VortexOutput, Vpin, Vwap, VwapStdDevBands,
+    MurreyMathLinesOutput, NakedPoc, Natr, NewHighsNewLows, NewPriceLines, Nrtr, NrtrOutput, Nvi,
+    OIPriceDivergence, OIWeighted, Obv, OiToVolumeRatio, OmegaRatio, OnNeck, OpenInterestDelta,
+    OpenInterestMomentum, OpeningMarubozu, OpeningRange, OpeningRangeOutput,
+    OrderBookImbalanceFull, OrderBookImbalanceTop1, OrderBookImbalanceTopN, OrderFlowImbalance,
+    OuHalfLife, OvernightGap, OvernightIntradayReturn, OvernightIntradayReturnOutput, PainIndex,
+    PairSpreadZScore, PairwiseBeta, ParkinsonVolatility, PearsonCorrelation, PercentAboveMa,
+    PercentB, PercentageTrailingStop, PerpetualPremiumIndex, Pgo, PiercingDarkCloud, Pin,
+    PivotReversal, PlusDi, PlusDm, Pmo, PointAndFigureBars, PolarizedFractalEfficiency, Ppo,
+    PpoHistogram, ProfileShape, ProfitFactor, ProjectionBands, ProjectionBandsOutput,
+    ProjectionOscillator, Psar, Pvi, Qqe, QqeOutput, Qstick, QuartileBands, QuartileBandsOutput,
+    QuotedSpread, RSquared, RealizedSpread, RealizedVolatility, RecoveryFactor, RectangleRange,
+    Reflex, RegimeLabel, RelativeStrengthAB, RelativeStrengthOutput, RenkoBars, RenkoTrailingStop,
+    RickshawMan, RisingThreeMethods, Rmi, Roc, Rocp, Rocr, Rocr100, RogersSatchellVolatility,
+    RollMeasure, RollingCorrelation, RollingCovariance, RollingIqr, RollingMinMaxScaler,
+    RollingPercentileRank, RollingQuantile, RollingVwap, RoofingFilter, Rsi, Rsx, Rvi,
+    RviVolatility, Rwi, RwiOutput, SampleEntropy, SarExt, SeasonalZScore, SeparatingLines,
+    SessionHighLow, SessionHighLowOutput, SessionRange, SessionRangeOutput, SessionVwap,
+    ShannonEntropy, Shark, SharpeRatio, ShootingStar, ShortLine, SignedVolume, SineWave,
+    SineWeightedMa, SinglePrints, Skewness, Sma, Smi, Smma, SmoothedHeikinAshi,
+    SmoothedHeikinAshiOutput, SortinoRatio, SpearmanCorrelation, SpinningTop, SpreadAr1Coefficient,
+    SpreadBollingerBands, SpreadBollingerBandsOutput, SpreadHurst, StalledPattern, StandardError,
+    StandardErrorBands, StandardErrorBandsOutput, StarcBands, StarcBandsOutput, Stc, StdDev,
+    StepTrailingStop, StickSandwich, StochRsi, Stochastic, StochasticCci, StochasticOutput,
+    SuperSmoother, SuperTrend, SuperTrendOutput, TakerBuySellRatio, Takuri, TasukiGap,
+    TdCamouflage, TdClop, TdClopwin, TdCombo, TdCountdown, TdDWave, TdDeMarker, TdDifferential,
+    TdLines, TdLinesOutput, TdMovingAverage, TdMovingAverageOutput, TdOpen, TdPressure,
+    TdPropulsion, TdRangeProjection, TdRangeProjectionOutput, TdRei, TdRiskLevel,
+    TdRiskLevelOutput, TdSequential, TdSequentialOutput, TdSetup, TdTrap, Tema, TermStructureBasis,
+    ThreeDrives, ThreeInside, ThreeLineBreak, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows,
+    ThreeStarsInSouth, Thrusting, TickIndex, Tii, TimeBasedStop, TimeOfDayReturnProfile,
+    TimeOfDayReturnProfileOutput, TowerTopBottom, TpoProfile, TpoProfileOutput, TradeImbalance,
+    TradeSignAutocorrelation, TradeVolumeIndex, TrendLabel, TrendStrengthIndex, Trendflex,
+    TreynorRatio, Triangle, Trima, Trin, TripleTopBottom, Tristar, Trix, TrueRange, Tsf,
+    TsfOscillator, Tsi, Tsv, TtmSqueeze, TtmSqueezeOutput, TtmTrend, TurnOfMonth, Tweezer,
+    TwiggsMoneyFlow, TwoCrows, TypicalPrice, UlcerIndex, UltimateOscillator, UniqueThreeRiver,
+    UniversalOscillator, UpDownVolumeRatio, UpsideGapThreeMethods, UpsideGapTwoCrows, ValueArea,
+    ValueAreaOutput, ValueAtRisk, Variance, VarianceRatio, VerticalHorizontalFilter, Vidya,
+    VolatilityCone, VolatilityConeOutput, VolatilityOfVolatility, VolatilityRatio, VoltyStop,
+    VolumeByTimeProfile, VolumeByTimeProfileOutput, VolumeOscillator, VolumePriceTrend,
+    VolumeProfile, VolumeProfileOutput, VolumeRsi, VolumeWeightedMacd, VolumeWeightedMacdOutput,
+    VolumeWeightedSr, VolumeWeightedSrOutput, Vortex, VortexOutput, Vpin, Vwap, VwapStdDevBands,
     VwapStdDevBandsOutput, Vwma, Vzo, Wad, WavePm, WaveTrend, WaveTrendOutput, Wedge,
     WeightedClose, WickRatio, WilliamsFractals, WilliamsFractalsOutput, WilliamsR, WinRate, Wma,
     WoodiePivots, WoodiePivotsOutput, YangZhangVolatility, YoyoExit, ZScore, ZeroLagMacd,

docs/README.md

@@ -8,7 +8,7 @@ That includes:
   [Python](https://docs.wickra.org/Quickstart-Python),
   [Node](https://docs.wickra.org/Quickstart-Node), and
   [WASM](https://docs.wickra.org/Quickstart-WASM).
-- A per-indicator deep dive for every one of the **488 indicators** across
+- A per-indicator deep dive for every one of the **498 indicators** across
   the sixteen families (Moving Averages, Momentum Oscillators, Trend &
   Directional, Price Oscillators, Volatility & Bands, Bands & Channels,
   Trailing Stops, Volume, Price Statistics, Ehlers / Cycle DSP, Pivots &

examples/node/package-lock.json

@@ -17,7 +17,7 @@
     },
     "../../bindings/node": {
       "name": "wickra",
-      "version": "0.7.0",
+      "version": "0.7.2",
       "license": "MIT OR Apache-2.0",
       "devDependencies": {
         "@napi-rs/cli": "^2.18.0"
@@ -26,12 +26,12 @@
         "node": ">= 18"
       },
       "optionalDependencies": {
-        "wickra-darwin-arm64": "0.7.0",
-        "wickra-darwin-x64": "0.7.0",
-        "wickra-linux-arm64-gnu": "0.7.0",
-        "wickra-linux-x64-gnu": "0.7.0",
-        "wickra-win32-arm64-msvc": "0.7.0",
-        "wickra-win32-x64-msvc": "0.7.0"
+        "wickra-darwin-arm64": "0.7.2",
+        "wickra-darwin-x64": "0.7.2",
+        "wickra-linux-arm64-gnu": "0.7.2",
+        "wickra-linux-x64-gnu": "0.7.2",
+        "wickra-win32-arm64-msvc": "0.7.2",
+        "wickra-win32-x64-msvc": "0.7.2"
       }
     },
     "node_modules/wickra": {

fuzz/fuzz_targets/indicator_update_candle.rs

@@ -22,7 +22,7 @@
 //! WeightedClose.
 
 use libfuzzer_sys::fuzz_target;
-use wickra_core::{AbandonedBaby, Abcd, AccelerationBands, AcceleratorOscillator, AdOscillator, AdaptiveCci, Adl, AdvanceBlock, Adx, Adxr, Alligator, AnchoredVwap, AndrewsPitchfork, Aroon, AroonOscillator, Atr, AtrBands, AtrRatchet, AtrTrailingStop, AutoFib, AverageDailyRange, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, Bat, BatchExt, BeltHold, BetterVolume, BodySizePct, Breakaway, Butterfly, Camarilla, Candle, CandleVolume, Cci, CentralPivotRange, ChaikinMoneyFlow, ChaikinOscillator, ChaikinVolatility, ChandeKrollStop, ChandelierExit, ChoppinessIndex, ClassicPivots, CloseVsOpen, ClosingMarubozu, ConcealingBabySwallow, Counterattack, Crab, CupAndHandle, Cypher, DayOfWeekProfile, DemandIndex, DemarkPivots, Doji, DojiStar, Donchian, DonchianStop, DoubleTopBottom, DownsideGapThreeMethods, DragonflyDoji, DumplingTop, Dx, EaseOfMovement, ElderRay, ElderSafeZone, Engulfing, Equivolume, EveningDojiStar, Evwma, FallingThreeMethods, FibArcs, FibChannel, FibConfluence, FibExtension, FibFan, FibProjection, FibRetracement, FibTimeZones, FibonacciPivots, FlagPennant, ForceIndex, FractalChaosBands, FryPanBottom, GapSideBySideWhite, GarmanKlassVolatility, Gartley, GatorOscillator, GoldenPocket, GravestoneDoji, Hammer, HangingMan, Harami, HaramiCross, HeadAndShoulders, HeikinAshi, HeikinAshiOscillator, HiLoActivator, HighLowRange, HighWave, Hikkake, HikkakeModified, HomingPigeon, HurstChannel, Ichimoku, IdenticalThreeCrows, InNeck, Indicator, Inertia, InitialBalance, IntradayIntensity, IntradayMomentumIndex, IntradayVolatilityProfile, InvertedHammer, KaseDevStop, KasePermissionStochastic, Keltner, Kicking, KickingByLength, Kvo, LadderBottom, LongLeggedDoji, LongLine, MarketFacilitationIndex, Marubozu, MassIndex, MatHold, MatchingLow, AvgPrice, MedianPrice, Mfi, MidPrice, MinusDi, MinusDm, ModifiedMaStop, MorningDojiStar, MorningEveningStar, MurreyMathLines, Natr, NewPriceLines, Nrtr, Nvi, Obv, OnNeck, OpeningMarubozu, OpeningRange, OvernightGap, OvernightIntradayReturn, ParkinsonVolatility, Pgo, PiercingDarkCloud, PivotReversal, PlusDi, PlusDm, ProjectionBands, ProjectionOscillator, Psar, Pvi, Qstick, RectangleRange, RickshawMan, RisingThreeMethods, RogersSatchellVolatility, RollingVwap, Rvi, Rwi, SarExt, SeasonalZScore, SeparatingLines, SessionHighLow, SessionRange, SessionVwap, Shark, ShootingStar, ShortLine, Smi, SmoothedHeikinAshi, SpinningTop, StalledPattern, StarcBands, StickSandwich, Stochastic, StochasticCci, SuperTrend, Takuri, TasukiGap, TdCamouflage, TdClop, TdClopwin, TdCombo, TdCountdown, TdDWave, TdDeMarker, TdDifferential, TdLines, TdMovingAverage, TdOpen, TdPressure, TdPropulsion, TdRangeProjection, TdRei, TdRiskLevel, TdSequential, TdSetup, TdTrap, ThreeDrives, ThreeInside, ThreeLineBreak, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TimeBasedStop, TimeOfDayReturnProfile, TowerTopBottom, TpoProfile, TradeVolumeIndex, Triangle, TripleTopBottom, Tristar, TrueRange, Tsv, TtmSqueeze, TtmTrend, TurnOfMonth, Tweezer, TwiggsMoneyFlow, TwoCrows, TypicalPrice, UltimateOscillator, UniqueThreeRiver, UpsideGapThreeMethods, UpsideGapTwoCrows, ValueArea, VolatilityCone, VolatilityRatio, VoltyStop, VolumeByTimeProfile, VolumeOscillator, VolumePriceTrend, VolumeProfile, VolumeRsi, VolumeWeightedMacd, VolumeWeightedSr, Vortex, Vwap, VwapStdDevBands, Vwma, Vzo, WaveTrend, Wedge, WeightedClose, WickRatio, Wad, WilliamsFractals, WilliamsR, WoodiePivots, YangZhangVolatility, YoyoExit, ZigZag};
+use wickra_core::{AbandonedBaby, Abcd, AccelerationBands, AcceleratorOscillator, AdOscillator, AdaptiveCci, Adl, AdvanceBlock, Adx, Adxr, Alligator, AnchoredVwap, AndrewsPitchfork, Aroon, AroonOscillator, Atr, AtrBands, AtrRatchet, AtrTrailingStop, AutoFib, AverageDailyRange, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, Bat, BatchExt, BeltHold, BetterVolume, BodySizePct, Breakaway, Butterfly, Camarilla, Candle, CandleVolume, Cci, CentralPivotRange, ChaikinMoneyFlow, ChaikinOscillator, ChaikinVolatility, ChandeKrollStop, ChandelierExit, ChoppinessIndex, ClassicPivots, CloseVsOpen, ClosingMarubozu, CompositeProfile, ConcealingBabySwallow, Counterattack, Crab, CupAndHandle, Cypher, DayOfWeekProfile, DemandIndex, DemarkPivots, Doji, DojiStar, Donchian, DonchianStop, DoubleTopBottom, DownsideGapThreeMethods, DragonflyDoji, DumplingTop, Dx, EaseOfMovement, ElderRay, ElderSafeZone, Engulfing, Equivolume, EveningDojiStar, Evwma, FallingThreeMethods, FibArcs, FibChannel, FibConfluence, FibExtension, FibFan, FibProjection, FibRetracement, FibTimeZones, FibonacciPivots, FlagPennant, ForceIndex, FractalChaosBands, FryPanBottom, GapSideBySideWhite, GarmanKlassVolatility, Gartley, GatorOscillator, GoldenPocket, GravestoneDoji, Hammer, HangingMan, Harami, HaramiCross, HeadAndShoulders, HeikinAshi, HeikinAshiOscillator, HiLoActivator, HighLowRange, HighLowVolumeNodes, HighWave, Hikkake, HikkakeModified, HomingPigeon, HurstChannel, Ichimoku, IdenticalThreeCrows, InNeck, Indicator, Inertia, InitialBalance, IntradayIntensity, IntradayMomentumIndex, IntradayVolatilityProfile, InvertedHammer, KaseDevStop, KasePermissionStochastic, Keltner, Kicking, KickingByLength, Kvo, LadderBottom, LongLeggedDoji, LongLine, MarketFacilitationIndex, Marubozu, MassIndex, MatHold, MatchingLow, AvgPrice, MedianPrice, Mfi, MidPrice, MinusDi, MinusDm, ModifiedMaStop, MorningDojiStar, MorningEveningStar, MurreyMathLines, NakedPoc, Natr, NewPriceLines, Nrtr, Nvi, Obv, OnNeck, OpeningMarubozu, OpeningRange, OvernightGap, OvernightIntradayReturn, ParkinsonVolatility, Pgo, PiercingDarkCloud, PivotReversal, PlusDi, PlusDm, ProfileShape, ProjectionBands, ProjectionOscillator, Psar, Pvi, Qstick, RectangleRange, RickshawMan, RisingThreeMethods, RogersSatchellVolatility, RollingVwap, Rvi, Rwi, SarExt, SeasonalZScore, SeparatingLines, SessionHighLow, SessionRange, SessionVwap, Shark, ShootingStar, ShortLine, SinglePrints, Smi, SmoothedHeikinAshi, SpinningTop, StalledPattern, StarcBands, StickSandwich, Stochastic, StochasticCci, SuperTrend, Takuri, TasukiGap, TdCamouflage, TdClop, TdClopwin, TdCombo, TdCountdown, TdDWave, TdDeMarker, TdDifferential, TdLines, TdMovingAverage, TdOpen, TdPressure, TdPropulsion, TdRangeProjection, TdRei, TdRiskLevel, TdSequential, TdSetup, TdTrap, ThreeDrives, ThreeInside, ThreeLineBreak, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, TimeBasedStop, TimeOfDayReturnProfile, TowerTopBottom, TpoProfile, TradeVolumeIndex, Triangle, TripleTopBottom, Tristar, TrueRange, Tsv, TtmSqueeze, TtmTrend, TurnOfMonth, Tweezer, TwiggsMoneyFlow, TwoCrows, TypicalPrice, UltimateOscillator, UniqueThreeRiver, UpsideGapThreeMethods, UpsideGapTwoCrows, ValueArea, VolatilityCone, VolatilityRatio, VoltyStop, VolumeByTimeProfile, VolumeOscillator, VolumePriceTrend, VolumeProfile, VolumeRsi, VolumeWeightedMacd, VolumeWeightedSr, Vortex, Vwap, VwapStdDevBands, Vwma, Vzo, WaveTrend, Wedge, WeightedClose, WickRatio, Wad, WilliamsFractals, WilliamsR, WoodiePivots, YangZhangVolatility, YoyoExit, ZigZag};
 
 /// Convert a flat `f64` stream into a `Vec<Candle>` by chunking it into
 /// `[open, high, low, close, volume]` groups. Tuples that fail OHLCV
@@ -188,6 +188,11 @@ fuzz_target!(|data: Vec<f64>| {
     }
 
     // --- Market Profile (multi-output) ---
+    drive(|| CompositeProfile::new(20, 24, 0.7).unwrap(), &candles);
+    drive(|| HighLowVolumeNodes::new(20, 24).unwrap(), &candles);
+    drive(|| NakedPoc::new(20, 24).unwrap(), &candles);
+    drive(|| SinglePrints::new(20, 24).unwrap(), &candles);
+    drive(|| ProfileShape::new(20, 24).unwrap(), &candles);
     drive(|| ValueArea::new(20, 50, 0.70).unwrap(), &candles);
     drive(|| VolumeProfile::new(20, 50).unwrap(), &candles);
     drive(|| TpoProfile::new(20, 50).unwrap(), &candles);

fuzz/fuzz_targets/indicator_update_derivatives.rs

@@ -10,11 +10,7 @@
 //! never panic, streaming or batched.
 
 use libfuzzer_sys::fuzz_target;
-use wickra_core::{
-    BatchExt, CalendarSpread, DerivativesTick, FundingBasis, FundingRate, FundingRateMean,
-    FundingRateZScore, Indicator, LiquidationFeatures, LongShortRatio, OIPriceDivergence,
-    OIWeighted, OpenInterestDelta, TakerBuySellRatio, TermStructureBasis,
-};
+use wickra_core::{BatchExt, CalendarSpread, DerivativesTick, EstimatedLeverageRatio, FundingBasis, FundingImpliedApr, FundingRate, FundingRateMean, FundingRateZScore, Indicator, LiquidationFeatures, LongShortRatio, OIPriceDivergence, OIWeighted, OiToVolumeRatio, OpenInterestDelta, OpenInterestMomentum, PerpetualPremiumIndex, TakerBuySellRatio, TermStructureBasis};
 
 #[inline(never)]
 fn drive<I>(make: impl Fn() -> I, ticks: &[DerivativesTick])
@@ -53,6 +49,11 @@ fuzz_target!(|data: &[u8]| {
     drive(TakerBuySellRatio::new, &ticks);
     drive(TermStructureBasis::new, &ticks);
     drive(CalendarSpread::new, &ticks);
+    drive(EstimatedLeverageRatio::new, &ticks);
+    drive(OiToVolumeRatio::new, &ticks);
+    drive(PerpetualPremiumIndex::new, &ticks);
+    drive(|| FundingImpliedApr::new(1095.0).unwrap(), &ticks);
+    drive(|| OpenInterestMomentum::new(14).unwrap(), &ticks);
 
     // LiquidationFeatures emits a struct, not an f64, so drive it directly.
     let mut liq = LiquidationFeatures::new();