@morscherlab/mint-sdk 1.0.63 → 1.1.0-beta.2

package/src/composables/useGeneratedAnalysis.ts

@@ -0,0 +1,1252 @@
+import {
+  computed,
+  onScopeDispose,
+  ref,
+  shallowRef,
+  type ComputedRef,
+  type Ref,
+  type ShallowRef,
+} from 'vue'
+
+import type {
+  JobsStatusTrayAdapter,
+  PluginJobCenterSource,
+} from './useJobsStatusTray'
+import { normalizeJobState } from '../jobs'
+import type {
+  GeneratedAnalysisJob,
+  GeneratedAnalysisJobInput,
+  GeneratedAnalysisResult,
+  GeneratedSession,
+  GeneratedAnalysisManifest,
+  PluginJobPathInput,
+  PluginJobPathUpload,
+  PluginJobStagedPartInput,
+  PluginJobStagedPartUploadResult,
+  PluginJobStaging,
+  PluginJobStagingPagination,
+} from '../types/generated-ui'
+
+export type GeneratedAnalysisTransport = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>
+
+export interface GeneratedAnalysisTransportOptions {
+  fetcher?: typeof fetch
+  getAccessToken?: () => string | null | undefined
+}
+
+export interface UsePluginJobsOptions {
+  baseUrl: string
+  transport?: GeneratedAnalysisTransport
+  storage?: Storage
+  createId?: () => string
+  pollInterval?: number
+  stream?: boolean
+  streamReconnectDelay?: number
+  immediate?: boolean
+}
+
+export type GeneratedAnalysisOptions = UsePluginJobsOptions
+
+export interface PluginJobWaitOptions {
+  signal?: AbortSignal
+  rejectOnFailure?: boolean
+}
+
+export interface PluginJobRequestOptions {
+  signal?: AbortSignal
+}
+
+interface GeneratedSessionStorage {
+  getItem: (key: string) => string | null
+  setItem: (key: string, value: string) => void
+}
+
+export interface UsePluginJobsReturn extends PluginJobCenterSource {
+  manifest: ShallowRef<GeneratedAnalysisManifest | null>
+  session: ShallowRef<GeneratedSession | null>
+  jobs: ShallowRef<GeneratedAnalysisJob[]>
+  latestResult: ComputedRef<GeneratedAnalysisResult | null>
+  isLoading: Ref<boolean>
+  isSubmitting: Ref<boolean>
+  error: ShallowRef<string | null>
+  status: ShallowRef<'idle' | 'initializing' | 'ready' | 'paused' | 'error' | 'disposed'>
+  initialize: () => Promise<void>
+  ready: () => Promise<void>
+  uploadPath: (input: PluginJobPathInput) => Promise<PluginJobPathUpload>
+  uploadStagedPart: <Metadata>(
+    input: PluginJobStagedPartInput<Metadata>,
+  ) => Promise<PluginJobStagedPartUploadResult<Metadata>>
+  getJobStaging: <Metadata = unknown>(
+    job: GeneratedAnalysisJob | string,
+    pagination?: PluginJobStagingPagination,
+  ) => Promise<PluginJobStaging<Metadata>>
+  sealJob: (job: GeneratedAnalysisJob | string) => Promise<GeneratedAnalysisJob>
+  submit: (definitionId: string, inputs: Record<string, unknown>) => Promise<GeneratedAnalysisJob>
+  loadResult: (job: GeneratedAnalysisJob) => Promise<GeneratedAnalysisResult | null>
+  resultForJob: (jobId: string) => GeneratedAnalysisResult | null
+  refreshJobs: () => Promise<GeneratedAnalysisJob[]>
+  refresh: () => Promise<GeneratedAnalysisJob[]>
+  getJob: (jobId: string, options?: PluginJobRequestOptions) => Promise<GeneratedAnalysisJob>
+  waitForJob: (
+    job: GeneratedAnalysisJob | string,
+    options?: PluginJobWaitOptions,
+  ) => Promise<GeneratedAnalysisJob>
+  jobsFor: (definitionId: string) => GeneratedAnalysisJob[]
+  cancelJob: (job: GeneratedAnalysisJob | string) => Promise<GeneratedAnalysisJob>
+  deleteJob: (job: GeneratedAnalysisJob | string) => Promise<boolean>
+  clearFinishedJobs: (definitionId?: string) => Promise<number>
+  pause: () => void
+  resume: () => void
+  dispose: () => void
+  /** @deprecated Pass the runtime itself to SDK job UI as its source. */
+  jobsAdapter: JobsStatusTrayAdapter
+}
+
+export type UseGeneratedAnalysisReturn = UsePluginJobsReturn
+
+const ACTIVE_STATUSES = new Set(['awaiting_input', 'queued', 'running'])
+const AUTH_TOKEN_KEY = 'mint-auth-token'
+const SESSION_NOT_FOUND_DETAIL = 'Session not found'
+const MAX_RESULT_CACHE_ENTRIES = 32
+const MAX_RESULT_RETRIES = 3
+const DOWNLOAD_URL_REFRESH_SKEW_MS = 30_000
+
+interface PluginJobWaiter {
+  resolve: (job: GeneratedAnalysisJob) => void
+  reject: (cause: unknown) => void
+  rejectOnFailure: boolean
+  signal?: AbortSignal
+  abort?: () => void
+}
+
+class GeneratedAnalysisRequestError extends Error {
+  constructor(
+    readonly status: number,
+    readonly detail: unknown,
+  ) {
+    super(typeof detail === 'string' ? detail : `Request failed (${status})`)
+    this.name = 'GeneratedAnalysisRequestError'
+  }
+}
+
+export function createGeneratedAnalysisTransport(
+  options: GeneratedAnalysisTransportOptions = {},
+): GeneratedAnalysisTransport {
+  const fetcher = options.fetcher ?? globalThis.fetch.bind(globalThis)
+  const getAccessToken = options.getAccessToken ?? readStoredAccessToken
+
+  return async (input, init = {}) => {
+    const headers = new Headers(init.headers)
+    const accessToken = getAccessToken()
+    if (accessToken && !headers.has('Authorization')) {
+      headers.set('Authorization', `Bearer ${accessToken}`)
+    }
+    return await fetcher(input, {
+      credentials: 'same-origin',
+      ...init,
+      headers,
+    })
+  }
+}
+
+export function useGeneratedAnalysis(
+  options: GeneratedAnalysisOptions,
+): UseGeneratedAnalysisReturn {
+  return createPluginJobs(options, '/generated/manifest')
+}
+
+export function usePluginJobs(
+  options: UsePluginJobsOptions,
+): UsePluginJobsReturn {
+  return createPluginJobs(options)
+}
+
+function createPluginJobs(
+  options: UsePluginJobsOptions,
+  manifestPath?: string,
+): UsePluginJobsReturn {
+  const baseUrl = options.baseUrl.replace(/\/$/, '')
+  const transport = options.transport ?? createGeneratedAnalysisTransport()
+  const storage = createGeneratedSessionStorage(options.storage)
+  const createId = options.createId ?? (() => globalThis.crypto.randomUUID())
+  const pollInterval = options.pollInterval ?? 750
+  const streamEnabled = options.stream ?? true
+  const streamReconnectDelay = options.streamReconnectDelay ?? 1_500
+  const tabKey = `mint:generated:${baseUrl}:tab`
+  const sessionKey = `mint:generated:${baseUrl}:session`
+  const manifest = shallowRef<GeneratedAnalysisManifest | null>(null)
+  const session = shallowRef<GeneratedSession | null>(null)
+  const jobs = shallowRef<GeneratedAnalysisJob[]>([])
+  const jobRevisions = new Map<string, number>()
+  const pendingJobOperations = new Map<string, number>()
+  const resultCache = shallowRef<Record<string, GeneratedAnalysisResult>>({})
+  const isLoading = ref(false)
+  const isSubmitting = ref(false)
+  const error = shallowRef<string | null>(null)
+  const status = shallowRef<'idle' | 'initializing' | 'ready' | 'paused' | 'error' | 'disposed'>('idle')
+  let pollTimer: ReturnType<typeof setTimeout> | undefined
+  let streamReconnectTimer: ReturnType<typeof setTimeout> | undefined
+  let streamController: AbortController | undefined
+  let streamConnected = false
+  let streamConnecting = false
+  let disposed = false
+  let paused = false
+  let initialized = false
+  let initializePromise: Promise<void> | undefined
+  let refreshPromise: Promise<GeneratedAnalysisJob[]> | undefined
+  let initializeRefreshPromise: Promise<GeneratedAnalysisJob[]> | undefined
+  let jobsRevision = 0
+  let resultCacheOrder: string[] = []
+  const resultRequests = new Map<string, Promise<GeneratedAnalysisResult | null>>()
+  const jobWaiters = new Map<string, Set<PluginJobWaiter>>()
+  const resultRetryAttempts = new Map<string, number>()
+  const resultRetryTimers = new Map<string, ReturnType<typeof setTimeout>>()
+  const downloadRefreshTimers = new Map<string, ReturnType<typeof setTimeout>>()
+
+  const latestResult = computed<GeneratedAnalysisResult | null>(() => {
+    const job = currentCompletedJob()
+    return job ? resultForJob(job.job_id) : null
+  })
+
+  function initialize(): Promise<void> {
+    if (disposed) return Promise.reject(new Error('Plugin jobs runtime is disposed'))
+    if (initialized) return Promise.resolve()
+    if (initializePromise) return initializePromise
+    isLoading.value = true
+    error.value = null
+    status.value = 'initializing'
+    const pending = (async () => {
+      if (manifestPath) {
+        const loadedManifest = await request<GeneratedAnalysisManifest>(manifestPath, { method: 'GET' })
+        if (!disposed) manifest.value = loadedManifest
+      }
+      const resolvedSession = await resolveSession()
+      if (disposed) return
+      session.value = resolvedSession
+      await refreshJobs()
+      if (disposed) return
+      initialized = true
+      status.value = paused ? 'paused' : 'ready'
+      if (streamEnabled && !paused) void connectJobStream()
+    })().catch((cause: unknown) => {
+      if (!disposed) {
+        error.value = errorMessage(cause, 'Failed to initialize generated analysis')
+        status.value = 'error'
+      }
+      throw cause
+    }).finally(() => {
+      if (initializePromise === pending) initializePromise = undefined
+      if (!disposed) isLoading.value = false
+    })
+    initializePromise = pending
+    return pending
+  }
+
+  async function resolveSession(): Promise<GeneratedSession> {
+    let tabId = storage.getItem(tabKey)
+    if (!tabId) {
+      tabId = createId()
+      storage.setItem(tabKey, tabId)
+    }
+    const storedSessionId = storage.getItem(sessionKey)
+    const payload = await request<{ sessions: GeneratedSession[] }>('/jobs/sessions', { method: 'GET' })
+    const existing = payload.sessions.find(candidate => (
+      candidate.id === storedSessionId && candidate.tab_id === tabId
+    ))
+    if (existing) return existing
+    const created = await request<GeneratedSession>('/jobs/sessions', {
+      method: 'POST',
+      body: JSON.stringify({ tab_id: tabId }),
+    })
+    storage.setItem(sessionKey, created.id)
+    return created
+  }
+
+  async function submit(
+    definitionId: string,
+    inputs: Record<string, unknown>,
+  ): Promise<GeneratedAnalysisJob> {
+    if (!session.value) throw new Error('Generated analysis session is not initialized')
+    const clientRequestId = createId()
+    isSubmitting.value = true
+    error.value = null
+    try {
+      let jobInput: GeneratedAnalysisJobInput
+      try {
+        jobInput = await submitToSession(
+          session.value.id,
+          clientRequestId,
+          await stagePathInputs(inputs, session.value.id),
+        )
+      } catch (cause) {
+        if (!isSessionNotFoundError(cause)) throw cause
+        session.value = await resolveSession()
+        jobInput = await submitToSession(
+          session.value.id,
+          clientRequestId,
+          await stagePathInputs(inputs, session.value.id),
+        )
+      }
+      const job = upsertJob(jobInput, definitionId)
+      if (!streamConnected) schedulePoll()
+      return job
+    } catch (cause) {
+      error.value = errorMessage(cause, 'Failed to submit analysis')
+      throw cause
+    } finally {
+      isSubmitting.value = false
+    }
+
+    function submitToSession(
+      sessionId: string,
+      requestId: string,
+      stagedInputs: Record<string, unknown>,
+    ): Promise<GeneratedAnalysisJobInput> {
+      return request<GeneratedAnalysisJobInput>('/jobs', {
+        method: 'POST',
+        body: JSON.stringify({
+          definition_id: definitionId,
+          inputs: stagedInputs,
+          session_id: sessionId,
+          client_request_id: requestId,
+        }),
+      })
+    }
+  }
+
+  async function uploadPath(input: PluginJobPathInput): Promise<PluginJobPathUpload> {
+    if (!session.value) throw new Error('Generated analysis session is not initialized')
+    return uploadPathForSession(input, session.value.id)
+  }
+
+  async function uploadStagedPart<Metadata>(
+    input: PluginJobStagedPartInput<Metadata>,
+  ): Promise<PluginJobStagedPartUploadResult<Metadata>> {
+    const jobId = jobIdFromReference(input.job)
+    const body = new FormData()
+    body.append('file', input.file)
+    body.append('metadata', JSON.stringify(input.metadata))
+    if (input.expectedSize !== undefined) {
+      body.append('expected_size', String(input.expectedSize))
+    }
+    if (input.expectedSha256 !== undefined) {
+      body.append('expected_sha256', input.expectedSha256)
+    }
+    return request<PluginJobStagedPartUploadResult<Metadata>>(
+      `/jobs/${encodeURIComponent(jobId)}/parts/${encodeStagedPartKey(input.key)}`,
+      { method: 'PUT', body, signal: input.signal },
+    )
+  }
+
+  function getJobStaging<Metadata = unknown>(
+    job: GeneratedAnalysisJob | string,
+    pagination: PluginJobStagingPagination = {},
+  ): Promise<PluginJobStaging<Metadata>> {
+    const jobId = jobIdFromReference(job)
+    const query = new URLSearchParams()
+    if (pagination.offset !== undefined) query.set('offset', String(pagination.offset))
+    if (pagination.limit !== undefined) query.set('limit', String(pagination.limit))
+    const suffix = query.size > 0 ? `?${query}` : ''
+    return request<PluginJobStaging<Metadata>>(
+      `/jobs/${encodeURIComponent(jobId)}/staging${suffix}`,
+      { method: 'GET' },
+    )
+  }
+
+  async function sealJob(
+    job: GeneratedAnalysisJob | string,
+  ): Promise<GeneratedAnalysisJob> {
+    const jobId = jobIdFromReference(job)
+    const revision = beginJobOperation(jobId)
+    try {
+      const updated = await request<GeneratedAnalysisJobInput>(
+        `/jobs/${encodeURIComponent(jobId)}/seal`,
+        { method: 'POST' },
+      )
+      return mergeJobResponse(updated, revision)
+    } finally {
+      finishJobOperation(jobId)
+    }
+  }
+
+  async function uploadPathForSession(
+    input: PluginJobPathInput,
+    sessionId: string,
+  ): Promise<PluginJobPathUpload> {
+    if (!input.files.length || input.files.length !== input.relativePaths.length) {
+      throw new Error('Path upload requires one relative path for each file')
+    }
+    const body = new FormData()
+    body.append('session_id', sessionId)
+    if (input.rootName) body.append('root_name', input.rootName)
+    for (let index = 0; index < input.files.length; index += 1) {
+      body.append('files', input.files[index]!)
+      body.append('relative_paths', input.relativePaths[index]!)
+    }
+    return request<PluginJobPathUpload>('/jobs/uploads', {
+      method: 'POST',
+      body,
+      signal: input.signal,
+      headers: { 'X-Mint-Job-Session': sessionId },
+    })
+  }
+
+  async function stagePathInputs(
+    inputs: Record<string, unknown>,
+    sessionId: string,
+  ): Promise<Record<string, unknown>> {
+    return await stagePathValue(inputs, sessionId) as Record<string, unknown>
+  }
+
+  async function stagePathValue(value: unknown, sessionId: string): Promise<unknown> {
+    if (typeof File !== 'undefined' && value instanceof File) {
+      const upload = await uploadPathForSession({
+        kind: 'path',
+        files: [value],
+        relativePaths: [value.name],
+      }, sessionId)
+      return { token: upload.token }
+    }
+    if (isPluginJobPathInput(value)) {
+      const upload = await uploadPathForSession(value, sessionId)
+      return { token: upload.token }
+    }
+    if (Array.isArray(value)) {
+      return await Promise.all(value.map(item => stagePathValue(item, sessionId)))
+    }
+    if (value && typeof value === 'object') {
+      const entries = await Promise.all(Object.entries(value).map(async ([key, child]) => (
+        [key, await stagePathValue(child, sessionId)] as const
+      )))
+      return Object.fromEntries(entries)
+    }
+    return value
+  }
+
+  function refreshJobs(): Promise<GeneratedAnalysisJob[]> {
+    if (disposed) return Promise.resolve(jobs.value)
+    if (refreshPromise) return refreshPromise
+    const revision = jobsRevision
+    const pending = request<{ jobs: GeneratedAnalysisJobInput[] }>('/jobs', { method: 'GET' })
+      .then((payload) => {
+        if (disposed || revision !== jobsRevision) return jobs.value
+        replaceJobs(payload.jobs)
+        error.value = null
+        if (!paused && !streamConnected && jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) {
+          schedulePoll()
+        }
+        return jobs.value
+      }).finally(() => {
+        if (refreshPromise === pending) refreshPromise = undefined
+      })
+    refreshPromise = pending
+    return pending
+  }
+
+  function refresh(): Promise<GeneratedAnalysisJob[]> {
+    if (disposed) return Promise.resolve(jobs.value)
+    if (initialized) return refreshJobs()
+    if (initializeRefreshPromise) return initializeRefreshPromise
+    const pending = initialize()
+      .then(() => jobs.value)
+      .finally(() => {
+        if (initializeRefreshPromise === pending) initializeRefreshPromise = undefined
+      })
+    initializeRefreshPromise = pending
+    return pending
+  }
+
+  async function getJob(
+    jobId: string,
+    options: PluginJobRequestOptions = {},
+  ): Promise<GeneratedAnalysisJob> {
+    const revision = beginJobOperation(jobId)
+    try {
+      const job = await request<GeneratedAnalysisJobInput>(
+        `/jobs/${encodeURIComponent(jobId)}`,
+        { method: 'GET', signal: options.signal },
+      )
+      return mergeJobResponse(job, revision)
+    } finally {
+      finishJobOperation(jobId)
+    }
+  }
+
+  function waitForJob(
+    job: GeneratedAnalysisJob | string,
+    options: PluginJobWaitOptions = {},
+  ): Promise<GeneratedAnalysisJob> {
+    if (disposed) return Promise.reject(new Error('Plugin jobs runtime is disposed'))
+    if (options.signal?.aborted) {
+      return Promise.reject(pluginJobWaitAbort(options.signal))
+    }
+    const jobId = jobIdFromReference(job)
+    const current = typeof job === 'string'
+      ? jobs.value.find(candidate => candidate.job_id === jobId)
+      : jobs.value.find(candidate => candidate.job_id === jobId) ?? job
+    if (current && !ACTIVE_STATUSES.has(current.status)) {
+      return terminalWaitResult(current, options.rejectOnFailure === true)
+    }
+    if (paused) return Promise.reject(new Error('Plugin jobs runtime is paused'))
+    return new Promise<GeneratedAnalysisJob>((resolve, reject) => {
+      const waiter: PluginJobWaiter = {
+        resolve,
+        reject,
+        rejectOnFailure: options.rejectOnFailure === true,
+        signal: options.signal,
+      }
+      if (options.signal) {
+        waiter.abort = () => {
+          removeJobWaiter(jobId, waiter)
+          reject(pluginJobWaitAbort(options.signal!))
+        }
+        options.signal.addEventListener('abort', waiter.abort, { once: true })
+      }
+      const waiting = jobWaiters.get(jobId) ?? new Set<PluginJobWaiter>()
+      waiting.add(waiter)
+      jobWaiters.set(jobId, waiting)
+      if (!paused) {
+        if (streamEnabled) void connectJobStream()
+        if (!streamConnected) schedulePoll()
+      }
+      void getJob(jobId, { signal: options.signal }).catch((cause: unknown) => {
+        if (current && isRetryableJobLookupError(cause)) {
+          if (!streamConnected) schedulePoll()
+          return
+        }
+        removeJobWaiter(jobId, waiter)
+        reject(cause)
+      })
+    })
+  }
+
+  function settleJobWaiters(job: GeneratedAnalysisJob): void {
+    if (ACTIVE_STATUSES.has(job.status)) return
+    const waiting = jobWaiters.get(job.job_id)
+    if (!waiting) return
+    jobWaiters.delete(job.job_id)
+    for (const waiter of waiting) {
+      if (waiter.abort && waiter.signal) {
+        waiter.signal.removeEventListener('abort', waiter.abort)
+      }
+      void terminalWaitResult(job, waiter.rejectOnFailure).then(
+        waiter.resolve,
+        waiter.reject,
+      )
+    }
+  }
+
+  function rejectJobWaiters(jobId: string, cause: unknown): void {
+    const waiting = jobWaiters.get(jobId)
+    if (!waiting) return
+    jobWaiters.delete(jobId)
+    for (const waiter of waiting) {
+      if (waiter.abort && waiter.signal) {
+        waiter.signal.removeEventListener('abort', waiter.abort)
+      }
+      waiter.reject(cause)
+    }
+  }
+
+  function removeJobWaiter(jobId: string, waiter: PluginJobWaiter): void {
+    const waiting = jobWaiters.get(jobId)
+    if (!waiting) return
+    waiting.delete(waiter)
+    if (waiting.size === 0) jobWaiters.delete(jobId)
+    if (waiter.abort && waiter.signal) {
+      waiter.signal.removeEventListener('abort', waiter.abort)
+    }
+  }
+
+  function jobsFor(definitionId: string): GeneratedAnalysisJob[] {
+    return jobs.value.filter(job => job.definition_id === definitionId)
+  }
+
+  function canonicalJob(
+    input: GeneratedAnalysisJobInput,
+    fallbackDefinitionId?: string,
+  ): GeneratedAnalysisJob {
+    const normalized = normalizeJobState(input)
+    const definitionId = normalized.definition_id ?? fallbackDefinitionId ?? null
+    return {
+      ...normalized,
+      definition_id: definitionId,
+      metadata: definitionId
+        ? { ...normalized.metadata, definition_id: definitionId }
+        : normalized.metadata,
+    }
+  }
+
+  function recordJobsMutation(jobIds: Iterable<string>): void {
+    jobsRevision += 1
+    for (const jobId of jobIds) {
+      jobRevisions.set(jobId, (jobRevisions.get(jobId) ?? 0) + 1)
+    }
+  }
+
+  function beginJobOperation(jobId: string): number {
+    pendingJobOperations.set(jobId, (pendingJobOperations.get(jobId) ?? 0) + 1)
+    return jobRevisions.get(jobId) ?? 0
+  }
+
+  function finishJobOperation(jobId: string): void {
+    const remaining = (pendingJobOperations.get(jobId) ?? 1) - 1
+    if (remaining > 0) pendingJobOperations.set(jobId, remaining)
+    else pendingJobOperations.delete(jobId)
+    pruneJobRevisions()
+  }
+
+  function pruneJobRevisions(): void {
+    const retained = new Set([
+      ...jobs.value.map(job => job.job_id),
+      ...pendingJobOperations.keys(),
+    ])
+    for (const jobId of jobRevisions.keys()) {
+      if (!retained.has(jobId)) jobRevisions.delete(jobId)
+    }
+  }
+
+  function replaceJobs(inputs: readonly GeneratedAnalysisJobInput[]): GeneratedAnalysisJob[] {
+    const previousJobs = new Map(jobs.value.map(job => [job.job_id, job]))
+    const previousJobIds = new Set(jobs.value.map(job => job.job_id))
+    const nextJobs = inputs.map((input) => {
+      const incoming = canonicalJob(input)
+      const current = previousJobs.get(incoming.job_id)
+      return current && shouldPreserveJobLifecycle(current, incoming) ? current : incoming
+    })
+    const nextJobIds = new Set(nextJobs.map(job => job.job_id))
+    recordJobsMutation(new Set([
+      ...previousJobIds,
+      ...nextJobIds,
+    ]))
+    jobs.value = nextJobs
+    for (const job of nextJobs) settleJobWaiters(job)
+    for (const jobId of previousJobIds) {
+      if (!nextJobIds.has(jobId)) {
+        rejectJobWaiters(jobId, new Error(`Job ${jobId} is no longer available`))
+      }
+    }
+    pruneResultState()
+    pruneJobRevisions()
+    return nextJobs
+  }
+
+  function upsertJob(
+    input: GeneratedAnalysisJobInput,
+    fallbackDefinitionId?: string,
+  ): GeneratedAnalysisJob {
+    const incoming = canonicalJob(input, fallbackDefinitionId)
+    const current = jobs.value.find(candidate => candidate.job_id === incoming.job_id)
+    const job = current && shouldPreserveJobLifecycle(current, incoming)
+      ? current
+      : incoming
+    if (job === current) {
+      settleJobWaiters(job)
+      pruneResultState()
+      pruneJobRevisions()
+      return job
+    }
+    jobs.value = [job, ...jobs.value.filter(candidate => candidate.job_id !== job.job_id)]
+    recordJobsMutation([job.job_id])
+    settleJobWaiters(job)
+    pruneResultState()
+    pruneJobRevisions()
+    return job
+  }
+
+  function mergeJobResponse(
+    input: GeneratedAnalysisJobInput,
+    expectedRevision: number,
+  ): GeneratedAnalysisJob {
+    const incoming = canonicalJob(input)
+    const current = jobs.value.find(candidate => candidate.job_id === incoming.job_id)
+    if (disposed) return current ?? incoming
+    if (current && shouldPreserveJobLifecycle(current, incoming)) return current
+    if (expectedRevision === (jobRevisions.get(incoming.job_id) ?? 0)) {
+      return upsertJob(incoming)
+    }
+    if (current && jobLifecycleRank(incoming.status) > jobLifecycleRank(current.status)) {
+      return upsertJob(incoming)
+    }
+    return current ?? incoming
+  }
+
+  function currentCompletedJob(): GeneratedAnalysisJob | undefined {
+    const activeSessionId = session.value?.id
+    return jobs.value.find(candidate => (
+      candidate.session_id === activeSessionId
+      && candidate.status === 'completed'
+      && candidate.result_status === 'available'
+    ))
+  }
+
+  function resultForJob(jobId: string): GeneratedAnalysisResult | null {
+    return resultCache.value[jobId] ?? null
+  }
+
+  function loadResult(job: GeneratedAnalysisJob): Promise<GeneratedAnalysisResult | null> {
+    return loadResultInternal(job)
+  }
+
+  function loadResultInternal(
+    job: GeneratedAnalysisJob,
+    forceRefresh = false,
+  ): Promise<GeneratedAnalysisResult | null> {
+    if (
+      disposed
+      || !isLoadableResultJob(job)
+    ) return Promise.resolve(null)
+
+    const cached = resultForJob(job.job_id)
+    if (cached && !forceRefresh && !managedDownloadNeedsRefresh(cached)) {
+      return Promise.resolve(cached)
+    }
+    const pending = resultRequests.get(job.job_id)
+    if (pending) return pending
+
+    const requestResult = request<GeneratedAnalysisResult>(
+      `/jobs/${encodeURIComponent(job.job_id)}/result`,
+      { method: 'GET' },
+    ).then((result) => {
+      if (!disposed && isCurrentResultJob(job.job_id)) {
+        cacheResult(job.job_id, result)
+        clearResultRetry(job.job_id)
+        error.value = null
+      }
+      return result
+    }).catch((cause: unknown) => {
+      if (!disposed && isCurrentResultJob(job.job_id)) {
+        error.value = errorMessage(cause, 'Failed to load analysis result')
+        if (cached && isManagedDownloadResult(cached)) {
+          handleManagedDownloadRefreshFailure(job, cause)
+        } else {
+          scheduleResultRetry(job, cause)
+        }
+      }
+      return null
+    }).finally(() => {
+      resultRequests.delete(job.job_id)
+    })
+    resultRequests.set(job.job_id, requestResult)
+    return requestResult
+  }
+
+  function cacheResult(jobId: string, result: GeneratedAnalysisResult): void {
+    resultCacheOrder = [jobId, ...resultCacheOrder.filter(candidate => candidate !== jobId)]
+      .slice(0, MAX_RESULT_CACHE_ENTRIES)
+    const retained = new Set(resultCacheOrder)
+    resultCache.value = Object.fromEntries([
+      ...Object.entries(resultCache.value)
+        .filter(([candidate]) => retained.has(candidate) && candidate !== jobId),
+      [jobId, result],
+    ])
+    for (const candidate of downloadRefreshTimers.keys()) {
+      if (!retained.has(candidate)) clearManagedDownloadRefresh(candidate)
+    }
+    scheduleManagedDownloadRefresh(jobId, managedDownloadRefreshDelay(result))
+  }
+
+  function pruneResultState(): void {
+    const loadableJobIds = new Set(jobs.value
+      .filter(job => isLoadableResultJob(job))
+      .map(job => job.job_id))
+    resultCacheOrder = resultCacheOrder
+      .filter(jobId => loadableJobIds.has(jobId))
+      .slice(0, MAX_RESULT_CACHE_ENTRIES)
+    const retained = new Set(resultCacheOrder)
+    resultCache.value = Object.fromEntries(
+      Object.entries(resultCache.value).filter(([jobId]) => retained.has(jobId)),
+    )
+    for (const jobId of resultRetryTimers.keys()) {
+      if (!loadableJobIds.has(jobId)) clearResultRetry(jobId)
+    }
+    for (const jobId of resultRetryAttempts.keys()) {
+      if (!loadableJobIds.has(jobId)) clearResultRetry(jobId)
+    }
+    for (const jobId of downloadRefreshTimers.keys()) {
+      if (!loadableJobIds.has(jobId) || !retained.has(jobId)) {
+        clearManagedDownloadRefresh(jobId)
+      }
+    }
+  }
+
+  function scheduleManagedDownloadRefresh(jobId: string, delay: number | null): void {
+    clearManagedDownloadRefresh(jobId)
+    if (delay === null || disposed || paused) return
+    downloadRefreshTimers.set(jobId, setTimeout(() => {
+      downloadRefreshTimers.delete(jobId)
+      if (disposed || paused) return
+      const current = jobs.value.find(candidate => candidate.job_id === jobId)
+      if (current && isLoadableResultJob(current)) {
+        void loadResultInternal(current, true)
+      }
+    }, Math.max(0, delay)))
+  }
+
+  function clearManagedDownloadRefresh(jobId: string): void {
+    const timer = downloadRefreshTimers.get(jobId)
+    if (timer !== undefined) clearTimeout(timer)
+    downloadRefreshTimers.delete(jobId)
+  }
+
+  function handleManagedDownloadRefreshFailure(
+    job: GeneratedAnalysisJob,
+    cause: unknown,
+  ): void {
+    if (cause instanceof GeneratedAnalysisRequestError) {
+      if (cause.status === 404 || cause.status === 410) {
+        discardCachedResult(job.job_id)
+        jobs.value = jobs.value.map(candidate => (
+          candidate.job_id === job.job_id
+            ? { ...candidate, result_status: 'expired' }
+            : candidate
+        ))
+        recordJobsMutation([job.job_id])
+        return
+      }
+      if (cause.status === 401 || cause.status === 403) {
+        discardCachedResult(job.job_id)
+        return
+      }
+    }
+    scheduleResultRetry(job, cause, true)
+  }
+
+  function discardCachedResult(jobId: string): void {
+    clearResultRetry(jobId)
+    clearManagedDownloadRefresh(jobId)
+    resultCacheOrder = resultCacheOrder.filter(candidate => candidate !== jobId)
+    const retainedResults = { ...resultCache.value }
+    delete retainedResults[jobId]
+    resultCache.value = retainedResults
+  }
+
+  function isLoadableResultJob(job: GeneratedAnalysisJob): boolean {
+    return job.status === 'completed'
+      && job.result_status === 'available'
+  }
+
+  function isCurrentResultJob(jobId: string): boolean {
+    const job = jobs.value.find(candidate => candidate.job_id === jobId)
+    return job !== undefined && isLoadableResultJob(job)
+  }
+
+  function scheduleResultRetry(
+    job: GeneratedAnalysisJob,
+    cause: unknown,
+    forceRefresh = false,
+  ): void {
+    if (
+      paused
+      || !isRetryableResultError(cause)
+      || resultRetryTimers.has(job.job_id)
+    ) return
+    const attempt = resultRetryAttempts.get(job.job_id) ?? 0
+    if (attempt >= MAX_RESULT_RETRIES) return
+    resultRetryAttempts.set(job.job_id, attempt + 1)
+    resultRetryTimers.set(job.job_id, setTimeout(() => {
+      resultRetryTimers.delete(job.job_id)
+      const current = jobs.value.find(candidate => candidate.job_id === job.job_id)
+      if (!paused && current && isLoadableResultJob(current)) {
+        void loadResultInternal(current, forceRefresh)
+      }
+    }, pollInterval * (2 ** attempt)))
+  }
+
+  function clearResultRetry(jobId: string): void {
+    const timer = resultRetryTimers.get(jobId)
+    if (timer !== undefined) clearTimeout(timer)
+    resultRetryTimers.delete(jobId)
+    resultRetryAttempts.delete(jobId)
+  }
+
+  function schedulePoll(): void {
+    if (disposed || paused || streamConnected || pollTimer !== undefined) return
+    pollTimer = setTimeout(async () => {
+      pollTimer = undefined
+      if (disposed) return
+      try {
+        await refreshJobs()
+      } catch (cause) {
+        error.value = errorMessage(cause, 'Failed to refresh analysis jobs')
+        if (jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) schedulePoll()
+      }
+    }, pollInterval)
+  }
+
+  async function connectJobStream(): Promise<void> {
+    if (disposed || paused || streamConnecting || streamConnected) return
+    streamConnecting = true
+    streamController = new AbortController()
+    try {
+      const response = await transport(`${baseUrl}/jobs/events`, {
+        method: 'GET',
+        headers: { Accept: 'text/event-stream' },
+        signal: streamController.signal,
+      })
+      if (!response.ok) throw new Error(`Job stream failed (${response.status})`)
+      if (!response.body) throw new Error('Job stream response has no readable body')
+      streamConnected = true
+      if (pollTimer !== undefined) {
+        clearTimeout(pollTimer)
+        pollTimer = undefined
+      }
+      await consumeJobStream(response.body)
+    } catch (cause) {
+      if (!isAbortError(cause) && !disposed) {
+        if (jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) schedulePoll()
+      }
+    } finally {
+      streamConnected = false
+      streamConnecting = false
+      streamController = undefined
+      if (!disposed && !paused) scheduleStreamReconnect()
+    }
+  }
+
+  async function consumeJobStream(body: ReadableStream<Uint8Array>): Promise<void> {
+    const reader = body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+    try {
+      while (!disposed) {
+        const { done, value } = await reader.read()
+        buffer += decoder.decode(value, { stream: !done })
+        const blocks = buffer.split(/\r?\n\r?\n/)
+        buffer = blocks.pop() ?? ''
+        for (const block of blocks) applyJobStreamEvent(block)
+        if (done) {
+          if (buffer.trim()) applyJobStreamEvent(buffer)
+          return
+        }
+      }
+    } finally {
+      reader.releaseLock()
+    }
+  }
+
+  function applyJobStreamEvent(block: string): void {
+    let event = 'message'
+    const data: string[] = []
+    for (const line of block.split(/\r?\n/)) {
+      if (!line || line.startsWith(':')) continue
+      if (line.startsWith('event:')) event = line.slice('event:'.length).trim()
+      if (line.startsWith('data:')) data.push(line.slice('data:'.length).trimStart())
+    }
+    if (!data.length) return
+    const payload = JSON.parse(data.join('\n')) as (
+      GeneratedAnalysisJobInput | { jobs: GeneratedAnalysisJobInput[] }
+    )
+    if (event === 'snapshot' && 'jobs' in payload) {
+      replaceJobs(payload.jobs)
+    } else if (event === 'job' || event === 'terminal') {
+      upsertJob(payload as GeneratedAnalysisJobInput)
+    }
+    error.value = null
+  }
+
+  function scheduleStreamReconnect(): void {
+    if (disposed || paused || streamReconnectTimer !== undefined) return
+    streamReconnectTimer = setTimeout(() => {
+      streamReconnectTimer = undefined
+      void connectJobStream()
+    }, streamReconnectDelay)
+  }
+
+  async function cancelJob(job: GeneratedAnalysisJob | string): Promise<GeneratedAnalysisJob> {
+    const jobId = typeof job === 'string' ? job : job.job_id
+    const revision = beginJobOperation(jobId)
+    try {
+      const updated = await request<GeneratedAnalysisJobInput>(
+        `/jobs/${encodeURIComponent(jobId)}/cancel`,
+        { method: 'POST' },
+      )
+      return mergeJobResponse(updated, revision)
+    } finally {
+      finishJobOperation(jobId)
+    }
+  }
+
+  async function deleteJob(job: GeneratedAnalysisJob | string): Promise<boolean> {
+    const jobId = typeof job === 'string' ? job : job.job_id
+    await request<{ status: 'deleted' }>(
+      `/jobs/${encodeURIComponent(jobId)}`,
+      { method: 'DELETE' },
+    )
+    jobs.value = jobs.value.filter(candidate => candidate.job_id !== jobId)
+    recordJobsMutation([jobId])
+    rejectJobWaiters(jobId, new Error(`Job ${jobId} was deleted`))
+    discardCachedResult(jobId)
+    pruneJobRevisions()
+    return true
+  }
+
+  async function clearFinishedJobs(definitionId?: string): Promise<number> {
+    const query = definitionId === undefined
+      ? ''
+      : `?definition_id=${encodeURIComponent(definitionId)}`
+    const payload = await request<{ deleted: number }>(`/jobs${query}`, { method: 'DELETE' })
+    if (payload.deleted > 0) await refreshJobs()
+    return payload.deleted
+  }
+
+  const jobsAdapter: JobsStatusTrayAdapter = {
+    listJobs: async () => ({ jobs: await refreshJobs() }),
+    cancelJob: async job => cancelJob(job as GeneratedAnalysisJob),
+    deleteJob: async job => deleteJob(job as GeneratedAnalysisJob),
+    clearFinishedJobs: async () => clearFinishedJobs(),
+  }
+  function pause(): void {
+    if (disposed || paused) return
+    paused = true
+    status.value = 'paused'
+    if (pollTimer !== undefined) clearTimeout(pollTimer)
+    if (streamReconnectTimer !== undefined) clearTimeout(streamReconnectTimer)
+    pollTimer = undefined
+    streamReconnectTimer = undefined
+    for (const jobId of resultRetryTimers.keys()) clearResultRetry(jobId)
+    for (const jobId of downloadRefreshTimers.keys()) {
+      clearManagedDownloadRefresh(jobId)
+    }
+    streamController?.abort()
+  }
+
+  function resume(): void {
+    if (disposed || !paused) return
+    paused = false
+    status.value = initialized ? 'ready' : 'idle'
+    if (!initialized) return
+    for (const [jobId, result] of Object.entries(resultCache.value)) {
+      scheduleManagedDownloadRefresh(jobId, managedDownloadRefreshDelay(result))
+    }
+    if (streamEnabled) void connectJobStream()
+    else if (jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) schedulePoll()
+  }
+
+  function dispose(): void {
+    if (disposed) return
+    disposed = true
+    paused = true
+    status.value = 'disposed'
+    if (pollTimer !== undefined) clearTimeout(pollTimer)
+    if (streamReconnectTimer !== undefined) clearTimeout(streamReconnectTimer)
+    pollTimer = undefined
+    streamReconnectTimer = undefined
+    for (const timer of resultRetryTimers.values()) clearTimeout(timer)
+    resultRetryTimers.clear()
+    resultRetryAttempts.clear()
+    for (const timer of downloadRefreshTimers.values()) clearTimeout(timer)
+    downloadRefreshTimers.clear()
+    const cause = new Error('Plugin jobs runtime is disposed')
+    for (const jobId of jobWaiters.keys()) rejectJobWaiters(jobId, cause)
+    jobRevisions.clear()
+    pendingJobOperations.clear()
+    streamController?.abort()
+  }
+
+  async function request<T>(path: string, init: RequestInit): Promise<T> {
+    const response = await transport(`${baseUrl}${path}`, {
+      ...init,
+      headers: {
+        Accept: 'application/json',
+        ...(init.body && !(init.body instanceof FormData)
+          ? { 'Content-Type': 'application/json' }
+          : {}),
+        ...init.headers,
+      },
+    })
+    if (!response.ok) {
+      const payload = await response.json().catch(() => null) as { detail?: unknown } | null
+      throw new GeneratedAnalysisRequestError(response.status, payload?.detail)
+    }
+    return await response.json() as T
+  }
+
+  onScopeDispose(dispose)
+
+  if (options.immediate) void initialize().catch(() => undefined)
+
+  return {
+    manifest,
+    session,
+    jobs,
+    latestResult,
+    isLoading,
+    isSubmitting,
+    error,
+    status,
+    initialize,
+    ready: initialize,
+    uploadPath,
+    uploadStagedPart,
+    getJobStaging,
+    sealJob,
+    submit,
+    loadResult,
+    resultForJob,
+    refreshJobs,
+    refresh,
+    getJob,
+    waitForJob,
+    jobsFor,
+    cancelJob,
+    deleteJob,
+    clearFinishedJobs,
+    pause,
+    resume,
+    dispose,
+    jobsAdapter,
+  }
+}
+
+function jobIdFromReference(job: GeneratedAnalysisJob | string): string {
+  return typeof job === 'string' ? job : job.job_id
+}
+
+function encodeStagedPartKey(key: string): string {
+  return key.split('/').map(segment => encodeURIComponent(segment)).join('/')
+}
+
+function jobLifecycleRank(status: GeneratedAnalysisJob['status']): number {
+  if (status === 'awaiting_input') return 0
+  if (status === 'queued') return 1
+  if (status === 'running') return 2
+  return 3
+}
+
+function shouldPreserveJobLifecycle(
+  current: GeneratedAnalysisJob,
+  incoming: GeneratedAnalysisJob,
+): boolean {
+  const currentRank = jobLifecycleRank(current.status)
+  const incomingRank = jobLifecycleRank(incoming.status)
+  return incomingRank < currentRank
+    || (currentRank === 3 && incomingRank === 3 && current.status !== incoming.status)
+}
+
+function terminalWaitResult(
+  job: GeneratedAnalysisJob,
+  rejectOnFailure: boolean,
+): Promise<GeneratedAnalysisJob> {
+  if (rejectOnFailure && (job.status === 'failed' || job.status === 'cancelled')) {
+    return Promise.reject(new Error(job.error ?? `Job ${job.job_id} ${job.status}`))
+  }
+  return Promise.resolve(job)
+}
+
+function pluginJobWaitAbort(signal: AbortSignal): unknown {
+  if (signal.reason !== undefined) return signal.reason
+  const cause = new Error('Waiting for job was aborted')
+  cause.name = 'AbortError'
+  return cause
+}
+
+function isPluginJobPathInput(value: unknown): value is PluginJobPathInput {
+  return Boolean(
+    value
+    && typeof value === 'object'
+    && 'kind' in value
+    && value.kind === 'path'
+    && 'files' in value
+    && Array.isArray(value.files)
+    && 'relativePaths' in value
+    && Array.isArray(value.relativePaths),
+  )
+}
+
+function readStoredAccessToken(): string | null {
+  try {
+    return globalThis.localStorage?.getItem(AUTH_TOKEN_KEY) ?? null
+  } catch {
+    return null
+  }
+}
+
+function createGeneratedSessionStorage(candidate?: Storage): GeneratedSessionStorage {
+  const fallback = new Map<string, string>()
+  let delegate: Storage | undefined
+  let available = true
+  try {
+    delegate = candidate ?? globalThis.sessionStorage
+  } catch {
+    available = false
+  }
+  return {
+    getItem(key) {
+      if (available && delegate) {
+        try {
+          return delegate.getItem(key) ?? fallback.get(key) ?? null
+        } catch {
+          available = false
+        }
+      }
+      return fallback.get(key) ?? null
+    },
+    setItem(key, value) {
+      fallback.set(key, value)
+      if (available && delegate) {
+        try {
+          delegate.setItem(key, value)
+        } catch {
+          available = false
+        }
+      }
+    },
+  }
+}
+
+function isAbortError(error: unknown): boolean {
+  return error instanceof DOMException && error.name === 'AbortError'
+}
+
+function isSessionNotFoundError(error: unknown): boolean {
+  return error instanceof GeneratedAnalysisRequestError
+    && error.status === 404
+    && error.detail === SESSION_NOT_FOUND_DETAIL
+}
+
+function isRetryableResultError(error: unknown): boolean {
+  return !(error instanceof GeneratedAnalysisRequestError)
+    || error.status === 409
+    || error.status === 429
+    || error.status >= 500
+}
+
+function isRetryableJobLookupError(error: unknown): boolean {
+  return !(error instanceof GeneratedAnalysisRequestError)
+    || error.status === 408
+    || error.status === 429
+    || error.status >= 500
+}
+
+function isManagedDownloadResult(
+  result: GeneratedAnalysisResult,
+): result is Extract<GeneratedAnalysisResult, { kind: 'artifact' }> {
+  return result.kind === 'artifact' && result.managed === true
+}
+
+function managedDownloadNeedsRefresh(result: GeneratedAnalysisResult): boolean {
+  if (!isManagedDownloadResult(result)) return false
+  if (!result.download_url || !result.download_expires_at) return true
+  const expiresAt = Date.parse(result.download_expires_at)
+  return !Number.isFinite(expiresAt)
+    || expiresAt <= Date.now() + DOWNLOAD_URL_REFRESH_SKEW_MS
+}
+
+function managedDownloadRefreshDelay(result: GeneratedAnalysisResult): number | null {
+  if (!isManagedDownloadResult(result)) return null
+  if (!result.download_url || !result.download_expires_at) return null
+  const expiresAt = Date.parse(result.download_expires_at)
+  if (!Number.isFinite(expiresAt)) return null
+  const remaining = expiresAt - Date.now()
+  return remaining <= DOWNLOAD_URL_REFRESH_SKEW_MS
+    ? remaining
+    : remaining - DOWNLOAD_URL_REFRESH_SKEW_MS
+}
+
+function errorMessage(error: unknown, fallback: string): string {
+  return error instanceof Error ? error.message : fallback
+}