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

package/src/__tests__/composables/{useEventStream.test.ts → eventStream.test.ts}

@@ -1,7 +1,7 @@
 import { effectScope } from 'vue'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
-import { useEventStream } from '../../composables/useEventStream'
+import { createEventStream } from '../../composables/eventStream'
 
 function pendingStreamResponse(): {
   response: Response
@@ -22,7 +22,7 @@ function pendingStreamResponse(): {
   return { response: new Response(body), close }
 }
 
-describe('useEventStream', () => {
+describe('createEventStream', () => {
   afterEach(() => {
     vi.useRealTimers()
   })
@@ -41,7 +41,7 @@ describe('useEventStream', () => {
     })
     const onMessage = vi.fn()
     const scope = effectScope()
-    const stream = scope.run(() => useEventStream('/events', {
+    const stream = scope.run(() => createEventStream('/events', {
       transport: vi.fn(async () => new Response(body)),
       reconnect: false,
       onMessage,
@@ -71,7 +71,7 @@ describe('useEventStream', () => {
       reconnectDelayMs: 1_000,
     }
     const scope = effectScope()
-    const stream = scope.run(() => useEventStream('/events', options))!
+    const stream = scope.run(() => createEventStream('/events', options))!
 
     await vi.waitFor(() => expect(stream.lastEventId.value).toBe('event-1'))
     await vi.advanceTimersByTimeAsync(7)
@@ -99,7 +99,7 @@ describe('useEventStream', () => {
       .mockResolvedValueOnce(second.response)
     const onMessage = vi.fn()
     const scope = effectScope()
-    const stream = scope.run(() => useEventStream('/events', {
+    const stream = scope.run(() => createEventStream('/events', {
       transport,
       reconnectDelayMs: 1_000,
       onMessage,
@@ -124,7 +124,7 @@ describe('useEventStream', () => {
       .mockResolvedValueOnce(new Response('data: first\n\n'))
       .mockResolvedValueOnce(second.response)
     const scope = effectScope()
-    const stream = scope.run(() => useEventStream('/events', {
+    const stream = scope.run(() => createEventStream('/events', {
       transport,
       reconnectDelayMs: 5,
     }))!

package/src/__tests__/composables/experiment-utils.test.ts

@@ -2,25 +2,24 @@ import { describe, expect, it } from 'vitest'
 
 import {
   experimentIdFromRoute,
-  formatExperimentStatus,
-  getExperimentStatusVariant,
   resolveExperimentCode,
 } from '../../composables/experiment-utils'
+import * as experimentStatus from '../../utils/experimentStatus'
 
 describe('experiment-utils', () => {
   it('formats canonical and custom experiment statuses', () => {
-    expect(formatExperimentStatus('planned')).toBe('Planned')
-    expect(formatExperimentStatus('ongoing')).toBe('Ongoing')
-    expect(formatExperimentStatus('ready_to_extract')).toBe('Ready to extract')
-    expect(formatExperimentStatus('qc-hold')).toBe('Qc hold')
-    expect(formatExperimentStatus(null)).toBe('')
-  })
-
-  it('maps known status variants and falls back for custom statuses', () => {
-    expect(getExperimentStatusVariant('ongoing')).toBe('primary')
-    expect(getExperimentStatusVariant('completed')).toBe('success')
-    expect(getExperimentStatusVariant('ready_to_extract')).toBe('default')
-    expect(getExperimentStatusVariant(undefined)).toBe('default')
+    expect(experimentStatus.format('planned')).toBe('Planned')
+    expect(experimentStatus.format('ongoing')).toBe('Ongoing')
+    expect(experimentStatus.format('ready_to_extract')).toBe('Ready to extract')
+    expect(experimentStatus.format('qc-hold')).toBe('Qc hold')
+    expect(experimentStatus.format(null)).toBe('')
+  })
+
+  it('maps known status tones and falls back for custom statuses', () => {
+    expect(experimentStatus.tone('ongoing')).toBe('primary')
+    expect(experimentStatus.tone('completed')).toBe('success')
+    expect(experimentStatus.tone('ready_to_extract')).toBe('neutral')
+    expect(experimentStatus.tone(undefined)).toBe('neutral')
   })
 
   it('resolves only formal experiment codes', () => {

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

@@ -5,6 +5,7 @@ import { AxiosError, type AxiosRequestConfig, type InternalAxiosRequestConfig }
 import { AuthenticationRequiredError, useApi } from '../../composables/useApi'
 import { MintApiError } from '../../apiErrors'
 import { useAuthStore } from '../../stores/auth'
+import { setSession } from '../../host'
 
 function readAuthorizationHeader(headers: InternalAxiosRequestConfig['headers']): unknown {
   const bag = headers as Record<string, unknown> & { get?: (header: string) => unknown }
@@ -32,8 +33,8 @@ function unauthorizedAdapter(config: AxiosRequestConfig): Promise<never> {
 
 describe('useApi URL helpers', () => {
   beforeEach(() => {
+    localStorage.clear()
     setActivePinia(createPinia())
-    useAuthStore().clearToken()
   })
 
   afterEach(() => {
@@ -78,8 +79,7 @@ describe('useApi URL helpers', () => {
   })
 
   it('honors withAuth=false even when the SDK auth store has a token', async () => {
-    const authStore = useAuthStore()
-    authStore.setToken('secret-token', 3600)
+    setSession('secret-token', new Date(Date.now() + 3_600_000))
     const api = useApi({ baseUrl: '/api', withAuth: false })
 
     let authorization: unknown
@@ -100,10 +100,10 @@ describe('useApi URL helpers', () => {
     expect(authorization).toBeUndefined()
   })
 
-  it.each([false, true])('normalizes authenticated 401 responses and clears the rejected token (typedErrors=%s)', async (typedErrors) => {
+  it('normalizes authenticated 401 responses and clears the rejected token', async () => {
     const authStore = useAuthStore()
-    authStore.setToken('expired-token', 3600)
-    const api = useApi({ baseUrl: '/api', typedErrors })
+    setSession('expired-token', new Date(Date.now() + 3_600_000))
+    const api = useApi({ baseUrl: '/api' })
 
     const adapter = vi.fn(unauthorizedAdapter)
     const error = await api.get('/protected', { adapter }).catch((reason: unknown) => reason)
@@ -125,10 +125,21 @@ describe('useApi URL helpers', () => {
     })
   })
 
-  it.each([false, true])('does not clear auth state for public requests that return 401 (typedErrors=%s)', async (typedErrors) => {
+  it('should keep the stored platform token when an authenticated request returns 401', async () => {
+    localStorage.setItem('mint-auth-token', 'platform-token')
+    const authStore = useAuthStore()
+    authStore.initialize()
+    const api = useApi({ baseUrl: '/api' })
+
+    await api.get('/protected', { adapter: unauthorizedAdapter }).catch(() => undefined)
+
+    expect(localStorage.getItem('mint-auth-token')).toBe('platform-token')
+  })
+
+  it('does not clear auth state for public requests that return 401', async () => {
     const authStore = useAuthStore()
-    authStore.setToken('still-valid-token', 3600)
-    const api = useApi({ baseUrl: '/api', typedErrors, withAuth: false })
+    setSession('still-valid-token', new Date(Date.now() + 3_600_000))
+    const api = useApi({ baseUrl: '/api', withAuth: false })
 
     const error = await api.get('/public', { adapter: unauthorizedAdapter }).catch((reason: unknown) => reason)
 
@@ -138,14 +149,14 @@ describe('useApi URL helpers', () => {
     })
   })
 
-  it.each([false, true])('does not clear a replacement token after an older request returns 401 (typedErrors=%s)', async (typedErrors) => {
+  it('does not clear a replacement token after an older request returns 401', async () => {
     const authStore = useAuthStore()
-    authStore.setToken('rejected-token', 3600)
-    const api = useApi({ baseUrl: '/api', typedErrors })
+    setSession('rejected-token', new Date(Date.now() + 3_600_000))
+    const api = useApi({ baseUrl: '/api' })
 
     await api.get('/protected', {
       adapter: async (config) => {
-        authStore.setToken('replacement-token', 3600)
+        setSession('replacement-token', new Date(Date.now() + 3_600_000))
         return unauthorizedAdapter(config)
       },
     }).catch(() => undefined)
@@ -153,14 +164,14 @@ describe('useApi URL helpers', () => {
     expect(authStore.token).toBe('replacement-token')
   })
 
-  it.each([false, true])('does not clear a token created while an unauthenticated request is in flight (typedErrors=%s)', async (typedErrors) => {
+  it('does not clear a token created while an unauthenticated request is in flight', async () => {
     const authStore = useAuthStore()
-    const api = useApi({ baseUrl: '/api', typedErrors })
+    const api = useApi({ baseUrl: '/api' })
     expect(authStore.token).toBeNull()
 
     await api.get('/protected', {
       adapter: async (config) => {
-        authStore.setToken('new-login-token', 3600)
+        setSession('new-login-token', new Date(Date.now() + 3_600_000))
         return unauthorizedAdapter(config)
       },
     }).catch(() => undefined)
@@ -168,8 +179,8 @@ describe('useApi URL helpers', () => {
     expect(authStore.token).toBe('new-login-token')
   })
 
-  it('normalizes a typed response when typed errors are enabled', async () => {
-    const api = useApi({ baseUrl: '/api', typedErrors: true })
+  it('normalizes a failed response into a MintApiError without an option', async () => {
+    const api = useApi({ baseUrl: '/api' })
     const adapter = vi.fn(async (config: AxiosRequestConfig) => Promise.reject(new AxiosError(
       'Not Found',
       AxiosError.ERR_BAD_REQUEST,
@@ -202,7 +213,7 @@ describe('useApi URL helpers', () => {
   })
 
   it.each([true, false])('normalizes Blob download errors (JSON=%s)', async (json) => {
-    const api = useApi({ typedErrors: true })
+    const api = useApi()
     const body = { code: 'artifact.unavailable', message: 'No artifact', details: { id: 67 } }
     const blob = new Blob([json ? JSON.stringify(body) : 'Bad gateway'], {
       type: json ? 'application/json' : 'text/plain',
@@ -228,8 +239,8 @@ describe('useApi URL helpers', () => {
     expect((error as MintApiError).body).toEqual(json ? body : blob)
   })
 
-  it('leaves cancellations and network failures unchanged in typed mode', async () => {
-    const api = useApi({ typedErrors: true })
+  it('leaves cancellations and network failures unchanged', async () => {
+    const api = useApi()
     const cause = new AxiosError('Offline', AxiosError.ERR_NETWORK)
     await expect(api.get('/offline', { adapter: async () => { throw cause } })).rejects.toBe(cause)
     const controller = new AbortController()

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

@@ -335,6 +335,23 @@ describe('useAppExperiment', () => {
       expect(onSelect).not.toHaveBeenCalled()
     })
 
+    it('should not call onSelect when the store refreshes the selected experiment', async () => {
+      const onSelect = vi.fn()
+      const store = useExperimentStore()
+      useAppExperiment({ onSelect })
+      store.select(makeExperiment({ id: 8 }))
+      await nextTick()
+      onSelect.mockClear()
+
+      const fetch = stubExperimentFetch()
+      const pending = store.refresh()
+      fetch.resolveWith(makeExperiment({ id: 8, name: 'Renamed run' }))
+      await pending
+      await nextTick()
+
+      expect(onSelect).not.toHaveBeenCalled()
+    })
+
     it('should not call onSelect for an experiment already selected at setup', async () => {
       const onSelect = vi.fn()
       useExperimentStore().select(makeExperiment())
@@ -473,6 +490,20 @@ describe('useAppExperiment', () => {
       expect(state.saveLoading.value).toBe(false)
     })
 
+    it('should show the refetched update time after a successful save', async () => {
+      const store = useExperimentStore()
+      useAppExperiment({ onSave: vi.fn().mockResolvedValue('Saved') })
+      const state = getState()
+      store.select(makeExperiment({ updated_at: '2025-01-01T00:00:00Z' }))
+
+      const fetch = stubExperimentFetch()
+      const saving = state.handleSave()
+      fetch.resolveWith(makeExperiment({ updated_at: '2026-10-28T09:30:00Z' }))
+      await saving
+
+      expect(state.popover.value.experimentUpdatedAt).toBe('2026-10-28T09:30:00Z')
+    })
+
     it('should not set saveSuccessMessage when onSave returns null', async () => {
       const onSave = vi.fn().mockResolvedValue(null)
       useAppExperiment({ onSave })
@@ -699,8 +730,9 @@ describe('useAppExperiment', () => {
     it('exposes live ExperimentPopover props from the provided state', async () => {
       const saveDisabled = ref(false)
       const saveDisabledMessage = ref<string | undefined>('Ready to save')
+      const dirty = ref(false)
       const onSave = vi.fn().mockResolvedValue('Saved')
-      useAppExperiment({ onSave, saveDisabled, saveDisabledMessage })
+      useAppExperiment({ onSave, saveDisabled, saveDisabledMessage, dirty })
       const state = getState()
 
       useExperimentStore().select(makeExperiment({
@@ -708,26 +740,37 @@ describe('useAppExperiment', () => {
         name: 'Dose response',
         status: 'ongoing',
         experiment_code: 'EXP-012',
+        project: 'legacy-project',
+        project_name: 'Hypoxia atlas',
+        created_by_user: { id: 3, username: 'jdoe', first_name: 'Jane', last_name: 'Doe' },
+        updated_at: '2026-10-28T10:00:00Z',
       }))
 
       expect(state.popover.value).toMatchObject({
         experimentName: 'Dose response',
         experimentCode: 'EXP-012',
         experimentStatus: 'ongoing',
+        experimentId: 12,
+        experimentProject: 'Hypoxia atlas',
+        experimentOwner: 'Jane Doe',
+        experimentUpdatedAt: '2026-10-28T10:00:00Z',
         isResolving: false,
         showSave: true,
         showDetach: true,
         saveDisabled: false,
         saveDisabledMessage: 'Ready to save',
         saveLoading: false,
+        dirty: false,
       })
       expect(state.popover.value.error).toBeUndefined()
 
       saveDisabled.value = true
       saveDisabledMessage.value = 'Locked'
+      dirty.value = true
 
       expect(state.popover.value.saveDisabled).toBe(true)
       expect(state.popover.value.saveDisabledMessage).toBe('Locked')
+      expect(state.popover.value.dirty).toBe(true)
 
       await state.handleSave()
 
@@ -777,7 +820,7 @@ describe('useAppExperiment', () => {
       const state = getState()
 
       expect(state.selectorModal.value).toEqual({
-        modelValue: false,
+        open: false,
         currentExperimentId: null,
       })
       expect(appExperiment.selectorModal.value).toEqual(state.selectorModal.value)
@@ -786,7 +829,7 @@ describe('useAppExperiment', () => {
       state.openModal()
 
       expect(state.selectorModal.value).toEqual({
-        modelValue: true,
+        open: true,
         currentExperimentId: 77,
       })
       expect(appExperiment.popover.value.experimentName).toBe('Test Experiment')

package/src/__tests__/composables/{useAnalysisArtifacts.test.ts → useArtifacts.test.ts}

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
 import { ref, nextTick } from 'vue'
 
 // ---------------------------------------------------------------------------
@@ -18,7 +19,8 @@ vi.mock('../../composables/useApi', () => ({
   useApi: (options: unknown) => mockUseApi(options),
 }))
 
-import { useAnalysisArtifacts } from '../../composables/useAnalysisArtifacts'
+import { useArtifacts } from '../../composables/useArtifacts'
+import { useExperimentStore } from '../../stores/experiment'
 import type {
   AnalysisArtifactDetail,
   AnalysisArtifactSummary,
@@ -58,8 +60,8 @@ const ARTIFACTS = [
   }),
 ]
 
-function setup(options?: Parameters<typeof useAnalysisArtifacts>[0]) {
-  return useAnalysisArtifacts({ experimentId: 42, ...options })
+function setup(options?: Parameters<typeof useArtifacts>[0]) {
+  return useArtifacts({ experimentId: 42, ...options })
 }
 
 /** Let watchers fire and their triggered requests settle. */
@@ -73,8 +75,9 @@ async function flush(): Promise<void> {
 // Tests
 // ---------------------------------------------------------------------------
 
-describe('useAnalysisArtifacts', () => {
+describe('useArtifacts', () => {
   beforeEach(() => {
+    setActivePinia(createPinia())
     vi.clearAllMocks()
     mockGet.mockResolvedValue({ artifacts: ARTIFACTS })
     mockPost.mockResolvedValue(makeArtifact())
@@ -133,7 +136,7 @@ describe('useAnalysisArtifacts', () => {
     })
 
     it('should set error and skip the request when no experiment id is available', async () => {
-      const { list, error } = useAnalysisArtifacts()
+      const { list, error } = useArtifacts()
 
       const result = await list()
 
@@ -257,7 +260,7 @@ describe('useAnalysisArtifacts', () => {
   describe('experiment id resolution', () => {
     it('should accept a ref experiment id', async () => {
       const experimentId = ref<number | undefined>(7)
-      const { list } = useAnalysisArtifacts({ experimentId })
+      const { list } = useArtifacts({ experimentId })
 
       await list()
 
@@ -265,32 +268,21 @@ describe('useAnalysisArtifacts', () => {
     })
 
     it('should accept a getter experiment id', async () => {
-      const { list } = useAnalysisArtifacts({ experimentId: () => 9 })
+      const { list } = useArtifacts({ experimentId: () => 9 })
 
       await list()
 
       expect(mockGet).toHaveBeenCalledWith('/experiments/9/analysis-artifacts?include_archived=false')
     })
 
-    it('should fall back to the injected platform context', async () => {
-      ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-        currentExperimentId: 33,
-      }
-      const { list } = useAnalysisArtifacts()
+    it('should fall back to the current experiment', async () => {
+      useExperimentStore().$patch({ currentId: 33 })
+      const { list } = useArtifacts()
 
       await list()
 
       expect(mockGet).toHaveBeenCalledWith('/experiments/33/analysis-artifacts?include_archived=false')
     })
-
-    it('should fall back to the URL experiment id', async () => {
-      window.history.replaceState({}, '', '/?experimentId=55')
-      const { list } = useAnalysisArtifacts()
-
-      await list()
-
-      expect(mockGet).toHaveBeenCalledWith('/experiments/55/analysis-artifacts?include_archived=false')
-    })
   })
 
   // -------------------------------------------------------------------------
@@ -542,7 +534,7 @@ describe('useAnalysisArtifacts', () => {
 
     it('should fetch once a late-resolving experiment id becomes available', async () => {
       const experimentId = ref<number | undefined>(undefined)
-      useAnalysisArtifacts({ experimentId, immediate: true })
+      useArtifacts({ experimentId, immediate: true })
 
       await flush()
       expect(mockGet).not.toHaveBeenCalled()
@@ -561,7 +553,7 @@ describe('useAnalysisArtifacts', () => {
   describe('reactive options', () => {
     it('should refetch when the experiment id changes after a load', async () => {
       const experimentId = ref<number | undefined>(42)
-      const { list } = useAnalysisArtifacts({ experimentId })
+      const { list } = useArtifacts({ experimentId })
       await list()
 
       experimentId.value = 43
@@ -572,7 +564,7 @@ describe('useAnalysisArtifacts', () => {
 
     it('should re-scope artifacts when a reactive pluginId changes without refetching', async () => {
       const pluginId = ref<string | null>('plugin-a')
-      const { list, artifacts } = useAnalysisArtifacts({ experimentId: 42, pluginId })
+      const { list, artifacts } = useArtifacts({ experimentId: 42, pluginId })
       await list()
       expect(artifacts.value.map((a) => a.id)).toEqual([1, 3])
 
@@ -585,7 +577,7 @@ describe('useAnalysisArtifacts', () => {
 
     it('should refetch with include_archived=true when a reactive includeArchived flips on', async () => {
       const includeArchived = ref(false)
-      const { list } = useAnalysisArtifacts({ experimentId: 42, includeArchived })
+      const { list } = useArtifacts({ experimentId: 42, includeArchived })
       await list()
 
       includeArchived.value = true
@@ -632,7 +624,7 @@ describe('useAnalysisArtifacts', () => {
 
     it('should clear artifacts and selection when the experiment id goes away', async () => {
       const experimentId = ref<number | undefined>(42)
-      const { list, getDetail, artifacts, selectedDetail } = useAnalysisArtifacts({ experimentId })
+      const { list, getDetail, artifacts, selectedDetail } = useArtifacts({ experimentId })
       await list()
       mockGet.mockResolvedValueOnce({ ...makeArtifact(), result: {}, tree: [], summary: null })
       await getDetail(1)
@@ -651,7 +643,7 @@ describe('useAnalysisArtifacts', () => {
       let resolveGet!: (v: unknown) => void
       mockGet.mockImplementationOnce(() => new Promise((r) => { resolveGet = r }))
 
-      const { list, artifacts } = useAnalysisArtifacts({ experimentId })
+      const { list, artifacts } = useArtifacts({ experimentId })
       const pending = list()
 
       experimentId.value = undefined

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

@@ -1,10 +1,10 @@
-import { describe, it, expect, vi } from 'vitest'
+import { describe, it, expect } from 'vitest'
 import {
   parseCSV,
   extractSamplesFromDesignData,
   useAutoGroup,
-} from '../../composables/useAutoGroup'
-import { classKey } from '../../composables/autoGroup/classKey'
+} from '../../components/internal/useAutoGroup'
+import { classKey } from '../../components/internal/autoGroup/classKey'
 
 describe('parseCSV', () => {
   it('should parse simple CSV with headers', () => {
@@ -432,16 +432,6 @@ describe('useAutoGroup — class-first orchestration', () => {
     expect(ag.classes.value.find(c => c.kind === 'iqc')!.disposition).toBe('group')
   })
 
-  it('legacy setOutlierAction is a no-op deprecation shim', () => {
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    const ag = useAutoGroup()
-    ag.rawText.value = ['a_b_c'].join('\n')
-    ag.parseInput()
-    ag.setOutlierAction(0, 'exclude')
-    expect(warn).toHaveBeenCalled()
-    warn.mockRestore()
-  })
-
   it('preserves legacy public refs after redesign', () => {
     const ag = useAutoGroup()
     ag.rawText.value = 'a_b_c\nd_e_f'

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

@@ -2,14 +2,16 @@ import { describe, expect, it } from 'vitest'
 import { useCalendarGrid } from '../../composables/useCalendarGrid'
 
 describe('useCalendarGrid', () => {
-  it('builds a stable 42-day month grid with previous and next month padding', () => {
+  it('builds a stable Monday-first 42-day month grid with previous and next month padding', () => {
     const calendar = useCalendarGrid()
     calendar.setCurrentMonthFromDate(new Date('2026-05-07T12:00:00'))
 
-    expect(calendar.weekDays).toEqual(['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'])
+    expect(calendar.weekDays).toEqual(['Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa', 'Su'])
     expect(calendar.monthYear.value).toBe('May 2026')
     expect(calendar.calendarDays.value).toHaveLength(42)
     expect(calendar.calendarDays.value[0].date.getMonth()).toBe(3)
+    expect(calendar.calendarDays.value[0].date.getDate()).toBe(27)
+    expect(calendar.calendarDays.value[0].date.getDay()).toBe(1)
     expect(calendar.calendarDays.value.some(day => day.isCurrentMonth && day.date.getDate() === 7)).toBe(true)
   })