@morscherlab/mint-sdk 1.2.10 → 1.3.0-beta.10

package/src/__tests__/components/WellPlate.interaction.test.ts

@@ -1,5 +1,8 @@
 import { describe, expect, it, vi } from 'vitest'
 import { nextTick } from 'vue'
+import { mount } from '@vue/test-utils'
+import WellPlate from '../../components/WellPlate.vue'
+import WellEditPopupInternal from '../../components/internal/WellEditPopupInternal.vue'
 import {
   nextClickedWellSelection,
   useWellPlateInteraction,
@@ -141,6 +144,29 @@ describe('WellPlate interaction helpers', () => {
     expect(interaction.isDragging.value).toBe(false)
   })
 
+  it('should select a well when it is clicked in rectangle mode', () => {
+    const { grid, interaction, selected, selectionMode } = createInteraction()
+    selectionMode.value = 'rectangle'
+
+    interaction.handleWellMouseDown(grid[0][0], mouseEvent())
+    interaction.handleMouseUp()
+    interaction.handleWellClick(grid[0][0], mouseEvent())
+
+    expect(selected.value).toEqual(['A1'])
+  })
+
+  it('should add a well to the selection when it is shift-clicked in rectangle mode', () => {
+    const { grid, interaction, selected, selectionMode } = createInteraction()
+    selectionMode.value = 'rectangle'
+    selected.value = ['A1']
+
+    interaction.handleWellMouseDown(grid[1][1], mouseEvent({ shiftKey: true }))
+    interaction.handleMouseUp()
+    interaction.handleWellClick(grid[1][1], mouseEvent({ shiftKey: true }))
+
+    expect(selected.value).toEqual(['A1', 'B2'])
+  })
+
   it('moves wells in drag mode and resets drag state', () => {
     const { emitted, grid, interaction, selectionMode } = createInteraction()
     selectionMode.value = 'drag'
@@ -228,3 +254,190 @@ describe('WellPlate interaction helpers', () => {
     expect(interaction.dragSourceWell.value).toBeNull()
   })
 })
+
+describe('WellPlate interaction for PlateEditor (7a)', () => {
+  it('should toggle the selection instead of opening the editor when a modifier click lands on an editable plate', () => {
+    const { emitted, grid, interaction } = createInteraction({ editable: () => true })
+
+    interaction.handleWellClick(grid[0][0], mouseEvent({ ctrlKey: true }))
+
+    expect(emitted.selected?.[0]).toEqual(['A1'])
+  })
+
+  it('should not open the editor when a modifier click lands on an editable plate', () => {
+    const { grid, interaction } = createInteraction({ editable: () => true })
+
+    interaction.handleWellClick(grid[0][0], mouseEvent({ metaKey: true }))
+
+    expect(interaction.editingWellId.value).toBeNull()
+  })
+
+  it('should emit well-click when the plate is readonly', () => {
+    const { emitted, grid, interaction } = createInteraction({ readonly: () => true })
+
+    interaction.handleWellClick(grid[0][0], mouseEvent())
+
+    expect(emitted.click?.[0]).toEqual(['A1', expect.anything()])
+  })
+
+  it('should not change the selection when a readonly plate is clicked', () => {
+    const { emitted, grid, interaction } = createInteraction({ readonly: () => true })
+
+    interaction.handleWellClick(grid[0][0], mouseEvent())
+
+    expect(emitted.selected).toBeUndefined()
+  })
+})
+
+describe('WellPlate well names', () => {
+  it('should name the sample in the well label even when names are not drawn', () => {
+    const wrapper = mount(WellPlate, {
+      props: { format: 6, showWellLabels: false, wells: { A1: { sampleType: 'sample', metadata: { label: 'S001' } } } },
+    })
+
+    expect(wrapper.find('[aria-label="Well A1, Name: S001, Sample type: sample"]').exists()).toBe(true)
+  })
+
+  const grouped = {
+    format: 6 as const,
+    legendItems: [{ type: 'ctrl', label: 'Control', color: 'red' }],
+    wells: { A1: { sampleType: 'qc', group: 'ctrl' } },
+  }
+
+  it('should name the group in the well label when the well has a group', () => {
+    const wrapper = mount(WellPlate, { props: grouped })
+
+    expect(wrapper.find('[aria-label="Well A1, Sample type: qc, Group: Control"]').exists()).toBe(true)
+  })
+
+  it('should name the group in the well tooltip when the well has a group', () => {
+    const wrapper = mount(WellPlate, { props: grouped })
+
+    expect(wrapper.get('[role="gridcell"]').attributes('title')).toBe('A1: qc, Control')
+  })
+})
+
+describe('WellPlate edit popover', () => {
+  it('should not reopen a popover that closed when the plate stopped being editable', async () => {
+    const wrapper = mount(WellPlate, { props: { format: 6, editable: true }, global: { stubs: { teleport: true } } })
+    await wrapper.get('[aria-label="Well B2"]').trigger('click')
+
+    await wrapper.setProps({ editable: false })
+    await wrapper.setProps({ editable: true })
+
+    expect(wrapper.findComponent(WellEditPopupInternal).exists()).toBe(false)
+  })
+})
+
+describe('WellPlate Shift-click range selection', () => {
+  it('should select the rectangle from the anchor when Shift-clicking another well', () => {
+    const { grid, interaction, selected } = createInteraction()
+
+    interaction.handleWellClick(grid[0][0], mouseEvent())
+    interaction.handleWellClick(grid[1][1], mouseEvent({ shiftKey: true }))
+
+    expect(selected.value).toEqual(['A1', 'A2', 'B1', 'B2'])
+  })
+
+  it('should keep the anchor when Shift-clicking twice', () => {
+    const { grid, interaction, selected } = createInteraction()
+
+    interaction.handleWellClick(grid[0][1], mouseEvent())
+    interaction.handleWellClick(grid[1][1], mouseEvent({ shiftKey: true }))
+    interaction.handleWellClick(grid[1][0], mouseEvent({ shiftKey: true }))
+
+    expect(selected.value).toEqual(['A1', 'A2', 'B1', 'B2'])
+  })
+
+  it('should move the anchor when a well is plain-clicked', () => {
+    const { grid, interaction, selected } = createInteraction()
+
+    interaction.handleWellClick(grid[0][0], mouseEvent())
+    interaction.handleWellClick(grid[1][0], mouseEvent())
+    interaction.handleWellClick(grid[1][1], mouseEvent({ shiftKey: true }))
+
+    expect(selected.value).toEqual(['B1', 'B2'])
+  })
+
+  it('should toggle a well on Ctrl-click after an anchor is set', () => {
+    const { grid, interaction, selected } = createInteraction()
+
+    interaction.handleWellClick(grid[0][0], mouseEvent())
+    interaction.handleWellClick(grid[1][1], mouseEvent({ ctrlKey: true }))
+
+    expect(selected.value).toEqual(['A1', 'B2'])
+  })
+
+  it('should toggle a well on Shift-click when no anchor is set', () => {
+    const { grid, interaction, selected } = createInteraction()
+    selected.value = ['A1']
+
+    interaction.handleWellClick(grid[1][1], mouseEvent({ shiftKey: true }))
+
+    expect(selected.value).toEqual(['A1', 'B2'])
+  })
+
+  it('should drop the anchor when the selection is cleared', async () => {
+    const { grid, interaction, selected } = createInteraction()
+
+    interaction.handleWellClick(grid[0][0], mouseEvent())
+    interaction.handleKeyDown({ key: 'Escape' } as KeyboardEvent)
+    await nextTick()
+    interaction.handleWellClick(grid[1][1], mouseEvent({ shiftKey: true }))
+
+    expect(selected.value).toEqual(['B2'])
+  })
+
+  it('should ignore Shift ranges in single selection mode', () => {
+    const { grid, interaction, selected, selectionMode } = createInteraction()
+    selectionMode.value = 'single'
+
+    interaction.handleWellClick(grid[0][0], mouseEvent())
+    interaction.handleWellClick(grid[1][1], mouseEvent({ shiftKey: true }))
+
+    expect(selected.value).toEqual(['B2'])
+  })
+
+  it('should range from the start of a dragged rectangle', () => {
+    const { grid, interaction, selected, selectionMode } = createInteraction()
+    selectionMode.value = 'rectangle'
+
+    interaction.handleWellClick(grid[1][1], mouseEvent())
+    interaction.handleWellMouseDown(grid[0][0], mouseEvent())
+    interaction.handleWellMouseEnter(grid[0][1], mouseEvent())
+    interaction.handleMouseUp()
+    interaction.handleWellClick(grid[1][0], mouseEvent({ shiftKey: true }))
+
+    expect(selected.value).toEqual(['A1', 'B1'])
+  })
+
+  it('should add the range to the selection when Ctrl+Shift-clicking', () => {
+    const { grid, interaction, selected } = createInteraction()
+
+    interaction.handleWellClick(grid[0][0], mouseEvent())
+    interaction.handleWellClick(grid[1][0], mouseEvent({ ctrlKey: true }))
+    interaction.handleWellClick(grid[1][1], mouseEvent({ ctrlKey: true, shiftKey: true }))
+
+    expect(selected.value).toEqual(['A1', 'B1', 'B2'])
+  })
+
+  it('should range from the well whose editor a plain click opened', () => {
+    const { grid, interaction, selected } = createInteraction({ editable: () => true })
+
+    interaction.handleWellClick(grid[0][0], mouseEvent())
+    interaction.handleWellClick(grid[0][1], mouseEvent({ shiftKey: true }))
+
+    expect(selected.value).toEqual(['A1', 'A2'])
+  })
+
+  it('should emit the range on Shift+Enter from a focused well', async () => {
+    const wrapper = mount(WellPlate, { props: { format: 6 } })
+    const cells = wrapper.findAll('[role="gridcell"]')
+
+    await cells[0].trigger('keydown', { key: 'Enter' })
+    await wrapper.setProps({ modelValue: ['A1'] })
+    await cells[4].trigger('keydown', { key: 'Enter', shiftKey: true })
+
+    expect(wrapper.emitted('selection-change')?.at(-1)?.[0]).toEqual(['A1', 'A2', 'B1', 'B2'])
+  })
+})

package/src/__tests__/components/WellPlate.keyboard.test.ts

@@ -0,0 +1,24 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+import WellPlate from '../../components/WellPlate.vue'
+
+// Shortcuts belong to the plate, never the page (7a): Ctrl/Cmd+A in an
+// unrelated input must keep selecting text.
+describe('WellPlate keyboard scope', () => {
+  it('should ignore Ctrl+A pressed outside the plate', () => {
+    const wrapper = mount(WellPlate, { props: { format: 6 }, attachTo: document.body })
+
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'a', ctrlKey: true, bubbles: true }))
+
+    expect(wrapper.emitted('selection-change')).toBeUndefined()
+    wrapper.unmount()
+  })
+
+  it('should select every well on Ctrl+A pressed inside the plate', async () => {
+    const wrapper = mount(WellPlate, { props: { format: 6 } })
+
+    await wrapper.get('[role="gridcell"]').trigger('keydown', { key: 'a', ctrlKey: true })
+
+    expect(wrapper.emitted('selection-change')?.[0]?.[0]).toHaveLength(6)
+  })
+})

