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

package/src/composables/useResourceCrud.ts

@@ -1,4 +1,5 @@
 import { computed, ref, shallowRef, type ComputedRef, type Ref, type ShallowRef } from 'vue'
+import { readErrorMessage } from '../utils/errors'
 
 export type ResourceKey = string | number
 
@@ -38,7 +39,11 @@ export interface UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey extends Res
   clearError: () => void
 }
 
-/** Common list/create/update/delete state wrapper for generated plugin clients. */
+/**
+ * Common list/create/update/delete state wrapper for generated plugin clients.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useGeneratedPluginClient()` instead.
+ */
 export function useResourceCrud<
   TItem,
   TCreate = Partial<TItem>,
@@ -228,18 +233,3 @@ function resolveKey<TItem, TKey extends ResourceKey>(
   }
   return getKey(keyOrItem as TItem)
 }
-
-function readErrorMessage(value: unknown): string {
-  if (value instanceof Error && value.message) return value.message
-  if (typeof value === 'string' && value.trim()) return value
-  if (
-    typeof value === 'object'
-    && value !== null
-    && 'message' in value
-    && typeof (value as { message?: unknown }).message === 'string'
-    && (value as { message: string }).message.trim()
-  ) {
-    return (value as { message: string }).message
-  }
-  return 'Request failed.'
-}

package/src/composables/useRovingFocus.ts

@@ -0,0 +1,66 @@
+import { nextTick } from 'vue'
+
+export interface UseRovingFocusOptions {
+  /** Selectable item ids, in DOM order. Already excludes items skipped entirely (e.g. disabled tabs). */
+  ids: () => string[]
+  /** The id that is currently active/selected. */
+  activeId: () => string | undefined
+  /** Activates an id (e.g. emit `update:modelValue`). The composable focuses the matching element afterward. */
+  activate: (id: string) => void
+  /** Returns the focusable element for an id, queried lazily so it reflects the post-activation DOM. */
+  getElement: (id: string) => HTMLElement | null | undefined
+  /** Arrow-key axis: `'horizontal'` (Left/Right, default) or `'vertical'` (Up/Down). */
+  orientation?: 'horizontal' | 'vertical'
+}
+
+export interface UseRovingFocusReturn {
+  /** Bind to each item's `@keydown`. */
+  handleKeydown: (event: KeyboardEvent) => void
+}
+
+/**
+ * WAI-ARIA roving-tabindex navigation with automatic activation (the tabs pattern):
+ * Left/Right (or Up/Down when `orientation` is `'vertical'`) move to the adjacent item
+ * and activate it immediately, wrapping past the ends; Home/End jump to the first/last
+ * item. Only the active item should carry `tabindex="0"`; give every other item
+ * `tabindex="-1"`. Used by BaseTabs.
+ */
+export function useRovingFocus(options: UseRovingFocusOptions): UseRovingFocusReturn {
+  const orientation = options.orientation ?? 'horizontal'
+  const prevKey = orientation === 'vertical' ? 'ArrowUp' : 'ArrowLeft'
+  const nextKey = orientation === 'vertical' ? 'ArrowDown' : 'ArrowRight'
+
+  function moveTo(id: string | undefined) {
+    if (id === undefined) return
+    options.activate(id)
+    void nextTick(() => options.getElement(id)?.focus())
+  }
+
+  function handleKeydown(event: KeyboardEvent) {
+    const ids = options.ids()
+    if (ids.length === 0) return
+    const currentIndex = ids.indexOf(options.activeId() ?? '')
+
+    if (event.key === 'Home') {
+      event.preventDefault()
+      moveTo(ids[0])
+      return
+    }
+    if (event.key === 'End') {
+      event.preventDefault()
+      moveTo(ids[ids.length - 1])
+      return
+    }
+    if (event.key === prevKey) {
+      event.preventDefault()
+      moveTo(ids[currentIndex <= 0 ? ids.length - 1 : currentIndex - 1])
+      return
+    }
+    if (event.key === nextKey) {
+      event.preventDefault()
+      moveTo(ids[currentIndex === -1 || currentIndex >= ids.length - 1 ? 0 : currentIndex + 1])
+    }
+  }
+
+  return { handleKeydown }
+}

package/src/composables/useScheduleDrag.ts

@@ -200,6 +200,42 @@ export function useScheduleDrag(options: UseScheduleDragOptions) {
     cleanup()
   }
 
