@morscherlab/mint-sdk 1.0.0-beta.7 → 1.0.0-rc.2

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

@@ -70,6 +70,29 @@ describe('useExperimentData', () => {
     expect(hook2.treeData.value).toEqual([{ id: '2' }])
   })
 
+  it('unwraps platform design-data responses and exposes sample helpers', async () => {
+    const response = {
+      experiment_id: 42,
+      plugin_id: 'ms-designer',
+      schema_version: '1.0',
+      data: {
+        tree_data: [{ id: 'design' }],
+        samples: [
+          { sample_name: 'S1', sample_type: 'sample', conditions: { group: 'A' } },
+          { sample_name: 'Blank', sample_type: 'blank', conditions: { group: 'QC' } },
+        ],
+      },
+    }
+    fakeResponse = response
+    const hook = useExperimentData()
+    await hook.fetch(42)
+
+    expect(hook.designData.value).toEqual(response.data)
+    expect(hook.treeData.value).toEqual([{ id: 'design' }])
+    expect(hook.sampleNames.value).toEqual(['S1'])
+    expect(hook.sampleOptions.value).toEqual([{ value: 'S1', label: 'S1' }])
+  })
+
   it('tableData falls back to empty array when absent', async () => {
     fakeResponse = {}
     const hook = useExperimentData()

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

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import axios, { type AxiosRequestConfig } from 'axios'
+
+import { useExperimentSamples } from '../../composables/useExperimentSamples'
+
+let fakeResponse: unknown = null
+let fakeError: Error | null = null
+let recordedUrls: string[] = []
+
+describe('useExperimentSamples', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    fakeResponse = {}
+    fakeError = null
+    recordedUrls = []
+    vi.spyOn(axios.Axios.prototype, 'get').mockImplementation(async function (
+      this: unknown,
+      url: string,
+      _config?: AxiosRequestConfig,
+    ) {
+      recordedUrls.push(url)
+      if (fakeError) throw fakeError
+      return { data: fakeResponse }
+    })
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('derives samples from pre-fetched MS Designer design_data', () => {
+    const hook = useExperimentSamples({
+      syncAppExperiment: false,
+      designData: {
+        samples: [
+          { sample_name: 'S1', sample_type: 'sample', conditions: { group: 'A' } },
+          { sample_name: 'QC1', sample_type: 'qc', conditions: { group: 'QC' } },
+        ],
+      },
+    })
+
+    expect(hook.samples.value).toEqual(['S1'])
+    expect(hook.sampleOptions.value).toEqual([{ value: 'S1', label: 'S1' }])
+    expect(recordedUrls).toEqual([])
+  })
+
+  it('loads and unwraps platform design_data for an experiment id', async () => {
+    fakeResponse = {
+      experiment_id: 7,
+      plugin_id: 'ms-designer',
+      data: {
+        samples: [
+          { sample_name: 'S1', sample_type: 'sample' },
+          { sample_name: 'S2', sample_type: 'sample' },
+        ],
+      },
+      schema_version: '1.0',
+    }
+    const hook = useExperimentSamples({ syncAppExperiment: false, immediate: false })
+
+    await hook.fetch(7)
+
+    expect(recordedUrls).toEqual(['/experiments/7/data'])
+    expect(hook.samples.value).toEqual(['S1', 'S2'])
+  })
+
+  it('extracts options from template collection sample sheets', () => {
+    const hook = useExperimentSamples({
+      syncAppExperiment: false,
+      designData: {
+        templates: {
+          'sample-sheet': {
+            data: {
+              samples: [
+                { sampleId: 'ctrl', name: 'Control', group: 'baseline' },
+                { sampleId: 'drug', name: 'Drug', group: 'treated' },
+              ],
+            },
+          },
+        },
+      },
+    })
+
+    expect(hook.samples.value).toEqual(['ctrl', 'drug'])
+    expect(hook.sampleOptions.value).toEqual([
+      { value: 'ctrl', label: 'Control', description: 'baseline' },
+      { value: 'drug', label: 'Drug', description: 'treated' },
+    ])
+  })
+})

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

@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { useProtocolTemplates } from '../../composables/useProtocolTemplates'
+
+const STORAGE_KEY = 'mint-custom-protocol-templates'
+
+function installLocalStorage() {
+  const storage: Record<string, string> = {}
+  vi.stubGlobal('localStorage', {
+    get length() {
+      return Object.keys(storage).length
+    },
+    key: vi.fn((index: number) => Object.keys(storage)[index] ?? null),
+    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]
+    }),
+  } as unknown as Storage)
+}
+
+describe('useProtocolTemplates', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+    vi.unstubAllGlobals()
+    installLocalStorage()
+  })
+
+  it('ignores corrupted custom template storage', () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify({ invalid: true }))
+
+    const templates = useProtocolTemplates()
+
+    expect(templates.customTemplates.value).toEqual([])
+    expect(templates.allTemplates.value.length).toBeGreaterThan(0)
+  })
+
+  it('filters invalid custom template entries', () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify([
+      { id: 'bad', name: 'Missing parameters', type: 'custom' },
+      {
+        id: 'custom-valid',
+        name: 'Valid custom step',
+        type: 'custom',
+        parameters: [],
+      },
+    ]))
+
+    const templates = useProtocolTemplates()
+
+    expect(templates.customTemplates.value).toEqual([
+      {
+        id: 'custom-valid',
+        name: 'Valid custom step',
+        type: 'custom',
+        parameters: [],
+      },
+    ])
+  })
+})