package/src/__tests__/components/WellPlate.rendering.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, it } from 'vitest'
 import {
-  sampleTypeIndicator,
   wellBadge,
   wellClasses,
   wellLabel,
@@ -70,42 +69,62 @@ describe('WellPlate rendering helpers', () => {
       heatmap: { enabled: false },
       sampleColors: { treated: '#123456' },
     })).toEqual({
-      backgroundColor: '#12345626',
-      border: '1px solid #12345666',
+      backgroundColor: 'color-mix(in srgb, #123456 15%, transparent)',
+      border: '1px solid color-mix(in srgb, #123456 40%, transparent)',
     })
 
     expect(wellStyle(well({ sampleType: 'qc' }), {
       heatmap: { enabled: false },
       sampleColors: {},
     })).toEqual({
-      backgroundColor: 'rgba(139, 92, 246, 0.15)',
-      border: '1px solid rgba(139, 92, 246, 0.4)',
+      backgroundColor: 'color-mix(in srgb, #8b5cf6 15%, transparent)',
+      border: '1px solid color-mix(in srgb, #8b5cf6 40%, transparent)',
     })
   })
 
-  it('falls back to empty or filled well styles', () => {
+  it('should tint a sample well green when no custom color is set', () => {
+    expect(wellStyle(well({ sampleType: 'sample' }), {
+      heatmap: { enabled: false },
+      sampleColors: {},
+    }).border).toBe('1px solid color-mix(in srgb, #10b981 40%, transparent)')
+  })
+
+  it('should tint a blank well orange when no custom color is set', () => {
+    expect(wellStyle(well({ sampleType: 'blank' }), {
+      heatmap: { enabled: false },
+      sampleColors: {},
+    }).border).toBe('1px solid color-mix(in srgb, #f97316 40%, transparent)')
+  })
+
+  it('should color a well by its group before its sample type', () => {
+    expect(wellStyle(well({ sampleType: 'iqc', group: 'trt' }), {
+      heatmap: { enabled: false },
+      sampleColors: { trt: '#123456' },
+    }).border).toBe('1px solid color-mix(in srgb, #123456 40%, transparent)')
+  })
+
+  it('should tint a well with a group color token', () => {
+    expect(wellStyle(well({ sampleType: 'sample', group: 'trt' }), {
+      heatmap: { enabled: false },
+      sampleColors: { trt: 'var(--mint-sample-3)' },
+    }).backgroundColor).toBe('color-mix(in srgb, var(--mint-sample-3) 15%, transparent)')
+  })
+
+  it('should leave empty wells to the stylesheet when the well has no sample type', () => {
     expect(wellStyle(well(), {
       heatmap: { enabled: false },
       sampleColors: {},
-    })).toEqual({
-      backgroundColor: 'var(--bg-tertiary)',
-      border: '1px dashed var(--border-color)',
-    })
+    })).toEqual({})
+  })
 
