@363045841yyt/klinechart-core 0.8.11-alpha.0 → 0.8.12

package/dist/chartTypes/renko.js

@@ -0,0 +1,207 @@
+import { KLineChartError } from '../errors';
+/** Compute true range for a bar against the prior close. */
+const trueRange = (bar, prevClose) => {
+    const hl = bar.high - bar.low;
+    if (prevClose === null)
+        return hl;
+    const hc = Math.abs(bar.high - prevClose);
+    const lc = Math.abs(bar.low - prevClose);
+    return Math.max(hl, hc, lc);
+};
+/**
+ * Build a Renko transform.
+ *
+ * The transform supports both `transform(input, config)` and `appendBar(bar)`.
+ * The config passed to `transform` is also captured for subsequent
+ * `appendBar` calls — so the typical flow is:
+ *
+ *     const r = createRenko()
+ *     const history = r.transform(historicalBars, { brickSize: 10 })
+ *     // ...later, as ticks arrive:
+ *     const newBricks = r.appendBar(liveBar)
+ */
+export function createRenko() {
+    let state = {
+        lastBrickClose: null,
+        lastDirection: null,
+        nextIndex: 0,
+        trWindow: [],
+        prevClose: null,
+        lastBrickSize: null,
+    };
+    let activeConfig = { brickSize: 1 };
+    /**
+     * Return the current effective brick size given the active config and the
+     * current ATR window. Returns `null` when ATR mode is enabled but the
+     * window hasn't filled yet (no bricks can form until we have a brick
+     * size).
+     */
+    const currentBrickSize = () => {
+        if (activeConfig.useATR) {
+            const period = activeConfig.useATR.period;
+            if (state.trWindow.length < period)
+                return null;
+            let sum = 0;
+            // Use only the most recent `period` entries — older history is
+            // not part of the rolling ATR (Wilder's smoothing is a separate
+            // discussion; we use the simple rolling mean which is the
+            // baseline TradingView ATR-Renko shows).
+            for (let i = state.trWindow.length - period; i < state.trWindow.length; i++) {
+                sum += state.trWindow[i] ?? 0;
+            }
+            return sum / period;
+        }
+        return activeConfig.brickSize ?? null;
+    };
+    /**
+     * Try to emit bricks from a single input bar. The bar's `close` is the
+     * trigger; we ignore intra-bar high/low for brick formation because Renko
+     * is canonically a *close-only* construction. (Using high/low works on
+     * tick data but creates phantom bricks on OHLC bars.)
+     */
+    const emitBricksFromBar = (bar, sourceIndex) => {
+        const out = [];
+        const brickSize = currentBrickSize();
+        if (brickSize === null || brickSize <= 0)
+            return out;
+        // Initialise the "last brick close" lazily on the first bar — we
+        // anchor it to the bar's close so the first non-trivial move starts
+        // brick formation. (Anchoring to `open` would mean the very first bar
+        // could itself form a brick, which differs from the convention.)
+        if (state.lastBrickClose === null) {
+            state.lastBrickClose = bar.close;
+            return out;
+        }
+        const close = bar.close;
+        let firstBrickInThisBar = true;
+        // Keep stepping bricks until the close no longer satisfies the
+        // threshold. Each iteration emits one brick and advances state.
+        // Loop bound: at most ceil(|close - lastBrickClose| / brickSize) — a
+        // hard upper bound prevents pathological infinite loops if brickSize
+        // becomes zero mid-iteration.
+        let safety = 0;
+        while (safety++ < 1_000_000) {
+            const last = state.lastBrickClose;
+            if (last === null)
+                break;
+            const diff = close - last;
+            // Continuation needs 1×, reversal needs 2×. First-ever brick uses 1×.
+            let upThreshold;
+            let downThreshold;
+            if (state.lastDirection === 'up') {
+                upThreshold = brickSize;
+                downThreshold = -2 * brickSize;
+            }
+            else if (state.lastDirection === 'down') {
+                upThreshold = 2 * brickSize;
+                downThreshold = -brickSize;
+            }
+            else {
+                upThreshold = brickSize;
+                downThreshold = -brickSize;
+            }
+            if (diff >= upThreshold) {
+                const newClose = last + brickSize;
+                out.push({
+                    timestamp: bar.timestamp,
+                    open: last,
+                    close: newClose,
+                    high: newClose,
+                    low: last,
+                    volume: firstBrickInThisBar ? bar.volume : 0,
+                    sourceBarIndexStart: sourceIndex,
+                    sourceBarIndexEnd: sourceIndex,
+                    meta: { direction: 'up', brickSize },
+                });
+                state.lastBrickClose = newClose;
+                state.lastDirection = 'up';
+                state.lastBrickSize = brickSize;
+                firstBrickInThisBar = false;
+                continue;
+            }
+            if (diff <= downThreshold) {
+                const newClose = last - brickSize;
+                out.push({
+                    timestamp: bar.timestamp,
+                    open: last,
+                    close: newClose,
+                    high: last,
+                    low: newClose,
+                    volume: firstBrickInThisBar ? bar.volume : 0,
+                    sourceBarIndexStart: sourceIndex,
+                    sourceBarIndexEnd: sourceIndex,
+                    meta: { direction: 'down', brickSize },
+                });
+                state.lastBrickClose = newClose;
+                state.lastDirection = 'down';
+                state.lastBrickSize = brickSize;
+                firstBrickInThisBar = false;
+                continue;
+            }
+            break;
+        }
+        return out;
+    };
+    const consumeBar = (bar) => {
+        const sourceIndex = state.nextIndex;
+        // Update TR window BEFORE checking brick formation so the first ATR
+        // window's worth of bars participate in brick sizing as soon as
+        // possible.
+        const tr = trueRange(bar, state.prevClose);
+        state.trWindow.push(tr);
+        // Cap the window growth to twice the period for memory bound;
+        // anything older is never read.
+        if (activeConfig.useATR) {
+            const period = activeConfig.useATR.period;
+            if (state.trWindow.length > period * 2) {
+                state.trWindow = state.trWindow.slice(state.trWindow.length - period);
+            }
+        }
+        else if (state.trWindow.length > 2048) {
+            // For non-ATR mode we don't need the window at all — clear it.
+            state.trWindow = [];
+        }
+        state.prevClose = bar.close;
+        const emitted = emitBricksFromBar(bar, sourceIndex);
+        state.nextIndex = sourceIndex + 1;
+        return emitted;
+    };
+    const resetState = () => {
+        state = {
+            lastBrickClose: null,
+            lastDirection: null,
+            nextIndex: 0,
+            trWindow: [],
+            prevClose: null,
+            lastBrickSize: null,
+        };
+    };
+    return {
+        typeId: 'renko',
+        transform(input, config) {
+            // Validate: at least one mode must be set with sane values.
+            if (!config.useATR && (config.brickSize === undefined || config.brickSize <= 0)) {
+                throw new KLineChartError('CHART_TYPE_CONFIG_INVALID', 'createRenko: config requires brickSize > 0 or useATR { period }');
+            }
+            if (config.useATR && config.useATR.period < 1) {
+                throw new KLineChartError('CHART_TYPE_CONFIG_INVALID', 'createRenko: useATR.period must be >= 1');
+            }
+            activeConfig = config;
+            resetState();
+            const out = [];
+            for (const bar of input) {
+                const fresh = consumeBar(bar);
+                for (const b of fresh)
+                    out.push(b);
+            }
+            return out;
+        },
+        appendBar(bar) {
+            return consumeBar(bar);
+        },
+        reset() {
+            resetState();
+        },
+    };
+}
+//# sourceMappingURL=renko.js.map

