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

package/src/composables/useFileBrowser.ts

@@ -19,9 +19,10 @@ import type {
   FileSelection,
   ServerMount,
 } from '../types/fileBrowserTypes'
+import { MintApiError } from '../apiErrors'
 import { useApi } from './useApi'
 import { getInjectedPlatformContext } from './platformContextHelpers'
-import { useRequestSyncState } from './useRequestSyncState'
+import { useRequest } from './useRequest'
 
 export interface UseFileBrowserOptions {
   /** Extensions the caller cares about; entries are flagged, never removed. */
@@ -78,7 +79,7 @@ export interface UseFileBrowserReturn {
 export function useFileBrowser(options: UseFileBrowserOptions = {}): UseFileBrowserReturn {
   const injectedContext = getInjectedPlatformContext()
   const api = useApi({ baseUrl: options.apiBaseUrl ?? injectedContext?.platformApiUrl })
-  const sync = useRequestSyncState('Could not read the server mounts.')
+  const sync = useRequest('Could not read the server mounts.')
 
   const mounts = ref<ServerMount[]>([])
   const mountId = shallowRef('')
@@ -121,18 +122,12 @@ export function useFileBrowser(options: UseFileBrowserOptions = {}): UseFileBrow
     return rules.map((rule) => `&type_rules=${encodeURIComponent(rule)}`).join('')
   }
 
-  /** Prefer the API's own `detail` over axios's "Request failed with status N". */
-  function describe(cause: unknown, fallback: string): string {
-    const detail = (cause as { response?: { data?: { detail?: unknown } } })?.response?.data?.detail
-    return typeof detail === 'string' && detail ? detail : sync.readErrorMessage(cause, fallback)
-  }
-
   function fail(cause: unknown, fallback: string): void {
-    sync.setError(new Error(describe(cause, fallback)), fallback)
+    sync.setError(new Error(sync.readErrorMessage(cause, fallback)), fallback)
   }
 
   function statusOf(cause: unknown): number | undefined {
-    return (cause as { response?: { status?: number } })?.response?.status
+    return cause instanceof MintApiError ? cause.status : undefined
   }
 
   async function loadMounts(): Promise<boolean> {
@@ -147,7 +142,6 @@ export function useFileBrowser(options: UseFileBrowserOptions = {}): UseFileBrow
       if (disposed || token !== mountsToken) return false
       mounts.value = data.mounts ?? []
       sync.clearError()
-      sync.markLoaded()
       return true
     } catch (cause) {
       if (disposed || token !== mountsToken) return false
@@ -156,7 +150,6 @@ export function useFileBrowser(options: UseFileBrowserOptions = {}): UseFileBrow
       if (statusOf(cause) === 404) {
         mounts.value = []
         sync.clearError()
-        sync.markLoaded()
         return true
       }
       mounts.value = []
@@ -201,7 +194,6 @@ export function useFileBrowser(options: UseFileBrowserOptions = {}): UseFileBrow
       truncated.value = listing.truncated ?? false
       listingReady.value = true
       sync.clearError()
-      sync.markLoaded()
     } catch (cause) {
       if (disposed || token !== listToken) return
       entries.value = []

package/src/composables/useFilePicker.ts

@@ -8,7 +8,7 @@ import type {
   PickerSort,
   PickerSource,
 } from '../types/filePicker'
-import type { SegmentedOption } from '../types'
+import type { OptionPrimitive, SelectOption } from '../types'
 import { usePickerNavigation } from './filePicker/usePickerNavigation'
 import { usePickerSelection } from './filePicker/usePickerSelection'
 import { localFilesAdapter } from './filePicker/localFiles'
@@ -78,7 +78,7 @@ export function useFilePicker(
   const mountView = computed(
     () => source.value === 'server' && !!props.adapter.mounts && mounts.value.length > 0,
   )
-  const segments = computed<SegmentedOption[]>(() =>
+  const segments = computed<SelectOption<OptionPrimitive>[]>(() =>
     allowedSources.value.flatMap((item) =>
       item === 'server' && props.adapter.mounts && mounts.value.length
         ? mounts.value.map((mount) => ({

package/src/composables/useFormBuilder.ts

@@ -107,10 +107,9 @@ export function useFormBuilder<T extends Record<string, unknown> = Record<string
     }
     merged.onBlur = formProps.onBlur
 
-    // Error as boolean for components that use boolean error prop
-    const errorMsg = formProps.error
-    if (errorMsg) {
-      merged.error = true
+    // A field with an error message renders its control as invalid
+    if (formProps.error) {
+      merged.invalid = true
     }
 
     // Schema-level props

package/src/composables/useJobCenter.ts

@@ -0,0 +1,324 @@
+import {
+  computed,
+  onMounted,
+  onUnmounted,
+  ref,
+  shallowRef,
+  toValue,
+  type ComputedRef,
+  type MaybeRefOrGetter,
+  type Ref,
+  type ShallowRef,
+} from 'vue'
+
+import { isActiveJobStatus, normalizeJobState } from '../jobs'
+import type {
+  JobListPayload,
+  JobState,
+  JobStateInput,
+} from '../types/jobs'
+
+export type JobsStatusTrayTab = 'active' | 'history'
+
+/**
+ * The canonical owner of a collection of plugin jobs.
+ *
+ * Sources, rather than job-center UI, own polling, event streams, and all job
+ * mutations. This keeps components and consumers on one reactive job graph.
+ */
+export interface PluginJobCenterSource {
+  jobs: MaybeRefOrGetter<readonly JobStateInput[]>
+  refresh?: () => Promise<JobListPayload | readonly JobStateInput[] | void>
+  cancel?: (jobId: string) => Promise<JobStateInput | void>
+  delete?: (jobId: string) => Promise<boolean | void>
+  clear?: () => Promise<number | void>
+  dispose?: () => void
+}
+
+export interface CombinedPluginJobCenterSource extends PluginJobCenterSource {
+  jobs: ComputedRef<readonly JobStateInput[]>
+}
+
+/**
+ * Combines independent job runtimes without copying their reactive state.
+ *
+ * Job ids must be globally unique across the sources. A duplicate id throws
+ * when jobs are read or an id-routed action is requested, rather than silently
+ * dispatching a mutation to the wrong owner.
+ */
+export function combinePluginJobSources(
+  sources: readonly PluginJobCenterSource[],
+): CombinedPluginJobCenterSource {
+  const jobs = computed<readonly JobStateInput[]>(() => {
+    const combined: JobStateInput[] = []
+    const owners = new Set<string>()
+    for (const source of sources) {
+      for (const job of toValue(source.jobs)) {
+        if (owners.has(job.job_id)) throw duplicatePluginJobId(job.job_id)
+        owners.add(job.job_id)
+        combined.push(job)
+      }
+    }
+    return combined
+  })
+
+  function ownerFor(jobId: string): PluginJobCenterSource {
+    let owner: PluginJobCenterSource | undefined
+    for (const source of sources) {
+      if (!toValue(source.jobs).some(job => job.job_id === jobId)) continue
+      if (owner) throw duplicatePluginJobId(jobId)
+      owner = source
+    }
+    if (!owner) throw new Error(`Unknown plugin job id: ${jobId}`)
+    return owner
+  }
+
+  const combined: CombinedPluginJobCenterSource = { jobs }
+  if (sources.some(source => source.refresh)) {
+    combined.refresh = async () => {
+      await Promise.all(sources.map(source => source.refresh?.()))
+      return jobs.value
+    }
+  }
+  if (sources.some(source => source.cancel)) {
+    combined.cancel = async (jobId) => {
+      const owner = ownerFor(jobId)
+      if (!owner.cancel) throw new Error(`Job ${jobId} cannot be cancelled by its source`)
+      return owner.cancel(jobId)
+    }
+  }
+  if (sources.length > 0 && sources.every(source => source.delete)) {
+    combined.delete = async (jobId) => {
+      const owner = ownerFor(jobId)
+      if (!owner.delete) throw new Error(`Job ${jobId} cannot be deleted by its source`)
+      return owner.delete(jobId)
+    }
+  }
+  // Never report a successful combined clear after mutating only a subset.
+  // Without bulk support from every source, the job center can still fall
+  // back to this source's id-routed delete method when all owners expose it.
+  if (sources.length > 0 && sources.every(source => source.clear)) {
+    combined.clear = async () => {
+      const results = await Promise.all(
+        sources.map(source => source.clear!()),
+      )
+      return results.every((result): result is number => typeof result === 'number')
+        ? results.reduce((total, result) => total + result, 0)
+        : undefined
+    }
+  }
+  if (sources.some(source => source.dispose)) {
+    combined.dispose = () => {
+      const errors: unknown[] = []
+      for (const source of sources) {
+        try {
+          source.dispose?.()
+        } catch (cause) {
+          errors.push(cause)
+        }
+      }
+      if (errors.length === 1) throw errors[0]
+      if (errors.length > 1) throw new PluginJobSourceDisposeError(errors)
+    }
+  }
+  return combined
+}
+
+class PluginJobSourceDisposeError extends Error {
+  readonly cause: unknown
+  readonly errors: readonly unknown[]
+
+  constructor(errors: readonly unknown[]) {
+    super('Failed to dispose plugin job sources')
+    this.name = 'PluginJobSourceDisposeError'
+    this.cause = errors[0]
+    this.errors = Object.freeze([...errors])
+  }
+}
+
+function duplicatePluginJobId(jobId: string): Error {
+  return new Error(`Duplicate plugin job id across combined sources: ${jobId}`)
+}
+
+export interface UseJobCenterOptions {
+  source?: MaybeRefOrGetter<PluginJobCenterSource | undefined>
+  loadOnMount?: boolean
+}
+
+export interface UseJobCenterReturn {
+  jobs: ComputedRef<JobState[]>
+  activeJobs: ComputedRef<JobState[]>
+  historyJobs: ComputedRef<JobState[]>
+  deletableJobs: ComputedRef<JobState[]>
+  featuredJob: ComputedRef<JobState | null>
+  canRefresh: ComputedRef<boolean>
+  canCancel: ComputedRef<boolean>
+  canDelete: ComputedRef<boolean>
+  canClearFinished: ComputedRef<boolean>
+  isOpen: Ref<boolean>
+  activeTab: Ref<JobsStatusTrayTab>
+  isLoading: Ref<boolean>
+  error: ShallowRef<string | null>
+  pendingJobIds: Ref<Set<string>>
+  open: () => void
+  close: () => void
+  toggle: () => void
+  refresh: () => Promise<boolean>
+  cancelJob: (job: JobState) => Promise<boolean>
+  deleteJob: (job: JobState) => Promise<boolean>
+  clearFinished: () => Promise<boolean>
+  isPending: (job: JobState) => boolean
+}
+
+function errorMessage(error: unknown, fallback: string): string {
+  return error instanceof Error ? error.message : fallback
+}
+
+/**
+ * Headless controller for plugin job presentation and actions.
+ *
+ * Every job list is derived directly from the source. The controller never
+ * mirrors source jobs into another ref.
+ */
+export function useJobCenter(
+  options: UseJobCenterOptions = {},
+): UseJobCenterReturn {
+  const isOpen = ref(false)
+  const activeTab = ref<JobsStatusTrayTab>('active')
+  const isLoading = ref(false)
+  const error = shallowRef<string | null>(null)
+  const pendingJobIds = ref(new Set<string>())
+  let requestGeneration = 0
+  let active = true
+  const source = computed(() => toValue(options.source))
+
+  const jobs = computed<JobState[]>(() => {
+    const currentSource = source.value
+    return currentSource ? [...toValue(currentSource.jobs)].map(normalizeJobState) : []
+  })
+  const activeJobs = computed(() => jobs.value.filter(job => isActiveJobStatus(job.status)))
+  const historyJobs = computed(() => jobs.value.filter(job => !isActiveJobStatus(job.status)))
+  const deletableJobs = computed(() => historyJobs.value.filter(job => job.can_delete))
+  const featuredJob = computed(() => activeJobs.value[0] ?? historyJobs.value[0] ?? null)
+  const canRefresh = computed(() => Boolean(source.value?.refresh))
+  const canCancel = computed(() => Boolean(source.value?.cancel))
+  const canDelete = computed(() => Boolean(source.value?.delete))
+  const canClearFinished = computed(() => Boolean(
+    source.value?.clear || source.value?.delete,
+  ))
+
+  function setPending(jobId: string, pending: boolean): void {
+    const next = new Set(pendingJobIds.value)
+    if (pending) next.add(jobId)
+    else next.delete(jobId)
+    pendingJobIds.value = next
+  }
+
+  async function refresh(): Promise<boolean> {
+    const listJobs = source.value?.refresh
+    if (!listJobs) return false
+    const generation = ++requestGeneration
+    isLoading.value = true
+    error.value = null
+    try {
+      await listJobs()
+      return active && generation === requestGeneration
+    } catch (cause) {
+      if (active && generation === requestGeneration) {
+        error.value = errorMessage(cause, 'Failed to load jobs')
+      }
+      return false
+    } finally {
+      if (active && generation === requestGeneration) isLoading.value = false
+    }
+  }
+
+  async function cancelJob(job: JobState): Promise<boolean> {
+    const sourceCancel = source.value?.cancel
+    if (!job.can_cancel || !sourceCancel || pendingJobIds.value.has(job.job_id)) {
+      return false
+    }
+    setPending(job.job_id, true)
+    error.value = null
+    try {
+      await sourceCancel(job.job_id)
+      return active
+    } catch (cause) {
+      if (active) error.value = errorMessage(cause, 'Failed to cancel job')
+      return false
+    } finally {
+      if (active) setPending(job.job_id, false)
+    }
+  }
+
+  async function deleteJob(job: JobState): Promise<boolean> {
+    const sourceDelete = source.value?.delete
+    if (!job.can_delete || !sourceDelete || pendingJobIds.value.has(job.job_id)) {
+      return false
+    }
+    setPending(job.job_id, true)
+    error.value = null
+    try {
+      const deleted = await sourceDelete(job.job_id)
+      return active && deleted !== false
+    } catch (cause) {
+      if (active) error.value = errorMessage(cause, 'Failed to delete job')
+      return false
+    } finally {
+      if (active) setPending(job.job_id, false)
+    }
+  }
+
+  async function clearFinished(): Promise<boolean> {
+    const targets = deletableJobs.value
+    if (targets.length === 0) return false
+    error.value = null
+    try {
+      const currentSource = source.value
+      if (currentSource?.clear) {
+        const deleted = await currentSource.clear()
+        if (!active) return false
+        return typeof deleted !== 'number' || deleted === targets.length
+      }
+      if (!currentSource?.delete) return false
+      const results = await Promise.all(targets.map(job => deleteJob(job)))
+      return results.every(Boolean)
+    } catch (cause) {
+      if (active) error.value = errorMessage(cause, 'Failed to clear jobs')
+      return false
+    }
+  }
+
+  onMounted(() => {
+    if (options.loadOnMount !== false) void refresh()
+  })
+  onUnmounted(() => {
+    active = false
+    requestGeneration += 1
+  })
+
+  return {
+    jobs,
+    activeJobs,
+    historyJobs,
+    deletableJobs,
+    featuredJob,
+    canRefresh,
+    canCancel,
+    canDelete,
+    canClearFinished,
+    isOpen,
+    activeTab,
+    isLoading,
+    error,
+    pendingJobIds,
+    open: () => { isOpen.value = true },
+    close: () => { isOpen.value = false },
+    toggle: () => { isOpen.value = !isOpen.value },
+    refresh,
+    cancelJob,
+    deleteJob,
+    clearFinished,
+    isPending: job => pendingJobIds.value.has(job.job_id),
+  }
+}

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

@@ -8,13 +8,11 @@ import {
   type ShallowRef,
 } from 'vue'
 
-import type {
-  JobsStatusTrayAdapter,
-  PluginJobCenterSource,
-} from './useJobsStatusTray'
-import { useEventStream, type EventStreamMessage } from './useEventStream'
+import type { PluginJobCenterSource } from './useJobCenter'
+import { createEventStream, type EventStreamMessage } from './eventStream'
 import { isActiveJobStatus, normalizeJobState } from '../jobs'
 import { MintApiError, mintApiErrorFromResponse } from '../apiErrors'
+import { AUTH_TOKEN_STORAGE_KEY } from '../stores/auth'
 import type {
   GeneratedAnalysisJob,
   GeneratedAnalysisJobInput,
@@ -40,19 +38,21 @@ export interface GeneratedAnalysisTransportOptions {
   getAccessToken?: () => string | null | undefined
 }
 
-export interface UsePluginJobsOptions {
+export interface UseJobsEndpointOptions {
   baseUrl: string
   transport?: GeneratedAnalysisTransport
   storage?: Storage
   createId?: () => string
-  pollInterval?: number
+  /** Milliseconds between job list polls while no event stream is open. Default 750. */
+  poll?: number
   stream?: boolean
   streamReconnectDelay?: number
+  /** List the existing jobs at once instead of on the first `submit()` or `refresh()`. */
   immediate?: boolean
+  /** Load the generated UI manifest (`/generated/manifest`) before the jobs. */
+  manifest?: boolean
 }
 
-export type GeneratedAnalysisOptions = UsePluginJobsOptions
-
 export interface PluginJobWaitOptions {
   signal?: AbortSignal
   rejectOnFailure?: boolean
@@ -67,7 +67,7 @@ interface GeneratedSessionStorage {
   setItem: (key: string, value: string) => void
 }
 
-export interface UsePluginJobsReturn extends PluginJobCenterSource {
+export interface UseJobsEndpointReturn extends PluginJobCenterSource {
   manifest: ShallowRef<GeneratedAnalysisManifest | null>
   session: ShallowRef<GeneratedSession | null>
   jobs: ShallowRef<GeneratedAnalysisJob[]>
@@ -76,8 +76,6 @@ export interface UsePluginJobsReturn extends PluginJobCenterSource {
   isSubmitting: Ref<boolean>
   error: ShallowRef<string | null>
   status: ShallowRef<'idle' | 'initializing' | 'ready' | 'paused' | 'error' | 'disposed'>
-  initialize: () => Promise<void>
-  ready: () => Promise<void>
   uploadPath: (
     input: PluginJobPathInput,
     definitionId?: string,
@@ -90,30 +88,26 @@ export interface UsePluginJobsReturn extends PluginJobCenterSource {
     pagination?: PluginJobStagingPagination,
   ) => Promise<PluginJobStaging<Metadata>>
   sealJob: (job: GeneratedAnalysisJob | string) => Promise<GeneratedAnalysisJob>
+  /** Submit a job. The first call opens the job session. */
   submit: (definitionId: string, inputs: Record<string, unknown>) => Promise<GeneratedAnalysisJob>
-  loadResult: (job: GeneratedAnalysisJob) => Promise<GeneratedAnalysisResult | null>
+  result: (job: GeneratedAnalysisJob) => Promise<GeneratedAnalysisResult | null>
   resultForJob: (jobId: string) => GeneratedAnalysisResult | null
-  refreshJobs: () => Promise<GeneratedAnalysisJob[]>
+  /** List the jobs again. The first call opens the job session. */
   refresh: () => Promise<GeneratedAnalysisJob[]>
-  getJob: (jobId: string, options?: PluginJobRequestOptions) => Promise<GeneratedAnalysisJob>
-  waitForJob: (
+  get: (jobId: string, options?: PluginJobRequestOptions) => Promise<GeneratedAnalysisJob>
+  wait: (
     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>
+  cancel: (job: GeneratedAnalysisJob | string) => Promise<GeneratedAnalysisJob>
+  delete: (job: GeneratedAnalysisJob | string) => Promise<boolean>
+  clear: (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 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
@@ -151,36 +145,25 @@ export function createGeneratedAnalysisTransport(
   }
 }
 
-export function useGeneratedAnalysis(
-  options: GeneratedAnalysisOptions,
-): UseGeneratedAnalysisReturn {
-  return createPluginJobs(options, '/generated/manifest')
-}
-
 /**
- * Connect a custom plugin frontend to the SDK-owned job lifecycle.
+ * Connect a frontend to the SDK-owned job lifecycle of one plugin API prefix.
+ * Generated clients use it through `useJobs()`.
  *
- * @example Recommended
+ * @example
  * ```ts
- * const jobs = usePluginJobs({ baseUrl: '/api/leaf/jobs' })
- * await jobs.initialize()
+ * const jobs = useJobsEndpoint({ baseUrl: '/api/leaf', immediate: true })
+ * const job = await jobs.submit('fit-plate', inputs)
  * ```
  */
-export function usePluginJobs(
-  options: UsePluginJobsOptions,
-): UsePluginJobsReturn {
-  return createPluginJobs(options)
-}
-
-function createPluginJobs(
-  options: UsePluginJobsOptions,
-  manifestPath?: string,
-): UsePluginJobsReturn {
+export function useJobsEndpoint(
+  options: UseJobsEndpointOptions,
+): UseJobsEndpointReturn {
+  const manifestPath = options.manifest ? '/generated/manifest' : undefined
   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 pollInterval = options.poll ?? 750
   const streamEnabled = options.stream ?? true
   const streamReconnectDelay = options.streamReconnectDelay ?? 1_500
   const tabKey = `mint:generated:${baseUrl}:tab`
@@ -209,7 +192,7 @@ function createPluginJobs(
   const resultRetryAttempts = new Map<string, number>()
   const resultRetryTimers = new Map<string, ReturnType<typeof setTimeout>>()
   const downloadRefreshTimers = new Map<string, ReturnType<typeof setTimeout>>()
-  const jobStream = useEventStream<PluginJobStreamData>(`${baseUrl}/jobs/events`, {
+  const jobStream = createEventStream<PluginJobStreamData>(`${baseUrl}/jobs/events`, {
     transport,
     immediate: false,
     reconnectDelayMs: streamReconnectDelay,
@@ -260,7 +243,17 @@ function createPluginJobs(
     return pending
   }
 
-  async function resolveSession(): Promise<GeneratedSession> {
+  // Runtimes of one plugin on one page share a session: a concurrent first
+  // resolve joins the request in flight instead of creating a second session.
+  function resolveSession(): Promise<GeneratedSession> {
+    const pending = pendingSessions.get(sessionKey)
+    if (pending) return pending
+    const resolving = resolveStoredSession().finally(() => pendingSessions.delete(sessionKey))
+    pendingSessions.set(sessionKey, resolving)
+    return resolving
+  }
+
+  async function resolveStoredSession(): Promise<GeneratedSession> {
     let tabId = storage.getItem(tabKey)
     if (!tabId) {
       tabId = createId()
@@ -284,7 +277,8 @@ function createPluginJobs(
     definitionId: string,
     inputs: Record<string, unknown>,
   ): Promise<GeneratedAnalysisJob> {
-    if (!session.value) throw new Error('Generated analysis session is not initialized')
+    await initialize()
+    if (!session.value) throw new Error('Plugin jobs runtime is disposed')
     const clientRequestId = createId()
     isSubmitting.value = true
     error.value = null
@@ -336,7 +330,8 @@ function createPluginJobs(
     input: PluginJobPathInput,
     definitionId?: string,
   ): Promise<PluginJobPathUpload> {
-    if (!session.value) throw new Error('Generated analysis session is not initialized')
+    await initialize()
+    if (!session.value) throw new Error('Plugin jobs runtime is disposed')
     return uploadPathForSession(input, session.value.id, definitionId)
   }
 
@@ -992,13 +987,6 @@ function createPluginJobs(
     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
@@ -1074,30 +1062,28 @@ function createPluginJobs(
     isSubmitting,
     error,
     status,
-    initialize,
-    ready: initialize,
     uploadPath,
     uploadStagedPart,
     getJobStaging,
     sealJob,
     submit,
-    loadResult,
+    result: loadResult,
     resultForJob,
-    refreshJobs,
     refresh,
-    getJob,
-    waitForJob,
+    get: getJob,
+    wait: waitForJob,
     jobsFor,
-    cancelJob,
-    deleteJob,
-    clearFinishedJobs,
+    cancel: cancelJob,
+    delete: deleteJob,
+    clear: clearFinishedJobs,
     pause,
     resume,
     dispose,
-    jobsAdapter,
   }
 }
 
+const pendingSessions = new Map<string, Promise<GeneratedSession>>()
+
 function jobIdFromReference(job: GeneratedAnalysisJob | string): string {
   return typeof job === 'string' ? job : job.job_id
 }
@@ -1168,7 +1154,7 @@ function isPluginJobPathInput(value: unknown): value is PluginJobPathInput {
 
 function readStoredAccessToken(): string | null {
   try {
-    return globalThis.localStorage?.getItem(AUTH_TOKEN_KEY) ?? null
+    return globalThis.localStorage?.getItem(AUTH_TOKEN_STORAGE_KEY) ?? null
   } catch {
     return null
   }

package/src/composables/useMenuKeyboard.ts

@@ -27,7 +27,7 @@ export interface UseMenuKeyboardReturn {
 
 /**
  * Shared keyboard contract for menu- and listbox-style disclosure panels (the
- * WAI-ARIA menu button pattern). Used by ActionMenu and AppAvatarMenu,
+ * WAI-ARIA menu button pattern). Used by ActionMenu and the platform account menu,
  * each pairing it with `useDropdownState` for the disclosure state itself.
  */
 export function useMenuKeyboard(options: UseMenuKeyboardOptions): UseMenuKeyboardReturn {