@363045841yyt/klinechart-core 0.7.8 → 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,13 +1,66 @@
 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'
 import { ENE_STATE_KEY, EMPTY_ENE_STATE, type ENERenderState } from '../eneState'
 import { createRSIStateKey, EMPTY_RSI_STATE, type RSIRenderState } from '../rsiState'
+import type { IndicatorMetadata } from '../indicatorMetadata'
 import type { KLineData } from '@/types/price'
 import type { PluginHost } from '@/plugin'
 
+function applyMainResult(key: string): NonNullable<IndicatorMetadata['applyResult']> {
+  return (host, state, _paneId) => {
+    ;(host as PluginHost).setSharedState(key, 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> = [
+    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') },
+    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)
+  }
+}
+
 /**
  * 创建测试用的 K 线数据
  */
@@ -76,6 +129,8 @@ describe('IndicatorScheduler', () => {
     scheduler = new IndicatorScheduler()
     mockHost = createMockPluginHost()
     scheduler.setPluginHost(mockHost)
+    registerTestIndicators(scheduler)
+    vi.mocked(mockHost.setSharedState).mockClear()
   })
 
   describe('initialization', () => {
@@ -107,7 +162,7 @@ describe('IndicatorScheduler', () => {
           visibleMin: expect.any(Number),
           visibleMax: expect.any(Number),
         }),
-        'ma_scheduler'
+        expect.any(String)
       )
     })
 
@@ -154,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', () => {
@@ -230,9 +307,11 @@ describe('IndicatorScheduler', () => {
       // Update only viewport
       scheduler.updateVisibleRange({ start: 50, end: 60 })
 
-      // updateVisibleStatesOnly writes the 32 sub-indicators.
-      // Main indicators (MA, BOLL, EXPMA, ENE) are not rewritten on viewport-only changes.
-      expect(mockHost.setSharedState).toHaveBeenCalledTimes(35)
+      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')
@@ -252,8 +331,8 @@ describe('IndicatorScheduler', () => {
       const data2 = createTestData(100, 200)
       scheduler.update(data2, { start: 0, end: 100 })
 
-      // Should be called 64 times (32 indicators × 2 data updates)
-      expect(mockHost.setSharedState).toHaveBeenCalledTimes(78)
+      // 26 registered indicators produce states × 2 data updates (1st triggers compute, 2nd retriggers with different data)
+      expect(mockHost.setSharedState).toHaveBeenCalledTimes(52)
     })
   })
 
@@ -266,8 +345,8 @@ describe('IndicatorScheduler', () => {
 
       scheduler.recompute()
 
-      // Should write all 32 indicator states (31 from PR 7 + VWAP)
-      expect(mockHost.setSharedState).toHaveBeenCalledTimes(39)
+      // Should write all 26 indicator states that have registered + known to composeRenderStates
+      expect(mockHost.setSharedState).toHaveBeenCalledTimes(26)
     })
 
     it('should recalculate with same data and range', () => {
@@ -345,6 +424,7 @@ describe('BOLL State in scheduler', () => {
     scheduler = new IndicatorScheduler()
     mockHost = createMockPluginHost()
     scheduler.setPluginHost(mockHost)
+    registerTestIndicators(scheduler)
   })
 
   it('should write BOLLRenderState to StateStore after update', () => {
@@ -427,6 +507,7 @@ describe('EXPMA State in scheduler', () => {
     scheduler = new IndicatorScheduler()
     mockHost = createMockPluginHost()
     scheduler.setPluginHost(mockHost)
+    registerTestIndicators(scheduler)
   })
 
   it('should write EXPMARenderState to StateStore after update', () => {
@@ -480,6 +561,7 @@ describe('ENE State in scheduler', () => {
     scheduler = new IndicatorScheduler()
     mockHost = createMockPluginHost()
     scheduler.setPluginHost(mockHost)
+    registerTestIndicators(scheduler)
   })
 
   it('should write ENERenderState to StateStore after update', () => {
@@ -536,6 +618,7 @@ describe('Per-indicator dirty flags', () => {
     scheduler = new IndicatorScheduler()
     mockHost = createMockPluginHost()
     scheduler.setPluginHost(mockHost)
+    registerTestIndicators(scheduler)
   })
 
   it('updateBOLLConfig should not recalculate MA series', () => {
@@ -684,6 +767,7 @@ describe('RSI State in scheduler', () => {
     scheduler = new IndicatorScheduler()
     mockHost = createMockPluginHost()
     scheduler.setPluginHost(mockHost)
+    registerTestIndicators(scheduler)
   })
 
   it('should write RSIRenderState to StateStore after update', () => {