@carto/ps-react-ui 5.0.0 → 6.0.0

package/src/widgets/stores/widget-store-performance.test.ts

@@ -1,750 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest'
-import { useWidgetStore } from './widget-store'
-
-/**
- * Performance tests for the widget store.
- *
- * These tests measure and assert on the performance characteristics of the
- * widget store when operating at scale (100-200 widgets). They quantify the
- * core issues that cause sluggish behavior in dashboards with many widgets:
- *
- * 1. O(n) selector evaluation on every store update (cross-widget interference)
- * 2. Multiple sequential store updates per widget during initialization
- * 3. Cascading tool registrations triggering re-evaluations
- * 4. Full `widgets` object spread on every setWidget call
- */
-describe.skip('WidgetStore Performance', () => {
-  beforeEach(() => {
-    useWidgetStore.setState({ widgets: {} })
-  })
-
-  describe('setWidget spreads entire widgets object', () => {
-    it('creates a new widgets object reference on every setWidget call', () => {
-      const { setWidget } = useWidgetStore.getState()
-
-      // Seed 100 widgets
-      for (let i = 0; i < 100; i++) {
-        setWidget(`widget-${i}`, {
-          type: 'formula',
-          isLoading: false,
-          data: { value: i },
-        })
-      }
-
-      const before = useWidgetStore.getState().widgets
-
-      // Updating a SINGLE widget creates a new widgets object
-      setWidget('widget-0', { data: { value: 999 } })
-
-      const after = useWidgetStore.getState().widgets
-
-      // The top-level widgets object reference changes
-      expect(before).not.toBe(after)
-
-      // But all OTHER widgets are the same object references
-      for (let i = 1; i < 100; i++) {
-        expect(before[`widget-${i}`]).toBe(after[`widget-${i}`])
-      }
-    })
-  })
-
-  describe('subscriber notification overhead at scale', () => {
-    it('notifies ALL subscribers when any single widget updates', () => {
-      const { setWidget } = useWidgetStore.getState()
-      const WIDGET_COUNT = 100
-
-      // Seed widgets
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        setWidget(`widget-${i}`, {
-          type: 'formula',
-          isLoading: false,
-          data: { value: i },
-        })
-      }
-
-      // Create selectors for each widget (simulating what components do)
-      const selectorCalls = new Array(WIDGET_COUNT).fill(0) as number[]
-      const selectors = Array.from({ length: WIDGET_COUNT }, (_, i) => {
-        return (state: ReturnType<typeof useWidgetStore.getState>) => {
-          selectorCalls[i]!++
-          return state.widgets[`widget-${i}`]?.data
-        }
-      })
-
-      // Subscribe all selectors
-      const unsubscribes = selectors.map((selector) =>
-        useWidgetStore.subscribe((state) => selector(state)),
-      )
-
-      // Reset counters after subscription setup
-      selectorCalls.fill(0)
-
-      // Update ONLY widget-0
-      setWidget('widget-0', { data: { value: 'updated' } })
-
-      // ALL 100 selectors were called, not just widget-0's
-      const totalCalls = selectorCalls.reduce((sum, c) => sum + c, 0)
-      expect(totalCalls).toBe(WIDGET_COUNT)
-
-      // Every single selector ran, even though only widget-0 changed
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        expect(selectorCalls[i]).toBe(1)
-      }
-
-      unsubscribes.forEach((unsub) => unsub())
-    })
-
-    it('measures O(n) selector evaluation cost per store update', () => {
-      const { setWidget } = useWidgetStore.getState()
-      const WIDGET_COUNT = 200
-
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        setWidget(`widget-${i}`, {
-          type: 'formula',
-          isLoading: false,
-          data: { value: i },
-        })
-      }
-
-      let selectorRunCount = 0
-
-      // Simulate realistic selectors: each widget has ~5 property selectors
-      const unsubscribes: (() => void)[] = []
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        const widgetId = `widget-${i}`
-        const properties = ['data', 'isLoading', 'isFetching', 'type', 'error']
-        for (const prop of properties) {
-          unsubscribes.push(
-            useWidgetStore.subscribe((state) => {
-              selectorRunCount++
-              return (
-                state.widgets[widgetId] as Record<string, unknown> | undefined
-              )?.[prop]
-            }),
-          )
-        }
-      }
-
-      selectorRunCount = 0
-
-      // A single widget update triggers ALL selectors
-      setWidget('widget-0', { data: { value: 'changed' } })
-
-      // 200 widgets × 5 selectors = 1000 selector evaluations for ONE update
-      expect(selectorRunCount).toBe(WIDGET_COUNT * 5)
-
-      unsubscribes.forEach((unsub) => unsub())
-    })
-  })
-
-  describe('initialization storm: setWidget calls per widget', () => {
-    it('counts store updates during widget initialization sequence (merged effects)', () => {
-      const storeSpy = vi.fn()
-      const unsub = useWidgetStore.subscribe(storeSpy)
-
-      const { setWidget } = useWidgetStore.getState()
-
-      // After Phase 1 optimization: WidgetLoader merges type + loading/error
-      // into a single setWidget call (Effect 1 merged with Effect 2).
-      setWidget('widget-0', {
-        type: 'bar',
-        isLoading: false,
-        isFetching: false,
-        error: undefined,
-      })
-
-      // 1 store update per widget from WidgetLoader metadata effect.
-      // executeToolPipeline and executeConfigPipeline add more.
-      expect(storeSpy).toHaveBeenCalledTimes(1)
-
-      unsub()
-    })
-
-    it('measures total store updates when 100 widgets initialize (merged effects)', () => {
-      const storeSpy = vi.fn()
-      const unsub = useWidgetStore.subscribe(storeSpy)
-
-      const { setWidget } = useWidgetStore.getState()
-      const WIDGET_COUNT = 100
-
-      // Simulate all 100 widgets calling their merged WidgetLoader effect
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        setWidget(`widget-${i}`, {
-          type: 'bar',
-          isLoading: false,
-          isFetching: false,
-          error: undefined,
-        })
-      }
-
-      // 100 widgets × 1 setWidget call = 100 store updates (was 200 before merge)
-      expect(storeSpy).toHaveBeenCalledTimes(WIDGET_COUNT)
-
-      unsub()
-    })
-  })
-
-  it('does not skip when values actually change', () => {
-    const { setWidget } = useWidgetStore.getState()
-
-    setWidget('widget-0', { type: 'bar', isLoading: false })
-
-    const storeSpy = vi.fn()
-    const unsub = useWidgetStore.subscribe(storeSpy)
-
-    setWidget('widget-0', { isLoading: true })
-
-    expect(storeSpy).toHaveBeenCalledTimes(1)
-
-    unsub()
-  })
-
-  it('does not skip for new widgets (no current state)', () => {
-    const storeSpy = vi.fn()
-    const unsub = useWidgetStore.subscribe(storeSpy)
-
-    const { setWidget } = useWidgetStore.getState()
-    setWidget('new-widget', { type: 'formula', isLoading: false })
-
-    expect(storeSpy).toHaveBeenCalledTimes(1)
-
-    unsub()
-  })
-
-  describe('tool registration cascading updates', () => {
-    it('counts store updates when actions register tools on 100 widgets', () => {
-      const { setWidget, registerTool } = useWidgetStore.getState()
-      const WIDGET_COUNT = 100
-
-      // Seed widgets
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        setWidget(`widget-${i}`, {
-          type: 'bar',
-          isLoading: false,
-        })
-      }
-
-      const storeSpy = vi.fn()
-      const unsub = useWidgetStore.subscribe(storeSpy)
-
-      // Simulate action components mounting and registering tools.
-      // A bar widget with full actions registers ~8 tools:
-      // RelativeData (2 tools), StackToggle (1), Searcher (1),
-      // SearcherToggle config (1), ZoomToggle (1), BrushToggle (1), Download ref (1)
-      const TOOLS_PER_WIDGET = 8
-
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        for (let t = 0; t < TOOLS_PER_WIDGET; t++) {
-          registerTool(`widget-${i}`, {
-            id: `tool-${t}`,
-            order: t * 10,
-            enabled: true,
-            fn: (data) => data,
-          })
-        }
-      }
-
-      // 100 widgets × 8 tools = 800 store updates from tool registration alone
-      expect(storeSpy).toHaveBeenCalledTimes(WIDGET_COUNT * TOOLS_PER_WIDGET)
-
-      unsub()
-    })
-
-    it('shows that registerTool triggers re-evaluation of all widget selectors', () => {
-      const { setWidget, registerTool } = useWidgetStore.getState()
-      const WIDGET_COUNT = 50
-
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        setWidget(`widget-${i}`, { type: 'bar', isLoading: false })
-      }
-
-      let totalSelectorRuns = 0
-      const unsubscribes = Array.from({ length: WIDGET_COUNT }, (_, i) =>
-        useWidgetStore.subscribe((state) => {
-          totalSelectorRuns++
-          return state.widgets[`widget-${i}`]?.registeredTools
-        }),
-      )
-
-      totalSelectorRuns = 0
-
-      // Registering a tool on widget-0 triggers ALL selectors
-      registerTool('widget-0', {
-        id: 'test-tool',
-        order: 10,
-        enabled: true,
-        fn: (data) => data,
-      })
-
-      expect(totalSelectorRuns).toBe(WIDGET_COUNT)
-
-      unsubscribes.forEach((unsub) => unsub())
-    })
-  })
-
-  describe('pipeline execution store updates', () => {
-    it('executeToolPipeline calls setWidget even with no tools', async () => {
-      const { setWidget, executeToolPipeline } = useWidgetStore.getState()
-
-      setWidget('widget-0', { type: 'bar', isLoading: false })
-
-      const storeSpy = vi.fn()
-      const unsub = useWidgetStore.subscribe(storeSpy)
-
-      // Even with no registered tools, executeToolPipeline does a set()
-      await executeToolPipeline('widget-0', [{ category: 'A', value: 1 }])
-
-      // 1 store update to write the data
-      expect(storeSpy).toHaveBeenCalledTimes(1)
-
-      unsub()
-    })
-
-    it('measures total store updates when 100 widgets execute pipelines simultaneously', async () => {
-      const { setWidget, executeToolPipeline, executeConfigPipeline } =
-        useWidgetStore.getState()
-      const WIDGET_COUNT = 100
-
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        setWidget(`widget-${i}`, { type: 'bar', isLoading: false })
-      }
-
-      const storeSpy = vi.fn()
-      const unsub = useWidgetStore.subscribe(storeSpy)
-
-      // All 100 widgets execute both pipelines concurrently (like on data change)
-      await Promise.all(
-        Array.from({ length: WIDGET_COUNT }, (_, i) =>
-          Promise.all([
-            executeToolPipeline(`widget-${i}`, { value: i }),
-            executeConfigPipeline(`widget-${i}`, { option: {} }),
-          ]),
-        ),
-      )
-
-      // Each widget: 1 data pipeline set + 1 config pipeline set = 2 store updates
-      // Total: 100 × 2 = 200 store updates
-      expect(storeSpy).toHaveBeenCalledTimes(WIDGET_COUNT * 2)
-
-      unsub()
-    })
-  })
-
-  describe('full initialization simulation', () => {
-    it('counts total store updates for a realistic 100-widget dashboard startup', async () => {
-      const storeSpy = vi.fn()
-      const unsub = useWidgetStore.subscribe(storeSpy)
-
-      const {
-        setWidget,
-        registerTool,
-        executeToolPipeline,
-        executeConfigPipeline,
-      } = useWidgetStore.getState()
-
-      const WIDGET_COUNT = 100
-      const TOOLS_PER_WIDGET = 6
-
-      // Phase 1: WidgetLoader merged effect (1 setWidget call each)
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        setWidget(`widget-${i}`, {
-          type: 'bar',
-          isLoading: false,
-          isFetching: false,
-        })
-      }
-
-      // Phase 2: Action components register tools
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        for (let t = 0; t < TOOLS_PER_WIDGET; t++) {
-          registerTool(`widget-${i}`, {
-            id: `tool-${t}`,
-            order: t * 10,
-            enabled: t < 3, // some enabled, some disabled
-            fn: (data) => data,
-          })
-        }
-      }
-
-      // Phase 3: Pipeline executions
-      await Promise.all(
-        Array.from({ length: WIDGET_COUNT }, (_, i) =>
-          Promise.all([
-            executeToolPipeline(`widget-${i}`, { value: i }),
-            executeConfigPipeline(`widget-${i}`, { option: {} }),
-          ]),
-        ),
-      )
-
-      const totalUpdates = storeSpy.mock.calls.length
-
-      // Phase 1: 100 × 1 = 100 (merged effects, was 200 before)
-      // Phase 2: 100 × 6 = 600
-      // Phase 3: 100 × 2 = 200
-      // Total: 900 store updates (was 1000 before merge)
-      expect(totalUpdates).toBe(
-        WIDGET_COUNT * 1 + // merged setWidget calls
-          WIDGET_COUNT * TOOLS_PER_WIDGET + // registerTool calls
-          WIDGET_COUNT * 2, // pipeline executions
-      )
-
-      unsub()
-    })
-  })
-
-  describe('shared widget IDs (200-widget scenario)', () => {
-    it('shows that two components sharing the same widget ID overwrite each other', () => {
-      const { setWidget } = useWidgetStore.getState()
-
-      // First "instance" sets data
-      setWidget('shared-widget', {
-        type: 'bar',
-        isLoading: false,
-        data: { value: 'first' },
-      })
-
-      // Second "instance" with same ID overwrites
-      setWidget('shared-widget', {
-        type: 'bar',
-        isLoading: false,
-        data: { value: 'second' },
-      })
-
-      const widget = useWidgetStore.getState().widgets['shared-widget']
-      expect((widget?.data as { value: string })?.value).toBe('second')
-    })
-
-    it('measures store updates when 200 widgets share 100 IDs', async () => {
-      const { setWidget, registerTool, executeToolPipeline } =
-        useWidgetStore.getState()
-
-      const storeSpy = vi.fn()
-      const unsub = useWidgetStore.subscribe(storeSpy)
-
-      // 200 widget instances, but only 100 unique IDs
-      // The second 100 re-use IDs from the first 100
-      for (let instance = 0; instance < 200; instance++) {
-        const id = `widget-${instance % 100}`
-        setWidget(id, { type: 'bar', isLoading: false })
-        setWidget(id, { isFetching: false })
-      }
-
-      // Tool registrations also double
-      storeSpy.mockClear()
-      for (let instance = 0; instance < 200; instance++) {
-        const id = `widget-${instance % 100}`
-        registerTool(id, {
-          id: 'relative-data',
-          order: 10,
-          enabled: true,
-          fn: (data) => data,
-        })
-      }
-
-      // First 100 registerTool calls create new tools = 100 store updates.
-      // Second 100 calls have same id/order/enabled/type/disables — registerTool's
-      // no-op detection updates fn via direct mutation and skips set().
-      expect(storeSpy).toHaveBeenCalledTimes(100)
-
-      // Pipeline executions also double
-      storeSpy.mockClear()
-      await Promise.all(
-        Array.from({ length: 200 }, (_, i) =>
-          executeToolPipeline(`widget-${i % 100}`, { value: i }),
-        ),
-      )
-
-      // 200 pipeline executions but with cancellation, only 100 survive
-      // (each later execution for the same ID cancels the previous one)
-      // The final set() calls: at most 100 (one per unique ID)
-      const pipelineUpdates = storeSpy.mock.calls.length
-      expect(pipelineUpdates).toBeLessThanOrEqual(200)
-      expect(pipelineUpdates).toBeGreaterThanOrEqual(100)
-
-      unsub()
-    })
-  })
-
-  describe('dynamic data update performance', () => {
-    it('measures store churn when all 100 widgets update data simultaneously', async () => {
-      const { setWidget, executeToolPipeline, registerTool } =
-        useWidgetStore.getState()
-      const WIDGET_COUNT = 100
-
-      // Setup: seed widgets with tools
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        setWidget(`widget-${i}`, { type: 'bar', isLoading: false })
-        registerTool(`widget-${i}`, {
-          id: 'data-transform',
-          order: 10,
-          enabled: true,
-          fn: (data) => data, // passthrough
-        })
-      }
-
-      const storeSpy = vi.fn()
-      const unsub = useWidgetStore.subscribe(storeSpy)
-
-      // Simulate dynamic data update: all widgets get new data at once
-      await Promise.all(
-        Array.from({ length: WIDGET_COUNT }, (_, i) =>
-          executeToolPipeline(`widget-${i}`, { value: Math.random() }),
-        ),
-      )
-
-      // Each pipeline: 1 set() call to write transformed data
-      expect(storeSpy).toHaveBeenCalledTimes(WIDGET_COUNT)
-
-      unsub()
-    })
-  })
-
-  describe('cascading Effect 4: tool registration triggers pipeline re-execution', () => {
-    it('proves each registerTool triggers 2 pipeline re-executions via Effect 4', async () => {
-      const {
-        setWidget,
-        registerTool,
-        executeToolPipeline,
-        executeConfigPipeline,
-      } = useWidgetStore.getState()
-
-      // Setup: create widget with initial data
-      setWidget('widget-0', { type: 'bar', isLoading: false })
-      await executeToolPipeline('widget-0', { value: 1 })
-      await executeConfigPipeline('widget-0', { option: {} })
-
-      const storeSpy = vi.fn()
-      const unsub = useWidgetStore.subscribe(storeSpy)
-
-      // Simulate what Effect 4 does: after each registerTool, WidgetLoader
-      // re-executes both pipelines because registeredTools changed.
-      const TOOLS_PER_WIDGET = 6
-      for (let t = 0; t < TOOLS_PER_WIDGET; t++) {
-        // Action component registers a tool
-        registerTool('widget-0', {
-          id: `tool-${t}`,
-          order: t * 10,
-          enabled: true,
-          fn: (data) => data,
-        })
-
-        // Effect 4 fires: re-execute both pipelines
-        await executeToolPipeline('widget-0', { value: 1 })
-        await executeConfigPipeline('widget-0', { option: {} })
-      }
-
-      // Per tool: 1 registerTool + 1 data pipeline + 1 config pipeline = 3 store updates
-      // 6 tools × 3 = 18 store updates just from tool registration cascading
-      expect(storeSpy).toHaveBeenCalledTimes(TOOLS_PER_WIDGET * 3)
-
-      unsub()
-    })
-
-    it('measures total store updates for realistic single widget mount', async () => {
-      const {
-        setWidget,
-        registerTool,
-        executeToolPipeline,
-        executeConfigPipeline,
-      } = useWidgetStore.getState()
-
-      const storeSpy = vi.fn()
-      const unsub = useWidgetStore.subscribe(storeSpy)
-
-      const data = { value: 1 }
-      const config = { option: {} }
-
-      // WidgetLoader Effect 1: metadata
-      setWidget('widget-0', {
-        type: 'bar',
-        isLoading: false,
-        isFetching: false,
-      })
-
-      // WidgetWrapper useLayoutEffect
-      setWidget('widget-0', {
-        collapsed: false,
-        disabled: false,
-        title: 'Test Widget',
-      })
-
-      // useWidgetRef useEffect
-      setWidget('widget-0', { refUI: undefined })
-
-      // WidgetLoader Effect 2: config pipeline
-      await executeConfigPipeline('widget-0', config)
-
-      // WidgetLoader Effect 3: data pipeline
-      await executeToolPipeline('widget-0', data)
-
-      // Action components register tools + Effect 4 cascades
-      const tools = [
-        'relative-data',
-        'relative-data-config',
-        'stack-toggle',
-        'zoom-toggle',
-        'brush-toggle',
-        'searcher',
-      ]
-      for (const toolId of tools) {
-        registerTool('widget-0', {
-          id: toolId,
-          order: 10,
-          enabled: true,
-          fn: (d) => d,
-        })
-        // Effect 4: re-execute both pipelines
-        await executeToolPipeline('widget-0', data)
-        await executeConfigPipeline('widget-0', config)
-      }
-
-      // StackToggle also calls setWidget for default isStacked
-      setWidget('widget-0', { isStacked: false })
-
-      const totalUpdates = storeSpy.mock.calls.length
-
-      // Breakdown:
-      // 3 setWidget calls (metadata + wrapper + widgetRef) = 3
-      // 2 initial pipeline executions (config + data) = 2
-      // 6 tool registrations = 6
-      // Pipeline re-executions after tool registration: the pipeline no-op detection
-      // (Object.is check in executeToolPipeline/executeConfigPipeline) skips the set()
-      // when passthrough tools return the same data reference. So cascading re-executions
-      // produce 0 additional store updates with passthrough tools.
-      // 1 StackToggle setWidget = 1
-      // Total = 12 store updates for ONE widget
-      expect(totalUpdates).toBe(3 + 2 + tools.length + 1)
-
-      unsub()
-    })
-  })
-
-  describe('full 200-widget initialization with cascading effects', () => {
-    it('measures total store updates for 200-widget dashboard startup', async () => {
-      const {
-        setWidget,
-        registerTool,
-        executeToolPipeline,
-        executeConfigPipeline,
-      } = useWidgetStore.getState()
-
-      const storeSpy = vi.fn()
-      const unsub = useWidgetStore.subscribe(storeSpy)
-
-      const WIDGET_COUNT = 200
-      const TOOLS_PER_WIDGET = 6
-
-      // Phase 1: WidgetLoader + Wrapper + Ref effects (3 setWidget each)
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        setWidget(`widget-${i}`, {
-          type: 'bar',
-          isLoading: false,
-          isFetching: false,
-        })
-        setWidget(`widget-${i}`, {
-          collapsed: false,
-          title: `Widget ${i}`,
-        })
-        setWidget(`widget-${i}`, { refUI: undefined })
-      }
-
-      // Phase 2: Initial pipeline executions
-      await Promise.all(
-        Array.from({ length: WIDGET_COUNT }, (_, i) =>
-          Promise.all([
-            executeToolPipeline(`widget-${i}`, { value: i }),
-            executeConfigPipeline(`widget-${i}`, { option: {} }),
-          ]),
-        ),
-      )
-
-      // Phase 3: Tool registrations + cascading pipeline re-executions
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        for (let t = 0; t < TOOLS_PER_WIDGET; t++) {
-          registerTool(`widget-${i}`, {
-            id: `tool-${t}`,
-            order: t * 10,
-            enabled: true,
-            fn: (data) => data,
-          })
-        }
-        // Effect 4 fires for each tool change, but we simulate the final
-        // cascade: one pair of pipeline re-executions per tool registration
-        await executeToolPipeline(`widget-${i}`, { value: i })
-        await executeConfigPipeline(`widget-${i}`, { option: {} })
-      }
-
-      const totalUpdates = storeSpy.mock.calls.length
-
-      // Phase 1: 200 × 3 setWidget = 600
-      // Phase 2: 200 × 2 pipelines = 400
-      // Phase 3: 200 × (6 registerTool + 2 pipeline re-executions) = 200 × 8 = 1600
-      // Total: 2600 store updates
-      //
-      // In reality, Effect 4 fires per registerTool (not batched), which would be
-      // 200 × 6 × 2 = 2400 extra pipeline updates. We simulate the conservative case.
-      expect(totalUpdates).toBe(
-        WIDGET_COUNT * 3 + // setWidget calls
-          WIDGET_COUNT * 2 + // initial pipeline executions
-          WIDGET_COUNT * TOOLS_PER_WIDGET + // registerTool calls
-          WIDGET_COUNT * 2, // cascading pipeline re-executions (conservative: 1 per widget)
-      )
-
-      unsub()
-    })
-
-    it('measures wall-clock time for 200-widget store initialization', async () => {
-      const {
-        setWidget,
-        registerTool,
-        executeToolPipeline,
-        executeConfigPipeline,
-      } = useWidgetStore.getState()
-
-      const WIDGET_COUNT = 200
-      const TOOLS_PER_WIDGET = 6
-
-      const start = performance.now()
-
-      // Simulate full initialization
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        const id = `widget-${i}`
-        setWidget(id, { type: 'bar', isLoading: false, isFetching: false })
-        setWidget(id, { collapsed: false, title: `Widget ${i}` })
-      }
-
-      await Promise.all(
-        Array.from({ length: WIDGET_COUNT }, (_, i) =>
-          Promise.all([
-            executeToolPipeline(`widget-${i}`, { value: i }),
-            executeConfigPipeline(`widget-${i}`, { option: {} }),
-          ]),
-        ),
-      )
-
-      for (let i = 0; i < WIDGET_COUNT; i++) {
-        for (let t = 0; t < TOOLS_PER_WIDGET; t++) {
-          registerTool(`widget-${i}`, {
-            id: `tool-${t}`,
-            order: t * 10,
-            enabled: true,
-            fn: (data) => data,
-          })
-        }
-      }
-
-      const elapsed = performance.now() - start
-
-      // Log timing for baseline tracking (not a strict assertion)
-      // eslint-disable-next-line no-console
-      console.log(
-        `[Performance] 200-widget store init: ${elapsed.toFixed(1)}ms ` +
-          `(${WIDGET_COUNT} widgets × ${TOOLS_PER_WIDGET} tools = ` +
-          `${WIDGET_COUNT * (2 + TOOLS_PER_WIDGET)} store updates)`,
-      )
-
-      // Sanity check: should complete in under 5 seconds even on slow CI
-      expect(elapsed).toBeLessThan(5000)
-    })
-  })
-})