@morscherlab/mint-sdk 1.0.0-beta.2 → 1.0.0-beta.4

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { ref, computed } from 'vue'
+import { ref, computed, nextTick } from 'vue'
 
 // Capture side-effect callbacks so tests can invoke them directly
 let capturedScopeDispose: (() => void) | null = null
@@ -83,6 +83,43 @@ describe('useAppExperiment', () => {
   // -------------------------------------------------------------------------
 
   describe('set', () => {
+    it('should initialize from a direct experiment option', () => {
+      const { experimentName, experimentCode, experimentId } = useAppExperiment({
+        experiment: makeExperiment({ id: 8, name: 'Initial run', experiment_code: 'EXP-008' }),
+      })
+
+      expect(experimentName.value).toBe('Initial run')
+      expect(experimentCode.value).toBe('EXP-008')
+      expect(experimentId.value).toBe(8)
+    })
+
+    it('should sync and clear a reactive experiment option', async () => {
+      const source = ref<ExperimentSummary | null>(
+        makeExperiment({ id: 8, name: 'Initial run', experiment_code: 'EXP-008' }),
+      )
+      const { experimentName, experimentCode, experimentId } = useAppExperiment({
+        experiment: source,
+      })
+
+      expect(experimentName.value).toBe('Initial run')
+      expect(experimentCode.value).toBe('EXP-008')
+      expect(experimentId.value).toBe(8)
+
+      source.value = makeExperiment({ id: 9, name: 'Updated run', experiment_code: 'EXP-009' })
+      await nextTick()
+
+      expect(experimentName.value).toBe('Updated run')
+      expect(experimentCode.value).toBe('EXP-009')
+      expect(experimentId.value).toBe(9)
+
+      source.value = null
+      await nextTick()
+
+      expect(experimentName.value).toBeUndefined()
+      expect(experimentCode.value).toBeUndefined()
+      expect(experimentId.value).toBeNull()
+    })
+
     it('should update experimentName and experimentId on set', () => {
       const { set, experimentName, experimentId } = useAppExperiment()
       const experiment = makeExperiment({ id: 7, name: 'Alpha Run' })
@@ -511,6 +548,68 @@ describe('useAppExperiment', () => {
     })
   })
 
+  // -------------------------------------------------------------------------
+  // component bindings
+  // -------------------------------------------------------------------------
+
+  describe('component bindings', () => {
+    it('exposes live ExperimentPopover props from the provided state', async () => {
+      const saveDisabled = ref(false)
+      const saveDisabledMessage = ref<string | undefined>('Ready to save')
+      const onSave = vi.fn().mockResolvedValue('Saved')
+      const { set } = useAppExperiment({ onSave, saveDisabled, saveDisabledMessage })
+      const state = getState()
+
+      set(makeExperiment({
+        id: 12,
+        name: 'Dose response',
+        status: 'ongoing',
+        experiment_code: 'EXP-012',
+      }))
+
+      expect(state.popover.value).toMatchObject({
+        experimentName: 'Dose response',
+        experimentCode: 'EXP-012',
+        experimentStatus: 'ongoing',
+        showSave: true,
+        showDetach: true,
+        saveDisabled: false,
+        saveDisabledMessage: 'Ready to save',
+        saveLoading: false,
+      })
+
+      saveDisabled.value = true
+      saveDisabledMessage.value = 'Locked'
+
+      expect(state.popover.value.saveDisabled).toBe(true)
+      expect(state.popover.value.saveDisabledMessage).toBe('Locked')
+
+      await state.handleSave()
+
+      expect(state.popover.value.saveSuccessMessage).toBe('Saved')
+    })
+
+    it('exposes live ExperimentSelectorModal props from state and return value', () => {
+      const appExperiment = useAppExperiment()
+      const state = getState()
+
+      expect(state.selectorModal.value).toEqual({
+        modelValue: false,
+        currentExperimentId: null,
+      })
+      expect(appExperiment.selectorModal.value).toEqual(state.selectorModal.value)
+
+      appExperiment.set(makeExperiment({ id: 77 }))
+      state.openModal()
+
+      expect(state.selectorModal.value).toEqual({
+        modelValue: true,
+        currentExperimentId: 77,
+      })
+      expect(appExperiment.popover.value.experimentName).toBe('Test Experiment')
+    })
+  })
+
   // -------------------------------------------------------------------------
   // Timer cleanup via onScopeDispose
   // -------------------------------------------------------------------------

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

@@ -0,0 +1,125 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockGet = vi.fn()
+const mockPut = vi.fn()
+const mockDelete = vi.fn()
+const mockUseApi = vi.fn((_options?: unknown) => ({
+  get: mockGet,
+  put: mockPut,
+  delete: mockDelete,
+}))
+
+vi.mock('../../composables/useApi', () => ({
+  useApi: (options: unknown) => mockUseApi(options),
+}))
+
+import { useBioTemplatePackWorkspace } from '../../composables/useBioTemplatePackWorkspace'
+
+describe('useBioTemplatePackWorkspace', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockGet.mockResolvedValue({})
+    mockPut.mockResolvedValue({})
+    mockDelete.mockResolvedValue({})
+    window.history.replaceState({}, '', '/')
+  })
+
+  it('creates renderer props and component bindings from one pack id', () => {
+    const workspace = useBioTemplatePackWorkspace('cell culture')
+
+    expect(workspace.packId).toBe('cell-culture-screen')
+    expect(workspace.pack.templates).toContain('dose-response')
+    expect(workspace.collection.value.metadata?.pack).toBe('cell-culture-screen')
+    expect(workspace.templateIds.value).toEqual([
+      'sample-sheet',
+      'sample-prep',
+      'plate-map',
+      'reagent-list',
+      'protocol-steps',
+      'dose-response',
+      'flow-cytometry-panel',
+    ])
+    expect(workspace.renderer.value.target).toBe(workspace.collection.value)
+    expect(workspace.workspace.value.renderer?.target).toBe(workspace.collection.value)
+    expect(workspace.form.value).toBe(workspace.workspace.value.form)
+    expect(workspace.form.value.modelValue).toBe(workspace.workspace.value.values)
+    expect(workspace.sidebar.value).toBe(workspace.workspace.value.sidebar)
+    expect(workspace.sidebar.value.values).toBe(workspace.workspace.value.values)
+    expect(workspace.sidebar.value.activeView).toBe('design')
+    expect(workspace.topBar.value).toBe(workspace.workspace.value.topBar.value)
+    expect(workspace.pillNav.value).toBe(workspace.workspace.value.pillNav)
+    expect(workspace.pillNav.value.items.map(item => item.id)).toContain('design')
+    expect(workspace.topBarSettings.value).toBe(workspace.workspace.value.topBarSettings)
+    expect(workspace.bindings.value).toBe(workspace.workspace.value.bindings)
+    expect(workspace.bindings.value.form).toBe(workspace.form.value)
+    expect(workspace.bindings.value.topBar.value.currentPillId).toBe('design')
+    expect(workspace.topBarSettings.value.settingsConfig.values).toBe(workspace.workspace.value.values)
+    expect(workspace.sidebar.value.panels.design.map(panel => panel.id)).toContain('dose')
+    expect(workspace.componentBindings.value.map(binding => binding.component)).toContain('DoseCalculator')
+    expect(workspace.componentBindingsById.value['dose-response:DoseCalculator'].component).toBe('DoseCalculator')
+    expect(workspace.componentBindingsById.value['dose-response:DoseCalculator'].props.mode).toBe('serial')
+    expect(workspace.componentProps.value.map(binding => binding.component)).toContain('PlateMapEditor')
+    expect(workspace.componentPropsById.value['plate-map:WellPlate'].wells).toBeDefined()
+    expect(workspace.bindings.value.componentPropsById['plate-map:WellPlate'].wells).toBeDefined()
+    expect(workspace.bindings.value.componentBindingsById['plate-map:WellPlate'].props.wells).toBeDefined()
+    expect(workspace.componentPropsByComponent.value.WellPlate.length).toBeGreaterThan(0)
+    expect(workspace.getComponentProps('WellPlate')?.wells).toBeDefined()
+    expect(workspace.bindings.value.getComponentProps('WellPlate')?.wells).toBeDefined()
+    expect(workspace.componentUsage.value?.template).toContain('<DoseCalculator')
+  })
+
+  it('exposes live AppSidebar, AppTopBar, and AppPillNav bindings for mixed-view packs', () => {
+    const workspace = useBioTemplatePackWorkspace('omics-assay')
+    const inner = workspace.workspace.value
+
+    expect(workspace.pillNav.value.items.map(item => item.id)).toEqual([
+      'design',
+      'run',
+      'analysis',
+    ])
+    expect(inner.activeView.value).toBe('design')
+
+    workspace.pillNav.value.onSelect({ id: 'analysis', label: 'Analysis' })
+    expect(inner.activeView.value).toBe('analysis')
+    expect(workspace.sidebar.value.activeView).toBe('analysis')
+    expect(workspace.topBar.value.currentPillId).toBe('analysis')
+    expect(workspace.bindings.value.topBar.value.currentPillId).toBe('analysis')
+
+    workspace.topBar.value.onPillSelect({ id: 'run', label: 'Run' })
+    expect(inner.activeView.value).toBe('run')
+    expect(workspace.sidebar.value.activeView).toBe('run')
+    expect(workspace.pillNav.value.currentItemId).toBe('run')
+    expect(workspace.bindings.value.topBar.value.currentPillId).toBe('run')
+  })
+
+  it('applies and resets pack collections', () => {
+    const workspace = useBioTemplatePackWorkspace('longitudinal-study')
+
+    workspace.applyCollection({ templates: {}, metadata: { source: 'empty' } })
+    expect(workspace.templateIds.value).toEqual([])
+    expect(workspace.collection.value.metadata?.source).toBe('empty')
+
+    workspace.resetToDefaultCollection()
+    expect(workspace.collection.value.metadata?.pack).toBe('longitudinal-study')
+    expect(workspace.templateIds.value).toEqual([
+      'sample-sheet',
+      'time-course',
+      'protocol-steps',
+      'assay-matrix',
+    ])
+  })
+
+  it('saves the generated pack collection through current experiment wiring', async () => {
+    window.history.replaceState({}, '', '/experiments/42/templates')
+    const workspace = useBioTemplatePackWorkspace('molecular-assay', { pluginId: 'p1' })
+
+    const ok = await workspace.saveCurrent()
+
+    expect(ok).toBe(true)
+    expect(mockPut).toHaveBeenCalledWith('/experiments/42/data', {
+      plugin_id: 'p1',
+      data: workspace.collection.value,
+      schema_version: '1.0',
+    })
+  })
+})

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

@@ -0,0 +1,199 @@
+import { nextTick } from 'vue'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mockGet = vi.fn()
+const mockPut = vi.fn()
+const mockDelete = vi.fn()
+const mockUseApi = vi.fn((_options?: unknown) => ({
+  get: mockGet,
+  put: mockPut,
+  delete: mockDelete,
+}))
+
+vi.mock('../../composables/useApi', () => ({
+  useApi: (options: unknown) => mockUseApi(options),
+}))
+
+import { useBioTemplatePresetWorkspace } from '../../composables/useBioTemplatePresetWorkspace'
+import {
+  extractTemplateCollection,
+} from '../../templates'
+import type {
+  PlateMapTemplate,
+} from '../../templates'
+
+describe('useBioTemplatePresetWorkspace', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockGet.mockResolvedValue({})
+    mockPut.mockResolvedValue({})
+    mockDelete.mockResolvedValue({})
+    window.history.replaceState({}, '', '/')
+  })
+
+  it('creates controls, renderer props, and component bindings from one preset id', () => {
+    const workspace = useBioTemplatePresetWorkspace('wellplate-screen')
+
+    expect(workspace.presetId).toBe('wellplate-screen')
+    expect(workspace.presetInfo.value?.label).toBe('Well-plate screen')
+    expect(workspace.presetLabel.value).toBe('Well-plate screen')
+    expect(workspace.collection.value.metadata?.preset).toBe('wellplate-screen')
+    expect(workspace.controlSchema).toBe(workspace.controls.controls)
+    expect(workspace.controlValues.value.sampleNames).toEqual(['Control', 'Treatment'])
+    expect(workspace.sidebar.panels.design.map(panel => panel.id)).toContain('dose')
+    expect(workspace.form.modelValue).toBe(workspace.controlValues.value)
+    expect(workspace.sidebar.modelValue).toBe(workspace.controlValues.value)
+    expect(workspace.sidebar.values).toBe(workspace.controlValues.value)
+    expect(workspace.sidebar.activeView).toBe('design')
+    expect(workspace.pillNav.items).toEqual(workspace.controls.viewItems)
+    expect(workspace.pillNav.currentItemId).toBe('design')
+    expect(workspace.topBarSettings.settingsConfig.values).toBe(workspace.controlValues.value)
+    expect(workspace.bindings.form).toBe(workspace.form)
+    expect(workspace.bindings.sidebar).toBe(workspace.sidebar)
+    expect(workspace.bindings.topBarSettings).toBe(workspace.topBarSettings)
+    expect(workspace.bindings.pillNav).toBe(workspace.pillNav)
+    expect(workspace.bindings.topBar.value.currentPillId).toBe('design')
+    expect(workspace.controlViewIds.value).toEqual(['design'])
+    expect(workspace.controlViewItems.value).toEqual([{ id: 'design', label: 'Design' }])
+    expect(workspace.activeControlView.value).toBe('design')
+    expect(workspace.renderer.value.target).toBe(workspace.collection.value)
+    expect(workspace.bindings.renderer.value.target).toBe(workspace.collection.value)
+    expect(workspace.componentBindings.value.map(binding => binding.component)).toContain('DoseCalculator')
+    expect(workspace.componentBindingsById.value['dose-response:DoseCalculator'].component).toBe('DoseCalculator')
+    expect(workspace.componentBindingsById.value['dose-response:DoseCalculator'].props.mode).toBe('serial')
+    expect(workspace.componentProps.value.map(binding => binding.component)).toContain('WellPlate')
+    expect(workspace.componentPropsById.value['dose-response:DoseCalculator'].mode).toBe('serial')
+    expect(workspace.bindings.componentPropsById.value['dose-response:DoseCalculator'].mode).toBe('serial')
+    expect(workspace.bindings.componentBindingsById.value['dose-response:DoseCalculator'].props.mode).toBe('serial')
+    expect(workspace.componentPropsByComponent.value.WellPlate).toHaveLength(2)
+    expect(workspace.getComponentProps('DoseCalculator')?.mode).toBe('serial')
+    expect(workspace.bindings.getComponentProps('DoseCalculator')?.mode).toBe('serial')
+    expect(workspace.componentUsage.value?.template).toContain('<DoseCalculator')
+  })
+
+  it('tracks active control view for mixed-view presets', () => {
+    const workspace = useBioTemplatePresetWorkspace('lcms-batch')
+
+    expect(workspace.controlViewIds.value).toEqual(['run', 'analysis'])
+    expect(workspace.controlViewItems.value).toEqual([
+      { id: 'run', label: 'Run' },
+      { id: 'analysis', label: 'Analysis' },
+    ])
+    expect(workspace.activeControlView.value).toBe('run')
+
+    workspace.setActiveControlView('analysis')
+    expect(workspace.activeControlView.value).toBe('analysis')
+    expect(workspace.sidebar.activeView).toBe('analysis')
+    expect(workspace.topBar.value.currentPillId).toBe('analysis')
+    expect(workspace.pillNav.currentItemId).toBe('analysis')
+
+    workspace.setActiveControlView('missing')
+    expect(workspace.activeControlView.value).toBe('analysis')
+  })
+
+  it('exposes live FormBuilder, AppSidebar, AppTopBar, and AppPillNav bindings', () => {
+    const workspace = useBioTemplatePresetWorkspace('lcms-batch')
+
+    workspace.form['onUpdate:modelValue']({
+      ...workspace.controlValues.value,
+      operator: 'Ada',
+    })
+    expect(workspace.controlValues.value.operator).toBe('Ada')
+    expect(workspace.form.modelValue).toBe(workspace.controlValues.value)
+    expect(workspace.sidebar.values).toBe(workspace.controlValues.value)
+    expect(workspace.topBarSettings.settingsConfig.values).toBe(workspace.controlValues.value)
+
+    workspace.pillNav.onSelect({ id: 'analysis', label: 'Analysis' })
+    expect(workspace.activeControlView.value).toBe('analysis')
+    expect(workspace.sidebar.activeView).toBe('analysis')
+    expect(workspace.topBar.value.currentPillId).toBe('analysis')
+    expect(workspace.bindings.topBar.value.currentPillId).toBe('analysis')
+
+    workspace.topBar.value.onPillSelect({ id: 'run', label: 'Run' })
+    expect(workspace.activeControlView.value).toBe('run')
+    expect(workspace.pillNav.currentItemId).toBe('run')
+    expect(workspace.bindings.topBar.value.currentPillId).toBe('run')
+  })
+
+  it('accepts direct initial values for generated preset controls and collection data', () => {
+    const workspace = useBioTemplatePresetWorkspace('wellplate-screen', {
+      controlOptions: {
+        initialValues: {
+          sampleNames: ['Nested default'],
+          unit: 'uM',
+        },
+      },
+      initialValues: {
+        sampleNames: ['Vehicle', 'Drug'],
+        unit: 'nM',
+      },
+    })
+
+    const plate = extractTemplateCollection(workspace.collection.value)['plate-map'] as PlateMapTemplate
+
+    expect(workspace.controlValues.value.sampleNames).toEqual(['Vehicle', 'Drug'])
+    expect(workspace.controlValues.value.unit).toBe('nM')
+    expect(plate.data.samples.map(sample => sample.name)).toEqual(['Vehicle', 'Drug'])
+  })
+
+  it('rebuilds the template collection when generated controls change', async () => {
+    const workspace = useBioTemplatePresetWorkspace('wellplate-screen')
+
+    workspace.controlValues.value = {
+      ...workspace.controlValues.value,
+      sampleNames: ['Vehicle', 'Drug'],
+    }
+    await nextTick()
+
+    const plate = extractTemplateCollection(workspace.collection.value)['plate-map'] as PlateMapTemplate
+    expect(plate.data.samples.map(sample => sample.name)).toEqual(['Vehicle', 'Drug'])
+  })
+
+  it('sets, updates, and resets generated control values without direct ref mutation', () => {
+    const workspace = useBioTemplatePresetWorkspace('wellplate-screen')
+
+    const setCollection = workspace.setControlValues({
+      sampleNames: ['Vehicle', 'Drug'],
+      unit: 'nM',
+      replicates: 2,
+    })
+    let plate = extractTemplateCollection(setCollection)['plate-map'] as PlateMapTemplate
+
+    expect(workspace.collection.value).toBe(setCollection)
+    expect(workspace.controlValues.value).toEqual({
+      sampleNames: ['Vehicle', 'Drug'],
+      unit: 'nM',
+      replicates: 2,
+    })
+    expect(plate.data.samples.map(sample => sample.name)).toEqual(['Vehicle', 'Drug'])
+
+    const updatedCollection = workspace.updateControlValues({ sampleNames: ['Updated'] })
+    plate = extractTemplateCollection(updatedCollection)['plate-map'] as PlateMapTemplate
+
+    expect(workspace.collection.value).toBe(updatedCollection)
+    expect(workspace.controlValues.value.unit).toBe('nM')
+    expect(workspace.controlValues.value.sampleNames).toEqual(['Updated'])
+    expect(plate.data.samples.map(sample => sample.name)).toEqual(['Updated'])
+
+    const resetCollection = workspace.resetToDefaultCollection()
+    plate = extractTemplateCollection(resetCollection)['plate-map'] as PlateMapTemplate
+
+    expect(workspace.collection.value).toBe(resetCollection)
+    expect(workspace.controlValues.value.sampleNames).toEqual(['Control', 'Treatment'])
+    expect(plate.data.samples.map(sample => sample.name)).toEqual(['Control', 'Treatment'])
+  })
+
+  it('saves the generated collection through current experiment wiring', async () => {
+    window.history.replaceState({}, '', '/experiments/42/templates')
+    const workspace = useBioTemplatePresetWorkspace('lcms-batch', { pluginId: 'p1' })
+
+    const ok = await workspace.saveCurrent()
+
+    expect(ok).toBe(true)
+    expect(mockPut).toHaveBeenCalledWith('/experiments/42/data', {
+      plugin_id: 'p1',
+      data: workspace.collection.value,
+      schema_version: '1.0',
+    })
+  })
+})

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

