@morscherlab/mint-sdk 1.2.0-beta.3 → 1.2.0-beta.4

package/src/generated/schema.ts

@@ -0,0 +1,130 @@
+import type {
+  FormFieldSchema,
+  FormFieldType,
+  FormSchema,
+} from '../types/form-builder'
+import type {
+  GeneratedJsonSchema,
+  GeneratedJobDefinition,
+} from '../types/generated-ui'
+
+type GeneratedReference = 'path'
+
+interface ResolvedGeneratedField {
+  schema: GeneratedJsonSchema
+  reference?: GeneratedReference
+  hasDefault: boolean
+  defaultValue?: unknown
+}
+
+export function generatedJobFormSchema(definition: GeneratedJobDefinition): FormSchema & { sections: NonNullable<FormSchema['sections']> } {
+  const root = definition.input_schema
+  const required = new Set(root.required ?? [])
+  const fields = Object.entries(root.properties ?? {}).map(([name, schema]) =>
+    toFormField(name, resolveGeneratedField(root, schema), required.has(name)),
+  )
+  return {
+    sections: [{
+      id: definition.id,
+      title: definition.title,
+      description: definition.description || undefined,
+      columns: 1,
+      fields,
+    }],
+    submitLabel: 'Run analysis',
+  }
+}
+
+export function generatedJobDefaults(definition: GeneratedJobDefinition): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(definition.input_schema.properties ?? {})
+      .filter(([, schema]) => hasOwnDefault(schema))
+      .map(([name, schema]) => [name, structuredClone(schema.default)]),
+  )
+}
+
+export function normalizeGeneratedJobInput(
+  definition: GeneratedJobDefinition,
+  values: Record<string, unknown>,
+): Record<string, unknown> {
+  const normalized: Record<string, unknown> = {}
+  for (const [name, value] of Object.entries(values)) {
+    const field = definition.input_schema.properties?.[name]
+    if (!field) continue
+    normalized[name] = value
+  }
+  return normalized
+}
+
+function toFormField(
+  name: string,
+  resolved: ResolvedGeneratedField,
+  required: boolean,
+): FormFieldSchema {
+  const { schema, reference } = resolved
+  const validation: NonNullable<FormFieldSchema['validation']> = {}
+  if (required) validation.required = true
+  if (schema.minimum !== undefined) validation.min = schema.minimum
+  if (schema.maximum !== undefined) validation.max = schema.maximum
+  if (schema.minLength !== undefined) validation.minLength = schema.minLength
+  if (schema.maxLength !== undefined) validation.maxLength = schema.maxLength
+
+  const props: Record<string, unknown> = {}
+  if (schema.enum) props.options = [...schema.enum]
+  if (reference === 'path' && schema.type === 'array') props.multiple = true
+  return {
+    name,
+    label: schema.title || humanize(name),
+    type: fieldType(schema, reference),
+    defaultValue: resolved.hasDefault ? structuredClone(resolved.defaultValue) : undefined,
+    hint: schema.description,
+    validation,
+    props,
+  }
+}
+
+function resolveGeneratedField(
+  root: GeneratedJsonSchema,
+  field: GeneratedJsonSchema,
+): ResolvedGeneratedField {
+  const hasDefault = hasOwnDefault(field)
+  const candidate = field.anyOf?.find(item => item.type !== 'null')
+    ?? field.allOf?.[0]
+    ?? field
+  if (candidate.$ref) {
+    const referenceParts = candidate.$ref.split('/')
+    const key = referenceParts[referenceParts.length - 1]
+    const schema = key ? root.$defs?.[key] : undefined
+    if (!schema) throw new Error(`Generated field reference is missing: ${candidate.$ref}`)
+    return {
+      schema: { ...schema, title: field.title ?? schema.title },
+      reference: field['x-mint-component'] ?? schema['x-mint-component'],
+      hasDefault,
+      defaultValue: field.default,
+    }
+  }
+  return {
+    schema: candidate,
+    reference: field['x-mint-component'] ?? candidate['x-mint-component'],
+    hasDefault,
+    defaultValue: field.default,
+  }
+}
+
+function fieldType(schema: GeneratedJsonSchema, reference?: GeneratedReference): FormFieldType {
+  if (reference === 'path') return 'path'
+  if (schema.enum) return 'select'
+  const type = Array.isArray(schema.type) ? schema.type.find(value => value !== 'null') : schema.type
+  if (type === 'boolean') return 'toggle'
+  if (type === 'number' || type === 'integer') return 'number'
+  if (type === 'array') return 'tags'
+  return 'text'
+}
+
+function hasOwnDefault(schema: GeneratedJsonSchema): boolean {
+  return Object.prototype.hasOwnProperty.call(schema, 'default')
+}
+
+function humanize(value: string): string {
+  return value.replace(/[_-]+/g, ' ').replace(/^\w/, character => character.toUpperCase())
+}

package/src/generated-ui/main.ts

@@ -0,0 +1,21 @@
+import { createPinia } from 'pinia'
+import { createApp, h } from 'vue'
+
+import GeneratedPluginView from '../components/GeneratedPluginView.vue'
+import '../styles/index.css'
+
+function generatedApiBase(location: Location): string {
+  const pluginPath = new URL('.', location.href).pathname.replace(/\/$/, '')
+  return `/api${pluginPath}`
+}
+
+const app = createApp({
+  name: 'MintGeneratedUiApp',
+  render: () => h(GeneratedPluginView, {
+    baseUrl: generatedApiBase(window.location),
+    showStandaloneLabel: true,
+  }),
+})
+
+app.use(createPinia())
+app.mount('#app')

package/src/histoire.setup.ts

