@363045841yyt/klinechart-core 0.7.9 → 0.7.10

package/src/engine/indicators/__tests__/registerBuiltins.test.ts

@@ -0,0 +1,380 @@
+import { describe, expect, it, vi } from 'vitest'
+import { getRegisteredIndicatorDefinition } from '../indicatorDefinitionRegistry'
+import { getBuiltinIndicatorDefinitions } from '../registerBuiltins'
+
+describe('builtin indicator registration', () => {
+  it('loads all builtin indicator definitions through decorators', () => {
+    const definitions = getBuiltinIndicatorDefinitions()
+
+    expect(definitions).toHaveLength(40)
+    expect(definitions.map((definition) => definition.name)).toEqual(
+      expect.arrayContaining([
+        'ma',
+        'boll',
+        'rsi',
+        'macd',
+        'volume',
+        'volumeProfile',
+        'zones',
+      ]),
+    )
+  })
+
+  it('allows builtin definitions to be queried by display name', () => {
+    expect(getRegisteredIndicatorDefinition('RSI')?.name).toBe('rsi')
+    expect(getRegisteredIndicatorDefinition('MACD')?.name).toBe('macd')
+    expect(getRegisteredIndicatorDefinition('VOL')?.name).toBe('volume')
+  })
+
+  it('registers metadata config updaters for stage 4A indicators', () => {
+    expect(getRegisteredIndicatorDefinition('RSI')?.updateConfig).toBeTypeOf('function')
+    expect(getRegisteredIndicatorDefinition('MACD')?.updateConfig).toBeTypeOf('function')
+    expect(getRegisteredIndicatorDefinition('VOL')?.updateConfig).toBeTypeOf('function')
+    expect(getRegisteredIndicatorDefinition('VOLUME_PROFILE')?.updateConfig).toBeTypeOf('function')
+  })
+
+  it('registers metadata config updaters for stage 4B indicators', () => {
+    const expectedIndicators = [
+      'CCI', 'STOCH', 'MOM', 'WMSR', 'KST', 'FASTK', 'ATR',
+      'WMA', 'DEMA', 'TEMA', 'HMA', 'KAMA', 'SAR',
+      'SUPERTREND', 'KELTNER', 'DONCHIAN', 'ICHIMOKU',
+      'ROC', 'TRIX', 'HV', 'PARKINSON', 'CHAIKIN_VOL',
+      'VMA', 'OBV', 'PVT', 'VWAP', 'CMF', 'MFI',
+      'PIVOT', 'FIB', 'STRUCTURE', 'ZONES',
+    ]
+    for (const id of expectedIndicators) {
+      expect(getRegisteredIndicatorDefinition(id)?.updateConfig).toBeTypeOf('function')
+    }
+  })
+
+  it('routes stage 4A metadata config updates to scheduler methods', () => {
+    const scheduler = {
+      updateRSIConfig: vi.fn(),
+      updateMACDConfig: vi.fn(),
+      updateVolumeProfileConfig: vi.fn(),
+    }
+
+    getRegisteredIndicatorDefinition('RSI')?.updateConfig?.(scheduler, { period1: 7 }, 'RSI_0')
+    getRegisteredIndicatorDefinition('MACD')?.updateConfig?.(scheduler, { fastPeriod: 8 }, 'MACD_0')
+    getRegisteredIndicatorDefinition('VOLUME_PROFILE')?.updateConfig?.(scheduler, { bins: 32 }, 'VP_0')
+    getRegisteredIndicatorDefinition('VOL')?.updateConfig?.(scheduler, {}, 'VOL_0')
+
+    expect(scheduler.updateRSIConfig).toHaveBeenCalledWith({ period1: 7 }, 'RSI_0')
+    expect(scheduler.updateMACDConfig).toHaveBeenCalledWith({ fastPeriod: 8 }, 'MACD_0')
+    expect(scheduler.updateVolumeProfileConfig).toHaveBeenCalledWith({ bins: 32 }, 'VP_0')
+  })
+
+  it('routes stage 4B metadata config updates to scheduler methods', () => {
+    const scheduler = {
+      updateCCIConfig: vi.fn(),
+      updateATRConfig: vi.fn(),
+      updateChaikinVolConfig: vi.fn(),
+      updateZonesConfig: vi.fn(),
+    }
+
+    getRegisteredIndicatorDefinition('CCI')?.updateConfig?.(scheduler, { period: 14 }, 'CCI_0')
+    getRegisteredIndicatorDefinition('ATR')?.updateConfig?.(scheduler, { period: 10 }, 'ATR_0')
+    getRegisteredIndicatorDefinition('CHAIKIN_VOL')?.updateConfig?.(scheduler, { emaPeriod: 10 }, 'CV_0')
+    getRegisteredIndicatorDefinition('ZONES')?.updateConfig?.(scheduler, { showFVG: true }, 'Z_0')
+
+    expect(scheduler.updateCCIConfig).toHaveBeenCalledWith({ period: 14 }, 'CCI_0')
+    expect(scheduler.updateATRConfig).toHaveBeenCalledWith({ period: 10 }, 'ATR_0')
+    expect(scheduler.updateChaikinVolConfig).toHaveBeenCalledWith({ emaPeriod: 10 }, 'CV_0')
+    expect(scheduler.updateZonesConfig).toHaveBeenCalledWith({ showFVG: true }, 'Z_0')
+  })
+
+  it('registers dedicated scale renderer factories for stage 5A indicators', () => {
+    const expectedIndicators = [
+      'VOL', 'MACD', 'RSI', 'CCI', 'STOCH', 'MOM', 'WMSR', 'KST', 'FASTK', 'ATR',
+    ]
+
+    for (const id of expectedIndicators) {
+      expect(getRegisteredIndicatorDefinition(id)?.scaleRendererFactory).toBeTypeOf('function')
+    }
+  })
+
+  it('creates scale renderers through stage 5A metadata factories', () => {
+    const rsiScaleRenderer = getRegisteredIndicatorDefinition('RSI')?.scaleRendererFactory?.({
+      indicatorId: 'RSI',
+      paneId: 'RSI_0',
+      axisWidth: 80,
+      yPaddingPx: 4,
+      getCrosshair: () => null,
+    })
+    const volumeScaleRenderer = getRegisteredIndicatorDefinition('VOL')?.scaleRendererFactory?.({
+      indicatorId: 'VOLUME',
+      paneId: 'VOLUME_0',
+      axisWidth: 80,
+      yPaddingPx: 4,
+      getCrosshair: () => null,
+    })
+
+    expect(rsiScaleRenderer?.name).toBe('rsiScale_RSI_0')
+    expect(volumeScaleRenderer?.name).toBe('volumeScale_VOLUME_0')
+  })
+
+  it('registers generic scale metadata for stage 5B indicators', () => {
+    const expected: Record<string, { indicatorKey: string; label: string; decimals: number }> = {
+      WMA: { indicatorKey: 'wma', label: 'WMA', decimals: 2 },
+      DEMA: { indicatorKey: 'dema', label: 'DEMA', decimals: 2 },
+      TEMA: { indicatorKey: 'tema', label: 'TEMA', decimals: 2 },
+      HMA: { indicatorKey: 'hma', label: 'HMA', decimals: 2 },
+      KAMA: { indicatorKey: 'kama', label: 'KAMA', decimals: 2 },
+      SAR: { indicatorKey: 'sar', label: 'SAR', decimals: 4 },
+      SUPERTREND: { indicatorKey: 'supertrend', label: 'SuperTrend', decimals: 2 },
+      KELTNER: { indicatorKey: 'keltner', label: 'Keltner', decimals: 2 },
+      DONCHIAN: { indicatorKey: 'donchian', label: 'Donchian', decimals: 2 },
+      ICHIMOKU: { indicatorKey: 'ichimoku', label: 'Ichimoku', decimals: 2 },
+      ROC: { indicatorKey: 'roc', label: 'ROC', decimals: 2 },
+      TRIX: { indicatorKey: 'trix', label: 'TRIX', decimals: 6 },
+      HV: { indicatorKey: 'hv', label: 'HV', decimals: 2 },
+      PARKINSON: { indicatorKey: 'parkinson', label: 'Parkinson', decimals: 2 },
+      CHAIKIN_VOL: { indicatorKey: 'chaikinVol', label: 'ChaikinVol', decimals: 2 },
+      VMA: { indicatorKey: 'vma', label: 'VMA', decimals: 0 },
+      OBV: { indicatorKey: 'obv', label: 'OBV', decimals: 0 },
+      PVT: { indicatorKey: 'pvt', label: 'PVT', decimals: 0 },
+      VWAP: { indicatorKey: 'vwap', label: 'VWAP', decimals: 2 },
+      CMF: { indicatorKey: 'cmf', label: 'CMF', decimals: 4 },
+      MFI: { indicatorKey: 'mfi', label: 'MFI', decimals: 2 },
+      PIVOT: { indicatorKey: 'pivot', label: 'Pivot', decimals: 2 },
+      FIB: { indicatorKey: 'fib', label: 'Fib', decimals: 4 },
+      STRUCTURE: { indicatorKey: 'structure', label: 'Structure', decimals: 2 },
+      ZONES: { indicatorKey: 'zones', label: 'Zones', decimals: 2 },
+      VOLUME_PROFILE: { indicatorKey: 'volumeProfile', label: 'VP', decimals: 0 },
+    }
+
+    for (const [id, scale] of Object.entries(expected)) {
+      expect(getRegisteredIndicatorDefinition(id)?.scale).toEqual(scale)
+    }
+  })
+
+  it('creates generic scale renderers through stage 5B metadata', () => {
+    const definition = getRegisteredIndicatorDefinition('WMA')
+    expect(definition?.scale).toBeDefined()
+  })
+
+  it('registers main pane renderer metadata for stage 6A-1 indicators', () => {
+    const expected: Record<string, string> = {
+      MA: 'ma',
+      BOLL: 'boll',
+      EXPMA: 'expma',
+      ENE: 'ene',
+    }
+
+    for (const [id, rendererName] of Object.entries(expected)) {
+      expect(getRegisteredIndicatorDefinition(id)?.mainPane?.rendererName).toBe(rendererName)
+    }
+  })
+
+  it('creates main pane renderers through stage 6A-1 metadata factories', () => {
+    const maRenderer = getRegisteredIndicatorDefinition('MA')?.rendererFactory({ paneId: 'main', indicatorId: 'MA' })
+    const bollRenderer = getRegisteredIndicatorDefinition('BOLL')?.rendererFactory({ paneId: 'main', indicatorId: 'BOLL' })
+
+    expect(maRenderer?.name).toBe('ma')
+    expect(bollRenderer?.name).toBe('boll')
+  })
+
+  it('registers main pane renderer metadata for stage 6A-2 indicators', () => {
+    const expected: Record<string, string> = {
+      WMA: 'wma_main',
+      DEMA: 'dema_main',
+      TEMA: 'tema_main',
+      HMA: 'hma_main',
+      KAMA: 'kama_main',
+      SAR: 'sar_main',
+      SUPERTREND: 'supertrend_main',
+      KELTNER: 'keltner_main',
+      DONCHIAN: 'donchian_main',
+      ICHIMOKU: 'ichimoku_main',
+      PIVOT: 'pivot_main',
+      FIB: 'fib_main',
+      STRUCTURE: 'structure_main',
+      ZONES: 'zones_main',
+    }
+
+    for (const [id, rendererName] of Object.entries(expected)) {
+      expect(getRegisteredIndicatorDefinition(id)?.mainPane?.rendererName).toBe(rendererName)
+    }
+  })
+
+  it('creates overlay main pane renderers through stage 6A-2 metadata factories', () => {
+    const wma = getRegisteredIndicatorDefinition('WMA')?.rendererFactory({ paneId: 'main', indicatorId: 'WMA' })
+    const zones = getRegisteredIndicatorDefinition('ZONES')?.rendererFactory({ paneId: 'main', indicatorId: 'ZONES' })
+
+    expect(wma?.name).toBe('wma_main')
+    expect(zones?.name).toBe('zones_main')
+  })
+
+  it('registers overlay main config metadata for stage 6B-2 indicators', () => {
+    const ids = [
+      'WMA', 'DEMA', 'TEMA', 'HMA', 'KAMA',
+      'SAR', 'SUPERTREND', 'KELTNER', 'DONCHIAN',
+      'ICHIMOKU', 'PIVOT', 'FIB', 'STRUCTURE', 'ZONES',
+    ]
+
+    for (const id of ids) {
+      expect(getRegisteredIndicatorDefinition(id)?.mainPane?.toActiveConfig).toBeTypeOf('function')
+    }
+  })
+
+  it('builds overlay main active configs through stage 6B-2 metadata', () => {
+    expect(getRegisteredIndicatorDefinition('WMA')?.mainPane?.toActiveConfig?.({ period: 10 }, false)).toEqual({
+      period: 10, showWMA: false,
+    })
+
+    expect(getRegisteredIndicatorDefinition('KELTNER')?.mainPane?.toActiveConfig?.({ emaPeriod: 20 }, false)).toEqual({
+      emaPeriod: 20, showUpper: false, showMiddle: false, showLower: false,
+    })
+
+    expect(getRegisteredIndicatorDefinition('ICHIMOKU')?.mainPane?.toActiveConfig?.({}, false)).toEqual({
+      showTenkan: false, showKijun: false, showSpanA: false,
+      showSpanB: false, showChikou: false, showCloud: false,
+    })
+
+    expect(getRegisteredIndicatorDefinition('ZONES')?.mainPane?.toActiveConfig?.({}, false)).toEqual({
+      showFVG: false, showOB: false, showFilledZones: false,
+    })
+  })
+
+  it('registers base main config metadata for stage 6B-1 indicators', () => {
+    for (const id of ['MA', 'BOLL', 'EXPMA', 'ENE']) {
+      const definition = getRegisteredIndicatorDefinition(id)
+      expect(definition?.updateConfig).toBeTypeOf('function')
+      expect(definition?.mainPane?.toActiveConfig).toBeTypeOf('function')
+    }
+  })
+
+  it('builds base main active configs through stage 6B-1 metadata', () => {
+    expect(getRegisteredIndicatorDefinition('MA')?.mainPane?.toActiveConfig?.({}, false)).toEqual({
+      ma5: false,
+      ma10: false,
+      ma20: false,
+      ma30: false,
+      ma60: false,
+    })
+    expect(getRegisteredIndicatorDefinition('BOLL')?.mainPane?.toActiveConfig?.({ period: 20 }, false)).toEqual({
+      period: 20,
+      showUpper: false,
+      showMiddle: false,
+      showLower: false,
+      showBand: false,
+    })
+    expect(getRegisteredIndicatorDefinition('EXPMA')?.mainPane?.toActiveConfig?.({}, false)).toBeNull()
+    expect(getRegisteredIndicatorDefinition('ENE')?.mainPane?.toActiveConfig?.({}, false)).toBeNull()
+  })
+
+  it('routes base main metadata config updates to scheduler methods', () => {
+    const scheduler = {
+      updateMAConfig: vi.fn(),
+      updateBOLLConfig: vi.fn(),
+      updateEXPMAConfig: vi.fn(),
+      updateENEConfig: vi.fn(),
+    }
+
+    getRegisteredIndicatorDefinition('MA')?.updateConfig?.(scheduler, { ma5: true }, 'main')
+    getRegisteredIndicatorDefinition('BOLL')?.updateConfig?.(scheduler, { period: 20 }, 'main')
+    getRegisteredIndicatorDefinition('EXPMA')?.updateConfig?.(scheduler, { fastPeriod: 12 }, 'main')
+    getRegisteredIndicatorDefinition('ENE')?.updateConfig?.(scheduler, { period: 10 }, 'main')
+
+    expect(scheduler.updateMAConfig).toHaveBeenCalledWith({ ma5: true })
+    expect(scheduler.updateBOLLConfig).toHaveBeenCalledWith({ period: 20 })
+    expect(scheduler.updateEXPMAConfig).toHaveBeenCalledWith({ fastPeriod: 12 })
+    expect(scheduler.updateENEConfig).toHaveBeenCalledWith({ period: 10 })
+  })
+
+  it('registers semantic apply metadata for stage 7A main indicators', () => {
+    for (const id of ['MA', 'BOLL', 'EXPMA', 'ENE']) {
+      expect(getRegisteredIndicatorDefinition(id)?.semantic?.apply).toBeTypeOf('function')
+    }
+  })
+
+  it('routes semantic main indicator configs through stage 7A metadata', () => {
+    const chart = { updateRendererConfig: vi.fn() }
+
+    getRegisteredIndicatorDefinition('MA')?.semantic?.apply?.(chart, {
+      type: 'MA',
+      enabled: true,
+      params: { periods: [5, 20, 99] },
+    })
+    getRegisteredIndicatorDefinition('BOLL')?.semantic?.apply?.(chart, {
+      type: 'BOLL',
+      enabled: true,
+      params: { period: 21, multiplier: 2.5 },
+    })
+    getRegisteredIndicatorDefinition('EXPMA')?.semantic?.apply?.(chart, {
+      type: 'EXPMA',
+      enabled: true,
+      params: {},
+    })
+    getRegisteredIndicatorDefinition('ENE')?.semantic?.apply?.(chart, {
+      type: 'ENE',
+      enabled: true,
+    })
+
+    expect(chart.updateRendererConfig).toHaveBeenCalledWith('ma', { ma5: true, ma20: true })
+    expect(chart.updateRendererConfig).toHaveBeenCalledWith('boll', { period: 21, multiplier: 2.5 })
+    expect(chart.updateRendererConfig).toHaveBeenCalledWith('expma', { fastPeriod: 12, slowPeriod: 50 })
+    expect(chart.updateRendererConfig).toHaveBeenCalledWith('ene', { period: 10, deviation: 11 })
+  })
+
+  it('registers main pane price range metadata for stage 8A indicators', () => {
+    for (const id of ['MA', 'BOLL', 'EXPMA', 'ENE']) {
+      expect(getRegisteredIndicatorDefinition(id)?.mainPane?.computePriceRange).toBeTypeOf('function')
+    }
+  })
+
+  it('registers main pane render state composer metadata for stage 8B indicators', () => {
+    for (const id of ['MA', 'BOLL', 'EXPMA', 'ENE']) {
+      expect(getRegisteredIndicatorDefinition(id)?.mainPane?.composeRenderState).toBeTypeOf('function')
+    }
+  })
+
+  it('registers visible state composer metadata for stage 8C-A indicators', () => {
+    for (const id of ['WMA', 'DEMA', 'TEMA', 'HMA', 'KAMA', 'ROC', 'ChaikinVol', 'OBV', 'PVT', 'VWAP']) {
+      expect(getRegisteredIndicatorDefinition(id)?.visibleState?.compose).toBeTypeOf('function')
+    }
+  })
+
+  it('registers visible state composer metadata for stage 8C-B indicators', () => {
+    for (const id of ['RSI', 'STOCH', 'FASTK', 'MFI', 'WMSR', 'CMF']) {
+      expect(getRegisteredIndicatorDefinition(id)?.visibleState?.compose).toBeTypeOf('function')
+    }
+  })
+
+  it('registers visible state composer metadata for stage 8C-C indicators', () => {
+    for (const id of ['MOM', 'KST', 'ATR', 'HV', 'PARKINSON', 'VMA', 'TRIX']) {
+      expect(getRegisteredIndicatorDefinition(id)?.visibleState?.compose).toBeTypeOf('function')
+    }
+  })
+
+  it('registers visible state composer metadata for stage 8C-D1 MACD indicator', () => {
+    expect(getRegisteredIndicatorDefinition('MACD')?.visibleState?.compose).toBeTypeOf('function')
+  })
+
+  it('registers visible state composer metadata for stage 8C-D2 overlay indicators', () => {
+    for (const id of ['SAR', 'SUPERTREND', 'KELTNER', 'DONCHIAN', 'ICHIMOKU', 'PIVOT', 'FIB']) {
+      expect(getRegisteredIndicatorDefinition(id)?.visibleState?.compose).toBeTypeOf('function')
+    }
+  })
+
+  it('registers visible state composer metadata for stage 8C-D2-B structure indicators', () => {
+    for (const id of ['STRUCTURE', 'ZONES', 'VOLUME_PROFILE']) {
+      expect(getRegisteredIndicatorDefinition(id)?.visibleState?.compose).toBeTypeOf('function')
+    }
+  })
+
+  it('registers visible state composer metadata for all composed visible sub indicators', () => {
+    const ids = [
+      'RSI', 'CCI', 'STOCH', 'MOM', 'WMSR', 'FASTK', 'MACD',
+      'ATR', 'WMA', 'DEMA', 'TEMA', 'HMA', 'KAMA',
+      'SAR', 'SUPERTREND', 'KELTNER', 'DONCHIAN', 'ICHIMOKU',
+      'ROC', 'TRIX', 'HV', 'PARKINSON', 'CHAIKIN_VOL',
+      'VMA', 'OBV', 'PVT', 'VWAP', 'CMF', 'MFI',
+      'KST', 'PIVOT', 'FIB', 'STRUCTURE', 'ZONES', 'VOLUME_PROFILE',
+    ]
+
+    for (const id of ids) {
+      expect(getRegisteredIndicatorDefinition(id)?.visibleState?.compose).toBeTypeOf('function')
+    }
+  })
+})

