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

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

@@ -12,15 +12,7 @@ describe('builtin indicator registration', () => {
 
     expect(definitions).toHaveLength(41)
     expect(definitions.map((definition) => definition.name)).toEqual(
-      expect.arrayContaining([
-        'ma',
-        'boll',
-        'rsi',
-        'macd',
-        'volume',
-        'volumeProfile',
-        'zones',
-      ]),
+      expect.arrayContaining(['ma', 'boll', 'rsi', 'macd', 'volume', 'volumeProfile', 'zones']),
     )
   })
 
@@ -38,12 +30,38 @@ describe('builtin indicator registration', () => {
 
   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',
+      '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')
@@ -57,12 +75,24 @@ describe('builtin indicator registration', () => {
 
     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('VOLUME_PROFILE')?.updateConfig?.(
+      scheduler,
+      { bins: 32 },
+      'VP_0',
+    )
     getRegisteredIndicatorDefinition('VOL')?.updateConfig?.(scheduler, {}, 'VOL_0')
 
     expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith('rsi', { period1: 7 }, 'RSI_0')
-    expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith('macd', { fastPeriod: 8 }, 'MACD_0')
-    expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith('volumeProfile', { bins: 32 }, 'VP_0')
+    expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith(
+      'macd',
+      { fastPeriod: 8 },
+      'MACD_0',
+    )
+    expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith(
+      'volumeProfile',
+      { bins: 32 },
+      'VP_0',
+    )
   })
 
   it('routes stage 4B metadata config updates to scheduler methods', () => {
@@ -72,18 +102,35 @@ describe('builtin indicator registration', () => {
 
     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('CHAIKIN_VOL')?.updateConfig?.(
+      scheduler,
+      { emaPeriod: 10 },
+      'CV_0',
+    )
     getRegisteredIndicatorDefinition('ZONES')?.updateConfig?.(scheduler, { showFVG: true }, 'Z_0')
 
     expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith('cci', { period: 14 }, 'CCI_0')
     expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith('atr', { period: 10 }, 'ATR_0')
-    expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith('chaikinVol', { emaPeriod: 10 }, 'CV_0')
+    expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith(
+      'chaikinVol',
+      { emaPeriod: 10 },
+      'CV_0',
+    )
     expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith('zones', { 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',
+      'VOL',
+      'MACD',
+      'RSI',
+      'CCI',
+      'STOCH',
+      'MOM',
+      'WMSR',
+      'KST',
+      'FASTK',
+      'ATR',
     ]
 
     for (const id of expectedIndicators) {
@@ -165,8 +212,14 @@ describe('builtin indicator registration', () => {
   })
 
   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' })
+    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')
@@ -196,8 +249,14 @@ describe('builtin indicator registration', () => {
   })
 
   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' })
+    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')
@@ -205,9 +264,20 @@ describe('builtin indicator registration', () => {
 
   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',
+      'WMA',
+      'DEMA',
+      'TEMA',
+      'HMA',
+      'KAMA',
+      'SAR',
+      'SUPERTREND',
+      'KELTNER',
+      'DONCHIAN',
+      'ICHIMOKU',
+      'PIVOT',
+      'FIB',
+      'STRUCTURE',
+      'ZONES',
     ]
 
     for (const id of ids) {
@@ -216,21 +286,42 @@ describe('builtin indicator registration', () => {
   })
 
   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('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('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('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,
+    expect(
+      getRegisteredIndicatorDefinition('ZONES')?.mainPane?.toActiveConfig?.({}, false),
+    ).toEqual({
+      showFVG: false,
+      showOB: false,
+      showFilledZones: false,
     })
   })
 
@@ -250,15 +341,21 @@ describe('builtin indicator registration', () => {
       ma30: false,
       ma60: false,
     })
-    expect(getRegisteredIndicatorDefinition('BOLL')?.mainPane?.toActiveConfig?.({ period: 20 }, false)).toEqual({
+    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()
+    expect(
+      getRegisteredIndicatorDefinition('EXPMA')?.mainPane?.toActiveConfig?.({}, false),
+    ).toBeNull()
+    expect(
+      getRegisteredIndicatorDefinition('ENE')?.mainPane?.toActiveConfig?.({}, false),
+    ).toBeNull()
   })
 
   it('routes base main metadata config updates to scheduler methods', () => {
@@ -273,7 +370,11 @@ describe('builtin indicator registration', () => {
 
     expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith('ma', { ma5: true }, 'main')
     expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith('boll', { period: 20 }, 'main')
-    expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith('expma', { fastPeriod: 12 }, 'main')
+    expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith(
+      'expma',
+      { fastPeriod: 12 },
+      'main',
+    )
     expect(scheduler.updateIndicatorConfig).toHaveBeenCalledWith('ene', { period: 10 }, 'main')
   })
 
@@ -308,24 +409,42 @@ describe('builtin indicator registration', () => {
 
     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('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')
+      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')
+      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']) {
+    for (const id of [
+      'WMA',
+      'DEMA',
+      'TEMA',
+      'HMA',
+      'KAMA',
+      'ROC',
+      'ChaikinVol',
+      'OBV',
+      'PVT',
+      'VWAP',
+    ]) {
       expect(getRegisteredIndicatorDefinition(id)?.visibleState?.compose).toBeTypeOf('function')
     }
   })
@@ -360,12 +479,41 @@ describe('builtin indicator registration', () => {
 
   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',
+      '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) {

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

@@ -1,68 +1,71 @@
 import { describe, it, expect } from 'vitest'
 import { calcROCData } from '../calculators'
 import {
-    empty,
-    constantPrice,
-    pureUptrend,
-    pureDowntrend,
-    sideways,
+  empty,
+  constantPrice,
+  pureUptrend,
+  pureDowntrend,
+  sideways,
 } from './__fixtures__/synthetic'
 
 describe('calcROCData', () => {
-    it('empty returns empty', () => {
-        expect(calcROCData(empty, 12)).toEqual([])
-    })
+  it('empty returns empty', () => {
+    expect(calcROCData(empty, 12)).toEqual([])
+  })
 
-    it('period <= 0 returns all undefined', () => {
-        const out = calcROCData(pureUptrend, 0)
-        for (const v of out) expect(v).toBeUndefined()
-    })
+  it('period <= 0 returns all undefined', () => {
+    const out = calcROCData(pureUptrend, 0)
+    for (const v of out) expect(v).toBeUndefined()
+  })
 
-    it('on constantPrice ROC = 0 after warm-up', () => {
-        const out = calcROCData(constantPrice, 12)
-        for (let t = 12; t < out.length; t++) {
-            expect(out[t]).toBe(0)
-        }
-    })
+  it('on constantPrice ROC = 0 after warm-up', () => {
+    const out = calcROCData(constantPrice, 12)
+    for (let t = 12; t < out.length; t++) {
+      expect(out[t]).toBe(0)
+    }
+  })
 
-    it('on pureUptrend ROC > 0 throughout post-warmup', () => {
-        const out = calcROCData(pureUptrend, 12)
-        for (let t = 12; t < out.length; t++) {
-            expect(out[t]).toBeGreaterThan(0)
-        }
-    })
+  it('on pureUptrend ROC > 0 throughout post-warmup', () => {
+    const out = calcROCData(pureUptrend, 12)
+    for (let t = 12; t < out.length; t++) {
+      expect(out[t]).toBeGreaterThan(0)
+    }
+  })
 
-    it('on pureDowntrend ROC < 0 throughout post-warmup', () => {
-        const out = calcROCData(pureDowntrend, 12)
-        for (let t = 12; t < out.length; t++) {
-            expect(out[t]).toBeLessThan(0)
-        }
-    })
+  it('on pureDowntrend ROC < 0 throughout post-warmup', () => {
+    const out = calcROCData(pureDowntrend, 12)
+    for (let t = 12; t < out.length; t++) {
+      expect(out[t]).toBeLessThan(0)
+    }
+  })
 
-    it('mathematical exactness: ROC(t) = (close[t]-close[t-p])/close[t-p]*100', () => {
-        const period = 12
-        const out = calcROCData(pureUptrend, period)
-        for (let t = period; t < out.length; t++) {
-            const expected = (pureUptrend[t]!.close - pureUptrend[t - period]!.close) / pureUptrend[t - period]!.close * 100
-            expect(out[t]!).toBeCloseTo(expected, 12)
-        }
-    })
+  it('mathematical exactness: ROC(t) = (close[t]-close[t-p])/close[t-p]*100', () => {
+    const period = 12
+    const out = calcROCData(pureUptrend, period)
+    for (let t = period; t < out.length; t++) {
+      const expected =
+        ((pureUptrend[t]!.close - pureUptrend[t - period]!.close) /
+          pureUptrend[t - period]!.close) *
+        100
+      expect(out[t]!).toBeCloseTo(expected, 12)
+    }
+  })
 
-    it('warm-up region is [0, period)', () => {
-        const out = calcROCData(sideways, 12)
-        for (let i = 0; i < 12; i++) expect(out[i]).toBeUndefined()
-        for (let i = 12; i < out.length; i++) expect(out[i]).toBeDefined()
-    })
+  it('warm-up region is [0, period)', () => {
+    const out = calcROCData(sideways, 12)
+    for (let i = 0; i < 12; i++) expect(out[i]).toBeUndefined()
+    for (let i = 12; i < out.length; i++) expect(out[i]).toBeDefined()
+  })
 
-    it('extensional consistency', () => {
-        const full = calcROCData(pureUptrend, 12)
-        for (let n = 15; n < pureUptrend.length; n++) {
-            const partial = calcROCData(pureUptrend.slice(0, n), 12)
-            for (let i = 0; i < n; i++) {
-                if (full[i] !== undefined && partial[i] !== undefined) {
-                    expect(partial[i]).toBeCloseTo(full[i]!, 12)
-                }
-            }
+  it('extensional consistency', () => {
+    const full = calcROCData(pureUptrend, 12)
+    for (let n = 15; n < pureUptrend.length; n++) {
+      const partial = calcROCData(pureUptrend.slice(0, n), 12)
+      for (let i = 0; i < n; i++) {
+        if (full[i] !== undefined && partial[i] !== undefined) {
+          expect(partial[i]).toBeCloseTo(full[i]!, 12)
         }
-    })
+      }
+    }
+  })
 })

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

@@ -1,86 +1,86 @@
 import { describe, it, expect } from 'vitest'
 import { calcSARData } from '../calculators'
 import {
-    empty,
-    singleBar,
-    pureUptrend,
-    pureDowntrend,
-    spikeAtBar19,
-    gapUp,
+  empty,
+  singleBar,
+  pureUptrend,
+  pureDowntrend,
+  spikeAtBar19,
+  gapUp,
 } from './__fixtures__/synthetic'
 
 describe('calcSARData — Parabolic SAR', () => {
-    describe('edge cases', () => {
-        it('empty returns empty array', () => {
-            expect(calcSARData(empty, 0.02, 0.2)).toEqual([])
-        })
+  describe('edge cases', () => {
+    it('empty returns empty array', () => {
+      expect(calcSARData(empty, 0.02, 0.2)).toEqual([])
+    })
 
-        it('single bar returns [undefined] (needs 2 bars to seed trend)', () => {
-            expect(calcSARData(singleBar, 0.02, 0.2)).toEqual([undefined])
-        })
+    it('single bar returns [undefined] (needs 2 bars to seed trend)', () => {
+      expect(calcSARData(singleBar, 0.02, 0.2)).toEqual([undefined])
+    })
 
-        it('step <= 0 returns all undefined', () => {
-            const out = calcSARData(pureUptrend, 0, 0.2)
-            for (const v of out) expect(v).toBeUndefined()
-        })
+    it('step <= 0 returns all undefined', () => {
+      const out = calcSARData(pureUptrend, 0, 0.2)
+      for (const v of out) expect(v).toBeUndefined()
     })
+  })
 
-    describe('mathematical properties', () => {
-        it('on pureUptrend SAR remains below the candles in an up trend', () => {
-            const out = calcSARData(pureUptrend, 0.02, 0.2)
-            for (let i = 1; i < out.length; i++) {
-                const point = out[i]!
-                expect(point).toBeDefined()
-                if (point.trend === 'up') {
-                    expect(point.value).toBeLessThanOrEqual(pureUptrend[i]!.low)
-                }
-            }
-        })
+  describe('mathematical properties', () => {
+    it('on pureUptrend SAR remains below the candles in an up trend', () => {
+      const out = calcSARData(pureUptrend, 0.02, 0.2)
+      for (let i = 1; i < out.length; i++) {
+        const point = out[i]!
+        expect(point).toBeDefined()
+        if (point.trend === 'up') {
+          expect(point.value).toBeLessThanOrEqual(pureUptrend[i]!.low)
+        }
+      }
+    })
 
-        it('on pureDowntrend SAR remains above the candles in a down trend', () => {
-            const out = calcSARData(pureDowntrend, 0.02, 0.2)
-            for (let i = 1; i < out.length; i++) {
-                const point = out[i]!
-                if (point.trend === 'down') {
-                    expect(point.value).toBeGreaterThanOrEqual(pureDowntrend[i]!.high)
-                }
-            }
-        })
+    it('on pureDowntrend SAR remains above the candles in a down trend', () => {
+      const out = calcSARData(pureDowntrend, 0.02, 0.2)
+      for (let i = 1; i < out.length; i++) {
+        const point = out[i]!
+        if (point.trend === 'down') {
+          expect(point.value).toBeGreaterThanOrEqual(pureDowntrend[i]!.high)
+        }
+      }
+    })
 
-        it('trend reverses after price violates SAR (spike fixture)', () => {
-            const out = calcSARData(spikeAtBar19, 0.02, 0.2)
-            // At least one transition should appear in the spike fixture
-            const trends = out
-                .filter((p): p is { value: number; trend: 'up' | 'down' } => p !== undefined)
-                .map((p) => p.trend)
-            const distinctTrends = new Set(trends)
-            expect(distinctTrends.size).toBeGreaterThanOrEqual(1)
-        })
+    it('trend reverses after price violates SAR (spike fixture)', () => {
+      const out = calcSARData(spikeAtBar19, 0.02, 0.2)
+      // At least one transition should appear in the spike fixture
+      const trends = out
+        .filter((p): p is { value: number; trend: 'up' | 'down' } => p !== undefined)
+        .map((p) => p.trend)
+      const distinctTrends = new Set(trends)
+      expect(distinctTrends.size).toBeGreaterThanOrEqual(1)
+    })
 
-        it('extensional consistency on gapUp fixture', () => {
-            const full = calcSARData(gapUp, 0.02, 0.2)
-            for (let n = 3; n < gapUp.length; n++) {
-                const partial = calcSARData(gapUp.slice(0, n), 0.02, 0.2)
-                for (let i = 0; i < n; i++) {
-                    const f = full[i]
-                    const p = partial[i]
-                    if (f && p) {
-                        expect(p.value).toBeCloseTo(f.value, 9)
-                        expect(p.trend).toBe(f.trend)
-                    }
-                }
-            }
-        })
+    it('extensional consistency on gapUp fixture', () => {
+      const full = calcSARData(gapUp, 0.02, 0.2)
+      for (let n = 3; n < gapUp.length; n++) {
+        const partial = calcSARData(gapUp.slice(0, n), 0.02, 0.2)
+        for (let i = 0; i < n; i++) {
+          const f = full[i]
+          const p = partial[i]
+          if (f && p) {
+            expect(p.value).toBeCloseTo(f.value, 9)
+            expect(p.trend).toBe(f.trend)
+          }
+        }
+      }
+    })
 
-        it('AF respects maxStep ceiling', () => {
-            // SAR with a very small maxStep should stay close to the seed (slow acceleration)
-            const slow = calcSARData(pureUptrend, 0.02, 0.02)
-            const fast = calcSARData(pureUptrend, 0.02, 0.2)
-            // After several bars, fast SAR should have caught up to price more aggressively
-            const t = 25
-            const slowGap = pureUptrend[t]!.close - slow[t]!.value
-            const fastGap = pureUptrend[t]!.close - fast[t]!.value
-            expect(fastGap).toBeLessThanOrEqual(slowGap)
-        })
+    it('AF respects maxStep ceiling', () => {
+      // SAR with a very small maxStep should stay close to the seed (slow acceleration)
+      const slow = calcSARData(pureUptrend, 0.02, 0.02)
+      const fast = calcSARData(pureUptrend, 0.02, 0.2)
+      // After several bars, fast SAR should have caught up to price more aggressively
+      const t = 25
+      const slowGap = pureUptrend[t]!.close - slow[t]!.value
+      const fastGap = pureUptrend[t]!.close - fast[t]!.value
+      expect(fastGap).toBeLessThanOrEqual(slowGap)
     })
+  })
 })