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

package/dist/composables/useBioTemplateWorkspace.d.ts

@@ -1,28 +1,21 @@
 import { BioTemplateEnvelope, TemplateCollectionEnvelope } from '../templates';
 import { ControlWorkspaceFormBinding, ControlWorkspaceOptions, ControlWorkspacePillNavBinding, ControlWorkspaceSidebarBinding, ControlWorkspaceTopBarSettingsBinding, UseControlSchemaReturn, UseControlWorkspaceReturn } from './controlSchemaTypes';
 import { BioTemplateControlSchema, BioTemplateControlTarget } from './useBioTemplateControls';
-import { BioTemplateComponentBinding, BioTemplateComponentBindingsById, BioTemplateComponentImport, BioTemplateComponentPropsByComponent, BioTemplateComponentPropsBinding, BioTemplateComponentPropsById, BioTemplateComponentSnippet, BioTemplateComponentUsage, UseBioTemplateComponentsReturn } from './useBioTemplateComponents';
+import { UseBioTemplateComponentsReturn } from './useBioTemplateComponents';
+import { BioTemplateWorkspaceComponentBindings } from './flattenWorkspaceBindings';
 export type BioTemplateWorkspaceTarget = BioTemplateControlTarget;
 export interface BioTemplateRendererBinding {
     target: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope;
 }
