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

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

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest'
+import { computed, ref } from 'vue'
+import {
+  compareSortValues,
+  useSortedItems,
+  type SortDescriptor,
+} from '../../composables/useSortedItems'
+
+describe('useSortedItems', () => {
+  const items = [
+    { name: 'Lactate', score: 2, supplier: 'Cayman' },
+    { name: 'Glucose', score: undefined, supplier: 'Sigma' },
+    { name: 'Pyruvate', score: 5, supplier: 'Thermo' },
+  ]
+
+  it('sorts by a reactive descriptor and keeps empty values last', () => {
+    const sort = ref<SortDescriptor<'score'>>({ key: 'score', direction: 'asc' })
+    const sorted = useSortedItems({
+      items,
+      sort,
+      getValue: (item, key) => item[key],
+    })
+
+    expect(sorted.sortedItems.value.map(item => item.name)).toEqual([
+      'Lactate',
+      'Pyruvate',
+      'Glucose',
+    ])
+
+    sort.value = { key: 'score', direction: 'desc' }
+    expect(sorted.sortedItems.value.map(item => item.name)).toEqual([
+      'Pyruvate',
+      'Lactate',
+      'Glucose',
+    ])
+  })
+
+  it('returns all items in original order when disabled', () => {
+    const enabled = ref(false)
+    const sorted = useSortedItems({
+      items: computed(() => items),
+      sort: { key: 'name', direction: 'asc' },
+      enabled,
+      getValue: item => item.name,
+    })
+
+    expect(sorted.sortedItems.value.map(item => item.name)).toEqual([
+      'Lactate',
+      'Glucose',
+      'Pyruvate',
+    ])
+
+    enabled.value = true
+    expect(sorted.sortedItems.value.map(item => item.name)).toEqual([
+      'Glucose',
+      'Lactate',
+      'Pyruvate',
+    ])
+  })
+
+  it('supports case-insensitive string comparison', () => {
+    const sorted = useSortedItems({
+      items: [
+        { name: 'beta' },
+        { name: 'Alpha' },
+        { name: 'gamma' },
+      ],
+      sort: { key: 'name', direction: 'asc' },
+      caseSensitive: false,
+      getValue: item => item.name,
+    })
+
+    expect(sorted.sortedItems.value.map(item => item.name)).toEqual([
+      'Alpha',
+      'beta',
+      'gamma',
+    ])
+  })
+
+  it('compares dates, numbers, strings, and empty values consistently', () => {
+    expect(compareSortValues(1, 2, 'asc')).toBeLessThan(0)
+    expect(compareSortValues(1, 2, 'desc')).toBeGreaterThan(0)
+    expect(compareSortValues(new Date('2026-01-01'), new Date('2026-02-01'))).toBeLessThan(0)
+    expect(compareSortValues(undefined, 2, 'asc')).toBeGreaterThan(0)
+    expect(compareSortValues(undefined, 2, 'desc')).toBeGreaterThan(0)
+  })
+})

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