package/src/__tests__/stores/settings.test.ts

@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import { useSettingsStore } from '../../stores/settings'
+
+function mockMatchMedia(matches = false) {
+  Object.defineProperty(window, 'matchMedia', {
+    configurable: true,
+    writable: true,
+    value: vi.fn(() => ({
+      matches,
+      media: '(prefers-color-scheme: dark)',
+      onchange: null,
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      addListener: vi.fn(),
+      removeListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+    })),
+  })
+}
+
+function installLocalStorage() {
+  const storage: Record<string, string> = {}
+  vi.stubGlobal('localStorage', {
+    get length() {
+      return Object.keys(storage).length
+    },
+    key: vi.fn((index: number) => Object.keys(storage)[index] ?? null),
+    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]
+    }),
+  } as unknown as Storage)
+}
+
+describe('useSettingsStore', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+    vi.unstubAllGlobals()
+    setActivePinia(createPinia())
+    installLocalStorage()
+    document.documentElement.classList.remove('dark')
+    mockMatchMedia(false)
+  })
+
+  it('migrates legacy MLD settings into the MINT settings key', () => {
+    localStorage.setItem('mld-settings', JSON.stringify({
+      serverHost: '127.0.0.1',
+      serverPort: 8001,
+      theme: 'dark',
+      colorPalette: 'viridis',
+      tableDensity: 'compact',
+    }))
+
+    const settings = useSettingsStore()
+    settings.initialize()
+
+    expect(settings.serverHost).toBe('127.0.0.1')
+    expect(settings.serverPort).toBe(8001)
+    expect(settings.theme).toBe('dark')
+    expect(settings.colorPalette).toBe('viridis')
+    expect(settings.tableDensity).toBe('compact')
+    expect(localStorage.getItem('mld-settings')).toBeNull()
+    expect(JSON.parse(localStorage.getItem('mint-settings') || '{}')).toEqual(expect.objectContaining({
+      serverHost: '127.0.0.1',
+      serverPort: 8001,
+      theme: 'dark',
+      colorPalette: 'viridis',
+      tableDensity: 'compact',
+    }))
+  })
+})

package/src/__tests__/templates/templates.test.ts

