@morscherlab/mint-sdk 1.3.11 → 1.4.0-beta.10

package/src/__tests__/composables/useControlSchema.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { nextTick } from 'vue'
+import type { WellPlateSpec } from '../../types'
 import {
   controlsToFormSchema,
   controlsToSectionFormSchema,
@@ -27,15 +28,6 @@ import {
   useControlSchema,
   useControlWorkspace,
 } from '../../composables/useControlSchema'
-import {
-  useBioTemplateComponents,
-} from '../../composables/useBioTemplateComponents'
-import {
-  useBioTemplateControls,
-} from '../../composables/useBioTemplateControls'
-import {
-  createWellPlateScreenCollection,
-} from '../../templates'
 
 describe('useControlSchema', () => {
   const shorthandControls = defineControls({
@@ -141,13 +133,13 @@ describe('useControlSchema', () => {
 
   it('converts controls to a FormBuilder schema', () => {
     const schema = controlsToFormSchema(controls, {
-      submitLabel: 'Run analysis',
+      actions: { submitLabel: 'Run analysis' },
       sections: {
         parameters: { columns: 2 },
       },
     })
 
-    expect(schema.submitLabel).toBe('Run analysis')
+    expect(schema).toMatchObject({ actions: true, submitLabel: 'Run analysis' })
     expect(schema.sections.map(section => section.id)).toEqual(['parameters', 'output', 'diagnostics'])
     expect(schema.sections[0].title).toBe('Parameters')
     expect(schema.sections[0].description).toBeUndefined()
@@ -327,7 +319,7 @@ describe('useControlSchema', () => {
     const workspace = useControlWorkspace(model.controls, model.controlOptions)
 
     expect(workspace.values.replicates).toBe(4)
-    expect(workspace.topBar.value.pillNav.map(item => [item.id, item.label])).toEqual([
+    expect(workspace.topBar.value.spec.pills.map(item => [item.id, item.label])).toEqual([
       ['design', 'Design'],
       ['results', 'Results'],
     ])
@@ -338,8 +330,8 @@ describe('useControlSchema', () => {
       'design-display',
       'plots',
     ])
-    expect(workspace.topBarSettings.settingsConfig.title).toBe('Design settings')
-    expect(workspace.topBarSettings.settingsConfig.showAppearance).toBe(false)
+    expect(workspace.topBarSettings.spec.settings.title).toBe('Design settings')
+    expect(workspace.topBarSettings.spec.settings.showAppearance).toBe(false)
     expect(workspace.getComponentProps(model.componentProps)).toEqual({
       mode: 'uM',
       targetWells: ['A1', 'A2'],
@@ -548,9 +540,7 @@ describe('useControlSchema', () => {
     expect(config.title).toBe('Analysis controls')
     expect(config.showAppearance).toBe(false)
     expect(config.layout).toBe('vertical')
-    expect(config.controls).toBe(controls)
-    expect(config.controlOptions).toBe(options)
-    expect(config.schema).toBeUndefined()
+    expect(config.spec).toEqual({ controls, controlOptions: options })
   })
 
   it('returns section-only schemas for sidebar slots', () => {
@@ -576,25 +566,20 @@ describe('useControlSchema', () => {
 
     expect(toolkit.initialValues.saveResults).toBe(true)
     expect(toolkit.formSchema.sections[0].id).toBe('parameters')
-    expect(toolkit.form.schema).toBe(toolkit.formSchema)
+    expect(toolkit.form.spec).toEqual({ controls: toolkit.controls, controlOptions: {} })
     expect(toolkit.settingsSchema.groups[0].id).toBe('parameters')
-    expect(toolkit.settings.schema).toBe(toolkit.settingsSchema)
-    expect(toolkit.topBarSettingsConfig.controls).toBe(toolkit.controls)
-    expect(toolkit.topBarSettingsConfig.controlOptions).toEqual({})
-    expect(toolkit.topBarSettingsConfig.schema).toBeUndefined()
+    expect(toolkit.settings.spec).toBe(toolkit.settingsSchema)
+    expect(toolkit.topBarSettingsConfig.spec).toEqual({ controls: toolkit.controls, controlOptions: {} })
     expect(toolkit.topBarSettings).toEqual({
-      showSettings: true,
-      settingsConfig: toolkit.topBarSettingsConfig,
+      spec: { settings: toolkit.topBarSettingsConfig },
     })
     expect(toolkit.sidebarPanels.analysis).toHaveLength(2)
     expect(toolkit.viewIds).toEqual(['analysis'])
     expect(toolkit.viewItems).toEqual([{ id: 'analysis', label: 'Analysis' }])
     expect(toolkit.defaultView).toBe('analysis')
-    expect(toolkit.sidebar.panels).toBe(toolkit.sidebarPanels)
-    expect(toolkit.sidebar.forms).toBe(toolkit.sectionSchemas)
-    expect(toolkit.sidebar.viewIds).toBe(toolkit.viewIds)
-    expect(toolkit.sidebar.viewItems).toBe(toolkit.viewItems)
-    expect(toolkit.sidebar.defaultView).toBe('analysis')
+    expect(toolkit.sidebar.spec.panels).toBe(toolkit.sidebarPanels)
+    expect(toolkit.sidebar.spec.forms).toBe(toolkit.sectionSchemas)
+    expect(toolkit.sidebar.activeView).toBe('analysis')
     expect(toolkit.fields.map(field => field.name)).toEqual([
       'threshold',
       'method',
@@ -621,19 +606,16 @@ describe('useControlSchema', () => {
       mode: 'fast',
     })
     expect(workspace.form.modelValue).toBe(workspace.values)
-    expect(workspace.sidebar.modelValue).toBe(workspace.values)
     expect(workspace.sidebar.values).toBe(workspace.values)
     expect(workspace.sidebar.activeView).toBe('default')
-    expect(workspace.topBar.value.pillNav).toEqual([{ id: 'default', label: 'Default' }])
-    expect(workspace.topBar.value.currentPillId).toBe('default')
+    expect(workspace.topBar.value.spec.pills).toEqual([{ id: 'default', label: 'Default' }])
+    expect(workspace.topBar.value.pill).toBe('default')
     expect(workspace.pillNav.items).toEqual([{ id: 'default', label: 'Default' }])
     expect(workspace.pillNav.currentItemId).toBe('default')
-    expect(workspace.topBarSettings.settingsConfig.values).toBe(workspace.values)
-    expect(workspace.topBarSettings.settingsConfig.title).toBe('Controls')
-    expect(workspace.topBarSettings.settingsConfig.showAppearance).toBe(false)
-    expect(workspace.topBarSettings.settingsConfig.controls).toBe(workspace.controls)
-    expect(workspace.topBarSettings.settingsConfig.controlOptions).toEqual({})
-    expect(workspace.topBarSettings.settingsConfig.schema).toBeUndefined()
+    expect(workspace.topBarSettings.spec.settings.values).toBe(workspace.values)
+    expect(workspace.topBarSettings.spec.settings.title).toBe('Controls')
+    expect(workspace.topBarSettings.spec.settings.showAppearance).toBe(false)
+    expect(workspace.topBarSettings.spec.settings.spec).toEqual({ controls: workspace.controls, controlOptions: {} })
     expect(workspace.bindings.form).toBe(workspace.form)
     expect(workspace.bindings.sidebar).toBe(workspace.sidebar)
     expect(workspace.bindings.topBar).toBe(workspace.topBar)
@@ -644,10 +626,8 @@ describe('useControlSchema', () => {
     expect(workspace.bindings.componentProps).toBe(workspace.componentProps)
     expect(workspace.bindings.componentPropsById).toBe(workspace.componentPropsById)
     expect(workspace.bindings.topBar.value).toMatchObject({
-      pillNav: workspace.pillNav.items,
-      currentPillId: 'default',
-      showSettings: true,
-      settingsConfig: workspace.topBarSettingsConfig,
+      spec: { pills: workspace.pillNav.items, settings: workspace.topBarSettingsConfig },
+      pill: 'default',
     })
 
     workspace.form['onUpdate:modelValue']({ threshold: 0.5, model: 'logistic' })
@@ -657,10 +637,6 @@ describe('useControlSchema', () => {
     workspace.sidebar['onUpdate:values']({ enabled: false })
     expect(workspace.values.enabled).toBe(false)
 
-    workspace.sidebar['onUpdate:modelValue']({ enabled: true, title: 'Updated screen' })
-    expect(workspace.values.enabled).toBe(true)
-    expect(workspace.values.title).toBe('Updated screen')
-
     workspace.topBarSettings.onSettingsValuesChange({ mode: 'careful' })
     expect(workspace.values.mode).toBe('careful')
 
@@ -746,7 +722,7 @@ describe('useControlSchema', () => {
     const componentPropsById = workspace.getComponentPropsById(model.componentPropsById)
 
     expect(componentPropsById.plate.modelValue).toEqual(['A1', 'A2'])
-    expect(componentPropsById.plate.format).toBe(96)
+    expect((componentPropsById.plate.spec as WellPlateSpec).format).toBe(96)
     expect(componentPropsById.plate.wells).toBeUndefined()
     expect(componentPropsById.plate.disabled).toBe(false)
     expect(componentPropsById.plate.readonly).toBeUndefined()
@@ -813,10 +789,10 @@ describe('useControlSchema', () => {
     expect(workspace.values.plateFormat).toBe(384)
     expect(workspace.values.doseMode).toBe('serial')
     expect(workspace.values.disabled).toBe(true)
-    expect(workspace.sidebar.panels.design.map(panel => panel.id)).toEqual(['design-dose'])
+    expect(workspace.sidebar.spec.panels.design.map(panel => panel.id)).toEqual(['design-dose'])
     expect(workspace.componentProps.value).toEqual({})
     expect(workspace.componentPropsById.value.plate.modelValue).toEqual(['E1'])
-    expect(workspace.componentPropsById.value.plate.format).toBe(384)
+    expect((workspace.componentPropsById.value.plate.spec as WellPlateSpec).format).toBe(384)
     expect(workspace.componentPropsById.value.plate.disabled).toBe(true)
     expect(workspace.componentPropsById.value.dose.mode).toBe('serial')
     expect(workspace.componentPropsById.value.dose.targetWells).toEqual(['E1'])
@@ -850,15 +826,13 @@ describe('useControlSchema', () => {
       format: 'format',
       wells: () => undefined,
       disabled: 'locked',
-      showSampleTypeIndicator: () => true,
     }))
 
     expect(plateProps.modelValue).toEqual(['B1'])
-    expect(plateProps.format).toBe(384)
+    expect((plateProps.spec as WellPlateSpec).format).toBe(384)
     expect(plateProps.wells).toBeUndefined()
     expect(plateProps.disabled).toBe(true)
     expect(plateProps.readonly).toBeUndefined()
-    expect(plateProps.showSampleTypeIndicator).toBe(true)
     const updatePlateSelection = plateProps['onUpdate:modelValue']
     expect(typeof updatePlateSelection).toBe('function')
     if (typeof updatePlateSelection !== 'function') throw new Error('Expected WellPlate update handler')
@@ -892,7 +866,7 @@ describe('useControlSchema', () => {
       ['dose', 'DoseCalculator'],
     ])
     expect(bindings[0].props.modelValue).toEqual(['B1'])
-    expect(bindings[0].props.format).toBe(384)
+    expect((bindings[0].props.spec as WellPlateSpec).format).toBe(384)
     expect(bindings[1].props.mode).toBe('serial')
     expect(bindings[1].props.targetWells).toEqual(['B1'])
   })
@@ -916,10 +890,10 @@ describe('useControlSchema', () => {
     expect(workspace.values.doseMode).toBe('serial')
     expect(workspace.values.disabled).toBe(false)
     expect(workspace.values.molecularWeight).toBe(300.44)
-    expect(workspace.sidebar.panels.design.map(panel => panel.id)).toEqual(['design-dose'])
+    expect(workspace.sidebar.spec.panels.design.map(panel => panel.id)).toEqual(['design-dose'])
     const componentPropsById = workspace.getComponentPropsById(model.componentPropsById)
     expect(componentPropsById.plate.modelValue).toEqual(['C1', 'C2'])
-    expect(componentPropsById.plate.format).toBe(384)
+    expect((componentPropsById.plate.spec as WellPlateSpec).format).toBe(384)
     expect(componentPropsById.plate.wells).toBeUndefined()
     expect(componentPropsById.plate.disabled).toBe(false)
     expect(componentPropsById.plate.readonly).toBeUndefined()
@@ -959,7 +933,7 @@ describe('useControlSchema', () => {
     expect(model.controlOptions.sections?.['setup-plate']).toMatchObject({ label: 'Plate setup' })
     const componentPropsById = workspace.getComponentPropsById(model.componentPropsById)
     expect(componentPropsById.wellPlate.modelValue).toEqual(['A1', 'A2'])
-    expect(componentPropsById.wellPlate.showLegend).toBe(true)
+    expect((componentPropsById.wellPlate.spec as WellPlateSpec).showLegend).toBe(true)
     expect(componentPropsById.doseCalculator.mode).toBe('serial')
     expect(componentPropsById.doseCalculator.targetWells).toEqual(['A1', 'A2'])
     expect(workspace.getComponentBindings(model.componentBindings).map(binding => [binding.id, binding.component])).toEqual([
@@ -989,43 +963,43 @@ describe('useControlSchema', () => {
 
     expect(workspace.activeView.value).toBe('analysis')
     expect(workspace.sidebar.activeView).toBe('analysis')
-    expect(workspace.topBar.value.currentPillId).toBe('analysis')
+    expect(workspace.topBar.value.pill).toBe('analysis')
     expect(workspace.pillNav.currentItemId).toBe('analysis')
-    expect(workspace.bindings.topBar.value.currentPillId).toBe('analysis')
-    expect(workspace.topBar.value.pillNav.map(item => item.label)).toEqual(['Run', 'Results'])
+    expect(workspace.bindings.topBar.value.pill).toBe('analysis')
+    expect(workspace.topBar.value.spec.pills.map(item => item.label)).toEqual(['Run', 'Results'])
     expect(workspace.pillNav.items.map(item => item.label)).toEqual(['Run', 'Results'])
 
     workspace.topBar.value.onPillSelect({ id: 'results', label: 'Results' })
     expect(workspace.activeView.value).toBe('results')
     expect(workspace.sidebar.activeView).toBe('results')
-    expect(workspace.topBar.value.currentPillId).toBe('results')
+    expect(workspace.topBar.value.pill).toBe('results')
     expect(workspace.pillNav.currentItemId).toBe('results')
-    expect(workspace.bindings.topBar.value.currentPillId).toBe('results')
+    expect(workspace.bindings.topBar.value.pill).toBe('results')
 
     workspace.setActiveView('analysis')
     expect(workspace.activeView.value).toBe('analysis')
     expect(workspace.sidebar.activeView).toBe('analysis')
-    expect(workspace.topBar.value.currentPillId).toBe('analysis')
+    expect(workspace.topBar.value.pill).toBe('analysis')
     expect(workspace.pillNav.currentItemId).toBe('analysis')
     workspace.bindings.topBar.value.onPillSelect({ id: 'results', label: 'Results' })
     expect(workspace.activeView.value).toBe('results')
-    expect(workspace.bindings.topBar.value.currentPillId).toBe('results')
+    expect(workspace.bindings.topBar.value.pill).toBe('results')
 
     workspace.pillNav.onSelect({ id: 'analysis', label: 'Run' })
     expect(workspace.activeView.value).toBe('analysis')
-    expect(workspace.bindings.topBar.value.currentPillId).toBe('analysis')
+    expect(workspace.bindings.topBar.value.pill).toBe('analysis')
 
     workspace.pillNav.onSelect({ id: 'results', label: 'Results' })
     expect(workspace.activeView.value).toBe('results')
     expect(workspace.sidebar.activeView).toBe('results')
-    expect(workspace.topBar.value.currentPillId).toBe('results')
+    expect(workspace.topBar.value.pill).toBe('results')
     expect(workspace.pillNav.currentItemId).toBe('results')
 
     workspace.activeView.value = 'analysis'
     await nextTick()
 
     expect(workspace.sidebar.activeView).toBe('analysis')
-    expect(workspace.topBar.value.currentPillId).toBe('analysis')
+    expect(workspace.topBar.value.pill).toBe('analysis')
     expect(workspace.pillNav.currentItemId).toBe('analysis')
 
     workspace.pillNav.currentItemId = 'results'
@@ -1033,38 +1007,6 @@ describe('useControlSchema', () => {
 
     expect(workspace.activeView.value).toBe('results')
     expect(workspace.sidebar.activeView).toBe('results')
-    expect(workspace.topBar.value.currentPillId).toBe('results')
-  })
-
-  it('builds controls and component bindings for biology templates', () => {
-    const controlsToolkit = useBioTemplateControls('wellplate-screen')
-    const collection = createWellPlateScreenCollection({
-      samples: ['Control', 'Treatment'],
-      compounds: { 'Drug A': [10, 1] },
-    })
-    const componentsToolkit = useBioTemplateComponents(collection)
-
-    expect(controlsToolkit.initialValues.plateFormat).toBe(96)
-    expect(controlsToolkit.sidebarPanels.design.map(panel => panel.id)).toContain('dose')
-    expect(componentsToolkit.bindings.map(binding => binding.component)).toContain('WellPlate')
-    expect(componentsToolkit.imports[0].statement).toContain('DoseCalculator')
-    expect(componentsToolkit.componentBindingsById['dose-response:DoseCalculator'].component).toBe('DoseCalculator')
-    expect(componentsToolkit.componentBindingsById['dose-response:DoseCalculator'].props.mode).toBe('serial')
-    expect(componentsToolkit.componentProps.map(binding => binding.component)).toContain('DoseCalculator')
-    expect(componentsToolkit.componentPropsById['dose-response:DoseCalculator'].mode).toBe('serial')
-    expect(componentsToolkit.componentPropsByComponent.WellPlate).toHaveLength(2)
-    expect(componentsToolkit.getComponentProps('DoseCalculator')?.mode).toBe('serial')
-    expect(componentsToolkit.snippets.map(snippet => snippet.component)).toContain('DoseCalculator')
-    expect(componentsToolkit.usage?.template).toContain('<DoseCalculator')
-
-    const presetOnlyToolkit = useBioTemplateComponents('wellplate-screen')
-    expect(presetOnlyToolkit.imports[0].statement).toContain('PlateEditor')
-    expect(presetOnlyToolkit.componentProps).toEqual([])
-    expect(presetOnlyToolkit.componentBindingsById).toEqual({})
-    expect(presetOnlyToolkit.componentPropsById).toEqual({})
-    expect(presetOnlyToolkit.componentPropsByComponent).toEqual({})
-    expect(presetOnlyToolkit.getComponentProps('WellPlate')).toBeUndefined()
-    expect(presetOnlyToolkit.snippets).toEqual([])
-    expect(presetOnlyToolkit.usage).toBeNull()
+    expect(workspace.topBar.value.pill).toBe('results')
   })
 })

package/src/__tests__/composables/useExperiment.test.ts

@@ -0,0 +1,63 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import axios from 'axios'
+import { createPinia, setActivePinia } from 'pinia'
+
+import { useExperiment } from '../../composables/useExperiment'
+import { useExperimentStore } from '../../stores/experiment'
+import type { ExperimentSummary } from '../../types'
+
+const record = { id: 7, name: 'Hexokinase knockout run' } as ExperimentSummary
+
+// Read at call time: the SDK client binds axios methods when it is built.
+let platformResponse: () => Promise<unknown> = () => Promise.reject(new Error('Unexpected platform request'))
+
+describe('useExperiment', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    vi.spyOn(axios.Axios.prototype, 'get').mockImplementation((() => platformResponse()) as never)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it.each([
+    ['idle', {}],
+    ['loading', { currentId: 7, isResolving: true }],
+    ['error', { currentId: 7, error: 'Failed to load experiment' }],
+    ['ready', { currentId: 7, current: record }],
+  ])('should report %s from the experiment store', (status, state: { currentId?: number; isResolving?: boolean; error?: string; current?: ExperimentSummary }) => {
+    useExperimentStore().$patch(store => Object.assign(store, state))
+
+    expect(useExperiment().status.value).toBe(status)
+  })
+
+  it('should read the selection that the experiment store holds', () => {
+    useExperimentStore().select(record)
+
+    const experiment = useExperiment()
+
+    expect({ id: experiment.id.value, current: experiment.current.value }).toEqual({ id: 7, current: record })
+  })
+
+  it('should keep the loaded record when a refresh fails', async () => {
+    useExperimentStore().select(record)
+    platformResponse = () => Promise.reject(new Error('offline'))
+    const experiment = useExperiment()
+
+    await experiment.refresh()
+
+    expect(experiment.current.value).toEqual(record)
+  })
+
+  it('should replace the record when a refresh succeeds', async () => {
+    useExperimentStore().select(record)
+    const renamed = { ...record, name: 'Renamed run' }
+    platformResponse = () => Promise.resolve({ data: renamed })
+    const experiment = useExperiment()
+
+    await experiment.refresh()
+
+    expect(experiment.current.value).toEqual(renamed)
+  })
+})

package/src/__tests__/composables/useExperimentSelector.test.ts

@@ -194,6 +194,117 @@ describe('useExperimentSelector', () => {
     ])
   })
 
+  it('should send the scope filters but not status to the stats route when counting', async () => {
+    fakeResponse = { total: 3, by_status: { planned: 1, ongoing: 2, completed: 0, cancelled: 0 } } as never
+    const hook = useExperimentSelector()
+    Object.assign(hook.filters, { search: 'glu', project: 'Screen', mine: true, status: 'planned' })
+
+    await hook.fetchStatusCounts()
+
+    const url = new URL(recordedUrls[0], 'http://mint.test')
+    expect(url.pathname).toBe('/experiments/stats')
+    expect(Object.fromEntries(url.searchParams)).toEqual({ search: 'glu', project: 'Screen', mine: 'true' })
+    expect(hook.statusCounts.value).toEqual({ planned: 1, ongoing: 2, completed: 0, cancelled: 0 })
+  })
+
+  it('should send mine=true on the list request when the mine filter is set', async () => {
+    const hook = useExperimentSelector()
+    hook.filters.mine = true
+
+    await hook.fetch()
+
+    expect(recordedUrls[0]).toContain('mine=true')
+  })
+
+  it('should sum the per-type stats when several experiment types are allowed', async () => {
+    vi.spyOn(useApi().client, 'get').mockImplementation(async (url: string) => {
+      recordedUrls.push(url)
+      const type = new URL(url, 'http://mint.test').searchParams.get('experiment_type')
+      return { data: { total: 2, by_status: { planned: type === 'drug-response' ? 2 : 0, ongoing: type === 'metabolomics' ? 2 : 0 } } }
+    })
+    const hook = useExperimentSelector({ allowedExperimentTypes: ['drug-response', 'metabolomics'] })
+
+    await hook.fetchStatusCounts()
+
+    expect(recordedUrls).toHaveLength(2)
+    expect(hook.statusCounts.value).toEqual({ planned: 2, ongoing: 2 })
+  })
+
+  it('should not query the stats route when the selected type is not allowed', async () => {
+    const hook = useExperimentSelector({ experimentType: 'proteomics', allowedExperimentTypes: ['drug-response'] })
+
+    await hook.fetchStatusCounts()
+
+    expect(recordedUrls).toEqual([])
+    expect(hook.statusCounts.value).toEqual({})
+  })
+
+  it('should refetch status counts with the list when a filter or the search changes and counts are on', async () => {
+    vi.useFakeTimers()
+    const hook = useExperimentSelector({ withStatusCounts: true })
+    const statsUrls = () => recordedUrls.filter(url => url.includes('/experiments/stats'))
+
+    hook.filters.project = 'Screen'
+    await nextTick()
+
+    expect(statsUrls()).toHaveLength(1)
+    expect(recordedUrls.filter(url => url.includes('/experiments?'))).toHaveLength(1)
+
+    hook.filters.search = 'glu'
+    await vi.advanceTimersByTimeAsync(300)
+
+    expect(statsUrls()).toHaveLength(2)
+    expect(statsUrls()[1]).toContain('search=glu')
+  })
+
+  it.each([
+    ['status', (hook: ReturnType<typeof useExperimentSelector>) => { hook.filters.status = 'planned' }, 1],
+    ['sort', (hook: ReturnType<typeof useExperimentSelector>) => { hook.sortKey.value = 'name:asc' }, 1],
+    ['project', (hook: ReturnType<typeof useExperimentSelector>) => { hook.filters.project = 'Screen' }, 2],
+  ] as const)('should refetch status counts on a %s change only when it changes the counts', async (_name, change, statsCalls) => {
+    // One body that serves both routes, so the first stats request succeeds.
+    fakeResponse = { ...fakeResponse, by_status: { planned: 1 } } as never
+    const hook = useExperimentSelector({ withStatusCounts: true })
+    await hook.fetchStatusCounts()
+
+    change(hook)
+    await nextTick()
+
+    expect(recordedUrls.filter(url => url.includes('/experiments/stats'))).toHaveLength(statsCalls)
+  })
+
+  it('should refetch status counts on a status change when the previous stats request failed', async () => {
+    const stats = vi.fn()
+      .mockRejectedValueOnce(new Error('offline'))
+      .mockResolvedValue({ data: { total: 1, by_status: { planned: 1 } } })
+    vi.spyOn(useApi().client, 'get').mockImplementation(async (url: string) =>
+      url.includes('/experiments/stats') ? stats() : { data: fakeResponse })
+    const hook = useExperimentSelector({ withStatusCounts: true })
+    await hook.fetchStatusCounts()
+    expect(hook.statusCounts.value).toEqual({})
+
+    hook.filters.status = 'planned'
+    await nextTick()
+
+    expect(stats).toHaveBeenCalledTimes(2)
+    await vi.waitFor(() => expect(hook.statusCounts.value).toEqual({ planned: 1 }))
+  })
+
+  it('should refetch status counts when a status change flushes a pending search', async () => {
+    vi.useFakeTimers()
+    const hook = useExperimentSelector({ withStatusCounts: true })
+    await hook.fetchStatusCounts()
+    const statsUrls = () => recordedUrls.filter(url => url.includes('/experiments/stats'))
+
+    hook.filters.search = 'glu'
+    await nextTick()
+    hook.filters.status = 'planned'
+    await nextTick()
+
+    expect(statsUrls()).toHaveLength(2)
+    expect(statsUrls()[1]).toContain('search=glu')
+  })
+
   it('loadMore appends the next page', async () => {
     const hook = useExperimentSelector({ limit: 1 })
 

package/src/__tests__/composables/useFileBrowser.test.ts

@@ -7,6 +7,7 @@ vi.mock('../../composables/useApi', () => ({
 
 import { effectScope, nextTick, ref } from 'vue'
 
+import { mintApiErrorFromResponse } from '../../apiErrors'
 import { useFileBrowser } from '../../composables/useFileBrowser'
 
 const MOUNTS = {
@@ -175,7 +176,7 @@ describe('useFileBrowser review fixes', () => {
 
   // No configured mounts means the routes are absent, not that browsing failed.
   it('should treat a 404 mount list as no mounts configured', async () => {
-    mockGet.mockRejectedValue({ response: { status: 404 } })
+    mockGet.mockRejectedValue(mintApiErrorFromResponse(404, null))
     const browser = useFileBrowser()
     await browser.init()
 
@@ -183,7 +184,7 @@ describe('useFileBrowser review fixes', () => {
   })
 
   it('should leave the mount list empty when none are configured', async () => {
-    mockGet.mockRejectedValue({ response: { status: 404 } })
+    mockGet.mockRejectedValue(mintApiErrorFromResponse(404, null))
     const browser = useFileBrowser()
     await browser.init()
 
@@ -191,10 +192,7 @@ describe('useFileBrowser review fixes', () => {
   })
 
   it('should surface the API error detail rather than the status code', async () => {
-    mockGet.mockRejectedValue({
-      response: { status: 404, data: { detail: "Mount 'nas' is not available" } },
-      message: 'Request failed with status code 404',
-    })
+    mockGet.mockRejectedValue(mintApiErrorFromResponse(404, { detail: "Mount 'nas' is not available" }))
     const browser = useFileBrowser()
     await browser.navigate({ mount_id: 'nas', path: '' })