@morscherlab/mint-sdk 1.0.0-rc.1 → 1.0.0-rc.2

package/src/composables/useExperimentData.ts

@@ -1,7 +1,12 @@
-import { ref, computed, type Ref, type ComputedRef } from 'vue'
-import { useApi } from './useApi'
+import { shallowRef, computed, type Ref, type ComputedRef } from 'vue'
+import { useApi, type UseApiReturn } from './useApi'
 import { useRequestSyncState } from './useRequestSyncState'
-import type { TreeNode, SummaryData } from '../types'
+import {
+  extractSampleNamesFromDesignData,
+  extractSampleOptionsFromDesignData,
+  unwrapExperimentDesignData,
+} from './experimentDesignData'
+import type { TreeNode, SummaryData, SelectOption } from '../types'
 
 export interface UseExperimentDataOptions {
   apiBaseUrl?: string
@@ -9,8 +14,14 @@ export interface UseExperimentDataOptions {
 }
 
 export interface UseExperimentDataReturn {
-  /** Raw experiment data payload from `/experiments/{id}/data`, or null. */
+  /** Raw experiment data response from `/experiments/{id}/data`, or null. */
   data: Ref<Record<string, unknown> | null>
+  /** Plugin-defined design_data payload unwrapped from platform response shapes, or null. */
+  designData: ComputedRef<Record<string, unknown> | null>
+  /** Sample values extracted from design_data for SampleSelector-style components. */
+  sampleNames: ComputedRef<string[]>
+  /** Sample options extracted from design_data for select/dropdown components. */
+  sampleOptions: ComputedRef<SelectOption<string>[]>
   /** Hierarchy tree rows normalised from `tree_data` or `treeData`. */
   treeData: ComputedRef<TreeNode[]>
   /** Table rows normalised from `table_data` or `tableData`. */
@@ -24,54 +35,74 @@ export interface UseExperimentDataReturn {
   /** Timestamp of the last successful experiment data fetch, or null. */
   lastLoadedAt: Ref<Date | null>
   /** Fetch experiment data for an experiment id. */
-  fetch: (experimentId: number) => Promise<void>
+  fetch: (experimentId: number) => Promise<Record<string, unknown> | null>
   /** Refetch the most recently fetched experiment id. */
   refresh: () => Promise<void>
+  /** Clear local experiment data and current fetch target. */
+  clear: () => void
 }
 
 /** Fetches and normalises experiment output data (tree, table, summary) from the platform API. */
 export function useExperimentData(
   options: UseExperimentDataOptions = {},
 ): UseExperimentDataReturn {
-  const api = useApi({ baseUrl: options.apiBaseUrl })
-
-  const data = ref<Record<string, unknown> | null>(null)
+  const data = shallowRef<Record<string, unknown> | null>(null)
   const request = useRequestSyncState('Failed to fetch experiment data')
   const isLoading = request.loading
   const error = request.error
   const lastLoadedAt = request.lastLoadedAt
   let lastExperimentId: number | null = null
+  let api: UseApiReturn | null = null
+
+  function getApi(): UseApiReturn {
+    api ??= useApi({ baseUrl: options.apiBaseUrl })
+    return api
+  }
+
+  const designData = computed<Record<string, unknown> | null>(() =>
+    unwrapExperimentDesignData(data.value),
+  )
+
+  const sampleNames = computed<string[]>(() =>
+    extractSampleNamesFromDesignData(designData.value),
+  )
+
+  const sampleOptions = computed<SelectOption<string>[]>(() =>
+    extractSampleOptionsFromDesignData(designData.value),
+  )
 
   const treeData = computed<TreeNode[]>(() => {
-    if (!data.value) return []
-    const tree = data.value.tree_data ?? data.value.treeData
+    if (!designData.value) return []
+    const tree = designData.value.tree_data ?? designData.value.treeData
     return Array.isArray(tree) ? tree as TreeNode[] : []
   })
 
   const tableData = computed<Record<string, unknown>[]>(() => {
-    if (!data.value) return []
-    const table = data.value.table_data ?? data.value.tableData
+    if (!designData.value) return []
+    const table = designData.value.table_data ?? designData.value.tableData
     return Array.isArray(table) ? table as Record<string, unknown>[] : []
   })
 
   const summaryData = computed<SummaryData | null>(() => {
-    if (!data.value) return null
-    const summary = data.value.summary_data ?? data.value.summaryData
+    if (!designData.value) return null
+    const summary = designData.value.summary_data ?? designData.value.summaryData
     if (summary && typeof summary === 'object' && 'metadata' in (summary as Record<string, unknown>)) {
       return summary as SummaryData
     }
     return null
   })
 
-  async function fetchData(experimentId: number): Promise<void> {
+  async function fetchData(experimentId: number): Promise<Record<string, unknown> | null> {
     lastExperimentId = experimentId
     try {
       data.value = await request.run(
-        () => api.get<Record<string, unknown>>(`/experiments/${experimentId}/data`),
+        () => getApi().get<Record<string, unknown>>(`/experiments/${experimentId}/data`),
         { success: 'load', errorMessage: 'Failed to fetch experiment data' },
       )
+      return data.value
     } catch {
       data.value = null
+      return null
     }
   }
 
@@ -81,8 +112,17 @@ export function useExperimentData(
     }
   }
 
+  function clear(): void {
+    data.value = null
+    lastExperimentId = null
+    request.clearError()
+  }
+
   return {
     data,
+    designData,
+    sampleNames,
+    sampleOptions,
     treeData,
     tableData,
     summaryData,
@@ -91,5 +131,6 @@ export function useExperimentData(
     lastLoadedAt,
     fetch: fetchData,
     refresh,
+    clear,
   }
 }

package/src/composables/useExperimentSamples.ts

@@ -0,0 +1,142 @@
+import {
+  computed,
+  inject,
+  toValue,
+  watch,
+  type ComputedRef,
+  type MaybeRefOrGetter,
+  type Ref,
+} from 'vue'
+import type { SelectOption } from '../types'
+import { APP_EXPERIMENT_KEY } from './useAppExperiment'
+import {
+  extractSampleNamesFromDesignData,
+  extractSampleOptionsFromDesignData,
+  unwrapExperimentDesignData,
+  type ExtractExperimentSamplesOptions,
+} from './experimentDesignData'
+import { parseExperimentId } from './platformContextHelpers'
+import { useExperimentData } from './useExperimentData'
+
+export type ExperimentIdSource = MaybeRefOrGetter<number | string | null | undefined>
+export type ExperimentDesignDataSource = MaybeRefOrGetter<Record<string, unknown> | null | undefined>
+
+export interface UseExperimentSamplesOptions extends ExtractExperimentSamplesOptions {
+  /** Experiment id to load from `/experiments/{id}/data`; defaults to provided AppExperiment context. */
+  experimentId?: ExperimentIdSource
+  /** Pre-fetched design_data or full platform design-data response. */
+  designData?: ExperimentDesignDataSource
+  /** API base URL override for platform calls. */
+  apiBaseUrl?: string
+  /** Auto-load when an experiment id becomes available. Defaults to true. */
+  immediate?: boolean
+  /** Enable or disable automatic loading while keeping derived samples reactive. Defaults to true. */
+  enabled?: MaybeRefOrGetter<boolean>
+  /** Use `useAppExperiment` provided state when `experimentId` is not set. Defaults to true. */
+  syncAppExperiment?: boolean
+}
+
+export interface UseExperimentSamplesReturn {
+  /** Experiment id currently used for automatic sample loading. */
+  experimentId: ComputedRef<number | undefined>
+  /** Raw `/experiments/{id}/data` response when loaded through the platform API. */
+  data: Ref<Record<string, unknown> | null>
+  /** Plugin-defined design_data payload from props or platform response. */
+  designData: ComputedRef<Record<string, unknown> | null>
+  /** SampleSelector-compatible string values extracted from design_data. */
+  samples: ComputedRef<string[]>
+  /** Select/dropdown-friendly sample options extracted from design_data. */
+  sampleOptions: ComputedRef<SelectOption<string>[]>
+  isLoading: Ref<boolean>
+  error: Ref<string | null>
+  lastLoadedAt: Ref<Date | null>
+  /** Fetch samples for a specific experiment id, defaulting to the resolved id. */
+  fetch: (experimentId?: number | string | null) => Promise<Record<string, unknown> | null>
+  /** Refetch the current experiment id. */
+  refresh: () => Promise<void>
+  /** Clear fetched platform data. */
+  clear: () => void
+}
+
+/** Loads experiment design_data and derives samples for SampleSelector-style UIs. */
+export function useExperimentSamples(
+  options: UseExperimentSamplesOptions = {},
+): UseExperimentSamplesReturn {
+  const appExperiment = options.syncAppExperiment === false
+    ? undefined
+    : inject(APP_EXPERIMENT_KEY, undefined)
+  const experimentData = useExperimentData({ apiBaseUrl: options.apiBaseUrl })
+
+  const experimentId = computed<number | undefined>(() => {
+    const explicitId = parseExperimentId(toValue(options.experimentId))
+    return explicitId ?? parseExperimentId(appExperiment?.experimentId.value)
+  })
+
+  const explicitDesignData = computed<Record<string, unknown> | null>(() =>
+    unwrapExperimentDesignData(toValue(options.designData) ?? null),
+  )
+
+  const designData = computed<Record<string, unknown> | null>(() =>
+    explicitDesignData.value ?? experimentData.designData.value,
+  )
+
+  const extractOptions = computed<ExtractExperimentSamplesOptions>(() => ({
+    includeControls: options.includeControls,
+  }))
+
+  const samples = computed<string[]>(() =>
+    extractSampleNamesFromDesignData(designData.value, extractOptions.value),
+  )
+
+  const sampleOptions = computed<SelectOption<string>[]>(() =>
+    extractSampleOptionsFromDesignData(designData.value, extractOptions.value),
+  )
+
+  const enabled = computed(() => toValue(options.enabled) ?? true)
+
+  async function fetchSamples(
+    id: number | string | null | undefined = experimentId.value,
+  ): Promise<Record<string, unknown> | null> {
+    const parsedId = parseExperimentId(id)
+    if (parsedId === undefined) {
+      experimentData.clear()
+      return null
+    }
+    return experimentData.fetch(parsedId)
+  }
+
+  watch(
+    () => ({
+      designData: explicitDesignData.value,
+      enabled: enabled.value,
+      experimentId: experimentId.value,
+    }),
+    ({ designData: currentDesignData, enabled: isEnabled, experimentId: currentExperimentId }) => {
+      if (options.immediate === false || !isEnabled) return
+      if (currentDesignData) {
+        experimentData.clear()
+        return
+      }
+      if (currentExperimentId === undefined) {
+        experimentData.clear()
+        return
+      }
+      void experimentData.fetch(currentExperimentId)
+    },
+    { immediate: options.immediate !== false },
+  )
+
+  return {
+    experimentId,
+    data: experimentData.data,
+    designData,
+    samples,
+    sampleOptions,
+    isLoading: experimentData.isLoading,
+    error: experimentData.error,
+    lastLoadedAt: experimentData.lastLoadedAt,
+    fetch: fetchSamples,
+    refresh: experimentData.refresh,
+    clear: experimentData.clear,
+  }
+}

package/src/index.ts

@@ -19,6 +19,15 @@ export {
 // Stores
 export * from './stores'
 
+// Permissions
+export * from './permissions'
+
+// Instrument monitoring
+export * from './instrument'
+
+// LCMS sequence helpers
+export * from './lcms'
+
 // Utils
 export {
   hexToHsl,
@@ -26,6 +35,24 @@ export {
   deriveShade,
   type Hsl,
 } from './utils/color'
+export {
+  LCMS_DEFAULT_CONTROL_POSITIONS,
+  createLcmsControlWellEditData,
+  getLcmsDefaultControlWellId,
+  lcmsPlateCellsToRack,
+  lcmsPlateCellsToRacks,
+  lcmsPlateTypeToRackFormat,
+  lcmsWellId,
+  parseLcmsWellId,
+  rackFormatToLcmsPlateType,
+  rackToLcmsPlateCells,
+  racksToLcmsPlateCells,
+  type LcmsControlSampleType,
+  type LcmsPlateCell,
+  type LcmsPlateCellsToRackOptions,
+  type LcmsPlateCellsToRacksOptions,
+  type LcmsPlateType,
+} from './utils/rack'
 
 // Biology data templates
 export * from './templates'

package/src/instrument.ts

@@ -0,0 +1,90 @@
+import type { SequenceProgress } from './types'
+
+export function sequenceProgressPercent(progress: SequenceProgress | null | undefined): number {
+  if (!progress || progress.total_samples <= 0) return 0
+  return Math.round(clamp((progress.current_sample / progress.total_samples) * 100, 0, 100))
+}
+
+export function sequenceSamplesRemaining(progress: SequenceProgress | null | undefined): number {
+  if (!progress) return 0
+  return Math.max(0, progress.total_samples - progress.current_sample)
+}
+
+export function estimateSequenceRemainingSeconds(
+  progress: SequenceProgress | null | undefined,
+): number | null {
+  if (!progress) return null
+  const samplesLeft = sequenceSamplesRemaining(progress)
+  if (samplesLeft <= 0) return 0
+
+  const explicit = progress.estimated_remaining_seconds
+  if (typeof explicit === 'number' && explicit > 0) return explicit
+
+  const avg = progress.avg_sample_seconds ?? average(progress.sample_durations)
+  if (typeof avg === 'number' && avg > 0) return samplesLeft * avg
+
+  const elapsed = progress.elapsed_seconds ?? 0
+  if (elapsed > 0 && progress.current_sample > 0) {
+    return (elapsed / progress.current_sample) * samplesLeft
+  }
+
+  return null
+}
+
+export function estimateSequenceFinishDate(
+  progress: SequenceProgress | null | undefined,
+  now = new Date(),
+): Date | null {
+  if (!progress) return null
+
+  const explicit = coerceDate(progress.estimated_finish_time)
+  if (explicit) return explicit
+
+  const remaining = estimateSequenceRemainingSeconds(progress)
+  if (remaining == null || remaining <= 0) return null
+  return new Date(now.getTime() + remaining * 1000)
+}
+
+export function formatSequenceRemaining(progress: SequenceProgress | null | undefined): string | null {
+  const remaining = estimateSequenceRemainingSeconds(progress)
+  if (remaining == null || remaining <= 0) return null
+
+  const minutes = remaining / 60
+  if (minutes < 1) return `${Math.round(remaining)}s left`
+  if (minutes < 60) return `~${Math.round(minutes)}m left`
+
+  const hours = Math.floor(minutes / 60)
+  const mins = Math.round(minutes % 60)
+  return mins > 0 ? `~${hours}h ${mins}m left` : `~${hours}h left`
+}
+
+export function formatSequenceEta(
+  progress: SequenceProgress | null | undefined,
+  locale?: Intl.LocalesArgument,
+  options: Intl.DateTimeFormatOptions = {},
+): string | null {
+  const finish = estimateSequenceFinishDate(progress)
+  if (!finish) return null
+  return finish.toLocaleTimeString(locale, {
+    hour: '2-digit',
+    minute: '2-digit',
+    ...options,
+  })
+}
+
+function average(values: readonly number[] | undefined): number | null {
+  if (!values?.length) return null
+  const usable = values.filter(value => Number.isFinite(value) && value >= 0)
+  if (usable.length === 0) return null
+  return usable.reduce((sum, value) => sum + value, 0) / usable.length
+}
+
+function coerceDate(value: string | Date | null | undefined): Date | null {
+  if (!value) return null
+  const date = value instanceof Date ? value : new Date(value)
+  return Number.isNaN(date.getTime()) ? null : date
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value))
+}

package/src/lcms.ts

@@ -0,0 +1,108 @@
+import type { LcmsPlateCell, LcmsPlateType } from './utils/rack'
+
+export type LcmsPolarity = 'POS' | 'NEG' | 'BOTH'
+export type LcmsContainerType = 'VIAL' | 'PLATE'
+
+export interface LcmsSequenceItem {
+  sample_type: string
+  file_name: string
+  sample_id: string
+  path: string
+  instrument_method: string
+  position: string
+  injection_volume: number
+}
+
+export interface LcmsSequenceTableColumn {
+  key: keyof LcmsSequenceItem | 'index' | 'actions'
+  label: string
+  align?: 'left' | 'right'
+}
+
+export const DEFAULT_LCMS_SEQUENCE_COLUMNS: LcmsSequenceTableColumn[] = [
+  { key: 'index', label: '#' },
+  { key: 'sample_type', label: 'Type' },
+  { key: 'file_name', label: 'File Name' },
+  { key: 'position', label: 'Position' },
+  { key: 'instrument_method', label: 'Method' },
+  { key: 'injection_volume', label: 'Inj Vol', align: 'right' },
+]
+
+export function extractLcmsCommonPrefix(fileNames: readonly string[]): string {
+  if (fileNames.length === 0) return ''
+  const stripped = fileNames.map(fileName => fileName.replace(/_\d{3}$/, ''))
+  const prefixes = stripped.map((fileName) => {
+    const match = fileName.match(/^(.+?)_(POS|NEG)_/i)
+    return match ? match[1] : fileName.replace(/_[^_]+$/, '')
+  })
+
+  let common = prefixes[0] ?? ''
+  for (const prefix of prefixes.slice(1)) {
+    while (common && !prefix.startsWith(common)) {
+      const index = common.lastIndexOf('_')
+      common = index > 0 ? common.substring(0, index) : common.substring(0, common.length - 1)
+    }
+  }
+  return common
+}
+
+export function extractLcmsSampleName(fileName: string, prefix = ''): string {
+  let name = fileName.replace(/_\d{3}$/, '')
+  if (prefix && name.startsWith(prefix)) {
+    name = name.substring(prefix.length).replace(/^_+/, '')
+  }
+  name = name.replace(/^(POS|NEG)_/i, '')
+  return name || fileName
+}
+
+export function lcmsWellIdFromPosition(position: string): string {
+  return position.includes(':') ? position.split(':').pop() ?? position : position
+}
+
+export function inferLcmsPlateTypeFromWellIds(wellIds: readonly string[]): LcmsPlateType | null {
+  let maxCol = 0
+  let maxRow = 0
+  for (const wellId of wellIds) {
+    const match = wellId.match(/^([A-Z])(\d+)$/i)
+    if (!match) continue
+    maxRow = Math.max(maxRow, match[1].toUpperCase().charCodeAt(0) - 64)
+    maxCol = Math.max(maxCol, Number(match[2]))
+  }
+  if (maxCol === 0 && maxRow === 0) return null
+  return maxCol <= 9 && maxRow <= 6 ? '54vial' : '96well'
+}
+
+export function reconstructLcmsPlateCellsFromSequenceItems(
+  items: readonly LcmsSequenceItem[],
+): { cells: LcmsPlateCell[]; plateType: LcmsPlateType } | null {
+  const unknownItems = items.filter(item => item.sample_type === 'Unknown')
+  if (unknownItems.length === 0) return null
+
+  const prefix = extractLcmsCommonPrefix(unknownItems.map(item => item.file_name))
+  const seen = new Set<string>()
+  const cells: LcmsPlateCell[] = []
+
+  for (const item of unknownItems) {
+    const wellId = lcmsWellIdFromPosition(item.position)
+    if (seen.has(wellId)) continue
+    seen.add(wellId)
+
+    const match = wellId.match(/^([A-Z])(\d+)$/i)
+    if (!match) continue
+    cells.push({
+      row: match[1].toUpperCase(),
+      column: Number(match[2]),
+      sample_name: extractLcmsSampleName(item.file_name, prefix),
+    })
+  }
+
+  if (cells.length === 0) return null
+  const plateType = inferLcmsPlateTypeFromWellIds(cells.map(cell => `${cell.row}${cell.column}`))
+  if (!plateType) return null
+  return { cells, plateType }
+}
+
+export function basenameFromWindowsPath(path: string | null | undefined): string {
+  if (!path) return ''
+  return path.split(/[\\/]/).pop() ?? path
+}

package/src/permissions.ts

@@ -0,0 +1,143 @@
+export const ADMIN_ROLE = 'admin'
+
+export const ADMIN_PANEL_PERMISSIONS = [
+  'users.view',
+  'users.invite',
+  'users.manage',
+  'platform.configure',
+  'platform.view_logs',
+  'plugins.configure',
+  'plugins.install',
+] as const
+
+export type AccessAudience = 'all' | 'admin' | 'user'
+export type AccessAudienceInput = AccessAudience | readonly AccessAudience[]
+
+export interface RoleInfo {
+  id?: number
+  slug: string
+  name?: string
+  color?: string
+  permissions?: readonly string[] | null
+  project_scope?: 'all' | 'assigned' | string
+  plugin_access?: readonly string[] | 'all' | null
+}
+
+export interface PermissionUser {
+  role?: string | null
+  role_obj?: RoleInfo | null
+  roleObj?: RoleInfo | null
+  permissions?: readonly string[] | null
+}
+
+export interface AccessPolicy {
+  audience?: AccessAudienceInput
+  visibleFor?: AccessAudienceInput
+  requiresAuth?: boolean
+  requiresAdmin?: boolean
+  permissions?: readonly string[]
+  anyPermissions?: readonly string[]
+  plugin?: string
+}
+
+export interface AccessControlled {
+  access?: AccessPolicy
+  visibleFor?: AccessAudienceInput
+  requiresAdmin?: boolean
+  permissions?: readonly string[]
+  anyPermissions?: readonly string[]
+}
+
+export function getRoleInfo(user: PermissionUser | null | undefined): RoleInfo | null {
+  return user?.roleObj ?? user?.role_obj ?? null
+}
+
+export function isAdminRole(role: string | null | undefined): boolean {
+  return role === ADMIN_ROLE
+}
+
+export function isAdminUser(user: PermissionUser | null | undefined): boolean {
+  return isAdminRole(user?.role) || getRoleInfo(user)?.slug === ADMIN_ROLE
+}
+
+export function getAccessAudience(user: PermissionUser | null | undefined): Exclude<AccessAudience, 'all'> {
+  return isAdminUser(user) ? 'admin' : 'user'
+}
+
+export function getUserPermissions(user: PermissionUser | null | undefined): string[] {
+  const rolePermissions = getRoleInfo(user)?.permissions
+  if (rolePermissions?.length) return [...rolePermissions]
+  return [...(user?.permissions ?? [])]
+}
+
+export function hasAllPermissions(
+  user: PermissionUser | null | undefined,
+  permissions: readonly string[] = [],
+): boolean {
+  if (permissions.length === 0) return true
+  if (isAdminUser(user)) return true
+  const granted = new Set(getUserPermissions(user))
+  return permissions.every(permission => granted.has(permission))
+}
+
+export function hasAnyPermission(
+  user: PermissionUser | null | undefined,
+  permissions: readonly string[] = [],
+): boolean {
+  if (permissions.length === 0) return true
+  if (isAdminUser(user)) return true
+  const granted = new Set(getUserPermissions(user))
+  return permissions.some(permission => granted.has(permission))
+}
+
+export function canAccessAdmin(user: PermissionUser | null | undefined): boolean {
+  return isAdminUser(user) || hasAnyPermission(user, ADMIN_PANEL_PERMISSIONS)
+}
+
+export function canAccessPlugin(
+  user: PermissionUser | null | undefined,
+  pluginName: string | null | undefined,
+): boolean {
+  if (!pluginName) return true
+  const access = getRoleInfo(user)?.plugin_access
+  if (!access || access === 'all') return true
+  return Array.isArray(access) && access.includes(pluginName)
+}
+
+export function normalizeAccessPolicy(rule: AccessControlled | AccessPolicy | undefined): AccessPolicy {
+  if (!rule) return {}
+  const { access: nested, ...direct } = rule as AccessPolicy & { access?: AccessPolicy }
+  return {
+    ...(nested ?? {}),
+    ...direct,
+    ...('visibleFor' in rule && rule.visibleFor !== undefined ? { visibleFor: rule.visibleFor } : {}),
+    ...('requiresAdmin' in rule && rule.requiresAdmin !== undefined ? { requiresAdmin: rule.requiresAdmin } : {}),
+    ...('permissions' in rule && rule.permissions !== undefined ? { permissions: rule.permissions } : {}),
+    ...('anyPermissions' in rule && rule.anyPermissions !== undefined ? { anyPermissions: rule.anyPermissions } : {}),
+  }
+}
+
+export function canAccessByPolicy(
+  user: PermissionUser | null | undefined,
+  rule: AccessControlled | AccessPolicy | undefined,
+  isAuthenticated = user !== null && user !== undefined,
+): boolean {
+  const policy = normalizeAccessPolicy(rule)
+  if (policy.requiresAuth && !isAuthenticated) return false
+  if (policy.requiresAdmin && !isAdminUser(user)) return false
+  if (!audienceAllowsUser(policy.visibleFor ?? policy.audience, user)) return false
+  if (!hasAllPermissions(user, policy.permissions)) return false
+  if (!hasAnyPermission(user, policy.anyPermissions)) return false
+  if (policy.plugin && !canAccessPlugin(user, policy.plugin)) return false
+  return true
+}
+
+function audienceAllowsUser(
+  audience: AccessAudienceInput | undefined,
+  user: PermissionUser | null | undefined,
+): boolean {
+  if (audience === undefined) return true
+  const allowed = Array.isArray(audience) ? audience : [audience]
+  if (allowed.includes('all')) return true
+  return allowed.includes(getAccessAudience(user))
+}