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

package/src/components/orderBookHeatmap/__tests__/deltaArchive.test.ts

@@ -4,85 +4,85 @@ import { createDeltaArchive } from '../deltaArchive'
 import type { OrderBookDelta } from '../types'
 
 function delta(ts: number, price = 100, size = 1): OrderBookDelta {
-    return { side: 'bid', price, size, timestamp: ts }
+  return { side: 'bid', price, size, timestamp: ts }
 }
 
 describe('createDeltaArchive', () => {
-    it('appends + ranges across the inserted window', () => {
-        const a = createDeltaArchive()
-        for (let i = 0; i < 10; i++) a.append(delta(i))
-        const r = a.range(2, 5)
-        expect(r.map((d) => d.timestamp)).toEqual([2, 3, 4, 5])
-    })
+  it('appends + ranges across the inserted window', () => {
+    const a = createDeltaArchive()
+    for (let i = 0; i < 10; i++) a.append(delta(i))
+    const r = a.range(2, 5)
+    expect(r.map((d) => d.timestamp)).toEqual([2, 3, 4, 5])
+  })
 
-    it('range bounds are inclusive on both ends', () => {
-        const a = createDeltaArchive()
-        a.append(delta(10))
-        a.append(delta(20))
-        a.append(delta(30))
-        expect(a.range(10, 30).map((d) => d.timestamp)).toEqual([10, 20, 30])
-        expect(a.range(11, 29).map((d) => d.timestamp)).toEqual([20])
-    })
+  it('range bounds are inclusive on both ends', () => {
+    const a = createDeltaArchive()
+    a.append(delta(10))
+    a.append(delta(20))
+    a.append(delta(30))
+    expect(a.range(10, 30).map((d) => d.timestamp)).toEqual([10, 20, 30])
+    expect(a.range(11, 29).map((d) => d.timestamp)).toEqual([20])
+  })
 
-    it('trim drops the oldest entries until size ≤ target', () => {
-        const a = createDeltaArchive()
-        for (let i = 0; i < 100; i++) a.append(delta(i))
-        a.trim(30)
-        expect(a.size()).toBe(30)
-        // The 30 newest should remain.
-        const all = a.range(0, 999)
-        expect(all[0].timestamp).toBe(70)
-        expect(all[all.length - 1].timestamp).toBe(99)
-    })
+  it('trim drops the oldest entries until size ≤ target', () => {
+    const a = createDeltaArchive()
+    for (let i = 0; i < 100; i++) a.append(delta(i))
+    a.trim(30)
+    expect(a.size()).toBe(30)
+    // The 30 newest should remain.
+    const all = a.range(0, 999)
+    expect(all[0].timestamp).toBe(70)
+    expect(all[all.length - 1].timestamp).toBe(99)
+  })
 
-    it('reports accurate size after append, trim, and clear', () => {
-        const a = createDeltaArchive()
-        expect(a.size()).toBe(0)
-        for (let i = 0; i < 5; i++) a.append(delta(i))
-        expect(a.size()).toBe(5)
-        a.trim(2)
-        expect(a.size()).toBe(2)
-        a.clear()
-        expect(a.size()).toBe(0)
-    })
+  it('reports accurate size after append, trim, and clear', () => {
+    const a = createDeltaArchive()
+    expect(a.size()).toBe(0)
+    for (let i = 0; i < 5; i++) a.append(delta(i))
+    expect(a.size()).toBe(5)
+    a.trim(2)
+    expect(a.size()).toBe(2)
+    a.clear()
+    expect(a.size()).toBe(0)
+  })
 
-    it('chunked storage does not break range queries across chunks', () => {
-        // CHUNK_SIZE is 10_000 in the impl. Push more than that to force at
-        // least one chunk boundary and ensure ordering still holds.
-        const a = createDeltaArchive()
-        const N = 25_000
-        for (let i = 0; i < N; i++) a.append(delta(i))
-        // Window straddles two chunk boundaries.
-        const r = a.range(9_998, 10_002)
-        expect(r.map((d) => d.timestamp)).toEqual([9_998, 9_999, 10_000, 10_001, 10_002])
-        // Full range returns every delta exactly once.
-        const all = a.range(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY)
-        expect(all.length).toBe(N)
-        expect(all[0].timestamp).toBe(0)
-        expect(all[N - 1].timestamp).toBe(N - 1)
-    })
+  it('chunked storage does not break range queries across chunks', () => {
+    // CHUNK_SIZE is 10_000 in the impl. Push more than that to force at
+    // least one chunk boundary and ensure ordering still holds.
+    const a = createDeltaArchive()
+    const N = 25_000
+    for (let i = 0; i < N; i++) a.append(delta(i))
+    // Window straddles two chunk boundaries.
+    const r = a.range(9_998, 10_002)
+    expect(r.map((d) => d.timestamp)).toEqual([9_998, 9_999, 10_000, 10_001, 10_002])
+    // Full range returns every delta exactly once.
+    const all = a.range(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY)
+    expect(all.length).toBe(N)
+    expect(all[0].timestamp).toBe(0)
+    expect(all[N - 1].timestamp).toBe(N - 1)
+  })
 
-    it('respects maxSize at construction by auto-trimming on append', () => {
-        const a = createDeltaArchive({ maxSize: 5 })
-        for (let i = 0; i < 12; i++) a.append(delta(i))
-        expect(a.size()).toBe(5)
-        const all = a.range(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY)
-        expect(all.map((d) => d.timestamp)).toEqual([7, 8, 9, 10, 11])
-    })
+  it('respects maxSize at construction by auto-trimming on append', () => {
+    const a = createDeltaArchive({ maxSize: 5 })
+    for (let i = 0; i < 12; i++) a.append(delta(i))
+    expect(a.size()).toBe(5)
+    const all = a.range(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY)
+    expect(all.map((d) => d.timestamp)).toEqual([7, 8, 9, 10, 11])
+  })
 
-    it('returns empty array when from > to', () => {
-        const a = createDeltaArchive()
-        for (let i = 0; i < 5; i++) a.append(delta(i))
-        expect(a.range(3, 1)).toEqual([])
-    })
+  it('returns empty array when from > to', () => {
+    const a = createDeltaArchive()
+    for (let i = 0; i < 5; i++) a.append(delta(i))
+    expect(a.range(3, 1)).toEqual([])
+  })
 
-    it('clear() resets the archive without breaking subsequent appends', () => {
-        const a = createDeltaArchive()
-        for (let i = 0; i < 5; i++) a.append(delta(i))
-        a.clear()
-        expect(a.size()).toBe(0)
-        a.append(delta(99))
-        expect(a.size()).toBe(1)
-        expect(a.range(0, 1000).map((d) => d.timestamp)).toEqual([99])
-    })
+  it('clear() resets the archive without breaking subsequent appends', () => {
+    const a = createDeltaArchive()
+    for (let i = 0; i < 5; i++) a.append(delta(i))
+    a.clear()
+    expect(a.size()).toBe(0)
+    a.append(delta(99))
+    expect(a.size()).toBe(1)
+    expect(a.range(0, 1000).map((d) => d.timestamp)).toEqual([99])
+  })
 })

