@morscherlab/mint-sdk 1.3.0-beta.3 → 1.3.0-beta.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morscherlab/mint-sdk",
-  "version": "1.3.0-beta.3",
+  "version": "1.3.0-beta.5",
   "description": "MINT Platform SDK — Vue 3 components, composables, and types for plugin development. MINT = Mass-spec INtegrated Toolkit.",
   "type": "module",
   "main": "./dist/index.js",
@@ -67,16 +67,12 @@
     "story:preview": "histoire preview"
   },
   "peerDependencies": {
-    "@simplewebauthn/browser": "^14.0.0",
     "pinia": "^4.0.3",
     "tailwindcss": "^4.3.3",
     "vue": "^3.5.43",
     "vue-router": "^5.3.1"
   },
   "peerDependenciesMeta": {
-    "@simplewebauthn/browser": {
-      "optional": true
-    },
     "vue-router": {
       "optional": true
     }
@@ -89,7 +85,6 @@
   },
   "devDependencies": {
     "@histoire/plugin-vue": "1.0.0-beta.1",
-    "@simplewebauthn/browser": "14.0.0",
     "@types/node": "22.20.4",
     "@vitejs/plugin-vue": "6.0.9",
     "@vue/language-core": "3.3.11",

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

@@ -267,4 +267,14 @@ describe('ActionMenu', () => {
 
     expect(document.activeElement).toBe(trigger.element)
   })
+
+  it('should render a checked item as a checked menu radio when checked is set', async () => {
+    const wrapper = mount(ActionMenu, {
+      attachTo: document.body,
+      props: { label: 'Sort', items: [{ id: 'a', label: 'A', checked: true }, { id: 'b', label: 'B', checked: false }] },
+    })
+    await wrapper.get('button').trigger('click')
+    const radios = [...document.body.querySelectorAll('[role="menuitemradio"]')]
+    expect(radios.map((item) => item.getAttribute('aria-checked'))).toEqual(['true', 'false'])
+  })
 })

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

@@ -1211,12 +1211,12 @@ describe('AppTopBar', () => {
         expect(wrapper.get('.mint-topbar__plugin-name').text()).toBe('LC-MS Analysis')
       })
 