+  /**
+   * Keyboard alternative to the pointer drag: shifts an event by one slot
+   * (`mode: 'move'`) or grows/shrinks its end by one slot (`mode: 'resize'`),
+   * staying inside the visible day. Returns whether the nudge was applied.
+   */
+  function nudgeEvent(
+    event: ScheduleEvent,
+    direction: -1 | 1,
+    mode: 'move' | 'resize' = 'move',
+  ): boolean {
+    if (options.readonly.value) return false
+    if (mode === 'move' && event.draggable === false) return false
+    if (mode === 'resize' && event.resizable === false) return false
+
+    const slotMin = options.slotDuration.value
+    const dayStart = options.dayStartHour.value * 60
+    const dayEnd = options.dayEndHour.value * 60
+    const start = dateToMinutes(new Date(event.start))
+    const end = dateToMinutes(new Date(event.end))
+
+    const nextStart = mode === 'move' ? start + direction * slotMin : start
+    const nextEnd = mode === 'move'
+      ? end + direction * slotMin
+      : Math.max(start + slotMin, end + direction * slotMin)
+
+    if (nextStart < dayStart || nextEnd > dayEnd || nextEnd <= nextStart) return false
+
+    const base = new Date(event.start)
+    const newStart = minutesToDate(base, nextStart)
+    const newEnd = minutesToDate(base, nextEnd)
+
+    if (mode === 'move') options.onMoveComplete?.(event, newStart, newEnd)
+    else options.onResizeComplete?.(event, newStart, newEnd)
+    return true
+  }
+
   function addListeners() {
     document.addEventListener('pointermove', onPointerMove)
     document.addEventListener('pointerup', onPointerUp)
@@ -221,6 +257,7 @@ export function useScheduleDrag(options: UseScheduleDragOptions) {
     startCreate,
     startMove,
     startResize,
+    nudgeEvent,
   }
 }
 

package/src/composables/useWellPainting.ts

@@ -1,5 +1,10 @@
 import { computed, ref, toValue, type ComputedRef, type Ref } from 'vue'
 import type { WellPlateFormat } from '../types'
+import {
+  PLATE_CONFIGS as PLATE_DIMENSIONS,
+  rowIndex as rowLabelToIndex,
+  rowLabel as indexToRowLabel,
+} from '../components/WellPlate.geometry'
 
 export type WellPlateSource<T> = T | Ref<T> | ComputedRef<T> | (() => T)
 
@@ -34,19 +39,12 @@ export interface UseWellPaintingReturn<TMode extends string = string, TPayload =
   cancel: () => void
 }
 
