@morscherlab/mint-sdk 1.3.9 → 1.4.0-beta.1

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/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: '' })
 

package/src/__tests__/composables/{useJobsStatusTray.test.ts → useJobCenter.test.ts}

@@ -4,9 +4,9 @@ import { describe, expect, it, vi } from 'vitest'
 
 import {
   combinePluginJobSources,
-  usePluginJobCenter,
-  type UsePluginJobCenterOptions,
-} from '../../composables/useJobsStatusTray'
+  useJobCenter,
+  type UseJobCenterOptions,
+} from '../../composables/useJobCenter'
 import type { JobStateInput, JobStatus } from '../../types/jobs'
 
 function job(status: JobStatus, id: string = status): JobStateInput {
@@ -43,18 +43,18 @@ function job(status: JobStatus, id: string = status): JobStateInput {
   }
 }
 
-function mountComposable(options: UsePluginJobCenterOptions) {
-  let tray!: ReturnType<typeof usePluginJobCenter>
+function mountComposable(options: UseJobCenterOptions) {
+  let tray!: ReturnType<typeof useJobCenter>
   const wrapper = mount(defineComponent({
     setup() {
-      tray = usePluginJobCenter(options)
+      tray = useJobCenter(options)
       return () => null
     },
   }))
   return { tray, wrapper }
 }
 
-describe('usePluginJobCenter', () => {
+describe('useJobCenter', () => {
   it('combines live source jobs and fans out or routes source actions', async () => {
     const firstJobs = shallowRef([job('running', 'first')])
     const secondJobs = shallowRef([job('completed', 'second')])
@@ -68,15 +68,15 @@ describe('usePluginJobCenter', () => {
     const combined = combinePluginJobSources([
       {
         jobs: firstJobs,
-        refreshJobs: firstRefresh,
-        clearFinishedJobs: firstClear,
+        refresh: firstRefresh,
+        clear: firstClear,
         dispose: firstDispose,
       },
       {
         jobs: secondJobs,
-        refreshJobs: secondRefresh,
-        cancelJob: secondCancel,
-        clearFinishedJobs: secondClear,
+        refresh: secondRefresh,
+        cancel: secondCancel,
+        clear: secondClear,
         dispose: secondDispose,
       },
     ])
@@ -86,9 +86,9 @@ describe('usePluginJobCenter', () => {
     await nextTick()
     expect(combined.jobs.value.map(item => item.job_id)).toEqual(['first', 'replacement'])
 
-    await combined.refreshJobs?.()
-    await combined.cancelJob?.('replacement')
-    await expect(combined.clearFinishedJobs?.()).resolves.toBe(3)
+    await combined.refresh?.()
+    await combined.cancel?.('replacement')
+    await expect(combined.clear?.()).resolves.toBe(3)
     combined.dispose?.()
 
     expect({
@@ -142,39 +142,39 @@ describe('usePluginJobCenter', () => {
     const firstCancel = vi.fn(async () => undefined)
     const secondCancel = vi.fn(async () => undefined)
     const combined = combinePluginJobSources([
-      { jobs: [job('running', 'duplicate')], cancelJob: firstCancel },
-      { jobs: [job('queued', 'duplicate')], cancelJob: secondCancel },
+      { jobs: [job('running', 'duplicate')], cancel: firstCancel },
+      { jobs: [job('queued', 'duplicate')], cancel: secondCancel },
     ])
 
     expect(() => combined.jobs.value).toThrow('Duplicate plugin job id')
-    await expect(combined.cancelJob?.('duplicate')).rejects.toThrow('Duplicate plugin job id')
+    await expect(combined.cancel?.('duplicate')).rejects.toThrow('Duplicate plugin job id')
     expect([firstCancel.mock.calls.length, secondCancel.mock.calls.length]).toEqual([0, 0])
   })
 
   it('does not expose a partial bulk clear across combined sources', () => {
     const combined = combinePluginJobSources([
-      { jobs: [job('completed', 'first')], clearFinishedJobs: async () => 1 },
+      { jobs: [job('completed', 'first')], clear: async () => 1 },
       { jobs: [job('completed', 'second')] },
     ])
 
-    expect(combined.clearFinishedJobs).toBeUndefined()
+    expect(combined.clear).toBeUndefined()
   })
 
   it('does not partially delete finished jobs when one combined source cannot delete', async () => {
     const firstDelete = vi.fn(async () => true)
     const combined = combinePluginJobSources([
-      { jobs: [job('completed', 'first')], deleteJob: firstDelete },
+      { jobs: [job('completed', 'first')], delete: firstDelete },
       { jobs: [job('completed', 'second')] },
     ])
-    let center!: ReturnType<typeof usePluginJobCenter>
+    let center!: ReturnType<typeof useJobCenter>
     const wrapper = mount(defineComponent({
       setup() {
-        center = usePluginJobCenter({ source: combined, loadOnMount: false })
+        center = useJobCenter({ source: combined, loadOnMount: false })
         return () => null
       },
     }))
 
-    expect(combined.deleteJob).toBeUndefined()
+    expect(combined.delete).toBeUndefined()
     expect(center.canClearFinished.value).toBe(false)
     await expect(center.clearFinished()).resolves.toBe(false)
     expect(firstDelete).not.toHaveBeenCalled()
@@ -184,10 +184,10 @@ describe('usePluginJobCenter', () => {
 
   it('derives jobs directly from a canonical source ref', async () => {
     const sourceJobs = shallowRef([job('queued', 'first')])
-    let center!: ReturnType<typeof usePluginJobCenter>
+    let center!: ReturnType<typeof useJobCenter>
     const wrapper = mount(defineComponent({
       setup() {
-        center = usePluginJobCenter({
+        center = useJobCenter({
           source: { jobs: sourceJobs },
           loadOnMount: false,
         })
@@ -208,11 +208,11 @@ describe('usePluginJobCenter', () => {
       sourceJobs.value = [job('cancelled', jobId)]
       return sourceJobs.value[0]
     })
-    let center!: ReturnType<typeof usePluginJobCenter>
+    let center!: ReturnType<typeof useJobCenter>
     const wrapper = mount(defineComponent({
       setup() {
-        center = usePluginJobCenter({
-          source: { jobs: sourceJobs, cancelJob },
+        center = useJobCenter({
+          source: { jobs: sourceJobs, cancel: cancelJob },
           loadOnMount: false,
         })
         return () => null
@@ -242,7 +242,7 @@ describe('usePluginJobCenter', () => {
     const { tray } = mountComposable({
       source: {
         jobs: [{ ...job('running'), can_cancel: false }],
-        cancelJob,
+        cancel: cancelJob,
       },
       loadOnMount: false,
     })
@@ -259,7 +259,7 @@ describe('usePluginJobCenter', () => {
       return sourceJobs.value
     })
     const { tray } = mountComposable({
-      source: { jobs: sourceJobs, refreshJobs },
+      source: { jobs: sourceJobs, refresh: refreshJobs },
       loadOnMount: false,
     })