@@ -0,0 +1,104 @@
+import { describe, expect, it } from 'vitest'
+import {
+  useBioTemplateWorkspace,
+} from '../../composables/useBioTemplateWorkspace'
+import {
+  createLcmsBatchCollection,
+  createWellPlateScreenCollection,
+} from '../../templates'
+
+describe('useBioTemplateWorkspace', () => {
+  it('returns AppSidebar, FormBuilder, renderer, and component bindings for a concrete collection', () => {
+    const collection = createWellPlateScreenCollection({
+      samples: ['Control', 'Treatment'],
+      compounds: { 'Drug A': [10, 1, 0.1] },
+      unit: 'uM',
+    })
+    const workspace = useBioTemplateWorkspace(collection)
+
+    expect(workspace.controlSchema).toBe(workspace.controls.controls)
+    expect(workspace.workspace.values).toBe(workspace.values)
+    expect(workspace.form).toBe(workspace.workspace.form)
+    expect(workspace.form.modelValue).toBe(workspace.values)
+    expect(workspace.sidebar).toBe(workspace.workspace.sidebar)
+    expect(workspace.sidebar.values).toBe(workspace.values)
+    expect(workspace.topBar).toBe(workspace.workspace.topBar)
+    expect(workspace.pillNav).toBe(workspace.workspace.pillNav)
+    expect(workspace.topBarSettings).toBe(workspace.workspace.topBarSettings)
+    expect(workspace.bindings.form).toBe(workspace.form)
+    expect(workspace.bindings.sidebar).toBe(workspace.sidebar)
+    expect(workspace.bindings.topBar).toBe(workspace.workspace.bindings.topBar)
+    expect(workspace.bindings.topBarSettings).toBe(workspace.topBarSettings)
+    expect(workspace.bindings.pillNav).toBe(workspace.pillNav)
+    expect(workspace.renderer).toEqual({ target: collection })
+    expect(workspace.bindings.renderer).toEqual({ target: collection })
+    expect(workspace.controls.initialValues.plateFormat).toBe(96)
+    expect(workspace.sidebar.panels.design.map(panel => panel.id)).toContain('dose')
+    expect(workspace.componentProps.map(binding => binding.component)).toContain('DoseCalculator')
+    expect(workspace.componentProps.map(binding => binding.component)).toContain('WellPlate')
+    expect(workspace.componentBindingsById['plate-map:WellPlate'].component).toBe('WellPlate')
+    expect(workspace.componentBindingsById['plate-map:WellPlate'].props.wells).toBeDefined()
+    expect(workspace.bindings.componentBindingsById['dose-response:DoseCalculator'].props.mode).toBe('serial')
+    expect(workspace.componentPropsById['plate-map:WellPlate'].wells).toBeDefined()
+    expect(workspace.bindings.componentPropsById['plate-map:WellPlate'].wells).toBeDefined()
+    expect(workspace.componentPropsById['dose-response:DoseCalculator'].mode).toBe('serial')
+    expect(workspace.componentPropsByComponent.WellPlate).toHaveLength(2)
+    expect(workspace.getComponentProps('DoseCalculator')?.mode).toBe('serial')
+    expect(workspace.bindings.getComponentProps('DoseCalculator')?.mode).toBe('serial')
+    expect(workspace.getComponentProps('WellPlate', { templateId: 'dose-response' })?.wells).toBeDefined()
+    expect(workspace.componentImports[0].statement).toContain('DoseCalculator')
+    expect(workspace.componentSnippets.map(snippet => snippet.component)).toContain('DoseCalculator')
+    expect(workspace.componentUsage?.template).toContain('<DoseCalculator')
+  })
+
+  it('returns preset controls and discoverable component metadata before concrete data exists', () => {
+    const workspace = useBioTemplateWorkspace('wellplate-screen')
+
+    expect(workspace.renderer).toBeNull()
+    expect(workspace.bindings.renderer).toBeNull()
+    expect(workspace.controlSchema.sampleNames).toBe(workspace.controls.controls.sampleNames)
+    expect(workspace.values.sampleNames).toEqual(['Control', 'Treatment'])
+    expect(workspace.activeView.value).toBe('design')
+    expect(workspace.topBar.value.pillNav.map(item => item.id)).toContain('design')
+    expect(workspace.pillNav.items.map(item => item.id)).toContain('design')
+    expect(workspace.controls.initialValues.sampleNames).toEqual(['Control', 'Treatment'])
+    expect(workspace.sidebar.panels.design.map(panel => panel.id)).toContain('layout')
+    expect(workspace.componentBindings.map(binding => binding.component)).toContain('PlateMapEditor')
+    expect(workspace.componentImports[0].statement).toContain('WellPlate')
+    expect(workspace.componentProps).toEqual([])
+    expect(workspace.componentBindingsById).toEqual({})
+    expect(workspace.componentPropsById).toEqual({})
+    expect(workspace.bindings.componentBindingsById).toEqual({})
+    expect(workspace.bindings.componentPropsById).toEqual({})
+    expect(workspace.componentPropsByComponent).toEqual({})
+    expect(workspace.getComponentProps('WellPlate')).toBeUndefined()
+    expect(workspace.componentUsage).toBeNull()
+  })
+
+  it('accepts direct initial values for generated preset controls', () => {
+    const workspace = useBioTemplateWorkspace('wellplate-screen', {
+      initialValues: {
+        sampleNames: ['Vehicle', 'Drug'],
+        unit: 'nM',
+      },
+    })
+
+    expect(workspace.controls.initialValues.sampleNames).toEqual(['Vehicle', 'Drug'])
+    expect(workspace.controls.initialValues.unit).toBe('nM')
+    expect(workspace.values.sampleNames).toEqual(['Vehicle', 'Drug'])
+    expect(workspace.form.modelValue.sampleNames).toEqual(['Vehicle', 'Drug'])
+  })
+
+  it('supports mixed-view presets for AppSidebar panels', () => {
+    const collection = createLcmsBatchCollection({
+      samples: ['S001', 'S002'],
+      features: ['Glucose', 'Lactate'],
+    })
+    const workspace = useBioTemplateWorkspace(collection)
+
+    expect(Object.keys(workspace.sidebar.panels)).toEqual(['run', 'analysis'])
+    expect(workspace.form.schema.sections.map(section => section.id)).toContain('acquisition')
+    expect(workspace.renderer?.target).toBe(collection)
+    expect(workspace.componentProps.map(binding => binding.component)).toContain('DataFrame')
+  })
+})

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

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest'
+import { useCalendarGrid } from '../../composables/useCalendarGrid'
+
+describe('useCalendarGrid', () => {
+  it('builds a stable 42-day month grid with previous and next month padding', () => {
+    const calendar = useCalendarGrid()
+    calendar.setCurrentMonthFromDate(new Date('2026-05-07T12:00:00'))
+
+    expect(calendar.weekDays).toEqual(['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'])
+    expect(calendar.monthYear.value).toBe('May 2026')
+    expect(calendar.calendarDays.value).toHaveLength(42)
+    expect(calendar.calendarDays.value[0].date.getMonth()).toBe(3)
+    expect(calendar.calendarDays.value.some(day => day.isCurrentMonth && day.date.getDate() === 7)).toBe(true)
+  })
+
+  it('applies min and max date bounds at day precision', () => {
+    const calendar = useCalendarGrid({
+      min: () => '2026-05-05T14:00:00',
+      max: () => '2026-05-10T09:00:00',
+    })
+
+    expect(calendar.isDateDisabled(new Date('2026-05-04T23:59:00'))).toBe(true)
+    expect(calendar.isDateDisabled(new Date('2026-05-05T00:00:00'))).toBe(false)
+    expect(calendar.isDateDisabled(new Date('2026-05-10T23:59:00'))).toBe(false)
+    expect(calendar.isDateDisabled(new Date('2026-05-11T00:00:00'))).toBe(true)
+  })
+
+  it('formats dates and advances months', () => {
+    const calendar = useCalendarGrid()
+    calendar.setCurrentMonthFromDate(new Date('2026-01-15T00:00:00'))
+
+    expect(calendar.formatDateValue(new Date('2026-01-05T13:00:00'))).toBe('2026-01-05')
+    calendar.nextMonth()
+    expect(calendar.monthYear.value).toBe('February 2026')
+    calendar.prevMonth()
+    expect(calendar.monthYear.value).toBe('January 2026')
+  })
+})