package/dist/chartTypes/renko.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renko.js","sourceRoot":"","sources":["../../src/chartTypes/renko.ts"],"names":[],"mappings":"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"}

package/dist/chartTypes/types.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Chart-type transformers — public type contract.
+ *
+ * A "chart type" in TradingView (Heikin Ashi, Renko, P&F, Range Bars, etc.) is
+ * a **data transform**, not a different renderer. Every output is still
+ * OHLCV-shaped, so the same candle renderer paints all of them. This package
+ * is therefore deliberately headless: rendering belongs to the
+ * Renderer/Scene layer (see `docs/ROADMAP.md` §0).
+ *
+ * Why this matters for the WebGPU path: because the output is OHLCV, the
+ * existing instanced-quad K-line vertex pipeline (see `docs/ROADMAP.md` §2.3)
+ * draws Heikin Ashi / Renko / P&F / Range Bars at the same throughput as raw
+ * candles — no new render path, no new shader.
+ *
+ * ## Two transforms in one interface — batch vs incremental
+ *
+ * Every transform here supports two modes:
+ *
+ *  - **Batch** (`transform`): pure function over an OHLCV slice. Re-derives the
+ *    output from scratch. Use this for chart loads / history scrolls.
+ *  - **Incremental** (`appendBar`): consume one live bar at a time, emit zero
+ *    or more output bars, and update internal state. Use this for streaming
+ *    quotes.
+ *
+ * Calling `appendBar` repeatedly over the same sequence must produce **bit-for-
+ * bit identical** output to a single `transform` over that sequence. The test
+ * suite enforces this with a randomised property test on a ≥30-bar input.
+ *
+ * ## A note on time semantics
+ *
+ * Renko, P&F and Range Bars all break the "one input bar = one output bar"
+ * assumption. We preserve provenance with `sourceBarIndexStart` /
+ * `sourceBarIndexEnd` so callers can map back to the source series for
+ * tooltips, x-axis labels, and event correlation. The `timestamp` on a
+ * derived bar is the timestamp of the source bar that **closed** it (i.e. the
+ * trigger).
+ */
+/** Standard OHLCV row. Timestamps are epoch milliseconds. */
+export interface OHLCV {
+    timestamp: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+/**
+ * One output bar from a chart-type transform. Extends `OHLCV` so it can flow
+ * through the same scale / renderer pipeline as raw candles.
+ *
+ * `sourceBarIndexStart` / `sourceBarIndexEnd` mark which input rows were
+ * aggregated into this output row (inclusive). For 1:1 transforms (Heikin
+ * Ashi) they are equal. For aggregating transforms (Renko, P&F, Range Bars)
+ * they describe a range of source rows. For "fanning" transforms — one input
+ * bar that produces multiple output bars (large-gap Renko, oversized Range
+ * bar) — every fanned-out output row shares the same start/end index.
+ */
+export interface TransformedBar extends OHLCV {
+    /** Lowest source index folded into this output bar (inclusive). */
+    sourceBarIndexStart: number;
+    /** Highest source index folded into this output bar (inclusive). */
+    sourceBarIndexEnd: number;
+    /**
+     * Transform-specific metadata. Marked `Readonly` so consumers can rely on
+     * structural sharing — a transform must never mutate metadata after
+     * emitting it.
+     */
+    meta?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Common shape for all chart-type transformers.
+ *
+ * `transform` is pure — it does NOT mutate `input` and (for stateful
+ * transforms) calling it resets internal state first so the result depends
+ * only on `input` + `config`.
+ *
+ * `appendBar` is incremental — it does mutate internal state. Calling
+ * `reset()` returns the transform to its initial state.
+ *
+ * `typeId` is a stable, human-readable identifier used by the scene/registry.
+ */
+export interface ChartTypeTransform<TConfig = unknown> {
+    readonly typeId: string;
+    transform(input: ReadonlyArray<OHLCV>, config: TConfig): ReadonlyArray<TransformedBar>;
+    /**
+     * Append one input bar and emit zero, one, or many output bars.
+     *
+     * Implementations that do not support incremental mode omit this method.
+     * For Heikin Ashi the output is always exactly one bar per call. For
+     * Renko / Range Bars / P&F the count can be 0..N depending on whether the
+     * new bar triggers brick/box formation.
+     */
+    appendBar?(input: OHLCV): ReadonlyArray<TransformedBar>;
+    /** Drop internal state. Idempotent. Safe to call on stateless transforms. */
+    reset?(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/chartTypes/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/chartTypes/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,6DAA6D;AAC7D,MAAM,WAAW,KAAK;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAe,SAAQ,KAAK;IACzC,mEAAmE;IACnE,mBAAmB,EAAE,MAAM,CAAA;IAC3B,oEAAoE;IACpE,iBAAiB,EAAE,MAAM,CAAA;IACzB;;;;OAIG;IACH,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAC3C;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,kBAAkB,CAAC,OAAO,GAAG,OAAO;IACjD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,SAAS,CAAC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,GAAG,aAAa,CAAC,cAAc,CAAC,CAAA;IACtF;;;;;;;OAOG;IACH,SAAS,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,CAAC,cAAc,CAAC,CAAA;IACvD,6EAA6E;IAC7E,KAAK,CAAC,IAAI,IAAI,CAAA;CACjB"}

package/dist/chartTypes/types.js

@@ -0,0 +1,39 @@
+/**
+ * Chart-type transformers — public type contract.
+ *
+ * A "chart type" in TradingView (Heikin Ashi, Renko, P&F, Range Bars, etc.) is
+ * a **data transform**, not a different renderer. Every output is still
+ * OHLCV-shaped, so the same candle renderer paints all of them. This package
+ * is therefore deliberately headless: rendering belongs to the
+ * Renderer/Scene layer (see `docs/ROADMAP.md` §0).
+ *
+ * Why this matters for the WebGPU path: because the output is OHLCV, the
+ * existing instanced-quad K-line vertex pipeline (see `docs/ROADMAP.md` §2.3)
+ * draws Heikin Ashi / Renko / P&F / Range Bars at the same throughput as raw
+ * candles — no new render path, no new shader.
+ *
+ * ## Two transforms in one interface — batch vs incremental
+ *
+ * Every transform here supports two modes:
+ *
+ *  - **Batch** (`transform`): pure function over an OHLCV slice. Re-derives the
+ *    output from scratch. Use this for chart loads / history scrolls.
+ *  - **Incremental** (`appendBar`): consume one live bar at a time, emit zero
+ *    or more output bars, and update internal state. Use this for streaming
+ *    quotes.
+ *
+ * Calling `appendBar` repeatedly over the same sequence must produce **bit-for-
+ * bit identical** output to a single `transform` over that sequence. The test
+ * suite enforces this with a randomised property test on a ≥30-bar input.
+ *
+ * ## A note on time semantics
+ *
+ * Renko, P&F and Range Bars all break the "one input bar = one output bar"
+ * assumption. We preserve provenance with `sourceBarIndexStart` /
+ * `sourceBarIndexEnd` so callers can map back to the source series for
+ * tooltips, x-axis labels, and event correlation. The `timestamp` on a
+ * derived bar is the timestamp of the source bar that **closed** it (i.e. the
+ * trigger).
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/chartTypes/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/chartTypes/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG"}

package/dist/components/anchoredVwap/computeAnchoredVwap.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Pure math: anchored VWAP + volume-weighted standard-deviation bands.
+ *
+ * Used by `createAnchoredVwapController` for the from-scratch path
+ * (`setBars`, `addAnchor`, `updateAnchor` when `barIndex` changes). The
+ * controller's incremental `appendBar` reuses the same formulas via
+ * running sums; the controller's tests pin equivalence between the two
+ * paths.
+ *
+ * Math summary (formal derivation in `docs/ROADMAP.md` §3):
+ *
+ *   typicalPrice(j) = (H[j] + L[j] + C[j]) / 3
+ *   vwp(j)          = typicalPrice(j) * V[j]
+ *   sumVwp(i)       = Σ_{j=a..i} vwp(j)
+ *   sumVol(i)       = Σ_{j=a..i} V[j]
+ *   AVWAP(i)        = sumVwp(i) / sumVol(i)               (when sumVol > 0)
+ *
+ *   ─── important subtlety ─────────────────────────────────────────────────
+ *   The standard-deviation bands MUST use the **prevailing** AVWAP(j) at
+ *   each bar j ∈ [a..i], NOT the final AVWAP(i). Naive implementations that
+ *   reuse the final mean understate the deviation early in the anchor and
+ *   overstate it late — the bands wind up visibly off-centre on long
+ *   anchors. The dedicated test
+ *   `computeAnchoredVwap.test.ts → "bands use prevailing AVWAP at j"` pins
+ *   this and would catch a regression to the wrong formula.
+ *
+ *   sqDev(j)        = (typicalPrice(j) - AVWAP(j))^2 * V[j]
+ *   sumSqDev(i)     = Σ_{j=a..i} sqDev(j)
+ *   variance(i)     = sumSqDev(i) / sumVol(i)
+ *   stdDev(i)       = sqrt(variance(i))
+ *   upper1(i)       = AVWAP(i) + stdDev(i)
+ *   lower1(i)       = AVWAP(i) - stdDev(i)
+ *   upper2(i)       = AVWAP(i) + 2 * stdDev(i)
+ *   lower2(i)       = AVWAP(i) - 2 * stdDev(i)
+ *
+ * Zero-volume handling:
+ *   - A bar with `volume === 0` contributes 0 to numerator, 0 to
+ *     denominator, and 0 to the squared-deviation sum. The cumulative
+ *     volume is unchanged.
+ *   - If the cumulative volume is still > 0 at this bar (i.e. there was a
+ *     prior non-zero bar) the AVWAP and bands **carry forward** the prior
+ *     values — they are still mathematically well-defined.
+ *   - If the cumulative volume is 0 (i.e. the anchor bar itself has
+ *     volume 0 and every subsequent bar so far has volume 0 too), the
+ *     point's `vwap` and band fields are `NaN`. The series still has an
+ *     entry for the bar — `barIndex` and `cumulativeVolume` are filled in.
+ */
+import type { AVWAPBar, AVWAPPoint } from './types';
+/**
+ * Compute the Anchored VWAP series for `bars`, anchored at
+ * `anchorIndex` (inclusive). Returns one `AVWAPPoint` per bar from
+ * `bars[anchorIndex]` through `bars[bars.length - 1]`.
+ *
+ * @param bars         the bar series; the anchor must lie inside it
+ * @param anchorIndex  0-based index of the anchor bar (must satisfy
+ *                     `0 <= anchorIndex < bars.length`)
+ * @param includeBands when `false`, the four band fields equal `vwap` and
+ *                     the (cheaper) one-pass cumulative-volume math is
+ *                     used. The second pass that drives the bands is
+ *                     skipped entirely.
+ *
+ * @throws RangeError when `anchorIndex` is out of range and `bars` is
+ *                    non-empty. An empty `bars` array returns `[]` even
+ *                    if `anchorIndex` would otherwise be invalid — this
+ *                    mirrors the "no data, no work" convention used by
+ *                    the volume-profile controller.
+ *
+ * @internal — building block used by the corresponding controller
+ *   factory. Reachable today via the top-level `@klinechart-quant/core`
+ *   barrel but **NOT part of the supported public API**. typedoc / api-
+ *   extractor hide it from generated docs. Prefer the controller
+ *   factory (e.g. `createVolumeProfileController`) for stable user code.
+ *   Closes API audit BLOCKER-002 (export * leakage taxonomy).
+ */
+export declare function computeAnchoredVwap(bars: ReadonlyArray<AVWAPBar>, anchorIndex: number, includeBands: boolean): ReadonlyArray<AVWAPPoint>;
+//# sourceMappingURL=computeAnchoredVwap.d.ts.map

package/dist/components/anchoredVwap/computeAnchoredVwap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeAnchoredVwap.d.ts","sourceRoot":"","sources":["../../../src/components/anchoredVwap/computeAnchoredVwap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGnD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,aAAa,CAAC,QAAQ,CAAC,EAC7B,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,OAAO,GACtB,aAAa,CAAC,UAAU,CAAC,CA4F3B"}

package/dist/components/anchoredVwap/computeAnchoredVwap.js

@@ -0,0 +1,155 @@
+/**
+ * Pure math: anchored VWAP + volume-weighted standard-deviation bands.
+ *
+ * Used by `createAnchoredVwapController` for the from-scratch path
+ * (`setBars`, `addAnchor`, `updateAnchor` when `barIndex` changes). The
+ * controller's incremental `appendBar` reuses the same formulas via
+ * running sums; the controller's tests pin equivalence between the two
+ * paths.
+ *
+ * Math summary (formal derivation in `docs/ROADMAP.md` §3):
+ *
+ *   typicalPrice(j) = (H[j] + L[j] + C[j]) / 3
+ *   vwp(j)          = typicalPrice(j) * V[j]
+ *   sumVwp(i)       = Σ_{j=a..i} vwp(j)
+ *   sumVol(i)       = Σ_{j=a..i} V[j]
+ *   AVWAP(i)        = sumVwp(i) / sumVol(i)               (when sumVol > 0)
+ *
+ *   ─── important subtlety ─────────────────────────────────────────────────
+ *   The standard-deviation bands MUST use the **prevailing** AVWAP(j) at
+ *   each bar j ∈ [a..i], NOT the final AVWAP(i). Naive implementations that
+ *   reuse the final mean understate the deviation early in the anchor and
+ *   overstate it late — the bands wind up visibly off-centre on long
+ *   anchors. The dedicated test
+ *   `computeAnchoredVwap.test.ts → "bands use prevailing AVWAP at j"` pins
+ *   this and would catch a regression to the wrong formula.
+ *
+ *   sqDev(j)        = (typicalPrice(j) - AVWAP(j))^2 * V[j]
+ *   sumSqDev(i)     = Σ_{j=a..i} sqDev(j)
+ *   variance(i)     = sumSqDev(i) / sumVol(i)
+ *   stdDev(i)       = sqrt(variance(i))
+ *   upper1(i)       = AVWAP(i) + stdDev(i)
+ *   lower1(i)       = AVWAP(i) - stdDev(i)
+ *   upper2(i)       = AVWAP(i) + 2 * stdDev(i)
+ *   lower2(i)       = AVWAP(i) - 2 * stdDev(i)
+ *
+ * Zero-volume handling:
+ *   - A bar with `volume === 0` contributes 0 to numerator, 0 to
+ *     denominator, and 0 to the squared-deviation sum. The cumulative
+ *     volume is unchanged.
+ *   - If the cumulative volume is still > 0 at this bar (i.e. there was a
+ *     prior non-zero bar) the AVWAP and bands **carry forward** the prior
+ *     values — they are still mathematically well-defined.
+ *   - If the cumulative volume is 0 (i.e. the anchor bar itself has
+ *     volume 0 and every subsequent bar so far has volume 0 too), the
+ *     point's `vwap` and band fields are `NaN`. The series still has an
+ *     entry for the bar — `barIndex` and `cumulativeVolume` are filled in.
+ */
+import { KLineChartError } from '../../errors';
+/**
+ * Compute the Anchored VWAP series for `bars`, anchored at
+ * `anchorIndex` (inclusive). Returns one `AVWAPPoint` per bar from
+ * `bars[anchorIndex]` through `bars[bars.length - 1]`.
+ *
+ * @param bars         the bar series; the anchor must lie inside it
+ * @param anchorIndex  0-based index of the anchor bar (must satisfy
+ *                     `0 <= anchorIndex < bars.length`)
+ * @param includeBands when `false`, the four band fields equal `vwap` and
+ *                     the (cheaper) one-pass cumulative-volume math is
+ *                     used. The second pass that drives the bands is
+ *                     skipped entirely.
+ *
+ * @throws RangeError when `anchorIndex` is out of range and `bars` is
+ *                    non-empty. An empty `bars` array returns `[]` even
+ *                    if `anchorIndex` would otherwise be invalid — this
+ *                    mirrors the "no data, no work" convention used by
+ *                    the volume-profile controller.
+ *
+ * @internal — building block used by the corresponding controller
+ *   factory. Reachable today via the top-level `@klinechart-quant/core`
+ *   barrel but **NOT part of the supported public API**. typedoc / api-
+ *   extractor hide it from generated docs. Prefer the controller
+ *   factory (e.g. `createVolumeProfileController`) for stable user code.
+ *   Closes API audit BLOCKER-002 (export * leakage taxonomy).
+ */
+export function computeAnchoredVwap(bars, anchorIndex, includeBands) {
+    if (bars.length === 0)
+        return [];
+    if (anchorIndex < 0 || anchorIndex >= bars.length) {
+        throw new KLineChartError('AVWAP_ANCHOR_OUT_OF_RANGE', `anchoredVwap: anchorIndex ${anchorIndex} is out of range ` +
+            `for bars of length ${bars.length}`);
+    }
+    const out = [];
+    // Running sums, advanced bar-by-bar.
+    let sumVwp = 0;
+    let sumVol = 0;
+    let sumSqDev = 0;
+    // `prevVwap` carries forward when a bar has zero volume but the
+    // cumulative volume so far is > 0. Initial value `NaN` flags the
+    // "anchor bar volume 0" case (see the docstring).
+    let prevVwap = Number.NaN;
+    for (let i = anchorIndex; i < bars.length; i++) {
+        const bar = bars[i];
+        // Guard against sparse arrays / undefined entries. `Float64Array`
+        // would never have this hole, but plain arrays might.
+        if (bar === undefined)
+            continue;
+        const tp = (bar.high + bar.low + bar.close) / 3;
+        const v = bar.volume;
+        // First update cumulative volume + vwp. A v === 0 bar is a no-op
+        // here and the running totals stay where they were.
+        if (v > 0) {
+            sumVwp += tp * v;
+            sumVol += v;
+        }
+        let vwap;
+        if (sumVol > 0) {
+            vwap = sumVwp / sumVol;
+            prevVwap = vwap;
+        }
+        else {
+            // No volume ever ingested — emit NaN. This only happens when
+            // the anchor bar and every bar since it has v === 0.
+            vwap = Number.NaN;
+        }
+        // Bands: the *prevailing* AVWAP at bar j is the mean used to weigh
+        // sqDev. That's exactly the `vwap` we just computed. Important:
+        // if v === 0 the squared-deviation contribution is also 0, so we
+        // can skip the term entirely (which also avoids touching `tp`
+        // when `vwap` is NaN).
+        if (includeBands && v > 0 && Number.isFinite(vwap)) {
+            const diff = tp - vwap;
+            sumSqDev += diff * diff * v;
+        }
+        let upper1 = vwap;
+        let lower1 = vwap;
+        let upper2 = vwap;
+        let lower2 = vwap;
+        if (includeBands && sumVol > 0 && Number.isFinite(vwap)) {
+            const variance = sumSqDev / sumVol;
+            // Numerical safety: variance can be a tiny negative on
+            // catastrophic cancellation. Treat as 0.
+            const stdDev = Math.sqrt(variance > 0 ? variance : 0);
+            upper1 = vwap + stdDev;
+            lower1 = vwap - stdDev;
+            upper2 = vwap + 2 * stdDev;
+            lower2 = vwap - 2 * stdDev;
+        }
+        out.push({
+            barIndex: i,
+            vwap,
+            upper1,
+            lower1,
+            upper2,
+            lower2,
+            cumulativeVolume: sumVol,
+        });
+        // `prevVwap` is kept up to date for documentation/clarity even
+        // though we don't currently read it (the `sumVol > 0` branch above
+        // assigns directly). Left in place to make the carry-forward
+        // semantics explicit to future readers.
+        void prevVwap;
+    }
+    return out;
+}
+//# sourceMappingURL=computeAnchoredVwap.js.map

package/dist/components/anchoredVwap/computeAnchoredVwap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeAnchoredVwap.js","sourceRoot":"","sources":["../../../src/components/anchoredVwap/computeAnchoredVwap.ts"],"names":[],"mappings":"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"}

package/dist/components/anchoredVwap/createAnchoredVwapController.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Anchored VWAP controller — framework-agnostic, signal-based, multi-anchor.
+ *
+ * Mirrors the dispose-guard pattern from
+ * `createIndicatorSelectorController` and `createVolumeProfileController` so
+ * React/Vue/Angular adapters bridge identically. The controller is pure
+ * data — no DOM, no rendering, no canvas.
+ *
+ * Why multi-anchor with per-anchor running sums:
+ *   TradingView's lower tiers cap the number of simultaneous anchors at
+ *   3 because each AVWAP is recomputed from scratch on every new bar. By
+ *   keeping per-anchor `sumVwp` / `sumVol` / `sumSqDev` totals we drop
+ *   `appendBar` from O(bars-since-anchor) to O(1) per anchor — anchors
+ *   become cheap enough to keep many open at once.
+ *
+ * Equivalence guarantee:
+ *   The point produced by `appendBar` is bit-for-bit identical (to
+ *   floating-point precision) to the point that `computeAnchoredVwap`
+ *   would produce on the same bar at the same anchor — same operands
+ *   added in the same order. The controller test
+ *   `appendBar incrementally matches full recompute` pins this.
+ */
+import type { AnchoredVwapController, AVWAPBar } from './types';
+export interface AnchoredVwapControllerInit {
+    initialBars?: ReadonlyArray<AVWAPBar>;
+}
+export declare function createAnchoredVwapController(opts?: AnchoredVwapControllerInit): AnchoredVwapController;
+//# sourceMappingURL=createAnchoredVwapController.d.ts.map

package/dist/components/anchoredVwap/createAnchoredVwapController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAnchoredVwapController.d.ts","sourceRoot":"","sources":["../../../src/components/anchoredVwap/createAnchoredVwapController.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAGR,sBAAsB,EACtB,QAAQ,EAEX,MAAM,SAAS,CAAA;AAuBhB,MAAM,WAAW,0BAA0B;IACvC,WAAW,CAAC,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;CACxC;AAED,wBAAgB,4BAA4B,CACxC,IAAI,CAAC,EAAE,0BAA0B,GAClC,sBAAsB,CAySxB"}