@morscherlab/mint-sdk 1.1.25 → 1.2.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morscherlab/mint-sdk",
-  "version": "1.1.25",
+  "version": "1.2.0-beta.2",
   "description": "MINT Platform SDK — Vue 3 components, composables, and types for plugin development. MINT = Mass-spec INtegrated Toolkit.",
   "type": "module",
   "main": "./dist/index.js",

package/src/__tests__/components/GeneratedPluginView.test.ts

@@ -65,7 +65,6 @@ vi.mock('../../composables/useGeneratedAnalysis', async () => {
       loadResult: generated.loadResult,
       resultForJob: generated.resultForJob,
       refreshJobs: vi.fn(),
-      jobsAdapter: {},
       })
     },
   }
@@ -146,8 +145,6 @@ describe('GeneratedPluginView', () => {
       result: wrapper.findComponent(GeneratedResultRenderer).text(),
       jobs: wrapper.findComponent(JobsStatusTray).exists(),
       jobSource: wrapper.findComponent(JobsStatusTray).props('source'),
-      legacyJobs: wrapper.findComponent(JobsStatusTray).props('jobs'),
-      legacyAdapter: wrapper.findComponent(JobsStatusTray).props('adapter'),
     }).toMatchObject({
       workspace: {
         title: 'Demo analysis',
@@ -159,8 +156,6 @@ describe('GeneratedPluginView', () => {
       result: 'complete',
       jobs: true,
       jobSource: expect.any(Object),
-      legacyJobs: undefined,
-      legacyAdapter: undefined,
     })
   })
 

package/src/__tests__/components/JobsStatusTray.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, it, vi } from 'vitest'
 import { h } from 'vue'
 
 import JobsStatusTray from '../../components/JobsStatusTray.vue'