-export interface BioTemplateWorkspaceBindings {
+export interface BioTemplateWorkspaceBindings extends BioTemplateWorkspaceComponentBindings {
     renderer: BioTemplateRendererBinding | null;
     form: ControlWorkspaceFormBinding;
     sidebar: ControlWorkspaceSidebarBinding;
     topBar: UseControlWorkspaceReturn<BioTemplateControlSchema>['bindings']['topBar'];
     topBarSettings: ControlWorkspaceTopBarSettingsBinding;
     pillNav: ControlWorkspacePillNavBinding;
-    componentBindings: BioTemplateComponentBinding[];
-    componentBindingsById: BioTemplateComponentBindingsById;
-    componentProps: BioTemplateComponentPropsBinding[];
-    componentPropsById: BioTemplateComponentPropsById;
-    componentPropsByComponent: BioTemplateComponentPropsByComponent;
-    componentSnippets: BioTemplateComponentSnippet[];
-    componentUsage: BioTemplateComponentUsage | null;
-    getComponentProps: UseBioTemplateComponentsReturn['getComponentProps'];
 }
-export interface UseBioTemplateWorkspaceReturn {
+export interface UseBioTemplateWorkspaceReturn extends BioTemplateWorkspaceComponentBindings {
     target: BioTemplateWorkspaceTarget;
     controls: UseControlSchemaReturn<BioTemplateControlSchema>;
     workspace: UseControlWorkspaceReturn<BioTemplateControlSchema>;
@@ -37,15 +30,6 @@ export interface UseBioTemplateWorkspaceReturn {
     topBarSettings: ControlWorkspaceTopBarSettingsBinding;
     bindings: BioTemplateWorkspaceBindings;
     renderer: BioTemplateRendererBinding | null;
-    componentBindings: BioTemplateComponentBinding[];
-    componentBindingsById: BioTemplateComponentBindingsById;
-    componentImports: BioTemplateComponentImport[];
-    componentProps: BioTemplateComponentPropsBinding[];
-    componentPropsById: BioTemplateComponentPropsById;
-    componentPropsByComponent: BioTemplateComponentPropsByComponent;
-    componentSnippets: BioTemplateComponentSnippet[];
-    componentUsage: BioTemplateComponentUsage | null;
-    getComponentProps: UseBioTemplateComponentsReturn['getComponentProps'];
 }
 /** One-stop wiring for BioTemplateRenderer, FormBuilder, AppSidebar, and template-aware SDK components. */
 export declare function useBioTemplateWorkspace(target: BioTemplateWorkspaceTarget, options?: ControlWorkspaceOptions): UseBioTemplateWorkspaceReturn;

package/dist/composables/useCommandHistory.d.ts

@@ -0,0 +1,33 @@
+import { ComputedRef, Ref } from 'vue';
+export type CommandHistoryResult = void | Promise<void>;
+export interface CommandHistoryCommand {
+    execute: () => CommandHistoryResult;
+    undo: () => CommandHistoryResult;
+    redo?: () => CommandHistoryResult;
+    description?: string;
+}
+export interface CommandHistoryExecuteOptions {
+    skipExecute?: boolean;
+}
+export interface UseCommandHistoryOptions {
+    maxDepth?: number;
+}
+export interface UseCommandHistoryReturn<TCommand extends CommandHistoryCommand = CommandHistoryCommand> {
+    undoStack: Ref<TCommand[]>;
+    redoStack: Ref<TCommand[]>;
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+    undoDescription: ComputedRef<string>;
+    redoDescription: ComputedRef<string>;
+    execute: (command: TCommand, options?: CommandHistoryExecuteOptions) => CommandHistoryResult;
+    push: (command: TCommand) => void;
+    undo: () => CommandHistoryResult;
+    redo: () => CommandHistoryResult;
+    clear: () => void;
+}
+/**
+ * Generic command-stack state for plugin editors with undo/redo controls.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; keep command stacks plugin-local.
+ */
+export declare function useCommandHistory<TCommand extends CommandHistoryCommand = CommandHistoryCommand>(options?: UseCommandHistoryOptions): UseCommandHistoryReturn<TCommand>;

package/dist/composables/useFocusTrap.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from 'vue';
+export interface UseFocusTrapOptions {
+    /** Ref to the trap's container element. Focusable elements are queried within it. */
+    containerRef: Ref<HTMLElement | null>;
+    /** Reactive flag — the trap activates when this becomes `true` and releases when it becomes `false`. */
+    active: Ref<boolean>;
+    /** Restore focus to the element that was focused before activation, when the trap releases. Default `true`. */
+    restoreFocus?: boolean;
+}
+export interface UseFocusTrapReturn {
+    /** Focusable descendants of the container, in DOM order, excluding roving-tabindex (`tabindex="-1"`) elements. */
+    getFocusableElements: () => HTMLElement[];
+}
+/**
+ * Traps Tab focus within a container while `active` is true: Tab wraps from the last
+ * focusable element back to the first (and Shift+Tab from the first to the last), the
+ * first focusable element (or the container itself, if none) receives focus when the
+ * trap activates, and focus returns to whatever was focused beforehand when it releases.
+ * Used by BaseModal and WellEditPopupInternal.
+ */
+export declare function useFocusTrap(options: UseFocusTrapOptions): UseFocusTrapReturn;

package/dist/composables/useGeneratedAnalysis.d.ts

@@ -1,5 +1,5 @@
 import { ComputedRef, Ref, ShallowRef } from 'vue';
-import { PluginJobCenterSource } from './useJobsStatusTray';
+import { JobsStatusTrayAdapter, PluginJobCenterSource } from './useJobsStatusTray';
 import { GeneratedAnalysisJob, GeneratedAnalysisResult, GeneratedSession, GeneratedAnalysisManifest, PluginJobPathInput, PluginJobPathUpload, PluginJobStagedPartInput, PluginJobStagedPartUploadResult, PluginJobStaging, PluginJobStagingPagination } from '../types/generated-ui';
 export type GeneratedAnalysisTransport = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 export interface GeneratedAnalysisTransportOptions {
@@ -34,6 +34,7 @@ export interface UsePluginJobsReturn extends PluginJobCenterSource {
     error: ShallowRef<string | null>;
     status: ShallowRef<'idle' | 'initializing' | 'ready' | 'paused' | 'error' | 'disposed'>;
     initialize: () => Promise<void>;
+    ready: () => Promise<void>;
     uploadPath: (input: PluginJobPathInput, definitionId?: string) => Promise<PluginJobPathUpload>;
     uploadStagedPart: <Metadata>(input: PluginJobStagedPartInput<Metadata>) => Promise<PluginJobStagedPartUploadResult<Metadata>>;
     getJobStaging: <Metadata = unknown>(job: GeneratedAnalysisJob | string, pagination?: PluginJobStagingPagination) => Promise<PluginJobStaging<Metadata>>;
@@ -42,6 +43,7 @@ export interface UsePluginJobsReturn extends PluginJobCenterSource {
     loadResult: (job: GeneratedAnalysisJob) => Promise<GeneratedAnalysisResult | null>;
     resultForJob: (jobId: string) => GeneratedAnalysisResult | null;
     refreshJobs: () => Promise<GeneratedAnalysisJob[]>;
+    refresh: () => Promise<GeneratedAnalysisJob[]>;
     getJob: (jobId: string, options?: PluginJobRequestOptions) => Promise<GeneratedAnalysisJob>;
     waitForJob: (job: GeneratedAnalysisJob | string, options?: PluginJobWaitOptions) => Promise<GeneratedAnalysisJob>;
     jobsFor: (definitionId: string) => GeneratedAnalysisJob[];
@@ -51,6 +53,8 @@ export interface UsePluginJobsReturn extends PluginJobCenterSource {
     pause: () => void;
     resume: () => void;
     dispose: () => void;
+    /** @deprecated Pass the runtime itself to SDK job UI as its source. */
+    jobsAdapter: JobsStatusTrayAdapter;
 }
 export type UseGeneratedAnalysisReturn = UsePluginJobsReturn;
 export declare function createGeneratedAnalysisTransport(options?: GeneratedAnalysisTransportOptions): GeneratedAnalysisTransport;

package/dist/composables/useGroupAssignment.d.ts

@@ -0,0 +1,31 @@
+import { ComputedRef, Ref } from 'vue';
+import { GroupItem } from '../types';
+export type GroupAssignmentZone = 'zone1' | 'zone2';
+export type GroupAssignmentSource<T> = T | Ref<T> | ComputedRef<T> | (() => T);
+export interface GroupAssignmentState {
+    group1: string[];
+    group2: string[];
+}
+export interface UseGroupAssignmentOptions {
+    groups: GroupAssignmentSource<readonly GroupItem[]>;
+    group1: GroupAssignmentSource<readonly string[]>;
+    group2: GroupAssignmentSource<readonly string[]>;
+    label1?: GroupAssignmentSource<string | null | undefined>;
+    label2?: GroupAssignmentSource<string | null | undefined>;
+    minPerGroup?: GroupAssignmentSource<number | null | undefined>;
+}
+export interface UseGroupAssignmentReturn {
+    unassignedGroups: ComputedRef<GroupItem[]>;
+    zone1Groups: ComputedRef<GroupItem[]>;
+    zone2Groups: ComputedRef<GroupItem[]>;
+    zone1Count: ComputedRef<number>;
+    zone2Count: ComputedRef<number>;
+    isValid: ComputedRef<boolean>;
+    validationMessage: ComputedRef<string | null>;
+    getZoneForGroup: (groupName: string) => GroupAssignmentZone | null;
+    assignToZone: (groupName: string, zone: GroupAssignmentZone) => GroupAssignmentState;
+    removeFromZone: (groupName: string, zone: GroupAssignmentZone) => GroupAssignmentState;
+    clearAll: () => GroupAssignmentState;
+}
+/** Shared two-zone group assignment model for control/treatment style workflows. */
+export declare function useGroupAssignment(options: UseGroupAssignmentOptions): UseGroupAssignmentReturn;

package/dist/composables/useJobsStatusTray.d.ts

@@ -1,5 +1,6 @@
 import { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
-import { JobState } from '../types/jobs';
+import { JobListPayload, JobState, JobStateInput, JobStreamData } from '../types/jobs';
+import { UsePluginEventStreamReturn } from './usePluginClient';
 export type JobsStatusTrayTab = 'active' | 'history';
 /**
  * The canonical owner of a collection of plugin jobs.
@@ -8,14 +9,46 @@ export type JobsStatusTrayTab = 'active' | 'history';
  * mutations. This keeps components and consumers on one reactive job graph.
  */
 export interface PluginJobCenterSource {
-    jobs: MaybeRefOrGetter<readonly JobState[]>;
-    refreshJobs?: () => Promise<readonly JobState[] | void>;
-    cancelJob?: (jobId: string) => Promise<JobState | void>;
+    jobs: MaybeRefOrGetter<readonly JobStateInput[]>;
+    refreshJobs?: () => Promise<JobListPayload | readonly JobStateInput[] | void>;
+    cancelJob?: (jobId: string) => Promise<JobStateInput | void>;
     deleteJob?: (jobId: string) => Promise<boolean | void>;
     clearFinishedJobs?: () => Promise<number | void>;
+    dispose?: () => void;
+}
+export interface CombinedPluginJobCenterSource extends PluginJobCenterSource {
+    jobs: ComputedRef<readonly JobStateInput[]>;
+}
+/**
+ * Combines independent job runtimes without copying their reactive state.
+ *
+ * Job ids must be globally unique across the sources. A duplicate id throws
+ * when jobs are read or an id-routed action is requested, rather than silently
+ * dispatching a mutation to the wrong owner.
+ */
+export declare function combinePluginJobSources(sources: readonly PluginJobCenterSource[]): CombinedPluginJobCenterSource;
+/** @deprecated Prefer a {@link PluginJobCenterSource}. */
+export interface JobsStatusTrayAdapter {
+    listJobs?: () => Promise<JobListPayload | readonly JobStateInput[]>;
+    cancelJob?: (job: JobState) => Promise<JobStateInput | void>;
+    deleteJob?: (job: JobState) => Promise<boolean | void>;
+    clearFinishedJobs?: (jobs: readonly JobState[]) => Promise<number | void>;
 }
 export interface UsePluginJobCenterOptions {
     source?: MaybeRefOrGetter<PluginJobCenterSource | undefined>;
+    /** @deprecated Pass a source with its canonical jobs ref. */
+    jobs?: MaybeRefOrGetter<readonly JobStateInput[] | undefined>;
+    /** @deprecated Pass source actions instead. */
+    adapter?: MaybeRefOrGetter<JobsStatusTrayAdapter | undefined>;
+    /** @deprecated Event handling belongs to the source runtime. */
+    eventStream?: MaybeRefOrGetter<UsePluginEventStreamReturn<JobStreamData> | undefined>;
+    loadOnMount?: boolean;
+}
+export interface UseJobsStatusTrayOptions extends UsePluginJobCenterOptions {
+}
+export interface JobStreamMessage {
+    event: string;
+    data: JobStreamData;
 }
 export interface UsePluginJobCenterReturn {
     jobs: ComputedRef<JobState[]>;
@@ -36,11 +69,13 @@ export interface UsePluginJobCenterReturn {
     close: () => void;
     toggle: () => void;
     refresh: () => Promise<boolean>;
+    applyStreamMessage: (message: JobStreamMessage) => void;
     cancelJob: (job: JobState) => Promise<boolean>;
     deleteJob: (job: JobState) => Promise<boolean>;
     clearFinished: () => Promise<boolean>;
     isPending: (job: JobState) => boolean;
 }
+export type UseJobsStatusTrayReturn = UsePluginJobCenterReturn;
 /**
  * Headless controller for plugin job presentation and actions.
  *
@@ -48,3 +83,5 @@ export interface UsePluginJobCenterReturn {
  * source. The controller never mirrors source jobs into another ref.
  */
 export declare function usePluginJobCenter(options?: UsePluginJobCenterOptions): UsePluginJobCenterReturn;
+/** @deprecated Use `usePluginJobCenter()` for the plugin job-center controller. */
+export declare function useJobsStatusTray(options?: UseJobsStatusTrayOptions): UseJobsStatusTrayReturn;

package/dist/composables/useMenuKeyboard.d.ts

@@ -0,0 +1,29 @@
+export interface UseMenuKeyboardOptions {
+    /** Returns the currently navigable items inside the open panel, in DOM order. */
+    items: () => HTMLElement[];
+    /** True while the panel is open. */
+    isOpen: () => boolean;
+    /** Opens the panel. */
+    open: () => void;
+    /** Closes the panel. When `returnFocus` is true, focus should return to the trigger. */
+    close: (returnFocus?: boolean) => void;
+}
+export interface UseMenuKeyboardReturn {
+    /**
+     * Bind to the trigger's `@keydown`. ArrowDown/Enter/Space open the panel (when
+     * closed) and focus its first item; ArrowUp opens it focused on the last item.
+     */
+    handleTriggerKeydown: (event: KeyboardEvent) => void;
+    /**
+     * Bind to the open panel's `@keydown`. ArrowUp/ArrowDown cycle focus with
+     * wraparound, Home/End jump to the first/last item, Escape closes and returns
+     * focus to the trigger, and Tab closes without moving focus.
+     */
+    handlePanelKeydown: (event: KeyboardEvent) => void;
+}
+/**
+ * Shared keyboard contract for menu- and listbox-style disclosure panels (the
+ * WAI-ARIA menu button pattern). Used by AppAvatarMenu and DropdownButton; ActionMenu
+ * implements the same contract inline.
+ */
+export declare function useMenuKeyboard(options: UseMenuKeyboardOptions): UseMenuKeyboardReturn;

package/dist/composables/useOptimisticMutation.d.ts

@@ -24,5 +24,9 @@ export interface UseOptimisticMutationReturn<TVariables, TData, TSnapshot = unkn
     clearError: () => void;
     reset: () => void;
 }
-/** Run async mutations with optional optimistic local updates and rollback. */
+/**
+ * Run async mutations with optional optimistic local updates and rollback.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useRequestSyncState()` instead.
+ */
 export declare function useOptimisticMutation<TVariables, TData, TSnapshot = unknown>(options: UseOptimisticMutationOptions<TVariables, TData, TSnapshot>): UseOptimisticMutationReturn<TVariables, TData, TSnapshot>;

package/dist/composables/usePluginClient.d.ts

@@ -133,6 +133,8 @@ export interface UsePluginSettingsReturn<TSettings = Record<string, unknown>> {
     settings: ComputedRef<PluginSettingsValues<TSettings>>;
     /** Editable settings values for SettingsModal. */
     values: Ref<PluginSettingsValues<TSettings>>;
+    /** Alias for values, kept for callers that think in platform config terms. */
+    config: Ref<PluginSettingsValues<TSettings>>;
     /** Ready-to-pass AppTopBar/PluginWorkspaceView settingsConfig. */
     settingsConfig: ComputedRef<TopBarSettingsConfig>;
     isLoading: Ref<boolean>;
@@ -207,6 +209,8 @@ export declare function createPluginClient<TClient extends object = GeneratedPlu
 export declare function uploadPluginEndpoint<TResponse = unknown>(contract: PluginContract, endpoint: PluginEndpointDefinition, payload?: unknown, options?: PluginEndpointRequestOptions): Promise<TResponse>;
 /** Fetch a generated plugin endpoint as a Blob and optionally trigger a browser download. */
 export declare function downloadPluginEndpoint(contract: PluginContract, endpoint: PluginEndpointDefinition, payload?: unknown, options?: DownloadPluginEndpointOptions): Promise<Blob>;
+/** @deprecated Use `useGeneratedPluginClient()` for generated clients. */
+export declare function usePluginClient<TClient>(client: TClient): TClient;
 /** Load, edit, and persist plugin settings from platform config or the plugin-local settings router. */
 export declare function usePluginSettings<TSettings = Record<string, unknown>>(options?: UsePluginSettingsOptions | string): UsePluginSettingsReturn<TSettings>;
 /** Consume a generated plugin SSE endpoint with auth headers, reconnect, and teardown. */

package/dist/composables/usePluginConfig.d.ts

@@ -0,0 +1,25 @@
+import { Ref, ComputedRef } from 'vue';
+export interface UsePluginConfigReturn {
+    /** Editable plugin configuration values. */
+    config: Ref<Record<string, unknown>>;
+    /** Whether the config is currently loading. */
+    isLoading: Ref<boolean>;
+    /** Whether the config is currently saving. */
+    isSaving: Ref<boolean>;
+    /** Error message from the last failed operation, or null. */
+    error: Ref<string | null>;
+    /** Timestamp of the last successful load, or null. */
+    lastLoadedAt: Ref<Date | null>;
+    /** Timestamp of the last successful save, or null. */
+    lastSavedAt: Ref<Date | null>;
+    /** Whether local config differs from the last loaded or saved snapshot. */
+    isDirty: ComputedRef<boolean>;
+    /** Load plugin configuration from the platform. */
+    load: () => Promise<void>;
+    /** Save plugin configuration to the platform. */
+    save: () => Promise<boolean>;
+    /** Restore the last loaded or saved configuration snapshot. */
+    reset: () => void;
+}
+/** @deprecated Use `usePluginSettings()` for typed plugin settings. */
+export declare function usePluginConfig(pluginName?: string): UsePluginConfigReturn;

package/dist/composables/usePluginWorkspace.d.ts

@@ -0,0 +1,51 @@
+import { ComputedRef } from 'vue';
+import { PageSelectorItem, PillNavItem } from '../types';
+import { PluginWorkspaceViewEmit, PluginWorkspaceViewProps } from '../components/PluginWorkspaceView.props';
+import { PluginWorkspaceControlsModel, PluginWorkspaceShellModel, PluginWorkspaceSidebarModel } from './pluginWorkspaceModel';
+/**
+ * Loosely-typed view of a component's `useSlots()` result: only slot presence and names are
+ * read here, so this accepts any `defineSlots()` shape without fighting Vue's `Slot` render
+ * function type. Mirrors the `SlotKeyMap` helper type in PluginWorkspaceView.shell.ts.
+ */
+export type PluginWorkspaceSlotsLike = Readonly<Record<string, unknown>>;
+export interface UsePluginWorkspaceOptions {
+    /** PluginWorkspaceView's own reactive props object (from `defineProps`). */
+    props: PluginWorkspaceViewProps;
+    /** PluginWorkspaceView's own slots (from `useSlots()`), used to detect provided passthrough slots. */
+    slots: PluginWorkspaceSlotsLike;
+    /** PluginWorkspaceView's own typed `emit` function (from `defineEmits<PluginWorkspaceViewEmits>()`). */
+    emit: PluginWorkspaceViewEmit;
+}
+export interface UsePluginWorkspaceReturn {
+    /** Model consumed by WorkspaceShellInternal's `shell` prop. */
+    shell: ComputedRef<PluginWorkspaceShellModel>;
+    /** Model consumed by WorkspaceSidebarInternal's `sidebar` prop. */
+    sidebar: ComputedRef<PluginWorkspaceSidebarModel>;
+    /** Model consumed by WorkspaceControlsInternal's `controls` prop, and by the raw `default` slot. */
+    controls: ComputedRef<PluginWorkspaceControlsModel>;
+    /** Whether AppLayout should render a sidebar surface at all. */
+    hasSidebarSurface: ComputedRef<boolean>;
+    /** Applies an AppSidebar `update:model-value` payload to the shared control values and emits `update:modelValue`/`update:values`. */
+    handleControlValuesUpdate: (values: Record<string, unknown>) => void;
+    /** Resolves an AppTopBar `page-selector-select` payload into the active view and emits `page-selector-select`. */
+    handlePageSelectorSelect: (page: PageSelectorItem) => void;
+    /** Resolves an AppTopBar `pill-select` payload into the active view and emits `pill-select`. */
+    handlePillSelect: (item: PillNavItem) => void;
+}
+/**
+ * Maps PluginWorkspaceView's flat 72-prop surface into the three typed model objects
+ * (`shell`, `sidebar`, `controls`) rendered by its internal pieces
+ * (WorkspaceShellInternal, WorkspaceSidebarInternal, WorkspaceControlsInternal). Reuses the
+ * existing `usePluginWorkspaceControls` / `usePluginWorkspaceNavigation` composables and the
+ * PluginWorkspaceView.shell slot-detection helpers, so it changes only how that state is
+ * assembled and exposed, not the underlying behavior.
+ *
+ * @example Recommended
+ * ```ts
+ * const props = withDefaults(defineProps<PluginWorkspaceViewProps>(), { ... })
+ * const emit = defineEmits<PluginWorkspaceViewEmits>()
+ * const slots = useSlots()
+ * const { shell, sidebar, controls } = usePluginWorkspace({ props, slots, emit })
+ * ```
+ */
+export declare function usePluginWorkspace(options: UsePluginWorkspaceOptions): UsePluginWorkspaceReturn;

package/dist/composables/useRackEditor.d.ts

@@ -0,0 +1,31 @@
+import { Ref, ComputedRef } from 'vue';
+import { Rack, WellPlateFormat, Well } from '../types';
+export interface UseRackEditorOptions {
+    defaultFormat?: WellPlateFormat;
+    defaultInjectionVolume?: number;
+    maxRacks?: number;
+    minRacks?: number;
+}
+export interface UseRackEditorReturn {
+    racks: Ref<Rack[]>;
+    activeRack: ComputedRef<Rack | undefined>;
+    activeRackId: Ref<string>;
+    addRack(name?: string): Rack;
+    removeRack(rackId: string): void;
+    reorderRacks(fromIndex: number, toIndex: number): void;
+    updateRack(rackId: string, data: Partial<Rack>): void;
+    setActiveRack(rackId: string): void;
+    setWellData(rackId: string, wellId: string, data: Partial<Well>): void;
+    clearWell(rackId: string, wellId: string): void;
+    clearAllWells(rackId: string): void;
+    fillSeries(rackId: string, prefix?: string): void;
+    getAllWells(): Array<{
+        rackId: string;
+        wellId: string;
+        well: Partial<Well>;
+    }>;
+    totalSampleCount: ComputedRef<number>;
+    reset(): void;
+}
+/** Manages a set of sample racks with well-level assignment, series fill, and multi-rack reordering. */
+export declare function useRackEditor(initialRacks?: Rack[], options?: UseRackEditorOptions): UseRackEditorReturn;

package/dist/composables/useResourceCrud.d.ts

@@ -0,0 +1,44 @@
+import { ComputedRef, Ref, ShallowRef } from 'vue';
+export type ResourceKey = string | number;
+export interface ResourceCrudAdapter<TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey> {
+    list: () => Promise<TItem[]>;
+    create?: (payload: TCreate) => Promise<TItem>;
+    update?: (key: TKey, payload: TUpdate) => Promise<TItem>;
+    remove?: (key: TKey) => Promise<void>;
+}
+export interface UseResourceCrudOptions<TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey> {
+    adapter: ResourceCrudAdapter<TItem, TCreate, TUpdate, TKey>;
+    initialItems?: readonly TItem[];
+    getKey?: (item: TItem) => TKey;
+    readErrorMessage?: (error: unknown) => string;
+}
+export interface UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey extends ResourceKey> {
+    items: Ref<TItem[]>;
+    loading: ShallowRef<boolean>;
+    saving: ShallowRef<boolean>;
+    deleting: ShallowRef<boolean>;
+    error: Ref<string | null>;
+    isBusy: ComputedRef<boolean>;
+    load: () => Promise<TItem[]>;
+    createItem: (payload: TCreate) => Promise<TItem>;
+    updateItem: (key: TKey, payload: TUpdate) => Promise<TItem>;
+    deleteItem: (keyOrItem: TKey | TItem) => Promise<void>;
+    setItems: (items: readonly TItem[]) => void;
+    upsertLocal: (item: TItem) => void;
+    removeLocal: (keyOrItem: TKey | TItem) => void;
+    clearError: () => void;
+}
+/**
+ * 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 declare function useResourceCrud<TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey>(options: UseResourceCrudOptions<TItem, TCreate, TUpdate, TKey>): UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey>;
+export interface PluginResourceClientOptions<TClient, TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey> {
+    client: TClient;
+    list: (client: TClient) => Promise<TItem[]>;
+    create?: (client: TClient, payload: TCreate) => Promise<TItem>;
+    update?: (client: TClient, key: TKey, payload: TUpdate) => Promise<TItem>;
+    remove?: (client: TClient, key: TKey) => Promise<void>;
+}
+export declare function createPluginResourceClient<TClient, TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey>(options: PluginResourceClientOptions<TClient, TItem, TCreate, TUpdate, TKey>): ResourceCrudAdapter<TItem, TCreate, TUpdate, TKey>;

package/dist/composables/useRovingFocus.d.ts

@@ -0,0 +1,24 @@
+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 declare function useRovingFocus(options: UseRovingFocusOptions): UseRovingFocusReturn;

package/dist/composables/useWellPainting.d.ts

@@ -0,0 +1,39 @@
+import { ComputedRef, Ref } from 'vue';
+import { WellPlateFormat } from '../types';
+export type WellPlateSource<T> = T | Ref<T> | ComputedRef<T> | (() => T);
+export interface WellCoordinate {
+    row: number;
+    col: number;
+}
+export interface WellPaintResult<TMode extends string = string, TPayload = unknown> {
+    wellIds: string[];
+    mode: TMode;
+    payload?: TPayload;
+}
+export interface UseWellPaintingOptions<TMode extends string = string, TPayload = unknown> {
+    format: WellPlateSource<WellPlateFormat>;
+    initialMode?: TMode;
+    initialPayload?: TPayload;
+    onComplete?: (result: WellPaintResult<TMode, TPayload>) => void;
+}
+export interface UseWellPaintingReturn<TMode extends string = string, TPayload = unknown> {
+    activeMode: Ref<TMode>;
+    activePayload: Ref<TPayload | undefined>;
+    isDragging: Ref<boolean>;
+    previewWellIds: ComputedRef<string[]>;
+    setMode: (mode: TMode, payload?: TPayload) => void;
+    setPayload: (payload: TPayload | undefined) => void;
+    onWellMouseDown: (wellId: string) => void;
+    onWellMouseMove: (wellId: string) => void;
+    onWellMouseUp: () => void;
+    cancel: () => void;
+}
+/**
+ * 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 declare function useWellPainting<TMode extends string = string, TPayload = unknown>(options: UseWellPaintingOptions<TMode, TPayload>): UseWellPaintingReturn<TMode, TPayload>;
+export declare function wellIdToCoordinate(wellId: string): WellCoordinate | null;
+export declare function coordinateToWellId(coord: WellCoordinate): string;
+export declare function wellIdsInRectangle(start: WellCoordinate, end: WellCoordinate, format: WellPlateFormat): string[];

package/dist/composables/useWellPlateAdapter.d.ts

@@ -0,0 +1,40 @@
+import { ComputedRef, Ref } from 'vue';
+import { ColumnCondition, RowCondition, Well } from '../types';
+export type WellPlateAdapterSource<T> = T | Ref<T> | ComputedRef<T> | (() => T);
+export interface WellPlateEntry {
+    wellId: string;
+    state?: Well['state'];
+    sampleType?: string;
+    value?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface WellPlateAdapterOptions<TEntry> {
+    entries: WellPlateAdapterSource<readonly TEntry[]>;
+    getWellId: (entry: TEntry) => string;
+    getState?: (entry: TEntry) => Well['state'] | undefined;
+    getSampleType?: (entry: TEntry) => string | undefined;
+    getValue?: (entry: TEntry) => number | undefined;
+    getMetadata?: (entry: TEntry) => Record<string, unknown> | undefined;
+}
+export interface UseWellPlateAdapterReturn {
+    wells: ComputedRef<Record<string, Partial<Well>>>;
+}
+/**
+ * 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 declare function useWellPlateAdapter<TEntry>(options: WellPlateAdapterOptions<TEntry>): UseWellPlateAdapterReturn;
+export declare function createWellPlateWells<TEntry>(entries: readonly TEntry[], options: Omit<WellPlateAdapterOptions<TEntry>, 'entries'>): Record<string, Partial<Well>>;
+export interface AxisConditionEntry {
+    label: string;
+    color: string;
+    start: string | number;
+    concentrations: readonly {
+        value: number;
+        replicates?: number;
+    }[];
+    unit?: string;
+}
+export declare function createColumnConditions(entries: readonly AxisConditionEntry[]): ColumnCondition[];
+export declare function createRowConditions(entries: readonly AxisConditionEntry[]): RowCondition[];

package/dist/composables/useWellPlateValidation.d.ts

@@ -22,6 +22,10 @@ export interface UseWellPlateValidationReturn<TType extends string = string> {
     warningCount: ComputedRef<number>;
     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 declare function useWellPlateValidation<TContext, TType extends string = string>(options: UseWellPlateValidationOptions<TContext, TType>): UseWellPlateValidationReturn<TType>;
 export declare function runWellPlateValidation<TContext, TType extends string = string>(context: TContext, rules: readonly WellPlateValidationRule<TContext, TType>[]): WellPlateValidationWarning<TType>[];