+  it('should leave filled wells to the stylesheet when the well has no sample type', () => {
     expect(wellStyle(well({ state: 'filled' }), {
       heatmap: { enabled: false },
       sampleColors: {},
-    })).toEqual({
-      backgroundColor: 'var(--bg-tertiary)',
-      border: '1px solid var(--border-color)',
-    })
+    })).toEqual({})
   })
 
-  it('formats indicators, labels, and badges for optional overlays', () => {
-    expect(sampleTypeIndicator(well({ sampleType: 'qc' }), true)).toBe('Q')
-    expect(sampleTypeIndicator(well({ sampleType: 'treated' }), true)).toBe('T')
-    expect(sampleTypeIndicator(well({ sampleType: 'treated' }), false)).toBeNull()
-
+  it('formats labels and badges for optional overlays', () => {
     expect(wellLabel(well({ metadata: { label: 'Dose A' } }), true)).toBe('Dose A')
     expect(wellLabel(well({ metadata: { label: 'Dose A' } }), false)).toBeUndefined()
 

package/src/__tests__/components/WellPlate.sampleDrop.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest'
 import {
   createTextDroppedSample,
   normalizeDroppedSample,
+  parseDroppedSampleJson,
   parseDroppedSampleTransfer,
 } from '../../components/WellPlate.sampleDrop'
 
@@ -68,3 +69,21 @@ describe('WellPlate sample drop helpers', () => {
     expect(parseDroppedSampleTransfer(createTransfer({ 'application/json': '{' }))).toBeNull()
   })
 })
+
+describe('parseDroppedSampleJson', () => {
+  it('should return null for a plain-text payload', () => {
+    expect(parseDroppedSampleJson(createTransfer({ 'text/plain': 'Sample 1' }))).toBeNull()
+  })
+
+  it('should parse a JSON sample payload', () => {
+    expect(parseDroppedSampleJson(createTransfer({ 'application/json': '{"id":"s1"}' }))?.id).toBe('s1')
+  })
+
+  it('should ignore an injection count below one', () => {
+    expect(normalizeDroppedSample({ name: 'x', injectionCount: -3 })?.injectionCount).toBeUndefined()
+  })
+
+  it('should ignore a zero injection volume', () => {
+    expect(normalizeDroppedSample({ name: 'x', injectionVolume: 0 })?.injectionVolume).toBeUndefined()
+  })
+})

package/src/__tests__/components/WellPlate.sampleTypeIndicator.test.ts

@@ -0,0 +1,58 @@
+import { mount } from '@vue/test-utils'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import WellPlate from '../../components/WellPlate.vue'
+import type { Well } from '../../types'
+
+// `showSampleTypeIndicator` is deprecated (3a): wells carry no letters, color
+// encodes the type. The warning fires once per module, so the order of the
+// first two tests matters.
+
+function mountPlate(sampleType: string, showSampleTypeIndicator: boolean) {
+  const wells: Record<string, Partial<Well>> = {
+    A1: { id: 'A1', row: 0, col: 0, state: 'filled', sampleType },
+  }
+  return mount(WellPlate, { props: { format: 6, wells, showSampleTypeIndicator } })
+}
+
+const firstWellText = (sampleType: string) =>
+  mountPlate(sampleType, true).findAll('.mint-well-plate__well')[0].text()
+
+describe('WellPlate showSampleTypeIndicator (deprecated)', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('should not warn when showSampleTypeIndicator is off', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    mountPlate('sample', false)
+    expect(warn).not.toHaveBeenCalled()
+  })
+
+  it('should warn once when several plates set showSampleTypeIndicator', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    mountPlate('sample', true)
+    mountPlate('blank', true)
+    expect(warn).toHaveBeenCalledTimes(1)
+  })
+
+  it('should render no letter for a sample well when showSampleTypeIndicator is on', () => {
+    expect(firstWellText('sample')).toBe('')
+  })
+
+  it('should render no letter for a control well when showSampleTypeIndicator is on', () => {
+    expect(firstWellText('control')).toBe('')
+  })
+
+  it('should render no letter for a blank well when showSampleTypeIndicator is on', () => {
+    expect(firstWellText('blank')).toBe('')
+  })
+
+  it('should render no letter for a QC well when showSampleTypeIndicator is on', () => {
+    expect(firstWellText('qc')).toBe('')
+  })
+
+  it('should render no letter for an iQC well when showSampleTypeIndicator is on', () => {
+    expect(firstWellText('iqc')).toBe('')
+  })
+})

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