package/src/components/orderBookHeatmap/__tests__/logColorScale.test.ts

@@ -3,67 +3,67 @@ import { describe, it, expect } from 'vitest'
 import { createLogColorScale } from '../logColorScale'
 
 describe('createLogColorScale', () => {
-    it('maps size = 0 to intensity 0', () => {
-        const scale = createLogColorScale(1, 1000)
-        expect(scale.intensity(0)).toBe(0)
-        expect(scale.intensity(-5)).toBe(0)
-    })
+  it('maps size = 0 to intensity 0', () => {
+    const scale = createLogColorScale(1, 1000)
+    expect(scale.intensity(0)).toBe(0)
+    expect(scale.intensity(-5)).toBe(0)
+  })
 
-    it('maps size below sizeMin to 0', () => {
-        const scale = createLogColorScale(10, 1000)
-        expect(scale.intensity(1)).toBe(0)
-        expect(scale.intensity(10)).toBe(0)
-    })
+  it('maps size below sizeMin to 0', () => {
+    const scale = createLogColorScale(10, 1000)
+    expect(scale.intensity(1)).toBe(0)
+    expect(scale.intensity(10)).toBe(0)
+  })
 
-    it('maps size above sizeMax to 1', () => {
-        const scale = createLogColorScale(1, 100)
-        expect(scale.intensity(100)).toBe(1)
-        expect(scale.intensity(1_000_000)).toBe(1)
-    })
+  it('maps size above sizeMax to 1', () => {
+    const scale = createLogColorScale(1, 100)
+    expect(scale.intensity(100)).toBe(1)
+    expect(scale.intensity(1_000_000)).toBe(1)
+  })
 
-    it('mid-range is monotonically increasing in log size', () => {
-        const scale = createLogColorScale(1, 10_000)
-        const a = scale.intensity(2)
-        const b = scale.intensity(20)
-        const c = scale.intensity(200)
-        const d = scale.intensity(2_000)
-        expect(a).toBeGreaterThan(0)
-        expect(a).toBeLessThan(b)
-        expect(b).toBeLessThan(c)
-        expect(c).toBeLessThan(d)
-        expect(d).toBeLessThan(1)
-    })
+  it('mid-range is monotonically increasing in log size', () => {
+    const scale = createLogColorScale(1, 10_000)
+    const a = scale.intensity(2)
+    const b = scale.intensity(20)
+    const c = scale.intensity(200)
+    const d = scale.intensity(2_000)
+    expect(a).toBeGreaterThan(0)
+    expect(a).toBeLessThan(b)
+    expect(b).toBeLessThan(c)
+    expect(c).toBeLessThan(d)
+    expect(d).toBeLessThan(1)
+  })
 
-    it('matches the exact log-ratio formula for a known interior point', () => {
-        // sizeMin = 1, sizeMax = 100 → log range = ln(100). At size = 10
-        // intensity should be ln(10) / ln(100) = 0.5.
-        const scale = createLogColorScale(1, 100)
-        expect(scale.intensity(10)).toBeCloseTo(0.5, 10)
-    })
+  it('matches the exact log-ratio formula for a known interior point', () => {
+    // sizeMin = 1, sizeMax = 100 → log range = ln(100). At size = 10
+    // intensity should be ln(10) / ln(100) = 0.5.
+    const scale = createLogColorScale(1, 100)
+    expect(scale.intensity(10)).toBeCloseTo(0.5, 10)
+  })
 
-    it('degenerate range (sizeMin === sizeMax) returns 0.5 for any positive size', () => {
-        const scale = createLogColorScale(5, 5)
-        expect(scale.intensity(1)).toBe(0.5)
-        expect(scale.intensity(5)).toBe(0.5)
-        expect(scale.intensity(1_000_000)).toBe(0.5)
-        // Non-positive sizes still map to 0.
-        expect(scale.intensity(0)).toBe(0)
-    })
+  it('degenerate range (sizeMin === sizeMax) returns 0.5 for any positive size', () => {
+    const scale = createLogColorScale(5, 5)
+    expect(scale.intensity(1)).toBe(0.5)
+    expect(scale.intensity(5)).toBe(0.5)
+    expect(scale.intensity(1_000_000)).toBe(0.5)
+    // Non-positive sizes still map to 0.
+    expect(scale.intensity(0)).toBe(0)
+  })
 
-    it('setRange swaps the range without rebuilding the scale', () => {
-        const scale = createLogColorScale(1, 100)
-        expect(scale.intensity(10)).toBeCloseTo(0.5, 10)
-        scale.setRange(1, 1_000_000)
-        // Now ln(10) / ln(1e6) = 1 / 6.
-        expect(scale.intensity(10)).toBeCloseTo(1 / 6, 6)
-        expect(scale.range()).toEqual({ sizeMin: 1, sizeMax: 1_000_000 })
-    })
+  it('setRange swaps the range without rebuilding the scale', () => {
+    const scale = createLogColorScale(1, 100)
+    expect(scale.intensity(10)).toBeCloseTo(0.5, 10)
+    scale.setRange(1, 1_000_000)
+    // Now ln(10) / ln(1e6) = 1 / 6.
+    expect(scale.intensity(10)).toBeCloseTo(1 / 6, 6)
+    expect(scale.range()).toEqual({ sizeMin: 1, sizeMax: 1_000_000 })
+  })
 
-    it('rejects invalid ranges at construction', () => {
-        expect(() => createLogColorScale(0, 1)).toThrow()
-        expect(() => createLogColorScale(1, 0)).toThrow()
-        expect(() => createLogColorScale(-1, 1)).toThrow()
-        expect(() => createLogColorScale(10, 1)).toThrow()
-        expect(() => createLogColorScale(Infinity, 1)).toThrow()
-    })
+  it('rejects invalid ranges at construction', () => {
+    expect(() => createLogColorScale(0, 1)).toThrow()
+    expect(() => createLogColorScale(1, 0)).toThrow()
+    expect(() => createLogColorScale(-1, 1)).toThrow()
+    expect(() => createLogColorScale(10, 1)).toThrow()
+    expect(() => createLogColorScale(Infinity, 1)).toThrow()
+  })
 })