-      it('should render the plugin version in mono after the name when integrated', () => {
+      it('should not render the plugin version when integrated', () => {
         mockPlatformCtx({ isIntegrated: true, plugin: integratedPlugin })
 
         const wrapper = createWrapper()
 
-        expect(wrapper.get('.mint-topbar__plugin-version').text()).toBe('v2.4.0')
+        expect(wrapper.text()).not.toContain('v2.4.0')
       })
 
       it('should not render the plugin identity text when standalone', () => {
@@ -1225,21 +1225,29 @@ describe('AppTopBar', () => {
         expect(wrapper.find('.mint-topbar__plugin-name').exists()).toBe(false)
       })
 
-      it('should render a divider between the identity and the page selector', () => {
+      it('should hide the plugin name when a page selector is shown', () => {
         mockPlatformCtx({ isIntegrated: true, plugin: integratedPlugin })
 
         const wrapper = createWrapper({ pageSelector: pages, currentPageSelectorId: 'peaks' })
 
-        expect(wrapper.get('.mint-topbar__divider').element.nextElementSibling?.classList)
-          .toContain('mint-page-selector')
+        expect(wrapper.find('.mint-topbar__plugin-name').exists()).toBe(false)
       })
 
-      it('should not render the divider without a page selector', () => {
-        mockPlatformCtx({ isIntegrated: true, plugin: integratedPlugin })
+      it('should hide the plugin name when the plugin declares several nav items', () => {
+        mockPlatformCtx({
+          isIntegrated: true,
+          plugin: {
+            ...integratedPlugin,
+            nav_items: [
+              { id: 'peaks', path: '/', label: 'Peaks' },
+              { id: 'report', path: '/report', label: 'Report' },
+            ],
+          },
+        })
 
         const wrapper = createWrapper()
 
-        expect(wrapper.find('.mint-topbar__divider').exists()).toBe(false)
+        expect(wrapper.find('.mint-topbar__plugin-name').exists()).toBe(false)
       })
 
       it('should not repeat the title next to the integrated identity', () => {

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

@@ -20,4 +20,19 @@ describe('EmptyState', () => {
 
     expect(wrapper.emitted('action')).toHaveLength(1)
   })
+
+  it('should wrap default-slot content in the spaced content block', () => {
+    const wrapper = mount(EmptyState, {
+      props: { title: 'No instruments yet', description: 'Add the lab systems.' },
+      slots: { default: '<button class="slot-action">New instrument</button>' },
+    })
+
+    expect(wrapper.find('.mint-empty-state__content .slot-action').exists()).toBe(true)
+  })
+
+  it('should not render the content block without default-slot content', () => {
+    const wrapper = mount(EmptyState, { props: { title: 'Empty' } })
+
+    expect(wrapper.find('.mint-empty-state__content').exists()).toBe(false)
+  })
 })

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

@@ -548,9 +548,10 @@ describe('FilePicker list view', () => {
     await row(wrapper, folder.path).trigger('dblclick')
     await flushPromises()
     expect(wrapper.findAll('[role="option"]').map((item) => item.attributes('data-path'))).toEqual([
+      // Undated rows fall back to name order under the default newest-first sort.
+      unsupported.path,
       one.path,
       two.path,
-      unsupported.path,
     ])
   })
 
@@ -767,4 +768,67 @@ describe('formatModified', () => {
   it('should show the full date outside the current year', () => {
     expect(formatModified('2025-01-02T08:00:00', now)).toBe('2025-01-02')
   })
+
+  it('should list the newest folder first when opened', async () => {
+    const wrapper = await setup({
+      adapter: {
+        ...adapter(),
+        listRoot: vi.fn(async () => [
+          { ...folder, modifiedAt: '2026-01-01T00:00:00Z' },
+          { ...other, modifiedAt: '2026-09-29T00:00:00Z' },
+        ]),
+      },
+    })
+    expect(wrapper.findAll('[role="treeitem"]').map((item) => item.attributes('data-path'))).toEqual([
+      other.path, folder.path,
+    ])
+  })
+
+  it('should reorder rows by name when Name A–Z is chosen from the sort menu', async () => {
+    const wrapper = await setup({ defaultSort: 'name-desc' })
+    await wrapper.get('.mint-picker__sort').trigger('click')
+    await wrapper.findAll('[role="menuitemradio"]').find((item) => item.text() === 'Name A–Z')!.trigger('click')
+    expect(wrapper.findAll('[role="treeitem"]').map((item) => item.attributes('data-path'))).toEqual([
+      other.path, folder.path,
+    ])
+  })
+
+  it('should label the sort trigger with the active order', async () => {
+    const wrapper = await setup()
+    expect(wrapper.get('.mint-picker__sort').text()).toContain('Newest first')
+  })
+
+  it('should tell the user when search results are partial', async () => {
+    vi.useFakeTimers()
+    const base = adapter()
+    const wrapper = await setup({
+      adapter: { ...base, search: vi.fn(async () => ({ nodes: [one], truncated: true })) },
+    })
+    await wrapper.get('[aria-label="Search folders and files"]').setValue('sample')
+    await vi.advanceTimersByTimeAsync(400)
+    await flushPromises()
+    expect(wrapper.get('.mint-picker__truncated').text()).toContain('first 1')
+  })
+
+  it('should still list the partial search results', async () => {
+    vi.useFakeTimers()
+    const wrapper = await setup({
+      adapter: { ...adapter(), search: vi.fn(async () => ({ nodes: [one], truncated: true })) },
+    })
+    await wrapper.get('[aria-label="Search folders and files"]').setValue('sample')
+    await vi.advanceTimersByTimeAsync(400)
+    await flushPromises()
+    expect(wrapper.findAll('[role="treeitem"]').map((item) => item.attributes('data-path'))).toEqual([one.path])
+  })
+
+  it('should say the search stopped early when a truncated search found nothing', async () => {
+    vi.useFakeTimers()
+    const wrapper = await setup({
+      adapter: { ...adapter(), search: vi.fn(async () => ({ nodes: [], truncated: true })) },
+    })
+    await wrapper.get('[aria-label="Search folders and files"]').setValue('sample')
+    await vi.advanceTimersByTimeAsync(400)
+    await flushPromises()
+    expect(wrapper.get('.mint-picker__empty').text()).toContain('stopped')
+  })
 })

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

@@ -26,7 +26,7 @@ describe('WellPlate per-well decoration', () => {
       .toEqual(['2px', 'solid', 'var(--mint-warning)'])
   })
 
-  it('should render the QC marker glyph when a QC well has no label or id', () => {
+  it('should render no glyph when a QC well has no label or id', () => {
     const wrapper = mount(WellPlate, {
       props: {
         format: 6,
@@ -34,37 +34,13 @@ describe('WellPlate per-well decoration', () => {
       },
     })
 
-    expect(wrapper.findAll('.mint-well-plate__well')[0].text()).toBe('Q')
+    expect(wrapper.findAll('.mint-well-plate__well')[0].text()).toBe('')
   })
 
-  it('should keep the iQC marker glyph when well IDs are shown', () => {
-    const wrapper = mount(WellPlate, {
-      props: {
-        format: 6,
-        showWellIds: true,
-        wells: { A1: { id: 'A1', row: 0, col: 0, state: 'filled', sampleType: 'iqc' } },
-      },
-    })
-
-    expect(wrapper.findAll('.mint-well-plate__well')[0].find('.mint-well-plate__corner-glyph').text()).toBe('i')
-  })
-
-  it('should keep the iQC marker glyph when a custom label is shown', () => {
-    const wrapper = mount(WellPlate, {
-      props: {
-        format: 6,
-        showWellLabels: true,
-        wells: { A1: { id: 'A1', row: 0, col: 0, state: 'filled', sampleType: 'iqc', metadata: { label: 'Std 1' } } },
-      },
-    })
-
-    expect(wrapper.findAll('.mint-well-plate__well')[0].find('.mint-well-plate__corner-glyph').text()).toBe('i')
-  })
-
-  it('should draw legend swatches with the sample-type marker when the legend is shown', () => {
+  it('should draw plain legend swatches when the legend is shown', () => {
     const wrapper = mount(WellPlate, { props: { format: 6, showLegend: true } })
 
     const dots = wrapper.findAll('.mint-well-plate__sample-legend-dot')
-    expect(dots.map(dot => dot.text())).toEqual(['', '', 'Q', 'i'])
+    expect(dots.map(dot => dot.text())).toEqual(['', '', '', ''])
   })
 })

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

@@ -1,6 +1,5 @@
 import { describe, expect, it } from 'vitest'
 import {
-  sampleTypeGlyph,
   wellBadge,
   wellClasses,
   wellLabel,
@@ -70,45 +69,45 @@ describe('WellPlate rendering helpers', () => {
       heatmap: { enabled: false },
       sampleColors: { treated: '#123456' },
     })).toEqual({
-      backgroundColor: 'color-mix(in srgb, #123456 28%, var(--bg-card))',
-      border: '1px solid #123456',
+      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: 'var(--bg-card)',
-      border: '1.5px solid var(--text-secondary-strong)',
+      backgroundColor: 'color-mix(in srgb, #8b5cf6 15%, transparent)',
+      border: '1px solid color-mix(in srgb, #8b5cf6 40%, transparent)',
     })
   })
 
-  it('should fill a sample well with its group token when no custom color is set', () => {
+  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 var(--mint-sample-1)')
+    }).border).toBe('1px solid color-mix(in srgb, #10b981 40%, transparent)')
   })
 
-  it('should color a well by its group before its sample type', () => {
-    expect(wellStyle(well({ sampleType: 'iqc', group: 'trt' }), {
+  it('should tint a blank well orange when no custom color is set', () => {
+    expect(wellStyle(well({ sampleType: 'blank' }), {
       heatmap: { enabled: false },
-      sampleColors: { trt: '#123456' },
-    }).border).toBe('1px solid #123456')
+      sampleColors: {},
+    }).border).toBe('1px solid color-mix(in srgb, #f97316 40%, transparent)')
   })
 
-  it('should keep a grouped blank well neutral', () => {
-    expect(wellStyle(well({ sampleType: 'blank', group: 'trt' }), {
+  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('1.5px dashed var(--_control-border-strong)')
+    }).border).toBe('1px solid color-mix(in srgb, #123456 40%, transparent)')
   })
 
-  it('should keep QC neutral when a custom QC color is set', () => {
-    expect(wellStyle(well({ sampleType: 'qc' }), {
+  it('should tint a well with a group color token', () => {
+    expect(wellStyle(well({ sampleType: 'sample', group: 'trt' }), {
       heatmap: { enabled: false },
-      sampleColors: { qc: '#8b5cf6' },
-    }).border).toBe('1.5px solid var(--text-secondary-strong)')
+      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', () => {
@@ -125,29 +124,17 @@ describe('WellPlate rendering helpers', () => {
     })).toEqual({})
   })
 
-  it('should return the Q glyph when the well is QC', () => {
-    expect(sampleTypeGlyph(well({ sampleType: 'qc' }))).toBe('Q')
-  })
-
-  it('should return the i glyph when the well is iQC', () => {
-    expect(sampleTypeGlyph(well({ sampleType: 'iqc' }))).toBe('i')
-  })
-
-  it('should return no glyph when the well is a sample', () => {
-    expect(sampleTypeGlyph(well({ sampleType: 'sample' }))).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()
 
     expect(wellBadge(well({ metadata: { injectionCount: 3 } }), true)).toEqual({
       text: '3',
-      color: 'var(--text-primary)',
+      color: '#6366f1',
     })
     expect(wellBadge(well({ metadata: { customMethod: 'LCMS-2' } }), true)).toEqual({
-      text: '',
-      color: 'var(--color-purple)',
+      text: '+',
+      color: '#ec4899',
     })
     expect(wellBadge(well({ metadata: { injectionCount: 1 } }), true)).toBeNull()
   })

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

@@ -4,9 +4,9 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import WellPlate from '../../components/WellPlate.vue'
 import type { Well } from '../../types'
 
-// `showSampleTypeIndicator` is deprecated (3a): shape encodes the type, only
-// QC `Q` and iQC `i` carry glyphs. The warning fires once per module, so the
-// order of the first two tests matters.
+// `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>> = {
@@ -48,11 +48,11 @@ describe('WellPlate showSampleTypeIndicator (deprecated)', () => {
     expect(firstWellText('blank')).toBe('')
   })
 
-  it('should keep the QC marker glyph when showSampleTypeIndicator is on', () => {
-    expect(firstWellText('qc')).toBe('Q')
+  it('should render no letter for a QC well when showSampleTypeIndicator is on', () => {
+    expect(firstWellText('qc')).toBe('')
   })
 
-  it('should keep the iQC marker glyph when showSampleTypeIndicator is on', () => {
-    expect(firstWellText('iqc')).toBe('i')
+  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')
@@ -162,3 +162,94 @@ 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/usePickerNavigation.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, expect, it, vi } from 'vitest'
 import { effectScope, type EffectScope } from 'vue'
 import { usePickerNavigation } from '../../composables/filePicker/usePickerNavigation'
-import type { PickerAdapter, PickerNode } from '../../types/filePicker'
+import type { PickerAdapter, PickerNode, PickerSort } from '../../types/filePicker'
 
 const scopes: EffectScope[] = []
 afterEach(() => {
@@ -147,3 +147,63 @@ it('restarts prefetch after reopening even if old requests ignore cancellation',
   finish[4]!()
   await vi.advanceTimersByTimeAsync(100)
 })
+
+const dated = (kind: 'folder' | 'file', name: string, modifiedAt?: string): PickerNode =>
+  kind === 'folder'
+    ? { kind, path: name, name, modifiedAt }
+    : { kind, path: name, name, modifiedAt, format: 'raw' }
+const mixed = () => [
+  dated('file', 'b.raw', '2026-09-01T00:00:00Z'),
+  dated('folder', 'old', '2026-01-01T00:00:00Z'),
+  dated('file', 'a.raw', '2026-09-29T00:00:00Z'),
+  dated('folder', 'new', '2026-09-28T00:00:00Z'),
+  dated('file', 'undated.raw'),
+]
+async function sortedNames(sort: PickerSort | undefined) {
+  vi.useFakeTimers()
+  const adapter: PickerAdapter = {
+    listRoot: vi.fn(async () => mixed()),
+    listChildren: vi.fn(async () => []),
+    search: vi.fn(async () => []),
+  }
+  const scope = effectScope()
+  scopes.push(scope)
+  const nav = scope.run(() => usePickerNavigation(() => adapter, () => ({}), () => true, () => sort))!
+  await nav.load()
+  return nav.rows.value.map((row) => row.node.name)
+}
+
+it('should list folders first, newest first, when sorted by newest', async () => {
+  expect(await sortedNames('newest')).toEqual(['new', 'old', 'a.raw', 'b.raw', 'undated.raw'])
+})
+
+it('should list folders first, oldest first, when sorted by oldest', async () => {
+  expect(await sortedNames('oldest')).toEqual(['old', 'new', 'b.raw', 'a.raw', 'undated.raw'])
+})
+
+it('should list folders first by name when sorted by name', async () => {
+  expect(await sortedNames('name')).toEqual(['new', 'old', 'a.raw', 'b.raw', 'undated.raw'])
+})
+
+it('should list folders first by reverse name when sorted by name-desc', async () => {
+  expect(await sortedNames('name-desc')).toEqual(['old', 'new', 'undated.raw', 'b.raw', 'a.raw'])
+})
+
+it('should keep the adapter order when no sort is given', async () => {
+  expect(await sortedNames(undefined)).toEqual(['b.raw', 'old', 'a.raw', 'new', 'undated.raw'])
+})
+
+it('should show partial results and flag them when the adapter search is truncated', async () => {
+  const { nav, adapter } = setup([folder('a')])
+  vi.mocked(adapter.search).mockResolvedValueOnce({ nodes: [folder('a')], truncated: true })
+  await nav.load('a', true)
+  expect([nav.entries.value.length, nav.truncated.value]).toEqual([1, true])
+})
+
+it('should clear the truncated flag on the next plain listing', async () => {
+  const { nav, adapter } = setup([folder('a')])
+  vi.mocked(adapter.search).mockResolvedValueOnce({ nodes: [], truncated: true })
+  await nav.load('a', true)
+  await nav.load()
+  expect(nav.truncated.value).toBe(false)
+})

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

@@ -26,7 +26,10 @@ it('passes cancellation, marks offline mounts, and maps compound extensions', as
       ],
     })
     .mockResolvedValueOnce({
-      entries: [{ kind: 'file', path: 'run.mzML.gz', name: 'run.mzML.gz', size_bytes: 7 }],
+      listings: [{
+        mount_id: 'online', path: '',
+        entries: [{ kind: 'file', path: 'run.mzML.gz', name: 'run.mzML.gz', size_bytes: 7 }],
+      }],
     })
   const adapter = usePlatformFilePickerAdapter({ apiBaseUrl: '/api' })
   const signal = new AbortController().signal
@@ -42,7 +45,7 @@ it('passes cancellation, marks offline mounts, and maps compound extensions', as
   expect(get.mock.calls.every((call) => call[1].signal === signal)).toBe(true)
 })
 it('refuses truncated listings rather than returning a partial folder selection', async () => {
-  get.mockResolvedValue({ truncated: true, entries: [] })
+  get.mockResolvedValue({ listings: [{ mount_id: 'a', path: '', truncated: true, entries: [] }] })
   await expect(
     usePlatformFilePickerAdapter({ apiBaseUrl: '/api' }).listChildren(
       encodePlatformPickerPath('a'),
@@ -58,22 +61,22 @@ it('scopes shallow search to one level and recursive search skips offline mounts
             { id: 'b', label: 'NAS', available: false },
           ],
         }
-      : { entries: [{ kind: 'file', path: 'run.raw', name: 'run.raw', size_bytes: 1 }] },
+      : { listings: [{ mount_id: 'a', path: '', entries: [{ kind: 'file', path: 'run.raw', name: 'run.raw', size_bytes: 1 }] }] },
   )
   const adapter = usePlatformFilePickerAdapter({ apiBaseUrl: '/api' })
   expect(await adapter.search('run', { path: '', recursive: false })).toEqual([])
   expect(await adapter.search('run', { path: '', recursive: true })).toHaveLength(1)
-  expect(get.mock.calls.filter((call) => call[0].includes('/browse'))).toHaveLength(1)
+  expect(get.mock.calls.filter((call) => call[0].includes('/tree'))).toHaveLength(1)
 })
 it('forwards explicit refresh to mount browsing and supports a scoped root', async () => {
-  get.mockResolvedValue({ entries: [] })
+  get.mockResolvedValue({ listings: [{ mount_id: 'raw', path: 'study', entries: [] }] })
   const adapter = usePlatformFilePickerAdapter({
     apiBaseUrl: '/api', rootLocation: { mount_id: 'raw', path: 'study' },
   })
   const signal = new AbortController().signal
   await adapter.listRoot({ refresh: true, signal })
   expect(get).toHaveBeenCalledExactlyOnceWith(
-    '/filesystem/browse?mount_id=raw&path=study&refresh=true', { signal },
+    '/filesystem/tree?mount_id=raw&path=study&refresh=true', { signal },
   )
 })
 it('forwards a mount-list refresh so server directory snapshots are invalidated too', async () => {
@@ -83,3 +86,12 @@ it('forwards a mount-list refresh so server directory snapshots are invalidated
   await adapter.listRoot({ refresh: true, signal })
   expect(get).toHaveBeenCalledExactlyOnceWith('/filesystem/mounts?refresh=true', { signal })
 })
+
+it('should search a folder on the server with the query and scope', async () => {
+  get.mockResolvedValue({ entries: [], truncated: false })
+  await usePlatformFilePickerAdapter({ apiBaseUrl: '/api' })
+    .search('run', { path: encodePlatformPickerPath('raw', 'study'), recursive: false })
+  expect(get).toHaveBeenCalledExactlyOnceWith(
+    '/filesystem/search?mount_id=raw&path=study&q=run&recursive=false', { signal: undefined },
+  )
+})

package/src/__tests__/docs/frontendDocsCatalog.test.ts

@@ -60,7 +60,7 @@ function parseComponentExports(): string[] {
   const componentsDir = join(SDK_ROOT, 'src', 'components')
   const content = readFileSync(join(componentsDir, 'index.ts'), 'utf8')
   return [...content.matchAll(
-    /export\s+\{\s*default\s+as\s+(\w+)(?:\s*,\s*[^}]*)?\s*\}\s+from\s+['"]\.\/([\w-]+)\.vue['"]/g,
+    /export\s+\{\s*(?:\/\*\*.*?\*\/\s*)?default\s+as\s+(\w+)(?:\s*,\s*[^}]*)?\s*\}\s+from\s+['"]\.\/([\w-]+)\.vue['"]/g,
   )]
     .filter((match) => existsSync(join(componentsDir, `${match[2]}.vue`)))
     .map(match => match[1])
@@ -121,7 +121,7 @@ function parseDeprecatedComponentExports(): Record<string, string> {
     }
 
     const exportMatch = line.match(
-      /export\s+\{\s*default\s+as\s+(\w+)(?:\s*,\s*[^}]*)?\s*\}\s+from\s+['"]\.\/([\w-]+)\.vue['"]/,
+      /export\s+\{\s*(?:\/\*\*.*?\*\/\s*)?default\s+as\s+(\w+)(?:\s*,\s*[^}]*)?\s*\}\s+from\s+['"]\.\/([\w-]+)\.vue['"]/,
     )
     if (!exportMatch) continue
 

package/src/__tests__/styles/controlRefreshRules.test.ts

@@ -184,12 +184,6 @@ describe('SDK control refresh style rules', () => {
     expect(rule).toMatch(/flex-wrap:\s*wrap/)
   })
 
-  it('should keep the badge text off white when scanning well-plate.css (7a)', () => {
-    const css = stripComments(readFileSync(component('well-plate.css'), 'utf-8'))
-    const rule = /\.mint-well-plate__badge\s*\{([^}]*)\}/.exec(css)?.[1] ?? ''
-    expect(rule).toMatch(/color:\s*var\(--bg-card\)/)
-  })
-
   it('should pad resource picker rows so two text lines fit the 44px row when scanning resource-picker-list.css (8b)', () => {
     // 16.25px title + 1px gap + 15px meta + 10px padding + 1px border = 43.25px, under min-height.
     const css = stripComments(readFileSync(component('resource-picker-list.css'), 'utf-8'))