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

package/src/__tests__/composables/{useGeneratedAnalysis.test.ts → useJobsEndpoint.test.ts}

@@ -1,13 +1,13 @@
 import { effectScope } from 'vue'
 import { describe, expect, it, vi } from 'vitest'
 
-import { useGeneratedAnalysis } from '../../composables/useGeneratedAnalysis'
+import { useJobsEndpoint } from '../../composables/useJobsEndpoint'
 import { MintApiError } from '../../apiErrors'
 import {
   createGeneratedAnalysisTransport,
   type GeneratedAnalysisTransport,
-} from '../../composables/useGeneratedAnalysis'
-import type { PluginJobCenterSource } from '../../composables/useJobsStatusTray'
+} from '../../composables/useJobsEndpoint'
+import type { PluginJobCenterSource } from '../../composables/useJobCenter'
 import type {
   GeneratedAnalysisJob,
   GeneratedAnalysisManifest,
@@ -149,10 +149,11 @@ function streamingJobTransport(): ReturnType<typeof vi.fn<GeneratedAnalysisTrans
   })
 }
 
-describe('useGeneratedAnalysis', () => {
+describe('useJobsEndpoint', () => {
   it('is directly usable as a job center source', () => {
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport: vi.fn<GeneratedAnalysisTransport>(),
       storage: memoryStorage(),
@@ -166,7 +167,8 @@ describe('useGeneratedAnalysis', () => {
 
   it('should report an immediate initialization failure without an unhandled rejection', async () => {
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport: vi.fn<GeneratedAnalysisTransport>()
         .mockRejectedValue(new TypeError('offline')),
@@ -200,7 +202,8 @@ describe('useGeneratedAnalysis', () => {
       }))
       .mockResolvedValueOnce(response({ jobs: [] }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: unavailableStorage,
@@ -209,7 +212,7 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
 
       expect(generated.session.value?.id).toBe('session-1')
     } finally {
@@ -217,6 +220,39 @@ describe('useGeneratedAnalysis', () => {
     }
   })
 
+  it('should open one job session when runtimes for the same plugin start together', async () => {
+    const storage = memoryStorage()
+    let created = 0
+    const transport = vi.fn<GeneratedAnalysisTransport>(async (input, init) => {
+      const url = String(input)
+      if (url.endsWith('/jobs/sessions') && init?.method === 'GET') return response({ sessions: [] })
+      if (url.endsWith('/jobs/sessions') && init?.method === 'POST') {
+        created += 1
+        return response({
+          id: `session-${created}`, tab_id: 'tab-1', created_at: '', last_seen_at: '', active_job_ids: [],
+        })
+      }
+      if (url.endsWith('/jobs')) return response({ jobs: [] })
+      throw new Error(`Unexpected request: ${url}`)
+    })
+    const scope = effectScope()
+    const runtimes = scope.run(() => [1, 2].map(() => useJobsEndpoint({
+      baseUrl: '/api/demo',
+      transport,
+      storage,
+      createId: () => 'tab-1',
+      stream: false,
+    })))!
+
+    try {
+      await Promise.all(runtimes.map(runtime => runtime.refresh()))
+
+      expect(runtimes.map(runtime => runtime.session.value?.id)).toEqual(['session-1', 'session-1'])
+    } finally {
+      scope.stop()
+    }
+  })
+
   it('should add the current bearer token to JSON and event-stream requests', async () => {
     const fetcher = vi.fn().mockResolvedValue(response({ ok: true }))
     const transport = createGeneratedAnalysisTransport({
@@ -269,7 +305,8 @@ describe('useGeneratedAnalysis', () => {
     })
     vi.stubGlobal('EventSource', eventSource)
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage,
@@ -278,12 +315,12 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       await vi.waitFor(() => expect(generated.jobs.value[0]?.status).toBe('completed'))
 
       expect(transport.mock.calls.some(call => String(call[0]).endsWith('/result'))).toBe(false)
 
-      await generated.loadResult(generated.jobs.value[0]!)
+      await generated.result(generated.jobs.value[0]!)
 
       const streamCall = transport.mock.calls.find(call => String(call[0]).endsWith('/jobs/events'))
       const resultCall = transport.mock.calls.find(call => String(call[0]).endsWith('/jobs/job-1/result'))
@@ -310,17 +347,18 @@ describe('useGeneratedAnalysis', () => {
     vi.useFakeTimers()
     const transport = streamingJobTransport()
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
       createId: () => 'tab-1',
-      pollInterval: 5,
+      poll: 5,
       streamReconnectDelay: 1_000,
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       await vi.advanceTimersByTimeAsync(5)
 
       expect(transport.mock.calls.filter(([input]) => String(input).endsWith('/jobs'))).toHaveLength(2)
@@ -335,17 +373,18 @@ describe('useGeneratedAnalysis', () => {
     vi.useFakeTimers()
     const transport = streamingJobTransport()
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
       createId: () => 'tab-1',
-      pollInterval: 5,
+      poll: 5,
       streamReconnectDelay: 10,
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       await vi.advanceTimersByTimeAsync(0)
       generated.pause()
       await vi.advanceTimersByTimeAsync(20)
@@ -365,16 +404,17 @@ describe('useGeneratedAnalysis', () => {
     vi.useFakeTimers()
     const transport = streamingJobTransport()
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
       createId: () => 'tab-1',
-      pollInterval: 5,
+      poll: 5,
       streamReconnectDelay: 10,
     }))!
 
-    await generated.initialize()
+    await generated.refresh()
     await vi.advanceTimersByTimeAsync(0)
     generated.dispose()
     await vi.advanceTimersByTimeAsync(20)
@@ -402,7 +442,8 @@ describe('useGeneratedAnalysis', () => {
       ))
       .mockResolvedValueOnce(response(lateQueued))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -411,7 +452,7 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       await vi.waitFor(() => expect(generated.jobs.value[0]?.status).toBe('completed'))
 
       const submitted = await generated.submit('run', {})
@@ -440,19 +481,20 @@ describe('useGeneratedAnalysis', () => {
       }))
       .mockResolvedValueOnce(response({ kind: 'text', text: 'done' }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport: fetcher,
       storage,
       createId: () => 'tab-1',
-      pollInterval: 60_000,
+      poll: 60_000,
       stream: false,
     }))!
 
-    await generated.initialize()
+    await generated.refresh()
     await generated.submit('run', { threshold: 2.5 })
-    await generated.refreshJobs()
-    await generated.loadResult(generated.jobs.value[0]!)
+    await generated.refresh()
+    await generated.result(generated.jobs.value[0]!)
     scope.stop()
 
     expect({
@@ -486,7 +528,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ token: 'upload-token', kind: 'file', name: 'data.csv', size: 4 }))
       .mockResolvedValueOnce(response(activeJob('job-1')))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -495,7 +538,7 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       await generated.submit('run', {
         source: {
           kind: 'path',
@@ -540,7 +583,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ token: 'artifact-token', kind: 'file', name: 'matrix.csv', size: 4 }))
       .mockResolvedValueOnce(response(activeJob('job-1')))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -549,7 +593,7 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       await generated.submit('run', {
         source: {
           kind: 'artifact-path',
@@ -618,7 +662,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response(staging))
       .mockResolvedValueOnce(response(sealedJob))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -627,7 +672,7 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       const uploaded = await generated.uploadStagedPart({
         job: 'staged/job',
         key: 'sample one/chunk#1',
@@ -701,7 +746,8 @@ describe('useGeneratedAnalysis', () => {
       .mockReturnValueOnce(sealRequest.promise)
       .mockResolvedValueOnce(response({ jobs: [awaiting] }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -710,10 +756,10 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       const sealing = generated.sealJob('seal-race')
       await vi.waitFor(() => expect(transport).toHaveBeenCalledTimes(5))
-      await generated.refreshJobs()
+      await generated.refresh()
       sealRequest.resolve(response(queued))
 
       await expect(sealing).resolves.toMatchObject({ status: 'queued' })
@@ -736,7 +782,8 @@ describe('useGeneratedAnalysis', () => {
       }))
       .mockResolvedValueOnce(response({ jobs: [] }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport: fetcher,
       storage,
@@ -744,7 +791,7 @@ describe('useGeneratedAnalysis', () => {
       stream: false,
     }))!
 
-    await generated.initialize()
+    await generated.refresh()
     scope.stop()
 
     expect(fetcher.mock.calls.map(call => [call[0], call[1]?.method])).toEqual([
@@ -776,7 +823,8 @@ describe('useGeneratedAnalysis', () => {
       }))
       .mockResolvedValueOnce(response({ ...activeJob('job-1'), session_id: 'session-2' }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage,
@@ -785,7 +833,7 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       const job = await generated.submit('run', { threshold: 2.5 })
       const jobBodies = transport.mock.calls
         .filter(call => String(call[0]).endsWith('/jobs') && call[1]?.method === 'POST')
@@ -834,7 +882,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ jobs: [] }))
       .mockResolvedValueOnce(response({ detail }, status))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage,
@@ -844,7 +893,7 @@ describe('useGeneratedAnalysis', () => {
     let caught: unknown
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       await generated.submit('run', {})
     } catch (error) {
       caught = error
@@ -883,17 +932,18 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ jobs: [completedJob('job-1')] }))
       .mockResolvedValueOnce(response({ kind: 'text', text: 'done' }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport: fetcher,
       storage,
       createId: () => 'tab-1',
-      pollInterval: 10,
+      poll: 10,
       stream: false,
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       await vi.advanceTimersByTimeAsync(20)
 
       expect({
@@ -928,7 +978,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ jobs: [newJob, oldJob] }))
       .mockReturnValueOnce(newResult.promise)
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage,
@@ -937,13 +988,13 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      await generated.refreshJobs()
-      const oldLoad = generated.loadResult(oldJob)
-      const duplicateOldLoad = generated.loadResult(oldJob)
+      await generated.refresh()
+      await generated.refresh()
+      const oldLoad = generated.result(oldJob)
+      const duplicateOldLoad = generated.result(oldJob)
       await vi.waitFor(() => expect(transport).toHaveBeenCalledTimes(6))
-      await generated.refreshJobs()
-      const newLoad = generated.loadResult(newJob)
+      await generated.refresh()
+      const newLoad = generated.result(newJob)
       await vi.waitFor(() => expect(transport).toHaveBeenCalledTimes(8))
 
       newResult.resolve(response({ kind: 'text', text: 'new' }))
@@ -1001,7 +1052,8 @@ describe('useGeneratedAnalysis', () => {
         download_expires_at: '2026-07-21T10:09:30Z',
       }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1010,8 +1062,8 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      await generated.loadResult(completed)
+      await generated.refresh()
+      await generated.result(completed)
       await vi.advanceTimersByTimeAsync(270_000)
 
       expect({
@@ -1053,7 +1105,8 @@ describe('useGeneratedAnalysis', () => {
       }))
       .mockResolvedValueOnce(response({ detail: 'Job result expired' }, 410))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1062,8 +1115,8 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      await generated.loadResult(completed)
+      await generated.refresh()
+      await generated.result(completed)
       await vi.advanceTimersByTimeAsync(270_000)
       await vi.advanceTimersByTimeAsync(60_000)
 
@@ -1106,7 +1159,8 @@ describe('useGeneratedAnalysis', () => {
       }))
       .mockResolvedValueOnce(response({ detail: 'Job result expired' }, 410))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1115,8 +1169,8 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      await generated.loadResult(completed)
+      await generated.refresh()
+      await generated.result(completed)
       await vi.advanceTimersByTimeAsync(19_999)
       expect(transport.mock.calls.filter(call => String(call[0]).endsWith('/result'))).toHaveLength(1)
 
@@ -1152,7 +1206,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response(managedResult('token-1', '2026-07-21T10:05:00Z')))
       .mockResolvedValueOnce(response(managedResult('token-2', '2026-07-21T10:10:01Z')))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1161,8 +1216,8 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      await generated.loadResult(completed)
+      await generated.refresh()
+      await generated.result(completed)
       generated.pause()
       await vi.advanceTimersByTimeAsync(301_000)
       expect(transport.mock.calls.filter(call => String(call[0]).endsWith('/result'))).toHaveLength(1)
@@ -1193,18 +1248,19 @@ describe('useGeneratedAnalysis', () => {
       .mockRejectedValueOnce(new TypeError('temporary result failure'))
       .mockResolvedValueOnce(response({ kind: 'text', text: 'recovered' }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage,
       createId: () => 'tab-1',
-      pollInterval: 10,
+      poll: 10,
       stream: false,
     }))!
 
     try {
-      await generated.initialize()
-      await generated.loadResult(completed)
+      await generated.refresh()
+      await generated.result(completed)
 
       expect(generated.error.value).toBe('temporary result failure')
 
@@ -1240,7 +1296,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ jobs: [sharedJob] }))
       .mockResolvedValueOnce(response({ kind: 'text', text: 'shared' }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage,
@@ -1249,8 +1306,8 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      const result = await generated.loadResult(sharedJob)
+      await generated.refresh()
+      const result = await generated.result(sharedJob)
 
       expect(result).toEqual({ kind: 'text', text: 'shared' })
     } finally {
@@ -1278,22 +1335,23 @@ describe('useGeneratedAnalysis', () => {
       .mockRejectedValueOnce(new TypeError('failure-after-return'))
       .mockResolvedValueOnce(response({ kind: 'text', text: 'recovered' }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage,
       createId: () => 'tab-1',
-      pollInterval: 10,
+      poll: 10,
       stream: false,
     }))!
 
     try {
-      await generated.initialize()
-      await generated.loadResult(completed)
+      await generated.refresh()
+      await generated.result(completed)
       await vi.advanceTimersByTimeAsync(70)
-      await generated.refreshJobs()
-      await generated.refreshJobs()
-      await generated.loadResult(completed)
+      await generated.refresh()
+      await generated.refresh()
+      await generated.result(completed)
       await vi.advanceTimersByTimeAsync(10)
 
       expect(generated.resultForJob('retry-job')).toEqual({
@@ -1321,7 +1379,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ jobs: completedJobs }))
       .mockImplementation(async input => response({ kind: 'text', text: String(input) }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage,
@@ -1330,8 +1389,8 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      for (const job of completedJobs) await generated.loadResult(job)
+      await generated.refresh()
+      for (const job of completedJobs) await generated.result(job)
 
       expect({
         evicted: generated.resultForJob('job-0'),
@@ -1362,26 +1421,27 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response(running))
       .mockResolvedValueOnce(response({ jobs: [completed] }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
       createId: () => 'tab-1',
-      pollInterval: 60_000,
+      poll: 60_000,
       stream: false,
     }))!
 
     try {
-      await generated.initialize()
-      const waiting = generated.waitForJob('wait-job')
+      await generated.refresh()
+      const waiting = generated.wait('wait-job')
       await vi.waitFor(() => expect(generated.jobs.value[0]?.status).toBe('running'))
-      await generated.refreshJobs()
+      await generated.refresh()
 
       await expect(waiting).resolves.toMatchObject({
         job_id: 'wait-job',
         status: 'completed',
       })
-      await expect(generated.waitForJob(completed)).resolves.toEqual(completed)
+      await expect(generated.wait(completed)).resolves.toEqual(completed)
       expect(transport).toHaveBeenCalledTimes(6)
     } finally {
       scope.stop()
@@ -1405,7 +1465,8 @@ describe('useGeneratedAnalysis', () => {
       }))
       .mockResolvedValueOnce(response({ jobs: [failed] }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1414,14 +1475,14 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      await expect(generated.waitForJob(failed)).resolves.toMatchObject({ status: 'failed' })
-      await expect(generated.waitForJob(failed, { rejectOnFailure: true }))
+      await generated.refresh()
+      await expect(generated.wait(failed)).resolves.toMatchObject({ status: 'failed' })
+      await expect(generated.wait(failed, { rejectOnFailure: true }))
         .rejects.toThrow('analysis exploded')
 
       const controller = new AbortController()
       controller.abort()
-      await expect(generated.waitForJob(failed, { signal: controller.signal }))
+      await expect(generated.wait(failed, { signal: controller.signal }))
         .rejects.toMatchObject({ name: 'AbortError' })
       expect(transport).toHaveBeenCalledTimes(4)
     } finally {
@@ -1441,19 +1502,20 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ jobs: [queued] }))
       .mockReturnValueOnce(jobRequest.promise)
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
       createId: () => 'tab-1',
-      pollInterval: 60_000,
+      poll: 60_000,
       stream: false,
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       const controller = new AbortController()
-      const waiting = generated.waitForJob('abort-job', { signal: controller.signal })
+      const waiting = generated.wait('abort-job', { signal: controller.signal })
       expect(transport.mock.calls[4]?.[1]?.signal).toBe(controller.signal)
       controller.abort()
 
@@ -1478,20 +1540,21 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ detail: 'temporarily unavailable' }, 503))
       .mockResolvedValueOnce(response({ jobs: [completed] }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
       createId: () => 'tab-1',
-      pollInterval: 60_000,
+      poll: 60_000,
       stream: false,
     }))!
 
     try {
-      await generated.initialize()
-      const waiting = generated.waitForJob('retry-wait-job')
+      await generated.refresh()
+      const waiting = generated.wait('retry-wait-job')
       await vi.waitFor(() => expect(transport).toHaveBeenCalledTimes(5))
-      await generated.refreshJobs()
+      await generated.refresh()
       await expect(waiting).resolves.toMatchObject({
         job_id: 'retry-wait-job',
         status: 'completed',
@@ -1511,7 +1574,8 @@ describe('useGeneratedAnalysis', () => {
       }))
       .mockResolvedValueOnce(response({ jobs: [queued] }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1520,9 +1584,9 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
+      await generated.refresh()
       generated.pause()
-      await expect(generated.waitForJob('paused-wait-job')).rejects.toThrow(
+      await expect(generated.wait('paused-wait-job')).rejects.toThrow(
         'Plugin jobs runtime is paused',
       )
       expect(transport).toHaveBeenCalledTimes(4)
@@ -1545,22 +1609,23 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ status: 'deleted' }))
       .mockReturnValueOnce(disposeJobRequest.promise)
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
       createId: () => 'tab-1',
-      pollInterval: 60_000,
+      poll: 60_000,
       stream: false,
     }))!
 
-    await generated.initialize()
-    const deletedWait = generated.waitForJob('delete-wait-job')
+    await generated.refresh()
+    const deletedWait = generated.wait('delete-wait-job')
     await vi.waitFor(() => expect(transport).toHaveBeenCalledTimes(5))
-    await generated.deleteJob('delete-wait-job')
+    await generated.delete('delete-wait-job')
     await expect(deletedWait).rejects.toThrow('was deleted')
 
-    const disposeWait = generated.waitForJob(activeJob('dispose-wait-job'))
+    const disposeWait = generated.wait(activeJob('dispose-wait-job'))
     scope.stop()
     await expect(disposeWait).rejects.toThrow('runtime is disposed')
     disposeJobRequest.resolve(response(activeJob('dispose-wait-job')))
@@ -1578,7 +1643,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ jobs: [] }))
       .mockReturnValueOnce(refreshRequest.promise)
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1586,13 +1652,13 @@ describe('useGeneratedAnalysis', () => {
       stream: false,
     }))!
 
-    const firstInitialize = generated.initialize()
-    const secondInitialize = generated.ready()
+    const firstInitialize = generated.refresh()
+    const secondInitialize = generated.refresh()
     expect(firstInitialize).toBe(secondInitialize)
     manifestRequest.resolve(response(manifest))
     await firstInitialize
 
-    const firstRefresh = generated.refreshJobs()
+    const firstRefresh = generated.refresh()
     const secondRefresh = generated.refresh()
     expect(firstRefresh).toBe(secondRefresh)
     refreshRequest.resolve(response({ jobs: [completedJob('coalesced')] }))
@@ -1611,7 +1677,7 @@ describe('useGeneratedAnalysis', () => {
       requests: 5,
       filtered: ['coalesced'],
     })
-    await expect(generated.initialize()).rejects.toThrow('disposed')
+    await expect(generated.submit('run', {})).rejects.toThrow('disposed')
   })
 
   it('does not let a late list response overwrite a newer canonical job update', async () => {
@@ -1628,7 +1694,8 @@ describe('useGeneratedAnalysis', () => {
       .mockReturnValueOnce(staleRefresh.promise)
       .mockResolvedValueOnce(response(completed))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1637,9 +1704,9 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      const refresh = generated.refreshJobs()
-      await generated.getJob('live-job')
+      await generated.refresh()
+      const refresh = generated.refresh()
+      await generated.get('live-job')
       staleRefresh.resolve(response({ jobs: [queued] }))
       await refresh
 
@@ -1667,19 +1734,20 @@ describe('useGeneratedAnalysis', () => {
       .mockReturnValueOnce(staleRefresh.promise)
       .mockResolvedValueOnce(response({ jobs: [completed] }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
       createId: () => 'tab-1',
-      pollInterval: 10,
+      poll: 10,
       stream: false,
     }))!
     let waiting: Promise<GeneratedAnalysisJob> | undefined
 
     try {
-      await generated.initialize()
-      waiting = generated.waitForJob('live-job')
+      await generated.refresh()
+      waiting = generated.wait('live-job')
       void waiting.catch(() => undefined)
 
       vi.advanceTimersByTime(10)
@@ -1719,7 +1787,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ jobs: [completed] }))
       .mockResolvedValueOnce(response({ jobs: [staleQueued] }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1728,8 +1797,8 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      await generated.refreshJobs()
+      await generated.refresh()
+      await generated.refresh()
 
       expect(generated.jobs.value[0]?.status).toBe('completed')
     } finally {
@@ -1746,7 +1815,8 @@ describe('useGeneratedAnalysis', () => {
       }))
       .mockResolvedValueOnce(response({ jobs: [completedJob('initial-refresh')] }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1788,7 +1858,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ jobs: [running] }))
       .mockResolvedValueOnce(response(cancelled))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1797,8 +1868,8 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      const updated = await generated.cancelJob('cancel-me')
+      await generated.refresh()
+      const updated = await generated.cancel('cancel-me')
 
       expect({
         updated,
@@ -1844,7 +1915,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ jobs: [legacyActive] }))
       .mockResolvedValueOnce(response(legacyCompleted))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1853,8 +1925,8 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      const fetched = await generated.getJob('legacy-completed')
+      await generated.refresh()
+      const fetched = await generated.get('legacy-completed')
 
       expect(generated.jobs.value[1]).toMatchObject({
         job_id: 'legacy-active',
@@ -1892,7 +1964,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ jobs: [completed] }))
       .mockResolvedValueOnce(response({ status: 'deleted' }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1901,8 +1974,8 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      const deleted = await generated.deleteJob(completed)
+      await generated.refresh()
+      const deleted = await generated.delete(completed)
 
       expect({
         deleted,
@@ -1935,7 +2008,8 @@ describe('useGeneratedAnalysis', () => {
       .mockResolvedValueOnce(response({ deleted: 1 }))
       .mockResolvedValueOnce(response({ jobs: [otherJob] }))
     const scope = effectScope()
-    const generated = scope.run(() => useGeneratedAnalysis({
+    const generated = scope.run(() => useJobsEndpoint({
+      manifest: true,
       baseUrl: '/api/demo',
       transport,
       storage: memoryStorage(),
@@ -1944,8 +2018,8 @@ describe('useGeneratedAnalysis', () => {
     }))!
 
     try {
-      await generated.initialize()
-      const deleted = await generated.clearFinishedJobs('run')
+      await generated.refresh()
+      const deleted = await generated.clear('run')
 
       expect(deleted).toBe(1)
       expect(generated.jobs.value.map(job => job.job_id)).toEqual(['keep-other'])