package/src/components/orderBookHeatmap/__tests__/orderBookState.test.ts

@@ -3,111 +3,111 @@ import { describe, it, expect } from 'vitest'
 import { createOrderBookState } from '../createOrderBookState'
 
 describe('createOrderBookState', () => {
-    it('applies a bid delta and reflects it in the next snapshot', () => {
-        const book = createOrderBookState({ tickSize: 0.01 })
-        book.applyDelta({ side: 'bid', price: 100.0, size: 5, timestamp: 1 })
-        const snap = book.snapshot()
-        expect(snap.bids).toEqual([[100.0, 5]])
-        expect(snap.asks).toEqual([])
-        expect(snap.timestamp).toBe(1)
-    })
+  it('applies a bid delta and reflects it in the next snapshot', () => {
+    const book = createOrderBookState({ tickSize: 0.01 })
+    book.applyDelta({ side: 'bid', price: 100.0, size: 5, timestamp: 1 })
+    const snap = book.snapshot()
+    expect(snap.bids).toEqual([[100.0, 5]])
+    expect(snap.asks).toEqual([])
+    expect(snap.timestamp).toBe(1)
+  })
 
-    it('treats size=0 as a removal of the level', () => {
-        const book = createOrderBookState({ tickSize: 0.01 })
-        book.applyDelta({ side: 'bid', price: 100.0, size: 5, timestamp: 1 })
-        book.applyDelta({ side: 'bid', price: 100.0, size: 0, timestamp: 2 })
-        const snap = book.snapshot()
-        expect(snap.bids).toEqual([])
-        expect(snap.timestamp).toBe(2)
-    })
+  it('treats size=0 as a removal of the level', () => {
+    const book = createOrderBookState({ tickSize: 0.01 })
+    book.applyDelta({ side: 'bid', price: 100.0, size: 5, timestamp: 1 })
+    book.applyDelta({ side: 'bid', price: 100.0, size: 0, timestamp: 2 })
+    const snap = book.snapshot()
+    expect(snap.bids).toEqual([])
+    expect(snap.timestamp).toBe(2)
+  })
 
-    it('quantizes input prices to ticks (67000.123 with tick 0.01 → 67000.12)', () => {
-        const book = createOrderBookState({ tickSize: 0.01 })
-        book.applyDelta({ side: 'ask', price: 67000.123, size: 1, timestamp: 1 })
-        const snap = book.snapshot()
-        expect(snap.asks).toHaveLength(1)
-        expect(snap.asks[0][0]).toBeCloseTo(67000.12, 6)
-        expect(snap.asks[0][1]).toBe(1)
-    })
+  it('quantizes input prices to ticks (67000.123 with tick 0.01 → 67000.12)', () => {
+    const book = createOrderBookState({ tickSize: 0.01 })
+    book.applyDelta({ side: 'ask', price: 67000.123, size: 1, timestamp: 1 })
+    const snap = book.snapshot()
+    expect(snap.asks).toHaveLength(1)
+    expect(snap.asks[0][0]).toBeCloseTo(67000.12, 6)
+    expect(snap.asks[0][1]).toBe(1)
+  })
 
-    it('returns dequantized prices (consumer never sees the tick index)', () => {
-        const book = createOrderBookState({ tickSize: 0.5 })
-        // 100.7 → tick 201 → 100.5
-        book.applyDelta({ side: 'bid', price: 100.7, size: 3, timestamp: 1 })
-        // 101.3 → tick 203 → 101.5
-        book.applyDelta({ side: 'ask', price: 101.3, size: 4, timestamp: 1 })
-        const snap = book.snapshot()
-        expect(snap.bids).toEqual([[100.5, 3]])
-        expect(snap.asks).toEqual([[101.5, 4]])
-    })
+  it('returns dequantized prices (consumer never sees the tick index)', () => {
+    const book = createOrderBookState({ tickSize: 0.5 })
+    // 100.7 → tick 201 → 100.5
+    book.applyDelta({ side: 'bid', price: 100.7, size: 3, timestamp: 1 })
+    // 101.3 → tick 203 → 101.5
+    book.applyDelta({ side: 'ask', price: 101.3, size: 4, timestamp: 1 })
+    const snap = book.snapshot()
+    expect(snap.bids).toEqual([[100.5, 3]])
+    expect(snap.asks).toEqual([[101.5, 4]])
+  })
 
-    it('clear() resets both sides and the last timestamp', () => {
-        const book = createOrderBookState({ tickSize: 0.01 })
-        book.applyDelta({ side: 'bid', price: 100, size: 1, timestamp: 5 })
-        book.applyDelta({ side: 'ask', price: 101, size: 2, timestamp: 6 })
-        book.clear()
-        const snap = book.snapshot()
-        expect(snap.bids).toEqual([])
-        expect(snap.asks).toEqual([])
-        expect(snap.timestamp).toBe(0)
-        expect(book.lastTimestamp()).toBe(0)
-    })
+  it('clear() resets both sides and the last timestamp', () => {
+    const book = createOrderBookState({ tickSize: 0.01 })
+    book.applyDelta({ side: 'bid', price: 100, size: 1, timestamp: 5 })
+    book.applyDelta({ side: 'ask', price: 101, size: 2, timestamp: 6 })
+    book.clear()
+    const snap = book.snapshot()
+    expect(snap.bids).toEqual([])
+    expect(snap.asks).toEqual([])
+    expect(snap.timestamp).toBe(0)
+    expect(book.lastTimestamp()).toBe(0)
+  })
 
-    it('last update wins for the same price (multiple updates collapse)', () => {
-        const book = createOrderBookState({ tickSize: 0.01 })
-        book.applyDelta({ side: 'bid', price: 100, size: 1, timestamp: 1 })
-        book.applyDelta({ side: 'bid', price: 100, size: 2, timestamp: 2 })
-        book.applyDelta({ side: 'bid', price: 100, size: 9, timestamp: 3 })
-        const snap = book.snapshot()
-        expect(snap.bids).toEqual([[100.0, 9]])
-        expect(snap.timestamp).toBe(3)
-    })
+  it('last update wins for the same price (multiple updates collapse)', () => {
+    const book = createOrderBookState({ tickSize: 0.01 })
+    book.applyDelta({ side: 'bid', price: 100, size: 1, timestamp: 1 })
+    book.applyDelta({ side: 'bid', price: 100, size: 2, timestamp: 2 })
+    book.applyDelta({ side: 'bid', price: 100, size: 9, timestamp: 3 })
+    const snap = book.snapshot()
+    expect(snap.bids).toEqual([[100.0, 9]])
+    expect(snap.timestamp).toBe(3)
+  })
 
-    it('maintains bid and ask side independence', () => {
-        const book = createOrderBookState({ tickSize: 0.01 })
-        book.applyDelta({ side: 'bid', price: 100, size: 5, timestamp: 1 })
-        book.applyDelta({ side: 'ask', price: 100, size: 7, timestamp: 2 })
-        // Removing bid at 100 must not remove ask at 100.
-        book.applyDelta({ side: 'bid', price: 100, size: 0, timestamp: 3 })
-        const snap = book.snapshot()
-        expect(snap.bids).toEqual([])
-        expect(snap.asks).toEqual([[100, 7]])
-    })
+  it('maintains bid and ask side independence', () => {
+    const book = createOrderBookState({ tickSize: 0.01 })
+    book.applyDelta({ side: 'bid', price: 100, size: 5, timestamp: 1 })
+    book.applyDelta({ side: 'ask', price: 100, size: 7, timestamp: 2 })
+    // Removing bid at 100 must not remove ask at 100.
+    book.applyDelta({ side: 'bid', price: 100, size: 0, timestamp: 3 })
+    const snap = book.snapshot()
+    expect(snap.bids).toEqual([])
+    expect(snap.asks).toEqual([[100, 7]])
+  })
 
-    it('sorts bids descending and asks ascending', () => {
-        const book = createOrderBookState({ tickSize: 0.01 })
-        book.applyDelta({ side: 'bid', price: 99.5, size: 1, timestamp: 1 })
-        book.applyDelta({ side: 'bid', price: 100.0, size: 1, timestamp: 1 })
-        book.applyDelta({ side: 'bid', price: 99.8, size: 1, timestamp: 1 })
-        book.applyDelta({ side: 'ask', price: 101.0, size: 1, timestamp: 1 })
-        book.applyDelta({ side: 'ask', price: 100.2, size: 1, timestamp: 1 })
-        book.applyDelta({ side: 'ask', price: 100.5, size: 1, timestamp: 1 })
-        const snap = book.snapshot()
-        expect(snap.bids.map((b) => b[0])).toEqual([100.0, 99.8, 99.5])
-        expect(snap.asks.map((a) => a[0])).toEqual([100.2, 100.5, 101.0])
-    })
+  it('sorts bids descending and asks ascending', () => {
+    const book = createOrderBookState({ tickSize: 0.01 })
+    book.applyDelta({ side: 'bid', price: 99.5, size: 1, timestamp: 1 })
+    book.applyDelta({ side: 'bid', price: 100.0, size: 1, timestamp: 1 })
+    book.applyDelta({ side: 'bid', price: 99.8, size: 1, timestamp: 1 })
+    book.applyDelta({ side: 'ask', price: 101.0, size: 1, timestamp: 1 })
+    book.applyDelta({ side: 'ask', price: 100.2, size: 1, timestamp: 1 })
+    book.applyDelta({ side: 'ask', price: 100.5, size: 1, timestamp: 1 })
+    const snap = book.snapshot()
+    expect(snap.bids.map((b) => b[0])).toEqual([100.0, 99.8, 99.5])
+    expect(snap.asks.map((a) => a[0])).toEqual([100.2, 100.5, 101.0])
+  })
 
-    it('respects maxLevels by truncating to top-of-book first', () => {
-        const book = createOrderBookState({ tickSize: 0.01, maxLevels: 2 })
-        book.applyDelta({ side: 'bid', price: 99.5, size: 1, timestamp: 1 })
-        book.applyDelta({ side: 'bid', price: 100.0, size: 1, timestamp: 1 })
-        book.applyDelta({ side: 'bid', price: 99.8, size: 1, timestamp: 1 })
-        const snap = book.snapshot()
-        expect(snap.bids.map((b) => b[0])).toEqual([100.0, 99.8])
-    })
+  it('respects maxLevels by truncating to top-of-book first', () => {
+    const book = createOrderBookState({ tickSize: 0.01, maxLevels: 2 })
+    book.applyDelta({ side: 'bid', price: 99.5, size: 1, timestamp: 1 })
+    book.applyDelta({ side: 'bid', price: 100.0, size: 1, timestamp: 1 })
+    book.applyDelta({ side: 'bid', price: 99.8, size: 1, timestamp: 1 })
+    const snap = book.snapshot()
+    expect(snap.bids.map((b) => b[0])).toEqual([100.0, 99.8])
+  })
 
-    it('rejects non-positive tickSize at construction', () => {
-        expect(() => createOrderBookState({ tickSize: 0 })).toThrow()
-        expect(() => createOrderBookState({ tickSize: -1 })).toThrow()
-        expect(() => createOrderBookState({ tickSize: Infinity })).toThrow()
-    })
+  it('rejects non-positive tickSize at construction', () => {
+    expect(() => createOrderBookState({ tickSize: 0 })).toThrow()
+    expect(() => createOrderBookState({ tickSize: -1 })).toThrow()
+    expect(() => createOrderBookState({ tickSize: Infinity })).toThrow()
+  })
 
-    it('ignores NaN / Infinity deltas without corrupting state', () => {
-        const book = createOrderBookState({ tickSize: 0.01 })
-        book.applyDelta({ side: 'bid', price: NaN, size: 1, timestamp: 1 })
-        book.applyDelta({ side: 'bid', price: 100, size: NaN, timestamp: 2 })
-        book.applyDelta({ side: 'bid', price: 100, size: 1, timestamp: 3 })
-        const snap = book.snapshot()
-        expect(snap.bids).toEqual([[100, 1]])
-    })
+  it('ignores NaN / Infinity deltas without corrupting state', () => {
+    const book = createOrderBookState({ tickSize: 0.01 })
+    book.applyDelta({ side: 'bid', price: NaN, size: 1, timestamp: 1 })
+    book.applyDelta({ side: 'bid', price: 100, size: NaN, timestamp: 2 })
+    book.applyDelta({ side: 'bid', price: 100, size: 1, timestamp: 3 })
+    const snap = book.snapshot()
+    expect(snap.bids).toEqual([[100, 1]])
+  })
 })