@@ -0,0 +1,147 @@
+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 { useTemplateCollection } from '../../composables/useTemplateCollection'
+import {
+  createPlateMapTemplate,
+  createSampleSheetTemplate,
+  createTemplateCollection,
+  createWellPlateScreenCollection,
+} from '../../templates'
+import type { PlateMapTemplate, SampleSheetTemplate } from '../../templates'
+
+function setup(options?: Parameters<typeof useTemplateCollection>[0]) {
+  return useTemplateCollection(options)
+}
+
+describe('useTemplateCollection', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockGet.mockResolvedValue({})
+    mockPut.mockResolvedValue({})
+    mockDelete.mockResolvedValue({})
+    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
+    window.history.replaceState({}, '', '/')
+  })
+
+  it('initializes from a template collection envelope', () => {
+    const plate = createPlateMapTemplate({ samples: ['Control', 'Treatment'] })
+    const { templateIds, templates, metadata, hasTemplates, getTemplate, requireTemplate } = setup({
+      initial: createTemplateCollection([plate], { preset: 'unit-test' }),
+    })
+
+    expect(templateIds.value).toEqual(['plate-map'])
+    expect(Object.keys(templates.value)).toEqual(['plate-map'])
+    expect(metadata.value).toEqual({ preset: 'unit-test' })
+    expect(hasTemplates.value).toBe(true)
+    expect(getTemplate<PlateMapTemplate>('plate-map')?.data.samples[1].id).toBe('treatment')
+    expect(requireTemplate<PlateMapTemplate>('plate-map').template_id).toBe('plate-map')
+  })
+
+  it('applies, sets, removes, and resets local templates', () => {
+    const plate = createPlateMapTemplate({ samples: ['Control'] })
+    const sampleSheet = createSampleSheetTemplate({
+      samples: [{ sampleId: 'S001', name: 'Sample 1' }],
+    })
+    const { apply, setTemplate, removeTemplate, reset, templateIds, metadata } = setup({
+      initial: [plate],
+    })
+
+    setTemplate(sampleSheet)
+    expect(templateIds.value).toEqual(['plate-map', 'sample-sheet'])
+
+    expect(removeTemplate('plate-map')).toBe(true)
+    expect(templateIds.value).toEqual(['sample-sheet'])
+    expect(removeTemplate('missing')).toBe(false)
+
+    apply(createTemplateCollection([sampleSheet], { source: 'loaded' }))
+    expect(metadata.value).toEqual({ source: 'loaded' })
+
+    reset()
+    expect(templateIds.value).toEqual(['plate-map'])
+  })
+
+  it('uses fallback metadata only when the payload has none', () => {
+    const plate = createPlateMapTemplate({ samples: ['Control'] })
+    const { apply, metadata } = setup()
+
+    apply(createTemplateCollection([plate], { source: 'payload' }), { source: 'fallback' })
+    expect(metadata.value).toEqual({ source: 'payload' })
+
+    apply([plate], { source: 'fallback' })
+    expect(metadata.value).toEqual({ source: 'fallback' })
+  })
+
+  it('saves the local collection through experiment design_data', async () => {
+    const collection = createWellPlateScreenCollection({
+      samples: ['Control', 'Treatment'],
+      compounds: { Drug: [10, 1] },
+    })
+    const { save, lastSavedAt } = setup({ pluginId: 'p1', initial: collection })
+
+    const ok = await save(42)
+
+    expect(ok).toBe(true)
+    expect(lastSavedAt.value).toBeInstanceOf(Date)
+    expect(mockPut).toHaveBeenCalledWith('/experiments/42/data', {
+      plugin_id: 'p1',
+      data: collection,
+      schema_version: '1.0',
+    })
+  })
+
+  it('loads design_data into the local collection', async () => {
+    const sampleSheet = createSampleSheetTemplate({
+      samples: [
+        { sampleId: 'S001', name: 'Sample 1' },
+        { sampleId: 'S002', name: 'Sample 2' },
+      ],
+    })
+    mockGet.mockResolvedValueOnce(createTemplateCollection([sampleSheet], { source: 'api' }))
+    const { load, templateIds, metadata, requireTemplate, lastLoadedAt } = setup()
+
+    const loaded = await load(7)
+
+    expect(mockGet).toHaveBeenCalledWith('/experiments/7/data')
+    expect(loaded?.metadata).toEqual({ source: 'api' })
+    expect(templateIds.value).toEqual(['sample-sheet'])
+    expect(requireTemplate<SampleSheetTemplate>('sample-sheet').data.samples[1].sampleId).toBe(
+      'S002',
+    )
+    expect(metadata.value).toEqual({ source: 'api' })
+    expect(lastLoadedAt.value).toBeInstanceOf(Date)
+  })
+
+  it('saves the current URL experiment without route plumbing', async () => {
+    window.history.replaceState({}, '', '/plugins/template?experimentId=88')
+    const plate = createPlateMapTemplate({ samples: ['Control'] })
+    const { currentExperimentId, hasCurrentExperiment, saveCurrent } = setup({
+      pluginId: 'p1',
+      initial: [plate],
+    })
+
+    expect(currentExperimentId.value).toBe(88)
+    expect(hasCurrentExperiment.value).toBe(true)
+
+    const ok = await saveCurrent()
+
+    expect(ok).toBe(true)
+    expect(mockPut).toHaveBeenCalledWith('/experiments/88/data', {
+      plugin_id: 'p1',
+      data: createTemplateCollection([plate]),
+      schema_version: '1.0',
+    })
+  })
+})

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

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest'
+import { computed, ref } from 'vue'
+import {
+  candidateMatchesSearch,
+  normalizeSearchQuery,
+  useTextSearch,
+} from '../../composables/useTextSearch'
+
+describe('useTextSearch', () => {
+  const items = [
+    { name: 'Glucose', catalogNumber: 'G-7528', supplier: 'Sigma' },
+    { name: 'Lactate', catalogNumber: 'L-1250', supplier: 'Cayman' },
+    { name: 'Pyruvate', catalogNumber: 'P-2256', supplier: 'Thermo' },
+  ]
+
+  it('normalizes whitespace and case', () => {
+    expect(normalizeSearchQuery('  GLU  ')).toBe('glu')
+    expect(normalizeSearchQuery(undefined)).toBe('')
+  })
+
+  it('filters by multiple candidate values', () => {
+    const query = ref('cay')
+    const search = useTextSearch({
+      items,
+      query,
+      getText: item => [item.name, item.catalogNumber, item.supplier],
+    })
+
+    expect(search.filteredItems.value.map(item => item.name)).toEqual(['Lactate'])
+
+    query.value = ' p-2256 '
+    expect(search.filteredItems.value.map(item => item.name)).toEqual(['Pyruvate'])
+  })
+
+  it('returns all items when disabled', () => {
+    const enabled = ref(false)
+    const search = useTextSearch({
+      items: computed(() => items),
+      query: 'sigma',
+      enabled,
+      getText: item => item.supplier,
+    })
+
+    expect(search.filteredItems.value).toHaveLength(3)
+
+    enabled.value = true
+    expect(search.filteredItems.value.map(item => item.name)).toEqual(['Glucose'])
+  })
+
+  it('matches empty queries and ignores nullish candidates', () => {
+    expect(candidateMatchesSearch([null, undefined, 'Alpha'], '')).toBe(true)
+    expect(candidateMatchesSearch([null, undefined, 'Alpha'], 'alp')).toBe(true)
+    expect(candidateMatchesSearch([null, undefined], 'alp')).toBe(false)
+  })
+})

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