@@ -110,7 +110,7 @@ it('bounds recursive traversal and rejects truncated listings', async () => {
     mount_id, path,
     entries: [{ kind: 'directory', name: 'next', path: path ? `${path}/next` : 'next' }],
   }))
-  await expect(adapter.search('missing', { path: '', recursive: true })).rejects.toThrow('folder limit')
+  expect(await adapter.search('missing', { path: '', recursive: true })).toEqual({ nodes: [], truncated: true })
   expect(transport.browse).toHaveBeenCalledTimes(500)
   vi.mocked(transport.browse).mockResolvedValue({ mount_id: 'raw', path: '', entries: [], truncated: true })
   await expect(adapter.listRoot({ refresh: true })).rejects.toThrow('listing limit')
@@ -140,3 +140,116 @@ it('keeps folders expandable when filtered child counts are zero', async () => {
   expect(folder?.kind).toBe('folder')
   expect(folder).not.toHaveProperty('hasChildren', false)
 })
+
+it('should mark the adapter as mount-rooted when no root location is configured', () => {
+  expect(createFilePickerAdapter(setup().transport).mounts).toBe(true)
+})
+
+it('should not mark the adapter as mount-rooted when a root location is configured', () => {
+  expect(setup().adapter.mounts).toBe(false)
+})
+
+it('should carry the entry modification time onto the picker node', async () => {
+  const { adapter, transport } = setup()
+  vi.mocked(transport.browse).mockResolvedValueOnce({
+    mount_id: 'raw', path: '',
+    entries: [{ kind: 'file', name: 'a.raw', path: 'a.raw', modified_at: '2026-09-24T14:32:00Z' }],
+  })
+  expect((await adapter.listRoot())[0]!.modifiedAt).toBe('2026-09-24T14:32:00Z')
+})
+
+it('names the mount holding a path and nothing for a path it cannot decode', () => {
+  const adapter = createFilePickerAdapter(setup().transport)
+  expect([adapter.mountOf!(identity('study/run')), adapter.mountOf!('not-json')]).toEqual([identity(), undefined])
+})
+
+function treeSetup() {
+  const study = { kind: 'directory' as const, name: 'study', path: 'study' }
+  const run = { kind: 'file' as const, name: 'run.raw', path: 'study/run.raw' }
+  const transport: FilePickerTransport = {
+    listMounts: vi.fn(async () => [{ id: 'raw', label: 'Raw files' }]),
+    browse: vi.fn(async ({ mount_id, path }) => ({ mount_id, path, entries: [] })),
+    tree: vi.fn(async ({ mount_id }) => ({
+      listings: [
+        { mount_id, path: '', entries: [study] },
+        { mount_id, path: 'study', entries: [run] },
+      ],
+      truncated: false,
+    })),
+    search: vi.fn(async ({ path }) => ({
+      entries: [study, run].filter((entry) => !path || entry.path.startsWith(`${path}/`)),
+      searched_directories: 2,
+      truncated: false,
+    })),
+  }
+  return { transport, adapter: createFilePickerAdapter(transport, { rootLocation: { mount_id: 'raw', path: '' } }) }
+}
+
+it('should serve a subfolder from the tree response when the transport has tree', async () => {
+  const { adapter, transport } = treeSetup()
+  await adapter.listRoot()
+  await adapter.listChildren(identity('study'))
+  expect(transport.tree).toHaveBeenCalledTimes(1)
+})
+
+it('should not call browse when the transport has tree', async () => {
+  const { adapter, transport } = treeSetup()
+  await adapter.listRoot()
+  expect(transport.browse).not.toHaveBeenCalled()
+})
+
+it('should map tree listings to their own parent folders', async () => {
+  const { adapter } = treeSetup()
+  await adapter.listRoot()
+  expect(await adapter.listChildren(identity('study'))).toMatchObject([
+    { path: identity('study/run.raw'), parentPath: identity('study'), kind: 'file' },
+  ])
+})
+
+it('should search on the server when the transport has search', async () => {
+  const { adapter, transport } = treeSetup()
+  await adapter.search('ru', { path: identity('study'), recursive: true })
+  expect(transport.search).toHaveBeenCalledWith({ mount_id: 'raw', path: 'study' }, 'ru', true, undefined)
+})
+
+it('should give server search results their parent folder', async () => {
+  const { adapter } = treeSetup()
+  expect(await adapter.search('ru', { path: '', recursive: true })).toMatchObject([
+    { path: identity('study'), parentPath: null },
+    { path: identity('study/run.raw'), parentPath: identity('study') },
+  ])
+})
+
+it('should return partial server results marked truncated when the server stops early', async () => {
+  const { adapter, transport } = treeSetup()
+  vi.mocked(transport.search!).mockResolvedValueOnce({
+    entries: [{ kind: 'file', name: 'run.raw', path: 'study/run.raw' }], searched_directories: 5000, truncated: true,
+  })
+  expect(await adapter.search('ru', { path: '', recursive: true })).toMatchObject({
+    nodes: [{ path: identity('study/run.raw') }], truncated: true,
+  })
+})
+
+it('should reject a search entry whose name is only a suffix of its last path segment', async () => {
+  const { adapter, transport } = treeSetup()
+  vi.mocked(transport.search!).mockResolvedValueOnce({
+    entries: [{ kind: 'file', name: 'b', path: 'study/ab' }], searched_directories: 1, truncated: false,
+  })
+  await expect(adapter.search('b', { path: '', recursive: true })).rejects.toThrow(/Invalid/)
+})
+
+it('should reject a server search entry outside the searched folder', async () => {
+  const { adapter, transport } = treeSetup()
+  vi.mocked(transport.search!).mockResolvedValueOnce({
+    entries: [{ kind: 'file', name: 'x.raw', path: 'other/x.raw' }], searched_directories: 1, truncated: false,
+  })
+  await expect(adapter.search('x', { path: identity('study'), recursive: true })).rejects.toThrow(/Invalid/)
+})
+
+it('should reject a nested entry from a search limited to this folder', async () => {
+  const { adapter, transport } = treeSetup()
+  vi.mocked(transport.search!).mockResolvedValueOnce({
+    entries: [{ kind: 'file', name: 'x.raw', path: 'study/private/x.raw' }], searched_directories: 1, truncated: false,
+  })
+  await expect(adapter.search('x', { path: identity('study'), recursive: false })).rejects.toThrow(/Invalid/)
+})

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