package/src/components/orderBookHeatmap/__tests__/snapshotRing.test.ts

@@ -4,50 +4,50 @@ import { createSnapshotRing } from '../snapshotRing'
 import type { BookSnapshot } from '../types'
 
 function makeSnap(ts: number): BookSnapshot {
-    return { bids: [], asks: [], timestamp: ts }
+  return { bids: [], asks: [], timestamp: ts }
 }
 
 describe('createSnapshotRing', () => {
-    it('respects the declared capacity and reports size accurately', () => {
-        const ring = createSnapshotRing(3)
-        expect(ring.capacity).toBe(3)
-        expect(ring.size()).toBe(0)
-        ring.push(makeSnap(1))
-        ring.push(makeSnap(2))
-        expect(ring.size()).toBe(2)
-    })
+  it('respects the declared capacity and reports size accurately', () => {
+    const ring = createSnapshotRing(3)
+    expect(ring.capacity).toBe(3)
+    expect(ring.size()).toBe(0)
+    ring.push(makeSnap(1))
+    ring.push(makeSnap(2))
+    expect(ring.size()).toBe(2)
+  })
 
-    it('drops the oldest entry when pushed past capacity', () => {
-        const ring = createSnapshotRing(3)
-        ring.push(makeSnap(1))
-        ring.push(makeSnap(2))
-        ring.push(makeSnap(3))
-        ring.push(makeSnap(4))
-        const out = ring.toArray()
-        expect(out.map((s) => s.timestamp)).toEqual([2, 3, 4])
-    })
+  it('drops the oldest entry when pushed past capacity', () => {
+    const ring = createSnapshotRing(3)
+    ring.push(makeSnap(1))
+    ring.push(makeSnap(2))
+    ring.push(makeSnap(3))
+    ring.push(makeSnap(4))
+    const out = ring.toArray()
+    expect(out.map((s) => s.timestamp)).toEqual([2, 3, 4])
+  })
 
-    it('toArray returns snapshots oldest → newest, even after wrap-around', () => {
-        const ring = createSnapshotRing(4)
-        for (let i = 1; i <= 10; i++) ring.push(makeSnap(i))
-        const out = ring.toArray()
-        expect(out.map((s) => s.timestamp)).toEqual([7, 8, 9, 10])
-    })
+  it('toArray returns snapshots oldest → newest, even after wrap-around', () => {
+    const ring = createSnapshotRing(4)
+    for (let i = 1; i <= 10; i++) ring.push(makeSnap(i))
+    const out = ring.toArray()
+    expect(out.map((s) => s.timestamp)).toEqual([7, 8, 9, 10])
+  })
 
-    it('clear() empties the buffer without affecting capacity', () => {
-        const ring = createSnapshotRing(2)
-        ring.push(makeSnap(1))
-        ring.push(makeSnap(2))
-        ring.clear()
-        expect(ring.size()).toBe(0)
-        expect(ring.toArray()).toEqual([])
-        ring.push(makeSnap(3))
-        expect(ring.toArray().map((s) => s.timestamp)).toEqual([3])
-    })
+  it('clear() empties the buffer without affecting capacity', () => {
+    const ring = createSnapshotRing(2)
+    ring.push(makeSnap(1))
+    ring.push(makeSnap(2))
+    ring.clear()
+    expect(ring.size()).toBe(0)
+    expect(ring.toArray()).toEqual([])
+    ring.push(makeSnap(3))
+    expect(ring.toArray().map((s) => s.timestamp)).toEqual([3])
+  })
 
-    it('rejects non-positive capacity', () => {
-        expect(() => createSnapshotRing(0)).toThrow()
-        expect(() => createSnapshotRing(-5)).toThrow()
-        expect(() => createSnapshotRing(1.5)).toThrow()
-    })
+  it('rejects non-positive capacity', () => {
+    expect(() => createSnapshotRing(0)).toThrow()
+    expect(() => createSnapshotRing(-5)).toThrow()
+    expect(() => createSnapshotRing(1.5)).toThrow()
+  })
 })

package/src/components/orderBookHeatmap/computeShader.wgsl.md

@@ -12,8 +12,8 @@ work.
 
 Logically a 2-D grid `intensity[col][row]` where:
 
-- `col`  ∈ `[0, snapshotRingCapacity)` — time axis (oldest → newest)
-- `row`  ∈ `[0, priceRowCount)` — price axis (low → high)
+- `col` ∈ `[0, snapshotRingCapacity)` — time axis (oldest → newest)
+- `row` ∈ `[0, priceRowCount)` — price axis (low → high)
 
 CPU-side layout (one upload per render frame for simplicity in v0):
 
@@ -125,6 +125,6 @@ call and a divide — no change to the buffer shape is required.
 ## Composition with depth chart / order book ladder
 
 The same `ring` storage buffer is consumed by §3.4's depth chart, which only
-needs the *current* column (`ringHead - 1 mod N`) and a different fragment
+needs the _current_ column (`ringHead - 1 mod N`) and a different fragment
 shader that does a cumulative-sum sweep. We deliberately avoid duplicating
 state for the two visualizations.