@morscherlab/mint-sdk 1.1.0-beta.4 → 1.1.0-beta.6

package/package.json

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

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

@@ -3,6 +3,58 @@ import { describe, expect, it } from 'vitest'
 import BaseSelect from '../../components/BaseSelect.vue'
 
 describe('BaseSelect', () => {
+  it('forwards native attributes to the select instead of the wrapper', () => {
+    const wrapper = mount(BaseSelect, {
+      props: {
+        options: ['linear'],
+      },
+      attrs: {
+        id: 'curve-model',
+        name: 'curve-model',
+        'aria-label': 'Curve model',
+        'data-testid': 'curve-model-select',
+        class: 'curve-model-layout',
+        style: 'width: 12rem;',
+      },
+    })
+
+    const select = wrapper.get('select')
+
+    expect({
+      select: {
+        id: select.attributes('id'),
+        name: select.attributes('name'),
+        ariaLabel: select.attributes('aria-label'),
+        testId: select.attributes('data-testid'),
+        layoutClass: select.classes().includes('curve-model-layout'),
+      },
+      wrapper: {
+        id: wrapper.attributes('id'),
+        name: wrapper.attributes('name'),
+        ariaLabel: wrapper.attributes('aria-label'),
+        testId: wrapper.attributes('data-testid'),
+        layoutClass: wrapper.classes().includes('curve-model-layout'),
+        style: wrapper.attributes('style'),
+      },
+    }).toEqual({
+      select: {
+        id: 'curve-model',
+        name: 'curve-model',
+        ariaLabel: 'Curve model',
+        testId: 'curve-model-select',
+        layoutClass: false,
+      },
+      wrapper: {
+        id: undefined,
+        name: undefined,
+        ariaLabel: undefined,
+        testId: undefined,
+        layoutClass: true,
+        style: 'width: 12rem;',
+      },
+    })
+  })
+
   it('accepts string and number shorthand options', async () => {
     const wrapper = mount(BaseSelect, {
       props: {

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

@@ -0,0 +1,40 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+import BaseToggle from '../../components/BaseToggle.vue'
+
+describe('BaseToggle', () => {
+  it('uses ariaLabel for the switch name without changing the visual label', () => {
+    const wrapper = mount(BaseToggle, {
+      props: {
+        label: 'Enabled',
+        ariaLabel: 'Email notifications',
+      },
+    })
+
+    expect({
+      accessibleName: wrapper.get('[role="switch"]').attributes('aria-label'),
+      visualText: wrapper.text(),
+      wrapperAriaLabel: wrapper.attributes('aria-label'),
+    }).toEqual({
+      accessibleName: 'Email notifications',
+      visualText: 'Enabled',
+      wrapperAriaLabel: undefined,
+    })
+  })
+
+  it('keeps using the visual label as the default switch name', () => {
+    const wrapper = mount(BaseToggle, {
+      props: {
+        label: 'Enabled',
+      },
+    })
+
+    expect(wrapper.get('[role="switch"]').attributes('aria-label')).toBe('Enabled')
+  })
+
+  it('keeps the existing fallback name when no labels are provided', () => {
+    const wrapper = mount(BaseToggle)
+
+    expect(wrapper.get('[role="switch"]').attributes('aria-label')).toBe('Toggle')
+  })
+})

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

@@ -190,6 +190,16 @@ describe('GeneratedPluginView', () => {
     expect(wrapper.find('[aria-label="Job resource requirements"]').text()).toBe('Host service')
   })
 
+  it('describes process CPU declarations as an upper bound', async () => {
+    const wrapper = mount(GeneratedPluginView, {
+      props: { baseUrl: '/api/demo' },
+      global: { plugins: [createPinia()], stubs: { 'router-link': true, Teleport: true } },
+    })
+    await flushPromises()
+
+    expect(wrapper.find('[aria-label="Job resource requirements"]').text()).toBe('Up to 2 CPU')
+  })
+
   it('should pass the host transport to the generated analysis composable', async () => {
     const transport = vi.fn()
     mount(GeneratedPluginView, {

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

@@ -1,4 +1,5 @@
 import { flushPromises, mount } from '@vue/test-utils'
+import type { VueWrapper } from '@vue/test-utils'
 import { createPinia } from 'pinia'
 import { computed, h, nextTick, ref } from 'vue'
 import { describe, expect, it, vi } from 'vitest'
@@ -10,7 +11,7 @@ import ExperimentSelectorModal from '../../components/ExperimentSelectorModal.vu
 import PluginWorkspaceView from '../../components/PluginWorkspaceView.vue'
 import { defineDoseDesignControlModel } from '../../composables/useControlSchema'
 import { usePlatformContext } from '../../composables/usePlatformContext'
-import type { PillNavItem, SidebarToolSection } from '../../types'
+import type { PageSelectorItemInput, PillNavItem, SidebarToolSection } from '../../types'
 
 vi.mock('../../composables/usePlatformContext', () => ({
   usePlatformContext: vi.fn(() => ({
@@ -79,6 +80,44 @@ const globalOptions = {
   },
 }
 
+interface PageSelectorWorkspaceProps {
+  pageSelector?: PageSelectorItemInput[]
+  currentPageSelectorId?: string
+}
+
+function mountIntegratedPageSelectorWorkspace(
+  props: PageSelectorWorkspaceProps = {},
+): VueWrapper {
+  vi.mocked(usePlatformContext).mockReturnValueOnce({
+    isIntegrated: computed(() => true),
+    context: ref({ isIntegrated: true, theme: 'system' }),
+    plugin: computed(() => ({
+      id: 'workspace-plugin',
+      name: 'Workspace Plugin',
+      version: '1.0.0',
+      route_prefix: '/workspace-plugin',
+      api_prefix: '/api/workspace-plugin',
+      nav_items: [
+        { path: '/platform-one', label: 'Platform One' },
+        { path: '/platform-two', label: 'Platform Two' },
+      ],
+    })),
+    user: computed(() => undefined),
+    theme: computed(() => 'system' as const),
+    features: computed(() => undefined),
+    navigate: vi.fn(),
+    notify: vi.fn(),
+    sendToPlatform: vi.fn(),
+  })
+  return mount(PluginWorkspaceView, {
+    props: {
+      title: 'Workspace',
+      ...props,
+    },
+    global: globalOptions,
+  })
+}
+
 describe('PluginWorkspaceView', () => {
   it('renders the standard AppLayout, AppTopBar, and AppSidebar plugin shell', () => {
     const wrapper = mount(PluginWorkspaceView, {
@@ -146,22 +185,37 @@ describe('PluginWorkspaceView', () => {
     expect(wrapper.emitted('pill-select')).toEqual([[{ id: 'results', label: 'Results' }]])
   })
 
-  it('hides topbar page selector until multiple pages are registered', () => {
-    const wrapper = mount(PluginWorkspaceView, {
-      props: {
-        title: 'Downloader',
-        subtitle: 'Downloads',
-        pageSelector: [
-          { id: 'downloads', label: 'Downloads', to: '/' },
-        ],
-        currentPageSelectorId: 'downloads',
-      },
-      global: globalOptions,
+  it('should use platform pages when pageSelector is omitted', () => {
+    const wrapper = mountIntegratedPageSelectorWorkspace()
+
+    expect(wrapper.find('.mint-page-selector').exists()).toBe(true)
+  })
+
+  it('should suppress platform pages when pageSelector is explicitly empty', () => {
+    const wrapper = mountIntegratedPageSelectorWorkspace({ pageSelector: [] })
+
+    expect(wrapper.find('.mint-page-selector').exists()).toBe(false)
+  })
+
+  it('should hide one explicit page without falling back to platform pages', () => {
+    const wrapper = mountIntegratedPageSelectorWorkspace({
+      pageSelector: [{ id: 'downloads', label: 'Downloads', to: '/' }],
+      currentPageSelectorId: 'downloads',
     })
 
-    expect(wrapper.findComponent(AppTopBar).props('pageSelector')).toBeUndefined()
     expect(wrapper.find('.mint-page-selector').exists()).toBe(false)
-    expect(wrapper.find('.mint-topbar-title-group').text()).toContain('Downloader')
+  })
+
+  it('should render multiple explicit pages ahead of platform pages', () => {
+    const wrapper = mountIntegratedPageSelectorWorkspace({
+      pageSelector: [
+        { id: 'overview', label: 'Overview', to: '/' },
+        { id: 'reports', label: 'Reports', to: '/reports' },
+      ],
+      currentPageSelectorId: 'overview',
+    })
+
+    expect(wrapper.get('.mint-page-selector__label').text()).toBe('Overview')
   })
 
   it('passes compact control models to the sidebar for generated forms', () => {

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

@@ -0,0 +1,77 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  buildAnalysisArtifactTargetQuery,
+  parseAnalysisArtifactTarget,
+} from '../../composables/analysisArtifactTarget'
+import {
+  currentExperimentIdFromUrl,
+  resolveCurrentPluginId,
+} from '../../composables/platformContextHelpers'
+
+describe('analysis artifact target', () => {
+  afterEach(() => {
+    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
+    vi.unstubAllGlobals()
+  })
+
+  it('should resolve the canonical injected plugin id', () => {
+    ;(window as unknown as { __MINT_PLATFORM__: unknown }).__MINT_PLATFORM__ = {
+      isIntegrated: true,
+      plugin: { id: 'LEAF', name: 'Leaf UI' },
+      theme: 'system',
+    }
+
+    expect(resolveCurrentPluginId()).toBe('LEAF')
+  })
+
+  it('should tolerate a host that provides a partial location object', () => {
+    vi.stubGlobal('window', {
+      location: { search: '' },
+    })
+
+    expect(currentExperimentIdFromUrl()).toBeUndefined()
+  })
+
+  it('should build the canonical readable query when an artifact id hint is present', () => {
+    const query = buildAnalysisArtifactTargetQuery({
+      experimentId: 66,
+      artifactPluginId: 'LEAF',
+      artifactKey: 'exp316_260703_ys_rna_ide_scr',
+      artifactId: 206,
+    })
+
+    expect(query.toString()).toBe(
+      'experiment_id=66&artifact_plugin_id=LEAF'
+      + '&artifact_key=exp316_260703_ys_rna_ide_scr&artifact_id=206',
+    )
+  })
+
+  it('should parse the canonical identity without requiring an artifact id hint', () => {
+    const target = parseAnalysisArtifactTarget(new URLSearchParams(
+      'experiment_id=66&artifact_plugin_id=LEAF&artifact_key=result',
+    ))
+
+    expect(target).toEqual({
+      experimentId: 66,
+      artifactPluginId: 'LEAF',
+      artifactKey: 'result',
+    })
+  })
+
+  it('should reject an incomplete target instead of guessing another artifact', () => {
+    const target = parseAnalysisArtifactTarget(new URLSearchParams(
+      'experiment_id=66&artifact_key=result',
+    ))
+
+    expect(target).toBeNull()
+  })
+
+  it('should reject non-positive numeric identifiers', () => {
+    const target = parseAnalysisArtifactTarget(new URLSearchParams(
+      'experiment_id=0&artifact_plugin_id=LEAF&artifact_key=result&artifact_id=-1',
+    ))
+
+    expect(target).toBeNull()
+  })
+})

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

@@ -19,7 +19,10 @@ vi.mock('../../composables/useApi', () => ({
 }))
 
 import { useAnalysisArtifacts } from '../../composables/useAnalysisArtifacts'
-import type { AnalysisArtifactSummary } from '../../types/analysisArtifactTypes'
+import type {
+  AnalysisArtifactDetail,
+  AnalysisArtifactSummary,
+} from '../../types/analysisArtifactTypes'
 
 // ---------------------------------------------------------------------------
 // Fixtures
@@ -177,6 +180,76 @@ describe('useAnalysisArtifacts', () => {
     })
   })
 
+  describe('resolveTarget', () => {
+    it('should resolve the exact stable identity when the numeric hint is stale', async () => {
+      const detail = {
+        ...makeArtifact({
+          id: 2,
+          experiment_id: 42,
+          plugin_id: 'plugin-b',
+          artifact_key: 'peaks',
+        }),
+        result: { schema_version: 'mint.analysis_file.v1' },
+        tree: [],
+        summary: null,
+      } satisfies AnalysisArtifactDetail
+      mockGet
+        .mockResolvedValueOnce({ artifacts: ARTIFACTS })
+        .mockResolvedValueOnce(detail)
+      const { resolveTarget } = setup()
+
+      const resolved = await resolveTarget({
+        experimentId: 42,
+        artifactPluginId: 'plugin-b',
+        artifactKey: 'peaks',
+        artifactId: 999,
+      })
+
+      expect({
+        resolvedId: resolved?.id,
+        detailPath: mockGet.mock.calls[1]?.[0],
+      }).toEqual({
+        resolvedId: 2,
+        detailPath: '/experiments/42/analysis-artifacts/2',
+      })
+    })
+
+    it('should fail explicitly when the stable identity is not available', async () => {
+      const { resolveTarget, error } = setup()
+
+      const resolved = await resolveTarget({
+        experimentId: 42,
+        artifactPluginId: 'LEAF',
+        artifactKey: 'missing',
+      })
+
+      expect({ resolved, error: error.value }).toEqual({
+        resolved: null,
+        error: 'Analysis artifact LEAF/missing is not available.',
+      })
+    })
+
+    it('should reject a target from another experiment before making a request', async () => {
+      const { resolveTarget, error } = setup()
+
+      const resolved = await resolveTarget({
+        experimentId: 66,
+        artifactPluginId: 'LEAF',
+        artifactKey: 'result',
+      })
+
+      expect({
+        resolved,
+        error: error.value,
+        requests: mockGet.mock.calls,
+      }).toEqual({
+        resolved: null,
+        error: 'Analysis artifact target belongs to experiment 66, not 42.',
+        requests: [],
+      })
+    })
+  })
+
   // -------------------------------------------------------------------------
   // experiment id resolution
   // -------------------------------------------------------------------------

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

@@ -407,6 +407,7 @@ describe('useGeneratedAnalysis', () => {
         uploadUrl: upload?.[0],
         uploadMethod: upload?.[1]?.method,
         uploadSessionHeader: new Headers(upload?.[1]?.headers).get('X-Mint-Job-Session'),
+        uploadDefinitionHeader: new Headers(upload?.[1]?.headers).get('X-Mint-Job-Definition'),
         sessionId: form.get('session_id'),
         relativePaths: form.getAll('relative_paths'),
         submittedSource: submit.inputs.source,
@@ -414,6 +415,7 @@ describe('useGeneratedAnalysis', () => {
         uploadUrl: '/api/demo/jobs/uploads',
         uploadMethod: 'POST',
         uploadSessionHeader: 'session-1',
+        uploadDefinitionHeader: 'run',
         sessionId: 'session-1',
         relativePaths: ['data.csv'],
         submittedSource: { token: 'upload-token' },

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

@@ -22,12 +22,37 @@ import { AuthenticationRequiredError } from '../../composables/useApi'
 import { useAuthStore } from '../../stores/auth'
 
 const contract: PluginContract = {
-  schemaVersion: 1,
+  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',
 }
@@ -818,6 +843,16 @@ describe('usePluginClient', () => {
     })
   })
 
+  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,

package/src/components/BaseSelect.vue

@@ -1,9 +1,12 @@
 <script setup lang="ts">
 /** Renders a native `<select>` element with size, error, and disabled states. */
-import { computed } from 'vue'
+import { computed, useAttrs } from 'vue'
+import type { HTMLAttributes } from 'vue'
 import type { SelectOption, SelectOptionInput } from '../types'
 import { findOptionByDomValue, normalizeOptionInput } from '../utils/options'
 
+defineOptions({ inheritAttrs: false })
+
 interface Props {
   modelValue?: string | number
   options: SelectOptionInput<string | number>[]
@@ -19,6 +22,16 @@ const props = withDefaults(defineProps<Props>(), {
   error: false,
   size: 'md',
 })
+const attrs = useAttrs()
+
+const controlAttrs = computed(() => {
+  const { class: _class, style: _style, ...nativeAttrs } = attrs
+  return nativeAttrs
+})
+const wrapperAttrs = computed<Pick<HTMLAttributes, 'class' | 'style'>>(() => ({
+  class: attrs.class as HTMLAttributes['class'],
+  style: attrs.style as HTMLAttributes['style'],
+}))
 
 const emit = defineEmits<{
   'update:modelValue': [value: string | number]
@@ -36,8 +49,9 @@ function handleChange(event: Event) {
 </script>
 
 <template>
-  <div class="mint-select">
+  <div v-bind="wrapperAttrs" class="mint-select">
     <select
+      v-bind="controlAttrs"
       :value="modelValue"
       :disabled="disabled"
       :aria-invalid="error || undefined"

package/src/components/BaseToggle.vue

@@ -5,6 +5,8 @@ import Tooltip from './Tooltip.vue'
 interface Props {
   modelValue?: boolean
   label?: string
+  /** Accessible switch name; defaults to the visual label, then "Toggle". */
+  ariaLabel?: string
   description?: string
   icon?: string | string[]
   iconColor?: string
@@ -111,7 +113,7 @@ function iconStyle(): Record<string, string> {
       role="switch"
       :tabindex="disabled ? -1 : 0"
       :aria-checked="modelValue"
-      :aria-label="label || 'Toggle'"
+      :aria-label="ariaLabel || label || 'Toggle'"
       :class="[
         'mint-toggle__track',
         `mint-toggle__track--${size}`,

package/src/components/GeneratedPluginView.vue

@@ -116,7 +116,7 @@ function resourceSummary(definition: GeneratedJobDefinition): string {
   if (definition.lifecycle === 'staged' || definition.profile?.kind === 'staged') {
     return 'Staged upload'
   }
-  return `${definition.cpu} CPU`
+  return `Up to ${definition.cpu} CPU`
 }
 
 onMounted(() => {

package/src/components/PluginWorkspaceView.props.ts

@@ -34,7 +34,7 @@ export interface PluginWorkspaceViewProps {
   homePath?: string
   /** Show the default MINT logo when no icon/logo slot is provided. */
   showLogo?: boolean
-  /** Preferred route-level page selector entries. */
+  /** Preferred route-level page selector entries. Pass [] to suppress integrated platform fallback. */
   pageSelector?: PageSelectorItemInput[]
   /** Active page selector id. Defaults to activeView. */
   currentPageSelectorId?: string

package/src/components/PluginWorkspaceView.vue

@@ -208,10 +208,6 @@ const {
   emitPillSelect: (item) => emit('pill-select', item),
 })
 
-const visiblePageSelector = computed(() =>
-  (props.pageSelector?.length ?? 0) > 1 ? props.pageSelector : undefined,
-)
-
 const hasSidebarSurface = computed(() => {
   return hasPluginWorkspaceSidebarSurface({
     showSidebar: props.showSidebar,
@@ -274,7 +270,7 @@ function handleFormCancel(sectionId: string) {
           :variant="topBarVariant"
           :home-path="homePath"
           :show-logo="showLogo"
-          :page-selector="visiblePageSelector"
+          :page-selector="pageSelector"
           :current-page-selector-id="resolvedCurrentPageSelectorId"
           :plugin-switcher="pluginSwitcher"
           :pill-nav="resolvedPillNav"

package/src/composables/analysisArtifactTarget.ts

@@ -0,0 +1,53 @@
+import type { AnalysisArtifactTarget } from '../types/analysisArtifactTypes'
+
+const EXPERIMENT_ID = 'experiment_id'
+const ARTIFACT_PLUGIN_ID = 'artifact_plugin_id'
+const ARTIFACT_KEY = 'artifact_key'
+const ARTIFACT_ID = 'artifact_id'
+
+function parsePositiveInteger(value: string | null): number | undefined {
+  if (value === null || !/^\d+$/.test(value)) return undefined
+  const parsed = Number(value)
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined
+}
+
+/** Build the canonical query used to open one analysis artifact in a plugin. */
+export function buildAnalysisArtifactTargetQuery(
+  target: AnalysisArtifactTarget,
+): URLSearchParams {
+  const query = new URLSearchParams()
+  query.set(EXPERIMENT_ID, String(target.experimentId))
+  query.set(ARTIFACT_PLUGIN_ID, target.artifactPluginId)
+  query.set(ARTIFACT_KEY, target.artifactKey)
+  if (target.artifactId !== undefined) {
+    query.set(ARTIFACT_ID, String(target.artifactId))
+  }
+  return query
+}
+
+/** Parse a complete canonical target. Incomplete or invalid input is not guessed. */
+export function parseAnalysisArtifactTarget(
+  query: URLSearchParams,
+): AnalysisArtifactTarget | null {
+  const experimentId = parsePositiveInteger(query.get(EXPERIMENT_ID))
+  const artifactPluginId = query.get(ARTIFACT_PLUGIN_ID)?.trim()
+  const artifactKey = query.get(ARTIFACT_KEY)?.trim()
+  const rawArtifactId = query.get(ARTIFACT_ID)
+  const artifactId = parsePositiveInteger(rawArtifactId)
+
+  if (
+    experimentId === undefined
+    || !artifactPluginId
+    || !artifactKey
+    || (rawArtifactId !== null && artifactId === undefined)
+  ) {
+    return null
+  }
+
+  return {
+    experimentId,
+    artifactPluginId,
+    artifactKey,
+    ...(artifactId === undefined ? {} : { artifactId }),
+  }
+}

package/src/composables/index.ts

@@ -159,6 +159,11 @@ export {
   type UseAnalysisArtifactsOptions,
   type UseAnalysisArtifactsReturn,
 } from './useAnalysisArtifacts'
+export {
+  buildAnalysisArtifactTargetQuery,
+  parseAnalysisArtifactTarget,
+} from './analysisArtifactTarget'
+export { resolveCurrentPluginId } from './platformContextHelpers'
 export {
   formatExperimentDate,
   formatExperimentStatus,
@@ -476,6 +481,7 @@ export {
   type DownloadBlobOptions,
   type DownloadPluginEndpointOptions,
   type PluginContract,
+  type PluginContractSettings,
   type PluginClientRequestOptions,
   type PluginEndpointContract,
   type PluginEndpointDefinition,