@continuumdao/continuum-node-sdk 1.3.36 → 1.3.38

package/dist/core/chart/overlays.js

@@ -5,7 +5,28 @@ const DEFAULT_MA_PERIOD = 20;
 const DEFAULT_BOLLINGER_PERIOD = 20;
 const DEFAULT_BOLLINGER_STD_DEV = 2;
 const DEFAULT_BOLLINGER_FILL_COLOR = '#6366f133';
+/** Analysis/overlay desk default (aligned with TA catalog donchianchannels). */
+const DEFAULT_DONCHIAN_PERIOD = 20;
+const DEFAULT_DONCHIAN_FILL_COLOR = '#0ea5e933';
+const DEFAULT_SUPERTREND_PERIOD = 10;
+const DEFAULT_SUPERTREND_MULTIPLIER = 3;
+const SUPERTREND_UP_COLOR = '#22c55e';
+const SUPERTREND_DOWN_COLOR = '#ef4444';
+/** Cap colored ST segments so total chart series stay under the expand limit. */
+const MAX_SUPERTREND_SEGMENTS = 10;
+const DEFAULT_ICHIMOKU_CONVERSION = 9;
+const DEFAULT_ICHIMOKU_BASE = 26;
+const DEFAULT_ICHIMOKU_SPAN = 52;
+const DEFAULT_ICHIMOKU_DISPLACEMENT = 26;
+const ICHIMOKU_TENKAN_COLOR = '#3b82f6';
+const ICHIMOKU_KIJUN_COLOR = '#ef4444';
+const ICHIMOKU_CHIKOU_COLOR = '#a855f7';
+const ICHIMOKU_CLOUD_BULL_COLOR = '#22c55e33';
+const ICHIMOKU_CLOUD_BEAR_COLOR = '#ef444433';
 const DEFAULT_RSI_PERIOD = 14;
+const DEFAULT_ZSCORE_PERIOD = 20;
+const DEFAULT_ZSCORE_ENTRY = 2;
+const DEFAULT_ZSCORE_EXIT = 0.5;
 const MACD_HIST_UP = '#22c55e';
 const MACD_HIST_DOWN = '#ef4444';
 const ALL_FIB_LEVELS = [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1];
@@ -16,8 +37,11 @@ function findSourceSeries(seriesList, sourceSeriesId) {
     }
     const times = [];
     const closes = [];
+    const highs = [];
+    const lows = [];
     let high = Number.NEGATIVE_INFINITY;
     let low = Number.POSITIVE_INFINITY;