@@ -20,6 +20,7 @@ import {
   createReagentListTemplate,
   createSampleSheetTemplate,
   createSamplePrepTemplate,
+  createTargetedMetabolomicsCollection,
   createDefaultBioTemplate,
   createTemplateCollection,
   createTimeCourseTemplate,
@@ -209,6 +210,7 @@ describe('bio data templates', () => {
       'wellplate-screen',
       'qpcr-expression',
       'lcms-batch',
+      'targeted-metabolomics',
       'elisa-assay',
       'flow-cytometry-assay',
       'western-blot-assay',
@@ -224,6 +226,8 @@ describe('bio data templates', () => {
     expect(getBioTemplatePresetInfo('metabolomics')?.name).toBe('lcms-batch')
     expect(getBioTemplatePresetInfo('metabolism')?.name).toBe('lcms-batch')
     expect(getBioTemplatePresetInfo('metabolite profiling')?.name).toBe('lcms-batch')
+    expect(getBioTemplatePresetInfo('targeted metabolomics')?.name).toBe('targeted-metabolomics')
+    expect(searchBioTemplatePresets('internal standards')[0].name).toBe('targeted-metabolomics')
     expect(getBioTemplatePresetInfo('immunoassay')?.templates).toEqual([
       'plate-map',
       'sample-sheet',
@@ -275,6 +279,7 @@ describe('bio data templates', () => {
     const plateSchema = getBioTemplateControlSchema('wellplate')
     const presetSchema = getBioTemplateControlSchema('wellplate-screen')
     const defaults = getBioTemplateControlDefaults('lcms-batch')
+    const targetedDefaults = getBioTemplateControlDefaults('targeted-metabolomics')
     const elisaDefaults = getBioTemplateControlDefaults('elisa-assay')
     const flowDefaults = getBioTemplateControlDefaults('flow-cytometry-assay')
     const westernDefaults = getBioTemplateControlDefaults('western-blot-assay')
@@ -284,6 +289,9 @@ describe('bio data templates', () => {
     expect(presetSchema?.replicates.default).toBe(3)
     expect(defaults.instrument).toBe('LC-MS')
     expect(defaults.featureNames).toEqual(['Glucose', 'Lactate'])
+    expect(targetedDefaults.metaboliteNames).toEqual(['Glucose', 'Lactate', 'Pyruvate'])
+    expect(targetedDefaults.internalStandards).toEqual(['Stable isotope internal standard mix'])
+    expect(targetedDefaults.method).toBe('Targeted metabolomics')
     expect(elisaDefaults.analyte).toBe('Analyte')
     expect(elisaDefaults.standardConcentrations).toEqual(['1000', '100', '10', '1'])
     expect(flowDefaults.markers).toEqual(['CD3', 'CD4', 'CD8'])
@@ -299,6 +307,7 @@ describe('bio data templates', () => {
     const elisaBindings = getBioTemplateComponentBindings('elisa-assay')
     const flowBindings = getBioTemplateComponentBindings('flow-cytometry-assay')
     const lcmsBindings = getBioTemplateComponentBindings('lcms-batch')
+    const targetedBindings = getBioTemplateComponentBindings('targeted-metabolomics')
     const westernBindings = getBioTemplateComponentBindings('western-blot-assay')
     const wellplateImports = toBioTemplateComponentImports('wellplate-screen')
 
@@ -311,6 +320,9 @@ describe('bio data templates', () => {
     expect(elisaBindings.map(binding => binding.component)).toContain('DataFrame')
     expect(lcmsBindings.map(binding => binding.component)).toContain('ScheduleCalendar')
     expect(lcmsBindings.map(binding => binding.component)).toContain('ExperimentTimeline')
+    expect(targetedBindings.map(binding => binding.component)).toContain('ReagentList')
+    expect(targetedBindings.map(binding => binding.component)).toContain('DataFrame')
+    expect(targetedBindings.map(binding => binding.component)).toContain('ScheduleCalendar')
     expect(flowBindings.map(binding => binding.template_id)).toEqual([
       'sample-sheet',
       'sample-sheet',
@@ -541,6 +553,13 @@ describe('bio data templates', () => {
       features: ['Glucose'],
       instrument: 'LC-MS',
     })
+    const targeted = createTargetedMetabolomicsCollection({
+      samples: ['S001', 'S002'],
+      metabolites: ['Glucose', 'Lactate'],
+      internalStandards: ['13C Glucose'],
+      standardConcentrations: [0.1, 1, 10],
+      instrument: 'Orbitrap',
+    })
     const flow = createFlowCytometryAssayCollection({
       samples: ['Control', 'Treatment'],
       markers: ['CD3', 'CD4'],
@@ -555,6 +574,7 @@ describe('bio data templates', () => {
     const wellplateTemplates = extractTemplateCollection(wellplate)
     const qpcrTemplates = extractTemplateCollection(qpcr)
     const lcmsTemplates = extractTemplateCollection(lcms)
+    const targetedTemplates = extractTemplateCollection(targeted)
     const flowTemplates = extractTemplateCollection(flow)
     const westernTemplates = extractTemplateCollection(western)
     const wellplateComponentProps = toBioTemplateComponentProps(wellplate)
@@ -572,6 +592,28 @@ describe('bio data templates', () => {
     expect(toInstrumentRunRows(lcmsTemplates['instrument-run'] as InstrumentRunTemplate)[2].sampleId).toBe('s001')
     expect(toTemplateDataFrame(lcmsTemplates['assay-matrix']).columns.map(column => column.key)).toContain('glucose')
     expect(toAssayMatrixSampleOptions(lcmsTemplates['assay-matrix'] as AssayMatrixTemplate).map(option => option.label)).toEqual(['S001', 'S002'])
+    expect(Object.keys(targetedTemplates)).toEqual([
+      'sample-sheet',
+      'sample-prep',
+      'reagent-list',
+      'instrument-run',
+      'calibration-curve',
+      'assay-matrix',
+    ])
+    expect(targeted.metadata?.preset).toBe('targeted-metabolomics')
+    expect(toReagentDataFrame(targetedTemplates['reagent-list'] as ReagentListTemplate).data[0].kind).toBe('compound')
+    expect(toTemplateDataFrame(targetedTemplates['calibration-curve']).data[0].role).toBe('blank')
+    expect(toInstrumentRunRows(targetedTemplates['instrument-run'] as InstrumentRunTemplate).map(row => row.kind)).toEqual([
+      'blank',
+      'standard',
+      'standard',
+      'standard',
+      'qc',
+      'qc',
+      'sample',
+      'sample',
+    ])
+    expect(toTemplateDataFrame(targetedTemplates['assay-matrix']).columns.map(column => column.key)).toContain('lactate')
     expect(Object.keys(flowTemplates)).toEqual(['sample-sheet', 'flow-cytometry-panel', 'assay-matrix'])
     expect(flow.metadata?.preset).toBe('flow-cytometry-assay')
     expect(flowTemplates['flow-cytometry-panel'].data).toMatchObject({
@@ -596,6 +638,7 @@ describe('bio data templates', () => {
     expect(Object.keys(extractTemplateCollection(aliasCollection))).toEqual(['plate-map', 'sample-sheet', 'dose-response'])
     expect(createBioTemplatePresetCollection('facs').metadata?.preset).toBe('flow-cytometry-assay')
     expect(createBioTemplatePresetCollection('immunoblot').metadata?.preset).toBe('western-blot-assay')
+    expect(createBioTemplatePresetCollection('targeted metabolomics').metadata?.preset).toBe('targeted-metabolomics')
     expect(() => createBioTemplatePresetCollection('unknown-preset')).toThrow("Unknown template preset 'unknown-preset'.")
   })
 
@@ -682,6 +725,49 @@ describe('bio data templates', () => {
     expect(run.data.items.map(item => item.kind)).toEqual(['blank', 'sample', 'sample'])
     expect(toTemplateDataFrame(lcmsTemplates['assay-matrix']).columns.map(column => column.key)).toContain('pyruvate')
 
+    const targetedOptions = bioTemplatePresetControlValuesToOptions('targeted-metabolomics', {
+      sampleNames: 'QC Pool, Patient A',
+      metaboliteNames: 'Glucose, Citrate',
+      internalStandards: '13C Glucose',
+      standardConcentrations: '0.5, 5, 50',
+      concentrationUnit: 'nM',
+      responseUnit: 'area ratio',
+      instrument: 'Triple quadrupole',
+      method: 'MRM panel',
+      outputVolume: '25',
+      includeQc: false,
+    })
+    const targetedTemplates = extractTemplateCollection(
+      createBioTemplatePresetCollectionFromControls('targeted-metabolomics', {
+        sampleNames: 'QC Pool, Patient A',
+        metaboliteNames: 'Glucose, Citrate',
+        internalStandards: '13C Glucose',
+        standardConcentrations: '0.5, 5, 50',
+        concentrationUnit: 'nM',
+        responseUnit: 'area ratio',
+        instrument: 'Triple quadrupole',
+        method: 'MRM panel',
+        outputVolume: '25',
+        includeQc: false,
+      }),
+    )
+    const targetedRun = targetedTemplates['instrument-run'] as InstrumentRunTemplate
+
+    expect(targetedOptions.metabolites).toEqual(['Glucose', 'Citrate'])
+    expect(targetedOptions.standardConcentrations).toEqual([0.5, 5, 50])
+    expect(targetedOptions.outputVolume).toBe(25)
+    expect(targetedRun.data.instrument).toBe('Triple quadrupole')
+    expect(targetedRun.data.methods[0].name).toBe('MRM panel')
+    expect(targetedRun.data.items.map(item => item.kind)).toEqual([
+      'blank',
+      'standard',
+      'standard',
+      'standard',
+      'sample',
+      'sample',
+    ])
+    expect(toTemplateDataFrame(targetedTemplates['assay-matrix']).columns.map(column => column.key)).toContain('citrate')
+
     const flowOptions = bioTemplatePresetControlValuesToOptions('flow-cytometry-assay', {
       sampleNames: 'Control, Treatment',
       markers: 'CD3, CD19',

package/src/__tests__/utils/instrument.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest'
+import {
+  estimateSequenceFinishDate,
+  estimateSequenceRemainingSeconds,
+  formatSequenceRemaining,
+  sequenceProgressPercent,
+} from '../../instrument'
+import type { SequenceProgress } from '../../types'
+
+describe('instrument sequence helpers', () => {
+  const progress: SequenceProgress = {
+    current_sample: 3,
+    total_samples: 6,
+    elapsed_seconds: 180,
+    sample_durations: [50, 70, 60],
+  }
+
+  it('calculates percent and remaining time from sample durations', () => {
+    expect(sequenceProgressPercent(progress)).toBe(50)
+    expect(estimateSequenceRemainingSeconds(progress)).toBe(180)
+    expect(formatSequenceRemaining(progress)).toBe('~3m left')
+  })
+
+  it('falls back to elapsed average when sample durations are unavailable', () => {
+    expect(estimateSequenceRemainingSeconds({
+      current_sample: 2,
+      total_samples: 5,
+      elapsed_seconds: 120,
+    })).toBe(180)
+  })
+
+  it('uses explicit finish time or builds one from remaining seconds', () => {
+    const now = new Date('2026-05-15T12:00:00.000Z')
+
+    expect(estimateSequenceFinishDate(progress, now)?.toISOString()).toBe('2026-05-15T12:03:00.000Z')
+    expect(estimateSequenceFinishDate({
+      current_sample: 1,
+      total_samples: 2,
+      estimated_finish_time: '2026-05-15T13:00:00.000Z',
+    })?.toISOString()).toBe('2026-05-15T13:00:00.000Z')
+  })
+
+  it('clamps completed or over-complete sequences for display', () => {
+    expect(sequenceProgressPercent({ current_sample: 12, total_samples: 10 })).toBe(100)
+    expect(formatSequenceRemaining({ current_sample: 10, total_samples: 10 })).toBeNull()
+  })
+})

package/src/__tests__/utils/lcms.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest'
+import {
+  basenameFromWindowsPath,
+  extractLcmsCommonPrefix,
+  extractLcmsSampleName,
+  inferLcmsPlateTypeFromWellIds,
+  lcmsWellIdFromPosition,
+  reconstructLcmsPlateCellsFromSequenceItems,
+} from '../../lcms'
+
+describe('lcms utilities', () => {
+  it('extracts common prefixes and sample names from Xcalibur file names', () => {
+    const prefix = extractLcmsCommonPrefix([
+      'Batch_01_NEG_S1_001',
+      'Batch_01_NEG_S2_002',
+      'Batch_01_NEG_QC_003',
+    ])
+
+    expect(prefix).toBe('Batch_01')
+    expect(extractLcmsSampleName('Batch_01_NEG_S1_001', prefix)).toBe('S1')
+  })
+
+  it('infers plate type from well geometry', () => {
+    expect(lcmsWellIdFromPosition('R:A1')).toBe('A1')
+    expect(inferLcmsPlateTypeFromWellIds(['A1', 'F9'])).toBe('54vial')
+    expect(inferLcmsPlateTypeFromWellIds(['A1', 'H12'])).toBe('96well')
+  })
+
+  it('reconstructs plate cells from sequence items while skipping controls', () => {
+    const result = reconstructLcmsPlateCellsFromSequenceItems([
+      {
+        sample_type: 'Unknown',
+        file_name: 'Batch_NEG_S1_001',
+        sample_id: 'R:A1',
+        path: '',
+        instrument_method: 'C:\\Methods\\neg.meth',
+        position: 'R:A1',
+        injection_volume: 5,
+      },
+      {
+        sample_type: 'Unknown',
+        file_name: 'Batch_NEG_S2_002',
+        sample_id: 'R:H12',
+        path: '',
+        instrument_method: 'C:\\Methods\\neg.meth',
+        position: 'R:H12',
+        injection_volume: 5,
+      },
+      {
+        sample_type: 'Blank',
+        file_name: 'Batch_NEG_Blank_003',
+        sample_id: 'R:F9',
+        path: '',
+        instrument_method: 'C:\\Methods\\neg.meth',
+        position: 'R:F9',
+        injection_volume: 5,
+      },
+    ])
+
+    expect(result).toEqual({
+      plateType: '96well',
+      cells: [
+        { row: 'A', column: 1, sample_name: 'S1' },
+        { row: 'H', column: 12, sample_name: 'S2' },
+      ],
+    })
+  })
+
+  it('extracts basenames from Windows and POSIX paths', () => {
+    expect(basenameFromWindowsPath('C:\\Methods\\neg.meth')).toBe('neg.meth')
+    expect(basenameFromWindowsPath('/methods/pos.meth')).toBe('pos.meth')
+  })
+})

package/src/__tests__/utils/permissions.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest'
+import {
+  canAccessAdmin,
+  canAccessByPolicy,
+  canAccessPlugin,
+  getAccessAudience,
+  hasAllPermissions,
+  hasAnyPermission,
+  isAdminUser,
+} from '../../permissions'
+
+describe('permission helpers', () => {
+  const member = {
+    role: 'member',
+    role_obj: {
+      slug: 'member',
+      permissions: ['experiments.view', 'plugins.configure'],
+      plugin_access: ['dose'],
+    },
+  }
+
+  it('treats the admin role as full access', () => {
+    const admin = { role: 'admin' }
+
+    expect(isAdminUser(admin)).toBe(true)
+    expect(getAccessAudience(admin)).toBe('admin')
+    expect(hasAllPermissions(admin, ['platform.configure'])).toBe(true)
+    expect(canAccessAdmin(admin)).toBe(true)
+  })
+
+  it('checks role permissions and plugin access for non-admin users', () => {
+    expect(isAdminUser(member)).toBe(false)
+    expect(getAccessAudience(member)).toBe('user')
+    expect(hasAllPermissions(member, ['experiments.view'])).toBe(true)
+    expect(hasAllPermissions(member, ['platform.configure'])).toBe(false)
+    expect(hasAnyPermission(member, ['platform.configure', 'plugins.configure'])).toBe(true)
+    expect(canAccessAdmin(member)).toBe(true)
+    expect(canAccessPlugin(member, 'dose')).toBe(true)
+    expect(canAccessPlugin(member, 'reports')).toBe(false)
+  })
+
+  it('evaluates access policies consistently', () => {
+    expect(canAccessByPolicy(member, { visibleFor: 'user' })).toBe(true)
+    expect(canAccessByPolicy(member, { visibleFor: 'admin' })).toBe(false)
+    expect(canAccessByPolicy(member, { permissions: ['experiments.view'] })).toBe(true)
+    expect(canAccessByPolicy(member, { anyPermissions: ['platform.configure', 'plugins.configure'] })).toBe(true)
+    expect(canAccessByPolicy(member, { requiresAdmin: true })).toBe(false)
+    expect(canAccessByPolicy(member, { plugin: 'reports' })).toBe(false)
+  })
+})