@@ -0,0 +1,91 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { nextTick } from 'vue'
+import { createPinia, setActivePinia } from 'pinia'
+import { useTheme } from '../../composables/useTheme'
+import { useSettingsStore } from '../../stores/settings'
+
+function mockMatchMedia(initialMatches = false) {
+  let matches = initialMatches
+  let changeListener: ((event: MediaQueryListEvent) => void) | undefined
+
+  const mediaQuery = {
+    get matches() {
+      return matches
+    },
+    media: '(prefers-color-scheme: dark)',
+    onchange: null,
+    addEventListener: vi.fn((_event: 'change', listener: (event: MediaQueryListEvent) => void) => {
+      changeListener = listener
+    }),
+    removeEventListener: vi.fn(),
+    addListener: vi.fn(),
+    removeListener: vi.fn(),
+    dispatchEvent: vi.fn(),
+  } as unknown as MediaQueryList
+
+  Object.defineProperty(window, 'matchMedia', {
+    configurable: true,
+    writable: true,
+    value: vi.fn(() => mediaQuery),
+  })
+
+  return {
+    mediaQuery,
+    setMatches(value: boolean) {
+      matches = value
+      changeListener?.({ matches: value } as MediaQueryListEvent)
+    },
+  }
+}
+
+describe('useTheme', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    vi.restoreAllMocks()
+    const storage: Record<string, string> = {}
+    vi.stubGlobal('localStorage', {
+      getItem: vi.fn((key: string) => storage[key] ?? null),
+      setItem: vi.fn((key: string, value: string) => { storage[key] = value }),
+      removeItem: vi.fn((key: string) => { delete storage[key] }),
+      clear: vi.fn(() => {
+        for (const key of Object.keys(storage)) delete storage[key]
+      }),
+    })
+    document.documentElement.classList.remove('dark')
+  })
+
+  it('reads system color scheme from the settings store reactively', async () => {
+    const system = mockMatchMedia(true)
+    const settings = useSettingsStore()
+    const { isDark } = useTheme()
+
+    expect(settings.theme).toBe('system')
+    expect(settings.systemPrefersDark).toBe(true)
+    expect(isDark.value).toBe(true)
+    expect(document.documentElement.classList.contains('dark')).toBe(true)
+
+    system.setMatches(false)
+    await nextTick()
+
+    expect(settings.systemPrefersDark).toBe(false)
+    expect(isDark.value).toBe(false)
+    expect(document.documentElement.classList.contains('dark')).toBe(false)
+  })
+
+  it('keeps explicit light and dark choices independent from system changes', async () => {
+    const system = mockMatchMedia(true)
+    const { isDark, setTheme } = useTheme()
+
+    setTheme('light')
+    await nextTick()
+    expect(isDark.value).toBe(false)
+
+    system.setMatches(false)
+    await nextTick()
+    expect(isDark.value).toBe(false)
+
+    setTheme('dark')
+    await nextTick()
+    expect(isDark.value).toBe(true)
+  })
+})

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

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest'
+import {
+  findNearestTimeSlotIndex,
+  formatTimeSlot,
+  fromMinutes,
+  generateTimeSlots,
+  toMinutes,
+  useTimeUtils,
+} from '../../composables/useTimeUtils'
+
+describe('useTimeUtils', () => {
+  it('formats HH:MM slots for shared picker display', () => {
+    expect(formatTimeSlot('00:00')).toBe('00:00')
+    expect(formatTimeSlot('14:30', '12h')).toBe('2:30 PM')
+  })
+
+  it('converts between HH:MM strings and minute offsets', () => {
+    expect(toMinutes('09:45')).toBe(585)
+    expect(fromMinutes(585)).toBe('09:45')
+  })
+
+  it('finds the nearest slot index for scroll and highlight behavior', () => {
+    const slots = generateTimeSlots('09:00', '10:00', 15)
+
+    expect(findNearestTimeSlotIndex('09:37', slots)).toBe(2)
+    expect(findNearestTimeSlotIndex('08:00', [])).toBe(-1)
+  })
+
+  it('exposes the shared slot helpers from the composable facade', () => {
+    const utils = useTimeUtils()
+
+    expect(utils.formatTimeSlot('23:15', '12h')).toBe('11:15 PM')
+    expect(utils.findNearestTimeSlotIndex('10:20', ['10:00', '10:30'])).toBe(1)
+  })
+})

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

