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

package/src/generated/schema.ts

@@ -1,130 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,67 +0,0 @@
-// 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

@@ -1,39 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,144 +0,0 @@
-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))
-}