@sybilion/uilib 1.3.63 → 1.3.65

package/dist/esm/components/ui/Chart/components/BaseChartWrapper.js

@@ -48,7 +48,7 @@ BaseChartWrapperLoading.displayName = 'BaseChartWrapperLoading';
  * Separated to maintain hook order consistency
  */
 const BaseChartWrapperContent = forwardRef((props, ref) => {
-    const { chartConfig = {}, chartData, historicalLineColor, forecastData = [], loading, hasCombinedData, renderId, isDarkTheme, height, className, loadingComponentClassName, footerClassName, chartClassName, xAxisClassName, yAxisClassName, legendClassName, footerActions, quantileBands, quantileBandKey, xMin, xMax, yMin, yMax, autoScaleYAxis = true, formatNumber, formatDate: formatDateFn = formatDate, labelFormatter, onLegendClick, margin, chartType = 'composed', disableAnimation = false, disableLineDrawAnimation = false, showGrid = true, showAxes = true, showTooltip = true, showLegend = true, showChartAxesLegend = true, xAxisLabel, yAxisLabel, showActiveDots = true, overlayElements, hiddenSeries, excludeLegendIds, onAnalysisSelect, onFailedAnalysisClick, containerProps, error, loadingMessage, noDataMessage = 'No data available', onGridHeightChange, forecastLineStyle = 'dashed', disableHistoricalAnimation = false, onShowAll: _onShowAll, onShowOnly: _onShowOnly, maxVisibleItems, preventDeselection, legendVariant = 'default', legendWidth = 1000, legendMarginLeft = 0, } = props;
+    const { chartConfig = {}, chartData, historicalLineColor, forecastData = [], loading, hasCombinedData, renderId, isDarkTheme, height, className, loadingComponentClassName, footerClassName, chartClassName, xAxisClassName, yAxisClassName, legendClassName, footerActions, quantileBands, quantileBandKey, xMin, xMax, yMin, yMax, autoScaleYAxis = true, formatNumber, formatDate: formatDateFn = formatDate, labelFormatter, onLegendClick, margin, chartType = 'composed', disableAnimation = false, disableLineDrawAnimation = false, showGrid = true, showAxes = true, showTooltip = true, showLegend = true, showChartAxesLegend = true, xAxisLabel, yAxisLabel, showActiveDots = true, overlayElements, hiddenSeries, includeHiddenInYScale = false, excludeLegendIds, onAnalysisSelect, onFailedAnalysisClick, containerProps, error, loadingMessage, noDataMessage = 'No data available', onGridHeightChange, forecastLineStyle = 'dashed', disableHistoricalAnimation = false, onShowAll: _onShowAll, onShowOnly: _onShowOnly, maxVisibleItems, preventDeselection, legendVariant = 'default', legendWidth = 1000, legendMarginLeft = 0, } = props;
     const [shouldAnimate, setShouldAnimate] = useState(false);
     const lineDataInitializedRef = useRef(false);
     const rootRef = useRef(null);
@@ -291,12 +291,17 @@ const BaseChartWrapperContent = forwardRef((props, ref) => {
     let effectiveAutoScale = autoScaleYAxis;
     if (autoScaleYAxis !== false && yMin !== undefined && yMax !== undefined) {
         const dataKeys = chartData.length > 0 ? Object.keys(chartData[0]) : [];
-        const historicalValues = chartData
-            .map(p => p.historical)
-            .filter(v => v !== null && v !== undefined);
+        const historicalValues = !includeHiddenInYScale && hiddenSeries?.has('historical')
+            ? []
+            : chartData
+                .map(p => p.historical)
+                .filter(v => v !== null && v !== undefined);
         const forecastKeys = dataKeys.filter(k => k.startsWith('forecast_'));
+        const visibleForecastKeys = !includeHiddenInYScale && hiddenSeries
+            ? forecastKeys.filter(k => !hiddenSeries.has(k))
+            : forecastKeys;
         const forecastValues = chartData
-            .flatMap(p => forecastKeys.map(k => p[k]))
+            .flatMap(p => visibleForecastKeys.map(k => p[k]))
             .filter(v => v !== null && v !== undefined);
         const allLineValues = [...historicalValues, ...forecastValues];
         if (allLineValues.length > 0) {

package/dist/esm/components/ui/Chart/components/QuantileBands.js

@@ -1,5 +1,5 @@
 import { jsx, Fragment } from 'react/jsx-runtime';
-import { getForecastQuantileBandColor, FORECAST_COLORS_MAP } from '../../ChartAreaInteractive/ChartLines.js';
+import { FORECAST_COLORS_MAP, getForecastQuantileBandColor } from '../../ChartAreaInteractive/ChartLines.js';
 import { Area } from 'recharts';
 
 const DEFAULT_QUANTILE_BAND_COLOR = FORECAST_COLORS_MAP['#04ADC3'];

package/dist/esm/components/ui/ChartAreaInteractive/ChartAreaInteractive.helpers.js

@@ -1,4 +1,48 @@
 // Helper function to format large numbers with k/m abbreviations
+const formatNumber = (value) => {
+    if (value >= 1000000) {
+        return (value / 1000000).toFixed(1).replace(/\.0$/, '') + 'm';
+    }
+    else if (value >= 1000) {
+        return (value / 1000).toFixed(1).replace(/\.0$/, '') + 'k';
+    }
+    return value.toFixed(0);
+};
+// Find pin position for a specific date in the current filtered data
+const findPinPositionForDate = (targetDate, filteredData) => {
+    if (!filteredData.length)
+        return 0;
+    const targetDateObj = new Date(targetDate);
+    let closestIndex = 0;
+    let minDistance = Infinity;
+    // First, try to find an exact match
+    const exactMatch = filteredData.findIndex(dataPoint => dataPoint.date &&
+        new Date(dataPoint.date).getTime() === targetDateObj.getTime());
+    if (exactMatch !== -1) {
+        return (exactMatch / (filteredData.length - 1)) * 100;
+    }
+    // If no exact match, find the closest date
+    filteredData.forEach((dataPoint, index) => {
+        if (dataPoint.date) {
+            const pointDate = new Date(dataPoint.date);
+            const distance = Math.abs(pointDate.getTime() - targetDateObj.getTime());
+            if (distance < minDistance) {
+                minDistance = distance;
+                closestIndex = index;
+            }
+        }
+    });
+    // If the target date is outside the current range, clamp to the nearest edge
+    const firstDate = new Date(filteredData[0].date);
+    const lastDate = new Date(filteredData[filteredData.length - 1].date);
+    if (targetDateObj < firstDate) {
+        return 0; // Pin at the beginning
+    }
+    else if (targetDateObj > lastDate) {
+        return 100; // Pin at the end
+    }
+    return (closestIndex / (filteredData.length - 1)) * 100;
+};
 const timeRangeToMonths = {
     '6m': 6,
     '1y': 12,
@@ -147,5 +191,20 @@ const longDateFormatter = (value) => {
         year: 'numeric',
     });
 };
+/**
+ * Checks if an analysis status is 'fail' (case-insensitive).
+ * @param analysis - The analysis object with optional status field
+ * @returns true if status is 'fail', false otherwise
+ */
+const isAnalysisFailed = (analysis) => {
+    return analysis.status?.toLowerCase() === 'fail';
+};
+/**
+ * Checks if an analysis status is not 'fail' (case-insensitive).
+ * @param analysis - The analysis object with optional status field
+ * @returns true if status is not 'fail', false otherwise
+ */
+const isAnalysisNotFailed = (analysis) => !isAnalysisFailed(analysis);
+const isAnalysisDone = (analysis) => analysis.status?.toLowerCase() === 'done';
 
-export { DRAG_TIME_RANGE_PREFIX, encodeDragTimeRange, filterDataForTimeRange, isTimeRangePreset, longDateFormatter, parseDragTimeRange, shortDateFormatter };
+export { DRAG_TIME_RANGE_PREFIX, encodeDragTimeRange, filterDataForTimeRange, findPinPositionForDate, formatNumber, isAnalysisDone, isAnalysisFailed, isAnalysisNotFailed, isTimeRangePreset, longDateFormatter, parseDragTimeRange, shortDateFormatter };

package/dist/esm/components/ui/ChartAreaInteractive/overlays/useChartYRange.js

@@ -1,75 +1,116 @@
 import { useRef, useMemo } from 'react';
 
+/** Serialize hidden series keys for stable cache comparison. */
+function serializeHiddenSeries(hiddenSeries) {
+    if (!hiddenSeries || hiddenSeries.size === 0)
+        return '';
+    return [...hiddenSeries].sort().join(',');
+}
 /**
- * Hook to calculate yMin and yMax from chart data
- * Optionally includes quantile values from forecast data
+ * Returns true when a chart data key should be skipped for Y-scale (series hidden).
  */
-function useChartYRange({ baseChartProps, chartData, disableRescaleWhenQuantileChanges, excludeQuantileBands = false, selectedForecastId, }) {
-    // Store initial Y-range when disableRescaleWhenQuantileChanges is true
-    const stableYRangeRef = useRef(null);
-    const prevBaseChartDataRef = useRef(baseChartProps.chartData);
-    // Helper function to calculate Y-range from data
-    const calculateYRange = (dataToUse, excludeQuantileBands, forecastId) => {
-        const allValues = [];
-        dataToUse.forEach(point => {
-            Object.entries(point).forEach(([key, value]) => {
-                if (key === 'date')
+function isKeyExcludedFromYScale(key, hiddenSeries) {
+    if (!hiddenSeries || hiddenSeries.size === 0)
+        return false;
+    if (key === 'historical') {
+        return hiddenSeries.has('historical');
+    }
+    if (key.startsWith('forecast_')) {
+        return hiddenSeries.has(key);
+    }
+    if (key.startsWith('q') && key.includes('_')) {
+        const forecastId = key.slice(key.lastIndexOf('_') + 1);
+        return hiddenSeries.has(`forecast_${forecastId}`);
+    }
+    if (key.startsWith('band_')) {
+        const forecastId = key.slice(key.lastIndexOf('_') + 1);
+        return hiddenSeries.has(`forecast_${forecastId}`);
+    }
+    return false;
+}
+/** Pure Y-range calculation from chart data points. */
+function calculateChartYRange(dataToUse, { excludeQuantileBands, forecastId, hiddenSeries, includeHiddenInYScale = false, }) {
+    const allValues = [];
+    dataToUse.forEach(point => {
+        Object.entries(point).forEach(([key, value]) => {
+            if (key === 'date')
+                return;
+            if (!includeHiddenInYScale &&
+                isKeyExcludedFromYScale(key, hiddenSeries)) {
+                return;
+            }
+            // When selectedForecastId is provided, scale from historical + selected forecast + its
+            // quantile band (exclude other forecasts and their quantile values only).
+            if (forecastId !== undefined) {
+                if (key.startsWith('forecast_') && key !== `forecast_${forecastId}`)
+                    return;
+                // Exclude q{quantile}_{otherAnalysisId} - only include selected forecast's quantiles
+                if (key.startsWith('q') && !key.endsWith(`_${forecastId}`))
+                    return;
+            }
+            // When excludeQuantileBands is true, exclude:
+            // 1. Quantile band arrays ([number, number])
+            // 2. Individual quantile values (q{quantile}_{analysisId} properties)
+            // Only include historical and forecast line values
+            if (excludeQuantileBands) {
+                // Skip quantile band arrays
+                if (Array.isArray(value) &&
+                    value.length === 2 &&
+                    typeof value[0] === 'number' &&
+                    typeof value[1] === 'number') {
                     return;
-                // When selectedForecastId is provided, scale from historical + selected forecast + its
-                // quantile band (exclude other forecasts and their quantile values only).
-                if (forecastId !== undefined) {
-                    if (key.startsWith('forecast_') && key !== `forecast_${forecastId}`)
-                        return;
-                    // Exclude q{quantile}_{otherAnalysisId} - only include selected forecast's quantiles
-                    if (key.startsWith('q') && !key.endsWith(`_${forecastId}`))
-                        return;
                 }
-                // When excludeQuantileBands is true, exclude:
-                // 1. Quantile band arrays ([number, number])
-                // 2. Individual quantile values (q{quantile}_{analysisId} properties)
-                // Only include historical and forecast line values
-                if (excludeQuantileBands) {
-                    // Skip quantile band arrays
-                    if (Array.isArray(value) &&
-                        value.length === 2 &&
-                        typeof value[0] === 'number' &&
-                        typeof value[1] === 'number') {
-                        return;
-                    }
-                    // Skip individual quantile values (properties starting with 'q' followed by number/underscore)
-                    // Format: q{quantile}_{analysisId} (e.g., q0.05_123, q0.95_123)
-                    if (key.startsWith('q') && typeof value === 'number') {
-                        return;
-                    }
-                    // Include only historical and forecast line values
-                    if (typeof value === 'number') {
-                        allValues.push(value);
-                    }
+                // Skip individual quantile values (properties starting with 'q' followed by number/underscore)
+                // Format: q{quantile}_{analysisId} (e.g., q0.05_123, q0.95_123)
+                if (key.startsWith('q') && typeof value === 'number') {
                     return;
                 }
-                // When not excluding, include both numbers and quantile band arrays
+                // Include only historical and forecast line values
                 if (typeof value === 'number') {
                     allValues.push(value);
                 }
-                else if (Array.isArray(value) &&
-                    value.length === 2 &&
-                    typeof value[0] === 'number' &&
-                    typeof value[1] === 'number') {
-                    allValues.push(value[0], value[1]);
-                }
-            });
+                return;
+            }
+            // When not excluding, include both numbers and quantile band arrays
+            if (typeof value === 'number') {
+                allValues.push(value);
+            }
+            else if (Array.isArray(value) &&
+                value.length === 2 &&
+                typeof value[0] === 'number' &&
+                typeof value[1] === 'number') {
+                allValues.push(value[0], value[1]);
+            }
         });
-        if (allValues.length === 0) {
-            return { yMin: 0, yMax: 100 };
-        }
-        const min = Math.min(...allValues);
-        const max = Math.max(...allValues);
-        const diff = max - min;
-        return {
-            yMin: min - diff * 0.1,
-            yMax: max + diff * 0.1,
-        };
+    });
+    if (allValues.length === 0) {
+        return { yMin: 0, yMax: 100 };
+    }
+    const min = Math.min(...allValues);
+    const max = Math.max(...allValues);
+    const diff = max - min;
+    return {
+        yMin: min - diff * 0.1,
+        yMax: max + diff * 0.1,
     };
+}
+/**
+ * Hook to calculate yMin and yMax from chart data
+ * Optionally includes quantile values from forecast data
+ */
+function useChartYRange({ baseChartProps, chartData, disableRescaleWhenQuantileChanges, excludeQuantileBands = false, selectedForecastId, }) {
+    const includeHiddenInYScale = baseChartProps.includeHiddenInYScale ?? false;
+    const hiddenSeries = baseChartProps.hiddenSeries;
+    // Store initial Y-range when disableRescaleWhenQuantileChanges is true
+    const stableYRangeRef = useRef(null);
+    const prevBaseChartDataRef = useRef(baseChartProps.chartData);
+    const prevHiddenSeriesKeyRef = useRef(serializeHiddenSeries(hiddenSeries));
+    const calculateYRange = (dataToUse, excludeBands, forecastId) => calculateChartYRange(dataToUse, {
+        excludeQuantileBands: excludeBands,
+        forecastId,
+        hiddenSeries,
+        includeHiddenInYScale,
+    });
     // When disableRescaleWhenQuantileChanges is true, calculate initial stable range
     // If chartData (transformedChartData) is provided, use it WITH quantile bands for initial calculation
     // Then keep it stable when dragging quantiles
@@ -84,7 +125,7 @@ function useChartYRange({ baseChartProps, chartData, disableRescaleWhenQuantileC
         if (!disableRescaleWhenQuantileChanges) {
             return null;
         }
-        // Reset stable range when dataset or selected forecast changes
+        // Reset stable range when dataset, selected forecast, or hidden series changes
         if (prevBaseChartDataRef.current !== baseChartProps.chartData) {
             prevBaseChartDataRef.current = baseChartProps.chartData;
             stableYRangeRef.current = null;
@@ -92,6 +133,11 @@ function useChartYRange({ baseChartProps, chartData, disableRescaleWhenQuantileC
         if (stableYRangeRef.current?.forecastId !== selectedForecastId) {
             stableYRangeRef.current = null;
         }
+        const hiddenSeriesKey = serializeHiddenSeries(hiddenSeries);
+        if (prevHiddenSeriesKeyRef.current !== hiddenSeriesKey) {
+            prevHiddenSeriesKeyRef.current = hiddenSeriesKey;
+            stableYRangeRef.current = null;
+        }
         // If chartData (transformedChartData) is provided, use it WITH quantile bands for initial calculation
         // This ensures IntervalsOverlay includes quantile bands in Y-scale
         const dataToUse = chartData ?? baseChartProps.chartData;
@@ -115,6 +161,8 @@ function useChartYRange({ baseChartProps, chartData, disableRescaleWhenQuantileC
         disableRescaleWhenQuantileChanges,
         excludeQuantileBands,
         selectedForecastId,
+        hiddenSeries,
+        includeHiddenInYScale,
     ]);
     // When disableRescaleWhenQuantileChanges is false, calculate from transformed data
     const dynamicRange = useMemo(() => {
@@ -138,6 +186,8 @@ function useChartYRange({ baseChartProps, chartData, disableRescaleWhenQuantileC
         disableRescaleWhenQuantileChanges,
         excludeQuantileBands,
         selectedForecastId,
+        hiddenSeries,
+        includeHiddenInYScale,
     ]);
     // Return appropriate range
     if (disableRescaleWhenQuantileChanges) {
@@ -150,4 +200,4 @@ function useChartYRange({ baseChartProps, chartData, disableRescaleWhenQuantileC
     return dynamicRange;
 }
 
-export { useChartYRange };
+export { calculateChartYRange, isKeyExcludedFromYScale, useChartYRange };

package/dist/esm/components/widgets/PerformanceChart/performanceChart.helpers.js

@@ -1,4 +1,4 @@
-import { normalizeToMonthStart, getPreviousMonth } from '../../../utils/chartConnectionPoint.js';
+import { normalizeToMonthStart, getNextMonth, getPreviousMonth } from '../../../utils/chartConnectionPoint.js';
 
 /** Legacy: API backtest spaghetti lines used `SPAGHETTI_FORECAST_ID_BASE + i` (spaghetti view now uses drift per-horizon instead). */
 const SPAGHETTI_FORECAST_ID_BASE = 6000;
@@ -36,14 +36,10 @@ function addSpaghettiHistoricalBridgeForSeries(map, dataKey, earliestForecastDat
     row[dataKey] = hist;
     map.set(connectionDate, row);
 }
-/**
- * Converts `performance.model` / `performance.drift` per-horizon forecasts into synthetic
- * backtest-shaped entries: each line is [horizon_1[i], …, horizon_n[i]] as date→value points
- * (aligned by sorted key index per horizon).
- */
-function buildPerHorizonSpaghettiEntries(forecastRoot, horizonKeys) {
-    if (!forecastRoot?.forecasts || horizonKeys.length === 0)
-        return [];
+/** When horizons have different lengths, align on the latest `n` months (suffix), not the oldest. */
+function perHorizonSortedKeyLists(forecastRoot, horizonKeys) {
+    if (!forecastRoot.forecasts || horizonKeys.length === 0)
+        return null;
     const forecasts = forecastRoot.forecasts;
     const sortedHorizons = [...horizonKeys].sort((a, b) => {
         const na = parseInt(a.replace(/\D/g, ''), 10) || 0;
@@ -59,15 +55,45 @@ function buildPerHorizonSpaghettiEntries(forecastRoot, horizonKeys) {
     });
     const lengths = perHorizonKeyLists.map(l => l.length).filter(l => l > 0);
     if (lengths.length === 0)
+        return null;
+    return { sortedHorizons, perHorizonKeyLists };
+}
+function alignedHorizonRowCount(perHorizonKeyLists) {
+    const lengths = perHorizonKeyLists.map(l => l.length).filter(l => l > 0);
+    if (lengths.length === 0)
+        return 0;
+    return Math.min(...lengths);
+}
+function horizonDateKeyAtRow(perHorizonKeyLists, horizonIndex, rowIndex, rowCount) {
+    const keys = perHorizonKeyLists[horizonIndex];
+    if (!keys?.length)
+        return undefined;
+    const offset = keys.length - rowCount;
+    return keys[offset + rowIndex];
+}
+/**
+ * Converts `performance.model` / `performance.drift` per-horizon forecasts into synthetic
+ * backtest-shaped entries: each line is [horizon_1[i], …, horizon_n[i]] as date→value points
+ * (aligned on the latest shared months per horizon).
+ */
+function buildPerHorizonSpaghettiEntries(forecastRoot, horizonKeys) {
+    const aligned = perHorizonSortedKeyLists(forecastRoot ?? {}, horizonKeys);
+    if (!aligned)
+        return [];
+    const { sortedHorizons, perHorizonKeyLists } = aligned;
+    const forecasts = forecastRoot.forecasts;
+    const normalizeDateKey = (d) => d.split(' ')[0];
+    const n = alignedHorizonRowCount(perHorizonKeyLists);
+    if (n === 0)
         return [];
-    const n = Math.min(...lengths);
     const entries = [];
     for (let i = 0; i < n; i++) {
         const forecast_series = {};
         for (let hi = 0; hi < sortedHorizons.length; hi++) {
             const h = sortedHorizons[hi];
-            const keys = perHorizonKeyLists[hi];
-            const dateKey = keys[i];
+            const dateKey = horizonDateKeyAtRow(perHorizonKeyLists, hi, i, n);
+            if (!dateKey)
+                continue;
             const rawVal = forecasts[h]?.[dateKey];
             if (typeof rawVal !== 'number' || !Number.isFinite(rawVal))
                 continue;
@@ -87,29 +113,19 @@ function buildPerHorizonSpaghettiEntries(forecastRoot, horizonKeys) {
 }
 /**
  * Same row alignment as {@link buildPerHorizonSpaghettiEntries}: row `i` uses each horizon's
- * i-th sorted forecast month; `dates[i]` is horizon_1's month at that row (Date column).
+ * latest-aligned forecast month; `dates[i]` is horizon_1's month at that row (Date column).
  * Use this for custom dialog seed + “copy statistical baseline (drift)” prefill.
  */
 function buildDriftSpaghettiMatrixForCustomDialog(driftRoot, horizonKeys) {
-    if (!driftRoot?.forecasts || horizonKeys.length === 0)
+    const aligned = perHorizonSortedKeyLists(driftRoot ?? {}, horizonKeys);
+    if (!aligned)
         return null;
+    const { sortedHorizons, perHorizonKeyLists } = aligned;
     const forecasts = driftRoot.forecasts;
-    const sortedHorizons = [...horizonKeys].sort((a, b) => {
-        const na = parseInt(a.replace(/\D/g, ''), 10) || 0;
-        const nb = parseInt(b.replace(/\D/g, ''), 10) || 0;
-        return na - nb;
-    });
     const normalizeDateKey = (d) => d.split(' ')[0];
-    const perHorizonKeyLists = sortedHorizons.map(h => {
-        const m = forecasts[h];
-        if (!m || typeof m !== 'object')
-            return [];
-        return Object.keys(m).sort((a, b) => normalizeDateKey(a).localeCompare(normalizeDateKey(b)));
-    });
-    const lengths = perHorizonKeyLists.map(l => l.length).filter(l => l > 0);
-    if (lengths.length === 0)
+    const n = alignedHorizonRowCount(perHorizonKeyLists);
+    if (n === 0)
         return null;
-    const n = Math.min(...lengths);
     const dates = [];
     const grid = [];
     const perHorizonDates = [];
@@ -118,15 +134,19 @@ function buildDriftSpaghettiMatrixForCustomDialog(driftRoot, horizonKeys) {
         const dateRow = [];
         for (let hi = 0; hi < sortedHorizons.length; hi++) {
             const h = sortedHorizons[hi];
-            const keys = perHorizonKeyLists[hi];
-            const dateKey = keys[i];
+            const dateKey = horizonDateKeyAtRow(perHorizonKeyLists, hi, i, n);
+            if (!dateKey) {
+                row.push(0);
+                dateRow.push('');
+                continue;
+            }
             dateRow.push(normalizeToMonthStart(normalizeDateKey(dateKey)));
             const rawVal = forecasts[h]?.[dateKey];
             const v = typeof rawVal === 'number' && Number.isFinite(rawVal) ? rawVal : NaN;
             row.push(v);
         }
-        const d0 = perHorizonKeyLists[0][i];
-        dates.push(normalizeToMonthStart(normalizeDateKey(d0)));
+        const d0 = horizonDateKeyAtRow(perHorizonKeyLists, 0, i, n);
+        dates.push(d0 ? normalizeToMonthStart(normalizeDateKey(d0)) : '');
         perHorizonDates.push(dateRow);
         grid.push(row.map(c => (Number.isFinite(c) ? c : 0)));
     }
@@ -136,6 +156,85 @@ function buildDriftSpaghettiMatrixForCustomDialog(driftRoot, horizonKeys) {
         perHorizonDates,
     };
 }
+function latestHistoricalMonthKey(historicalByDate) {
+    let latest = null;
+    historicalByDate.forEach((_, d) => {
+        if (!latest || d.localeCompare(latest) > 0)
+            latest = d;
+    });
+    return latest;
+}
+/**
+ * Append monthly spaghetti rows after drift backtests so the dialog (and chart) reach the latest
+ * historical month (e.g. Apr 2026), not only the last drift origin (e.g. Nov 2025).
+ */
+function extendCustomPerformanceDriftSeedToHistoricalEnd(seed, historicalByDate) {
+    const latest = latestHistoricalMonthKey(historicalByDate);
+    if (!latest || seed.dates.length === 0)
+        return seed;
+    const norm = (d) => normalizeToMonthStart(String(d).split(' ')[0] ?? d);
+    const dates = seed.dates.map(d => norm(d));
+    const grid = seed.grid.map(r => [...r]);
+    const perHorizonDates = seed.perHorizonDates.map(row => row.map(d => norm(String(d))));
+    const horizonCount = grid[0]?.length ?? perHorizonDates[0]?.length ?? 0;
+    if (horizonCount === 0)
+        return seed;
+    let lastOrigin = dates[dates.length - 1];
+    if (!lastOrigin)
+        return seed;
+    while (lastOrigin.localeCompare(latest) < 0) {
+        const nextOrigin = norm(getNextMonth(lastOrigin));
+        const prevPh = perHorizonDates[perHorizonDates.length - 1];
+        const newPh = prevPh.length === horizonCount
+            ? prevPh.map(d => norm(getNextMonth(norm(d))))
+            : Array.from({ length: horizonCount }, () => nextOrigin);
+        perHorizonDates.push(newPh);
+        dates.push(nextOrigin);
+        const baselineRow = spaghettiGridFromHistoricalPreviousMonth([newPh], horizonCount, historicalByDate);
+        grid.push(baselineRow[0] ?? Array.from({ length: horizonCount }, () => 0));
+        lastOrigin = nextOrigin;
+    }
+    return { dates, grid, perHorizonDates };
+}
+/** Pad a saved custom matrix with drift/baseline rows so edit + chart cover latest backtest months. */
+function extendCustomPerformanceMatrixWithDriftSeed(saved, driftSeed, baselineGrid) {
+    const norm = (d) => normalizeToMonthStart(String(d).split(' ')[0] ?? d);
+    const horizonCount = saved.horizonKeys.length;
+    const savedByDate = new Map();
+    for (let r = 0; r < saved.dates.length; r++) {
+        savedByDate.set(norm(saved.dates[r]), {
+            grid: saved.grid[r],
+            perHorizon: saved.perHorizonDates?.[r],
+        });
+    }
+    const dates = [];
+    const grid = [];
+    const perHorizonDates = [];
+    for (let i = 0; i < driftSeed.dates.length; i++) {
+        const d = norm(driftSeed.dates[i]);
+        if (!d)
+            continue;
+        dates.push(d);
+        const existing = savedByDate.get(d);
+        if (existing) {
+            grid.push([...existing.grid]);
+            const ph = existing.perHorizon && existing.perHorizon.length === horizonCount
+                ? existing.perHorizon.map(c => norm(String(c)))
+                : (driftSeed.perHorizonDates[i]?.map(c => norm(String(c))) ?? []);
+            perHorizonDates.push(ph);
+            continue;
+        }
+        grid.push(baselineGrid?.[i] ? [...baselineGrid[i]] : [...driftSeed.grid[i]]);
+        perHorizonDates.push((driftSeed.perHorizonDates[i] ?? []).map(c => norm(String(c))));
+    }
+    return {
+        v: saved.v,
+        dates,
+        horizonKeys: [...saved.horizonKeys],
+        grid,
+        perHorizonDates,
+    };
+}
 /**
  * Prefill for custom performance when copying drift layout: each spaghetti row is flat at the
  * historical value for the month before the earliest forecast month in that row (same anchor as
@@ -588,4 +687,4 @@ function calculateYRangeFromChartData(chartData) {
     };
 }
 
-export { SPAGHETTI_DRIFT_PER_HORIZON_ID_BASE, SPAGHETTI_FORECAST_ID_BASE, SPAGHETTI_MODEL_PER_HORIZON_ID_BASE, averageForecastErrorsVsHistoricalForMatrixColumn, buildDriftSpaghettiMatrixForCustomDialog, buildPerHorizonSpaghettiEntries, buildSpaghettiMergedChartData, calculateAccuracy, calculateBenefit, calculateROI, calculateROIMultiple, calculateYRangeFromChartData, filterChartDataLast24Months, filterSpaghettiDataFromEarliestForecastStart, formatAccuracy, formatBenefit, formatError, formatROI, getForecastModelDisplayName, isSpaghettiDriftPerHorizonLineId, isSpaghettiModelPerHorizonLineId, mergeHistoricalIntoSpaghettiChartData, mergeSpaghettiMergedBases, mergeSpaghettiUserSeriesFromForecastData, spaghettiGridFromHistoricalPreviousMonth };
+export { SPAGHETTI_DRIFT_PER_HORIZON_ID_BASE, SPAGHETTI_FORECAST_ID_BASE, SPAGHETTI_MODEL_PER_HORIZON_ID_BASE, averageForecastErrorsVsHistoricalForMatrixColumn, buildDriftSpaghettiMatrixForCustomDialog, buildPerHorizonSpaghettiEntries, buildSpaghettiMergedChartData, calculateAccuracy, calculateBenefit, calculateROI, calculateROIMultiple, calculateYRangeFromChartData, extendCustomPerformanceDriftSeedToHistoricalEnd, extendCustomPerformanceMatrixWithDriftSeed, filterChartDataLast24Months, filterSpaghettiDataFromEarliestForecastStart, formatAccuracy, formatBenefit, formatError, formatROI, getForecastModelDisplayName, isSpaghettiDriftPerHorizonLineId, isSpaghettiModelPerHorizonLineId, latestHistoricalMonthKey, mergeHistoricalIntoSpaghettiChartData, mergeSpaghettiMergedBases, mergeSpaghettiUserSeriesFromForecastData, spaghettiGridFromHistoricalPreviousMonth };

package/dist/esm/index.js

@@ -21,6 +21,8 @@ export { Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader,
 export { ChartLegend, ChartTooltip } from './components/ui/Chart/Chart.js';
 export { THEMES } from './components/ui/Chart/Chart.types.js';
 export { ChartAreaInteractive, chartConfig } from './components/ui/ChartAreaInteractive/ChartAreaInteractive.js';
+export { DRAG_TIME_RANGE_PREFIX, encodeDragTimeRange, filterDataForTimeRange, findPinPositionForDate, formatNumber, isAnalysisDone, isAnalysisFailed, isAnalysisNotFailed, isTimeRangePreset, longDateFormatter, parseDragTimeRange, shortDateFormatter } from './components/ui/ChartAreaInteractive/ChartAreaInteractive.helpers.js';
+export { ChartLines, FORECAST_COLORS_MAP, FORECAST_LINE_COLORS, getForecastColor, getForecastQuantileBandColor, resolveQuantileBandFillForForecastLine } from './components/ui/ChartAreaInteractive/ChartLines.js';
 export { Chat } from './components/ui/Chat/Chat.js';
 export { formatChatTranscript, usedPresetIdsFromMessages } from './components/ui/Chat/chat-preset-utils.js';
 export { ChatChrome } from './components/ui/Chat/ChatChrome/ChatChrome.js';
@@ -111,7 +113,7 @@ export { DriversComparisonChart } from './components/widgets/DriversComparisonCh
 export { DRIVER_COMPARISON_CHART_LEAD_MONTHS, DRIVER_FORECAST_ID_BASE, INITIAL_VISIBLE_SERIES_COUNT, applyDriversComparisonViewToPayload, buildDriversComparisonChartData, formatLagMonthsLabel, formatSeriesImportance, getLagDisplayForView, mergeBacktestsChartData, mergeDatasetHistoricalWithBacktestsChartData, parseLagMonthsFromLabel, resolveDriverLagLabel, shiftNormalizedSeriesForward } from './components/widgets/DriversComparisonChart/driversComparisonChart.helpers.js';
 export { PerformanceChart } from './components/widgets/PerformanceChart/PerformanceChart.js';
 export { PerformanceTable } from './components/widgets/PerformanceChart/PerformanceTable.js';
-export { SPAGHETTI_DRIFT_PER_HORIZON_ID_BASE, SPAGHETTI_MODEL_PER_HORIZON_ID_BASE, averageForecastErrorsVsHistoricalForMatrixColumn, buildDriftSpaghettiMatrixForCustomDialog, buildPerHorizonSpaghettiEntries, buildSpaghettiMergedChartData, calculateYRangeFromChartData, getForecastModelDisplayName, spaghettiGridFromHistoricalPreviousMonth } from './components/widgets/PerformanceChart/performanceChart.helpers.js';
+export { SPAGHETTI_DRIFT_PER_HORIZON_ID_BASE, SPAGHETTI_MODEL_PER_HORIZON_ID_BASE, averageForecastErrorsVsHistoricalForMatrixColumn, buildDriftSpaghettiMatrixForCustomDialog, buildPerHorizonSpaghettiEntries, buildSpaghettiMergedChartData, calculateYRangeFromChartData, extendCustomPerformanceDriftSeedToHistoricalEnd, extendCustomPerformanceMatrixWithDriftSeed, getForecastModelDisplayName, latestHistoricalMonthKey, spaghettiGridFromHistoricalPreviousMonth } from './components/widgets/PerformanceChart/performanceChart.helpers.js';
 export { SPAGHETTI_LOCAL_LS_USER_SERIES_ROW_ID, SPAGHETTI_TIME_SERIES_MATRIX_V, tryParseSpaghettiPerformanceMatrix } from './components/widgets/PerformanceChart/performanceChartUserSeries.js';
 export { SybilionAppHeader } from './components/widgets/SybilionAppHeader/SybilionAppHeader.js';
 export { SybilionAuthLayout } from './components/widgets/SybilionAuthLayout/SybilionAuthLayout.js';

package/dist/esm/types/src/components/ui/Chart/components/BaseChartWrapper.d.ts

@@ -58,6 +58,8 @@ export interface BaseChartWrapperProps {
     showActiveDots?: boolean;
     overlayElements?: ReactNode;
     hiddenSeries?: Set<string>;
+    /** When false (default), hidden series values are excluded from Y-axis domain calculation. */
+    includeHiddenInYScale?: boolean;
     excludeLegendIds?: number[];
     onAnalysisSelect?: (analysisId: number | string) => void;
     onFailedAnalysisClick?: (analysisId?: number | string) => void;

package/dist/esm/types/src/components/ui/ChartAreaInteractive/ChartAreaInteractive.helpers.d.ts

@@ -9,8 +9,6 @@ declare const timeRangeToMonths: {
     readonly All: 12;
 };
 export type TimeRangePreset = keyof typeof timeRangeToMonths;
-/** @deprecated Use `TimeRangePreset` or `string` for brush-encoded ranges. */
-export type TimeRange = TimeRangePreset;
 export declare const DRAG_TIME_RANGE_PREFIX: "__drag:";
 export declare function encodeDragTimeRange(a: Date, b: Date): string;
 export declare function parseDragTimeRange(s: string): {
@@ -42,4 +40,7 @@ export declare const isAnalysisFailed: (analysis: Analysis | {
 export declare const isAnalysisNotFailed: (analysis: Analysis | {
     status?: string;
 }) => boolean;
+export declare const isAnalysisDone: (analysis: Analysis | {
+    status?: string;
+}) => boolean;
 export {};

package/dist/esm/types/src/components/ui/ChartAreaInteractive/index.d.ts

@@ -1,3 +1,5 @@
 export * from './ChartAreaInteractive';
+export * from './ChartAreaInteractive.helpers';
 export * from './ChartAreaInteractive.types';
+export * from './ChartLines';
 export type { OverlayMode } from './ChartAreaInteractive.types';

package/dist/esm/types/src/components/ui/ChartAreaInteractive/overlays/useChartYRange.d.ts

@@ -7,6 +7,21 @@ interface UseChartYRangeOptions {
     excludeQuantileBands?: boolean;
     selectedForecastId?: number;
 }
+export interface CalculateChartYRangeOptions {
+    excludeQuantileBands: boolean;
+    forecastId?: number;
+    hiddenSeries?: Set<string>;
+    includeHiddenInYScale?: boolean;
+}
+/**
+ * Returns true when a chart data key should be skipped for Y-scale (series hidden).
+ */
+export declare function isKeyExcludedFromYScale(key: string, hiddenSeries?: Set<string>): boolean;
+/** Pure Y-range calculation from chart data points. */
+export declare function calculateChartYRange(dataToUse: ChartDataPoint[], { excludeQuantileBands, forecastId, hiddenSeries, includeHiddenInYScale, }: CalculateChartYRangeOptions): {
+    yMin: number;
+    yMax: number;
+};
 /**
  * Hook to calculate yMin and yMax from chart data
  * Optionally includes quantile values from forecast data

package/dist/esm/types/src/components/ui/ChartAreaInteractive/overlays/useChartYRange.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/src/components/widgets/PerformanceChart/index.d.ts

@@ -1,4 +1,4 @@
 export { PerformanceChart, type PerformanceChartPayload, type PerformanceChartProps, type PerformanceViewTab, } from './PerformanceChart';
 export { type AdjustParameters, type ForecastModelData, PerformanceTable, } from './PerformanceTable';
-export { SPAGHETTI_DRIFT_PER_HORIZON_ID_BASE, SPAGHETTI_MODEL_PER_HORIZON_ID_BASE, averageForecastErrorsVsHistoricalForMatrixColumn, buildDriftSpaghettiMatrixForCustomDialog, buildPerHorizonSpaghettiEntries, buildSpaghettiMergedChartData, calculateYRangeFromChartData, getForecastModelDisplayName, spaghettiGridFromHistoricalPreviousMonth, } from './performanceChart.helpers';
+export { SPAGHETTI_DRIFT_PER_HORIZON_ID_BASE, SPAGHETTI_MODEL_PER_HORIZON_ID_BASE, averageForecastErrorsVsHistoricalForMatrixColumn, buildDriftSpaghettiMatrixForCustomDialog, buildPerHorizonSpaghettiEntries, extendCustomPerformanceDriftSeedToHistoricalEnd, extendCustomPerformanceMatrixWithDriftSeed, latestHistoricalMonthKey, buildSpaghettiMergedChartData, calculateYRangeFromChartData, getForecastModelDisplayName, spaghettiGridFromHistoricalPreviousMonth, } from './performanceChart.helpers';
 export { SPAGHETTI_LOCAL_LS_USER_SERIES_ROW_ID, SPAGHETTI_TIME_SERIES_MATRIX_V, tryParseSpaghettiPerformanceMatrix, type SpaghettiPerformanceMatrixPayload, } from './performanceChartUserSeries';