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

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

@@ -2,12 +2,8 @@ import { flushPromises, mount } from '@vue/test-utils'
 import { nextTick } from 'vue'
 import { describe, expect, it } from 'vitest'
 import FormBuilder from '../../components/FormBuilder.vue'
-import FormActions from '../../components/FormActions.vue'
-import Tooltip from '../../components/Tooltip.vue'
-import { generatedJobFormSchema } from '../../generated/schema'
-import type { GeneratedJsonSchema } from '../../types/generated-ui'
+import FormActionsInternal from '../../components/internal/FormActionsInternal.vue'
 import { defineControlModel, useControlWorkspace, type ControlSchema } from '../../composables/useControlSchema'
-import type { FormSchema } from '../../types/form-builder'
 
 const controls: ControlSchema = {
   threshold: {
@@ -32,34 +28,13 @@ const controls: ControlSchema = {
   },
 }
 
-describe('FormBuilder', () => {
-  it.each([
-    { name: 'nullable tags', items: { type: 'string' }, value: null, component: 'TagsInput', displayed: [], updated: ['1'] },
-    { name: 'nullable enum array', items: { type: 'string', enum: ['a', 'b'] }, value: null, component: 'MultiSelect', displayed: [], updated: ['1'] },
-    { name: 'numeric tags', items: { type: 'number' }, value: [1, 2], component: 'TagsInput', displayed: ['1', '2'], updated: [1] },
-  ])('renders $name without changing its submitted default', async ({ items, value, component, displayed, updated }) => {
-    const field: GeneratedJsonSchema = {
-      anyOf: [{ type: 'array', items }, { type: 'null' }], default: value,
-    }
-    const schema = generatedJobFormSchema({
-      id: 'arrays', title: 'Arrays', description: '', cpu: 1,
-      input_schema: { properties: { values: field } }, output_schema: {},
-    })
-    const wrapper = mount(FormBuilder, { props: { schema } })
-    const control = wrapper.findComponent({ name: component })
-    expect(control.props('modelValue')).toEqual(displayed)
-    wrapper.findComponent(FormActions).vm.$emit('submit')
-    await flushPromises()
-    expect(wrapper.emitted('submit')?.at(-1)?.[0]).toEqual({ values: value })
+const spec = defineControlModel({ controls })
+const specWithActions = defineControlModel({ controls, actions: true })
 
-    control.vm.$emit('update:modelValue', ['1'])
-    await nextTick()
-    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toEqual({ values: updated })
-  })
-
-  it('renders compact controls without a prebuilt FormSchema', () => {
+describe('FormBuilder', () => {
+  it('renders the sections of a control model', () => {
     const wrapper = mount(FormBuilder, {
-      props: { controls },
+      props: { spec },
     })
 
     expect(wrapper.find('.mint-form-builder').exists()).toBe(true)
@@ -72,7 +47,7 @@ describe('FormBuilder', () => {
   it('merges compact control defaults with incoming model values', async () => {
     const wrapper = mount(FormBuilder, {
       props: {
-        controls,
+        spec,
         modelValue: { threshold: 0.25 },
       },
     })
@@ -86,16 +61,16 @@ describe('FormBuilder', () => {
     })
   })
 
-  it('uses controlOptions initialValues over compact control defaults', () => {
+  it('uses the control model initialValues over control defaults', () => {
     const wrapper = mount(FormBuilder, {
       props: {
-        controls,
-        controlOptions: {
+        spec: defineControlModel({
+          controls,
           initialValues: {
             threshold: 0.35,
             method: 'logistic',
           },
-        },
+        }),
       },
     })
 
@@ -106,7 +81,7 @@ describe('FormBuilder', () => {
   it('syncs external modelValue changes into rendered fields', async () => {
     const wrapper = mount(FormBuilder, {
       props: {
-        controls,
+        spec,
         modelValue: { threshold: 0.25 },
       },
     })
@@ -124,23 +99,26 @@ describe('FormBuilder', () => {
 
     const wrapper = mount(FormBuilder, {
       props: {
-        controls: thresholdOnly,
+        spec: defineControlModel({ controls: thresholdOnly, actions: true }),
       },
     })
 
     await wrapper.find('input').setValue('0.5')
     await wrapper.setProps({
-      controls: {
-        threshold: controls.threshold,
-        method: controls.method,
-      },
+      spec: defineControlModel({
+        controls: {
+          threshold: controls.threshold,
+          method: controls.method,
+        },
+        actions: true,
+      }),
     })
 
     expect(wrapper.find('select').exists()).toBe(true)
     expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.5')
     expect((wrapper.find('select').element as HTMLSelectElement).value).toBe('linear')
 
-    wrapper.findComponent(FormActions).vm.$emit('submit')
+    wrapper.findComponent(FormActionsInternal).vm.$emit('submit')
     await flushPromises()
 
     expect(wrapper.emitted('submit')?.at(-1)?.[0]).toMatchObject({
@@ -151,17 +129,20 @@ describe('FormBuilder', () => {
 
   it('removes stale field data when compact controls are removed', async () => {
     const wrapper = mount(FormBuilder, {
-      props: { controls },
+      props: { spec: specWithActions },
     })
 
     await wrapper.setProps({
-      controls: {
-        method: controls.method,
-      },
+      spec: defineControlModel({
+        controls: {
+          method: controls.method,
+        },
+        actions: true,
+      }),
     })
 
     expect(wrapper.find('input').exists()).toBe(false)
-    wrapper.findComponent(FormActions).vm.$emit('submit')
+    wrapper.findComponent(FormActionsInternal).vm.$emit('submit')
     await flushPromises()
 
     const submitted = wrapper.emitted('submit')?.at(-1)?.[0] as Record<string, unknown>
@@ -188,7 +169,7 @@ describe('FormBuilder', () => {
     })
     const wrapper = mount(FormBuilder, {
       props: {
-        model,
+        spec: model,
         modelValue: { threshold: 0.25 },
       },
     })
@@ -205,46 +186,10 @@ describe('FormBuilder', () => {
     })
   })
 
-  it('uses initialValues from a complete control model binding', () => {
-    const model = defineControlModel({
-      initialValues: {
-        threshold: 0.25,
-        method: 'logistic',
-      },
-      views: {
-        run: {
-          label: 'Run',
-          sections: {
-            parameters: {
-              label: 'Parameters',
-              controls: {
-                threshold: { label: 'Threshold', default: 0.05, min: 0, max: 1 },
-                method: { label: 'Method', default: 'linear', options: ['linear', 'logistic'] },
-              },
-            },
-          },
-        },
-      },
-    })
-    const wrapper = mount(FormBuilder, {
-      props: {
-        model,
-        controlOptions: {
-          initialValues: {
-            method: 'linear',
-          },
-        },
-      },
-    })
-
-    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('0.25')
-    expect((wrapper.find('select').element as HTMLSelectElement).value).toBe('linear')
-  })
-
   it('ignores external modelValue keys that are not part of the form schema', async () => {
     const wrapper = mount(FormBuilder, {
       props: {
-        controls,
+        spec,
         modelValue: { threshold: 0.25, externalContext: 'experiment-1' },
       },
     })
@@ -275,103 +220,40 @@ describe('FormBuilder', () => {
     expect((wrapper.find('select').element as HTMLSelectElement).value).toBe('logistic')
   })
 
-  it('uses explicit schema when both schema and controls are provided', () => {
-    const schema: FormSchema = {
-      sections: [
-        {
-          id: 'explicit',
-          title: 'Explicit Schema',
-          fields: [
-            {
-              name: 'explicitField',
-              label: 'Explicit Field',
-              type: 'text',
-              defaultValue: 'from schema',
-            },
-          ],
-        },
-      ],
-    }
-
+  it('renders no action bar when the control model sets no actions', () => {
     const wrapper = mount(FormBuilder, {
-      props: { controls, schema },
+      props: { spec },
     })
 
-    expect(wrapper.text()).toContain('Explicit Schema')
-    expect(wrapper.text()).not.toContain('Parameters')
-    expect((wrapper.find('input').element as HTMLInputElement).value).toBe('from schema')
+    expect(wrapper.find('.mint-form-actions').exists()).toBe(false)
   })
 
-  it('can hide the default actions for embedded forms', () => {
+  it('labels the action bar from the control model actions', () => {
     const wrapper = mount(FormBuilder, {
-      props: {
-        controls,
-        showActions: false,
-      },
+      props: { spec: defineControlModel({ controls, actions: { submitLabel: 'Run', showCancel: true } }) },
     })
 
-    expect(wrapper.find('.mint-form-actions').exists()).toBe(false)
+    expect(wrapper.get('.mint-form-actions').text()).toContain('Run')
+    expect(wrapper.get('.mint-form-actions').text()).toContain('Cancel')
   })
 
-  it('renders boolean fields as compact choice rows', async () => {
-    const schema: FormSchema = {
-      sections: [
-        {
-          id: 'display',
-          title: 'Display',
-          fields: [
-            {
-              name: 'showOutliers',
-              label: 'Show outliers',
-              type: 'toggle',
-              defaultValue: true,
-              hint: 'Keep flagged peaks visible',
-              icon: ['M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z'],
-            },
-            {
-              name: 'includeMetadata',
-              label: 'Include metadata',
-              type: 'checkbox',
-              defaultValue: false,
-              hint: 'Add method context',
-              icon: ['M12 3c4.418 0 8 1.343 8 3s-3.582 3-8 3-8-1.343-8-3z'],
-            },
-          ],
-        },
-      ],
-    }
-
+  it('applies the control model enhancements', async () => {
     const wrapper = mount(FormBuilder, {
-      props: { schema, showActions: false },
+      props: {
+        spec: defineControlModel({
+          controls,
+          enhancements: { fields: { method: { options: () => ['linear', 'quadratic'] } } },
+        }),
+      },
     })
+    await nextTick()
 
-    const toggle = wrapper.get('.mint-toggle--row')
-    const checkbox = wrapper.get('.mint-checkbox--row')
-
-    expect(toggle.text()).toContain('Show outliers')
-    expect(toggle.text()).not.toContain('Keep flagged peaks visible')
-    expect(toggle.find('.mint-toggle__row-svg').exists()).toBe(true)
-    expect(wrapper.findAll('.mint-form-field__label')).toHaveLength(0)
-
-    expect(checkbox.text()).toContain('Include metadata')
-    expect(checkbox.text()).not.toContain('Add method context')
-    expect(checkbox.find('.mint-checkbox__row-svg').exists()).toBe(true)
-    expect(wrapper.findAllComponents(Tooltip).map(tooltip => tooltip.props('text'))).toEqual([
-      'Keep flagged peaks visible',
-      'Add method context',
-    ])
-
-    await toggle.trigger('click')
-
-    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toMatchObject({
-      showOutliers: false,
-      includeMetadata: false,
-    })
+    expect(wrapper.findAll('option').map(option => option.text())).toContain('quadratic')
   })
 
-  it('renders default actions by default', () => {
+  it('renders the action bar when the control model sets actions', () => {
     const wrapper = mount(FormBuilder, {
-      props: { controls },
+      props: { spec: specWithActions },
     })
 
     expect(wrapper.find('.mint-form-actions').exists()).toBe(true)

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

@@ -0,0 +1,91 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { nextTick } from 'vue'
+import { describe, expect, it } from 'vitest'
+import FormActionsInternal from '../../components/internal/FormActionsInternal.vue'
+import FormSchemaInternal from '../../components/internal/FormSchemaInternal.vue'
+import Tooltip from '../../components/Tooltip.vue'
+import { generatedJobFormSchema } from '../../generated/schema'
+import type { GeneratedJsonSchema } from '../../types/generated-ui'
+import type { FormSchema } from '../../types/form-builder'
+
+describe('FormSchemaInternal', () => {
+  it.each([
+    { name: 'nullable tags', items: { type: 'string' }, value: null, component: 'TagsInput', displayed: [], updated: ['1'] },
+    { name: 'nullable enum array', items: { type: 'string', enum: ['a', 'b'] }, value: null, component: 'BaseSelect', displayed: [], updated: ['1'] },
+    { name: 'numeric tags', items: { type: 'number' }, value: [1, 2], component: 'TagsInput', displayed: ['1', '2'], updated: [1] },
+  ])('renders $name without changing its submitted default', async ({ items, value, component, displayed, updated }) => {
+    const field: GeneratedJsonSchema = {
+      anyOf: [{ type: 'array', items }, { type: 'null' }], default: value,
+    }
+    const schema = generatedJobFormSchema({
+      id: 'arrays', title: 'Arrays', description: '', cpu: 1,
+      input_schema: { properties: { values: field } }, output_schema: {},
+    })
+    const wrapper = mount(FormSchemaInternal, { props: { schema } })
+    const control = wrapper.findComponent({ name: component })
+    expect(control.props('modelValue')).toEqual(displayed)
+    wrapper.findComponent(FormActionsInternal).vm.$emit('submit')
+    await flushPromises()
+    expect(wrapper.emitted('submit')?.at(-1)?.[0]).toEqual({ values: value })
+
+    control.vm.$emit('update:modelValue', ['1'])
+    await nextTick()
+    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toEqual({ values: updated })
+  })
+
+  it('renders boolean fields as compact choice rows', async () => {
+    const schema: FormSchema = {
+      sections: [
+        {
+          id: 'display',
+          title: 'Display',
+          fields: [
+            {
+              name: 'showOutliers',
+              label: 'Show outliers',
+              type: 'toggle',
+              defaultValue: true,
+              hint: 'Keep flagged peaks visible',
+              icon: ['M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z'],
+            },
+            {
+              name: 'includeMetadata',
+              label: 'Include metadata',
+              type: 'checkbox',
+              defaultValue: false,
+              hint: 'Add method context',
+              icon: ['M12 3c4.418 0 8 1.343 8 3s-3.582 3-8 3-8-1.343-8-3z'],
+            },
+          ],
+        },
+      ],
+    }
+
+    const wrapper = mount(FormSchemaInternal, {
+      props: { schema },
+    })
+
+    const toggle = wrapper.get('.mint-toggle--row')
+    const checkbox = wrapper.get('.mint-checkbox--row')
+
+    expect(toggle.text()).toContain('Show outliers')
+    expect(toggle.text()).not.toContain('Keep flagged peaks visible')
+    expect(toggle.find('.mint-toggle__row-svg').exists()).toBe(true)
+    expect(wrapper.findAll('.mint-form-field__label')).toHaveLength(0)
+
+    expect(checkbox.text()).toContain('Include metadata')
+    expect(checkbox.text()).not.toContain('Add method context')
+    expect(checkbox.find('.mint-checkbox__row-svg').exists()).toBe(true)
+    expect(wrapper.findAllComponents(Tooltip).map(tooltip => tooltip.props('text'))).toEqual([
+      'Keep flagged peaks visible',
+      'Add method context',
+    ])
+
+    await toggle.trigger('click')
+
+    expect(wrapper.emitted('update:modelValue')?.at(-1)?.[0]).toMatchObject({
+      showOutliers: false,
+      includeMetadata: false,
+    })
+  })
+})

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

@@ -1,23 +1,28 @@
 import { flushPromises, mount } from '@vue/test-utils'
-import { createPinia } from 'pinia'
+import { createPinia, setActivePinia, type Pinia } from 'pinia'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import FileUploader from '../../components/FileUploader.vue'
 import GeneratedPathInput from '../../components/GeneratedPathInput.vue'
 import { GENERATED_JOBS_API_KEY } from '../../components/internal/generatedJobsApi'
-import type { GeneratedAnalysisTransport } from '../../composables/useGeneratedAnalysis'
+import type { GeneratedAnalysisTransport } from '../../composables/useJobsEndpoint'
 import type { PluginJobPathInput } from '../../types/generated-ui'
+import { useExperimentStore } from '../../stores/experiment'
 
 describe('GeneratedPathInput', () => {
+  let pinia: Pinia
+
   beforeEach(() => {
     Object.assign(window, {
       __MINT_PLATFORM__: {
         isIntegrated: true,
         platformApiUrl: '/api',
         theme: 'system',
-        currentExperimentId: 42,
       },
     })
+    pinia = createPinia()
+    setActivePinia(pinia)
+    useExperimentStore().$patch({ currentId: 42 })
   })
 
   afterEach(() => {
@@ -27,7 +32,7 @@ describe('GeneratedPathInput', () => {
 
   it('should preserve selected directory paths for SDK staging', async () => {
     const wrapper = mount(GeneratedPathInput, {
-      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+      global: { plugins: [pinia], stubs: { Teleport: true } },
     })
     const files = [new File(['a'], 'a.txt'), new File(['b'], 'b.txt')]
 
@@ -50,7 +55,7 @@ describe('GeneratedPathInput', () => {
     const file = new File(['a'], 'a.txt')
     const wrapper = mount(GeneratedPathInput, {
       props: { modelValue: { kind: 'path', files: [file], relativePaths: ['a.txt'] } },
-      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+      global: { plugins: [pinia], stubs: { Teleport: true } },
     })
     expect(wrapper.find('button[aria-label="Remove a.txt"]').exists()).toBe(true)
     await wrapper.setProps({
@@ -67,7 +72,7 @@ describe('GeneratedPathInput', () => {
   it('should emit one path selection per file when multiple paths are requested', async () => {
     const wrapper = mount(GeneratedPathInput, {
       props: { multiple: true },
-      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+      global: { plugins: [pinia], stubs: { Teleport: true } },
     })
     const files = [new File(['a'], 'a.txt'), new File(['b'], 'b.txt')]
 
@@ -86,7 +91,7 @@ describe('GeneratedPathInput', () => {
 
   it('should remove a file from the submitted value when the uploader removes it', async () => {
     const wrapper = mount(GeneratedPathInput, {
-      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+      global: { plugins: [pinia], stubs: { Teleport: true } },
     })
     const uploader = wrapper.findComponent(FileUploader)
     const file = new File(['a'], 'a.txt')
@@ -138,7 +143,7 @@ describe('GeneratedPathInput', () => {
     return mount(GeneratedPathInput, {
       props,
       global: {
-        plugins: [createPinia()],
+        plugins: [pinia],
         stubs: { Teleport: true },
         provide: { [GENERATED_JOBS_API_KEY as symbol]: { baseUrl: '/api/demo', transport } },
       },
@@ -216,7 +221,7 @@ describe('GeneratedPathInput', () => {
     const transport = listing()
     const wrapper = mount(GeneratedPathInput, {
       global: {
-        plugins: [createPinia()],
+        plugins: [pinia],
         stubs: { Teleport: true },
         provide: { [GENERATED_JOBS_API_KEY as symbol]: { baseUrl: '/api/demo/', transport } },
       },
@@ -229,7 +234,7 @@ describe('GeneratedPathInput', () => {
 
   it('should hide the artifact choice outside a generated jobs workspace', () => {
     const wrapper = mount(GeneratedPathInput, {
-      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+      global: { plugins: [pinia], stubs: { Teleport: true } },
     })
 
     expect(wrapper.text()).not.toContain('Existing artifact')
@@ -238,7 +243,7 @@ describe('GeneratedPathInput', () => {
   it('should show the selected artifact by name when the model holds one', () => {
     const wrapper = mount(GeneratedPathInput, {
       props: { modelValue: artifactSelection },
-      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+      global: { plugins: [pinia], stubs: { Teleport: true } },
     })
 
     expect(wrapper.get('.mint-generated-path-input__artifact').text()).toContain('matrix.csv')
@@ -247,7 +252,7 @@ describe('GeneratedPathInput', () => {
   it('should clear the model when the selected artifact is removed', async () => {
     const wrapper = mount(GeneratedPathInput, {
       props: { modelValue: artifactSelection },
-      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+      global: { plugins: [pinia], stubs: { Teleport: true } },
     })
 
     await wrapper.get('button[aria-label="Remove matrix.csv"]').trigger('click')
@@ -269,7 +274,7 @@ describe('GeneratedPathInput', () => {
   it('should keep the selected artifact locked while the input is disabled', () => {
     const wrapper = mount(GeneratedPathInput, {
       props: { modelValue: artifactSelection, disabled: true },
-      global: { plugins: [createPinia()], stubs: { Teleport: true } },
+      global: { plugins: [pinia], stubs: { Teleport: true } },
     })
 
     expect(wrapper.get('button[aria-label="Remove matrix.csv"]').attributes('disabled')).toBeDefined()

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

@@ -9,18 +9,19 @@ import JobsStatusTray from '../../components/JobsStatusTray.vue'
 import PluginWorkspaceView from '../../components/PluginWorkspaceView.vue'
 
 const generated = vi.hoisted(() => ({
-  initialize: vi.fn(),
+  refresh: vi.fn(),
   submit: vi.fn(),
-  loadResult: vi.fn(),
+  result: vi.fn(),
   resultForJob: vi.fn(),
   options: undefined as unknown,
   jobs: [] as Array<Record<string, unknown>>,
+  error: null as string | null,
 }))
 
-vi.mock('../../composables/useGeneratedAnalysis', async () => {
+vi.mock('../../composables/useJobsEndpoint', async () => {
   const { computed, ref, shallowRef } = await import('vue')
   return {
-    useGeneratedAnalysis: (options: unknown) => {
+    useJobsEndpoint: (options: unknown) => {
       generated.options = options
       const jobs = shallowRef(generated.jobs)
       return ({
@@ -59,28 +60,25 @@ vi.mock('../../composables/useGeneratedAnalysis', async () => {
       latestResult: computed(() => ({ kind: 'text', text: 'complete' })),
       isLoading: ref(false),
       isSubmitting: ref(false),
-      error: shallowRef(null),
-      initialize: generated.initialize,
+      error: shallowRef(generated.error),
+      refresh: generated.refresh,
       submit: generated.submit,
-      loadResult: generated.loadResult,
+      result: generated.result,
       resultForJob: generated.resultForJob,
-      refreshJobs: vi.fn(),
       })
     },
   }
 })
 
-vi.mock('../../composables/usePlatformContext', () => ({
-  usePlatformContext: vi.fn(() => ({
-    isIntegrated: computed(() => false),
-    context: ref({ isIntegrated: false, theme: 'system' }),
+vi.mock('../../composables/usePlatform', () => ({
+  usePlatform: vi.fn(() => ({
+    integrated: computed(() => false),
+    isAdmin: computed(() => true),
+    can: () => true,
     plugin: computed(() => undefined),
     user: computed(() => undefined),
     theme: computed(() => 'system'),
     features: computed(() => undefined),
-    navigate: vi.fn(),
-    notify: vi.fn(),
-    sendToPlatform: vi.fn(),
   })),
 }))
 
@@ -121,9 +119,10 @@ describe('GeneratedPluginView', () => {
       { ...baseJob, id: 'job-1', job_id: 'job-1' },
       { ...baseJob, id: 'job-2', job_id: 'job-2', session_id: 'shared-session' },
     ]
-    generated.initialize.mockResolvedValue(undefined)
+    generated.error = null
+    generated.refresh.mockResolvedValue(undefined)
     generated.submit.mockResolvedValue(undefined)
-    generated.loadResult.mockResolvedValue({ kind: 'text', text: 'complete' })
+    generated.result.mockResolvedValue({ kind: 'text', text: 'complete' })
     generated.resultForJob.mockReturnValue({ kind: 'text', text: 'complete' })
   })
 
@@ -147,10 +146,11 @@ describe('GeneratedPluginView', () => {
       jobSource: wrapper.findComponent(JobsStatusTray).props('source'),
     }).toMatchObject({
       workspace: {
-        title: 'Demo analysis',
-        subtitle: 'Backend-only workspace',
-        sidebarPosition: 'left',
-        showFormActions: true,
+        spec: {
+          title: 'Demo analysis',
+          subtitle: 'Backend-only workspace',
+          sidebar: { title: 'Parameters', forms: { run: { actions: true } } },
+        },
         values: { threshold: 2.5 },
       },
       result: 'complete',
@@ -159,6 +159,20 @@ describe('GeneratedPluginView', () => {
     })
   })
 
+  it('should show the load error text when the workspace fails to load', async () => {
+    generated.error = 'Manifest request failed'
+    const wrapper = mount(GeneratedPluginView, {
+      props: { baseUrl: '/api/demo' },
+      global: {
+        plugins: [createPinia()],
+        stubs: { 'router-link': { template: '<a><slot /></a>' }, Teleport: true },
+      },
+    })
+    await flushPromises()
+
+    expect(wrapper.find('.mint-alert__message').text()).toBe('Manifest request failed')
+  })
+
   it('submits normalized form values through the current job definition', async () => {
     const wrapper = mount(GeneratedPluginView, {
       props: { baseUrl: '/api/demo' },
@@ -179,7 +193,7 @@ describe('GeneratedPluginView', () => {
     })
     await flushPromises()
 
-    wrapper.findComponent(PluginWorkspaceView).vm.$emit('update:activeView', 'sync')
+    wrapper.findComponent(PluginWorkspaceView).vm.$emit('update:view', 'sync')
     await flushPromises()
 
     expect(wrapper.find('[aria-label="Job resource requirements"]').text()).toBe('Host service')
@@ -213,7 +227,7 @@ describe('GeneratedPluginView', () => {
     })
     await flushPromises()
 
-    expect(generated.loadResult).toHaveBeenCalledWith(expect.objectContaining({ job_id: 'job-1' }))
+    expect(generated.result).toHaveBeenCalledWith(expect.objectContaining({ job_id: 'job-1' }))
   })
 
   it('should display the exact historical job selected from the jobs tray', async () => {
@@ -229,7 +243,7 @@ describe('GeneratedPluginView', () => {
 
     expect({
       result: wrapper.findComponent(GeneratedResultRenderer).text(),
-      loadedJob: generated.loadResult.mock.calls.at(-1)?.[0]?.job_id,
+      loadedJob: generated.result.mock.calls.at(-1)?.[0]?.job_id,
     }).toEqual({ result: 'job-2', loadedJob: 'job-2' })
   })
 })