@@ -0,0 +1,229 @@
+import { execFileSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+
+interface FrontendManifest {
+  categories: {
+    components: Array<{
+      name: string
+      deprecated?: boolean
+      replacement?: string
+    }>
+    composables: Array<{
+      name: string
+      members?: Array<{ name: string }>
+    }>
+    templateExports: Array<{ name: string }>
+    templatePacks: Array<{ name: string }>
+  }
+}
+
+const TEST_DIR = dirname(fileURLToPath(import.meta.url))
+const SDK_ROOT = resolve(TEST_DIR, '../../..')
+
+function extractFrontendManifest(): FrontendManifest {
+  const output = execFileSync('bun', ['run', 'scripts/extract-docs.ts'], {
+    cwd: SDK_ROOT,
+    encoding: 'utf8',
+  })
+  return JSON.parse(output) as FrontendManifest
+}
+
+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,
+  )]
+    .filter((match) => existsSync(join(componentsDir, `${match[2]}.vue`)))
+    .map(match => match[1])
+    .sort()
+}
+
+function parseDeprecatedComponentExports(): Record<string, string> {
+  const componentsDir = join(SDK_ROOT, 'src', 'components')
+  const content = readFileSync(join(componentsDir, 'index.ts'), 'utf8')
+  const deprecated = new Map<string, string>()
+  let pendingJsdoc = ''
+  let jsdocLines: string[] = []
+  let inJsdoc = false
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim()
+
+    if (inJsdoc) {
+      jsdocLines.push(line)
+      if (trimmed.includes('*/')) {
+        pendingJsdoc = jsdocLines.join('\n')
+        jsdocLines = []
+        inJsdoc = false
+      }
+      continue
+    }
+
+    if (trimmed.startsWith('/**')) {
+      jsdocLines = [line]
+      if (trimmed.includes('*/')) {
+        pendingJsdoc = jsdocLines.join('\n')
+        jsdocLines = []
+      } else {
+        inJsdoc = true
+      }
+      continue
+    }
+
+    const exportMatch = line.match(
+      /export\s+\{\s*default\s+as\s+(\w+)(?:\s*,\s*[^}]*)?\s*\}\s+from\s+['"]\.\/([\w-]+)\.vue['"]/,
+    )
+    if (!exportMatch) continue
+
+    if (/@deprecated\b/i.test(pendingJsdoc)) {
+      const replacement = pendingJsdoc.match(
+        /@deprecated[\s\S]*?\b(?:use|prefer)\s+`?([A-Za-z_][A-Za-z0-9_]*)\(?\)?`?\s+instead/i,
+      )?.[1] ?? ''
+      deprecated.set(exportMatch[1], replacement)
+    }
+    pendingJsdoc = ''
+  }
+
+  return Object.fromEntries([...deprecated.entries()].sort(([a], [b]) => a.localeCompare(b)))
+}
+
+function parseDocumentedComposableExports(): string[] {
+  const scriptContent = readFileSync(join(SDK_ROOT, 'scripts', 'extract-docs.ts'), 'utf8')
+  const helperNames = new Set(
+    [...(scriptContent.match(
+      /const DOCUMENTED_COMPOSABLE_EXPORTS = new Set\(\[([\s\S]*?)\]\);/,
+    )?.[1] ?? '').matchAll(/"(\w+)"/g)].map(match => match[1]),
+  )
+  const indexContent = readFileSync(join(SDK_ROOT, 'src', 'composables', 'index.ts'), 'utf8')
+  const names: string[] = []
+
+  for (const match of indexContent.matchAll(/export\s+\{([\s\S]*?)\}\s+from\s+['"]\.\/[\w-]+['"]/g)) {
+    for (const item of match[1].split(',')) {
+      const spec = item.trim()
+      if (!spec || spec.startsWith('type ')) continue
+      const name = spec.split(/\s+as\s+/, 1)[0].trim()
+      if (name.startsWith('use') || helperNames.has(name)) {
+        names.push(name)
+      }
+    }
+  }
+
+  return [...new Set(names)].sort()
+}
+
+function parseTemplateExports(): string[] {
+  const indexContent = readFileSync(join(SDK_ROOT, 'src', 'templates', 'index.ts'), 'utf8')
+  const names = new Set<string>()
+
+  for (const match of indexContent.matchAll(/export\s+(?:type\s+)?\{(?<body>[\s\S]*?)\}\s+from\s+['"][^'"]+['"]/g)) {
+    const body = match.groups?.body ?? ''
+    for (const item of body.split(',')) {
+      const spec = item.trim()
+      if (!spec) continue
+      const normalized = spec.startsWith('type ') ? spec.slice(5).trim() : spec
+      const name = normalized.split(/\s+as\s+/, 1)[0].trim()
+      if (/^[A-Za-z]\w*$/.test(name)) names.add(name)
+    }
+  }
+
+  return [...names].sort()
+}
+
+function missingFromManifest(expected: string[], actual: string[]): string[] {
+  const actualNames = new Set(actual)
+  return expected.filter(name => !actualNames.has(name))
+}
+
+describe('frontend docs catalog coverage', () => {
+  it('documents every public component export', () => {
+    const manifest = extractFrontendManifest()
+    const publicComponents = parseComponentExports()
+    const documentedComponents = manifest.categories.components.map(item => item.name).sort()
+
+    expect(missingFromManifest(publicComponents, documentedComponents)).toEqual([])
+    expect(missingFromManifest(documentedComponents, publicComponents)).toEqual([])
+  })
+
+  it('marks every deprecated public component export with its replacement', () => {
+    const manifest = extractFrontendManifest()
+    const expected = parseDeprecatedComponentExports()
+    const documented = Object.fromEntries(
+      manifest.categories.components
+        .filter(item => item.deprecated === true)
+        .map(item => [item.name, item.replacement ?? ''])
+        .sort(([a], [b]) => a.localeCompare(b)),
+    )
+
+    expect(documented).toEqual(expected)
+  })
+
+  it('keeps compatibility exports deprecated at public SDK entrypoints', () => {
+    const rootIndex = readFileSync(join(SDK_ROOT, 'src', 'index.ts'), 'utf8')
+    const composablesIndex = readFileSync(join(SDK_ROOT, 'src', 'composables', 'index.ts'), 'utf8')
+
+    expect(rootIndex).toContain(
+      "/** @deprecated Use AppToastContainer instead. */\nexport { ToastNotification } from './components'",
+    )
+    expect(rootIndex).toContain(
+      "/** @deprecated Use AppTopBar settingsConfig or SettingsModal instead. */\nexport { SettingsButton } from './components'",
+    )
+    expect(rootIndex).toContain(
+      "/** @deprecated Use AutoGroupModal instead. */\nexport { GroupingModal } from './components'",
+    )
+    expect(rootIndex).toContain(
+      "/** @deprecated Use generated plugin clients from `mint sdk generate` instead. */\nexport {\n  usePluginApi,\n  type UsePluginApiOptions,\n} from './composables'",
+    )
+    expect(composablesIndex).toContain(
+      "/** @deprecated Use generated plugin clients from `mint sdk generate` instead. */\nexport {\n  usePluginApi,\n  type UsePluginApiOptions,\n} from './usePluginApi'",
+    )
+  })
+
+  it('keeps deprecated usePluginApi docs focused on migration', () => {
+    const content = readFileSync(join(SDK_ROOT, 'src', 'composables', 'usePluginApi.ts'), 'utf8')
+
+    expect(content).toContain('Migration shape for generated plugins')
+    expect(content).toContain('useGeneratedPluginClient')
+    expect(content).not.toContain('const api = usePluginApi')
+    expect(content).not.toContain("fallbackPrefix: '/api/drp'")
+  })
+
+  it('documents every public composable/helper export used by docs and doctor', () => {
+    const manifest = extractFrontendManifest()
+    const publicComposables = parseDocumentedComposableExports()
+    const documentedComposables = manifest.categories.composables.map(item => item.name).sort()
+
+    expect(missingFromManifest(publicComposables, documentedComposables)).toEqual([])
+    expect(missingFromManifest(documentedComposables, publicComposables)).toEqual([])
+  })
+
+  it('documents curated biology template packs', () => {
+    const manifest = extractFrontendManifest()
+
+    expect(manifest.categories.templatePacks.map(item => item.name)).toEqual([
+      'cell-culture-screen',
+      'omics-assay',
+      'longitudinal-study',
+      'molecular-assay',
+    ])
+  })
+
+  it('documents every public template subpath export used by doctor', () => {
+    const manifest = extractFrontendManifest()
+    const publicTemplateExports = parseTemplateExports()
+    const documentedTemplateExports = manifest.categories.templateExports.map(item => item.name).sort()
+
+    expect(missingFromManifest(publicTemplateExports, documentedTemplateExports)).toEqual([])
+    expect(missingFromManifest(documentedTemplateExports, publicTemplateExports)).toEqual([])
+  })
+
+  it('extracts return members from external type files', () => {
+    const manifest = extractFrontendManifest()
+    const useFormBuilder = manifest.categories.composables.find(item => item.name === 'useFormBuilder')
+
+    expect(useFormBuilder?.members?.map(member => member.name)).toContain('updateSchema')
+  })
+})