+import type { PluginJobCenterSource } from '../../composables/useJobsStatusTray'
 import type { JobState, JobStateInput, JobStatus } from '../../types/jobs'
 
 function job(status: JobStatus, id: string = status): JobStateInput {
@@ -40,8 +41,7 @@ function job(status: JobStatus, id: string = status): JobStateInput {
 }
 
 async function openTray(options: {
-  jobs: JobStateInput[]
-  adapter?: Record<string, unknown>
+  source: PluginJobCenterSource
   slots?: Record<string, (props: { job: JobState }) => unknown>
 }) {
   const { slots, ...props } = options
@@ -60,7 +60,7 @@ async function openTray(options: {
 
 describe('JobsStatusTray', () => {
   it('shows awaiting input as active without default actions', async () => {
-    const wrapper = await openTray({ jobs: [job('awaiting_input')] })
+    const wrapper = await openTray({ source: { jobs: [job('awaiting_input')] } })
 
     expect([
       wrapper.text().includes('Waiting for input'),
@@ -69,15 +69,15 @@ describe('JobsStatusTray', () => {
     ]).toEqual([true, false, false])
   })
 
-  it('shows only actions supported by both capability and adapter', async () => {
+  it('shows only actions supported by both capability and source', async () => {
     const wrapper = await openTray({
-      jobs: [
-        { ...job('awaiting_input', 'input'), can_cancel: true },
-        { ...job('completed', 'done'), can_delete: true },
-      ],
-      adapter: {
-        cancelJob: vi.fn(),
-        deleteJob: vi.fn(),
+      source: {
+        jobs: [
+          { ...job('awaiting_input', 'input'), can_cancel: true },
+          { ...job('completed', 'done'), can_delete: true },
+        ],
+        cancelJob: vi.fn(async () => undefined),
+        deleteJob: vi.fn(async () => true),
       },
     })
 
@@ -91,7 +91,7 @@ describe('JobsStatusTray', () => {
   })
 
   it('exposes dialog state and closes on Escape', async () => {
-    const wrapper = await openTray({ jobs: [job('running')] })
+    const wrapper = await openTray({ source: { jobs: [job('running')] } })
     const trigger = wrapper.get('.mint-jobs-tray__trigger')
 
     await wrapper.get('[role="dialog"]').trigger('keydown', { key: 'Escape' })
@@ -104,15 +104,17 @@ describe('JobsStatusTray', () => {
 
   it('renders an individual delete action for an active capable job', async () => {
     const wrapper = await openTray({
-      jobs: [{ ...job('awaiting_input'), can_delete: true }],
-      adapter: { deleteJob: vi.fn() },
+      source: {
+        jobs: [{ ...job('awaiting_input'), can_delete: true }],
+        deleteJob: vi.fn(async () => true),
+      },
     })
 
     expect(wrapper.find('[aria-label="Delete job"]').exists()).toBe(true)
   })
 
   it('traps forward Tab navigation inside the modal dialog', async () => {
-    const wrapper = await openTray({ jobs: [job('running')] })
+    const wrapper = await openTray({ source: { jobs: [job('running')] } })
     const focusable = wrapper.findAll('button')
     const firstInsidePanel = wrapper.get('[aria-label="Close jobs"]')
     const lastInsidePanel = focusable[focusable.length - 1]!
@@ -124,7 +126,7 @@ describe('JobsStatusTray', () => {
   })
 
   it('traps reverse Tab navigation from the dialog container', async () => {
-    const wrapper = await openTray({ jobs: [job('running')] })
+    const wrapper = await openTray({ source: { jobs: [job('running')] } })
     const panel = wrapper.get('[role="dialog"]')
     const focusable = panel.findAll('button')
     const panelElement = panel.element as HTMLElement
@@ -136,7 +138,7 @@ describe('JobsStatusTray', () => {
   })
 
   it('exposes job selection through a keyboard-accessible button', async () => {
-    const wrapper = await openTray({ jobs: [job('running')] })
+    const wrapper = await openTray({ source: { jobs: [job('running')] } })
 
     await wrapper.get('.mint-jobs-tray__job-select').trigger('click')
 
@@ -145,7 +147,7 @@ describe('JobsStatusTray', () => {
 
   it('renders the job-actions slot once per row in both tabs with the row job', async () => {
     const wrapper = await openTray({
-      jobs: [job('running', 'R-1'), job('completed', 'C-1')],
+      source: { jobs: [job('running', 'R-1'), job('completed', 'C-1')] },
       slots: {
         'job-actions': ({ job: row }) =>
           h('button', { 'data-testid': 'open', 'data-job': row.job_id }, 'Open'),

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

@@ -50,6 +50,29 @@ describe('useAuth', () => {
     vi.restoreAllMocks()
   })
 
+  it('loads the PostgreSQL-only public auth contract', async () => {
+    mockedAxios.get.mockResolvedValueOnce({
+      data: {
+        auth_required: true,
+        passkey_enabled: true,
+        passkey_registered: false,
+        registration_enabled: true,
+        access: { experiment_visibility_mode: 'restricted' },
+      },
+    })
+
+    const config = await useAuth().fetchAuthConfig()
+    const expected = {
+      authRequired: true,
+      passkeyEnabled: true,
+      passkeyRegistered: false,
+      registrationEnabled: true,
+      experimentVisibilityMode: 'restricted',
+    }
+
+    expect([config, useAuthStore().authConfig]).toEqual([expected, expected])
+  })
+
   describe('login', () => {
     it('should set token on successful login', async () => {
       mockedAxios.post.mockResolvedValueOnce({

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

@@ -0,0 +1,140 @@
+import { effectScope } from 'vue'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { useEventStream } from '../../composables/useEventStream'
+
+function pendingStreamResponse(): {
+  response: Response
+  close: () => void
+} {
+  let close!: () => void
+  const body = new ReadableStream<Uint8Array>({
+    start(controller) {
+      close = () => {
+        try {
+          controller.close()
+        } catch {
+          // stop() may already have cancelled the reader.
+        }
+      }
+    },
+  })
+  return { response: new Response(body), close }
+}
+
+describe('useEventStream', () => {
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('should decode chunked UTF-8 and dispatch an unterminated multiline tail frame', async () => {
+    const encoded = new TextEncoder().encode(
+      ': keepalive\nevent: result\nid: event-7\ndata: first\ndata: 2 µmol',
+    )
+    const split = encoded.indexOf(0xc2) + 1
+    const body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encoded.slice(0, split))
+        controller.enqueue(encoded.slice(split))
+        controller.close()
+      },
+    })
+    const onMessage = vi.fn()
+    const scope = effectScope()
+    const stream = scope.run(() => useEventStream('/events', {
+      transport: vi.fn(async () => new Response(body)),
+      reconnect: false,
+      onMessage,
+    }))!
+
+    await vi.waitFor(() => expect(onMessage).toHaveBeenCalledOnce())
+
+    expect(stream.lastMessage.value).toEqual({
+      event: 'result',
+      data: 'first\n2 µmol',
+      id: 'event-7',
+      retry: undefined,
+      raw: ': keepalive\nevent: result\nid: event-7\ndata: first\ndata: 2 µmol',
+    })
+    scope.stop()
+  })
+
+  it('should keep server retry delay local and send Last-Event-ID on reconnect', async () => {
+    vi.useFakeTimers()
+    const first = new Response('id: event-1\nretry: 7\ndata: first\n\n')
+    const second = pendingStreamResponse()
+    const transport = vi.fn()
+      .mockResolvedValueOnce(first)
+      .mockResolvedValueOnce(second.response)
+    const options = {
+      transport,
+      reconnectDelayMs: 1_000,
+    }
+    const scope = effectScope()
+    const stream = scope.run(() => useEventStream('/events', options))!
+
+    await vi.waitFor(() => expect(stream.lastEventId.value).toBe('event-1'))
+    await vi.advanceTimersByTimeAsync(7)
+
+    const secondHeaders = new Headers(transport.mock.calls[1]?.[1]?.headers)
+    expect({
+      attempts: transport.mock.calls.length,
+      lastEventId: secondHeaders.get('Last-Event-ID'),
+      configuredDelay: options.reconnectDelayMs,
+    }).toEqual({
+      attempts: 2,
+      lastEventId: 'event-1',
+      configuredDelay: 1_000,
+    })
+    stream.stop()
+    second.close()
+    scope.stop()
+  })
+
+  it('should apply control-only frames without dispatching a data message', async () => {
+    vi.useFakeTimers()
+    const second = pendingStreamResponse()
+    const transport = vi.fn()
+      .mockResolvedValueOnce(new Response('id: event-2\nretry: 7\n\n'))
+      .mockResolvedValueOnce(second.response)
+    const onMessage = vi.fn()
+    const scope = effectScope()
+    const stream = scope.run(() => useEventStream('/events', {
+      transport,
+      reconnectDelayMs: 1_000,
+      onMessage,
+    }))!
+
+    await vi.waitFor(() => expect(stream.lastEventId.value).toBe('event-2'))
+    await vi.advanceTimersByTimeAsync(7)
+
+    expect({
+      messages: onMessage.mock.calls.length,
+      reconnectCursor: new Headers(transport.mock.calls[1]?.[1]?.headers).get('Last-Event-ID'),
+    }).toEqual({ messages: 0, reconnectCursor: 'event-2' })
+    stream.stop()
+    second.close()
+    scope.stop()
+  })
+
+  it('should reconnect after an ordinary stream close', async () => {
+    vi.useFakeTimers()
+    const second = pendingStreamResponse()
+    const transport = vi.fn()
+      .mockResolvedValueOnce(new Response('data: first\n\n'))
+      .mockResolvedValueOnce(second.response)
+    const scope = effectScope()
+    const stream = scope.run(() => useEventStream('/events', {
+      transport,
+      reconnectDelayMs: 5,
+    }))!
+
+    await vi.waitFor(() => expect(stream.lastMessage.value?.data).toBe('first'))
+    await vi.advanceTimersByTimeAsync(5)
+
+    expect(transport).toHaveBeenCalledTimes(2)
+    stream.stop()
+    second.close()
+    scope.stop()
+  })
+})

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

@@ -126,6 +126,28 @@ function activeJob(
   }
 }
 
+function streamingJobTransport(): ReturnType<typeof vi.fn<GeneratedAnalysisTransport>> {
+  return vi.fn<GeneratedAnalysisTransport>(async (input, init) => {
+    const url = String(input)
+    if (url.endsWith('/generated/manifest')) return response(manifest)
+    if (url.endsWith('/jobs/sessions') && init?.method === 'GET') {
+      return response({ sessions: [] })
+    }
+    if (url.endsWith('/jobs/sessions') && init?.method === 'POST') {
+      return response({
+        id: 'session-1',
+        tab_id: 'tab-1',
+        created_at: '',
+        last_seen_at: '',
+        active_job_ids: [],
+      })
+    }
+    if (url.endsWith('/jobs/events')) return eventStream()
+    if (url.endsWith('/jobs')) return response({ jobs: [activeJob('job-1')] })
+    throw new Error(`Unexpected request: ${url}`)
+  })
+}
+
 describe('useGeneratedAnalysis', () => {
   it('is directly usable as a job center source', () => {
     const scope = effectScope()
@@ -283,6 +305,87 @@ describe('useGeneratedAnalysis', () => {
     }
   })
 
+  it('should poll active jobs while a closed stream waits to reconnect', async () => {
+    vi.useFakeTimers()
+    const transport = streamingJobTransport()
+    const scope = effectScope()
+    const generated = scope.run(() => useGeneratedAnalysis({
+      baseUrl: '/api/demo',
+      transport,
+      storage: memoryStorage(),
+      createId: () => 'tab-1',
+      pollInterval: 5,
+      streamReconnectDelay: 1_000,
+    }))!
+
+    try {
+      await generated.initialize()
+      await vi.advanceTimersByTimeAsync(5)
+
+      expect(transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs'))).toHaveLength(2)
+    } finally {
+      generated.dispose()
+      scope.stop()
+      vi.useRealTimers()
+    }
+  })
+
+  it('should not poll or reconnect a paused job stream', async () => {
+    vi.useFakeTimers()
+    const transport = streamingJobTransport()
+    const scope = effectScope()
+    const generated = scope.run(() => useGeneratedAnalysis({
+      baseUrl: '/api/demo',
+      transport,
+      storage: memoryStorage(),
+      createId: () => 'tab-1',
+      pollInterval: 5,
+      streamReconnectDelay: 10,
+    }))!
+
+    try {
+      await generated.initialize()
+      await vi.advanceTimersByTimeAsync(0)
+      generated.pause()
+      await vi.advanceTimersByTimeAsync(20)
+
+      expect({
+        jobLists: transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs')).length,
+        streams: transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs/events')).length,
+      }).toEqual({ jobLists: 1, streams: 1 })
+    } finally {
+      generated.dispose()
+      scope.stop()
+      vi.useRealTimers()
+    }
+  })
+
+  it('should not poll or reconnect a disposed job stream', async () => {
+    vi.useFakeTimers()
+    const transport = streamingJobTransport()
+    const scope = effectScope()
+    const generated = scope.run(() => useGeneratedAnalysis({
+      baseUrl: '/api/demo',
+      transport,
+      storage: memoryStorage(),
+      createId: () => 'tab-1',
+      pollInterval: 5,
+      streamReconnectDelay: 10,
+    }))!
+
+    await generated.initialize()
+    await vi.advanceTimersByTimeAsync(0)
+    generated.dispose()
+    await vi.advanceTimersByTimeAsync(20)
+
+    expect({
+      jobLists: transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs')).length,
+      streams: transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs/events')).length,
+    }).toEqual({ jobLists: 1, streams: 1 })
+    scope.stop()
+    vi.useRealTimers()
+  })
+
   it('does not let a late submit response regress a terminal stream update', async () => {
     const terminal = completedJob('fast-service-job')
     const lateQueued = activeJob('fast-service-job')

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

@@ -1,14 +1,13 @@
 import { mount } from '@vue/test-utils'
-import { defineComponent, nextTick, ref, shallowRef } from 'vue'
+import { defineComponent, nextTick, shallowRef } from 'vue'
 import { describe, expect, it, vi } from 'vitest'
 
 import {
   combinePluginJobSources,
-  useJobsStatusTray,
   usePluginJobCenter,
-  type UseJobsStatusTrayOptions,
+  type UsePluginJobCenterOptions,
 } from '../../composables/useJobsStatusTray'
-import type { JobState, JobStateInput, JobStatus } from '../../types/jobs'
+import type { JobStateInput, JobStatus } from '../../types/jobs'
 
 function job(status: JobStatus, id: string = status): JobStateInput {
   return {
@@ -44,29 +43,18 @@ function job(status: JobStatus, id: string = status): JobStateInput {
   }
 }
 
-function mountComposable(options: UseJobsStatusTrayOptions) {
-  let tray!: ReturnType<typeof useJobsStatusTray>
+function mountComposable(options: UsePluginJobCenterOptions) {
+  let tray!: ReturnType<typeof usePluginJobCenter>
   const wrapper = mount(defineComponent({
     setup() {
-      tray = useJobsStatusTray(options)
+      tray = usePluginJobCenter(options)
       return () => null
     },
   }))
   return { tray, wrapper }
 }
 
-function deferred<T>(): {
-  promise: Promise<T>
-  resolve: (value: T) => void
-} {
-  let resolve!: (value: T) => void
-  const promise = new Promise<T>((done) => {
-    resolve = done
-  })
-  return { promise, resolve }
-}
-
-describe('useJobsStatusTray', () => {
+describe('usePluginJobCenter', () => {
   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')])
@@ -242,37 +230,20 @@ describe('useJobsStatusTray', () => {
 
   it('keeps awaiting input jobs in the active group', () => {
     const { tray } = mountComposable({
-      jobs: [job('awaiting_input')],
+      source: { jobs: [job('awaiting_input')] },
       loadOnMount: false,
     })
 
     expect(tray.activeJobs.value.map(item => item.job_id)).toEqual(['awaiting_input'])
   })
 
-  it('replaces stale jobs when an SSE snapshot arrives', () => {
-    const { tray } = mountComposable({ jobs: [job('running', 'old')], loadOnMount: false })
-
-    tray.applyStreamMessage({
-      event: 'snapshot',
-      data: { jobs: [job('queued', 'new')] },
-    })
-
-    expect(tray.jobs.value.map(item => item.job_id)).toEqual(['new'])
-  })
-
-  it('moves an SSE terminal update into history', () => {
-    const { tray } = mountComposable({ jobs: [job('running', 'fit')], loadOnMount: false })
-
-    tray.applyStreamMessage({ event: 'terminal', data: job('completed', 'fit') })
-
-    expect(tray.historyJobs.value.map(item => item.job_id)).toEqual(['fit'])
-  })
-
-  it('does not call a cancel adapter when the capability is disabled', async () => {
+  it('does not call a source cancel action when the capability is disabled', async () => {
     const cancelJob = vi.fn()
     const { tray } = mountComposable({
-      jobs: [{ ...job('running'), can_cancel: false }],
-      adapter: { cancelJob },
+      source: {
+        jobs: [{ ...job('running'), can_cancel: false }],
+        cancelJob,
+      },
       loadOnMount: false,
     })
 
@@ -281,139 +252,32 @@ describe('useJobsStatusTray', () => {
     expect(cancelJob).not.toHaveBeenCalled()
   })
 
-  it('does not let a stale list response overwrite an SSE update', async () => {
-    let resolveList!: (jobs: JobStateInput[]) => void
-    const listJobs = vi.fn(() => new Promise<JobStateInput[]>((resolve) => {
-      resolveList = resolve
-    }))
-    const { tray } = mountComposable({
-      adapter: { listJobs },
-      loadOnMount: false,
+  it('refreshes through the source without mirroring its jobs', async () => {
+    const sourceJobs = shallowRef([job('running', 'old')])
+    const refreshJobs = vi.fn(async () => {
+      sourceJobs.value = [job('queued', 'new')]
+      return sourceJobs.value
     })
-
-    const refresh = tray.refresh()
-    tray.applyStreamMessage({ event: 'job', data: job('running', 'live') })
-    resolveList([job('queued', 'stale')])
-    await refresh
-    await nextTick()
-
-    expect(tray.jobs.value.map(item => item.job_id)).toEqual(['live'])
-  })
-
-  it('passes only explicitly deletable jobs to the bulk clear adapter', async () => {
-    const clearFinishedJobs = vi.fn(async (_jobs: readonly JobState[]) => undefined)
     const { tray } = mountComposable({
-      jobs: [
-        job('completed', 'legacy-deletable'),
-        { ...job('failed', 'retained'), can_delete: false },
-      ],
-      adapter: { clearFinishedJobs },
+      source: { jobs: sourceJobs, refreshJobs },
       loadOnMount: false,
     })
 
-    await tray.clearFinished()
+    await tray.refresh()
+    await nextTick()
 
-    expect(clearFinishedJobs.mock.calls[0]![0].map(item => item.job_id)).toEqual([
-      'legacy-deletable',
+    expect([refreshJobs.mock.calls.length, tray.jobs.value.map(item => item.job_id)]).toEqual([
+      1,
+      ['new'],
     ])
   })
 
   it('does not include active deletable jobs in bulk clear targets', () => {
     const { tray } = mountComposable({
-      jobs: [{ ...job('awaiting_input'), can_delete: true }],
+      source: { jobs: [{ ...job('awaiting_input'), can_delete: true }] },
       loadOnMount: false,
     })
 
     expect(tray.deletableJobs.value).toEqual([])
   })
-
-  it('does not let a late cancel response overwrite a newer SSE state', async () => {
-    const pending = deferred<JobStateInput>()
-    const { tray } = mountComposable({
-      jobs: [job('running', 'fit')],
-      adapter: { cancelJob: async () => pending.promise },
-      loadOnMount: false,
-    })
-
-    const cancellation = tray.cancelJob(tray.jobs.value[0]!)
-    tray.applyStreamMessage({ event: 'terminal', data: job('completed', 'fit') })
-    pending.resolve(job('cancelled', 'fit'))
-    await cancellation
-
-    expect(tray.jobs.value[0]!.status).toBe('completed')
-  })
-
-  it('applies a cancel response after an unrelated job update', async () => {
-    const pending = deferred<JobStateInput>()
-    const { tray } = mountComposable({
-      jobs: [job('running', 'fit'), job('running', 'export')],
-      adapter: { cancelJob: async () => pending.promise },
-      loadOnMount: false,
-    })
-
-    const cancellation = tray.cancelJob(tray.jobs.value[0]!)
-    tray.applyStreamMessage({ event: 'job', data: job('running', 'export') })
-    pending.resolve(job('cancelled', 'fit'))
-    await cancellation
-
-    expect(tray.jobs.value.find(item => item.job_id === 'fit')?.status).toBe('cancelled')
-  })
-
-  it('refreshes instead of removing every target after a partial bulk clear', async () => {
-    const listJobs = vi.fn(async () => [job('completed', 'retained')])
-    const clearFinishedJobs = vi.fn(async () => 1)
-    const { tray } = mountComposable({
-      jobs: [job('completed', 'deleted'), job('completed', 'retained')],
-      adapter: { listJobs, clearFinishedJobs },
-      loadOnMount: false,
-    })
-
-    const cleared = await tray.clearFinished()
-
-    expect([
-      cleared,
-      listJobs.mock.calls.length,
-      tray.jobs.value.map(item => item.job_id),
-    ]).toEqual([false, 1, ['retained']])
-  })
-
-  it('uses a replacement reactive adapter for later actions', async () => {
-    const first = vi.fn(async () => undefined)
-    const second = vi.fn(async () => undefined)
-    const adapter = shallowRef({ cancelJob: first })
-    const { tray } = mountComposable({
-      jobs: [job('running')],
-      adapter,
-      loadOnMount: false,
-    })
-    adapter.value = { cancelJob: second }
-
-    await tray.cancelJob(tray.jobs.value[0]!)
-
-    expect([first.mock.calls.length, second.mock.calls.length]).toEqual([0, 1])
-  })
-
-  it('applies the latest message from a replacement stream immediately', async () => {
-    const eventStream = shallowRef({
-      isConnected: ref(true),
-      isConnecting: ref(false),
-      error: ref<string | null>(null),
-      lastMessage: shallowRef({
-        event: 'snapshot',
-        data: { jobs: [job('queued', 'replacement')] },
-        raw: '',
-      }),
-      lastEventId: ref<string | null>(null),
-      start: vi.fn(),
-      stop: vi.fn(),
-    })
-
-    const { tray } = mountComposable({
-      eventStream,
-      loadOnMount: false,
-    })
-    await nextTick()
-
-    expect(tray.jobs.value.map(item => item.job_id)).toEqual(['replacement'])
-  })
 })