package/src/engine/indicators/__tests__/scheduler.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { IndicatorScheduler } from '../scheduler'
+import { getBuiltinIndicatorDefinitions } from '../registerBuiltins'
 import { MA_STATE_KEY, EMPTY_MA_STATE, type MARenderState } from '../maState'
 import { BOLL_STATE_KEY, EMPTY_BOLL_STATE, type BOLLRenderState } from '../bollState'
 import { EXPMA_STATE_KEY, EMPTY_EXPMA_STATE, type EXPMARenderState } from '../expmaState'
@@ -15,40 +16,45 @@ function applyMainResult(key: string): NonNullable<IndicatorMetadata['applyResul
   }
 }
 
-function applyRSIResult(host: any, state: any, paneId: string): void {
-  host.setSharedState(createRSIStateKey(paneId), state as any, 'indicator_scheduler')
+const builtinDefinitionsByName = new Map(getBuiltinIndicatorDefinitions().map((definition) => [definition.name, definition]))
+
+function getBuiltinTestIndicator(name: string): IndicatorMetadata {
+  const definition = builtinDefinitionsByName.get(name)
+  if (!definition) {
+    throw new Error(`Missing builtin test indicator: ${name}`)
+  }
+  return definition
 }
 
 function registerTestIndicators(scheduler: IndicatorScheduler): void {
   const indicators: Array<IndicatorMetadata> = [
-    { name: 'ma', displayName: 'MA', category: 'main' as const, stateKey: MA_STATE_KEY, defaultPaneId: 'main', rendererFactory: vi.fn() as any, applyResult: applyMainResult(MA_STATE_KEY) },
-    { name: 'boll', displayName: 'BOLL', category: 'main' as const, stateKey: BOLL_STATE_KEY, defaultPaneId: 'main', rendererFactory: vi.fn() as any, applyResult: applyMainResult(BOLL_STATE_KEY) },
-    { name: 'expma', displayName: 'EXPMA', category: 'main' as const, stateKey: EXPMA_STATE_KEY, defaultPaneId: 'main', rendererFactory: vi.fn() as any, applyResult: applyMainResult(EXPMA_STATE_KEY) },
-    { name: 'ene', displayName: 'ENE', category: 'main' as const, stateKey: ENE_STATE_KEY, defaultPaneId: 'main', rendererFactory: vi.fn() as any, applyResult: applyMainResult(ENE_STATE_KEY) },
-    { name: 'rsi', displayName: 'RSI', category: 'sub' as const, stateKey: createRSIStateKey('sub_RSI'), defaultPaneId: 'sub_RSI', rendererFactory: vi.fn() as any, paneIdField: 'rsiPaneId' as any, applyResult: applyRSIResult },
-    { name: 'macd', displayName: 'MACD', category: 'sub' as const, stateKey: 'indicator:macd:sub_MACD', defaultPaneId: 'sub_MACD', rendererFactory: vi.fn() as any, paneIdField: 'macdPaneId' as any, applyResult: applyMainResult('indicator:macd:sub_MACD') },
+    getBuiltinTestIndicator('ma'),
+    getBuiltinTestIndicator('boll'),
+    getBuiltinTestIndicator('expma'),
+    getBuiltinTestIndicator('ene'),
+    getBuiltinTestIndicator('rsi'),
+    getBuiltinTestIndicator('macd'),
     { name: 'volume', displayName: 'Volume', category: 'sub' as const, stateKey: 'indicator:volume:sub_Volume', defaultPaneId: 'sub_Volume', rendererFactory: vi.fn() as any, paneIdField: 'volumePaneId' as any, applyResult: applyMainResult('indicator:volume:sub_Volume') },
-    { name: 'stoch', displayName: 'STOCH', category: 'sub' as const, stateKey: 'indicator:stoch:sub_STOCH', defaultPaneId: 'sub_STOCH', rendererFactory: vi.fn() as any, paneIdField: 'stochPaneId' as any, applyResult: applyMainResult('indicator:stoch:sub_STOCH') },
-    { name: 'rsi2', displayName: 'RSI2', category: 'sub' as const, stateKey: createRSIStateKey('sub_RSI2'), defaultPaneId: 'sub_RSI2', rendererFactory: vi.fn() as any, paneIdField: 'rsi2PaneId' as any, applyResult: applyRSIResult },
-    { name: 'wmsr', displayName: 'WMSR', category: 'sub' as const, stateKey: 'indicator:wmsr:sub_WMSR', defaultPaneId: 'sub_WMSR', rendererFactory: vi.fn() as any, paneIdField: 'wmsrPaneId' as any, applyResult: applyMainResult('indicator:wmsr:sub_WMSR') },
-    { name: 'mom', displayName: 'MOM', category: 'sub' as const, stateKey: 'indicator:mom:sub_MOM', defaultPaneId: 'sub_MOM', rendererFactory: vi.fn() as any, paneIdField: 'momPaneId' as any, applyResult: applyMainResult('indicator:mom:sub_MOM') },
-    { name: 'fastk', displayName: 'FASTK', category: 'sub' as const, stateKey: 'indicator:fastk:sub_FASTK', defaultPaneId: 'sub_FASTK', rendererFactory: vi.fn() as any, paneIdField: 'fastkPaneId' as any, applyResult: applyMainResult('indicator:fastk:sub_FASTK') },
-    { name: 'cci', displayName: 'CCI', category: 'sub' as const, stateKey: 'indicator:cci:sub_CCI', defaultPaneId: 'sub_CCI', rendererFactory: vi.fn() as any, paneIdField: 'cciPaneId' as any, applyResult: applyMainResult('indicator:cci:sub_CCI') },
-    { name: 'atr', displayName: 'ATR', category: 'sub' as const, stateKey: 'indicator:atr:sub_ATR', defaultPaneId: 'sub_ATR', rendererFactory: vi.fn() as any, paneIdField: 'atrPaneId' as any, applyResult: applyMainResult('indicator:atr:sub_ATR') },
-    { name: 'kst', displayName: 'KST', category: 'sub' as const, stateKey: 'indicator:kst:sub_KST', defaultPaneId: 'sub_KST', rendererFactory: vi.fn() as any, paneIdField: 'kstPaneId' as any, applyResult: applyMainResult('indicator:kst:sub_KST') },
-    { name: 'roc', displayName: 'ROC', category: 'sub' as const, stateKey: 'indicator:roc:sub_ROC', defaultPaneId: 'sub_ROC', rendererFactory: vi.fn() as any, paneIdField: 'rocPaneId' as any, applyResult: applyMainResult('indicator:roc:sub_ROC') },
-    { name: 'trix', displayName: 'TRIX', category: 'sub' as const, stateKey: 'indicator:trix:sub_TRIX', defaultPaneId: 'sub_TRIX', rendererFactory: vi.fn() as any, paneIdField: 'trixPaneId' as any, applyResult: applyMainResult('indicator:trix:sub_TRIX') },
-    { name: 'hv', displayName: 'HV', category: 'sub' as const, stateKey: 'indicator:hv:sub_HV', defaultPaneId: 'sub_HV', rendererFactory: vi.fn() as any, paneIdField: 'hvPaneId' as any, applyResult: applyMainResult('indicator:hv:sub_HV') },
-    { name: 'parkinson', displayName: 'Parkinson', category: 'sub' as const, stateKey: 'indicator:parkinson:sub_Parkinson', defaultPaneId: 'sub_Parkinson', rendererFactory: vi.fn() as any, paneIdField: 'parkinsonPaneId' as any, applyResult: applyMainResult('indicator:parkinson:sub_Parkinson') },
-    { name: 'chaikinVol', displayName: 'ChaikinVol', category: 'sub' as const, stateKey: 'indicator:chaikinVol:sub_ChaikinVol', defaultPaneId: 'sub_ChaikinVol', rendererFactory: vi.fn() as any, paneIdField: 'chaikinVolPaneId' as any, applyResult: applyMainResult('indicator:chaikinVol:sub_ChaikinVol') },
-    { name: 'vma', displayName: 'VMA', category: 'sub' as const, stateKey: 'indicator:vma:sub_VMA', defaultPaneId: 'sub_VMA', rendererFactory: vi.fn() as any, paneIdField: 'vmaPaneId' as any, applyResult: applyMainResult('indicator:vma:sub_VMA') },
-    { name: 'obv', displayName: 'OBV', category: 'sub' as const, stateKey: 'indicator:obv:sub_OBV', defaultPaneId: 'sub_OBV', rendererFactory: vi.fn() as any, paneIdField: 'obvPaneId' as any, applyResult: applyMainResult('indicator:obv:sub_OBV') },
-    { name: 'pvt', displayName: 'PVT', category: 'sub' as const, stateKey: 'indicator:pvt:sub_PVT', defaultPaneId: 'sub_PVT', rendererFactory: vi.fn() as any, paneIdField: 'pvtPaneId' as any, applyResult: applyMainResult('indicator:pvt:sub_PVT') },
-    { name: 'vwap', displayName: 'VWAP', category: 'sub' as const, stateKey: 'indicator:vwap:sub_VWAP', defaultPaneId: 'sub_VWAP', rendererFactory: vi.fn() as any, paneIdField: 'vwapPaneId' as any, applyResult: applyMainResult('indicator:vwap:sub_VWAP') },
-    { name: 'cmf', displayName: 'CMF', category: 'sub' as const, stateKey: 'indicator:cmf:sub_CMF', defaultPaneId: 'sub_CMF', rendererFactory: vi.fn() as any, paneIdField: 'cmfPaneId' as any, applyResult: applyMainResult('indicator:cmf:sub_CMF') },
-    { name: 'mfi', displayName: 'MFI', category: 'sub' as const, stateKey: 'indicator:mfi:sub_MFI', defaultPaneId: 'sub_MFI', rendererFactory: vi.fn() as any, paneIdField: 'mfiPaneId' as any, applyResult: applyMainResult('indicator:mfi:sub_MFI') },
-    { name: 'sar', displayName: 'SAR', category: 'main' as const, stateKey: 'indicator:sar:main', defaultPaneId: 'main', rendererFactory: vi.fn() as any, applyResult: applyMainResult('indicator:sar:main') },
-    { name: 'keltner', displayName: 'Keltner', category: 'main' as const, stateKey: 'indicator:keltner:main', defaultPaneId: 'main', rendererFactory: vi.fn() as any, applyResult: applyMainResult('indicator:keltner:main') },
+    getBuiltinTestIndicator('stoch'),
+    getBuiltinTestIndicator('wmsr'),
+    getBuiltinTestIndicator('mom'),
+    getBuiltinTestIndicator('fastk'),
+    getBuiltinTestIndicator('cci'),
+    getBuiltinTestIndicator('atr'),
+    getBuiltinTestIndicator('kst'),
+    getBuiltinTestIndicator('roc'),
+    getBuiltinTestIndicator('trix'),
+    getBuiltinTestIndicator('hv'),
+    getBuiltinTestIndicator('parkinson'),
+    getBuiltinTestIndicator('chaikinVol'),
+    getBuiltinTestIndicator('vma'),
+    getBuiltinTestIndicator('obv'),
+    getBuiltinTestIndicator('pvt'),
+    getBuiltinTestIndicator('vwap'),
+    getBuiltinTestIndicator('cmf'),
+    getBuiltinTestIndicator('mfi'),
+    getBuiltinTestIndicator('sar'),
+    getBuiltinTestIndicator('keltner'),
   ]
   for (const meta of indicators) {
     scheduler.registerIndicator(meta)
@@ -203,6 +209,28 @@ describe('IndicatorScheduler', () => {
       expect(state!.visibleMin).toBe(Infinity)
       expect(state!.visibleMax).toBe(-Infinity)
     })
+
+    it('should refresh main indicator visible extremes when visible range changes', () => {
+      const data = createTestData(100, 100)
+      const invalidate = vi.fn()
+      scheduler.setInvalidateCallback(invalidate)
+
+      scheduler.update(data, { start: 0, end: 0 })
+      invalidate.mockClear()
+      const initialState = getStateFromMockCalls<BOLLRenderState>(mockHost, BOLL_STATE_KEY)
+      expect(initialState).toBeDefined()
+      expect(initialState!.visibleMin).toBe(Infinity)
+      expect(initialState!.visibleMax).toBe(-Infinity)
+
+      scheduler.updateVisibleRange({ start: 30, end: 60 })
+
+      const updatedState = getStateFromMockCalls<BOLLRenderState>(mockHost, BOLL_STATE_KEY)
+      expect(updatedState).toBeDefined()
+      expect(updatedState!.visibleMin).toBeLessThan(updatedState!.visibleMax)
+      expect(Number.isFinite(updatedState!.visibleMin)).toBe(true)
+      expect(Number.isFinite(updatedState!.visibleMax)).toBe(true)
+      expect(invalidate).toHaveBeenCalledTimes(1)
+    })
   })
 
   describe('MA config update', () => {
@@ -279,9 +307,11 @@ describe('IndicatorScheduler', () => {
       // Update only viewport
       scheduler.updateVisibleRange({ start: 50, end: 60 })
 
-      // updateVisibleStatesOnly writes the 20 sub-indicators that are both
-      // registered and known to composeVisibleSubIndicatorStates.
-      expect(mockHost.setSharedState).toHaveBeenCalledTimes(20)
+      const calls = vi.mocked(mockHost.setSharedState).mock.calls
+      expect(calls.some((call) => call[0] === MA_STATE_KEY)).toBe(false)
+      expect(calls.some((call) => call[0] === BOLL_STATE_KEY)).toBe(false)
+      expect(calls.some((call) => call[0] === EXPMA_STATE_KEY)).toBe(false)
+      expect(calls.some((call) => call[0] === ENE_STATE_KEY)).toBe(false)
 
       // Inspect a sub-indicator (RSI) since main indicators are not rewritten on viewport-only updates
       const rsiKey = createRSIStateKey('sub_RSI')