@@ -58,7 +58,7 @@ describe('useBioTemplatePackWorkspace', () => {
     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.componentProps.value.map(binding => binding.component)).toContain('PlateEditor')
     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()

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

@@ -63,7 +63,7 @@ describe('useBioTemplateWorkspace', () => {
     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.componentBindings.map(binding => binding.component)).toContain('PlateEditor')
     expect(workspace.componentImports[0].statement).toContain('WellPlate')
     expect(workspace.componentProps).toEqual([])
     expect(workspace.componentBindingsById).toEqual({})

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

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest'
+import { useChemicalFormula } from '../../composables/useChemicalFormula'
+
+const { parseFormula, calculateMW, renderFormulaParts } = useChemicalFormula()
+
+describe('useChemicalFormula parser (4b)', () => {
+  it('should multiply a parenthesised group when it carries a count', () => {
+    expect(parseFormula('Ca(OH)2').elements).toEqual({ Ca: 1, O: 2, H: 2 })
+  })
+
+  it('should add hydrate water when the formula uses a middle dot', () => {
+    expect(parseFormula('CuSO4·5H2O').elements).toEqual({ Cu: 1, S: 1, O: 9, H: 10 })
+  })
+
+  it('should accept an asterisk as the hydrate separator', () => {
+    expect(parseFormula('CuSO4*5H2O').elements).toEqual({ Cu: 1, S: 1, O: 9, H: 10 })
+  })
+
+  it('should name the symbol when an element is unknown', () => {
+    expect(parseFormula('C6Xx2').error).toBe('Unknown element: Xx')
+  })
+
+  it('should compute the molecular weight of glucose when parsed', () => {
+    expect(calculateMW(parseFormula('C6H12O6').elements)).toBeCloseTo(180.156, 2)
+  })
+
+  it('should render a hydrate coefficient as full-size text when it follows the dot', () => {
+    expect(renderFormulaParts('CuSO4·5H2O')).toContainEqual({ type: 'coefficient', text: '5' })
+  })
+
+  it('should render the asterisk hydrate separator as a middle dot', () => {
+    expect(renderFormulaParts('CuSO4*5H2O')).toContainEqual({ type: 'dot', text: '·' })
+  })
+})
+
+describe('useChemicalFormula charges', () => {
+  it('should keep the subscript when a polyatomic ion has a bare trailing sign', () => {
+    expect(parseFormula('NH4+').elements).toEqual({ N: 1, H: 4 })
+  })
+
+  it('should read the digits as the charge when a lone element has a bare trailing sign', () => {
+    expect(parseFormula('Fe2+').elements).toEqual({ Fe: 1 })
+  })
+
+  it('should strip a caret charge when the formula ends with one', () => {
+    expect(parseFormula('SO4^2-').elements).toEqual({ S: 1, O: 4 })
+  })
+
+  it('should reject the formula when it is only a charge', () => {
+    expect(parseFormula('+').valid).toBe(false)
+  })
+
+  it('should render the subscript when a polyatomic ion has a bare trailing sign', () => {
+    expect(renderFormulaParts('NH4+')).toContainEqual({ type: 'subscript', text: '4' })
+  })
+
+  it('should render the digits as the charge when a lone element has a bare trailing sign', () => {
+    expect(renderFormulaParts('Fe2+')).toEqual([{ type: 'element', text: 'Fe' }, { type: 'charge', text: '2+' }])
+  })
+})