-const ROW_LABELS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
-const PLATE_DIMENSIONS: Record<WellPlateFormat, { rows: number; cols: number }> = {
-  6: { rows: 2, cols: 3 },
-  12: { rows: 3, cols: 4 },
-  24: { rows: 4, cols: 6 },
-  48: { rows: 6, cols: 8 },
-  54: { rows: 6, cols: 9 },
-  96: { rows: 8, cols: 12 },
-  384: { rows: 16, cols: 24 },
-}
-
-/** Pointer painting/rectangle selection state for WellPlate-based editors. */
+/**
+ * Pointer painting/rectangle selection state for WellPlate-based editors.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useWellPlateEditor()` instead.
+ */
 export function useWellPainting<TMode extends string = string, TPayload = unknown>(
   options: UseWellPaintingOptions<TMode, TPayload>,
 ): UseWellPaintingReturn<TMode, TPayload> {
@@ -166,22 +164,4 @@ export function wellIdsInRectangle(
   return ids
 }
 
-function rowLabelToIndex(label: string): number {
-  let result = 0
-  for (const char of label) {
-    result = result * 26 + (char.charCodeAt(0) - 64)
-  }
-  return result - 1
-}
 
-function indexToRowLabel(index: number): string {
-  if (index < ROW_LABELS.length) return ROW_LABELS[index]
-  let value = index + 1
-  let label = ''
-  while (value > 0) {
-    value--
-    label = ROW_LABELS[value % 26] + label
-    value = Math.floor(value / 26)
-  }
-  return label
-}

package/src/composables/useWellPlateAdapter.ts

@@ -28,7 +28,11 @@ export interface UseWellPlateAdapterReturn {
   wells: ComputedRef<Record<string, Partial<Well>>>
 }
 
-/** Convert domain rows into WellPlate's wells prop without hand-written adapters. */
+/**
+ * Convert domain rows into WellPlate's wells prop without hand-written adapters.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useWellPlateEditor()` instead.
+ */
 export function useWellPlateAdapter<TEntry>(
   options: WellPlateAdapterOptions<TEntry>,
 ): UseWellPlateAdapterReturn {

package/src/composables/useWellPlateEditor.ts

@@ -5,18 +5,8 @@ import type {
   SampleType,
   WellPlateFormat,
 } from '../types'
+import { SAMPLE_COLOR_SCALE as DEFAULT_PALETTE } from '../utils/color'
 
-const DEFAULT_PALETTE = [
-  '#3B82F6', // blue
-  '#10B981', // green
-  '#EF4444', // red
-  '#F59E0B', // amber
-  '#8B5CF6', // purple
-  '#F97316', // orange
-  '#06B6D4', // cyan
-  '#14B8A6', // teal
-  '#6B7280', // gray
-]
 
 const MAX_HISTORY = 50
 

package/src/composables/useWellPlateValidation.ts

@@ -33,7 +33,11 @@ export interface UseWellPlateValidationReturn<TType extends string = string> {
   errorCount: ComputedRef<number>
 }
 
-/** Rule-driven validation state for WellPlate layout/design screens. */
+/**
+ * Rule-driven validation state for WellPlate layout/design screens.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useWellPlateEditor()` instead.
+ */
 export function useWellPlateValidation<TContext, TType extends string = string>(
   options: UseWellPlateValidationOptions<TContext, TType>,
 ): UseWellPlateValidationReturn<TType> {

package/src/composables/workspaceRecipes.ts

@@ -0,0 +1,267 @@
+import type { TopBarVariant } from '../types'
+import type { FormEnhancements } from '../types/form-builder'
+import type {
+  ControlModel,
+  ControlModelBinding,
+  ControlSchema,
+  ControlWorkspaceOptions,
+  UseControlWorkspaceReturn,
+} from './useControlSchema'
+import { mergeControlWorkspaceOptions, resolveControlModel } from './useControlSchema'
+
+/**
+ * Merges `initialValues`/external `modelValue`/`values` on top of a base
+ * `ControlWorkspaceOptions.initialValues`, matching the layering FormBuilder expects: base
+ * defaults, then caller-supplied initial values, then live external values win last. Shared by
+ * {@link controlWorkspaceProps} and {@link bioTemplatePresetWorkspaceProps} so both "generate a
+ * workspace from options, initialValues, and v-model" views merge options identically.
+ */
+export function resolveControlOptionsWithExternalValues<TOptions extends ControlWorkspaceOptions>(
+  base: TOptions,
+  initialValues: Record<string, unknown> | undefined,
+  externalValues: Record<string, unknown> | undefined,
+): TOptions {
+  if (initialValues === undefined && externalValues === undefined) return base
+
+  return {
+    ...base,
+    initialValues: {
+      ...(base.initialValues ?? {}),
+      ...(initialValues ?? {}),
+      ...(externalValues ?? {}),
+    },
+  }
+}
+
+export interface ControlWorkspaceModelProps {
+  model?: ControlModel | ControlModelBinding
+  controls?: ControlSchema
+  controlOptions?: ControlWorkspaceOptions
+  initialValues?: Record<string, unknown>
+  modelValue?: Record<string, unknown>
+  values?: Record<string, unknown>
+}
+
+export interface ResolvedControlWorkspaceModel {
+  /** `modelValue` if provided, else `values` — the single external v-model source of truth. */
+  externalValues: Record<string, unknown> | undefined
+  /** `model` resolved through `resolveControlModel()`, or undefined for a raw `controls` schema. */
+  resolvedModel: ControlModelBinding | undefined
+  /** `controls` if provided, else the resolved model's controls, else `{}`. */
+  resolvedControls: ControlSchema
+  /** `controlOptions` merged over the resolved model's own options, with initialValues/external values layered on top. */
+  resolvedControlOptions: ControlWorkspaceOptions
+}
+
+/**
+ * Resolves ControlWorkspaceView's `model`/`controls`/`controlOptions`/`initialValues`/
+ * `modelValue`/`values` props into the schema + options pair `useControlWorkspace()` needs.
+ * Pure and framework-free so callers wrap each field in their own `computed()`.
+ *
+ * @example Recommended
+ * ```ts
+ * const resolved = computed(() => controlWorkspaceProps(props))
+ * const resolvedControls = computed(() => resolved.value.resolvedControls)
+ * ```
+ */
+export function controlWorkspaceProps(props: ControlWorkspaceModelProps): ResolvedControlWorkspaceModel {
+  const externalValues = props.modelValue ?? props.values
+  const resolvedModel = resolveControlModel(props.model)
+  const resolvedControls: ControlSchema = props.controls ?? resolvedModel?.controls ?? {}
+  const baseControlOptions = mergeControlWorkspaceOptions(resolvedModel?.controlOptions, props.controlOptions)
+  const resolvedControlOptions = resolveControlOptionsWithExternalValues(
+    baseControlOptions,
+    props.initialValues,
+    externalValues,
+  )
+
+  return { externalValues, resolvedModel, resolvedControls, resolvedControlOptions }
+}
+
+export interface DoseDesignWorkspacePassthroughProps {
+  workspace?: UseControlWorkspaceReturn<ControlSchema>
+  controlOptions?: ControlWorkspaceOptions
+  initialValues?: Record<string, unknown>
+  modelValue?: Record<string, unknown>
+  values?: Record<string, unknown>
+  title?: string
+  subtitle?: string
+  topBarVariant?: TopBarVariant
+  sidebarWidth?: string
+  sidebarVariant?: 'default' | 'analysis'
+  responsiveSidebar?: boolean
+  sidebarPosition?: 'left' | 'right'
+  sidebarTitle?: string
+  sidebarSubtitle?: string
+  sidebarBadge?: string | number
+  floating?: boolean
+  dense?: boolean
+  showSettings?: boolean
+  showFormActions?: boolean
+  formEnhancements?: FormEnhancements<Record<string, unknown>>
+  formLoading?: boolean
+  formDisabled?: boolean
+  formReadonly?: boolean
+  formSize?: 'sm' | 'md' | 'lg'
+}
+
+/**
+ * Maps DoseDesignWorkspaceView's props straight through to the identically-named
+ * ControlWorkspaceView props it wraps — the ~25-key pass-through list that used to be spelled
+ * out attribute-by-attribute in the template. `model` is the caller's already-resolved dose
+ * design model, not the raw (possibly absent) `props.model`.
+ *
+ * @example Recommended
+ * ```vue
+ * <ControlWorkspaceView v-bind="doseDesignWorkspaceProps(props, resolvedModel)" />
+ * ```
+ */
+export function doseDesignWorkspaceProps(
+  props: DoseDesignWorkspacePassthroughProps,
+  model: ControlModel | ControlModelBinding,
+) {
+  return {
+    model,
+    workspace: props.workspace,
+    controlOptions: props.controlOptions,
+    initialValues: props.initialValues,
+    modelValue: props.modelValue,
+    values: props.values,
+    title: props.title,
+    subtitle: props.subtitle,
+    topBarVariant: props.topBarVariant,
+    sidebarWidth: props.sidebarWidth,
+    sidebarVariant: props.sidebarVariant,
+    responsiveSidebar: props.responsiveSidebar,
+    sidebarPosition: props.sidebarPosition,
+    sidebarTitle: props.sidebarTitle,
+    sidebarSubtitle: props.sidebarSubtitle,
+    sidebarBadge: props.sidebarBadge,
+    floating: props.floating,
+    dense: props.dense,
+    showSettings: props.showSettings,
+    showFormActions: props.showFormActions,
+    formEnhancements: props.formEnhancements,
+    formLoading: props.formLoading,
+    formDisabled: props.formDisabled,
+    formReadonly: props.formReadonly,
+    formSize: props.formSize,
+  }
+}
+
+export interface BioTemplateExperimentWorkspaceStatusProps {
+  status?: {
+    loading?: boolean
+    saving?: boolean
+    error?: string | null
+    hasExperiment?: boolean
+    currentExperimentId?: number
+    lastLoadedAt?: Date | null
+    lastSavedAt?: Date | null
+  }
+  loading?: boolean
+  error?: string | null
+  hasExperiment?: boolean
+  currentExperimentId?: number
+  lastLoadedAt?: Date | null
+  lastSavedAt?: Date | null
+}
+
+export interface ResolvedBioTemplateExperimentStatus {
+  loading: boolean
+  error: string | null | undefined
+  hasExperiment: boolean
+  currentExperimentId: number | undefined
+  lastLoadedAt: Date | null | undefined
+  lastSavedAt: Date | null | undefined
+}
+
+/**
+ * Merges BioTemplateExperimentWorkspaceView's grouped `status` prop over its individual
+ * `loading`/`error`/`hasExperiment`/... props: `status` wins whenever the corresponding field
+ * on it is set, otherwise the flat prop (or its default) is used. Centralizes the six
+ * independent fallback rules generated plugin pages rely on when they pass a request/experiment
+ * `status` object instead of wiring each field by hand.
+ */
+export function bioTemplateExperimentWorkspaceProps(
+  props: BioTemplateExperimentWorkspaceStatusProps,
+): ResolvedBioTemplateExperimentStatus {
+  const status = props.status
+  return {
+    loading: status?.loading !== undefined || status?.saving !== undefined
+      ? Boolean(status?.loading) || Boolean(status?.saving)
+      : Boolean(props.loading),
+    error: status?.error !== undefined ? status.error : props.error,
+    hasExperiment: status?.hasExperiment ?? props.hasExperiment ?? false,
+    currentExperimentId: status?.currentExperimentId ?? props.currentExperimentId,
+    lastLoadedAt: status?.lastLoadedAt !== undefined ? status.lastLoadedAt : props.lastLoadedAt,
+    lastSavedAt: status?.lastSavedAt !== undefined ? status.lastSavedAt : props.lastSavedAt,
+  }
+}
+
+export interface BioTemplatePackWorkspacePassthroughProps {
+  message?: string
+  dense?: boolean
+  readonly?: boolean
+  showStatus?: boolean
+  showTemplateSummary?: boolean
+  loadLabel?: string
+  resetLabel?: string
+  saveLabel?: string
+}
+
+/**
+ * Assembles the prop object BioTemplatePackWorkspaceView binds onto the
+ * BioTemplateExperimentWorkspaceView it wraps: its own display props passed straight through,
+ * plus the pack-derived `target`/`label`/`status`/`actions` computed by the caller.
+ */
+export function bioTemplatePackWorkspaceProps<TTarget, TStatus, TActions>(
+  props: BioTemplatePackWorkspacePassthroughProps,
+  derived: {
+    target: TTarget
+    label: string
+    status: TStatus
+    actions: TActions
+  },
+) {
+  return {
+    target: derived.target,
+    kind: 'collection' as const,
+    label: derived.label,
+    message: props.message,
+    status: derived.status,
+    actions: derived.actions,
+    dense: props.dense,
+    readonly: props.readonly,
+    showStatus: props.showStatus,
+    showTemplateSummary: props.showTemplateSummary,
+    loadLabel: props.loadLabel,
+    resetLabel: props.resetLabel,
+    saveLabel: props.saveLabel,
+  }
+}
+
+export interface BioTemplatePresetWorkspaceOptionsProps<TOptions extends ControlWorkspaceOptions> {
+  workspaceOptions?: TOptions
+  initialValues?: Record<string, unknown>
+  modelValue?: Record<string, unknown>
+  values?: Record<string, unknown>
+}
+
+/**
+ * Resolves BioTemplatePresetWorkspaceView's `workspaceOptions`/`initialValues`/`modelValue`/
+ * `values` props into the single options object `useBioTemplatePresetWorkspace()` needs,
+ * reusing the same base/initialValues/external-values layering as {@link controlWorkspaceProps}.
+ */
+export function bioTemplatePresetWorkspaceProps<TOptions extends ControlWorkspaceOptions>(
+  props: BioTemplatePresetWorkspaceOptionsProps<TOptions>,
+): { externalValues: Record<string, unknown> | undefined; resolvedWorkspaceOptions: TOptions } {
+  const externalValues = props.modelValue ?? props.values
+  const resolvedWorkspaceOptions = resolveControlOptionsWithExternalValues(
+    (props.workspaceOptions ?? {}) as TOptions,
+    props.initialValues,
+    externalValues,
+  )
+
+  return { externalValues, resolvedWorkspaceOptions }
+}

package/src/index.ts

@@ -41,6 +41,22 @@ export {
   deriveShade,
   type Hsl,
 } from './utils/color'
+export {
+  PLUGIN_SECRET_FORMAT_KEY,
+  PLUGIN_SECRET_FORMAT_REF,
+  PLUGIN_SECRET_REF_KEY,
+  clearPluginSecret,
+  isPluginSecretLocked,
+  isPluginSecretRef,
+  keepPluginSecret,
+  pluginSecretId,
+  pluginSecretLabel,
+  pluginSecretState,
+  setPluginSecret,
+  usesPluginSecretReferences,
+  type PluginSecretRef,
+  type PluginSecretState,
+} from './utils/pluginSecrets'
 export {
   LCMS_DEFAULT_CONTROL_POSITIONS,
   createLcmsControlWellEditData,

package/src/permissions.ts

@@ -2,7 +2,6 @@ export const ADMIN_ROLE = 'admin'
 
 export const ADMIN_PANEL_PERMISSIONS = [
   'users.view',
-  'users.invite',
   'users.manage',
   'platform.configure',
   'platform.view_logs',
@@ -41,11 +40,36 @@ export interface AccessPolicy {
   plugin?: string
 }
 
+/**
+ * An object that carries an access rule.
+ *
+ * The nested `access` policy is the supported shape. The four flat fields are
+ * the pre-1.2 spelling of the same four `AccessPolicy` fields; they still work
+ * but are deprecated, and `normalizeAccessPolicy()` lets the nested policy win
+ * wherever both are given.
+ */
 export interface AccessControlled {
+  /** The access policy. Preferred over the flat fields below. */
   access?: AccessPolicy
+  /**
+   * @deprecated Since MINT 1.2; use `access.visibleFor` instead. The flat
+   * duplicate is removed in 1.3.
+   */
   visibleFor?: AccessAudienceInput
+  /**
+   * @deprecated Since MINT 1.2; use `access.requiresAdmin` instead. The flat
+   * duplicate is removed in 1.3.
+   */
   requiresAdmin?: boolean
+  /**
+   * @deprecated Since MINT 1.2; use `access.permissions` instead. The flat
+   * duplicate is removed in 1.3.
+   */
   permissions?: readonly string[]
+  /**
+   * @deprecated Since MINT 1.2; use `access.anyPermissions` instead. The flat
+   * duplicate is removed in 1.3.
+   */
   anyPermissions?: readonly string[]
 }
 
@@ -105,17 +129,32 @@ export function canAccessPlugin(
   return Array.isArray(access) && access.includes(pluginName)
 }
 
+/**
+ * Flatten an access rule — either shape, or a mix of both — into one policy.
+ *
+ * ## Precedence
+ *
+ * 1. A defined field on the nested `access` policy wins. It is the supported
+ *    spelling, so an object that carries both shapes is read as "the nested
+ *    policy, with the deprecated flat fields as leftovers".
+ * 2. Otherwise the flat field on the rule itself is used.
+ * 3. A field set to `undefined` on either side counts as unset and never
+ *    masks the other side.
+ *
+ * Only `AccessPolicy` fields the flat shape never had (`audience`,
+ * `requiresAuth`, `plugin`) can come from the nested policy alone; the four
+ * duplicated fields are the ones this ordering exists for.
+ */
 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 } : {}),
+  const { access: nested, ...flat } = rule as AccessPolicy & { access?: AccessPolicy }
+  const policy = { ...flat } as Record<string, unknown>
+
+  for (const [field, value] of Object.entries(nested ?? {})) {
+    if (value !== undefined) policy[field] = value
   }
+
+  return policy as AccessPolicy
 }
 
 export function canAccessByPolicy(

package/src/stores/auth.ts

@@ -58,6 +58,7 @@ export const useAuthStore = defineStore('mint-auth', () => {
     passkeyEnabled: false,
     passkeyRegistered: false,
     registrationEnabled: false,
+    databaseMode: 'none',
     experimentVisibilityMode: 'open',
   })
   const isInitialized = ref(false)

package/src/stores/experiment.ts

@@ -1,6 +1,7 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
 import { useApi } from '../composables/useApi'
+import { readErrorMessage } from '../utils/errors'
 import type { ExperimentSummary, PlatformContext } from '../types'
 
 function getPlatformApiUrl(): string | undefined {
@@ -9,12 +10,6 @@ function getPlatformApiUrl(): string | undefined {
     ?.platformApiUrl
 }
 
-function readErrorMessage(value: unknown): string {
-  if (value instanceof Error && value.message) return value.message
-  if (typeof value === 'string' && value.trim()) return value
-  return 'Failed to load experiment'
-}
-
 /**
  * The single source of truth for the experiment a plugin is currently working on.
  *
@@ -89,7 +84,7 @@ export const useExperimentStore = defineStore('mint-experiment', () => {
     } catch (err) {
       if (token !== selectionToken) return null
       current.value = null
-      error.value = readErrorMessage(err)
+      error.value = readErrorMessage(err, 'Failed to load experiment')
       return null
     } finally {
       // Only the newest request owns the loading flag; otherwise a superseded