@@ -0,0 +1,17 @@
+import { defineSetupVue3 } from '@histoire/plugin-vue'
+import { createPinia } from 'pinia'
+import './styles/index.css'
+
+export const setupVue3 = defineSetupVue3(({ app }) => {
+  app.use(createPinia())
+
+  // Sync Histoire dark mode toggle to html.dark class (drives CSS variables)
+  if (typeof window !== 'undefined' && typeof window.matchMedia === 'function') {
+    const mq = window.matchMedia('(prefers-color-scheme: dark)')
+    const sync = (dark: boolean) => {
+      document.documentElement.classList.toggle('dark', dark)
+    }
+    sync(mq.matches)
+    mq.addEventListener('change', (e) => sync(e.matches))
+  }
+})

package/src/index.ts

@@ -0,0 +1,67 @@
+// Styles (import to ensure bundling)
+import './styles/index.css'
+
+// Vue Plugin for global component registration
+export { MINTSdk, default } from './install'
+
+// Components
+export * from './components'
+
+// Composables
+export * from './composables'
+// Resolve names shared by composables and templates so root exports stay unambiguous.
+export {
+  getBioTemplateComponentProps,
+  toBioTemplateComponentPropsByComponent,
+  type ControlDefinition,
+} from './composables'
+
+// Stores
+export * from './stores'
+
+// Permissions
+export * from './permissions'
+
+// Instrument monitoring
+export * from './instrument'
+
+// Job state helpers
+export * from './jobs'
+
+// Experimental generated analysis workspace
+export * from './generated/schema'
+
+// LCMS sequence helpers
+export * from './lcms'
+
+// Utils
+export {
+  hexToHsl,
+  hslToHex,
+  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'
+
+// Types
+export type * from './types'

package/src/install.ts

@@ -0,0 +1,39 @@
+import * as components from './components'
+
+type ComponentRegistryApp = {
+  component: (name: string, component: any) => unknown
+}
+
+export interface MINTSdkPlugin {
+  install(app: ComponentRegistryApp): void
+}
+
+/**
+ * Vue plugin that registers all MINT SDK components globally.
+ *
+ * @example
+ * ```typescript
+ * import { createApp } from 'vue'
+ * import { MINTSdk } from '@morscherlab/mint-sdk'
+ * import '@morscherlab/mint-sdk/styles'
+ *
+ * const app = createApp(App)
+ * app.use(MINTSdk)
+ * ```
+ */
+export const MINTSdk: MINTSdkPlugin = {
+  install(app) {
+    for (const [name, component] of Object.entries(components)) {
+      // Check if it's a valid Vue component (has setup, render, or template)
+      if (
+        component &&
+        typeof component === 'object' &&
+        ('setup' in component || 'render' in component || '__name' in component)
+      ) {
+        app.component(name, component)
+      }
+    }
+  },
+}
+
+export default MINTSdk

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/jobs.ts

@@ -0,0 +1,80 @@
+import type { JobState, JobStateInput, JobStatus } from './types/jobs'
+
+const ACTIVE_JOB_STATUSES = new Set<JobStatus>([
+  'awaiting_input',
+  'queued',
+  'running',
+])
+const TERMINAL_JOB_STATUSES = new Set<JobStatus>([
+  'completed',
+  'failed',
+  'cancelled',
+])
+
+export interface JobCapabilityInput {
+  status: string
+  can_cancel?: boolean | null
+  can_delete?: boolean | null
+}
+
+export interface JobCapabilities {
+  can_cancel: boolean
+  can_delete: boolean
+}
+
+/** Resolve action support while retaining one-cycle legacy status inference. */
+export function resolveJobCapabilities(job: JobCapabilityInput): JobCapabilities {
+  const legacyCanCancel = job.status === 'queued' || job.status === 'running'
+  const legacyCanDelete = TERMINAL_JOB_STATUSES.has(job.status as JobStatus)
+  return {
+    can_cancel: typeof job.can_cancel === 'boolean' ? job.can_cancel : legacyCanCancel,
+    can_delete: typeof job.can_delete === 'boolean' ? job.can_delete : legacyCanDelete,
+  }
+}
+
+/** Clamp invalid or out-of-range progress values for safe display. */
+export function normalizeJobPercent(value: number): number {
+  if (!Number.isFinite(value)) return 0
+  return Math.min(100, Math.max(0, value))
+}
+
+/** Create a detached canonical state without changing the transport input. */
+export function normalizeJobState(job: JobStateInput): JobState {
+  const capabilities = resolveJobCapabilities(job)
+  return {
+    ...job,
+    definition_id: job.definition_id
+      ?? (typeof job.metadata.definition_id === 'string' ? job.metadata.definition_id : null),
+    result_status: job.result_status
+      ?? (job.status === 'completed' && job.metadata.has_result === true ? 'available' : 'none'),
+    result_expires_at: job.result_expires_at ?? null,
+    progress: {
+      ...job.progress,
+      percent: normalizeJobPercent(job.progress.percent),
+    },
+    warnings: [...job.warnings],
+    folders: [...job.folders],
+    metadata: { ...job.metadata },
+    ...capabilities,
+  }
+}
+
+export function isActiveJobStatus(status: JobStatus): boolean {
+  return ACTIVE_JOB_STATUSES.has(status)
+}
+
+export function isTerminalJobStatus(status: JobStatus): boolean {
+  return TERMINAL_JOB_STATUSES.has(status)
+}
+
+export function jobStatusLabel(status: JobStatus): string {
+  const labels: Record<JobStatus, string> = {
+    awaiting_input: 'Waiting for input',
+    queued: 'Queued',
+    running: 'Running',
+    completed: 'Completed',
+    failed: 'Failed',
+    cancelled: 'Cancelled',
+  }
+  return labels[status]
+}

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,144 @@
+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',
+  'notices.publish',
+] 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))
+}