@morscherlab/mint-sdk 1.3.9 → 1.4.0-beta.2

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

@@ -21,14 +21,14 @@ interface FrontendManifest {
       replacement?: string
       examples?: Array<{ title: string; language: string; code: string }>
       props?: Array<{ name: string }>
+      subpath?: string
     }>
     composables: Array<{
       name: string
+      subpath?: string
       members?: Array<{ name: string; type?: string }>
       examples?: Array<{ title: string; language: string; code: string }>
     }>
-    templateExports: Array<{ name: string }>
-    templatePacks: Array<{ name: string }>
   }
   exports: Array<{ name: string }>
 }
@@ -37,15 +37,14 @@ const TEST_DIR = dirname(fileURLToPath(import.meta.url))
 const SDK_ROOT = resolve(TEST_DIR, '../../..')
 const CORE_USAGE_NAMES = [
   'ArtifactSelectorModal',
-  'ControlWorkspaceView',
   'ExperimentSelectorModal',
   'GeneratedPluginView',
   'GeneratedResultRenderer',
   'JobsStatusTray',
   'PluginWorkspaceView',
-  'useAnalysisArtifacts',
+  'useArtifacts',
   'useAppExperiment',
-  'usePluginJobs',
+  'useJobsEndpoint',
 ]
 
 function extractFrontendManifest(): FrontendManifest {
@@ -56,12 +55,18 @@ function extractFrontendManifest(): FrontendManifest {
   return JSON.parse(output) as FrontendManifest
 }
 
-function parseComponentExports(): string[] {
+const ROOT_COMPONENTS_INDEX = join(SDK_ROOT, 'src', 'components', 'index.ts')
+// The package root barrel and the subpath entries that export components.
+const COMPONENT_ENTRY_FILES = [
+  ROOT_COMPONENTS_INDEX,
+  ...['lab', 'shell', 'data', 'runtime'].map(subpath => join(SDK_ROOT, 'src', `${subpath}.ts`)),
+]
+
+function parseComponentExports(entryFiles: string[] = COMPONENT_ENTRY_FILES): string[] {
   const componentsDir = join(SDK_ROOT, 'src', 'components')
-  const content = readFileSync(join(componentsDir, 'index.ts'), 'utf8')
-  return [...content.matchAll(
-    /export\s+\{\s*(?:\/\*\*.*?\*\/\s*)?default\s+as\s+(\w+)(?:\s*,\s*[^}]*)?\s*\}\s+from\s+['"]\.\/([\w-]+)\.vue['"]/g,
-  )]
+  return entryFiles.flatMap(file => [...readFileSync(file, 'utf8').matchAll(
+    /export\s+\{\s*(?:\/\*\*.*?\*\/\s*)?default\s+as\s+(\w+)(?:\s*,\s*[^}]*)?\s*\}\s+from\s+['"]\.\/(?:components\/)?([\w-]+)\.vue['"]/g,
+  )])
     .filter((match) => existsSync(join(componentsDir, `${match[2]}.vue`)))
     .map(match => match[1])
     .sort()
@@ -70,7 +75,7 @@ function parseComponentExports(): string[] {
 function parseRootComponentExports(): string[] {
   const content = readFileSync(join(SDK_ROOT, 'src', 'index.ts'), 'utf8')
   if (/export\s+\*\s+from\s+['"]\.\/components['"]/.test(content)) {
-    return parseComponentExports()
+    return parseComponentExports([ROOT_COMPONENTS_INDEX])
   }
 
   const names = new Set<string>()
@@ -89,8 +94,7 @@ function parseRootComponentExports(): string[] {
 }
 
 function parseDeprecatedComponentExports(): Record<string, string> {
-  const componentsDir = join(SDK_ROOT, 'src', 'components')
-  const content = readFileSync(join(componentsDir, 'index.ts'), 'utf8')
+  const content = COMPONENT_ENTRY_FILES.map(file => readFileSync(file, 'utf8')).join('\n')
   const deprecated = new Map<string, string>()
   let pendingJsdoc = ''
   let jsdocLines: string[] = []
@@ -121,7 +125,7 @@ function parseDeprecatedComponentExports(): Record<string, string> {
     }
 
     const exportMatch = line.match(
-      /export\s+\{\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+['"]\.\/(?:components\/)?([\w-]+)\.vue['"]/,
     )
     if (!exportMatch) continue
 
@@ -137,17 +141,24 @@ function parseDeprecatedComponentExports(): Record<string, string> {
   return Object.fromEntries([...deprecated.entries()].sort(([a], [b]) => a.localeCompare(b)))
 }
 
-function parseDocumentedComposableExports(): string[] {
+const ROOT_COMPOSABLES_INDEX = join(SDK_ROOT, 'src', 'composables', 'index.ts')
+// The package-root composables barrel and the subpath entries that export composables.
+const COMPOSABLE_ENTRY_FILES = [
+  ROOT_COMPOSABLES_INDEX,
+  ...['lab', 'shell', 'data', 'runtime'].map(subpath => join(SDK_ROOT, 'src', `${subpath}.ts`)),
+]
+
+function parseDocumentedComposableExports(entryFiles: string[] = COMPOSABLE_ENTRY_FILES): string[] {
   const scriptContent = readFileSync(join(SDK_ROOT, 'scripts', 'extract-docs-composables.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 indexContent = entryFiles.map(file => readFileSync(file, 'utf8')).join('\n')
   const names: string[] = []
 
-  for (const match of indexContent.matchAll(/export\s+\{([\s\S]*?)\}\s+from\s+['"]\.\/[\w-]+['"]/g)) {
+  for (const match of indexContent.matchAll(/export\s+\{([^{}]*)\}\s+from\s+['"]\.\/(?:composables\/)?[\w-]+['"]/g)) {
     for (const item of match[1].split(',')) {
       const spec = item.trim()
       if (!spec || spec.startsWith('type ')) continue
@@ -163,7 +174,7 @@ function parseDocumentedComposableExports(): string[] {
 
 function parseRootComposableExports(): string[] {
   const rootContent = readFileSync(join(SDK_ROOT, 'src', 'index.ts'), 'utf8')
-  const composableExports = parseDocumentedComposableExports()
+  const composableExports = parseDocumentedComposableExports([ROOT_COMPOSABLES_INDEX])
 
   if (/export\s+\*\s+from\s+['"]\.\/composables['"]/.test(rootContent)) {
     return composableExports
@@ -182,24 +193,6 @@ function parseRootComposableExports(): string[] {
   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))
@@ -269,18 +262,15 @@ describe('frontend docs catalog coverage', () => {
       GeneratedResultRenderer: byName.get('GeneratedResultRenderer')?.props?.map(prop => prop.name),
     }).toEqual({
       GeneratedPluginView: ['baseUrl', 'showStandaloneLabel', 'transport'],
-      GeneratedResultRenderer: ['result'],
+      GeneratedResultRenderer: ['result', 'searchable'],
     })
   })
 
-  it('documents the source and MINT 1.1 JobsStatusTray props', () => {
+  it('documents only the source-driven JobsStatusTray props', () => {
     const manifest = extractFrontendManifest()
     const jobsStatusTray = manifest.categories.components.find(item => item.name === 'JobsStatusTray')
 
     expect(jobsStatusTray?.props?.map(prop => prop.name).sort()).toEqual([
-      'adapter',
-      'eventStream',
-      'jobs',
       'loadOnMount',
       'source',
       'teleportTo',
@@ -288,8 +278,8 @@ describe('frontend docs catalog coverage', () => {
     ])
   })
 
-  it('re-exports every public component from the root SDK entrypoint', () => {
-    const publicComponents = parseComponentExports()
+  it('re-exports every root component from the root SDK entrypoint', () => {
+    const publicComponents = parseComponentExports([ROOT_COMPONENTS_INDEX])
     const rootComponents = parseRootComponentExports()
 
     expect(missingFromManifest(publicComponents, rootComponents)).toEqual([])
@@ -338,27 +328,87 @@ describe('frontend docs catalog coverage', () => {
       'useWellPainting',
       'useWellPlateAdapter',
       'useWellPlateValidation',
+      'DoseDesignWorkspaceView',
+      'usePluginClient',
+      'useJobsStatusTray',
+      'UseJobsStatusTrayOptions',
+      'UseJobsStatusTrayReturn',
+      'JobsStatusTrayAdapter',
+      'JobStreamMessage',
+      'BioTemplateRenderer',
+      'BioTemplateExperimentWorkspaceView',
+      'BioTemplatePackWorkspaceView',
+      'BioTemplatePresetWorkspaceView',
+      'ReagentList',
+      'ReagentEditor',
+      'ExperimentTimeline',
+      'SampleLegend',
+      'FitPanel',
+      'useBioTemplateComponents',
+      'useBioTemplateControls',
+      'useBioTemplatePackWorkspace',
+      'useBioTemplatePresetWorkspace',
+      'useBioTemplateWorkspace',
+      'useTemplateCollection',
+      'useExperimentSave',
+      'getBioTemplateComponentProps',
+      'toBioTemplateComponentPropsByComponent',
+      'SmartGroupModal',
+      'SmartGroupFieldRecipe',
+      'SmartGroupManual',
+      'GroupAssigner',
+      'useGroupAssignment',
+      'GroupAssignmentSource',
+      'GroupAssignmentState',
+      'GroupAssignmentZone',
+      'UseGroupAssignmentOptions',
+      'UseGroupAssignmentReturn',
+      // Renamed or removed in MINT 1.4 (spec 3.3).
+      'usePlatformContext',
+      'useCurrentExperiment',
+      'createPluginClient',
+      'buildPluginEndpointUrl',
+      'uploadPluginEndpoint',
+      'downloadPluginEndpoint',
+      'usePluginEventStream',
+      'usePluginSettings',
+      'usePluginJobs',
+      'useGeneratedAnalysis',
+      'usePluginJobCenter',
+      'useRequestSyncState',
+      'useAnalysisArtifacts',
+      'useTimeUtils',
+      'useDoseCalculator',
+      'useChemicalFormula',
+      'getPluginPageSelectorItems',
     ]
+    const subpathIndexes = ['lab', 'shell', 'data', 'runtime']
+      .map(subpath => readFileSync(join(SDK_ROOT, 'src', `${subpath}.ts`), 'utf8'))
+      .join('\n')
 
     for (const name of retiredNames) {
+      expect(subpathIndexes).not.toMatch(new RegExp(`\\b${name}\\b`))
       expect(rootIndex).not.toMatch(new RegExp(`\\b${name}\\b`))
       expect(componentsIndex).not.toMatch(new RegExp(`\\b${name}\\b`))
       expect(composableExports).not.toMatch(new RegExp(`\\b${name}\\b`))
     }
   })
 
-  it('keeps the MINT 1.1 composable compatibility exports', () => {
+  it('should keep the replacement APIs public when the MINT 1.4 removals land', () => {
+    const componentEntries = COMPONENT_ENTRY_FILES.map(file => readFileSync(file, 'utf8')).join('\n')
     const composablesIndex = readFileSync(join(SDK_ROOT, 'src', 'composables', 'index.ts'), 'utf8')
     const expected = [
-      'useJobsStatusTray',
-      'UseJobsStatusTrayOptions',
-      'UseJobsStatusTrayReturn',
-      'JobsStatusTrayAdapter',
-      'JobStreamMessage',
-      'usePluginClient',
+      'PluginWorkspaceView',
+      'InstrumentStateBadge',
+      'SequenceProgressBar',
+      'JobsStatusTray',
+      'defineDoseDesignControlModel',
+      'useJobCenter',
+      'PluginJobCenterSource',
     ]
+    const publicExports = `${componentEntries}\n${composablesIndex}`
 
-    expect(expected.filter(name => !new RegExp(`\\b${name}\\b`).test(composablesIndex))).toEqual([])
+    expect(expected.filter(name => !new RegExp(`\\b${name}\\b`).test(publicExports))).toEqual([])
   })
 
   it('documents every public composable/helper export used by docs and doctor', () => {
@@ -375,13 +425,19 @@ describe('frontend docs catalog coverage', () => {
     const documentedComposables = new Set(manifest.categories.composables.map(item => item.name))
 
     expect(documentedComposables.has('defineControlComponentBindings')).toBe(true)
-    expect(documentedComposables.has('controlValuesToComponentBindings')).toBe(true)
-    expect(documentedComposables.has('controlValuesToComponentBindingsById')).toBe(true)
+    expect(documentedComposables.has('controlsTo')).toBe(true)
     expect(documentedComposables.has('defineWellPlateDoseComponentBindings')).toBe(true)
   })
 
+  it('should name the package subpath of a subpath composable when the docs manifest lists it', () => {
+    const manifest = extractFrontendManifest()
+    const subpathOf = (name: string) => manifest.categories.composables.find(item => item.name === name)?.subpath
+
+    expect([subpathOf('useToast'), subpathOf('useJobsEndpoint')]).toEqual([undefined, 'runtime'])
+  })
+
   it('re-exports every documented composable/helper from the root SDK entrypoint', () => {
-    const publicComposables = parseDocumentedComposableExports()
+    const publicComposables = parseDocumentedComposableExports([ROOT_COMPOSABLES_INDEX])
     const rootComposables = parseRootComposableExports()
 
     expect(missingFromManifest(publicComposables, rootComposables)).toEqual([])
@@ -399,10 +455,10 @@ describe('frontend docs catalog coverage', () => {
     expect(rootIndex).toMatch(/export\s+\*\s+from\s+['"]\.\/stores['"]/)
   })
 
-  it('re-exports the public templates barrel from the root SDK entrypoint', () => {
+  it('should not re-export a templates barrel from the root SDK entrypoint', () => {
     const rootIndex = readFileSync(join(SDK_ROOT, 'src', 'index.ts'), 'utf8')
 
-    expect(rootIndex).toMatch(/export\s+\*\s+from\s+['"]\.\/templates['"]/)
+    expect(rootIndex).not.toMatch(/from\s+['"]\.\/templates['"]/)
   })
 
   it('expands root barrel exports into the docs manifest', () => {
@@ -411,34 +467,20 @@ describe('frontend docs catalog coverage', () => {
 
     expect(rootExports).toEqual(expect.arrayContaining([
       'BaseButton',
-      'DoseDesignWorkspaceView',
-      'WellPlate',
+      'PluginWorkspaceView',
+      'DataFrame',
       'useForm',
       'useReagentSeries',
-      'ConversionResult',
+      'ConcentrationValue',
       'FormSectionSchema',
-      'createWellPlateScreenCollection',
     ]))
   })
 
-  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', () => {
+  it('should name the package subpath of a subpath component when the docs manifest lists it', () => {
     const manifest = extractFrontendManifest()
-    const publicTemplateExports = parseTemplateExports()
-    const documentedTemplateExports = manifest.categories.templateExports.map(item => item.name).sort()
+    const subpathOf = (name: string) => manifest.categories.components.find(item => item.name === name)?.subpath
 
-    expect(missingFromManifest(publicTemplateExports, documentedTemplateExports)).toEqual([])
-    expect(missingFromManifest(documentedTemplateExports, publicTemplateExports)).toEqual([])
+    expect([subpathOf('BaseButton'), subpathOf('WellPlate')]).toEqual([undefined, 'lab'])
   })
 
   it('extracts return members from external type files', () => {
@@ -449,10 +491,31 @@ describe('frontend docs catalog coverage', () => {
   })
 
   it('extracts inherited return interface members', () => {
-    const manifest = extractFrontendManifest()
-    const workspace = manifest.categories.composables.find(item => item.name === 'useBioTemplateWorkspace')
+    const root = mkdtempSync(join(tmpdir(), 'mint-docs-'))
+    const composablesDir = join(root, 'composables')
+    mkdirSync(composablesDir)
+    writeFileSync(join(composablesDir, 'index.ts'), "export { useStack } from './useStack'\n")
+    writeFileSync(join(composablesDir, 'useStack.ts'), [
+      'export interface StackBase {',
+      '  size: number',
+      '}',
+      'export interface UseStackReturn extends StackBase {',
+      '  push: (item: string) => void',
+      '}',
+      'export function useStack(): UseStackReturn { return { size: 0, push: () => {} } }',
+    ].join('\n'))
+
+    try {
+      const [stack] = extractComposables({
+        sdkRoot: root,
+        composablesDir,
+        returnTypeFiles: [],
+      })
 
-    expect(workspace?.members?.map(member => member.name)).toContain('componentUsage')
+      expect(stack.members.map(member => member.name)).toContain('size')
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
   })
 
   it('ignores generic constraints when extracting inherited return members', () => {
@@ -472,8 +535,6 @@ describe('frontend docs catalog coverage', () => {
       const [stack] = extractComposables({
         sdkRoot: root,
         composablesDir,
-        templatesDir: join(root, 'templates'),
-        templateIndexTs: join(root, 'templates', 'index.ts'),
         returnTypeFiles: [],
       })
 
@@ -484,9 +545,28 @@ describe('frontend docs catalog coverage', () => {
   })
 
   it('extracts exact array return member types while resolving inheritance', () => {
-    const manifest = extractFrontendManifest()
-    const bindings = manifest.categories.composables.find(item => item.name === 'controlValuesToComponentBindings')
+    const root = mkdtempSync(join(tmpdir(), 'mint-docs-'))
+    const composablesDir = join(root, 'composables')
+    mkdirSync(composablesDir)
+    writeFileSync(join(composablesDir, 'index.ts'), "export { useBindings } from './useBindings'\n")
+    writeFileSync(join(composablesDir, 'useBindings.ts'), [
+      'export interface BindingBase { id: string }',
+      'export interface Binding extends BindingBase {',
+      '  props: Record<string, unknown>',
+      '}',
+      'export function useBindings(): Binding[] { return [] }',
+    ].join('\n'))
 
-    expect(bindings?.members?.find(member => member.name === 'props')?.type).toBe('Record<string, unknown>')
+    try {
+      const [bindings] = extractComposables({
+        sdkRoot: root,
+        composablesDir,
+        returnTypeFiles: [],
+      })
+
+      expect(bindings.members.find(member => member.name === 'props')?.type).toBe('Record<string, unknown>')
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
   })
 })

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

@@ -91,7 +91,7 @@ describe('SDK control refresh base-control rules', () => {
   })
 
   it('should find no literal var() fallback when scanning drift files (1i drift, 10c)', () => {
-    const files = ['checkbox.css', 'toggle.css', 'slider.css', 'app-layout.css', 'app-container.css', 'mobile-support-gate.css']
+    const files = ['checkbox.css', 'toggle.css', 'slider.css', 'app-layout.css', 'app-container.css']
     expect(offenders(files, (l) => /var\(--[\w-]+,\s*[^v\s]/.test(l))).toEqual([])
   })
 

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

@@ -26,10 +26,8 @@ describe('dark-mode ink and hairline rules', () => {
   it.each([
     ['batch-progress-list.css', 'mint-batch-progress'],
     ['dataframe.css', 'mint-dataframe'],
-    ['fit-panel.css', 'mint-fit-panel'],
     ['jobs-status-tray.css', 'mint-jobs-tray'],
     ['molecule-input.css', 'mint-molecule-input'],
-    ['reagent-list.css', 'mint-reagent-list'],
     ['sample-hierarchy-tree.css', 'mint-sample-tree'],
     ['sequence-input.css', 'mint-sequence-input'],
     ['step-wizard.css', 'mint-wizard'],
@@ -40,8 +38,4 @@ describe('dark-mode ink and hairline rules', () => {
   it('should stripe DataFrame rows with a tint that differs from the --bg-card surface', () => {
     expect(css('dataframe.css')).not.toMatch(/\.mint-dataframe__row--striped[^{]*\{[^}]*--bg-secondary/)
   })
-
-  it('should size timeline icons border-box so the dashed skipped ring keeps the nominal size', () => {
-    expect(css('experiment-timeline.css')).toMatch(/\.mint-timeline__icon \{[^}]*box-sizing: border-box;/)
-  })
 })

package/src/__tests__/{composables/useChemicalFormula.test.ts → utils/formula.test.ts}

@@ -1,9 +1,7 @@
 import { describe, expect, it } from 'vitest'
-import { useChemicalFormula } from '../../composables/useChemicalFormula'
+import { calculateMW, parseFormula, renderFormulaParts } from '../../utils/formula'
 
-const { parseFormula, calculateMW, renderFormulaParts } = useChemicalFormula()
-
-describe('useChemicalFormula parser (4b)', () => {
+describe('formula 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 })
   })
@@ -33,7 +31,7 @@ describe('useChemicalFormula parser (4b)', () => {
   })
 })
 
-describe('useChemicalFormula charges', () => {
+describe('formula charges', () => {
   it('should keep the subscript when a polyatomic ion has a bare trailing sign', () => {
     expect(parseFormula('NH4+').elements).toEqual({ N: 1, H: 4 })
   })

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

@@ -1,8 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import {
-  canAccessAdmin,
   canAccessByPolicy,
-  canAccessPlugin,
   getAccessAudience,
   hasAllPermissions,
   hasAnyPermission,
@@ -15,7 +13,6 @@ describe('permission helpers', () => {
     role_obj: {
       slug: 'member',
       permissions: ['experiments.view', 'plugins.configure'],
-      plugin_access: ['dose'],
     },
   }
 
@@ -25,45 +22,14 @@ describe('permission helpers', () => {
     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', () => {
+  it('checks role permissions 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.each(['none', '', {}, { dose: true }, 42])(
-    'should deny every plugin when plugin_access is malformed (%j)',
-    (access) => {
-      const user = { role: 'member', role_obj: { slug: 'member', plugin_access: access as never } }
-
-      expect(canAccessPlugin(user, 'dose')).toBe(false)
-    },
-  )
-
-  it('should allow every plugin when the user is an administrator', () => {
-    const admin = { role: 'admin', role_obj: { slug: 'admin', plugin_access: ['dose'] } }
-
-    expect(canAccessPlugin(admin, 'reports')).toBe(true)
-  })
-
-  it('allows notice publishers to enter the admin panel', () => {
-    const publisher = {
-      role: 'notice-publisher',
-      role_obj: {
-        slug: 'notice-publisher',
-        permissions: ['notices.publish'],
-      },
-    }
-
-    expect(canAccessAdmin(publisher)).toBe(true)
   })
 
   it('evaluates access policies consistently', () => {
@@ -72,6 +38,5 @@ describe('permission helpers', () => {
     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)
   })
 })

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

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import { mintPlotlyTemplate } from '../../utils/plotlyTemplate'
+import { mintPlotlyTemplate, resolveCssColor } from '../../utils/plotlyTemplate'
 
 const tokens: Record<string, string> = {
   '--mint-sample-1': '#111111',
@@ -67,3 +67,18 @@ describe('mintPlotlyTemplate', () => {
     expect(mintPlotlyTemplate().layout?.colorway?.[0]).toBe('#3B82F6')
   })
 })
+
+describe('resolveCssColor', () => {
+  afterEach(() => {
+    document.documentElement.removeAttribute('style')
+  })
+
+  it.each([
+    ['var(--color-primary)', '#14B8A6'],
+    ['var(--undefined-token)', 'var(--undefined-token)'],
+    ['#123456', '#123456'],
+  ])('should resolve %s to %s', (color, expected) => {
+    document.documentElement.style.setProperty('--color-primary', '#14B8A6')
+    expect(resolveCssColor(color)).toBe(expected)
+  })
+})

package/src/__tests__/{composables/useTimeUtils.test.ts → utils/time.test.ts}

@@ -5,10 +5,9 @@ import {
   fromMinutes,
   generateTimeSlots,
   toMinutes,
-  useTimeUtils,
-} from '../../composables/useTimeUtils'
+} from '../../utils/time'
 
-describe('useTimeUtils', () => {
+describe('time', () => {
   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')
@@ -26,10 +25,4 @@ describe('useTimeUtils', () => {
     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/components/ActionMenu.vue

@@ -1,12 +1,12 @@
 <script setup lang="ts">
-/** Compact overflow actions with an IconButton trigger and a viewport-safe teleported menu. */
+/** Compact overflow actions with an icon-only BaseButton trigger and a viewport-safe teleported menu. */
 import { computePosition, flip, offset, shift } from '@floating-ui/dom'
 import { Check, Ellipsis } from 'lucide-vue-next'
 import { nextTick, onMounted, ref, watch } from 'vue'
 import { useDropdownState } from '../composables/useDropdownState'
 import { useMenuKeyboard } from '../composables/useMenuKeyboard'
 import type { ActionMenuItem } from '../types/components'
-import IconButton from './IconButton.vue'
+import BaseButton from './BaseButton.vue'
 
 interface Props {
   label: string
@@ -25,7 +25,7 @@ const emit = defineEmits<{
 }>()
 
 defineSlots<{
-  /** Replaces the ellipsis IconButton; `toggle` and `keydown` go on the slotted button. */
+  /** Replaces the ellipsis button; `toggle` and `keydown` go on the slotted button. */
   trigger?: (props: { open: boolean; toggle: () => void; keydown: (event: KeyboardEvent) => void }) => unknown
 }>()
 
@@ -44,7 +44,7 @@ const { isOpen, rootRef, triggerRef, open, close } = useDropdownState({
   onClose: () => emit('close'),
 })
 
-// IconButton owns the actual <button>, so the trigger element is resolved from
+// BaseButton owns the actual <button>, so the trigger element is resolved from
 // the wrapper once mounted rather than bound with a template ref.
 onMounted(() => {
   triggerRef.value = rootRef.value?.querySelector('button') ?? null
@@ -117,23 +117,17 @@ watch(isOpen, async (opened) => {
   <span ref="rootRef" class="mint-action-menu">
     <!-- A custom trigger must render one <button> and wire toggle + keydown to it. -->
     <slot name="trigger" :open="isOpen" :toggle="toggleMenu" :keydown="handleTriggerKeydown">
-      <IconButton
+      <BaseButton
         variant="secondary"
         size="sm"
+        :icon="Ellipsis"
         :label="label"
         :disabled="disabled"
         aria-haspopup="menu"
         :aria-expanded="isOpen"
         @click="toggleMenu"
         @keydown="handleTriggerKeydown"
-      >
-        <Ellipsis
-          class="mint-action-menu__trigger-icon"
-          :size="16"
-          :stroke-width="2"
-          aria-hidden="true"
-        />
-      </IconButton>
+      />
     </slot>
   </span>