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

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

@@ -1,1772 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { createPinia, setActivePinia } from 'pinia'
-import axios, { type AxiosRequestConfig } from 'axios'
-import { watch } from 'vue'
-
-import {
-  buildPluginEndpointUrl,
-  createPluginClient,
-  downloadBlob,
-  downloadPluginEndpoint,
-  getPluginPageSelectorItems,
-  pluginFormDataFromPayload,
-  resolvePluginBaseUrl,
-  uploadPluginEndpoint,
-  useCurrentExperiment,
-  usePluginEventStream,
-  usePluginSettings,
-  type PluginContract,
-} from '../../composables/usePluginClient'
-import { AuthenticationRequiredError } from '../../composables/useApi'
-import { useAuthStore } from '../../stores/auth'
-
-const contract: PluginContract = {
-  schemaVersion: 2,
-  plugin: {
-    routesPrefix: '/drp',
-    apiPrefix: '/api/drp',
-    type: 'analysis',
-  },
-  settings: {
-    modelName: 'PluginSettings',
-    valueSchema: {
-      type: 'object',
-      properties: {
-        threshold: { type: 'number', default: 0.05 },
-      },
-    },
-    formSchema: {
-      groups: [
-        {
-          id: 'settings',
-          label: 'Settings',
-          fields: [
-            {
-              name: 'threshold',
-              label: 'Threshold',
-              type: 'number',
-              defaultValue: 0.05,
-            },
-          ],
-        },
-      ],
-    },
-  },
-  endpoints: [],
-  hash: 'sha256:test',
-}
-
-function deferred<T>(): {
-  promise: Promise<T>
-  resolve: (value: T) => void
-} {
-  let resolve!: (value: T) => void
-  const promise = new Promise<T>((done) => {
-    resolve = done
-  })
-  return { promise, resolve }
-}
-
-function pendingEventStreamResponse(): {
-  response: Response
-  close: () => void
-} {
-  let streamController!: ReadableStreamDefaultController<Uint8Array>
-  const body = new ReadableStream<Uint8Array>({
-    start(controller) {
-      streamController = controller
-    },
-  })
-  return {
-    response: new Response(body, { status: 200 }),
-    close: () => {
-      try {
-        streamController.close()
-      } catch {
-        // stop() may already have cancelled the reader.
-      }
-    },
-  }
-}
-
-describe('usePluginClient', () => {
-  let requestConfigs: AxiosRequestConfig[] = []
-  let requestBodies: unknown[] = []
-  let requestMethods: string[] = []
-  let nextGetError: Error | null = null
-  let nextGetData: unknown
-  let nextPostData: unknown
-  let nextPatchData: unknown
-  let nextPutData: unknown
-
-  beforeEach(() => {
-    setActivePinia(createPinia())
-    requestConfigs = []
-    requestBodies = []
-    requestMethods = []
-    nextGetError = null
-    nextGetData = undefined
-    nextPostData = undefined
-    nextPatchData = undefined
-    nextPutData = undefined
-    vi.spyOn(axios.Axios.prototype, 'get').mockImplementation(async function (
-      this: unknown,
-      url: string,
-      config?: AxiosRequestConfig,
-    ) {
-      requestMethods.push('get')
-      requestConfigs.push({ url, ...config })
-      if (nextGetError) throw nextGetError
-      return { data: nextGetData ?? { called: url } }
-    })
-    vi.spyOn(axios.Axios.prototype, 'post').mockImplementation(async function (
-      this: unknown,
-      url: string,
-      data?: unknown,
-      config?: AxiosRequestConfig,
-    ) {
-      requestMethods.push('post')
-      requestConfigs.push({ url, ...config })
-      requestBodies.push(data)
-      return { data: nextPostData ?? { called: url } }
-    })
-    vi.spyOn(axios.Axios.prototype, 'patch').mockImplementation(async function (
-      this: unknown,
-      url: string,
-      data?: unknown,
-      config?: AxiosRequestConfig,
-    ) {
-      requestMethods.push('patch')
-      requestConfigs.push({ url, ...config })
-      requestBodies.push(data)
-      return { data: nextPatchData ?? { called: url } }
-    })
-    vi.spyOn(axios.Axios.prototype, 'put').mockImplementation(async function (
-      this: unknown,
-      url: string,
-      data?: unknown,
-      config?: AxiosRequestConfig,
-    ) {
-      requestMethods.push('put')
-      requestConfigs.push({ url, ...config })
-      requestBodies.push(data)
-      return { data: nextPutData ?? { called: url } }
-    })
-    vi.spyOn(axios.Axios.prototype, 'delete').mockImplementation(async function (
-      this: unknown,
-      url: string,
-      config?: AxiosRequestConfig,
-    ) {
-      requestMethods.push('delete')
-      requestConfigs.push({ url, ...config })
-      requestBodies.push(config?.data)
-      return { data: { called: url } }
-    })
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-    vi.restoreAllMocks()
-    vi.unstubAllGlobals()
-    vi.unstubAllEnvs()
-    window.history.replaceState({}, '', '/')
-    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
-  })
-
-  it('uses contract apiPrefix by default', async () => {
-    const client = createPluginClient(contract, {
-      endpoints: {
-        health: { method: 'get', path: '/health' },
-      },
-    })
-
-    await client.health()
-
-    expect(requestConfigs[0]!.baseURL).toBe('/api/drp')
-    expect(requestConfigs[0]!.url).toBe('/health')
-  })
-
-  it('omits MINT auth transport for a public generated endpoint', async () => {
-    const client = createPluginClient(contract, {
-      endpoints: {
-        health: { method: 'get', path: '/health', requiresAuth: false },
-      },
-    })
-
-    await client.health()
-
-    expect(
-      (requestConfigs[0] as AxiosRequestConfig & { _mintSkipAuth?: boolean })
-        ._mintSkipAuth,
-    ).toBe(true)
-  })
-
-  it('VITE_API_PREFIX overrides contract apiPrefix', async () => {
-    vi.stubEnv('VITE_API_PREFIX', '/api/override')
-    const client = createPluginClient(contract, {
-      endpoints: {
-        health: { method: 'get', path: '/health' },
-      },
-    })
-
-    await client.health()
-
-    expect(requestConfigs[0]!.baseURL).toBe('/api/override')
-  })
-
-  it('platform injected api_prefix overrides contract fallback', async () => {
-    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      plugin: {
-        id: 'drp',
-        name: 'DRP',
-        version: '1.0.0',
-        route_prefix: '/drp',
-        api_prefix: '/api/platform-drp',
-      },
-    }
-    const client = createPluginClient(contract, {
-      endpoints: {
-        health: { method: 'get', path: '/health' },
-      },
-    })
-
-    await client.health()
-
-    expect(requestConfigs[0]!.baseURL).toBe('/api/platform-drp')
-  })
-
-  it('resolves plugin base URLs without making requests', () => {
-    expect(resolvePluginBaseUrl(contract)).toBe('/api/drp')
-
-    expect(resolvePluginBaseUrl(
-      { ...contract, plugin: { ...contract.plugin, apiPrefix: '/api/drp/' } },
-    )).toBe('/api/drp')
-    expect(resolvePluginBaseUrl(contract, '/api/explicit/')).toBe('/api/explicit')
-
-    vi.stubEnv('VITE_API_PREFIX', '/api/env/')
-    expect(resolvePluginBaseUrl(contract, '/api/explicit')).toBe('/api/env')
-  })
-
-  it('normalizes platform-injected plugin base URLs', () => {
-    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      plugin: {
-        id: 'drp',
-        name: 'DRP',
-        version: '1.0.0',
-        route_prefix: '/ignored/',
-        api_prefix: '/api/platform-drp/',
-      },
-    }
-
-    expect(resolvePluginBaseUrl(contract)).toBe('/api/platform-drp')
-
-    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      plugin: {
-        id: 'drp',
-        name: 'DRP',
-        version: '1.0.0',
-        route_prefix: '/platform-drp/',
-      },
-    }
-
-    expect(resolvePluginBaseUrl(contract)).toBe('/api/platform-drp')
-  })
-
-  it('builds concrete endpoint URLs without making requests', () => {
-    const url = buildPluginEndpointUrl(
-      contract,
-      {
-        method: 'post',
-        path: '/analyze/{experimentId}',
-        pathParams: ['experimentId'],
-        queryParams: [
-          { name: 'dry_run', fieldName: 'dryRun', type: 'boolean', required: false },
-        ],
-        hasBody: true,
-      },
-      { experimentId: 42, dryRun: true, body: { threshold: 0.5 } },
-    )
-
-    expect(url).toBe('/api/drp/analyze/42?dry_run=true')
-    expect(requestConfigs).toHaveLength(0)
-  })
-
-  it('builds concrete endpoint URLs from structured generated payloads', () => {
-    const url = buildPluginEndpointUrl(
-      contract,
-      {
-        method: 'post',
-        path: '/analyze/{experimentId}',
-        pathParams: ['experimentId'],
-        queryParams: [
-          { name: 'dry_run', fieldName: 'dryRun', type: 'boolean', required: false },
-        ],
-        hasBody: true,
-      },
-      {
-        pathParams: { experimentId: 42 },
-        query: { dryRun: true },
-        body: { threshold: 0.5 },
-      },
-    )
-
-    expect(url).toBe('/api/drp/analyze/42?dry_run=true')
-    expect(requestConfigs).toHaveLength(0)
-  })
-
-  it('builds URLs from rich generated path parameter contracts', () => {
-    const url = buildPluginEndpointUrl(
-      contract,
-      {
-        method: 'get',
-        path: '/templates/{template_type}',
-        pathParams: [
-          { name: 'template_type', fieldName: 'templateType', type: 'string' },
-        ],
-      },
-      { templateType: 'plate map' },
-      { includeBaseUrl: false },
-    )
-
-    expect(url).toBe('/templates/plate%20map')
-  })
-
-  it('builds URLs from FastAPI converted path parameters', () => {
-    const url = buildPluginEndpointUrl(
-      contract,
-      {
-        method: 'get',
-        path: '/raw/{folder}/{filename:path}',
-        pathParams: ['folder', 'filename'],
-      },
-      { folder: 'batch 1', filename: 'sample.mzML' },
-      { includeBaseUrl: false },
-    )
-
-    expect(url).toBe('/raw/batch%201/sample.mzML')
-  })
-
-  it('preserves flat scalar query fields when no structured query object is used', () => {
-    const url = buildPluginEndpointUrl(
-      contract,
-      {
-        method: 'get',
-        path: '/search',
-      },
-      { query: 'glucose' },
-      { includeBaseUrl: false },
-    )
-
-    expect(url).toBe('/search?query=glucose')
-  })
-
-  it('encodes generated plugin upload endpoint payloads as multipart form data', async () => {
-    const response = await uploadPluginEndpoint<{ ok: boolean }>(
-      contract,
-      {
-        method: 'post',
-        path: '/schedule/import',
-        queryParams: [
-          { name: 'instrument_id', fieldName: 'instrumentId', type: 'string', required: true },
-          { name: 'mode', fieldName: 'mode', type: 'string', required: false },
-        ],
-        hasBody: true,
-      },
-      {
-        query: {
-          instrumentId: 'orbitrap',
-          mode: 'replace',
-        },
-        body: {
-          file: new Blob(['csv']),
-          metadata: { source: 'test' },
-          dryRun: false,
-        },
-      },
-    )
-
-    expect(response).toEqual({ called: '/schedule/import' })
-    expect(requestConfigs[0]!.baseURL).toBe('/api/drp')
-    expect(requestConfigs[0]!.url).toBe('/schedule/import')
-    expect(requestConfigs[0]!.params).toEqual({ instrument_id: 'orbitrap', mode: 'replace' })
-    expect(requestConfigs[0]!.headers).toEqual({ 'Content-Type': undefined })
-    expect(requestBodies[0]).toBeInstanceOf(FormData)
-    const form = requestBodies[0] as FormData
-    expect(form.get('file')).toBeInstanceOf(Blob)
-    expect(form.get('metadata')).toBe('{"source":"test"}')
-    expect(form.get('dryRun')).toBe('false')
-  })
-
-  it('uploads generated octet-stream endpoint bodies without multipart conversion', async () => {
-    const body = new Uint8Array([1, 2, 3])
-
-    await uploadPluginEndpoint(
-      contract,
-      {
-        method: 'put',
-        path: '/chunks',
-        hasBody: true,
-        requestContentType: 'application/octet-stream',
-      },
-      body,
-    )
-
-    expect({
-      body: requestBodies[0],
-      contentType: (requestConfigs[0]!.headers as Record<string, unknown>)['Content-Type'],
-    }).toEqual({
-      body,
-      contentType: 'application/octet-stream',
-    })
-  })
-
-  it('builds multipart form data from repeated scalar values', () => {
-    const form = pluginFormDataFromPayload({
-      tags: ['qc', 'plate'],
-      threshold: 0.5,
-      enabled: true,
-      omitted: undefined,
-    })
-
-    expect(form.getAll('tags')).toEqual(['qc', 'plate'])
-    expect(form.get('threshold')).toBe('0.5')
-    expect(form.get('enabled')).toBe('true')
-    expect(form.has('omitted')).toBe(false)
-  })
-
-  it('downloads generated plugin endpoint blobs with contract query handling', async () => {
-    const expectedBlob = new Blob(['a,b'])
-    nextGetData = expectedBlob
-
-    const blob = await downloadPluginEndpoint(
-      contract,
-      {
-        method: 'get',
-        path: '/schedule/export',
-        queryParams: [
-          { name: 'instrument_id', fieldName: 'instrumentId', type: 'string', required: true },
-          { name: 'start', fieldName: 'start', type: 'string', required: true },
-        ],
-      },
-      { query: { instrumentId: 'orbitrap', start: '2026-05-27' } },
-    )
-
-    expect(blob).toBe(expectedBlob)
-    expect(requestConfigs[0]!.baseURL).toBe('/api/drp')
-    expect(requestConfigs[0]!.url).toBe('/schedule/export')
-    expect(requestConfigs[0]!.params).toEqual({ instrument_id: 'orbitrap', start: '2026-05-27' })
-    expect(requestConfigs[0]!.responseType).toBe('blob')
-  })
-
-  it('downloads generated POST endpoint blobs with the contract body and request options', async () => {
-    const expectedBlob = new Blob(['zip'])
-    const controller = new AbortController()
-    nextPostData = expectedBlob
-
-    const blob = await downloadPluginEndpoint(
-      contract,
-      {
-        method: 'post',
-        path: '/export/{sessionId}/results',
-        pathParams: ['sessionId'],
-        queryParams: [
-          { name: 'revision', fieldName: 'revision', type: 'number', required: true },
-        ],
-        hasBody: true,
-        requestContentType: 'application/json',
-      },
-      {
-        sessionId: 'session-1',
-        revision: 4,
-        body: { format: 'wide', correction: false },
-      },
-      { signal: controller.signal },
-    )
-
-    expect({
-      blob,
-      body: requestBodies[0],
-      url: requestConfigs[0]!.url,
-      params: requestConfigs[0]!.params,
-      signal: requestConfigs[0]!.signal,
-      responseType: requestConfigs[0]!.responseType,
-      method: requestMethods[0],
-    }).toEqual({
-      blob: expectedBlob,
-      body: { format: 'wide', correction: false },
-      url: '/export/session-1/results',
-      params: { revision: 4 },
-      signal: controller.signal,
-      responseType: 'blob',
-      method: 'post',
-    })
-  })
-
-  it.each(['put', 'patch', 'delete'] as const)(
-    'downloads generated %s endpoint blobs with the contract body',
-    async (method) => {
-      await downloadPluginEndpoint(
-        contract,
-        {
-          method,
-          path: '/exports/{exportId}',
-          pathParams: ['exportId'],
-          hasBody: true,
-        },
-        { exportId: 'export-1', body: { format: 'wide' } },
-      )
-
-      expect({
-        body: requestBodies[0],
-        method: requestMethods[0],
-        responseType: requestConfigs[0]!.responseType,
-        url: requestConfigs[0]!.url,
-      }).toEqual({
-        body: { format: 'wide' },
-        method,
-        responseType: 'blob',
-        url: '/exports/export-1',
-      })
-    },
-  )
-
-  it('rejects multipart download request bodies', async () => {
-    await expect(downloadPluginEndpoint(
-      contract,
-      {
-        method: 'post',
-        path: '/exports',
-        hasBody: true,
-        requestContentType: 'multipart/form-data',
-      },
-      { body: { format: 'wide' } },
-    )).rejects.toThrow('Plugin download endpoints do not support multipart request bodies')
-  })
-
-  it.each([
-    new Blob(['chunk']),
-    new Uint8Array([1, 2, 3]),
-    new Uint8Array([4, 5, 6]).buffer,
-  ])('sends generated octet-stream request bodies without encoding them', async (body) => {
-    const client = createPluginClient(contract, {
-      endpoints: {
-        uploadChunk: {
-          method: 'post',
-          path: '/chunks',
-          hasBody: true,
-          requestContentType: 'application/octet-stream',
-        },
-      },
-    })
-
-    await client.uploadChunk(body)
-
-    expect({
-      body: requestBodies[0],
-      contentType: (requestConfigs[0]!.headers as Record<string, unknown>)['Content-Type'],
-    }).toEqual({
-      body,
-      contentType: 'application/octet-stream',
-    })
-  })
-
-  it('returns generated octet-stream responses as blobs', async () => {
-    const expectedBlob = new Blob(['result'])
-    nextGetData = expectedBlob
-    const client = createPluginClient(contract, {
-      endpoints: {
-        downloadResult: {
-          method: 'get',
-          path: '/result',
-          responseContentType: 'application/octet-stream',
-        },
-      },
-    })
-
-    const result = await client.downloadResult()
-
-    expect({ result, responseType: requestConfigs[0]!.responseType }).toEqual({
-      result: expectedBlob,
-      responseType: 'blob',
-    })
-  })
-
-  it('passes AbortSignal through generated endpoint calls', async () => {
-    const controller = new AbortController()
-    const client = createPluginClient(contract, {
-      endpoints: {
-        health: { method: 'get', path: '/health' },
-      },
-    })
-
-    await client.health({ signal: controller.signal })
-
-    expect(requestConfigs[0]!.signal).toBe(controller.signal)
-  })
-
-  it('encodes generated multipart endpoint bodies as FormData', async () => {
-    const file = new Blob(['csv'])
-    const client = createPluginClient(contract, {
-      endpoints: {
-        uploadFile: {
-          method: 'post',
-          path: '/files',
-          hasBody: true,
-          requestContentType: 'multipart/form-data',
-        },
-      },
-    })
-
-    await client.uploadFile({ file, label: 'sample' })
-
-    const body = requestBodies[0] as FormData
-    expect({
-      isFormData: body instanceof FormData,
-      fileIsBlob: body.get('file') instanceof Blob,
-      label: body.get('label'),
-      contentType: (requestConfigs[0]!.headers as Record<string, unknown>)['Content-Type'],
-    }).toEqual({
-      isFormData: true,
-      fileIsBlob: true,
-      label: 'sample',
-      contentType: undefined,
-    })
-  })
-
-  it('triggers browser downloads for existing blobs', () => {
-    vi.useFakeTimers()
-    const createObjectURL = vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:test')
-    const revokeObjectURL = vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => {})
-    const click = vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {})
-
-    downloadBlob(new Blob(['csv']), 'export.csv', { revokeObjectUrlDelayMs: 0 })
-
-    expect(createObjectURL).toHaveBeenCalledOnce()
-    expect(click).toHaveBeenCalledOnce()
-    expect(revokeObjectURL).not.toHaveBeenCalled()
-    vi.runOnlyPendingTimers()
-    expect(revokeObjectURL).toHaveBeenCalledWith('blob:test')
-    vi.useRealTimers()
-  })
-
-  it('maps plugin contract nav items to AppTopBar page selector metadata', () => {
-    const pageSelectorItems = getPluginPageSelectorItems({
-      ...contract,
-      plugin: {
-        ...contract.plugin,
-        name: 'Dose Designer',
-        description: 'Build dose designs',
-        icon: 'PLUGIN_ICON',
-        navItems: [
-          { path: '/', label: 'Dashboard', icon: 'DASHBOARD_ICON', description: 'Overview' },
-          { id: 'dose-design', path: 'dose-design', label: 'Dose Design' },
-          { path: '/qc/review/', label: 'QC Review', icon: 'QC_ICON' },
-        ],
-      },
-    })
-
-    expect(pageSelectorItems).toEqual([
-      {
-        id: 'dashboard',
-        label: 'Dashboard',
-        to: '/',
-        icon: 'DASHBOARD_ICON',
-      },
-      {
-        id: 'dose-design',
-        label: 'Dose Design',
-        to: '/dose-design',
-        icon: 'PLUGIN_ICON',
-      },
-      {
-        id: 'qc-review',
-        label: 'QC Review',
-        to: '/qc/review',
-        icon: 'QC_ICON',
-      },
-    ])
-    expect(requestConfigs).toHaveLength(0)
-  })
-
-  it('does not synthesize page selector items when contract nav items are absent', () => {
-    expect(getPluginPageSelectorItems({
-      ...contract,
-      plugin: {
-        ...contract.plugin,
-        name: 'Dose Designer',
-        description: 'Build dose designs',
-        icon: 'PLUGIN_ICON',
-        navItems: [],
-      },
-    })).toEqual([])
-    expect(requestConfigs).toHaveLength(0)
-  })
-
-  it('does not synthesize page selector items when contract nav items are omitted', () => {
-    const { navItems: _navItems, ...pluginWithoutNavItems } = contract.plugin
-    expect(getPluginPageSelectorItems({
-      ...contract,
-      plugin: pluginWithoutNavItems,
-    })).toEqual([])
-    expect(requestConfigs).toHaveLength(0)
-  })
-
-  it.each([
-    'platform',
-    undefined,
-  ] as const)(
-    'should use the integrated platform config facade when settings_api is %s',
-    async (settingsApi) => {
-      ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-        isIntegrated: true,
-        theme: 'light',
-        platformApiUrl: '/api',
-        plugin: {
-          id: 'drp',
-          name: 'drp',
-          version: '1.0.0',
-          route_prefix: '/drp',
-          api_prefix: '/api/drp',
-          ...(settingsApi ? { settings_api: settingsApi } : {}),
-        },
-      }
-      nextGetData = {
-        plugin_name: 'drp',
-        config: {
-          nasBasePath: '/data',
-          allowed_experiment_types: ['metabolomics'],
-        },
-        revision: 'revision-1',
-      }
-      nextPatchData = {
-        plugin_name: 'drp',
-        config: {
-          nasBasePath: '/mnt',
-          allowed_experiment_types: ['metabolomics'],
-        },
-        revision: 'revision-2',
-      }
-
-      const settings = usePluginSettings<{ nasBasePath?: string }>({ pluginName: 'drp' })
-      await settings.load()
-
-      expect(requestConfigs[0]!.baseURL).toBe('/api')
-      expect(requestConfigs[0]!.url).toBe('/plugins/drp/config')
-      expect(settings.values.value).toEqual({
-        nasBasePath: '/data',
-        allowed_experiment_types: ['metabolomics'],
-      })
-      expect(settings.settings.value).toEqual({
-        nasBasePath: '/data',
-        allowed_experiment_types: ['metabolomics'],
-      })
-      expect(settings.isDirty.value).toBe(false)
-
-      settings.setValues({
-        nasBasePath: '/mnt',
-        allowed_experiment_types: ['metabolomics'],
-      })
-      expect(settings.isDirty.value).toBe(true)
-      const ok = await settings.save()
-
-      expect(ok).toBe(true)
-      expect(requestConfigs[1]!.baseURL).toBe('/api')
-      expect(requestConfigs[1]!.url).toBe('/plugins/drp/config')
-      expect(requestMethods[1]).toBe('patch')
-      expect(requestConfigs[1]!.headers).toBeUndefined()
-      expect(requestBodies[0]).toEqual({ config: { nasBasePath: '/mnt' } })
-      expect(settings.values.value).toEqual({
-        nasBasePath: '/mnt',
-        allowed_experiment_types: ['metabolomics'],
-      })
-      expect(settings.isDirty.value).toBe(false)
-    },
-  )
-
-  it('should use the plugin settings router for an integrated plugin capability', async () => {
-    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      platformApiUrl: '/api',
-      plugin: {
-        id: 'drp',
-        name: 'drp',
-        version: '1.0.0',
-        route_prefix: '/drp',
-        api_prefix: '/api/drp',
-        settings_api: 'plugin',
-      },
-    }
-    nextGetData = {
-      settings: { threshold: 1 },
-      mode: 'integrated',
-      revision: 'revision-1',
-    }
-    nextPutData = {
-      settings: { threshold: 2 },
-      mode: 'integrated',
-      revision: 'revision-2',
-    }
-
-    const settings = usePluginSettings<{ threshold?: number }>({ pluginName: 'drp' })
-    await settings.load()
-    const saved = await settings.save({ threshold: 2 })
-
-    expect({
-      saved,
-      methods: requestMethods,
-      requests: requestConfigs.map(({ baseURL, url, headers }) => ({
-        baseURL,
-        url,
-        headers,
-      })),
-      bodies: requestBodies,
-      values: settings.values.value,
-    }).toEqual({
-      saved: true,
-      methods: ['get', 'put'],
-      requests: [
-        {
-          baseURL: '/api/drp',
-          url: '/settings',
-          headers: undefined,
-        },
-        {
-          baseURL: '/api/drp',
-          url: '/settings',
-          headers: { 'If-Match': '"revision-1"' },
-        },
-      ],
-      bodies: [{ threshold: 2 }],
-      values: { threshold: 2 },
-    })
-  })
-
-  it('should preserve the contract v2 form schema in settingsConfig', () => {
-    const settings = usePluginSettings({
-      apiBaseUrl: '/api/drp',
-      loadOnMount: false,
-      schema: contract.settings.formSchema,
-    })
-
-    expect(settings.settingsConfig.value.schema).toBe(contract.settings.formSchema)
-  })
-
-  it('should use the platform facade for an explicit different plugin name', async () => {
-    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      platformApiUrl: '/api',
-      plugin: {
-        id: 'current-plugin',
-        name: 'current-plugin',
-        version: '1.0.0',
-        route_prefix: '/current-plugin',
-        api_prefix: '/api/current-plugin',
-        settings_api: 'plugin',
-      },
-    }
-    nextGetData = {
-      plugin_name: 'other-plugin',
-      config: { threshold: 1 },
-      revision: 'revision-1',
-    }
-
-    const settings = usePluginSettings<{ threshold?: number }>({
-      pluginName: 'other-plugin',
-    })
-    await settings.load()
-
-    expect({
-      method: requestMethods[0],
-      baseURL: requestConfigs[0]!.baseURL,
-      url: requestConfigs[0]!.url,
-      values: settings.values.value,
-    }).toEqual({
-      method: 'get',
-      baseURL: '/api',
-      url: '/plugins/other-plugin/config',
-      values: { threshold: 1 },
-    })
-  })
-
-  it('should split changed platform-owned settings from a versioned typed save', async () => {
-    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      platformApiUrl: '/api',
-      plugin: {
-        id: 'drp',
-        name: 'drp',
-        version: '1.0.0',
-        route_prefix: '/drp',
-        api_prefix: '/api/drp',
-      },
-    }
-    nextGetData = {
-      plugin_name: 'drp',
-      config: {
-        threshold: 1,
-        allowed_experiment_types: ['metabolomics'],
-      },
-      revision: 'revision-1',
-    }
-    nextPatchData = {
-      plugin_name: 'drp',
-      config: {
-        threshold: 2,
-        allowed_experiment_types: ['proteomics'],
-      },
-      revision: 'untrusted-platform-revision',
-    }
-    const settings = usePluginSettings<{ threshold?: number }>({ pluginName: 'drp' })
-    await settings.load()
-    settings.setValues({
-      threshold: 2,
-      allowed_experiment_types: ['proteomics'],
-    })
-
-    const saved = await settings.save()
-    nextPatchData = {
-      plugin_name: 'drp',
-      config: {
-        threshold: 3,
-        allowed_experiment_types: ['proteomics'],
-      },
-      revision: 'revision-3',
-    }
-    settings.setValues({
-      threshold: 3,
-      allowed_experiment_types: ['proteomics'],
-    })
-    const savedAgain = await settings.save()
-
-    expect({
-      saved,
-      savedAgain,
-      methods: requestMethods,
-      bodies: requestBodies,
-      writeHeaders: requestConfigs.slice(1).map(config => config.headers),
-      values: settings.values.value,
-      isDirty: settings.isDirty.value,
-    }).toEqual({
-      saved: true,
-      savedAgain: true,
-      methods: ['get', 'patch', 'patch', 'patch'],
-      bodies: [
-        { config: { threshold: 2 } },
-        { config: { allowed_experiment_types: ['proteomics'] } },
-        { config: { threshold: 3 } },
-      ],
-      writeHeaders: [undefined, undefined, undefined],
-      values: {
-        threshold: 3,
-        allowed_experiment_types: ['proteomics'],
-      },
-      isDirty: false,
-    })
-  })
-
-  it('should avoid a typed PUT when only the platform-owned setting changes', async () => {
-    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      platformApiUrl: '/api',
-      plugin: {
-        id: 'drp',
-        name: 'drp',
-        version: '1.0.0',
-        route_prefix: '/drp',
-        api_prefix: '/api/drp',
-      },
-    }
-    nextGetData = {
-      plugin_name: 'drp',
-      config: {
-        threshold: 1,
-        allowed_experiment_types: ['metabolomics'],
-      },
-      revision: 'revision-1',
-    }
-    nextPatchData = {
-      plugin_name: 'drp',
-      config: {
-        threshold: 1,
-        allowed_experiment_types: ['proteomics'],
-      },
-    }
-
-    const settings = usePluginSettings<{ threshold?: number }>({ pluginName: 'drp' })
-    await settings.load()
-    settings.setValues({
-      threshold: 1,
-      allowed_experiment_types: ['proteomics'],
-    })
-
-    const saved = await settings.save()
-
-    expect({
-      saved,
-      methods: requestMethods,
-      bodies: requestBodies,
-      values: settings.values.value,
-    }).toEqual({
-      saved: true,
-      methods: ['get', 'patch'],
-      bodies: [{ config: { allowed_experiment_types: ['proteomics'] } }],
-      values: {
-        threshold: 1,
-        allowed_experiment_types: ['proteomics'],
-      },
-    })
-  })
-
-  it('should detect nested settings edits and restore the saved JSON snapshot', async () => {
-    nextGetData = {
-      settings: {
-        rules: {
-          thresholds: [1, 2],
-        },
-      },
-      mode: 'standalone',
-    }
-
-    const settings = usePluginSettings<{
-      rules?: { thresholds: number[] }
-    }>({
-      apiBaseUrl: '/api/drp',
-      loadOnMount: false,
-    })
-    await settings.load()
-    settings.values.value.rules!.thresholds[0] = 9
-
-    const dirtyAfterMutation = settings.isDirty.value
-    settings.reset()
-
-    expect({
-      dirtyAfterMutation,
-      values: settings.values.value,
-      isDirty: settings.isDirty.value,
-    }).toEqual({
-      dirtyAfterMutation: true,
-      values: {
-        rules: {
-          thresholds: [1, 2],
-        },
-      },
-      isDirty: false,
-    })
-  })
-
-  it('loads and saves plugin settings through the standalone settings router', async () => {
-    nextGetData = {
-      settings: { nas_base_path: '/data' },
-      mode: 'standalone',
-      revision: 'revision-1',
-    }
-    nextPutData = {
-      settings: { nas_base_path: '/mnt' },
-      mode: 'standalone',
-      revision: 'revision-2',
-    }
-
-    const settings = usePluginSettings<{ nas_base_path?: string }>({
-      apiBaseUrl: '/api/drp',
-      loadOnMount: false,
-    })
-    await settings.load()
-    const ok = await settings.save({ nas_base_path: '/mnt' })
-
-    expect(ok).toBe(true)
-    expect(requestConfigs[0]!.baseURL).toBe('/api/drp')
-    expect(requestConfigs[0]!.url).toBe('/settings')
-    expect(requestConfigs[1]!.baseURL).toBe('/api/drp')
-    expect(requestConfigs[1]!.url).toBe('/settings')
-    expect(requestConfigs[1]!.headers).toEqual({ 'If-Match': '"revision-1"' })
-    expect(requestBodies[0]).toEqual({ nas_base_path: '/mnt' })
-    expect(settings.settingsConfig.value.values).toEqual({ nas_base_path: '/mnt' })
-  })
-
-  it('streams plugin events with auth headers and SSE parsing', async () => {
-    const authStore = useAuthStore()
-    authStore.setToken('stream-token', 3600)
-    const onMessage = vi.fn()
-    const streamBody = new ReadableStream({
-      start(controller) {
-        controller.enqueue(new TextEncoder().encode('event: progress\nid: 7\ndata: {"pct":50}\n\n'))
-        controller.close()
-      },
-    })
-    const fetchMock = vi.fn(async (_url: RequestInfo | URL, _init?: RequestInit) =>
-      new Response(streamBody, { status: 200 }),
-    )
-    vi.stubGlobal('fetch', fetchMock)
-
-    const stream = usePluginEventStream<{ pct: number }>(
-      contract,
-      { method: 'get', path: '/downloads/events' },
-      {
-        parseJson: true,
-        reconnect: false,
-        onMessage,
-      },
-    )
-
-    await vi.waitFor(() => {
-      expect(onMessage).toHaveBeenCalledOnce()
-    })
-
-    expect(fetchMock).toHaveBeenCalledOnce()
-    const [url, init] = fetchMock.mock.calls[0]!
-    expect(url).toBe('/api/drp/downloads/events')
-    expect((init?.headers as Headers).get('Authorization')).toBe('Bearer stream-token')
-    expect((init?.headers as Headers).get('Accept')).toBe('text/event-stream')
-    expect(onMessage).toHaveBeenCalledWith({
-      event: 'progress',
-      data: { pct: 50 },
-      id: '7',
-      retry: undefined,
-      raw: 'event: progress\nid: 7\ndata: {"pct":50}',
-    })
-    expect(stream.lastMessage.value?.data).toEqual({ pct: 50 })
-    expect(stream.lastEventId.value).toBe('7')
-  })
-
-  it('omits MINT auth from a public plugin event stream', async () => {
-    const authStore = useAuthStore()
-    authStore.setToken('stream-token', 3600)
-    const fetchMock = vi.fn<typeof fetch>(async () =>
-      new Response(new ReadableStream({ start: controller => controller.close() }), {
-        status: 200,
-      }),
-    )
-    vi.stubGlobal('fetch', fetchMock)
-
-    usePluginEventStream(
-      contract,
-      { method: 'get', path: '/public/events', requiresAuth: false },
-      { reconnect: false },
-    )
-
-    await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledOnce())
-    const [, init] = fetchMock.mock.calls[0]!
-
-    expect((init?.headers as Headers).get('Authorization')).toBeNull()
-  })
-
-  it('normalizes stream auth failures and does not reconnect rejected requests', async () => {
-    const authStore = useAuthStore()
-    authStore.setToken('expired-stream-token', 3600)
-    const onError = vi.fn()
-    const fetchMock = vi.fn(async () => new Response(null, { status: 401 }))
-    vi.stubGlobal('fetch', fetchMock)
-
-    const stream = usePluginEventStream(
-      contract,
-      { method: 'get', path: '/downloads/events' },
-      { reconnectDelayMs: 1, onError },
-    )
-
-    await vi.waitFor(() => expect(onError).toHaveBeenCalledOnce())
-    await new Promise((resolve) => setTimeout(resolve, 10))
-
-    expect({
-      attempts: fetchMock.mock.calls.length,
-      errorType: onError.mock.calls[0]![0]?.constructor,
-      message: stream.error.value,
-      token: authStore.token,
-    }).toEqual({
-      attempts: 1,
-      errorType: AuthenticationRequiredError,
-      message: 'Authentication required. Please sign in again.',
-      token: null,
-    })
-  })
-
-  it('parses generated typed event streams as JSON by default', async () => {
-    const onMessage = vi.fn()
-    const streamBody = new ReadableStream({
-      start(controller) {
-        controller.enqueue(new TextEncoder().encode('event: job\ndata: {"job_id":"fit"}\n\n'))
-        controller.close()
-      },
-    })
-    vi.stubGlobal('fetch', vi.fn(async () => new Response(streamBody, { status: 200 })))
-
-    usePluginEventStream<{ job_id: string }>(
-      contract,
-      {
-        method: 'get',
-        path: '/jobs/events',
-        eventStream: true,
-        responseType: 'JobStatePayload | JobSnapshotPayload',
-      },
-      { reconnect: false, onMessage },
-    )
-
-    await vi.waitFor(() => {
-      expect(onMessage).toHaveBeenCalledOnce()
-    })
-    expect(onMessage.mock.calls[0]![0].data).toEqual({ job_id: 'fit' })
-  })
-
-  it('should deliver terminal enrichment on the original generated stream', async () => {
-    type JobStreamData = {
-      jobs?: Array<Record<string, unknown>>
-      job_id?: string
-      can_delete?: boolean
-      output_path?: string | null
-    }
-    const onMessage = vi.fn()
-    const streamBody = new ReadableStream({
-      start(controller) {
-        controller.enqueue(new TextEncoder().encode(
-          'event: snapshot\ndata: {"jobs":[{"job_id":"fit","can_delete":false,"output_path":null}]}\n\n'
-          + 'event: terminal\ndata: {"job_id":"fit","can_delete":true,"output_path":"/results/final.csv"}\n\n',
-        ))
-        controller.close()
-      },
-    })
-    const fetchMock = vi.fn(async () => new Response(streamBody, { status: 200 }))
-    vi.stubGlobal('fetch', fetchMock)
-
-    const stream = usePluginEventStream<JobStreamData>(
-      contract,
-      {
-        method: 'get',
-        path: '/jobs/events',
-        eventStream: true,
-        responseType: 'JobStatePayload | JobSnapshotPayload',
-      },
-      { reconnect: false, onMessage },
-    )
-
-    await vi.waitFor(() => {
-      expect({
-        fetches: fetchMock.mock.calls.length,
-        events: onMessage.mock.calls.map(([message]) => message.event),
-        last: stream.lastMessage.value?.data,
-      }).toEqual({
-        fetches: 1,
-        events: ['snapshot', 'terminal'],
-        last: {
-          job_id: 'fit',
-          can_delete: true,
-          output_path: '/results/final.csv',
-        },
-      })
-    })
-  })
-
-  it('keeps generated string event streams as text by default', async () => {
-    const onMessage = vi.fn()
-    const streamBody = new ReadableStream({
-      start(controller) {
-        controller.enqueue(new TextEncoder().encode('event: ready\ndata: ready\n\n'))
-        controller.close()
-      },
-    })
-    vi.stubGlobal('fetch', vi.fn(async () => new Response(streamBody, { status: 200 })))
-
-    usePluginEventStream(
-      contract,
-      {
-        method: 'get',
-        path: '/jobs/events',
-        eventStream: true,
-        responseType: 'string',
-      },
-      { reconnect: false, onMessage },
-    )
-
-    await vi.waitFor(() => {
-      expect(onMessage).toHaveBeenCalledOnce()
-    })
-    expect(onMessage.mock.calls[0]![0].data).toBe('ready')
-  })
-
-  it('should keep start idempotent when an event stream is active', async () => {
-    const active = pendingEventStreamResponse()
-    const fetchMock = vi.fn(async () => active.response)
-    vi.stubGlobal('fetch', fetchMock)
-    const stream = usePluginEventStream(
-      contract,
-      { method: 'get', path: '/downloads/events' },
-      { immediate: false },
-    )
-
-    try {
-      stream.start()
-      stream.start()
-      await Promise.resolve()
-
-      expect(fetchMock).toHaveBeenCalledOnce()
-    } finally {
-      stream.stop()
-      active.close()
-    }
-  })
-
-  it('should keep replacement stream connected when an old connection finishes', async () => {
-    const oldFetch = deferred<Response>()
-    const replacement = pendingEventStreamResponse()
-    const fetchMock = vi.fn()
-      .mockReturnValueOnce(oldFetch.promise)
-      .mockResolvedValueOnce(replacement.response)
-    vi.stubGlobal('fetch', fetchMock)
-    const stream = usePluginEventStream(
-      contract,
-      { method: 'get', path: '/downloads/events' },
-      { immediate: false },
-    )
-
-    try {
-      stream.start()
-      stream.stop()
-      stream.start()
-      await Promise.resolve()
-      await Promise.resolve()
-      oldFetch.resolve(new Response('', { status: 200 }))
-      await Promise.resolve()
-      await Promise.resolve()
-
-      expect(stream.isConnected.value).toBe(true)
-    } finally {
-      stream.stop()
-      replacement.close()
-    }
-  })
-
-  it('should not reconnect after a stale event stream finishes', async () => {
-    vi.useFakeTimers()
-    const oldFetch = deferred<Response>()
-    const replacement = pendingEventStreamResponse()
-    const fetchMock = vi.fn()
-      .mockReturnValueOnce(oldFetch.promise)
-      .mockResolvedValueOnce(replacement.response)
-      .mockResolvedValue(new Response('', { status: 200 }))
-    vi.stubGlobal('fetch', fetchMock)
-    const stream = usePluginEventStream(
-      contract,
-      { method: 'get', path: '/downloads/events' },
-      { immediate: false, reconnectDelayMs: 10 },
-    )
-
-    try {
-      stream.start()
-      stream.stop()
-      stream.start()
-      await Promise.resolve()
-      oldFetch.resolve(new Response('', { status: 200 }))
-      await Promise.resolve()
-      await vi.advanceTimersByTimeAsync(10)
-
-      expect(fetchMock).toHaveBeenCalledTimes(2)
-    } finally {
-      stream.stop()
-      replacement.close()
-    }
-  })
-
-  it('should not call onOpen after a synchronous restart invalidates the stream', async () => {
-    const oldConnection = pendingEventStreamResponse()
-    const replacement = pendingEventStreamResponse()
-    const fetchMock = vi.fn()
-      .mockResolvedValueOnce(oldConnection.response)
-      .mockResolvedValueOnce(replacement.response)
-    vi.stubGlobal('fetch', fetchMock)
-    const onOpen = vi.fn()
-    const stream = usePluginEventStream(
-      contract,
-      { method: 'get', path: '/downloads/events' },
-      { immediate: false, onOpen },
-    )
-    let restarted = false
-    const stopWatching = watch(
-      stream.isConnected,
-      (connected) => {
-        if (!connected || restarted) return
-        restarted = true
-        stream.stop()
-        stream.start()
-      },
-      { flush: 'sync' },
-    )
-
-    try {
-      stream.start()
-      await vi.waitFor(() => expect(onOpen).toHaveBeenCalledOnce())
-    } finally {
-      stopWatching()
-      stream.stop()
-      oldConnection.close()
-      replacement.close()
-    }
-  })
-
-  it('should not fetch after a synchronous setup restart invalidates the stream', async () => {
-    const replacement = pendingEventStreamResponse()
-    const stale = pendingEventStreamResponse()
-    const fetchMock = vi.fn()
-      .mockResolvedValueOnce(replacement.response)
-      .mockResolvedValueOnce(stale.response)
-    vi.stubGlobal('fetch', fetchMock)
-    const stream = usePluginEventStream(
-      contract,
-      { method: 'get', path: '/downloads/events' },
-      { immediate: false },
-    )
-    let restarted = false
-    const stopWatching = watch(
-      stream.isConnecting,
-      (connecting) => {
-        if (!connecting || restarted) return
-        restarted = true
-        stream.stop()
-        stream.start()
-      },
-      { flush: 'sync' },
-    )
-
-    try {
-      stream.start()
-      await Promise.resolve()
-
-      expect(fetchMock).toHaveBeenCalledOnce()
-    } finally {
-      stopWatching()
-      stream.stop()
-      replacement.close()
-      stale.close()
-    }
-  })
-
-  it('can build path-only endpoint URLs with inferred experiment ids', () => {
-    window.history.replaceState({}, '', '/experiments/42/plugins/drp')
-
-    const url = buildPluginEndpointUrl(
-      contract,
-      {
-        method: 'get',
-        path: '/experiments/{experimentId}/summary',
-        pathParams: ['experimentId'],
-        queryParams: [
-          { name: 'include_qc', fieldName: 'includeQc', type: 'boolean', required: false },
-        ],
-      },
-      { includeQc: true },
-      { includeBaseUrl: false },
-    )
-
-    expect(url).toBe('/experiments/42/summary?include_qc=true')
-  })
-
-  it('validates required query params when building endpoint URLs', () => {
-    expect(() => buildPluginEndpointUrl(
-      contract,
-      {
-        method: 'get',
-        path: '/search',
-        queryParams: [
-          { name: 'q', fieldName: 'q', type: 'string', required: true },
-        ],
-      },
-      {},
-    )).toThrow("[MINT SDK] Missing query parameter 'q' for plugin endpoint /search")
-  })
-
-  it('replaces path params and sends request body', async () => {
-    type Client = {
-      analyze(params: { experimentId: number; body: { threshold: number } }): Promise<unknown>
-    }
-    const client = createPluginClient<Client>(contract, {
-      endpoints: {
-        analyze: {
-          method: 'post',
-          path: '/analyze/{experimentId}',
-          pathParams: ['experimentId'],
-          hasBody: true,
-        },
-      },
-    })
-
-    await client.analyze({ experimentId: 42, body: { threshold: 0.5 } })
-
-    expect(requestConfigs[0]!.url).toBe('/analyze/42')
-    expect(requestConfigs[0]!.params).toBeUndefined()
-    expect(requestBodies[0]).toEqual({ threshold: 0.5 })
-  })
-
-  it('infers experimentId path params from the current platform route', async () => {
-    window.history.replaceState({}, '', '/experiments/42/plugins/drp')
-    type Client = {
-      analyze(params: { body: { threshold: number } }): Promise<unknown>
-    }
-    const client = createPluginClient<Client>(contract, {
-      endpoints: {
-        analyze: {
-          method: 'post',
-          path: '/analyze/{experimentId}',
-          pathParams: ['experimentId'],
-          hasBody: true,
-        },
-      },
-    })
-
-    await client.analyze({ body: { threshold: 0.5 } })
-
-    expect(requestConfigs[0]!.url).toBe('/analyze/42')
-    expect(requestConfigs[0]!.params).toBeUndefined()
-    expect(requestBodies[0]).toEqual({ threshold: 0.5 })
-  })
-
-  it('sends query params for non-GET endpoints with request bodies', async () => {
-    type Client = {
-      analyze(params: {
-        experimentId: number
-        dryRun?: boolean
-        body: { threshold: number }
-      }): Promise<unknown>
-    }
-    const client = createPluginClient<Client>(contract, {
-      endpoints: {
-        analyze: {
-          method: 'post',
-          path: '/analyze/{experimentId}',
-          pathParams: ['experimentId'],
-          queryParams: [
-            { name: 'dry_run', fieldName: 'dryRun', type: 'boolean', required: false },
-          ],
-          hasBody: true,
-        },
-      },
-    })
-
-    await client.analyze({
-      experimentId: 42,
-      dryRun: true,
-      body: { threshold: 0.5 },
-    })
-
-    expect(requestConfigs[0]!.url).toBe('/analyze/42')
-    expect(requestConfigs[0]!.params).toEqual({ dry_run: true })
-    expect(requestBodies[0]).toEqual({ threshold: 0.5 })
-  })
-
-  it('sends structured generated payloads with path params, query params, and bodies', async () => {
-    type Client = {
-      analyze(params: {
-        pathParams: { experimentId: number }
-        query?: { dryRun?: boolean }
-        body: { threshold: number }
-      }): Promise<unknown>
-    }
-    const client = createPluginClient<Client>(contract, {
-      endpoints: {
-        analyze: {
-          method: 'post',
-          path: '/analyze/{experimentId}',
-          pathParams: ['experimentId'],
-          queryParams: [
-            { name: 'dry_run', fieldName: 'dryRun', type: 'boolean', required: false },
-          ],
-          hasBody: true,
-        },
-      },
-    })
-
-    await client.analyze({
-      pathParams: { experimentId: 42 },
-      query: { dryRun: true },
-      body: { threshold: 0.5 },
-    })
-
-    expect(requestConfigs[0]!.url).toBe('/analyze/42')
-    expect(requestConfigs[0]!.params).toEqual({ dry_run: true })
-    expect(requestBodies[0]).toEqual({ threshold: 0.5 })
-  })
-
-  it('throws a clear error before requests with missing request bodies', async () => {
-    type Client = {
-      analyze(params: { experimentId: number; body?: { threshold: number } }): Promise<unknown>
-    }
-    const client = createPluginClient<Client>(contract, {
-      endpoints: {
-        analyze: {
-          method: 'post',
-          path: '/analyze/{experimentId}',
-          pathParams: ['experimentId'],
-          hasBody: true,
-        },
-      },
-    })
-
-    await expect(client.analyze({ experimentId: 42 })).rejects.toThrow(
-      '[MINT SDK] Missing request body for plugin endpoint /analyze/{experimentId}',
-    )
-    expect(requestConfigs).toHaveLength(0)
-  })
-
-  it('sends request bodies and query params for DELETE endpoints', async () => {
-    type Client = {
-      purge(params: { dryRun?: boolean; body: { reason: string } }): Promise<unknown>
-    }
-    const client = createPluginClient<Client>(contract, {
-      endpoints: {
-        purge: {
-          method: 'delete',
-          path: '/purge',
-          queryParams: [
-            { name: 'dry_run', fieldName: 'dryRun', type: 'boolean', required: false },
-          ],
-          hasBody: true,
-        },
-      },
-    })
-
-    await client.purge({ dryRun: true, body: { reason: 'duplicate' } })
-
-    expect(requestConfigs[0]!.url).toBe('/purge')
-    expect(requestConfigs[0]!.params).toEqual({ dry_run: true })
-    expect(requestBodies[0]).toEqual({ reason: 'duplicate' })
-  })
-
-  it('sends non-path GET params as query params', async () => {
-    type Client = {
-      search(params: { experimentId: number; q?: string; limit?: number; includeArchived?: boolean }): Promise<unknown>
-    }
-    const client = createPluginClient<Client>(contract, {
-      endpoints: {
-        search: {
-          method: 'get',
-          path: '/experiments/{experimentId}/search',
-          pathParams: ['experimentId'],
-          queryParams: [
-            { name: 'q', fieldName: 'q', type: 'string', required: false },
-            { name: 'limit', fieldName: 'limit', type: 'number', required: false },
-            { name: 'include_archived', fieldName: 'includeArchived', type: 'boolean', required: false },
-          ],
-        },
-      },
-    })
-
-    await client.search({ experimentId: 42, q: 'glucose', limit: 20, includeArchived: true })
-
-    expect(requestConfigs[0]!.url).toBe('/experiments/42/search')
-    expect(requestConfigs[0]!.params).toEqual({ q: 'glucose', limit: 20, include_archived: true })
-  })
-
-  it('throws a clear error before requests with missing required query params', async () => {
-    type Client = {
-      search(params: { experimentId: number; q?: string }): Promise<unknown>
-    }
-    const client = createPluginClient<Client>(contract, {
-      endpoints: {
-        search: {
-          method: 'get',
-          path: '/experiments/{experimentId}/search',
-          pathParams: ['experimentId'],
-          queryParams: [
-            { name: 'q', fieldName: 'q', type: 'string', required: true },
-          ],
-        },
-      },
-    })
-
-    await expect(client.search({ experimentId: 42 })).rejects.toThrow(
-      "[MINT SDK] Missing query parameter 'q' for plugin endpoint /experiments/{experimentId}/search",
-    )
-    expect(requestConfigs).toHaveLength(0)
-  })
-
-  it('loads the current experiment from URL conventions', async () => {
-    window.history.replaceState({}, '', '/analysis?experimentId=42')
-    const current = useCurrentExperiment<{ called: string }>({ immediate: false })
-
-    expect(current.experimentId.value).toBe(42)
-    expect(current.hasExperiment.value).toBe(true)
-    expect(current.requireExperimentId()).toBe(42)
-    expect(current.lastLoadedAt.value).toBeNull()
-
-    const pending = current.refresh()
-    expect(current.isLoading.value).toBe(true)
-    await pending
-
-    expect(requestConfigs[0]!.url).toBe('/experiments/42')
-    expect(current.experiment.value).toEqual({ called: '/experiments/42' })
-    expect(current.error.value).toBeNull()
-    expect(current.isLoading.value).toBe(false)
-    expect(current.lastLoadedAt.value).toBeInstanceOf(Date)
-  })
-
-  it('throws a clear error when a current experiment is required but missing', () => {
-    const current = useCurrentExperiment({ immediate: false })
-
-    expect(current.experimentId.value).toBeUndefined()
-    expect(current.hasExperiment.value).toBe(false)
-    expect(() => current.requireExperimentId()).toThrow('[MINT SDK] No current experiment is selected.')
-  })
-
-  it('loads the current experiment from platform route paths', async () => {
-    window.history.replaceState({}, '', '/projects/3/experiments/42/plugins/drp')
-    const current = useCurrentExperiment<{ called: string }>({ immediate: false })
-
-    expect(current.experimentId.value).toBe(42)
-
-    await current.refresh()
-
-    expect(requestConfigs[0]!.url).toBe('/experiments/42')
-  })
-
-  it('loads the current experiment from hash route paths', async () => {
-    window.history.replaceState({}, '', '/plugins/drp#/experiments/43/analysis')
-    const current = useCurrentExperiment<{ called: string }>({ immediate: false })
-
-    expect(current.experimentId.value).toBe(43)
-  })
-
-  it('returns undefined and preserves sync state on current experiment load failure', async () => {
-    window.history.replaceState({}, '', '/analysis?experimentId=42')
-    nextGetError = new Error('network down')
-    const current = useCurrentExperiment<{ called: string }>({ immediate: false })
-
-    const result = await current.refresh()
-
-    expect(result).toBeUndefined()
-    expect(requestConfigs[0]!.url).toBe('/experiments/42')
-    expect(current.experiment.value).toBeUndefined()
-    expect(current.error.value).toBe('network down')
-    expect(current.isLoading.value).toBe(false)
-    expect(current.lastLoadedAt.value).toBeNull()
-  })
-
-  it('prefers platform-injected experiment context and API base', async () => {
-    ;(window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__ = {
-      isIntegrated: true,
-      theme: 'light',
-      platformApiUrl: '/api/platform',
-      currentExperimentId: '7',
-      plugin: {
-        id: 'drp',
-        name: 'DRP',
-        version: '1.0.0',
-        route_prefix: '/drp',
-        api_prefix: '/api/platform-drp',
-      },
-    }
-    const current = useCurrentExperiment<{ called: string }>({ immediate: false })
-
-    expect(current.experimentId.value).toBe(7)
-
-    await current.fetch()
-
-    expect(requestConfigs[0]!.baseURL).toBe('/api/platform')
-    expect(requestConfigs[0]!.url).toBe('/experiments/7')
-  })
-})