+    let hasOhlc = false;
     for (const row of source.data) {
         const time = row.time;
         if (time == null) {
@@ -35,6 +59,9 @@ function findSourceSeries(seriesList, sourceSeriesId) {
             }
             times.push(time);
             closes.push(close);
+            highs.push(rowHigh);
+            lows.push(rowLow);
+            hasOhlc = true;
             high = Math.max(high, rowHigh);
             low = Math.min(low, rowLow);
             continue;
@@ -59,7 +86,16 @@ function findSourceSeries(seriesList, sourceSeriesId) {
     if (!Number.isFinite(high) || !Number.isFinite(low)) {
         return { ok: false, reason: `Overlay source "${sourceSeriesId}" has invalid high/low range.` };
     }
-    return { ok: true, data: { times, closes, high, low } };
+    return {
+        ok: true,
+        data: {
+            times,
+            closes,
+            ...(hasOhlc ? { highs, lows } : {}),
+            high,
+            low,
+        },
+    };
 }
 function primaryTimeSpan(seriesList) {
     const primary = seriesList.find(s => s.type === 'candlestick' || s.type === 'line');
@@ -252,6 +288,405 @@ function computeBollingerOverlay(overlay, source) {
         ],
     };
 }
+function computeDonchianOverlay(overlay, source) {
+    const period = overlay.period ?? DEFAULT_DONCHIAN_PERIOD;
+    const highs = source.highs;
+    const lows = source.lows;
+    if (!highs?.length || !lows?.length || highs.length !== source.closes.length) {
+        return {
+            ok: false,
+            reason: 'Donchian overlay requires a candlestick source series with high/low.',
+        };
+    }
+    const result = calculateTechnicalIndicator({
+        indicator: 'donchianchannels',
+        params: { period },
+        input: { high: highs, low: lows, close: source.closes },
+        options: { maxPoints: highs.length },
+    });
+    if (!result.ok) {
+        return result;
+    }
+    const rows = result.data.result;
+    if (!Array.isArray(rows) || rows.length === 0) {
+        return { ok: false, reason: 'Overlay donchian returned no data.' };
+    }
+    const upper = [];
+    const middle = [];
+    const lower = [];
+    const bandFill = [];
+    const aligned = alignObjectIndicatorRows(source.times, rows, result.data.warmupCount);
+    for (const { time, row } of aligned) {
+        const u = pickNumber(row, ['upper', 'Upper']);
+        const m = pickNumber(row, ['middle', 'Middle']);
+        const l = pickNumber(row, ['lower', 'Lower']);
+        if (u != null) {
+            upper.push({ time, value: u });
+        }
+        if (m != null) {
+            middle.push({ time, value: m });
+        }
+        if (l != null) {
+            lower.push({ time, value: l });
+        }
+        if (u != null && l != null) {
+            bandFill.push({ time, upper: u, lower: l });
+        }
+    }
+    if (middle.length === 0) {
+        return {
+            ok: false,
+            reason: `Overlay donchian(${period}) has no points after warmup.`,
+        };
+    }
+    const prefix = overlay.id ?? `dc${period}_${overlay.sourceSeriesId}`;
+    const baseStyle = overlay.style ?? { lineWidth: 1 };
+    const showFill = overlay.fill !== false;
+    const fillColor = overlay.style?.color ?? DEFAULT_DONCHIAN_FILL_COLOR;
+    const seriesOut = [];
+    if (showFill && bandFill.length > 0) {
+        seriesOut.push({
+            id: `${prefix}_fill`,
+            type: 'band',
+            label: `DC fill (${period})`,
+            data: bandFill,
+            priceScaleId: overlay.priceScaleId ?? 'right',
+            overlay: overlay.overlay ?? true,
+            lastValueVisible: false,
+            style: { color: fillColor, lineWidth: 1 },
+        });
+    }
+    return {
+        ok: true,
+        data: [
+            ...seriesOut,
+            {
+                id: `${prefix}_upper`,
+                type: 'line',
+                label: `DC upper (${period})`,
+                data: upper,
+                priceScaleId: overlay.priceScaleId ?? 'right',
+                overlay: overlay.overlay ?? true,
+                style: { ...baseStyle, lineStyle: 'dashed' },
+            },
+            {
+                id: `${prefix}_middle`,
+                type: 'line',
+                label: `DC middle (${period})`,
+                data: middle,
+                priceScaleId: overlay.priceScaleId ?? 'right',
+                overlay: overlay.overlay ?? true,
+                style: { ...baseStyle, lineStyle: 'solid' },
+            },
+            {
+                id: `${prefix}_lower`,
+                type: 'line',
+                label: `DC lower (${period})`,
+                data: lower,
+                priceScaleId: overlay.priceScaleId ?? 'right',
+                overlay: overlay.overlay ?? true,
+                style: { ...baseStyle, lineStyle: 'dashed' },
+            },
+        ],
+    };
+}
+function computeSupertrendOverlay(overlay, source) {
+    const period = overlay.period ?? DEFAULT_SUPERTREND_PERIOD;
+    const multiplier = overlay.multiplier ?? DEFAULT_SUPERTREND_MULTIPLIER;
+    const highs = source.highs;
+    const lows = source.lows;
+    if (!highs?.length || !lows?.length || highs.length !== source.closes.length) {
+        return {
+            ok: false,
+            reason: 'Supertrend overlay requires a candlestick source series with high/low.',
+        };
+    }
+    const result = calculateTechnicalIndicator({
+        indicator: 'supertrend',
+        params: { period, multiplier },
+        input: { high: highs, low: lows, close: source.closes },
+        options: { maxPoints: highs.length },
+    });
+    if (!result.ok) {
+        return result;
+    }
+    const rows = result.data.result;
+    if (!Array.isArray(rows) || rows.length === 0) {
+        return { ok: false, reason: 'Overlay supertrend returned no data.' };
+    }
+    const aligned = alignObjectIndicatorRows(source.times, rows, result.data.warmupCount);
+    const points = [];
+    for (const { time, row } of aligned) {
+        const value = pickNumber(row, ['supertrend', 'SuperTrend', 'Supertrend']);
+        const direction = pickNumber(row, ['direction', 'Direction']);
+        if (value == null || direction == null || !Number.isFinite(value)) {
+            continue;
+        }
+        points.push({ time, value, direction: direction >= 0 ? 1 : -1 });
+    }
+    if (points.length === 0) {
+        return {
+            ok: false,
+            reason: `Overlay supertrend(${period}, ${multiplier}) has no points after warmup.`,
+        };
+    }
+    const segments = [];
+    for (const pt of points) {
+        const last = segments[segments.length - 1];
+        if (!last || last.direction !== pt.direction) {
+            segments.push({ direction: pt.direction, data: [{ time: pt.time, value: pt.value }] });
+        }
+        else {
+            last.data.push({ time: pt.time, value: pt.value });
+        }
+    }
+    const kept = segments.length > MAX_SUPERTREND_SEGMENTS
+        ? segments.slice(segments.length - MAX_SUPERTREND_SEGMENTS)
+        : segments;
+    const prefix = overlay.id ?? `st${period}x${multiplier}_${overlay.sourceSeriesId}`;
+    const lineWidth = overlay.style?.lineWidth ?? 2;
+    const seriesOut = kept.map((seg, i) => ({
+        id: `${prefix}_seg${i}`,
+        type: 'line',
+        label: i === kept.length - 1 ? `Supertrend (${period}, ${multiplier})` : `ST seg ${i + 1}`,
+        data: seg.data,
+        priceScaleId: overlay.priceScaleId ?? 'right',
+        overlay: overlay.overlay ?? true,
+        lastValueVisible: i === kept.length - 1,
+        style: {
+            lineWidth,
+            lineStyle: 'solid',
+            color: seg.direction >= 0 ? SUPERTREND_UP_COLOR : SUPERTREND_DOWN_COLOR,
+        },
+    }));
+    return { ok: true, data: seriesOut };
+}
+function medianBarIntervalSec(times) {
+    const secs = [];
+    for (const t of times) {
+        const s = chartTimeSec(t);
+        if (s != null) {
+            secs.push(s);
+        }
+    }
+    if (secs.length < 2) {
+        return null;
+    }
+    const deltas = [];
+    for (let i = 1; i < secs.length; i++) {
+        const d = secs[i] - secs[i - 1];
+        if (d > 0) {
+            deltas.push(d);
+        }
+    }
+    if (deltas.length === 0) {
+        return null;
+    }
+    deltas.sort((a, b) => a - b);
+    return deltas[Math.floor(deltas.length / 2)];
+}
+function extendChartTime(last, intervalSec, steps) {
+    const sec = chartTimeSec(last);
+    if (sec == null || typeof last !== 'number') {
+        // Business-day charts: fall back to unix seconds from last if possible.
+        if (sec == null) {
+            return last;
+        }
+        return sec + intervalSec * steps;
+    }
+    return last + intervalSec * steps;
+}
+function computeIchimokuOverlay(overlay, source) {
+    const conversionPeriod = overlay.conversionPeriod ?? DEFAULT_ICHIMOKU_CONVERSION;
+    const basePeriod = overlay.basePeriod ?? DEFAULT_ICHIMOKU_BASE;
+    const spanPeriod = overlay.spanPeriod ?? DEFAULT_ICHIMOKU_SPAN;
+    const displacement = overlay.displacement ?? DEFAULT_ICHIMOKU_DISPLACEMENT;
+    const highs = source.highs;
+    const lows = source.lows;
+    if (!highs?.length || !lows?.length || highs.length !== source.closes.length) {
+        return {
+            ok: false,
+            reason: 'Ichimoku overlay requires a candlestick source series with high/low.',
+        };
+    }
+    const result = calculateTechnicalIndicator({
+        indicator: 'ichimokukinkouhyou',
+        params: { conversionPeriod, basePeriod, spanPeriod, displacement },
+        input: { high: highs, low: lows, close: source.closes },
+        options: { maxPoints: highs.length },
+    });
+    if (!result.ok) {
+        return result;
+    }
+    const rows = result.data.result;
+    if (!Array.isArray(rows) || rows.length === 0) {
+        return { ok: false, reason: 'Overlay ichimoku returned no data.' };
+    }
+    const aligned = alignObjectIndicatorRows(source.times, rows, result.data.warmupCount);
+    const tenkan = [];
+    const kijun = [];
+    const spanPoints = [];
+    const intervalSec = medianBarIntervalSec(source.times) ?? 3600;
+    const alignOffset = rows.length < source.times.length ? source.times.length - rows.length : 0;
+    for (let i = 0; i < aligned.length; i++) {
+        const { time, row } = aligned[i];
+        const conversion = pickNumber(row, ['conversion', 'Conversion', 'tenkan', 'Tenkan']);
+        const base = pickNumber(row, ['base', 'Base', 'kijun', 'Kijun']);
+        const spanA = pickNumber(row, ['spanA', 'SpanA', 'senkouA', 'SenkouA']);
+        const spanB = pickNumber(row, ['spanB', 'SpanB', 'senkouB', 'SenkouB']);
+        if (conversion != null) {
+            tenkan.push({ time, value: conversion });
+        }
+        if (base != null) {
+            kijun.push({ time, value: base });
+        }
+        if (spanA != null && spanB != null) {
+            const sourceIndex = alignOffset + i;
+            const targetIndex = sourceIndex + displacement;
+            let cloudTime;
+            if (targetIndex >= 0 && targetIndex < source.times.length) {
+                cloudTime = source.times[targetIndex];
+            }
+            else if (source.times.length > 0 && targetIndex >= source.times.length) {
+                const last = source.times[source.times.length - 1];
+                const stepsBeyond = targetIndex - (source.times.length - 1);
+                cloudTime = extendChartTime(last, intervalSec, stepsBeyond);
+            }
+            else {
+                continue;
+            }
+            spanPoints.push({ time: cloudTime, spanA, spanB });
+        }
+    }
+    if (tenkan.length === 0 && kijun.length === 0) {
+        return {
+            ok: false,
+            reason: `Overlay ichimoku(${conversionPeriod}/${basePeriod}/${spanPeriod}) has no points after warmup.`,
+        };
+    }
+    const prefix = overlay.id ?? `ichi_${overlay.sourceSeriesId}`;
+    const priceScaleId = overlay.priceScaleId ?? 'right';
+    const isOverlay = overlay.overlay ?? true;
+    const showFill = overlay.fill !== false;
+    const showChikou = overlay.chikou !== false;
+    const seriesOut = [];
+    if (showFill && spanPoints.length > 0) {
+        const bullBands = [];
+        const bearBands = [];
+        for (const pt of spanPoints) {
+            const upper = Math.max(pt.spanA, pt.spanB);
+            const lower = Math.min(pt.spanA, pt.spanB);
+            const bandPt = { time: pt.time, upper, lower };
+            if (pt.spanA >= pt.spanB) {
+                bullBands.push(bandPt);
+            }
+            else {
+                bearBands.push(bandPt);
+            }
+        }
+        if (bullBands.length > 0) {
+            seriesOut.push({
+                id: `${prefix}_cloud_bull`,
+                type: 'band',
+                label: 'Ichimoku cloud (bull)',
+                data: bullBands,
+                priceScaleId,
+                overlay: isOverlay,
+                lastValueVisible: false,
+                style: { color: ICHIMOKU_CLOUD_BULL_COLOR, lineWidth: 1 },
+            });
+        }
+        if (bearBands.length > 0) {
+            seriesOut.push({
+                id: `${prefix}_cloud_bear`,
+                type: 'band',
+                label: 'Ichimoku cloud (bear)',
+                data: bearBands,
+                priceScaleId,
+                overlay: isOverlay,
+                lastValueVisible: false,
+                style: { color: ICHIMOKU_CLOUD_BEAR_COLOR, lineWidth: 1 },
+            });
+        }
+    }
+    if (tenkan.length > 0) {
+        seriesOut.push({
+            id: `${prefix}_tenkan`,
+            type: 'line',
+            label: `Tenkan (${conversionPeriod})`,
+            data: tenkan,
+            priceScaleId,
+            overlay: isOverlay,
+            style: { color: ICHIMOKU_TENKAN_COLOR, lineWidth: 1, lineStyle: 'solid' },
+        });
+    }
+    if (kijun.length > 0) {
+        seriesOut.push({
+            id: `${prefix}_kijun`,
+            type: 'line',
+            label: `Kijun (${basePeriod})`,
+            data: kijun,
+            priceScaleId,
+            overlay: isOverlay,
+            style: { color: ICHIMOKU_KIJUN_COLOR, lineWidth: 1, lineStyle: 'solid' },
+        });
+    }
+    // Senkou outline lines (forward-displaced).
+    const spanALine = [];
+    const spanBLine = [];
+    for (const pt of spanPoints) {
+        spanALine.push({ time: pt.time, value: pt.spanA });
+        spanBLine.push({ time: pt.time, value: pt.spanB });
+    }
+    if (spanALine.length > 0) {
+        seriesOut.push({
+            id: `${prefix}_spanA`,
+            type: 'line',
+            label: 'Senkou A',
+            data: spanALine,
+            priceScaleId,
+            overlay: isOverlay,
+            lastValueVisible: false,
+            style: { color: '#22c55e', lineWidth: 1, lineStyle: 'dashed' },
+        });
+    }
+    if (spanBLine.length > 0) {
+        seriesOut.push({
+            id: `${prefix}_spanB`,
+            type: 'line',
+            label: 'Senkou B',
+            data: spanBLine,
+            priceScaleId,
+            overlay: isOverlay,
+            lastValueVisible: false,
+            style: { color: '#ef4444', lineWidth: 1, lineStyle: 'dashed' },
+        });
+    }
+    if (showChikou && displacement > 0 && source.closes.length > displacement) {
+        const chikou = [];
+        for (let i = displacement; i < source.closes.length; i++) {
+            const close = source.closes[i];
+            const time = source.times[i - displacement];
+            if (time == null || !Number.isFinite(close)) {
+                continue;
+            }
+            chikou.push({ time, value: close });
+        }
+        if (chikou.length > 0) {
+            seriesOut.push({
+                id: `${prefix}_chikou`,
+                type: 'line',
+                label: `Chikou (${displacement})`,
+                data: chikou,
+                priceScaleId,
+                overlay: isOverlay,
+                lastValueVisible: false,
+                style: { color: ICHIMOKU_CHIKOU_COLOR, lineWidth: 1, lineStyle: 'dotted' },
+            });
+        }
+    }
+    return { ok: true, data: seriesOut };
+}
 function horizontalLineData(timeStart, timeEnd, value) {
     return [
         { time: timeStart, value },
@@ -795,6 +1230,97 @@ function oscillatorPaneId(overlay, index) {
     const base = overlay.id ?? `${overlay.type}_${index}`;
     return `osc_${base.replace(/[^a-zA-Z0-9_-]/g, '_')}`;
 }
+/** Resolve pane ids for rsi / stochasticrsi overlays in the same order expandChartOverlays uses. */
+export function resolveOscillatorPaneIds(overlays) {
+    const out = {};
+    if (!overlays?.length) {
+        return out;
+    }
+    let oscillatorIndex = 0;
+    for (const overlay of overlays) {
+        if (overlay.type === 'rsi' ||
+            overlay.type === 'zscore' ||
+            overlay.type === 'macd' ||
+            overlay.type === 'stochasticrsi') {
+            const paneId = oscillatorPaneId(overlay, oscillatorIndex++);
+            if (out[overlay.type] == null) {
+                out[overlay.type] = paneId;
+            }
+        }
+    }
+    return out;
+}
+function divergenceSegmentStyle(kind, base) {
+    const bullish = kind === 'regular_bullish' || kind === 'hidden_bullish';
+    const hidden = kind === 'hidden_bullish' || kind === 'hidden_bearish';
+    return {
+        color: bullish ? '#3b82f6' : '#ef4444',
+        lineWidth: 2,
+        lineStyle: hidden ? 'dashed' : 'solid',
+        ...base,
+    };
+}
+function chartTimeToUnix(time) {
+    if (typeof time === 'number' && Number.isFinite(time)) {
+        return time;
+    }
+    if (time && typeof time === 'object' && 'year' in time) {
+        return Math.floor(Date.UTC(time.year, time.month - 1, time.day) / 1000);
+    }
+    return null;
+}
+function computeDivergenceOverlay(overlay, paneByOsc) {
+    const prefix = overlay.id ?? 'divergence';
+    const seriesOut = [];
+    for (let i = 0; i < overlay.segments.length; i++) {
+        const seg = overlay.segments[i];
+        const paneId = seg.oscillatorPaneId ?? paneByOsc[seg.oscillator];
+        if (!paneId) {
+            return {
+                ok: false,
+                reason: `Divergence segment needs ${seg.oscillator} pane — ensure that oscillator overlay is present.`,
+            };
+        }
+        const style = divergenceSegmentStyle(seg.kind, overlay.style);
+        const pA = chartTimeToUnix(seg.price.pointA.time);
+        const pB = chartTimeToUnix(seg.price.pointB.time);
+        const oA = chartTimeToUnix(seg.oscillatorLine.pointA.time);
+        const oB = chartTimeToUnix(seg.oscillatorLine.pointB.time);
+        if (pA == null || pB == null || oA == null || oB == null) {
+            return { ok: false, reason: 'Divergence segment has invalid times.' };
+        }
+        const label = seg.label?.trim() || seg.kind.replace(/_/g, ' ');
+        seriesOut.push({
+            id: `${prefix}_price_${i}`,
+            type: 'line',
+            label: `${label} (price)`,
+            data: [
+                { time: pA, value: seg.price.pointA.price },
+                { time: pB, value: seg.price.pointB.price },
+            ],
+            priceScaleId: 'right',
+            overlay: true,
+            style,
+        });
+        seriesOut.push({
+            id: `${prefix}_osc_${i}`,
+            type: 'line',
+            label: `${label} (${seg.oscillator})`,
+            data: [
+                { time: oA, value: seg.oscillatorLine.pointA.value },
+                { time: oB, value: seg.oscillatorLine.pointB.value },
+            ],
+            priceScaleId: 'right',
+            overlay: true,
+            paneId,
+            style,
+        });
+    }
+    if (!seriesOut.length) {
+        return { ok: false, reason: 'divergence produced no drawable geometry.' };
+    }
+    return { ok: true, data: seriesOut };
+}
 function tagSeriesPane(series, paneId) {
     return series.map(s => ({ ...s, paneId }));
 }
@@ -844,6 +1370,80 @@ function computeRsiOverlay(overlay, source, paneId) {
         ], paneId),
     };
 }
+function computeZScoreOverlay(overlay, source, paneId) {
+    const period = overlay.period ?? DEFAULT_ZSCORE_PERIOD;
+    const entryZ = overlay.entryZ ?? DEFAULT_ZSCORE_ENTRY;
+    const exitZ = overlay.exitZ ?? DEFAULT_ZSCORE_EXIT;
+    const smaResult = calculateTechnicalIndicator({
+        indicator: 'sma',
+        params: { period },
+        input: { values: source.closes },
+        options: { maxPoints: source.closes.length },
+    });
+    if (!smaResult.ok) {
+        return smaResult;
+    }
+    const sdResult = calculateTechnicalIndicator({
+        indicator: 'sd',
+        params: { period },
+        input: { values: source.closes },
+        options: { maxPoints: source.closes.length },
+    });
+    if (!sdResult.ok) {
+        return sdResult;
+    }
+    const smaAligned = alignNumericIndicator(source.times, smaResult.data.result, smaResult.data.warmupCount);
+    const sdAligned = alignNumericIndicator(source.times, sdResult.data.result, sdResult.data.warmupCount);
+    const sdByTime = new Map(sdAligned.map(p => [String(p.time), p.value]));
+    const zLine = [];
+    for (let i = 0; i < source.closes.length; i++) {
+        const time = source.times[i];
+        const close = source.closes[i];
+        const smaPoint = smaAligned.find(p => p.time === time);
+        const sd = sdByTime.get(String(time));
+        if (smaPoint == null || sd == null || !Number.isFinite(sd) || sd <= 0) {
+            continue;
+        }
+        zLine.push({ time, value: (close - smaPoint.value) / sd });
+    }
+    if (zLine.length === 0) {
+        return { ok: false, reason: `Overlay zscore(${period}) has no points after warmup.` };
+    }
+    const prefix = overlay.id ?? `zscore${period}_${overlay.sourceSeriesId}`;
+    const guide = (level, idSuffix, label, dashed = true) => ({
+        id: `${prefix}_${idSuffix}`,
+        type: 'line',
+        label,
+        data: zLine.map(p => ({ time: p.time, value: level })),
+        priceScaleId: 'right',
+        overlay: true,
+        lastValueVisible: false,
+        style: {
+            lineStyle: dashed ? 'dashed' : 'dotted',
+            lineWidth: 1,
+            color: '#94a3b8',
+        },
+    });
+    const seriesOut = [
+        {
+            id: `${prefix}_z`,
+            type: 'line',
+            label: overlay.label ?? `Z(${period})`,
+            data: zLine,
+            priceScaleId: 'right',
+            overlay: true,
+            style: overlay.style ?? { lineStyle: 'solid', lineWidth: 2, color: '#7c3aed' },
+        },
+        guide(0, 'zero', 'Z=0', false),
+        guide(entryZ, 'entry_pos', `+${entryZ}`),
+        guide(-entryZ, 'entry_neg', `−${entryZ}`),
+    ];
+    if (exitZ > 0) {
+        seriesOut.push(guide(exitZ, 'exit_pos', `+${exitZ}`));
+        seriesOut.push(guide(-exitZ, 'exit_neg', `−${exitZ}`));
+    }
+    return { ok: true, data: tagSeriesPane(seriesOut, paneId) };
+}
 function computeMacdOverlay(overlay, source, paneId) {
     const params = {
         ...(overlay.fastPeriod != null ? { fastPeriod: overlay.fastPeriod } : {}),
@@ -1005,13 +1605,15 @@ export function expandChartOverlays(baseSeries, overlays) {
     }
     const expanded = [...baseSeries];
     let oscillatorIndex = 0;
+    const paneByOsc = resolveOscillatorPaneIds(overlays);
     for (const overlay of overlays) {
         let overlaySeries;
         if (overlay.type === 'horizontal_levels' ||
             overlay.type === 'pivot_levels' ||
             overlay.type === 'trend_lines' ||
             overlay.type === 'chart_pattern' ||
-            overlay.type === 'elliott_waves') {
+            overlay.type === 'elliott_waves' ||
+            overlay.type === 'divergence') {
             const span = primaryTimeSpan(baseSeries);
             if (!span.ok) {
                 return span;
@@ -1028,6 +1630,9 @@ export function expandChartOverlays(baseSeries, overlays) {
             else if (overlay.type === 'elliott_waves') {
                 overlaySeries = computeElliottWavesOverlay(overlay, span.data.timeStart, span.data.timeEnd);
             }
+            else if (overlay.type === 'divergence') {
+                overlaySeries = computeDivergenceOverlay(overlay, paneByOsc);
+            }
             else {
                 overlaySeries = computeTrendLinesOverlay(overlay, span.data.timeStart, span.data.timeEnd);
             }
@@ -1055,6 +1660,7 @@ export function expandChartOverlays(baseSeries, overlays) {
             overlaySeries = computeFibonacciOverlay(overlay, span.data.timeStart, span.data.timeEnd, range);
         }
         else if (overlay.type === 'rsi' ||
+            overlay.type === 'zscore' ||
             overlay.type === 'macd' ||
             overlay.type === 'stochasticrsi') {
             const sourceResult = findSourceSeries(baseSeries, overlay.sourceSeriesId);
@@ -1065,6 +1671,9 @@ export function expandChartOverlays(baseSeries, overlays) {
             if (overlay.type === 'rsi') {
                 overlaySeries = computeRsiOverlay(overlay, sourceResult.data, paneId);
             }
+            else if (overlay.type === 'zscore') {
+                overlaySeries = computeZScoreOverlay(overlay, sourceResult.data, paneId);
+            }
             else if (overlay.type === 'macd') {
                 overlaySeries = computeMacdOverlay(overlay, sourceResult.data, paneId);
             }
@@ -1086,6 +1695,15 @@ export function expandChartOverlays(baseSeries, overlays) {
             else if (overlay.type === 'bollinger') {
                 overlaySeries = computeBollingerOverlay(overlay, sourceResult.data);
             }
+            else if (overlay.type === 'donchian') {
+                overlaySeries = computeDonchianOverlay(overlay, sourceResult.data);
+            }
+            else if (overlay.type === 'supertrend') {
+                overlaySeries = computeSupertrendOverlay(overlay, sourceResult.data);
+            }
+            else if (overlay.type === 'ichimoku') {
+                overlaySeries = computeIchimokuOverlay(overlay, sourceResult.data);
+            }
             else {
                 return { ok: false, reason: `Unsupported overlay type.` };
             }